private void verify(Map<Integer, Integer> model, RangeMap<Integer, Integer> test) { for (int i = MIN_BOUND - 1; i <= MAX_BOUND + 1; i++) { assertEquals(model.get(i), test.get(i)); Entry<Range<Integer>, Integer> entry = test.getEntry(i); assertEquals(model.containsKey(i), entry != null); if (entry != null) { assertTrue(test.asMapOfRanges().entrySet().contains(entry)); } } for (Range<Integer> range : test.asMapOfRanges().keySet()) { assertFalse(range.isEmpty()); } }
public void testSpanTwoRanges() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(range1, 1); rangeMap.put(range2, 2); Range<Integer> expected; if (range1.isEmpty()) { if (range2.isEmpty()) { expected = null; } else { expected = range2; } } else { if (range2.isEmpty()) { expected = range1; } else { expected = range1.span(range2); } } try { assertEquals(expected, rangeMap.span()); assertNotNull(expected); } catch (NoSuchElementException e) { assertNull(expected); } } } }
rangeMap.put(Range.closed(12, 16), 3); RangeMap<Integer, Integer> sub = rangeMap.subRangeMap(Range.closed(5, 11)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub.asMapOfRanges()); sub.putCoalescing(Range.closed(7, 9), 2); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(7, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of(Range.open(3, 7), 1, Range.closed(7, 10), 2, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); assertEquals( ImmutableMap.of(Range.closed(5, 7), 1, Range.openClosed(7, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of( Range.open(3, 5), fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) {
public void testPutAndRemove() { for (Range<Integer> rangeToPut : RANGES) { for (Range<Integer> rangeToRemove : RANGES) { Map<Integer, Integer> model = Maps.newHashMap(); putModel(model, rangeToPut, 1); removeModel(model, rangeToRemove); RangeMap<Integer, Integer> test = TreeRangeMap.create(); test.put(rangeToPut, 1); test.remove(rangeToRemove); verify(model, test); } } }
public void testSubSubRangeMap() { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(Range.open(3, 7), 1); rangeMap.put(Range.closed(9, 10), 2); rangeMap.put(Range.closed(12, 16), 3); RangeMap<Integer, Integer> sub1 = rangeMap.subRangeMap(Range.closed(5, 11)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub1.asMapOfRanges()); RangeMap<Integer, Integer> sub2 = sub1.subRangeMap(Range.open(6, 15)); assertEquals( ImmutableMap.of(Range.open(6, 7), 1, Range.closed(9, 10), 2), sub2.asMapOfRanges()); }
public void testPutTwoAndRemove() { for (Range<Integer> rangeToPut1 : RANGES) { for (Range<Integer> rangeToPut2 : RANGES) { for (Range<Integer> rangeToRemove : RANGES) { Map<Integer, Integer> model = Maps.newHashMap(); putModel(model, rangeToPut1, 1); putModel(model, rangeToPut2, 2); removeModel(model, rangeToRemove); RangeMap<Integer, Integer> test = TreeRangeMap.create(); test.put(rangeToPut1, 1); test.put(rangeToPut2, 2); test.remove(rangeToRemove); verify(model, test); } } } }
public void testAllRangePairs() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { Map<Integer, Integer> model = Maps.newHashMap(); putModel(model, range1, 1); putModel(model, range2, 2); RangeMap<Integer, Integer> test = TreeRangeMap.create(); test.put(range1, 1); test.put(range2, 2); verify(model, test); } } }
public void testSubRangeMapClear() { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(Range.open(3, 7), 1); rangeMap.put(Range.closed(9, 10), 2); rangeMap.put(Range.closed(12, 16), 3); RangeMap<Integer, Integer> sub = rangeMap.subRangeMap(Range.closed(5, 11)); sub.clear(); assertEquals( ImmutableMap.of(Range.open(3, 5), 1, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); }
public void testPutCoalescingTwoAndRemove() { for (Range<Integer> rangeToPut1 : RANGES) { for (Range<Integer> rangeToPut2 : RANGES) { for (Range<Integer> rangeToRemove : RANGES) { Map<Integer, Integer> model = Maps.newHashMap(); putModel(model, rangeToPut1, 1); putModel(model, rangeToPut2, 2); removeModel(model, rangeToRemove); RangeMap<Integer, Integer> test = TreeRangeMap.create(); test.putCoalescing(rangeToPut1, 1); test.putCoalescing(rangeToPut2, 2); test.remove(rangeToRemove); verify(model, test); } } } }
public void testSpanSingleRange() { for (Range<Integer> range : RANGES) { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(range, 1); try { assertEquals(range, rangeMap.span()); assertFalse(range.isEmpty()); } catch (NoSuchElementException e) { assertTrue(range.isEmpty()); } } }
public void testAllRangeTriples() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { for (Range<Integer> range3 : RANGES) { Map<Integer, Integer> model = Maps.newHashMap(); putModel(model, range1, 1); putModel(model, range2, 2); putModel(model, range3, 3); RangeMap<Integer, Integer> test = TreeRangeMap.create(); test.put(range1, 1); test.put(range2, 2); test.put(range3, 3); verify(model, test); } } } }
public void testSpanTwoRanges() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(range1, 1); rangeMap.put(range2, 2); Range<Integer> expected; if (range1.isEmpty()) { if (range2.isEmpty()) { expected = null; } else { expected = range2; } } else { if (range2.isEmpty()) { expected = range1; } else { expected = range1.span(range2); } } try { assertEquals(expected, rangeMap.span()); assertNotNull(expected); } catch (NoSuchElementException e) { assertNull(expected); } } } }
rangeMap.put(Range.closed(12, 16), 3); RangeMap<Integer, Integer> sub = rangeMap.subRangeMap(Range.closed(5, 11)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub.asMapOfRanges()); sub.put(Range.closed(7, 9), 4); assertEquals( ImmutableMap.of( Range.closedOpen(5, 7), 1, Range.closed(7, 9), 4, Range.openClosed(9, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of( Range.open(3, 7), fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { assertEquals( ImmutableMap.of( Range.open(3, 7),
public void testSubRangeMapRemove() { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(Range.open(3, 7), 1); rangeMap.put(Range.closed(9, 10), 2); rangeMap.put(Range.closed(12, 16), 3); RangeMap<Integer, Integer> sub = rangeMap.subRangeMap(Range.closed(5, 11)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub.asMapOfRanges()); sub.remove(Range.closed(7, 9)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.openClosed(9, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of(Range.open(3, 7), 1, Range.openClosed(9, 10), 2, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); sub.remove(Range.closed(3, 9)); assertEquals(ImmutableMap.of(Range.openClosed(9, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of(Range.open(3, 5), 1, Range.openClosed(9, 10), 2, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); }
public void testPutAndRemove() { for (Range<Integer> rangeToPut : RANGES) { for (Range<Integer> rangeToRemove : RANGES) { Map<Integer, Integer> model = Maps.newHashMap(); putModel(model, rangeToPut, 1); removeModel(model, rangeToRemove); RangeMap<Integer, Integer> test = TreeRangeMap.create(); test.put(rangeToPut, 1); test.remove(rangeToRemove); verify(model, test); } } }
private void verify(Map<Integer, Integer> model, RangeMap<Integer, Integer> test) { for (int i = MIN_BOUND - 1; i <= MAX_BOUND + 1; i++) { assertEquals(model.get(i), test.get(i)); Map.Entry<Range<Integer>, Integer> entry = test.getEntry(i); assertEquals(model.containsKey(i), entry != null); if (entry != null) { assertTrue(test.asMapOfRanges().entrySet().contains(entry)); } } for (Range<Integer> range : test.asMapOfRanges().keySet()) { assertFalse(range.isEmpty()); } }
public void testPutAll() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { for (Range<Integer> range3 : RANGES) { Map<Integer, Integer> model = Maps.newHashMap(); putModel(model, range1, 1); putModel(model, range2, 2); putModel(model, range3, 3); RangeMap<Integer, Integer> test = TreeRangeMap.create(); RangeMap<Integer, Integer> test2 = TreeRangeMap.create(); // put range2 and range3 into test2, and then put test2 into test test.put(range1, 1); test2.put(range2, 2); test2.put(range3, 3); test.putAll(test2); verify(model, test); } } } }
rangeMap.put(Range.closed(12, 16), 3); RangeMap<Integer, Integer> sub = rangeMap.subRangeMap(Range.closed(5, 11)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub.asMapOfRanges()); sub.putCoalescing(Range.closed(7, 9), 2); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(7, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of(Range.open(3, 7), 1, Range.closed(7, 10), 2, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); assertEquals( ImmutableMap.of(Range.closed(5, 7), 1, Range.openClosed(7, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of( Range.open(3, 5), fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) {
assertEquals(expected, subRangeMap); assertEquals(expected.asMapOfRanges(), subRangeMap.asMapOfRanges()); assertEquals(expected.asDescendingMapOfRanges(), subRangeMap.asDescendingMapOfRanges()); assertEquals( ImmutableList.copyOf(subRangeMap.asMapOfRanges().entrySet()).reverse(), ImmutableList.copyOf(subRangeMap.asDescendingMapOfRanges().entrySet())); assertEquals(expected.span(), subRangeMap.span()); assertEquals(expected.get(i), subRangeMap.get(i)); assertEquals( expected.asMapOfRanges().get(query), subRangeMap.asMapOfRanges().get(query));