@Override public Map<Range<Integer>, String> create(Object... elements) { RangeMap<Integer, String> rangeMap = TreeRangeMap.create(); for (Object o : elements) { @SuppressWarnings("unchecked") Entry<Range<Integer>, String> entry = (Entry<Range<Integer>, String>) o; rangeMap.put(entry.getKey(), entry.getValue()); } return rangeMap.asMapOfRanges(); }
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); } } } }
@Override public Map<Range<Integer>, String> create(Object... elements) { RangeMap<Integer, String> rangeMap = TreeRangeMap.create(); for (Object o : elements) { @SuppressWarnings("unchecked") Entry<Range<Integer>, String> entry = (Entry<Range<Integer>, String>) o; rangeMap.put(entry.getKey(), entry.getValue()); } return rangeMap.asDescendingMapOfRanges(); }
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 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 testSubRangeMapPutCoalescing() { 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(
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 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 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 testAllRangesAlone() { for (Range<Integer> range : RANGES) { Map<Integer, Integer> model = Maps.newHashMap(); putModel(model, range, 1); RangeMap<Integer, Integer> test = TreeRangeMap.create(); test.put(range, 1); verify(model, test); } }
@Override public Map<Range<Integer>, String> create(Object... elements) { RangeMap<Integer, String> rangeMap = TreeRangeMap.create(); for (Object o : elements) { @SuppressWarnings("unchecked") Entry<Range<Integer>, String> entry = (Entry<Range<Integer>, String>) o; rangeMap.put(entry.getKey(), entry.getValue()); } return rangeMap.subRangeMap(Range.atMost(22)).asDescendingMapOfRanges(); }
@Override public Map<Range<Integer>, String> create(Object... elements) { RangeMap<Integer, String> rangeMap = TreeRangeMap.create(); for (Object o : elements) { @SuppressWarnings("unchecked") Entry<Range<Integer>, String> entry = (Entry<Range<Integer>, String>) o; rangeMap.put(entry.getKey(), entry.getValue()); } return rangeMap.subRangeMap(Range.atMost(22)).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 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 testSubRangeMapPut() { 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.put(Range.closed(7, 9), 4); assertEquals( ImmutableMap.of( sub.put(Range.open(9, 12), 5); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { sub.put(Range.closedOpen(5, 5), 6); // should be a no-op assertEquals( ImmutableMap.of(
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()); }
for (Range<Integer> range2 : RANGES) { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(range1, 1); rangeMap.put(range2, 2); for (Entry<Range<Integer>, Integer> entry : rangeMap.asMapOfRanges().entrySet()) { if (entry.getKey().isConnected(subRange)) { expected.put(entry.getKey().intersection(subRange), entry.getValue());
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); } } } }
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()); } } }