| /* |
| * Copyright (C) 2012 The Guava Authors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except |
| * in compliance with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software distributed under the License |
| * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express |
| * or implied. See the License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| |
| package com.google.common.collect; |
| |
| import static com.google.common.collect.BoundType.OPEN; |
| |
| import com.google.common.annotations.GwtIncompatible; |
| |
| import junit.framework.TestCase; |
| |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.NoSuchElementException; |
| |
| /** |
| * Tests for {@code ImmutableRangeMap}. |
| * |
| * @author Louis Wasserman |
| */ |
| @GwtIncompatible("NavigableMap") |
| public class ImmutableRangeMapTest extends TestCase { |
| private static final ImmutableList<Range<Integer>> RANGES; |
| private static final int MIN_BOUND = 0; |
| private static final int MAX_BOUND = 10; |
| static { |
| ImmutableList.Builder<Range<Integer>> builder = ImmutableList.builder(); |
| |
| builder.add(Range.<Integer>all()); |
| |
| // Add one-ended ranges |
| for (int i = MIN_BOUND; i <= MAX_BOUND; i++) { |
| for (BoundType type : BoundType.values()) { |
| builder.add(Range.upTo(i, type)); |
| builder.add(Range.downTo(i, type)); |
| } |
| } |
| |
| // Add two-ended ranges |
| for (int i = MIN_BOUND; i <= MAX_BOUND; i++) { |
| for (int j = i + 1; j <= MAX_BOUND; j++) { |
| for (BoundType lowerType : BoundType.values()) { |
| for (BoundType upperType : BoundType.values()) { |
| if (i == j & lowerType == OPEN & upperType == OPEN) { |
| continue; |
| } |
| builder.add(Range.range(i, lowerType, j, upperType)); |
| } |
| } |
| } |
| } |
| RANGES = builder.build(); |
| } |
| |
| public void testBuilderRejectsEmptyRanges() { |
| for (int i = MIN_BOUND; i <= MAX_BOUND; i++) { |
| ImmutableRangeMap.Builder<Integer, Integer> builder = ImmutableRangeMap.builder(); |
| try { |
| builder.put(Range.closedOpen(i, i), 1); |
| fail("Expected IllegalArgumentException"); |
| } catch (IllegalArgumentException expected) { |
| // success |
| } |
| try { |
| builder.put(Range.openClosed(i, i), 1); |
| fail("Expected IllegalArgumentException"); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| } |
| |
| public void testOverlapRejection() { |
| for (Range<Integer> range1 : RANGES) { |
| for (Range<Integer> range2 : RANGES) { |
| boolean expectRejection = |
| range1.isConnected(range2) && !range1.intersection(range2).isEmpty(); |
| ImmutableRangeMap.Builder<Integer, Integer> builder = ImmutableRangeMap.builder(); |
| builder.put(range1, 1); |
| try { |
| builder.put(range2, 2); |
| assertFalse(expectRejection); |
| } catch (IllegalArgumentException e) { |
| assertTrue(expectRejection); |
| } |
| } |
| } |
| } |
| |
| public void testGet() { |
| for (Range<Integer> range1 : RANGES) { |
| for (Range<Integer> range2 : RANGES) { |
| if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { |
| ImmutableRangeMap<Integer, Integer> rangeMap = |
| ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); |
| |
| for (int i = MIN_BOUND; i <= MAX_BOUND; i++) { |
| Integer expectedValue = null; |
| if (range1.contains(i)) { |
| expectedValue = 1; |
| } else if (range2.contains(i)) { |
| expectedValue = 2; |
| } |
| |
| assertEquals(expectedValue, rangeMap.get(i)); |
| } |
| } |
| } |
| } |
| } |
| |
| public void testSpanEmpty() { |
| try { |
| ImmutableRangeMap.of().span(); |
| fail("Expected NoSuchElementException"); |
| } catch (NoSuchElementException expected) { |
| } |
| } |
| |
| public void testSpanSingleRange() { |
| for (Range<Integer> range : RANGES) { |
| RangeMap<Integer, Integer> rangemap = |
| ImmutableRangeMap.<Integer, Integer>builder().put(range, 1).build(); |
| assertEquals(range, rangemap.span()); |
| } |
| } |
| |
| public void testSpanTwoRanges() { |
| for (Range<Integer> range1 : RANGES) { |
| for (Range<Integer> range2 : RANGES) { |
| if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { |
| RangeMap<Integer, Integer> rangemap = |
| ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); |
| assertEquals(range1.span(range2), rangemap.span()); |
| } |
| } |
| } |
| } |
| |
| public void testGetEntry() { |
| for (Range<Integer> range1 : RANGES) { |
| for (Range<Integer> range2 : RANGES) { |
| if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { |
| ImmutableRangeMap<Integer, Integer> rangeMap = |
| ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); |
| |
| for (int i = MIN_BOUND; i <= MAX_BOUND; i++) { |
| Entry<Range<Integer>, Integer> expectedEntry = null; |
| if (range1.contains(i)) { |
| expectedEntry = Maps.immutableEntry(range1, 1); |
| } else if (range2.contains(i)) { |
| expectedEntry = Maps.immutableEntry(range2, 2); |
| } |
| |
| assertEquals(expectedEntry, rangeMap.getEntry(i)); |
| } |
| } |
| } |
| } |
| } |
| |
| 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 testAsMapOfRanges() { |
| for (Range<Integer> range1 : RANGES) { |
| for (Range<Integer> range2 : RANGES) { |
| if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { |
| ImmutableRangeMap<Integer, Integer> rangeMap = |
| ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); |
| |
| ImmutableMap<Range<Integer>, Integer> expectedAsMap = |
| ImmutableMap.of(range1, 1, range2, 2); |
| ImmutableMap<Range<Integer>, Integer> asMap = rangeMap.asMapOfRanges(); |
| assertEquals(expectedAsMap, asMap); |
| |
| for (Range<Integer> query : RANGES) { |
| assertEquals(expectedAsMap.get(query), asMap.get(query)); |
| } |
| } |
| } |
| } |
| } |
| |
| public void testSubRangeMap() { |
| for (Range<Integer> range1 : RANGES) { |
| for (Range<Integer> range2 : RANGES) { |
| if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { |
| for (Range<Integer> subRange : RANGES) { |
| ImmutableRangeMap<Integer, Integer> rangeMap = |
| ImmutableRangeMap.<Integer, Integer>builder() |
| .put(range1, 1).put(range2, 2).build(); |
| |
| ImmutableRangeMap.Builder<Integer, Integer> expectedBuilder = |
| ImmutableRangeMap.builder(); |
| for (Map.Entry<Range<Integer>, Integer> entry : rangeMap.asMapOfRanges().entrySet()) { |
| if (entry.getKey().isConnected(subRange) |
| && !entry.getKey().intersection(subRange).isEmpty()) { |
| expectedBuilder.put(entry.getKey().intersection(subRange), entry.getValue()); |
| } |
| } |
| |
| ImmutableRangeMap<Integer, Integer> expected = expectedBuilder.build(); |
| assertEquals(expected, rangeMap.subRangeMap(subRange)); |
| } |
| } |
| } |
| } |
| } |
| } |