@Override public int remove(Object o, int n) { synchronized (mutex) { return delegate().remove(o, n); } }
@Override public N removeInEdge(E edge, boolean isSelfLoop) { N node = super.removeInEdge(edge, isSelfLoop); Multiset<N> predecessors = getReference(predecessorsReference); if (predecessors != null) { checkState(predecessors.remove(node)); } return node; }
@Override public N removeOutEdge(E edge) { N node = super.removeOutEdge(edge); Multiset<N> adjacentNodes = getReference(adjacentNodesReference); if (adjacentNodes != null) { checkState(adjacentNodes.remove(node)); } return node; }
@Override public N removeOutEdge(E edge) { N node = super.removeOutEdge(edge); Multiset<N> successors = getReference(successorsReference); if (successors != null) { checkState(successors.remove(node)); } return node; }
/** An implementation of {@link Multiset#setCount(Object, int)}. */ static <E> int setCountImpl(Multiset<E> self, E element, int count) { checkNonnegative(count, "count"); int oldCount = self.count(element); int delta = count - oldCount; if (delta > 0) { self.add(element, delta); } else if (delta < 0) { self.remove(element, -delta); } return oldCount; }
@Override public void remove() { checkRemove(canRemove); if (totalCount == 1) { entryIterator.remove(); } else { multiset.remove(currentEntry.getElement()); } totalCount--; canRemove = false; } }
@CanIgnoreReturnValue @Override public int remove(Object element, int occurrences) { return delegate().remove(element, occurrences); }
@CollectionFeature.Require(value = SUPPORTS_REMOVE, absent = ALLOWS_NULL_QUERIES) public void testRemove_nullForbidden() { try { getMultiset().remove(null, 2); fail("Expected NullPointerException"); } catch (NullPointerException expected) { } }
@MapFeature.Require(SUPPORTS_REMOVE) public void testKeysRemove() { int original = multimap().keys().remove(k0(), 1); assertEquals(Math.max(original - 1, 0), multimap().get(k0()).size()); }
@CollectionFeature.Require(absent = SUPPORTS_REMOVE) public void testRemoveUnsupported() { try { getMultiset().remove(e0(), 2); fail("Expected UnsupportedOperationException"); } catch (UnsupportedOperationException expected) { } }
@CollectionFeature.Require(SUPPORTS_REMOVE) public void testRemove_occurrences_negative() { try { getMultiset().remove(e0(), -1); fail("multiset.remove(E, -1) didn't throw an exception"); } catch (IllegalArgumentException required) { } }
@CollectionSize.Require(absent = ZERO) public void testEquals_differentElements() { Multiset<E> other = HashMultiset.create(getSampleElements()); other.remove(e0()); other.add(e3()); assertFalse("multiset equals a multiset with different elements", getMultiset().equals(other)); }
@CollectionFeature.Require(absent = SUPPORTS_REMOVE) public void testRemove_occurrences_unsupported_absent() { // notice: we don't care whether it succeeds, or fails with UOE try { assertEquals( "multiset.remove(absent, 2) didn't return 0 or throw an exception", 0, getMultiset().remove(e3(), 2)); } catch (UnsupportedOperationException ok) { } }
@Override public int remove(@Nullable Object element, int occurrences) { checkNonnegative(occurrences, "occurrences"); if (occurrences == 0) { return count(element); } else { return contains(element) ? unfiltered.remove(element, occurrences) : 0; } } }
@CollectionFeature.Require(SUPPORTS_REMOVE) public void testRemoveNegative() { try { getMultiset().remove(e0(), -1); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } expectUnchanged(); }
public void testLinkedKeys() { Multimap<String, Integer> map = create(); map.put("bar", 1); map.put("foo", 2); map.put("bar", 3); map.put("bar", 4); assertEquals("[bar=1, foo=2, bar=3, bar=4]", map.entries().toString()); assertThat(map.keys()).containsExactly("bar", "foo", "bar", "bar").inOrder(); map.keys().remove("bar"); // bar is no longer the first key! assertEquals("{foo=[2], bar=[3, 4]}", map.toString()); }
@CollectionFeature.Require(SUPPORTS_REMOVE) public void testRemove_occurrences_0() { int oldCount = getMultiset().count(e0()); assertEquals( "multiset.remove(E, 0) didn't return the old count", oldCount, getMultiset().remove(e0(), 0)); }
public void testRemoveUnsupported() { Multiset<String> multiset = new NoRemoveMultiset<>(); multiset.add("a"); try { multiset.remove("a"); fail(); } catch (UnsupportedOperationException expected) { } assertTrue(multiset.contains("a")); }
@CollectionFeature.Require(SUPPORTS_REMOVE) public void testRemoveZeroNoOp() { int originalCount = getMultiset().count(e0()); assertEquals("old count", originalCount, getMultiset().remove(e0(), 0)); expectUnchanged(); }
@CollectionSize.Require(absent = ZERO) @CollectionFeature.Require(SUPPORTS_REMOVE) public void testRemove_occurrences_present() { assertEquals( "multiset.remove(present, 2) didn't return the old count", 1, getMultiset().remove(e0(), 2)); assertFalse( "multiset contains present after multiset.remove(present, 2)", getMultiset().contains(e0())); assertEquals(0, getMultiset().count(e0())); }