core/src/test/java/org/apache/commons/functor/range/TestFloatRange.java

/*
 * 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.0f
 * (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.0f
 *
 * 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;

/**
 * Tests for float range.
 * 
 * @since 1.0
 * @version $Revision: $ $Date: $
 */
public class TestFloatRange extends BaseFunctorTest {

    // A base range with all longs between -6 and 6
    private final List<Float> fullRange = Collections.unmodifiableList(Arrays
        .asList(-6.0f, -5.0f, -4.0f, -3.0f, -2.0f, -1.0f, 0.0f, 1.0f, 2.0f,
                3.0f, 4.0f, 5.0f, 6.0f));

    // Attributes
    // ------------------------------------------------------------------------
    private FloatRange ascFloatRange = null;
    private FloatRange descFloatRange = null;
    private Collection<Float> expectedAsc = null;
    private Collection<Float> expectedDesc = null;

    // Test set up
    // ------------------------------------------------------------------------
    @Before
    public void setUp() {
        ascFloatRange = Ranges.floatRange(0.0f, 10.0f);
        descFloatRange = Ranges.floatRange(10.0f, 0.0f);
        expectedAsc = Arrays.asList(0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f,
                                    7.0f, 8.0f, 9.0f);
        expectedDesc = Arrays.asList(10.0f, 9.0f, 8.0f, 7.0f, 6.0f, 5.0f, 4.0f,
                                     3.0f, 2.0f, 1.0f);
    }

    @After
    public void tearDown() {
        ascFloatRange = null;
        descFloatRange = null;
    }

    @Override
    protected Object makeFunctor()
        throws Exception {
        return Ranges.floatRange(10, 20);
    }

    // Generator tests
    // ---------------------------------------------------------------

    @Test
    public void testGenerateListExample() {
        // generates a collection of Floats from 0 (inclusive) to 10 (exclusive)
        {
            List<? super Float> list = (List<? super Float>) (
                IteratorToGeneratorAdapter.adapt(Ranges.floatRange(0, 10))
                    .to(new ArrayList<Float>()));
            for (int i = 0; i < 10; i++) {
                assertEquals(Float.valueOf(i), list.get(i));
            }
        }

        // generates a collection of Floats from 10 (inclusive) to 0 (exclusive)
        {
            List<? super Float> list = (List<? super Float>) (
                IteratorToGeneratorAdapter.adapt(Ranges.floatRange(10, 0))
                    .to(new ArrayList<Float>()));
            for (int i = 10; i > 0; i--) {
                assertEquals(Float.valueOf(i), list.get(10 - i));
            }
        }
    }

    @Test
    public void testStepChecking() {
        {
            Ranges.floatRange(2, 2, 0); // step of 0 is ok when range is empty
        }
        {
            Ranges.floatRange(2, 2, 1); // positive step is ok when range is
                                         // empty
        }
        {
            Ranges.floatRange(2, 2, -1); // negative step is ok when range is
                                          // empty
        }
        {
            Ranges.floatRange(0, 1, 10); // big steps are ok
        }
        {
            Ranges.floatRange(1, 0, -10); // big steps are ok
        }
        try {
            Ranges.floatRange(0, 1, 0);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }
        try {
            Ranges.floatRange(0, 1, -1);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }
        try {
            Ranges.floatRange(0, -1, 1);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }
    }

    @Test
    public void testObjectConstructor() {
        FloatRange range = Ranges.floatRange(Float.valueOf(0), Float.valueOf(5));
        assertEquals("[0.0, 1.0, 2.0, 3.0, 4.0]", IteratorToGeneratorAdapter.adapt(range).toCollection()
            .toString());
        range = Ranges.floatRange(Float.valueOf(0), Float.valueOf(5), Float.valueOf(1));
        assertEquals("[0.0, 1.0, 2.0, 3.0, 4.0]", IteratorToGeneratorAdapter.adapt(range).toCollection()
            .toString());
    }

    @Test
    public void testReverseStep() {
        FloatRange range = Ranges.floatRange(10, 0, -2);
        assertEquals("[10.0, 8.0, 6.0, 4.0, 2.0]", IteratorToGeneratorAdapter.adapt(range).toCollection()
            .toString());
    }

    @Test
    public void testStep() {
        FloatRange range = Ranges.floatRange(0, 10, 2);
        assertEquals("[0.0, 2.0, 4.0, 6.0, 8.0]", IteratorToGeneratorAdapter.adapt(range).toCollection()
            .toString());
    }

    @Test
    public void testForwardRange() {
        FloatRange range = Ranges.floatRange(0, 5);
        assertEquals("[0.0, 1.0, 2.0, 3.0, 4.0]", IteratorToGeneratorAdapter.adapt(range).toCollection()
            .toString());
    }

    @Test
    public void testReverseRange() {
        FloatRange range = Ranges.floatRange(5, 0);
        assertEquals("[5.0, 4.0, 3.0, 2.0, 1.0]", IteratorToGeneratorAdapter.adapt(range).toCollection()
            .toString());
    }

    @Test
    public void testClosedClosedAscending() {
        // [-5.0f, 5.0f], 3.0f = -5.0f, -2.0f, 1.0f, 4.0f
        FloatRange range = Ranges.floatRange(-5.0f, BoundType.CLOSED, 5.0f,
                                          BoundType.CLOSED, 3.0f);
        // [-5.0f, 5.0f], 3.0f = -5.0f, -2.0f, 1.0f, 4.0f
        List<Float> expected = Arrays.asList(-5.0f, -2.0f, 1.0f, 4.0f);
        Collection<Float> elements = IteratorToGeneratorAdapter.adapt(range).toCollection();
        assertEquals(expected, elements);
    }

    @Test
    public void testOpenClosedAscending() {
        // (-5.0f, 5.0f], 3.0f = -2.0f, 1.0f, 4.0f
        FloatRange range = Ranges.floatRange(-5.0f, BoundType.OPEN, 5.0f,
                                          BoundType.CLOSED, 3.0f);
        // (-5.0f, 5.0f], 3.0f = -2.0f, 1.0f, 4.0f
        List<Float> expected = Arrays.asList(-2.0f, 1.0f, 4.0f);
        Collection<Float> elements = IteratorToGeneratorAdapter.adapt(range).toCollection();
        assertEquals(expected, elements);
    }

    @Test
    public void testClosedOpenAscending() {
        // [-5.0f, 5.0f), 3.0f = -5.0f, -2.0f, 1.0f, 4.0f
        FloatRange range = Ranges.floatRange(-5.0f, BoundType.CLOSED, 5.0f,
                                          BoundType.OPEN, 3.0f);
        // (-5.0f, 5.0f], 3.0f = -5.0f, -2.0f, 1.0f, 4.0f
        List<Float> expected = Arrays.asList(-5.0f, -2.0f, 1.0f, 4.0f);
        Collection<Float> elements = IteratorToGeneratorAdapter.adapt(range).toCollection();
        assertEquals(expected, elements);
    }

    @Test
    public void testOpenOpenAscending() {
        // (-5.0f, 5.0f), 3.0f = -2.0f, 1.0f, 4.0f
        FloatRange range = Ranges.floatRange(-5.0f, BoundType.OPEN, 5.0f,
                                          BoundType.OPEN, 3.0f);
        // (-5.0f, 5.0f), 3.0f = -2.0f, 1.0f, 4.0f
        List<Float> expected = Arrays.asList(-2.0f, 1.0f, 4.0f);
        Collection<Float> elements = IteratorToGeneratorAdapter.adapt(range).toCollection();
        assertEquals(expected, elements);
    }

    @Test
    public void testSingleStepAscending() {
        // (-2.0f, 2.0f], 1.0f = -1.0f, 0.0f, 1.0f, 2.0f
        FloatRange range = Ranges.floatRange(-2.0f, BoundType.OPEN, 2.0f,
                                          BoundType.CLOSED, 1.0f);
        // (-2.0f, 2.0f], 1.0f = -1.0f, 0.0f, 1.0f, 2.0f
        List<Float> expected = Arrays.asList(-1.0f, 0.0f, 1.0f, 2.0f);
        Collection<Float> elements = IteratorToGeneratorAdapter.adapt(range).toCollection();
        assertEquals(expected, elements);
    }

    @Test
    public void testClosedClosedDescending() {
        // [5.0f, -5.0f], -3.0f = 5.0f, 2.0f, -1.0f, -4.0f
        FloatRange range = Ranges.floatRange(5.0f, BoundType.CLOSED, -5.0f,
                                          BoundType.CLOSED, -3.0f);
        // [5.0f, -5.0f], -3.0f = 5.0f, 2.0f, -1.0f, -4.0f
        List<Float> expected = Arrays.asList(5.0f, 2.0f, -1.0f, -4.0f);
        Collection<Float> elements = IteratorToGeneratorAdapter.adapt(range).toCollection();
        assertEquals(expected, elements);
    }

    @Test
    public void testOpenClosedDescending() {
        // (5.0f, -5.0f], -3.0f = 2.0f, -1.0f, -4.0f
        FloatRange range = Ranges.floatRange(5.0f, BoundType.OPEN, -5.0f,
                                          BoundType.CLOSED, -3.0f);
        // (5.0f, -5.0f], -3.0f = 2.0f, -1.0f, -4.0f
        List<Float> expected = Arrays.asList(2.0f, -1.0f, -4.0f);
        Collection<Float> elements = IteratorToGeneratorAdapter.adapt(range).toCollection();
        assertEquals(expected, elements);
    }

    @Test
    public void testClosedOpenDescending() {
        // [5.0f, -5.0f), -3.0f = 5.0f, 2.0f, -1.0f, -4.0f
        FloatRange range = Ranges.floatRange(5.0f, BoundType.CLOSED, -5.0f,
                                          BoundType.OPEN, -3.0f);
        // [5.0f, -5.0f), -3.0f = 5.0f, 2.0f, -1.0f, -4.0f
        List<Float> expected = Arrays.asList(5.0f, 2.0f, -1.0f, -4.0f);
        Collection<Float> elements = IteratorToGeneratorAdapter.adapt(range).toCollection();
        assertEquals(expected, elements);
    }

    @Test
    public void testOpenOpenDescending() {
        // (5.0f, -5.0f), -3.0f = 2.0f, -1.0f, -4.0f
        FloatRange range = Ranges.floatRange(5.0f, BoundType.OPEN, -5.0f,
                                          BoundType.OPEN, -3.0f);
        // (5.0f, -5.0f), -3.0f = 2.0f, -1.0f, -4.0f
        List<Float> expected = Arrays.asList(2.0f, -1.0f, -4.0f);
        Collection<Float> elements = IteratorToGeneratorAdapter.adapt(range).toCollection();
        assertEquals(expected, elements);
    }

    @Test
    public void testSingleStepDescending() {
        // [2.0f, -2.0f), -1.0f = 2.0f, 1.0f, 0.0f, -1.0f
        FloatRange range = Ranges.floatRange(2.0f, BoundType.CLOSED, -2.0f,
                                          BoundType.OPEN, -1.0f);
        // [2.0f, -2.0f), -1.0f = 2.0f, 1.0f, 0.0f, -1.0f
        List<Float> expected = Arrays.asList(2.0f, 1.0f, 0.0f, -1.0f);
        Collection<Float> elements = IteratorToGeneratorAdapter.adapt(range).toCollection();
        assertEquals(expected, elements);
    }

    @Test
    public void testAscending() {
        final List<Float> list = new ArrayList<Float>();
        for (float f : ascFloatRange) {
            list.add(f);
        }
        assertTrue(expectedAsc.containsAll(list));
    }

    @Test
    public void testDescending() {
        final List<Float> list = new ArrayList<Float>();
        for (float f : descFloatRange) {
            list.add(f);
        }
        assertTrue(expectedDesc.containsAll(list));
    }

    @Test
    public void testToCollection() {
        Collection<Float> ascCol = IteratorToGeneratorAdapter.adapt(ascFloatRange).toCollection();
        assertEquals("Different collections", expectedAsc, ascCol);
        Collection<Float> descCol = IteratorToGeneratorAdapter.adapt(descFloatRange).toCollection();
        assertEquals("Different collections", expectedDesc, descCol);
    }

    @Test
    public void testTransformedGenerator() {
        Float expected = 45.0f;
        Float total = IteratorToGeneratorAdapter.adapt(ascFloatRange)
            .to(new Function<Generator<? extends Float>, Float>() {

                public Float evaluate(Generator<? extends Float> obj) {
                    Float total = 0.0f;
                    for (Object element : obj.toCollection()) {
                        total += (Float) element;
                    }
                    return total;
                }
            });
        assertEquals(expected, total);
        expected = 55.0f;
        total = IteratorToGeneratorAdapter.adapt(descFloatRange)
            .to(new Function<Generator<? extends Float>, Float>() {

                public Float evaluate(Generator<? extends Float> obj) {
                    Float total = 0.0f;
                    for (Object element : obj.toCollection()) {
                        total += (Float) element;
                    }
                    return total;
                }
            });
        assertEquals(expected, total);
    }

    // Range tests
    // ---------------------------------------------------------------
    
    @Test
    public void testEmptyRanges() {
        FloatRange empty1 = Ranges.floatRange(-2, BoundType.OPEN, -1,
                                           BoundType.OPEN, 2);
        assertTrue("The range was expected to be empty.", empty1.isEmpty());
        FloatRange empty2 = Ranges.floatRange(2, BoundType.OPEN, 0,
                                           BoundType.OPEN, -2);
        assertTrue("The range was expected to be empty.", empty2.isEmpty());
        FloatRange empty3 = Ranges.floatRange(0, BoundType.OPEN, 1,
                                           BoundType.CLOSED, 2);
        assertTrue("The range was expected to be empty.", empty3.isEmpty());
        FloatRange empty4 = Ranges.floatRange(-3, BoundType.OPEN, -3,
                                           BoundType.OPEN, 1);
        assertTrue("The range was expected to be empty.", empty4.isEmpty());
        FloatRange empty5 = Ranges.floatRange(-3, BoundType.CLOSED, -3,
                                           BoundType.OPEN, 1);
        assertTrue("The range was expected to be empty.", empty5.isEmpty());
        FloatRange empty6 = Ranges.floatRange(1, BoundType.OPEN, 0,
                                           BoundType.CLOSED, -2);
        assertTrue("The range was expected to be empty.", empty6.isEmpty());
        FloatRange notEmpty1 = Ranges.floatRange(-3, BoundType.CLOSED, -3,
                                              BoundType.CLOSED, 1);
        assertFalse("The range was not expected to be empty.",
                    notEmpty1.isEmpty());
        FloatRange notEmpty2 = Ranges.floatRange(-3, BoundType.OPEN, -2,
                                              BoundType.CLOSED, 1);
        assertFalse("The range was not expected to be empty.",
                    notEmpty2.isEmpty());
        FloatRange notEmpty3 = Ranges.floatRange(2, BoundType.OPEN, 1,
                                              BoundType.CLOSED, -1);
        assertFalse("The range was not expected to be empty.",
                    notEmpty3.isEmpty());
        FloatRange notEmpty4 = Ranges.floatRange(2, BoundType.CLOSED, 1,
                                              BoundType.OPEN, -1);
        assertFalse("The range was not expected to be empty.",
                    notEmpty4.isEmpty());
        FloatRange notEmpty5 = Ranges.floatRange(1, BoundType.CLOSED, 2,
                                              BoundType.OPEN, 1);
        assertFalse("The range was not expected to be empty.",
                    notEmpty5.isEmpty());
    }

    @Test
    public void testBoundaries() {
        FloatRange range = Ranges.floatRange(0.0f, 10.0f);
        assertEquals(new Endpoint<Comparable<?>>(0.0f, BoundType.CLOSED),
                     range.getLeftEndpoint());
        assertEquals(new Endpoint<Comparable<?>>(10.0f, BoundType.OPEN),
                     range.getRightEndpoint());
    }

    @Test
    public void testClosedClosedAscendingContains() {
        // [-5, 5], 3 = -5, -2, 1, 4
        FloatRange range = Ranges.floatRange(-5, BoundType.CLOSED, 5,
                                          BoundType.CLOSED, 3);
        // [-5, 5], 3 = -5, -2, 1, 4
        List<Float> arr = Arrays.asList(-5.0f, -2.0f, 1.0f, 4.0f);
        for (Float element : arr) {
            assertTrue("Expected element [" + element +
                               "] is missing in range [" + range + "]",
                       range.contains(element));
        }
        List<Float> elementsNotPresent = new ArrayList<Float>(fullRange);
        elementsNotPresent.removeAll(arr);
        for (Float element : elementsNotPresent) {
            assertFalse("Unexpected element [" + element +
                                "] is present in range [" + range + "]",
                        range.contains(element));
        }
    }

    @Test
    public void testOpenClosedAscendingContains() {
        // (-5, 5], 3 = -2, 1, 4
        FloatRange range = Ranges.floatRange(-5, BoundType.OPEN, 5,
                                          BoundType.CLOSED, 3);
        // (-5, 5], 3 = -2, 1, 4
        List<Float> arr = Arrays.asList(-2.0f, 1.0f, 4.0f);
        for (Float element : arr) {
            assertTrue("Expected element [" + element +
                               "] is missing in range [" + range + "]",
                       range.contains(element));
        }
        List<Float> elementsNotPresent = new ArrayList<Float>(fullRange);
        elementsNotPresent.removeAll(arr);
        for (Float 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
        FloatRange range = Ranges.floatRange(-5, BoundType.CLOSED, 5,
                                          BoundType.OPEN, 3);
        // (-5, 5], 3 = -5, -2, 1, 4
        List<Float> arr = Arrays.asList(-5.0f, -2.0f, 1.0f, 4.0f);
        for (Float element : arr) {
            assertTrue("Expected element [" + element +
                               "] is missing in range [" + range + "]",
                       range.contains(element));
        }
        List<Float> elementsNotPresent = new ArrayList<Float>(fullRange);
        elementsNotPresent.removeAll(arr);
        for (Float element : elementsNotPresent) {
            assertFalse("Unexpected element [" + element +
                                "] is present in range [" + range + "]",
                        range.contains(element));
        }
    }

    @Test
    public void testOpenOpenAscendingContains() {
        // (-5, 5), 3 = -2, 1, 4
        FloatRange range = Ranges.floatRange(-5, BoundType.OPEN, 5,
                                          BoundType.OPEN, 3);
        // (-5, 5), 3 = -2, 1, 4
        List<Float> arr = Arrays.asList(-2.0f, 1.0f, 4.0f);
        for (Float element : arr) {
            assertTrue("Expected element [" + element +
                               "] is missing in range [" + range + "]",
                       range.contains(element));
        }
        List<Float> elementsNotPresent = new ArrayList<Float>(fullRange);
        elementsNotPresent.removeAll(arr);
        for (Float 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
        FloatRange ascendingRange = Ranges.floatRange(-2, BoundType.OPEN, 2,
                                                   BoundType.CLOSED, 1);
        // (-2, 2], 1 = -1, 0, 1, 2
        List<Float> arr = Arrays.asList(-1.0f, 0.0f, 1.0f, 2.0f);
        for (Float element : arr) {
            assertTrue("Expected element [" + element +
                               "] is missing in range [" + ascendingRange + "]",
                       ascendingRange.contains(element));
        }
        List<Float> elementsNotPresent = new ArrayList<Float>(fullRange);
        elementsNotPresent.removeAll(arr);
        for (Float 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
        FloatRange range = Ranges.floatRange(5, BoundType.CLOSED, -5,
                                          BoundType.CLOSED, -3);
        // [5, -5], -3 = 5, 2, -1, -4
        List<Float> arr = Arrays.asList(5.0f, 2.0f, -1.0f, -4.0f);
        for (Float element : arr) {
            assertTrue("Expected element [" + element +
                               "] is missing in range [" + range + "]",
                       range.contains(element));
        }
        List<Float> elementsNotPresent = new ArrayList<Float>(fullRange);
        elementsNotPresent.removeAll(arr);
        for (Float element : elementsNotPresent) {
            assertFalse("Unexpected element [" + element +
                                "] is present in range [" + range + "]",
                        range.contains(element));
        }
    }

    @Test
    public void testOpenClosedDescendingContains() {
        // (5, -5], -3 = 2, -1, -4
        FloatRange range = Ranges.floatRange(5, BoundType.OPEN, -5,
                                          BoundType.CLOSED, -3);
        // (5, -5], -3 = 2, -1, -4
        List<Float> arr = Arrays.asList(2.0f, -1.0f, -4.0f);
        for (Float element : arr) {
            assertTrue("Expected element [" + element +
                               "] is missing in range [" + range + "]",
                       range.contains(element));
        }
        List<Float> elementsNotPresent = new ArrayList<Float>(fullRange);
        elementsNotPresent.removeAll(arr);
        for (Float 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
        FloatRange range = Ranges.floatRange(5, BoundType.CLOSED, -5,
                                          BoundType.OPEN, -3);
        // [5, -5), -3 = 5, 2, -1, -4
        List<Float> arr = Arrays.asList(5.0f, 2.0f, -1.0f, -4.0f);
        for (Float element : arr) {
            assertTrue("Expected element [" + element +
                               "] is missing in range [" + range + "]",
                       range.contains(element));
        }
        List<Float> elementsNotPresent = new ArrayList<Float>(fullRange);
        elementsNotPresent.removeAll(arr);
        for (Float element : elementsNotPresent) {
            assertFalse("Unexpected element [" + element +
                                "] is present in range [" + range + "]",
                        range.contains(element));
        }
    }

    @Test
    public void testOpenOpenDescendingContains() {
        // (5, -5), -3 = 2, -1, -4
        FloatRange range = Ranges.floatRange(5, BoundType.OPEN, -5,
                                          BoundType.OPEN, -3);
        // (5, -5), -3 = 2, -1, -4
        List<Float> arr = Arrays.asList(2.0f, -1.0f, -4.0f);
        for (Float element : arr) {
            assertTrue("Expected element [" + element +
                               "] is missing in range [" + range + "]",
                       range.contains(element));
        }
        List<Float> elementsNotPresent = new ArrayList<Float>(fullRange);
        elementsNotPresent.removeAll(arr);
        for (Float 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
        FloatRange descendingRange = Ranges.floatRange(2, BoundType.CLOSED, -2,
                                                    BoundType.OPEN, -1);
        // [2, -2), -1 = 2, 1, 0, -1
        List<Float> arr = Arrays.asList(2.0f, 1.0f, 0.0f, -1.0f);
        for (Float element : arr) {
            assertTrue("Expected element [" + element +
                               "] is missing in range [" + descendingRange +
                               "]",
                       descendingRange.contains(element));
        }
        List<Float> elementsNotPresent = new ArrayList<Float>(fullRange);
        elementsNotPresent.removeAll(arr);
        for (Float element : elementsNotPresent) {
            assertFalse("Unexpected element [" + element +
                                "] is present in range [" + descendingRange +
                                "]",
                        descendingRange.contains(element));
        }
    }

    @Test
    public void testContainsNullOrEmpty() {
        FloatRange range = Ranges.floatRange(-2, BoundType.OPEN, 2,
                                          BoundType.CLOSED, 1);
        assertFalse(range.contains(null));
    }

    @SuppressWarnings("unchecked")
    @Test
    public void testContainsAll() {
        // (-2, 2], 1 = -1, 0, 1, 2
        FloatRange range = Ranges.floatRange(-2, BoundType.OPEN, 2,
                                          BoundType.CLOSED, 1);
        List<Float> list = Arrays.asList(-1.0f, 0.0f, 1.0f, 2.0f);
        assertTrue("Range [" + range +
                   "] was expected to contain all elements from list [" + list +
                   "]", range.containsAll(list));
        List<Float> listWithExtraElements = Arrays.asList(2.0f, -1.0f, 0.0f,
                                                          1.0f, 2.0f, 3.0f);
        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
        FloatRange range = Ranges.floatRange(-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.floatRange(-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.floatRange(-1, BoundType.CLOSED, 2, BoundType.OPEN,
                                       1);
        assertFalse("Invalid equals after changing attributes",
                    range.equals(range3));

        Object range4 = Ranges.floatRange(-2, BoundType.OPEN, 2, BoundType.OPEN, 1);
        assertFalse("Invalid equals after changing attributes",
                    range.equals(range4));

        Object range5 = Ranges.floatRange(-2, BoundType.CLOSED, 1, BoundType.OPEN,
                                       1);
        assertFalse("Invalid equals after changing attributes",
                    range.equals(range5));

        Object range6 = Ranges.floatRange(-2, BoundType.CLOSED, 2,
                                       BoundType.CLOSED, 1);
        assertFalse("Invalid equals after changing attributes",
                    range.equals(range6));

        Object range7 = Ranges.floatRange(-2, BoundType.CLOSED, 2, BoundType.OPEN,
                                       2);
        assertFalse("Invalid equals after changing attributes",
                    range.equals(range7));

        // Using different constructors
        FloatRange range8 = Ranges.floatRange(Long.valueOf(-2), Long.valueOf(2),
                                           Long.valueOf(1));
        assertEquals("Invalid equals using different constructor", range,
                     range8);

        FloatRange range9 = Ranges.floatRange(Long.valueOf(-2), Long.valueOf(2));
        assertEquals("Invalid equals using different constructor", range,
                     range9);

        Endpoint<Float> leftEndpoint = new Endpoint<Float>(-2.0f,
                                                           BoundType.CLOSED);
        Endpoint<Float> rightEndpoint = new Endpoint<Float>(2.0f,
                                                            BoundType.OPEN);
        FloatRange range10 = Ranges.floatRange(leftEndpoint, rightEndpoint, 1.0f);
        assertEquals("Invalid equals using different constructor", range,
                     range10);
    }

    @Test
    public void testToString() {
        FloatRange range = Ranges.floatRange(-2, BoundType.OPEN, 2,
                                          BoundType.CLOSED, 1);
        assertEquals("Wrong string value", "FloatRange<(-2.0, 2.0], 1.0>",
                     range.toString());
    }

    @Test
    public void testConstructorUsingSameEndpoint() {
        Endpoint<Float> uniqueEndpoint = new Endpoint<Float>(10.0f,
                                                             BoundType.CLOSED);
        try {
            Ranges.floatRange(uniqueEndpoint, uniqueEndpoint, 1.0f);
        } catch (IllegalArgumentException e) {
            fail("Not expected to get here");
        }
    }

    @Test
    public void testInvalidRange() {
        try {
            Ranges.floatRange(10.0f, BoundType.OPEN, -5.0f, BoundType.CLOSED,
                           10.0f);
            fail("Not expected to get here");
        } catch (IllegalArgumentException e) {
            // Do nothing
        }
        Endpoint<Float> leftEndpoint = new Endpoint<Float>(10.0f,
                                                           BoundType.CLOSED);
        Endpoint<Float> rightEndpoint = new Endpoint<Float>(-5.0f,
                                                            BoundType.OPEN);
        try {
            Ranges.floatRange(leftEndpoint, rightEndpoint, 1.0f);
            fail("Not expected to get here");
        } catch (IllegalArgumentException e) {
            // Do nothing
        }
    }

    @Test
    public void testDefaultStep() {
        assertEquals("Invalid default step", Float.valueOf(-1.0f),
                     FloatRange.DEFAULT_STEP.evaluate(10.0f, 1.0f));
        assertEquals("Invalid default step", Float.valueOf(1.0f),
                     FloatRange.DEFAULT_STEP.evaluate(1.0f, 10.0f));
    }

}