ChangeColumnAssert (AssertJ-DB - Assertions for database 1.0.0m1 API)

java.lang.Object
- org.assertj.db.api.AbstractAssert<E>
- - org.assertj.db.api.AbstractAssertWithOrigin<E,O>
  - - org.assertj.db.api.AbstractAssertWithOriginWithChanges<E,O>
    - - org.assertj.db.api.AbstractAssertWithOriginWithColumnsAndRowsFromChange<ChangeColumnAssert,ChangeAssert>
      - org.assertj.db.api.ChangeColumnAssert

All Implemented Interfaces:

org.assertj.core.api.Descriptable<ChangeColumnAssert>, AssertOnColumnName<ChangeColumnAssert>, AssertOnColumnOfChangeEquality<ChangeColumnAssert>, AssertOnColumnType<ChangeColumnAssert>, AssertOnModifiedColumn<ChangeColumnAssert>, ColumnAssert, ToChange, ToChanges, ToColumn<ChangeColumnAssert>, ToColumnFromChange<ChangeColumnAssert>, ToRowFromChange<ChangeRowAssert>, ToValueFromColumn<ChangeColumnValueAssert>, Origin, OriginWithChanges, OriginWithColumnsAndRowsFromChange, OriginWithValuesFromColumn
```
public class ChangeColumnAssert
extends AbstractAssertWithOriginWithColumnsAndRowsFromChange<ChangeColumnAssert,ChangeAssert>
implements ColumnAssert, OriginWithValuesFromColumn, AssertOnColumnOfChangeEquality<ChangeColumnAssert>, AssertOnModifiedColumn<ChangeColumnAssert>, AssertOnColumnName<ChangeColumnAssert>, AssertOnColumnType<ChangeColumnAssert>
```
Assertion methods for a Column of a Change.

Author:

Régis Pouiller

Field Summary
- Fields inherited from class org.assertj.db.api.AbstractAssertWithOrigin
  origin
- Fields inherited from class org.assertj.db.api.AbstractAssert
  info, myself

Method Summary

Methods
Modifier and Type	Method and Description
`ChangeColumnAssert`	`hasColumnName(String columnName)` Verifies that the name of a column is equal to the parameter.
`ChangeColumnAssert`	`hasValuesEqualTo(Boolean expected)` Verifies that the values at the start point and the end point are equal to a boolean.
`ChangeColumnAssert`	`hasValuesEqualTo(Boolean expectedAtStartPoint, Boolean expectedAtEndPoint)` Verifies that the values at the start point and the end point are equal to a boolean for start point and another boolean for end point.
`ChangeColumnAssert`	`hasValuesEqualTo(byte[] expected)` Verifies that the values at the start point and the end point are equal to bytes.
`ChangeColumnAssert`	`hasValuesEqualTo(byte[] expectedAtStartPoint, byte[] expectedAtEndPoint)` Verifies that the values at the start point and the end point are equal to bytes for start point and other bytes for end point.
`ChangeColumnAssert`	`hasValuesEqualTo(DateTimeValue expected)` Verifies that the values at the start point and the end point are equal to a date/time.
`ChangeColumnAssert`	`hasValuesEqualTo(DateTimeValue expectedAtStartPoint, DateTimeValue expectedAtEndPoint)` Verifies that the values at the start point and the end point are equal to a date/time for start point and another date/time for end point.
`ChangeColumnAssert`	`hasValuesEqualTo(DateValue expected)` Verifies that the values at the start point and the end point are equal to a date.
`ChangeColumnAssert`	`hasValuesEqualTo(DateValue expectedAtStartPoint, DateValue expectedAtEndPoint)` Verifies that the values at the start point and the end point are equal to a date for start point and another date for end point.
`ChangeColumnAssert`	`hasValuesEqualTo(Number expected)` Verifies that the values at the start point and the end point are equal to a number.
`ChangeColumnAssert`	`hasValuesEqualTo(Number expectedAtStartPoint, Number expectedAtEndPoint)` Verifies that the values at the start point and the end point are equal to a number for start point and another number for end point.
`ChangeColumnAssert`	`hasValuesEqualTo(String expected)` Verifies that the values at the start point and the end point are equal to a text.
`ChangeColumnAssert`	`hasValuesEqualTo(String expectedAtStartPoint, String expectedAtEndPoint)` Verifies that the values at the start point and the end point are equal to a text for start point and another text for end point.
`ChangeColumnAssert`	`hasValuesEqualTo(TimeValue expected)` Verifies that the values at the start point and the end point are equal to a time.
`ChangeColumnAssert`	`hasValuesEqualTo(TimeValue expectedAtStartPoint, TimeValue expectedAtEndPoint)` Verifies that the values at the start point and the end point are equal to a time for start point and another time for end point.
`ChangeColumnAssert`	`isBoolean(boolean lenient)` Verifies that the type of the values of the column is boolean.
`ChangeColumnAssert`	`isBytes(boolean lenient)` Verifies that the type of the values of the column is array of bytes.
`ChangeColumnAssert`	`isDate(boolean lenient)` Verifies that the type of the values of the column is date.
`ChangeColumnAssert`	`isDateTime(boolean lenient)` Verifies that the type of the values of the column is date/time.
`ChangeColumnAssert`	`isModified()` Verifies that the column is modified between the start point and the end point.
`ChangeColumnAssert`	`isNotModified()` Verifies that the column is not modified between the start point and the end point.
`ChangeColumnAssert`	`isNumber(boolean lenient)` Verifies that the type of the values of the column is number.
`ChangeColumnAssert`	`isOfAnyOfTypes(ValueType... expected)` Verifies that the type of the column is equal to one of the types in parameters.
`ChangeColumnAssert`	`isOfType(ValueType expected, boolean lenient)` Verifies that the type of the values of the column is equal to the type in parameter.
`ChangeColumnAssert`	`isText(boolean lenient)` Verifies that the type of the values of the column is text.
`ChangeColumnAssert`	`isTime(boolean lenient)` Verifies that the type of the values of the column is time.
`ChangeAssert`	`returnToChange()` Returns to level of assertion methods on a `Change`.
`ChangeColumnValueAssert`	`valueAtEndPoint()` Returns assertion methods on the value at the end point.
`ChangeColumnValueAssert`	`valueAtStartPoint()` Returns assertion methods on the value at the start point.

Methods inherited from class org.assertj.db.api.AbstractAssertWithOriginWithColumnsAndRowsFromChange
column, column, column, columnAmongTheModifiedOnes, columnAmongTheModifiedOnes, columnAmongTheModifiedOnes, rowAtEndPoint, rowAtStartPoint

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

Methods inherited from class org.assertj.db.api.AbstractAssert
as, as, describedAs, describedAs

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.api.navigation.ToChanges
ofAll, ofCreation, ofCreationOnTable, ofDeletion, ofDeletionOnTable, ofModification, ofModificationOnTable, onTable

Methods inherited from interface org.assertj.db.api.navigation.ToChange
change, change, changeOfCreation, changeOfCreation, changeOfCreationOnTable, changeOfCreationOnTable, changeOfDeletion, changeOfDeletion, changeOfDeletionOnTable, changeOfDeletionOnTable, changeOfModification, changeOfModification, changeOfModificationOnTable, changeOfModificationOnTable, changeOnTable, changeOnTable, changeOnTableWithPks

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

Methods inherited from interface org.assertj.db.api.navigation.ToColumnFromChange
columnAmongTheModifiedOnes, columnAmongTheModifiedOnes, columnAmongTheModifiedOnes

Methods inherited from interface org.assertj.db.api.navigation.ToRowFromChange
rowAtEndPoint, rowAtStartPoint

- Method Detail
  - valueAtStartPoint
```
public ChangeColumnValueAssert valueAtStartPoint()
```
    Returns assertion methods on the value at the start point.
    
    Specified by:
    
    valueAtStartPoint in interface ToValueFromColumn<ChangeColumnValueAssert>
    
    Returns:
    An object to make assertions on the next value.
    See Also:
    valueAtStartPoint, ChangeColumnValueAssert.valueAtStartPoint()
  - valueAtEndPoint
```
public ChangeColumnValueAssert valueAtEndPoint()
```
    Returns assertion methods on the value at the end point.
    
    Specified by:
    
    valueAtEndPoint in interface ToValueFromColumn<ChangeColumnValueAssert>
    
    Returns:
    An object to make assertions on the value.
    See Also:
    valueAtEndPoint, ChangeColumnValueAssert.valueAtEndPoint()
  - isModified
```
public ChangeColumnAssert isModified()
```
    Verifies that the column is modified between the start point and the end point.
    Example where the assertion verifies that :
```
 
 assertThat(changes).change(1).column().isModified();
 
 
```
    Specified by:
    
    isModified in interface AssertOnModifiedColumn<ChangeColumnAssert>
    
    Returns:
    this assertion object.
    See Also:
    isModified()
  - isNotModified
```
public ChangeColumnAssert isNotModified()
```
    Verifies that the column is not modified between the start point and the end point.
    Example where the assertion verifies that :
```
 
 assertThat(changes).change(1).column().isNotModified();
 
 
```
    Specified by:
    
    isNotModified in interface AssertOnModifiedColumn<ChangeColumnAssert>
    
    Returns:
    this assertion object.
    See Also:
    isNotModified()
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(Boolean expected)
```
    Verifies that the values at the start point and the end point are equal to a boolean.
    Example where the assertion verifies that the values of the first Column of the Table are equal to true :
```
 assertThat(changes).change(1).column().hasValuesEqualTo(true);
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expected - The expected boolean value.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(Boolean)
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(Boolean expectedAtStartPoint,
                                  Boolean expectedAtEndPoint)
```
    Verifies that the values at the start point and the end point are equal to a boolean for start point and another boolean for end point.
    Example where the assertion verifies that the values of the first Column of the Table are equal to true at start point and false at end point :
```
 assertThat(changes).change(1).column().hasValuesEqualTo(true, false);
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expectedAtStartPoint - The expected boolean at start point.
    expectedAtEndPoint - The expected boolean at end point.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(Boolean, Boolean)
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(Number expected)
```
    Verifies that the values at the start point and the end point are equal to a number.
    Example where the assertion verifies that the values of the first Column of the Table are equal to 1 :
```
 assertThat(changes).change(1).column().hasValuesEqualTo(1);
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expected - The expected number value.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(Number)
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(Number expectedAtStartPoint,
                                  Number expectedAtEndPoint)
```
    Verifies that the values at the start point and the end point are equal to a number for start point and another number for end point.
    Example where the assertion verifies that the values of the first Column of the Table are equal to 1 at start point and 2 at end point :
```
 assertThat(changes).change(1).column().hasValuesEqualTo(1, 2);
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expectedAtStartPoint - The expected number at start point.
    expectedAtEndPoint - The expected number at end point.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(Number, Number)
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(byte[] expected)
```
    Verifies that the values at the start point and the end point are equal to bytes.
    Example where the assertion verifies that the values of the first Column of the Table are equal to a array of bytes loaded from a file in the classpath :
```
 byte[] bytes = bytesContentFromClassPathOf("file.png");
 assertThat(changes).change(1).column().hasValuesEqualTo(bytes);
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expected - The expected bytes value.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(byte[])
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(byte[] expectedAtStartPoint,
                                  byte[] expectedAtEndPoint)
```
    Verifies that the values at the start point and the end point are equal to bytes for start point and other bytes for end point.
    Example where the assertion verifies that the values of the first Column of the Table are equal to a array of bytes loaded from a file in the classpath at start point and another array at end point :
```
 byte[] bytes = bytesContentFromClassPathOf("file.png");
 byte[] bytes2 = bytesContentFromClassPathOf("file2.png");
 assertThat(changes).change(1).column().hasValuesEqualTo(bytes, bytes2);
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expectedAtStartPoint - The expected bytes at start point.
    expectedAtEndPoint - The expected bytes at end point.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(byte[], byte[])
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(String expected)
```
    Verifies that the values at the start point and the end point are equal to a text.
    Example where the assertion verifies that the values of the first Column of the Table are equal to "Ellen Louise Ripley" :
```
 assertThat(changes).change(1).column().hasValuesEqualTo("Ellen Louise Ripley");
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expected - The expected text value.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(String)
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(String expectedAtStartPoint,
                                  String expectedAtEndPoint)
```
    Verifies that the values at the start point and the end point are equal to a text for start point and another text for end point.
    Example where the assertion verifies that the values of the first Column of the Table are equal to "Sigourney" at start point and "Susan Alexandra" at end point :
```
 assertThat(changes).change(1).column().hasValuesEqualTo("Sigourney", "Susan Alexandra");
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expectedAtStartPoint - The expected text at start point.
    expectedAtEndPoint - The expected text at end point.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(String, String)
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(DateValue expected)
```
    Verifies that the values at the start point and the end point are equal to a date.
    Example where the assertion verifies that the values of the first Column of the Table are equal to 12/23/2007 :
```
 assertThat(changes).change(1).column().hasValuesEqualTo(DateValue.of(2007, 12, 23));
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expected - The expected date value.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(DateValue)
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(DateValue expectedAtStartPoint,
                                  DateValue expectedAtEndPoint)
```
    Verifies that the values at the start point and the end point are equal to a date for start point and another date for end point.
    Example where the assertion verifies that the values of the first Column of the Table are equal to 12/23/2007 at start point and 07/25/2002 at end point :
```
 assertThat(changes).change(1).column().hasValuesEqualTo(DateValue.of(2007, 12, 23), DateValue.of(2002, 7, 25));
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expectedAtStartPoint - The expected date at start point.
    expectedAtEndPoint - The expected date at end point.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(DateValue, DateValue)
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(TimeValue expected)
```
    Verifies that the values at the start point and the end point are equal to a time.
    Example where the assertion verifies that the values of the first Column of the Table are equal to 09:01AM :
```
 assertThat(changes).change(1).column().hasValuesEqualTo(TimeValue.of(9, 1));
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expected - The expected time value.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(TimeValue)
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(TimeValue expectedAtStartPoint,
                                  TimeValue expectedAtEndPoint)
```
    Verifies that the values at the start point and the end point are equal to a time for start point and another time for end point.
    Example where the assertion verifies that the values of the first Column of the Table are equal to 09:01AM at start point and 03:30AM at end point :
```
 assertThat(changes).change(1).column().hasValuesEqualTo(TimeValue.of(9, 1), TimeValue.of(3, 30));
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expectedAtStartPoint - The expected time at start point.
    expectedAtEndPoint - The expected time at end point.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(TimeValue, TimeValue)
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(DateTimeValue expected)
```
    Verifies that the values at the start point and the end point are equal to a date/time.
    Example where the assertion verifies that the values of the first Column of the Table are equal to 12/23/2007 09:01AM :
```
 assertThat(changes).change(1).column().hasValuesEqualTo(DateTimeValue.of(DateValue.of(2007, 12, 23), TimeValue.of(9, 1)));
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expected - The expected date/time value.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(DateTimeValue)
  - hasValuesEqualTo
```
public ChangeColumnAssert hasValuesEqualTo(DateTimeValue expectedAtStartPoint,
                                  DateTimeValue expectedAtEndPoint)
```
    Verifies that the values at the start point and the end point are equal to a date/time for start point and another date/time for end point.
    Example where the assertion verifies that the values of the first Column of the Table are equal to 12/23/2007 09:01AM at start point and 07/25/2002 00:00AM at end point :
```
 assertThat(changes).change(1).column().hasValuesEqualTo(DateTimeValue.of(DateValue.of(2007, 12, 23), TimeValue.of(9, 1)), DateTimeValue.of(DateValue.of(2002, 7, 25)));
 
```
    Specified by:
    
    hasValuesEqualTo in interface AssertOnColumnOfChangeEquality<ChangeColumnAssert>
    
    Parameters:
    expectedAtStartPoint - The expected date/time at start point.
    expectedAtEndPoint - The expected date/time at end point.
    
    Returns:
    this assertion object.
    See Also:
    hasValuesEqualTo(DateTimeValue, DateTimeValue)
  - hasColumnName
```
public ChangeColumnAssert 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<ChangeColumnAssert>
    
    Parameters:
    columnName - The expected column name.
    
    Returns:
    this assertion object.
    See Also:
    AbstractColumnAssert.hasColumnName(String), AbstractRowValueAssert.hasColumnName(String), hasColumnName(String), ChangeRowValueAssert.hasColumnName(String)
  - isOfType
```
public ChangeColumnAssert 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<ChangeColumnAssert>
    
    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:
    AbstractColumnAssert.isOfType(org.assertj.db.type.ValueType, boolean)
  - isOfAnyOfTypes
```
public ChangeColumnAssert isOfAnyOfTypes(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").isOfAnyOfTypes(ValueType.TEXT, ValueType.NUMBER);
 
```
    Specified by:
    
    isOfAnyOfTypes in interface AssertOnColumnType<ChangeColumnAssert>
    
    Parameters:
    expected - The expected types to compare to.
    
    Returns:
    this assertion object.
    See Also:
    AbstractColumnAssert.isOfAnyOfTypes(org.assertj.db.type.ValueType...)
  - isNumber
```
public ChangeColumnAssert 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<ChangeColumnAssert>
    
    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, AbstractColumnAssert.isNumber(boolean)
  - isBoolean
```
public ChangeColumnAssert 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<ChangeColumnAssert>
    
    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, AbstractColumnAssert.isBoolean(boolean)
  - isDate
```
public ChangeColumnAssert 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<ChangeColumnAssert>
    
    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, AbstractColumnAssert.isDate(boolean)
  - isTime
```
public ChangeColumnAssert 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<ChangeColumnAssert>
    
    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, AbstractColumnAssert.isTime(boolean)
  - isDateTime
```
public ChangeColumnAssert 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<ChangeColumnAssert>
    
    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, AbstractColumnAssert.isDateTime(boolean)
  - isBytes
```
public ChangeColumnAssert 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<ChangeColumnAssert>
    
    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, AbstractColumnAssert.isBytes(boolean)
  - isText
```
public ChangeColumnAssert 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<ChangeColumnAssert>
    
    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, AbstractColumnAssert.isText(boolean)
  - returnToChange
```
public ChangeAssert returnToChange()
```
    Returns to level of assertion methods on a Change.
    
    Returns:
    a object of assertion methods on a Change.

Class ChangeColumnAssert

Field Summary

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

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

Method Summary

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

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

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

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

Methods inherited from class java.lang.Object

Methods inherited from interface org.assertj.db.api.navigation.ToChanges

Methods inherited from interface org.assertj.db.api.navigation.ToChange

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

Methods inherited from interface org.assertj.db.api.navigation.ToColumnFromChange

Methods inherited from interface org.assertj.db.api.navigation.ToRowFromChange

Method Detail

valueAtStartPoint

valueAtEndPoint

isModified

isNotModified

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasValuesEqualTo

hasColumnName

isOfType

isOfAnyOfTypes

isNumber

isBoolean

isDate

isTime

isDateTime

isBytes

isText

returnToChange