1 /* 2 * Copyright (C) 2008 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.testing.SerializableTester.reserializeAndAssert; 23 import static com.google.common.truth.Truth.assertThat; 24 import static java.util.Arrays.asList; 25 26 import com.google.common.annotations.GwtCompatible; 27 import com.google.common.annotations.GwtIncompatible; 28 import com.google.common.base.Predicate; 29 import com.google.common.collect.testing.Helpers; 30 import com.google.common.testing.EqualsTester; 31 import java.util.Arrays; 32 import java.util.Collections; 33 import java.util.List; 34 import java.util.NoSuchElementException; 35 import junit.framework.TestCase; 36 37 /** 38 * Unit test for {@link Range}. 39 * 40 * @author Kevin Bourrillion 41 */ 42 @GwtCompatible(emulated = true) 43 public class RangeTest extends TestCase { testOpen()44 public void testOpen() { 45 Range<Integer> range = Range.open(4, 8); 46 checkContains(range); 47 assertTrue(range.hasLowerBound()); 48 assertEquals(4, (int) range.lowerEndpoint()); 49 assertEquals(OPEN, range.lowerBoundType()); 50 assertTrue(range.hasUpperBound()); 51 assertEquals(8, (int) range.upperEndpoint()); 52 assertEquals(OPEN, range.upperBoundType()); 53 assertFalse(range.isEmpty()); 54 assertEquals("(4..8)", range.toString()); 55 reserializeAndAssert(range); 56 } 57 testOpen_invalid()58 public void testOpen_invalid() { 59 try { 60 Range.open(4, 3); 61 fail(); 62 } catch (IllegalArgumentException expected) { 63 } 64 try { 65 Range.open(3, 3); 66 fail(); 67 } catch (IllegalArgumentException expected) { 68 } 69 } 70 testClosed()71 public void testClosed() { 72 Range<Integer> range = Range.closed(5, 7); 73 checkContains(range); 74 assertTrue(range.hasLowerBound()); 75 assertEquals(5, (int) range.lowerEndpoint()); 76 assertEquals(CLOSED, range.lowerBoundType()); 77 assertTrue(range.hasUpperBound()); 78 assertEquals(7, (int) range.upperEndpoint()); 79 assertEquals(CLOSED, range.upperBoundType()); 80 assertFalse(range.isEmpty()); 81 assertEquals("[5..7]", range.toString()); 82 reserializeAndAssert(range); 83 } 84 testClosed_invalid()85 public void testClosed_invalid() { 86 try { 87 Range.closed(4, 3); 88 fail(); 89 } catch (IllegalArgumentException expected) { 90 } 91 } 92 testOpenClosed()93 public void testOpenClosed() { 94 Range<Integer> range = Range.openClosed(4, 7); 95 checkContains(range); 96 assertTrue(range.hasLowerBound()); 97 assertEquals(4, (int) range.lowerEndpoint()); 98 assertEquals(OPEN, range.lowerBoundType()); 99 assertTrue(range.hasUpperBound()); 100 assertEquals(7, (int) range.upperEndpoint()); 101 assertEquals(CLOSED, range.upperBoundType()); 102 assertFalse(range.isEmpty()); 103 assertEquals("(4..7]", range.toString()); 104 reserializeAndAssert(range); 105 } 106 testClosedOpen()107 public void testClosedOpen() { 108 Range<Integer> range = Range.closedOpen(5, 8); 109 checkContains(range); 110 assertTrue(range.hasLowerBound()); 111 assertEquals(5, (int) range.lowerEndpoint()); 112 assertEquals(CLOSED, range.lowerBoundType()); 113 assertTrue(range.hasUpperBound()); 114 assertEquals(8, (int) range.upperEndpoint()); 115 assertEquals(OPEN, range.upperBoundType()); 116 assertFalse(range.isEmpty()); 117 assertEquals("[5..8)", range.toString()); 118 reserializeAndAssert(range); 119 } 120 testIsConnected()121 public void testIsConnected() { 122 assertTrue(Range.closed(3, 5).isConnected(Range.open(5, 6))); 123 assertTrue(Range.closed(3, 5).isConnected(Range.closed(5, 6))); 124 assertTrue(Range.closed(5, 6).isConnected(Range.closed(3, 5))); 125 assertTrue(Range.closed(3, 5).isConnected(Range.openClosed(5, 5))); 126 assertTrue(Range.open(3, 5).isConnected(Range.closed(5, 6))); 127 assertTrue(Range.closed(3, 7).isConnected(Range.open(6, 8))); 128 assertTrue(Range.open(3, 7).isConnected(Range.closed(5, 6))); 129 assertFalse(Range.closed(3, 5).isConnected(Range.closed(7, 8))); 130 assertFalse(Range.closed(3, 5).isConnected(Range.closedOpen(7, 7))); 131 } 132 checkContains(Range<Integer> range)133 private static void checkContains(Range<Integer> range) { 134 assertFalse(range.contains(4)); 135 assertTrue(range.contains(5)); 136 assertTrue(range.contains(7)); 137 assertFalse(range.contains(8)); 138 } 139 testSingleton()140 public void testSingleton() { 141 Range<Integer> range = Range.closed(4, 4); 142 assertFalse(range.contains(3)); 143 assertTrue(range.contains(4)); 144 assertFalse(range.contains(5)); 145 assertTrue(range.hasLowerBound()); 146 assertEquals(4, (int) range.lowerEndpoint()); 147 assertEquals(CLOSED, range.lowerBoundType()); 148 assertTrue(range.hasUpperBound()); 149 assertEquals(4, (int) range.upperEndpoint()); 150 assertEquals(CLOSED, range.upperBoundType()); 151 assertFalse(range.isEmpty()); 152 assertEquals("[4..4]", range.toString()); 153 reserializeAndAssert(range); 154 } 155 testEmpty1()156 public void testEmpty1() { 157 Range<Integer> range = Range.closedOpen(4, 4); 158 assertFalse(range.contains(3)); 159 assertFalse(range.contains(4)); 160 assertFalse(range.contains(5)); 161 assertTrue(range.hasLowerBound()); 162 assertEquals(4, (int) range.lowerEndpoint()); 163 assertEquals(CLOSED, range.lowerBoundType()); 164 assertTrue(range.hasUpperBound()); 165 assertEquals(4, (int) range.upperEndpoint()); 166 assertEquals(OPEN, range.upperBoundType()); 167 assertTrue(range.isEmpty()); 168 assertEquals("[4..4)", range.toString()); 169 reserializeAndAssert(range); 170 } 171 testEmpty2()172 public void testEmpty2() { 173 Range<Integer> range = Range.openClosed(4, 4); 174 assertFalse(range.contains(3)); 175 assertFalse(range.contains(4)); 176 assertFalse(range.contains(5)); 177 assertTrue(range.hasLowerBound()); 178 assertEquals(4, (int) range.lowerEndpoint()); 179 assertEquals(OPEN, range.lowerBoundType()); 180 assertTrue(range.hasUpperBound()); 181 assertEquals(4, (int) range.upperEndpoint()); 182 assertEquals(CLOSED, range.upperBoundType()); 183 assertTrue(range.isEmpty()); 184 assertEquals("(4..4]", range.toString()); 185 reserializeAndAssert(range); 186 } 187 testLessThan()188 public void testLessThan() { 189 Range<Integer> range = Range.lessThan(5); 190 assertTrue(range.contains(Integer.MIN_VALUE)); 191 assertTrue(range.contains(4)); 192 assertFalse(range.contains(5)); 193 assertUnboundedBelow(range); 194 assertTrue(range.hasUpperBound()); 195 assertEquals(5, (int) range.upperEndpoint()); 196 assertEquals(OPEN, range.upperBoundType()); 197 assertFalse(range.isEmpty()); 198 assertEquals("(-\u221e..5)", range.toString()); 199 reserializeAndAssert(range); 200 } 201 testGreaterThan()202 public void testGreaterThan() { 203 Range<Integer> range = Range.greaterThan(5); 204 assertFalse(range.contains(5)); 205 assertTrue(range.contains(6)); 206 assertTrue(range.contains(Integer.MAX_VALUE)); 207 assertTrue(range.hasLowerBound()); 208 assertEquals(5, (int) range.lowerEndpoint()); 209 assertEquals(OPEN, range.lowerBoundType()); 210 assertUnboundedAbove(range); 211 assertFalse(range.isEmpty()); 212 assertEquals("(5..+\u221e)", range.toString()); 213 reserializeAndAssert(range); 214 } 215 testAtLeast()216 public void testAtLeast() { 217 Range<Integer> range = Range.atLeast(6); 218 assertFalse(range.contains(5)); 219 assertTrue(range.contains(6)); 220 assertTrue(range.contains(Integer.MAX_VALUE)); 221 assertTrue(range.hasLowerBound()); 222 assertEquals(6, (int) range.lowerEndpoint()); 223 assertEquals(CLOSED, range.lowerBoundType()); 224 assertUnboundedAbove(range); 225 assertFalse(range.isEmpty()); 226 assertEquals("[6..+\u221e)", range.toString()); 227 reserializeAndAssert(range); 228 } 229 testAtMost()230 public void testAtMost() { 231 Range<Integer> range = Range.atMost(4); 232 assertTrue(range.contains(Integer.MIN_VALUE)); 233 assertTrue(range.contains(4)); 234 assertFalse(range.contains(5)); 235 assertUnboundedBelow(range); 236 assertTrue(range.hasUpperBound()); 237 assertEquals(4, (int) range.upperEndpoint()); 238 assertEquals(CLOSED, range.upperBoundType()); 239 assertFalse(range.isEmpty()); 240 assertEquals("(-\u221e..4]", range.toString()); 241 reserializeAndAssert(range); 242 } 243 testAll()244 public void testAll() { 245 Range<Integer> range = Range.all(); 246 assertTrue(range.contains(Integer.MIN_VALUE)); 247 assertTrue(range.contains(Integer.MAX_VALUE)); 248 assertUnboundedBelow(range); 249 assertUnboundedAbove(range); 250 assertFalse(range.isEmpty()); 251 assertEquals("(-\u221e..+\u221e)", range.toString()); 252 assertSame(range, reserializeAndAssert(range)); 253 assertSame(range, Range.all()); 254 } 255 assertUnboundedBelow(Range<Integer> range)256 private static void assertUnboundedBelow(Range<Integer> range) { 257 assertFalse(range.hasLowerBound()); 258 try { 259 range.lowerEndpoint(); 260 fail(); 261 } catch (IllegalStateException expected) { 262 } 263 try { 264 range.lowerBoundType(); 265 fail(); 266 } catch (IllegalStateException expected) { 267 } 268 } 269 assertUnboundedAbove(Range<Integer> range)270 private static void assertUnboundedAbove(Range<Integer> range) { 271 assertFalse(range.hasUpperBound()); 272 try { 273 range.upperEndpoint(); 274 fail(); 275 } catch (IllegalStateException expected) { 276 } 277 try { 278 range.upperBoundType(); 279 fail(); 280 } catch (IllegalStateException expected) { 281 } 282 } 283 testOrderingCuts()284 public void testOrderingCuts() { 285 Cut<Integer> a = Range.lessThan(0).lowerBound; 286 Cut<Integer> b = Range.atLeast(0).lowerBound; 287 Cut<Integer> c = Range.greaterThan(0).lowerBound; 288 Cut<Integer> d = Range.atLeast(1).lowerBound; 289 Cut<Integer> e = Range.greaterThan(1).lowerBound; 290 Cut<Integer> f = Range.greaterThan(1).upperBound; 291 292 Helpers.testCompareToAndEquals(ImmutableList.of(a, b, c, d, e, f)); 293 } 294 testContainsAll()295 public void testContainsAll() { 296 Range<Integer> range = Range.closed(3, 5); 297 assertTrue(range.containsAll(asList(3, 3, 4, 5))); 298 assertFalse(range.containsAll(asList(3, 3, 4, 5, 6))); 299 300 // We happen to know that natural-order sorted sets use a different code 301 // path, so we test that separately 302 assertTrue(range.containsAll(ImmutableSortedSet.of(3, 3, 4, 5))); 303 assertTrue(range.containsAll(ImmutableSortedSet.of(3))); 304 assertTrue(range.containsAll(ImmutableSortedSet.<Integer>of())); 305 assertFalse(range.containsAll(ImmutableSortedSet.of(3, 3, 4, 5, 6))); 306 307 assertTrue(Range.openClosed(3, 3).containsAll(Collections.<Integer>emptySet())); 308 } 309 testEncloses_open()310 public void testEncloses_open() { 311 Range<Integer> range = Range.open(2, 5); 312 assertTrue(range.encloses(range)); 313 assertTrue(range.encloses(Range.open(2, 4))); 314 assertTrue(range.encloses(Range.open(3, 5))); 315 assertTrue(range.encloses(Range.closed(3, 4))); 316 317 assertFalse(range.encloses(Range.openClosed(2, 5))); 318 assertFalse(range.encloses(Range.closedOpen(2, 5))); 319 assertFalse(range.encloses(Range.closed(1, 4))); 320 assertFalse(range.encloses(Range.closed(3, 6))); 321 assertFalse(range.encloses(Range.greaterThan(3))); 322 assertFalse(range.encloses(Range.lessThan(3))); 323 assertFalse(range.encloses(Range.atLeast(3))); 324 assertFalse(range.encloses(Range.atMost(3))); 325 assertFalse(range.encloses(Range.<Integer>all())); 326 } 327 testEncloses_closed()328 public void testEncloses_closed() { 329 Range<Integer> range = Range.closed(2, 5); 330 assertTrue(range.encloses(range)); 331 assertTrue(range.encloses(Range.open(2, 5))); 332 assertTrue(range.encloses(Range.openClosed(2, 5))); 333 assertTrue(range.encloses(Range.closedOpen(2, 5))); 334 assertTrue(range.encloses(Range.closed(3, 5))); 335 assertTrue(range.encloses(Range.closed(2, 4))); 336 337 assertFalse(range.encloses(Range.open(1, 6))); 338 assertFalse(range.encloses(Range.greaterThan(3))); 339 assertFalse(range.encloses(Range.lessThan(3))); 340 assertFalse(range.encloses(Range.atLeast(3))); 341 assertFalse(range.encloses(Range.atMost(3))); 342 assertFalse(range.encloses(Range.<Integer>all())); 343 } 344 testIntersection_empty()345 public void testIntersection_empty() { 346 Range<Integer> range = Range.closedOpen(3, 3); 347 assertEquals(range, range.intersection(range)); 348 349 try { 350 range.intersection(Range.open(3, 5)); 351 fail(); 352 } catch (IllegalArgumentException expected) { 353 // TODO(kevinb): convert the rest of this file to Truth someday 354 assertThat(expected).hasMessageThat().contains("connected"); 355 } 356 try { 357 range.intersection(Range.closed(0, 2)); 358 fail(); 359 } catch (IllegalArgumentException expected) { 360 assertThat(expected).hasMessageThat().contains("connected"); 361 } 362 } 363 testIntersection_deFactoEmpty()364 public void testIntersection_deFactoEmpty() { 365 Range<Integer> range = Range.open(3, 4); 366 assertEquals(range, range.intersection(range)); 367 368 assertEquals(Range.openClosed(3, 3), range.intersection(Range.atMost(3))); 369 assertEquals(Range.closedOpen(4, 4), range.intersection(Range.atLeast(4))); 370 371 try { 372 range.intersection(Range.lessThan(3)); 373 fail(); 374 } catch (IllegalArgumentException expected) { 375 assertThat(expected).hasMessageThat().contains("connected"); 376 } 377 try { 378 range.intersection(Range.greaterThan(4)); 379 fail(); 380 } catch (IllegalArgumentException expected) { 381 assertThat(expected).hasMessageThat().contains("connected"); 382 } 383 384 range = Range.closed(3, 4); 385 assertEquals(Range.openClosed(4, 4), range.intersection(Range.greaterThan(4))); 386 } 387 testIntersection_singleton()388 public void testIntersection_singleton() { 389 Range<Integer> range = Range.closed(3, 3); 390 assertEquals(range, range.intersection(range)); 391 392 assertEquals(range, range.intersection(Range.atMost(4))); 393 assertEquals(range, range.intersection(Range.atMost(3))); 394 assertEquals(range, range.intersection(Range.atLeast(3))); 395 assertEquals(range, range.intersection(Range.atLeast(2))); 396 397 assertEquals(Range.closedOpen(3, 3), range.intersection(Range.lessThan(3))); 398 assertEquals(Range.openClosed(3, 3), range.intersection(Range.greaterThan(3))); 399 400 try { 401 range.intersection(Range.atLeast(4)); 402 fail(); 403 } catch (IllegalArgumentException expected) { 404 assertThat(expected).hasMessageThat().contains("connected"); 405 } 406 try { 407 range.intersection(Range.atMost(2)); 408 fail(); 409 } catch (IllegalArgumentException expected) { 410 assertThat(expected).hasMessageThat().contains("connected"); 411 } 412 } 413 testIntersection_general()414 public void testIntersection_general() { 415 Range<Integer> range = Range.closed(4, 8); 416 417 // separate below 418 try { 419 range.intersection(Range.closed(0, 2)); 420 fail(); 421 } catch (IllegalArgumentException expected) { 422 assertThat(expected).hasMessageThat().contains("connected"); 423 } 424 425 // adjacent below 426 assertEquals(Range.closedOpen(4, 4), range.intersection(Range.closedOpen(2, 4))); 427 428 // overlap below 429 assertEquals(Range.closed(4, 6), range.intersection(Range.closed(2, 6))); 430 431 // enclosed with same start 432 assertEquals(Range.closed(4, 6), range.intersection(Range.closed(4, 6))); 433 434 // enclosed, interior 435 assertEquals(Range.closed(5, 7), range.intersection(Range.closed(5, 7))); 436 437 // enclosed with same end 438 assertEquals(Range.closed(6, 8), range.intersection(Range.closed(6, 8))); 439 440 // equal 441 assertEquals(range, range.intersection(range)); 442 443 // enclosing with same start 444 assertEquals(range, range.intersection(Range.closed(4, 10))); 445 446 // enclosing with same end 447 assertEquals(range, range.intersection(Range.closed(2, 8))); 448 449 // enclosing, exterior 450 assertEquals(range, range.intersection(Range.closed(2, 10))); 451 452 // overlap above 453 assertEquals(Range.closed(6, 8), range.intersection(Range.closed(6, 10))); 454 455 // adjacent above 456 assertEquals(Range.openClosed(8, 8), range.intersection(Range.openClosed(8, 10))); 457 458 // separate above 459 try { 460 range.intersection(Range.closed(10, 12)); 461 fail(); 462 } catch (IllegalArgumentException expected) { 463 assertThat(expected).hasMessageThat().contains("connected"); 464 } 465 } 466 testGap_overlapping()467 public void testGap_overlapping() { 468 Range<Integer> range = Range.closedOpen(3, 5); 469 470 try { 471 range.gap(Range.closed(4, 6)); 472 fail(); 473 } catch (IllegalArgumentException expected) { 474 } 475 try { 476 range.gap(Range.closed(2, 4)); 477 fail(); 478 } catch (IllegalArgumentException expected) { 479 } 480 try { 481 range.gap(Range.closed(2, 3)); 482 fail(); 483 } catch (IllegalArgumentException expected) { 484 } 485 } 486 testGap_invalidRangesWithInfinity()487 public void testGap_invalidRangesWithInfinity() { 488 try { 489 Range.atLeast(1).gap(Range.atLeast(2)); 490 fail(); 491 } catch (IllegalArgumentException expected) { 492 } 493 494 try { 495 Range.atLeast(2).gap(Range.atLeast(1)); 496 fail(); 497 } catch (IllegalArgumentException expected) { 498 } 499 500 try { 501 Range.atMost(1).gap(Range.atMost(2)); 502 fail(); 503 } catch (IllegalArgumentException expected) { 504 } 505 506 try { 507 Range.atMost(2).gap(Range.atMost(1)); 508 fail(); 509 } catch (IllegalArgumentException expected) { 510 } 511 } 512 testGap_connectedAdjacentYieldsEmpty()513 public void testGap_connectedAdjacentYieldsEmpty() { 514 Range<Integer> range = Range.open(3, 4); 515 516 assertEquals(Range.closedOpen(4, 4), range.gap(Range.atLeast(4))); 517 assertEquals(Range.openClosed(3, 3), range.gap(Range.atMost(3))); 518 } 519 testGap_general()520 public void testGap_general() { 521 Range<Integer> openRange = Range.open(4, 8); 522 Range<Integer> closedRange = Range.closed(4, 8); 523 524 // first range open end, second range open start 525 assertEquals(Range.closed(2, 4), Range.lessThan(2).gap(openRange)); 526 assertEquals(Range.closed(2, 4), openRange.gap(Range.lessThan(2))); 527 528 // first range closed end, second range open start 529 assertEquals(Range.openClosed(2, 4), Range.atMost(2).gap(openRange)); 530 assertEquals(Range.openClosed(2, 4), openRange.gap(Range.atMost(2))); 531 532 // first range open end, second range closed start 533 assertEquals(Range.closedOpen(2, 4), Range.lessThan(2).gap(closedRange)); 534 assertEquals(Range.closedOpen(2, 4), closedRange.gap(Range.lessThan(2))); 535 536 // first range closed end, second range closed start 537 assertEquals(Range.open(2, 4), Range.atMost(2).gap(closedRange)); 538 assertEquals(Range.open(2, 4), closedRange.gap(Range.atMost(2))); 539 } 540 541 // TODO(cpovirk): More extensive testing of gap(). 542 testSpan_general()543 public void testSpan_general() { 544 Range<Integer> range = Range.closed(4, 8); 545 546 // separate below 547 assertEquals(Range.closed(0, 8), range.span(Range.closed(0, 2))); 548 assertEquals(Range.atMost(8), range.span(Range.atMost(2))); 549 550 // adjacent below 551 assertEquals(Range.closed(2, 8), range.span(Range.closedOpen(2, 4))); 552 assertEquals(Range.atMost(8), range.span(Range.lessThan(4))); 553 554 // overlap below 555 assertEquals(Range.closed(2, 8), range.span(Range.closed(2, 6))); 556 assertEquals(Range.atMost(8), range.span(Range.atMost(6))); 557 558 // enclosed with same start 559 assertEquals(range, range.span(Range.closed(4, 6))); 560 561 // enclosed, interior 562 assertEquals(range, range.span(Range.closed(5, 7))); 563 564 // enclosed with same end 565 assertEquals(range, range.span(Range.closed(6, 8))); 566 567 // equal 568 assertEquals(range, range.span(range)); 569 570 // enclosing with same start 571 assertEquals(Range.closed(4, 10), range.span(Range.closed(4, 10))); 572 assertEquals(Range.atLeast(4), range.span(Range.atLeast(4))); 573 574 // enclosing with same end 575 assertEquals(Range.closed(2, 8), range.span(Range.closed(2, 8))); 576 assertEquals(Range.atMost(8), range.span(Range.atMost(8))); 577 578 // enclosing, exterior 579 assertEquals(Range.closed(2, 10), range.span(Range.closed(2, 10))); 580 assertEquals(Range.<Integer>all(), range.span(Range.<Integer>all())); 581 582 // overlap above 583 assertEquals(Range.closed(4, 10), range.span(Range.closed(6, 10))); 584 assertEquals(Range.atLeast(4), range.span(Range.atLeast(6))); 585 586 // adjacent above 587 assertEquals(Range.closed(4, 10), range.span(Range.openClosed(8, 10))); 588 assertEquals(Range.atLeast(4), range.span(Range.greaterThan(8))); 589 590 // separate above 591 assertEquals(Range.closed(4, 12), range.span(Range.closed(10, 12))); 592 assertEquals(Range.atLeast(4), range.span(Range.atLeast(10))); 593 } 594 testApply()595 public void testApply() { 596 Predicate<Integer> predicate = Range.closed(2, 3); 597 assertFalse(predicate.apply(1)); 598 assertTrue(predicate.apply(2)); 599 assertTrue(predicate.apply(3)); 600 assertFalse(predicate.apply(4)); 601 } 602 testEquals()603 public void testEquals() { 604 new EqualsTester() 605 .addEqualityGroup(Range.open(1, 5), Range.range(1, OPEN, 5, OPEN)) 606 .addEqualityGroup(Range.greaterThan(2), Range.greaterThan(2)) 607 .addEqualityGroup(Range.all(), Range.all()) 608 .addEqualityGroup("Phil") 609 .testEquals(); 610 } 611 612 @GwtIncompatible // TODO(b/148207871): Restore once Eclipse compiler no longer flakes for this. testLegacyComparable()613 public void testLegacyComparable() { 614 Range<LegacyComparable> range = Range.closed(LegacyComparable.X, LegacyComparable.Y); 615 } 616 617 static final DiscreteDomain<Integer> UNBOUNDED_DOMAIN = 618 new DiscreteDomain<Integer>() { 619 @Override 620 public Integer next(Integer value) { 621 return integers().next(value); 622 } 623 624 @Override 625 public Integer previous(Integer value) { 626 return integers().previous(value); 627 } 628 629 @Override 630 public long distance(Integer start, Integer end) { 631 return integers().distance(start, end); 632 } 633 }; 634 testCanonical()635 public void testCanonical() { 636 assertEquals(Range.closedOpen(1, 5), Range.closed(1, 4).canonical(integers())); 637 assertEquals(Range.closedOpen(1, 5), Range.open(0, 5).canonical(integers())); 638 assertEquals(Range.closedOpen(1, 5), Range.closedOpen(1, 5).canonical(integers())); 639 assertEquals(Range.closedOpen(1, 5), Range.openClosed(0, 4).canonical(integers())); 640 641 assertEquals( 642 Range.closedOpen(Integer.MIN_VALUE, 0), 643 Range.closedOpen(Integer.MIN_VALUE, 0).canonical(integers())); 644 645 assertEquals(Range.closedOpen(Integer.MIN_VALUE, 0), Range.lessThan(0).canonical(integers())); 646 assertEquals(Range.closedOpen(Integer.MIN_VALUE, 1), Range.atMost(0).canonical(integers())); 647 assertEquals(Range.atLeast(0), Range.atLeast(0).canonical(integers())); 648 assertEquals(Range.atLeast(1), Range.greaterThan(0).canonical(integers())); 649 650 assertEquals(Range.atLeast(Integer.MIN_VALUE), Range.<Integer>all().canonical(integers())); 651 } 652 testCanonical_unboundedDomain()653 public void testCanonical_unboundedDomain() { 654 assertEquals(Range.lessThan(0), Range.lessThan(0).canonical(UNBOUNDED_DOMAIN)); 655 assertEquals(Range.lessThan(1), Range.atMost(0).canonical(UNBOUNDED_DOMAIN)); 656 assertEquals(Range.atLeast(0), Range.atLeast(0).canonical(UNBOUNDED_DOMAIN)); 657 assertEquals(Range.atLeast(1), Range.greaterThan(0).canonical(UNBOUNDED_DOMAIN)); 658 659 assertEquals(Range.all(), Range.<Integer>all().canonical(UNBOUNDED_DOMAIN)); 660 } 661 testEncloseAll()662 public void testEncloseAll() { 663 assertEquals(Range.closed(0, 0), Range.encloseAll(Arrays.asList(0))); 664 assertEquals(Range.closed(-3, 5), Range.encloseAll(Arrays.asList(5, -3))); 665 assertEquals(Range.closed(-3, 5), Range.encloseAll(Arrays.asList(1, 2, 2, 2, 5, -3, 0, -1))); 666 } 667 testEncloseAll_empty()668 public void testEncloseAll_empty() { 669 try { 670 Range.encloseAll(ImmutableSet.<Integer>of()); 671 fail(); 672 } catch (NoSuchElementException expected) { 673 } 674 } 675 testEncloseAll_nullValue()676 public void testEncloseAll_nullValue() { 677 List<Integer> nullFirst = Lists.newArrayList(null, 0); 678 try { 679 Range.encloseAll(nullFirst); 680 fail(); 681 } catch (NullPointerException expected) { 682 } 683 List<Integer> nullNotFirst = Lists.newArrayList(0, null); 684 try { 685 Range.encloseAll(nullNotFirst); 686 fail(); 687 } catch (NullPointerException expected) { 688 } 689 } 690 testEquivalentFactories()691 public void testEquivalentFactories() { 692 new EqualsTester() 693 .addEqualityGroup(Range.all()) 694 .addEqualityGroup(Range.atLeast(1), Range.downTo(1, CLOSED)) 695 .addEqualityGroup(Range.greaterThan(1), Range.downTo(1, OPEN)) 696 .addEqualityGroup(Range.atMost(7), Range.upTo(7, CLOSED)) 697 .addEqualityGroup(Range.lessThan(7), Range.upTo(7, OPEN)) 698 .addEqualityGroup(Range.open(1, 7), Range.range(1, OPEN, 7, OPEN)) 699 .addEqualityGroup(Range.openClosed(1, 7), Range.range(1, OPEN, 7, CLOSED)) 700 .addEqualityGroup(Range.closed(1, 7), Range.range(1, CLOSED, 7, CLOSED)) 701 .addEqualityGroup(Range.closedOpen(1, 7), Range.range(1, CLOSED, 7, OPEN)) 702 .testEquals(); 703 } 704 } 705