public void testAsList() { ImmutableList<Integer> list = ContiguousSet.create(Range.closed(1, 3), integers()).asList(); for (int i = 0; i < 3; i++) { assertEquals(i + 1, list.get(i).intValue()); } assertEquals(ImmutableList.of(1, 2, 3), ImmutableList.copyOf(list.iterator())); assertEquals(ImmutableList.of(1, 2, 3), ImmutableList.copyOf(list.toArray(new Integer[0]))); }
public void testContains() { ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), 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()); assertFalse(set.contains(0)); assertTrue(set.contains(1)); assertTrue(set.contains(2)); assertTrue(set.contains(3)); assertFalse(set.contains(4)); assertFalse(set.contains((Object) "blah")); }
@GwtIncompatible // SerializableTester public void testSerialization() { ContiguousSet<Integer> empty = ContiguousSet.create(Range.closedOpen(1, 1), integers()); assertTrue(empty instanceof EmptyContiguousSet); reserializeAndAssert(empty); ContiguousSet<Integer> regular = ContiguousSet.create(Range.closed(1, 3), integers()); assertTrue(regular instanceof RegularContiguousSet); reserializeAndAssert(regular); /* * 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()); assertTrue(enormous instanceof RegularContiguousSet); // We can't use reserializeAndAssert because it calls hashCode, which is enormously slow. ContiguousSet<Integer> enormousReserialized = reserialize(enormous); assertEquals(enormous, enormousReserialized); }
@GwtIncompatible // SerializableTester public void testSerialization() { ContiguousSet<Integer> empty = ContiguousSet.create(Range.closedOpen(1, 1), integers()); assertTrue(empty instanceof EmptyContiguousSet); reserializeAndAssert(empty); ContiguousSet<Integer> regular = ContiguousSet.create(Range.closed(1, 3), integers()); assertTrue(regular instanceof RegularContiguousSet); reserializeAndAssert(regular); /* * 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()); assertTrue(enormous instanceof RegularContiguousSet); // We can't use reserializeAndAssert because it calls hashCode, which is enormously slow. ContiguousSet<Integer> enormousReserialized = reserialize(enormous); assertEquals(enormous, enormousReserialized); }
public void testCreate_empty() { assertEquals(ImmutableSet.of(), ContiguousSet.create(Range.closedOpen(1, 1), integers())); assertEquals(ImmutableSet.of(), ContiguousSet.closedOpen(1, 1)); assertEquals(ImmutableSet.of(), ContiguousSet.create(Range.openClosed(5, 5), integers())); assertEquals( ImmutableSet.of(), ContiguousSet.create(Range.lessThan(Integer.MIN_VALUE), integers())); assertEquals( ImmutableSet.of(), ContiguousSet.create(Range.greaterThan(Integer.MAX_VALUE), integers())); }
public void testContainsAll() { ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) { assertTrue(set.containsAll(subset)); } for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) { assertFalse(set.containsAll(Sets.union(subset, ImmutableSet.of(9)))); } assertFalse(set.containsAll((Collection<?>) ImmutableSet.of("blah"))); }
public void testIntersection_empty() { ContiguousSet<Integer> set = ContiguousSet.closed(1, 3); ContiguousSet<Integer> emptySet = ContiguousSet.closedOpen(2, 2); 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()))); }
public void testContainsAll() { ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) { assertTrue(set.containsAll(subset)); } for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) { assertFalse(set.containsAll(Sets.union(subset, ImmutableSet.of(9)))); } assertFalse(set.containsAll((Collection<?>) ImmutableSet.of("blah"))); }
public void testCreate_noMax() { Range<Integer> range = Range.greaterThan(0); try { ContiguousSet.create(range, RangeTest.UNBOUNDED_DOMAIN); 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()); }
public void testContains() { ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), 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()); assertFalse(set.contains(0)); assertTrue(set.contains(1)); assertTrue(set.contains(2)); assertTrue(set.contains(3)); assertFalse(set.contains(4)); assertFalse(set.contains((Object) "blah")); }
public void testCreate_noMin() { Range<Integer> range = Range.lessThan(0); try { ContiguousSet.create(range, RangeTest.UNBOUNDED_DOMAIN); fail(); } catch (IllegalArgumentException expected) { } }
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()); }
public void testSubSet_outOfOrder() { ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); try { set.subSet(3, 2); fail(); } catch (IllegalArgumentException expected) { } }
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()))); assertEquals( ImmutableSet.of(3), set.intersection(ContiguousSet.create(Range.closed(3, 5), integers()))); }
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)); }