Package org.assertj.db.api

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>>

java.lang.Object
org.assertj.db.global.AbstractElement<C>
org.assertj.db.api.AbstractAssert<C>
org.assertj.db.api.AbstractAssertWithOrigin<C,A>
org.assertj.db.api.AbstractAssertWithOriginWithColumnsAndRows<C,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 Details

  • Method Details

    • 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<D extends AbstractDbData<D>>
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The number to compare to the number of rows.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The number to compare to the number of rows.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The number to compare to the number of rows.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The number to compare to the number of rows.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The number to compare to the number of rows.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      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:

    • 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<D extends AbstractDbData<D>>
      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:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected types to compare to.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      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:

    • 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<D extends AbstractDbData<D>>
      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:

    • 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<D extends AbstractDbData<D>>
      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:

    • 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<D extends AbstractDbData<D>>
      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:

    • 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<D extends AbstractDbData<D>>
      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:

    • 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<D extends AbstractDbData<D>>
      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:

    • 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<D extends AbstractDbData<D>>
      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:

    • 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<D extends AbstractDbData<D>>
      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:

    • 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<D extends AbstractDbData<D>>
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected object values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected boolean values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected numbers values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected bytes values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected text values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected character values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected UUID values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected date values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected time values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected date/time values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected object values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected boolean values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected numbers values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected bytes values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected text values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected character values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected UUID values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected date values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected time values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      expected - The expected date/time values.
      Returns:
      this assertion object.
      See Also:

    • 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<D extends AbstractDbData<D>>
      Parameters:
      columnName - The expected column name.
      Returns:
      this assertion object.
      See Also: