Tests for the Closure

• different parameter types
• mixed final and non final parameters
• deferred evaluation

(:source lang=java:)

    public void testClosureMinimal() {
        final StringBuilder input=new StringBuilder("abc");
        final Integer input2=10;

        final Closure closure = new Closure() {{
                result=(input+input2.toString()).startsWith("a");
        }};

        assertEquals(true, closure.eval());
        input.setCharAt(0,'b');
        assertEquals(false, closure.eval());
    }

    public void testClosureRaw() {
        final StringBuilder input=new StringBuilder("abc");

        final Closure closure = new Closure(input) {{
                set(value.toString().startsWith("a"));
        }};
        assertEquals(true, closure.eval());

        input.setCharAt(0,'b');
        assertEquals(false, closure.eval());
    }

    public void testClosureInt() {
        final StringBuilder input=new StringBuilder("abc");

        final Closure closure = new Closure<CharSequence,Integer>(input) {{
                set(value.length());
        }};

        assertEquals(3, closure.eval());
        input.append("def");
        assertEquals(6, closure.eval());
    }

    public void testClosureString() {
        final StringBuilder input=new StringBuilder("abc");

        final Closure closure = new Closure<CharSequence,CharSequence>(input) {{
                set(value.toString().toUpperCase());
        }};

        assertEquals("ABC", closure.eval());
        input.setLength(0);
        input.append("def");
        assertEquals("DEF", closure.eval());
    }

(:sourcend:)

The Closure superclass used

(:source lang=java:) public class Closure<T, R> {

    protected final T[] values;
    protected final T value;
    protected R result;

    public Closure(final T... values) {
        this.values = values;
        this.value = values.length > 0 ? values[0] : null;
    }

    protected void set(final R result) {
        this.result = result;
    }

    public R eval() {
        return newInstance().result;
    }

    public R get() {
        return result;
    }

    private Closure<T, R> newInstance() {
        try {
            final Constructor syntheticConstructor = getClass().getDeclaredConstructors()[0];
            return (Closure<T, R>) syntheticConstructor.newInstance(createParams());
        } catch (Exception e) {
            throw new RuntimeException("Error creating new instance of closure", e);
        }
    }

    private Object[] createParams() throws IllegalAccessException {
        final Field[] fields = getClass().getDeclaredFields();
        final int fieldCount = fields.length;
        final Object[] params = new Object[fieldCount + 1];
        params[0] = fields[fieldCount - 1].get(this); // enclosing Instance
        params[1] = values;
        for (int i = fieldCount - 2; i >= 0; i--) {
            params[2 + i] = fields[i].get(this);
        }
        return params;
    }

} (:sourcend:)