Modified: commons/proper/functor/branches/generators-FUNCTOR-14/src/test/java/org/apache/commons/functor/generator/range/TestLongRange.java URL: http://svn.apache.org/viewvc/commons/proper/functor/branches/generators-FUNCTOR-14/src/test/java/org/apache/commons/functor/generator/range/TestLongRange.java?rev=1385335&r1=1385334&r2=1385335&view=diff ============================================================================== --- commons/proper/functor/branches/generators-FUNCTOR-14/src/test/java/org/apache/commons/functor/generator/range/TestLongRange.java (original) +++ commons/proper/functor/branches/generators-FUNCTOR-14/src/test/java/org/apache/commons/functor/generator/range/TestLongRange.java Sun Sep 16 18:08:31 2012 @@ -17,13 +17,22 @@ package org.apache.commons.functor.generator.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.generator.range.LongRange; +import org.apache.commons.functor.UnaryFunction; +import org.apache.commons.functor.UnaryProcedure; +import org.apache.commons.functor.generator.Generator; +import org.junit.After; +import org.junit.Before; import org.junit.Test; /** @@ -31,19 +40,47 @@ import org.junit.Test; */ public class TestLongRange extends BaseFunctorTest { + // A base range with all longs between -6 and 6 + private final List<Long> fullRange = Collections.unmodifiableList(Arrays + .asList(-6L, -5L, -4L, -3L, -2L, -1L, 0L, 1L, 2L, 3L, 4L, 5L, 6L)); + + // Attributes + // ------------------------------------------------------------------------ + private LongRange ascLongRange = null; + private LongRange descLongRange = null; + private Collection<Long> expectedAsc = null; + private Collection<Long> expectedDesc = null; + + // Test set up + // ------------------------------------------------------------------------ + @Before + public void setUp() { + ascLongRange = Ranges.longRange(0L, 10L); + descLongRange = Ranges.longRange(10L, 0L); + expectedAsc = Arrays.asList(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L); + expectedDesc = Arrays.asList(10L, 9L, 8L, 7L, 6L, 5L, 4L, 3L, 2L, 1L); + } + + @After + public void tearDown() { + ascLongRange = null; + descLongRange = null; + } + @Override - protected Object makeFunctor() throws Exception { - return new LongRange(10, 20); + protected Object makeFunctor() + throws Exception { + return Ranges.longRange(10, 20); } - // Tests + // Generator tests // ------------------------------------------------------------------------ @Test public void testGenerateListExample() { // generates a collection of Integers from 0 (inclusive) to 10 (exclusive) { - List<? super Long> list = (List<? super Long>)(new LongRange(0,10).to(new ArrayList<Long>())); + List<? super Long> list = (List<? super Long>)(Ranges.longRange(0,10).to(new ArrayList<Long>())); for (int i=0;i<10;i++) { assertEquals(new Long(i),list.get(i)); } @@ -51,7 +88,7 @@ public class TestLongRange extends BaseF // generates a collection of Integers from 10 (inclusive) to 0 (exclusive) { - List<? super Long> list = (List<? super Long>)(new LongRange(10,0).to(new ArrayList<Long>())); + List<? super Long> list = (List<? super Long>)(Ranges.longRange(10,0).to(new ArrayList<Long>())); for (int i=10;i>0;i--) { assertEquals(new Long(i),list.get(10-i)); } @@ -61,34 +98,34 @@ public class TestLongRange extends BaseF @Test public void testStepChecking() { { - new LongRange(2, 2, 0); // step of 0 is ok when range is empty + Ranges.longRange(2, 2, 0); // step of 0 is ok when range is empty } { - new LongRange(2, 2, 1); // positive step is ok when range is empty + Ranges.longRange(2, 2, 1); // positive step is ok when range is empty } { - new LongRange(2, 2, -1); // negative step is ok when range is empty + Ranges.longRange(2, 2, -1); // negative step is ok when range is empty } { - new LongRange(0, 1, 10); // big steps are ok + Ranges.longRange(0, 1, 10); // big steps are ok } { - new LongRange(1, 0, -10); // big steps are ok + Ranges.longRange(1, 0, -10); // big steps are ok } try { - new LongRange(0, 1, 0); + Ranges.longRange(0, 1, 0); fail("Expected IllegalArgumentException"); } catch(IllegalArgumentException e) { // expected } try { - new LongRange(0, 1, -1); + Ranges.longRange(0, 1, -1); fail("Expected IllegalArgumentException"); } catch(IllegalArgumentException e) { // expected } try { - new LongRange(0, -1, 1); + Ranges.longRange(0, -1, 1); fail("Expected IllegalArgumentException"); } catch(IllegalArgumentException e) { // expected @@ -97,59 +134,618 @@ public class TestLongRange extends BaseF @Test public void testObjectConstructor() { - LongRange range = new LongRange(new Long(0), new Long(5)); + LongRange range = Ranges.longRange(new Long(0), new Long(5)); assertEquals("[0, 1, 2, 3, 4]", range.toCollection().toString()); - range = new LongRange(new Integer(0), new Long(5), new Long(1)); + range = Ranges.longRange(new Integer(0), new Long(5), new Long(1)); assertEquals("[0, 1, 2, 3, 4]", range.toCollection().toString()); } @Test public void testReverseStep() { - LongRange range = new LongRange(10, 0, -2); + LongRange range = Ranges.longRange(10, 0, -2); assertEquals("[10, 8, 6, 4, 2]", range.toCollection().toString()); assertEquals("[10, 8, 6, 4, 2]", range.toCollection().toString()); } @Test public void testStep() { - LongRange range = new LongRange(0, 10, 2); + LongRange range = Ranges.longRange(0, 10, 2); assertEquals("[0, 2, 4, 6, 8]", range.toCollection().toString()); assertEquals("[0, 2, 4, 6, 8]", range.toCollection().toString()); } @Test public void testForwardRange() { - LongRange range = new LongRange(0, 5); + LongRange range = Ranges.longRange(0, 5); assertEquals("[0, 1, 2, 3, 4]", range.toCollection().toString()); assertEquals("[0, 1, 2, 3, 4]", range.toCollection().toString()); } @Test public void testReverseRange() { - LongRange range = new LongRange(5, 0); + LongRange range = Ranges.longRange(5, 0); assertEquals("[5, 4, 3, 2, 1]", range.toCollection().toString()); assertEquals("[5, 4, 3, 2, 1]", range.toCollection().toString()); } @Test public void testEdgeCase() { - LongRange range = new LongRange(Long.MAX_VALUE - 3L, Long.MAX_VALUE); + LongRange range = Ranges.longRange(Long.MAX_VALUE - 3L, Long.MAX_VALUE); assertEquals("[9223372036854775804, 9223372036854775805, 9223372036854775806]", range.toCollection().toString()); assertEquals("[9223372036854775804, 9223372036854775805, 9223372036854775806]", range.toCollection().toString()); } + + @Test + public void testClosedClosedAscending() { + // [-5L, 5L], 3L = -5L, -2L, 1L, 4L + LongRange range = Ranges.longRange(-5L, BoundType.CLOSED, 5L, + BoundType.CLOSED, 3L); + // [-5L, 5L], 3L = -5L, -2L, 1L, 4L + List<Long> expected = Arrays.asList(-5L, -2L, 1L, 4L); + Collection<Long> elements = range.toCollection(); + assertEquals(expected, elements); + } + + @Test + public void testOpenClosedAscending() { + // (-5L, 5L], 3L = -2L, 1L, 4L + LongRange range = Ranges.longRange(-5L, BoundType.OPEN, 5L, + BoundType.CLOSED, 3L); + // (-5L, 5L], 3L = -2L, 1L, 4L + List<Long> expected = Arrays.asList(-2L, 1L, 4L); + Collection<Long> elements = range.toCollection(); + assertEquals(expected, elements); + } + + @Test + public void testClosedOpenAscending() { + // [-5L, 5L), 3L = -5L, -2L, 1L, 4L + LongRange range = Ranges.longRange(-5L, BoundType.CLOSED, 5L, + BoundType.OPEN, 3L); + // (-5L, 5L], 3L = -5L, -2L, 1L, 4L + List<Long> expected = Arrays.asList(-5L, -2L, 1L, 4L); + Collection<Long> elements = range.toCollection(); + assertEquals(expected, elements); + } + + @Test + public void testOpenOpenAscending() { + // (-5L, 5L), 3L = -2L, 1L, 4L + LongRange range = Ranges.longRange(-5L, BoundType.OPEN, 5L, + BoundType.OPEN, 3L); + // (-5L, 5L), 3L = -2L, 1L, 4L + List<Long> expected = Arrays.asList(-2L, 1L, 4L); + Collection<Long> elements = range.toCollection(); + assertEquals(expected, elements); + } + + @Test + public void testSingleStepAscending() { + // (-2L, 2L], 1L = -1L, 0L, 1L, 2L + LongRange range = Ranges.longRange(-2L, BoundType.OPEN, 2L, + BoundType.CLOSED, 1L); + // (-2L, 2L], 1L = -1L, 0L, 1L, 2L + List<Long> expected = Arrays.asList(-1L, 0L, 1L, 2L); + Collection<Long> elements = range.toCollection(); + assertEquals(expected, elements); + } + + @Test + public void testClosedClosedDescending() { + // [5L, -5L], -3L = 5L, 2L, -1L, -4L + LongRange range = Ranges.longRange(5L, BoundType.CLOSED, -5L, + BoundType.CLOSED, -3L); + // [5L, -5L], -3L = 5L, 2L, -1L, -4L + List<Long> expected = Arrays.asList(5L, 2L, -1L, -4L); + Collection<Long> elements = range.toCollection(); + assertEquals(expected, elements); + } + + @Test + public void testOpenClosedDescending() { + // (5L, -5L], -3L = 2L, -1L, -4L + LongRange range = Ranges.longRange(5L, BoundType.OPEN, -5L, + BoundType.CLOSED, -3L); + // (5L, -5L], -3L = 2L, -1L, -4L + List<Long> expected = Arrays.asList(2L, -1L, -4L); + Collection<Long> elements = range.toCollection(); + assertEquals(expected, elements); + } + + @Test + public void testClosedOpenDescending() { + // [5L, -5L), -3L = 5L, 2L, -1L, -4L + LongRange range = Ranges.longRange(5L, BoundType.CLOSED, -5L, + BoundType.OPEN, -3L); + // [5L, -5L), -3L = 5L, 2L, -1L, -4L + List<Long> expected = Arrays.asList(5L, 2L, -1L, -4L); + Collection<Long> elements = range.toCollection(); + assertEquals(expected, elements); + } + + @Test + public void testOpenOpenDescending() { + // (5L, -5L), -3L = 2L, -1L, -4L + LongRange range = Ranges.longRange(5L, BoundType.OPEN, -5L, + BoundType.OPEN, -3L); + // (5L, -5L), -3L = 2L, -1L, -4L + List<Long> expected = Arrays.asList(2L, -1L, -4L); + Collection<Long> elements = range.toCollection(); + assertEquals(expected, elements); + } + + @Test + public void testSingleStepDescending() { + // [2L, -2L), -1L = 2L, 1L, 0L, -1L + LongRange range = Ranges.longRange(2L, BoundType.CLOSED, -2L, + BoundType.OPEN, -1L); + // [2L, -2L), -1L = 2L, 1L, 0L, -1L + List<Long> expected = Arrays.asList(2L, 1L, 0L, -1L); + Collection<Long> elements = range.toCollection(); + assertEquals(expected, elements); + } + + @Test + public void testAscending() { + final List<Long> list = new ArrayList<Long>(); + ascLongRange.run(new UnaryProcedure<Long>() { + + public void run(Long obj) { + list.add(obj); + } + }); + assertTrue(expectedAsc.containsAll(list)); + } + + @Test + public void testDescending() { + final List<Long> list = new ArrayList<Long>(); + descLongRange.run(new UnaryProcedure<Long>() { + + public void run(Long obj) { + list.add(obj); + } + }); + assertTrue(expectedDesc.containsAll(list)); + } + + @Test + public void testToCollection() { + Collection<Long> ascCol = ascLongRange.toCollection(); + assertEquals("Different collections", expectedAsc, ascCol); + Collection<Long> descCol = descLongRange.toCollection(); + assertEquals("Different collections", expectedDesc, descCol); + } + + @Test + public void testTransformedGenerator() { + long expected = 45L; + long total = ascLongRange + .to(new UnaryFunction<Generator<? extends Long>, Long>() { + + public Long evaluate(Generator<? extends Long> obj) { + long total = 0L; + for (Object element : obj.toCollection()) { + total += (Long) element; + } + return total; + } + }); + assertEquals(expected, total); + expected = 55L; + total = descLongRange + .to(new UnaryFunction<Generator<? extends Long>, Long>() { + + public Long evaluate(Generator<? extends Long> obj) { + long total = 0L; + for (Object element : obj.toCollection()) { + total += (Long) element; + } + return total; + } + }); + assertEquals(expected, total); + } + + // Range tests + // ------------------------------------------------------------------------ + + @Test + public void testEmptyRanges() { + LongRange empty1 = Ranges.longRange(-2, BoundType.OPEN, -1, + BoundType.OPEN, 2); + assertTrue("The range was expected to be empty.", empty1.isEmpty()); + LongRange empty2 = Ranges.longRange(2, BoundType.OPEN, 0, BoundType.OPEN, + -2); + assertTrue("The range was expected to be empty.", empty2.isEmpty()); + LongRange empty3 = Ranges.longRange(0, BoundType.OPEN, 1, + BoundType.CLOSED, 2); + assertTrue("The range was expected to be empty.", empty3.isEmpty()); + LongRange empty4 = Ranges.longRange(-3, BoundType.OPEN, -3, + BoundType.OPEN, 1); + assertTrue("The range was expected to be empty.", empty4.isEmpty()); + LongRange empty5 = Ranges.longRange(-3, BoundType.CLOSED, -3, + BoundType.OPEN, 1); + assertTrue("The range was expected to be empty.", empty5.isEmpty()); + LongRange empty6 = Ranges.longRange(1, BoundType.OPEN, 0, + BoundType.CLOSED, -2); + assertTrue("The range was expected to be empty.", empty6.isEmpty()); + LongRange notEmpty1 = Ranges.longRange(-3, BoundType.CLOSED, -3, + BoundType.CLOSED, 1); + assertFalse("The range was not expected to be empty.", + notEmpty1.isEmpty()); + LongRange notEmpty2 = Ranges.longRange(-3, BoundType.OPEN, -2, + BoundType.CLOSED, 1); + assertFalse("The range was not expected to be empty.", + notEmpty2.isEmpty()); + LongRange notEmpty3 = Ranges.longRange(2, BoundType.OPEN, 1, + BoundType.CLOSED, -1); + assertFalse("The range was not expected to be empty.", + notEmpty3.isEmpty()); + LongRange notEmpty4 = Ranges.longRange(2, BoundType.CLOSED, 1, + BoundType.OPEN, -1); + assertFalse("The range was not expected to be empty.", + notEmpty4.isEmpty()); + LongRange notEmpty5 = Ranges.longRange(1, BoundType.CLOSED, 2, + BoundType.OPEN, 1); + assertFalse("The range was not expected to be empty.", + notEmpty5.isEmpty()); + } + + @Test + public void testBoundaries() { + LongRange range = Ranges.longRange(0L, 10L); + assertEquals(new Endpoint<Comparable<?>>(0L, BoundType.CLOSED), + range.getLeftEndpoint()); + assertEquals(new Endpoint<Comparable<?>>(10L, BoundType.OPEN), + range.getRightEndpoint()); + } + + @Test + public void testClosedClosedAscendingContains() { + // [-5, 5], 3 = -5, -2, 1, 4 + LongRange range = Ranges.longRange(-5, BoundType.CLOSED, 5, + BoundType.CLOSED, 3); + // [-5, 5], 3 = -5, -2, 1, 4 + List<Long> arr = Arrays.asList(-5L, -2L, 1L, 4L); + for (Long element : arr) { + assertTrue("Expected element [" + element + + "] is missing in range [" + range + "]", + range.contains(element)); + } + List<Long> elementsNotPresent = new ArrayList<Long>(fullRange); + elementsNotPresent.removeAll(arr); + for (Long element : elementsNotPresent) { + assertFalse("Unexpected element [" + element + + "] is present in range [" + range + "]", + range.contains(element)); + } + } + + @Test + public void testOpenClosedAscendingContains() { + // (-5, 5], 3 = -2, 1, 4 + LongRange range = Ranges.longRange(-5, BoundType.OPEN, 5, + BoundType.CLOSED, 3); + // (-5, 5], 3 = -2, 1, 4 + List<Long> arr = Arrays.asList(-2L, 1L, 4L); + for (Long element : arr) { + assertTrue("Expected element [" + element + + "] is missing in range [" + range + "]", + range.contains(element)); + } + List<Long> elementsNotPresent = new ArrayList<Long>(fullRange); + elementsNotPresent.removeAll(arr); + for (Long 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 + LongRange range = Ranges.longRange(-5, BoundType.CLOSED, 5, + BoundType.OPEN, 3); + // (-5, 5], 3 = -5, -2, 1, 4 + List<Long> arr = Arrays.asList(-5L, -2L, 1L, 4L); + for (Long element : arr) { + assertTrue("Expected element [" + element + + "] is missing in range [" + range + "]", + range.contains(element)); + } + List<Long> elementsNotPresent = new ArrayList<Long>(fullRange); + elementsNotPresent.removeAll(arr); + for (Long element : elementsNotPresent) { + assertFalse("Unexpected element [" + element + + "] is present in range [" + range + "]", + range.contains(element)); + } + } + + @Test + public void testOpenOpenAscendingContains() { + // (-5, 5), 3 = -2, 1, 4 + LongRange range = Ranges.longRange(-5, BoundType.OPEN, 5, BoundType.OPEN, + 3); + // (-5, 5), 3 = -2, 1, 4 + List<Long> arr = Arrays.asList(-2L, 1L, 4L); + for (Long element : arr) { + assertTrue("Expected element [" + element + + "] is missing in range [" + range + "]", + range.contains(element)); + } + List<Long> elementsNotPresent = new ArrayList<Long>(fullRange); + elementsNotPresent.removeAll(arr); + for (Long 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 + LongRange ascendingRange = Ranges.longRange(-2, BoundType.OPEN, 2, + BoundType.CLOSED, 1); + // (-2, 2], 1 = -1, 0, 1, 2 + List<Long> arr = Arrays.asList(-1L, 0L, 1L, 2L); + for (Long element : arr) { + assertTrue("Expected element [" + element + + "] is missing in range [" + ascendingRange + "]", + ascendingRange.contains(element)); + } + List<Long> elementsNotPresent = new ArrayList<Long>(fullRange); + elementsNotPresent.removeAll(arr); + for (Long 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 + LongRange range = Ranges.longRange(5, BoundType.CLOSED, -5, + BoundType.CLOSED, -3); + // [5, -5], -3 = 5, 2, -1, -4 + List<Long> arr = Arrays.asList(5L, 2L, -1L, -4L); + for (Long element : arr) { + assertTrue("Expected element [" + element + + "] is missing in range [" + range + "]", + range.contains(element)); + } + List<Long> elementsNotPresent = new ArrayList<Long>(fullRange); + elementsNotPresent.removeAll(arr); + for (Long element : elementsNotPresent) { + assertFalse("Unexpected element [" + element + + "] is present in range [" + range + "]", + range.contains(element)); + } + } + + @Test + public void testOpenClosedDescendingContains() { + // (5, -5], -3 = 2, -1, -4 + LongRange range = Ranges.longRange(5, BoundType.OPEN, -5, + BoundType.CLOSED, -3); + // (5, -5], -3 = 2, -1, -4 + List<Long> arr = Arrays.asList(2L, -1L, -4L); + for (Long element : arr) { + assertTrue("Expected element [" + element + + "] is missing in range [" + range + "]", + range.contains(element)); + } + List<Long> elementsNotPresent = new ArrayList<Long>(fullRange); + elementsNotPresent.removeAll(arr); + for (Long 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 + LongRange range = Ranges.longRange(5, BoundType.CLOSED, -5, + BoundType.OPEN, -3); + // [5, -5), -3 = 5, 2, -1, -4 + List<Long> arr = Arrays.asList(5L, 2L, -1L, -4L); + for (Long element : arr) { + assertTrue("Expected element [" + element + + "] is missing in range [" + range + "]", + range.contains(element)); + } + List<Long> elementsNotPresent = new ArrayList<Long>(fullRange); + elementsNotPresent.removeAll(arr); + for (Long element : elementsNotPresent) { + assertFalse("Unexpected element [" + element + + "] is present in range [" + range + "]", + range.contains(element)); + } + } + + @Test + public void testOpenOpenDescendingContains() { + // (5, -5), -3 = 2, -1, -4 + LongRange range = Ranges.longRange(5, BoundType.OPEN, -5, BoundType.OPEN, + -3); + // (5, -5), -3 = 2, -1, -4 + List<Long> arr = Arrays.asList(2L, -1L, -4L); + for (Long element : arr) { + assertTrue("Expected element [" + element + + "] is missing in range [" + range + "]", + range.contains(element)); + } + List<Long> elementsNotPresent = new ArrayList<Long>(fullRange); + elementsNotPresent.removeAll(arr); + for (Long 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 + LongRange descendingRange = Ranges.longRange(2, BoundType.CLOSED, -2, + BoundType.OPEN, -1); + // [2, -2), -1 = 2, 1, 0, -1 + List<Long> arr = Arrays.asList(2L, 1L, 0L, -1L); + for (Long element : arr) { + assertTrue("Expected element [" + element + + "] is missing in range [" + descendingRange + + "]", + descendingRange.contains(element)); + } + List<Long> elementsNotPresent = new ArrayList<Long>(fullRange); + elementsNotPresent.removeAll(arr); + for (Long element : elementsNotPresent) { + assertFalse("Unexpected element [" + element + + "] is present in range [" + descendingRange + + "]", + descendingRange.contains(element)); + } + } + + @Test + public void testContainsNullOrEmpty() { + LongRange range = Ranges.longRange(-2, BoundType.OPEN, 2, + BoundType.CLOSED, 1); + assertFalse(range.contains(null)); + } + + @SuppressWarnings("unchecked") + @Test + public void testContainsAll() { + // (-2, 2], 1 = -1, 0, 1, 2 + LongRange range = Ranges.longRange(-2, BoundType.OPEN, 2, + BoundType.CLOSED, 1); + List<Long> list = Arrays.asList(-1L, 0L, 1L, 2L); + assertTrue("Range [" + range + + "] was expected to contain all elements from list [" + list + + "]", range.containsAll(list)); + List<Long> listWithExtraElements = Arrays.asList(2L, -1L, 0L, 1L, 2L, + 3L); + 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 + LongRange range = Ranges.longRange(-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.longRange(-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.longRange(-1, BoundType.CLOSED, 2, BoundType.OPEN, + 1); + assertFalse("Invalid equals after changing attributes", + range.equals(range3)); + + Object range4 = Ranges.longRange(-2, BoundType.OPEN, 2, BoundType.OPEN, 1); + assertFalse("Invalid equals after changing attributes", + range.equals(range4)); + + Object range5 = Ranges.longRange(-2, BoundType.CLOSED, 1, BoundType.OPEN, + 1); + assertFalse("Invalid equals after changing attributes", + range.equals(range5)); + + Object range6 = Ranges.longRange(-2, BoundType.CLOSED, 2, + BoundType.CLOSED, 1); + assertFalse("Invalid equals after changing attributes", + range.equals(range6)); + + Object range7 = Ranges.longRange(-2, BoundType.CLOSED, 2, BoundType.OPEN, + 2); + assertFalse("Invalid equals after changing attributes", + range.equals(range7)); + + // Using different constructors + LongRange range8 = Ranges.longRange(Integer.valueOf(-2), Integer.valueOf(2), + Integer.valueOf(1)); + assertEquals("Invalid equals using different constructor", range, + range8); + + LongRange range9 = Ranges.longRange(Integer.valueOf(-2),Integer.valueOf(2)); + assertEquals("Invalid equals using different constructor", range, + range9); + + Endpoint<Long> leftEndpoint = new Endpoint<Long>(-2L, BoundType.CLOSED); + Endpoint<Long> rightEndpoint = new Endpoint<Long>(2L, BoundType.OPEN); + LongRange range10 = Ranges.longRange(leftEndpoint, rightEndpoint, 1L); + assertEquals("Invalid equals using different constructor", range, + range10); + } + + @Test + public void testToString() { + LongRange range = Ranges.longRange(-2, BoundType.OPEN, 2, + BoundType.CLOSED, 1); + assertEquals("Wrong string value", "LongRange<(-2, 2], 1>", + range.toString()); + } + + @Test + public void testConstructorUsingSameEndpoint() { + Endpoint<Long> uniqueEndpoint = new Endpoint<Long>(10L, + BoundType.CLOSED); + try { + Ranges.longRange(uniqueEndpoint, uniqueEndpoint, 1L); + } catch (IllegalArgumentException e) { + fail("Not expected to get here"); + } + } + + @Test + public void testInvalidRange() { + try { + Ranges.longRange(10, BoundType.OPEN, -5, BoundType.CLOSED, 10); + fail("Not expected to get here"); + } catch (IllegalArgumentException e) { + // Do nothing + } + Endpoint<Long> leftEndpoint = new Endpoint<Long>(10L, BoundType.CLOSED); + Endpoint<Long> rightEndpoint = new Endpoint<Long>(-5L, BoundType.OPEN); + try { + Ranges.longRange(leftEndpoint, rightEndpoint, 1L); + fail("Not expected to get here"); + } catch (IllegalArgumentException e) { + // Do nothing + } + } @Test - public void testEquals() { - LongRange range = new LongRange(1, 5); - assertObjectsAreEqual(range, range); - assertObjectsAreEqual(range, new LongRange(1, 5)); - assertObjectsAreEqual(range, new LongRange(1, 5, 1)); - assertObjectsAreEqual(range, new LongRange(new Integer(1), new Long(5))); - assertObjectsAreEqual(range, new LongRange(new Long(1), new Short((short)5), new Long(1))); - assertObjectsAreNotEqual(range, new LongRange(2, 5)); - assertObjectsAreNotEqual(range, new LongRange(1, 6)); - assertObjectsAreNotEqual(range, new LongRange(1, 5, 2)); + public void testDefaultStep() { + assertEquals("Invalid default step", Long.valueOf(-1L), + LongRange.DEFAULT_STEP.evaluate(10L, 1L)); + assertEquals("Invalid default step", Long.valueOf(1L), + LongRange.DEFAULT_STEP.evaluate(1L, 10L)); } } \ No newline at end of file
