Application: gvSIG desktop

package org.gvsig.expresionevaluator.impl;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

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.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.tools.dataTypes.DataTypes;

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

/**

 *

 * @author jjdelcerro

 */

public class TestDateExpressionBuilder extends TestCase {

    public TestDateExpressionBuilder(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 ExpressionBuilder createExpressionBuilder() {

        ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

        return builder;

    }

    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 SymbolTable createSymbolTable() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        MutableSymbolTable symbolTable = manager.createSymbolTable();

        return symbolTable;

    }

    protected Interpreter createInterpreter(SymbolTable symbolTable) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Interpreter interpreter = manager.createInterpreter();

        interpreter.setSymbolTable(symbolTable);

        return interpreter;

    }

    protected Object execute(Value value) {

        Compiler compiler = createCompiler();

        SymbolTable symbolTable = createSymbolTable();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = value.toString();

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);      

        return v;

    }

    private void link(Code code) {

      code.link(createSymbolTable());

    }

    private Date date(String x) throws ParseException {

        Date d = new SimpleDateFormat("yyyy-M-d H:mm:ss").parse(x);

        return d;

    }

    public void testDate() {

        ExpressionBuilder builder = createExpressionBuilder();

        Value v = builder.date( builder.constant("2020-02-18"));

        assertEquals("DATE '2020-02-18'", v.toString());

    }

    public void testTime() {

        ExpressionBuilder builder = createExpressionBuilder();

        Value v = builder.time( builder.constant("19:01:00"));

        assertEquals("TIME '19:01:00'", v.toString());

    }

    public void testTimestamp() {

        ExpressionBuilder builder = createExpressionBuilder();

        Value v = builder.timestamp(builder.constant("2020-02-18 19:01:00"));

        assertEquals("TIMESTAMP '2020-02-18 19:01:00'", v.toString());

    }

    public void testCurrentDate() {

        ExpressionBuilder builder = createExpressionBuilder();

        Value v = builder.current_date();

        assertEquals("CURRENT_DATE()", v.toString());

    }

    public void testCurrentTime() {

        ExpressionBuilder builder = createExpressionBuilder();

        Value v = builder.current_time();

        assertEquals("CURRENT_TIME()", v.toString());

    }

    public void testCurrentTimestamp() {

        ExpressionBuilder builder = createExpressionBuilder();

        Value v = builder.current_timestamp();

        assertEquals("CURRENT_TIMESTAMP()", v.toString());

    }

    public void testExtractDay() {

        ExpressionBuilder builder = createExpressionBuilder();

        Value v = builder.extract(

                builder.constant("DAY"),

                builder.date(builder.constant("2020-02-18"))

        );

        assertEquals("EXTRACT(DAY FROM DATE '2020-02-18')", v.toString());

    }

    public void testToDate() {

        ExpressionBuilder builder = createExpressionBuilder();

        Value v = builder.to_date(

                builder.constant("05 Dec 2000"),

                builder.constant("DD MMM YYYY")

        );

        assertEquals("TO_DATE('05 Dec 2000', 'DD MMM YYYY')", v.toString());

    }

    public void testToTimestamp() {

        ExpressionBuilder builder = createExpressionBuilder();

        Value v = builder.to_timestamp(

                builder.constant("05 Dec 2000"),

                builder.constant("DD MMM YYYY")

        );

        assertEquals("TO_TIMESTAMP('05 Dec 2000', 'DD MMM YYYY')", v.toString());

    }

    public void testUseCaseFilter1() throws ParseException {

        ExpressionBuilder builder = createExpressionBuilder();

        Date dd = date("2020-02-20 16:30:50");

        Value v = builder.or(

          builder.and(

            builder.gt(

                    builder.column("Time"), 

                    builder.time(builder.constant("01:02:03"))

            ),

            builder.lt(

                    builder.column("Time"), 

                    builder.time(dd)

            )

          ),

          builder.and(

            builder.gt(

                    builder.column("Date"), 

                    builder.date(builder.constant("2019-02-17"))

            ),

            builder.lt(

                    builder.column("Date"), 

                    builder.date(dd)

            )

          )

        );

        assertEquals("(( (\"Time\") > (TIME '01:02:03') ) AND ( (\"Time\") < (TIME '16:30:50') )) OR (( (\"Date\") > (DATE '2019-02-17') ) AND ( (\"Date\") < (DATE '2020-02-20') ))", v.toString());

    }

    public void testConstant() {

        ExpressionBuilder builder = createExpressionBuilder();

        Value v = builder.constant(10,DataTypes.INT);

        assertEquals("10", v.toString());

        v = builder.constant("10",DataTypes.INT);

        assertEquals("10", v.toString());

        v = builder.constant(10,DataTypes.LONG);

        assertEquals("10", v.toString());

        v = builder.constant("10",DataTypes.LONG);

        assertEquals("10", v.toString());

        v = builder.constant(10.5,DataTypes.DOUBLE);

        assertEquals("10.5", v.toString());

        v = builder.constant("10.5",DataTypes.DOUBLE);

//        assertEquals("10.5", v.toString());

        v = builder.constant(10,DataTypes.STRING);

        assertEquals("'10'", v.toString());

        v = builder.constant(10.5,DataTypes.STRING);

//        assertEquals("'10.5'", v.toString());

    }

}