transcendental-lisp/test/function/ArgumentValidatorTester.java

package function;

import static error.ErrorManager.Severity.ERROR;
import static org.junit.Assert.*;

import org.junit.*;

import function.ArgumentValidator.*;
import sexpression.*;

public class ArgumentValidatorTester {

    private ArgumentValidator validator;

    private Cons makeArgumentListOfSize(int size) {
        Cons argumentList = Nil.getInstance();

        for (int i = 0; i < size; i++)
            argumentList = new Cons(Nil.getInstance(), argumentList);

        return argumentList;
    }

    @Before
    public void setUp() throws Exception {
        validator = new ArgumentValidator("TEST");
    }

    @Test
    public void noConstraints_DoesNotThrowExceptionWithNoArguments() {
        validator.validate(makeArgumentListOfSize(0));
    }

    @Test
    public void noConstraints_DoesNotThrowExceptionWithOneArgument() {
        validator.validate(makeArgumentListOfSize(1));
    }

    @Test
    public void noConstraints_DoesNotThrowExceptionWithManyArguments() {
        validator.validate(makeArgumentListOfSize(20));
    }

    @Test(expected = TooFewArgumentsException.class)
    public void tooFewArgumentsWithMinimumSet_ThrowsException() {
        validator.setMinimumNumberOfArguments(1);
        validator.validate(makeArgumentListOfSize(0));
    }

    @Test(expected = TooManyArgumentsException.class)
    public void tooManyArgumentsWithMaximumSet_ThrowsException() {
        validator.setMaximumNumberOfArguments(1);
        validator.validate(makeArgumentListOfSize(2));
    }

    @Test
    public void exactNumberOfArguments_DoesNotThrowException() {
        validator.setExactNumberOfArguments(5);
        validator.validate(makeArgumentListOfSize(5));
    }

    @Test(expected = TooFewArgumentsException.class)
    public void tooFewArgumentsWithExactSet_ThrowsException() {
        validator.setExactNumberOfArguments(3);
        validator.validate(makeArgumentListOfSize(2));
    }

    @Test(expected = TooManyArgumentsException.class)
    public void tooManyArgumentsWithExactSet_ThrowsException() {
        validator.setExactNumberOfArguments(3);
        validator.validate(makeArgumentListOfSize(4));
    }

    @Test
    public void tooManyArgumentsException_HasCorrectSeverity() {
        TooManyArgumentsException e = new TooManyArgumentsException("TEST", Nil.getInstance());

        assertEquals(ERROR, e.getSeverity());
    }

    @Test
    public void tooManyArgumentsException_HasMessageText() {
        TooManyArgumentsException e = new TooManyArgumentsException("TEST", Nil.getInstance());

        assertNotNull(e.getMessage());
        assertTrue(e.getMessage().length() > 0);
    }

    @Test
    public void tooFewArgumentsException_HasCorrectSeverity() {
        TooFewArgumentsException e = new TooFewArgumentsException("TEST", Nil.getInstance());

        assertEquals(ERROR, e.getSeverity());
    }

    @Test
    public void tooFewArgumentsException_HasMessageText() {
        TooFewArgumentsException e = new TooFewArgumentsException("TEST", Nil.getInstance());

        assertNotNull(e.getMessage());
        assertTrue(e.getMessage().length() > 0);
    }

    @Test
    public void BadArgumentTypeException_HasCorrectSeverity() {
        BadArgumentTypeException e = new BadArgumentTypeException("TEST", Nil.getInstance(), SExpression.class);

        assertEquals(ERROR, e.getSeverity());
    }

    @Test
    public void BadArgumentTypeException_HasMessageText() {
        BadArgumentTypeException e = new BadArgumentTypeException("TEST", Nil.getInstance(), SExpression.class);

        assertNotNull(e.getMessage());
        assertTrue(e.getMessage().length() > 0);
    }

    @Test
    public void correctArgumentType_DoesNotThrowException() {
        validator.setEveryArgumentExpectedType(Nil.class);
        validator.validate(makeArgumentListOfSize(1));
    }

    @Test(expected = BadArgumentTypeException.class)
    public void badArgumentType_ThrowsException() {
        validator.setEveryArgumentExpectedType(LispString.class);
        validator.validate(makeArgumentListOfSize(1));
    }

    @Test
    public void correctFirstAndRestArgumentTypes_DoesNotThrowException() {
        Cons argumentList = new Cons(Symbol.T, new Cons(Nil.getInstance(), Nil.getInstance()));

        validator.setFirstArgumentExpectedType(Symbol.class);
        validator.setTrailingArgumentExpectedType(Cons.class);
        validator.validate(argumentList);
    }

    @Test(expected = BadArgumentTypeException.class)
    public void badFirstArgumentType_ThrowsException() {
        Cons argumentList = new Cons(Symbol.T, new Cons(Nil.getInstance(), Nil.getInstance()));

        validator.setFirstArgumentExpectedType(Cons.class);
        validator.setTrailingArgumentExpectedType(Cons.class);
        validator.validate(argumentList);
    }

    @Test(expected = BadArgumentTypeException.class)
    public void badTrailingArgumentType_ThrowsException() {
        Cons argumentList = new Cons(Symbol.T, new Cons(Nil.getInstance(), Nil.getInstance()));

        validator.setFirstArgumentExpectedType(Symbol.class);
        validator.setTrailingArgumentExpectedType(Symbol.class);
        validator.validate(argumentList);
    }

    @Test
    public void expectedTypeWithNoDisplayName_DoesNotCauseNPE() {
        Cons argumentList = new Cons(Symbol.T, new Cons(Nil.getInstance(), Nil.getInstance()));
        SExpression withoutDisplayName = new SExpression() {};

        validator.setEveryArgumentExpectedType(withoutDisplayName.getClass());

        try {
            validator.validate(argumentList);
        } catch (BadArgumentTypeException e) {
            assertNotNull(e.getMessage());
            assertTrue(e.getMessage().length() > 0);
        }
    }

    @Test(expected = DottedArgumentListException.class)
    public void givenDottedArgumentList_ThrowsException() {
        Cons argumentList = new Cons(Symbol.T, Symbol.T);

        validator.validate(argumentList);
    }

    @Test(expected = DottedArgumentListException.class)
    public void givenLargeDottedArgumentList_ThrowsException() {
        Cons argumentList = new Cons(Symbol.T, new Cons(Symbol.T, Symbol.T));

        validator.validate(argumentList);
    }

    @Test
    public void DottedArgumentListException_HasCorrectSeverity() {
        DottedArgumentListException e = new DottedArgumentListException("TEST", Nil.getInstance());

        assertEquals(ERROR, e.getSeverity());
    }

    @Test
    public void dottedArgumentListException_HasMessageText() {
        DottedArgumentListException e = new DottedArgumentListException("TEST", Nil.getInstance());

        assertNotNull(e.getMessage());
        assertTrue(e.getMessage().length() > 0);
    }

    @Test(expected = BadArgumentTypeException.class)
    public void doNotAcceptNil_ThrowsExceptionOnNilArgument() {
        validator.doNotAcceptNil();
        validator.validate(new Cons(Symbol.T, new Cons(Nil.getInstance(), Nil.getInstance())));
    }

    @Test
    public void doNotAcceptNil_AllowsEmptyArgumentList() {
        validator.doNotAcceptNil();
        validator.validate(Nil.getInstance());
    }

    @Test
    public void doNotAcceptNil_AllowsProperList() {
        validator.doNotAcceptNil();
        validator.validate(new Cons(Symbol.T, new Cons(Symbol.T, Nil.getInstance())));
    }

}