/** This method tests the {@code isOfType} assertion method. */
  @Test
  @NeedReload
  public void test_is_of_type() {
    Changes changes = new Changes(source).setStartPointNow();
    update("update test set var14 = 1 where var1 = 1");
    update(
        "insert into test(var1, var2, var11, var10, var9, var3, var12, var8) values(5, true, FILE_READ('classpath:h2-logo-2.png'), '2014-05-24 09:46:30', '2014-05-24', 3, 'test', '09:46:30')");
    changes.setEndPointNow();
    Table table = new Table(source, "test");
    Table table2 = new Table(source, "test2");

    ChangeColumnAssert changeColumnAssert1 = assertThat(changes).change().column("var2");
    ChangeColumnAssert changeColumnAssertReturn1 =
        changeColumnAssert1.isOfType(ValueType.BOOLEAN, true);
    Assertions.assertThat(changeColumnAssert1).isSameAs(changeColumnAssertReturn1);
    ChangeColumnAssert changeColumnAssert2 = assertThat(changes).change(1).column("var2");
    ChangeColumnAssert changeColumnAssertReturn2 =
        changeColumnAssert2.isOfType(ValueType.BOOLEAN, false);
    Assertions.assertThat(changeColumnAssert2).isSameAs(changeColumnAssertReturn2);
    TableColumnAssert tableColumnAssert1 = assertThat(table).column("var2");
    TableColumnAssert tableColumnAssertReturn1 =
        tableColumnAssert1.isOfType(ValueType.BOOLEAN, false);
    Assertions.assertThat(tableColumnAssert1).isSameAs(tableColumnAssertReturn1);
    TableColumnAssert tableColumnAssert2 = assertThat(table2).column("var2");
    TableColumnAssert tableColumnAssertReturn2 =
        tableColumnAssert2.isOfType(ValueType.BOOLEAN, true);
    Assertions.assertThat(tableColumnAssert2).isSameAs(tableColumnAssertReturn2);
  }
  /** This method should fail because the value is not null. */
  @Test
  @NeedReload
  public void should_fail_because_value_is_not_null() {
    Table table = new Table(source, "test");
    Changes changes = new Changes(table).setStartPointNow();
    update("update test set var14 = 1 where var1 = 1");
    changes.setEndPointNow();

    try {
      assertThat(changes).change().column("var3").valueAtEndPoint().isNull();
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Value at end point of Column at index 2 (column name : VAR3) of Change at index 0 (with primary key : [1]) of Changes on TEST table of 'sa/jdbc:h2:mem:test' source] expected:<null> but was:<2>"));
    }
    try {
      assertThat(table).column("var3").value().isNull();
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Value at index 0 of Column at index 2 (column name : VAR3) of TEST table] expected:<null> but was:<2>"));
    }
  }
  /** This method tests the {@code hasModifiedColumns} assertion method. */
  @Test
  @NeedReload
  public void test_has_modified_columns() throws Exception {
    Changes changes = new Changes(source).setStartPointNow();
    updateChangesForTests();
    changes.setEndPointNow();

    ChangeAssert changeAssert = assertThat(changes).change(3);
    ChangeAssert changeAssert2 = changeAssert.hasModifiedColumns("FIRSTNAME");
    Assertions.assertThat(changeAssert).isSameAs(changeAssert2);
  }
  /** This method should fail because the values are different. */
  @Test
  @NeedReload
  public void should_fail_because_values_are_different() {
    Table table = new Table(source, "actor");
    Changes changes = new Changes(table).setStartPointNow();
    updateChangesForTests();
    changes.setEndPointNow();

    try {
      assertThat(changes)
          .change()
          .rowAtEndPoint()
          .hasValues(
              4,
              "Murray",
              "Billy",
              "1950-09-21",
              UUID.fromString("30B443AE-C0C9-4790-9BEC-CE1380808435"));
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Row at end point of Change at index 0 (with primary key : [4]) of Changes on actor table of 'sa/jdbc:h2:mem:test' source] %n"
                      + "Expecting that the value at index 2:%n"
                      + "  <\"Bill\">%n"
                      + "to be equal to: %n"
                      + "  <\"Billy\">"));
    }
    try {
      assertThat(table)
          .row()
          .hasValues(
              1,
              "Weaver",
              "Sigourney",
              "1949-10-08",
              UUID.fromString("648DFAC8-14AC-47F7-95CF-3475525A3BE3"));
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Row at index 0 of actor table] %n"
                      + "Expecting that the value at index 2:%n"
                      + "  <\"Susan Alexandra\">%n"
                      + "to be equal to: %n"
                      + "  <\"Sigourney\">"));
    }
  }
  /** This method should fail because the value is no close to. */
  @Test
  @NeedReload
  public void should_fail_because_value_is_not_close_to() {
    Table table = new Table(source, "test");
    Changes changes = new Changes(table).setStartPointNow();
    update("update test set var14 = 1 where var1 = 1");
    changes.setEndPointNow();

    try {
      assertThat(changes)
          .change()
          .column("var10")
          .valueAtEndPoint()
          .isCloseTo(
              DateTimeValue.of(DateValue.of(2014, 5, 24), TimeValue.of(9, 46, 31)),
              TimeValue.of(0, 0, 0, 1));
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Value at end point of Column at index 9 (column name : VAR10) of Change at index 0 (with primary key : [1]) of Changes on TEST table of 'sa/jdbc:h2:mem:test' source] %n"
                      + "Expecting:%n"
                      + "  <2014-05-24T09:46:30.000000000>%n"
                      + "to be close to: %n"
                      + "  <2014-05-24T09:46:31.000000000> %n"
                      + " with tolerance <00:00:00.000000001>"));
    }
    try {
      assertThat(table)
          .column("var10")
          .value()
          .isCloseTo(
              DateTimeValue.of(DateValue.of(2014, 5, 24), TimeValue.of(9, 46, 31)),
              TimeValue.of(0, 0, 0, 100));
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Value at index 0 of Column at index 9 (column name : VAR10) of TEST table] %n"
                      + "Expecting:%n"
                      + "  <2014-05-24T09:46:30.000000000>%n"
                      + "to be close to: %n"
                      + "  <2014-05-24T09:46:31.000000000> %n"
                      + " with tolerance <00:00:00.000000100>"));
    }
  }
  /** This method tests the {@code isNull} assertion method. */
  @Test
  @NeedReload
  public void test_is_null() {
    Table table = new Table(source, "test2");
    Changes changes = new Changes(table).setStartPointNow();
    update("update test2 set var14 = 1 where var1 is null");
    changes.setEndPointNow();

    ChangeColumnValueAssert changeColumnValueAssert =
        assertThat(changes).change().column("var10").valueAtEndPoint();
    ChangeColumnValueAssert changeColumnValueAssert2 = changeColumnValueAssert.isNull();
    Assertions.assertThat(changeColumnValueAssert).isSameAs(changeColumnValueAssert2);

    TableColumnValueAssert tableColumnValueAssert = assertThat(table).column("var10").value(1);
    TableColumnValueAssert tableColumnValueAssert2 = tableColumnValueAssert.isNull();
    Assertions.assertThat(tableColumnValueAssert).isSameAs(tableColumnValueAssert2);
  }
  /** This example shows simple cases of navigation for changes. */
  @Test
  public void basic_navigation_examples_for_changes() throws SQLException {
    Changes changes = new Changes(dataSource);
    changes.setStartPointNow(); // Start point (the moment when the changes start to be taken into
    // account)
    makeChangesInTheData();
    changes
        .setEndPointNow(); // End point (the moment when the changes stop to be taken into account)

    assertThat(changes)
        .change() // First change
        .isCreation() // Assertion on the first change
        .rowAtStartPoint() // Row at the start point
        .doesNotExist() // Assertion on the row at start point of the first change
        .returnToChange() // Go back to the change
        .rowAtEndPoint() // Row at the end point
        .hasNumberOfColumns(6) // Assertion on the row at end point of the first change
        .exists() // Another assertion on the same row
        .value(1) // Value at index 1 of the row at end point of the first change
        .isEqualTo("McGuiness") // Assertion on the value
        .returnToRow() // Go back to the row
        .returnToChange() // Go back to the change
        .change() // Next change
        .rowAtEndPoint() // Row at end point of this change
        .hasValues(1, "Hewson", "Paul David", "Bono Vox", "1960-05-10", 1.75)
        .column("surname") // Column with name is "surname" of the second change (note that
        // returnToChange() is not mandatory)
        .isModified() // Assertion on column
        .hasValues("Bono", "Bono Vox")
        .column() // Next column
        .isNotModified() // Assertion on the column
        .valueAtEndPoint() // Value at end point in the column after "surname" ("birth") of the
        // second change
        .isEqualTo(DateValue.of(1960, 5, 10))
        .ofDeletion() // All the changes of deletion (note that the returnToXxxx() methods are not
        // mandatory)
        .change() // First change of these changes of deletion
        .isOnTable("albums")
        .hasPksValues(15)
        .changeOnTableWithPks("members", 5) // Change with primary key 5 on "members" table
        .isCreation()
        .rowAtEndPoint() // Row at end point of change with primary key 5 on "members" table
        .hasValues(5, "McGuiness", "Paul", null, "1951-06-17", null);
  }
  /** This method tests the {@code isBefore} assertion method. */
  @Test
  @NeedReload
  public void test_is_before() throws ParseException {
    Table table = new Table(source, "test");
    Changes changes = new Changes(table).setStartPointNow();
    update("update test set var14 = 1 where var1 = 1");
    changes.setEndPointNow();

    ChangeColumnValueAssert changeColumnValueAssert =
        assertThat(changes).change().column("var10").valueAtEndPoint();
    ChangeColumnValueAssert changeColumnValueAssert2 =
        changeColumnValueAssert.isBefore(DateTimeValue.parse("2014-05-24T09:46:31"));
    Assertions.assertThat(changeColumnValueAssert).isSameAs(changeColumnValueAssert2);

    TableColumnValueAssert tableColumnValueAssert = assertThat(table).column("var10").value();
    TableColumnValueAssert tableColumnValueAssert2 =
        tableColumnValueAssert.isBefore(DateTimeValue.parse("2014-05-24T09:46:31"));
    Assertions.assertThat(tableColumnValueAssert).isSameAs(tableColumnValueAssert2);
  }
  /** This method should fail because the value is after or equal to. */
  @Test
  @NeedReload
  public void should_fail_because_value_is_after_or_equal_to() throws ParseException {
    Table table = new Table(source, "test");
    Changes changes = new Changes(table).setStartPointNow();
    update("update test set var14 = 1 where var1 = 1");
    changes.setEndPointNow();

    try {
      assertThat(changes)
          .change()
          .column("var10")
          .valueAtEndPoint()
          .isBefore(DateTimeValue.parse("2014-05-24T09:46:30"));
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Value at end point of Column at index 9 (column name : VAR10) of Change at index 0 (with primary key : [1]) of Changes on TEST table of 'sa/jdbc:h2:mem:test' source] %n"
                      + "Expecting:%n"
                      + "  <2014-05-24T09:46:30.000000000>%n"
                      + "to be before %n"
                      + "  <2014-05-24T09:46:30.000000000>"));
    }
    try {
      assertThat(table)
          .column("var10")
          .value()
          .isBefore(DateTimeValue.parse("2014-05-24T09:46:30"));
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Value at index 0 of Column at index 9 (column name : VAR10) of TEST table] %n"
                      + "Expecting:%n"
                      + "  <2014-05-24T09:46:30.000000000>%n"
                      + "to be before %n"
                      + "  <2014-05-24T09:46:30.000000000>"));
    }
  }
  /** This method should fail because the modified columns are different. */
  @Test
  @NeedReload
  public void should_fail_because_modified_columns_are_different() throws Exception {
    Changes changes = new Changes(source).setStartPointNow();
    updateChangesForTests();
    changes.setEndPointNow();

    try {
      assertThat(changes).change(3).hasModifiedColumns("ID");
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Change at index 3 (on table : ACTOR and with primary key : [1]) of Changes on tables of 'sa/jdbc:h2:mem:test' source] %n"
                      + "Expecting :%n"
                      + "  [\"ID\"]%n"
                      + "as modified columns but was:%n"
                      + "  [\"FIRSTNAME\"]"));
    }
  }
  /** This method should fail because the value is not a boolean. */
  @Test
  @NeedReload
  public void should_fail_because_value_is_not_a_boolean() {
    Table table = new Table(source, "test");
    Changes changes = new Changes(table).setStartPointNow();
    update("update test set var14 = 1 where var1 = 1");
    changes.setEndPointNow();

    try {
      assertThat(changes).change().column("var1").valueAtEndPoint().isBoolean();
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Value at end point of Column at index 0 (column name : VAR1) of Change at index 0 (with primary key : [1]) of Changes on TEST table of 'sa/jdbc:h2:mem:test' source] %n"
                      + "Expecting:%n"
                      + "  <1>%n"
                      + "to be of type%n"
                      + "  <BOOLEAN>%n"
                      + "but was of type%n"
                      + "  <NUMBER>"));
    }
    try {
      assertThat(table).column("var1").value().isBoolean();
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Value at index 0 of Column at index 0 (column name : VAR1) of TEST table] %n"
                      + "Expecting:%n"
                      + "  <1>%n"
                      + "to be of type%n"
                      + "  <BOOLEAN>%n"
                      + "but was of type%n"
                      + "  <NUMBER>"));
    }
  }
  /** This method tests the {@code isCloseTo} assertion method. */
  @Test
  @NeedReload
  public void test_is_close_to() {
    Table table = new Table(source, "test");
    Changes changes = new Changes(table).setStartPointNow();
    update("update test set var14 = 1 where var1 = 1");
    changes.setEndPointNow();

    ChangeColumnValueAssert changeColumnValueAssert =
        assertThat(changes).change().column("var10").valueAtEndPoint();
    ChangeColumnValueAssert changeColumnValueAssert2 =
        changeColumnValueAssert.isCloseTo(
            DateTimeValue.of(DateValue.of(2014, 5, 24), TimeValue.of(9, 46, 30)),
            TimeValue.of(0, 0, 0));
    Assertions.assertThat(changeColumnValueAssert).isSameAs(changeColumnValueAssert2);

    TableColumnValueAssert tableColumnValueAssert = assertThat(table).column("var10").value();
    TableColumnValueAssert tableColumnValueAssert2 =
        tableColumnValueAssert.isCloseTo(
            DateTimeValue.of(DateValue.of(2014, 5, 24), TimeValue.of(9, 46, 30)),
            TimeValue.of(0, 0, 0));
    Assertions.assertThat(tableColumnValueAssert).isSameAs(tableColumnValueAssert2);
  }
  /** This method tests the {@code hasValues} assertion method. */
  @Test
  @NeedReload
  public void test_has_values() {
    Table table = new Table(source, "actor");
    Changes changes = new Changes(table).setStartPointNow();
    updateChangesForTests();
    changes.setEndPointNow();

    ChangeRowAssert changeRowAssert = assertThat(changes).change().rowAtEndPoint();
    ChangeRowAssert changeRowAssert2 =
        changeRowAssert
            .hasValues(4, "Murray", "Bill", "1950-09-21", "30B443AE-C0C9-4790-9BEC-CE1380808435")
            .hasValues(
                4,
                "Murray",
                "Bill",
                "1950-09-21",
                UUID.fromString("30B443AE-C0C9-4790-9BEC-CE1380808435"));
    Assertions.assertThat(changeRowAssert).isSameAs(changeRowAssert2);

    TableRowAssert tableRowAssert = assertThat(table).row();
    TableRowAssert tableRowAssert2 =
        tableRowAssert
            .hasValues(
                1,
                "Weaver",
                "Susan Alexandra",
                "1949-10-08",
                "30B443AE-C0C9-4790-9BEC-CE1380808435")
            .hasValues(
                1,
                "Weaver",
                "Susan Alexandra",
                "1949-10-08",
                UUID.fromString("30B443AE-C0C9-4790-9BEC-CE1380808435"));
    Assertions.assertThat(tableRowAssert).isSameAs(tableRowAssert2);
  }
  /** This method tests the {@code changeOfCreation} with index navigation method. */
  @Test
  @NeedReload
  public void test_change_of_creation_with_index_with_assertions() throws Exception {
    Changes changes = new Changes(source).setStartPointNow();
    updateChangesForTests();
    changes.setEndPointNow();

    Field fieldPosition = ChangesAssert.class.getDeclaredField("changesPosition");
    fieldPosition.setAccessible(true);
    Field fieldList = Changes.class.getDeclaredField("changesList");
    fieldList.setAccessible(true);
    Field fieldIndex = PositionWithChanges.class.getDeclaredField("indexNextChangeMap");
    fieldIndex.setAccessible(true);
    Field fieldChange = ChangeAssert.class.getDeclaredField("change");
    fieldChange.setAccessible(true);

    ChangesAssert changesAssert = assertThat(changes);
    PositionWithChanges position = (PositionWithChanges) fieldPosition.get(changesAssert);
    Map<ChangeType, Map<String, Integer>> map =
        (Map<ChangeType, Map<String, Integer>>) fieldIndex.get(position);
    assertThat(map).hasSize(0);
    assertThat(map.get(null)).isNull();
    ChangeAssert changeAssert0 = changesAssert.changeOfCreation(0);
    assertThat(map).hasSize(1);
    assertThat(map.get(null)).isNull();
    assertThat(map.get(ChangeType.CREATION)).hasSize(1);
    assertThat(map.get(ChangeType.CREATION).get(null)).isEqualTo(1);
    ChangeAssert changeAssert1 = changesAssert.changeOfCreation(1);
    assertThat(map).hasSize(1);
    assertThat(map.get(null)).isNull();
    assertThat(map.get(ChangeType.CREATION)).hasSize(1);
    assertThat(map.get(ChangeType.CREATION).get(null)).isEqualTo(2);
    ChangeAssert changeAssert2 = changesAssert.changeOfCreation(2);
    assertThat(map).hasSize(1);
    assertThat(map.get(null)).isNull();
    assertThat(map.get(ChangeType.CREATION)).hasSize(1);
    assertThat(map.get(ChangeType.CREATION).get(null)).isEqualTo(3);
    try {
      changesAssert.changeOfCreation(3);
      fail("An exception must be raised");
    } catch (AssertJDBException e) {
      Assertions.assertThat(e.getMessage()).isEqualTo("Index 3 out of the limits [0, 3[");
    }
    try {
      changesAssert.changeOfCreation(-1);
      fail("An exception must be raised");
    } catch (AssertJDBException e) {
      Assertions.assertThat(e.getMessage()).isEqualTo("Index -1 out of the limits [0, 3[");
    }
    ChangeAssert changeAssertAgain0 = changesAssert.changeOfCreation(0);
    assertThat(changeAssert0).isSameAs(changeAssertAgain0);

    ChangesAssert changesAssertBis = assertThat(changes);
    PositionWithChanges positionBis = (PositionWithChanges) fieldPosition.get(changesAssertBis);
    map = (Map<ChangeType, Map<String, Integer>>) fieldIndex.get(positionBis);
    assertThat(map).hasSize(0);
    assertThat(map.get(null)).isNull();
    ChangeAssert changeAssertBis0 = changesAssertBis.changeOfCreation(0);
    assertThat(map).hasSize(1);
    assertThat(map.get(null)).isNull();
    assertThat(map.get(ChangeType.CREATION)).hasSize(1);
    assertThat(map.get(ChangeType.CREATION).get(null)).isEqualTo(1);
    ChangeAssert changeAssertBis1 = changeAssertBis0.changeOfCreation(1);
    assertThat(map).hasSize(1);
    assertThat(map.get(null)).isNull();
    assertThat(map.get(ChangeType.CREATION)).hasSize(1);
    assertThat(map.get(ChangeType.CREATION).get(null)).isEqualTo(2);
    ChangeAssert changeAssertBis2 = changeAssertBis1.changeOfCreation(2);
    assertThat(map).hasSize(1);
    assertThat(map.get(null)).isNull();
    assertThat(map.get(ChangeType.CREATION)).hasSize(1);
    assertThat(map.get(ChangeType.CREATION).get(null)).isEqualTo(3);
    try {
      changeAssertBis2.changeOfCreation(3);
      fail("An exception must be raised");
    } catch (AssertJDBException e) {
      Assertions.assertThat(e.getMessage()).isEqualTo("Index 3 out of the limits [0, 3[");
    }
    try {
      changeAssertBis2.changeOfCreation(-1);
      fail("An exception must be raised");
    } catch (AssertJDBException e) {
      Assertions.assertThat(e.getMessage()).isEqualTo("Index -1 out of the limits [0, 3[");
    }
    ChangeAssert changeAssertBisAgain0 = changeAssertBis2.changeOfCreation(0);
    assertThat(changeAssertBis0).isSameAs(changeAssertBisAgain0);

    List<Changes> changesList = (List<Changes>) fieldList.get(changes);
    assertThat(fieldChange.get(changeAssert0))
        .isSameAs(fieldChange.get(changeAssertBis0))
        .isSameAs(changesList.get(0));
    assertThat(fieldChange.get(changeAssert1))
        .isSameAs(fieldChange.get(changeAssertBis1))
        .isSameAs(changesList.get(1));
    assertThat(fieldChange.get(changeAssert2))
        .isSameAs(fieldChange.get(changeAssertBis2))
        .isSameAs(changesList.get(2));
  }
  /** This method should fail because a value have different type. */
  @Test
  @NeedReload
  public void should_fail_because_value_have_different_type() {
    Changes changes = new Changes(source).setStartPointNow();
    update("update test set var14 = 1 where var1 = 1");
    update(
        "insert into test(var1, var2, var11, var10, var9, var3, var12, var8) values(5, true, FILE_READ('classpath:h2-logo-2.png'), '2014-05-24 09:46:30', '2014-05-24', 3, 'test', '09:46:30')");
    changes.setEndPointNow();
    Table table = new Table(source, "test");
    Table table2 = new Table(source, "test2");

    try {
      assertThat(changes).change().column("var2").isOfType(ValueType.BOOLEAN, false);
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Column at index 1 (column name : VAR2) of Change at index 0 (on table : TEST and with primary key : [5]) of Changes on tables of 'sa/jdbc:h2:mem:test' source] %n"
                      + "Expecting that the value at start point:%n"
                      + "  <null>%n"
                      + "to be of type%n"
                      + "  <BOOLEAN>%n"
                      + "but was of type%n"
                      + "  <NOT_IDENTIFIED>"));
    }
    try {
      assertThat(changes).change(1).column("var1").isOfType(ValueType.BOOLEAN, true);
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Column at index 0 (column name : VAR1) of Change at index 1 (on table : TEST and with primary key : [1]) of Changes on tables of 'sa/jdbc:h2:mem:test' source] %n"
                      + "Expecting that the value at start point:%n"
                      + "  <1>%n"
                      + "to be of type%n"
                      + "  <[BOOLEAN, NOT_IDENTIFIED]>%n"
                      + "but was of type%n"
                      + "  <NUMBER>"));
    }
    try {
      assertThat(table).column("var1").isOfType(ValueType.BOOLEAN, true);
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Column at index 0 (column name : VAR1) of test table] %n"
                      + "Expecting that the value at index 0:%n"
                      + "  <1>%n"
                      + "to be of type%n"
                      + "  <[BOOLEAN, NOT_IDENTIFIED]>%n"
                      + "but was of type%n"
                      + "  <NUMBER>"));
    }
    try {
      assertThat(table2).column("var2").isOfType(ValueType.BOOLEAN, false);
      fail("An exception must be raised");
    } catch (AssertionError e) {
      Assertions.assertThat(e.getMessage())
          .isEqualTo(
              String.format(
                  "[Column at index 1 (column name : VAR2) of test2 table] %n"
                      + "Expecting that the value at index 1:%n"
                      + "  <null>%n"
                      + "to be of type%n"
                      + "  <BOOLEAN>%n"
                      + "but was of type%n"
                      + "  <NOT_IDENTIFIED>"));
    }
  }