public void testGetFeatureReader() throws IOException { FeatureReader<SimpleFeatureType, SimpleFeature> reader = data.getFeatureSource("road").getReader(); assertCovered(roadFeatures, reader); assertEquals(false, reader.hasNext()); }
public void testGetFeatureSourceRiver() throws NoSuchElementException, IOException { SimpleFeatureSource river = data.getFeatureSource("river"); assertSame(riverType, river.getSchema()); assertSame(data, river.getDataStore()); SimpleFeatureCollection all = river.getFeatures(); assertEquals(2, all.size()); assertEquals(riverBounds, all.getBounds()); assertTrue("rivers", covers(all.features(), riverFeatures)); SimpleFeatureCollection expected = DataUtilities.collection(riverFeatures); assertCovers("all", expected, all); assertEquals(riverBounds, all.getBounds()); }
public void testGetFeatureWriter() throws NoSuchElementException, IOException { FeatureWriter<SimpleFeatureType, SimpleFeature> writer = data.getFeatureWriter("road", Transaction.AUTO_COMMIT); assertEquals(roadFeatures.length, count(writer)); assertFalse(writer.hasNext()); try { writer.next(); fail("Should not be able to use a closed writer"); } catch (IOException expected) { } }
public void testGetFeatureTypes() throws IOException { String[] names = data.getTypeNames(); assertEquals(2, names.length); assertTrue(contains(names, "road")); assertTrue(contains(names, "river")); }
public void testGetFeatureWriterFilter() throws NoSuchElementException, IOException { FeatureWriter<SimpleFeatureType, SimpleFeature> writer; writer = data.getFeatureWriter("road", Filter.EXCLUDE, Transaction.AUTO_COMMIT); assertEquals(0, count(writer)); writer = data.getFeatureWriter("road", Filter.INCLUDE, Transaction.AUTO_COMMIT); assertEquals(roadFeatures.length, count(writer)); writer = data.getFeatureWriter("road", rd1Filter, Transaction.AUTO_COMMIT); assertEquals(1, count(writer)); }
public void testMemoryDataStore() throws Exception { DataStore store = new MemoryDataStore(); assertNotNull(store); String[] typeNames = store.getTypeNames(); assertNotNull(typeNames); assertEquals(0, typeNames.length); }
public void testGetFeatureReaderFilterAutoCommit() throws NoSuchElementException, IOException { SimpleFeatureType type = data.getSchema("road"); FeatureReader<SimpleFeatureType, SimpleFeature> reader; reader = data.getFeatureReader(new Query("road"), Transaction.AUTO_COMMIT); assertFalse(reader instanceof FilteringFeatureReader); assertEquals(type, reader.getFeatureType()); assertEquals(roadFeatures.length, count(reader)); reader = data.getFeatureReader(new Query("road", Filter.EXCLUDE), Transaction.AUTO_COMMIT); assertEquals(type, reader.getFeatureType()); assertEquals(0, count(reader)); reader = data.getFeatureReader(new Query("road", rd1Filter), Transaction.AUTO_COMMIT); assertTrue(reader instanceof FilteringFeatureReader); assertEquals(type, reader.getFeatureType()); assertEquals(1, count(reader)); }
assertFalse(isLocked("road", "road.rd1")); assertFalse(isLocked("road", "road.rd2")); assertFalse(isLocked("road", "road.rd3")); assertTrue(isLocked("road", "road.rd1")); assertFalse(isLocked("road", "road.rd2")); assertFalse(isLocked("road", "road.rd3")); assertTrue(isLocked("road", "road.rd1")); assertTrue(isLocked("road", "road.rd2")); assertFalse(isLocked("road", "road.rd3")); fail("need authorization"); } catch (IOException expected) { try { road1.unLockFeatures(rd2Filter); fail("need correct authorization"); } catch (IOException expected) { assertFalse(isLocked("road", "road.rd1")); assertTrue(isLocked("road", "road.rd2")); assertFalse(isLocked("road", "road.rd3")); assertFalse(isLocked("road", "road.rd1")); assertFalse(isLocked("road", "road.rd2")); assertFalse(isLocked("road", "road.rd3")); } finally { t1.close();
assertTrue(covers(reader, ORIGIONAL)); assertEquals("road.rd1", feature.getID()); writer1.remove(); assertTrue(covers(reader, ORIGIONAL)); reader = data.getFeatureReader(new Query("road"), t1); assertTrue(covers(reader, REMOVE)); assertTrue(covers(reader, ORIGIONAL)); reader = data.getFeatureReader(new Query("road"), t1); assertTrue(covers(reader, REMOVE)); assertTrue(covers(reader, ORIGIONAL)); reader = data.getFeatureReader(new Query("road"), t2); assertTrue(coversLax(reader, ADD)); assertTrue(covers(reader, ORIGIONAL)); reader = data.getFeatureReader(new Query("road"), t2); assertTrue(coversLax(reader, ADD)); assertTrue(covers(reader, REMOVE)); reader = data.getFeatureReader(new Query("road"), t1); assertTrue(covers(reader, REMOVE)); reader = data.getFeatureReader(new Query("road"), t2); assertTrue(coversLax(reader, FINAL)); assertTrue(coversLax(reader, FINAL)); reader = data.getFeatureReader(new Query("road"), t1);
public void testFixture() throws Exception { SimpleFeatureType type = DataUtilities.createType( "namespace.typename", "name:String,id:0,geom:MultiLineString"); assertEquals("namespace", "namespace", type.getName().getNamespaceURI()); assertEquals("typename", "typename", type.getTypeName()); assertEquals("attributes", 3, type.getAttributeCount()); assertEquals("a1", "name", type.getDescriptor(0).getLocalName()); assertEquals("a1", String.class, type.getDescriptor(0).getType().getBinding()); assertEquals("a2", "id", type.getDescriptor(1).getLocalName()); assertEquals("a2", Integer.class, type.getDescriptor(1).getType().getBinding()); assertEquals("a3", "geom", type.getDescriptor(2).getLocalName()); assertEquals("a3", MultiLineString.class, type.getDescriptor(2).getType().getBinding()); }
public void testGetFeatureLockingExpire() throws Exception { FeatureLock lock = new FeatureLock("Timed", 500); @SuppressWarnings("unchecked") FeatureLocking<SimpleFeatureType, SimpleFeature> road = (FeatureLocking<SimpleFeatureType, SimpleFeature>) data.getFeatureSource("road"); road.setFeatureLock(lock); assertFalse(isLocked("road", "road.rd1")); road.lockFeatures(rd1Filter); assertTrue(isLocked("road", "road.rd1")); long then = System.currentTimeMillis(); do { Thread.sleep(15); } while (then > System.currentTimeMillis() - 515); assertFalse(isLocked("road", "road.rd1")); }
public void testRemoveTypeThatDoesntExistsGracefulWithoutIOException() throws IOException { // two featureTypes should be in List<Name> names = data.getNames(); assertNotNull(names); assertEquals(2, names.size()); try { data.removeSchema("typeThatDoesntExists"); } catch (IOException e) { fail("remove Schema should act gracfully if it has never been created for that type"); } // still the same size and no IOException List<Name> namesAfterRemove = data.getNames(); assertNotNull(namesAfterRemove); assertEquals(2, namesAfterRemove.size()); }
void assertCovers(String msg, SimpleFeatureCollection c1, SimpleFeatureCollection c2) { if (c1 == c2) { return; } assertNotNull(msg, c1); assertNotNull(msg, c2); assertEquals(msg + " size", c1.size(), c2.size()); SimpleFeature f; for (SimpleFeatureIterator i = c1.features(); i.hasNext(); ) { f = i.next(); assertTrue(msg + " " + f.getID(), c2.contains(f)); } }
public void testMemoryDataStoreAddFeatures() throws Exception { MemoryDataStore store = new MemoryDataStore(); assertNotNull(store); store.addFeatures(DataUtilities.collection(roadFeatures)); assertStoreHasFeatureType(store, "road"); SimpleFeatureSource featureSource = store.getFeatureSource("road"); SimpleFeatureCollection features = featureSource.getFeatures(); int size = features.size(); assertEquals(roadFeatures.length, size); } /*
assertEquals(type, reader.getFeatureType()); assertEquals(0, count(reader)); assertTrue(reader instanceof DiffFeatureReader); assertEquals(type, reader.getFeatureType()); assertEquals(roadFeatures.length, count(reader)); assertEquals(type, reader.getFeatureType()); assertEquals(1, count(reader)); assertEquals(0, count(reader)); assertEquals(roadFeatures.length - 1, count(reader)); assertEquals(0, count(reader)); assertEquals(0, count(reader)); assertEquals(roadFeatures.length, count(reader)); assertEquals(1, count(reader));
assertSame(roadType, road.getSchema()); assertSame(data, road.getDataStore()); assertEquals(3, road.getCount(Query.ALL)); assertEquals(new ReferencedEnvelope(1, 5, 0, 4, null), road.getBounds(Query.ALL)); assertEquals(3, all.size()); assertEquals(roadBounds, all.getBounds()); assertCovers("all", expected, all); assertEquals(roadBounds, all.getBounds()); assertEquals(2, some.size()); assertEquals(rd12Bounds, some.getBounds()); assertEquals(some.getSchema(), road.getSchema()); assertEquals(2, half.size()); assertEquals(2, half.getSchema().getAttributeCount()); SimpleFeatureIterator reader = half.features(); SimpleFeatureType type = half.getSchema(); assertEquals(type.getTypeName(), actual.getTypeName()); assertEquals(type.getName(), actual.getName()); assertEquals(type.getAttributeCount(), actual.getAttributeCount()); for (int i = 0; i < type.getAttributeCount(); i++) { assertEquals(type.getDescriptor(i), actual.getDescriptor(i)); assertEquals(type.getGeometryDescriptor(), actual.getGeometryDescriptor()); assertEquals(type, actual); Envelope b = half.getBounds();
assertTrue(contains(roadFeatures, reader1.next())); assertTrue(contains(roadFeatures, reader2.next())); assertTrue(contains(riverFeatures, reader3.next())); fail("next should fail with an IOException"); } catch (IOException expected) { fail("next should fail with an IOException"); } catch (IOException expected) { fail("next should fail with an IOException"); } catch (IOException expected) {
assertTrue(covers(road.getFeatures().features(), ORIGIONAL)); assertTrue(covers(road.getFeatures().features(), ORIGIONAL)); assertTrue(covers(road1.getFeatures().features(), REMOVE)); assertTrue(covers(road.getFeatures().features(), ORIGIONAL)); assertTrue(covers(road1.getFeatures().features(), REMOVE)); assertTrue(coversLax(road2.getFeatures().features(), ADD)); assertTrue(covers(road.getFeatures().features(), REMOVE)); assertTrue(covers(road1.getFeatures().features(), REMOVE)); assertTrue(coversLax(road2.getFeatures().features(), FINAL)); assertTrue(coversLax(road.getFeatures().features(), FINAL)); assertTrue(coversLax(road1.getFeatures().features(), FINAL)); assertTrue(coversLax(road2.getFeatures().features(), FINAL));
public void testOrderPreservationMemFetures() throws Exception { SimpleFeature[] dynFeatures = new SimpleFeature[3]; dynFeatures[0] = SimpleFeatureBuilder.build( roadType, new Object[] { Integer.valueOf(1), line(new int[] {1, 1, 2, 2, 4, 2, 5, 1}), "r1" }, null); dynFeatures[1] = SimpleFeatureBuilder.build( roadType, new Object[] { Integer.valueOf(2), line(new int[] {3, 0, 3, 2, 3, 3, 3, 4}), "r2" }, null); dynFeatures[2] = SimpleFeatureBuilder.build( roadType, new Object[] {Integer.valueOf(3), line(new int[] {3, 2, 4, 2, 5, 3}), "r3"}, null); assertOrderSame(dynFeatures); }
public void testGetFeaturesWriterAdd() throws IOException { FeatureWriter<SimpleFeatureType, SimpleFeature> writer = data.getFeatureWriter("road", Transaction.AUTO_COMMIT); SimpleFeature feature; while (writer.hasNext()) { feature = (SimpleFeature) writer.next(); } assertFalse(writer.hasNext()); feature = (SimpleFeature) writer.next(); feature.setAttributes(newRoad.getAttributes()); writer.write(); assertFalse(writer.hasNext()); assertEquals(roadFeatures.length + 1, data.entry("road").getMemory().size()); }