// int functors

class IntPredicate
{
    false => int default;

    fun int test(int arg)
    {
        return false;
    }
}

class IntProcedure
{
    fun void run(int arg)
    {
        // empty
    }
}

class IntFunction
{
    0 => int default;

    fun int evaluate(int arg)
    {
        return default;
    }
}

class IntComparator
{
    0 => int default;

    fun int compare(int arg0, int arg1)
    {
        return default;
    }
}

class IntIntPredicate
{
    false => int default;

    fun int test(int arg0, int arg1)
    {
        return default;
    }
}

class IntIntProcedure
{
    fun void run(int arg0, int arg1)
    {
        // empty
    }
}

class IntIntFunction
{
    0 => int default;

    fun int evaluate(int arg0, int arg1)
    {
        return default;
    }
}

class IntIntIntPredicate
{
    false => int default;

    fun int test(int arg0, int arg1, int arg2)
    {
        return default;
    }
}

class IntIntIntProcedure
{
    fun void run(int arg0, int arg1, int arg2)
    {
        // empty
    }
}

class IntIntIntFunction
{
    0 => int default;

    fun int evaluate(int arg0, int arg1, int arg2)
    {
        return default;
    }
}

class IntIntIntIntPredicate
{
    false => int default;

    fun int test(int arg0, int arg1, int arg2, int arg3)
    {
        return default;
    }
}

class IntIntIntIntProcedure
{
    fun void run(int arg0, int arg1, int arg2, int arg3)
    {
        // empty
    }
}

class IntIntIntIntFunction
{
    0 => int default;

    fun int evaluate(int arg0, int arg1, int arg2, int arg3)
    {
        return default;
    }
}

// int list api

class IntIterator
{
    fun int hasNext()
    {
        return false;
    }

    fun int next()
    {
        return -1;
    }
}

class IntList
{
    fun int size()
    {
        return -1;
    }

    fun int isEmpty()
    {
        return (size() == 0);
    }

    fun int size(int capacity)
    {
        return -1;
    }

    fun int get(int index)
    {
        return -1;
    }

    fun void add(int value)
    {
        // empty
    }

    fun void addAll(IntList list)
    {
        // empty
    }

    fun void set(int index, int value)
    {
        // empty
    }

    fun IntIterator iterator()
    {
        return null;
    }

    fun void forEach(IntProcedure procedure)
    {
        // empty
    }

    fun void forEach(IntPredicate predicate, IntProcedure procedure)
    {
        // empty
    }

    fun void clear()
    {
        // empty
    }

    fun void assign(int value)
    {
        // empty
    }

    fun void transform(IntFunction fn)
    {
        // empty
    }

    fun void sort(IntComparator comparator)
    {
        // empty
    }

    fun IntList copy()
    {
        return null;
    }

    fun IntList subList(int fromIndex, int toIndex)
    {
        return null;
    }
}

// int list implementation

class IntListIterator extends IntIterator
{
    0 => int index;
    IntList @ list;

    fun int hasNext()
    {
        return (index < list.size());
    }

    fun int next()
    {
        list.get(index) => int rv;
        index++;
        return rv;
    }
}

class IntArrayList extends IntList
{
    int values[0];

    fun int size()
    {
        return values.size();
    }
    
    fun int size(int capacity)
    {
        return values.size(capacity);
    }

    fun int get(int index)
    {
        return values[index];
    }

    fun void add(int value)
    {
        values << value;
    }

    fun void addAll(IntList list)
    {
        list.iterator() @=> IntIterator it;
        while (it.hasNext())
        {
            add(it.next());
        }
    }

    fun void set(int index, int value)
    {
        value => values[index];
    }

    fun IntIterator iterator()
    {
        IntListIterator i;
        this @=> i.list;
        return i;
    }

    fun void forEach(IntProcedure procedure)
    {
        for (0 => int i; i < size(); i++)
        {
            procedure.run(values[i]);
        }
    }

    fun void forEach(IntPredicate predicate, IntProcedure procedure)
    {
        for (0 => int i; i < size(); i++)
        {
            if (predicate.test(values[i]))
            {
                procedure.run(values[i]);
            }
        }
    }

    fun void assign(int value)
    {
        for (0 => int i; i < size(); i++)
        {
            value => values[i];
        }        
    }

    fun void transform(IntFunction fn)
    {
        for (0 => int i; i < size(); i++)
        {
            fn.evaluate(values[i]) => values[i];
        }
    }
}

// chuck-unit

class Assert
{
    false => int exitOnFailure;

    fun void assertTrue(int expr)
    {
        if (!expr)
        {
            "expected true" => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertTrue(string message, int expr)
    {
        if (!expr)
        {
            message + " expected true" => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertFalse(int expr)
    {
        if (expr)
        {
            "expected false" => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertFalse(string message, int expr)
    {
        if (expr)
        {
            message + " expected false" => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertNull(Object value)
    {
        if (value != null)
        {
            "expected null, was: " + value => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertNull(string message, Object value)
    {
        if (value != null)
        {
            message + " expected null, was: " + value => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertNotNull(Object value)
    {
        if (value == null)
        {
            "expected not null" => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertNotNull(string message, Object value)
    {
        if (value == null)
        {
            message + " expected not null" => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertEquals(int expected, int actual)
    {
        if (expected != actual)
        {
            "expected: " + expected + " actual: " + actual => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertEquals(string message, int expected, int actual)
    {
        if (expected != actual)
        {
            message + " expected: " + expected + " actual: " + actual => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertEquals(float expected, float actual, float delta)
    {
        if (Std.fabs(expected - actual) > delta)
        {
            "expected: " + expected + " actual: " + actual + " not within: " + delta => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertEquals(string message, float expected, float actual, float delta)
    {
        if (Std.fabs(expected - actual) > delta)
        {
            message + " expected: " + expected + " actual: " + actual + " not within: " + delta => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertEquals(Object expected, Object actual)
    {
        if (expected != actual)
        {
            "expected: " + expected + " actual: " + actual => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertEquals(string message, Object expected, Object actual)
    {
        if (expected != actual)
        {
            message + " expected: " + expected + " actual: " + actual => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertNotEquals(int expected, int actual)
    {
        if (expected == actual)
        {
            "expected: " + expected + " actual: " + actual + " expected not equals" => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertNotEquals(string message, int expected, int actual)
    {
        if (expected == actual)
        {
            message + " expected: " + expected + " actual: " + actual + " expected not equals" => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertNotEquals(float expected, float actual, float delta)
    {
        if (Std.fabs(expected - actual) <= delta)
        {
            "expected: " + expected + " actual: " + actual + " expected not within: " + delta => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertNotEquals(string message, float expected, float actual, float delta)
    {
        if (Std.fabs(expected - actual) <= delta)
        {
            message + " expected: " + expected + " actual: " + actual + " expected not within: " + delta => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertNotEquals(Object expected, Object actual)
    {
        if (expected == actual)
        {
            "expected: " + expected + " actual: " + actual + " expected not equals" => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void assertNotEquals(string message, Object expected, Object actual)
    {
        if (expected == actual)
        {
            message + " expected: " + expected + " actual: " + actual + " expected not equals" => string errorMessage;
            fail(errorMessage);
        }
    }

    fun void fail()
    {
        fail(null);
    }

    fun void fail(string message)
    {
        if (message == null)
        {
            <<<"test failure">>>;
        }
        else
        {
            <<<"test failure:", message>>>;            
        }
        if (exitOnFailure)
        {
            me.exit();
        }
    }
}

// unit test for IntArrayList

class NeverTrue extends IntPredicate
{
    // empty
}

class AlwaysTrue extends IntPredicate
{
    fun int test(int arg)
    {
        return true;
    }
}

class Inverse extends IntFunction
{
    fun int evaluate(int arg)
    {
        return (-1 * arg);
    }
}

class IntArrayListTest extends Assert
{
    {
        true => exitOnFailure;
        testConstructor();
        testSize();
        testGetAddSet();
        testIterator();
        testForEach();
        testAssign();
        testTransform();
        testAddAll();

        <<<"ok">>>;
    }

    fun void testConstructor()
    {
        IntArrayList list;
        assertNotNull(list);
    }

    fun void testSize()
    {
        IntArrayList list;
        assertNotNull(list);
        assertEquals(0, list.size());
        assertTrue(list.isEmpty());

        assertEquals(16, list.size(16));
        assertFalse(list.isEmpty());

        assertEquals(0, list.size(0));
        assertTrue(list.isEmpty());
    }

    fun void testGetAddSet()
    {
        IntArrayList list;

        list.add(42);
        assertEquals(1, list.size());
        assertFalse(list.isEmpty());
        assertEquals(42, list.get(0));

        list.set(0, -42);
        assertEquals(-42, list.get(0));

        // throws ArrayOutofBounds
        //list.get(99);
        //list.set(1, 99);
    }

    fun void testIterator()
    {
        IntArrayList list;
        list.add(1);
        list.add(2);
        list.add(3);

        list.iterator() @=> IntIterator iterator;
        assertNotNull(iterator);
        while (iterator.hasNext())
        {
            iterator.next() => int value;
            assertTrue(value > 0);
        }
    }

    fun void testForEach()
    {
        IntArrayList list;
        list.add(1);
        list.add(2);
        list.add(3);

        IntProcedure procedure;
        list.forEach(procedure);

        NeverTrue neverTrue;
        list.forEach(neverTrue, procedure);

        AlwaysTrue alwaysTrue;
        list.forEach(alwaysTrue, procedure);

        // throws NullPointerException
        //list.forEach(null);
        //list.forEach(null, procedure);
        //list.forEach(alwaysTrue, null);
    }

    fun void testAssign()
    {
        IntArrayList list;
        IntIterator @ iterator;
        list.size(16);

        list.iterator() @=> iterator;
        while (iterator.hasNext())
        {
            iterator.next() => int value;
            assertEquals(0, value);
        }

        list.assign(42);
        list.iterator() @=> iterator;
        while (iterator.hasNext())
        {
            iterator.next() => int value;
            assertEquals(42, value);
        }

        list.assign(0);
        list.iterator() @=> iterator;
        while (iterator.hasNext())
        {
            iterator.next() => int value;
            assertEquals(0, value);
        }
    }

    fun void testTransform()
    {
        IntArrayList list;
        IntIterator @ iterator;
        Inverse inverse;
        list.size(16);

        list.assign(42);
        list.iterator() @=> iterator;
        while (iterator.hasNext())
        {
            iterator.next() => int value;
            assertEquals(42, value);
        }

        list.transform(inverse);
        list.iterator() @=> iterator;
        while (iterator.hasNext())
        {
            iterator.next() => int value;
            assertEquals(-42, value);
        }

        list.transform(inverse);
        list.iterator() @=> iterator;
        while (iterator.hasNext())
        {
            iterator.next() => int value;
            assertEquals(42, value);
        }

        // throws NullPointerException
        //list.transform(null);
    }

    fun void testAddAll()
    {
        IntArrayList list0;
        list0.size(16);
        list0.assign(42);

        IntArrayList list1;
        list1.size(16);
        list1.assign(-42);

        IntArrayList list2;
        list2.addAll(list0);
        list2.addAll(list1);
        assertEquals(32, list2.size());

        list2.iterator() @=> IntIterator iterator;
        while (iterator.hasNext())
        {
            iterator.next() => int value;
            assertTrue((value == 42) || (value == -42));
        }
    }
}

IntArrayListTest intArrayListTest;
1::second => now;