// object functors

class Function // or Factory
{
    Object @ default;

    fun Object evaluate()
    {
        return default;
    }
}

class Predicate
{
    false => int default;

    fun int test()
    {
        return false;
    }
}

class Procedure // or Runnable
{
    fun void run()
    {
        // empty
    }
}

class Comparator
{
    0 => int default;

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

class UnaryPredicate
{
    false => int default;

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

class UnaryProcedure
{
    fun void run(Object arg)
    {
        // empty
    }
}

class UnaryFunction
{
    Object @ default;

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

class BinaryPredicate
{
    false => int default;

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

class BinaryProcedure
{
    fun void run(Object arg0, Object arg1)
    {
        // empty
    }
}

class BinaryFunction
{
    Object @ default;

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

class TertiaryPredicate
{
    false => int default;

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

class TertiaryProcedure
{
    fun void run(Object arg0, Object arg1, Object arg2)
    {
        // empty
    }
}

class TertiaryFunction
{
    Object @ default;

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

class QuaternaryPredicate
{
    false => int default;

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

class QuaternaryProcedure
{
    fun void run(Object arg0, Object arg1, Object arg2, Object arg3)
    {
        // empty
    }
}

class QuaternaryFunction
{
    Object @ default;

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

// list api

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

    fun Object next()
    {
        return null;
    }
}

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

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

    fun int size(int capacity)
    {
        // empty
    }

    fun Object get(int index)
    {
        return null;
    }

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

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

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

    fun Iterator iterator()
    {
        return null;
    }

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

    fun void forEach(UnaryPredicate predicate, UnaryProcedure procedure)
    {
        // empty
    }

    fun void clear()
    {
        // empty
    }

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

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

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

    fun List copy()
    {
        return null;
    }

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

// list implementation

class ListIterator extends Iterator
{
    0 => int index;
    List @ list;

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

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

class ArrayList extends List
{
    Object values[0];

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

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

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

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

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

    fun Iterator iterator()
    {
        ListIterator i;
        this @=> i.list;
        return i;
    }

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

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

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

    fun void transform(UnaryFunction 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 ArrayList

class NeverTrue extends UnaryPredicate
{
    // empty
}

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

class Nullify extends UnaryFunction
{
    fun Object evaluate(Object arg)
    {
        return null;
    }
}

class ArrayListTest extends Assert
{
    Object foo;
    Object bar;
    Object baz;
    Object qux;
    Object garply;

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

        <<<"ok">>>;
    }

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

    fun void testSize()
    {
        ArrayList 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()
    {
        ArrayList list;

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

        list.set(0, bar);
        assertEquals(bar, list.get(0));

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

    fun void testIterator()
    {
        ArrayList list;
        list.add(foo);
        list.add(bar);
        list.add(baz);

        list.iterator() @=> Iterator iterator;
        assertNotNull(iterator);
        while (iterator.hasNext())
        {
            iterator.next() @=> Object value;
            assertNotNull(value);
        }
    }

    fun void testForEach()
    {
        ArrayList list;
        list.add(foo);
        list.add(bar);
        list.add(baz);

        UnaryProcedure 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()
    {
        ArrayList list;
        Iterator @ iterator;
        list.size(16);

        list.iterator() @=> iterator;
        while (iterator.hasNext())
        {
            iterator.next() @=> Object value;
            assertNull(value);
        }

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

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

    fun void testTransform()
    {
        ArrayList list;
        Iterator @ iterator;
        Nullify nullify;
        list.size(16);

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

        list.transform(nullify);
        list.iterator() @=> iterator;
        while (iterator.hasNext())
        {
            iterator.next() @=> Object value;
            assertNull(value);
        }

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

    fun void testAddAll()
    {
        ArrayList list0;
        list0.size(16);
        list0.assign(foo);

        ArrayList list1;
        list1.size(16);
        list1.assign(bar);

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

        list2.iterator() @=> Iterator iterator;
        while (iterator.hasNext())
        {
            iterator.next() @=> Object value;
            assertTrue((value == foo) || (value == bar));
        }
    }
}

ArrayListTest arrayListTest;
1::second => now;