Application: gvSIG desktop

package org.gvsig.expresionevaluator.impl;

import static junit.framework.Assert.assertEquals;

import junit.framework.TestCase;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

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

public class TestCodeToValue extends TestCase {

    public TestCodeToValue(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();

        org.gvsig.expressionevaluator.Compiler compiler = manager.createCompiler();

        compiler.setLexicalAnalyzer(createLexicalAnalyzer());

        return compiler;

    }

    public Code compileExpression(String source) {

        org.gvsig.expressionevaluator.Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        return code;

    }

    public void testIdentifier1() {

        String source = "precio";

        Code code = compileExpression(source);

        assertEquals("\"precio\"", code.toValue().toString());

    }

    public void testIdentifier2() {

        org.gvsig.expressionevaluator.Compiler compiler = createCompiler();

        compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true);

        String source = "[precio]";

        Code code = compiler.compileExpression(source);

        assertEquals("\"precio\"", code.toValue().toString());

    }

    public void testIdentifier3() {

        String source = "\"precio\"";

        Code code = compileExpression(source);

        assertEquals("\"precio\"", code.toValue().toString());

    }

    public void testTrue() {

        String source = "true";

        Code code = compileExpression(source);

        assertEquals("TRUE", code.toValue().toString());

    }

    public void testFalse() {

        String source = "false";

        Code code = compileExpression(source);

        assertEquals("FALSE", code.toValue().toString());

    }

    public void testNull() {

        String source = "null";

        Code code = compileExpression(source);

        assertEquals("NULL", code.toValue().toString());

    }

    public void testNotTrue() {

        String source = "not true";

        Code code = compileExpression(source);

        assertEquals("NOT(TRUE)", code.toValue().toString());

    }

    public void testInteger() {

        String source = "23";

        Code code = compileExpression(source);

        assertEquals("23", code.toValue().toString());

    }

    public void operator(String operatorName) {

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

        Code code = compileExpression(source);

        assertEquals("(\"precio\" "+ operatorName + " 23)", code.toValue().toString());

    }

    public void testOperators() {

        operator("=");

        operator("<>");

        operator(">");

        operator(">=");

        operator("<");

        operator("<=");

        operator("LIKE");

        operator("ILIKE");

        operator("||");

        operator("+");

        operator("-");

        operator("*");

        operator("OR");

        operator("AND");

        operator("%");

        operator("IS");

        operator("~");

    }

//    public void testILike() {

//        String source = "precio ILike 23";

//

//        Code code = compileExpression(source);

//        assertEquals("LOWER(\"precio\") LIKE LOWER(23)", code.toValue().toString());

//    }

    public void testAddMul() {

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

        Code code = compileExpression(source);

        assertEquals("(((\"precio\" + (10 * 2)) + 20) + 30)", code.toValue().toString());

    }

    public void testAddMulPar() {

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

        Code code = compileExpression(source);

        assertEquals("((((\"precio\" + 10) * 2) + 20) + 30)", code.toValue().toString());

    }

    public void testAbs() {

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

        Code code = compileExpression(source);

        assertEquals("(\"precio\" + abs(10))", code.toValue().toString());

    }

    public void testAbs2() {

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

        Code code = compileExpression(source);

        assertEquals("(\"precio\" + abs(-(10)))", code.toValue().toString());

    }

    public void testPI() {

        String source = "precio + PI()";

        Code code = compileExpression(source);

        assertEquals("(\"precio\" + PI())", code.toValue().toString());

    }

    public void testCeil() {

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

        Code code = compileExpression(source);

        assertEquals("(\"precio\" + CEIL(PI()))", code.toValue().toString());

    }

    public void testGetitem1() {

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

        Code code = compileExpression(source);

        assertEquals("GETITEM(LIST('uno', 'dos', 'tres'), 1)", code.toValue().toString());

    }

    public void testConcat() {

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

        Code code = compileExpression(source);

        assertEquals("CONCAT(\"precio\", ' euros')", code.toValue().toString());

    }

    public void test1() {

        String source = "NOMBRE03 = 'Torre d''En Besora (la)'";

        Code code = compileExpression(source);

        assertEquals("(\"NOMBRE03\" = 'Torre d''En Besora (la)')", code.toValue().toString());

    }

    public void test2() {

        org.gvsig.expressionevaluator.Compiler compiler = createCompiler();

        compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true);

        String source = "[1990] = 0.168873933773767";

        Code code = compiler.compileExpression(source);

        assertEquals("(\"1990\" = 0.168873933773767)", code.toValue().toString());

    }

    public void test2fields() {

        org.gvsig.expressionevaluator.Compiler compiler = createCompiler();

        compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true);

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

        Code code = compiler.compileExpression(source);

        assertEquals("(\"1990\" = \"precio\")", code.toValue().toString());

    }

    public void testInvokeFunction1() {

        String source = "ST_Area(GEOMETRY)";

        Code code = compileExpression(source);

        assertEquals("ST_Area(\"GEOMETRY\")", code.toValue().toString());

    }

    public void test3() throws CreateGeometryException {

        ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

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

        Point point = GeometryUtils.createPoint(10, 20);

        builder.set(        

            builder.ST_Intersects(

              builder.geometry(point,proj),

              builder.variable("the_geom")

            )

        );

        Code code = compileExpression(builder.toString());

        assertEquals(

                "ST_Intersects(ST_GeomFromWKB(DECODE('000000000140240000000000004034000000000000', 'hex'), 4326), \"the_geom\")",

                code.toValue().toString()

        );

    }

    public void test4() throws CreateGeometryException {

        ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

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

        Point point = GeometryUtils.createPoint(10, 20);

        builder.set(        

            builder.function("ST_Intersects2",

                builder.geometry(point,proj),

                builder.variable("the_geom")

            )

        );

        Code code = compileExpression(builder.toString());

        assertEquals(

                "ST_Intersects2(ST_GeomFromWKB(DECODE('000000000140240000000000004034000000000000', 'hex'), 4326), \"the_geom\")",

                code.toValue().toString()

        );

    }

}