1 /* 2 * Copyright (C) 2010 The Guava Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.google.common.collect; 18 19 import com.google.common.collect.testing.SafeTreeSet; 20 import com.google.common.collect.testing.SetTestSuiteBuilder; 21 import com.google.common.collect.testing.TestStringSetGenerator; 22 import com.google.common.collect.testing.features.CollectionFeature; 23 import com.google.common.collect.testing.features.CollectionSize; 24 25 import junit.framework.Test; 26 import junit.framework.TestSuite; 27 28 import java.util.Arrays; 29 import java.util.Collection; 30 import java.util.List; 31 import java.util.Set; 32 import java.util.SortedSet; 33 34 /** 35 * Tests for {@code ForwardingSortedSet}. 36 * 37 * @author Louis Wasserman 38 */ 39 public class ForwardingSortedSetTest extends ForwardingSetTest { 40 static class StandardImplForwardingSortedSet<T> 41 extends ForwardingSortedSet<T> { 42 private final SortedSet<T> backingSet; 43 StandardImplForwardingSortedSet(SortedSet<T> backingSet)44 StandardImplForwardingSortedSet(SortedSet<T> backingSet) { 45 this.backingSet = backingSet; 46 } 47 delegate()48 @Override protected SortedSet<T> delegate() { 49 return backingSet; 50 } 51 equals(Object object)52 @Override public boolean equals(Object object) { 53 return standardEquals(object); 54 } 55 hashCode()56 @Override public int hashCode() { 57 return standardHashCode(); 58 } 59 addAll(Collection<? extends T> collection)60 @Override public boolean addAll(Collection<? extends T> collection) { 61 return standardAddAll(collection); 62 } 63 clear()64 @Override public void clear() { 65 standardClear(); 66 } 67 contains(Object object)68 @Override public boolean contains(Object object) { 69 return standardContains(object); 70 } 71 containsAll(Collection<?> collection)72 @Override public boolean containsAll(Collection<?> collection) { 73 return standardContainsAll(collection); 74 } 75 remove(Object object)76 @Override public boolean remove(Object object) { 77 return standardRemove(object); 78 } 79 removeAll(Collection<?> collection)80 @Override public boolean removeAll(Collection<?> collection) { 81 return standardRemoveAll(collection); 82 } 83 retainAll(Collection<?> collection)84 @Override public boolean retainAll(Collection<?> collection) { 85 return standardRetainAll(collection); 86 } 87 toArray()88 @Override public Object[] toArray() { 89 return standardToArray(); 90 } 91 toArray(T[] array)92 @Override public <T> T[] toArray(T[] array) { 93 return standardToArray(array); 94 } 95 toString()96 @Override public String toString() { 97 return standardToString(); 98 } 99 subSet(T fromElement, T toElement)100 @Override public SortedSet<T> subSet(T fromElement, T toElement) { 101 return standardSubSet(fromElement, toElement); 102 } 103 } 104 suite()105 public static Test suite() { 106 TestSuite suite = new TestSuite(); 107 108 suite.addTestSuite(ForwardingSortedSetTest.class); 109 suite.addTest( 110 SetTestSuiteBuilder.using(new TestStringSetGenerator() { 111 @Override protected Set<String> create(String[] elements) { 112 return new StandardImplForwardingSortedSet<String>( 113 new SafeTreeSet<String>(Arrays.asList(elements))); 114 } 115 116 @Override public List<String> order(List<String> insertionOrder) { 117 return Lists.newArrayList(Sets.newTreeSet(insertionOrder)); 118 } 119 }).named( 120 "ForwardingSortedSet[SafeTreeSet] with standard implementations") 121 .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, 122 CollectionFeature.GENERAL_PURPOSE).createTestSuite()); 123 124 return suite; 125 } 126 setUp()127 @Override public void setUp() throws Exception { 128 super.setUp(); 129 /* 130 * Class parameters must be raw, so we can't create a proxy with generic 131 * type arguments. The created proxy only records calls and returns null, so 132 * the type is irrelevant at runtime. 133 */ 134 @SuppressWarnings("unchecked") 135 final SortedSet<String> sortedSet 136 = createProxyInstance(SortedSet.class); 137 forward = new ForwardingSortedSet<String>() { 138 @Override protected SortedSet<String> delegate() { 139 return sortedSet; 140 } 141 }; 142 } 143 testComparator()144 public void testComparator() { 145 forward().comparator(); 146 assertEquals("[comparator]", getCalls()); 147 } 148 testFirst()149 public void testFirst() { 150 forward().first(); 151 assertEquals("[first]", getCalls()); 152 } 153 testHeadSet_K()154 public void testHeadSet_K() { 155 forward().headSet("asdf"); 156 assertEquals("[headSet(Object)]", getCalls()); 157 } 158 testLast()159 public void testLast() { 160 forward().last(); 161 assertEquals("[last]", getCalls()); 162 } 163 testSubSet_K_K()164 public void testSubSet_K_K() { 165 forward().subSet("first", "last"); 166 assertEquals("[subSet(Object,Object)]", getCalls()); 167 } 168 testTailSet_K()169 public void testTailSet_K() { 170 forward().tailSet("last"); 171 assertEquals("[tailSet(Object)]", getCalls()); 172 } 173 forward()174 @Override SortedSet<String> forward() { 175 return (SortedSet<String>) super.forward(); 176 } 177 } 178