mifdatastoretest.java

.mif .mid file read and write

    /**
     */
    public void testFeatureReaderFilter() {
        initDS("grafo"); // .mif

        try {
             FeatureReader<SimpleFeatureType, SimpleFeature> fr = getFeatureReader("grafo", "ID = 33755");
            SimpleFeature arc = null;
            Integer id = new Integer(0);

            if (fr.hasNext()) {
                arc = fr.next();
                id = (Integer) arc.getAttribute("ID");
            }

            assertNotNull(arc);
            assertEquals(id.intValue(), 33755);
            fr.close();
        } catch (Exception e) {
            fail(e.getMessage());
        }
    }

    /**
     * Tests createSchema & FeatureWriter
     */
    public void testFeatureWriter() {
        initDS("");

        String outmif = "grafo_new";

        try {
            SimpleFeatureType newFT = MIFTestUtils.duplicateSchema(ds.getSchema(
                        "grafo"), outmif);
            ds.createSchema(newFT);

            int maxAttr = newFT.getAttributeCount() - 1;

            FeatureWriter<SimpleFeatureType, SimpleFeature> fw = ds.getFeatureWriterAppend(outmif,
                    Transaction.AUTO_COMMIT);
            SimpleFeature f;
             FeatureReader<SimpleFeatureType, SimpleFeature> fr = getFeatureReader("grafo",
                    "ID == 73690 || ID == 71045");

            int counter = 0;

            while (fr.hasNext()) {
                ++counter;

                SimpleFeature fin = fr.next();
                f = fw.next();

                for (int i = 0; i <= maxAttr; i++) {
                    f.setAttribute(i, fin.getAttribute(i));
                }

                fw.write();
            }

            fr.close();
            fw.close();

            assertEquals(counter, 2);

            fw = ds.getFeatureWriter(outmif,
                    MIFTestUtils.parseFilter("ID == 71045"),
                    Transaction.AUTO_COMMIT);

            assertEquals(true, fw.hasNext());
            f = fw.next();
            fw.remove();

            fw.close();

            fw = ds.getFeatureWriterAppend(outmif, Transaction.AUTO_COMMIT);

            f = fw.next();
            f.setAttribute("ID", "99998");
            f.setAttribute("NOMECOMUNE", "foobar");
            fw.write();

            fw.close();

            fr = getFeatureReader(outmif);

            counter = 0;

            while (fr.hasNext()) {
                f = fr.next();
                counter++;
            }

            fr.close();
            assertEquals(counter, 2);
        } catch (Exception e) {
            fail(e.getMessage());
        }
    }

    /**
     * Tests createSchema & FeatureWriter
     */
    public void testFeatureWriterAppendTransaction() {
        try {
            String outmif = "grafo_append";
            MIFTestUtils.copyMif("grafo", outmif);
            initDS(outmif);

            SimpleFeature f;
            Transaction transaction = new DefaultTransaction("mif");

            try {
                FeatureWriter<SimpleFeatureType, SimpleFeature> fw = ds.getFeatureWriterAppend(outmif, transaction);

                f = fw.next();
                f = fw.next();
                f.setAttribute("ID", "80001");
                f.setAttribute("NOMECOMUNE", "foo");
                fw.write();

                f = fw.next();
                f.setAttribute("ID", "80002");
                f.setAttribute("NOMECOMUNE", "bar");
                fw.write();

                fw.close();

                transaction.commit();
            } catch (Exception e) {
            	e.printStackTrace();
                transaction.rollback();
                fail(e.getMessage());
            } finally {
                transaction.close();
            }

             FeatureReader<SimpleFeatureType, SimpleFeature> fr = getFeatureReader(outmif,
                    "ID > 80000 && ID <80003");

            int counter = 0;

            while (fr.hasNext()) {
                f = fr.next();
                counter++;
            }

            fr.close();

            assertEquals(counter, 2);
        } catch (Exception e) {
        	e.printStackTrace();
            fail(e.getMessage());
        }
    }

    /**
     * DOCUMENT ME!
     */
    public void testFeatureSource() {
        String outmif = "mixed_fs";

        try {
            MIFTestUtils.copyMif("mixed", outmif);
        } catch (IOException e) {
            fail(e.getMessage());
        }

        initDS(outmif);

        FeatureSource<SimpleFeatureType, SimpleFeature> fs = null;
        SimpleFeatureType featureType = null;

        try {
            featureType = ds.getSchema(outmif);
            assertNotNull("Cannot get FeatureType", featureType);
        } catch (Exception e) {
            fail("Cannot get FeatureType: " + e.getMessage());
        }

        try {
            fs = ds.getFeatureSource(outmif);
            assertNotNull("Cannot get FeatureSource.", fs);
        } catch (IOException e) {
            fail("Cannot get FeatureSource: " + e.getMessage());
        }

        try {
            ((FeatureStore<SimpleFeatureType, SimpleFeature>) fs).modifyFeatures(featureType.getAttribute(
                    "DESCRIPTION"), "FOO", Filter.INCLUDE);
        } catch (Exception e) {
            fail("Cannot update Features: " + e.getMessage());
        }

        try {
            ((FeatureStore<SimpleFeatureType, SimpleFeature>) fs).removeFeatures(MIFTestUtils.parseFilter(
                    "GEOMTYPE != 'NULL'"));
        } catch (IOException e) {
            fail("Cannot delete Features: " + e.getMessage());
        }

        try {
             FeatureReader<SimpleFeatureType, SimpleFeature> fr = getFeatureReader(outmif);

            assertEquals(true, fr.hasNext());

            SimpleFeature f = fr.next();
            assertEquals("FOO", f.getAttribute("DESCRIPTION"));
            assertEquals(false, fr.hasNext());

            fr.close();
        } catch (Exception e) {
            fail("Cannot check feature: " + e.getMessage());
        }
    }

    /**
     * Test that feature get the correct SRID
     */
    public void testSRID() {
        initDS("");

         FeatureReader<SimpleFeatureType, SimpleFeature> fr;

        try {
            fr = getFeatureReader("grafo");

            SimpleFeature f = fr.next();
            assertEquals(((Geometry) f.getDefaultGeometry()).getFactory().getSRID(),
                MIFTestUtils.SRID);

            fr.close();
        } catch (Exception e) {
            fail("Cannot check SRID: " + e.getMessage());
        }
    }

    /**
     * Obtain a feature reader for the given featureType / filter
     *
     * @param featureTypeName
     * @param filter
     *
     *
     * @throws Exception
     */
    protected  FeatureReader<SimpleFeatureType, SimpleFeature> getFeatureReader(String featureTypeName,
        String filter) throws Exception {
        DefaultQuery q = new DefaultQuery(featureTypeName,
                MIFTestUtils.parseFilter(filter));

        return ds.getFeatureReader(q, Transaction.AUTO_COMMIT);
    }

    /**
     * Obtain a feature reader for all the features of the given featureType
     *
     * @param featureTypeName
     *
     *
     * @throws Exception
     */
    protected  FeatureReader<SimpleFeatureType, SimpleFeature> getFeatureReader(String featureTypeName)
        throws Exception {
        return getFeatureReader(featureTypeName, "1=1");
    }
}