Codota Logo
ListAssert.isEmpty
Code IndexAdd Codota to your IDE (free)

How to use
isEmpty
method
in
org.fest.assertions.ListAssert

Best Java code snippets using org.fest.assertions.ListAssert.isEmpty (Showing top 20 results out of 315)

  • Add the Codota plugin to your IDE and get smart completions
private void myMethod () {
Dictionary d =
  • Codota Iconnew Hashtable()
  • Codota IconBundle bundle;bundle.getHeaders()
  • Codota Iconnew Properties()
  • Smart code suggestions by Codota
}
origin: debezium/debezium

@Test
public void shouldNotHaveColumnsIfEmpty() {
  assertThat(editor.columnWithName("any")).isNull();
  assertThat(editor.columns()).isEmpty();
  assertThat(editor.primaryKeyColumnNames()).isEmpty();
}
origin: debezium/debezium

assertThat(neverRunTasks).isEmpty();
try {
  while (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
origin: debezium/debezium

@Test
public void shouldCreateTableWhenEditorHasIdButNoColumns() {
  table = editor.tableId(id).create();
  assertThat(table.columnWithName("any")).isNull();
  assertThat(table.columns()).isEmpty();
  assertThat(table.primaryKeyColumnNames()).isEmpty();
}
origin: debezium/debezium

@Test
public void shouldParseCreateViewStatementColumnAliasInnerSelect() {
  String ddl = "CREATE TABLE foo ( " + System.lineSeparator()
      + " c1 INTEGER NOT NULL AUTO_INCREMENT, " + System.lineSeparator()
      + " c2 VARCHAR(22) " + System.lineSeparator()
      + "); " + System.lineSeparator();
  String ddl2 = "CREATE VIEW fooView(w1) AS (SELECT foo2.c2 as w1 FROM (SELECT c1 as c2 FROM foo) AS foo2)" + System.lineSeparator();
  parser = new MysqlDdlParserWithSimpleTestListener(listener, true);
  parser.parse(ddl, tables);
  parser.parse(ddl2, tables);
  assertThat(tables.size()).isEqualTo(2);
  Table foo = tables.forTable(new TableId(null, null, "fooView"));
  assertThat(foo).isNotNull();
  assertThat(foo.retrieveColumnNames()).containsExactly("w1");
  assertThat(foo.primaryKeyColumnNames()).isEmpty();
  assertColumn(foo, "w1", "INTEGER", Types.INTEGER, -1, -1, false, true, true);
}
origin: debezium/debezium

@Test
public void shouldParseCreateTableStatementWithSignedTypes() {
  String ddl = "CREATE TABLE foo ( " + System.lineSeparator()
      + " c1 BIGINT SIGNED NOT NULL, " + System.lineSeparator()
      + " c2 INT UNSIGNED NOT NULL " + System.lineSeparator()
      + "); " + System.lineSeparator();
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
  Table foo = tables.forTable(new TableId(null, null, "foo"));
  assertThat(foo).isNotNull();
  assertThat(foo.retrieveColumnNames()).containsExactly("c1", "c2");
  assertThat(foo.primaryKeyColumnNames()).isEmpty();
  assertColumn(foo, "c1", "BIGINT SIGNED", Types.BIGINT, -1, -1, false, false, false);
  assertColumn(foo, "c2", "INT UNSIGNED", Types.INTEGER, -1, -1, false, false, false);
}
origin: debezium/debezium

@Test
public void shouldParseCreateViewStatementColumnAlias() {
  String ddl = "CREATE TABLE foo ( " + System.lineSeparator()
      + " c1 INTEGER NOT NULL AUTO_INCREMENT, " + System.lineSeparator()
      + " c2 VARCHAR(22) " + System.lineSeparator()
      + "); " + System.lineSeparator();
  String ddl2 = "CREATE VIEW fooView(w1) AS (SELECT c2 as w1 FROM foo)" + System.lineSeparator();
  parser = new MysqlDdlParserWithSimpleTestListener(listener, true);
  parser.parse(ddl, tables);
  parser.parse(ddl2, tables);
  assertThat(tables.size()).isEqualTo(2);
  Table foo = tables.forTable(new TableId(null, null, "fooView"));
  assertThat(foo).isNotNull();
  assertThat(foo.retrieveColumnNames()).containsExactly("w1");
  assertThat(foo.primaryKeyColumnNames()).isEmpty();
  assertColumn(foo, "w1", "VARCHAR", Types.VARCHAR, 22, -1, true, false, false);
}
origin: debezium/debezium

@Test
public void shouldParseCreateTableStatementWithSingleGeneratedAndPrimaryKeyColumn() {
  String ddl = "CREATE TABLE foo ( " + System.lineSeparator()
      + " c1 INTEGER NOT NULL AUTO_INCREMENT, " + System.lineSeparator()
      + " c2 VARCHAR(22) " + System.lineSeparator()
      + "); " + System.lineSeparator();
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
  Table foo = tables.forTable(new TableId(null, null, "foo"));
  assertThat(foo).isNotNull();
  assertThat(foo.retrieveColumnNames()).containsExactly("c1", "c2");
  assertThat(foo.primaryKeyColumnNames()).isEmpty();
  assertColumn(foo, "c1", "INTEGER", Types.INTEGER, -1, -1, false, true, true);
  assertColumn(foo, "c2", "VARCHAR", Types.VARCHAR, 22, -1, true, false, false);
}
origin: debezium/debezium

@Test
public void shouldParseCreateViewStatementStartSelect() {
  String ddl = "CREATE TABLE foo ( " + System.lineSeparator()
      + " c1 INTEGER NOT NULL AUTO_INCREMENT, " + System.lineSeparator()
      + " c2 VARCHAR(22) " + System.lineSeparator()
      + "); " + System.lineSeparator();
  String ddl2 = "CREATE VIEW fooView AS (SELECT * FROM foo)" + System.lineSeparator();
  parser = new MysqlDdlParserWithSimpleTestListener(listener, true);
  parser.parse(ddl, tables);
  parser.parse(ddl2, tables);
  assertThat(tables.size()).isEqualTo(2);
  Table foo = tables.forTable(new TableId(null, null, "fooView"));
  assertThat(foo).isNotNull();
  assertThat(foo.retrieveColumnNames()).containsExactly("c1", "c2");
  assertThat(foo.primaryKeyColumnNames()).isEmpty();
  assertColumn(foo, "c1", "INTEGER", Types.INTEGER, -1, -1, false, true, true);
  assertColumn(foo, "c2", "VARCHAR", Types.VARCHAR, 22, -1, true, false, false);
}
origin: debezium/debezium

@Test
public void shouldParseAlterViewStatementColumnAliasInnerSelect() {
  String ddl = "CREATE TABLE foo ( " + System.lineSeparator()
      + " c1 INTEGER NOT NULL AUTO_INCREMENT, " + System.lineSeparator()
      + " c2 VARCHAR(22) " + System.lineSeparator()
      + "); " + System.lineSeparator();
  String ddl2 = "CREATE VIEW fooView(w1) AS (SELECT foo2.c2 as w1 FROM (SELECT c1 as c2 FROM foo) AS foo2)" + System.lineSeparator();
  String ddl3 = "ALTER VIEW fooView AS (SELECT c2 FROM foo)";
  parser = new MysqlDdlParserWithSimpleTestListener(listener, true);
  parser.parse(ddl, tables);
  parser.parse(ddl2, tables);
  parser.parse(ddl3, tables);
  assertThat(tables.size()).isEqualTo(2);
  assertThat(listener.total()).isEqualTo(3);
  Table foo = tables.forTable(new TableId(null, null, "fooView"));
  assertThat(foo).isNotNull();
  assertThat(foo.retrieveColumnNames()).containsExactly("c2");
  assertThat(foo.primaryKeyColumnNames()).isEmpty();
  assertColumn(foo, "c2", "VARCHAR", Types.VARCHAR, 22, -1, true, false, false);
}
origin: debezium/debezium

@Test
public void shouldParseCreateTableStatementWithCharacterSetForColumns() {
  String ddl = "CREATE TABLE t ( col1 VARCHAR(25) CHARACTER SET greek ); ";
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
  Table t = tables.forTable(new TableId(null, null, "t"));
  assertThat(t).isNotNull();
  assertThat(t.retrieveColumnNames()).containsExactly("col1");
  assertThat(t.primaryKeyColumnNames()).isEmpty();
  assertColumn(t, "col1", "VARCHAR", Types.VARCHAR, 25, -1, true, false, false);
}
origin: debezium/debezium

@FixFor("DBZ-160")
@Test
public void shouldParseCreateTableWithEnumDefault() {
  String ddl = "CREATE TABLE t ( c1 ENUM('a','b','c') NOT NULL DEFAULT 'b', c2 ENUM('a', 'b', 'c') NOT NULL DEFAULT 'a');";
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
  Table t = tables.forTable(new TableId(null, null, "t"));
  assertThat(t).isNotNull();
  assertThat(t.retrieveColumnNames()).containsExactly("c1", "c2");
  assertThat(t.primaryKeyColumnNames()).isEmpty();
  assertColumn(t, "c1", "ENUM", Types.CHAR, 1, -1, false, false, false);
  assertColumn(t, "c2", "ENUM", Types.CHAR, 1, -1, false, false, false);
}
origin: debezium/debezium

@FixFor("DBZ-160")
@Test
public void shouldParseCreateTableWithBitDefault() {
  String ddl = "CREATE TABLE t ( c1 Bit(2) NOT NULL DEFAULT b'1', c2 Bit(2) NOT NULL);";
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
  Table t = tables.forTable(new TableId(null, null, "t"));
  assertThat(t).isNotNull();
  assertThat(t.retrieveColumnNames()).containsExactly("c1", "c2");
  assertThat(t.primaryKeyColumnNames()).isEmpty();
  assertColumn(t, "c1", "BIT", Types.BIT, 2, -1, false, false, false);
  assertColumn(t, "c2", "BIT", Types.BIT, 2, -1, false, false, false);
}
origin: debezium/debezium

@Test
public void parseDdlForDecAndFixed() {
  String ddl = "CREATE TABLE t ( c1 DEC(2) NOT NULL, c2 FIXED(1,0) NOT NULL, c3 NUMERIC(3) NOT NULL);";
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
  Table t = tables.forTable(new TableId(null, null, "t"));
  assertThat(t).isNotNull();
  assertThat(t.retrieveColumnNames()).containsExactly("c1", "c2", "c3");
  assertThat(t.primaryKeyColumnNames()).isEmpty();
  assertColumn(t, "c1", "DEC", Types.DECIMAL, 2, 0, false, false, false);
  assertColumn(t, "c2", "FIXED", Types.DECIMAL, 1, 0, false, false, false);
  assertColumn(t, "c3", "NUMERIC", Types.NUMERIC, 3, 0, false, false, false);
}
origin: debezium/debezium

@Test
public void shouldParseAlterTableStatementThatAddsCharacterSetForColumns() {
  String ddl = "CREATE TABLE t ( col1 VARCHAR(25) ); ";
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
  Table t = tables.forTable(new TableId(null, null, "t"));
  assertThat(t).isNotNull();
  assertThat(t.retrieveColumnNames()).containsExactly("col1");
  assertThat(t.primaryKeyColumnNames()).isEmpty();
  assertColumn(t, "col1", "VARCHAR", Types.VARCHAR, 25, null, true);
  ddl = "ALTER TABLE t MODIFY col1 VARCHAR(50) CHARACTER SET greek;";
  parser.parse(ddl, tables);
  Table t2 = tables.forTable(new TableId(null, null, "t"));
  assertThat(t2).isNotNull();
  assertThat(t2.retrieveColumnNames()).containsExactly("col1");
  assertThat(t2.primaryKeyColumnNames()).isEmpty();
  assertColumn(t2, "col1", "VARCHAR", Types.VARCHAR, 50, "greek", true);
  ddl = "ALTER TABLE t MODIFY col1 VARCHAR(75) CHARSET utf8;";
  parser.parse(ddl, tables);
  Table t3 = tables.forTable(new TableId(null, null, "t"));
  assertThat(t3).isNotNull();
  assertThat(t3.retrieveColumnNames()).containsExactly("col1");
  assertThat(t3.primaryKeyColumnNames()).isEmpty();
  assertColumn(t3, "col1", "VARCHAR", Types.VARCHAR, 75, "utf8", true);
}
origin: debezium/debezium

@Test
@FixFor({"DBZ-615", "DBZ-727"})
public void parseDdlForUnscaledDecAndFixed() {
  String ddl = "CREATE TABLE t ( c1 DEC NOT NULL, c2 FIXED(3) NOT NULL, c3 NUMERIC NOT NULL);";
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
  Table t = tables.forTable(new TableId(null, null, "t"));
  assertThat(t).isNotNull();
  assertThat(t.retrieveColumnNames()).containsExactly("c1", "c2", "c3");
  assertThat(t.primaryKeyColumnNames()).isEmpty();
  assertColumn(t, "c1", "DEC", Types.DECIMAL, 10, 0, false, false, false);
  assertColumn(t, "c2", "FIXED", Types.DECIMAL, 3, 0, false, false, false);
  assertColumn(t, "c3", "NUMERIC", Types.NUMERIC, 10, 0, false, false, false);
}
origin: debezium/debezium

assertThat(t).isNotNull();
assertThat(t.retrieveColumnNames()).containsExactly("col1");
assertThat(t.primaryKeyColumnNames()).isEmpty();
assertColumn(t, "col1", "VARCHAR", Types.VARCHAR, 25, -1, true, false, false);
assertThat(t2).isNotNull();
assertThat(t2.retrieveColumnNames()).containsExactly("col1");
assertThat(t2.primaryKeyColumnNames()).isEmpty();
assertColumn(t2, "col1", "VARCHAR", Types.VARCHAR, 25, -1, true, false, false);
assertThat(t3).isNotNull();
assertThat(t3.retrieveColumnNames()).containsExactly("col1");
assertThat(t3.primaryKeyColumnNames()).isEmpty();
assertColumn(t3, "col1", "VARCHAR", Types.VARCHAR, 25, -1, true, false, false);
assertThat(t4).isNotNull();
assertThat(t4.retrieveColumnNames()).containsExactly("col1");
assertThat(t4.primaryKeyColumnNames()).isEmpty();
assertColumn(t4, "col1", "VARCHAR", Types.VARCHAR, 25, -1, true, false, false);
origin: debezium/debezium

@Test
public void shouldParseCreateTableWithEnumAndSetColumns() {
  String ddl = "CREATE TABLE t ( c1 ENUM('a','b','c') NOT NULL, c2 SET('a','b','c') NULL);";
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
  Table t = tables.forTable(new TableId(null, null, "t"));
  assertThat(t).isNotNull();
  assertThat(t.retrieveColumnNames()).containsExactly("c1", "c2");
  assertThat(t.primaryKeyColumnNames()).isEmpty();
  assertColumn(t, "c1", "ENUM", Types.CHAR, 1, -1, false, false, false);
  assertColumn(t, "c2", "SET", Types.CHAR, 5, -1, true, false, false);
  assertThat(t.columnWithName("c1").position()).isEqualTo(1);
  assertThat(t.columnWithName("c2").position()).isEqualTo(2);
}
origin: debezium/debezium

@FixFor("DBZ-204")
@Test
public void shouldParseAlterTableThatChangesMultipleColumns() {
  String ddl = "CREATE TABLE `s`.`test` (a INT(11) NULL, b INT NULL, c INT NULL, INDEX i1(b));";
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
  Table t = tables.forTable(new TableId(null, "s", "test"));
  assertThat(t).isNotNull();
  assertThat(t.retrieveColumnNames()).containsExactly("a", "b", "c");
  assertThat(t.primaryKeyColumnNames()).isEmpty();
  assertColumn(t, "a", "INT", Types.INTEGER, 11, -1, true, false, false);
  assertColumn(t, "b", "INT", Types.INTEGER, -1, -1, true, false, false);
  assertColumn(t, "c", "INT", Types.INTEGER, -1, -1, true, false, false);
  ddl = "ALTER TABLE `s`.`test` CHANGE COLUMN `a` `d` BIGINT(20) NOT NULL AUTO_INCREMENT";
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
  t = tables.forTable(new TableId(null, "s", "test"));
  assertThat(t).isNotNull();
  assertThat(t.retrieveColumnNames()).containsExactly("d", "b", "c");
  assertThat(t.primaryKeyColumnNames()).isEmpty();
  assertColumn(t, "d", "BIGINT", Types.BIGINT, 20, -1, false, true, true);
  assertColumn(t, "b", "INT", Types.INTEGER, -1, -1, true, false, false);
  assertColumn(t, "c", "INT", Types.INTEGER, -1, -1, true, false, false);
  ddl = "ALTER TABLE `s`.`test` DROP INDEX i1";
  parser.parse(ddl, tables);
  assertThat(tables.size()).isEqualTo(1);
}
origin: debezium/debezium

assertThat(t).isNotNull();
assertThat(t.retrieveColumnNames()).containsExactly("col1");
assertThat(t.primaryKeyColumnNames()).isEmpty();
assertColumn(t, "col1", "VARCHAR", Types.VARCHAR, 25, -1, true, false, false);
assertThat(t.columnWithName("col1").position()).isEqualTo(1);
assertThat(t2).isNotNull();
assertThat(t2.retrieveColumnNames()).containsExactly("col1", "col2");
assertThat(t2.primaryKeyColumnNames()).isEmpty();
assertColumn(t2, "col1", "VARCHAR", Types.VARCHAR, 25, -1, true, false, false);
assertColumn(t2, "col2", "VARCHAR", Types.VARCHAR, 50, -1, false, false, false);
assertThat(t3).isNotNull();
assertThat(t3.retrieveColumnNames()).containsExactly("col1", "col3", "col2");
assertThat(t3.primaryKeyColumnNames()).isEmpty();
assertColumn(t3, "col1", "VARCHAR", Types.VARCHAR, 25, -1, true, false, false);
assertColumn(t3, "col3", "FLOAT", Types.FLOAT, -1, -1, false, false, false);
origin: debezium/debezium

Table person = tables.forTable(DATABASE.getDatabaseName(), null, "person");
assertThat(person).isNotNull();
assertThat(person.filterColumns(col->col.isAutoIncremented())).isEmpty();
assertThat(person.primaryKeyColumnNames()).containsOnly("name");
assertThat(person.retrieveColumnNames()).containsExactly("name","birthdate","age","salary","bitStr");
Table purchased = tables.forTable(DATABASE.getDatabaseName(), null, "purchased");
assertThat(purchased).isNotNull();
assertThat(person.filterColumns(col->col.isAutoIncremented())).isEmpty();
assertThat(purchased.primaryKeyColumnNames()).containsOnly("productId","purchaser");
assertThat(purchased.retrieveColumnNames()).containsExactly("purchaser","productId","purchaseDate");
org.fest.assertionsListAssertisEmpty

Popular methods of ListAssert

  • hasSize
  • isEqualTo
  • containsExactly
  • as
  • containsOnly
  • isNotNull
  • contains
  • isNotEmpty
  • isNull
  • containsSequence
  • excludes
  • isNullOrEmpty
  • excludes,
  • isNullOrEmpty,
  • overridingErrorMessage,
  • isSameAs,
  • onProperty

Popular in Java

  • Reading from database using SQL prepared statement
  • requestLocationUpdates (LocationManager)
  • setScale (BigDecimal)
    Returns a BigDecimal whose scale is the specified value, and whose value is numerically equal to thi
  • compareTo (BigDecimal)
    Compares this BigDecimal with the specified BigDecimal. Two BigDecimal objects that are equal in val
  • Rectangle (java.awt)
    A Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle object's top-
  • BufferedWriter (java.io)
    Wraps an existing Writer and buffers the output. Expensive interaction with the underlying reader is
  • IOException (java.io)
    Signals that an I/O exception of some sort has occurred. This class is the general class of exceptio
  • InputStreamReader (java.io)
    An InputStreamReader is a bridge from byte streams to character streams: It reads bytes and decodes
  • Calendar (java.util)
    Calendar is an abstract base class for converting between a Date object and a set of integer fields
  • StringTokenizer (java.util)
    The string tokenizer class allows an application to break a string into tokens. The tokenization met
Codota Logo
  • Products

    Search for Java codeSearch for JavaScript codeEnterprise
  • IDE Plugins

    IntelliJ IDEAWebStormAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogCodota Academy Plugin user guide Terms of usePrivacy policyJava Code IndexJavascript Code Index
Get Codota for your IDE now