@Test public void checkGetElements() { assumeTrue(dataStructure instanceof INodeListDatastructureReadable); IReadable tempDS = (IReadable) dataStructure; int size = 20; IElement singleDummy; ArrayList<IElement> dummies = new ArrayList<>(); for (int i = 0; i < size; i++) { singleDummy = mock(this.elementClass); /* * Nodes are stored with an index, so set it please! */ if (singleDummy instanceof Node) { when(((Node) singleDummy).getIndex()).thenReturn(i); } if (singleDummy instanceof Edge) { when(((Edge) singleDummy).getHashString()).thenReturn("" + i); } assertTrue(tempDS.add(singleDummy)); dummies.add(singleDummy); } Collection<IElement> elements = tempDS.getElements(); /* * Check for the proper size and content */ assertEquals(dummies.size(), elements.size()); assertTrue(dummies.containsAll(elements)); assertTrue(elements.containsAll(dummies)); }
public void testContainsAll_sameType() { Collection<String> c = of("a", "b", "c"); assertFalse(c.containsAll(of("a", "b", "c", "d"))); assertFalse(c.containsAll(of("a", "d"))); assertTrue(c.containsAll(of("a", "c"))); assertTrue(c.containsAll(of("a", "b", "c"))); }
public void test() { Graph g1 = new PrimaryGraph(); Node[] n1 = g1.newNodes(2); g1.newEdge(n1[0], n1[1]); Graph g2 = new PrimaryGraph(); Node[] n2 = g2.newNodes(2); g2.newEdge(n2[0], n2[1]); SecondaryGraph sg = new SecondaryGraph(); sg.adoptGraph(g1); sg.adoptGraph(g2); Clusterer cc = Clusterers.connectedComponents(sg); Collection<Object> components = cc.getClusters(); assertEquals(2, components.size()); Iterator<Object> iterator = components.iterator(); Object c1 = iterator.next(); Object c2 = iterator.next(); assertTrue(c1 != c2); assertTrue(components.contains(c1)); assertTrue(components.contains(c2)); Collection<Node> comp1 = cc.getCluster(c1); assertTrue(comp1.containsAll(Arrays.asList(n1))); Collection<Node> comp2 = cc.getCluster(c2); assertTrue(comp2.containsAll(Arrays.asList(n2))); assertTrue(cc.getCluster(c1).contains(n1[0])); assertTrue(cc.getCluster(c2).contains(n2[0])); }
@Override public boolean containsAll(Collection<?> arg0) { if (containsCounter.incrementAndGet() >= maxContains && !copyDone.get()) { try { writeLock.lock(); // many calls to contains, inefficient if the delegate // is not a set // copyDone is doublechecked, but here it's protected by // the write // lock as in all other instances in which its value is // changed if (!(delegate instanceof Set)) { if (!copyDone.getAndSet(true)) { delegate = new SyncSet<T>(delegate); } } // skip the second portion of the method: no need to // reacquire // the lock, it's already a write lock return delegate.containsAll(arg0); } finally { writeLock.unlock(); } } try { readLock.lock(); return delegate.containsAll(arg0); } finally { readLock.unlock(); } }
public void testToCollection() { setUpTest(); one.add("1"); two.add("2"); c.addComposited(one, two); Collection foo = c.toCollection(); assertTrue(foo.containsAll(c)); assertEquals(c.size(), foo.size()); one.add("3"); assertTrue(!foo.containsAll(c)); }
/** * Additional assert method for testing that will test that two Collections have equal contents * The Collections must be of equal size, and each object from one Collection must equal an object * in the other Collection Order is not considered. * * @param expected * @param actual */ @SuppressWarnings("unchecked") public static void assertCollectionContentsEquals(Collection expected, Collection actual) throws AssertionError { try { if (!expected.containsAll(actual) || !actual.containsAll(expected)) { throw new AssertionError("Expected " + expected + " but found " + actual); } } catch (Exception e) { throw new AssertionError(e); } }
private void testGetGrantedAuthorities( MapBasedAttributes2GrantedAuthoritiesMapper mapper, String[] roles, String[] expectedGas) { List<GrantedAuthority> result = mapper.getGrantedAuthorities(Arrays.asList(roles)); Collection resultColl = new ArrayList(result.size()); for (GrantedAuthority auth : result) { resultColl.add(auth.getAuthority()); } Collection expectedColl = Arrays.asList(expectedGas); assertTrue( "Role collections should match; result: " + resultColl + ", expected: " + expectedColl, expectedColl.containsAll(resultColl) && resultColl.containsAll(expectedColl)); }
private void testGetGrantedAuthorities( SimpleAttributes2GrantedAuthoritiesMapper mapper, String[] roles, String[] expectedGas) { List<GrantedAuthority> result = mapper.getGrantedAuthorities(Arrays.asList(roles)); Collection<String> resultColl = new ArrayList<String>(result.size()); for (int i = 0; i < result.size(); i++) { resultColl.add(result.get(i).getAuthority()); } Collection<String> expectedColl = Arrays.asList(expectedGas); assertTrue( "Role collections do not match; result: " + resultColl + ", expected: " + expectedColl, expectedColl.containsAll(resultColl) && resultColl.containsAll(expectedColl)); }
// Again, overriding for generics @Override public int compareTo(M o) { final Map<K, V> thisMap = getValue(); final Map<K, V> otherMap = o.asMap(); final Set<K> thisKeySet = thisMap.keySet(); final Set<K> otherKeySet = otherMap.keySet(); final Collection<V> thisValueSet = thisMap.values(); final Collection<V> otherValueSet = otherMap.values(); return ComparisonChain.start() .compare(thisKeySet.containsAll(otherKeySet), otherKeySet.containsAll(thisKeySet)) .compare(thisValueSet.containsAll(otherValueSet), otherValueSet.containsAll(thisValueSet)) .result(); }
@SmallTest @MediumTest @LargeTest public void testCollectionContainsAll() throws JSONException { JSONArray array = new JSONArray(); array.put(5); array.put(-1); Collection<Integer> collection = GraphObject.Factory.createList(array, Integer.class); assertTrue(collection.containsAll(Arrays.asList(5))); assertTrue(collection.containsAll(Arrays.asList(5, -1))); assertFalse(collection.containsAll(Arrays.asList(5, -1, 2))); }
public static void main(String[] args) { Collection<String> collection = new HashSet<String>(); collection.add("one"); collection.add("two"); Iterator<String> iterator = collection.iterator(); while (iterator.hasNext()) { String s = iterator.next(); System.out.println(s); } System.out.println("======================================"); TreeSet<String> set = new TreeSet<String>(collection); Iterator<String> itor = set.iterator(); while (itor.hasNext()) { System.out.println(itor.next()); } Collection<String> colList = new ArrayList<String>(); colList.add("one"); colList.add("two"); colList.add("three"); if (colList.containsAll(collection)) { System.out.println("true"); } System.out.println("================="); String[] strings = colList.toArray(new String[0]); String[] strings1 = (String[]) colList.toArray(); }
/** Tests the hash code computation. */ @Test public void testHashCode() { final CitationImpl citation = new CitationImpl(); final PropertyAccessor accessor = createPropertyAccessor(citation); int hashCode = accessor.hashCode(citation); assertEquals("Empty metadata.", 0, hashCode); final String ISBN = "Dummy ISBN"; citation.setISBN(ISBN); hashCode = accessor.hashCode(citation); assertEquals("Metadata with a single String value.", ISBN.hashCode(), hashCode); final Set<Object> set = new HashSet<Object>(); assertEquals("By Set.hashCode() contract.", 0, set.hashCode()); assertTrue(set.add(ISBN)); assertEquals("Expected Metadata.hashCode() == Set.hashCode().", set.hashCode(), hashCode); final InternationalString title = new SimpleInternationalString("Dummy title"); citation.setTitle(title); hashCode = accessor.hashCode(citation); assertEquals("Metadata with two values.", ISBN.hashCode() + title.hashCode(), hashCode); assertTrue(set.add(title)); assertEquals("Expected Metadata.hashCode() == Set.hashCode().", set.hashCode(), hashCode); assertEquals("CitationsImpl.hashCode() should delegate.", hashCode, citation.hashCode()); final Collection<Object> values = citation.asMap().values(); assertEquals(hashCode, new HashSet<Object>(values).hashCode()); assertTrue(values.containsAll(set)); assertTrue(set.containsAll(values)); }
@NotNull public static Library updatePackagesLibraryRoots( @NotNull final Project project, @NotNull final DartLibInfo libInfo) { final LibraryTable projectLibraryTable = ProjectLibraryTable.getInstance(project); final Library existingLibrary = projectLibraryTable.getLibraryByName(DartPackagesLibraryType.DART_PACKAGES_LIBRARY_NAME); final Library library = existingLibrary != null ? existingLibrary : ApplicationManager.getApplication() .runWriteAction( new Computable<Library>() { @Override public Library compute() { final LibraryTableBase.ModifiableModel libTableModel = ProjectLibraryTable.getInstance(project).getModifiableModel(); final Library lib = libTableModel.createLibrary( DartPackagesLibraryType.DART_PACKAGES_LIBRARY_NAME, DartPackagesLibraryType.LIBRARY_KIND); libTableModel.commit(); return lib; } }); final String[] existingUrls = library.getUrls(OrderRootType.CLASSES); final Collection<String> libRootUrls = libInfo.getLibRootUrls(); if ((!libInfo.isProjectWithoutPubspec() && isBrokenPackageMap(((LibraryEx) library).getProperties())) || existingUrls.length != libRootUrls.size() || !libRootUrls.containsAll(Arrays.asList(existingUrls))) { ApplicationManager.getApplication() .runWriteAction( new Runnable() { @Override public void run() { final LibraryEx.ModifiableModelEx model = (LibraryEx.ModifiableModelEx) library.getModifiableModel(); for (String url : existingUrls) { model.removeRoot(url, OrderRootType.CLASSES); } for (String url : libRootUrls) { model.addRoot(url, OrderRootType.CLASSES); } final DartPackagesLibraryProperties libraryProperties = new DartPackagesLibraryProperties(); libraryProperties.setPackageNameToDirsMap(libInfo.getPackagesMap()); model.setProperties(libraryProperties); model.commit(); } }); } return library; }
private static void compareDatabaseVersionFileHistories( Collection<PartialFileHistory> writtenFileHistories, Collection<PartialFileHistory> readFileHistories) { assertTrue( "FileHistory objects in written/read database version different.", writtenFileHistories.containsAll(readFileHistories)); }
public static void main(String[] args) { Collection c = new ArrayList(); // 添加元素 c.add("孙悟空"); // 虽然集合里不能放基本类型的值,但Java支持自动装箱 c.add(6); System.out.println("c集合的元素个数为:" + c.size()); // 删除指定元素 c.remove(6); System.out.println("c集合的元素个数为:" + c.size()); // 判断是否包含指定字符串 System.out.println("c集合的是否包含\"孙悟空\"字符串:" + c.contains("孙悟空")); c.add("轻量级Java EE企业应用实战"); System.out.println("c集合的元素:" + c); Collection books = new HashSet(); books.add("轻量级Java EE企业应用实战"); books.add("疯狂Java讲义"); System.out.println("c集合是否完全包含books集合?" + c.containsAll(books)); // 用c集合减去books集合里的元素 c.removeAll(books); System.out.println("c集合的元素:" + c); // 删除c集合里所有元素 c.clear(); System.out.println("c集合的元素:" + c); // books集合里只剩下c集合里也包含的元素 books.retainAll(c); System.out.println("books集合的元素:" + books); }
public boolean retainAll(Collection<?> c) { if (c.containsAll(this)) return false; for (int i = 0; i < backingArray.length; i++) { if (!c.contains(backingArray[i])) remove(i); } return true; }
public void testEnvironmentVariablesNotExist() { final ISymbolMap symbolTable = context.mock(ISymbolMap.class); final CapabilitySymbol capSym = new CapabilitySymbol( EnvironmentTestXML.capabilityId, EnvironmentTestXML.capabilityDesc, EnvironmentTestXML.capabilityClass); context.checking( new Expectations() { { one(symbolTable).put(EnvironmentTestXML.capabilityId, capSym); } }); final byte[] xmlBytes = EnvironmentTestXML.noExistsProfileXML.getBytes(); final ByteArrayInputStream stream = new ByteArrayInputStream(xmlBytes); try { parser.setSymbolTable(symbolTable).parse(stream); } catch (ParserException ex) { if (ex instanceof ProfileParserException) { final Collection<String> missing = ((ProfileParserException) ex).getMissingEnvironment(); assertTrue(missing.size() == EnvironmentTestXML.varNames.length); final Collection<String> expectedMissing = new HashSet<String>(); for (int idx = 0; idx < missing.size(); idx++) { expectedMissing.add(EnvironmentTestXML.varNames[idx]); } assertTrue(expectedMissing.containsAll(missing)); context.assertIsSatisfied(); return; } } assertTrue(false); }
@Test public void testGetRuleNames() { final KieServices ks = KieServices.Factory.get(); final KieFileSystem kfs = ks.newKieFileSystem(); kfs.write( "src/main/resources/test1.drl", "package org.test\n" + "rule A\n" + " when\n" + "then\n" + "end\n" + "rule B\n" + " when\n" + "then\n" + "end\n"); kfs.write( "src/main/resources/test2.drl", "package org.test\n" + "rule C\n" + " when\n" + "then\n" + "end\n"); final KieBuilder kieBuilder = ks.newKieBuilder(kfs); final List<Message> messages = kieBuilder.buildAll().getResults().getMessages(); assertTrue(messages.isEmpty()); final KieModule kieModule = kieBuilder.getKieModule(); final KieModuleMetaData kieModuleMetaData = KieModuleMetaData.Factory.newKieModuleMetaData(kieModule); Collection<String> rules = kieModuleMetaData.getRuleNamesInPackage("org.test"); assertEquals(3, rules.size()); assertTrue(rules.containsAll(asList("A", "B", "C"))); }
public Mapping getParentMapping(Collection<?> collection) { // Barring a better result, this will be the result. // Mapping result = this; // Cache the tree path for each object. // final Collection<List<?>> allTreePaths = new ArrayList<List<?>>(); for (Object object : collection) { allTreePaths.add(domain.getTreePath(object)); } // Iterate over the mappings in the tree. // OuterLoop: for (TreeIterator<Mapping> mappings = treeIterator(); mappings.hasNext(); ) { Mapping mapping = mappings.next(); // Check to make sure that every object in the collection has an ancestor that is contained in // this mapping. // for (Iterator<List<?>> treePaths = allTreePaths.iterator(); treePaths.hasNext(); ) { List<?> treePath = treePaths.next(); Collection<?> mappedObjects = mapping.getMappedObjects(); mappedObjects.retainAll(treePath); // If the intersection is empty, i.e., no ancestor is in the mapping... // if (mappedObjects.isEmpty()) { // If this mapping isn't a parent, it's children definitely won't be either. // mappings.prune(); continue OuterLoop; } } // Make sure the collections aren't identical... // Collection<?> mappedObjects = mapping.getMappedObjects(); if (!collection.containsAll(mappedObjects) || !mappedObjects.containsAll(collection)) { result = mapping; } } return result; }
public static <T> void assertEquals(Collection<T> expected, Collection<T> actual) { Assert.assertEquals( "The two collections do not have the same number of items!", expected.size(), actual.size()); Assert.assertTrue( "The actual collection didn't contain all of the items from the expected!", actual.containsAll(expected)); }
@Test public void valuesCollection_PostSerializedEquality_chainedMap() { MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(2); Collection<Integer> values = map.values(); Collection<Integer> revived = SerializeTestHelper.serializeDeserialize(values); Assert.assertNotNull(revived); Verify.assertSize(values.size(), revived); Assert.assertTrue(revived.containsAll(values)); }
@Test public void resultCanBeExtractedAsHashSet() { assertThat($(integerInput).asHashSet(), instanceOf(HashSet.class)); Collection<String> stringInputAsSet = $(stringInput).asCollection(); assertTrue($(stringInput).asHashSet().containsAll(stringInputAsSet)); assertTrue(stringInputAsSet.containsAll($(stringInput).asHashSet())); }
/** @return {@code True} if all replies are received. */ private boolean allReceived() { Collection<UUID> rmtIds = this.rmtIds; assert rmtIds != null : "Remote Ids can't be null: " + this; synchronized (rcvdIds) { return rcvdIds.containsAll(rmtIds); } }
private static void compareDatabaseVersionChunks( Collection<ChunkEntry> writtenChunks, Collection<ChunkEntry> readChunks) { assertEquals("Different amount of Chunk objects.", writtenChunks.size(), readChunks.size()); assertTrue( "Chunk objects in written/read database version different.", writtenChunks.containsAll(readChunks)); // assertCollectionEquals("Chunk objects in written/read database version different.", // writtenChunks, readChunks); }
public Collection<? extends Mapping> getExactMappings(Collection<?> collection) { Collection<Mapping> result = new ArrayList<Mapping>(); for (Mapping mapping : getAllMappings(collection)) { if (collection.containsAll(mapping.getMappedObjects())) { result.add(mapping); } } return result; }
/** * Asserts that the given {@link MonitoringRequest} is for {@link #CRUD_OPERATIONS} on the current * directory. * * @param monitoringRequest the request to check (required) * @param expectedToWatchSubTree whether we expect the sub-tree to be monitored as well */ private void assertMonitorsCurrentDirectory( final MonitoringRequest monitoringRequest, final boolean expectedToWatchSubTree) { assertEquals(DirectoryMonitoringRequest.class, monitoringRequest.getClass()); assertEquals( expectedToWatchSubTree, ((DirectoryMonitoringRequest) monitoringRequest).isWatchSubtree()); final Collection<FileOperation> notifyOn = monitoringRequest.getNotifyOn(); assertEquals(CRUD_OPERATIONS.length, notifyOn.size()); assertTrue(notifyOn.containsAll(Arrays.asList(CRUD_OPERATIONS))); assertEquals(new File("."), monitoringRequest.getFile()); }
public void testAddAllToCollection() { setUpTest(); one.add("1"); two.add("2"); c.addComposited(one, two); Collection toCollection = new HashSet(); toCollection.addAll(c); assertTrue(toCollection.containsAll(c)); assertEquals(c.size(), toCollection.size()); }
@SuppressWarnings("rawtypes") @Override public boolean equals(Object obj) { if (obj == null) { return false; } if (this == obj) { return true; } if (obj instanceof ConditionalCopySet) { return delegate.containsAll(((ConditionalCopySet) obj).delegate) && ((ConditionalCopySet<?>) obj).delegate.containsAll(delegate); } if (obj instanceof Collection) { return delegate.containsAll((Collection<?>) obj) && ((Collection<?>) obj).containsAll(delegate); } return false; }
/** Asserts that all the expected methods were found in the call results. */ public void assertCalls(Collection expectedMembers, Collection calls) { Collection foundMembers = new ArrayList(); for (Iterator iter = calls.iterator(); iter.hasNext(); ) { MethodWrapper element = (MethodWrapper) iter.next(); foundMembers.add(element.getMember()); } Assert.assertEquals("Wrong number of calls", expectedMembers.size(), calls.size()); Assert.assertTrue("One or more members not found", foundMembers.containsAll(expectedMembers)); }
private static void compareDatabaseVersionFileContents( Collection<FileContent> writtenFileContents, Collection<FileContent> readFileContents) { assertEquals( "Different amount of FileContent objects.", writtenFileContents.size(), readFileContents.size()); assertTrue( "FileContent objects in written/read database version different.", writtenFileContents.containsAll(readFileContents)); // assertCollectionEquals("FileContent objects in written/read database version different.", // writtenFileContents, readFileContents); }