*    GeoTools - The Open Source Java GIS Toolkit

*    http://geotools.org

*

*    (C) 2002-2008, Open Source Geospatial Foundation (OSGeo)

*

*    This library is free software; you can redistribute it and/or

*    modify it under the terms of the GNU Lesser General Public

*    License as published by the Free Software Foundation;

*    version 2.1 of the License.

*

*    This library is distributed in the hope that it will be useful,

*    but WITHOUT ANY WARRANTY; without even the implied warranty of

*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

*    Lesser General Public License for more details.

*/

* Unit tests for transaction support

*

* @author Gabriel Roldan, Axios Engineering

*

*

* @source $URL$

*         http://svn.geotools.org/geotools/trunk/gt/modules/plugin/arcsde/da/src/test/java/org

*         /geotools/arcsde/data/ArcSDEFeatureStoreTest.java $

* @version $Id$

*/

    /** package logger */

    private static Logger LOGGER = org.geotools.util.logging.Logging

            .getLogger(ArcSDEFeatureStoreTest.class.getPackage().getName());

    private TestData testData;

    /**

     * Flag that indicates whether the underlying database is MS SQL Server.

     * <p>

     * This is used to decide what's the expected result count in some transaction tests, and its

     * value is obtained from an {@link SeDBMSInfo} object. Hacky as it seems it is. The problem is

     * that ArcSDE for SQL Server _explicitly_ sets the transaction isolation level to READ

     * UNCOMMITTED for all and every transaction, while for other databases it uses READ COMMITTED.

     * And no, ESRI documentation says there's no way to change nor workaround this behaviour.

     * </p>

     */

    private static boolean databaseIsMsSqlServer;

    @Before

    public void setUp() throws Exception {

        testData = new TestData();

        testData.setUp();

        // do not insert test data, will do it at each test case

        final boolean insertTestData = false;

        testData.createTempTable(insertTestData);

        ISession session = testData.getConnectionPool().getSession();

        try {

            SeDBMSInfo dbInfo = session.getDBMSInfo();

            databaseIsMsSqlServer = dbInfo.dbmsId == SeDBMSInfo.SE_DBMS_IS_SQLSERVER;

        } finally {

            session.dispose();

        }

    }

    @After

    public void tearDown() {

        boolean cleanTestTable = false;

        boolean cleanPool = true;

        testData.tearDown(cleanTestTable, cleanPool);

    }

    /**

     * This is an adaptation of a classic MemoryDataStore test to match our sample data.

     * <p>

     * This test is focused on two things:

     * <ul>

     * <li>Are the Transactions actually independent?

     * <li>Do the correct feature event notifications get sent out

     * </ul>

     */

    @Ignore

    @Test

    public void testFeatureEventsAndTransactionsForDelete() throws Exception {

        // We are going to start with ...

        testData.insertTestData();

        final DataStore dataStore = testData.getDataStore();

        final String typeName = testData.getTempTableName();

        final SimpleFeatureSource origional = dataStore.getFeatureSource(typeName);

        TestFeatureListener listener = new TestFeatureListener();

        origional.addFeatureListener(listener);

        // we are going to use this feature source to check that the

        // public Transaction.AUTO_COMMIT view of the world

        // is as expected.

        assertEquals(8, origional.getCount(Query.ALL));

        final SortedSet<String> allFids = new TreeSet<String>();

        SimpleFeatureCollection collection = origional.getFeatures();

        TestProgressListener progress = new TestProgressListener();

        collection.accepts(new FeatureVisitor() {

            public void visit(Feature feature) {

                allFids.add(feature.getIdentifier().getID());

            }

        }, progress);

        assertTrue("visitor completed", progress.completed);

        assertEquals("visitor 100%", 100f, progress.progress);

        assertNull("visitor no problems", progress.exception);

        // we are going to use this transaction to modify and commit

        DefaultTransaction t1 = new DefaultTransaction("Transaction 1");

        SimpleFeatureStore featureStore1 = (SimpleFeatureStore) dataStore

                .getFeatureSource(typeName);

        featureStore1.setTransaction(t1);

        TestFeatureListener listener1 = new TestFeatureListener();

        featureStore1.addFeatureListener(listener1);

        // we are going to use this transaction to modify and rollback

        DefaultTransaction t2 = new DefaultTransaction("Transaction 2");

        SimpleFeatureStore featureStore2 = (SimpleFeatureStore) dataStore

                .getFeatureSource(typeName);

        featureStore2.setTransaction(t2);

        TestFeatureListener listener2 = new TestFeatureListener();

        featureStore2.addFeatureListener(listener2);

        // verify they are all working

        assertEquals(8, origional.getCount(Query.ALL));

        assertEquals(8, featureStore1.getCount(Query.ALL));

        assertEquals(8, featureStore2.getCount(Query.ALL));

        Query queryOneFeature = new Query();

        queryOneFeature.setTypeName(typeName);

        queryOneFeature.setFilter(Filter.INCLUDE);

        queryOneFeature.setMaxFeatures(1);

        queryOneFeature.setPropertyNames(Query.ALL_NAMES);

        collection = featureStore1.getFeatures(queryOneFeature);

        progress.reset();

        final SortedSet<String> fids = new TreeSet<String>();

        collection.accepts(new FeatureVisitor() {

            public void visit(Feature feature) {

                fids.add(feature.getIdentifier().getID());

            }

        }, progress);

        assertTrue("visitor completed", progress.completed);

        assertEquals("visitor 100%", 100f, progress.progress);

        assertNull("visitor no problems", progress.exception);

        assertEquals(1, fids.size());

        String featureId = fids.first();

        assertTrue(allFids.contains(featureId));

        FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(null);

        Filter filterOne = ff.id(Collections.singleton(ff.featureId(featureId)));

        assertEquals("no events on AUTO_COMMIT", 0, listener.list.size());

        assertEquals("no events on transaction1", 0, listener1.list.size());

        assertEquals("no events on transaction2", 0, listener2.list.size());

        featureStore1.removeFeatures(filterOne);

        assertEquals("no events on AUTO_COMMIT", 0, listener.list.size());

        assertEquals("single event on transaction2", 1, listener1.list.size());

        assertEquals("no events on AUTO_COMMIT", 0, listener2.list.size());

        FeatureEvent e = listener1.list.get(0);

        assertEquals(featureStore1, e.getFeatureSource());

        Id id = (Id) e.getFilter();

        assertNotNull(id);

        assertNotNull(id.getIDs());

        assertTrue(id.getIDs().contains(featureId));

        ReferencedEnvelope bounds = e.getBounds();

        assertFalse(bounds.isEmpty());

        assertFalse(bounds.isNull());

        t1.commit();

        assertEquals("commit event sent to AUTO_COMMIT", 1, listener.list.size());

        assertEquals("commit event sent to transaction 1", 2, listener1.list.size());

        assertEquals("commit event sent to transaction 2", listener2.list.size());

    }

    @Test

    @Ignore

    public void testFeatureEventsAndTransactionsForAdd() throws Exception {

        // We are going to start with ...

        testData.insertTestData();

        final DataStore dataStore = testData.getDataStore();

        final String typeName = testData.getTempTableName();

        final SimpleFeatureSource origional = dataStore.getFeatureSource(typeName);

        TestFeatureListener listener = new TestFeatureListener();

        origional.addFeatureListener(listener);

        // we are going to use this feature source to check that the

        // public Transaction.AUTO_COMMIT view of the world

        // is as expected.

        assertEquals(8, origional.getCount(Query.ALL));

        // we are going to use this transaction to modify and commit

        DefaultTransaction t1 = new DefaultTransaction("Transaction 1");

        SimpleFeatureStore featureStore1 = (SimpleFeatureStore) dataStore

                .getFeatureSource(typeName);

        featureStore1.setTransaction(t1);

        TestFeatureListener listener1 = new TestFeatureListener();

        featureStore1.addFeatureListener(listener1);

        // verify they are all working

        assertEquals(8, origional.getCount(Query.ALL));

        assertEquals(8, featureStore1.getCount(Query.ALL));

        SimpleFeatureType schema = origional.getSchema();

        SimpleFeatureBuilder build = new SimpleFeatureBuilder(schema);

        int value = 24;

        build.add(Integer.valueOf(value));

        build.add(Short.valueOf((short) value));

        build.add(new Float(value / 10.0F));

        build.add(new Double(value / 10D));

        build.add("FEATURE_" + value);

        Calendar cal = Calendar.getInstance();

        cal.set(2004, 06, value, 0, 0, 0);

        build.add(cal);

        WKTReader reader = new WKTReader();

        build.add(reader.read("POINT(1 1)"));

        SimpleFeature newFeature = build.buildFeature(null);

        SimpleFeatureCollection newFeatures = DataUtilities.collection(newFeature);

        List<FeatureId> newFids = featureStore1.addFeatures(newFeatures);

        assertEquals(0, listener.list.size());

        assertEquals(1, listener1.list.size());

        FeatureEvent e = listener1.list.get(0);

        Id id = (Id) e.getFilter();

        assertTrue(id.getIdentifiers().containsAll(newFids));

        // remember the FeatureId with a strong reference

        FeatureId tempFeatureId = (FeatureId) id.getIdentifiers().iterator().next();

        assertTrue(newFids.contains(tempFeatureId));

        t1.commit();

        assertEquals(1, listener.list.size());

        assertEquals(2, listener1.list.size());

        BatchFeatureEvent batch = (BatchFeatureEvent) listener1.list.get(2);

        assertFalse("confirm tempFid is not in the commit",

                id.getIdentifiers().contains(tempFeatureId));

        assertNotNull(batch.getFilter());

        FeatureId featureId = (FeatureId) batch.getCreatedFeatureIds().iterator().next();

        assertSame("confirm temp feature Id was updated", tempFeatureId, featureId);

    }

    @Test

    public void testDeleteByFIDAutoCommit() throws Exception {

        testData.insertTestData();

        final DataStore ds = testData.getDataStore();

        final String typeName = testData.getTempTableName();

        final String fid;

        final Filter fidFilter;

        {

            // get a fid

            Query query = new Query(typeName);

            FeatureReader<SimpleFeatureType, SimpleFeature> reader = ds.getFeatureReader(query,

                    Transaction.AUTO_COMMIT);

            try {

                fid = reader.next().getID();

            } finally {

                reader.close();

            }

            final FilterFactory ff = CommonFactoryFinder.getFilterFactory(null);

            Set<FeatureId> ids = new HashSet<FeatureId>();

            ids.add(ff.featureId(fid));

            fidFilter = ff.id(ids);

        }

        {

            FeatureWriter<SimpleFeatureType, SimpleFeature> writer;

            writer = ds.getFeatureWriter(typeName, fidFilter, Transaction.AUTO_COMMIT);

            try {

                assertTrue(writer.hasNext());

                SimpleFeature feature = writer.next();

                assertEquals(fid, feature.getID());

                writer.remove();

                assertFalse(writer.hasNext());

            } finally {

                writer.close();

            }

        }

        ISessionPool connectionPool = testData.getConnectionPool();

        ISession session = connectionPool.getSession();

        SeQuery seQuery;

        try {

            int objectId = (int) ArcSDEAdapter.getNumericFid(fid);

            final String whereClause = "ROW_ID=" + objectId;

            seQuery = session.issue(new Command<SeQuery>() {

                @Override

                public SeQuery execute(ISession session, SeConnection connection)

                        throws SeException, IOException {

                    SeQuery seQuery = new SeQuery(connection, new String[] { "ROW_ID", "INT32_COL",

                            "STRING_COL" }, new SeSqlConstruct(typeName, whereClause));

                    seQuery.prepareQuery();

                    seQuery.execute();

                    return seQuery;

                }

            });

            SdeRow row = session.fetch(seQuery);

            assertNull(row);

        } finally {

            session.dispose();

        }

        // was it really removed?

        {

            Query query = new Query(typeName, fidFilter);

            FeatureReader<SimpleFeatureType, SimpleFeature> reader = ds.getFeatureReader(query,

                    Transaction.AUTO_COMMIT);

            try {

                assertFalse(reader.hasNext());

            } finally {

                reader.close();

            }

        }

    }

    /**

     * Tests that all the features that match a filter based on attribute only filters (aka non

     * spatial filters), are deleted correctly. This test assumes that there are no duplicate values

     * in the test data.

     *

     * @throws Exception

     */

    @Test

    public void testDeleteByAttOnlyFilter() throws Exception {

        testData.insertTestData();

        final DataStore ds = testData.getDataStore();

        final String typeName = testData.getTempTableName();

        // get 2 features and build an OR'ed PropertyIsEqualTo filter

        Filter or = CQL.toFilter("INT32_COL = 1 OR INT32_COL = 2");

        FeatureWriter<SimpleFeatureType, SimpleFeature> writer = ds.getFeatureWriter(typeName, or,

                Transaction.AUTO_COMMIT);

        try {

            assertTrue(writer.hasNext());

            SimpleFeature feature = writer.next();

            assertEquals(Integer.valueOf(1), feature.getAttribute("INT32_COL"));

            writer.remove();

            feature = writer.next();

            assertEquals(Integer.valueOf(2), feature.getAttribute("INT32_COL"));

            writer.remove();

            assertFalse(writer.hasNext());

        } finally {

            writer.close();

        }

        // was it really removed?

        FeatureReader<SimpleFeatureType, SimpleFeature> read = ds.getFeatureReader(new Query(

                typeName, or), Transaction.AUTO_COMMIT);

        try {

            assertFalse(read.hasNext());

        } finally {

            read.close();

        }

    }

    @Test

    public void testInsertAutoCommit() throws Exception {

        // the table populated here is test friendly since it can hold

        // any kind of geometries.

        testData.truncateTempTable();

        // there are some commented out just because the server I'm hitting

        // is slow, not because they don't work. Feel free to uncomment.

        testInsertAutoCommit(Geometry.class);

        testInsertAutoCommit(Point.class);

        testInsertAutoCommit(MultiPoint.class);

        testInsertAutoCommit(LineString.class);

        testInsertAutoCommit(MultiLineString.class);

        testInsertAutoCommit(Polygon.class);

        testInsertAutoCommit(MultiPolygon.class);

    }

    /**

     * Add features to a FeatureWriter with a {@link Transaction} and ensure if the transaction was

     * not committed, a request gets no features, and when the transaction is committed the query

     * returns it.

     *

     * @throws Exception

     */

    @Test

    public void testInsertTransaction() throws Exception {

        // start with an empty table

        testData.truncateTempTable();

        final String typeName = testData.getTempTableName();

        final int featureCount = 2;

        final SimpleFeatureCollection testFeatures;

        testFeatures = testData.createTestFeatures(LineString.class, featureCount);

        final DataStore ds = testData.getDataStore();

        final SimpleFeatureType ftype = testFeatures.getSchema();

        final SimpleFeatureIterator iterator = testFeatures.features();

        final Transaction transaction = new DefaultTransaction();

        final FeatureWriter<SimpleFeatureType, SimpleFeature> writer;

        writer = ds.getFeatureWriter(typeName, transaction);

        FeatureReader<SimpleFeatureType, SimpleFeature> reader;

        final Query query = new Query(typeName);

        try {

            try {

                while (iterator.hasNext()) {

                    SimpleFeature addFeature = iterator.next();

                    SimpleFeature newFeature = writer.next();

                    for (int i = 0; i < ftype.getAttributeCount(); i++) {

                        String localName = ftype.getDescriptor(i).getLocalName();

                        newFeature.setAttribute(localName, addFeature.getAttribute(localName));

                    }

                    writer.write();

                }

            } catch (Exception e) {

                transaction.rollback();

                transaction.close();

            } finally {

                writer.close();

            }

            reader = ds.getFeatureReader(query, Transaction.AUTO_COMMIT);

            boolean hasNext;

            try {

                hasNext = reader.hasNext();

            } finally {

                reader.close();

            }

            if (databaseIsMsSqlServer) {

                // SQL Server always is at READ UNCOMMITTED isolation level...

                assertTrue(hasNext);

            } else {

                assertFalse("Features added, transaction not commited", hasNext);

            }

            try {

                transaction.commit();

            } catch (Exception e) {

                transaction.rollback();

                throw e;

            }

        } finally {

            transaction.close();

        }

        try {

            reader = ds.getFeatureReader(query, Transaction.AUTO_COMMIT);

            for (int i = 0; i < featureCount; i++) {

                assertTrue(reader.hasNext());

                reader.next();

            }

            assertFalse(reader.hasNext());

        } finally {

            reader.close();

        }

    }

    @Test

    public void testInsertTransactionAndQueryByFid() throws Exception {

        // start with an empty table

        final String typeName = testData.getTempTableName();

        final int featureCount = 2;

        final SimpleFeatureCollection testFeatures;

        testFeatures = testData.createTestFeatures(LineString.class, featureCount);

        final DataStore ds = testData.getDataStore();

        final SimpleFeatureStore fStore;

        fStore = (SimpleFeatureStore) ds.getFeatureSource(typeName);

        final Transaction transaction = new DefaultTransaction("testInsertTransactionAndQueryByFid");

        fStore.setTransaction(transaction);

        try {

            final List<FeatureId> addedFids = fStore.addFeatures(testFeatures);

            final FilterFactory ff = CommonFactoryFinder.getFilterFactory(null);

            final Set<FeatureId> fids = new HashSet<FeatureId>();

            for (FeatureId fid : addedFids) {

                fids.add(fid);

            }

            final Id newFidsFilter = ff.id(fids);

            SimpleFeatureCollection features;

            features = fStore.getFeatures(newFidsFilter);

            assertEquals(2, features.size());

            transaction.commit();

        } catch (Exception e) {

            transaction.rollback();

            throw e;

        } finally {

            transaction.close();

        }

    }

    /**

     * Make sure features are validated against it's schema before being added

     */

    @Test

    public void testInsertNonNillableAttributeCheck() throws Exception {

        // start with an empty table

        testData.truncateTempTable();

        final String typeName = testData.getTempTableName();

        final int featureCount = 1;

        SimpleFeature feature;

        feature = testData.createTestFeatures(LineString.class, featureCount).features().next();

        final DataStore ds = testData.getDataStore();

        SimpleFeatureStore store = (SimpleFeatureStore) ds.getFeatureSource(typeName);

        SimpleFeatureType ftype = store.getSchema();

        assertFalse(ftype.getDescriptor("INT32_COL").isNillable());

        feature.setAttribute("INT32_COL", null);

        SimpleFeatureCollection collection = DataUtilities.collection(feature);

        try {

            store.addFeatures(collection);

            fail("Expected IAE");

        } catch (IllegalArgumentException e) {

            // note this should really be org.opengis.feature.IllegalAttributeException but

            // Types.validate throws IllegalArgumentException instead

            assertTrue(true);

        }

    }

    @Test

    public void testUpdateAutoCommit() throws Exception {

        testData.insertTestData();

        final String typeName = testData.getTempTableName();

        final DataStore ds = testData.getDataStore();

        final Filter filter = CQL.toFilter("INT32_COL = 3");

        final FeatureWriter<SimpleFeatureType, SimpleFeature> writer;

        writer = ds.getFeatureWriter(typeName, filter, Transaction.AUTO_COMMIT);

        try {

            assertTrue(writer.hasNext());

            SimpleFeature feature = writer.next();

            feature.setAttribute("INT32_COL", Integer.valueOf(-1000));

            writer.write();

            assertFalse(writer.hasNext());

        } finally {

            writer.close();

        }

        Query query = new Query(typeName, filter);

        FeatureReader<SimpleFeatureType, SimpleFeature> reader;

        reader = ds.getFeatureReader(query, Transaction.AUTO_COMMIT);

        try {

            assertFalse(reader.hasNext());

        } finally {

            reader.close();

        }

        query = new Query(typeName, CQL.toFilter("INT32_COL = -1000"));

        reader = ds.getFeatureReader(query, Transaction.AUTO_COMMIT);

        try {

            assertTrue(reader.hasNext());

            reader.next();

            assertFalse(reader.hasNext());

        } finally {

            reader.close();

        }

    }

    @Test

    public void testUpdateTransaction() throws Exception {

        testData.insertTestData();

        final String typeName = testData.getTempTableName();

        final DataStore ds = testData.getDataStore();

        final Filter oldValueFilter = CQL.toFilter("INT32_COL = 3");

        final Query oldValueQuery = new Query(typeName, oldValueFilter);

        final Filter newValueFilter = CQL.toFilter("INT32_COL = -1000");

        final Query newValueQuery = new Query(typeName, newValueFilter);

        final Transaction transaction = new DefaultTransaction("testUpdateTransaction");

        FeatureWriter<SimpleFeatureType, SimpleFeature> writer;

        writer = ds.getFeatureWriter(typeName, oldValueFilter, transaction);

        FeatureReader<SimpleFeatureType, SimpleFeature> reader;

        try {

            try {

                assertTrue(writer.hasNext());

                SimpleFeature feature = writer.next();

                feature.setAttribute("INT32_COL", Integer.valueOf(-1000));

                writer.write();

                assertFalse(writer.hasNext());

            } finally {

                writer.close();

            }

            reader = ds.getFeatureReader(oldValueQuery, Transaction.AUTO_COMMIT);

            try {

                if (databaseIsMsSqlServer) {

                    // SQL Server always is at READ UNCOMMITTED isolation level...

                    assertFalse(reader.hasNext());

                } else {

                    assertTrue(reader.hasNext());

                }

            } finally {

                reader.close();

            }

            reader = ds.getFeatureReader(newValueQuery, Transaction.AUTO_COMMIT);

            try {

                if (databaseIsMsSqlServer) {

                    // SQL Server always is at READ UNCOMMITTED isolation level...

                    assertTrue(reader.hasNext());

                } else {

                    assertFalse(reader.hasNext());

                }

            } finally {

                reader.close();

            }

            reader = ds.getFeatureReader(oldValueQuery, transaction);

            try {

                assertFalse(reader.hasNext());

            } finally {

                reader.close();

            }

            reader = ds.getFeatureReader(newValueQuery, transaction);

            try {

                assertTrue(reader.hasNext());

            } finally {

                reader.close();

            }

            try {

                transaction.commit();

            } catch (IOException e) {

                transaction.rollback();

                throw e;

            }

        } finally {

            transaction.close();

        }

        reader = ds.getFeatureReader(newValueQuery, Transaction.AUTO_COMMIT);

        try {

            assertTrue(reader.hasNext());

        } finally {

            reader.close();

        }

    }

    @Test

    @SuppressWarnings("unchecked")

    public void testModifyFeaturesTransaction() throws Exception {

        testData.insertTestData();

        final String typeName = testData.getTempTableName();

        final DataStore ds = testData.getDataStore();

        final SimpleFeatureStore store;

        store = (SimpleFeatureStore) ds.getFeatureSource(typeName);

        final SimpleFeatureType schema = store.getSchema();

        final Filter oldValueFilter = CQL.toFilter("INT32_COL = 3");

        final Filter newValueFilter = CQL.toFilter("INT32_COL = -1000");

        SimpleFeatureCollection features = store.getFeatures(oldValueFilter);

        final int initialSize = features.size();

        assertEquals(1, initialSize);// just to not go forward with bad data

        final SimpleFeature originalFeature;

        SimpleFeatureIterator iterator = features.features();

        try {

            originalFeature = iterator.next();

        } finally {

            iterator.close();

        }

        {

            final Transaction transaction = new DefaultTransaction("testModifyFeaturesTransaction");

            store.setTransaction(transaction);

            try {

                final AttributeDescriptor propDescriptor = schema.getDescriptor("INT32_COL");

                store.modifyFeatures(propDescriptor.getName(), Integer.valueOf(-1000),

                        oldValueFilter);

                transaction.commit();

            } catch (Exception e) {

                transaction.rollback();

            } finally {

                transaction.close();

            }

        }

        store.setTransaction(Transaction.AUTO_COMMIT);

        final Query oldValueQuery = new Query(typeName, oldValueFilter);

        final Query newValueQuery = new Query(typeName, newValueFilter);

        assertEquals(0, store.getCount(oldValueQuery));

        assertEquals(1, store.getCount(newValueQuery));

        final SimpleFeatureIterator newFeatures = store.getFeatures(newValueQuery).features();

        final SimpleFeature modifiedFeature;

        try {

            modifiedFeature = newFeatures.next();

        } finally {

            newFeatures.close();

        }

        // verify the non modified properties stay the same

        final List<Attribute> originalValues = (List<Attribute>) originalFeature.getValue();

        final List<Attribute> actualValues = (List<Attribute>) modifiedFeature.getValue();

        for (int i = 0; i < originalValues.size(); i++) {

            Attribute originalAtt = originalValues.get(i);

            Attribute actualAtt = actualValues.get(i);

            Name name = originalAtt.getName();

            // bah, date equals does not work, I don't care for this test

            String localName = name.getLocalPart();

            if (!"INT32_COL".equals(localName) && !"SHAPE".equals(localName)

                    && !"DATE_COL".equals(localName)) {

                assertEquals(name + " does not match", originalAtt.getValue(), actualAtt.getValue());

            }

        }

    }

    @Test

    public void testUpdateAdjacentPolygonsTransaction() throws Exception {

        final WKTReader reader = new WKTReader();

        final Polygon p1 = (Polygon) reader

                .read("POLYGON((-10 -10, -10 10, 0 10, 0 -10, -10 -10))");

        final Polygon p2 = (Polygon) reader.read("POLYGON((0 -10, 0 10, 10 10, 10 -10, 0 -10))");

        final Polygon modif1 = (Polygon) reader

                .read("POLYGON ((-10 -10, -10 10, 5 10, -5 -10, -10 -10))");

        final Polygon modif2 = (Polygon) reader

                .read("POLYGON ((-5 -10, 5 10, 10 10, 10 -10, -5 -10))");

        final String typeName = testData.getTempTableName(); // "SDE.CJ_TST_1";

        final ArcSDEDataStore dataStore = testData.getDataStore();

        // String[] typeNames = dataStore.getTypeNames();

        // System.err.println(typeNames);

        final SimpleFeatureStore store;

        store = (SimpleFeatureStore) dataStore.getFeatureSource(typeName);

        final SimpleFeatureType schema = store.getSchema();

        GeometryDescriptor defaultGeometry = schema.getGeometryDescriptor();

        String fid1;

        String fid2;

        // insert polygons p1, p2 and grab the fids for later retrieval

        {

            FeatureWriter<SimpleFeatureType, SimpleFeature> writer = dataStore

                    .getFeatureWriterAppend(typeName, Transaction.AUTO_COMMIT);

            SimpleFeature feature;

            try {

                feature = writer.next();

                // set this attribute as its the only non nillable one

                feature.setAttribute("INT32_COL", Integer.valueOf(0));

                // now set the geometry

                feature.setAttribute(defaultGeometry.getName(), p1);

                writer.write();

                fid1 = feature.getID();

                feature = writer.next();

                // set this attribute as its the only non nillable one

                feature.setAttribute("INT32_COL", Integer.valueOf(0));

                // now set the geometry

                feature.setAttribute(defaultGeometry.getName(), p2);

                writer.write();

                fid2 = feature.getID();

            } finally {

                writer.close();

            }

        }

        final Transaction transaction = new DefaultTransaction("testUpdateAdjacentPolygons");

        store.setTransaction(transaction);

        final FilterFactory ff = CommonFactoryFinder.getFilterFactory(null);

        Filter fid1Filter = ff.id(Collections.singleton(ff.featureId(fid1)));

        Filter fid2Filter = ff.id(Collections.singleton(ff.featureId(fid2)));

        try {

            store.modifyFeatures(defaultGeometry.getName(), modif2, fid2Filter);

            store.modifyFeatures(defaultGeometry.getName(), modif1, fid1Filter);

            transaction.commit();

        } catch (Exception e) {

            transaction.rollback();

            throw e;

        } finally {

            transaction.close();

        }

        store.setTransaction(Transaction.AUTO_COMMIT);

        try {

            SimpleFeatureCollection features;

            SimpleFeatureIterator iterator;

            features = store.getFeatures(fid1Filter);

            iterator = features.features();

            final SimpleFeature feature1 = iterator.next();

            iterator.close();

            features = store.getFeatures(fid2Filter);

            iterator = features.features();

            final SimpleFeature feature2 = iterator.next();

            iterator.close();

            // Note that for tables that are ambiguous about what types of geometries

            // they store (as this table is), ArcSDE will "compress" a stored geometry

            // to it's simplest representation. So in case the defaultGeometry.getBinding()

            // returns "Geometry", do instanceof checks to verify what kind of geometry

            // you're getting back

            Geometry actual1 = (Geometry) feature1.getAttribute(defaultGeometry.getLocalName());

            Geometry actual2 = (Geometry) feature2.getAttribute(defaultGeometry.getLocalName());

            System.out.println(actual1);

            System.out.println(modif1);

            // there's some rounding that goes on inside SDE. Need to do some simple buffering to

            // make sure

            // we're not getting rounding errors

            assertTrue(modif1.buffer(.01).contains(actual1));

            assertTrue(modif2.buffer(.01).contains(actual2));

        } finally {

            try {

                store.removeFeatures(fid1Filter);

                store.removeFeatures(fid2Filter);

            } catch (Exception e) {

                e.printStackTrace();

                throw e;

            }

        }

    }

    /**

     * Tests the writing of features with autocommit transaction.

     *

     */

    private void testInsertAutoCommit(Class<? extends Geometry> geometryClass) throws Exception {

        final String typeName = testData.getTempTableName();

        final int insertCount = 2;

        final SimpleFeatureCollection testFeatures;

        testFeatures = testData.createTestFeatures(geometryClass, insertCount);

        final DataStore ds = testData.getDataStore();

        final SimpleFeatureSource fsource = ds.getFeatureSource(typeName);

        // incremented on each feature added event to

        // ensure events are being raised as expected

        // (the count is wraped inside an array to be able of declaring

        // the variable as final and accessing it from inside the anonymous

        // inner class)

        /*

         * final int[] featureAddedEventCount = { 0 };

         *

         * fsource.addFeatureListener(new FeatureListener() { public void changed(FeatureEvent evt)

         * { if (evt.getEventType() != FeatureEvent.FEATURES_ADDED) { throw new

         * IllegalArgumentException( "Expected FEATURES_ADDED event, got " + evt.getEventType()); }

         *

         * ++featureAddedEventCount[0]; } });

         */

        final int initialCount = fsource.getCount(Query.ALL);

        FeatureWriter<SimpleFeatureType, SimpleFeature> writer = ds.getFeatureWriterAppend(

                typeName, Transaction.AUTO_COMMIT);

        SimpleFeature source;

        SimpleFeature dest;

        try {

            for (SimpleFeatureIterator fi = testFeatures.features(); fi.hasNext();) {

                source = fi.next();

                dest = writer.next();

                dest.setAttributes(source.getAttributes());

                writer.write();

            }

        } finally {

            writer.close();

        }

        // was the features really inserted?

        int fcount = fsource.getCount(Query.ALL);

        assertEquals(testFeatures.size() + initialCount, fcount);

        /*

         * String msg = "a FEATURES_ADDED event should have been called " + features.size() + "

         * times"; assertEquals(msg, features.size(), featureAddedEventCount[0]);

         */

    }

    @Test

    public void testWriteAndUpdateNullShapes() throws Exception {

        final String typeName = testData.getTempTableName();

        testData.truncateTempTable();

        DataStore ds = testData.getDataStore();

        SimpleFeature feature;

        FeatureWriter<SimpleFeatureType, SimpleFeature> writer;

        writer = ds.getFeatureWriter(typeName, Transaction.AUTO_COMMIT);

        try {

            feature = writer.next();

            feature.setAttribute("INT32_COL", Integer.valueOf(1000));

            writer.write();

        } finally {

            writer.close();

        }

        LOGGER.info("Wrote null-geom feature to sde");

        FeatureReader<SimpleFeatureType, SimpleFeature> reader;

        reader = ds.getFeatureReader(new Query(typeName, Filter.INCLUDE), Transaction.AUTO_COMMIT);

        // save the ID to update the feature later

        String newId;

        try {

            assertTrue(reader.hasNext());

            feature = reader.next();

            LOGGER.info("recovered geometry " + feature.getDefaultGeometry()

                    + " from single inserted feature.");

            assertNull(feature.getDefaultGeometry());

            newId = feature.getID();

            assertFalse(reader.hasNext());

        } finally {

            reader.close();

        }

        LOGGER.info("Confirmed exactly one feature in new sde layer");

        FilterFactory ff = CommonFactoryFinder.getFilterFactory(null);

        HashSet<FeatureId> ids = new HashSet<FeatureId>();

        ids.add(ff.featureId(newId));

        Filter idFilter = ff.id(ids);

        writer = ds.getFeatureWriter(typeName, idFilter, Transaction.AUTO_COMMIT);

        try {

            assertTrue(writer.hasNext());

            LOGGER.info("Confirmed feature is fetchable via it's api-determined FID");

            GeometryFactory gf = new GeometryFactory();

            int index = 10;

            Coordinate[] coords1 = { new Coordinate(0, 0), new Coordinate(++index, ++index) };

            Coordinate[] coords2 = { new Coordinate(0, index), new Coordinate(index, 0) };

            LineString[] lines = { gf.createLineString(coords1), gf.createLineString(coords2) };

            MultiLineString sampleMultiLine = gf.createMultiLineString(lines);

            SimpleFeature toBeUpdated = writer.next();

            toBeUpdated.setAttribute("SHAPE", sampleMultiLine);

            writer.write();

        } finally {

            writer.close();

        }

        LOGGER.info("Null-geom feature updated with a sample geometry.");

        Query query = new Query(testData.getTempTableName(), idFilter);

        reader = ds.getFeatureReader(query, Transaction.AUTO_COMMIT);

        try {

            assertTrue(reader.hasNext());

            feature = reader.next();

            MultiLineString recoveredMLS = (MultiLineString) feature.getDefaultGeometry();

            assertTrue(!recoveredMLS.isEmpty());

            // I tried to compare the recovered MLS to the

            // sampleMultiLineString, but they're

            // slightly different. SDE does some rounding, and winds up giving

            // me 0.0000002 for zero,

            // and 11.9992 for 12. Meh.

        } finally {

            reader.close();

        }

    }

    /**

     * Tests the writing of features with real transactions

     *

     */

    @Test

    public void testFeatureWriterTransaction() throws Exception {

        // the table populated here is test friendly since it can hold

        // any kind of geometries.

        testData.insertTestData();

        final String typeName = testData.getTempTableName();

        final DataStore ds = testData.getDataStore();

        final SimpleFeatureSource fsource = ds.getFeatureSource(typeName);

        final int initialCount = fsource.getCount(Query.ALL);

        final int writeCount = initialCount + 2;

        final SimpleFeatureCollection testFeatures = testData.createTestFeatures(LineString.class,

                writeCount);

        // incremented on each feature added event to

        // ensure events are being raised as expected

        // (the count is wraped inside an array to be able of declaring

        // the variable as final and accessing it from inside the anonymous

        // inner class)

        // final int[] featureAddedEventCount = { 0 };

        final Transaction transaction = new DefaultTransaction();

        final FeatureWriter<SimpleFeatureType, SimpleFeature> writer = ds.getFeatureWriter(

                typeName, Filter.INCLUDE, transaction);

        SimpleFeature source;

        SimpleFeature dest;

        int count = 0;

        try {

            for (SimpleFeatureIterator fi = testFeatures.features(); fi.hasNext(); count++) {

                if (count < initialCount) {

                    assertTrue("at index " + count, writer.hasNext());

                } else {

                    assertFalse("at index " + count, writer.hasNext());

                }

                source = fi.next();

                dest = writer.next();

                dest.setAttributes(source.getAttributes());

                writer.write();

            }

            transaction.commit();

        } catch (Exception e) {

            transaction.rollback();

            throw e;

        } finally {

            writer.close();

            transaction.close();

        }

        // was the features really inserted?

        int fcount = fsource.getCount(Query.ALL);

        assertEquals(writeCount, fcount);

        /*

         * String msg = "a FEATURES_ADDED event should have been called " + features.size() + "

         * times"; assertEquals(msg, features.size(), featureAddedEventCount[0]);

         */

    }

    @Test

    public void testFeatureWriterAppend() throws Exception {

        // the table populated here is test friendly since it can hold

        // any kind of geometries.

        testData.insertTestData();

        final String typeName = testData.getTempTableName();

        final SimpleFeatureCollection testFeatures = testData.createTestFeatures(LineString.class,

                2);

        final DataStore ds = testData.getDataStore();

        final SimpleFeatureSource fsource = ds.getFeatureSource(typeName);

        final int initialCount = fsource.getCount(Query.ALL);

        final FeatureWriter<SimpleFeatureType, SimpleFeature> writer = ds.getFeatureWriterAppend(

                typeName, Transaction.AUTO_COMMIT);

        SimpleFeature source;

        SimpleFeature dest;

        for (SimpleFeatureIterator fi = testFeatures.features(); fi.hasNext();) {

            assertFalse(writer.hasNext());

            source = fi.next();

            dest = writer.next();

            dest.setAttributes(source.getAttributes());

            writer.write();

        }

        writer.close();

        // were the features really inserted?

        int fcount = fsource.getCount(Query.ALL);

        assertEquals(testFeatures.size() + initialCount, fcount);

    }

    /**

     * Ensure modified features for a given FeatureStore are returned by subsequent queries even if

     * the transaction has not been committed.

     *

     * @throws Exception

     */

    @Test

    public void testTransactionStateDiff() throws Exception {

        testData.createTempTable(true);

        // testData.insertTestData();

        final DataStore ds = testData.getDataStore();

        final String typeName = testData.getTempTableName();

        final SimpleFeatureStore transFs;

        transFs = (SimpleFeatureStore) ds.getFeatureSource(typeName);

        final SimpleFeatureType schema = transFs.getSchema();

        // once the transaction is set to the FeatureStore, it lasts until

        // another transaction

        // is set. Calling transaction.close() closes Transaction.State

        // held on it, allowing State objects to release resources. After

        // close() the transaction

        // is no longer valid.

        final Transaction transaction = new DefaultTransaction("test_handle");

        transFs.setTransaction(transaction);

        try {

            // create a feature to add

            SimpleFeatureBuilder builder = new SimpleFeatureBuilder(schema);

            builder.set("INT32_COL", Integer.valueOf(1000));

            builder.set("STRING_COL", "inside transaction");

            SimpleFeature feature = builder.buildFeature(null);

            // add the feature

            transFs.addFeatures(DataUtilities.collection(feature));

            // now confirm for that transaction the feature is fetched, and outside

            // it it's not.

            final Filter filterNewFeature = CQL.toFilter("INT32_COL = 1000");

            final Query newFeatureQuery = new Query(typeName, filterNewFeature);

            SimpleFeatureCollection features;

            features = transFs.getFeatures(filterNewFeature);

            int size = features.size();

            assertEquals(1, size);

            // ok transaction respected, assert the feature does not exist outside

            // it (except is the db is MS SQL Server)

            {

                FeatureReader<SimpleFeatureType, SimpleFeature> autoCommitReader;

                autoCommitReader = ds.getFeatureReader(newFeatureQuery, Transaction.AUTO_COMMIT);

                try {

                    if (databaseIsMsSqlServer) {

                        // SQL Server always is at READ UNCOMMITTED isolation level...

                        assertTrue(autoCommitReader.hasNext());

                    } else {

                        assertFalse(autoCommitReader.hasNext());

                    }

                } finally {

                    autoCommitReader.close();

                }

            }

            // ok, but what if we ask for a feature reader with the same transaction

            {

                FeatureReader<SimpleFeatureType, SimpleFeature> transactionReader;

                transactionReader = ds.getFeatureReader(newFeatureQuery, transaction);

                try {

                    assertTrue(transactionReader.hasNext());

                    transactionReader.next();

                    assertFalse(transactionReader.hasNext());

                } finally {

                    transactionReader.close();

                }

            }

            // now commit, and Transaction.AUTO_COMMIT should carry it over

            // do not close the transaction, we'll keep using it

            try {

                transaction.commit();

            } catch (IOException e) {

                transaction.rollback();

                throw e;

            }

            {

                FeatureReader<SimpleFeatureType, SimpleFeature> autoCommitReader;

                autoCommitReader = ds.getFeatureReader(newFeatureQuery, Transaction.AUTO_COMMIT);

                try {

                    assertTrue(autoCommitReader.hasNext());

                } finally {

                    autoCommitReader.close();