org.fest.assertions.ListAssert.isEmpty java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Dictionary d =new Hashtable()
Bundle bundle;bundle.getHeaders()
new Properties()
Smart code suggestions by Codota
}

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

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

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

@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);
}

@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);
}

@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);
}

@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);
}

@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);
}

@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);
}

@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);
}

@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);
}

@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);
}

@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);
}

@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);
}

@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);
}

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

@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);
}

@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);
}

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

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");

Popular methods of ListAssert

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

How to use isEmptymethodin org.fest.assertions.ListAssert

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

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