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