transcendental-lisp/test/parser/LispParserTester.java

package parser;

import static org.junit.Assert.*;

import java.io.InputStream;

import org.junit.Test;

import error.LispException;
import testutils.TestUtilities;

public class LispParserTester {

    private LispParser createLispParser(String input) {
        InputStream stringInputStream = TestUtilities.createInputStreamFromString(input);
        return new LispParser(stringInputStream, "testFile");
    }

    private void assertList(SExpression sExpression) {
        assertFalse(sExpression.atomp());
        assertTrue(sExpression.consp());
        assertFalse(sExpression.functionp());
        assertTrue(sExpression.listp());
        assertFalse(sExpression.nullp());
        assertFalse(sExpression.numberp());
        assertFalse(sExpression.stringp());
        assertFalse(sExpression.symbolp());
    }

    private void assertNil(SExpression sExpression) {
        assertEquals(sExpression, Nil.getUniqueInstance());

        assertTrue(sExpression.atomp());
        assertFalse(sExpression.consp());
        assertFalse(sExpression.functionp());
        assertTrue(sExpression.listp());
        assertTrue(sExpression.nullp());
        assertFalse(sExpression.numberp());
        assertFalse(sExpression.stringp());
        assertTrue(sExpression.symbolp());

    }

    private void assertNumber(SExpression sExpression) {
        assertTrue(sExpression.atomp());
        assertFalse(sExpression.consp());
        assertFalse(sExpression.functionp());
        assertFalse(sExpression.listp());
        assertFalse(sExpression.nullp());
        assertTrue(sExpression.numberp());
        assertFalse(sExpression.stringp());
        assertFalse(sExpression.symbolp());
    }

    private void assertString(SExpression sExpression) {
        assertTrue(sExpression.atomp());
        assertFalse(sExpression.consp());
        assertFalse(sExpression.functionp());
        assertFalse(sExpression.listp());
        assertFalse(sExpression.nullp());
        assertFalse(sExpression.numberp());
        assertTrue(sExpression.stringp());
        assertFalse(sExpression.symbolp());
    }

    private void assertSymbol(SExpression sExpression) {
        assertTrue(sExpression.atomp());
        assertFalse(sExpression.consp());
        assertFalse(sExpression.functionp());
        assertFalse(sExpression.listp());
        assertFalse(sExpression.nullp());
        assertFalse(sExpression.numberp());
        assertFalse(sExpression.stringp());
        assertTrue(sExpression.symbolp());
    }

    @Test
    public void testEofMethod_ReturnsTrueWithNoInput() {
        String input = "";
        LispParser parser = createLispParser(input);

        assertTrue(parser.eof());
    }

    @Test
    public void testEofMethod_ReturnsFalseWithSomeInput() {
        String input = "abc";
        LispParser parser = createLispParser(input);

        assertFalse(parser.eof());
    }

    @Test
    public void testEofMethod_ReturnsTrueAfterSomeInput() {
        String input = "(yyz 9 9 9)";
        LispParser parser = createLispParser(input);
        parser.getSExpr();

        assertTrue(parser.eof());
    }

    @Test
    public void testEofMethod_ReturnsFalseAfterMultipleExpressions() {
        String input = "()()()";
        LispParser parser = createLispParser(input);
        assertFalse(parser.eof());
        parser.getSExpr();
        assertFalse(parser.eof());
        parser.getSExpr();
        assertFalse(parser.eof());
    }

    @Test
    public void testEofMethod_ReturnsTrueAfterMultipleExpressions() {
        String input = "()()()";
        LispParser parser = createLispParser(input);
        assertFalse(parser.eof());
        parser.getSExpr();
        assertFalse(parser.eof());
        parser.getSExpr();
        assertFalse(parser.eof());
        parser.getSExpr();
        assertTrue(parser.eof());
    }

    @Test
    public void givenNil_CreatesCorrectSExpression() {
        String input = "()";
        LispParser parser = createLispParser(input);

        assertNil(parser.getSExpr());
    }

    @Test
    public void givenNumber_CreatesCorrectSExpression() {
        String input = "12";
        LispParser parser = createLispParser(input);

        assertNumber(parser.getSExpr());
    }

    @Test
    public void givenIdentifier_CreatesCorrectSExpression() {
        String input = "identifier1";
        LispParser parser = createLispParser(input);

        assertSymbol(parser.getSExpr());
    }

    @Test
    public void givenString_CreatesCorrectSExpression() {
        String input = "\"string\"";
        LispParser parser = createLispParser(input);

        assertString(parser.getSExpr());
    }

    @Test
    public void givenList_CreatesCorrectSExpression() {
        String input = "(1 2)";
        LispParser parser = createLispParser(input);

        assertList(parser.getSExpr());
    }

    @Test
    public void givenQuotedIdentifier_CreatesCorrectSExpression() {
        String input = "'quoted";
        LispParser parser = createLispParser(input);

        assertList(parser.getSExpr());
        assertTrue(parser.eof());
    }

    @Test
    public void givenComplexList_CreatesCorrectSExpression() {
        String input = "(defun f (x) \n (print \n (list \"x is \" x) \n ) \n )";
        LispParser parser = createLispParser(input);

        assertList(parser.getSExpr());
        assertTrue(parser.eof());
    }

    @Test
    public void givenMultipleExpressions_CreatesCorrectSExpressions() {
        String input = "(setf x 2) x \"hi\" () 29";
        LispParser parser = createLispParser(input);

        assertList(parser.getSExpr());
        assertSymbol(parser.getSExpr());
        assertString(parser.getSExpr());
        assertNil(parser.getSExpr());
        assertNumber(parser.getSExpr());
        assertTrue(parser.eof());
    }

    @Test
    public void givenNil_CreatesCorrectSExpressionAfterEofCalls() {
        String input = "()";
        LispParser parser = createLispParser(input);

        parser.eof();
        parser.eof();

        assertNil(parser.getSExpr());
        assertTrue(parser.eof());
    }

    @Test(expected = LispException.class)
    public void givenBadToken_ThrowsException() {
        String input = "[";
        LispParser parser = createLispParser(input);

        parser.getSExpr();
    }

    @Test(expected = LispException.class)
    public void givenUnterminatedString_ThrowsException() {
        String input = "\"string";
        LispParser parser = createLispParser(input);

        parser.getSExpr();
    }

    @Test(expected = LispException.class)
    public void givenUnterminatedList_ThrowsException() {
        String input = "(bad list";
        LispParser parser = createLispParser(input);

        parser.getSExpr();
    }

    @Test(expected = LispException.class)
    public void givenUnmatchedRightParenthesis_ThrowsException() {
        String input = ")";
        LispParser parser = createLispParser(input);

        parser.getSExpr();
    }

    @Test(expected = LispException.class)
    public void givenBadCharacter_ThrowsExceptionAfterEofCalled() {
        String input = "[";
        LispParser parser = createLispParser(input);

        try {
            parser.eof();
        } catch (LispException e) {
            fail("Exception thrown too early");
        }

        parser.getSExpr();
    }

    @Test(expected = LispException.class)
    public void givenBadCharacterAfterValidToken_ThrowsExceptionAtTheCorrectTime() {
        String input = "id[]";
        LispParser parser = createLispParser(input);

        try {
            parser.getSExpr();
            parser.eof();
        } catch (LispException e) {
            fail("Exception thrown too early");
        }

        parser.getSExpr();
    }

}