Refine search![Refine arrow](//d16xvuom8mr9m8.cloudfront.net/code/public/images/refine-arrow.226bef887e7b1c430d6d498717d9d561.svg)
@CollectionSize.Require(SEVERAL) public void testDescendingNavigation() { List<Entry<E>> ascending = new ArrayList<>(); Iterators.addAll(ascending, sortedMultiset.entrySet().iterator()); List<Entry<E>> descending = new ArrayList<>(); Iterators.addAll(descending, sortedMultiset.descendingMultiset().entrySet().iterator()); Collections.reverse(descending); assertEquals(ascending, descending); }
@CollectionSize.Require(ONE) public void testSingletonMultisetNearby() { assertNull(sortedMultiset.headMultiset(e0(), OPEN).lastEntry()); assertNull(sortedMultiset.tailMultiset(e0(), OPEN).lastEntry()); assertEquals(a, sortedMultiset.headMultiset(e0(), CLOSED).lastEntry()); assertEquals(a, sortedMultiset.tailMultiset(e0(), CLOSED).firstEntry()); }
@SuppressWarnings("unchecked") SerializedForm(SortedMultiset<E> multiset) { this.comparator = multiset.comparator(); int n = multiset.entrySet().size(); elements = (E[]) new Object[n]; counts = new int[n]; int i = 0; for (Entry<E> entry : multiset.entrySet()) { elements[i] = entry.getElement(); counts[i] = entry.getCount(); i++; } }
@Override public SortedMultiset<E> subMultiset( E fromElement, BoundType fromBoundType, E toElement, BoundType toBoundType) { return forwardMultiset() .subMultiset(toElement, toBoundType, fromElement, fromBoundType) .descendingMultiset(); }
@Override public SortedSet<E> subSet(E fromElement, E toElement) { return multiset().subMultiset(fromElement, CLOSED, toElement, OPEN).elementSet(); }
@Override public SortedSet<E> headSet(E toElement) { return multiset().headMultiset(toElement, OPEN).elementSet(); }
@CollectionSize.Require(SEVERAL) @CollectionFeature.Require(SUPPORTS_REMOVE) public void testClearTailOpen() { List<Entry<E>> expected = copyToList(sortedMultiset.headMultiset(b.getElement(), CLOSED).entrySet()); sortedMultiset.tailMultiset(b.getElement(), OPEN).clear(); assertEquals(expected, copyToList(sortedMultiset.entrySet())); }
@CollectionSize.Require(SEVERAL) @CollectionFeature.Require(SUPPORTS_REMOVE) public void testClearTailClosedEntrySet() { List<Entry<E>> expected = copyToList(sortedMultiset.headMultiset(b.getElement(), OPEN).entrySet()); sortedMultiset.tailMultiset(b.getElement(), CLOSED).entrySet().clear(); assertEquals(expected, copyToList(sortedMultiset.entrySet())); }
/** * A sensible definition of {@link #lastEntry()} in terms of {@code * descendingMultiset().entrySet().iterator()}. * * <p>If you override {@link #descendingMultiset} or {@link #entrySet()}, you may wish to override * {@link #firstEntry()} to forward to this implementation. */ protected Entry<E> standardLastEntry() { Iterator<Entry<E>> entryIterator = descendingMultiset().entrySet().iterator(); if (!entryIterator.hasNext()) { return null; } Entry<E> entry = entryIterator.next(); return Multisets.immutableEntry(entry.getElement(), entry.getCount()); }
@Override public E lower(E e) { return getElementOrNull(multiset().headMultiset(e, OPEN).lastEntry()); }
@Override public void setUp() throws Exception { super.setUp(); sortedMultiset = cast(getMultiset()); entries = copyToList( getSubjectGenerator() .getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements())); Collections.sort(entries, sortedMultiset.comparator()); // some tests assume SEVERAL == 3 if (entries.size() >= 1) { a = Multisets.immutableEntry(entries.get(0), sortedMultiset.count(entries.get(0))); if (entries.size() >= 3) { b = Multisets.immutableEntry(entries.get(1), sortedMultiset.count(entries.get(1))); c = Multisets.immutableEntry(entries.get(2), sortedMultiset.count(entries.get(2))); } } }
@Override public SortedMultiset<E> tailMultiset(E fromElement, BoundType boundType) { return forwardMultiset().headMultiset(fromElement, boundType).descendingMultiset(); }
@Override public SortedMultiset<E> headMultiset(E toElement, BoundType boundType) { return forwardMultiset().tailMultiset(toElement, boundType).descendingMultiset(); }
@CollectionSize.Require(SEVERAL) public void testHigher() { resetWithHole(); assertEquals(c, sortedMultiset.tailMultiset(a.getElement(), OPEN).firstEntry()); assertEquals(c, sortedMultiset.tailMultiset(b.getElement(), OPEN).firstEntry()); assertEquals(null, sortedMultiset.tailMultiset(c.getElement(), OPEN).firstEntry()); }
@Override public Entry<E> pollLastEntry() { return forwardMultiset().pollFirstEntry(); }
@Override public Entry<E> pollLastEntry() { return delegate().pollLastEntry(); }
@Override public SortedSet<E> tailSet(E fromElement) { return multiset().tailMultiset(fromElement, CLOSED).elementSet(); }
@Override public Comparator<? super E> comparator() { return multiset().comparator(); }
private void testSubMultisetDistinctElements(SubMultisetSpec spec) { List<Entry<E>> entries = copyToList(sortedMultiset.entrySet()); for (int i = 0; i < entries.size(); i++) { List<Entry<E>> expected = spec.expectedEntries(i, entries); SortedMultiset<E> subMultiset = spec.subMultiset(sortedMultiset, entries, i); assertEquals(expected.size(), subMultiset.entrySet().size()); assertEquals(expected.size(), subMultiset.elementSet().size()); } }
@Override public SortedMultiset<E> descendingMultiset() { return delegate().descendingMultiset(); }