public void testRangeContaining1() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); assertEquals(Range.closed(3, 10), rangeSet.rangeContaining(5)); assertTrue(rangeSet.contains(5)); assertNull(rangeSet.rangeContaining(1)); assertFalse(rangeSet.contains(1)); }
public void testSubRangeSetOfComplement() { for (Range<Integer> range1 : QUERY_RANGES) { for (Range<Integer> range2 : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range1); rangeSet.add(range2); for (Range<Integer> subRange : QUERY_RANGES) { testViewAgainstExpected( expectedSubRangeSet(expectedComplement(rangeSet), subRange), rangeSet.complement().subRangeSet(subRange)); } } } }
void testViewAgainstExpected(RangeSet<Integer> expected, RangeSet<Integer> view) { assertEquals(expected, view); assertEquals(expected.asRanges(), view.asRanges()); assertEquals(expected.isEmpty(), view.isEmpty()); if (!expected.isEmpty()) { assertEquals(expected.span(), view.span()); } for (int i = MIN_BOUND - 1; i <= MAX_BOUND + 1; i++) { assertEquals(expected.contains(i), view.contains(i)); assertEquals(expected.rangeContaining(i), view.rangeContaining(i)); } testEnclosing(view); if (view instanceof TreeRangeSet) { testRangesByLowerBounds((TreeRangeSet<Integer>) view, expected.asRanges()); } }
public void testInvariantsEmpty() { testInvariants(TreeRangeSet.create()); }
public void testComplement() { for (Range<Integer> range1 : QUERY_RANGES) { for (Range<Integer> range2 : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range1); rangeSet.add(range2); testViewAgainstExpected(expectedComplement(rangeSet), rangeSet.complement()); } } }
public void testCreateCopy() { for (Range<Integer> range1 : QUERY_RANGES) { for (Range<Integer> range2 : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range1); rangeSet.add(range2); assertEquals(rangeSet, TreeRangeSet.create(rangeSet)); } } }
public void testSubRangeSet() { for (Range<Integer> range1 : QUERY_RANGES) { for (Range<Integer> range2 : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range1); rangeSet.add(range2); for (Range<Integer> subRange : QUERY_RANGES) { testViewAgainstExpected( expectedSubRangeSet(rangeSet, subRange), rangeSet.subRangeSet(subRange)); } } } }
public void testEnclosing(RangeSet<Integer> rangeSet) { assertTrue(rangeSet.enclosesAll(ImmutableList.<Range<Integer>>of())); for (Range<Integer> query : QUERY_RANGES) { boolean expectEnclose = false; for (Range<Integer> expectedRange : rangeSet.asRanges()) { if (expectedRange.encloses(query)) { expectEnclose = true; break; } } assertEquals( rangeSet + " was incorrect on encloses(" + query + ")", expectEnclose, rangeSet.encloses(query)); assertEquals( rangeSet + " was incorrect on enclosesAll([" + query + "])", expectEnclose, rangeSet.enclosesAll(ImmutableList.of(query))); } }
public void testAllSingleRangesIntersecting() { for (Range<Integer> range : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range); testIntersects(rangeSet); testIntersects(rangeSet.complement()); } }
public void testAllSingleRangesEnclosing() { for (Range<Integer> range : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range); testEnclosing(rangeSet); testEnclosing(rangeSet.complement()); } }
public void testAddManyPairs() { for (int aLow = 0; aLow < 6; aLow++) { for (int aHigh = 0; aHigh < 6; aHigh++) { for (BoundType aLowType : BoundType.values()) { for (BoundType aHighType : BoundType.values()) { if ((aLow == aHigh && aLowType == OPEN && aHighType == OPEN) || aLow > aHigh) { continue; } for (int bLow = 0; bLow < 6; bLow++) { for (int bHigh = 0; bHigh < 6; bHigh++) { for (BoundType bLowType : BoundType.values()) { for (BoundType bHighType : BoundType.values()) { if ((bLow == bHigh && bLowType == OPEN && bHighType == OPEN) || bLow > bHigh) { continue; } doPairTest( range(aLow, aLowType, aHigh, aHighType), range(bLow, bLowType, bHigh, bHighType)); } } } } } } } } }
public void testRemoveExact() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 6)); rangeSet.remove(Range.closed(3, 6)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).isEmpty(); }
public void testComplement() { for (Range<Integer> range1 : QUERY_RANGES) { for (Range<Integer> range2 : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range1); rangeSet.add(range2); testViewAgainstExpected(expectedComplement(rangeSet), rangeSet.complement()); } } }
<K, V> void testNavigationAgainstExpected( NavigableMap<K, V> expected, NavigableMap<K, V> navigableMap, Iterable<K> keysToTest) { for (K key : keysToTest) { assertEquals(expected.lowerEntry(key), navigableMap.lowerEntry(key)); assertEquals(expected.floorEntry(key), navigableMap.floorEntry(key)); assertEquals(expected.ceilingEntry(key), navigableMap.ceilingEntry(key)); assertEquals(expected.higherEntry(key), navigableMap.higherEntry(key)); for (boolean inclusive : new boolean[] {false, true}) { assertThat(navigableMap.headMap(key, inclusive).entrySet()) .containsExactlyElementsIn(expected.headMap(key, inclusive).entrySet()) .inOrder(); assertThat(navigableMap.tailMap(key, inclusive).entrySet()) .containsExactlyElementsIn(expected.tailMap(key, inclusive).entrySet()) .inOrder(); assertThat(navigableMap.headMap(key, inclusive).descendingMap().entrySet()) .containsExactlyElementsIn(expected.headMap(key, inclusive).descendingMap().entrySet()) .inOrder(); assertThat(navigableMap.tailMap(key, inclusive).descendingMap().entrySet()) .containsExactlyElementsIn(expected.tailMap(key, inclusive).descendingMap().entrySet()) .inOrder(); } } }
public void testSubRangeSet() { for (Range<Integer> range1 : QUERY_RANGES) { for (Range<Integer> range2 : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range1); rangeSet.add(range2); for (Range<Integer> subRange : QUERY_RANGES) { testViewAgainstExpected( expectedSubRangeSet(rangeSet, subRange), rangeSet.subRangeSet(subRange)); } } } }
public void testEnclosing(RangeSet<Integer> rangeSet) { assertTrue(rangeSet.enclosesAll(ImmutableList.<Range<Integer>>of())); for (Range<Integer> query : QUERY_RANGES) { boolean expectEnclose = false; for (Range<Integer> expectedRange : rangeSet.asRanges()) { if (expectedRange.encloses(query)) { expectEnclose = true; break; } } assertEquals(rangeSet + " was incorrect on encloses(" + query + ")", expectEnclose, rangeSet.encloses(query)); assertEquals( rangeSet + " was incorrect on enclosesAll([" + query + "])", expectEnclose, rangeSet.enclosesAll(ImmutableList.of(query))); } }
public void testEmptyIntersecting() { testIntersects(TreeRangeSet.<Integer>create()); testIntersects(TreeRangeSet.<Integer>create().complement()); }
public void testEmptyEnclosing() { testEnclosing(TreeRangeSet.<Integer>create()); testEnclosing(TreeRangeSet.<Integer>create().complement()); }
public void testAddManyPairs() { for (int aLow = 0; aLow < 6; aLow++) { for (int aHigh = 0; aHigh < 6; aHigh++) { for (BoundType aLowType : BoundType.values()) { for (BoundType aHighType : BoundType.values()) { if ((aLow == aHigh && aLowType == OPEN && aHighType == OPEN) || aLow > aHigh) { continue; } for (int bLow = 0; bLow < 6; bLow++) { for (int bHigh = 0; bHigh < 6; bHigh++) { for (BoundType bLowType : BoundType.values()) { for (BoundType bHighType : BoundType.values()) { if ((bLow == bHigh && bLowType == OPEN && bHighType == OPEN) || bLow > bHigh) { continue; } doPairTest(range(aLow, aLowType, aHigh, aHighType), range(bLow, bLowType, bHigh, bHighType)); } } } } } } } } }
public void testRangeContaining2() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); rangeSet.remove(Range.open(5, 7)); assertEquals(Range.closed(3, 5), rangeSet.rangeContaining(5)); assertTrue(rangeSet.contains(5)); assertEquals(Range.closed(7, 10), rangeSet.rangeContaining(8)); assertTrue(rangeSet.contains(8)); assertNull(rangeSet.rangeContaining(6)); assertFalse(rangeSet.contains(6)); }