Application: gvSIG desktop

package org.gvsig.fmap.dal.store.jdbc2;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.lang3.tuple.Pair;

import org.apache.log4j.Level;

import org.apache.log4j.LogManager;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

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

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

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

import org.gvsig.fmap.dal.store.jdbc2.impl.ResulSetControlerBase;

import org.gvsig.tools.dispose.DisposeUtils;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public abstract class AbstractTestFeatureReferenceIteratorToFeatureIterator extends TestCase {

    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractTestFeatureReferenceIteratorToFeatureIterator.class);

    protected AbstractTestUtils utils;

    public AbstractTestFeatureReferenceIteratorToFeatureIterator(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    public AbstractTestUtils utils() {

        if (this.utils == null) {

            this.utils = this.createUtils();

        }

        return this.utils;

    }

    protected abstract AbstractTestUtils createUtils();

    private List<Pair<org.apache.log4j.Logger,Level>> get_loggers(Object... classes) {

        List<Pair<org.apache.log4j.Logger,Level>> loggers = new ArrayList<>();

        for (Object theClass : classes) {

            org.apache.log4j.Logger logger;

            if( theClass instanceof Class ) {

                logger = LogManager.getLogger((Class)theClass);

            } else {

                logger = LogManager.getLogger(Objects.toString(theClass, null));

            }

            if( logger!=null ) {

                loggers.add(Pair.of(logger,logger.getLevel()));

            }

        }

        return loggers;

    }

    private void restore_level(List<Pair<org.apache.log4j.Logger,Level>> loggers) {

        for (Pair<org.apache.log4j.Logger, Level> logger : loggers) {

            logger.getLeft().setLevel(logger.getRight());

        }

    }

    private void set_level(List<Pair<org.apache.log4j.Logger,Level>> loggers, Level level) {

        for (Pair<org.apache.log4j.Logger, Level> logger : loggers) {

            logger.getLeft().setLevel(level);

        }

    }

    protected void testFRI2FI1() throws Exception {

        try {

            if (!utils().isTheDatabaseAvailable()) {

                return;

            }

            List<Pair<org.apache.log4j.Logger, Level>> loggers = get_loggers(JDBCUtils.class, ResulSetControlerBase.class, "org.gvsig.fmap.dal.store.h2.H2SpatialHelper");

            set_level(loggers, Level.INFO);

            FeatureStore sourceStore = utils().openCSVStore("/org/gvsig/fmap/dal/store/jdbc2/esp_poblaciones-nogeom.csv");

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

            utils().info_jdbc(explorer);

            // Importamos el CSV en la bbdd

            LOGGER.info("Creating table 'poblaciones' in h2 temporary database.");

            utils().drop_tables(explorer, "poblaciones", DatabaseWorkspaceManager.TABLE_RESOURCES_NAME);

            utils().create_table_from(explorer, "poblaciones", sourceStore);

            utils().insert_into_from(explorer, "poblaciones", sourceStore, FeatureStore.MODE_APPEND);

            LOGGER.info("Loading table 'poblaciones' in in memory and populate selection.");

            FeatureStore dbstore = utils().openStore(explorer, "poblaciones");

            FeatureSelection selection = dbstore.getFeatureSelection();            

            Map<Integer,Feature> features = new HashMap<>();

            for (Feature feature : dbstore.getFeatureSet()) {

                Feature f = feature;

                int pk = f.getInt("COD_POBLACION");

                features.put(pk,feature.getCopy());

                selection.select(feature);

            }

//            selection.selectAll();

//            LOGGER.info("Getting features from selection (1)");

//            long t1 = System.currentTimeMillis();

//            int count1 = 0;

//            Set<Integer> found1 = new HashSet<>();

//            for (FeatureReference featureReference : selection.referenceIterable()) {

//                Feature f = featureReference.getFeature();

//                int pk = f.getInt("COD_POBLACION");

//                assertNotNull("row "+count1, features.get(pk));

//                found1.add(pk);

//                count1++;

//            }

//            assertEquals("features recuperadas (1)", features.size(), found1.size());

//            long time1 = System.currentTimeMillis()-t1;

//            LOGGER.info("time (1) "+time1+"ms, count "+count1);

            LOGGER.info("Getting features from selection (2)");

            long t2 = System.currentTimeMillis();

            int count2 = 0;

            Set<Integer> found2 = new HashSet<>();

            for (Feature feature : dbstore.getFeaturesIterable(selection.referenceIterator()) ) {

                Feature f = feature;

                int pk = f.getInt("COD_POBLACION");

                assertNotNull("row "+count2, features.get(pk));

                found2.add(pk);

                count2++;

            }

            assertEquals("features recuperadas (2)", features.size(), found2.size());

            long time2 = System.currentTimeMillis()-t2;

//            LOGGER.info("time (1) "+time1+"ms, count "+count1);

            LOGGER.info("time (2) "+time2+"ms, count "+count2);

            restore_level(loggers);

            DisposeUtils.dispose(dbstore);

        } catch (Throwable th) {

            LOGGER.warn("", th);

            throw th;

        }

    }

}