Object readResolve() { if (this.equals(ALL)) { return all(); } else { return this; } }
@Override public void clear() { remove(Range.<C>all()); }
@Empty private static <C extends Comparable<?>> Range<C> generateRange() { return Range.all(); }
@Override public boolean isEmpty() { return upperBoundWindow.equals(Range.all()) ? rangesByLowerBound.isEmpty() : !entryIterator().hasNext(); } }
Object readResolve() { if (ranges.isEmpty()) { return of(); } else if (ranges.equals(ImmutableList.of(Range.all()))) { return all(); } else { return new ImmutableRangeSet<C>(ranges); } } }
@Override public RangeMap<K, V> subRangeMap(Range<K> subRange) { if (subRange.equals(Range.all())) { return this; } else { return new SubRangeMap(subRange); } }
@Override public RangeSet<C> subRangeSet(Range<C> view) { return view.equals(Range.<C>all()) ? this : new SubRangeSet(view); }
@Override public int size() { if (upperBoundWindow.equals(Range.all())) { return rangesByLowerBound.size(); } return Iterators.size(entryIterator()); }
private RangeSet<Integer> expectedComplement(RangeSet<Integer> rangeSet) { RangeSet<Integer> expected = TreeRangeSet.create(); expected.add(Range.<Integer>all()); expected.removeAll(rangeSet); return expected; }
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)); }
@GwtIncompatible // NavigableSet public void testSubSet_unboundedRange() { ImmutableSortedSet<Integer> set = ImmutableSortedSet.of(2, 4, 6, 8, 10); assertEquals(set, Sets.subSet(set, Range.<Integer>all())); }
@GwtIncompatible // NavigableMap public void testSubMap_unboundedRange() { ImmutableSortedMap<Integer, Integer> map = ImmutableSortedMap.of(2, 0, 4, 0, 6, 0, 8, 0, 10, 0); assertEquals(map, Maps.subMap(map, Range.<Integer>all())); }
public void testAll() { Range<Integer> range = Range.all(); assertTrue(range.contains(Integer.MIN_VALUE)); assertTrue(range.contains(Integer.MAX_VALUE)); assertUnboundedBelow(range); assertUnboundedAbove(range); assertFalse(range.isEmpty()); assertEquals("(-\u221e..+\u221e)", range.toString()); assertSame(range, reserializeAndAssert(range)); assertSame(range, Range.all()); }
public void testAddEmpty() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closedOpen(3, 3)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).isEmpty(); assertThat(rangeSet.complement().asRanges()).containsExactly(Range.<Integer>all()); }
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 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 testAll() { ImmutableRangeSet<Integer> rangeSet = ImmutableRangeSet.all(); assertThat(rangeSet.asRanges()).contains(Range.<Integer>all()); assertTrue(rangeSet.contains(0)); assertTrue(rangeSet.intersects(Range.singleton(0))); assertTrue(rangeSet.intersects(Range.<Integer>all())); assertTrue(rangeSet.encloses(Range.<Integer>all())); assertTrue(rangeSet.enclosesAll(rangeSet)); assertEquals(ImmutableRangeSet.<Integer>of(), rangeSet.complement()); }
public void testNullPointers() { NullPointerTester tester = new NullPointerTester(); tester.testAllPublicStaticMethods(Range.class); tester.testAllPublicStaticMethods(Range.class); tester.testAllPublicInstanceMethods(Range.all()); tester.testAllPublicInstanceMethods(Range.open(1, 3)); } }
public void testCanonical_unboundedDomain() { assertEquals(Range.lessThan(0), Range.lessThan(0).canonical(UNBOUNDED_DOMAIN)); assertEquals(Range.lessThan(1), Range.atMost(0).canonical(UNBOUNDED_DOMAIN)); assertEquals(Range.atLeast(0), Range.atLeast(0).canonical(UNBOUNDED_DOMAIN)); assertEquals(Range.atLeast(1), Range.greaterThan(0).canonical(UNBOUNDED_DOMAIN)); assertEquals(Range.all(), Range.<Integer>all().canonical(UNBOUNDED_DOMAIN)); }