• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2012 The Guava Authors
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
5  * in compliance with the License. You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software distributed under the License
10  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
11  * or implied. See the License for the specific language governing permissions and limitations under
12  * the License.
13  */
14 
15 package com.google.common.collect;
16 
17 import static com.google.common.truth.Truth.assertThat;
18 import static org.junit.Assert.assertThrows;
19 
20 import com.google.common.annotations.GwtIncompatible;
21 import com.google.common.collect.testing.NavigableSetTestSuiteBuilder;
22 import com.google.common.collect.testing.SampleElements;
23 import com.google.common.collect.testing.TestSetGenerator;
24 import com.google.common.collect.testing.features.CollectionFeature;
25 import com.google.common.collect.testing.features.CollectionSize;
26 import com.google.common.testing.CollectorTester;
27 import com.google.common.testing.SerializableTester;
28 import java.math.BigInteger;
29 import java.util.List;
30 import java.util.Set;
31 import junit.framework.Test;
32 import junit.framework.TestSuite;
33 
34 /**
35  * Tests for {@link ImmutableRangeSet}.
36  *
37  * @author Louis Wasserman
38  */
39 @GwtIncompatible // ImmutableRangeSet
40 public class ImmutableRangeSetTest extends AbstractRangeSetTest {
41 
42   static final class ImmutableRangeSetIntegerAsSetGenerator implements TestSetGenerator<Integer> {
43     @Override
samples()44     public SampleElements<Integer> samples() {
45       return new SampleElements<>(1, 4, 3, 2, 5);
46     }
47 
48     @Override
createArray(int length)49     public Integer[] createArray(int length) {
50       return new Integer[length];
51     }
52 
53     @Override
order(List<Integer> insertionOrder)54     public Iterable<Integer> order(List<Integer> insertionOrder) {
55       return Ordering.natural().sortedCopy(insertionOrder);
56     }
57 
58     @Override
create(Object... elements)59     public Set<Integer> create(Object... elements) {
60       ImmutableRangeSet.Builder<Integer> builder = ImmutableRangeSet.builder();
61       for (Object o : elements) {
62         Integer i = (Integer) o;
63         builder.add(Range.singleton(i));
64       }
65       return builder.build().asSet(DiscreteDomain.integers());
66     }
67   }
68 
69   static final class ImmutableRangeSetBigIntegerAsSetGenerator
70       implements TestSetGenerator<BigInteger> {
71     @Override
samples()72     public SampleElements<BigInteger> samples() {
73       return new SampleElements<>(
74           BigInteger.valueOf(1),
75           BigInteger.valueOf(4),
76           BigInteger.valueOf(3),
77           BigInteger.valueOf(2),
78           BigInteger.valueOf(5));
79     }
80 
81     @Override
createArray(int length)82     public BigInteger[] createArray(int length) {
83       return new BigInteger[length];
84     }
85 
86     @Override
order(List<BigInteger> insertionOrder)87     public Iterable<BigInteger> order(List<BigInteger> insertionOrder) {
88       return Ordering.natural().sortedCopy(insertionOrder);
89     }
90 
91     @Override
create(Object... elements)92     public Set<BigInteger> create(Object... elements) {
93       ImmutableRangeSet.Builder<BigInteger> builder = ImmutableRangeSet.builder();
94       for (Object o : elements) {
95         BigInteger i = (BigInteger) o;
96         builder.add(Range.closedOpen(i, i.add(BigInteger.ONE)));
97       }
98       return builder.build().asSet(DiscreteDomain.bigIntegers());
99     }
100   }
101 
suite()102   public static Test suite() {
103     TestSuite suite = new TestSuite();
104     suite.addTestSuite(ImmutableRangeSetTest.class);
105     suite.addTest(
106         NavigableSetTestSuiteBuilder.using(new ImmutableRangeSetIntegerAsSetGenerator())
107             .named("ImmutableRangeSet.asSet[DiscreteDomain.integers[]]")
108             .withFeatures(
109                 CollectionSize.ANY,
110                 CollectionFeature.REJECTS_DUPLICATES_AT_CREATION,
111                 CollectionFeature.ALLOWS_NULL_QUERIES,
112                 CollectionFeature.KNOWN_ORDER,
113                 CollectionFeature.NON_STANDARD_TOSTRING,
114                 CollectionFeature.SERIALIZABLE)
115             .createTestSuite());
116 
117     suite.addTest(
118         NavigableSetTestSuiteBuilder.using(new ImmutableRangeSetBigIntegerAsSetGenerator())
119             .named("ImmutableRangeSet.asSet[DiscreteDomain.bigIntegers[]]")
120             .withFeatures(
121                 CollectionSize.ANY,
122                 CollectionFeature.REJECTS_DUPLICATES_AT_CREATION,
123                 CollectionFeature.ALLOWS_NULL_QUERIES,
124                 CollectionFeature.KNOWN_ORDER,
125                 CollectionFeature.NON_STANDARD_TOSTRING,
126                 CollectionFeature.SERIALIZABLE)
127             .createTestSuite());
128     return suite;
129   }
130 
testEmpty()131   public void testEmpty() {
132     ImmutableRangeSet<Integer> rangeSet = ImmutableRangeSet.of();
133 
134     assertThat(rangeSet.asRanges()).isEmpty();
135     assertEquals(ImmutableRangeSet.<Integer>all(), rangeSet.complement());
136     assertFalse(rangeSet.contains(0));
137     assertFalse(rangeSet.intersects(Range.singleton(0)));
138     assertFalse(rangeSet.encloses(Range.singleton(0)));
139     assertTrue(rangeSet.enclosesAll(rangeSet));
140     assertTrue(rangeSet.isEmpty());
141   }
142 
testAll()143   public void testAll() {
144     ImmutableRangeSet<Integer> rangeSet = ImmutableRangeSet.all();
145 
146     assertThat(rangeSet.asRanges()).contains(Range.<Integer>all());
147     assertTrue(rangeSet.contains(0));
148     assertTrue(rangeSet.intersects(Range.singleton(0)));
149     assertTrue(rangeSet.intersects(Range.<Integer>all()));
150     assertTrue(rangeSet.encloses(Range.<Integer>all()));
151     assertTrue(rangeSet.enclosesAll(rangeSet));
152     assertEquals(ImmutableRangeSet.<Integer>of(), rangeSet.complement());
153   }
154 
testSingleBoundedRange()155   public void testSingleBoundedRange() {
156     ImmutableRangeSet<Integer> rangeSet = ImmutableRangeSet.of(Range.closedOpen(1, 5));
157 
158     assertThat(rangeSet.asRanges()).contains(Range.closedOpen(1, 5));
159 
160     assertTrue(rangeSet.intersects(Range.closed(3, 4)));
161     assertTrue(rangeSet.intersects(Range.closedOpen(0, 2)));
162     assertTrue(rangeSet.intersects(Range.closedOpen(3, 7)));
163     assertTrue(rangeSet.intersects(Range.greaterThan(2)));
164     assertFalse(rangeSet.intersects(Range.greaterThan(7)));
165 
166     assertTrue(rangeSet.encloses(Range.closed(3, 4)));
167     assertTrue(rangeSet.encloses(Range.closedOpen(1, 4)));
168     assertTrue(rangeSet.encloses(Range.closedOpen(1, 5)));
169     assertFalse(rangeSet.encloses(Range.greaterThan(2)));
170 
171     assertTrue(rangeSet.contains(3));
172     assertFalse(rangeSet.contains(5));
173     assertFalse(rangeSet.contains(0));
174 
175     RangeSet<Integer> expectedComplement = TreeRangeSet.create();
176     expectedComplement.add(Range.lessThan(1));
177     expectedComplement.add(Range.atLeast(5));
178 
179     assertEquals(expectedComplement, rangeSet.complement());
180   }
181 
testSingleBoundedBelowRange()182   public void testSingleBoundedBelowRange() {
183     ImmutableRangeSet<Integer> rangeSet = ImmutableRangeSet.of(Range.greaterThan(2));
184 
185     assertThat(rangeSet.asRanges()).contains(Range.greaterThan(2));
186 
187     assertTrue(rangeSet.intersects(Range.closed(3, 4)));
188     assertTrue(rangeSet.intersects(Range.closedOpen(1, 5)));
189     assertFalse(rangeSet.intersects(Range.lessThan(1)));
190     assertTrue(rangeSet.intersects(Range.greaterThan(1)));
191     assertTrue(rangeSet.intersects(Range.greaterThan(3)));
192 
193     assertTrue(rangeSet.encloses(Range.closed(3, 4)));
194     assertTrue(rangeSet.encloses(Range.greaterThan(3)));
195     assertFalse(rangeSet.encloses(Range.closedOpen(1, 5)));
196 
197     assertTrue(rangeSet.contains(3));
198     assertTrue(rangeSet.contains(5));
199     assertFalse(rangeSet.contains(0));
200     assertFalse(rangeSet.contains(2));
201 
202     assertEquals(ImmutableRangeSet.of(Range.atMost(2)), rangeSet.complement());
203   }
204 
testSingleBoundedAboveRange()205   public void testSingleBoundedAboveRange() {
206     ImmutableRangeSet<Integer> rangeSet = ImmutableRangeSet.of(Range.atMost(3));
207 
208     assertThat(rangeSet.asRanges()).contains(Range.atMost(3));
209 
210     assertTrue(rangeSet.intersects(Range.closed(3, 4)));
211     assertTrue(rangeSet.intersects(Range.closedOpen(1, 5)));
212     assertFalse(rangeSet.intersects(Range.closedOpen(4, 5)));
213     assertTrue(rangeSet.intersects(Range.lessThan(1)));
214     assertTrue(rangeSet.intersects(Range.greaterThan(1)));
215     assertFalse(rangeSet.intersects(Range.greaterThan(3)));
216 
217     assertTrue(rangeSet.encloses(Range.closed(2, 3)));
218     assertTrue(rangeSet.encloses(Range.lessThan(1)));
219     assertFalse(rangeSet.encloses(Range.closedOpen(1, 5)));
220 
221     assertTrue(rangeSet.contains(3));
222     assertTrue(rangeSet.contains(0));
223     assertFalse(rangeSet.contains(4));
224     assertFalse(rangeSet.contains(5));
225 
226     assertEquals(ImmutableRangeSet.of(Range.greaterThan(3)), rangeSet.complement());
227   }
228 
testMultipleBoundedRanges()229   public void testMultipleBoundedRanges() {
230     ImmutableRangeSet<Integer> rangeSet =
231         ImmutableRangeSet.<Integer>builder()
232             .add(Range.closed(5, 8))
233             .add(Range.closedOpen(1, 3))
234             .build();
235 
236     assertThat(rangeSet.asRanges())
237         .containsExactly(Range.closedOpen(1, 3), Range.closed(5, 8))
238         .inOrder();
239 
240     assertTrue(rangeSet.intersects(Range.closed(1, 2)));
241     assertTrue(rangeSet.intersects(Range.open(5, 8)));
242     assertFalse(rangeSet.intersects(Range.closed(3, 4)));
243     assertTrue(rangeSet.intersects(Range.greaterThan(5)));
244     assertFalse(rangeSet.intersects(Range.greaterThan(8)));
245 
246     assertTrue(rangeSet.encloses(Range.closed(1, 2)));
247     assertTrue(rangeSet.encloses(Range.open(5, 8)));
248     assertFalse(rangeSet.encloses(Range.closed(1, 8)));
249     assertFalse(rangeSet.encloses(Range.greaterThan(5)));
250 
251     RangeSet<Integer> expectedComplement =
252         ImmutableRangeSet.<Integer>builder()
253             .add(Range.lessThan(1))
254             .add(Range.closedOpen(3, 5))
255             .add(Range.greaterThan(8))
256             .build();
257 
258     assertEquals(expectedComplement, rangeSet.complement());
259   }
260 
testMultipleBoundedBelowRanges()261   public void testMultipleBoundedBelowRanges() {
262     ImmutableRangeSet<Integer> rangeSet =
263         ImmutableRangeSet.<Integer>builder()
264             .add(Range.greaterThan(6))
265             .add(Range.closedOpen(1, 3))
266             .build();
267 
268     assertThat(rangeSet.asRanges())
269         .containsExactly(Range.closedOpen(1, 3), Range.greaterThan(6))
270         .inOrder();
271 
272     assertTrue(rangeSet.intersects(Range.closed(1, 2)));
273     assertTrue(rangeSet.intersects(Range.open(6, 8)));
274     assertFalse(rangeSet.intersects(Range.closed(3, 6)));
275     assertTrue(rangeSet.intersects(Range.greaterThan(5)));
276     assertFalse(rangeSet.intersects(Range.lessThan(1)));
277 
278     assertTrue(rangeSet.encloses(Range.closed(1, 2)));
279     assertTrue(rangeSet.encloses(Range.open(6, 8)));
280     assertFalse(rangeSet.encloses(Range.closed(1, 8)));
281     assertFalse(rangeSet.encloses(Range.greaterThan(5)));
282 
283     RangeSet<Integer> expectedComplement =
284         ImmutableRangeSet.<Integer>builder().add(Range.lessThan(1)).add(Range.closed(3, 6)).build();
285 
286     assertEquals(expectedComplement, rangeSet.complement());
287   }
288 
testMultipleBoundedAboveRanges()289   public void testMultipleBoundedAboveRanges() {
290     ImmutableRangeSet<Integer> rangeSet =
291         ImmutableRangeSet.<Integer>builder()
292             .add(Range.atMost(0))
293             .add(Range.closedOpen(2, 5))
294             .build();
295 
296     assertThat(rangeSet.asRanges())
297         .containsExactly(Range.atMost(0), Range.closedOpen(2, 5))
298         .inOrder();
299 
300     assertTrue(rangeSet.intersects(Range.closed(2, 4)));
301     assertTrue(rangeSet.intersects(Range.open(-5, -2)));
302     assertTrue(rangeSet.intersects(Range.closed(1, 8)));
303     assertFalse(rangeSet.intersects(Range.singleton(1)));
304     assertFalse(rangeSet.intersects(Range.greaterThan(5)));
305 
306     assertTrue(rangeSet.encloses(Range.closed(2, 4)));
307     assertTrue(rangeSet.encloses(Range.open(-5, -2)));
308     assertFalse(rangeSet.encloses(Range.closed(1, 8)));
309     assertFalse(rangeSet.encloses(Range.greaterThan(5)));
310 
311     RangeSet<Integer> expectedComplement =
312         ImmutableRangeSet.<Integer>builder().add(Range.open(0, 2)).add(Range.atLeast(5)).build();
313 
314     assertEquals(expectedComplement, rangeSet.complement());
315   }
316 
317   @SuppressWarnings("DoNotCall")
testAddUnsupported()318   public void testAddUnsupported() {
319     RangeSet<Integer> rangeSet =
320         ImmutableRangeSet.<Integer>builder()
321             .add(Range.closed(5, 8))
322             .add(Range.closedOpen(1, 3))
323             .build();
324 
325     assertThrows(UnsupportedOperationException.class, () -> rangeSet.add(Range.open(3, 4)));
326   }
327 
328   @SuppressWarnings("DoNotCall")
testAddAllUnsupported()329   public void testAddAllUnsupported() {
330     RangeSet<Integer> rangeSet =
331         ImmutableRangeSet.<Integer>builder()
332             .add(Range.closed(5, 8))
333             .add(Range.closedOpen(1, 3))
334             .build();
335 
336     assertThrows(
337         UnsupportedOperationException.class,
338         () -> rangeSet.addAll(ImmutableRangeSet.<Integer>of()));
339   }
340 
341   @SuppressWarnings("DoNotCall")
testRemoveUnsupported()342   public void testRemoveUnsupported() {
343     RangeSet<Integer> rangeSet =
344         ImmutableRangeSet.<Integer>builder()
345             .add(Range.closed(5, 8))
346             .add(Range.closedOpen(1, 3))
347             .build();
348 
349     assertThrows(UnsupportedOperationException.class, () -> rangeSet.remove(Range.closed(6, 7)));
350   }
351 
352   @SuppressWarnings("DoNotCall")
testRemoveAllUnsupported()353   public void testRemoveAllUnsupported() {
354     RangeSet<Integer> rangeSet =
355         ImmutableRangeSet.<Integer>builder()
356             .add(Range.closed(5, 8))
357             .add(Range.closedOpen(1, 3))
358             .build();
359 
360     assertThrows(
361         UnsupportedOperationException.class,
362         () -> rangeSet.removeAll(ImmutableRangeSet.<Integer>of()));
363 
364     assertThrows(
365         UnsupportedOperationException.class,
366         () -> rangeSet.removeAll(ImmutableRangeSet.of(Range.closed(6, 8))));
367   }
368 
369   @AndroidIncompatible // slow
testExhaustive()370   public void testExhaustive() {
371     @SuppressWarnings("unchecked")
372     ImmutableSet<Range<Integer>> ranges =
373         ImmutableSet.of(
374             Range.<Integer>all(),
375             Range.<Integer>closedOpen(3, 5),
376             Range.singleton(1),
377             Range.lessThan(2),
378             Range.greaterThan(10),
379             Range.atMost(4),
380             Range.atLeast(3),
381             Range.closed(4, 6),
382             Range.closedOpen(1, 3),
383             Range.openClosed(5, 7),
384             Range.open(3, 4));
385     subsets:
386     for (Set<Range<Integer>> subset : Sets.powerSet(ranges)) {
387       assertEquals(TreeRangeSet.create(subset), ImmutableRangeSet.unionOf(subset));
388 
389       RangeSet<Integer> mutable = TreeRangeSet.create();
390       ImmutableRangeSet.Builder<Integer> builder = ImmutableRangeSet.builder();
391 
392       boolean anyOverlaps = false;
393       for (Range<Integer> range : subset) {
394         boolean overlaps = false;
395         for (Range<Integer> other : mutable.asRanges()) {
396           if (other.isConnected(range) && !other.intersection(range).isEmpty()) {
397             overlaps = true;
398             anyOverlaps = true;
399             break;
400           }
401         }
402 
403         try {
404           ImmutableRangeSet<Integer> unused = builder.add(range).build();
405           assertFalse(overlaps);
406           mutable.add(range);
407         } catch (IllegalArgumentException e) {
408           assertTrue(overlaps);
409           continue subsets;
410         }
411       }
412 
413       if (anyOverlaps) {
414         assertThrows(
415             IllegalArgumentException.class,
416             () -> {
417               RangeSet<Integer> copy = ImmutableRangeSet.copyOf(subset);
418             });
419       } else {
420         RangeSet<Integer> copy = ImmutableRangeSet.copyOf(subset);
421         assertEquals(mutable, copy);
422       }
423 
424       ImmutableRangeSet<Integer> built = builder.build();
425       assertEquals(mutable, built);
426       assertEquals(ImmutableRangeSet.copyOf(mutable), built);
427       assertEquals(mutable.complement(), built.complement());
428 
429       for (int i = 0; i <= 11; i++) {
430         assertEquals(mutable.contains(i), built.contains(i));
431       }
432 
433       SerializableTester.reserializeAndAssert(built);
434       SerializableTester.reserializeAndAssert(built.asRanges());
435     }
436   }
437 
438   private static final ImmutableRangeSet<Integer> RANGE_SET_ONE =
439       ImmutableRangeSet.<Integer>builder()
440           .add(Range.closed(2, 4))
441           .add(Range.open(6, 7))
442           .add(Range.closedOpen(8, 10))
443           .add(Range.openClosed(15, 17))
444           .build();
445 
446   private static final ImmutableRangeSet<Integer> RANGE_SET_TWO =
447       ImmutableRangeSet.<Integer>builder()
448           .add(Range.openClosed(0, 3))
449           .add(Range.closed(5, 8))
450           .add(Range.closedOpen(12, 15))
451           .add(Range.open(19, 20))
452           .build();
453 
testUnion()454   public void testUnion() {
455     RangeSet<Integer> expected =
456         ImmutableRangeSet.<Integer>builder()
457             .add(Range.openClosed(0, 4))
458             .add(Range.closedOpen(5, 10))
459             .add(Range.closedOpen(12, 15))
460             .add(Range.openClosed(15, 17))
461             .add(Range.open(19, 20))
462             .build();
463 
464     assertThat(RANGE_SET_ONE.union(RANGE_SET_TWO)).isEqualTo(expected);
465   }
466 
testIntersection()467   public void testIntersection() {
468     RangeSet<Integer> expected =
469         ImmutableRangeSet.<Integer>builder()
470             .add(Range.closed(2, 3))
471             .add(Range.open(6, 7))
472             .add(Range.singleton(8))
473             .build();
474 
475     assertThat(RANGE_SET_ONE.intersection(RANGE_SET_TWO)).isEqualTo(expected);
476   }
477 
testDifference()478   public void testDifference() {
479     RangeSet<Integer> expected =
480         ImmutableRangeSet.<Integer>builder()
481             .add(Range.openClosed(3, 4))
482             .add(Range.open(8, 10))
483             .add(Range.openClosed(15, 17))
484             .build();
485 
486     assertThat(RANGE_SET_ONE.difference(RANGE_SET_TWO)).isEqualTo(expected);
487   }
488 
testAsSet()489   public void testAsSet() {
490     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
491     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
492     assertEquals(expectedSet, asSet);
493     assertThat(asSet).containsExactlyElementsIn(expectedSet).inOrder();
494     assertTrue(asSet.containsAll(expectedSet));
495     SerializableTester.reserializeAndAssert(asSet);
496   }
497 
testAsSetHeadSet()498   public void testAsSetHeadSet() {
499     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
500     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
501 
502     for (int i = 0; i <= 20; i++) {
503       assertEquals(asSet.headSet(i, false), expectedSet.headSet(i, false));
504       assertEquals(asSet.headSet(i, true), expectedSet.headSet(i, true));
505     }
506   }
507 
testAsSetTailSet()508   public void testAsSetTailSet() {
509     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
510     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
511 
512     for (int i = 0; i <= 20; i++) {
513       assertEquals(asSet.tailSet(i, false), expectedSet.tailSet(i, false));
514       assertEquals(asSet.tailSet(i, true), expectedSet.tailSet(i, true));
515     }
516   }
517 
testAsSetSubSet()518   public void testAsSetSubSet() {
519     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
520     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
521 
522     for (int i = 0; i <= 20; i++) {
523       for (int j = i + 1; j <= 20; j++) {
524         assertEquals(expectedSet.subSet(i, false, j, false), asSet.subSet(i, false, j, false));
525         assertEquals(expectedSet.subSet(i, true, j, false), asSet.subSet(i, true, j, false));
526         assertEquals(expectedSet.subSet(i, false, j, true), asSet.subSet(i, false, j, true));
527         assertEquals(expectedSet.subSet(i, true, j, true), asSet.subSet(i, true, j, true));
528       }
529     }
530   }
531 
testSubRangeSet()532   public void testSubRangeSet() {
533     ImmutableList.Builder<Range<Integer>> rangesBuilder = ImmutableList.builder();
534     rangesBuilder.add(Range.<Integer>all());
535     for (int i = -2; i <= 2; i++) {
536       for (BoundType boundType : BoundType.values()) {
537         rangesBuilder.add(Range.upTo(i, boundType));
538         rangesBuilder.add(Range.downTo(i, boundType));
539       }
540       for (int j = i + 1; j <= 2; j++) {
541         for (BoundType lbType : BoundType.values()) {
542           for (BoundType ubType : BoundType.values()) {
543             rangesBuilder.add(Range.range(i, lbType, j, ubType));
544           }
545         }
546       }
547     }
548     ImmutableList<Range<Integer>> ranges = rangesBuilder.build();
549     for (int i = -2; i <= 2; i++) {
550       rangesBuilder.add(Range.closedOpen(i, i));
551       rangesBuilder.add(Range.openClosed(i, i));
552     }
553     ImmutableList<Range<Integer>> subRanges = rangesBuilder.build();
554     for (Range<Integer> range1 : ranges) {
555       for (Range<Integer> range2 : ranges) {
556         if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) {
557           ImmutableRangeSet<Integer> rangeSet =
558               ImmutableRangeSet.<Integer>builder().add(range1).add(range2).build();
559           for (Range<Integer> subRange : subRanges) {
560             RangeSet<Integer> expected = TreeRangeSet.create();
561             for (Range<Integer> range : rangeSet.asRanges()) {
562               if (range.isConnected(subRange)) {
563                 expected.add(range.intersection(subRange));
564               }
565             }
566             ImmutableRangeSet<Integer> subRangeSet = rangeSet.subRangeSet(subRange);
567             assertEquals(expected, subRangeSet);
568             assertEquals(expected.asRanges(), subRangeSet.asRanges());
569             if (!expected.isEmpty()) {
570               assertEquals(expected.span(), subRangeSet.span());
571             }
572             for (int i = -3; i <= 3; i++) {
573               assertEquals(expected.contains(i), subRangeSet.contains(i));
574             }
575           }
576         }
577       }
578     }
579   }
580 
testToImmutableRangeSet()581   public void testToImmutableRangeSet() {
582     Range<Integer> rangeOne = Range.closedOpen(1, 5);
583     Range<Integer> rangeTwo = Range.openClosed(6, 7);
584     ImmutableRangeSet<Integer> ranges =
585         ImmutableRangeSet.copyOf(ImmutableList.of(rangeOne, rangeTwo));
586     CollectorTester.of(ImmutableRangeSet.<Integer>toImmutableRangeSet())
587         .expectCollects(ranges, rangeOne, rangeTwo);
588   }
589 }
590