View Javadoc
1   /*
2    * Copyright (C) 2011 The Guava Authors
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    * http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package com.google.common.collect;
18  
19  import static com.google.common.collect.BoundType.CLOSED;
20  import static com.google.common.collect.BoundType.OPEN;
21  import static com.google.common.collect.DiscreteDomain.integers;
22  import static com.google.common.truth.Truth.assertThat;
23  
24  import com.google.common.annotations.GwtCompatible;
25  import com.google.common.testing.EqualsTester;
26  
27  import junit.framework.TestCase;
28  
29  import java.util.Set;
30  
31  /**
32   * @author Gregory Kick
33   */
34  @GwtCompatible(emulated = true)
35  public class ContiguousSetTest extends TestCase {
36    private static DiscreteDomain<Integer> NOT_EQUAL_TO_INTEGERS = new DiscreteDomain<Integer>() {
37      @Override public Integer next(Integer value) {
38        return integers().next(value);
39      }
40  
41      @Override public Integer previous(Integer value) {
42        return integers().previous(value);
43      }
44  
45      @Override public long distance(Integer start, Integer end) {
46        return integers().distance(start, end);
47      }
48  
49      @Override public Integer minValue() {
50        return integers().minValue();
51      }
52  
53      @Override public Integer maxValue() {
54        return integers().maxValue();
55      }
56    };
57  
58    public void testEquals() {
59      new EqualsTester()
60          .addEqualityGroup(
61              ContiguousSet.create(Range.closed(1, 3), integers()),
62              ContiguousSet.create(Range.closedOpen(1, 4), integers()),
63              ContiguousSet.create(Range.openClosed(0, 3), integers()),
64              ContiguousSet.create(Range.open(0, 4), integers()),
65              ContiguousSet.create(Range.closed(1, 3), NOT_EQUAL_TO_INTEGERS),
66              ContiguousSet.create(Range.closedOpen(1, 4), NOT_EQUAL_TO_INTEGERS),
67              ContiguousSet.create(Range.openClosed(0, 3), NOT_EQUAL_TO_INTEGERS),
68              ContiguousSet.create(Range.open(0, 4), NOT_EQUAL_TO_INTEGERS),
69              ImmutableSortedSet.of(1, 2, 3))
70          .testEquals();
71      // not testing hashCode for these because it takes forever to compute
72      assertEquals(
73          ContiguousSet.create(Range.closed(Integer.MIN_VALUE, Integer.MAX_VALUE), integers()),
74          ContiguousSet.create(Range.<Integer>all(), integers()));
75      assertEquals(
76          ContiguousSet.create(Range.closed(Integer.MIN_VALUE, Integer.MAX_VALUE), integers()),
77          ContiguousSet.create(Range.atLeast(Integer.MIN_VALUE), integers()));
78      assertEquals(
79          ContiguousSet.create(Range.closed(Integer.MIN_VALUE, Integer.MAX_VALUE), integers()),
80          ContiguousSet.create(Range.atMost(Integer.MAX_VALUE), integers()));
81    }
82  
83    public void testCreate_noMin() {
84      Range<Integer> range = Range.lessThan(0);
85      try {
86        ContiguousSet.create(range, RangeTest.UNBOUNDED_DOMAIN);
87        fail();
88      } catch (IllegalArgumentException expected) {}
89    }
90  
91    public void testCreate_noMax() {
92      Range<Integer> range = Range.greaterThan(0);
93      try {
94        ContiguousSet.create(range, RangeTest.UNBOUNDED_DOMAIN);
95        fail();
96      } catch (IllegalArgumentException expected) {}
97    }
98  
99    public void testCreate_empty() {
100     assertEquals(ImmutableSet.of(), ContiguousSet.create(Range.closedOpen(1, 1), integers()));
101     assertEquals(ImmutableSet.of(), ContiguousSet.create(Range.openClosed(5, 5), integers()));
102     assertEquals(ImmutableSet.of(),
103         ContiguousSet.create(Range.lessThan(Integer.MIN_VALUE), integers()));
104     assertEquals(ImmutableSet.of(),
105         ContiguousSet.create(Range.greaterThan(Integer.MAX_VALUE), integers()));
106   }
107 
108   public void testHeadSet() {
109     ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
110     assertThat(set.headSet(1)).isEmpty();
111     assertThat(set.headSet(2)).has().item(1);
112     assertThat(set.headSet(3)).has().exactly(1, 2).inOrder();
113     assertThat(set.headSet(4)).has().exactly(1, 2, 3).inOrder();
114     assertThat(set.headSet(Integer.MAX_VALUE)).has().exactly(1, 2, 3).inOrder();
115     assertThat(set.headSet(1, true)).has().item(1);
116     assertThat(set.headSet(2, true)).has().exactly(1, 2).inOrder();
117     assertThat(set.headSet(3, true)).has().exactly(1, 2, 3).inOrder();
118     assertThat(set.headSet(4, true)).has().exactly(1, 2, 3).inOrder();
119     assertThat(set.headSet(Integer.MAX_VALUE, true)).has().exactly(1, 2, 3).inOrder();
120   }
121 
122   public void testHeadSet_tooSmall() {
123     assertThat(ContiguousSet.create(Range.closed(1, 3), integers()).headSet(0)).isEmpty();
124   }
125 
126   public void testTailSet() {
127     ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
128     assertThat(set.tailSet(Integer.MIN_VALUE)).has().exactly(1, 2, 3).inOrder();
129     assertThat(set.tailSet(1)).has().exactly(1, 2, 3).inOrder();
130     assertThat(set.tailSet(2)).has().exactly(2, 3).inOrder();
131     assertThat(set.tailSet(3)).has().item(3);
132     assertThat(set.tailSet(Integer.MIN_VALUE, false)).has().exactly(1, 2, 3).inOrder();
133     assertThat(set.tailSet(1, false)).has().exactly(2, 3).inOrder();
134     assertThat(set.tailSet(2, false)).has().item(3);
135     assertThat(set.tailSet(3, false)).isEmpty();
136   }
137 
138   public void testTailSet_tooLarge() {
139     assertThat(ContiguousSet.create(Range.closed(1, 3), integers()).tailSet(4)).isEmpty();
140   }
141 
142   public void testSubSet() {
143     ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
144     assertThat(set.subSet(1, 4)).has().exactly(1, 2, 3).inOrder();
145     assertThat(set.subSet(2, 4)).has().exactly(2, 3).inOrder();
146     assertThat(set.subSet(3, 4)).has().item(3);
147     assertThat(set.subSet(3, 3)).isEmpty();
148     assertThat(set.subSet(2, 3)).has().item(2);
149     assertThat(set.subSet(1, 3)).has().exactly(1, 2).inOrder();
150     assertThat(set.subSet(1, 2)).has().item(1);
151     assertThat(set.subSet(2, 2)).isEmpty();
152     assertThat(set.subSet(Integer.MIN_VALUE, Integer.MAX_VALUE)).has().exactly(1, 2, 3).inOrder();
153     assertThat(set.subSet(1, true, 3, true)).has().exactly(1, 2, 3).inOrder();
154     assertThat(set.subSet(1, false, 3, true)).has().exactly(2, 3).inOrder();
155     assertThat(set.subSet(1, true, 3, false)).has().exactly(1, 2).inOrder();
156     assertThat(set.subSet(1, false, 3, false)).has().item(2);
157   }
158 
159   public void testSubSet_outOfOrder() {
160     ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
161     try {
162       set.subSet(3, 2);
163       fail();
164     } catch (IllegalArgumentException expected) {}
165   }
166 
167   public void testSubSet_tooLarge() {
168     assertThat(ContiguousSet.create(Range.closed(1, 3), integers()).subSet(4, 6)).isEmpty();
169   }
170 
171   public void testSubSet_tooSmall() {
172     assertThat(ContiguousSet.create(Range.closed(1, 3), integers()).subSet(-1, 0)).isEmpty();
173   }
174 
175   public void testFirst() {
176     assertEquals(1, ContiguousSet.create(Range.closed(1, 3), integers()).first().intValue());
177     assertEquals(1, ContiguousSet.create(Range.open(0, 4), integers()).first().intValue());
178     assertEquals(Integer.MIN_VALUE,
179         ContiguousSet.create(Range.<Integer>all(), integers()).first().intValue());
180   }
181 
182   public void testLast() {
183     assertEquals(3, ContiguousSet.create(Range.closed(1, 3), integers()).last().intValue());
184     assertEquals(3, ContiguousSet.create(Range.open(0, 4), integers()).last().intValue());
185     assertEquals(Integer.MAX_VALUE,
186         ContiguousSet.create(Range.<Integer>all(), integers()).last().intValue());
187   }
188 
189   public void testContains() {
190     ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
191     assertFalse(set.contains(0));
192     assertTrue(set.contains(1));
193     assertTrue(set.contains(2));
194     assertTrue(set.contains(3));
195     assertFalse(set.contains(4));
196     set = ContiguousSet.create(Range.open(0, 4), integers());
197     assertFalse(set.contains(0));
198     assertTrue(set.contains(1));
199     assertTrue(set.contains(2));
200     assertTrue(set.contains(3));
201     assertFalse(set.contains(4));
202     assertFalse(set.contains("blah"));
203   }
204 
205   public void testContainsAll() {
206     ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
207     for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) {
208       assertTrue(set.containsAll(subset));
209     }
210     for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) {
211       assertFalse(set.containsAll(Sets.union(subset, ImmutableSet.of(9))));
212     }
213     assertFalse(set.containsAll(ImmutableSet.of("blah")));
214   }
215 
216   public void testRange() {
217     assertEquals(Range.closed(1, 3),
218         ContiguousSet.create(Range.closed(1, 3), integers()).range());
219     assertEquals(Range.closed(1, 3),
220         ContiguousSet.create(Range.closedOpen(1, 4), integers()).range());
221     assertEquals(Range.closed(1, 3), ContiguousSet.create(Range.open(0, 4), integers()).range());
222     assertEquals(Range.closed(1, 3),
223         ContiguousSet.create(Range.openClosed(0, 3), integers()).range());
224 
225     assertEquals(Range.openClosed(0, 3),
226         ContiguousSet.create(Range.closed(1, 3), integers()).range(OPEN, CLOSED));
227     assertEquals(Range.openClosed(0, 3),
228         ContiguousSet.create(Range.closedOpen(1, 4), integers()).range(OPEN, CLOSED));
229     assertEquals(Range.openClosed(0, 3),
230         ContiguousSet.create(Range.open(0, 4), integers()).range(OPEN, CLOSED));
231     assertEquals(Range.openClosed(0, 3),
232         ContiguousSet.create(Range.openClosed(0, 3), integers()).range(OPEN, CLOSED));
233 
234     assertEquals(Range.open(0, 4),
235         ContiguousSet.create(Range.closed(1, 3), integers()).range(OPEN, OPEN));
236     assertEquals(Range.open(0, 4),
237         ContiguousSet.create(Range.closedOpen(1, 4), integers()).range(OPEN, OPEN));
238     assertEquals(Range.open(0, 4),
239         ContiguousSet.create(Range.open(0, 4), integers()).range(OPEN, OPEN));
240     assertEquals(Range.open(0, 4),
241         ContiguousSet.create(Range.openClosed(0, 3), integers()).range(OPEN, OPEN));
242 
243     assertEquals(Range.closedOpen(1, 4),
244         ContiguousSet.create(Range.closed(1, 3), integers()).range(CLOSED, OPEN));
245     assertEquals(Range.closedOpen(1, 4),
246         ContiguousSet.create(Range.closedOpen(1, 4), integers()).range(CLOSED, OPEN));
247     assertEquals(Range.closedOpen(1, 4),
248         ContiguousSet.create(Range.open(0, 4), integers()).range(CLOSED, OPEN));
249     assertEquals(Range.closedOpen(1, 4),
250         ContiguousSet.create(Range.openClosed(0, 3), integers()).range(CLOSED, OPEN));
251   }
252 
253   public void testRange_unboundedRange() {
254     assertEquals(Range.closed(Integer.MIN_VALUE, Integer.MAX_VALUE),
255         ContiguousSet.create(Range.<Integer>all(), integers()).range());
256     assertEquals(Range.atLeast(Integer.MIN_VALUE),
257         ContiguousSet.create(Range.<Integer>all(), integers()).range(CLOSED, OPEN));
258     assertEquals(Range.all(),
259         ContiguousSet.create(Range.<Integer>all(), integers()).range(OPEN, OPEN));
260     assertEquals(Range.atMost(Integer.MAX_VALUE),
261         ContiguousSet.create(Range.<Integer>all(), integers()).range(OPEN, CLOSED));
262   }
263 
264   public void testIntersection_empty() {
265     ContiguousSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
266     ContiguousSet<Integer> emptySet = ContiguousSet.create(Range.closedOpen(2, 2), integers());
267     assertEquals(ImmutableSet.of(), set.intersection(emptySet));
268     assertEquals(ImmutableSet.of(), emptySet.intersection(set));
269     assertEquals(ImmutableSet.of(),
270         ContiguousSet.create(Range.closed(-5, -1), integers()).intersection(
271             ContiguousSet.create(Range.open(3, 64), integers())));
272   }
273 
274   public void testIntersection() {
275     ContiguousSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
276     assertEquals(ImmutableSet.of(1, 2, 3),
277         ContiguousSet.create(Range.open(-1, 4), integers()).intersection(set));
278     assertEquals(ImmutableSet.of(1, 2, 3),
279         set.intersection(ContiguousSet.create(Range.open(-1, 4), integers())));
280   }
281 }
282