/branches/v2_0_0_prep/libraries/libFMap_dal/src-test/org/gvsig/fmap/dal/feature/BaseTestEditableFeatureStore.java - Diff - Application: gvSIG desktop - gvSIG

Revision 27723 branches/v2_0_0_prep/libraries/libFMap_dal/src-test/org/gvsig/fmap/dal/feature/BaseTestEditableFeatureStore.java

     import org.gvsig.fmap.dal.DataTypes;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.exception.RemoveException;
     import org.gvsig.fmap.dal.exception.ValidateDataParametersException;
     import org.gvsig.fmap.dal.feature.exception.ConcurrentDataModificationException;
     import org.gvsig.fmap.dal.feature.testediting.DeleteFirstAndLastFeature;
     import org.gvsig.fmap.dal.feature.testediting.DeleteLastFeature;
-...
     public abstract class BaseTestEditableFeatureStore extends BaseTestFeatureStore {
     	public abstract NewFeatureStoreParameters getDefaultNewDataStoreParameters()
     			throws DataException;
     			throws Exception;
     	public abstract boolean usesResources();
-...
+    	}
     	protected FeatureStore getStoreCopy(FeatureStore source,
     			NewFeatureStoreParameters targetParams) throws DataException {
     			NewFeatureStoreParameters targetParams) throws DataException,
     			ValidateDataParametersException {
     		DataServerExplorer explorer = source.getExplorer();
     		source.export(explorer, targetParams);
     		FeatureStore result = (FeatureStore) dataManager
-...
+    	}
     	protected void clearCopy(FeatureStore source,
     			NewFeatureStoreParameters targetParams) throws DataException,
     			RemoveException {
     			NewFeatureStoreParameters targetParams) throws Exception {
     		DataServerExplorer explorer = source.getExplorer();
     		explorer.remove(targetParams);
-...
     	public void testExport() {
     	public void testExport() throws Exception {
     		DataStoreParameters parameters = null;
     		try {
     			parameters = getDefaultDataStoreParameters();
-...
     			this.clearCopy(store, newParams);
     			store.dispose();
     		} catch (DataException e3) {
     			e3.printStackTrace();
     			fail();
     			return;
+    		}
+    	}
     	public void testRemove() {
     	public void testRemove() throws Exception {
     		DataStoreParameters parameters = null;
     		try {
     			parameters = getDefaultDataStoreParameters();
     			FeatureStore store = (FeatureStore) dataManager
-...
     			this.clearCopy(store, newParams);
     			store.dispose();
     		} catch (DataException e3) {
     			e3.printStackTrace();
     			fail();
     			return;
+    		}
+    	}
     	public void testInsert() {
     	public void testInsert() throws Exception {
     		DataStoreParameters parameters = null;
     		try {
     			parameters = getDefaultDataStoreParameters();
     		parameters = getDefaultDataStoreParameters();
     			FeatureStore store = (FeatureStore) dataManager
     					.createStore(parameters);
     		FeatureStore store = (FeatureStore) dataManager
     		.createStore(parameters);
     			NewFeatureStoreParameters newParams = this
     					.getDefaultNewDataStoreParameters();
     			try {
     				this.clearCopy(store, newParams);
     			} catch (RemoveException e) {
     				//Do nothing
+    			}
     		NewFeatureStoreParameters newParams = this
     		.getDefaultNewDataStoreParameters();
     		try {
     			this.clearCopy(store, newParams);
     		} catch (RemoveException e) {
     			//Do nothing
+    		}
     			FeatureStore result = this.getStoreCopy(store, newParams);
     		FeatureStore result = this.getStoreCopy(store, newParams);
     			result.edit(FeatureStore.MODE_FULLEDIT);
     		result.edit(FeatureStore.MODE_FULLEDIT);
     			FeatureSet set = result.getFeatureSet();
     			FeatureSet originalSet = store.getFeatureSet();
     			assertEquals(set.getSize(), originalSet.getSize());
     		FeatureSet set = result.getFeatureSet();
     		FeatureSet originalSet = store.getFeatureSet();
     		assertEquals(set.getSize(), originalSet.getSize());
     			set.insert(result.createNewFeature(true));
     			DisposableIterator originalIter = originalSet.iterator();
     			DisposableIterator iter = set.iterator();
     			int i = 0;
     			while (originalIter.hasNext()) {
     				assertTrue("" + i, compareFeatures((Feature) originalIter
     						.next(), (Feature) iter.next()));
     				i++;
+    			}
     			assertTrue(iter.hasNext());
     			assertNotNull(iter.next());
     			assertFalse(iter.hasNext());
     		set.insert(result.createNewFeature(true));
     		DisposableIterator originalIter = originalSet.iterator();
     		DisposableIterator iter = set.iterator();
     		int i = 0;
     		while (originalIter.hasNext()) {
     			assertTrue("" + i, compareFeatures((Feature) originalIter
     					.next(), (Feature) iter.next()));
     			i++;
+    		}
     		assertTrue(iter.hasNext());
     		assertNotNull(iter.next());
     		assertFalse(iter.hasNext());
     			assertEquals(originalSet.getSize() + 1, set.getSize());
     		assertEquals(originalSet.getSize() + 1, set.getSize());
     			iter.dispose();
     			originalIter.dispose();
     		iter.dispose();
     		originalIter.dispose();
     			originalIter = originalSet.iterator();
     			iter = set.iterator();
     			i = 0;
     			while (originalIter.hasNext()) {
     				assertTrue("" + i, compareFeatures((Feature) originalIter
     						.next(), (Feature) iter.next()));
     				i++;
+    			}
     			assertTrue(iter.hasNext());
     			assertNotNull(iter.next());
     		originalIter = originalSet.iterator();
     		iter = set.iterator();
     		i = 0;
     		while (originalIter.hasNext()) {
     			assertTrue("" + i, compareFeatures((Feature) originalIter
     					.next(), (Feature) iter.next()));
     			i++;
+    		}
     		assertTrue(iter.hasNext());
     		assertNotNull(iter.next());
     			set.insert(result.createNewFeature(true));
     		set.insert(result.createNewFeature(true));
     			assertEquals(originalSet.getSize() + 2, set.getSize());
     		assertEquals(originalSet.getSize() + 2, set.getSize());
     			iter.dispose();
     			originalIter.dispose();
     		iter.dispose();
     		originalIter.dispose();
     			set.dispose();
     		set.dispose();
     			result.finishEditing();
     		result.finishEditing();
     			set = result.getFeatureSet();
     			assertEquals(originalSet.getSize() + 2, set.getSize());
     		set = result.getFeatureSet();
     		assertEquals(originalSet.getSize() + 2, set.getSize());
     			originalIter = originalSet.iterator();
     			iter = set.iterator();
     			i = 0;
     			while (originalIter.hasNext()) {
     				assertTrue("" + i, compareFeatures((Feature) originalIter
     						.next(), (Feature) iter.next()));
     				i++;
+    			}
     		originalIter = originalSet.iterator();
     		iter = set.iterator();
     		i = 0;
     		while (originalIter.hasNext()) {
     			assertTrue("" + i, compareFeatures((Feature) originalIter
     					.next(), (Feature) iter.next()));
     			i++;
+    		}
     			assertNotNull(iter.next());
     			assertNotNull(iter.next());
     			assertFalse(iter.hasNext());
     		assertNotNull(iter.next());
     		assertNotNull(iter.next());
     		assertFalse(iter.hasNext());
     			iter.dispose();
     			originalIter.dispose();
     		iter.dispose();
     		originalIter.dispose();
     			set.dispose();
     			originalSet.dispose();
     		set.dispose();
     		originalSet.dispose();
     			result.dispose();
     			this.clearCopy(store, newParams);
     			store.dispose();
     		result.dispose();
     		this.clearCopy(store, newParams);
     		store.dispose();
     		} catch (DataException e3) {
     			e3.printStackTrace();
     			fail();
     			return;
+    		}
+    	}
     	public void testConcurrentRemove() {
     	public void testConcurrentRemove() throws Exception {
     		DataStoreParameters parameters = null;
     		try {
     			parameters = getDefaultDataStoreParameters();
     		parameters = getDefaultDataStoreParameters();
     			FeatureStore store = (FeatureStore) dataManager
     					.createStore(parameters);
     		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);
     			NewFeatureStoreParameters newParams = this
     					.getDefaultNewDataStoreParameters();
     			try {
     				this.clearCopy(store, newParams);
     			} catch (RemoveException e) {
     				//Dp nothing
+    			}
     		NewFeatureStoreParameters newParams = this
     				.getDefaultNewDataStoreParameters();
     		try {
     			this.clearCopy(store, newParams);
     		} catch (RemoveException e) {
     			// Dp nothing
+    		}
     			FeatureStore result = this.getStoreCopy(store, newParams);
     		FeatureStore result = this.getStoreCopy(store, newParams);
     			result.edit(FeatureStore.MODE_FULLEDIT);
     		result.edit(FeatureStore.MODE_FULLEDIT);
     			DeleteFirstAndLastFeature deleteFeature = new DeleteFirstAndLastFeature(
     					"1", result, EditStore.TIME_TO_WAIT_NO_WAIT);
     		DeleteFirstAndLastFeature deleteFeature = new DeleteFirstAndLastFeature(
     				"1", result, EditStore.TIME_TO_WAIT_NO_WAIT);
     			FeatureSet set = result.getFeatureSet();
     		FeatureSet set = result.getFeatureSet();
     			DisposableIterator iter = set.iterator();
     			assertTrue(iter.hasNext());
     			assertNotNull(iter.next());
     		DisposableIterator iter = set.iterator();
     		assertTrue(iter.hasNext());
     		assertNotNull(iter.next());
     			deleteFeature.start();
     		deleteFeature.start();
     			while (deleteFeature.getCurrentStatus() <= EditStore.STATUS_RUNING) {
     				Thread.yield();
     				Thread.sleep(100);
     				if (deleteFeature.isOutOfDate()) {
     					break;
+    				}
     		while (deleteFeature.getCurrentStatus() <= EditStore.STATUS_RUNING) {
     			Thread.yield();
     			Thread.sleep(100);
     			if (deleteFeature.isOutOfDate()) {
     				break;
+    			}
+    		}
     			assertEquals(deleteFeature.getCurrentStatus(),
     					EditStore.STATUS_FINISHED_OK);
     		assertEquals(deleteFeature.getCurrentStatus(),
     				EditStore.STATUS_FINISHED_OK);
     			Exception ex = null;
     			try {
     				iter.next();
     			} catch (Exception e) {
     				ex = e;
+    			}
     			assertNotNull(ex);
     			assertEquals(ConcurrentDataModificationException.class, ex
     					.getClass());
     		Exception ex = null;
     		try {
     			iter.next();
     		} catch (Exception e) {
     			ex = e;
+    		}
     		assertNotNull(ex);
     		assertEquals(ConcurrentDataModificationException.class, ex.getClass());
     			ex = null;
     			try {
     				set.getSize();
     			} catch (Exception e) {
     				ex = e;
+    			}
     			assertNotNull(ex);
     			assertEquals(ConcurrentDataModificationException.class, ex
     					.getClass());
     		ex = null;
     		try {
     			set.getSize();
     		} catch (Exception e) {
     			ex = e;
+    		}
     		assertNotNull(ex);
     		assertEquals(ConcurrentDataModificationException.class, ex.getClass());
     			iter.dispose();
     			result.dispose();
     			this.clearCopy(store, newParams);
     			store.dispose();
     		iter.dispose();
     		result.dispose();
     		this.clearCopy(store, newParams);
     		store.dispose();
     		} catch (DataException e3) {
     			e3.printStackTrace();
     			fail();
     			return;
     		} catch (InterruptedException e) {
     			e.printStackTrace();
     			fail();
     			return;
+    		}
+    	}
     	public void testConcurrentInsert() {
     	public void testConcurrentInsert() throws Exception{
     		DataStoreParameters parameters = null;
     		try {
     			parameters = getDefaultDataStoreParameters();
     		parameters = getDefaultDataStoreParameters();
     			FeatureStore store = (FeatureStore) dataManager
     					.createStore(parameters);
     		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);
     			NewFeatureStoreParameters newParams = this
     					.getDefaultNewDataStoreParameters();
     			try {
     				this.clearCopy(store, newParams);
     			} catch (RemoveException e) {
     				//Dp nothing
+    			}
     		NewFeatureStoreParameters newParams = this
     				.getDefaultNewDataStoreParameters();
     		try {
     			this.clearCopy(store, newParams);
     		} catch (RemoveException e) {
     			// Dp nothing
+    		}
     			FeatureStore result = this.getStoreCopy(store, newParams);
     		FeatureStore result = this.getStoreCopy(store, newParams);
     			result.edit(FeatureStore.MODE_FULLEDIT);
     		result.edit(FeatureStore.MODE_FULLEDIT);
     			InsertFeature insertFeature = new InsertFeature("1", result,
     					EditStore.TIME_TO_WAIT_NO_WAIT);
     		InsertFeature insertFeature = new InsertFeature("1", result,
     				EditStore.TIME_TO_WAIT_NO_WAIT);
     			FeatureSet set = result.getFeatureSet();
     		FeatureSet set = result.getFeatureSet();
     			DisposableIterator iter = set.iterator();
     			assertTrue(iter.hasNext());
     			assertNotNull(iter.next());
     		DisposableIterator iter = set.iterator();
     		assertTrue(iter.hasNext());
     		assertNotNull(iter.next());
     			insertFeature.start();
     		insertFeature.start();
     			while (insertFeature.getCurrentStatus() <= EditStore.STATUS_RUNING) {
     				Thread.yield();
     				Thread.sleep(100);
     				if (insertFeature.isOutOfDate()) {
     					break;
+    				}
     		while (insertFeature.getCurrentStatus() <= EditStore.STATUS_RUNING) {
     			Thread.yield();
     			Thread.sleep(100);
     			if (insertFeature.isOutOfDate()) {
     				break;
+    			}
+    		}
     			assertEquals(EditStore.STATUS_FINISHED_OK, insertFeature
     					.getCurrentStatus());
     		assertEquals(EditStore.STATUS_FINISHED_OK, insertFeature
     				.getCurrentStatus());
     			Exception ex = null;
     			try {
     				iter.next();
     			} catch (Exception e) {
     				ex = e;
+    			}
     			assertNotNull(ex);
     			assertEquals(ConcurrentDataModificationException.class, ex
     					.getClass());
     		Exception ex = null;
     		try {
     			iter.next();
     		} catch (Exception e) {
     			ex = e;
+    		}
     		assertNotNull(ex);
     		assertEquals(ConcurrentDataModificationException.class, ex.getClass());
     			ex = null;
     			try {
     				set.getSize();
     			} catch (Exception e) {
     				ex = e;
+    			}
     			assertNotNull(ex);
     			assertEquals(ConcurrentDataModificationException.class, ex
     					.getClass());
     			iter.dispose();
     			result.dispose();
     			this.clearCopy(store, newParams);
     			store.dispose();
     		} catch (DataException e3) {
     			e3.printStackTrace();
     			fail();
     			return;
     		} catch (InterruptedException e) {
     			e.printStackTrace();
     			fail();
     			return;
     		ex = null;
     		try {
     			set.getSize();
     		} catch (Exception e) {
     			ex = e;
+    		}
     		assertNotNull(ex);
     		assertEquals(ConcurrentDataModificationException.class, ex.getClass());
     		iter.dispose();
     		result.dispose();
     		this.clearCopy(store, newParams);
     		store.dispose();
+    	}
     	public void testConcurrentUpdate() {
     	public void testConcurrentUpdate() throws Exception {
     		DataStoreParameters parameters = null;
     		try {
     			parameters = getDefaultDataStoreParameters();
     		parameters = getDefaultDataStoreParameters();
     			FeatureStore store = (FeatureStore) dataManager
     					.createStore(parameters);
     		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);
     			NewFeatureStoreParameters newParams = this
     					.getDefaultNewDataStoreParameters();
     			try {
     				this.clearCopy(store, newParams);
     			} catch (RemoveException e) {
     				//Dp nothing
+    			}
     		NewFeatureStoreParameters newParams = this
     				.getDefaultNewDataStoreParameters();
     		try {
     			this.clearCopy(store, newParams);
     		} catch (RemoveException e) {
     			// Dp nothing
+    		}
     			FeatureStore result = this.getStoreCopy(store, newParams);
     		FeatureStore result = this.getStoreCopy(store, newParams);
     			result.edit(FeatureStore.MODE_FULLEDIT);
     		result.edit(FeatureStore.MODE_FULLEDIT);
     			UpdateFeature updateFeature = new UpdateFeature("1", result,
     					EditStore.TIME_TO_WAIT_NO_WAIT);
     		UpdateFeature updateFeature = new UpdateFeature("1", result,
     				EditStore.TIME_TO_WAIT_NO_WAIT);
     			updateFeature.addUpdate(UpdateFeature.UPDATE_ALL_FEATURES,
     					"OTRO_IDIOM", "XXX");
     		updateFeature.addUpdate(UpdateFeature.UPDATE_ALL_FEATURES,
     				"OTRO_IDIOM", "XXX");
     			FeatureSet set = result.getFeatureSet();
     		FeatureSet set = result.getFeatureSet();
     			DisposableIterator iter = set.iterator();
     			assertTrue(iter.hasNext());
     			assertNotNull(iter.next());
     		DisposableIterator iter = set.iterator();
     		assertTrue(iter.hasNext());
     		assertNotNull(iter.next());
     			updateFeature.start();
     		updateFeature.start();
     			while (updateFeature.getCurrentStatus() <= EditStore.STATUS_RUNING) {
     				Thread.yield();
     				Thread.sleep(100);
     				if (updateFeature.isOutOfDate()) {
     					break;
+    				}
     		while (updateFeature.getCurrentStatus() <= EditStore.STATUS_RUNING) {
     			Thread.yield();
     			Thread.sleep(100);
     			if (updateFeature.isOutOfDate()) {
     				break;
+    			}
+    		}
     			assertEquals(EditStore.STATUS_FINISHED_OK, updateFeature
     					.getCurrentStatus());
     		assertEquals(EditStore.STATUS_FINISHED_OK, updateFeature
     				.getCurrentStatus());
     			Exception ex = null;
     			try {
     				iter.next();
     			} catch (Exception e) {
     				ex = e;
+    			}
     			assertNotNull(ex);
     			assertEquals(ConcurrentDataModificationException.class, ex
     					.getClass());
     		Exception ex = null;
     		try {
     			iter.next();
     		} catch (Exception e) {
     			ex = e;
+    		}
     		assertNotNull(ex);
     		assertEquals(ConcurrentDataModificationException.class, ex.getClass());
     			ex = null;
     			try {
     				set.getSize();
     			} catch (Exception e) {
     				ex = e;
+    			}
     			assertNotNull(ex);
     			assertEquals(ConcurrentDataModificationException.class, ex
     					.getClass());
     		ex = null;
     		try {
     			set.getSize();
     		} catch (Exception e) {
     			ex = e;
+    		}
     		assertNotNull(ex);
     		assertEquals(ConcurrentDataModificationException.class, ex.getClass());
     			iter.dispose();
     			result.dispose();
     			this.clearCopy(store, newParams);
     			store.dispose();
     		iter.dispose();
     		result.dispose();
     		this.clearCopy(store, newParams);
     		store.dispose();
     		} catch (DataException e3) {
     			e3.printStackTrace();
     			fail();
     			return;
     		} catch (InterruptedException e) {
     			e.printStackTrace();
     			fail();
     			return;
+    		}
+    	}
     	public void testSequencedRemove() {
     	public void testSequencedRemove() throws Exception {
     		DataStoreParameters parameters = null;
     		int ntimes = 3;
     		try {
     			parameters = getDefaultDataStoreParameters();
     		parameters = getDefaultDataStoreParameters();
     			FeatureStore store = (FeatureStore) dataManager
     					.createStore(parameters);
     		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);
     			NewFeatureStoreParameters newParams = this
     					.getDefaultNewDataStoreParameters();
     			try {
     				this.clearCopy(store, newParams);
     			} catch (RemoveException e) {
     				//Dp nothing
+    			}
     		NewFeatureStoreParameters newParams = this
     				.getDefaultNewDataStoreParameters();
     		try {
     			this.clearCopy(store, newParams);
     		} catch (RemoveException e) {
     			// Dp nothing
+    		}
     			FeatureStore result = this.getStoreCopy(store, newParams);
     		FeatureStore result = this.getStoreCopy(store, newParams);
     			result.edit(FeatureStore.MODE_FULLEDIT);
     		result.edit(FeatureStore.MODE_FULLEDIT);
     			DeleteLastFeature[] deletesFeature = new DeleteLastFeature[ntimes];
     			int i;
     			for (i = 0; i < deletesFeature.length; i++) {
     				deletesFeature[i] = new DeleteLastFeature("DeleteLastFeature:"
     						+ i, result, 300 * i);
+    			}
     		DeleteLastFeature[] deletesFeature = new DeleteLastFeature[ntimes];
     		int i;
     		for (i = 0; i < deletesFeature.length; i++) {
     			deletesFeature[i] = new DeleteLastFeature("DeleteLastFeature:" + i,
     					result, 300 * i);
+    		}
     			for (i = 0; i < deletesFeature.length; i++) {
     				deletesFeature[i].start();
+    			}
     		for (i = 0; i < deletesFeature.length; i++) {
     			deletesFeature[i].start();
+    		}
     			try {
     				for (int x = 0; x < (deletesFeature.length + 2); x++) {
     					Thread.yield();
     					Thread.sleep(500);
+    				}
     			} catch (InterruptedException e) {
     				e.printStackTrace();
     				result.dispose();
     				fail();
     				return;
     		try {
     			for (int x = 0; x < (deletesFeature.length + 2); x++) {
     				Thread.yield();
     				Thread.sleep(500);
+    			}
     			boolean testAll = false;
     			boolean restart;
     			DeleteLastFeature item;
     			while (!testAll) {
     				restart = false;
     				for (i = 0; i < deletesFeature.length; i++) {
     					item = deletesFeature[i];
     					if (item.getCurrentStatus() <= EditStore.STATUS_RUNING) {
     						if (item.isOutOfDate()) {
     							result.dispose();
     							fail("OutOfDate: " + i);
     							return;
+    						}
     						try {
     							Thread.yield();
     							Thread.sleep(400);
     						} catch (InterruptedException e) {
     							e.printStackTrace();
     							result.dispose();
     							fail();
     							return;
+    						}
     						restart = true;
     						break;
     					} else if (item.getCurrentStatus() == EditStore.STATUS_ERROR) {
     						item.getException().printStackTrace();
     		} catch (InterruptedException e) {
     			e.printStackTrace();
     			result.dispose();
     			fail();
     			return;
+    		}
     		boolean testAll = false;
     		boolean restart;
     		DeleteLastFeature item;
     		while (!testAll) {
     			restart = false;
     			for (i = 0; i < deletesFeature.length; i++) {
     				item = deletesFeature[i];
     				if (item.getCurrentStatus() <= EditStore.STATUS_RUNING) {
     					if (item.isOutOfDate()) {
     						result.dispose();
     						fail("ERROR: " + i);
     						fail("OutOfDate: " + i);
     						return;
     					} else if (item.getCurrentStatus() != EditStore.STATUS_FINISHED_OK) {
     						item.getException().printStackTrace();
+    					}
     					try {
     						Thread.yield();
     						Thread.sleep(400);
     					} catch (InterruptedException e) {
     						e.printStackTrace();
     						result.dispose();
     						fail("Data ERROR: " + i);
     						fail();
     						return;
+    					}
     					restart = true;
     					break;
     				} else if (item.getCurrentStatus() == EditStore.STATUS_ERROR) {
     					item.getException().printStackTrace();
     					result.dispose();
     					fail("ERROR: " + i);
     					return;
     				} else if (item.getCurrentStatus() != EditStore.STATUS_FINISHED_OK) {
     					item.getException().printStackTrace();
     					result.dispose();
     					fail("Data ERROR: " + i);
     					return;
+    				}
     				if (restart) {
     					continue;
+    				}
     				testAll = true;
+    			}
     			FeatureSet set = result.getFeatureSet();
     			FeatureSet originalSet = store.getFeatureSet();
     			assertEquals(originalSet.getSize() - deletesFeature.length, set
     					.getSize());
     			DisposableIterator originalIter = originalSet.iterator();
     			DisposableIterator iter = set.iterator();
     			i = 0;
     			while (iter.hasNext()) {
     				assertTrue("" + i, compareFeatures((Feature) originalIter
     						.next(), (Feature) iter.next()));
     				i++;
     			if (restart) {
     				continue;
+    			}
     			testAll = true;
+    		}
     			originalIter.dispose();
     			iter.dispose();
     		FeatureSet set = result.getFeatureSet();
     		FeatureSet originalSet = store.getFeatureSet();
     		assertEquals(originalSet.getSize() - deletesFeature.length, set
     				.getSize());
     			set.dispose();
     		DisposableIterator originalIter = originalSet.iterator();
     		DisposableIterator iter = set.iterator();
     			result.finishEditing();
     		i = 0;
     		while (iter.hasNext()) {
     			assertTrue("" + i, compareFeatures((Feature) originalIter.next(),
     					(Feature) iter.next()));
     			i++;
+    		}
     			set = result.getFeatureSet();
     			assertEquals(originalSet.getSize() - deletesFeature.length, set
     					.getSize());
     		originalIter.dispose();
     		iter.dispose();
     			originalIter = originalSet.iterator();
     			iter = set.iterator();
     			i = 0;
     			while (iter.hasNext()) {
     				assertTrue("" + i, compareFeatures((Feature) originalIter
     						.next(), (Feature) iter.next()));
     				i++;
+    			}
     		set.dispose();
     		result.finishEditing();
     			originalIter.dispose();
     			iter.dispose();
     		set = result.getFeatureSet();
     		assertEquals(originalSet.getSize() - deletesFeature.length, set
     				.getSize());
     			set.dispose();
     			originalSet.dispose();
     		originalIter = originalSet.iterator();
     		iter = set.iterator();
     		i = 0;
     		while (iter.hasNext()) {
     			assertTrue("" + i, compareFeatures((Feature) originalIter.next(),
     					(Feature) iter.next()));
     			i++;
+    		}
     			result.dispose();
     			this.clearCopy(store, newParams);
     			store.dispose();
     		} catch (DataException e3) {
     			e3.printStackTrace();
     			fail();
     			return;
+    		}
     		originalIter.dispose();
     		iter.dispose();
     		set.dispose();
     		originalSet.dispose();
     		result.dispose();
     		this.clearCopy(store, newParams);
     		store.dispose();
+    	}
     	public void testSequencedInsert() {
     	public void testSequencedInsert() throws Exception {
     		DataStoreParameters parameters = null;
     		int ntimes = 3;
     		try {
     			parameters = getDefaultDataStoreParameters();
     		parameters = getDefaultDataStoreParameters();
     			FeatureStore store = (FeatureStore) dataManager
     					.createStore(parameters);
     		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);
     			NewFeatureStoreParameters newParams = this
     					.getDefaultNewDataStoreParameters();
     			try {
     				this.clearCopy(store, newParams);
     			} catch (RemoveException e) {
     				//Dp nothing
+    			}
     		NewFeatureStoreParameters newParams = this
     				.getDefaultNewDataStoreParameters();
     		try {
     			this.clearCopy(store, newParams);
     		} catch (RemoveException e) {
     			// Dp nothing
+    		}
     			FeatureStore result = this.getStoreCopy(store, newParams);
     		FeatureStore result = this.getStoreCopy(store, newParams);
     			result.edit(FeatureStore.MODE_FULLEDIT);
     		result.edit(FeatureStore.MODE_FULLEDIT);
     			InsertFeature[] insertsFeature = new InsertFeature[ntimes];
     			int i;
     			for (i = 0; i < insertsFeature.length; i++) {
     				insertsFeature[i] = new InsertFeature("InsertFeature:" + i,
     						result, 300 * i);
+    			}
     		InsertFeature[] insertsFeature = new InsertFeature[ntimes];
     		int i;
     		for (i = 0; i < insertsFeature.length; i++) {
     			insertsFeature[i] = new InsertFeature("InsertFeature:" + i, result,
 * i);
+    		}
     			for (i = 0; i < insertsFeature.length; i++) {
     				insertsFeature[i].start();
+    			}
     		for (i = 0; i < insertsFeature.length; i++) {
     			insertsFeature[i].start();
+    		}
     			try {
     		try {
     				for (int x = 0; x < (insertsFeature.length + 2); x++) {
     					Thread.yield();
     					Thread.sleep(500);
+    				}
     			} catch (InterruptedException e) {
     				e.printStackTrace();
     				result.dispose();
     				fail();
     				return;
     			for (int x = 0; x < (insertsFeature.length + 2); x++) {
     				Thread.yield();
     				Thread.sleep(500);
+    			}
     			boolean testAll = false;
     			boolean restart;
     			InsertFeature item;
     			while (!testAll) {
     				restart = false;
     				for (i = 0; i < insertsFeature.length; i++) {
     					item = insertsFeature[i];
     					if (item.getCurrentStatus() <= EditStore.STATUS_RUNING) {
     						if (item.isOutOfDate()) {
     							result.dispose();
     							fail("OutOfDate: " + i);
     							return;
+    						}
     						try {
     							Thread.yield();
     							Thread.sleep(400);
     						} catch (InterruptedException e) {
     							e.printStackTrace();
     							result.dispose();
     							fail();
     							return;
+    						}
     						restart = true;
     						break;
     					} else if (item.getCurrentStatus() == EditStore.STATUS_ERROR) {
     						item.getException().printStackTrace();
     		} catch (InterruptedException e) {
     			e.printStackTrace();
     			result.dispose();
     			fail();
     			return;
+    		}
     		boolean testAll = false;
     		boolean restart;
     		InsertFeature item;
     		while (!testAll) {
     			restart = false;
     			for (i = 0; i < insertsFeature.length; i++) {
     				item = insertsFeature[i];
     				if (item.getCurrentStatus() <= EditStore.STATUS_RUNING) {
     					if (item.isOutOfDate()) {
     						result.dispose();
     						fail("ERROR: " + i);
     						fail("OutOfDate: " + i);
     						return;
     					} else if (item.getCurrentStatus() == EditStore.STATUS_FINISHED_NO_OK) {
+    					}
     					try {
     						Thread.yield();
     						Thread.sleep(400);
     					} catch (InterruptedException e) {
     						e.printStackTrace();
     						result.dispose();
     						fail("No OK: " + i);
     						fail();
     						return;
     					} else if (item.getCurrentStatus() != EditStore.STATUS_FINISHED_OK) {
     						item.getException().printStackTrace();
     						result.dispose();
     						fail("Data ERROR: " + i);
     						return;
+    					}
     					restart = true;
     					break;
     				} else if (item.getCurrentStatus() == EditStore.STATUS_ERROR) {
     					item.getException().printStackTrace();
     					result.dispose();
     					fail("ERROR: " + i);
     					return;
     				} else if (item.getCurrentStatus() == EditStore.STATUS_FINISHED_NO_OK) {
     					result.dispose();
     					fail("No OK: " + i);
     					return;
     				} else if (item.getCurrentStatus() != EditStore.STATUS_FINISHED_OK) {
     					item.getException().printStackTrace();
     					result.dispose();
     					fail("Data ERROR: " + i);
     					return;
+    				}
     				if (restart) {
     					continue;
+    				}
     				testAll = true;
+    			}
     			FeatureSet set = result.getFeatureSet();
     			FeatureSet originalSet = store.getFeatureSet();
     			assertEquals(originalSet.getSize() + insertsFeature.length, set
     					.getSize());
     			DisposableIterator originalIter = originalSet.iterator();
     			DisposableIterator iter = set.iterator();
     			i = 0;
     			while (originalIter.hasNext()) {
     				assertTrue("" + i, compareFeatures((Feature) originalIter
     						.next(), (Feature) iter.next()));
     				i++;
     			if (restart) {
     				continue;
+    			}
     			for (; i < insertsFeature.length; i++) {
     				iter.next();
+    			}
     			testAll = true;
+    		}
     		FeatureSet set = result.getFeatureSet();
     		FeatureSet originalSet = store.getFeatureSet();
     		assertEquals(originalSet.getSize() + insertsFeature.length, set
     				.getSize());
     			originalIter.dispose();
     			iter.dispose();
     		DisposableIterator originalIter = originalSet.iterator();
     		DisposableIterator iter = set.iterator();
     			set.dispose();
     		i = 0;
     		while (originalIter.hasNext()) {
     			assertTrue("" + i, compareFeatures((Feature) originalIter.next(),
     					(Feature) iter.next()));
     			i++;
+    		}
     		for (; i < insertsFeature.length; i++) {
     			iter.next();
+    		}
     			result.finishEditing();
     			set = result.getFeatureSet();
     			assertEquals(originalSet.getSize() + insertsFeature.length, set
     					.getSize());
     		originalIter.dispose();
     		iter.dispose();
     			originalIter = originalSet.iterator();
     			iter = set.iterator();
     			i = 0;
     			while (originalIter.hasNext()) {
     				assertTrue("" + i, compareFeatures((Feature) originalIter
     						.next(), (Feature) iter.next()));
     				i++;
+    			}
     			for (; i < insertsFeature.length; i++) {
     				iter.next();
+    			}
     		set.dispose();
     			set.dispose();
     			originalSet.dispose();
     		result.finishEditing();
     			result.dispose();
     			this.clearCopy(store, newParams);
     			store.dispose();
     		set = result.getFeatureSet();
     		assertEquals(originalSet.getSize() + insertsFeature.length, set
     				.getSize());
     		} catch (DataException e3) {
     			e3.printStackTrace();
     			fail();
     			return;
     		originalIter = originalSet.iterator();
     		iter = set.iterator();
     		i = 0;
     		while (originalIter.hasNext()) {
     			assertTrue("" + i, compareFeatures((Feature) originalIter.next(),
     					(Feature) iter.next()));
     			i++;
+    		}
     		for (; i < insertsFeature.length; i++) {
     			iter.next();
+    		}
     		set.dispose();
     		originalSet.dispose();
     		result.dispose();
     		this.clearCopy(store, newParams);
     		store.dispose();
+    	}
     	public void testUpdate() {
     	public void testUpdate() throws Exception {
     		DataStoreParameters parameters = null;
     		try {
     			parameters = getDefaultDataStoreParameters();
     		parameters = getDefaultDataStoreParameters();
     			FeatureStore store = (FeatureStore) dataManager
     					.createStore(parameters);
     		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);
     			NewFeatureStoreParameters newParams = this
     					.getDefaultNewDataStoreParameters();
     			try {
     				this.clearCopy(store, newParams);
     			} catch (RemoveException e) {
     				//Dp nothing
+    			}
     		NewFeatureStoreParameters newParams = this
     				.getDefaultNewDataStoreParameters();
     		try {
     			this.clearCopy(store, newParams);
     		} catch (RemoveException e) {
     			// Dp nothing
+    		}
     			FeatureStore result = this.getStoreCopy(store, newParams);
     		FeatureStore result = this.getStoreCopy(store, newParams);
     			result.edit(FeatureStore.MODE_FULLEDIT);
     		result.edit(FeatureStore.MODE_FULLEDIT);
     			FeatureSet set = result.getFeatureSet();
     			long size = set.getSize();
     		FeatureSet set = result.getFeatureSet();
     		long size = set.getSize();
     			set.dispose();
     		set.dispose();
     			UpdateFeature updater = new UpdateFeature("1", result,
     					UpdateFeature.TIME_TO_WAIT_NO_WAIT);
     			FeatureAttributeDescriptor attr = getFirstAttributeOfType(result.getDefaultFeatureType(), DataTypes.STRING);
     			assertNotNull("No String attributes found", attr);
     		UpdateFeature updater = new UpdateFeature("1", result,
     				UpdateFeature.TIME_TO_WAIT_NO_WAIT);
     		FeatureAttributeDescriptor attr = getFirstAttributeOfType(result
     				.getDefaultFeatureType(), DataTypes.STRING);
     		assertNotNull("No String attributes found", attr);
     			updater.addUpdate(UpdateFeature.UPDATE_ALL_FEATURES,
     					attr.getName(), getEvaluatorToLower(attr.getName()));
     		updater.addUpdate(UpdateFeature.UPDATE_ALL_FEATURES, attr.getName(),
     				getEvaluatorToLower(attr.getName()));
     			updater.run();
     			while (updater.getCurrentStatus() < EditStore.STATUS_FINISHED_OK
     					&& !updater.isOutOfDate()) {
     				Thread.yield();
     				try {
     					Thread.sleep(200);
     				} catch (InterruptedException e) {
     					e.printStackTrace();
     					fail();
+    				}
     		updater.run();
     		while (updater.getCurrentStatus() < EditStore.STATUS_FINISHED_OK
     				&& !updater.isOutOfDate()) {
     			Thread.yield();
     			try {
     				Thread.sleep(200);
     			} catch (InterruptedException e) {
     				e.printStackTrace();
     				fail();
+    			}
     			set = result.getFeatureSet();
     			DisposableIterator iter = set.iterator();
+    		}
     		set = result.getFeatureSet();
     		DisposableIterator iter = set.iterator();
     			printFeatureTypeColNames(set.getDefaultFeatureType(), 15);
     			Feature f;
     			while (iter.hasNext()) {
     				f = (Feature) iter.next();
     				this.printFeature(f,false, 15);
+    			}
     		printFeatureTypeColNames(set.getDefaultFeatureType(), 15);
     		Feature f;
     		while (iter.hasNext()) {
     			f = (Feature) iter.next();
     			this.printFeature(f, false, 15);
+    		}
     			iter.dispose();
     		iter.dispose();
     			FeatureSet originalSet = store.getFeatureSet();
     		FeatureSet originalSet = store.getFeatureSet();
     			DisposableIterator originalIter = originalSet.iterator();
     		DisposableIterator originalIter = originalSet.iterator();
     			iter = set.iterator();
     		iter = set.iterator();
     			long i = 0;
     			while (originalIter.hasNext()) {
     				try {
     					assertTrue("" + i, compareFeatures((Feature) originalIter
     							.next(), (Feature) iter.next(), updater, i, size));
     				} catch (EvaluatorException e) {
     					e.printStackTrace();
     					fail();
+    				}
     				i++;
     		long i = 0;
     		while (originalIter.hasNext()) {
     			try {
     				assertTrue("" + i, compareFeatures((Feature) originalIter
     						.next(), (Feature) iter.next(), updater, i, size));
     			} catch (EvaluatorException e) {
     				e.printStackTrace();
     				fail();
+    			}
     			iter.dispose();
     			originalIter.dispose();
     			i++;
+    		}
     		iter.dispose();
     		originalIter.dispose();
     			set.dispose();
     		set.dispose();
     			result.finishEditing();
     		result.finishEditing();
     			set = result.getFeatureSet();
     			assertEquals(originalSet.getSize(), set.getSize());
     		set = result.getFeatureSet();
     		assertEquals(originalSet.getSize(), set.getSize());
     			originalIter = originalSet.iterator();
     			iter = set.iterator();
     			i = 0;
     			while (originalIter.hasNext()) {
     				try {
     					assertTrue("" + i, compareFeatures((Feature) originalIter
     							.next(), (Feature) iter.next(), updater, i, size));
     				} catch (EvaluatorException e) {
     					e.printStackTrace();
     					fail();
+    				}
     				i++;
     		originalIter = originalSet.iterator();
     		iter = set.iterator();
     		i = 0;
     		while (originalIter.hasNext()) {
     			try {
     				assertTrue("" + i, compareFeatures((Feature) originalIter
     						.next(), (Feature) iter.next(), updater, i, size));
     			} catch (EvaluatorException e) {
     				e.printStackTrace();
     				fail();
+    			}
     			i++;
+    		}
     			iter.dispose();
     			originalIter.dispose();
     			set.dispose();
     		iter.dispose();
     		originalIter.dispose();
     		set.dispose();
     			updater = new UpdateFeature("1", result,
     					UpdateFeature.TIME_TO_WAIT_NO_WAIT);
     		updater = new UpdateFeature("1", result,
     				UpdateFeature.TIME_TO_WAIT_NO_WAIT);
     			updater.addUpdate(UpdateFeature.UPDATE_ALL_FEATURES,
     					attr.getName(), getEvaluatorToLower(attr.getName()));
     		updater.addUpdate(UpdateFeature.UPDATE_ALL_FEATURES, attr.getName(),
     				getEvaluatorToLower(attr.getName()));
     			updater.run();
     			while (updater.getCurrentStatus() < EditStore.STATUS_FINISHED_OK
     					&& !updater.isOutOfDate()) {
     				Thread.yield();
     				try {
     					Thread.sleep(200);
     				} catch (InterruptedException e) {
     					e.printStackTrace();
     					fail();
+    				}
     		updater.run();
     		while (updater.getCurrentStatus() < EditStore.STATUS_FINISHED_OK
     				&& !updater.isOutOfDate()) {
     			Thread.yield();
     			try {
     				Thread.sleep(200);
     			} catch (InterruptedException e) {
     				e.printStackTrace();
     				fail();
+    			}
     			set = result.getFeatureSet();
+    		}
     		set = result.getFeatureSet();
     			iter = set.iterator();
     			originalIter = originalSet.iterator();
     			i = 0;
     			while (originalIter.hasNext()) {
     				try {
     					assertTrue("" + i, compareFeatures((Feature) originalIter
     							.next(), (Feature) iter.next(), updater, i, size));
     				} catch (EvaluatorException e) {
     					e.printStackTrace();
     					fail();
+    				}
     				i++;
     		iter = set.iterator();
     		originalIter = originalSet.iterator();
     		i = 0;
     		while (originalIter.hasNext()) {
     			try {
     				assertTrue("" + i, compareFeatures((Feature) originalIter
     						.next(), (Feature) iter.next(), updater, i, size));
     			} catch (EvaluatorException e) {
     				e.printStackTrace();
     				fail();
+    			}
     			i++;
+    		}
     			iter.dispose();
     			originalIter.dispose();
     			set.dispose();
     		iter.dispose();
     		originalIter.dispose();
     		set.dispose();
     			originalSet.dispose();
     		originalSet.dispose();
     			result.dispose();
     			this.clearCopy(store, newParams);
     			store.dispose();
     		result.dispose();
     		this.clearCopy(store, newParams);
     		store.dispose();
     		} catch (DataException e3) {
     			e3.printStackTrace();
     			fail();
     			return;
+    		}
+    	}
     	public void testResourceChangeNotification() {
     	public void testResourceChangeNotification() throws Exception{
     		DataStoreParameters parameters = null;
     		try {
     			parameters = getDefaultDataStoreParameters();
     		parameters = getDefaultDataStoreParameters();
     			FeatureStore store = (FeatureStore) dataManager
     					.createStore(parameters);
     		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);
     			NewFeatureStoreParameters newParams = this
     					.getDefaultNewDataStoreParameters();
     			try {
     				this.clearCopy(store, newParams);
     			} catch (RemoveException e) {
     				//Dp nothing
+    			}
     		NewFeatureStoreParameters newParams = this
     				.getDefaultNewDataStoreParameters();
     		try {
     			this.clearCopy(store, newParams);
     		} catch (RemoveException e) {
     			// Dp nothing
+    		}
     			FeatureStore result = this.getStoreCopy(store, newParams);
     		FeatureStore result = this.getStoreCopy(store, newParams);
     			FeatureStore result2 = (FeatureStore) dataManager
     		FeatureStore result2 = (FeatureStore) dataManager
     				.createStore(newParams);
     			FeatureAttributeDescriptor attr = getFirstAttributeOfType(result.getDefaultFeatureType(), DataTypes.STRING);
     			assertNotNull("No String attributes found", attr);
     		FeatureAttributeDescriptor attr = getFirstAttributeOfType(result
     				.getDefaultFeatureType(), DataTypes.STRING);
     		assertNotNull("No String attributes found", attr);
     			UpdateFeature updater = new UpdateFeature("1", result,
     					UpdateFeature.TIME_TO_WAIT_NO_WAIT);
     		UpdateFeature updater = new UpdateFeature("1", result,
     				UpdateFeature.TIME_TO_WAIT_NO_WAIT);
     			updater.addUpdate(UpdateFeature.UPDATE_LAST_FEATURE,
     					attr.getName(), getEvaluatorToLower(attr.getName()));
     		updater.addUpdate(UpdateFeature.UPDATE_LAST_FEATURE, attr.getName(),
     				getEvaluatorToLower(attr.getName()));
     			StoreObserverForNotify observer = new StoreObserverForNotify(result2,FeatureStoreNotification.RESOURCE_CHANGED);
     			result2.addObserver(observer);
     		StoreObserverForNotify observer = new StoreObserverForNotify(result2,
     				FeatureStoreNotification.RESOURCE_CHANGED);
     		result2.addObserver(observer);
     			result.edit();
     			updater.run();
     			while (updater.getCurrentStatus() < EditStore.STATUS_FINISHED_OK
     					&& !updater.isOutOfDate()) {
     				Thread.yield();
     				try {
     					Thread.sleep(200);
     				} catch (InterruptedException e) {
     					e.printStackTrace();
     					fail();
+    				}
     		result.edit();
     		updater.run();
     		while (updater.getCurrentStatus() < EditStore.STATUS_FINISHED_OK
     				&& !updater.isOutOfDate()) {
     			Thread.yield();
     			try {
     				Thread.sleep(200);
     			} catch (InterruptedException e) {
     				e.printStackTrace();
     				fail();
+    			}
+    		}

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff