Application: gvSIG desktop

package org.gvsig.expresionevaluator.impl;

import org.gvsig.expressionevaluator.impl.SQLLexicalAnalyzer;

import junit.framework.TestCase;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.expressionevaluator.LexicalAnalyzer.Token;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

public class TestSQLLexer extends TestCase {

    public TestSQLLexer(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    // TODO add test methods here. The name must begin with 'test'. For example:

    // public void testHello() {}

    protected LexicalAnalyzer createLexicalAnalyzer(String expression) {

        SQLLexicalAnalyzer lex = new SQLLexicalAnalyzer(expression);

        return lex;

    }

    public void testIdentifier1() {

        String expression = "precio";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.IDENTIFIER, t1.getType());

        assertEquals("precio", t1.getLiteral());

    }

    public void testIdentifier2() {

        String expression = "\"precio\"";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.IDENTIFIER, t1.getType());

        assertEquals("precio", t1.getLiteral());

    }

    public void testIdentifier3() {

        String expression = "[precio]";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.IDENTIFIER, t1.getType());

        assertEquals("precio", t1.getLiteral());

    }

    public void testTrue() {

        String expression = "true";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.TRUE, t1.getType());

        assertEquals("true", t1.getLiteral());

    }

    public void testFalse() {

        String expression = "false";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.FALSE, t1.getType());

        assertEquals("false", t1.getLiteral());

    }

    public void testNull() {

        String expression = "null";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.NULL, t1.getType());

        assertEquals("null", t1.getLiteral());

        assertNotNull(t1.getValue());

    }

    public void testIsNull() {

        String expression = "isnull";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.ISNULL, t1.getType());

        assertEquals("isnull", t1.getLiteral());

        assertNotNull(t1.getValue());

    }

    public void testNotNull() {

        String expression = "notnull";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.NOTNULL, t1.getType());

        assertEquals("notnull", t1.getLiteral());

        assertNotNull(t1.getValue());

    }

    public void testNotTrue() {

        String expression = "not true";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.OP_NOT, t1.getType());

        assertEquals("not", t1.getLiteral());

        t1 = lex.next();

        assertEquals(Token.TRUE, t1.getType());

        assertEquals("true", t1.getLiteral());

    }

    public void testInteger() {

        String expression = "23";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.INTEGER_LITERAL, t1.getType());

        assertEquals("23", t1.getLiteral());

        assertEquals(new Long(23), t1.getValue());

    }

    public void testDecimal() {

        String expression = "23.1";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.FLOATING_POINT_LITERAL, t1.getType());

        assertEquals("23.1", t1.getLiteral());

        assertEquals(new Double(23.1), t1.getValue());

    }

    public void testStringLiteral1() {

        String expression = "'hola macu'";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.STRING_LITERAL, t1.getType());

        assertEquals("hola macu", t1.getLiteral());

        assertEquals("hola macu", t1.getValue());

    }

    public void testStringLiteral2() {

        String expression = "'hola''s macu'";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.STRING_LITERAL, t1.getType());

        assertEquals("hola's macu", t1.getLiteral());

        assertEquals("hola's macu", t1.getValue());

    }

    public void operator(String operatorName, int operatorId) {

        String expression = "precio " + operatorName + " 23";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.IDENTIFIER, t1.getType());

        assertEquals("precio", t1.getLiteral());

        Token t2 = lex.next();

        assertEquals(operatorId, t2.getType());

        assertEquals(operatorName, t2.getLiteral());

        Token t3 = lex.next();

        assertEquals(Token.INTEGER_LITERAL, t3.getType());

        assertEquals("23", t3.getLiteral());

        assertEquals(new Long(23), t3.getValue());

    }

    public void testOperators() {

        operator("=", Token.OP_EQ);

        operator("<>", Token.OP_NE);

        operator(">", Token.OP_GT);

        operator(">=", Token.OP_GE);

        operator("<", Token.OP_LT);

        operator("<=", Token.OP_LE);

        operator("like", Token.PRED_LIKE);

        operator("ilike", Token.PRED_ILIKE);

        operator("+", Token.OP_ADD);

        operator("-", Token.OP_SUBST);

        operator("*", Token.OP_MULT);

//        operator("^", Token.OP_POW);

        operator("or", Token.OP_OR);

        operator("and", Token.OP_AND);

        operator("%", Token.OP_MOD);

        operator("is", Token.PRED_IS);

        operator("->", Token.OP_GETATTR);

        operator(".", Token.OP_GETATTR);

    }

    public void testPar() {

        String expression = "precio = ( 23 + 5 )";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.IDENTIFIER, t1.getType());

        assertEquals("precio", t1.getLiteral());

        t1 = lex.next();

        assertEquals(Token.OP_EQ, t1.getType());

        assertEquals("=", t1.getLiteral());

        t1 = lex.next();

        assertEquals(Token.PARENTHESIS_OPEN, t1.getType());

        assertEquals("(", t1.getLiteral());

        t1 = lex.next();

        assertEquals(Token.INTEGER_LITERAL, t1.getType());

        assertEquals("23", t1.getLiteral());

        assertEquals(new Long(23), t1.getValue());

        t1 = lex.next();

        assertEquals(Token.OP_ADD, t1.getType());

        assertEquals("+", t1.getLiteral());

        t1 = lex.next();

        assertEquals(Token.INTEGER_LITERAL, t1.getType());

        assertEquals("5", t1.getLiteral());

        assertEquals(new Long(5), t1.getValue());

        t1 = lex.next();

        assertEquals(Token.PARENTHESIS_CLOSE, t1.getType());

        assertEquals(")", t1.getLiteral());

    }

    public void testFuncWithArgs() {

        String expression = "precio = add(23, 5)";

        LexicalAnalyzer lex = createLexicalAnalyzer(expression);

        Token t1 = lex.next();

        assertEquals(Token.IDENTIFIER, t1.getType());

        assertEquals("precio", t1.getLiteral());

        t1 = lex.next();

        assertEquals(Token.OP_EQ, t1.getType());

        assertEquals("=", t1.getLiteral());

        t1 = lex.next();

        assertEquals(Token.IDENTIFIER, t1.getType());

        assertEquals("add", t1.getLiteral());

        t1 = lex.next();

        assertEquals(Token.PARENTHESIS_OPEN, t1.getType());

        assertEquals("(", t1.getLiteral());

        t1 = lex.next();

        assertEquals(Token.INTEGER_LITERAL, t1.getType());

        assertEquals("23", t1.getLiteral());

        assertEquals(new Long(23), t1.getValue());

        t1 = lex.next();

        assertEquals(Token.COMA, t1.getType());

        assertEquals(",", t1.getLiteral());

        t1 = lex.next();

        assertEquals(Token.INTEGER_LITERAL, t1.getType());

        assertEquals("5", t1.getLiteral());

        assertEquals(new Long(5), t1.getValue());

        t1 = lex.next();

        assertEquals(Token.PARENTHESIS_CLOSE, t1.getType());

        assertEquals(")", t1.getLiteral());

    }

}