1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
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
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