gvSIG projects pool

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.vcsgis.lib</artifactId>

        <version>1.0.91</version>

    </parent>

    <artifactId>org.gvsig.vcsgis.lib.impl</artifactId>

    <name>${project.artifactId}</name>

    <dependencies>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.vcsgis.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <!--<artifactId>${org.gvsig.h2spatial.provider}</artifactId>-->

            <artifactId>org.gvsig.h2spatial.h2gis132.provider</artifactId>

            <scope>compile</scope>

            <exclusions>

                <exclusion>

                    <!-- postgis-jts-osgi-5.0.1.jar  -->

                    <groupId>org.orbisgis</groupId>

                    <artifactId>postgis-jts-osgi</artifactId>

                </exclusion>

            </exclusions>

        </dependency>            

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.file.csv</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>${org.gvsig.fmap.geometry.impl}</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.geometry.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.swing.impl</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>${org.gvsig.proj.lib.impl}</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.compat.se</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.metadata.lib.basic.impl</artifactId>

            <scope>test</scope>

        </dependency>      

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.timesupport.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>

<!--        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.file.csv</artifactId>

            <scope>test</scope>

        </dependency>-->

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.lib</artifactId>

            <scope>test</scope>

            <type>test-jar</type>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.util.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.apache.httpcomponents</groupId>

            <artifactId>httpclient</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.dynform.spi</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.dynform.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.dynform.services</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.mapcontext.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.raster.lib.buffer.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.raster.lib.buffer.spi</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.swing.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.swing.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>javax.servlet</groupId>

            <artifactId>javax.servlet-api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>commons-io</groupId>

            <artifactId>commons-io</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.oracle.provider</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.postgresql.provider</artifactId>

            <scope>test</scope>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-surefire-plugin</artifactId>

                <configuration>

                    <!-- Skip test execution ? -->

                    <skipTests>true</skipTests>

                    <!-- Ignore test execution failure ? -->

                    <testFailureIgnore>false</testFailureIgnore>

                </configuration>

            </plugin>

            <!-- Skip test compilation ? -->

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-compiler-plugin</artifactId>

                <executions>

                    <execution>

                        <id>default-testCompile</id>

                        <phase>process-test-sources</phase>

                        <goals>

                            <goal>testCompile</goal>

                        </goals>

                        <configuration>

                            <skip>false</skip>

                        </configuration>

                    </execution>

                </executions>

            </plugin>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-jar-plugin</artifactId>

                <configuration>

                </configuration>

                <executions>

                    <!-- Generates a jar file only with the test classes -->

                    <execution>

                        <goals>

                            <goal>test-jar</goal>

                        </goals>

                    </execution>

                </executions>

            </plugin>

        </plugins>

    </build>

</project>

package org.gvsig.vcsgis.lib.impl;

import java.io.File;

import java.util.List;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

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

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

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.vcsgis.lib.SequentialCodeGenerator;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_NO_ERROR;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_UPDATE_NEED_MERGE;

import static org.gvsig.vcsgis.lib.VCSGisManager.FEATURECODE_FIELD_NAME;

import static org.gvsig.vcsgis.lib.VCSGisManager.OP_DELETE;

import static org.gvsig.vcsgis.lib.VCSGisManager.OP_INSERT;

import static org.gvsig.vcsgis.lib.VCSGisManager.STATE_CONFLICT;

import org.gvsig.vcsgis.lib.repository.VCSGisRepository;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspace;

import org.gvsig.vcsgis.lib.workspace.tables.RemoteChangesTable;

import org.gvsig.vcsgis.lib.workspace.tables.WorkspaceChangesTable;

public abstract class AbstractTest14UpdateWithConflict extends AbstractTestVCSGIS {

    public AbstractTest14UpdateWithConflict(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    private Feature insert(FeatureStore store, int id, String text) throws DataException{

        EditableFeature ef = store.createNewFeature();

        ef.set("id",id);

        ef.set("text",text);

        store.insert(ef);

        return ef;

    }

    private void update(FeatureStore store, int id, String text) throws DataException{

        Feature f = store.findFirst("id="+id);

        EditableFeature ef = f.getEditable();

        ef.set("text", text);

        store.update(ef);

    }

    private void delete(FeatureStore store, int id, String text) throws DataException{

        Feature f = store.findFirst("id="+id);

        store.delete(f);

    }

    private void check(List<Feature> features, int index, int id, String text){

        assertEquals(id    , features.get(index).getInt("id"));

        assertEquals(text, features.get(index).getString("text"));

    }

    private void check(FeatureStore store2, String relatedFeatureCode, int id, String text) throws Exception {

        Feature f = store2.findFirst("VCSGISCODE = '"+relatedFeatureCode+"'");

        assertEquals(id, f.getInt("id"));

        assertEquals(text, f.getString("text"));

    }

    private void selectRemoteChange(VCSGisWorkspace ws, boolean select, int id, String text, VCSGisWorkspace wsSource) throws Exception {

        Feature fTest;

        FeatureStore testStore = ws.openFeatureStore("test",false);

        FeatureStore testStoreSource = wsSource.openFeatureStore("test",false);

        fTest = testStoreSource.findFirst("id = "+id);

        FeatureStore rchangesStore = ws.openFeatureStore(RemoteChangesTable.TABLE_NAME,false);

        Feature fChanges = rchangesStore.findFirst("RCH_DATACODE = '"+fTest.getString(FEATURECODE_FIELD_NAME)+"'");

        EditableFeature efChanges = fChanges.getEditable();

        rchangesStore.edit(MODE_PASS_THROUGH);

        efChanges.set("RCH_SELECTED",select);

        rchangesStore.update(efChanges);

        rchangesStore.finishEditing();

        DisposeUtils.dispose(testStore);

        DisposeUtils.dispose(testStoreSource);

        DisposeUtils.dispose(rchangesStore);

    }

    private void checkLocalChange(FeatureStore data, FeatureStore changes, String code, int operation, int id, String text, int status) throws DataException{

        Feature change = changes.findFirst("WSCH_FEATURECODE = '"+code+"'");

        assertNotNull("Change code not exists", change);

        assertEquals(operation, change.getInt(WorkspaceChangesTable.OPERATION));

        if(status >=0){

            assertEquals(status, change.getInt(WorkspaceChangesTable.STATUS));

        }

        // Uf, ojo con operation delete, no tiene data. en la primera pasada lo saltaria, y a ver que pasa con

        // los inserts y updates.

//        if(operation != OP_DELETE){

//            Feature f = data.findFirst("VCSGISCODE = '"+code+"'");

//            assertEquals(id  , f.getInt("id"));

//            assertEquals(text, f.getString("text"));

//        }

    }

    private VCSGisWorkspace[] initTest() throws Exception{

        utils().cleanRepositoryDatabase();

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-update");

        File ws1file = utils().getFile(FileUtils.getFile("test-dbs","ws1-update")); 

        File ws2file = utils().getFile(FileUtils.getFile("test-dbs","ws2-update")); 

        File ws3file = utils().getFile(FileUtils.getFile("test-dbs","ws3-update")); 

        manager.setCodeGenerator(new SequentialCodeGenerator());

        int r;

        List<Feature> features;

        FeatureStore store2;

        FeatureStore store3;

        // ------------------------------------------------------------

        // Inicializamos el repositorio y lo abrimos

        r = manager.initRepository(server.getParameters(), null);

        assertEquals("init_server status", ERR_NO_ERROR, r);

        VCSGisRepository repo = manager.openRepository(server.getParameters());

        utils().info_repository(repo);

        // ------------------------------------------------------------

        // Creamos workspace1 y lo abrimos.

        r = manager.initWorkspace(ws1file, repo, "Test update1",null);

        assertEquals("init_ws1 status", ERR_NO_ERROR, r);

        VCSGisWorkspace ws1 = manager.openWorkspace(ws1file);

        utils().info_workspace(ws1);

        // ------------------------------------------------------------

        // Adicionamos al workspace1 la tabla "test" y la commitamos.

        //REV 0

        FeatureStore sourceTest = utils().openSourceStore2();

        r = ws1.add("test", sourceTest, "text");

        DisposeUtils.disposeQuietly(sourceTest);

        assertEquals("ws1.add status", ERR_NO_ERROR, r);

        r = ws1.commit();

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        // ------------------------------------------------------------

        // Inicializamos el workspace2 asociandolo al mismo repositorio que 

        // workspace1 y lo abrimos.

        r = manager.initWorkspace(ws2file, repo, "Test update2",null);

        assertEquals("init_ws2 status", ERR_NO_ERROR, r);

        VCSGisWorkspace ws2 = manager.openWorkspace(ws2file);

        utils().info_workspace(ws2);

        // ------------------------------------------------------------

        // Actualizamos (update) la tabla "test" en el workspace2 

        // y comprobamos que tiene lo que toca.

        r = ws2.checkout("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

        store2 = ws2.openFeatureStore("test",false);

        assertEquals("ws2-upfate sizes", 3, store2.size64());

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BBB");

        check(features, 2, 3, "CCC");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

        // ------------------------------------------------------------

        // Inicializamos el workspace3 asociandolo al mismo repositorio que 

        // workspace1 y lo abrimos.

        r = manager.initWorkspace(ws3file, repo, "Test update2",null);

        assertEquals("init_ws2 status", ERR_NO_ERROR, r);

        VCSGisWorkspace ws3 = manager.openWorkspace(ws3file);

        utils().info_workspace(ws3);

        // ------------------------------------------------------------

        // Actualizamos (update) la tabla "test" en el workspace3

        // y comprobamos que tiene lo que toca.

        r = ws3.checkout("test");

        assertEquals("ws3.update-1 status", ERR_NO_ERROR, r);

        store3 = ws3.openFeatureStore("test",false);

        assertEquals("ws3-upfate sizes", 3, store3.size64());

        features = store3.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BBB");

        check(features, 2, 3, "CCC");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

        DisposeUtils.disposeQuietly(store3);

        return new VCSGisWorkspace[] {ws1, ws2, ws3};

    }

    protected void testTwoUpdatesAndMerge() throws Exception {

        VCSGisWorkspace[] wss = initTest();

        VCSGisWorkspace ws1 = wss[0];

        VCSGisWorkspace ws2 = wss[1];

        int r;

        Feature f;

        EditableFeature ef;

        FeatureStore store1;

        FeatureStore store2;

        // Añadimos al workspace1 una feature con una id concreta y la commitamos

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        update(store1, 3, "CC1");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        // Añadimos al workspace2 una feature con la misma id

        store2 = ws2.openFeatureStore("test",false);

        store2.edit();

        update(store2, 3, "CC2");

        store2.finishEditing();

        DisposeUtils.disposeQuietly(store2);

        // ------------------------------------------------------------

        // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

        // comprobamos que funciona y que tiene lo que toca.

        r = ws2.updatePrepare("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

//        assertTrue(false);

        // Actualizamos (update) la tabla "test" en el workspace2 

        // comprobamos que falla

        r = ws2.update("test");

        assertEquals("ws2.update-1 status", ERR_UPDATE_NEED_MERGE, r);

        // Actualizamos (merge) la tabla "test" en el workspace2 

        // comprobamos que no falla

        r = ws2.merge("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

        //Comprobar que en la tabla de cambios locales hay 1 elemento

        FeatureStore changes = ws2.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        assertEquals("ws2-changes size", 1, changes.size64());

    }

    protected void testTwoUpdatesMergeAndUpdate() throws Exception {

        VCSGisWorkspace[] wss = initTest();

        VCSGisWorkspace ws1 = wss[0];

        VCSGisWorkspace ws2 = wss[1];

        VCSGisWorkspace ws3 = wss[2];

        int r;

        Feature f;

        EditableFeature ef;

        FeatureStore store1;

        FeatureStore store2;

        FeatureStore store3;

        // Editamos en el workspace1 una feature con una id concreta y la commitamos

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        update(store1, 3, "CC1");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        // Editamos en el workspace2 la feature con la misma id

        store2 = ws2.openFeatureStore("test",false);

        store2.edit();

        update(store2, 3, "CC2");

        store2.finishEditing();

        DisposeUtils.disposeQuietly(store2);

        // ------------------------------------------------------------

        // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

        // comprobamos que funciona y que tiene lo que toca.

        r = ws2.updatePrepare("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

//        assertTrue(false);

        // Actualizamos (update) la tabla "test" en el workspace2 

        // comprobamos que falla

        r = ws2.update("test");

        assertEquals("ws2.update-1 status", ERR_UPDATE_NEED_MERGE, r);

        // Actualizamos (merge) la tabla "test" en el workspace2 

        // comprobamos que no falla

        r = ws2.merge("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

        //Comprobar que en la tabla de cambios locales hay 1 elemento

        FeatureStore changes = ws2.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        assertEquals("ws2-changes size", 1, changes.size64());

        DisposeUtils.dispose(changes);

        // Commitamos el workspace2

        r = ws2.commit();

        assertEquals("ws2.commit-1 status", ERR_NO_ERROR, r);

        // ------------------------------------------------------------

        // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace3

        // comprobamos que funciona y que tiene lo que toca.

        r = ws3.updatePrepare("test");

        assertEquals("ws3.update-1 status", ERR_NO_ERROR, r);

        //Comprobar que en la tabla de cambios remotos hay 1 elemento

        FeatureStore remoteChanges = ws3.getFeatureStore(RemoteChangesTable.TABLE_NAME);

        assertEquals("ws3-remoteChanges size", 1, remoteChanges.size64());

        DisposeUtils.dispose(remoteChanges);

        // Actualizamos (update) la tabla "test" en el workspace3 

        // comprobamos que no falla

        r = ws3.update("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

        store3 = ws3.openFeatureStore("test",false);

        assertEquals("ws3-update sizes", 3, store3.size64());

        List<Feature> features = store3.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BBB");

        check(features, 2, 3, "CC2");

        DisposeUtils.disposeQuietly(store3);

    }

    protected void testTwoUpdatesAndUpdate() throws Exception {

        VCSGisWorkspace[] wss = initTest();

        VCSGisWorkspace ws1 = wss[0];

        VCSGisWorkspace ws2 = wss[1];

        int r;

        Feature f;

        EditableFeature ef;

        FeatureStore store1;

        FeatureStore store2;

        // Añadimos al workspace1 una feature con una id concreta y la commitamos

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        update(store1, 3, "CC1");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        // Añadimos al workspace2 una feature con la misma id

        store2 = ws2.openFeatureStore("test",false);

        store2.edit();

        update(store2, 3, "CC2");

        store2.finishEditing();

        DisposeUtils.disposeQuietly(store2);

        // ------------------------------------------------------------

        // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

        // comprobamos que funciona y que tiene lo que toca.

        r = ws2.updatePrepare("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

//        assertTrue(false);

        // Actualizamos (update) la tabla "test" en el workspace2 

        // comprobamos que falla

        r = ws2.update("test");

        assertEquals("ws2.update-1 status", ERR_UPDATE_NEED_MERGE, r);

        //Seleccionar el cambio conflictivo id=4

        selectRemoteChange(ws2, true, 3, "CC1", ws1);

        // Actualizamos (merge) la tabla "test" en el workspace2 

        // comprobamos que no falla

        r = ws2.update("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

        //Comprobar que en la tabla de cambios locales no hay nada

        FeatureStore changes = ws2.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        assertEquals("ws2-changes size", 0, changes.size64());

        DisposeUtils.dispose(changes);

    }

    protected void testTwoInsertsAndUpdate() throws Exception {

        VCSGisWorkspace[] wss = initTest();

        VCSGisWorkspace ws1 = wss[0];

        VCSGisWorkspace ws2 = wss[1];

        int r;

        Feature f;

        EditableFeature ef;

        List<Feature> features;

        FeatureStore store1;

        FeatureStore store2;

                // Añadimos al workspace1 una feature con una id concreta y la commitamos

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 4, "DD1");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        // Añadimos al workspace2 una feature con la misma id

        store2 = ws2.openFeatureStore("test",false);

        store2.edit();

        f = insert(store2, 4, "DD2");

        String code_id4_DD2 = f.getString("VCSGISCODE");

        store2.finishEditing();

        DisposeUtils.disposeQuietly(store2);

        // ------------------------------------------------------------

        // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

        // comprobamos que funciona y que tiene lo que toca.

        r = ws2.updatePrepare("test");

        assertEquals("ws2.updatePrepare-1 status", ERR_NO_ERROR, r);

        FeatureStore changes = ws2.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        checkLocalChange(store2, changes, code_id4_DD2, OP_INSERT, 4, "DD2", STATE_CONFLICT);

        DisposeUtils.dispose(changes);

        // Actualizamos (update) la tabla "test" en el workspace2 

        // comprobamos que no falla

        r = ws2.update("test");

        assertEquals("ws2.update-1 status", ERR_UPDATE_NEED_MERGE, r);

        //Seleccionar el cambio conflictivo id=4

        selectRemoteChange(ws2, true, 4, "DD1", ws1);

        //update y comprobar que funciona y se ha borrado la feature conflictiva nuestra

        r = ws2.update("test");

        assertEquals("ws2.update-2 status", ERR_NO_ERROR, r);

        store2 = ws2.openFeatureStore("test",false);

        assertEquals("ws2-upfate sizes", 4, store2.size64());

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BBB");

        check(features, 2, 3, "CCC");

        check(features, 3, 4, "DD1");

        //Comprobar que en la tabla de cambios locales no hay nada

        changes = ws2.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        assertEquals("ws2-changes size", 0, changes.size64());

        DisposeUtils.dispose(changes);

    }

    protected void testTwoInsertsAndMerge() throws Exception {

        VCSGisWorkspace[] wss = initTest();

        VCSGisWorkspace ws1 = wss[0];

        VCSGisWorkspace ws2 = wss[1];

        int r;

        Feature f;

        EditableFeature ef;

        List<Feature> features;

        FeatureStore store1;

        FeatureStore store2;

                //Insertamos dos registros nuevos y repetirlo todo sin seleccionar cambio conflictivo y hacer un merge y que funcione

        // Añadimos al workspace1 una feature con una id concreta y la commitamos

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        f = insert(store1, 4, "DD1");

        String code_id4_DD1 = f.getString("VCSGISCODE");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        // Añadimos al workspace2 una feature con la misma id

        store2 = ws2.openFeatureStore("test",false);

        store2.edit();

        f = insert(store2, 4, "DD2");

        String code_id4_DD2 = f.getString("VCSGISCODE");

        store2.finishEditing();

        DisposeUtils.disposeQuietly(store2);

        // ------------------------------------------------------------

        // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

        // comprobamos que funciona y que tiene lo que toca.

        r = ws2.updatePrepare("test");

        assertEquals("ws2.updatePrepare-1 status", ERR_NO_ERROR, r);

        // Actualizamos (update) la tabla "test" en el workspace2 

        // comprobamos que no falla

        r = ws2.update("test");

        assertEquals("ws2.update-1 status", ERR_UPDATE_NEED_MERGE, r);

        //merge y comprobar que funciona y no se insertado el cambio conflictivo

        r = ws2.merge("test");

        assertEquals("ws2.update-2 status", ERR_NO_ERROR, r);

        store2 = ws2.openFeatureStore("test",false);

        assertEquals("ws2-upfate sizes", 4, store2.size64());

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BBB");

        check(features, 2, 3, "CCC");

        check(features, 3, 4, "DD2");

        //Comprobamos que se ha añadido a la tabla de cambios local el delete del cambio conflictivo

        FeatureStore changes = ws2.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        assertEquals("ws2-changes size", 2, changes.size64());

        checkLocalChange(store2, changes, code_id4_DD1, OP_DELETE, 4, "DD1", -1);

        checkLocalChange(store2, changes, code_id4_DD2, OP_INSERT, 4, "DD2", -1);

        DisposeUtils.dispose(changes);

    }

    protected void testOneCommitAndUpdateOverDeleted() throws Exception {

        VCSGisWorkspace[] wss = initTest();

        VCSGisWorkspace ws1 = wss[0];

        VCSGisWorkspace ws2 = wss[1];

        List<Feature> features;

        int r;

        Feature f;

        EditableFeature ef;

        FeatureStore store1;

        FeatureStore store2;

        // Modificamos en workspace1 una feature con una id concreta y la commitamos

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        update(store1, 3, "CC1");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        // Borramos en el workspace2 la feature con la misma id

        store2 = ws2.openFeatureStore("test",false);

        store2.edit();

        delete(store2, 3, "CCC");

        store2.finishEditing();

        DisposeUtils.disposeQuietly(store2);

        // ------------------------------------------------------------

        // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

        // comprobamos que funciona y que tiene lo que toca.

        r = ws2.updatePrepare("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

//        assertTrue(false);

        // Actualizamos (update) la tabla "test" en el workspace2 

        // comprobamos que falla

        r = ws2.update("test");

        assertEquals("ws2.update-1 status", ERR_UPDATE_NEED_MERGE, r);

//        // Actualizamos (merge) la tabla "test" en el workspace2 

//        // comprobamos que no falla

//        r = ws2.merge("test");

//        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

        //Seleccionar el cambio conflictivo id=4

        selectRemoteChange(ws2, true, 3, "CC1", ws1);

        //update y comprobar que funciona y no se ha insertado la feature conflictiva

        r = ws2.update("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

        store2 = ws2.openFeatureStore("test",false);

        assertEquals("ws2-update sizes", 3, store2.size64());

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BBB");

        check(features, 2, 3, "CC1");

        //Comprobar que en la tabla de cambios locales no hay nada

        FeatureStore changes = ws2.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        assertEquals("ws2-changes size", 0, changes.size64());

        DisposeUtils.dispose(changes);

    }

    protected void testOneCommitAndMergeOverDeleted() throws Exception {

        VCSGisWorkspace[] wss = initTest();

        VCSGisWorkspace ws1 = wss[0];

        VCSGisWorkspace ws2 = wss[1];

        List<Feature> features;

        int r;

        Feature f;

        EditableFeature ef;

        FeatureStore store1;

        FeatureStore store2;

        // Modificamos en workspace1 una feature con una id concreta y la commitamos

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        update(store1, 3, "CC1");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        // Borramos en el workspace2 la feature con la misma id

        store2 = ws2.openFeatureStore("test",false);

        store2.edit();

        delete(store2, 3, "CCC");

        store2.finishEditing();

        DisposeUtils.disposeQuietly(store2);

        // ------------------------------------------------------------

        // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

        // comprobamos que funciona y que tiene lo que toca.

        r = ws2.updatePrepare("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

//        assertTrue(false);

        // Actualizamos (update) la tabla "test" en el workspace2 

        // comprobamos que falla

//        r = ws2.update("test");

//        assertEquals("ws2.update-1 status", ERR_UPDATE_NEED_MERGE, r);

        // Actualizamos (merge) la tabla "test" en el workspace2 

        // comprobamos que no falla

        r = ws2.merge("test");

        assertEquals("ws2.update-1 status", ERR_NO_ERROR, r);

        //Comprobamos que en workspace2 hay lo que toca

        store2 = ws2.openFeatureStore("test",false);

        assertEquals("ws2-update sizes", 2, store2.size64());

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BBB");

//        check(features, 2, 3, "CC1");

        //Comprobar que en la tabla de cambios locales permanece el cambio

        FeatureStore changes = ws2.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        assertEquals("ws2-changes size", 1, changes.size64());

        DisposeUtils.dispose(changes);

    }

}

package org.gvsig.vcsgis.lib.impl;

import java.io.File;

import java.sql.Timestamp;

import java.util.List;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

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

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.vcsgis.lib.SequentialCodeGenerator;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_NO_ERROR;

import org.gvsig.vcsgis.lib.repository.VCSGisRepository;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspace;

public abstract class AbstractTest20ExportToEffectiveDate extends AbstractTestVCSGIS {

    public AbstractTest20ExportToEffectiveDate(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    // TODO add test methods here. The name must begin with 'test'. For example:

    // public void testHello() {}

    private void insert(FeatureStore store, int id, String text) throws DataException{

        EditableFeature ef = store.createNewFeature();

        ef.set("id",id);

        ef.set("text",text);

        store.insert(ef);

    }

    private void update(FeatureStore store, int id, String text) throws DataException{

        Feature f = store.findFirst("id="+id);

        EditableFeature ef = f.getEditable();

        ef.set("text", text);

        store.update(ef);

    }

    private void delete(FeatureStore store, int id, String text) throws DataException{

        Feature f = store.findFirst("id="+id);

        store.delete(f);

    }

    private void check(List<Feature> features, int index, int id, String text){

        assertEquals(id    , features.get(index).getInt("id"));

        assertEquals(text, features.get(index).getString("text"));

    }

    private void check(FeatureStore store2, String relatedFeatureCode, int id, String text) throws Exception {

        Feature f = store2.findFirst("VCSGISCODE = '"+relatedFeatureCode+"'");

        assertEquals(id, f.getInt("id"));

        assertEquals(text, f.getString("text"));

    }

    protected void testExportToEffectiveDateConsecutive() throws Exception {

        utils().cleanRepositoryDatabase();

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        manager.setCodeGenerator(new SequentialCodeGenerator());

        JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-update");

        File ws1file = utils().getFile(FileUtils.getFile("test-dbs","ws1-update")); 

        File ws2file = utils().getFile(FileUtils.getFile("test-dbs","ws2-update")); 

        int r;

        Feature f;

        EditableFeature ef;

        List<Feature> features;

        FeatureStore store1;

        FeatureStore store2;

        // ------------------------------------------------------------

        // Inicializamos el repositorio y lo abrimos

        r = manager.initRepository(server.getParameters(), null);

        assertEquals("init_server status", ERR_NO_ERROR, r);

        VCSGisRepository repo = manager.openRepository(server.getParameters());

        utils().info_repository(repo);

        // ------------------------------------------------------------

        // Creamos workspace1 y lo abrimos.

        r = manager.initWorkspace(ws1file, repo, "Test update1",null);

        assertEquals("init_ws1 status", ERR_NO_ERROR, r);

        VCSGisWorkspace ws1 = manager.openWorkspace(ws1file);

        utils().info_workspace(ws1);

        // ------------------------------------------------------------

        // Adicionamos al workspace1 la tabla "test" y la commitamos.

        //REV 0

        FeatureStore sourceTest = utils().openSourceStore2();

        r = ws1.add("test", sourceTest, "text");

        DisposeUtils.disposeQuietly(sourceTest);

        assertEquals("ws1.add status", ERR_NO_ERROR, r);

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 4, "DDD");

        insert(store1, 5, "EEE");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-01-01 00:00:00.000"), "2021-01-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //REV 1

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 6, "FFF");

        insert(store1, 7, "GGG");

        insert(store1, 8, "HHH");

        insert(store1, 9, "III");

        insert(store1, 10, "JJJ");

        delete(store1, 5, "EEE");

        update(store1, 2, "BB2");

        update(store1, 4, "DD2");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-02-01 00:00:00.000"), "2021-02-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //REV 2

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 11, "KKK");

        insert(store1, 12, "LLL");

        insert(store1, 13, "MMM");

        delete(store1, 4, "DD2");

        delete(store1, 7, "GGG");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-03-01 00:00:00.000"), "2021-03-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //REV 3

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 14, "NNN");

        insert(store1, 15, "OOO");

        insert(store1, 16, "PPP");

        insert(store1, 17, "QQQ");

        delete(store1, 3, "CCC");

        delete(store1, 10, "JJJ");

        update(store1, 13, "MM2");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-04-01 00:00:00.000"), "2021-04-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //REV 4

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 18, "RRR");

        insert(store1, 19, "SSS");

        insert(store1, 20, "TTT");

        insert(store1, 21, "UUU");

        delete(store1, 9, "III");

        update(store1, 17, "QQ2");

        delete(store1, 16, "PPP");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-05-01 00:00:00.000"), "2021-05-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //REV 5

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 22, "VVV");

        insert(store1, 23, "WWW");

        insert(store1, 24, "XXX");

        insert(store1, 25, "YYY");

        insert(store1, 26, "ZZZ");

        delete(store1, 13, "MM2");

        delete(store1, 19, "SSS");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-06-01 00:00:00.000"), "2021-06-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //Export enero

        r = ws1.export("test", "exp_enero", null, Timestamp.valueOf("2021-01-15 00:00:00.000"), null, null);

        assertEquals("ws1.export-1 status", 0, r);

        store2 = ws1.openFeatureStore("exp_enero",false);

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BBB");

        check(features, 2, 3, "CCC");

        check(features, 3, 4, "DDD");

        check(features, 4, 5, "EEE");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

        //Export febrero

        r = ws1.export("test", "exp_febrero", null, Timestamp.valueOf("2021-02-15 00:00:00.000"), null, null);

        assertEquals("ws1.export-1 status", 0, r);

        store2 = ws1.openFeatureStore("exp_febrero",false);

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BB2");

        check(features, 2, 3, "CCC");

        check(features, 3, 4, "DD2");

        check(features, 4, 6, "FFF");

        check(features, 5, 7, "GGG");

        check(features, 6, 8, "HHH");

        check(features, 7, 9, "III");

        check(features, 8, 10, "JJJ");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

        //Export marzo

        r = ws1.export("test", "exp_marzo", null, Timestamp.valueOf("2021-03-15 00:00:00.000"), null, null);

        assertEquals("ws1.export-1 status", 0, r);

        store2 = ws1.openFeatureStore("exp_marzo",false);

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BB2");

        check(features, 2, 3, "CCC");

        check(features, 3, 6, "FFF");

        check(features, 4, 8, "HHH");

        check(features, 5, 9, "III");

        check(features, 6, 10, "JJJ");

        check(features, 7, 11, "KKK");

        check(features, 8, 12, "LLL");

        check(features, 9, 13, "MMM");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

        //Export abril

        r = ws1.export("test", "exp_abril", null, Timestamp.valueOf("2021-04-15 00:00:00.000"), null, null);

        assertEquals("ws1.export-1 status", 0, r);

        store2 = ws1.openFeatureStore("exp_abril",false);

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BB2");

        check(features, 2, 6, "FFF");

        check(features, 3, 8, "HHH");

        check(features, 4, 9, "III");

        check(features, 5, 11, "KKK");

        check(features, 6, 12, "LLL");

        check(features, 7, 13, "MM2");

        check(features, 8, 14, "NNN");

        check(features, 9, 15, "OOO");

        check(features, 10, 16, "PPP");

        check(features, 11, 17, "QQQ");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

        //Export mayo

        r = ws1.export("test", "exp_mayo", null, Timestamp.valueOf("2021-05-15 00:00:00.000"), null, null);

        assertEquals("ws1.export-1 status", 0, r);

        store2 = ws1.openFeatureStore("exp_mayo",false);

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BB2");

        check(features, 2, 6, "FFF");

        check(features, 3, 8, "HHH");

        check(features, 4, 11, "KKK");

        check(features, 5, 12, "LLL");

        check(features, 6, 13, "MM2");

        check(features, 7, 14, "NNN");

        check(features, 8, 15, "OOO");

        check(features, 9, 17, "QQ2");

        check(features, 10, 18, "RRR");

        check(features, 11, 19, "SSS");

        check(features, 12, 20, "TTT");

        check(features, 13, 21, "UUU");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

        //Export junio

        r = ws1.export("test", "exp_junio", null, Timestamp.valueOf("2021-06-15 00:00:00.000"), null, null);

        assertEquals("ws1.export-2 status", 0, r);

        store2 = ws1.openFeatureStore("exp_junio",false);

        features = store2.getFeatures((Expression)null, "id", true);

        int n=0;

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BB2");

        check(features, 2, 6, "FFF");

        check(features, 3, 8, "HHH");

        check(features, 4, 11, "KKK");

        check(features, 5, 12, "LLL");

        check(features, 6, 14, "NNN");

        check(features, 7, 15, "OOO");

        check(features, 8, 17, "QQ2");

        check(features, 9, 18, "RRR");

        check(features, 10, 20, "TTT");

        check(features, 11, 21, "UUU");

        check(features, 12, 22, "VVV");

        check(features, 13, 23, "WWW");

        check(features, 14, 24, "XXX");

        check(features, 15, 25, "YYY");

        check(features, 16, 26, "ZZZ");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

    }

    protected void testExportToEffectiveDateAlteredOrder() throws Exception {

        utils().cleanRepositoryDatabase();

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        manager.setCodeGenerator(new SequentialCodeGenerator());

        JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-update");

        File ws1file = utils().getFile(FileUtils.getFile("test-dbs","ws1-update")); 

        File ws2file = utils().getFile(FileUtils.getFile("test-dbs","ws2-update")); 

        int r;

        Feature f;

        EditableFeature ef;

        List<Feature> features;

        FeatureStore store1;

        FeatureStore store2;

        // ------------------------------------------------------------

        // Inicializamos el repositorio y lo abrimos

        r = manager.initRepository(server.getParameters(), null);

        assertEquals("init_server status", ERR_NO_ERROR, r);

        VCSGisRepository repo = manager.openRepository(server.getParameters());

        utils().info_repository(repo);

        // ------------------------------------------------------------

        // Creamos workspace1 y lo abrimos.

        r = manager.initWorkspace(ws1file, repo, "Test update1",null);

        assertEquals("init_ws1 status", ERR_NO_ERROR, r);

        VCSGisWorkspace ws1 = manager.openWorkspace(ws1file);

        utils().info_workspace(ws1);

        // ------------------------------------------------------------

        // Adicionamos al workspace1 la tabla "test" y la commitamos.

        //REV 0

        FeatureStore sourceTest = utils().openSourceStore2();

        r = ws1.add("test", sourceTest, "text");

        DisposeUtils.disposeQuietly(sourceTest);

        assertEquals("ws1.add status", ERR_NO_ERROR, r);

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 4, "DDD");

        insert(store1, 5, "EEE");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-01-01 00:00:00.000"), "2021-01-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //REV 1

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 6, "FFF");

        insert(store1, 7, "GGG");

        insert(store1, 8, "HHH");

        insert(store1, 9, "III");

        insert(store1, 10, "JJJ");

        delete(store1, 5, "EEE");

        update(store1, 2, "BB2");

        update(store1, 4, "DD2");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-02-01 00:00:00.000"), "2021-02-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //REV 2

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 11, "KKK");

        insert(store1, 12, "LLL");

        insert(store1, 13, "MMM");

        delete(store1, 4, "DD2");

        delete(store1, 7, "GGG");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-04-01 00:00:00.000"), "2021-04-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //REV 3

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 14, "NNN");

        insert(store1, 15, "OOO");

        insert(store1, 16, "PPP");

        insert(store1, 17, "QQQ");

        delete(store1, 3, "CCC");

        delete(store1, 10, "JJJ");

        update(store1, 13, "MM2");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-03-01 00:00:00.000"), "2021-03-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //REV 4

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 18, "RRR");

        insert(store1, 19, "SSS");

        insert(store1, 20, "TTT");

        insert(store1, 21, "UUU");

        delete(store1, 9, "III");

        update(store1, 17, "QQ2");

        delete(store1, 16, "PPP");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-06-01 00:00:00.000"), "2021-06-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //REV 5

        store1 = ws1.openFeatureStore("test",false);

        store1.edit();

        insert(store1, 22, "VVV");

        insert(store1, 23, "WWW");

        insert(store1, 24, "XXX");

        insert(store1, 25, "YYY");

        insert(store1, 26, "ZZZ");

        delete(store1, 13, "MM2");

        delete(store1, 19, "SSS");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit(null, Timestamp.valueOf("2021-05-01 00:00:00.000"), "2021-05-01 00:00:00.000", null);

        assertEquals("ws1.commit-1 status", ERR_NO_ERROR, r);

        //Export enero

        r = ws1.export("test", "exp_enero", null, Timestamp.valueOf("2021-01-15 00:00:00.000"), null, null);

        assertEquals("ws1.export-1 status", 0, r);

        store2 = ws1.openFeatureStore("exp_enero",false);

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BBB");

        check(features, 2, 3, "CCC");

        check(features, 3, 4, "DDD");

        check(features, 4, 5, "EEE");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

        //Export febrero

        r = ws1.export("test", "exp_febrero", null, Timestamp.valueOf("2021-02-15 00:00:00.000"), null, null);

        assertEquals("ws1.export-1 status", 0, r);

        store2 = ws1.openFeatureStore("exp_febrero",false);

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BB2");

        check(features, 2, 3, "CCC");

        check(features, 3, 4, "DD2");

        check(features, 4, 6, "FFF");

        check(features, 5, 7, "GGG");

        check(features, 6, 8, "HHH");

        check(features, 7, 9, "III");

        check(features, 8, 10, "JJJ");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

        //Export marzo

        r = ws1.export("test", "exp_marzo", null, Timestamp.valueOf("2021-03-15 00:00:00.000"), null, null);

        assertEquals("ws1.export-1 status", 0, r);

        store2 = ws1.openFeatureStore("exp_marzo",false);

        features = store2.getFeatures((Expression)null, "id", true);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BB2");

        check(features, 2, 4, "DD2");

        check(features, 3, 6, "FFF");

        check(features, 4, 7, "GGG");

        check(features, 5, 8, "HHH");

        check(features, 6, 9, "III");

        check(features, 7, 13, "MM2");

        check(features, 8, 14, "NNN");

        check(features, 9, 15, "OOO");

        check(features, 10, 16, "PPP");

        check(features, 11, 17, "QQQ");

//        update(store1, 13, "MM2");