Application: gvSIG desktop

package org.gvsig.expresionevaluator.impl;

import junit.framework.TestCase;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.MutableSymbolTable;

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

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UnusedAssignment")

public class TestGrammarInterpreter extends TestCase {

    public TestGrammarInterpreter(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() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        LexicalAnalyzer lexer = manager.createLexicalAnalyzer();

        return lexer;

    }

    protected org.gvsig.expressionevaluator.Compiler createCompiler() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Compiler compiler = manager.createCompiler();

        compiler.setLexicalAnalyzer(createLexicalAnalyzer());

        return compiler;

    }

    protected MutableSymbolTable createSymbolTable() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        MutableSymbolTable symbolTable = manager.createSymbolTable();

        symbolTable.setVar("precio", 200);

        symbolTable.setVar("1990", 0.168873933773767);

        return symbolTable;

    }

    protected Interpreter createInterpreter(SymbolTable symbolTable) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Interpreter interpreter = manager.createInterpreter();

        interpreter.setSymbolTable(symbolTable);

        return interpreter;

    }

    public void testLet() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "LET V1 = 23";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(23, symbolTable.value("V1"));

    }

    public void testVar() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "(VAR V1 DEFAULT 23)+2";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(23, symbolTable.value("V1"));

        assertEquals((Integer)25, v);

    }

    public void testBlock() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "BEGIN SET V1 = 23 END";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(23, symbolTable.value("V1"));

    }

    public void testBlock2() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "BEGIN SET V1 = 11; SET V2 = 22  END";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Integer)11, symbolTable.value("V1"));

        assertEquals((Integer)22, symbolTable.value("V2"));

    }

    public void testBlock3() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "BEGIN SET V1 = 11; SET V2 = :V1 * 2;  END";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Integer)11, symbolTable.value("V1"));

        assertEquals((Integer)22, symbolTable.value("V2"));

    }

    public void testCall1() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "CALL ABS(-1)";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Integer)1, v);

    }

    public void testIfThen() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        symbolTable.setVar("V1", 10);

        String source = "IF V1 = 11 THEN SET V2 = 22; END IF";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(null, v);

        assertEquals((Integer)10, symbolTable.value("V1"));

        assertEquals(null, symbolTable.value("V2"));

        symbolTable.setVar("V1", 11);

        source = "IF V1 = 11 THEN SET V2 = 22; END IF";

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals((Integer)22, v);

        assertEquals((Integer)11, symbolTable.value("V1"));

        assertEquals((Integer)22, symbolTable.value("V2"));

    }

    public void testIfThenElse() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        symbolTable.setVar("V1", 10);

        String source = "IF V1 = 11 THEN SET V2 = 11; ELSE SET V2 = 22; END IF";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Integer)22, v);

        assertEquals((Integer)10, symbolTable.value("V1"));

        assertEquals((Integer)22, symbolTable.value("V2"));

    }

    public void testIfThenBlock() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        symbolTable.setVar("V1", 11);

        String source = "IF V1 = 11 THEN LET V2 = 22; LET V1 = 10; END IF";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Integer)10, v);

        assertEquals((Integer)10, symbolTable.value("V1"));

        assertEquals((Integer)22, symbolTable.value("V2"));

    }

    public void testWhile() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        symbolTable.setVar("n",0);

        String source = "WHILE n < 10 BEGIN SET n = n + 1; END WHILE";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Integer)10, v);

        assertEquals((Integer)10, symbolTable.value("n"));

    }

    public void testWhileBreak() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        symbolTable.setVar("n",0);

        String source = "WHILE n < 10 BEGIN IF n = 5 THEN BREAK; END; SET n = n + 1; END WHILE";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Integer)5, v);

        assertEquals((Integer)5, symbolTable.value("n"));

    }

    public void testWhileBlock() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        symbolTable.setVar("n",0);

        String source = "WHILE n < 10 BEGIN SET n = n + 1; print(n) END";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Integer)10, v);

        assertEquals((Integer)10, symbolTable.value("n"));

    }

    public void testCast() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        symbolTable.setVar("n",1.0);

        String source = "CAST n AS INTEGER";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Integer)1, v);

        assertEquals((Double)1.0, symbolTable.value("n"));

    }

    public void testMatch() {

        Compiler compiler = createCompiler();

        String source;

        Code code;

        source = "MATCH 'Hola', '[Hh]ola'";

        code = compiler.compileExpression(source);

        assertEquals("~('Hola', '[Hh]ola')", code.toString());

        source = "MATCH 'Hola' '[Hh]ola'";

        code = compiler.compileExpression(source);

        assertEquals("~('Hola', '[Hh]ola')", code.toString());

        source = "MATCH('Hola', '[Hh]ola')";

        code = compiler.compileExpression(source);

        assertEquals("~('Hola', '[Hh]ola')", code.toString());

    }

    public void testForEach() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "FOR n in RANGE(10) LOOP print(n); END LOOP";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Long)9L, v);

        assertEquals((Long)9L, symbolTable.value("n"));

    }

    public void testForEachBreak() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "FOR n in RANGE(10) LOOP IF n = 5 THEN BREAK; END; print(n); END LOOP";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Long)4L, v);

        assertEquals((Long)5L, symbolTable.value("n"));

    }

    public void testCase() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        symbolTable.setVar("software","unknown");

        String source = "CASE WHEN software LIKE '%gvSIG%' THEN 'gvSIG' ELSE 'Other' END"; // ;)

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals("Other", v);

        symbolTable.setVar("software","gvSIG desktop");

        source = "CASE WHEN software LIKE '%gvSIG%' THEN 'gvSIG' ELSE 'Other' END"; // ;)

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals("gvSIG", v);

    }

    public void testCaseUnWhenSolo() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        symbolTable.setVar("software","unknown");

        String source = "CASE WHEN software LIKE '%gvSIG%' THEN 'gvSIG' END"; // ;)

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(null, v);

    }

    public void testCase2() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        symbolTable.setVar("Field_1",77);

        String source = "CASE WHEN Field_1 >= 75 AND Field_1 <=79 THEN 100 WHEN Field_1 >=80 AND Field_1 <=84 THEN 110 END"; // ;)

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Integer)100, v);

        symbolTable.setVar("Field_1",81);

        source = "CASE WHEN Field_1 >= 75 AND Field_1 <=79 THEN 100 WHEN Field_1 >=80 AND Field_1 <=84 THEN 110 END"; // ;)

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals((Integer)110, v);

    }

    public void testCase3() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        symbolTable.setVar("Field_1",100);

        String source = "CASE WHEN Field_1 >= 75 AND Field_1 <=79 THEN 100 WHEN Field_1 >=80 AND Field_1 <=84 THEN 110 ELSE 120 END"; // ;)

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals((Integer)120, v);

    }

    public void testCreateProcedure1() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "CREATE PROCEDURE test1 AS BEGIN RETURN 'Hola'; END PROCEDURE"; 

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        source = "test1()"; 

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals("Hola", v);

    }

    public void testCreateOrReplaceProcedure1() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "CREATE OR REPLACE PROCEDURE test1 AS BEGIN RETURN 'Hola'; END PROCEDURE"; 

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        source = "test1()"; 

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals("Hola", v);

    }

    public void testCreateProcedure2() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "CREATE PROCEDURE test1 nombre AS BEGIN RETURN 'Hola ' || nombre; END PROCEDURE";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        source = "test1('Joaquin')"; 

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals("Hola Joaquin", v);

    }

    public void testReturn1() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "CREATE PROCEDURE test1 nombre AS BEGIN RETURN 'Hola ' || nombre; END PROCEDURE";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        source = "test1('Joaquin')"; 

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals("Hola Joaquin", v);

    }

    public void testReturn2() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "CREATE PROCEDURE test1 nombre AS BEGIN RETURN ; END PROCEDURE";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        source = "test1('Joaquin')"; 

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals(null, v);

    }

    public void testUseCase1() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "begin set x = ''; for n in list('hola','adios','fin') loop let x = x || ' ' || n; end loop; end";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(" hola adios fin", v);

    }

    public void testUseCase2() {

        MutableSymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "begin set s = ''; set x = LIST('hola','adios','fin'); FOR n in RANGE(3) loop set s = s || ' ' || x[n]; end loop; end";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(" hola adios fin", v);

    }

}