Application: gvSIG desktop

package org.gvsig.fmap.dal;

import junit.framework.Test;

import junit.framework.TestCase;

import junit.framework.TestSuite;

import org.gvsig.fmap.dal.commands.CommandTest;

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

public class AllTests extends TestCase{

	public static Test suite() {

		TestSuite suite = new TestSuite("Test for libDataSource");

		//$JUnit-BEGIN$

		suite.addTestSuite(CommandTest.class);

		suite.addTestSuite(DataStoreTest.class);

		suite.addTestSuite(FeatureTest.class);

		//$JUnit-END$

		return suite;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

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

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

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program 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 General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2010 {}  {{Task}}

 */

package org.gvsig.fmap.dal.feature.paging.impl;

import junit.framework.TestCase;

import org.gvsig.tools.paging.PagingCalculator.Sizeable;

/**

 * Unit tests for the {@link OneSubsetOneSetPagingCalculator} class.

 * 

 * @author gvSIG team

 */

public class OneSubsetOneSetPagingCalculatorTest extends

 TestCase {

	private static final int MAX_PAGE_SIZE = 4;

	private TestSizeable sizeable1 = new TestSizeable(6);

	private TestSizeable sizeable2 = new TestSizeable(17);

	private OneSubsetOneSetPagingCalculator calculator;

	protected void setUp() throws Exception {

		super.setUp();

		calculator =

            new OneSubsetOneSetPagingCalculator(sizeable1, sizeable2,

                MAX_PAGE_SIZE);

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getFirstSetSize()}

	 * .

	 */

	public void testGetFirstSetSize() {

		assertEquals(sizeable1.getSize(), calculator.getFirstSetSize());

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getSecondSetSize()}

	 * .

	 */

	public void testGetSecondSetSize() {

		assertEquals(sizeable2.getSize() - sizeable1.getSize(), calculator.getSecondSetSize());

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getFirstSetInitialIndex()}

	 * .

	 */

	public void testGetFirstSetInitialIndex() {

		calculator.setCurrentPage(0);

		assertEquals(0, calculator.getFirstSetInitialIndex());

		calculator.setCurrentPage(1);

		assertEquals(0 + MAX_PAGE_SIZE, calculator.getFirstSetInitialIndex());

		calculator.setCurrentPage(2);

		assertEquals(-1, calculator.getFirstSetInitialIndex());

		calculator.setCurrentPage(3);

		assertEquals(-1, calculator.getFirstSetInitialIndex());

		calculator.setCurrentPage(calculator.getNumPages() - 1);

		assertEquals(-1, calculator.getFirstSetInitialIndex());

		// Change values so all data fits into a single page

		sizeable1.setSize(1l);

		sizeable2.setSize(15l);

		calculator.setMaxPageSize(20);

		calculator.setCurrentPage(0);

		assertEquals(0, calculator.getFirstSetInitialIndex());

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getSecondSetInitialIndex()}

	 * .

	 */

	public void testGetSecondSetInitialIndex() {

		calculator.setCurrentPage(0);

		assertEquals(-1, calculator.getSecondSetInitialIndex());

		calculator.setCurrentPage(1);

		assertEquals(0, calculator.getSecondSetInitialIndex());

		calculator.setCurrentPage(2);

		assertEquals(2, calculator.getSecondSetInitialIndex());

		calculator.setCurrentPage(3);

		assertEquals(2 + MAX_PAGE_SIZE, calculator.getSecondSetInitialIndex());

		calculator.setCurrentPage(calculator.getNumPages() - 1);

		assertEquals(2 + ((calculator.getNumPages() - 3) * MAX_PAGE_SIZE),

				calculator.getSecondSetInitialIndex());

		// Change values so all data fits into a single page

		sizeable1.setSize(1l);

		sizeable2.setSize(15l);

		calculator.setMaxPageSize(20);

		calculator.setCurrentPage(0);

		assertEquals(0, calculator.getSecondSetInitialIndex());

		// Set the two sets equal, so all elements in the first set are

		// contained in the second one

		sizeable1.setSize(15l);

		sizeable2.setSize(15l);

		calculator.setMaxPageSize(4);

		calculator.setCurrentPage(0);

		assertEquals(-1, calculator.getSecondSetInitialIndex());

		calculator.setCurrentPage(1);

		assertEquals(-1, calculator.getSecondSetInitialIndex());

		calculator.setCurrentPage(2);

		assertEquals(-1, calculator.getSecondSetInitialIndex());

		calculator.setCurrentPage(3);

		assertEquals(-1, calculator.getSecondSetInitialIndex());

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getFirstSetHowMany()}

	 * .

	 */

	public void testGetFirstSetHowMany() {

		calculator.setCurrentPage(0);

		assertEquals(MAX_PAGE_SIZE, calculator.getFirstSetHowMany());

		calculator.setCurrentPage(1);

		assertEquals(2, calculator.getFirstSetHowMany());

		calculator.setCurrentPage(2);

		assertEquals(0, calculator.getFirstSetHowMany());

		calculator.setCurrentPage(3);

		assertEquals(0, calculator.getFirstSetHowMany());

		calculator.setCurrentPage(calculator.getNumPages() - 1);

		assertEquals(0, calculator.getFirstSetHowMany());

		// Change values so all data fits into a single page

		sizeable1.setSize(1l);

		sizeable2.setSize(15l);

		calculator.setMaxPageSize(20);

		calculator.setCurrentPage(0);

		assertEquals(1, calculator.getFirstSetHowMany());

		// Change values so all data is available into the first set

		sizeable1.setSize(25l);

		sizeable2.setSize(25l);

		calculator.setMaxPageSize(20);

		calculator.setCurrentPage(0);

		assertEquals(20, calculator.getFirstSetHowMany());

		calculator.setCurrentPage(1);

		assertEquals(5, calculator.getFirstSetHowMany());

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getSecondSetHowMany()}

	 * .

	 */

	public void testGetSecondSetHowMany() {

		calculator.setCurrentPage(0);

		assertEquals(0l, calculator.getSecondSetHowMany());

		calculator.setCurrentPage(1);

		assertEquals(2l, calculator.getSecondSetHowMany());

		calculator.setCurrentPage(2);

		assertEquals(MAX_PAGE_SIZE, calculator.getSecondSetHowMany());

		calculator.setCurrentPage(3);

		assertEquals(MAX_PAGE_SIZE, calculator.getSecondSetHowMany());

		calculator.setCurrentPage(calculator.getNumPages() - 1);

		assertEquals(1l, calculator.getSecondSetHowMany());

		// Change values so all data fits into a single page

		sizeable1.setSize(1l);

		sizeable2.setSize(15l);

		calculator.setMaxPageSize(20);

		calculator.setCurrentPage(0);

		assertEquals(14l, calculator.getSecondSetHowMany());

		// Set the two sets equal, so all elements in the first set are

		// contained in the second one

		sizeable1.setSize(15l);

		sizeable2.setSize(15l);

		calculator.setMaxPageSize(4);

		calculator.setCurrentPage(0);

		assertEquals(0l, calculator.getSecondSetHowMany());

		calculator.setCurrentPage(1);

		assertEquals(0l, calculator.getSecondSetHowMany());

		calculator.setCurrentPage(2);

		assertEquals(0l, calculator.getSecondSetHowMany());

		calculator.setCurrentPage(3);

		assertEquals(0l, calculator.getSecondSetHowMany());

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#hasCurrentPageAllValuesInFirstSet()}

	 * .

	 */

	public void testHasCurrentPageAllValuesInFirstSet() {

		calculator.setCurrentPage(0);

		assertTrue(calculator.hasCurrentPageAllValuesInFirstSet());

		calculator.setCurrentPage(1);

		assertFalse(calculator.hasCurrentPageAllValuesInFirstSet());

		calculator.setCurrentPage(2);

		assertFalse(calculator.hasCurrentPageAllValuesInFirstSet());

		calculator.setCurrentPage(3);

		assertFalse(calculator.hasCurrentPageAllValuesInFirstSet());

		calculator.setCurrentPage(calculator.getNumPages() - 1);

		assertFalse(calculator.hasCurrentPageAllValuesInFirstSet());

		// Change values so all data fits into a single page

		sizeable1.setSize(1l);

		sizeable2.setSize(15l);

		calculator.setMaxPageSize(20);

		calculator.setCurrentPage(0);

		assertFalse(calculator.hasCurrentPageAllValuesInFirstSet());

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#hasCurrentPageAnyValuesInFirstSet()}

	 * .

	 */

	public void testHasCurrentPageAnyValuesInFirstSet() {

		calculator.setCurrentPage(0);

		assertTrue(calculator.hasCurrentPageAnyValuesInFirstSet());

		calculator.setCurrentPage(1);

		assertTrue(calculator.hasCurrentPageAnyValuesInFirstSet());

		calculator.setCurrentPage(2);

		assertFalse(calculator.hasCurrentPageAnyValuesInFirstSet());

		calculator.setCurrentPage(3);

		assertFalse(calculator.hasCurrentPageAnyValuesInFirstSet());

		calculator.setCurrentPage(calculator.getNumPages() - 1);

		assertFalse(calculator.hasCurrentPageAnyValuesInFirstSet());

		// Change values so all data fits into a single page

		sizeable1.setSize(1l);

		sizeable2.setSize(15l);

		calculator.setMaxPageSize(20);

		calculator.setCurrentPage(0);

		assertTrue(calculator.hasCurrentPageAnyValuesInFirstSet());

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#hasCurrentPageAnyValuesInSecondSet()}

	 * .

	 */

	public void testHasCurrentPageAnyValuesInSecondSet() {

		calculator.setCurrentPage(0);

		assertFalse(calculator.hasCurrentPageAnyValuesInSecondSet());

		calculator.setCurrentPage(1);

		assertTrue(calculator.hasCurrentPageAnyValuesInSecondSet());

		calculator.setCurrentPage(2);

		assertTrue(calculator.hasCurrentPageAnyValuesInSecondSet());

		calculator.setCurrentPage(3);

		assertTrue(calculator.hasCurrentPageAnyValuesInSecondSet());

		calculator.setCurrentPage(calculator.getNumPages() - 1);

		assertTrue(calculator.hasCurrentPageAnyValuesInSecondSet());

		// Change values so all data fits into a single page

		sizeable1.setSize(1l);

		sizeable2.setSize(15l);

		calculator.setMaxPageSize(20);

		calculator.setCurrentPage(0);

		assertTrue(calculator.hasCurrentPageAnyValuesInSecondSet());

		// Set the two sets equal, so all elements in the first set are

		// contained in the second one

		sizeable1.setSize(15l);

		sizeable2.setSize(15l);

		calculator.setMaxPageSize(4);

		calculator.setCurrentPage(0);

		assertFalse(calculator.hasCurrentPageAnyValuesInSecondSet());

		calculator.setCurrentPage(1);

		assertFalse(calculator.hasCurrentPageAnyValuesInSecondSet());

		calculator.setCurrentPage(2);

		assertFalse(calculator.hasCurrentPageAnyValuesInSecondSet());

		calculator.setCurrentPage(3);

		assertFalse(calculator.hasCurrentPageAnyValuesInSecondSet());

	}

    private class TestSizeable implements Sizeable {

		private long size;

		public TestSizeable(long size) {

			this.size = size;

		}

		public long getSize() {

			return size;

		}

		public void setSize(long size) {

			this.size = size;

		}

	}

}

package org.gvsig.fmap.dal.feature;

import junit.framework.TestCase;

public class FeatureTest extends TestCase {

    public void testVoid() {

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

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

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I. S.A.   {{Task}}

*/

/**

 *

 */

package org.gvsig.fmap.dal.feature;

import java.util.Iterator;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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.testmulithread.DeleteFirstAndLastFeature;

import org.gvsig.fmap.dal.feature.testmulithread.DeleteLastFeature;

import org.gvsig.fmap.dal.feature.testmulithread.InsertFeature;

import org.gvsig.fmap.dal.feature.testmulithread.StoreTask;

import org.gvsig.fmap.dal.feature.testmulithread.UpdateFeature;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.evaluator.AbstractEvaluator;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.evaluator.EvaluatorFieldValue;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

/**

 * @author jmvivo

 *

 */

public abstract class BaseTestEditableFeatureStore extends BaseTestFeatureStore {

	public abstract NewFeatureStoreParameters getDefaultNewDataStoreParameters()

			throws Exception;

	public abstract boolean resourcesNotifyChanges();

	//=================================================

	//=================================================

	public void fillPrimaryKeyInserFeature(EditableFeature feature) {

		return;

	}

	protected Evaluator getEvaluatorToLower(String attibuteName) {

		return new ToLower(attibuteName);

	}

	protected Evaluator getEvaluatorToUpper(String attibuteName) {

		return new ToUpper(attibuteName);

	}

	public class ToLower extends AbstractEvaluator {

		private String attributeName;

		public ToLower(String attrName) {

			this.attributeName = attrName;

			this.getFieldsInfo().addFieldValue(this.attributeName);

		}

		public Object evaluate(EvaluatorData data) throws EvaluatorException {

			String value = (String) data.getDataValue(this.attributeName);

			if (value == null) {

				return null;

			}

			return value.toLowerCase();

		}

		public String getSQL() {

			return null;

		}

		public String getDescription() {

			return null;

		}

		public String getName() {

			return null;

		}

	}

	public class ToUpper extends AbstractEvaluator {

		private String attributeName;

		public ToUpper(String attrName) {

			this.attributeName = attrName;

			this.getFieldsInfo().addFieldValue(this.attributeName);

		}

		public Object evaluate(EvaluatorData data) throws EvaluatorException {

			String value = (String) data.getDataValue(this.attributeName);

			if (value == null) {

				return null;

			}

			return value.toUpperCase();

		}

		public String getSQL() {

			return null;

		}

		public String getDescription() {

			return null;

		}

		public EvaluatorFieldValue[] getFieldValues(String name) {

			return null;

		}

		public String getName() {

			return null;

		}

	}

	protected FeatureStore getStoreCopy(FeatureStore source,

			NewFeatureStoreParameters targetParams) throws DataException,

			ValidateDataParametersException {

		DataServerExplorer explorer = source.getExplorer();

		source.export(explorer, source.getProviderName(), targetParams);

		FeatureStore result = (FeatureStore) dataManager.openStore(source.getProviderName(), targetParams);

		return result;

	}

	protected void clearCopy(FeatureStore source,

			NewFeatureStoreParameters targetParams) throws Exception {

		DataServerExplorer explorer = source.getExplorer();

		explorer.remove(targetParams);

	}

	protected boolean compareFeatures(Feature f1, Feature f2,

			String[] attrsNames, UpdateFeature updated, long index,

			long lastIndex) throws DataException, EvaluatorException {

		FeatureAttributeDescriptor attr1;

		FeatureAttributeDescriptor attr2;

		EditableFeature f2e = f2.getEditable();

		updated.applyUpdateList(f2e, index, lastIndex);

		Object v1, v2;

		for (int i = 0; i < attrsNames.length; i++) {

			attr1 = f1.getType().getAttributeDescriptor(attrsNames[i]);

			attr2 = f2e.getType().getAttributeDescriptor(attrsNames[i]);

			if (attr1 != attr2) {

				if (!compareAttributes(attr1, attr1)) {

					return false;

				}

			}

			v1 = f1.get(attr1.getName());

			v2 = f2.get(attr2.getName());

			if (!compareFeatureValue(v1, v2, attr1)) {

				return false;

			}

		}

		return true;

	}

	protected boolean compareFeatures(Feature f1, Feature f2,

			UpdateFeature updated, long index, long lastIndex)

			throws DataException, EvaluatorException {

		if (!compareTypes(f1.getType(), f2.getType())) {

			System.out.println("compareFeatures() type !=");

			return false;

		}

		Iterator iter = f1.getType().iterator();

		FeatureAttributeDescriptor attr;

		EditableFeature f1e = f1.getEditable();

		updated.applyUpdateList(f1e, index, lastIndex);

		Object v1, v2;

		while (iter.hasNext()) {

			attr = (FeatureAttributeDescriptor) iter.next();

			v1 = f1e.get(attr.getName());

			v2 = f2.get(attr.getName());

			if (!compareFeatureValue(v1, v2, attr)) {

				return false;

			}

		}

		return true;

	}

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

	//=================================================

	//=================================================

	public void testExport() throws Exception {

		DataStoreParameters parameters = null;

		parameters = getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);

		NewFeatureStoreParameters newParams = this

				.getDefaultNewDataStoreParameters();

		try {

			this.clearCopy(store, newParams);

		} catch (RemoveException e) {

			// Dp nothing

		}

		FeatureStore result = this.getStoreCopy(store, newParams);

		fullStoreIteratorTest(result);

		FeatureSet set;

		FeatureSet originalSet;

		if (result.getDefaultFeatureType().getPrimaryKey() != null

				&& result.getDefaultFeatureType().getPrimaryKey().length > 0) {

			FeatureQuery queryR = result.createFeatureQuery();

			FeatureQuery queryO = store.createFeatureQuery();

			FeatureAttributeDescriptor[] pk = result.getDefaultFeatureType()

					.getPrimaryKey();

			for (int i = 0; i < pk.length; i++) {

				queryO.getOrder().add(pk[i].getName(), true);

				queryR.getOrder().add(pk[i].getName(), true);

			}

			set = result.getFeatureSet(queryR);

			originalSet = store.getFeatureSet(queryO);

		} else {

			set = result.getFeatureSet();

			originalSet = store.getFeatureSet();

		}

		assertEquals(set.getSize(), originalSet.getSize());

		DisposableIterator originalIter = originalSet.iterator();

		DisposableIterator iter = set.iterator();

		assertTrue(compareFeatureIterators(originalIter, iter));

		originalIter.dispose();

		iter.dispose();

		if (store.getEnvelope() != result.getEnvelope()) {

			if (store.getEnvelope() != null) {

				assertTrue(store.getEnvelope().equals(result.getEnvelope()));

			} else {

				fail("Envelope: src=" + store.getEnvelope() + " traget="

						+ store.getEnvelope());

			}

		}

		set.dispose();

		originalSet.dispose();

		result.dispose();

		this.clearCopy(store, newParams);

		store.dispose();

	}

	public void testRemove() throws Exception {

		DataStoreParameters parameters = null;

		parameters = getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);

		NewFeatureStoreParameters newParams = this

				.getDefaultNewDataStoreParameters();

		try {

			this.clearCopy(store, newParams);

		} catch (RemoveException e) {

			// Dp nothing

		}

		FeatureStore result = this.getStoreCopy(store, newParams);

		result.edit(FeatureStore.MODE_FULLEDIT);

		FeatureSet set = result.getFeatureSet(getDefaultQuery(result));

		FeatureSet originalSet = store.getFeatureSet(getDefaultQuery(store));

		assertEquals(set.getSize(), originalSet.getSize());

		DisposableIterator originalIter = originalSet.iterator();

		DisposableIterator iter = set.iterator();

		int i = 0;

		while (iter.hasNext()) {

			assertTrue("" + i, compareFeatures((Feature) originalIter.next(),

					(Feature) iter.next()));

			i++;

		}

		iter.remove();

		assertEquals(originalSet.getSize() - 1, set.getSize());

		iter.dispose();

		originalIter.dispose();

		originalIter = originalSet.iterator();

		iter = set.iterator();

		i = 0;

		while (iter.hasNext()) {

			assertTrue("" + i, compareFeatures((Feature) originalIter.next(),

					(Feature) iter.next()));

			i++;

		}

		iter.remove();

		assertEquals(originalSet.getSize() - 2, set.getSize());

		iter.dispose();

		originalIter.dispose();

		set.dispose();

		result.finishEditing();

		set = result.getFeatureSet();

		assertEquals(originalSet.getSize() - 2, set.getSize());

		originalIter = originalSet.iterator();

		iter = set.iterator();

		i = 0;

		while (iter.hasNext()) {

			assertTrue("" + i, compareFeatures((Feature) originalIter.next(),

					(Feature) iter.next()));

			i++;

		}

		iter.dispose();

		originalIter.dispose();

		set.dispose();

		originalSet.dispose();

		result.dispose();

		this.clearCopy(store, newParams);

		store.dispose();

	}

	public void testInsert() throws Exception {

		DataStoreParameters parameters = null;

		parameters = getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager

		.createStore(parameters);

		NewFeatureStoreParameters newParams = this

		.getDefaultNewDataStoreParameters();

		try {

			this.clearCopy(store, newParams);

		} catch (RemoveException e) {

			//Do nothing

		}

		FeatureStore result = this.getStoreCopy(store, newParams);

		result.edit(FeatureStore.MODE_FULLEDIT);

		FeatureSet set = result.getFeatureSet(getDefaultQuery(result));

		FeatureSet originalSet = store.getFeatureSet(getDefaultQuery(store));

		assertEquals(set.getSize(), originalSet.getSize());

		EditableFeature newFeature = result.createNewFeature(true);

		fillPrimaryKeyInserFeature(newFeature);

		set.insert(newFeature);

		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());

		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());

		newFeature = result.createNewFeature(true);

		fillPrimaryKeyInserFeature(newFeature);

		set.insert(newFeature);

		assertEquals(originalSet.getSize() + 2, set.getSize());

		iter.dispose();

		originalIter.dispose();

		set.dispose();

		result.finishEditing();

		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++;

		}

		assertNotNull(iter.next());

		assertNotNull(iter.next());

		assertFalse(iter.hasNext());

		iter.dispose();

		originalIter.dispose();

		set.dispose();

		originalSet.dispose();

		result.dispose();

		this.clearCopy(store, newParams);

		store.dispose();

	}

	public void testConcurrentRemove() throws Exception {

		DataStoreParameters parameters = null;

		parameters = getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);

		NewFeatureStoreParameters newParams = this

		.getDefaultNewDataStoreParameters();

		try {

			this.clearCopy(store, newParams);

		} catch (RemoveException e) {

			// Dp nothing

		}

		FeatureStore result = this.getStoreCopy(store, newParams);

		result.edit(FeatureStore.MODE_FULLEDIT);

		DeleteFirstAndLastFeature deleteFeature = new DeleteFirstAndLastFeature(

				"1", result, StoreTask.TIME_TO_WAIT_NO_WAIT);

		FeatureSet set = result.getFeatureSet();

		DisposableIterator iter = set.iterator();

		assertTrue(iter.hasNext());

		assertNotNull(iter.next());

		deleteFeature.start();

		while (deleteFeature.getCurrentStatus() <= StoreTask.STATUS_RUNING) {

			Thread.yield();

			Thread.sleep(100);

			if (deleteFeature.isOutOfDate()) {

				break;

			}

		}

		assertEquals(deleteFeature.getCurrentStatus(),

				StoreTask.STATUS_FINISHED_OK);

		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();

	}

	public void testConcurrentInsert() throws Exception{

		DataStoreParameters parameters = null;

		parameters = getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);

		NewFeatureStoreParameters newParams = this

		.getDefaultNewDataStoreParameters();

		try {

			this.clearCopy(store, newParams);

		} catch (RemoveException e) {

			// Dp nothing

		}

		FeatureStore result = this.getStoreCopy(store, newParams);

		result.edit(FeatureStore.MODE_FULLEDIT);

		InsertFeature insertFeature = new InsertFeature("1", result,

				StoreTask.TIME_TO_WAIT_NO_WAIT, this);

		FeatureSet set = result.getFeatureSet();

		DisposableIterator iter = set.iterator();

		assertTrue(iter.hasNext());

		assertNotNull(iter.next());

		insertFeature.start();

		while (insertFeature.getCurrentStatus() <= StoreTask.STATUS_RUNING) {

			Thread.yield();

			Thread.sleep(100);

			if (insertFeature.isOutOfDate()) {

				break;

			}

		}

		assertEquals(StoreTask.STATUS_FINISHED_OK, insertFeature

				.getCurrentStatus());

		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();

	}

	public void testConcurrentUpdate() throws Exception {

		DataStoreParameters parameters = null;

		parameters = getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);

		NewFeatureStoreParameters newParams = this

		.getDefaultNewDataStoreParameters();

		try {

			this.clearCopy(store, newParams);

		} catch (RemoveException e) {

			// Dp nothing

		}

		FeatureStore result = this.getStoreCopy(store, newParams);

		result.edit(FeatureStore.MODE_FULLEDIT);

		UpdateFeature updateFeature = new UpdateFeature("1", result,

				StoreTask.TIME_TO_WAIT_NO_WAIT);

		FeatureType fType = result.getDefaultFeatureType();

		FeatureAttributeDescriptor attr;

		Iterator fTypeIter = fType.iterator();

		String attrName = null;

		while (fTypeIter.hasNext()){

			attr = (FeatureAttributeDescriptor) fTypeIter.next();

			if (attr.getType() == DataTypes.STRING && !attr.isReadOnly() && !attr.isPrimaryKey() && !attr.isAutomatic()){

				attrName= attr.getName();

			}

		}

		if (attrName == null) {

			fail("This test needs an normal attribute String (no Pk, no ReadOnly & no Auto)");

			return;

		}

		updateFeature.addUpdate(UpdateFeature.UPDATE_ALL_FEATURES, attrName,

				"XXX");

		FeatureSet set = result.getFeatureSet();

		DisposableIterator iter = set.iterator();

		assertTrue(iter.hasNext());

		assertNotNull(iter.next());

		updateFeature.start();

		while (updateFeature.getCurrentStatus() <= StoreTask.STATUS_RUNING) {

			Thread.yield();

			Thread.sleep(100);

			if (updateFeature.isOutOfDate()) {

				break;

			}

		}

		assertEquals(StoreTask.STATUS_FINISHED_OK, updateFeature

				.getCurrentStatus());

		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();

	}

	public void testSequencedRemove() throws Exception {

		DataStoreParameters parameters = null;

		int ntimes = 3;

		parameters = getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);

		NewFeatureStoreParameters newParams = this

		.getDefaultNewDataStoreParameters();

		try {

			this.clearCopy(store, newParams);

		} catch (RemoveException e) {

			// Dp nothing

		}

		FeatureStore result = this.getStoreCopy(store, newParams);

		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);

		}

		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;

		}

		boolean testAll = false;

		boolean restart;

		DeleteLastFeature item;

		while (!testAll) {

			restart = false;

			for (i = 0; i < deletesFeature.length; i++) {

				item = deletesFeature[i];

				if (item.getCurrentStatus() <= StoreTask.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() == StoreTask.STATUS_ERROR) {

					item.getException().printStackTrace();

					result.dispose();

					fail("ERROR: " + i);

					return;

				} else if (item.getCurrentStatus() != StoreTask.STATUS_FINISHED_OK) {

					item.getException().printStackTrace();

					result.dispose();

					fail("Data ERROR: " + i);

					return;

				}

			}

			if (restart) {

				continue;

			}

			testAll = true;

		}

		FeatureSet set = result.getFeatureSet(getDefaultQuery(result));

		FeatureSet originalSet = store.getFeatureSet(getDefaultQuery(store));

		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++;

		}

		originalIter.dispose();

		iter.dispose();

		set.dispose();

		result.finishEditing();

		set = result.getFeatureSet(getDefaultQuery(result));

		assertEquals(originalSet.getSize() - deletesFeature.length, set

				.getSize());

		originalIter = originalSet.iterator();

		iter = set.iterator();

		i = 0;

		while (iter.hasNext()) {

			assertTrue("" + i, compareFeatures((Feature) originalIter.next(),

					(Feature) iter.next()));

			i++;

		}

		originalIter.dispose();

		iter.dispose();

		set.dispose();

		originalSet.dispose();

		result.dispose();

		this.clearCopy(store, newParams);

		store.dispose();

	}

	public void testSequencedInsert() throws Exception {

		DataStoreParameters parameters = null;

		int ntimes = 3;

		parameters = getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);

		NewFeatureStoreParameters newParams = this

		.getDefaultNewDataStoreParameters();

		try {

			this.clearCopy(store, newParams);

		} catch (RemoveException e) {

			// Dp nothing

		}

		FeatureStore result = this.getStoreCopy(store, newParams);

		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, this);

		}

		for (i = 0; i < insertsFeature.length; i++) {

			insertsFeature[i].start();

		}

		try {

			for (int x = 0; x < (insertsFeature.length + 2); x++) {

				Thread.yield();

				Thread.sleep(500);

			}

		} 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() <= StoreTask.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() == StoreTask.STATUS_ERROR) {

					item.getException().printStackTrace();

					result.dispose();

					fail("ERROR: " + i);

					return;

				} else if (item.getCurrentStatus() == StoreTask.STATUS_FINISHED_NO_OK) {

					result.dispose();

					fail("No OK: " + i);

					return;

				} else if (item.getCurrentStatus() != StoreTask.STATUS_FINISHED_OK) {

					item.getException().printStackTrace();

					result.dispose();

					fail("Data ERROR: " + i);

					return;

				}

			}

			if (restart) {

				continue;

			}

			testAll = true;

		}

		FeatureSet set = result.getFeatureSet(getDefaultQuery(result));

		FeatureSet originalSet = store.getFeatureSet(getDefaultQuery(store));

		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++;

		}

		for (; i < insertsFeature.length; i++) {

			iter.next();

		}

		originalIter.dispose();

		iter.dispose();

		set.dispose();

		result.finishEditing();

		set = result.getFeatureSet();

		assertEquals(originalSet.getSize() + insertsFeature.length, set

				.getSize());

		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() throws Exception {

		DataStoreParameters parameters = null;

		parameters = getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.createStore(parameters);

		NewFeatureStoreParameters newParams = this

		.getDefaultNewDataStoreParameters();

		try {

			this.clearCopy(store, newParams);

		} catch (RemoveException e) {

			// Dp nothing

		}

		FeatureStore result = this.getStoreCopy(store, newParams);

		result.edit(FeatureStore.MODE_FULLEDIT);

		FeatureSet set = result.getFeatureSet();

		long size = set.getSize();

		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);

		updater.addUpdate(UpdateFeature.UPDATE_ALL_FEATURES, attr.getName(),

				getEvaluatorToLower(attr.getName()));

		updater.run();

		while (updater.getCurrentStatus() < StoreTask.STATUS_FINISHED_OK

				&& !updater.isOutOfDate()) {

			Thread.yield();

			try {

				Thread.sleep(200);

			} catch (InterruptedException e) {

				e.printStackTrace();

				fail();

			}

		}

		set = result.getFeatureSet(getDefaultQuery(result));

		DisposableIterator iter = set.iterator();

		printFeatureTypeColNames(set.getDefaultFeatureType(), 15);

		Feature f;

		while (iter.hasNext()) {

			f = (Feature) iter.next();

			this.printFeature(f, false, 15);

		}

		iter.dispose();

		FeatureSet originalSet = store.getFeatureSet(getDefaultQuery(store));

		DisposableIterator originalIter = originalSet.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++;

		}

		iter.dispose();

		originalIter.dispose();

		set.dispose();

		result.finishEditing();

		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++;