diff options
Diffstat (limited to 'guava-tests/test/com/google/common/collect/ImmutableSortedSetTest.java')
| -rw-r--r-- | guava-tests/test/com/google/common/collect/ImmutableSortedSetTest.java | 258 |
1 files changed, 56 insertions, 202 deletions
diff --git a/guava-tests/test/com/google/common/collect/ImmutableSortedSetTest.java b/guava-tests/test/com/google/common/collect/ImmutableSortedSetTest.java index b4820b2..59506db 100644 --- a/guava-tests/test/com/google/common/collect/ImmutableSortedSetTest.java +++ b/guava-tests/test/com/google/common/collect/ImmutableSortedSetTest.java @@ -17,33 +17,14 @@ package com.google.common.collect; import static java.util.Arrays.asList; -import static org.truth0.Truth.ASSERT; +import static org.junit.contrib.truth.Truth.ASSERT; import com.google.common.annotations.GwtCompatible; import com.google.common.annotations.GwtIncompatible; -import com.google.common.collect.testing.ListTestSuiteBuilder; -import com.google.common.collect.testing.NavigableSetTestSuiteBuilder; -import com.google.common.collect.testing.features.CollectionFeature; -import com.google.common.collect.testing.features.CollectionSize; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetAsListGenerator; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetCopyOfGenerator; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetDescendingAsListGenerator; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetDescendingGenerator; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetExplicitComparator; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetExplicitSuperclassComparatorGenerator; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetHeadsetGenerator; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetReversedOrderGenerator; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetSubsetAsListGenerator; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetSubsetGenerator; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetTailsetGenerator; -import com.google.common.collect.testing.google.SetGenerators.ImmutableSortedSetUnhashableGenerator; -import com.google.common.collect.testing.testers.SetHashCodeTester; +import com.google.common.collect.ImmutableSet.Builder; import com.google.common.testing.NullPointerTester; import com.google.common.testing.SerializableTester; -import junit.framework.Test; -import junit.framework.TestSuite; - import java.util.Arrays; import java.util.Collection; import java.util.Collections; @@ -62,117 +43,6 @@ import java.util.TreeSet; @GwtCompatible(emulated = true) public class ImmutableSortedSetTest extends AbstractImmutableSetTest { - @GwtIncompatible("suite") - public static Test suite() { - TestSuite suite = new TestSuite(); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ImmutableSortedSetCopyOfGenerator()) - .named(ImmutableSortedSetTest.class.getName()) - .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, - CollectionFeature.SERIALIZABLE, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ImmutableSortedSetHeadsetGenerator()) - .named(ImmutableSortedSetTest.class.getName() + ", headset") - .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, - CollectionFeature.SERIALIZABLE, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ImmutableSortedSetTailsetGenerator()) - .named(ImmutableSortedSetTest.class.getName() + ", tailset") - .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, - CollectionFeature.SERIALIZABLE, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ImmutableSortedSetSubsetGenerator()) - .named(ImmutableSortedSetTest.class.getName() + ", subset") - .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, - CollectionFeature.SERIALIZABLE, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ImmutableSortedSetExplicitComparator()) - .named(ImmutableSortedSetTest.class.getName() - + ", explicit comparator, vararg") - .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, - CollectionFeature.SERIALIZABLE, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ImmutableSortedSetExplicitSuperclassComparatorGenerator()) - .named(ImmutableSortedSetTest.class.getName() - + ", explicit superclass comparator, iterable") - .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, - CollectionFeature.SERIALIZABLE, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ImmutableSortedSetReversedOrderGenerator()) - .named(ImmutableSortedSetTest.class.getName() - + ", reverseOrder, iterator") - .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, - CollectionFeature.SERIALIZABLE, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ImmutableSortedSetUnhashableGenerator()) - .suppressing(SetHashCodeTester.getHashCodeMethods()) - .named(ImmutableSortedSetTest.class.getName() + ", unhashable") - .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ImmutableSortedSetDescendingGenerator()) - .named(ImmutableSortedSetTest.class.getName() + ", descending") - .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, - CollectionFeature.SERIALIZABLE, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTest(ListTestSuiteBuilder.using( - new ImmutableSortedSetAsListGenerator()) - .named("ImmutableSortedSet.asList") - .withFeatures(CollectionSize.ANY, - CollectionFeature.REJECTS_DUPLICATES_AT_CREATION, - CollectionFeature.SERIALIZABLE, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTest(ListTestSuiteBuilder.using( - new ImmutableSortedSetSubsetAsListGenerator()) - .named("ImmutableSortedSet.subSet.asList") - .withFeatures(CollectionSize.ANY, - CollectionFeature.REJECTS_DUPLICATES_AT_CREATION, - CollectionFeature.SERIALIZABLE, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTest(ListTestSuiteBuilder.using( - new ImmutableSortedSetDescendingAsListGenerator()) - .named("ImmutableSortedSet.descendingSet.asList") - .withFeatures(CollectionSize.ANY, - CollectionFeature.REJECTS_DUPLICATES_AT_CREATION, - CollectionFeature.SERIALIZABLE, - CollectionFeature.ALLOWS_NULL_QUERIES) - .createTestSuite()); - - suite.addTestSuite(ImmutableSortedSetTest.class); - - return suite; - } - // enum singleton pattern private enum StringLengthComparator implements Comparator<String> { INSTANCE; @@ -234,8 +104,10 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { } @GwtIncompatible("NullPointerTester") - public void testNullPointers() { - new NullPointerTester().testAllPublicStaticMethods(ImmutableSortedSet.class); + public void testNullPointers() throws Exception { + NullPointerTester tester = new NullPointerTester(); + tester.setDefault(Comparable[].class, new Comparable[] { 0 }); + tester.testAllPublicStaticMethods(ImmutableSortedSet.class); } public void testEmpty_comparator() { @@ -291,7 +163,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testSingle_headSet() { SortedSet<String> set = of("e"); assertTrue(set.headSet("g") instanceof ImmutableSortedSet); - ASSERT.that(set.headSet("g")).has().item("e"); + ASSERT.that(set.headSet("g")).hasContentsInOrder("e"); assertSame(of(), set.headSet("c")); assertSame(of(), set.headSet("e")); } @@ -299,16 +171,16 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testSingle_tailSet() { SortedSet<String> set = of("e"); assertTrue(set.tailSet("c") instanceof ImmutableSortedSet); - ASSERT.that(set.tailSet("c")).has().item("e"); - ASSERT.that(set.tailSet("e")).has().item("e"); + ASSERT.that(set.tailSet("c")).hasContentsInOrder("e"); + ASSERT.that(set.tailSet("e")).hasContentsInOrder("e"); assertSame(of(), set.tailSet("g")); } public void testSingle_subSet() { SortedSet<String> set = of("e"); assertTrue(set.subSet("c", "g") instanceof ImmutableSortedSet); - ASSERT.that(set.subSet("c", "g")).has().item("e"); - ASSERT.that(set.subSet("e", "g")).has().item("e"); + ASSERT.that(set.subSet("c", "g")).hasContentsInOrder("e"); + ASSERT.that(set.subSet("e", "g")).hasContentsInOrder("e"); assertSame(of(), set.subSet("f", "g")); assertSame(of(), set.subSet("c", "e")); assertSame(of(), set.subSet("c", "d")); @@ -333,7 +205,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testOf_ordering() { SortedSet<String> set = of("e", "a", "f", "b", "d", "c"); - ASSERT.that(set).has().allOf("a", "b", "c", "d", "e", "f").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "b", "c", "d", "e", "f"); } /* @@ -382,7 +254,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testOf_ordering_dupes() { SortedSet<String> set = of("e", "a", "e", "f", "b", "b", "d", "a", "c"); - ASSERT.that(set).has().allOf("a", "b", "c", "d", "e", "f").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "b", "c", "d", "e", "f"); } public void testOf_comparator() { @@ -393,8 +265,8 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testOf_headSet() { SortedSet<String> set = of("e", "f", "b", "d", "c"); assertTrue(set.headSet("e") instanceof ImmutableSortedSet); - ASSERT.that(set.headSet("e")).has().allOf("b", "c", "d").inOrder(); - ASSERT.that(set.headSet("g")).has().allOf("b", "c", "d", "e", "f").inOrder(); + ASSERT.that(set.headSet("e")).hasContentsInOrder("b", "c", "d"); + ASSERT.that(set.headSet("g")).hasContentsInOrder("b", "c", "d", "e", "f"); assertSame(of(), set.headSet("a")); assertSame(of(), set.headSet("b")); } @@ -402,16 +274,16 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testOf_tailSet() { SortedSet<String> set = of("e", "f", "b", "d", "c"); assertTrue(set.tailSet("e") instanceof ImmutableSortedSet); - ASSERT.that(set.tailSet("e")).has().allOf("e", "f").inOrder(); - ASSERT.that(set.tailSet("a")).has().allOf("b", "c", "d", "e", "f").inOrder(); + ASSERT.that(set.tailSet("e")).hasContentsInOrder("e", "f"); + ASSERT.that(set.tailSet("a")).hasContentsInOrder("b", "c", "d", "e", "f"); assertSame(of(), set.tailSet("g")); } public void testOf_subSet() { SortedSet<String> set = of("e", "f", "b", "d", "c"); assertTrue(set.subSet("c", "e") instanceof ImmutableSortedSet); - ASSERT.that(set.subSet("c", "e")).has().allOf("c", "d").inOrder(); - ASSERT.that(set.subSet("a", "g")).has().allOf("b", "c", "d", "e", "f").inOrder(); + ASSERT.that(set.subSet("c", "e")).hasContentsInOrder("c", "d"); + ASSERT.that(set.subSet("a", "g")).hasContentsInOrder("b", "c", "d", "e", "f"); assertSame(of(), set.subSet("a", "b")); assertSame(of(), set.subSet("g", "h")); assertSame(of(), set.subSet("c", "c")); @@ -451,14 +323,14 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testExplicit_ordering() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH).add( "in", "the", "quick", "jumped", "over", "a").build(); - ASSERT.that(set).has().allOf("a", "in", "the", "over", "quick", "jumped").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "in", "the", "over", "quick", "jumped"); } public void testExplicit_ordering_dupes() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH).add( "in", "the", "quick", "brown", "fox", "jumped", "over", "a", "lazy", "dog").build(); - ASSERT.that(set).has().allOf("a", "in", "the", "over", "quick", "jumped").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "in", "the", "over", "quick", "jumped"); } public void testExplicit_contains() { @@ -488,9 +360,9 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { "in", "the", "quick", "jumped", "over", "a").build(); assertTrue(set.headSet("a") instanceof ImmutableSortedSet); assertTrue(set.headSet("fish") instanceof ImmutableSortedSet); - ASSERT.that(set.headSet("fish")).has().allOf("a", "in", "the").inOrder(); - ASSERT.that(set.headSet("california")).has() - .allOf("a", "in", "the", "over", "quick", "jumped").inOrder(); + ASSERT.that(set.headSet("fish")).hasContentsInOrder("a", "in", "the"); + ASSERT.that( + set.headSet("california")).hasContentsInOrder("a", "in", "the", "over", "quick", "jumped"); assertTrue(set.headSet("a").isEmpty()); assertTrue(set.headSet("").isEmpty()); } @@ -500,9 +372,9 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { "in", "the", "quick", "jumped", "over", "a").build(); assertTrue(set.tailSet("california") instanceof ImmutableSortedSet); assertTrue(set.tailSet("fish") instanceof ImmutableSortedSet); - ASSERT.that(set.tailSet("fish")).has().allOf("over", "quick", "jumped").inOrder(); + ASSERT.that(set.tailSet("fish")).hasContentsInOrder("over", "quick", "jumped"); ASSERT.that( - set.tailSet("a")).has().allOf("a", "in", "the", "over", "quick", "jumped").inOrder(); + set.tailSet("a")).hasContentsInOrder("a", "in", "the", "over", "quick", "jumped"); assertTrue(set.tailSet("california").isEmpty()); } @@ -511,9 +383,9 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { "in", "the", "quick", "jumped", "over", "a").build(); assertTrue(set.subSet("the", "quick") instanceof ImmutableSortedSet); assertTrue(set.subSet("", "b") instanceof ImmutableSortedSet); - ASSERT.that(set.subSet("the", "quick")).has().allOf("the", "over").inOrder(); + ASSERT.that(set.subSet("the", "quick")).hasContentsInOrder("the", "over"); ASSERT.that(set.subSet("a", "california")) - .has().allOf("a", "in", "the", "over", "quick", "jumped").inOrder(); + .hasContentsInOrder("a", "in", "the", "over", "quick", "jumped"); assertTrue(set.subSet("", "b").isEmpty()); assertTrue(set.subSet("vermont", "california").isEmpty()); assertTrue(set.subSet("aaa", "zzz").isEmpty()); @@ -557,13 +429,13 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testCopyOf_ordering() { SortedSet<String> set = copyOf(asList("e", "a", "f", "b", "d", "c")); - ASSERT.that(set).has().allOf("a", "b", "c", "d", "e", "f").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "b", "c", "d", "e", "f"); } public void testCopyOf_ordering_dupes() { SortedSet<String> set = copyOf(asList("e", "a", "e", "f", "b", "b", "d", "a", "c")); - ASSERT.that(set).has().allOf("a", "b", "c", "d", "e", "f").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "b", "c", "d", "e", "f"); } public void testCopyOf_subSet() { @@ -594,13 +466,13 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testCopyOf_iterator_ordering() { SortedSet<String> set = copyOf(asIterator("e", "a", "f", "b", "d", "c")); - ASSERT.that(set).has().allOf("a", "b", "c", "d", "e", "f").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "b", "c", "d", "e", "f"); } public void testCopyOf_iterator_ordering_dupes() { SortedSet<String> set = copyOf(asIterator("e", "a", "e", "f", "b", "b", "d", "a", "c")); - ASSERT.that(set).has().allOf("a", "b", "c", "d", "e", "f").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "b", "c", "d", "e", "f"); } public void testCopyOf_iterator_comparator() { @@ -611,7 +483,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testCopyOf_sortedSet_ordering() { SortedSet<String> set = copyOf(Sets.newTreeSet(asList("e", "a", "f", "b", "d", "c"))); - ASSERT.that(set).has().allOf("a", "b", "c", "d", "e", "f").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "b", "c", "d", "e", "f"); } public void testCopyOf_sortedSet_comparator() { @@ -623,7 +495,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { SortedSet<String> set = ImmutableSortedSet.copyOf(STRING_LENGTH, asList( "in", "the", "quick", "jumped", "over", "a")); - ASSERT.that(set).has().allOf("a", "in", "the", "over", "quick", "jumped").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "in", "the", "over", "quick", "jumped"); } public void testCopyOfExplicit_ordering_dupes() { @@ -631,7 +503,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { ImmutableSortedSet.copyOf(STRING_LENGTH, asList( "in", "the", "quick", "brown", "fox", "jumped", "over", "a", "lazy", "dog")); - ASSERT.that(set).has().allOf("a", "in", "the", "over", "quick", "jumped").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "in", "the", "over", "quick", "jumped"); } public void testCopyOfExplicit_comparator() { @@ -645,7 +517,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { SortedSet<String> set = ImmutableSortedSet.copyOf(STRING_LENGTH, asIterator( "in", "the", "quick", "jumped", "over", "a")); - ASSERT.that(set).has().allOf("a", "in", "the", "over", "quick", "jumped").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "in", "the", "over", "quick", "jumped"); } public void testCopyOfExplicit_iterator_ordering_dupes() { @@ -653,7 +525,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { ImmutableSortedSet.copyOf(STRING_LENGTH, asIterator( "in", "the", "quick", "brown", "fox", "jumped", "over", "a", "lazy", "dog")); - ASSERT.that(set).has().allOf("a", "in", "the", "over", "quick", "jumped").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "in", "the", "over", "quick", "jumped"); } public void testCopyOfExplicit_iterator_comparator() { @@ -667,14 +539,14 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { SortedSet<String> input = Sets.newTreeSet(STRING_LENGTH); Collections.addAll(input, "in", "the", "quick", "jumped", "over", "a"); SortedSet<String> set = copyOf(input); - ASSERT.that(set).has().allOf("a", "in", "jumped", "over", "quick", "the").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "in", "jumped", "over", "quick", "the"); } public void testCopyOfSorted_natural_ordering() { SortedSet<String> input = Sets.newTreeSet( asList("in", "the", "quick", "jumped", "over", "a")); SortedSet<String> set = ImmutableSortedSet.copyOfSorted(input); - ASSERT.that(set).has().allOf("a", "in", "jumped", "over", "quick", "the").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "in", "jumped", "over", "quick", "the"); } public void testCopyOfSorted_natural_comparator() { @@ -688,7 +560,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { SortedSet<String> input = Sets.newTreeSet(STRING_LENGTH); Collections.addAll(input, "in", "the", "quick", "jumped", "over", "a"); SortedSet<String> set = ImmutableSortedSet.copyOfSorted(input); - ASSERT.that(set).has().allOf("a", "in", "the", "over", "quick", "jumped").inOrder(); + ASSERT.that(set).hasContentsInOrder("a", "in", "the", "over", "quick", "jumped"); assertSame(STRING_LENGTH, set.comparator()); } @@ -786,7 +658,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testReverseOrder() { SortedSet<String> set = ImmutableSortedSet.<String>reverseOrder() .add("a", "b", "c").build(); - ASSERT.that(set).has().allOf("c", "b", "a").inOrder(); + ASSERT.that(set).hasContentsInOrder("c", "b", "a"); assertEquals(Ordering.natural().reverse(), set.comparator()); } @@ -801,16 +673,16 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { public void testSupertypeComparator() { SortedSet<Integer> set = new ImmutableSortedSet.Builder<Integer>(TO_STRING) .add(3, 12, 101, 44).build(); - ASSERT.that(set).has().allOf(101, 12, 3, 44).inOrder(); + ASSERT.that(set).hasContentsInOrder(101, 12, 3, 44); } public void testSupertypeComparatorSubtypeElements() { SortedSet<Number> set = new ImmutableSortedSet.Builder<Number>(TO_STRING) .add(3, 12, 101, 44).build(); - ASSERT.that(set).has().allOf(101, 12, 3, 44).inOrder(); + ASSERT.that(set).hasContentsInOrder(101, 12, 3, 44); } - @Override <E extends Comparable<E>> ImmutableSortedSet.Builder<E> builder() { + @Override <E extends Comparable<E>> Builder<E> builder() { return ImmutableSortedSet.naturalOrder(); } @@ -949,7 +821,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { Arrays.sort(strings); for (int i = 0; i < strings.length; i++) { ASSERT.that(set.headSet(strings[i], true)) - .has().allFrom(sortedNumberNames(0, i + 1)).inOrder(); + .hasContentsInOrder(sortedNumberNames(0, i + 1)); } } @@ -958,7 +830,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { ImmutableSortedSet<String> set = ImmutableSortedSet.copyOf(strings); Arrays.sort(strings); for (int i = 0; i < strings.length; i++) { - ASSERT.that(set.headSet(strings[i], false)).has().allFrom(sortedNumberNames(0, i)).inOrder(); + ASSERT.that(set.headSet(strings[i], false)).hasContentsInOrder(sortedNumberNames(0, i)); } } @@ -967,8 +839,8 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { ImmutableSortedSet<String> set = ImmutableSortedSet.copyOf(strings); Arrays.sort(strings); for (int i = 0; i < strings.length; i++) { - ASSERT.that(set.tailSet(strings[i], true)).has().allFrom( - sortedNumberNames(i, strings.length)).inOrder(); + ASSERT.that(set.tailSet(strings[i], true)).hasContentsInOrder( + sortedNumberNames(i, strings.length)); } } @@ -977,8 +849,8 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { ImmutableSortedSet<String> set = ImmutableSortedSet.copyOf(strings); Arrays.sort(strings); for (int i = 0; i < strings.length; i++) { - ASSERT.that(set.tailSet(strings[i], false)).has().allFrom( - sortedNumberNames(i + 1, strings.length)).inOrder(); + ASSERT.that(set.tailSet(strings[i], false)).hasContentsInOrder( + sortedNumberNames(i + 1, strings.length)); } } @@ -989,7 +861,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { for (int i = 0; i < strings.length; i++) { for (int j = i; j < strings.length; j++) { ASSERT.that(set.subSet(strings[i], false, strings[j], false)) - .has().allFrom(sortedNumberNames(Math.min(i + 1, j), j)).inOrder(); + .hasContentsInOrder(sortedNumberNames(Math.min(i + 1, j), j)); } } } @@ -1001,7 +873,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { for (int i = 0; i < strings.length; i++) { for (int j = i; j < strings.length; j++) { ASSERT.that(set.subSet(strings[i], true, strings[j], false)) - .has().allFrom(sortedNumberNames(i, j)).inOrder(); + .hasContentsInOrder(sortedNumberNames(i, j)); } } } @@ -1013,7 +885,7 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { for (int i = 0; i < strings.length; i++) { for (int j = i; j < strings.length; j++) { ASSERT.that(set.subSet(strings[i], false, strings[j], true)) - .has().allFrom(sortedNumberNames(i + 1, j + 1)).inOrder(); + .hasContentsInOrder(sortedNumberNames(i + 1, j + 1)); } } } @@ -1025,13 +897,13 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { for (int i = 0; i < strings.length; i++) { for (int j = i; j < strings.length; j++) { ASSERT.that(set.subSet(strings[i], true, strings[j], true)) - .has().allFrom(sortedNumberNames(i, j + 1)).inOrder(); + .hasContentsInOrder(sortedNumberNames(i, j + 1)); } } } - private static ImmutableList<String> sortedNumberNames(int i, int j) { - return ImmutableList.copyOf(SORTED_NUMBER_NAMES.subList(i, j)); + private static String[] sortedNumberNames(int i, int j) { + return SORTED_NUMBER_NAMES.subList(i, j).toArray(new String[0]); } private static final ImmutableList<String> NUMBER_NAMES = @@ -1040,22 +912,4 @@ public class ImmutableSortedSetTest extends AbstractImmutableSetTest { private static final ImmutableList<String> SORTED_NUMBER_NAMES = Ordering.natural().immutableSortedCopy(NUMBER_NAMES); - private static class SelfComparableExample implements Comparable<SelfComparableExample> { - @Override - public int compareTo(SelfComparableExample o) { - return 0; - } - } - - public void testBuilderGenerics_SelfComparable() { - ImmutableSortedSet.Builder<SelfComparableExample> natural = ImmutableSortedSet.naturalOrder(); - ImmutableSortedSet.Builder<SelfComparableExample> reverse = ImmutableSortedSet.reverseOrder(); - } - - private static class SuperComparableExample extends SelfComparableExample {} - - public void testBuilderGenerics_SuperComparable() { - ImmutableSortedSet.Builder<SuperComparableExample> natural = ImmutableSortedSet.naturalOrder(); - ImmutableSortedSet.Builder<SuperComparableExample> reverse = ImmutableSortedSet.reverseOrder(); - } } |