Application: gvSIG desktop

package org.gvsig.expresionevaluator.impl;

import junit.framework.TestCase;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.expressionevaluator.GeometryExpressionUtils;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.primitive.Point;

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

public class TestInterpreter extends TestCase {

    public TestInterpreter(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;

    }

    protected GeometryExpressionBuilder createExpressionBuilder() {

        GeometryExpressionBuilder builder = GeometryExpressionUtils.createExpressionBuilder();

        return builder;

    }

    public void testIdentifier1() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "precio";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(200, ((Number)v).intValue());

    }

    public void testInteger() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "23";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(23, ((Number)v).intValue());

    }

    public void testNumberDMS() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "@10 30 1.2 N";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(10.5003, Math.round(((Number)v).doubleValue()*10000d)/10000d);

        source = "@10 30 0.09 N";

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals(10.500025, Math.round(((Number)v).doubleValue()*1000000d)/1000000d);

        source = "@10 30 0.09 S";

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals(-10.500025, Math.round(((Number)v).doubleValue()*1000000d)/1000000d);

        source = "@+10 30 0.09";

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals(10.500025, Math.round(((Number)v).doubleValue()*1000000d)/1000000d);

        source = "@-10 30 0.09";

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals(-10.500025, Math.round(((Number)v).doubleValue()*1000000d)/1000000d);

    }

    public void testTrue() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "true";

        Code code = compiler.compileExpression(source);

        assertEquals(Boolean.TRUE, interpreter.run(code));

    }

    public void testFalse() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "false";

        Code code = compiler.compileExpression(source);

        assertEquals(Boolean.FALSE, interpreter.run(code));

    }

    public void testNull() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "null";

        Code code = compiler.compileExpression(source);

        assertEquals(null, interpreter.run(code));

    }

    public void testIsNull() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "10 is null";

        Code code = compiler.compileExpression(source);

        assertEquals(false, interpreter.run(code));

    }

    public void testIsNotNull() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "10 is not null";

        Code code = compiler.compileExpression(source);

        assertEquals(true, interpreter.run(code));

    }

    public void testAdd1() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "precio + 10";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(210, ((Number)v).intValue());

    }

    public void testSimpleAdd1() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "5+10";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(15, ((Number)v).intValue());

    }

    public void testSimpleAdd2() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "5 + 10";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(15, ((Number)v).intValue());

    }

    public void testSimpleAdd3() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "10+-5";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(5, ((Number)v).intValue());

    }

    public void testSimpleSub1() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "10-5";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(5, ((Number)v).intValue());

    }

    public void testSimpleSub2() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "10 - 5";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(5, ((Number)v).intValue());

    }

    public void testSimpleNumber() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "23";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(23, ((Number)v).intValue());

    }

    public void testSimpleNegativeNumber() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "-23";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(-23, ((Number)v).intValue());

    }

    public void testNegateFunction() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "-PI()";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(-Math.PI, ((Number)v).doubleValue());

    }

    public void testSub1() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "precio - 10";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(190, ((Number)v).intValue());

    }

    @SuppressWarnings({"UseSpecificCatch", "CallToPrintStackTrace"})

    public void testAndAnd1() throws Throwable {

        try {

            GeometryExpressionBuilder builder = createExpressionBuilder();

            GeometryManager geometryManager = GeometryLocator.getGeometryManager();

            IProjection proj = CRSFactory.getCRS("EPSG:4326");

            Point point = geometryManager.createPoint(-0.1779813, 51.6122315, Geometry.SUBTYPES.GEOM2D);

            Geometry point_buffer = point.buffer(0.001);

            builder.and(

                builder.andand(

                    builder.column("geometry"),

                    builder.geometry(point_buffer, proj)

                )

            );            

            MutableSymbolTable symbolTable = createSymbolTable();

            Compiler compiler = createCompiler();

            Interpreter interpreter = createInterpreter(symbolTable);

            symbolTable.setVar("geometry", point);

            String source = builder.toString();

            Code code = compiler.compileExpression(source);

            Object v = interpreter.run(code);

            assertEquals(true, ((Boolean)v).booleanValue());

        } catch(Throwable t) {

            t.printStackTrace();

            throw t;

        }

    }

    public void testMul1() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "precio * 10";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(2000, ((Number)v).intValue());

    }

    public void testDiv1() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "precio / 10";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(20, ((Number)v).intValue());

    }

    public void testAdd2() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "precio + 10 + 20 + 30";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(260, ((Number)v).intValue());

    }

    public void testAddMul() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "precio + 10 * 2 + 20 + 30";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(270, ((Number)v).intValue());

    }

    public void testAddMulPar() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "(precio + 10) * 2 + 20 + 30";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(470, ((Number)v).intValue());

    }    

    public void testAbs() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "precio + abs(10)";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(210, ((Number)v).intValue());

    }

    public void testAbs2() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "precio + abs(-10)";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(210, ((Number)v).intValue());

    }

    public void testCeil() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "precio + CEIL(PI())";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(204, ((Number)v).intValue());

    }

    public void testConcat() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "CONCAT(precio,' euros')";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals("200 euros", (String)v);

    }

    public void testAccuracy() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        Code code;

        Object v;

        compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true);

        code = compiler.compileExpression("[1990] = 0.168873933773767");

        v = interpreter.run(code);

        assertEquals(true, ((Boolean)v).booleanValue());

        code = compiler.compileExpression("[1990] = 0.1688739");

        v = interpreter.run(code);

        assertEquals(false, ((Boolean)v).booleanValue());

        interpreter.setAccuracy(0.0000001);

        v = interpreter.run(code);

        assertEquals(true, ((Boolean)v).booleanValue());

    }    

    public void test2fields() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true);

        String source = "[1990] = [precio]";

        compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true);

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(false, ((Boolean)v).booleanValue());

    }

    public void testInvokeMethod1() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "'hola'.length()";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(4, ((Number)v).intValue());

    }

    public void testInvokeMethod2() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "'hola'.indexOf('l')";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(2, ((Number)v).intValue());

    }

    public void testAlias() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "UPPER('hola')";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals("HOLA", (String)v);

        source = "UCASE('hola')";

        code = compiler.compileExpression(source);

        v = interpreter.run(code);

        assertEquals("HOLA", (String)v);

    }

    public void testRegexp1() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "'Hola' ~ '[Hh]ola'" ;

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertTrue((Boolean)v);

    }

    public void testGetitem1() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(false);

        String source = "LIST('uno','dos','tres')[1]" ;

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals("dos", (String)v);

    }

}