/** An implementation of {@link Multiset#removeAll}. */ static boolean removeAllImpl(Multiset<?> self, Collection<?> elementsToRemove) { Collection<?> collection = (elementsToRemove instanceof Multiset) ? ((Multiset<?>) elementsToRemove).elementSet() : elementsToRemove; return self.elementSet().removeAll(collection); }
/** An implementation of {@link Multiset#retainAll}. */ static boolean retainAllImpl(Multiset<?> self, Collection<?> elementsToRetain) { checkNotNull(elementsToRetain); Collection<?> collection = (elementsToRetain instanceof Multiset) ? ((Multiset<?>) elementsToRetain).elementSet() : elementsToRetain; return self.elementSet().retainAll(collection); }
/** * Returns the expected number of distinct elements given the specified elements. The number of * distinct elements is only computed if {@code elements} is an instance of {@code Multiset}; * otherwise the default value of 11 is returned. */ static int inferDistinctElements(Iterable<?> elements) { if (elements instanceof Multiset) { return ((Multiset<?>) elements).elementSet().size(); } return 11; // initial capacity will be rounded up to 16 }
@Override public Set<E> create(Object... elements) { Object[] duplicated = new Object[elements.length * 2]; for (int i = 0; i < elements.length; i++) { duplicated[i] = elements[i]; duplicated[i + elements.length] = elements[i]; } return ((Multiset<E>) gen.create(duplicated)).elementSet(); }
@Override public Set<E> elementSet() { synchronized (mutex) { if (elementSet == null) { elementSet = typePreservingSet(delegate().elementSet(), mutex); } return elementSet; } }
@Override public Set<E> elementSet() { return delegate().elementSet(); }
@Override public Set<N> successors() { return Collections.unmodifiableSet(successorsMultiset().elementSet()); }
@CollectionFeature.Require(SUPPORTS_REMOVE) public void testRemove_occurrences_absent() { int distinct = getMultiset().elementSet().size(); assertEquals("multiset.remove(absent, 0) didn't return 0", 0, getMultiset().remove(e3(), 2)); assertEquals(distinct, getMultiset().elementSet().size()); }
@CollectionFeature.Require(SUPPORTS_REMOVE) public void testElementSetClear() { getMultiset().elementSet().clear(); assertEmpty(getMultiset()); }
@CollectionSize.Require(absent = ZERO) public void testElementSet_contains() { assertTrue( "multiset.elementSet().contains(present) returned false", getMultiset().elementSet().contains(e0())); }
@CollectionFeature.Require(SUPPORTS_REMOVE) public void testElementSetRemoveAbsent() { Set<E> elementSet = getMultiset().elementSet(); assertFalse(elementSet.remove(e3())); expectUnchanged(); }
@CollectionFeature.Require(SUPPORTS_ADD) public void testElementSetReflectsAddAbsent() { Set<E> elementSet = getMultiset().elementSet(); assertFalse(elementSet.contains(e3())); getMultiset().add(e3(), 4); assertTrue(elementSet.contains(e3())); }
@CollectionFeature.Require(SERIALIZABLE_INCLUDING_VIEWS) public void testElementSetSerialization() { Set<E> expected = getMultiset().elementSet(); assertEquals(expected, SerializableTester.reserialize(expected)); } }
@CollectionSize.Require(absent = ZERO) @CollectionFeature.Require(SUPPORTS_REMOVE) public void testElementSetReflectsRemove() { Set<E> elementSet = getMultiset().elementSet(); assertTrue(elementSet.contains(e0())); getMultiset().removeAll(Collections.singleton(e0())); assertFalse(elementSet.contains(e0())); }
private static long worstCaseQueryOperations(Multiset<?> multiset, CallsCounter counter) { long worstCalls = 0; for (Object k : multiset.elementSet()) { counter.zero(); int unused = multiset.count(k); worstCalls = Math.max(worstCalls, counter.total()); } return worstCalls; } }
public void testSerialization_elementSet() { Multiset<String> c = ImmutableSortedMultiset.of("a", "b", "a"); Collection<String> copy = SerializableTester.reserializeAndAssert(c.elementSet()); assertThat(copy).containsExactly("a", "b").inOrder(); }
@CollectionSize.Require(SEVERAL) @CollectionFeature.Require(SUPPORTS_REMOVE) @MultisetFeature.Require(ENTRIES_ARE_VIEWS) public void testEntryReflectsElementSetClear() { initThreeCopies(); assertEquals(3, getMultiset().count(e0())); Multiset.Entry<E> entry = Iterables.getOnlyElement(getMultiset().entrySet()); assertEquals(3, entry.getCount()); getMultiset().elementSet().clear(); assertEquals(0, entry.getCount()); }
@GwtIncompatible // SerializableTester public void testSerialization_elementSet() { Multiset<String> c = ImmutableMultiset.of("a", "b", "a"); Collection<String> copy = LenientSerializableTester.reserializeAndAssertLenient(c.elementSet()); assertThat(copy).containsExactly("a", "b").inOrder(); }
@CollectionSize.Require(SEVERAL) @CollectionFeature.Require(SUPPORTS_REMOVE) public void testElementSetRemoveDuplicatePropagatesToMultiset() { initThreeCopies(); int size = getNumElements(); int expectedSize = size - getMultiset().count(e0()); Set<E> elementSet = getMultiset().elementSet(); assertTrue(elementSet.remove(e0())); assertEmpty(getMultiset()); assertEquals(expectedSize, getMultiset().size()); }
@CollectionSize.Require(absent = ZERO) @CollectionFeature.Require(SUPPORTS_REMOVE) public void testElementSetRemovePropagatesToMultiset() { Set<E> elementSet = getMultiset().elementSet(); int size = getNumElements(); int expectedSize = size - getMultiset().count(e0()); assertTrue(elementSet.remove(e0())); assertFalse(getMultiset().contains(e0())); assertEquals(expectedSize, getMultiset().size()); }