AbstractColumnAssert (AssertJ-DB - Assertions for database 2.0.1 API)

java.lang.Object
- org.assertj.db.global.AbstractElement<E>
- - org.assertj.db.api.AbstractAssert<E>
  - - org.assertj.db.api.AbstractAssertWithOrigin<E,O>
    - - org.assertj.db.api.AbstractAssertWithOriginWithColumnsAndRows<S,A,D,A,C,CV,R,RV>
      - org.assertj.db.api.AbstractSubAssert<D,A,C,CV,C,CV,R,RV>
        
        org.assertj.db.api.AbstractColumnAssert<D,A,C,CV,R,RV>

Type Parameters:

D - The class of the actual value (an sub-class of AbstractDbData).

A - The class of the original assertion (an sub-class of AbstractDbAssert).

C - The class of this assertion (an sub-class of AbstractColumnAssert).

CV - The class of this assertion on the value (an sub-class of AbstractColumnValueAssert).

R - The class of the equivalent row assertion (an sub-class of AbstractRowAssert).

RV - The class of the equivalent row assertion on the value (an sub-class of AbstractRowValueAssert).

All Implemented Interfaces:

org.assertj.core.api.Descriptable<C>, AssertOnColumnClass<C>, AssertOnColumnContent<C>, AssertOnColumnEquality<C>, AssertOnColumnName<C>, AssertOnColumnNullity<C>, AssertOnColumnType<C>, AssertOnNumberOfRows<C>, ColumnElement, Element, Navigation, Origin, OriginWithColumnsAndRows<C,R>, ToColumn<C>, ToRow<R>, ToValue<CV>

Direct Known Subclasses:

RequestColumnAssert, TableColumnAssert
```
public abstract class AbstractColumnAssert<D extends AbstractDbData<D>,A extends AbstractDbAssert<D,A,C,CV,R,RV>,C extends AbstractColumnAssert<D,A,C,CV,R,RV>,CV extends AbstractColumnValueAssert<D,A,C,CV,R,RV>,R extends AbstractRowAssert<D,A,C,CV,R,RV>,RV extends AbstractRowValueAssert<D,A,C,CV,R,RV>>
extends AbstractSubAssert<D,A,C,CV,C,CV,R,RV>
implements ColumnElement, AssertOnColumnClass<C>, AssertOnColumnEquality<C>, AssertOnColumnContent<C>, AssertOnNumberOfRows<C>, AssertOnColumnName<C>, AssertOnColumnType<C>, AssertOnColumnNullity<C>
```
Base class for all Columns assertions.

Author:

Régis Pouiller, Otoniel Isidoro

Field Summary

Fields
Modifier and Type Field and Description

protected Column column
Column on which do the assertion.

protected Position<C,CV,Value> valuePosition
Position of navigation to value.
- Fields inherited from class org.assertj.db.api.AbstractAssertWithOrigin
  origin
- Fields inherited from class org.assertj.db.global.AbstractElement
  info, myself

Fields
Modifier and Type	Field and Description
`protected Column`	`column` Column on which do the assertion.
`protected Position<C,CV,Value>`	`valuePosition` Position of navigation to value.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`C`	`containsValues(Boolean... expected)` Verifies that the values of a column contains booleans.
`C`	`containsValues(byte[]... expected)` Verifies that the values of a column contains bytes.
`C`	`containsValues(Character... expected)` Verifies that the values of a column contains characters.
`C`	`containsValues(DateTimeValue... expected)` Verifies that the values of a column contains date/time values.
`C`	`containsValues(DateValue... expected)` Verifies that the values of a column contains date values.
`C`	`containsValues(Number... expected)` Verifies that the values of a column contains numbers.
`C`	`containsValues(Object... expected)` Verifies that the values of a column contains objects.
`C`	`containsValues(String... expected)` Verifies that the values of a column contains texts.
`C`	`containsValues(TimeValue... expected)` Verifies that the values of a column contains time values.
`C`	`containsValues(UUID... expected)` Verifies that the values of a column containsUUIDs.
`protected String`	`getValueDescription(int index)` Returns the value description.
`protected Position<C,CV,Value>`	`getValuePosition()` Returns the position of navigation to value.
`protected List<Value>`	`getValuesList()` Returns the list of values.
`C`	`hasColumnName(String columnName)` Verifies that the name of a column is equal to the parameter.
`C`	`hasNumberOfRows(int expected)` Verifies that the number of rows is equal to the number in parameter.
`C`	`hasNumberOfRowsGreaterThan(int expected)` Verifies that the number of rows is greater than the number in parameter.
`C`	`hasNumberOfRowsGreaterThanOrEqualTo(int expected)` Verifies that the number of rows is greater than or equal to the number in parameter.
`C`	`hasNumberOfRowsLessThan(int expected)` Verifies that the number of rows is less than the number in parameter.
`C`	`hasNumberOfRowsLessThanOrEqualTo(int expected)` Verifies that the number of rows is less than or equal to the number in parameter.
`C`	`hasOnlyNotNullValues()` Verifies that all the values of the column are not `null`.
`C`	`hasOnlyNullValues()` Verifies that all the values of the column are `null`.
`C`	`hasValues(Boolean... expected)` Verifies that the values of a column are equal to booleans.
`C`	`hasValues(byte[]... expected)` Verifies that the values of a column are equal to bytes.
`C`	`hasValues(Character... expected)` Verifies that the values of a column are equal to characters.
`C`	`hasValues(DateTimeValue... expected)` Verifies that the values of a column are equal to date/time values.
`C`	`hasValues(DateValue... expected)` Verifies that the values of a column are equal to date values.
`C`	`hasValues(Number... expected)` Verifies that the values of a column are equal to numbers.
`C`	`hasValues(Object... expected)` Verifies that the values of a column are equal to objects.
`C`	`hasValues(String... expected)` Verifies that the values of a column are equal to texts.
`C`	`hasValues(TimeValue... expected)` Verifies that the values of a column are equal to time values.
`C`	`hasValues(UUID... expected)` Verifies that the values of a column are equal to UUIDs.
`C`	`isBoolean(boolean lenient)` Verifies that the type of the values of the column is boolean.
`C`	`isBytes(boolean lenient)` Verifies that the type of the values of the column is array of bytes.
`C`	`isDate(boolean lenient)` Verifies that the type of the values of the column is date.
`C`	`isDateTime(boolean lenient)` Verifies that the type of the values of the column is date/time.
`C`	`isEmpty()` Verifies that the number of rows is zero.
`C`	`isNumber(boolean lenient)` Verifies that the type of the values of the column is number.
`C`	`isOfAnyTypeIn(ValueType... expected)` Verifies that the type of the column is equal to one of the types in parameters.
`C`	`isOfClass(Class<?> expected, boolean lenient)` Verifies that the class of the values of the column is equal to the class in parameter.
`C`	`isOfType(ValueType expected, boolean lenient)` Verifies that the type of the values of the column is equal to the type in parameter.
`C`	`isText(boolean lenient)` Verifies that the type of the values of the column is text.
`C`	`isTime(boolean lenient)` Verifies that the type of the values of the column is time.
`C`	`isUUID(boolean lenient)` Verifies that the type of the values of the column is UUID.

Methods inherited from class org.assertj.db.api.AbstractSubAssert
value, value

Methods inherited from class org.assertj.db.api.AbstractAssertWithOriginWithColumnsAndRows
column, column, column, row, row

Methods inherited from class org.assertj.db.api.AbstractAssertWithOrigin
returnToOrigin

Methods inherited from class org.assertj.db.global.AbstractElement
as, as, describedAs, describedAs, getInfo

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.assertj.db.navigation.ToColumn
column, column, column

Methods inherited from interface org.assertj.db.navigation.ToRow
row, row

- Field Detail
  - valuePosition
```
protected final Position<C extends AbstractColumnAssert<D,A,C,CV,R,RV>,CV extends AbstractColumnValueAssert<D,A,C,CV,R,RV>,Value> valuePosition
```
    Position of navigation to value.
  - column
```
protected final Column column
```
    Column on which do the assertion.
- Method Detail
  - getValueDescription
```
protected String getValueDescription(int index)
```
    Returns the value description.
    
    Specified by:
    
    getValueDescription in class AbstractSubAssert<D extends AbstractDbData<D>,A extends AbstractDbAssert<D,A,C,CV,R,RV>,C extends AbstractColumnAssert<D,A,C,CV,R,RV>,CV extends AbstractColumnValueAssert<D,A,C,CV,R,RV>,C extends AbstractColumnAssert<D,A,C,CV,R,RV>,CV extends AbstractColumnValueAssert<D,A,C,CV,R,RV>,R extends AbstractRowAssert<D,A,C,CV,R,RV>,RV extends AbstractRowValueAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    index - The index of the value.
    
    Returns:
    
    The description.
  - getValuePosition
```
protected Position<C,CV,Value> getValuePosition()
```
    Returns the position of navigation to value.
    
    Specified by:
    
    getValuePosition in class AbstractSubAssert<D extends AbstractDbData<D>,A extends AbstractDbAssert<D,A,C,CV,R,RV>,C extends AbstractColumnAssert<D,A,C,CV,R,RV>,CV extends AbstractColumnValueAssert<D,A,C,CV,R,RV>,C extends AbstractColumnAssert<D,A,C,CV,R,RV>,CV extends AbstractColumnValueAssert<D,A,C,CV,R,RV>,R extends AbstractRowAssert<D,A,C,CV,R,RV>,RV extends AbstractRowValueAssert<D,A,C,CV,R,RV>>
    
    Returns:
    
    The position of navigation to value.
  - getValuesList
```
protected List<Value> getValuesList()
```
    Returns the list of values.
    
    Specified by:
    
    getValuesList in class AbstractSubAssert<D extends AbstractDbData<D>,A extends AbstractDbAssert<D,A,C,CV,R,RV>,C extends AbstractColumnAssert<D,A,C,CV,R,RV>,CV extends AbstractColumnValueAssert<D,A,C,CV,R,RV>,C extends AbstractColumnAssert<D,A,C,CV,R,RV>,CV extends AbstractColumnValueAssert<D,A,C,CV,R,RV>,R extends AbstractRowAssert<D,A,C,CV,R,RV>,RV extends AbstractRowValueAssert<D,A,C,CV,R,RV>>
    
    Returns:
    
    The list of values.
  - isEmpty
```
public C isEmpty()
```
    Verifies that the number of rows is zero.
    Example where the assertion verifies that the table is empty :
```
 assertThat(table).isEmpty();
 
```
    Specified by:
    
    isEmpty in interface AssertOnNumberOfRows<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AbstractDbAssert.isEmpty(), isEmpty()
  - hasNumberOfRows
```
public C hasNumberOfRows(int expected)
```
    Verifies that the number of rows is equal to the number in parameter.
    Example where the assertion verifies that the table has 2 rows :
```
 assertThat(table).hasNumberOfRows(2);
 
```
    Example where the assertion verifies that the column with index 1 of the table has 5 rows :
```
 assertThat(table).column(1).hasNumberOfRows(5);
 
```
    Specified by:
    
    hasNumberOfRows in interface AssertOnNumberOfRows<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The number to compare to the number of rows.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AbstractDbAssert.hasNumberOfRows(int), hasNumberOfRows(int)
  - hasNumberOfRowsGreaterThan
```
public C hasNumberOfRowsGreaterThan(int expected)
```
    Verifies that the number of rows is greater than the number in parameter.
    Example where the assertion verifies that the table has more than 8 rows :
```
 assertThat(table).hasNumberOfRowsGreaterThan(8);
 
```
    Example where the assertion verifies that the first row of the table has more than 8 rows :
```
 assertThat(table).row().hasNumberOfRowsGreaterThan(8);
 
```
    Example where the assertion verifies that the row at end point of the first change has more than 8 rows :
```
 assertThat(changes).change().rowAtEndPoint().hasNumberOfRowsGreaterThan(8);
 
```
    Specified by:
    
    hasNumberOfRowsGreaterThan in interface AssertOnNumberOfRows<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The number to compare to the number of rows.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AbstractDbAssert.hasNumberOfRowsGreaterThan(int), hasNumberOfRowsGreaterThan(int)
  - hasNumberOfRowsLessThan
```
public C hasNumberOfRowsLessThan(int expected)
```
    Verifies that the number of rows is less than the number in parameter.
    Example where the assertion verifies that the table has less than 8 rows :
```
 assertThat(table).hasNumberOfRowsLessThan(8);
 
```
    Example where the assertion verifies that the first row of the table has less than 8 rows :
```
 assertThat(table).row().hasNumberOfRowsLessThan(8);
 
```
    Example where the assertion verifies that the row at end point of the first change has less than 8 rows :
```
 assertThat(changes).change().rowAtEndPoint().hasNumberOfRowsLessThan(8);
 
```
    Specified by:
    
    hasNumberOfRowsLessThan in interface AssertOnNumberOfRows<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The number to compare to the number of rows.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AbstractDbAssert.hasNumberOfRowsLessThan(int), hasNumberOfRowsLessThan(int)
  - hasNumberOfRowsGreaterThanOrEqualTo
```
public C hasNumberOfRowsGreaterThanOrEqualTo(int expected)
```
    Verifies that the number of rows is greater than or equal to the number in parameter.
    Example where the assertion verifies that the table has at least 8 rows :
```
 assertThat(table).hasNumberOfRowsGreaterThanOrEqualTo(8);
 
```
    Example where the assertion verifies that the first row of the table has at least 8 rows :
```
 assertThat(table).row().hasNumberOfRowsGreaterThanOrEqualTo(8);
 
```
    Example where the assertion verifies that the row at end point of the first change has at least 8 rows :
```
 assertThat(changes).change().rowAtEndPoint().hasNumberOfRowsGreaterThanOrEqualTo(8);
 
```
    Specified by:
    
    hasNumberOfRowsGreaterThanOrEqualTo in interface AssertOnNumberOfRows<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The number to compare to the number of rows.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AbstractDbAssert.hasNumberOfRowsGreaterThanOrEqualTo(int), hasNumberOfRowsGreaterThanOrEqualTo(int)
  - hasNumberOfRowsLessThanOrEqualTo
```
public C hasNumberOfRowsLessThanOrEqualTo(int expected)
```
    Verifies that the number of rows is less than or equal to the number in parameter.
    Example where the assertion verifies that the table has at most 8 rows :
```
 assertThat(table).hasNumberOfRowsLessThanOrEqualTo(8);
 
```
    Example where the assertion verifies that the first row of the table has at most 8 rows :
```
 assertThat(table).row().hasNumberOfRowsLessThanOrEqualTo(8);
 
```
    Example where the assertion verifies that the row at end point of the first change has at most 8 rows :
```
 assertThat(changes).change().rowAtEndPoint().hasNumberOfRowsLessThanOrEqualTo(8);
 
```
    Specified by:
    
    hasNumberOfRowsLessThanOrEqualTo in interface AssertOnNumberOfRows<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The number to compare to the number of rows.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AbstractDbAssert.hasNumberOfRowsLessThanOrEqualTo(int), hasNumberOfRowsLessThanOrEqualTo(int)
  - isOfClass
```
public C isOfClass(Class<?> expected,
                   boolean lenient)
```
    Verifies that the class of the values of the column is equal to the class in parameter.
    Example where the assertion verifies that all the values in the Column called "title" of the Table is of class String :
```
 assertThat(table).column("title").isOfClass(String.class, false);
 
```
    Example where the assertion verifies that all the values in the Column called "title" of the Table is of class String or not identified (for example null) :
```
 assertThat(table).column("title").isOfClass(String.class, true);
 
```
    Specified by:
    
    isOfClass in interface AssertOnColumnClass<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected class to compare to.
    
    lenient - true if the test is lenient : if the class of a value is not identified (for example when the value is null), it consider that it is ok.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    isOfClass(Class, boolean), ChangeColumnAssert.isOfClass(Class, boolean)
  - isOfType
```
public C isOfType(ValueType expected,
                  boolean lenient)
```
    Verifies that the type of the values of the column is equal to the type in parameter.
    Example where the assertion verifies that all the values in the Column called "title" of the Table is of type TEXT :
```
 assertThat(table).column("title").isOfType(ValueType.TEXT, false);
 
```
    Example where the assertion verifies that all the values in the Column called "title" of the Table is of type TEXT or not identified (for example null) :
```
 assertThat(table).column("title").isOfType(ValueType.TEXT, true);
 
```
    Specified by:
    
    isOfType in interface AssertOnColumnType<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected type to compare to.
    
    lenient - true if the test is lenient : if the type of a value is not identified (for example when the value is null), it consider that it is ok.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    isOfType(org.assertj.db.type.ValueType, boolean), ChangeColumnAssert.isOfType(org.assertj.db.type.ValueType, boolean)
  - isOfAnyTypeIn
```
public C isOfAnyTypeIn(ValueType... expected)
```
    Verifies that the type of the column is equal to one of the types in parameters.
    Example where the assertion verifies that the values in the Column called "title" of the Table is of type TEXT or of type NUMBER :
```
 assertThat(table).column("title").isOfAnyTypeIn(ValueType.TEXT, ValueType.NUMBER);
 
```
    Specified by:
    
    isOfAnyTypeIn in interface AssertOnColumnType<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected types to compare to.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    isOfAnyTypeIn(org.assertj.db.type.ValueType...), ChangeColumnAssert.isOfAnyTypeIn(org.assertj.db.type.ValueType...)
  - isNumber
```
public C isNumber(boolean lenient)
```
    Verifies that the type of the values of the column is number.
    Example where the assertion verifies that all the values in the Column called "year" of the Table is a number :
```
 assertThat(table).column("year").isNumber(true);
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOfType(ValueType.NUMBER, lenient);
 
 
```
    Specified by:
    
    isNumber in interface AssertOnColumnType<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    lenient - true if the test is lenient : if the type of a value is not identified (for example when the value is null), it consider that it is ok.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    ValueType.NUMBER, isNumber(boolean), ChangeColumnAssert.isNumber(boolean)
  - isBoolean
```
public C isBoolean(boolean lenient)
```
    Verifies that the type of the values of the column is boolean.
    Example where the assertion verifies that all the values in the first Column of the Table is a boolean :
```
 assertThat(table).column().isBoolean(false);
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOfType(ValueType.BOOLEAN, lenient);
 
 
```
    Specified by:
    
    isBoolean in interface AssertOnColumnType<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    lenient - true if the test is lenient : if the type of a value is not identified (for example when the value is null), it consider that it is ok.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    ValueType.BOOLEAN, isBoolean(boolean), ChangeColumnAssert.isBoolean(boolean)
  - isDate
```
public C isDate(boolean lenient)
```
    Verifies that the type of the values of the column is date.
    Example where the assertion verifies that all the values in the Column called "birth" of the Table is a date :
```
 assertThat(table).column("birth").isDate(false);
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOfType(ValueType.DATE, lenient);
 
 
```
    Specified by:
    
    isDate in interface AssertOnColumnType<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    lenient - true if the test is lenient : if the type of a value is not identified (for example when the value is null), it consider that it is ok.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    ValueType.DATE, isDate(boolean), ChangeColumnAssert.isDate(boolean)
  - isTime
```
public C isTime(boolean lenient)
```
    Verifies that the type of the values of the column is time.
    Example where the assertion verifies that all the values in the first Column of the Table is a time :
```
 assertThat(table).column().isTime(false);
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOfType(ValueType.TIME, lenient);
 
 
```
    Specified by:
    
    isTime in interface AssertOnColumnType<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    lenient - true if the test is lenient : if the type of a value is not identified (for example when the value is null), it consider that it is ok.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    ValueType.TIME, isTime(boolean), ChangeColumnAssert.isTime(boolean)
  - isDateTime
```
public C isDateTime(boolean lenient)
```
    Verifies that the type of the values of the column is date/time.
    Example where the assertion verifies that all the values in the first Column of the Table is a date/time :
```
 assertThat(table).column().isDateTime(false);
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOfType(ValueType.DATE_TIME, lenient);
 
 
```
    Specified by:
    
    isDateTime in interface AssertOnColumnType<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    lenient - true if the test is lenient : if the type of a value is not identified (for example when the value is null), it consider that it is ok.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    ValueType.DATE_TIME, isDateTime(boolean), ChangeColumnAssert.isDateTime(boolean)
  - isBytes
```
public C isBytes(boolean lenient)
```
    Verifies that the type of the values of the column is array of bytes.
    Example where the assertion verifies that all the values in the first Column of the Table is a array of bytes :
```
 assertThat(table).column().isBytes(false);
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOfType(ValueType.BYTES, lenient);
 
 
```
    Specified by:
    
    isBytes in interface AssertOnColumnType<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    lenient - true if the test is lenient : if the type of a value is not identified (for example when the value is null), it consider that it is ok.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    ValueType.BYTES, isBytes(boolean), ChangeColumnAssert.isBytes(boolean)
  - isText
```
public C isText(boolean lenient)
```
    Verifies that the type of the values of the column is text.
    Example where the assertion verifies that all the values in the Column called "title" of the Table is a text :
```
 assertThat(table).column("title").isText(false);
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOfType(ValueType.TEXT, lenient);
 
 
```
    Specified by:
    
    isText in interface AssertOnColumnType<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    lenient - true if the test is lenient : if the type of a value is not identified (for example when the value is null), it consider that it is ok.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    ValueType.TEXT, isText(boolean), ChangeColumnAssert.isText(boolean)
  - isUUID
```
public C isUUID(boolean lenient)
```
    Verifies that the type of the values of the column is UUID.
    Example where the assertion verifies that all the values in the Column called "id" of the Table is UUID :
```
 assertThat(table).column("id").isUUID(false);
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOfType(ValueType.UUID, lenient);
 
 
```
    Specified by:
    
    isUUID in interface AssertOnColumnType<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    lenient - true if the test is lenient : if the type of a value is not identified (for example when the value is null), it consider that it is ok.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    ValueType.UUID, isUUID(boolean), ChangeColumnAssert.isUUID(boolean)
  - hasOnlyNullValues
```
public C hasOnlyNullValues()
```
    Verifies that all the values of the column are null.
    Example where the assertion verifies that all the values in the first Column of the Table are null :
```
 assertThat(table).column().hasOnlyNullValues();
 
```
    Specified by:
    
    hasOnlyNullValues in interface AssertOnColumnNullity<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasOnlyNullValues()
  - hasOnlyNotNullValues
```
public C hasOnlyNotNullValues()
```
    Verifies that all the values of the column are not null.
    Example where the assertion verifies that all the values in the first Column of the Table are not null :
```
 assertThat(table).column().hasOnlyNotNullValues();
 
```
    Specified by:
    
    hasOnlyNotNullValues in interface AssertOnColumnNullity<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasOnlyNotNullValues()
  - hasValues
```
public C hasValues(Object... expected)
```
    Verifies that the values of a column are equal to objects.
    Example where the assertion verifies that the values in the first Column of the Table are equal to the objects in parameter :
```
 assertThat(table).column().hasValues(Locale.FRENCH, Locale.ENGLISH, Locale.FRENCH);
 
```
    Specified by:
    
    hasValues in interface AssertOnColumnEquality<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected object values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasValues(Object...)
  - hasValues
```
public C hasValues(Boolean... expected)
```
    Verifies that the values of a column are equal to booleans.
    Example where the assertion verifies that the values in the first Column of the Table are equal to the booleans in parameter :
```
 assertThat(table).column().hasValues(true, false, true);
 
```
    Specified by:
    
    hasValues in interface AssertOnColumnEquality<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected boolean values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasValues(Boolean...)
  - hasValues
```
public C hasValues(Number... expected)
```
    Verifies that the values of a column are equal to numbers.
    Example where the assertion verifies that the values in the first Column of the Table are equal to the numbers in parameter :
```
 assertThat(table).column().hasValues(5, 10.5, 6);
 
```
    Specified by:
    
    hasValues in interface AssertOnColumnEquality<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected numbers values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasValues(Number...)
  - hasValues
```
public C hasValues(byte[]... expected)
```
    Verifies that the values of a column are equal to bytes.
    Example where the assertion verifies that the values in the first Column of the Table are equal to arrays of bytes loaded from files in the classpath :
```
 byte[] bytes1 = bytesContentFromClassPathOf("file1.png");
 byte[] bytes2 = bytesContentFromClassPathOf("file2.png");
 assertThat(table).column().hasValues(bytes1, bytes2);
 
```
    Specified by:
    
    hasValues in interface AssertOnColumnEquality<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected bytes values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    org.assertj.db.api.AbstractColumnAssert#hasValues(byte[]...)
  - hasValues
```
public C hasValues(String... expected)
```
    Verifies that the values of a column are equal to texts.
    Example where the assertion verifies that the values in the first Column of the Table are equal to the texts in parameter :
```
 assertThat(table).column().hasValues("text", "text2", "text3");
 
```
    Specified by:
    
    hasValues in interface AssertOnColumnEquality<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected text values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasValues(String...)
  - hasValues
```
public C hasValues(Character... expected)
```
    Verifies that the values of a column are equal to characters.
    Example where the assertion verifies that the values in the first Column of the Table are equal to the characters in parameter :
```
 assertThat(table).column().hasValues('t', 'e', 'x', 't');
 
```
    Specified by:
    
    hasValues in interface AssertOnColumnEquality<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected character values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasValues(Character...)
  - hasValues
```
public C hasValues(UUID... expected)
```
    Verifies that the values of a column are equal to UUIDs.
    Example where the assertion verifies that the values in the first Column of the Table are equal to the UUIDs in parameter :
```
 assertThat(table).column().hasValues(UUID.fromString("30B443AE-C0C9-4790-9BEC-CE1380808435"),
 UUID.fromString("16319617-AE95-4087-9264-D3D21BF611B6"), UUID.fromString("D735221B-5DE5-4112-AA1E-49090CB75ADA"));
 
```
    Specified by:
    
    hasValues in interface AssertOnColumnEquality<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected UUID values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasValues(UUID...)
  - hasValues
```
public C hasValues(DateValue... expected)
```
    Verifies that the values of a column are equal to date values.
    Example where the assertion verifies that the values in the first Column of the Table are equal to the date values in parameter :
```
 assertThat(table).column().hasValues(DateValue.of(2014, 7, 7), DateValue.of(2014, 10, 3),
     DateValue.of(2014, 12, 23));
 
```
    Specified by:
    
    hasValues in interface AssertOnColumnEquality<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected date values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasValues(DateValue...)
  - hasValues
```
public C hasValues(TimeValue... expected)
```
    Verifies that the values of a column are equal to time values.
    Example where the assertion verifies that the values in the first Column of the Table are equal to the time values in parameter :
```
 assertThat(table).column().hasValues(TimeValue.of(21, 29, 30), TimeValue.of(10, 1, 25), TimeValue.of(9, 1));
 
```
    Specified by:
    
    hasValues in interface AssertOnColumnEquality<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected time values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasValues(TimeValue...)
  - hasValues
```
public C hasValues(DateTimeValue... expected)
```
    Verifies that the values of a column are equal to date/time values.
    Example where the assertion verifies that the values in the first Column of the Table are equal to the date/time values in parameter :
```
 assertThat(table).column().hasValues(DateTimeValue.of(DateValue.of(2014, 7, 7), TimeValue.of(21, 29)),
     DateTimeValue.of(DateValue.of(2014, 7, 7), TimeValue.of(10, 1, 25)),
     DateTimeValue.of(DateValue.of(2014, 7, 7), TimeValue.of(9, 1)));
 
```
    Specified by:
    
    hasValues in interface AssertOnColumnEquality<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected date/time values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasValues(DateTimeValue...)
  - containsValues
```
public C containsValues(Object... expected)
```
    Verifies that the values of a column contains objects.
    Example where the assertion verifies that the values in the first Column of the Table are containing the objects in parameter :
```
 assertThat(table).column().containsValues(Locale.FRENCH, Locale.ENGLISH, Locale.FRENCH);
 
```
    Specified by:
    
    containsValues in interface AssertOnColumnContent<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected object values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    containsValues(Object...)
  - containsValues
```
public C containsValues(Boolean... expected)
```
    Verifies that the values of a column contains booleans.
    Example where the assertion verifies that the values in the first Column of the Table are containing the booleans in parameter :
```
 assertThat(table).column().containsValues(true, false, true);
 
```
    Specified by:
    
    containsValues in interface AssertOnColumnContent<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected boolean values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    containsValues(Boolean...)
  - containsValues
```
public C containsValues(Number... expected)
```
    Verifies that the values of a column contains numbers.
    Example where the assertion verifies that the values in the first Column of the Table are containing the numbers in parameter :
```
 assertThat(table).column().containsValues(5, 10.5, 6);
 
```
    Specified by:
    
    containsValues in interface AssertOnColumnContent<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected numbers values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    containsValues(Number...)
  - containsValues
```
public C containsValues(byte[]... expected)
```
    Verifies that the values of a column contains bytes.
    Example where the assertion verifies that the values in the first Column of the Table are containing arrays of bytes loaded from files in the classpath :
```
 byte[] bytes1 = bytesContentFromClassPathOf("file1.png");
 byte[] bytes2 = bytesContentFromClassPathOf("file2.png");
 assertThat(table).column().containsValues(bytes1, bytes2);
 
```
    Specified by:
    
    containsValues in interface AssertOnColumnContent<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected bytes values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    org.assertj.db.api.AbstractColumnAssert#containsValues(byte[]...)
  - containsValues
```
public C containsValues(String... expected)
```
    Verifies that the values of a column contains texts.
    Example where the assertion verifies that the values in the first Column of the Table are containing the texts in parameter :
```
 assertThat(table).column().containsValues("text", "text2", "text3");
 
```
    Specified by:
    
    containsValues in interface AssertOnColumnContent<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected text values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    containsValues(String...)
  - containsValues
```
public C containsValues(Character... expected)
```
    Verifies that the values of a column contains characters.
    Example where the assertion verifies that the values in the first Column of the Table are containing the characters in parameter :
```
 assertThat(table).column().containsValues('t', 'e', 'x', 't');
 
```
    Specified by:
    
    containsValues in interface AssertOnColumnContent<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected character values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    containsValues(Character...)
  - containsValues
```
public C containsValues(UUID... expected)
```
    Verifies that the values of a column containsUUIDs.
    Example where the assertion verifies that the values in the first Column of the Table are containing the UUIDs in parameter :
```
 assertThat(table).column().containsValues(UUID.fromString("30B443AE-C0C9-4790-9BEC-CE1380808435"),
 UUID.fromString("16319617-AE95-4087-9264-D3D21BF611B6"), UUID.fromString("D735221B-5DE5-4112-AA1E-49090CB75ADA"));
 
```
    Specified by:
    
    containsValues in interface AssertOnColumnContent<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected UUID values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    containsValues(java.util.UUID...)
  - containsValues
```
public C containsValues(DateValue... expected)
```
    Verifies that the values of a column contains date values.
    Example where the assertion verifies that the values in the first Column of the Table are containing the date values in parameter :
```
 assertThat(table).column().containsValues(DateValue.of(2014, 7, 7), DateValue.of(2014, 10, 3),
     DateValue.of(2014, 12, 23));
 
```
    Specified by:
    
    containsValues in interface AssertOnColumnContent<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected date values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    containsValues(org.assertj.db.type.DateValue...)
  - containsValues
```
public C containsValues(TimeValue... expected)
```
    Verifies that the values of a column contains time values.
    Example where the assertion verifies that the values in the first Column of the Table are containing the time values in parameter :
```
 assertThat(table).column().containsValues(TimeValue.of(21, 29, 30), TimeValue.of(10, 1, 25), TimeValue.of(9, 1));
 
```
    Specified by:
    
    containsValues in interface AssertOnColumnContent<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected time values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    containsValues(org.assertj.db.type.TimeValue...)
  - containsValues
```
public C containsValues(DateTimeValue... expected)
```
    Verifies that the values of a column contains date/time values.
    Example where the assertion verifies that the values in the first Column of the Table are containing the date/time values in parameter :
```
 assertThat(table).column().containsValues(DateTimeValue.of(DateValue.of(2014, 7, 7), TimeValue.of(21, 29)),
     DateTimeValue.of(DateValue.of(2014, 7, 7), TimeValue.of(10, 1, 25)),
     DateTimeValue.of(DateValue.of(2014, 7, 7), TimeValue.of(9, 1)));
 
```
    Specified by:
    
    containsValues in interface AssertOnColumnContent<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    expected - The expected date/time values.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    containsValues(org.assertj.db.type.DateTimeValue...)
  - hasColumnName
```
public C hasColumnName(String columnName)
```
    Verifies that the name of a column is equal to the parameter.
    Example where the assertion verifies that the column name of the first Column of the Table is equal to "title" :
```
 assertThat(table).column().hasColumnName("title");
 
```
    Example where the assertion verifies that the first value of the first Row of the Table is equal to "title" :
```
 assertThat(table).row().value().hasColumnName("title");
 
```
    Example where the assertion verifies that the column name of the first Column of the Table is equal to "title" :
```
 assertThat(changes).change(1).column().hasColumnName("title");
 
```
    Example where the assertion verifies that the first value of the first Row of the Table is equal to "title" :
```
 assertThat(changes).change(1).row().value().hasColumnName("title");
 
```
    Specified by:
    
    hasColumnName in interface AssertOnColumnName<C extends AbstractColumnAssert<D,A,C,CV,R,RV>>
    
    Parameters:
    
    columnName - The expected column name.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasColumnName(String), AbstractRowValueAssert.hasColumnName(String), ChangeColumnAssert.hasColumnName(String), ChangeRowValueAssert.hasColumnName(String)

Class AbstractColumnAssert<D extends AbstractDbData<D>,A extends AbstractDbAssert<D,A,C,CV,R,RV>,C extends AbstractColumnAssert<D,A,C,CV,R,RV>,CV extends AbstractColumnValueAssert<D,A,C,CV,R,RV>,R extends AbstractRowAssert<D,A,C,CV,R,RV>,RV extends AbstractRowValueAssert<D,A,C,CV,R,RV>>

Field Summary

Fields inherited from class org.assertj.db.api.AbstractAssertWithOrigin

Fields inherited from class org.assertj.db.global.AbstractElement

Method Summary

Methods inherited from class org.assertj.db.api.AbstractSubAssert

Methods inherited from class org.assertj.db.api.AbstractAssertWithOriginWithColumnsAndRows

Methods inherited from class org.assertj.db.api.AbstractAssertWithOrigin

Methods inherited from class org.assertj.db.global.AbstractElement

Methods inherited from class java.lang.Object

Methods inherited from interface org.assertj.db.navigation.ToColumn

Methods inherited from interface org.assertj.db.navigation.ToRow

Field Detail

valuePosition

column

Method Detail

getValueDescription

getValuePosition

getValuesList

isEmpty

hasNumberOfRows

hasNumberOfRowsGreaterThan

hasNumberOfRowsLessThan

hasNumberOfRowsGreaterThanOrEqualTo

hasNumberOfRowsLessThanOrEqualTo

isOfClass

isOfType

isOfAnyTypeIn

isNumber

isBoolean

isDate

isTime

isDateTime

isBytes

isText

isUUID

hasOnlyNullValues

hasOnlyNotNullValues

hasValues

hasValues

hasValues

hasValues

hasValues

hasValues

hasValues

hasValues

hasValues

hasValues

containsValues

containsValues

containsValues

containsValues

containsValues

containsValues

containsValues

containsValues

containsValues

containsValues

hasColumnName