/*
 $Id: NumberRangeTest.java,v 1.2 2006/11/13 10:23:58 edwin Exp edwin $

 Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.

 Redistribution and use of this software and associated documentation
 ("Software"), with or without modification, are permitted provided
 that the following conditions are met:

 1. Redistributions of source code must retain copyright
    statements and notices.  Redistributions must also contain a
    copy of this document.

 2. Redistributions in binary form must reproduce the
    above copyright notice, this list of conditions and the
    following disclaimer in the documentation and/or other
    materials provided with the distribution.

 3. The name "groovy" must not be used to endorse or promote
    products derived from this Software without prior written
    permission of The Codehaus.  For written permission,
    please contact info@codehaus.org.

 4. Products derived from this Software may not be called "groovy"
    nor may "groovy" appear in their names without prior written
    permission of The Codehaus. "groovy" is a registered
    trademark of The Codehaus.

 5. Due credit should be given to The Codehaus -
    http://groovy.codehaus.org/

 THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS
 ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
 NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 OF THE POSSIBILITY OF SUCH DAMAGE.

 */
package groovy.lang;

import junit.framework.TestCase;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

/**
 * Provides unit tests for ranges of numbers.
 *
 * @author Edwin Tellman
 */
public abstract class NumberRangeTest extends TestCase {

    /**
     * Records the values passed to a closure.
     */
    protected static class RecordingClosure extends Closure {
        /**
         * Holds the values passed in
         */
        final List callLog;

        /**
         * Creates a new <code>RecordingClosure</code>
         *
         * @param callLog is filled with the values passed to <code>doCall</code>
         */
        RecordingClosure(final List callLog) {
            super(null);
            this.callLog = callLog;
        }

        /**
         * Stores <code>params</code> in the <code>callLog</code>.
         *
         * @param params the parameters.
         * @return null
         */
        public Object doCall(final Object params) {
            callLog.add(params);
            return null;
        }
    }

    /**
     * Creates a {@link Range} to test.
     *
     * @param from the first value in the range.
     * @param to   the last value in the range.
     * @return a {@link Range} to test
     */
    protected abstract Range createRange(final int from, final int to);

    /**
     * Creates a value in the range.
     *
     * @param value the value to create.
     * @return a value in the range.
     */
    protected abstract Comparable createValue(final int value);

    /**
     * Tests <code>hashCode</code> and <code>equals</code> comparing one {@link IntRange} to another {@link IntRange}.
     */
    public final void testHashCodeAndEquals() {
        Range a = createRange(1, 11);
        Range b = createRange(1, 11);
        Range c = createRange(2, 11);

        assertEquals("hashcode", a.hashCode(), b.hashCode());
        assertTrue("hashcode", a.hashCode() != c.hashCode());

        assertEquals("a and b", a, b);
        assertFalse("a != c", a.equals(c));
    }

    /**
     * Tests using different classes for 'from' and 'to'.
     */
    public void testDifferentClassesForFromAndTo() {
        final Integer from = new Integer(1);
        final Comparable to = createValue(5);
        final Range range = new ObjectRange(from, to);

        assertEquals("wrong 'from' value", from, range.getFrom());
        assertEquals("wrong 'to' value", to, range.getTo());
    }

    /**
     * Tests a <code>null</code> 'from' value.
     */
    public void testNullFrom() {
        try {
            new ObjectRange(null, createValue(5));
            fail("null 'from' accepted");
        }
        catch (IllegalArgumentException e) {
            assertTrue("expected exception thrown", true);
        }
    }

    /**
     * Tests a <code>null</code> 'to' value.
     */
    public void testNullTo() {
        try {
            new ObjectRange(createValue(23), null);
            fail("null 'to' accepted");
        }
        catch (IllegalArgumentException e) {
            assertTrue("expected exception thrown", true);
        }
    }

    /**
     * Tests stepping through a range by two with a closure.
     */
    public void testStepByTwoWithClosure() {
        final List callLog = new ArrayList();
        final Closure closure = new RecordingClosure(callLog);

        final Range range = createRange(0, 4);
        range.step(2, closure);

        assertEquals("wrong number of calls to closure", 3, callLog.size());
        final Iterator iter = callLog.iterator();
        for (int i = 0; i <= 4; i += 2) {
            assertEquals("wrong argument passed to closure", createValue(i), iter.next());
        }
    }

    /**
     * Tests iterating over a one-element range.
     */
    public void testOneElementRange() {
        final Range range = createRange(1, 1);
        int next = 1;
        for (Iterator iter = range.iterator(); iter.hasNext();) {
            final Number number = (Number) iter.next();
            assertEquals("wrong number", createValue(next++), number);
        }
        assertEquals("wrong number of elements in iteration", 2, next);
    }

    /**
     * Tests stepping through a reversed range by two with a closure.
     */
    public void testReverseStepByTwoWithClosure() {
        final List callLog = new ArrayList();
        final Closure closure = new RecordingClosure(callLog);

        final Range range = createRange(4, 0);
        range.step(2, closure);

        assertEquals("wrong number of calls to closure", 3, callLog.size());
        final Iterator iter = callLog.iterator();
        for (int i = 4; i >= 0; i -= 2) {
            assertEquals("wrong argument passed to closure", createValue(i), iter.next());
        }
    }

    /**
     * Tests stepping through a range with a closure.
     */
    public void testStepByOneWithClosure() {
        final List callLog = new ArrayList();
        final Closure closure = new RecordingClosure(callLog);

        final Range range = createRange(1, 5);
        range.step(1, closure);

        assertEquals("wrong number of calls to closure", 5, callLog.size());
        final Iterator iter = callLog.iterator();
        for (int i = 1; i <= 5; i++) {
            assertEquals("wrong argument passed to closure", createValue(i), iter.next());
        }
    }

    /**
     * Tests stepping through a reversed range by one with a closure.
     */
    public void testReverseStepByOneWithClosure() {
        final List callLog = new ArrayList();
        final Closure closure = new RecordingClosure(callLog);

        final Range range = createRange(5, 1);
        range.step(1, closure);

        assertEquals("wrong number of calls to closure", 5, callLog.size());
        final Iterator iter = callLog.iterator();
        for (int i = 5; i >= 1; i--) {
            assertEquals("wrong argument passed to closure", createValue(i), iter.next());
        }
    }

    /**
     * Tests stepping backwards through a range with a closure.
     */
    public void testNegativeStepByOneWithClosure() {
        final List callLog = new ArrayList();
        final Closure closure = new RecordingClosure(callLog);

        final Range range = createRange(1, 5);
        range.step(-1, closure);

        assertEquals("wrong number of calls to closure", 5, callLog.size());
        final Iterator iter = callLog.iterator();
        for (int i = 5; i >= 1; i--) {
            assertEquals("wrong argument passed to closure", createValue(i), iter.next());
        }
    }

    /**
     * Tests stepping backwards through a reversed range with a closure.
     */
    public void testNegativeReverseStepByOneWithClosure() {
        final List callLog = new ArrayList();
        final Closure closure = new RecordingClosure(callLog);

        final Range range = createRange(5, 1);
        range.step(-1, closure);

        assertEquals("wrong number of calls to closure", 5, callLog.size());
        final Iterator iter = callLog.iterator();
        for (int i = 1; i <= 5; i++) {
            assertEquals("wrong argument passed to closure", createValue(i), iter.next());
        }
    }

    /**
     * Tests stepping backwards through a range with a step size greater than the range size.
     */
    public void testStepLargerThanRange() {
        final List callLog = new ArrayList();
        final Closure closure = new RecordingClosure(callLog);

        final Range range = createRange(1, 5);

        range.step(6, closure);
        assertEquals("wrong number of calls to closure", 1, callLog.size());
        assertEquals("wrong value", createValue(1), callLog.get(0));

        final List stepList = range.step(6);
        assertEquals("wrong number of values in result", 1, stepList.size());
        assertEquals("wrong value", createValue(1), callLog.get(0));
    }

    /**
     * Tests stepping through a range by one.
     */
    public void testStepByOne() {
        final Range range = createRange(1, 5);
        final List result = range.step(1);

        assertEquals("wrong number of calls", 5, result.size());
        final Iterator iter = result.iterator();
        for (int i = 1; i <= 5; i++) {
            assertEquals("incorrect value in result", createValue(i), iter.next());
        }
    }

    /**
     * Tests stepping through a range by two.
     */
    public void testStepByTwo() {
        final Range range = createRange(1, 5);
        final List result = range.step(2);

        assertEquals("wrong number of calls", 3, result.size());
        final Iterator iter = result.iterator();
        for (int i = 1; i <= 5; i += 2) {
            assertEquals("incorrect value in result", createValue(i), iter.next());
        }
    }

    /**
     * Tests getting the size.
     */
    public void testSize() {
        Range range = createRange(0, 10);
        assertEquals("Size of " + range, 11, range.size());
        range = createRange(0, 1);
        assertEquals("Size of " + range, 2, range.size());
        range = createRange(0, 0);
        assertEquals("Size of " + range, 1, range.size());
    }

    /**
     * Tests asking for an index outside of the valid range
     */
    public void testGetOutOfRange() {
        Range r = createRange(10, 20);

        try {
            r.get(-1);
            fail("Should have thrown IndexOutOfBoundsException");
        }
        catch (IndexOutOfBoundsException e) {
            assertTrue("expected exception thrown", true);
        }
        try {
            r.get(11);
            fail("Should have thrown IndexOutOfBoundsException");
        }
        catch (IndexOutOfBoundsException e) {
            assertTrue("expected exception thrown", true);
        }

    }

    /**
     * Tests getting a sub list.
     */
    public void testSubList() {
        Range range = createRange(0, 5);

        List subList = range.subList(2, 4);
        assertEquals("size", 2, subList.size());

        assertTrue("sublist not a range", subList instanceof Range);
        Range subListRange = (Range) subList;

        assertEquals("from", createValue(2), subListRange.getFrom());
        assertEquals("to", createValue(3), subListRange.getTo());

        subList = range.subList(0, 6);
        assertEquals("size", 6, subList.size());

        assertTrue("sublist not a range", subList instanceof Range);
        subListRange = (Range) subList;

        assertEquals("from", createValue(0), subListRange.getFrom());
        assertEquals("to", createValue(5), subListRange.getTo());
    }

    /**
     * Tests creating a sub list with a negative "from" index.
     */
    public void testSubListNegativeFrom() {
        try {
            final Range range = createRange(1, 5);
            range.subList(-1, 3);
            fail("accepted sub list with negative index");
        }
        catch (IndexOutOfBoundsException e) {
            assertTrue("expected exception thrown", true);
        }
    }

    /**
     * Tests creating a sub list with an out of range "to" index.
     */
    public void testSubListOutOfRangeTo() {
        try {
            final Range range = createRange(0, 3);
            range.subList(0, 5);
            fail("accepted sub list with invalid 'to'");
        }
        catch (IndexOutOfBoundsException e) {
            assertTrue("expected exception thrown", true);
        }
    }

    /**
     * Tests creating a sub list with "from" grater than "to."
     */
    public void testSubListFromGreaterThanTo() {
        try {
            final Range range = createRange(1, 5);
            range.subList(3, 2);
            fail("accepted sub list with 'from' greater than 'to'");
        }
        catch (IllegalArgumentException e) {
            assertTrue("expected exception thrown", true);
        }
    }

    /**
     * Tests creating an empty sub list.
     */
    public void testEmptySubList() {
        final Range range = createRange(1, 5);

        List subList = range.subList(0, 0);
        assertEquals("wrong number of elements in sub list", 0, subList.size());

        subList = range.subList(2, 2);
        assertEquals("wrong number of elements in sub list", 0, subList.size());
    }

    /**
     * Tests iterating over a non-reversed range.
     */
    public void testIterate() {
        final Range range = createRange(1, 5);
        int next = 1;
        final Iterator iter = range.iterator();
        while (iter.hasNext()) {
            final Object value = iter.next();
            assertEquals("wrong next value", createValue(next++), value);
        }
        assertEquals("wrong number of elements in iteration", 6, next);
        assertNull("got element after iterator finished", iter.next());
    }

    /**
     * Tests removing an element from the range using an iterator (not supported).
     */
    public void testRemoveFromIterator() {
        final Range range = createRange(1, 5);

        try {
            final Iterator iter = range.iterator();
            iter.remove();
            fail("successfully removed an element using an iterator");
        }
        catch (UnsupportedOperationException e) {
            assertTrue("expected exception thrown", true);
        }
    }

    /**
     * Tests iterating over a reversed range.
     */
    public void testIterateReversed() {
        final Range range = createRange(5, 1);
        int next = 5;
        for (Iterator iter = range.iterator(); iter.hasNext();) {
            assertEquals("wrong number", createValue(next--), iter.next());
        }
        assertEquals("wrong number of elements in iteration", 0, next);
    }

    /**
     * Tests creating an <code>IntRange</code> with from > to.
     */
    public void testFromGreaterThanTo() {
        final int from = 9;
        final int to = 0;
        final Range range = createRange(from, to);

        assertTrue("range not reversed", range.isReverse());

        // make sure to/from are swapped
        assertEquals("from incorrect", createValue(to), range.getFrom());
        assertEquals("to incorrect", createValue(from), range.getTo());

        assertEquals("wrong size", 10, range.size());

        assertEquals("wrong first element", createValue(9), range.get(0));
        assertEquals("wrong last element", createValue(0), range.get(9));
    }

    /**
     * Tests creating an <code>IntRange</code> with from == to.
     */
    public void testFromEqualsTo() {
        final Range range = createRange(5, 5);

        assertFalse("range reversed", range.isReverse());
        assertEquals("wrong size", 1, range.size());
    }

    /**
     * Tests creating an <code>IntRange</code> with from < to.
     */
    public void testFromLessThanTo() {
        final int from = 1;
        final int to = 4;
        final Range range = createRange(from, to);

        assertFalse("range reversed", range.isReverse());

        assertEquals("to incorrect", createValue(from), range.getFrom());
        assertEquals("from incorrect", createValue(to), range.getTo());

        assertEquals("wrong size", 4, range.size());
    }

    /**
     * Making a range equal a list is not actually possible, since list.equals(range) will not evaluate to
     * <code>true</code> and <code>equals</code> should be symmetric.
     */
    public void testEqualsList() {
        final List list = new ArrayList();
        list.add(createValue(1));
        list.add(createValue(2));

        final Range range = createRange(1, 2);

        // cast to Object to test routing through equals(Object)
        assertTrue("range does not equal list", range.equals((Object) list));
        assertTrue("list does not equal range", list.equals(range));
        assertEquals("hash codes are not equal", range.hashCode(), list.hashCode());

        // compare lists that are the same size but contain different elements
        list.set(0, createValue(3));
        assertFalse("range equals list", range.equals(list));
        assertFalse("list equals range", list.equals(range));
        assertFalse("hash codes are equal", range.hashCode() == list.hashCode());

        // compare a list longer than the range
        list.set(0, createValue(1));
        list.add(createValue(3));
        assertFalse("range equals list", range.equals(list));
        assertFalse("list equals range", list.equals(range));
        assertFalse("hash are equal", range.hashCode() == list.hashCode());

        // compare a list shorter than the range
        list.remove(2);
        list.remove(1);
        assertFalse("range equals list", range.equals(list));
        assertFalse("list equals range", list.equals(range));
        assertFalse("hash are equal", range.hashCode() == list.hashCode());
    }

    /**
     * Tests comparing {@link Range} to an object that is not a {@link Range}.
     */
    public void testEqualsNonRange() {
        final Range range = createRange(1, 5);
        assertFalse("range equal to string", range.equals("hello"));
    }

    /**
     * Tests comparing a {@link Range} cast to an {@link Object}
     */
    public void testEqualsRangeAsObject() {
        final Range range1 = createRange(1, 5);
        final Range range2 = createRange(1, 5);
        assertTrue("ranges not equal", range1.equals((Object) range2));
    }

    /**
     * Tests comparing two {@link Range}s to each other.
     */
    public void testEqualsRange() {
        final Range range1 = createRange(1, 5);
        Range range2 = createRange(1, 5);
        assertTrue("ranges not equal", range1.equals((Object) range2));
        assertTrue("ranges not equal", range2.equals((Object) range1));
        assertEquals("hash codes not equal", range1.hashCode(), range2.hashCode());

        range2 = createRange(0, 5);
        assertFalse("ranges equal", range1.equals((Object) range2));
        assertFalse("ranges equal", range2.equals((Object) range1));
        assertFalse("hash codes equal", range1.hashCode() == range2.hashCode());

        range2 = createRange(1, 6);
        assertFalse("ranges equal", range1.equals((Object) range2));
        assertFalse("ranges equal", range2.equals((Object) range1));
        assertFalse("hash codes equal", range1.hashCode() == range2.hashCode());

        range2 = createRange(0, 6);
        assertFalse("ranges equal", range1.equals((Object) range2));
        assertFalse("ranges equal", range2.equals((Object) range1));
        assertFalse("hash codes equal", range1.hashCode() == range2.hashCode());

        range2 = createRange(2, 4);
        assertFalse("ranges equal", range1.equals((Object) range2));
        assertFalse("ranges equal", range2.equals((Object) range1));
        assertFalse("hash codes equal", range1.hashCode() == range2.hashCode());

        range2 = createRange(5, 1);
        assertFalse("ranges equal", range1.equals((Object) range2));
        assertFalse("ranges equal", range2.equals((Object) range1));
        assertFalse("hash codes equal", range1.hashCode() == range2.hashCode());
    }

    /**
     * Tests <code>toString</code> and <code>inspect</code>
     */
    public void testToStringAndInspect() {
        Range range = createRange(1, 5);
        String expected = range.getFrom() + ".." + range.getTo();
        assertEquals("wrong string representation", expected, range.toString());
        assertEquals("wrong string representation", expected, range.inspect());

        range = createRange(5, 1);
        expected = range.getTo() + ".." + range.getFrom();
        assertEquals("wrong string representation", expected, range.toString());
        assertEquals("wrong string representation", expected, range.inspect());
    }

    /**
     * Tests <code>getFrom</code> and <code>getTo</code>.
     */
    public void testGetFromAndTo() {
        final int from = 1, to = 5;
        final Range range = createRange(from, to);

        assertEquals("wrong 'from' value", createValue(from), range.getFrom());
        assertEquals("wrong 'to' value", createValue(to), range.getTo());
    }

    /**
     * Tests comparing a {@link Range} to <code>null</code>.
     */
    public void testEqualsNull() {
        final Range range = createRange(1, 5);
        assertFalse("range equal to null", range.equals(null));
        assertFalse("range equal to null Object", range.equals((Object) null));
        assertFalse("range equal to null Range", range.equals((Range) null));
        assertFalse("range equal to null List", range.equals((List) null));
    }

    /**
     * Tests attempting to add a value to a range.
     */
    public void testAddValue() {
        try {
            final Range range = createRange(1, 5);
            range.add(createValue(20));
            fail("expected exception not thrown");
        }
        catch (UnsupportedOperationException e) {
            assertTrue("expected exception thrown", true);
        }
    }

    /**
     * Tests attempting to remove a value from a range.
     */
    public void testRemoveValue() {
        try {
            final Range range = createRange(1, 5);
            range.remove(0);
            fail("expected exception not thrown");
        }
        catch (UnsupportedOperationException e) {
            assertTrue("expected exception thrown", true);
        }
    }

    private void doTestContains(int from, int to, Range range) {
        // test integers
        assertTrue("missing 'from' value", range.contains(createValue(from)));
        assertTrue("missing 'to' value", range.contains(createValue(to)));
        assertTrue("missing mid point", range.contains(createValue((from + to) / 2)));
        assertFalse("contains out of range value", range.contains(createValue(from - 1)));
        assertFalse("contains out of range value", range.contains(createValue(to + 1)));

        // test ranges
        assertTrue("missing same range", range.containsAll(createRange(from, to)));
        assertTrue("missing same range", range.containsAll(createRange(to, from)));
        assertTrue("missing strict subset", range.containsAll(createRange(from + 1, to - 1)));
        assertTrue("missing subset", range.containsAll(createRange(from, to - 1)));
        assertTrue("missing subset", range.containsAll(createRange(from + 1, to)));
        assertFalse("contains non-subset", range.containsAll(createRange(from - 1, to)));
        assertFalse("contains non-subset", range.containsAll(createRange(from, to + 1)));
        assertFalse("contains non-subset", range.containsAll(createRange(from - 2, from - 1)));

        // ranges don't contain other ranges
        assertFalse("range contains sub-range", range.contains(createRange(from + 1, to - 1)));

        // test list
        final List list = new ArrayList();
        list.add(createValue(from));
        list.add(createValue(to));
        assertTrue("missing strict subset", range.containsAll(list));

        // test non-integer number
        assertFalse("contains Float", range.contains(new Float((to + from) / 2.0 + 0.3)));
    }

    /**
     * Tests whether the range contains a {@link Comparable} object which is not comparable with a {@link Number}.
     */
    public void testContainsIncompatibleComparable() {
        final Range range = createRange(1, 5);
        assertFalse("range contains string", range.contains("hello"));
        assertFalse("range contains string", range.contains("1"));
    }

    /**
     * Tests whether the range contains a non-comparable object.
     */
    public void testContainsNonComparable() {
        final Range range = createRange(1, 5);
        assertFalse("range contains hash map", range.contains(new HashMap()));
    }

    /**
     * Tests whether a {@link Range} contains another {@link Range} or a specific integer.
     */
    public void testContains() {
        final int from = 1, to = 5;
        doTestContains(from, to, createRange(from, to));
        doTestContains(from, to, createRange(to, from));
    }

    /**
     * Tests <code>get</code> from a reversed range.
     */
    public void testGetFromReversedRange() {
        final Range range = createRange(5, 1);

        for (int i = 0; i < 5; i++) {
            assertEquals("wrong element at position " + i, createValue(5 - i), range.get(i));
        }
    }

    /**
     * Tests getting values from the range.
     */
    public void testGet() {
        final Range range = createRange(10, 20);
        for (int i = 0; i <= 10; i++) {
            assertEquals("Item at index: " + i, createValue(i + 10), range.get(i));
        }
    }
}