/** * Returns a contiguous set containing all {@code int} values from {@code lower} (inclusive) to * {@code upper} (exclusive). If the endpoints are equal, an empty set is returned. (These are the * same values contained in {@code Range.closedOpen(lower, upper)}.) * * @throws IllegalArgumentException if {@code lower} is greater than {@code upper} * @since 23.0 */ @Beta public static ContiguousSet<Integer> closedOpen(int lower, int upper) { return create(Range.closedOpen(lower, upper), DiscreteDomain.integers()); }
/** * Returns a contiguous set containing all {@code long} values from {@code lower} (inclusive) to * {@code upper} (exclusive). If the endpoints are equal, an empty set is returned. (These are the * same values contained in {@code Range.closedOpen(lower, upper)}.) * * @throws IllegalArgumentException if {@code lower} is greater than {@code upper} * @since 23.0 */ @Beta public static ContiguousSet<Long> closedOpen(long lower, long upper) { return create(Range.closedOpen(lower, upper), DiscreteDomain.longs()); }
public void testPutCoalescingEmpty() { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(Range.closedOpen(0, 1), 1); rangeMap.put(Range.closedOpen(1, 2), 1); assertEquals( ImmutableMap.of(Range.closedOpen(0, 1), 1, Range.closedOpen(1, 2), 1), rangeMap.asMapOfRanges()); rangeMap.putCoalescing(Range.closedOpen(1, 1), 1); // empty range coalesces connected ranges assertEquals(ImmutableMap.of(Range.closedOpen(0, 2), 1), rangeMap.asMapOfRanges()); }
public void testFillHoleWithOverlap() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closedOpen(1, 3)); rangeSet.add(Range.closedOpen(4, 6)); rangeSet.add(Range.closedOpen(2, 5)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.closedOpen(1, 6)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(1), Range.atLeast(6)) .inOrder(); }
public void testFillHoleExactly() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closedOpen(1, 3)); rangeSet.add(Range.closedOpen(4, 6)); rangeSet.add(Range.closedOpen(3, 4)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.closedOpen(1, 6)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(1), Range.atLeast(6)) .inOrder(); }
public void testRemoveAll() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); rangeSet.removeAll(Arrays.asList(Range.open(1, 3), Range.closed(5, 8), Range.closed(9, 11))); assertThat(rangeSet.asRanges()) .containsExactly(Range.closedOpen(3, 5), Range.open(8, 9)) .inOrder(); }
public void testRemoveNoOverlap() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 6)); rangeSet.remove(Range.closedOpen(1, 3)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).containsExactly(Range.closed(3, 6)); }
public void testToImmutableRangeSet() { Range<Integer> rangeOne = Range.closedOpen(1, 5); Range<Integer> rangeTwo = Range.openClosed(6, 7); ImmutableRangeSet<Integer> ranges = ImmutableRangeSet.copyOf(ImmutableList.of(rangeOne, rangeTwo)); CollectorTester.of(ImmutableRangeSet.<Integer>toImmutableRangeSet()) .expectCollects(ranges, rangeOne, rangeTwo); } }
public void testGetLargeRangeMap() { ImmutableRangeMap.Builder<Integer, Integer> builder = ImmutableRangeMap.builder(); for (int i = 0; i < 100; i++) { builder.put(Range.closedOpen(i, i + 1), i); } ImmutableRangeMap<Integer, Integer> map = builder.build(); for (int i = 0; i < 100; i++) { assertEquals(Integer.valueOf(i), map.get(i)); } }
public void testRemoveMiddle() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.atMost(6)); rangeSet.remove(Range.closedOpen(3, 4)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()) .containsExactly(Range.lessThan(3), Range.closed(4, 6)) .inOrder(); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.closedOpen(3, 4), Range.greaterThan(6)) .inOrder(); }
public void testUnion() { RangeSet<Integer> expected = ImmutableRangeSet.<Integer>builder() .add(Range.openClosed(0, 4)) .add(Range.closedOpen(5, 10)) .add(Range.closedOpen(12, 15)) .add(Range.openClosed(15, 17)) .add(Range.open(19, 20)) .build(); assertThat(RANGE_SET_ONE.union(RANGE_SET_TWO)).isEqualTo(expected); }
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 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 testRemovePartSharingLowerBound() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 5)); rangeSet.remove(Range.closedOpen(3, 5)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.singleton(5)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(5), Range.greaterThan(5)) .inOrder(); }
public void testMergesConnectedDisjoint() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(1, 4)); rangeSet.add(Range.open(4, 6)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.closedOpen(1, 6)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(1), Range.atLeast(6)) .inOrder(); }
@Override public SampleElements<Entry<Range<Integer>, String>> samples() { return new SampleElements<>( mapEntry(Range.singleton(0), "banana"), mapEntry(Range.closedOpen(3, 5), "frisbee"), mapEntry(Range.atMost(-1), "fruitcake"), mapEntry(Range.open(10, 15), "elephant"), mapEntry(Range.closed(20, 22), "umbrella")); }
@Override public SampleElements<Entry<Range<Integer>, String>> samples() { return new SampleElements<>( mapEntry(Range.singleton(0), "banana"), mapEntry(Range.closedOpen(3, 5), "frisbee"), mapEntry(Range.atMost(-1), "fruitcake"), mapEntry(Range.open(10, 15), "elephant"), mapEntry(Range.closed(20, 22), "umbrella")); }
@Override public SampleElements<Entry<Range<Integer>, String>> samples() { return new SampleElements<>( mapEntry(Range.singleton(0), "banana"), mapEntry(Range.closedOpen(3, 5), "frisbee"), mapEntry(Range.atMost(-1), "fruitcake"), mapEntry(Range.open(10, 15), "elephant"), mapEntry(Range.closed(20, 22), "umbrella")); }
public void testGap_connectedAdjacentYieldsEmpty() { Range<Integer> range = Range.open(3, 4); assertEquals(Range.closedOpen(4, 4), range.gap(Range.atLeast(4))); assertEquals(Range.openClosed(3, 3), range.gap(Range.atMost(3))); }
public void testToImmutableRangeSet() { Range<Integer> rangeOne = Range.closedOpen(1, 5); Range<Integer> rangeTwo = Range.openClosed(6, 7); ImmutableRangeMap<Integer, Integer> rangeMap = new ImmutableRangeMap.Builder<Integer, Integer>().put(rangeOne, 1).put(rangeTwo, 6).build(); CollectorTester.of( ImmutableRangeMap.<Range<Integer>, Integer, Integer>toImmutableRangeMap( k -> k, k -> k.lowerEndpoint())) .expectCollects(rangeMap, rangeOne, rangeTwo); } }