• 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.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 
316   @SuppressWarnings("DoNotCall")
testAddUnsupported()317   public void testAddUnsupported() {
318     RangeSet<Integer> rangeSet =
319         ImmutableRangeSet.<Integer>builder()
320             .add(Range.closed(5, 8))
321             .add(Range.closedOpen(1, 3))
322             .build();
323 
324     assertThrows(UnsupportedOperationException.class, () -> rangeSet.add(Range.open(3, 4)));
325   }
326 
327   @SuppressWarnings("DoNotCall")
testAddAllUnsupported()328   public void testAddAllUnsupported() {
329     RangeSet<Integer> rangeSet =
330         ImmutableRangeSet.<Integer>builder()
331             .add(Range.closed(5, 8))
332             .add(Range.closedOpen(1, 3))
333             .build();
334 
335     assertThrows(
336         UnsupportedOperationException.class,
337         () -> rangeSet.addAll(ImmutableRangeSet.<Integer>of()));
338   }
339 
340   @SuppressWarnings("DoNotCall")
testRemoveUnsupported()341   public void testRemoveUnsupported() {
342     RangeSet<Integer> rangeSet =
343         ImmutableRangeSet.<Integer>builder()
344             .add(Range.closed(5, 8))
345             .add(Range.closedOpen(1, 3))
346             .build();
347 
348     assertThrows(UnsupportedOperationException.class, () -> rangeSet.remove(Range.closed(6, 7)));
349   }
350 
351   @SuppressWarnings("DoNotCall")
testRemoveAllUnsupported()352   public void testRemoveAllUnsupported() {
353     RangeSet<Integer> rangeSet =
354         ImmutableRangeSet.<Integer>builder()
355             .add(Range.closed(5, 8))
356             .add(Range.closedOpen(1, 3))
357             .build();
358 
359     assertThrows(
360         UnsupportedOperationException.class,
361         () -> rangeSet.removeAll(ImmutableRangeSet.<Integer>of()));
362 
363     assertThrows(
364         UnsupportedOperationException.class,
365         () -> rangeSet.removeAll(ImmutableRangeSet.of(Range.closed(6, 8))));
366   }
367 
368   @AndroidIncompatible // slow
testExhaustive()369   public void testExhaustive() {
370     @SuppressWarnings("unchecked")
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(
414             IllegalArgumentException.class,
415             () -> {
416               RangeSet<Integer> copy = ImmutableRangeSet.copyOf(subset);
417             });
418       } else {
419         RangeSet<Integer> copy = ImmutableRangeSet.copyOf(subset);
420         assertEquals(mutable, copy);
421       }
422 
423       ImmutableRangeSet<Integer> built = builder.build();
424       assertEquals(mutable, built);
425       assertEquals(ImmutableRangeSet.copyOf(mutable), built);
426       assertEquals(mutable.complement(), built.complement());
427 
428       for (int i = 0; i <= 11; i++) {
429         assertEquals(mutable.contains(i), built.contains(i));
430       }
431 
432       SerializableTester.reserializeAndAssert(built);
433       SerializableTester.reserializeAndAssert(built.asRanges());
434     }
435   }
436 
437   private static final ImmutableRangeSet<Integer> RANGE_SET_ONE =
438       ImmutableRangeSet.<Integer>builder()
439           .add(Range.closed(2, 4))
440           .add(Range.open(6, 7))
441           .add(Range.closedOpen(8, 10))
442           .add(Range.openClosed(15, 17))
443           .build();
444 
445   private static final ImmutableRangeSet<Integer> RANGE_SET_TWO =
446       ImmutableRangeSet.<Integer>builder()
447           .add(Range.openClosed(0, 3))
448           .add(Range.closed(5, 8))
449           .add(Range.closedOpen(12, 15))
450           .add(Range.open(19, 20))
451           .build();
452 
testUnion()453   public void testUnion() {
454     RangeSet<Integer> expected =
455         ImmutableRangeSet.<Integer>builder()
456             .add(Range.openClosed(0, 4))
457             .add(Range.closedOpen(5, 10))
458             .add(Range.closedOpen(12, 15))
459             .add(Range.openClosed(15, 17))
460             .add(Range.open(19, 20))
461             .build();
462 
463     assertThat(RANGE_SET_ONE.union(RANGE_SET_TWO)).isEqualTo(expected);
464   }
465 
testIntersection()466   public void testIntersection() {
467     RangeSet<Integer> expected =
468         ImmutableRangeSet.<Integer>builder()
469             .add(Range.closed(2, 3))
470             .add(Range.open(6, 7))
471             .add(Range.singleton(8))
472             .build();
473 
474     assertThat(RANGE_SET_ONE.intersection(RANGE_SET_TWO)).isEqualTo(expected);
475   }
476 
testDifference()477   public void testDifference() {
478     RangeSet<Integer> expected =
479         ImmutableRangeSet.<Integer>builder()
480             .add(Range.openClosed(3, 4))
481             .add(Range.open(8, 10))
482             .add(Range.openClosed(15, 17))
483             .build();
484 
485     assertThat(RANGE_SET_ONE.difference(RANGE_SET_TWO)).isEqualTo(expected);
486   }
487 
testAsSet()488   public void testAsSet() {
489     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
490     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
491     assertEquals(expectedSet, asSet);
492     assertThat(asSet).containsExactlyElementsIn(expectedSet).inOrder();
493     assertTrue(asSet.containsAll(expectedSet));
494     SerializableTester.reserializeAndAssert(asSet);
495   }
496 
testAsSetHeadSet()497   public void testAsSetHeadSet() {
498     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
499     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
500 
501     for (int i = 0; i <= 20; i++) {
502       assertEquals(asSet.headSet(i, false), expectedSet.headSet(i, false));
503       assertEquals(asSet.headSet(i, true), expectedSet.headSet(i, true));
504     }
505   }
506 
testAsSetTailSet()507   public void testAsSetTailSet() {
508     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
509     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
510 
511     for (int i = 0; i <= 20; i++) {
512       assertEquals(asSet.tailSet(i, false), expectedSet.tailSet(i, false));
513       assertEquals(asSet.tailSet(i, true), expectedSet.tailSet(i, true));
514     }
515   }
516 
testAsSetSubSet()517   public void testAsSetSubSet() {
518     ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17);
519     ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers());
520 
521     for (int i = 0; i <= 20; i++) {
522       for (int j = i + 1; j <= 20; j++) {
523         assertEquals(expectedSet.subSet(i, false, j, false), asSet.subSet(i, false, j, false));
524         assertEquals(expectedSet.subSet(i, true, j, false), asSet.subSet(i, true, j, false));
525         assertEquals(expectedSet.subSet(i, false, j, true), asSet.subSet(i, false, j, true));
526         assertEquals(expectedSet.subSet(i, true, j, true), asSet.subSet(i, true, j, true));
527       }
528     }
529   }
530 
testSubRangeSet()531   public void testSubRangeSet() {
532     ImmutableList.Builder<Range<Integer>> rangesBuilder = ImmutableList.builder();
533     rangesBuilder.add(Range.<Integer>all());
534     for (int i = -2; i <= 2; i++) {
535       for (BoundType boundType : BoundType.values()) {
536         rangesBuilder.add(Range.upTo(i, boundType));
537         rangesBuilder.add(Range.downTo(i, boundType));
538       }
539       for (int j = i + 1; j <= 2; j++) {
540         for (BoundType lbType : BoundType.values()) {
541           for (BoundType ubType : BoundType.values()) {
542             rangesBuilder.add(Range.range(i, lbType, j, ubType));
543           }
544         }
545       }
546     }
547     ImmutableList<Range<Integer>> ranges = rangesBuilder.build();
548     for (int i = -2; i <= 2; i++) {
549       rangesBuilder.add(Range.closedOpen(i, i));
550       rangesBuilder.add(Range.openClosed(i, i));
551     }
552     ImmutableList<Range<Integer>> subRanges = rangesBuilder.build();
553     for (Range<Integer> range1 : ranges) {
554       for (Range<Integer> range2 : ranges) {
555         if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) {
556           ImmutableRangeSet<Integer> rangeSet =
557               ImmutableRangeSet.<Integer>builder().add(range1).add(range2).build();
558           for (Range<Integer> subRange : subRanges) {
559             RangeSet<Integer> expected = TreeRangeSet.create();
560             for (Range<Integer> range : rangeSet.asRanges()) {
561               if (range.isConnected(subRange)) {
562                 expected.add(range.intersection(subRange));
563               }
564             }
565             ImmutableRangeSet<Integer> subRangeSet = rangeSet.subRangeSet(subRange);
566             assertEquals(expected, subRangeSet);
567             assertEquals(expected.asRanges(), subRangeSet.asRanges());
568             if (!expected.isEmpty()) {
569               assertEquals(expected.span(), subRangeSet.span());
570             }
571             for (int i = -3; i <= 3; i++) {
572               assertEquals(expected.contains(i), subRangeSet.contains(i));
573             }
574           }
575         }
576       }
577     }
578   }
579 
580   // TODO(b/172823566): Use mainline testToImmutableRangeSet once CollectorTester is usable to java7
testToImmutableRangeSet_java7_combine()581   public void testToImmutableRangeSet_java7_combine() {
582     Range<Integer> rangeOne = Range.closedOpen(1, 3);
583     Range<Integer> rangeTwo = Range.closedOpen(7, 9);
584     Range<Integer> rangeThree = Range.closedOpen(4, 5);
585     Range<Integer> rangeFour = Range.closedOpen(6, 7);
586 
587     ImmutableRangeSet.Builder<Integer> zis =
588         ImmutableRangeSet.<Integer>builder().add(rangeOne).add(rangeTwo);
589     ImmutableRangeSet.Builder<Integer> zat =
590         ImmutableRangeSet.<Integer>builder().add(rangeThree).add(rangeFour);
591 
592     ImmutableRangeSet<Integer> rangeSet = zis.combine(zat).build();
593 
594     assertThat(rangeSet.asRanges())
595         .containsExactly(Range.closedOpen(1, 3), Range.closedOpen(4, 5), Range.closedOpen(6, 9))
596         .inOrder();
597   }
598 }
599