Application: gvSIG desktop

package org.gvsig.expresionevaluator.impl;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Locale;

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

 */

public class TestDateInterpreter extends TestCase {

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

    }

    private java.sql.Date date(String x) throws ParseException {

        Date d;

        if( x == null ) {

          d = new Date();

        } else {

          d = new SimpleDateFormat("yyyy-M-d").parse(x);

        }

        return new java.sql.Date(d.getTime());

    }

    private java.sql.Time time(String x) throws ParseException {

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

        return new java.sql.Time(d.getTime());

    }

    private java.sql.Timestamp timestamp(String x) throws ParseException {

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

        return new java.sql.Timestamp(d.getTime());

    }

    public void testDate() throws ParseException {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "DATE '2020-02-18'";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(date("2020-02-18"), ((java.sql.Date)v));

    }

    public void testTime() throws ParseException {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "TIME '19:01:00'";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(time("19:01:00"), ((java.sql.Time)v));

    }

    public void testTimestamp() throws ParseException {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "TIMESTAMP '2020-02-18 19:01:00'";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(timestamp("2020-02-18 19:01:00"), ((java.sql.Timestamp)v));

    }

    public void testCurrentDate() throws ParseException {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "CURRENT_DATE()";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(date(null), ((java.sql.Date)v));

    }

    public void testCurrentTime() throws ParseException {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "CURRENT_TIME()";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertTrue( v instanceof java.sql.Time);

    }

    public void testCurrentTimestamp() throws ParseException {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "CURRENT_TIMESTAMP()";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertTrue( v instanceof java.sql.Timestamp);

    }

    public void testExtractDayFromDate() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "EXTRACT(DAY FROM DATE '2020-02-18')";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(18, ((Integer)v).intValue());

    }

    public void testExtractDayFromTimestamp() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "EXTRACT(DAY FROM TIMESTAMP '2020-02-18')";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(18, ((Integer)v).intValue());

    }

    public void testExtractHourFromTime() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "EXTRACT(HOUR FROM TIME '20:24:00')";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

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

    }

//    public void testToDate() throws ParseException {

//        SymbolTable symbolTable = createSymbolTable();

//        Compiler compiler = createCompiler();

//        Interpreter interpreter = createInterpreter(symbolTable);

//

//        String source = "to_date('05 Dec 2000', 'DD MMM YYYY', 'en')";

//

//        Code code = compiler.compileExpression(source);

//        Object v = interpreter.run(code);

//        assertEquals(date("2000-12-05"), ((java.sql.Date)v));

//    }

//

//    public void testToTimestamp() throws ParseException {

//        SymbolTable symbolTable = createSymbolTable();

//        Compiler compiler = createCompiler();

//        Interpreter interpreter = createInterpreter(symbolTable);

//

//        String source = "to_timestamp('05 Dec 2000', 'DD MMM YYYY')";

//

//        Code code = compiler.compileExpression(source);

//        Object v = interpreter.run(code);

//        assertEquals(timestamp("2000-12-05 0:00:00"), ((java.sql.Timestamp)v));

//    }

}