• 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     ImmutableSet<Range<Integer>> ranges =
372         ImmutableSet.of(
373             Range.<Integer>all(),
374             Range.<Integer>closedOpen(3, 5),
375             Range.singleton(1),
376             Range.lessThan(2),
377             Range.greaterThan(10),
378             Range.atMost(4),
379             Range.atLeast(3),
380             Range.closed(4, 6),
381             Range.closedOpen(1, 3),
382             Range.openClosed(5, 7),
383             Range.open(3, 4));
384     subsets:
385     for (Set<Range<Integer>> subset : Sets.powerSet(ranges)) {
386       assertEquals(TreeRangeSet.create(subset), ImmutableRangeSet.unionOf(subset));
387 
388       RangeSet<Integer> mutable = TreeRangeSet.create();
389       ImmutableRangeSet.Builder<Integer> builder = ImmutableRangeSet.builder();
390 
391       boolean anyOverlaps = false;
392       for (Range<Integer> range : subset) {
393         boolean overlaps = false;
394         for (Range<Integer> other : mutable.asRanges()) {
395           if (other.isConnected(range) && !other.intersection(range).isEmpty()) {
396             overlaps = true;
397             anyOverlaps = true;
398             break;
399           }
400         }
401 
402         try {
403           ImmutableRangeSet<Integer> unused = builder.add(range).build();
404           assertFalse(overlaps);
405           mutable.add(range);
406         } catch (IllegalArgumentException e) {
407           assertTrue(overlaps);
408           continue subsets;
409         }
410       }
411 
412       if (anyOverlaps) {
413         assertThrows(IllegalArgumentException.class, () -> ImmutableRangeSet.copyOf(subset));
414       } else {
415         RangeSet<Integer> copy = ImmutableRangeSet.copyOf(subset);
416         assertEquals(mutable, copy);
417       }
418 
419       ImmutableRangeSet<Integer> built = builder.build();
420       assertEquals(mutable, built);
421       assertEquals(ImmutableRangeSet.copyOf(mutable), built);
422       assertEquals(mutable.complement(), built.complement());
423 
424       for (int i = 0; i <= 11; i++) {
425         assertEquals(mutable.contains(i), built.contains(i));
426       }
427 
428       SerializableTester.reserializeAndAssert(built);
429       SerializableTester.reserializeAndAssert(built.asRanges());
430     }
431   }
432 
433   private static final ImmutableRangeSet<Integer> RANGE_SET_ONE =
434       ImmutableRangeSet.<Integer>builder()
435           .add(Range.closed(2, 4))
436           .add(Range.open(6, 7))
437           .add(Range.closedOpen(8, 10))
438           .add(Range.openClosed(15, 17))
439           .build();
440 
441   private static final ImmutableRangeSet<Integer> RANGE_SET_TWO =
442       ImmutableRangeSet.<Integer>builder()
443           .add(Range.openClosed(0, 3))
444           .add(Range.closed(5, 8))
445           .add(Range.closedOpen(12, 15))
446           .add(Range.open(19, 20))
447           .build();
448 
testUnion()449   public void testUnion() {
450     RangeSet<Integer> expected =
451         ImmutableRangeSet.<Integer>builder()
452             .add(Range.openClosed(0, 4))
453             .add(Range.closedOpen(5, 10))
454             .add(Range.closedOpen(12, 15))
455             .add(Range.openClosed(15, 17))
456             .add(Range.open(19, 20))
457             .build();
458 
459     assertThat(RANGE_SET_ONE.union(RANGE_SET_TWO)).isEqualTo(expected);
460   }
461 
testIntersection()462   public void testIntersection() {
463     RangeSet<Integer> expected =
464         ImmutableRangeSet.<Integer>builder()
465             .add(Range.closed(2, 3))
466             .add(Range.open(6, 7))
467             .add(Range.singleton(8))
468             .build();
469 
470     assertThat(RANGE_SET_ONE.intersection(RANGE_SET_TWO)).isEqualTo(expected);
471   }
472 
testDifference()473   public void testDifference() {
474     RangeSet<Integer> expected =
475         ImmutableRangeSet.<Integer>builder()
476             .add(Range.openClosed(3, 4))
477             .add(Range.open(8, 10))
478             .add(Range.openClosed(15, 17))
479             .build();
480 
481     assertThat(RANGE_SET_ONE.difference(RANGE_SET_TWO)).isEqualTo(expected);
482   }
483 
testAsSet()484   public void testAsSet() {
485     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
486     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
487     assertEquals(expectedSet, asSet);
488     assertThat(asSet).containsExactlyElementsIn(expectedSet).inOrder();
489     assertTrue(asSet.containsAll(expectedSet));
490     SerializableTester.reserializeAndAssert(asSet);
491   }
492 
testAsSetHeadSet()493   public void testAsSetHeadSet() {
494     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
495     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
496 
497     for (int i = 0; i <= 20; i++) {
498       assertEquals(asSet.headSet(i, false), expectedSet.headSet(i, false));
499       assertEquals(asSet.headSet(i, true), expectedSet.headSet(i, true));
500     }
501   }
502 
testAsSetTailSet()503   public void testAsSetTailSet() {
504     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
505     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
506 
507     for (int i = 0; i <= 20; i++) {
508       assertEquals(asSet.tailSet(i, false), expectedSet.tailSet(i, false));
509       assertEquals(asSet.tailSet(i, true), expectedSet.tailSet(i, true));
510     }
511   }
512 
testAsSetSubSet()513   public void testAsSetSubSet() {
514     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
515     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
516 
517     for (int i = 0; i <= 20; i++) {
518       for (int j = i + 1; j <= 20; j++) {
519         assertEquals(expectedSet.subSet(i, false, j, false), asSet.subSet(i, false, j, false));
520         assertEquals(expectedSet.subSet(i, true, j, false), asSet.subSet(i, true, j, false));
521         assertEquals(expectedSet.subSet(i, false, j, true), asSet.subSet(i, false, j, true));
522         assertEquals(expectedSet.subSet(i, true, j, true), asSet.subSet(i, true, j, true));
523       }
524     }
525   }
526 
testSubRangeSet()527   public void testSubRangeSet() {
528     ImmutableList.Builder<Range<Integer>> rangesBuilder = ImmutableList.builder();
529     rangesBuilder.add(Range.<Integer>all());
530     for (int i = -2; i <= 2; i++) {
531       for (BoundType boundType : BoundType.values()) {
532         rangesBuilder.add(Range.upTo(i, boundType));
533         rangesBuilder.add(Range.downTo(i, boundType));
534       }
535       for (int j = i + 1; j <= 2; j++) {
536         for (BoundType lbType : BoundType.values()) {
537           for (BoundType ubType : BoundType.values()) {
538             rangesBuilder.add(Range.range(i, lbType, j, ubType));
539           }
540         }
541       }
542     }
543     ImmutableList<Range<Integer>> ranges = rangesBuilder.build();
544     for (int i = -2; i <= 2; i++) {
545       rangesBuilder.add(Range.closedOpen(i, i));
546       rangesBuilder.add(Range.openClosed(i, i));
547     }
548     ImmutableList<Range<Integer>> subRanges = rangesBuilder.build();
549     for (Range<Integer> range1 : ranges) {
550       for (Range<Integer> range2 : ranges) {
551         if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) {
552           ImmutableRangeSet<Integer> rangeSet =
553               ImmutableRangeSet.<Integer>builder().add(range1).add(range2).build();
554           for (Range<Integer> subRange : subRanges) {
555             RangeSet<Integer> expected = TreeRangeSet.create();
556             for (Range<Integer> range : rangeSet.asRanges()) {
557               if (range.isConnected(subRange)) {
558                 expected.add(range.intersection(subRange));
559               }
560             }
561             ImmutableRangeSet<Integer> subRangeSet = rangeSet.subRangeSet(subRange);
562             assertEquals(expected, subRangeSet);
563             assertEquals(expected.asRanges(), subRangeSet.asRanges());
564             if (!expected.isEmpty()) {
565               assertEquals(expected.span(), subRangeSet.span());
566             }
567             for (int i = -3; i <= 3; i++) {
568               assertEquals(expected.contains(i), subRangeSet.contains(i));
569             }
570           }
571         }
572       }
573     }
574   }
575 
testToImmutableRangeSet()576   public void testToImmutableRangeSet() {
577     Range<Integer> rangeOne = Range.closedOpen(1, 5);
578     Range<Integer> rangeTwo = Range.openClosed(6, 7);
579     ImmutableRangeSet<Integer> ranges =
580         ImmutableRangeSet.copyOf(ImmutableList.of(rangeOne, rangeTwo));
581     CollectorTester.of(ImmutableRangeSet.<Integer>toImmutableRangeSet())
582         .expectCollects(ranges, rangeOne, rangeTwo);
583   }
584 }
585