Application: gvSIG desktop

package org.gvsig.sqlite.dal.operations.usecases.arena2;

import java.util.Objects;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

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

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.store.jdbc2.AbstractTestUtils;

import org.gvsig.fmap.dal.store.jdbc2.JDBCServerExplorer;

import org.gvsig.sqlite.dal.TestUtilsSQLite;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class TestSelectArena2A extends TestCase {

    private static final Logger LOGGER = LoggerFactory.getLogger(TestSelectArena2A.class);

    public TestSelectArena2A(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    protected AbstractTestUtils utils;

    public AbstractTestUtils utils() {

        if (this.utils == null) {

            this.utils = this.createUtils();

        }

        return this.utils;

    }

    protected AbstractTestUtils createUtils() {

        return new TestUtilsSQLite();

    }

    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;

    }

    protected SymbolTable 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 void dump(String testname, Object expected, Object actual) {

        System.out.println("### ---------------------");

        System.out.println("### "+testname);

        System.out.println("### expected: ["+Objects.toString(expected)+"]");

        System.out.println("### actual  : ["+Objects.toString(actual)+"]");

    }

    private void checkEquals(String testname, Object expected, Object actual) {

        dump(testname,expected,actual);

        assertEquals(expected, actual);

    }

    private void checkEquals(Object expected, Object actual) {

        try {

            throw new RuntimeException();

        } catch(Throwable t) {

            String testname = t.getStackTrace()[1].getMethodName();

            dump(testname,expected,actual);

            assertEquals(expected, actual);

        }

    }

    private void link(Code code) {

      code.link(createSymbolTable());

    }

    public void testSelectArena2A() throws Exception {

        try {

            FeatureStore sourceStoreConductores = utils().openCSVStore("usecases/arena2/ARENA2_CONDUCTORES.csv");

            FeatureStore sourceStoreVehiculos = utils().openCSVStore("usecases/arena2/ARENA2_VEHICULOS.csv");

            JDBCServerExplorer explorer = utils().openServerExplorer("testSelectArena2A");

            utils().info_jdbc(explorer);

            utils().drop_tables(explorer, sourceStoreConductores.getName());

            utils().drop_tables(explorer, sourceStoreVehiculos.getName());

            utils().create_table_from(explorer, sourceStoreConductores.getName(), sourceStoreConductores);

            utils().create_table_from(explorer, sourceStoreVehiculos.getName(), sourceStoreVehiculos);

            utils().insert_into_from(explorer, sourceStoreConductores.getName(), sourceStoreConductores, FeatureStore.MODE_APPEND);

            utils().insert_into_from(explorer, sourceStoreVehiculos.getName(), sourceStoreVehiculos, FeatureStore.MODE_APPEND);

            DataManager dataManager = DALLocator.getDataManager();

            dataManager.getStoresRepository().add(sourceStoreConductores.getName(), explorer.get(sourceStoreConductores.getName()));

            dataManager.getStoresRepository().add(sourceStoreVehiculos.getName(), explorer.get(sourceStoreVehiculos.getName()));

            StringBuilder source = new StringBuilder();

            source.append("SELECT * FROM ARENA2_CONDUCTORES  WHERE ARENA2_CONDUCTORES.LID_VEHICULO = ARENA2_VEHICULOS.LID_VEHICULO");

            MutableSymbolTable symbolTable = (MutableSymbolTable) createSymbolTable();

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

            Interpreter interpreter = createInterpreter(symbolTable);

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

            link(code);       

            checkEquals("( SELECT * FROM \"ARENA2_CONDUCTORES\" WHERE (\"ARENA2_CONDUCTORES\".\"LID_VEHICULO\" = \"ARENA2_VEHICULOS\".\"LID_VEHICULO\") )", code.toString());

        } catch (Throwable th) {

            LOGGER.warn("", th);

            throw th;

        }

    }

}