diff options
Diffstat (limited to 'guava-tests/test/com/google/common/collect/ContiguousSetTest.java')
| -rw-r--r-- | guava-tests/test/com/google/common/collect/ContiguousSetTest.java | 303 |
1 files changed, 119 insertions, 184 deletions
diff --git a/guava-tests/test/com/google/common/collect/ContiguousSetTest.java b/guava-tests/test/com/google/common/collect/ContiguousSetTest.java index 373cf64..6909f7a 100644 --- a/guava-tests/test/com/google/common/collect/ContiguousSetTest.java +++ b/guava-tests/test/com/google/common/collect/ContiguousSetTest.java @@ -18,30 +18,16 @@ package com.google.common.collect; import static com.google.common.collect.BoundType.CLOSED; import static com.google.common.collect.BoundType.OPEN; -import static com.google.common.collect.DiscreteDomain.integers; -import static com.google.common.collect.testing.features.CollectionFeature.ALLOWS_NULL_QUERIES; -import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER; -import static com.google.common.collect.testing.features.CollectionFeature.NON_STANDARD_TOSTRING; -import static com.google.common.collect.testing.features.CollectionFeature.RESTRICTS_ELEMENTS; -import static com.google.common.collect.testing.testers.NavigableSetNavigationTester.getHoleMethods; +import static com.google.common.collect.DiscreteDomains.integers; import static com.google.common.testing.SerializableTester.reserialize; import static com.google.common.testing.SerializableTester.reserializeAndAssert; -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.NavigableSetTestSuiteBuilder; -import com.google.common.collect.testing.features.CollectionSize; -import com.google.common.collect.testing.google.SetGenerators.ContiguousSetDescendingGenerator; -import com.google.common.collect.testing.google.SetGenerators.ContiguousSetGenerator; -import com.google.common.collect.testing.google.SetGenerators.ContiguousSetHeadsetGenerator; -import com.google.common.collect.testing.google.SetGenerators.ContiguousSetSubsetGenerator; -import com.google.common.collect.testing.google.SetGenerators.ContiguousSetTailsetGenerator; import com.google.common.testing.EqualsTester; -import junit.framework.Test; import junit.framework.TestCase; -import junit.framework.TestSuite; import java.util.Set; @@ -75,35 +61,32 @@ public class ContiguousSetTest extends TestCase { public void testEquals() { new EqualsTester() .addEqualityGroup( - ContiguousSet.create(Range.closed(1, 3), integers()), - ContiguousSet.create(Range.closedOpen(1, 4), integers()), - ContiguousSet.create(Range.openClosed(0, 3), integers()), - ContiguousSet.create(Range.open(0, 4), integers()), - ContiguousSet.create(Range.closed(1, 3), NOT_EQUAL_TO_INTEGERS), - ContiguousSet.create(Range.closedOpen(1, 4), NOT_EQUAL_TO_INTEGERS), - ContiguousSet.create(Range.openClosed(0, 3), NOT_EQUAL_TO_INTEGERS), - ContiguousSet.create(Range.open(0, 4), NOT_EQUAL_TO_INTEGERS), + Ranges.closed(1, 3).asSet(integers()), + Ranges.closedOpen(1, 4).asSet(integers()), + Ranges.openClosed(0, 3).asSet(integers()), + Ranges.open(0, 4).asSet(integers()), + Ranges.closed(1, 3).asSet(NOT_EQUAL_TO_INTEGERS), + Ranges.closedOpen(1, 4).asSet(NOT_EQUAL_TO_INTEGERS), + Ranges.openClosed(0, 3).asSet(NOT_EQUAL_TO_INTEGERS), + Ranges.open(0, 4).asSet(NOT_EQUAL_TO_INTEGERS), ImmutableSortedSet.of(1, 2, 3)) .testEquals(); // not testing hashCode for these because it takes forever to compute - assertEquals( - ContiguousSet.create(Range.closed(Integer.MIN_VALUE, Integer.MAX_VALUE), integers()), - ContiguousSet.create(Range.<Integer>all(), integers())); - assertEquals( - ContiguousSet.create(Range.closed(Integer.MIN_VALUE, Integer.MAX_VALUE), integers()), - ContiguousSet.create(Range.atLeast(Integer.MIN_VALUE), integers())); - assertEquals( - ContiguousSet.create(Range.closed(Integer.MIN_VALUE, Integer.MAX_VALUE), integers()), - ContiguousSet.create(Range.atMost(Integer.MAX_VALUE), integers())); + assertEquals(Ranges.closed(Integer.MIN_VALUE, Integer.MAX_VALUE).asSet(integers()), + Ranges.<Integer>all().asSet(integers())); + assertEquals(Ranges.closed(Integer.MIN_VALUE, Integer.MAX_VALUE).asSet(integers()), + Ranges.atLeast(Integer.MIN_VALUE).asSet(integers())); + assertEquals(Ranges.closed(Integer.MIN_VALUE, Integer.MAX_VALUE).asSet(integers()), + Ranges.atMost(Integer.MAX_VALUE).asSet(integers())); } @GwtIncompatible("SerializableTester") public void testSerialization() { - ContiguousSet<Integer> empty = ContiguousSet.create(Range.closedOpen(1, 1), integers()); + ContiguousSet<Integer> empty = Ranges.closedOpen(1, 1).asSet(integers()); assertTrue(empty instanceof EmptyContiguousSet); reserializeAndAssert(empty); - ContiguousSet<Integer> regular = ContiguousSet.create(Range.closed(1, 3), integers()); + ContiguousSet<Integer> regular = Ranges.closed(1, 3).asSet(integers()); assertTrue(regular instanceof RegularContiguousSet); reserializeAndAssert(regular); @@ -111,7 +94,7 @@ public class ContiguousSetTest extends TestCase { * Make sure that we're using RegularContiguousSet.SerializedForm and not * ImmutableSet.SerializedForm, which would be enormous. */ - ContiguousSet<Integer> enormous = ContiguousSet.create(Range.<Integer>all(), integers()); + ContiguousSet<Integer> enormous = Ranges.<Integer>all().asSet(integers()); assertTrue(enormous instanceof RegularContiguousSet); // We can't use reserializeAndAssert because it calls hashCode, which is enormously slow. ContiguousSet<Integer> enormousReserialized = reserialize(enormous); @@ -119,58 +102,66 @@ public class ContiguousSetTest extends TestCase { } public void testHeadSet() { - ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); + ImmutableSortedSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); ASSERT.that(set.headSet(1)).isEmpty(); - ASSERT.that(set.headSet(2)).has().item(1); - ASSERT.that(set.headSet(3)).has().allOf(1, 2).inOrder(); - ASSERT.that(set.headSet(4)).has().allOf(1, 2, 3).inOrder(); - ASSERT.that(set.headSet(Integer.MAX_VALUE)).has().allOf(1, 2, 3).inOrder(); - ASSERT.that(set.headSet(1, true)).has().item(1); - ASSERT.that(set.headSet(2, true)).has().allOf(1, 2).inOrder(); - ASSERT.that(set.headSet(3, true)).has().allOf(1, 2, 3).inOrder(); - ASSERT.that(set.headSet(4, true)).has().allOf(1, 2, 3).inOrder(); - ASSERT.that(set.headSet(Integer.MAX_VALUE, true)).has().allOf(1, 2, 3).inOrder(); + ASSERT.that(set.headSet(2)).hasContentsInOrder(1); + ASSERT.that(set.headSet(3)).hasContentsInOrder(1, 2); + ASSERT.that(set.headSet(4)).hasContentsInOrder(1, 2, 3); + ASSERT.that(set.headSet(Integer.MAX_VALUE)).hasContentsInOrder(1, 2, 3); + ASSERT.that(set.headSet(1, true)).hasContentsInOrder(1); + ASSERT.that(set.headSet(2, true)).hasContentsInOrder(1, 2); + ASSERT.that(set.headSet(3, true)).hasContentsInOrder(1, 2, 3); + ASSERT.that(set.headSet(4, true)).hasContentsInOrder(1, 2, 3); + ASSERT.that(set.headSet(Integer.MAX_VALUE, true)).hasContentsInOrder(1, 2, 3); } public void testHeadSet_tooSmall() { - ASSERT.that(ContiguousSet.create(Range.closed(1, 3), integers()).headSet(0)).isEmpty(); + ImmutableSortedSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); + try { + set.headSet(0); + fail(); + } catch (IllegalArgumentException e) {} } public void testTailSet() { - ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); - ASSERT.that(set.tailSet(Integer.MIN_VALUE)).has().allOf(1, 2, 3).inOrder(); - ASSERT.that(set.tailSet(1)).has().allOf(1, 2, 3).inOrder(); - ASSERT.that(set.tailSet(2)).has().allOf(2, 3).inOrder(); - ASSERT.that(set.tailSet(3)).has().item(3); - ASSERT.that(set.tailSet(Integer.MIN_VALUE, false)).has().allOf(1, 2, 3).inOrder(); - ASSERT.that(set.tailSet(1, false)).has().allOf(2, 3).inOrder(); - ASSERT.that(set.tailSet(2, false)).has().item(3); + ImmutableSortedSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); + ASSERT.that(set.tailSet(Integer.MIN_VALUE)).hasContentsInOrder(1, 2, 3); + ASSERT.that(set.tailSet(1)).hasContentsInOrder(1, 2, 3); + ASSERT.that(set.tailSet(2)).hasContentsInOrder(2, 3); + ASSERT.that(set.tailSet(3)).hasContentsInOrder(3); + ASSERT.that(set.tailSet(Integer.MIN_VALUE, false)).hasContentsInOrder(1, 2, 3); + ASSERT.that(set.tailSet(1, false)).hasContentsInOrder(2, 3); + ASSERT.that(set.tailSet(2, false)).hasContentsInOrder(3); ASSERT.that(set.tailSet(3, false)).isEmpty(); } public void testTailSet_tooLarge() { - ASSERT.that(ContiguousSet.create(Range.closed(1, 3), integers()).tailSet(4)).isEmpty(); + ImmutableSortedSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); + try { + set.tailSet(4); + fail(); + } catch (IllegalArgumentException e) {} } public void testSubSet() { - ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); - ASSERT.that(set.subSet(1, 4)).has().allOf(1, 2, 3).inOrder(); - ASSERT.that(set.subSet(2, 4)).has().allOf(2, 3).inOrder(); - ASSERT.that(set.subSet(3, 4)).has().item(3); + ImmutableSortedSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); + ASSERT.that(set.subSet(1, 4)).hasContentsInOrder(1, 2, 3); + ASSERT.that(set.subSet(2, 4)).hasContentsInOrder(2, 3); + ASSERT.that(set.subSet(3, 4)).hasContentsInOrder(3); ASSERT.that(set.subSet(3, 3)).isEmpty(); - ASSERT.that(set.subSet(2, 3)).has().item(2); - ASSERT.that(set.subSet(1, 3)).has().allOf(1, 2).inOrder(); - ASSERT.that(set.subSet(1, 2)).has().item(1); + ASSERT.that(set.subSet(2, 3)).hasContentsInOrder(2); + ASSERT.that(set.subSet(1, 3)).hasContentsInOrder(1, 2); + ASSERT.that(set.subSet(1, 2)).hasContentsInOrder(1); ASSERT.that(set.subSet(2, 2)).isEmpty(); - ASSERT.that(set.subSet(Integer.MIN_VALUE, Integer.MAX_VALUE)).has().allOf(1, 2, 3).inOrder(); - ASSERT.that(set.subSet(1, true, 3, true)).has().allOf(1, 2, 3).inOrder(); - ASSERT.that(set.subSet(1, false, 3, true)).has().allOf(2, 3).inOrder(); - ASSERT.that(set.subSet(1, true, 3, false)).has().allOf(1, 2).inOrder(); - ASSERT.that(set.subSet(1, false, 3, false)).has().item(2); + ASSERT.that(set.subSet(Integer.MIN_VALUE, Integer.MAX_VALUE)).hasContentsInOrder(1, 2, 3); + ASSERT.that(set.subSet(1, true, 3, true)).hasContentsInOrder(1, 2, 3); + ASSERT.that(set.subSet(1, false, 3, true)).hasContentsInOrder(2, 3); + ASSERT.that(set.subSet(1, true, 3, false)).hasContentsInOrder(1, 2); + ASSERT.that(set.subSet(1, false, 3, false)).hasContentsInOrder(2); } public void testSubSet_outOfOrder() { - ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); + ImmutableSortedSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); try { set.subSet(3, 2); fail(); @@ -178,35 +169,41 @@ public class ContiguousSetTest extends TestCase { } public void testSubSet_tooLarge() { - ASSERT.that(ContiguousSet.create(Range.closed(1, 3), integers()).subSet(4, 6)).isEmpty(); + ImmutableSortedSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); + try { + set.subSet(4, 6); + fail(); + } catch (IllegalArgumentException expected) {} } public void testSubSet_tooSmall() { - ASSERT.that(ContiguousSet.create(Range.closed(1, 3), integers()).subSet(-1, 0)).isEmpty(); + ImmutableSortedSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); + try { + set.subSet(-1, 0); + fail(); + } catch (IllegalArgumentException expected) {} } public void testFirst() { - assertEquals(1, ContiguousSet.create(Range.closed(1, 3), integers()).first().intValue()); - assertEquals(1, ContiguousSet.create(Range.open(0, 4), integers()).first().intValue()); - assertEquals(Integer.MIN_VALUE, - ContiguousSet.create(Range.<Integer>all(), integers()).first().intValue()); + assertEquals(1, Ranges.closed(1, 3).asSet(integers()).first().intValue()); + assertEquals(1, Ranges.open(0, 4).asSet(integers()).first().intValue()); + assertEquals(Integer.MIN_VALUE, Ranges.<Integer>all().asSet(integers()).first().intValue()); } public void testLast() { - assertEquals(3, ContiguousSet.create(Range.closed(1, 3), integers()).last().intValue()); - assertEquals(3, ContiguousSet.create(Range.open(0, 4), integers()).last().intValue()); - assertEquals(Integer.MAX_VALUE, - ContiguousSet.create(Range.<Integer>all(), integers()).last().intValue()); + assertEquals(3, Ranges.closed(1, 3).asSet(integers()).last().intValue()); + assertEquals(3, Ranges.open(0, 4).asSet(integers()).last().intValue()); + assertEquals(Integer.MAX_VALUE, Ranges.<Integer>all().asSet(integers()).last().intValue()); } public void testContains() { - ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); + ImmutableSortedSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); assertFalse(set.contains(0)); assertTrue(set.contains(1)); assertTrue(set.contains(2)); assertTrue(set.contains(3)); assertFalse(set.contains(4)); - set = ContiguousSet.create(Range.open(0, 4), integers()); + set = Ranges.open(0, 4).asSet(integers()); assertFalse(set.contains(0)); assertTrue(set.contains(1)); assertTrue(set.contains(2)); @@ -216,7 +213,7 @@ public class ContiguousSetTest extends TestCase { } public void testContainsAll() { - ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); + ImmutableSortedSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) { assertTrue(set.containsAll(subset)); } @@ -227,117 +224,55 @@ public class ContiguousSetTest extends TestCase { } public void testRange() { - assertEquals(Range.closed(1, 3), - ContiguousSet.create(Range.closed(1, 3), integers()).range()); - assertEquals(Range.closed(1, 3), - ContiguousSet.create(Range.closedOpen(1, 4), integers()).range()); - assertEquals(Range.closed(1, 3), ContiguousSet.create(Range.open(0, 4), integers()).range()); - assertEquals(Range.closed(1, 3), - ContiguousSet.create(Range.openClosed(0, 3), integers()).range()); - - assertEquals(Range.openClosed(0, 3), - ContiguousSet.create(Range.closed(1, 3), integers()).range(OPEN, CLOSED)); - assertEquals(Range.openClosed(0, 3), - ContiguousSet.create(Range.closedOpen(1, 4), integers()).range(OPEN, CLOSED)); - assertEquals(Range.openClosed(0, 3), - ContiguousSet.create(Range.open(0, 4), integers()).range(OPEN, CLOSED)); - assertEquals(Range.openClosed(0, 3), - ContiguousSet.create(Range.openClosed(0, 3), integers()).range(OPEN, CLOSED)); - - assertEquals(Range.open(0, 4), - ContiguousSet.create(Range.closed(1, 3), integers()).range(OPEN, OPEN)); - assertEquals(Range.open(0, 4), - ContiguousSet.create(Range.closedOpen(1, 4), integers()).range(OPEN, OPEN)); - assertEquals(Range.open(0, 4), - ContiguousSet.create(Range.open(0, 4), integers()).range(OPEN, OPEN)); - assertEquals(Range.open(0, 4), - ContiguousSet.create(Range.openClosed(0, 3), integers()).range(OPEN, OPEN)); - - assertEquals(Range.closedOpen(1, 4), - ContiguousSet.create(Range.closed(1, 3), integers()).range(CLOSED, OPEN)); - assertEquals(Range.closedOpen(1, 4), - ContiguousSet.create(Range.closedOpen(1, 4), integers()).range(CLOSED, OPEN)); - assertEquals(Range.closedOpen(1, 4), - ContiguousSet.create(Range.open(0, 4), integers()).range(CLOSED, OPEN)); - assertEquals(Range.closedOpen(1, 4), - ContiguousSet.create(Range.openClosed(0, 3), integers()).range(CLOSED, OPEN)); + assertEquals(Ranges.closed(1, 3), Ranges.closed(1, 3).asSet(integers()).range()); + assertEquals(Ranges.closed(1, 3), Ranges.closedOpen(1, 4).asSet(integers()).range()); + assertEquals(Ranges.closed(1, 3), Ranges.open(0, 4).asSet(integers()).range()); + assertEquals(Ranges.closed(1, 3), Ranges.openClosed(0, 3).asSet(integers()).range()); + + assertEquals(Ranges.openClosed(0, 3), + Ranges.closed(1, 3).asSet(integers()).range(OPEN, CLOSED)); + assertEquals(Ranges.openClosed(0, 3), + Ranges.closedOpen(1, 4).asSet(integers()).range(OPEN, CLOSED)); + assertEquals(Ranges.openClosed(0, 3), Ranges.open(0, 4).asSet(integers()).range(OPEN, CLOSED)); + assertEquals(Ranges.openClosed(0, 3), + Ranges.openClosed(0, 3).asSet(integers()).range(OPEN, CLOSED)); + + assertEquals(Ranges.open(0, 4), Ranges.closed(1, 3).asSet(integers()).range(OPEN, OPEN)); + assertEquals(Ranges.open(0, 4), Ranges.closedOpen(1, 4).asSet(integers()).range(OPEN, OPEN)); + assertEquals(Ranges.open(0, 4), Ranges.open(0, 4).asSet(integers()).range(OPEN, OPEN)); + assertEquals(Ranges.open(0, 4), Ranges.openClosed(0, 3).asSet(integers()).range(OPEN, OPEN)); + + assertEquals(Ranges.closedOpen(1, 4), + Ranges.closed(1, 3).asSet(integers()).range(CLOSED, OPEN)); + assertEquals(Ranges.closedOpen(1, 4), + Ranges.closedOpen(1, 4).asSet(integers()).range(CLOSED, OPEN)); + assertEquals(Ranges.closedOpen(1, 4), Ranges.open(0, 4).asSet(integers()).range(CLOSED, OPEN)); + assertEquals(Ranges.closedOpen(1, 4), + Ranges.openClosed(0, 3).asSet(integers()).range(CLOSED, OPEN)); } - public void testRange_unboundedRange() { - assertEquals(Range.closed(Integer.MIN_VALUE, Integer.MAX_VALUE), - ContiguousSet.create(Range.<Integer>all(), integers()).range()); - assertEquals(Range.atLeast(Integer.MIN_VALUE), - ContiguousSet.create(Range.<Integer>all(), integers()).range(CLOSED, OPEN)); - assertEquals(Range.all(), - ContiguousSet.create(Range.<Integer>all(), integers()).range(OPEN, OPEN)); - assertEquals(Range.atMost(Integer.MAX_VALUE), - ContiguousSet.create(Range.<Integer>all(), integers()).range(OPEN, CLOSED)); + public void testRange_unboundedRanges() { + assertEquals(Ranges.closed(Integer.MIN_VALUE, Integer.MAX_VALUE), + Ranges.<Integer>all().asSet(integers()).range()); + assertEquals(Ranges.atLeast(Integer.MIN_VALUE), + Ranges.<Integer>all().asSet(integers()).range(CLOSED, OPEN)); + assertEquals(Ranges.all(), Ranges.<Integer>all().asSet(integers()).range(OPEN, OPEN)); + assertEquals(Ranges.atMost(Integer.MAX_VALUE), + Ranges.<Integer>all().asSet(integers()).range(OPEN, CLOSED)); } public void testIntersection_empty() { - ContiguousSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); - ContiguousSet<Integer> emptySet = ContiguousSet.create(Range.closedOpen(2, 2), integers()); + ContiguousSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); + ContiguousSet<Integer> emptySet = Ranges.closedOpen(2,2).asSet(integers()); assertEquals(ImmutableSet.of(), set.intersection(emptySet)); assertEquals(ImmutableSet.of(), emptySet.intersection(set)); - assertEquals(ImmutableSet.of(), - ContiguousSet.create(Range.closed(-5, -1), integers()).intersection( - ContiguousSet.create(Range.open(3, 64), integers()))); + assertEquals(ImmutableSet.of(), Ranges.closed(-5, -1).asSet(integers()).intersection( + Ranges.open(3, 64).asSet(integers()))); } public void testIntersection() { - ContiguousSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); - assertEquals(ImmutableSet.of(1, 2, 3), - ContiguousSet.create(Range.open(-1, 4), integers()).intersection(set)); - assertEquals(ImmutableSet.of(1, 2, 3), - set.intersection(ContiguousSet.create(Range.open(-1, 4), integers()))); - } - - @GwtIncompatible("suite") - public static class BuiltTests extends TestCase { - public static Test suite() { - TestSuite suite = new TestSuite(); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ContiguousSetGenerator()) - .named("Range.asSet") - .withFeatures(CollectionSize.ANY, KNOWN_ORDER, ALLOWS_NULL_QUERIES, - NON_STANDARD_TOSTRING, RESTRICTS_ELEMENTS) - .suppressing(getHoleMethods()) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ContiguousSetHeadsetGenerator()) - .named("Range.asSet, headset") - .withFeatures(CollectionSize.ANY, KNOWN_ORDER, ALLOWS_NULL_QUERIES, - NON_STANDARD_TOSTRING, RESTRICTS_ELEMENTS) - .suppressing(getHoleMethods()) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ContiguousSetTailsetGenerator()) - .named("Range.asSet, tailset") - .withFeatures(CollectionSize.ANY, KNOWN_ORDER, ALLOWS_NULL_QUERIES, - NON_STANDARD_TOSTRING, RESTRICTS_ELEMENTS) - .suppressing(getHoleMethods()) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ContiguousSetSubsetGenerator()) - .named("Range.asSet, subset") - .withFeatures(CollectionSize.ANY, KNOWN_ORDER, ALLOWS_NULL_QUERIES, - NON_STANDARD_TOSTRING, RESTRICTS_ELEMENTS) - .suppressing(getHoleMethods()) - .createTestSuite()); - - suite.addTest(NavigableSetTestSuiteBuilder.using( - new ContiguousSetDescendingGenerator()) - .named("Range.asSet.descendingSet") - .withFeatures(CollectionSize.ANY, KNOWN_ORDER, ALLOWS_NULL_QUERIES, - NON_STANDARD_TOSTRING, RESTRICTS_ELEMENTS) - .suppressing(getHoleMethods()) - .createTestSuite()); - - return suite; - } + ContiguousSet<Integer> set = Ranges.closed(1, 3).asSet(integers()); + assertEquals(ImmutableSet.of(1, 2, 3), Ranges.open(-1, 4).asSet(integers()).intersection(set)); + assertEquals(ImmutableSet.of(1, 2, 3), set.intersection(Ranges.open(-1, 4).asSet(integers()))); } } |