How to use

size

method

in

com.google.common.collect.Multiset

@Override
public int size() {
 return IntMath.saturatedAdd(multiset1.size(), multiset2.size());
}

public void testCreate() {
 Multiset<String> multiset = HashMultiset.create();
 multiset.add("foo", 2);
 multiset.add("bar");
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
}

public void testCreateWithSize() {
 Multiset<String> multiset = HashMultiset.create(50);
 multiset.add("foo", 2);
 multiset.add("bar");
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
}

public void testCreateFromIterable() {
 Multiset<String> multiset = HashMultiset.create(Arrays.asList("foo", "bar", "foo"));
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
}

static <E> Spliterator<E> spliteratorImpl(Multiset<E> multiset) {
 Spliterator<Entry<E>> entrySpliterator = multiset.entrySet().spliterator();
 return CollectSpliterators.flatMap(
   entrySpliterator,
   entry -> Collections.nCopies(entry.getCount(), entry.getElement()).spliterator(),
   Spliterator.SIZED
     | (entrySpliterator.characteristics()
       & (Spliterator.ORDERED | Spliterator.NONNULL | Spliterator.IMMUTABLE)),
   multiset.size());
}

 @CollectionSize.Require(SEVERAL)
 public void testSizeMultipleValues() {
  resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k0(), v2()));

  assertEquals(3, multimap().size());
  assertEquals(3, multimap().entries().size());
  assertEquals(3, multimap().keys().size());

  assertEquals(1, multimap().keySet().size());
  assertEquals(1, multimap().asMap().size());
 }
}

@GwtIncompatible // SerializableTester
public void testSerializationContainingSelf() {
 Multiset<Multiset<?>> multiset = HashMultiset.create();
 multiset.add(multiset, 2);
 Multiset<Multiset<?>> copy = SerializableTester.reserialize(multiset);
 assertEquals(2, copy.size());
 assertSame(copy, copy.iterator().next());
}

@CollectionFeature.Require(SUPPORTS_ADD)
public void testAddTooMany() {
 getMultiset().add(e3(), Integer.MAX_VALUE);
 try {
  getMultiset().add(e3());
  fail();
 } catch (IllegalArgumentException expected) {
 }
 assertEquals(Integer.MAX_VALUE, getMultiset().count(e3()));
 assertEquals(Integer.MAX_VALUE, getMultiset().size());
}

@GwtIncompatible // SerializableTester
public void testSerializationIndirectSelfReference() {
 Multiset<MultisetHolder> multiset = HashMultiset.create();
 MultisetHolder holder = new MultisetHolder(multiset);
 multiset.add(holder, 2);
 Multiset<MultisetHolder> copy = SerializableTester.reserialize(multiset);
 assertEquals(2, copy.size());
 assertSame(copy, copy.iterator().next().member);
}

public void testCreateWithComparator() {
 Multiset<String> multiset = TreeMultiset.create(Collections.reverseOrder());
 multiset.add("foo", 2);
 multiset.add("bar");
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
 assertEquals("[foo x 2, bar]", multiset.toString());
}

public void testCreate() {
 Multiset<String> multiset = LinkedHashMultiset.create();
 multiset.add("foo", 2);
 multiset.add("bar");
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
 assertEquals("[foo x 2, bar]", multiset.toString());
}

public void testCreateWithSize() {
 Multiset<String> multiset = LinkedHashMultiset.create(50);
 multiset.add("foo", 2);
 multiset.add("bar");
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
 assertEquals("[foo x 2, bar]", multiset.toString());
}

public void testCreateFromIterable() {
 Multiset<String> multiset = LinkedHashMultiset.create(Arrays.asList("foo", "bar", "foo"));
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
 assertEquals("[foo x 2, bar]", multiset.toString());
}

public void testCreateFromIterable() {
 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("foo", "bar", "foo"));
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
 assertEquals("[bar, foo x 2]", multiset.toString());
}

private void assertSetCount(E element, int count) {
 setCountCheckReturnValue(element, count);
 assertEquals(
   "multiset.count() should return the value passed to setCount()",
   count,
   getMultiset().count(element));
 int size = 0;
 for (Multiset.Entry<E> entry : getMultiset().entrySet()) {
  size += entry.getCount();
 }
 assertEquals(
   "multiset.size() should be the sum of the counts of all entries",
   size,
   getMultiset().size());
}

@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());
}

public void testEnqueueAndDispatch_multipleListeners() {
 Object listener1 = new Object();
 ListenerCallQueue<Object> queue = new ListenerCallQueue<>();
 queue.addListener(listener1, directExecutor());
 Multiset<Object> counters = ConcurrentHashMultiset.create();
 queue.enqueue(incrementingEvent(counters, listener1, 1));
 queue.enqueue(incrementingEvent(counters, listener1, 2));
 Object listener2 = new Object();
 queue.addListener(listener2, directExecutor());
 queue.enqueue(incrementingEvent(counters, multiset(listener1, 3, listener2, 1)));
 queue.enqueue(incrementingEvent(counters, multiset(listener1, 4, listener2, 2)));
 assertEquals(0, counters.size());
 queue.dispatch();
 assertEquals(multiset(listener1, 4, listener2, 2), counters);
}

public void testEnqueueAndDispatch() {
 Object listener = new Object();
 ListenerCallQueue<Object> queue = new ListenerCallQueue<>();
 queue.addListener(listener, directExecutor());
 Multiset<Object> counters = ConcurrentHashMultiset.create();
 queue.enqueue(incrementingEvent(counters, listener, 1));
 queue.enqueue(incrementingEvent(counters, listener, 2));
 queue.enqueue(incrementingEvent(counters, listener, 3));
 queue.enqueue(incrementingEvent(counters, listener, 4));
 assertEquals(0, counters.size());
 queue.dispatch();
 assertEquals(multiset(listener, 4), counters);
}

@CollectionSize.Require(SEVERAL)
public void testKeys() {
 resetContainer(
   Helpers.mapEntry(k0(), v0()), Helpers.mapEntry(k0(), v1()), Helpers.mapEntry(k1(), v0()));
 Multiset<K> keys = multimap().keys();
 assertEquals(2, keys.count(k0()));
 assertEquals(1, keys.count(k1()));
 assertEquals(3, keys.size());
 assertContainsAllOf(keys, k0(), k1());
 assertContainsAllOf(
   keys.entrySet(), Multisets.immutableEntry(k0(), 2), Multisets.immutableEntry(k1(), 1));
}