@Test public void BuildListWith1Item() { List<String> documentClassCodeList = new ArrayList<String>(); documentClassCodeList.add("classcode1"); String classCodes = DocumentClassCodeParser.buildDocumentClassCodeItem(documentClassCodeList); assertEquals("('classcode1')", classCodes); }
/** Reads a custom schema. */ @Test public void testCustomSchema() throws IOException { final ObjectMapper mapper = mapper(); JsonRoot root = mapper.readValue( "{\n" + " version: '1.0',\n" + " schemas: [\n" + " {\n" + " type: 'custom',\n" + " name: 'My Custom Schema',\n" + " factory: 'com.acme.MySchemaFactory',\n" + " operand: {a: 'foo', b: [1, 3.5] }\n" + " }\n" + " ]\n" + "}", JsonRoot.class); assertEquals("1.0", root.version); assertEquals(1, root.schemas.size()); final JsonCustomSchema schema = (JsonCustomSchema) root.schemas.get(0); assertEquals("My Custom Schema", schema.name); assertEquals("com.acme.MySchemaFactory", schema.factory); assertEquals("foo", schema.operand.get("a")); assertNull(schema.operand.get("c")); assertTrue(schema.operand.get("b") instanceof List); final List list = (List) schema.operand.get("b"); assertEquals(2, list.size()); assertEquals(1, list.get(0)); assertEquals(3.5, list.get(1)); }
public List<TestFile> files(Object... paths) { List<TestFile> files = new ArrayList<TestFile>(); for (Object path : paths) { files.add(file(path)); } return files; }
@Override public void verify() throws TransformException { ItemList targets = mod.nearest(NodeTarget.class).targets(); List<Node> references = mod.references(); ItemList records = mod.supplementQuery().all("sort-proxy"); assert targets.size() == references.size(); assert records.size() == references.size(); for (int i = 0; i < targets.size(); i++) { Node target = targets.get(i).node(); Node restoredProxy = references.get(i); ItemList items = query.runOn(mod.scope(target.query())); if (items.size() != 1) throw new TransformException( "sort by corresponding node must select one node per target, but instead selected " + items.size() + ": " + items); Node proxy = items.get(0).node(); if (!restoredProxy.equals(proxy)) throw new TransformException("computed proxy changed"); if (!proxy .query() .single( "(count(preceding::*) + count(ancestor::*)) eq xs:integer($_1/@position)", records.get(i)) .booleanValue()) throw new SortingException("computed proxy moved"); } }
@Test public void rejectAllStorageOperationsBeingInInappropriateState() throws Exception { // -- generate list of "inappropriate" states final List<String> states = new LinkedList<>(); final EnumSet<StorageNode.StorageState> allowedStates = EnumSet.of(StorageNode.StorageState.RECOVERING, StorageNode.StorageState.RUNNING); for (StorageNode.StorageState s : StorageNode.StorageState.values()) { if (!allowedStates.contains(s)) { states.add(s.name()); } } // -- for (String s : states) { if (!node.getState().equals(s)) { manageNode(new ControlMessage.Builder().setState(s)); } assertEquals(s, node.getState()); for (StorageOperation op : allOperations) { // TODO: rewrite with Exception Matcher to introduce message checking try { node.onStorageRequest(op); fail(); } catch (IllegalStateException ex) { } } } }
/** * Test importing of Clinical Data File. * * @throws DaoException Database Access Error. * @throws IOException IO Error. */ @Test @Ignore("To be fixed") public void testImportClinicalDataSurvival() throws Exception { // TBD: change this to use getResourceAsStream() File clinicalFile = new File("target/test-classes/clinical_data.txt"); ImportClinicalData importClinicalData = new ImportClinicalData(study, clinicalFile); importClinicalData.importData(); LinkedHashSet<String> caseSet = new LinkedHashSet<String>(); caseSet.add("TCGA-A1-A0SB"); caseSet.add("TCGA-A1-A0SI"); caseSet.add("TCGA-A1-A0SE"); List<Patient> clinicalCaseList = DaoClinicalData.getSurvivalData(study.getInternalId(), caseSet); assertEquals(3, clinicalCaseList.size()); Patient clinical0 = clinicalCaseList.get(0); assertEquals(new Double(79.04), clinical0.getAgeAtDiagnosis()); assertEquals("DECEASED", clinical0.getOverallSurvivalStatus()); assertEquals("Recurred/Progressed", clinical0.getDiseaseFreeSurvivalStatus()); assertEquals(new Double(43.8), clinical0.getOverallSurvivalMonths()); assertEquals(new Double(15.05), clinical0.getDiseaseFreeSurvivalMonths()); Patient clinical1 = clinicalCaseList.get(1); assertEquals(new Double(55.53), clinical1.getAgeAtDiagnosis()); assertEquals("LIVING", clinical1.getOverallSurvivalStatus()); assertEquals("DiseaseFree", clinical1.getDiseaseFreeSurvivalStatus()); assertEquals(new Double(49.02), clinical1.getOverallSurvivalMonths()); assertEquals(new Double(49.02), clinical1.getDiseaseFreeSurvivalMonths()); Patient clinical2 = clinicalCaseList.get(2); assertEquals(null, clinical2.getDiseaseFreeSurvivalMonths()); }
@Test public void test2() { List<Integer> input = new ArrayList<>(Arrays.asList(1, 2, 3)); List<Integer> output = new ArrayList<>(Arrays.asList(3, 2, 1)); WithList.reverse(input); for (int i = 0; i < input.size(); i++) assertEquals(output.get(i), input.get(i)); }
@Test public void test_find_children_2() { for (boolean left : new boolean[] {true, false}) { for (boolean right : new boolean[] {true, false}) { List keys = new ArrayList(); for (int i = 0; i < 100; i += 10) { keys.add(i); } int[] child = new int[keys.size() + (right ? 1 : 0) + (left ? 1 : 0)]; Arrays.fill(child, 11); if (right) child[child.length - 1] = 0; BTreeMap.BNode n = new BTreeMap.DirNode(keys.toArray(), left, right, false, mkchild(child)); for (int i = -10; i < 110; i++) { int pos = BTreeKeySerializer.BASIC.findChildren(n, i); int expected = (i + (left ? 19 : 9)) / 10; expected = Math.max(left ? 1 : 0, expected); expected = Math.min(left ? 11 : 10, expected); assertEquals("i:" + i + " - l:" + left + " - r:" + right, expected, pos); } } } }
/** * Test usage from multiple threads. * * @throws InterruptedException if interrupted */ public final void testInstancesUsedFromMultipleThreads() throws InterruptedException { final Set<Touchable> set = Collections.synchronizedSet(new HashSet<Touchable>()); final List<Touchable> list = Collections.synchronizedList(new ArrayList<Touchable>()); final ComponentAdapter componentAdapter = new ThreadLocalizing.ThreadLocalized( new ConstructorInjection.ConstructorInjector( Touchable.class, SimpleTouchable.class, null)); final Touchable touchable = (Touchable) componentAdapter.getComponentInstance(null, ComponentAdapter.NOTHING.class); final Thread[] threads = { new Thread(new Runner(touchable, list, set), "junit-1"), new Thread(new Runner(touchable, list, set), "junit-2"), new Thread(new Runner(touchable, list, set), "junit-3"), }; for (int i = threads.length; i-- > 0; ) { threads[i].start(); } Thread.sleep(300); for (int i = threads.length; i-- > 0; ) { synchronized (threads[i]) { threads[i].notifyAll(); } } Thread.sleep(300); for (int i = threads.length; i-- > 0; ) { threads[i].interrupt(); } Thread.sleep(300); assertEquals(6, list.size()); assertEquals(3, set.size()); }
@Test public void testNetworkConfig() { NetworkConfig networkConfig = config.getNetworkConfig(); assertNotNull(networkConfig); assertEquals(5700, networkConfig.getPort()); assertFalse(networkConfig.isPortAutoIncrement()); final Collection<String> allowedPorts = networkConfig.getOutboundPortDefinitions(); assertEquals(2, allowedPorts.size()); Iterator portIter = allowedPorts.iterator(); assertEquals("35000-35100", portIter.next()); assertEquals("36000,36100", portIter.next()); assertFalse(networkConfig.getJoin().getMulticastConfig().isEnabled()); assertEquals(networkConfig.getJoin().getMulticastConfig().getMulticastTimeoutSeconds(), 8); assertEquals(networkConfig.getJoin().getMulticastConfig().getMulticastTimeToLive(), 16); assertFalse(networkConfig.getInterfaces().isEnabled()); assertEquals(1, networkConfig.getInterfaces().getInterfaces().size()); assertEquals("10.10.1.*", networkConfig.getInterfaces().getInterfaces().iterator().next()); TcpIpConfig tcp = networkConfig.getJoin().getTcpIpConfig(); assertNotNull(tcp); assertTrue(tcp.isEnabled()); assertTrue(networkConfig.getSymmetricEncryptionConfig().isEnabled()); final List<String> members = tcp.getMembers(); assertEquals(members.toString(), 2, members.size()); assertEquals("127.0.0.1:5700", members.get(0)); assertEquals("127.0.0.1:5701", members.get(1)); assertEquals("127.0.0.1:5700", tcp.getRequiredMember()); AwsConfig aws = networkConfig.getJoin().getAwsConfig(); assertFalse(aws.isEnabled()); assertEquals("sample-access-key", aws.getAccessKey()); assertEquals("sample-secret-key", aws.getSecretKey()); assertEquals("sample-region", aws.getRegion()); assertEquals("sample-group", aws.getSecurityGroupName()); assertEquals("sample-tag-key", aws.getTagKey()); assertEquals("sample-tag-value", aws.getTagValue()); }
@Test // Uses of JMockit API: 8 public void useArgumentMatchers() { new Expectations() { { // Using built-in matchers: mockedList.get(anyInt); result = "element"; // Using Hamcrest matchers: mockedList.get(withArgThat(is(equalTo(5)))); result = new IllegalArgumentException(); minTimes = 0; mockedList.contains(withArgThat(hasProperty("bytes"))); result = true; mockedList.containsAll(withArgThat(hasSize(2))); result = true; } }; assertEquals("element", mockedList.get(999)); assertTrue(mockedList.contains("abc")); assertTrue(mockedList.containsAll(asList("a", "b"))); new Verifications() { { mockedList.get(anyInt); } }; }
@Test public void insertChildrenAtPosition() { Document doc = Jsoup.parse( "<div id=1>Text1 <p>One</p> Text2 <p>Two</p></div><div id=2>Text3 <p>Three</p></div>"); Element div1 = doc.select("div").get(0); Elements p1s = div1.select("p"); Element div2 = doc.select("div").get(1); assertEquals(2, div2.childNodeSize()); div2.insertChildren(-1, p1s); assertEquals(2, div1.childNodeSize()); // moved two out assertEquals(4, div2.childNodeSize()); assertEquals(3, p1s.get(1).siblingIndex()); // should be last List<Node> els = new ArrayList<Node>(); Element el1 = new Element(Tag.valueOf("span"), "").text("Span1"); Element el2 = new Element(Tag.valueOf("span"), "").text("Span2"); TextNode tn1 = new TextNode("Text4", ""); els.add(el1); els.add(el2); els.add(tn1); assertNull(el1.parent()); div2.insertChildren(-2, els); assertEquals(div2, el1.parent()); assertEquals(7, div2.childNodeSize()); assertEquals(3, el1.siblingIndex()); assertEquals(4, el2.siblingIndex()); assertEquals(5, tn1.siblingIndex()); }
@Test public void getSliceRespectsAllBoundsInclusionArguments() throws Exception { // Test case where endColumn=startColumn+1 ByteBuffer key = KeyColumnValueStoreUtil.longToByteBuffer(0); ByteBuffer columnBeforeStart = KeyColumnValueStoreUtil.longToByteBuffer(776); ByteBuffer columnStart = KeyColumnValueStoreUtil.longToByteBuffer(777); ByteBuffer columnEnd = KeyColumnValueStoreUtil.longToByteBuffer(778); ByteBuffer columnAfterEnd = KeyColumnValueStoreUtil.longToByteBuffer(779); // First insert four test Entries TransactionHandle txn = manager.beginTransaction(); List<Entry> entries = Arrays.asList( new Entry(columnBeforeStart, columnBeforeStart), new Entry(columnStart, columnStart), new Entry(columnEnd, columnEnd), new Entry(columnAfterEnd, columnAfterEnd)); store.mutate(key, entries, null, txn); txn.commit(); // getSlice() with only start inclusive txn = manager.beginTransaction(); List<Entry> result = store.getSlice(key, columnStart, columnEnd, txn); assertEquals(1, result.size()); assertEquals(777, result.get(0).getColumn().getLong()); txn.commit(); }
public void checkSlice( String[][] values, Set<KeyColumn> removed, int key, int start, int end, int limit) { List<Entry> entries; if (limit <= 0) entries = store.getSlice( KeyValueStoreUtil.getBuffer(key), KeyValueStoreUtil.getBuffer(start), KeyValueStoreUtil.getBuffer(end), tx); else entries = store.getSlice( KeyValueStoreUtil.getBuffer(key), KeyValueStoreUtil.getBuffer(start), KeyValueStoreUtil.getBuffer(end), limit, tx); int pos = 0; for (int i = start; i < end; i++) { if (removed.contains(new KeyColumn(key, i))) continue; if (limit <= 0 || pos < limit) { Entry entry = entries.get(pos); int col = KeyValueStoreUtil.getID(entry.getColumn()); String str = KeyValueStoreUtil.getString(entry.getValue()); assertEquals(i, col); assertEquals(values[key][i], str); } pos++; } assertNotNull(entries); if (limit > 0 && pos > limit) assertEquals(limit, entries.size()); else assertEquals(pos, entries.size()); }
@Test public void testAdd() throws DatabaseException { Project census = new Project("census", 2, 3, 4, 5); Project births = new Project("births", 6, 7, 8, 9); dbProjects.add(census); dbProjects.add(births); List<Project> all = dbProjects.getAll(); assertEquals(2, all.size()); boolean foundAge = false; boolean foundPlace = false; for (Project p : all) { assertFalse(p.getId() == -1); if (!foundAge) { foundAge = areEqual(p, census, false); } if (!foundPlace) { foundPlace = areEqual(p, births, false); } } assertTrue(foundAge && foundPlace); }
// #list-validate public List<ValidationError> validate() { List<ValidationError> errors = new ArrayList<ValidationError>(); if (User.byEmail(email) != null) { errors.add(new ValidationError("email", "This e-mail is already registered.")); } return errors.isEmpty() ? null : errors; }
@Test public void testCompareByName() throws Exception { final Category cat1 = context.mock(Category.class, "cat1"); final Category cat2 = context.mock(Category.class, "cat2"); context.checking( new Expectations() { { allowing(cat1).getRank(); will(returnValue(0)); allowing(cat1).getName(); will(returnValue("name 2")); allowing(cat1).getCategoryId(); will(returnValue(1L)); allowing(cat2).getRank(); will(returnValue(0)); allowing(cat2).getName(); will(returnValue("name 1")); } }); final SortedSet<Category> set = new TreeSet<Category>(new CategoryRankNameComparator()); set.addAll(Arrays.asList(cat1, cat2)); final List<Category> list = new ArrayList<Category>(set); assertTrue(cat2 == list.get(0)); assertTrue(cat1 == list.get(1)); }
@Test public void insert_many_reopen_check() throws InterruptedException { e = openEngine(); int max = 1000; int size = 100000; Random r = new Random(0); List<Long> recids = new ArrayList<Long>(); for (int j = 0; j < max; j++) { byte[] b = new byte[r.nextInt(size)]; r.nextBytes(b); long recid = e.put(b, Serializer.BYTE_ARRAY_NOSIZE); recids.add(recid); } e.commit(); reopen(); r = new Random(0); for (long recid : recids) { byte[] b = new byte[r.nextInt(size)]; r.nextBytes(b); byte[] b2 = e.get(recid, Serializer.BYTE_ARRAY_NOSIZE); assertTrue("Data were not commited recid=" + recid, Arrays.equals(b, b2)); } }
@Test public void testCreateAndDropManyDatabases() throws Exception { List<String> createdDatabases = new ArrayList<>(); InfoSchemaMetadataDictionary dictionary = new InfoSchemaMetadataDictionary(); String namePrefix = "database_"; final int NUM = 10; for (int i = 0; i < NUM; i++) { String databaseName = namePrefix + i; assertFalse(catalog.existDatabase(databaseName)); catalog.createDatabase(databaseName, TajoConstants.DEFAULT_TABLESPACE_NAME); assertTrue(catalog.existDatabase(databaseName)); createdDatabases.add(databaseName); } Collection<String> allDatabaseNames = catalog.getAllDatabaseNames(); for (String databaseName : allDatabaseNames) { assertTrue( databaseName.equals(DEFAULT_DATABASE_NAME) || createdDatabases.contains(databaseName) || dictionary.isSystemDatabase(databaseName)); } // additional ones are 'default' and 'system' databases. assertEquals(NUM + 2, allDatabaseNames.size()); Collections.shuffle(createdDatabases); for (String tobeDropped : createdDatabases) { assertTrue(catalog.existDatabase(tobeDropped)); catalog.dropDatabase(tobeDropped); assertFalse(catalog.existDatabase(tobeDropped)); } }
private List<String> dependenciesOf(Package source) { List<String> result = new ArrayList<>(); if (source.isAnnotationPresent(DependsUpon.class)) for (Class<?> target : source.getAnnotation(DependsUpon.class).packagesOf()) result.add(target.getPackage().getName()); return result; }
@Test public void testDelTail() { System.out.println("\n___ TEST DEL TAIL____\n"); List<Object> l = new ArrayList<Object>(); l.add("a"); l.add("b"); l.add("c"); l.add("d"); l.add("e"); l.add("f"); l.add("g"); DifTree test = DifTreeImpl.create(l); System.out.println("Del everything from the Tail"); System.out.println(test); test.delTail(); System.out.println(test); test.delTail(); System.out.println(test); test.delTail(); System.out.println(test); test.delTail(); System.out.println(test); test.delTail(); System.out.println(test); test.delTail(); System.out.println(test); test.delTail(); System.out.println(test); assertTrue(true); }
@Test public void testEnums() { sql2o .createQuery( "create table EnumTest(id int identity primary key, enum_val varchar(10), enum_val2 int) ") .executeUpdate(); sql2o .createQuery("insert into EnumTest(enum_val, enum_val2) values (:val, :val2)") .addParameter("val", TestEnum.HELLO) .addParameter("val2", TestEnum.HELLO.ordinal()) .addToBatch() .addParameter("val", TestEnum.WORLD) .addParameter("val2", TestEnum.WORLD.ordinal()) .addToBatch() .executeBatch(); List<EntityWithEnum> list = sql2o .createQuery("select id, enum_val val, enum_val2 val2 from EnumTest") .executeAndFetch(EntityWithEnum.class); assertThat(list.get(0).val, is(TestEnum.HELLO)); assertThat(list.get(0).val2, is(TestEnum.HELLO)); assertThat(list.get(1).val, is(TestEnum.WORLD)); assertThat(list.get(1).val2, is(TestEnum.WORLD)); TestEnum testEnum = sql2o.createQuery("select 'HELLO' from (values(0))").executeScalar(TestEnum.class); assertThat(testEnum, is(TestEnum.HELLO)); TestEnum testEnum2 = sql2o.createQuery("select NULL from (values(0))").executeScalar(TestEnum.class); assertThat(testEnum2, is(nullValue())); }
/** * Tests that the system.peers table is not updated after a node has been removed. (See * CASSANDRA-6053) */ @Test public void testStateChangeOnRemovedNode() throws UnknownHostException { StorageService ss = StorageService.instance; VersionedValue.VersionedValueFactory valueFactory = new VersionedValue.VersionedValueFactory(partitioner); // create a ring of 2 nodes ArrayList<Token> endpointTokens = new ArrayList<>(); List<InetAddress> hosts = new ArrayList<>(); Util.createInitialRing( ss, partitioner, endpointTokens, new ArrayList<Token>(), hosts, new ArrayList<UUID>(), 2); InetAddress toRemove = hosts.get(1); SystemKeyspace.updatePeerInfo(toRemove, "data_center", "dc42"); SystemKeyspace.updatePeerInfo(toRemove, "rack", "rack42"); assertEquals("rack42", SystemKeyspace.loadDcRackInfo().get(toRemove).get("rack")); // mark the node as removed Gossiper.instance.injectApplicationState( toRemove, ApplicationState.STATUS, valueFactory.left( Collections.singleton(endpointTokens.get(1)), Gossiper.computeExpireTime())); assertTrue( Gossiper.instance.isDeadState(Gossiper.instance.getEndpointStateForEndpoint(hosts.get(1)))); // state changes made after the endpoint has left should be ignored ss.onChange(hosts.get(1), ApplicationState.RACK, valueFactory.rack("rack9999")); assertEquals("rack42", SystemKeyspace.loadDcRackInfo().get(toRemove).get("rack")); }
@Test public void testJodaTime() { sql2o .createQuery("create table testjoda(id int primary key, joda1 datetime, joda2 datetime)") .executeUpdate(); sql2o .createQuery("insert into testjoda(id, joda1, joda2) values(:id, :joda1, :joda2)") .addParameter("id", 1) .addParameter("joda1", new DateTime()) .addParameter("joda2", new DateTime().plusDays(-1)) .addToBatch() .addParameter("id", 2) .addParameter("joda1", new DateTime().plusYears(1)) .addParameter("joda2", new DateTime().plusDays(-2)) .addToBatch() .addParameter("id", 3) .addParameter("joda1", new DateTime().plusYears(2)) .addParameter("joda2", new DateTime().plusDays(-3)) .addToBatch() .executeBatch(); List<JodaEntity> list = sql2o.createQuery("select * from testjoda").executeAndFetch(JodaEntity.class); assertTrue(list.size() == 3); assertTrue(list.get(0).getJoda2().isBeforeNow()); }
@Test public void testUtilDate() { sql2o .createQuery("create table testutildate(id int primary key, d1 datetime, d2 timestamp)") .executeUpdate(); sql2o .createQuery("insert into testutildate(id, d1, d2) values(:id, :d1, :d2)") .addParameter("id", 1) .addParameter("d1", new Date()) .addParameter("d2", new Date()) .addToBatch() .addParameter("id", 2) .addParameter("d1", new Date()) .addParameter("d2", new Date()) .addToBatch() .addParameter("id", 3) .addParameter("d1", new Date()) .addParameter("d2", new Date()) .addToBatch() .executeBatch(); List<UtilDateEntity> list = sql2o.createQuery("select * from testutildate").executeAndFetch(UtilDateEntity.class); assertTrue(list.size() == 3); }
@Test public void testCaseInsensitive() { sql2o .createQuery( "create table testCI(id2 int primary key, value2 varchar(20), sometext varchar(20), valwithgetter varchar(20))") .executeUpdate(); Query query = sql2o.createQuery( "insert into testCI(id2, value2, sometext, valwithgetter) values(:id, :value, :someText, :valwithgetter)"); for (int i = 0; i < 20; i++) { query .addParameter("id", i) .addParameter("value", "some text " + i) .addParameter("someText", "whatever " + i) .addParameter("valwithgetter", "spaz" + i) .addToBatch(); } query.executeBatch(); List<CIEntity> ciEntities = sql2o .createQuery("select * from testCI") .setCaseSensitive(false) .executeAndFetch(CIEntity.class); assertTrue(ciEntities.size() == 20); // test defaultCaseSensitive; sql2o.setDefaultCaseSensitive(false); List<CIEntity> ciEntities2 = sql2o.createQuery("select * from testCI").executeAndFetch(CIEntity.class); assertTrue(ciEntities2.size() == 20); }
private List<String> executeDDL( String ddlFileName, @Nullable String dataFileName, boolean isLocalTable, @Nullable String[] args) throws Exception { Path ddlFilePath = new Path(currentQueryPath, ddlFileName); FileSystem fs = ddlFilePath.getFileSystem(conf); assertTrue(ddlFilePath + " existence check", fs.exists(ddlFilePath)); String template = FileUtil.readTextFile(new File(ddlFilePath.toUri())); String dataFilePath = null; if (dataFileName != null) { dataFilePath = getDataSetFile(dataFileName).toString(); } String compiled = compileTemplate(template, dataFilePath, args); List<ParsedResult> parsedResults = SimpleParser.parseScript(compiled); List<String> createdTableNames = new ArrayList<String>(); for (ParsedResult parsedResult : parsedResults) { // parse a statement Expr expr = sqlParser.parse(parsedResult.getStatement()); assertNotNull(ddlFilePath + " cannot be parsed", expr); if (expr.getType() == OpType.CreateTable) { CreateTable createTable = (CreateTable) expr; String tableName = createTable.getTableName(); assertTrue("Table creation is failed.", client.updateQuery(parsedResult.getStatement())); TableDesc createdTable = client.getTableDesc(tableName); String createdTableName = createdTable.getName(); assertTrue( "table '" + createdTableName + "' creation check", client.existTable(createdTableName)); if (isLocalTable) { createdTableGlobalSet.add(createdTableName); createdTableNames.add(tableName); } } else if (expr.getType() == OpType.DropTable) { DropTable dropTable = (DropTable) expr; String tableName = dropTable.getTableName(); assertTrue( "table '" + tableName + "' existence check", client.existTable(CatalogUtil.buildFQName(currentDatabase, tableName))); assertTrue("table drop is failed.", client.updateQuery(parsedResult.getStatement())); assertFalse( "table '" + tableName + "' dropped check", client.existTable(CatalogUtil.buildFQName(currentDatabase, tableName))); if (isLocalTable) { createdTableGlobalSet.remove(tableName); } } else { assertTrue(ddlFilePath + " is not a Create or Drop Table statement", false); } } return createdTableNames; }
static ServerMessage doTxRx(ClientMessage... cms) { List<ClientMessage> cmArray = new ArrayList<ClientMessage>(); for (ClientMessage cm : cms) { cmArray.add(cm); } ServerMessage result = doTxRx(cmArray); return result; }
@Test public void testExists() throws Exception { List<Integer> list = List.list(1, 2, 3, 4, 5, 6, 7, 8); assertTrue(list.exists(x -> x < 4)); assertFalse(list.exists(x -> x < 1)); assertTrue(list.exists(x -> x > 0)); assertTrue(list.exists(x -> x > 4)); }
@Test public void testExistsEmpty() throws Exception { List<Integer> list = List.list(); assertFalse(list.exists(x -> x < 4)); assertFalse(list.exists(x -> x < 1)); assertFalse(list.exists(x -> x > 0)); assertFalse(list.exists(x -> x > 4)); }