com.google.common.collect.testing.google.MultisetNavigationTester Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of guava-testlib Show documentation
Show all versions of guava-testlib Show documentation
Guava testlib is a set of java classes used for more convenient
unit testing - particularly to assist the tests for Guava itself.
/*
* Copyright (C) 2011 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.common.collect.testing.google;
import static com.google.common.collect.BoundType.CLOSED;
import static com.google.common.collect.BoundType.OPEN;
import static com.google.common.collect.testing.Helpers.copyToList;
import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_ADD;
import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
import static com.google.common.collect.testing.features.CollectionSize.ONE;
import static com.google.common.collect.testing.features.CollectionSize.SEVERAL;
import static com.google.common.collect.testing.features.CollectionSize.ZERO;
import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.BoundType;
import com.google.common.collect.Iterators;
import com.google.common.collect.Multiset;
import com.google.common.collect.Multiset.Entry;
import com.google.common.collect.Multisets;
import com.google.common.collect.SortedMultiset;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.CollectionSize;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.NoSuchElementException;
import org.junit.Ignore;
/**
* Tester for navigation of SortedMultisets.
*
* @author Louis Wasserman
*/
@GwtCompatible
@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
public class MultisetNavigationTester extends AbstractMultisetTester {
private SortedMultiset sortedMultiset;
private List entries;
private Entry a;
private Entry b;
private Entry c;
/** Used to avoid http://bugs.sun.com/view_bug.do?bug_id=6558557 */
static SortedMultiset cast(Multiset iterable) {
return (SortedMultiset) iterable;
}
@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)));
}
}
}
/** Resets the contents of sortedMultiset to have entries a, c, for the navigation tests. */
@SuppressWarnings("unchecked")
// Needed to stop Eclipse whining
private void resetWithHole() {
List container = new ArrayList();
container.addAll(Collections.nCopies(a.getCount(), a.getElement()));
container.addAll(Collections.nCopies(c.getCount(), c.getElement()));
super.resetContainer(getSubjectGenerator().create(container.toArray()));
sortedMultiset = (SortedMultiset) getMultiset();
}
@CollectionSize.Require(ZERO)
public void testEmptyMultisetFirst() {
assertNull(sortedMultiset.firstEntry());
try {
sortedMultiset.elementSet().first();
fail();
} catch (NoSuchElementException e) {
}
}
@CollectionFeature.Require(SUPPORTS_REMOVE)
@CollectionSize.Require(ZERO)
public void testEmptyMultisetPollFirst() {
assertNull(sortedMultiset.pollFirstEntry());
}
@CollectionSize.Require(ZERO)
public void testEmptyMultisetNearby() {
for (BoundType type : BoundType.values()) {
assertNull(sortedMultiset.headMultiset(e0(), type).lastEntry());
assertNull(sortedMultiset.tailMultiset(e0(), type).firstEntry());
}
}
@CollectionSize.Require(ZERO)
public void testEmptyMultisetLast() {
assertNull(sortedMultiset.lastEntry());
try {
assertNull(sortedMultiset.elementSet().last());
fail();
} catch (NoSuchElementException e) {
}
}
@CollectionFeature.Require(SUPPORTS_REMOVE)
@CollectionSize.Require(ZERO)
public void testEmptyMultisetPollLast() {
assertNull(sortedMultiset.pollLastEntry());
}
@CollectionSize.Require(ONE)
public void testSingletonMultisetFirst() {
assertEquals(a, sortedMultiset.firstEntry());
}
@CollectionFeature.Require(SUPPORTS_REMOVE)
@CollectionSize.Require(ONE)
public void testSingletonMultisetPollFirst() {
assertEquals(a, sortedMultiset.pollFirstEntry());
assertTrue(sortedMultiset.isEmpty());
}
@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());
}
@CollectionSize.Require(ONE)
public void testSingletonMultisetLast() {
assertEquals(a, sortedMultiset.lastEntry());
}
@CollectionFeature.Require(SUPPORTS_REMOVE)
@CollectionSize.Require(ONE)
public void testSingletonMultisetPollLast() {
assertEquals(a, sortedMultiset.pollLastEntry());
assertTrue(sortedMultiset.isEmpty());
}
@CollectionSize.Require(SEVERAL)
public void testFirst() {
assertEquals(a, sortedMultiset.firstEntry());
}
@SuppressWarnings("unchecked")
@CollectionFeature.Require(SUPPORTS_REMOVE)
@CollectionSize.Require(SEVERAL)
public void testPollFirst() {
assertEquals(a, sortedMultiset.pollFirstEntry());
assertEquals(Arrays.asList(b, c), copyToList(sortedMultiset.entrySet()));
}
@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
public void testPollFirstUnsupported() {
try {
sortedMultiset.pollFirstEntry();
fail();
} catch (UnsupportedOperationException e) {
}
}
@CollectionSize.Require(SEVERAL)
public void testLower() {
resetWithHole();
assertEquals(null, sortedMultiset.headMultiset(a.getElement(), OPEN).lastEntry());
assertEquals(a, sortedMultiset.headMultiset(b.getElement(), OPEN).lastEntry());
assertEquals(a, sortedMultiset.headMultiset(c.getElement(), OPEN).lastEntry());
}
@CollectionSize.Require(SEVERAL)
public void testFloor() {
resetWithHole();
assertEquals(a, sortedMultiset.headMultiset(a.getElement(), CLOSED).lastEntry());
assertEquals(a, sortedMultiset.headMultiset(b.getElement(), CLOSED).lastEntry());
assertEquals(c, sortedMultiset.headMultiset(c.getElement(), CLOSED).lastEntry());
}
@CollectionSize.Require(SEVERAL)
public void testCeiling() {
resetWithHole();
assertEquals(a, sortedMultiset.tailMultiset(a.getElement(), CLOSED).firstEntry());
assertEquals(c, sortedMultiset.tailMultiset(b.getElement(), CLOSED).firstEntry());
assertEquals(c, sortedMultiset.tailMultiset(c.getElement(), CLOSED).firstEntry());
}
@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());
}
@CollectionSize.Require(SEVERAL)
public void testLast() {
assertEquals(c, sortedMultiset.lastEntry());
}
@SuppressWarnings("unchecked")
@CollectionFeature.Require(SUPPORTS_REMOVE)
@CollectionSize.Require(SEVERAL)
public void testPollLast() {
assertEquals(c, sortedMultiset.pollLastEntry());
assertEquals(Arrays.asList(a, b), copyToList(sortedMultiset.entrySet()));
}
@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
@CollectionSize.Require(SEVERAL)
public void testPollLastUnsupported() {
try {
sortedMultiset.pollLastEntry();
fail();
} catch (UnsupportedOperationException e) {
}
}
@CollectionSize.Require(SEVERAL)
public void testDescendingNavigation() {
List> ascending = new ArrayList<>();
Iterators.addAll(ascending, sortedMultiset.entrySet().iterator());
List> descending = new ArrayList<>();
Iterators.addAll(descending, sortedMultiset.descendingMultiset().entrySet().iterator());
Collections.reverse(descending);
assertEquals(ascending, descending);
}
void expectAddFailure(SortedMultiset multiset, Entry entry) {
try {
multiset.add(entry.getElement(), entry.getCount());
fail("Expected IllegalArgumentException");
} catch (IllegalArgumentException expected) {
}
try {
multiset.add(entry.getElement());
fail("Expected IllegalArgumentException");
} catch (IllegalArgumentException expected) {
}
try {
multiset.addAll(Collections.singletonList(entry.getElement()));
fail("Expected IllegalArgumentException");
} catch (IllegalArgumentException expected) {
}
}
void expectRemoveZero(SortedMultiset multiset, Entry entry) {
assertEquals(0, multiset.remove(entry.getElement(), entry.getCount()));
assertFalse(multiset.remove(entry.getElement()));
assertFalse(multiset.elementSet().remove(entry.getElement()));
}
void expectSetCountFailure(SortedMultiset multiset, Entry entry) {
try {
multiset.setCount(entry.getElement(), multiset.count(entry.getElement()));
} catch (IllegalArgumentException acceptable) {
}
try {
multiset.setCount(entry.getElement(), multiset.count(entry.getElement()) + 1);
fail("Expected IllegalArgumentException");
} catch (IllegalArgumentException expected) {
}
}
@CollectionSize.Require(ONE)
@CollectionFeature.Require(SUPPORTS_ADD)
public void testAddOutOfTailBoundsOne() {
expectAddFailure(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_ADD)
public void testAddOutOfTailBoundsSeveral() {
expectAddFailure(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
expectAddFailure(sortedMultiset.tailMultiset(b.getElement(), CLOSED), a);
expectAddFailure(sortedMultiset.tailMultiset(b.getElement(), OPEN), a);
expectAddFailure(sortedMultiset.tailMultiset(b.getElement(), OPEN), b);
expectAddFailure(sortedMultiset.tailMultiset(c.getElement(), CLOSED), a);
expectAddFailure(sortedMultiset.tailMultiset(c.getElement(), CLOSED), b);
expectAddFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), a);
expectAddFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), b);
expectAddFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), c);
}
@CollectionSize.Require(ONE)
@CollectionFeature.Require(SUPPORTS_ADD)
public void testAddOutOfHeadBoundsOne() {
expectAddFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_ADD)
public void testAddOutOfHeadBoundsSeveral() {
expectAddFailure(sortedMultiset.headMultiset(c.getElement(), OPEN), c);
expectAddFailure(sortedMultiset.headMultiset(b.getElement(), CLOSED), c);
expectAddFailure(sortedMultiset.headMultiset(b.getElement(), OPEN), c);
expectAddFailure(sortedMultiset.headMultiset(b.getElement(), OPEN), b);
expectAddFailure(sortedMultiset.headMultiset(a.getElement(), CLOSED), c);
expectAddFailure(sortedMultiset.headMultiset(a.getElement(), CLOSED), b);
expectAddFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), c);
expectAddFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), b);
expectAddFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
}
@CollectionSize.Require(ONE)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemoveOutOfTailBoundsOne() {
expectRemoveZero(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemoveOutOfTailBoundsSeveral() {
expectRemoveZero(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
expectRemoveZero(sortedMultiset.tailMultiset(b.getElement(), CLOSED), a);
expectRemoveZero(sortedMultiset.tailMultiset(b.getElement(), OPEN), a);
expectRemoveZero(sortedMultiset.tailMultiset(b.getElement(), OPEN), b);
expectRemoveZero(sortedMultiset.tailMultiset(c.getElement(), CLOSED), a);
expectRemoveZero(sortedMultiset.tailMultiset(c.getElement(), CLOSED), b);
expectRemoveZero(sortedMultiset.tailMultiset(c.getElement(), OPEN), a);
expectRemoveZero(sortedMultiset.tailMultiset(c.getElement(), OPEN), b);
expectRemoveZero(sortedMultiset.tailMultiset(c.getElement(), OPEN), c);
}
@CollectionSize.Require(ONE)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemoveOutOfHeadBoundsOne() {
expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemoveOutOfHeadBoundsSeveral() {
expectRemoveZero(sortedMultiset.headMultiset(c.getElement(), OPEN), c);
expectRemoveZero(sortedMultiset.headMultiset(b.getElement(), CLOSED), c);
expectRemoveZero(sortedMultiset.headMultiset(b.getElement(), OPEN), c);
expectRemoveZero(sortedMultiset.headMultiset(b.getElement(), OPEN), b);
expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), CLOSED), c);
expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), CLOSED), b);
expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), OPEN), c);
expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), OPEN), b);
expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
}
@CollectionSize.Require(ONE)
@CollectionFeature.Require({SUPPORTS_ADD, SUPPORTS_REMOVE})
public void testSetCountOutOfTailBoundsOne() {
expectSetCountFailure(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require({SUPPORTS_ADD, SUPPORTS_REMOVE})
public void testSetCountOutOfTailBoundsSeveral() {
expectSetCountFailure(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
expectSetCountFailure(sortedMultiset.tailMultiset(b.getElement(), CLOSED), a);
expectSetCountFailure(sortedMultiset.tailMultiset(b.getElement(), OPEN), a);
expectSetCountFailure(sortedMultiset.tailMultiset(b.getElement(), OPEN), b);
expectSetCountFailure(sortedMultiset.tailMultiset(c.getElement(), CLOSED), a);
expectSetCountFailure(sortedMultiset.tailMultiset(c.getElement(), CLOSED), b);
expectSetCountFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), a);
expectSetCountFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), b);
expectSetCountFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), c);
}
@CollectionSize.Require(ONE)
@CollectionFeature.Require({SUPPORTS_ADD, SUPPORTS_REMOVE})
public void testSetCountOutOfHeadBoundsOne() {
expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require({SUPPORTS_ADD, SUPPORTS_REMOVE})
public void testSetCountOutOfHeadBoundsSeveral() {
expectSetCountFailure(sortedMultiset.headMultiset(c.getElement(), OPEN), c);
expectSetCountFailure(sortedMultiset.headMultiset(b.getElement(), CLOSED), c);
expectSetCountFailure(sortedMultiset.headMultiset(b.getElement(), OPEN), c);
expectSetCountFailure(sortedMultiset.headMultiset(b.getElement(), OPEN), b);
expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), CLOSED), c);
expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), CLOSED), b);
expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), c);
expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), b);
expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_ADD)
public void testAddWithConflictingBounds() {
testEmptyRangeSubMultisetSupportingAdd(
sortedMultiset.subMultiset(a.getElement(), CLOSED, a.getElement(), OPEN));
testEmptyRangeSubMultisetSupportingAdd(
sortedMultiset.subMultiset(a.getElement(), OPEN, a.getElement(), OPEN));
testEmptyRangeSubMultisetSupportingAdd(
sortedMultiset.subMultiset(a.getElement(), OPEN, a.getElement(), CLOSED));
testEmptyRangeSubMultisetSupportingAdd(
sortedMultiset.subMultiset(b.getElement(), CLOSED, a.getElement(), CLOSED));
testEmptyRangeSubMultisetSupportingAdd(
sortedMultiset.subMultiset(b.getElement(), CLOSED, a.getElement(), OPEN));
testEmptyRangeSubMultisetSupportingAdd(
sortedMultiset.subMultiset(b.getElement(), OPEN, a.getElement(), OPEN));
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_ADD)
public void testConflictingBounds() {
testEmptyRangeSubMultiset(
sortedMultiset.subMultiset(a.getElement(), CLOSED, a.getElement(), OPEN));
testEmptyRangeSubMultiset(
sortedMultiset.subMultiset(a.getElement(), OPEN, a.getElement(), OPEN));
testEmptyRangeSubMultiset(
sortedMultiset.subMultiset(a.getElement(), OPEN, a.getElement(), CLOSED));
testEmptyRangeSubMultiset(
sortedMultiset.subMultiset(b.getElement(), CLOSED, a.getElement(), CLOSED));
testEmptyRangeSubMultiset(
sortedMultiset.subMultiset(b.getElement(), CLOSED, a.getElement(), OPEN));
testEmptyRangeSubMultiset(
sortedMultiset.subMultiset(b.getElement(), OPEN, a.getElement(), OPEN));
}
public void testEmptyRangeSubMultiset(SortedMultiset multiset) {
assertTrue(multiset.isEmpty());
assertEquals(0, multiset.size());
assertEquals(0, multiset.toArray().length);
assertTrue(multiset.entrySet().isEmpty());
assertFalse(multiset.iterator().hasNext());
assertEquals(0, multiset.entrySet().size());
assertEquals(0, multiset.entrySet().toArray().length);
assertFalse(multiset.entrySet().iterator().hasNext());
}
@SuppressWarnings("unchecked")
public void testEmptyRangeSubMultisetSupportingAdd(SortedMultiset multiset) {
for (Entry entry : Arrays.asList(a, b, c)) {
expectAddFailure(multiset, entry);
}
}
private static int totalSize(Iterable> entries) {
int sum = 0;
for (Entry entry : entries) {
sum += entry.getCount();
}
return sum;
}
private enum SubMultisetSpec {
TAIL_CLOSED {
@Override
List> expectedEntries(int targetEntry, List> entries) {
return entries.subList(targetEntry, entries.size());
}
@Override
SortedMultiset subMultiset(
SortedMultiset multiset, List> entries, int targetEntry) {
return multiset.tailMultiset(entries.get(targetEntry).getElement(), CLOSED);
}
},
TAIL_OPEN {
@Override
List> expectedEntries(int targetEntry, List> entries) {
return entries.subList(targetEntry + 1, entries.size());
}
@Override
SortedMultiset subMultiset(
SortedMultiset multiset, List> entries, int targetEntry) {
return multiset.tailMultiset(entries.get(targetEntry).getElement(), OPEN);
}
},
HEAD_CLOSED {
@Override
List> expectedEntries(int targetEntry, List> entries) {
return entries.subList(0, targetEntry + 1);
}
@Override
SortedMultiset subMultiset(
SortedMultiset multiset, List> entries, int targetEntry) {
return multiset.headMultiset(entries.get(targetEntry).getElement(), CLOSED);
}
},
HEAD_OPEN {
@Override
List> expectedEntries(int targetEntry, List> entries) {
return entries.subList(0, targetEntry);
}
@Override
SortedMultiset subMultiset(
SortedMultiset multiset, List> entries, int targetEntry) {
return multiset.headMultiset(entries.get(targetEntry).getElement(), OPEN);
}
};
abstract List> expectedEntries(int targetEntry, List> entries);
abstract SortedMultiset subMultiset(
SortedMultiset multiset, List> entries, int targetEntry);
}
private void testSubMultisetEntrySet(SubMultisetSpec spec) {
List> entries = copyToList(sortedMultiset.entrySet());
for (int i = 0; i < entries.size(); i++) {
List> expected = spec.expectedEntries(i, entries);
SortedMultiset subMultiset = spec.subMultiset(sortedMultiset, entries, i);
assertEquals(expected, copyToList(subMultiset.entrySet()));
}
}
private void testSubMultisetSize(SubMultisetSpec spec) {
List> entries = copyToList(sortedMultiset.entrySet());
for (int i = 0; i < entries.size(); i++) {
List> expected = spec.expectedEntries(i, entries);
SortedMultiset subMultiset = spec.subMultiset(sortedMultiset, entries, i);
assertEquals(totalSize(expected), subMultiset.size());
}
}
private void testSubMultisetDistinctElements(SubMultisetSpec spec) {
List> entries = copyToList(sortedMultiset.entrySet());
for (int i = 0; i < entries.size(); i++) {
List> expected = spec.expectedEntries(i, entries);
SortedMultiset subMultiset = spec.subMultiset(sortedMultiset, entries, i);
assertEquals(expected.size(), subMultiset.entrySet().size());
assertEquals(expected.size(), subMultiset.elementSet().size());
}
}
public void testTailClosedEntrySet() {
testSubMultisetEntrySet(SubMultisetSpec.TAIL_CLOSED);
}
public void testTailClosedSize() {
testSubMultisetSize(SubMultisetSpec.TAIL_CLOSED);
}
public void testTailClosedDistinctElements() {
testSubMultisetDistinctElements(SubMultisetSpec.TAIL_CLOSED);
}
public void testTailOpenEntrySet() {
testSubMultisetEntrySet(SubMultisetSpec.TAIL_OPEN);
}
public void testTailOpenSize() {
testSubMultisetSize(SubMultisetSpec.TAIL_OPEN);
}
public void testTailOpenDistinctElements() {
testSubMultisetDistinctElements(SubMultisetSpec.TAIL_OPEN);
}
public void testHeadClosedEntrySet() {
testSubMultisetEntrySet(SubMultisetSpec.HEAD_CLOSED);
}
public void testHeadClosedSize() {
testSubMultisetSize(SubMultisetSpec.HEAD_CLOSED);
}
public void testHeadClosedDistinctElements() {
testSubMultisetDistinctElements(SubMultisetSpec.HEAD_CLOSED);
}
public void testHeadOpenEntrySet() {
testSubMultisetEntrySet(SubMultisetSpec.HEAD_OPEN);
}
public void testHeadOpenSize() {
testSubMultisetSize(SubMultisetSpec.HEAD_OPEN);
}
public void testHeadOpenDistinctElements() {
testSubMultisetDistinctElements(SubMultisetSpec.HEAD_OPEN);
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testClearTailOpen() {
List> 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 testClearTailOpenEntrySet() {
List> expected =
copyToList(sortedMultiset.headMultiset(b.getElement(), CLOSED).entrySet());
sortedMultiset.tailMultiset(b.getElement(), OPEN).entrySet().clear();
assertEquals(expected, copyToList(sortedMultiset.entrySet()));
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testClearTailClosed() {
List> expected =
copyToList(sortedMultiset.headMultiset(b.getElement(), OPEN).entrySet());
sortedMultiset.tailMultiset(b.getElement(), CLOSED).clear();
assertEquals(expected, copyToList(sortedMultiset.entrySet()));
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testClearTailClosedEntrySet() {
List> expected =
copyToList(sortedMultiset.headMultiset(b.getElement(), OPEN).entrySet());
sortedMultiset.tailMultiset(b.getElement(), CLOSED).entrySet().clear();
assertEquals(expected, copyToList(sortedMultiset.entrySet()));
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testClearHeadOpen() {
List> expected =
copyToList(sortedMultiset.tailMultiset(b.getElement(), CLOSED).entrySet());
sortedMultiset.headMultiset(b.getElement(), OPEN).clear();
assertEquals(expected, copyToList(sortedMultiset.entrySet()));
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testClearHeadOpenEntrySet() {
List> expected =
copyToList(sortedMultiset.tailMultiset(b.getElement(), CLOSED).entrySet());
sortedMultiset.headMultiset(b.getElement(), OPEN).entrySet().clear();
assertEquals(expected, copyToList(sortedMultiset.entrySet()));
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testClearHeadClosed() {
List> expected =
copyToList(sortedMultiset.tailMultiset(b.getElement(), OPEN).entrySet());
sortedMultiset.headMultiset(b.getElement(), CLOSED).clear();
assertEquals(expected, copyToList(sortedMultiset.entrySet()));
}
@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testClearHeadClosedEntrySet() {
List> expected =
copyToList(sortedMultiset.tailMultiset(b.getElement(), OPEN).entrySet());
sortedMultiset.headMultiset(b.getElement(), CLOSED).entrySet().clear();
assertEquals(expected, copyToList(sortedMultiset.entrySet()));
}
}