| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.commons.functor.range; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| |
| import org.apache.commons.functor.BaseFunctorTest; |
| import org.apache.commons.functor.Function; |
| import org.apache.commons.functor.generator.Generator; |
| import org.apache.commons.functor.generator.loop.IteratorToGeneratorAdapter; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| /** |
| * @version $Revision: 1515264 $ $Date: 2013-08-18 23:51:41 -0300 (Sun, 18 Aug 2013) $ |
| */ |
| public class TestIntegerRange extends BaseFunctorTest { |
| |
| // Attributes |
| // ------------------------------------------------------------------------ |
| private IntegerRange ascIntRange = null; |
| private IntegerRange descIntRange = null; |
| private Collection<Integer> expectedAsc = null; |
| private Collection<Integer> expectedDesc = null; |
| |
| // Test set up |
| // ------------------------------------------------------------------------ |
| @Before |
| public void setUp() { |
| ascIntRange = Ranges.integerRange(0, 10); |
| descIntRange = Ranges.integerRange(10, 0); |
| expectedAsc = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); |
| expectedDesc = Arrays.asList(10, 9, 8, 7, 6, 5, 4, 3, 2, 1); |
| } |
| |
| @After |
| public void tearDown() { |
| ascIntRange = null; |
| descIntRange = null; |
| } |
| |
| @Override |
| protected Object makeFunctor() throws Exception { |
| return Ranges.integerRange(10, 20); |
| } |
| |
| // Generator tests |
| // ------------------------------------------------------------------------ |
| |
| @Test |
| public void testGenerateListExample() { |
| // generates a collection of Integers from 0 (inclusive) to 10 (exclusive) |
| { |
| List<? super Integer> list = (List<? super Integer>) ( |
| IteratorToGeneratorAdapter.adapt(Ranges.integerRange(0,10)).to(new ArrayList<Integer>())); |
| for (int i=0;i<10;i++) { |
| assertEquals(Integer.valueOf(i),list.get(i)); |
| } |
| } |
| |
| // generates a collection of Integers from 10 (inclusive) to 0 (exclusive) |
| { |
| List<? super Integer> list = (List<? super Integer>) ( |
| IteratorToGeneratorAdapter.adapt(Ranges.integerRange(10,0)).to(new ArrayList<Integer>())); |
| for (int i=10;i>0;i--) { |
| assertEquals(Integer.valueOf(i),list.get(10-i)); |
| } |
| } |
| } |
| |
| @Test |
| public void testStepChecking() { |
| { |
| Ranges.integerRange(2, 2, 0); // step of 0 is ok when range is empty |
| } |
| { |
| Ranges.integerRange(2, 2, 1); // positive step is ok when range is empty |
| } |
| { |
| Ranges.integerRange(2, 2, -1); // negative step is ok when range is empty |
| } |
| { |
| Ranges.integerRange(0, 1, 10); // big steps are ok |
| } |
| { |
| Ranges.integerRange(1, 0, -10); // big steps are ok |
| } |
| try { |
| Ranges.integerRange(0, 1, 0); |
| fail("Expected IllegalArgumentException"); |
| } catch(IllegalArgumentException e) { |
| // expected |
| } |
| try { |
| Ranges.integerRange(0, 1, -1); |
| fail("Expected IllegalArgumentException"); |
| } catch(IllegalArgumentException e) { |
| // expected |
| } |
| try { |
| Ranges.integerRange(0, -1, 1); |
| fail("Expected IllegalArgumentException"); |
| } catch(IllegalArgumentException e) { |
| // expected |
| } |
| } |
| |
| @Test |
| public void testObjectConstructor() { |
| IntegerRange range = Ranges.integerRange(Integer.valueOf(0), Integer.valueOf(5)); |
| assertEquals("[0, 1, 2, 3, 4]", IteratorToGeneratorAdapter.adapt(range).toCollection().toString()); |
| range = Ranges.integerRange(Integer.valueOf(0), Integer.valueOf(5), Integer.valueOf(1)); |
| assertEquals("[0, 1, 2, 3, 4]", IteratorToGeneratorAdapter.adapt(range).toCollection().toString()); |
| } |
| |
| |
| @Test |
| public void testReverseStep() { |
| IntegerRange range = Ranges.integerRange(10, 0, -2); |
| assertEquals("[10, 8, 6, 4, 2]", IteratorToGeneratorAdapter.adapt(range).toCollection().toString()); |
| } |
| |
| @Test |
| public void testStep() { |
| IntegerRange range = Ranges.integerRange(0, 10, 2); |
| assertEquals("[0, 2, 4, 6, 8]", IteratorToGeneratorAdapter.adapt(range).toCollection().toString()); |
| } |
| |
| @Test |
| public void testForwardRange() { |
| IntegerRange range = Ranges.integerRange(0, 5); |
| assertEquals("[0, 1, 2, 3, 4]", IteratorToGeneratorAdapter.adapt(range).toCollection().toString()); |
| } |
| |
| @Test |
| public void testReverseRange() { |
| IntegerRange range = Ranges.integerRange(5, 0); |
| assertEquals("[5, 4, 3, 2, 1]", IteratorToGeneratorAdapter.adapt(range).toCollection().toString()); |
| } |
| |
| @Test |
| public void testEdgeCase() { |
| IntegerRange range = Ranges.integerRange(Integer.MAX_VALUE - 3, Integer.MAX_VALUE); |
| assertEquals("[2147483644, 2147483645, 2147483646]", IteratorToGeneratorAdapter.adapt(range).toCollection().toString()); |
| } |
| |
| @Test |
| public void testBoundaries() { |
| IntegerRange range = Ranges.integerRange(0, 10); |
| assertEquals(new Endpoint<Comparable<?>>(0, BoundType.CLOSED), |
| range.getLeftEndpoint()); |
| assertEquals(new Endpoint<Comparable<?>>(10, BoundType.OPEN), |
| range.getRightEndpoint()); |
| } |
| |
| @Test |
| public void testClosedClosedAscending() { |
| // [-5, 5], 3 = -5, -2, 1, 4 |
| IntegerRange range = Ranges.integerRange(-5, BoundType.CLOSED, 5, |
| BoundType.CLOSED, 3); |
| // [-5, 5], 3 = -5, -2, 1, 4 |
| List<Integer> expected = Arrays.asList(-5, -2, 1, 4); |
| Collection<Integer> elements = IteratorToGeneratorAdapter.adapt(range).toCollection(); |
| assertEquals(expected, elements); |
| } |
| |
| @Test |
| public void testOpenClosedAscending() { |
| // (-5, 5], 3 = -2, 1, 4 |
| IntegerRange range = Ranges.integerRange(-5, BoundType.OPEN, 5, |
| BoundType.CLOSED, 3); |
| // (-5, 5], 3 = -2, 1, 4 |
| List<Integer> expected = Arrays.asList(-2, 1, 4); |
| Collection<Integer> elements = IteratorToGeneratorAdapter.adapt(range).toCollection(); |
| assertEquals(expected, elements); |
| } |
| |
| @Test |
| public void testClosedOpenAscending() { |
| // [-5, 5), 3 = -5, -2, 1, 4 |
| IntegerRange range = Ranges.integerRange(-5, BoundType.CLOSED, 5, |
| BoundType.OPEN, 3); |
| // (-5, 5], 3 = -5, -2, 1, 4 |
| List<Integer> expected = Arrays.asList(-5, -2, 1, 4); |
| Collection<Integer> elements = IteratorToGeneratorAdapter.adapt(range).toCollection(); |
| assertEquals(expected, elements); |
| } |
| |
| @Test |
| public void testOpenOpenAscending() { |
| // (-5, 5), 3 = -2, 1, 4 |
| IntegerRange range = Ranges.integerRange(-5, BoundType.OPEN, 5, |
| BoundType.OPEN, 3); |
| // (-5, 5), 3 = -2, 1, 4 |
| List<Integer> expected = Arrays.asList(-2, 1, 4); |
| Collection<Integer> elements = IteratorToGeneratorAdapter.adapt(range).toCollection(); |
| assertEquals(expected, elements); |
| } |
| |
| @Test |
| public void testSingleStepAscending() { |
| // (-2, 2], 1 = -1, 0, 1, 2 |
| IntegerRange range = Ranges.integerRange(-2, BoundType.OPEN, 2, |
| BoundType.CLOSED, 1); |
| // (-2, 2], 1 = -1, 0, 1, 2 |
| List<Integer> expected = Arrays.asList(-1, 0, 1, 2); |
| Collection<Integer> elements = IteratorToGeneratorAdapter.adapt(range).toCollection(); |
| assertEquals(expected, elements); |
| } |
| |
| @Test |
| public void testClosedClosedDescending() { |
| // [5, -5], -3 = 5, 2, -1, -4 |
| IntegerRange range = Ranges.integerRange(5, BoundType.CLOSED, -5, |
| BoundType.CLOSED, -3); |
| // [5, -5], -3 = 5, 2, -1, -4 |
| List<Integer> expected = Arrays.asList(5, 2, -1, -4); |
| Collection<Integer> elements = IteratorToGeneratorAdapter.adapt(range).toCollection(); |
| assertEquals(expected, elements); |
| } |
| |
| @Test |
| public void testOpenClosedDescending() { |
| // (5, -5], -3 = 2, -1, -4 |
| IntegerRange range = Ranges.integerRange(5, BoundType.OPEN, -5, |
| BoundType.CLOSED, -3); |
| // (5, -5], -3 = 2, -1, -4 |
| List<Integer> expected = Arrays.asList(2, -1, -4); |
| Collection<Integer> elements = IteratorToGeneratorAdapter.adapt(range).toCollection(); |
| assertEquals(expected, elements); |
| } |
| |
| @Test |
| public void testClosedOpenDescending() { |
| // [5, -5), -3 = 5, 2, -1, -4 |
| IntegerRange range = Ranges.integerRange(5, BoundType.CLOSED, -5, |
| BoundType.OPEN, -3); |
| // [5, -5), -3 = 5, 2, -1, -4 |
| List<Integer> expected = Arrays.asList(5, 2, -1, -4); |
| Collection<Integer> elements = IteratorToGeneratorAdapter.adapt(range).toCollection(); |
| assertEquals(expected, elements); |
| } |
| |
| @Test |
| public void testOpenOpenDescending() { |
| // (5, -5), -3 = 2, -1, -4 |
| IntegerRange range = Ranges.integerRange(5, BoundType.OPEN, -5, |
| BoundType.OPEN, -3); |
| // (5, -5), -3 = 2, -1, -4 |
| List<Integer> expected = Arrays.asList(2, -1, -4); |
| Collection<Integer> elements = IteratorToGeneratorAdapter.adapt(range).toCollection(); |
| assertEquals(expected, elements); |
| } |
| |
| @Test |
| public void testSingleStepDescending() { |
| // [2, -2), -1 = 2, 1, 0, -1 |
| IntegerRange range = Ranges.integerRange(2, BoundType.CLOSED, -2, |
| BoundType.OPEN, -1); |
| // [2, -2), -1 = 2, 1, 0, -1 |
| List<Integer> expected = Arrays.asList(2, 1, 0, -1); |
| Collection<Integer> elements = IteratorToGeneratorAdapter.adapt(range).toCollection(); |
| assertEquals(expected, elements); |
| } |
| |
| @Test |
| public void testAscending() { |
| final List<Integer> list = new ArrayList<Integer>(); |
| for (int i : ascIntRange) { |
| list.add(i); |
| } |
| assertTrue(expectedAsc.containsAll(list)); |
| } |
| |
| @Test |
| public void testDescending() { |
| final List<Integer> list = new ArrayList<Integer>(); |
| for (int i : descIntRange) { |
| list.add(i); |
| } |
| assertTrue(expectedDesc.containsAll(list)); |
| } |
| |
| @Test |
| public void testToCollection() { |
| Collection<Integer> ascCol = IteratorToGeneratorAdapter.adapt(ascIntRange).toCollection(); |
| assertEquals("Different collections", expectedAsc, ascCol); |
| Collection<Integer> descCol = IteratorToGeneratorAdapter.adapt(descIntRange).toCollection(); |
| assertEquals("Different collections", expectedDesc, descCol); |
| } |
| |
| @Test |
| public void testTransformedGenerator() { |
| int expected = 45; |
| int total = IteratorToGeneratorAdapter.adapt(ascIntRange) |
| .to(new Function<Generator<? extends Integer>, Integer>() { |
| |
| public Integer evaluate(Generator<? extends Integer> obj) { |
| int total = 0; |
| for (Object element : obj.toCollection()) { |
| total += (Integer) element; |
| } |
| return total; |
| } |
| }); |
| assertEquals(expected, total); |
| expected = 55; |
| total = IteratorToGeneratorAdapter.adapt(descIntRange) |
| .to(new Function<Generator<? extends Integer>, Integer>() { |
| |
| public Integer evaluate(Generator<? extends Integer> obj) { |
| int total = 0; |
| for (Object element : obj.toCollection()) { |
| total += (Integer) element; |
| } |
| return total; |
| } |
| }); |
| assertEquals(expected, total); |
| } |
| |
| // Range tests |
| // --------------------------------------------------------------- |
| |
| // A base range with all integers between -6 and 6 |
| private final List<Integer> fullRange = Collections.unmodifiableList(Arrays |
| .asList(-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6)); |
| |
| @Test |
| public void testEmptyRanges() { |
| IntegerRange empty1 = Ranges.integerRange(-2, BoundType.OPEN, -1, |
| BoundType.OPEN, 2); |
| assertTrue("The range was expected to be empty.", empty1.isEmpty()); |
| IntegerRange empty2 = Ranges.integerRange(2, BoundType.OPEN, 0, |
| BoundType.OPEN, -2); |
| assertTrue("The range was expected to be empty.", empty2.isEmpty()); |
| IntegerRange empty3 = Ranges.integerRange(0, BoundType.OPEN, 1, |
| BoundType.CLOSED, 2); |
| assertTrue("The range was expected to be empty.", empty3.isEmpty()); |
| IntegerRange empty4 = Ranges.integerRange(-3, BoundType.OPEN, -3, |
| BoundType.OPEN, 1); |
| assertTrue("The range was expected to be empty.", empty4.isEmpty()); |
| IntegerRange empty5 = Ranges.integerRange(-3, BoundType.CLOSED, -3, |
| BoundType.OPEN, 1); |
| assertTrue("The range was expected to be empty.", empty5.isEmpty()); |
| IntegerRange empty6 = Ranges.integerRange(1, BoundType.OPEN, 0, |
| BoundType.CLOSED, -2); |
| assertTrue("The range was expected to be empty.", empty6.isEmpty()); |
| IntegerRange notEmpty1 = Ranges.integerRange(-3, BoundType.CLOSED, -3, |
| BoundType.CLOSED, 1); |
| assertFalse("The range was not expected to be empty.", |
| notEmpty1.isEmpty()); |
| IntegerRange notEmpty2 = Ranges.integerRange(-3, BoundType.OPEN, -2, |
| BoundType.CLOSED, 1); |
| assertFalse("The range was not expected to be empty.", |
| notEmpty2.isEmpty()); |
| IntegerRange notEmpty3 = Ranges.integerRange(2, BoundType.OPEN, 1, |
| BoundType.CLOSED, -1); |
| assertFalse("The range was not expected to be empty.", |
| notEmpty3.isEmpty()); |
| IntegerRange notEmpty4 = Ranges.integerRange(2, BoundType.CLOSED, 1, |
| BoundType.OPEN, -1); |
| assertFalse("The range was not expected to be empty.", |
| notEmpty4.isEmpty()); |
| IntegerRange notEmpty5 = Ranges.integerRange(1, BoundType.CLOSED, 2, |
| BoundType.OPEN, 1); |
| assertFalse("The range was not expected to be empty.", |
| notEmpty5.isEmpty()); |
| } |
| |
| @Test |
| public void testClosedClosedAscendingContains() { |
| // [-5, 5], 3 = -5, -2, 1, 4 |
| IntegerRange range = Ranges.integerRange(-5, BoundType.CLOSED, 5, |
| BoundType.CLOSED, 3); |
| // [-5, 5], 3 = -5, -2, 1, 4 |
| List<Integer> arr = Arrays.asList(-5, -2, 1, 4); |
| for (Integer element : arr) { |
| assertTrue("Expected element [" + element + |
| "] is missing in range [" + range + "]", |
| range.contains(element)); |
| } |
| List<Integer> elementsNotPresent = new ArrayList<Integer>(fullRange); |
| elementsNotPresent.removeAll(arr); |
| for (Integer element : elementsNotPresent) { |
| assertFalse("Unexpected element [" + element + |
| "] is present in range [" + range + "]", |
| range.contains(element)); |
| } |
| } |
| |
| @Test |
| public void testOpenClosedAscendingContains() { |
| // (-5, 5], 3 = -2, 1, 4 |
| IntegerRange range = Ranges.integerRange(-5, BoundType.OPEN, 5, |
| BoundType.CLOSED, 3); |
| // (-5, 5], 3 = -2, 1, 4 |
| List<Integer> arr = Arrays.asList(-2, 1, 4); |
| for (Integer element : arr) { |
| assertTrue("Expected element [" + element + |
| "] is missing in range [" + range + "]", |
| range.contains(element)); |
| } |
| List<Integer> elementsNotPresent = new ArrayList<Integer>(fullRange); |
| elementsNotPresent.removeAll(arr); |
| for (Integer element : elementsNotPresent) { |
| assertFalse("Unexpected element [" + element + |
| "] is present in range [" + range + "]", |
| range.contains(element)); |
| } |
| } |
| |
| @Test |
| public void testClosedOpenAscendingContains() { |
| // [-5, 5), 3 = -5, -2, 1, 4 |
| IntegerRange range = Ranges.integerRange(-5, BoundType.CLOSED, 5, |
| BoundType.OPEN, 3); |
| // (-5, 5], 3 = -5, -2, 1, 4 |
| List<Integer> arr = Arrays.asList(-5, -2, 1, 4); |
| for (Integer element : arr) { |
| assertTrue("Expected element [" + element + |
| "] is missing in range [" + range + "]", |
| range.contains(element)); |
| } |
| List<Integer> elementsNotPresent = new ArrayList<Integer>(fullRange); |
| elementsNotPresent.removeAll(arr); |
| for (Integer element : elementsNotPresent) { |
| assertFalse("Unexpected element [" + element + |
| "] is present in range [" + range + "]", |
| range.contains(element)); |
| } |
| } |
| |
| @Test |
| public void testOpenOpenAscendingContains() { |
| // (-5, 5), 3 = -2, 1, 4 |
| IntegerRange range = Ranges.integerRange(-5, BoundType.OPEN, 5, |
| BoundType.OPEN, 3); |
| // (-5, 5), 3 = -2, 1, 4 |
| List<Integer> arr = Arrays.asList(-2, 1, 4); |
| for (Integer element : arr) { |
| assertTrue("Expected element [" + element + |
| "] is missing in range [" + range + "]", |
| range.contains(element)); |
| } |
| List<Integer> elementsNotPresent = new ArrayList<Integer>(fullRange); |
| elementsNotPresent.removeAll(arr); |
| for (Integer element : elementsNotPresent) { |
| assertFalse("Unexpected element [" + element + |
| "] is present in range [" + range + "]", |
| range.contains(element)); |
| } |
| } |
| |
| @Test |
| public void testContainsSingleStepAscending() { |
| // (-2, 2], 1 = -1, 0, 1, 2 |
| IntegerRange ascendingRange = Ranges.integerRange(-2, BoundType.OPEN, 2, |
| BoundType.CLOSED, 1); |
| // (-2, 2], 1 = -1, 0, 1, 2 |
| List<Integer> arr = Arrays.asList(-1, 0, 1, 2); |
| for (Integer element : arr) { |
| assertTrue("Expected element [" + element + |
| "] is missing in range [" + ascendingRange + "]", |
| ascendingRange.contains(element)); |
| } |
| List<Integer> elementsNotPresent = new ArrayList<Integer>(fullRange); |
| elementsNotPresent.removeAll(arr); |
| for (Integer element : elementsNotPresent) { |
| assertFalse("Unexpected element [" + element + |
| "] is present in range [" + ascendingRange + |
| "]", |
| ascendingRange.contains(element)); |
| } |
| } |
| |
| @Test |
| public void testClosedClosedDescendingContains() { |
| // [5, -5], -3 = 5, 2, -1, -4 |
| IntegerRange range = Ranges.integerRange(5, BoundType.CLOSED, -5, |
| BoundType.CLOSED, -3); |
| // [5, -5], -3 = 5, 2, -1, -4 |
| List<Integer> arr = Arrays.asList(5, 2, -1, -4); |
| for (Integer element : arr) { |
| assertTrue("Expected element [" + element + |
| "] is missing in range [" + range + "]", |
| range.contains(element)); |
| } |
| List<Integer> elementsNotPresent = new ArrayList<Integer>(fullRange); |
| elementsNotPresent.removeAll(arr); |
| for (Integer element : elementsNotPresent) { |
| assertFalse("Unexpected element [" + element + |
| "] is present in range [" + range + "]", |
| range.contains(element)); |
| } |
| } |
| |
| @Test |
| public void testOpenClosedDescendingContains() { |
| // (5, -5], -3 = 2, -1, -4 |
| IntegerRange range = Ranges.integerRange(5, BoundType.OPEN, -5, |
| BoundType.CLOSED, -3); |
| // (5, -5], -3 = 2, -1, -4 |
| List<Integer> arr = Arrays.asList(2, -1, -4); |
| for (Integer element : arr) { |
| assertTrue("Expected element [" + element + |
| "] is missing in range [" + range + "]", |
| range.contains(element)); |
| } |
| List<Integer> elementsNotPresent = new ArrayList<Integer>(fullRange); |
| elementsNotPresent.removeAll(arr); |
| for (Integer element : elementsNotPresent) { |
| assertFalse("Unexpected element [" + element + |
| "] is present in range [" + range + "]", |
| range.contains(element)); |
| } |
| } |
| |
| @Test |
| public void testClosedOpenDescendingContains() { |
| // [5, -5), -3 = 5, 2, -1, -4 |
| IntegerRange range = Ranges.integerRange(5, BoundType.CLOSED, -5, |
| BoundType.OPEN, -3); |
| // [5, -5), -3 = 5, 2, -1, -4 |
| List<Integer> arr = Arrays.asList(5, 2, -1, -4); |
| for (Integer element : arr) { |
| assertTrue("Expected element [" + element + |
| "] is missing in range [" + range + "]", |
| range.contains(element)); |
| } |
| List<Integer> elementsNotPresent = new ArrayList<Integer>(fullRange); |
| elementsNotPresent.removeAll(arr); |
| for (Integer element : elementsNotPresent) { |
| assertFalse("Unexpected element [" + element + |
| "] is present in range [" + range + "]", |
| range.contains(element)); |
| } |
| } |
| |
| @Test |
| public void testOpenOpenDescendingContains() { |
| // (5, -5), -3 = 2, -1, -4 |
| IntegerRange range = Ranges.integerRange(5, BoundType.OPEN, -5, |
| BoundType.OPEN, -3); |
| // (5, -5), -3 = 2, -1, -4 |
| List<Integer> arr = Arrays.asList(2, -1, -4); |
| for (Integer element : arr) { |
| assertTrue("Expected element [" + element + |
| "] is missing in range [" + range + "]", |
| range.contains(element)); |
| } |
| List<Integer> elementsNotPresent = new ArrayList<Integer>(fullRange); |
| elementsNotPresent.removeAll(arr); |
| for (Integer element : elementsNotPresent) { |
| assertFalse("Unexpected element [" + element + |
| "] is present in range [" + range + "]", |
| range.contains(element)); |
| } |
| } |
| |
| @Test |
| public void testContainsSingleStepDescending() { |
| // [2, -2), -1 = 2, 1, 0, -1 |
| IntegerRange descendingRange = Ranges.integerRange(2, BoundType.CLOSED, |
| -2, BoundType.OPEN, -1); |
| // [2, -2), -1 = 2, 1, 0, -1 |
| List<Integer> arr = Arrays.asList(2, 1, 0, -1); |
| for (Integer element : arr) { |
| assertTrue("Expected element [" + element + |
| "] is missing in range [" + descendingRange + |
| "]", |
| descendingRange.contains(element)); |
| } |
| List<Integer> elementsNotPresent = new ArrayList<Integer>(fullRange); |
| elementsNotPresent.removeAll(arr); |
| for (Integer element : elementsNotPresent) { |
| assertFalse("Unexpected element [" + element + |
| "] is present in range [" + descendingRange + |
| "]", |
| descendingRange.contains(element)); |
| } |
| } |
| |
| @Test |
| public void testContainsNullOrEmpty() { |
| IntegerRange range = Ranges.integerRange(-2, BoundType.OPEN, 2, |
| BoundType.CLOSED, 1); |
| assertFalse(range.contains(null)); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Test |
| public void testContainsAll() { |
| // (-2, 2], 1 = -1, 0, 1, 2 |
| IntegerRange range = Ranges.integerRange(-2, BoundType.OPEN, 2, |
| BoundType.CLOSED, 1); |
| List<Integer> list = Arrays.asList(-1, 0, 1, 2); |
| assertTrue("Range [" + range + |
| "] was expected to contain all elements from list [" + list + |
| "]", range.containsAll(list)); |
| List<Integer> listWithExtraElements = Arrays.asList(2, -1, 0, 1, 2, 3); |
| assertFalse("Range [" + range + "] has more elements than expected", |
| range.containsAll(listWithExtraElements)); |
| assertFalse(range.containsAll(null)); |
| assertFalse(range.containsAll(Collections.EMPTY_LIST)); |
| } |
| |
| @Test |
| public void testEquals() |
| throws Exception { |
| // equals basic properties |
| IntegerRange range = Ranges.integerRange(-2, BoundType.CLOSED, 2, |
| BoundType.OPEN, 1); |
| assertEquals("equals must be reflexive", range, range); |
| assertEquals("hashCode must be reflexive", range.hashCode(), |
| range.hashCode()); |
| assertTrue(!range.equals(null)); // should be able to compare to null |
| |
| Object range2 = Ranges.integerRange(-2, BoundType.CLOSED, 2, |
| BoundType.OPEN, 1); |
| if (range.equals(range2)) { |
| assertEquals("equals implies hash equals", range.hashCode(), |
| range2.hashCode()); |
| assertEquals("equals must be symmetric", range2, range); |
| } else { |
| assertTrue("equals must be symmetric", !range2.equals(range)); |
| } |
| |
| // Changing attributes |
| Object range3 = Ranges.integerRange(-1, BoundType.CLOSED, 2, |
| BoundType.OPEN, 1); |
| assertFalse("Invalid equals after changing attributes", |
| range.equals(range3)); |
| |
| Object range4 = Ranges.integerRange(-2, BoundType.OPEN, 2, BoundType.OPEN, |
| 1); |
| assertFalse("Invalid equals after changing attributes", |
| range.equals(range4)); |
| |
| Object range5 = Ranges.integerRange(-2, BoundType.CLOSED, 1, |
| BoundType.OPEN, 1); |
| assertFalse("Invalid equals after changing attributes", |
| range.equals(range5)); |
| |
| Object range6 = Ranges.integerRange(-2, BoundType.CLOSED, 2, |
| BoundType.CLOSED, 1); |
| assertFalse("Invalid equals after changing attributes", |
| range.equals(range6)); |
| |
| Object range7 = Ranges.integerRange(-2, BoundType.CLOSED, 2, |
| BoundType.OPEN, 2); |
| assertFalse("Invalid equals after changing attributes", |
| range.equals(range7)); |
| |
| // Using different constructors |
| IntegerRange range8 = Ranges.integerRange(Long.valueOf(-2), |
| Long.valueOf(2), Long.valueOf(1)); |
| assertEquals("Invalid equals using different constructor", range, |
| range8); |
| |
| IntegerRange range9 = Ranges.integerRange(Long.valueOf(-2), |
| Long.valueOf(2)); |
| assertEquals("Invalid equals using different constructor", range, |
| range9); |
| |
| Endpoint<Integer> leftEndpoint = new Endpoint<Integer>(-2, |
| BoundType.CLOSED); |
| Endpoint<Integer> rightEndpoint = new Endpoint<Integer>(2, |
| BoundType.OPEN); |
| IntegerRange range10 = Ranges.integerRange(leftEndpoint, rightEndpoint, 1); |
| assertEquals("Invalid equals using different constructor", range, |
| range10); |
| } |
| |
| @Test |
| public void testToString() { |
| IntegerRange range = Ranges.integerRange(-2, BoundType.OPEN, 2, |
| BoundType.CLOSED, 1); |
| assertEquals("Wrong string value", "IntegerRange<(-2, 2], 1>", |
| range.toString()); |
| } |
| |
| @Test |
| public void testConstructorUsingSameEndpoint() { |
| Endpoint<Integer> uniqueEndpoint = new Endpoint<Integer>( |
| 10, |
| BoundType.CLOSED); |
| try { |
| Ranges.integerRange(uniqueEndpoint, uniqueEndpoint, 1); |
| } catch (IllegalArgumentException e) { |
| fail("Not expected to get here"); |
| } |
| } |
| |
| @Test |
| public void testInvalidRange() { |
| try { |
| Ranges.integerRange(10, BoundType.OPEN, -5, BoundType.CLOSED, 10); |
| fail("Not expected to get here"); |
| } catch (IllegalArgumentException e) { |
| // Do nothing |
| } |
| Endpoint<Integer> leftEndpoint = new Endpoint<Integer>(10, |
| BoundType.CLOSED); |
| Endpoint<Integer> rightEndpoint = new Endpoint<Integer>(-5, |
| BoundType.OPEN); |
| try { |
| Ranges.integerRange(leftEndpoint, rightEndpoint, 1); |
| fail("Not expected to get here"); |
| } catch (IllegalArgumentException e) { |
| // Do nothing |
| } |
| } |
| |
| @Test |
| public void testDefaultStep() { |
| assertEquals("Invalid default step", Integer.valueOf(-1), |
| IntegerRange.DEFAULT_STEP.evaluate(10, 1)); |
| assertEquals("Invalid default step", Integer.valueOf(1), |
| IntegerRange.DEFAULT_STEP.evaluate(1, 10)); |
| } |
| |
| } |
