1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 package com.google.common.collect;
16
17 import static com.google.common.collect.BoundType.CLOSED;
18 import static com.google.common.collect.BoundType.OPEN;
19
20 import com.google.common.annotations.GwtCompatible;
21 import com.google.common.base.Objects;
22
23 import junit.framework.TestCase;
24
25 import java.util.Arrays;
26 import java.util.List;
27
28
29
30
31
32
33 @GwtCompatible(emulated = true)
34 public class GeneralRangeTest extends TestCase {
35 private static final Ordering<Integer> ORDERING = Ordering.natural().nullsFirst();
36
37 private static final List<Integer> IN_ORDER_VALUES = Arrays.asList(null, 1, 2, 3, 4, 5);
38
39 public void testCreateEmptyRangeFails() {
40 for (BoundType lboundType : BoundType.values()) {
41 for (BoundType uboundType : BoundType.values()) {
42 try {
43 GeneralRange.range(ORDERING, 4, lboundType, 2, uboundType);
44 fail("Expected IAE");
45 } catch (IllegalArgumentException expected) {}
46 }
47 }
48 }
49
50 public void testCreateEmptyRangeOpenOpenFails() {
51 for (Integer i : IN_ORDER_VALUES) {
52 try {
53 GeneralRange.range(ORDERING, i, OPEN, i, OPEN);
54 fail("Expected IAE");
55 } catch (IllegalArgumentException expected) {}
56 }
57 }
58
59 public void testCreateEmptyRangeClosedOpenSucceeds() {
60 for (Integer i : IN_ORDER_VALUES) {
61 GeneralRange<Integer> range = GeneralRange.range(ORDERING, i, CLOSED, i, OPEN);
62 for (Integer j : IN_ORDER_VALUES) {
63 assertFalse(range.contains(j));
64 }
65 }
66 }
67
68 public void testCreateEmptyRangeOpenClosedSucceeds() {
69 for (Integer i : IN_ORDER_VALUES) {
70 GeneralRange<Integer> range = GeneralRange.range(ORDERING, i, OPEN, i, CLOSED);
71 for (Integer j : IN_ORDER_VALUES) {
72 assertFalse(range.contains(j));
73 }
74 }
75 }
76
77 public void testCreateSingletonRangeSucceeds() {
78 for (Integer i : IN_ORDER_VALUES) {
79 GeneralRange<Integer> range = GeneralRange.range(ORDERING, i, CLOSED, i, CLOSED);
80 for (Integer j : IN_ORDER_VALUES) {
81 assertEquals(Objects.equal(i, j), range.contains(j));
82 }
83 }
84 }
85
86 public void testSingletonRange() {
87 GeneralRange<Integer> range = GeneralRange.range(ORDERING, 3, CLOSED, 3, CLOSED);
88 for (Integer i : IN_ORDER_VALUES) {
89 assertEquals(ORDERING.compare(i, 3) == 0, range.contains(i));
90 }
91 }
92
93 public void testLowerRange() {
94 for (BoundType lBoundType : BoundType.values()) {
95 GeneralRange<Integer> range = GeneralRange.downTo(ORDERING, 3, lBoundType);
96 for (Integer i : IN_ORDER_VALUES) {
97 assertEquals(ORDERING.compare(i, 3) > 0
98 || (ORDERING.compare(i, 3) == 0 && lBoundType == CLOSED), range.contains(i));
99 assertEquals(ORDERING.compare(i, 3) < 0
100 || (ORDERING.compare(i, 3) == 0 && lBoundType == OPEN), range.tooLow(i));
101 assertFalse(range.tooHigh(i));
102 }
103 }
104 }
105
106 public void testUpperRange() {
107 for (BoundType lBoundType : BoundType.values()) {
108 GeneralRange<Integer> range = GeneralRange.upTo(ORDERING, 3, lBoundType);
109 for (Integer i : IN_ORDER_VALUES) {
110 assertEquals(ORDERING.compare(i, 3) < 0
111 || (ORDERING.compare(i, 3) == 0 && lBoundType == CLOSED), range.contains(i));
112 assertEquals(ORDERING.compare(i, 3) > 0
113 || (ORDERING.compare(i, 3) == 0 && lBoundType == OPEN), range.tooHigh(i));
114 assertFalse(range.tooLow(i));
115 }
116 }
117 }
118
119 public void testDoublyBoundedAgainstRange() {
120 for (BoundType lboundType : BoundType.values()) {
121 for (BoundType uboundType : BoundType.values()) {
122 Range<Integer> range = Range.range(2, lboundType, 4, uboundType);
123 GeneralRange<Integer> gRange = GeneralRange.range(ORDERING, 2, lboundType, 4, uboundType);
124 for (Integer i : IN_ORDER_VALUES) {
125 assertEquals(i != null && range.contains(i), gRange.contains(i));
126 }
127 }
128 }
129 }
130
131 public void testIntersectAgainstMatchingEndpointsRange() {
132 GeneralRange<Integer> range = GeneralRange.range(ORDERING, 2, CLOSED, 4, OPEN);
133 assertEquals(GeneralRange.range(ORDERING, 2, OPEN, 4, OPEN),
134 range.intersect(GeneralRange.range(ORDERING, 2, OPEN, 4, CLOSED)));
135 }
136
137 public void testIntersectAgainstBiggerRange() {
138 GeneralRange<Integer> range = GeneralRange.range(ORDERING, 2, CLOSED, 4, OPEN);
139
140 assertEquals(GeneralRange.range(ORDERING, 2, CLOSED, 4, OPEN),
141 range.intersect(GeneralRange.range(ORDERING, null, OPEN, 5, CLOSED)));
142
143 assertEquals(GeneralRange.range(ORDERING, 2, OPEN, 4, OPEN),
144 range.intersect(GeneralRange.range(ORDERING, 2, OPEN, 5, CLOSED)));
145
146 assertEquals(GeneralRange.range(ORDERING, 2, CLOSED, 4, OPEN),
147 range.intersect(GeneralRange.range(ORDERING, 1, OPEN, 4, OPEN)));
148 }
149
150 public void testIntersectAgainstSmallerRange() {
151 GeneralRange<Integer> range = GeneralRange.range(ORDERING, 2, OPEN, 4, OPEN);
152 assertEquals(GeneralRange.range(ORDERING, 3, CLOSED, 4, OPEN),
153 range.intersect(GeneralRange.range(ORDERING, 3, CLOSED, 4, CLOSED)));
154 }
155
156 public void testIntersectOverlappingRange() {
157 GeneralRange<Integer> range = GeneralRange.range(ORDERING, 2, OPEN, 4, CLOSED);
158 assertEquals(GeneralRange.range(ORDERING, 3, CLOSED, 4, CLOSED),
159 range.intersect(GeneralRange.range(ORDERING, 3, CLOSED, 5, CLOSED)));
160 assertEquals(GeneralRange.range(ORDERING, 2, OPEN, 3, OPEN),
161 range.intersect(GeneralRange.range(ORDERING, 1, OPEN, 3, OPEN)));
162 }
163
164 public void testIntersectNonOverlappingRange() {
165 GeneralRange<Integer> range = GeneralRange.range(ORDERING, 2, OPEN, 4, CLOSED);
166 assertTrue(range.intersect(GeneralRange.range(ORDERING, 5, CLOSED, 6, CLOSED)).isEmpty());
167 assertTrue(range.intersect(GeneralRange.range(ORDERING, 1, OPEN, 2, OPEN)).isEmpty());
168 }
169
170 public void testFromRangeAll() {
171 assertEquals(GeneralRange.all(Ordering.natural()), GeneralRange.from(Range.all()));
172 }
173
174 public void testFromRangeOneEnd() {
175 for (BoundType endpointType : BoundType.values()) {
176 assertEquals(GeneralRange.upTo(Ordering.natural(), 3, endpointType),
177 GeneralRange.from(Range.upTo(3, endpointType)));
178
179 assertEquals(GeneralRange.downTo(Ordering.natural(), 3, endpointType),
180 GeneralRange.from(Range.downTo(3, endpointType)));
181 }
182 }
183
184 public void testFromRangeTwoEnds() {
185 for (BoundType lowerType : BoundType.values()) {
186 for (BoundType upperType : BoundType.values()) {
187 assertEquals(GeneralRange.range(Ordering.natural(), 3, lowerType, 4, upperType),
188 GeneralRange.from(Range.range(3, lowerType, 4, upperType)));
189 }
190 }
191 }
192
193 public void testReverse() {
194 assertEquals(GeneralRange.all(ORDERING.reverse()), GeneralRange.all(ORDERING).reverse());
195 assertEquals(GeneralRange.downTo(ORDERING.reverse(), 3, CLOSED),
196 GeneralRange.upTo(ORDERING, 3, CLOSED).reverse());
197 assertEquals(GeneralRange.upTo(ORDERING.reverse(), 3, OPEN),
198 GeneralRange.downTo(ORDERING, 3, OPEN).reverse());
199 assertEquals(GeneralRange.range(ORDERING.reverse(), 5, OPEN, 3, CLOSED),
200 GeneralRange.range(ORDERING, 3, CLOSED, 5, OPEN).reverse());
201 }
202 }
203