Refine search
@Test public void shouldMatchCommaSeparatedLiteralExcludes() { Predicate<Integer> p = Predicates.excludes("1,2,3,4,5", (i)->i.toString()); assertThat(p.test(1)).isFalse(); assertThat(p.test(2)).isFalse(); assertThat(p.test(3)).isFalse(); assertThat(p.test(4)).isFalse(); assertThat(p.test(5)).isFalse(); assertThat(p.test(0)).isTrue(); assertThat(p.test(6)).isTrue(); assertThat(p.test(-1)).isTrue(); }
@Test public void shouldReturnFalseFromMatchIfAllTypeValuesDoNotMatch() { makeCaseInsensitive(); assertThat(tokens.matches(BasicTokenizer.WORD, BasicTokenizer.DECIMAL)).isFalse(); assertThat(tokens.matches(BasicTokenizer.DECIMAL, BasicTokenizer.WORD)).isFalse(); }
protected void verifyFromInitialSync(SourceRecord record, AtomicBoolean foundLast) { if (record.sourceOffset().containsKey(SourceInfo.INITIAL_SYNC)) { assertThat(record.sourceOffset().containsKey(SourceInfo.INITIAL_SYNC)).isTrue(); Struct value = (Struct) record.value(); assertThat(value.getStruct(Envelope.FieldName.SOURCE).getBoolean(SourceInfo.INITIAL_SYNC)).isTrue(); } else { // Only the last record in the initial sync should be marked as not being part of the initial sync ... assertThat(foundLast.getAndSet(true)).isFalse(); } }
@Test public void shouldMatchCommaSeparatedRegexIncludes() { Predicate<String> p = Predicates.includes("1.*5,30"); assertThat(p.test("30")).isTrue(); assertThat(p.test("1005")).isTrue(); assertThat(p.test("105")).isTrue(); assertThat(p.test("15")).isTrue(); assertThat(p.test("215")).isFalse(); assertThat(p.test("150")).isFalse(); assertThat(p.test("015")).isFalse(); assertThat(p.test("5")).isFalse(); }
@Test public void shouldCanConsumeStringAfterTokensCompleteFromCanConsumeStringArray() { makeCaseInsensitive(); // consume ALL the tokens using canConsume() tokens.canConsume(new String[] { "SELECT", "ALL", "COLUMNS", "FROM", "THIS", "TABLE" }); // try to canConsume() single word assertThat(tokens.canConsume("SELECT")).isFalse(); assertThat(tokens.canConsume(TokenStream.ANY_VALUE)).isFalse(); assertThat(tokens.canConsume(BasicTokenizer.SYMBOL)).isFalse(); }
@Test public void shouldMatchCommaSeparatedLiteralIncludes() { Predicate<Integer> p = Predicates.includes("1,2,3,4,5", (i)->i.toString()); assertThat(p.test(1)).isTrue(); assertThat(p.test(2)).isTrue(); assertThat(p.test(3)).isTrue(); assertThat(p.test(4)).isTrue(); assertThat(p.test(5)).isTrue(); assertThat(p.test(0)).isFalse(); assertThat(p.test(6)).isFalse(); assertThat(p.test(-1)).isFalse(); }
@Test public void shouldCanConsumeStringAfterTokensCompleteFromCanConsumeStringIterator() { makeCaseInsensitive(); // consume ALL the tokens using canConsume() tokens.canConsume(Arrays.asList(new String[] { "SELECT", "ALL", "COLUMNS", "FROM", "THIS", "TABLE" })); // try to canConsume() single word assertThat(tokens.canConsume("SELECT")).isFalse(); assertThat(tokens.canConsume(TokenStream.ANY_VALUE)).isFalse(); assertThat(tokens.canConsume(BasicTokenizer.SYMBOL)).isFalse(); }
@Test public void shouldDetermineIfColumnIsAutoIncrementedUsingColumnName() { assertThat(table.isAutoIncremented("C1")).isFalse(); assertThat(table.isAutoIncremented("C2")).isFalse(); assertThat(table.isAutoIncremented("C3")).isFalse(); assertThat(table.isAutoIncremented("C4")).isTrue(); assertThat(table.isAutoIncremented("non-existant")).isFalse(); }
@Test public void shouldExcludeDatabaseCoveredByMultipleLiteralsInBlacklist() { filters = build.excludeDatabases("db1,db2").createFilters(); assertThat(filters.databaseFilter().test("db1")).isFalse(); assertThat(filters.databaseFilter().test("db2")).isFalse(); }
@Test public void shouldRemoveDirectory() throws Exception { Path path = Paths.get(Testing.Files.dataDir(), "test-dir"); assertThat(path.toFile().mkdirs()).isTrue(); Path file = path.resolve("file.txt"); assertThat(file.toFile().createNewFile()).isTrue(); Testing.Files.delete(path); assertThat(java.nio.file.Files.exists(path)).isFalse(); } }
@Test public void shouldCanConsumeSingleAfterTokensCompleteFromCanConsumeStringList() { makeCaseInsensitive(); // consume ALL the tokens using canConsume() tokens.canConsume("SELECT", "ALL", "COLUMNS", "FROM", "THIS", "TABLE"); // try to canConsume() single word assertThat(tokens.canConsume("SELECT")).isFalse(); assertThat(tokens.canConsume(TokenStream.ANY_VALUE)).isFalse(); assertThat(tokens.canConsume(BasicTokenizer.SYMBOL)).isFalse(); }
@Test public void shouldDetermineIfColumnIsGeneratedUsingColumnName() { assertThat(table.isGenerated("C1")).isTrue(); assertThat(table.isGenerated("C2")).isFalse(); assertThat(table.isGenerated("C3")).isFalse(); assertThat(table.isGenerated("C4")).isFalse(); assertThat(table.isGenerated("non-existant")).isFalse(); }
@Test public void shouldConsiderUnchangedSameInstance() { sets = ReplicaSets.parse("localhost:27017"); assertThat(sets.haveChangedSince(sets)).isFalse(); }
@Test public void shouldDetermineIfColumnIsOptionalUsingColumnName() { assertThat(table.isOptional("C1")).isFalse(); assertThat(table.isOptional("C2")).isFalse(); assertThat(table.isOptional("C3")).isTrue(); assertThat(table.isOptional("C4")).isTrue(); assertThat(table.isOptional("non-existant")).isFalse(); }
@Test public void shouldExcludeDatabaseCoveredByMultipleWildcardsInBlacklist() { filters = build.excludeDatabases("db.*,mongo.*").createFilters(); assertThat(filters.databaseFilter().test("db1")).isFalse(); assertThat(filters.databaseFilter().test("mongo2")).isFalse(); }
@Test public void shouldDetermineIfColumnIsPartOfPrimaryKeyUsingColumnNameWithExactMatch() { assertThat(table.isPrimaryKeyColumn("C1")).isTrue(); assertThat(table.isPrimaryKeyColumn("C2")).isTrue(); assertThat(table.isPrimaryKeyColumn("C3")).isFalse(); assertThat(table.isPrimaryKeyColumn("C4")).isFalse(); assertThat(table.isPrimaryKeyColumn("non-existant")).isFalse(); }
@Test public void shouldExcludeDatabaseCoveredByLiteralInBlacklist() { filters = build.excludeDatabases("db1").createFilters(); assertThat(filters.databaseFilter().test("db1")).isFalse(); }
@Test public void shouldDetermineIfColumnIsPartOfPrimaryKeyUsingColumnNameWithWrongCase() { assertThat(table.isPrimaryKeyColumn("c1")).isTrue(); assertThat(table.isPrimaryKeyColumn("c2")).isTrue(); assertThat(table.isPrimaryKeyColumn("c3")).isFalse(); assertThat(table.isPrimaryKeyColumn("c4")).isFalse(); assertThat(table.isPrimaryKeyColumn("non-existant")).isFalse(); }
@Test public void shouldExcludeDatabaseCoveredByWildcardInBlacklist() { filters = build.excludeDatabases("db.*").createFilters(); assertThat(filters.databaseFilter().test("db1")).isFalse(); }
@Test public void shouldReturnFalseFromCanConsumeWithCaseInsensitiveTokenStreamIfMatchStringIsNotUppercase() { makeCaseInsensitive(); assertThat(tokens.canConsume("Select")).isFalse(); assertThat(tokens.canConsume("SELECT")).isTrue(); assertThat(tokens.canConsume("aLL")).isFalse(); assertThat(tokens.canConsume("all")).isFalse(); assertThat(tokens.canConsume("ALL")).isTrue(); }