Refine search
private static boolean sameElements(Collection<BlockNode> c1, Collection<BlockNode> c2) { return c1.size() == c2.size() && c1.containsAll(c2); }
private static boolean isCollectionEqual(Collection<String> c1, Collection<String> c2) { if (c1 == null) { return c2 == null; } if (c2 == null) { return false; } return c1.size() == c2.size() && c1.containsAll(c2); }
return true; if (set1 == null || set2 == null || set1.size() != set2.size()) { return false; return set1.containsAll(set2);
/** Create a new {@link ConjunctionScorer}, note that {@code scorers} must be a subset of {@code required}. */ ConjunctionScorer(Weight weight, Collection<Scorer> required, Collection<Scorer> scorers) { super(weight); assert required.containsAll(scorers); this.disi = ConjunctionDISI.intersectScorers(required); this.scorers = scorers.toArray(new Scorer[scorers.size()]); this.required = required; }
return true; if (set1 == null || set2 == null || set1.size() != set2.size()) { return false; return set1.containsAll(set2);
return true; if (set1 == null || set2 == null || set1.size() != set2.size()) { return false; return set1.containsAll(set2);
@MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE}) public void testReplaceValuesWithDuplicates() { int size = multimap().size(); List<V> oldValues = new ArrayList<>(multimap().get(k0())); List<V> values = Arrays.asList(v0(), v3(), v0()); assertEquals(oldValues, new ArrayList<V>(multimap().replaceValues(k0(), values))); assertEquals(size - oldValues.size() + multimap().get(k0()).size(), multimap().size()); assertTrue(multimap().get(k0()).containsAll(values)); }
/** Helper assertion comparing two maps */ private void assertMapsEqual(Map<?, ?> expected, Map<?, ?> map) { assertEquals(expected, map); assertEquals(expected.hashCode(), map.hashCode()); assertEquals(expected.entrySet(), map.entrySet()); // Assert that expectedValues > mapValues and that // mapValues > expectedValues; i.e. that expectedValues == mapValues. Collection<?> expectedValues = expected.values(); Collection<?> mapValues = map.values(); assertEquals(expectedValues.size(), mapValues.size()); assertTrue(expectedValues.containsAll(mapValues)); assertTrue(mapValues.containsAll(expectedValues)); }
/** Helper assertion comparing two maps */ private void assertMapsEqual(Map<?, ?> expected, Map<?, ?> map) { assertEquals(expected, map); assertEquals(expected.hashCode(), map.hashCode()); assertEquals(expected.entrySet(), map.entrySet()); // Assert that expectedValues > mapValues and that // mapValues > expectedValues; i.e. that expectedValues == mapValues. Collection<?> expectedValues = expected.values(); Collection<?> mapValues = map.values(); assertEquals(expectedValues.size(), mapValues.size()); assertTrue(expectedValues.containsAll(mapValues)); assertTrue(mapValues.containsAll(expectedValues)); }
assertTrue(map.containsValue(value)); assertTrue(valueCollection.contains(value)); assertTrue(valueCollection.containsAll(Collections.singleton(value))); assertTrue(entrySet.contains(mapEntry(key, value))); assertTrue(allowsNullKeys || (key != null)); assertEquals(map.size(), valueCollection.size()); assertEquals(valueCollection.size() == 0, valueCollection.isEmpty()); assertEquals(!valueCollection.isEmpty(), valueCollection.iterator().hasNext()); for (V value : valueCollection) {
/** * */ private Collection<IgniteInternalCache> manageStatisticsCaches(Collection<String> caches) throws IgniteCheckedException { assert caches != null; Collection<IgniteInternalCache> res = new ArrayList<>(caches.size()); if (!cacheNames().containsAll(caches)) throw new IgniteCheckedException("One or more cache descriptors not found [caches=" + caches + ']'); for (String cacheName : caches) { IgniteInternalCache cache = cache(cacheName); if (cache == null) throw new IgniteCheckedException("Cache not found [cacheName=" + cacheName + ']'); res.add(cache); } return res; }
int size = groupsD.size(); if (!groupsD.containsAll(cuboid.getColumns().subList(0, size))) { storageLimitLevel = StorageLimitLevel.LIMIT_ON_RETURN_SIZE; logger.debug( if (!groups.containsAll(derivedPostAggregation)) { storageLimitLevel = StorageLimitLevel.NO_LIMIT; logger.debug("storageLimitLevel set to NO_LIMIT because derived column require post aggregation: {0}",
private void verifyCollectionsEqual(Collection<HStoreFile> sfs, Collection<HStoreFile> scr) { // Dumb. assertEquals(sfs.size(), scr.size()); assertTrue(scr.containsAll(sfs)); }
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); }
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); }
private static void compareDatabaseVersionMultiChunks(Collection<MultiChunkEntry> writtenMultiChunks, Collection<MultiChunkEntry> readMultiChunks) { assertEquals("Different amount of MultiChunk objects.", writtenMultiChunks.size(), readMultiChunks.size()); assertTrue("MultiChunk objects in written/read database version different.", writtenMultiChunks.containsAll(readMultiChunks)); //assertCollectionEquals("MultiChunk objects in written/read database version different.", writtenMultiChunks, readMultiChunks); }
private <T, S extends T> void assertSameCollections(Collection<S> expected, Collection<T> actual) { assertEquals(expected.size(), actual.size()); assertTrue(expected.containsAll(actual)); }
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()); }
private void assertExpired(List<TtlBucket> expiredBuckets, int bucketIndex, Inode... inodes) { TtlBucket bucket = expiredBuckets.get(bucketIndex); Assert.assertEquals(inodes.length, bucket.getInodes().size()); Assert.assertTrue(bucket.getInodes().containsAll(Lists.newArrayList(inodes))); }
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)); }