/*
* 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;
import static com.google.common.collect.BoundType.CLOSED;
import static com.google.common.collect.BoundType.OPEN;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.CollectionSize;
import com.google.common.collect.testing.google.SortedMultisetTestSuiteBuilder;
import com.google.common.collect.testing.google.TestStringMultisetGenerator;
import junit.framework.Test;
import junit.framework.TestSuite;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.NavigableSet;
import javax.annotation.Nullable;
/**
* Tests for {@link ForwardingSortedMultiset}.
*
* @author Louis Wasserman
*/
public class ForwardingSortedMultisetTest extends ForwardingMultisetTest {
static class StandardImplForwardingSortedMultiset<E> extends ForwardingSortedMultiset<E> {
private final SortedMultiset<E> backingMultiset;
StandardImplForwardingSortedMultiset(SortedMultiset<E> backingMultiset) {
this.backingMultiset = backingMultiset;
}
@Override
protected SortedMultiset<E> delegate() {
return backingMultiset;
}
@Override
public SortedMultiset<E> descendingMultiset() {
return new StandardDescendingMultiset() {
@Override
Iterator<Entry<E>> entryIterator() {
return backingMultiset
.descendingMultiset()
.entrySet()
.iterator();
}
};
}
@Override
public NavigableSet<E> elementSet() {
return new StandardElementSet();
}
@Override
public Entry<E> firstEntry() {
return standardFirstEntry();
}
@Override
public Entry<E> lastEntry() {
return standardLastEntry();
}
@Override
public Entry<E> pollFirstEntry() {
return standardPollFirstEntry();
}
@Override
public Entry<E> pollLastEntry() {
return standardPollLastEntry();
}
@Override
public SortedMultiset<E> subMultiset(
E lowerBound, BoundType lowerBoundType, E upperBound, BoundType upperBoundType) {
return standardSubMultiset(lowerBound, lowerBoundType, upperBound, upperBoundType);
}
@Override
public int count(@Nullable Object element) {
return standardCount(element);
}
@Override
public boolean equals(@Nullable Object object) {
return standardEquals(object);
}
@Override
public int hashCode() {
return standardHashCode();
}
@Override
public boolean add(E element) {
return standardAdd(element);
}
@Override
public boolean addAll(Collection<? extends E> collection) {
return standardAddAll(collection);
}
@Override
public void clear() {
standardClear();
}
@Override
public boolean contains(@Nullable Object object) {
return standardContains(object);
}
@Override
public boolean containsAll(Collection<?> collection) {
return standardContainsAll(collection);
}
@Override
public boolean isEmpty() {
return standardIsEmpty();
}
@Override
public Iterator<E> iterator() {
return standardIterator();
}
@Override
public boolean remove(@Nullable Object object) {
return standardRemove(object);
}
@Override
public boolean removeAll(Collection<?> collection) {
return standardRemoveAll(collection);
}
@Override
public boolean retainAll(Collection<?> collection) {
return standardRetainAll(collection);
}
@Override
public int size() {
return standardSize();
}
@Override
public Object[] toArray() {
return standardToArray();
}
@Override
public <T> T[] toArray(T[] array) {
return standardToArray(array);
}
}
public static Test suite() {
TestSuite suite = new TestSuite();
suite.addTestSuite(ForwardingSortedMultisetTest.class);
suite.addTest(SortedMultisetTestSuiteBuilder
.using(new TestStringMultisetGenerator() {
@Override
protected Multiset<String> create(String[] elements) {
return new StandardImplForwardingSortedMultiset<String>(
TreeMultiset.create(Arrays.asList(elements)));
}
@Override
public List<String> order(List<String> insertionOrder) {
return Ordering.natural().sortedCopy(insertionOrder);
}
})
.named("ForwardingSortedMultiset with standard impls")
.withFeatures(
CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, CollectionFeature.GENERAL_PURPOSE,
CollectionFeature.ALLOWS_NULL_QUERIES)
.createTestSuite());
return suite;
}
@Override
public void setUp() throws Exception {
super.setUp();
/*
* Class parameters must be raw, so we can't create a proxy with generic type arguments. The
* created proxy only records calls and returns null, so the type is irrelevant at runtime.
*/
@SuppressWarnings("unchecked")
final SortedMultiset<String> sortedMultiset = createProxyInstance(SortedMultiset.class);
forward = new ForwardingSortedMultiset<String>() {
@Override
protected SortedMultiset<String> delegate() {
return sortedMultiset;
}
};
}
public void testComparator() {
forward().comparator();
assertEquals("[comparator]", getCalls());
}
public void testFirstEntry() {
forward().firstEntry();
assertEquals("[firstEntry]", getCalls());
}
public void testLastEntry() {
forward().lastEntry();
assertEquals("[lastEntry]", getCalls());
}
public void testPollFirstEntry() {
forward().pollFirstEntry();
assertEquals("[pollFirstEntry]", getCalls());
}
public void testPollLastEntry() {
forward().pollLastEntry();
assertEquals("[pollLastEntry]", getCalls());
}
public void testDescendingMultiset() {
forward().descendingMultiset();
assertEquals("[descendingMultiset]", getCalls());
}
public void testHeadMultiset() {
forward().headMultiset("abcd", CLOSED);
assertEquals("[headMultiset(Object,BoundType)]", getCalls());
}
public void testSubMultiset() {
forward().subMultiset("abcd", CLOSED, "dcba", OPEN);
assertEquals("[subMultiset(Object,BoundType,Object,BoundType)]", getCalls());
}
public void testTailMultiset() {
forward().tailMultiset("last", OPEN);
assertEquals("[tailMultiset(Object,BoundType)]", getCalls());
}
@Override
protected SortedMultiset<String> forward() {
return (SortedMultiset<String>) super.forward();
}
}