| gvSIG desktop 1

package org.gvsig.fmap.dal;

import junit.framework.TestCase;

public class DataStoreTest 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 {}  {{Task}}

*/

package org.gvsig.fmap.dal.resource.spi;

import junit.framework.TestCase;

import org.easymock.MockControl;

import org.gvsig.fmap.dal.resource.ResourceAction;

import org.gvsig.fmap.dal.resource.ResourceParameters;

import org.gvsig.fmap.dal.resource.exception.ResourceNotifyOpenException;

/**

 * Unit tests for the class {@link AbstractResource}

 * 

 * @author 2009- <a href="cordinyana@gvsig.org">C?sar Ordi?ana</a> - gvSIG team

 */

public class AbstractResourceTest extends TestCase {

	private AbstractResource resource;

	private MockControl paramsControl;

	private ResourceParameters params;

	protected void setUp() throws Exception {

		super.setUp();

		paramsControl = MockControl.createNiceControl(ResourceParameters.class);

		params = (ResourceParameters) paramsControl.getMock();

		resource = new TestResource(params);

	}

	/**

	 * Test method for {@link org.gvsig.fmap.dal.resource.spi.AbstractResource#getLastTimeOpen()}.

	 */

	public void testGetLastTimeOpen() throws ResourceNotifyOpenException {

		long time = resource.getLastTimeOpen();

		resource.notifyOpen();

		assertTrue("The resource last time open hasn't been updated",

				resource.getLastTimeOpen() > time);

	}

	/**

	 * Test method for {@link org.gvsig.fmap.dal.resource.spi.AbstractResource#getLastTimeUsed()}.

	 */

	public void testGetLastTimeUsed() throws Exception {

		long time = resource.getLastTimeUsed();

		resource.execute(new ResourceAction() {

			public Object run() throws Exception {

				try {

					// Wait for 100 milliseconds

					Thread.sleep(100);

				} catch (InterruptedException e) {

					// No problem

				}

				return null;

			}

		});

		assertTrue("The resource last time used hasn't been updated",

				resource.getLastTimeUsed() > time);

	}

	/**

	 * Test method for {@link org.gvsig.fmap.dal.resource.spi.AbstractResource#openCount()}.

	 */

	public void testOpenCount() throws Exception {

		assertEquals(0, resource.openCount());

		resource.notifyOpen();

		assertEquals(1, resource.openCount());

		resource.notifyOpen();

		resource.notifyOpen();

		assertEquals(3, resource.openCount());

		resource.notifyClose();

		assertEquals(2, resource.openCount());

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.resource.spi.AbstractResource#execute(java.lang.Runnable)}

	 * .

	 */

	public void testExecute() throws Exception {

		final MutableBoolean testValue = new MutableBoolean();

		resource.execute(new ResourceAction() {

			public Object run() throws Exception {

				testValue.setValue(true);

				return null;

			}

		});

		assertTrue("Runnable execution not performed", testValue.isValue());

	}

	public class MutableBoolean {

		private boolean value = false;

		public void setValue(boolean value) {

			this.value = value;

		}

		public boolean isValue() {

			return value;

		}

	}

}

/* 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 {}  {{Task}}

*/

package org.gvsig.fmap.dal.resource.spi;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.resource.ResourceParameters;

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

import org.gvsig.fmap.dal.resource.exception.ResourceException;

/**

 * Test resource implementation.

 * 

 * @author 2009- <a href="cordinyana@gvsig.org">C?sar Ordi?ana</a> - gvSIG team

 */

public class TestNonBlockingResource extends AbstractNonBlockingResource {

	protected TestNonBlockingResource(ResourceParameters parameters)

			throws InitializeException {

		super(parameters);

	}

	public Object get() throws AccessResourceException {

		return getName();

	}

	public String getName() throws AccessResourceException {

		return getClass().getName();

	}

	public boolean isThis(ResourceParameters parameters)

			throws ResourceException {

		return false;

	}

}

package org.gvsig.fmap.dal.resource.spi;

import junit.framework.TestCase;

import org.easymock.MockControl;

import org.gvsig.fmap.dal.resource.Resource;

import org.gvsig.fmap.dal.resource.ResourceAction;

import org.gvsig.fmap.dal.resource.ResourceParameters;

public class TestAbstractResourcePerformance extends TestCase {

	private MockControl paramsControl;

	private ResourceParameters params;

	private AbstractResource resource;

	private MockControl paramsControl2;

	private ResourceParameters params2;

	private AbstractNonBlockingResource nonBlockingResource;

	protected void setUp() throws Exception {

		super.setUp();

		paramsControl = MockControl.createNiceControl(ResourceParameters.class);

		params = (ResourceParameters) paramsControl.getMock();

		resource = new TestResource(params);

		paramsControl2 =

				MockControl.createNiceControl(ResourceParameters.class);

		params2 = (ResourceParameters) paramsControl2.getMock();

		nonBlockingResource = new TestNonBlockingResource(params2);

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.resource.spi.AbstractResource#execute(java.lang.Runnable)}

	 * .

	 */

	public void testExecuteBlockingPerformance() throws Exception {

		executePerformance(new ResourceAction() {

			public Object run() throws Exception {

				return null;

			}

		}, resource);

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.resource.spi.AbstractResource#execute(java.lang.Runnable)}

	 * .

	 */

	public void testExecuteNonBlockingPerformance() throws Exception {

		executePerformance(new ResourceAction() {

			public Object run() throws Exception {

				return null;

			}

		}, nonBlockingResource);

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.dal.resource.spi.AbstractResource#execute(java.lang.Runnable)}

	 * .

	 */

	public void executePerformance(ResourceAction action, Resource resource)

			throws Exception {

		final int executions = 100000;

		long time1 = System.currentTimeMillis();

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

			resource.execute(action);

		}

		long time2 = System.currentTimeMillis();

		System.out.print(resource.getName());

		System.out.print(": total time: " + (time2 - time1) + " ms.");

		System.out.println(" - time per execution: "

				+ ((float) (time2 - time1) / (float) executions) + " ms.");

	}

}

/* 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 {}  {{Task}}

*/

package org.gvsig.fmap.dal.resource.spi;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.resource.ResourceParameters;

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

import org.gvsig.fmap.dal.resource.exception.ResourceException;

/**

 * Test non blocking resource implementation.

 * 

 * @author 2009- <a href="cordinyana@gvsig.org">C?sar Ordi?ana</a> - gvSIG team

 */

public class TestResource extends AbstractResource {

	protected TestResource(ResourceParameters parameters)

			throws InitializeException {

		super(parameters);

	}

	public Object get() throws AccessResourceException {

		return getName();

	}

	public String getName() throws AccessResourceException {

		return getClass().getName();

	}

	public boolean isThis(ResourceParameters parameters)

			throws ResourceException {

		return false;

	}

}

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

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

*/

/**

 *

 */

package org.gvsig.fmap.dal.feature;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Random;

import java.util.TreeSet;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.exception.DataEvaluatorRuntimeException;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.FeatureQueryOrder.FeatureQueryOrderMember;

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

import org.gvsig.fmap.dal.resource.ResourceManager;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.persistence.PersistentState;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author jmvivo

 *

 */

public abstract class BaseTestFeatureStore extends

		AbstractLibraryAutoInitTestCase {

	private static Logger logger = null;

	protected DataManager dataManager = null;

	private static Random rnd;

	public Logger getLogger() {

		if (logger == null) {

			logger = LoggerFactory.getLogger(this.getClass());

		}

		return logger;

	}

	public abstract boolean usesResources();

	public abstract boolean hasExplorer();

	public FeatureQuery getDefaultQuery(FeatureStore store)

			throws DataException {

		FeatureQuery query = store.createFeatureQuery();

		FeatureAttributeDescriptor[] key = store.getDefaultFeatureType()

				.getPrimaryKey();

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

			query.getOrder().add(key[i].getName(), true);

		}

		return query;

	}

	public abstract DataStoreParameters getDefaultDataStoreParameters()

			throws DataException;

	protected void doSetUp() throws Exception {

		dataManager = DALLocator.getDataManager();

	}

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

	public void printFeature(Feature feature, int maxColSize) {

		printFeature(feature, true, maxColSize);

	}

	public void printFeature(Feature feature, boolean showColName,int maxColSize) {

		FeatureType fType = feature.getType();

		if (showColName){

			this.printFeatureTypeColNames(feature.getType(), maxColSize);

		}

		StringBuffer row = new StringBuffer();

		Iterator iter = fType.iterator();

		FeatureAttributeDescriptor attr;

		while (iter.hasNext()) {

			attr = (FeatureAttributeDescriptor) iter.next();

			row.append(truncateOrFillString(feature.get(attr.getName()),

					maxColSize + 1, ' '));

		}

		System.out.println(row.toString());

	}

	public String truncateOrFillString(Object str, int max, char fillWith) {

		if (str == null) {

			return truncateOrFillString("{null}", max, fillWith);

		}

		return truncateOrFillString(str.toString(), max, fillWith);

	}

	public String truncateOrFillString(String str, int max, char fillWith) {

		if (str.length() > max) {

			return str.substring(0, max - 1) + " ";

		} else {

			StringBuffer strB = new StringBuffer(str);

			while (strB.length() < max) {

				strB.append(fillWith);

			}

			return strB.toString();

		}

	}

	public void printFeatureTypeColNames(FeatureType fType, int maxColSize) {

		Iterator iter = fType.iterator();

		FeatureAttributeDescriptor attr;

		StringBuffer colNames = new StringBuffer();

		StringBuffer typeNames = new StringBuffer();

		StringBuffer sep = new StringBuffer();

		if (maxColSize < 1){

			maxColSize = 15;

		}

		while (iter.hasNext()) {

			attr = (FeatureAttributeDescriptor) iter.next();

			colNames.append(truncateOrFillString(attr.getName(), maxColSize + 1, ' '));

			typeNames.append(truncateOrFillString("(" + attr.getDataTypeName() + ")",

					maxColSize + 1, ' '));

			sep.append(truncateOrFillString("", maxColSize, '='));

			sep.append(' ');

		}

		System.out.println("");

		System.out.println("");

		System.out.println(colNames.toString());

		System.out.println(typeNames.toString());

		System.out.println(sep.toString());

	}

	protected FeatureAttributeDescriptor getFirstAttributeOfType(

			FeatureType ftype, int dataType) {

		return getFirstAttributeOfType(ftype, new int[] { dataType });

	}

	protected FeatureAttributeDescriptor getFirstAttributeOfType(

			FeatureType ftype, int[] dataTypes) {

		FeatureAttributeDescriptor attr;

		Iterator iter = ftype.iterator();

		int i;

		while (iter.hasNext()) {

			attr = (FeatureAttributeDescriptor) iter.next();

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

				if (attr.getType() == dataTypes[i]) {

					return attr;

				}

			}

		}

		return null;

	}

	protected boolean compareDynObject(DynObject obj1, DynObject obj2) {

		DynClass dynClass = obj1.getDynClass();

		if (!dynClass.getName().equals(obj2.getDynClass().getName())) {

			return false;

		}

		DynField[] fields = dynClass.getDeclaredDynFields();

		String fieldName;

		Object v1, v2;

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

			fieldName = fields[i].getName();

			v1 = obj1.getDynValue(fieldName);

			v2 = obj2.getDynValue(fieldName);

			if (v1 == v2) {

				continue;

			} else if (v1 != null) {

				if (!v1.equals(v2)) {

					return false;

				}

			}

		}

		return true;

	}

	protected boolean compareStores(FeatureStore store1, FeatureStore store2)

			throws DataException {

		if (store1.getParameters().getClass() != store2.getParameters()

				.getClass()) {

			return false;

		}

		if (!compareDynObject(store1.getParameters(), store2.getParameters())) {

			return false;

		}

		if (store1.getEnvelope() != store2.getEnvelope()) {

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

				return store1.getEnvelope().equals(store2.getEnvelope());

			} else {

				return false;

			}

		}

		if (!store1.getName().equals(store2.getName())) {

			return false;

		}

		if (((FeatureSelection) store1.getSelection()).getSize() != ((FeatureSelection) store2

				.getSelection()).getSize()) {

			return false;

		}

		DisposableIterator iter1 = ((FeatureSelection) store1.getSelection())

				.fastIterator();

		DisposableIterator iter2 = ((FeatureSelection) store2.getSelection())

				.fastIterator();

		if (!compareFeatureIterators(iter1, iter2)) {

			return false;

		}

		iter1.dispose();

		iter2.dispose();

		if (store1.getFeatureTypes().size() != store2.getFeatureTypes().size()) {

			return false;

		}

		Iterator iterTypes1 = store1.getFeatureTypes().iterator();

		Iterator iterTypes2 = store2.getFeatureTypes().iterator();

		while (iterTypes1.hasNext()) {

			if (!compareTypes((FeatureType) iterTypes1.next(),

					(FeatureType) iterTypes2

					.next())) {

				return false;

			}

		}

		if (!compareTypes(store1.getDefaultFeatureType(), store2

				.getDefaultFeatureType())) {

			return false;

		}

		if (store1.getLocks() != null) {

			if (store1.getLocks().getLocksCount() != store2.getLocks()

					.getLocksCount()) {

				return false;

			}

			if (!compareFeatureIterators(store1.getLocks().getLocks(), store2

					.getLocks().getLocks())) {

				return false;

			}

		} else if (store2.getLocks() != null) {

			return false;

		}

		return true;

	}

	protected boolean compareFeatureIterators(Iterator iter1, Iterator iter2) {

		Feature feature;

		Feature ffeature;

		while (iter1.hasNext()) {

			feature = (Feature) iter1.next();

			ffeature = (Feature) iter2.next();

			if (!this.compareFeatures(feature, ffeature)) {

				return false;

			}

		}

		if (!iter2.hasNext()) {

			return true;

		} else {

			getLogger().warn("size !=");

			return false;

		}

	}

	protected boolean compareFeatureIterators(Iterator iter1, Iterator iter2,

			String[] attrNames) {

		Feature feature;

		Feature ffeature;

		while (iter1.hasNext()) {

			feature = (Feature) iter1.next();

			ffeature = (Feature) iter2.next();

			if (!this.compareFeatures(feature, ffeature, attrNames)) {

				return false;

			}

		}

		return !iter2.hasNext();

	}

	protected boolean compareTypes(FeatureType ft1, FeatureType ft2) {

		if (ft1.size() != ft2.size()) {

			getLogger().warn("size !=");

			return false;

		}

		if (ft1.getDefaultGeometryAttributeIndex() != ft2

				.getDefaultGeometryAttributeIndex()) {

			getLogger().warn(

					"getDefaultGeometryAttributeIndex "

							+ ft1.getDefaultGeometryAttributeIndex() +

					" !="+ ft2.getDefaultGeometryAttributeIndex());

			return false;

		}

		if (ft1.getDefaultGeometryAttributeIndex() > -1) {

			if (ft1.getDefaultSRS() != null) {

				if (!ft1.getDefaultSRS().equals(ft2.getDefaultSRS())) {

					getLogger().warn("getDefaultSRS !=");

					return false;

				}

			} else {

				if (ft2.getDefaultSRS() != null) {

					getLogger().warn("getDefaultSRS !=");

					return false;

				}

			}

		}

		if (ft1.getDefaultGeometryAttributeName() != null) {

			if (!ft1.getDefaultGeometryAttributeName().equals(

					ft2.getDefaultGeometryAttributeName())) {

				getLogger().warn("getDefaultGeometryAttributeName !=");

				return false;

			}

		} else {

			if (ft2.getDefaultGeometryAttributeName() != null) {

				getLogger().warn("getDefaultGeometryAttributeName !=");

				return false;

			}

		}

		FeatureAttributeDescriptor attr1, attr2;

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

			attr1 = ft1.getAttributeDescriptor(i);

			attr2 = ft2.getAttributeDescriptor(i);

			if (!compareAttributes(attr1, attr2)) {

				return false;

			}

		}

		return true;

	}

	protected boolean compareAttributes(FeatureAttributeDescriptor attr1,

			FeatureAttributeDescriptor attr2) {

		if (attr1 == null || attr2 == null) {

			getLogger().warn("attr1 == null || attr2 == null");

			return false;

		}

		if (!attr1.getName().equals(attr2.getName())) {

			getLogger().warn(

					"name '" + attr1.getName() + "' != '" + attr2.getName()

							+ "'");

			return false;

		}

		if (attr1.getDataType() != attr2.getDataType()) {

			getLogger().warn(

					attr1.getName() + ":" +

					"dataType '" + attr1.getDataTypeName() + "'["

							+ attr1.getDataType() + "] != '"

							+ attr2.getDataTypeName() + "'["

							+ attr2.getDataType() + "]");

			return false;

		}

		if (attr1.getSize() != attr2.getSize()) {

			getLogger().warn(

					attr1.getName() + ":" +

					"size " + attr1.getSize() + " != " + attr2.getSize());

			return false;

		}

		if (attr1.getPrecision() != attr2.getPrecision()) {

			getLogger().warn(

					attr1.getName() + ":" +

					"precision " + attr1.getPrecision() + " != "

							+ attr1.getPrecision());

			return false;

		}

		if (attr1.getGeometryType() != attr2.getGeometryType()) {

			getLogger().warn(

					attr1.getName() + ":" +

					"GeometryType " + attr1.getGeometryType() + " != "

							+ attr2.getGeometryType());

			return false;

		}

		if (attr1.getGeometrySubType() != attr2.getGeometrySubType()) {

			getLogger().warn(

					attr1.getName() + ":" +

					"GeometrySubType " + attr1.getGeometrySubType() + " != "

							+ attr2.getGeometrySubType());

			return false;

		}

		if (attr1.getSRS() != null) {

			if (!attr1.getSRS().equals(attr2.getSRS())) {

				getLogger().warn(

						attr1.getName() + ":" +

						"srs " + attr1.getSRS() + " != " + attr2.getSRS());

				return false;

			}

		} else {

			if (attr2.getSRS() != null) {

				getLogger().warn(

						attr1.getName() + ":" +

						"srs " + attr1.getSRS() + " != " + attr2.getSRS());

				return false;

			}

		}

		return true;

	}

	protected boolean compareFeatures(Feature f1, Feature f2,

			String[] attrsNames) {

		FeatureAttributeDescriptor attr1;

		FeatureAttributeDescriptor attr2;

		Object v1, v2;

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

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

			attr2 = f2.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) {

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

			return false;

		}

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

		FeatureAttributeDescriptor attr;

		Object v1, v2;

		while (iter.hasNext()) {

			attr = (FeatureAttributeDescriptor) iter.next();

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

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

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

				return false;

			}

		}

		return true;

	}

	protected boolean compareFeatureValue(Object v1, Object v2,

			FeatureAttributeDescriptor attr) {

		if ((v1 == null || v2 == null) &&  !attr.allowNull() ){

			getLogger().warn("null and !allowNull:"

							+ attr.getName());

			return false;

		}

		if (v1 == v2) {

			return true;

		} else if (v1 == null) {

			getLogger().warn(" v1 == null and v2 != null:"

							+ attr.getName());

			return false;

		} else if (v2 == null) {

			getLogger().warn("v2 == null and v1 != null:"

							+ attr.getName());

			return false;

		}

		switch (attr.getType()) {

		case DataTypes.GEOMETRY:

			Geometry geom1 = (Geometry) v1;

			Geometry geom2 = (Geometry) v2;

			if (!geom1.equals(geom2)) {

				getLogger().warn(" v1 != v2 (Geom):" + attr.getName());

				return false;

			}

			return true;

		case DataTypes.DOUBLE:

			double diff = ((Double) v1).doubleValue()

					- ((Double) v1).doubleValue();

			if (!(Math.abs(diff) < 0.000001)) {

				getLogger().warn(" v1 != v2 (Dobule):" + attr.getName());

				return false;

			}

			return true;

		case DataTypes.OBJECT:

			if (!v1.equals(v2)) {

				getLogger().warn(

						" v1 != v2 (object):" + attr.getName() + " [ignored]");

				return false;

			}

			return true;

		default:

			if (!v1.equals(v2)) {

				getLogger()

						.warn(

								" v1 != v2:" + attr.getName() + ": " + v1

										+ " != " + v2);

				return false;

			}

		}

		return true;

	}

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

	public void testSimpleIteration(FeatureStore store) {

		this.testSimpleIteration(store, null);

	}

	protected String[] getRandomAttibuteList(FeatureType fType) {

		String[] attrNames = new String[fType.size()];

		Iterator iter = fType.iterator();

		int i = 0;

		while (iter.hasNext()) {

			attrNames[i] = ((FeatureAttributeDescriptor) iter.next()).getName();

			i++;

		}

		return this.getRandomAttibuteList(attrNames);

	}

	protected Random getRandom(){

		if (rnd == null){

			rnd = new Random();

			rnd.setSeed(System.currentTimeMillis());

		}

		return rnd;

	}

	protected String[] getRandomAttibuteList(String[] attrNames) {

		int nAttributes = getRandom().nextInt(

				attrNames.length + (attrNames.length / 2)) + 1;

		TreeSet set = new TreeSet();

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

			set.add(attrNames[getRandom().nextInt(attrNames.length)]);

		}

		return (String[]) set.toArray(new String[0]);

	}

	public void testIterationFastAndStandart(FeatureStore store)

			throws Exception {

		this.testIterationFastAndStandart(store, null);

		FeatureQuery query = this.getDefaultQuery(store);

		// Random Attribute list

		query.setAttributeNames(getRandomAttibuteList(store

				.getDefaultFeatureType()));

		this.testIterationFastAndStandart(store, query);

		// Sorted

		FeatureAttributeDescriptor attr = getFirstAttributeOfType(store

				.getDefaultFeatureType(), new int[] { DataTypes.INT,

				DataTypes.LONG, DataTypes.STRING, DataTypes.DOUBLE, DataTypes.FLOAT });

		{

			// asure that attr is in query attributes

			boolean attrFound = false;

			String[] curAttrs = query.getAttributeNames();

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

				if (curAttrs[i].equals(attr.getName())) {

					attrFound = true;

					break;

				}

			}

			if (!attrFound) {

				String[] newAttrs = new String[curAttrs.length + 1];

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

					newAttrs[i] = curAttrs[i];

				}

				newAttrs[curAttrs.length] = attr.getName();

				query.setAttributeNames(newAttrs);

			}

		}

		query.getOrder().add(attr.getName(), true);

		this.testIterationFastAndStandart(store, query);

		// Filter

		query = this.getDefaultQuery(store);

		query.setFilter(new Evaluator(){

		    private EvaluatorFieldsInfo evaluatorFieldsInfo = new EvaluatorFieldsInfo();

			public Object evaluate(EvaluatorData data)

					throws EvaluatorException {

				// TODO Auto-generated method stub

				return Boolean.TRUE;

			}

			public String getSQL() {

				return "true = true";

			}

			public String getDescription() {

				// TODO Auto-generated method stub

				return null;

			}

			public String getName() {

				return "AlwaysTrue";

			}

			public EvaluatorFieldsInfo getFieldsInfo() {				

				return evaluatorFieldsInfo;

			}

		});

		this.testIterationFastAndStandart(store, query);

		// Filter + Sorted

		query.getOrder().add(attr.getName(), true);

		this.testIterationFastAndStandart(store, query);

	}

	public void testSimpleIteration(FeatureStore store, FeatureQuery query) {

		FeatureSet set;

		try {

			if (query == null) {

				query = this.getDefaultQuery(store);

			}

			set = store.getFeatureSet(query);

			FeatureType type = set.getDefaultFeatureType();

			DisposableIterator it = set.iterator();

			Feature feature;

			printFeatureTypeColNames(type, 15);

			while (it.hasNext()) {

				feature = (Feature) it.next();

				printFeature(feature, false, 15);

			}

			it.dispose();

			set.dispose();

		} catch (DataException e3) {

			e3.printStackTrace();

			fail();

			return;

		}

	}

	public void testIterationFastAndStandart(FeatureStore store,

			FeatureQuery query) {

		FeatureSet set;

		try {

			if (query == null) {

				query = this.getDefaultQuery(store);

			}

			set = store.getFeatureSet(query);

			DisposableIterator it = set.iterator();

			DisposableIterator fit = set.fastIterator();

			assertTrue(this.compareFeatureIterators(it, fit));

			it.dispose();

			fit.dispose();

			set.dispose();

		} catch (DataException e3) {

			e3.printStackTrace();

			fail();

			return;

		}

	}

	public void testSimpleIteration(DataStoreParameters parameters)

			throws Exception {

		FeatureStore store = null;

		store = (FeatureStore) dataManager.openStore(parameters

				.getDataStoreName(), parameters);

		this.testSimpleIteration(store);

		store.dispose();

	}

	public void testIterationFastAndStandart(DataStoreParameters parameters)

			throws Exception {

		FeatureStore store = null;

		store = (FeatureStore) dataManager.openStore(parameters

				.getDataStoreName(), parameters);

		this.testIterationFastAndStandart(store);

		store.dispose();

	}

	/**

	 *

	 * @param count

	 *            if (< 0) list.size() >= 1 else list.size() == count

	 * @throws Exception

	 */

	public void testExplorerList(int count) throws Exception {

		FeatureStore store = null;

		DataStoreParameters params = getDefaultDataStoreParameters();

		store = (FeatureStore) dataManager.openStore(params.getDataStoreName(),

				params);

		DataServerExplorer explorer;

		explorer = store.getExplorer();

		if (count < 0) {

			assertTrue(explorer.list().size() >= 1);

		} else {

			assertTrue(explorer.list().size() == count);

		}

		store.dispose();

		explorer.dispose();

	}

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

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

	public void testIterationFastAndStandart() throws Exception {

		this.testIterationFastAndStandart(this.getDefaultDataStoreParameters());

	}

	public void testSimpleIteration() throws Exception {

		this.testSimpleIteration(this.getDefaultDataStoreParameters());

	}

	public void testInitializeStore() throws Exception {

		DataStoreParameters params = getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.openStore(params

				.getDataStoreName(), params);

		assertNotNull(store.getMetadataID());

		assertNotNull(store.getName());

		assertEquals(store.getEnvelope(), store.getDynValue("Envelope"));

		assertTrue("Feature count not > 0", store.getFeatureCount() > 0);

		if (store.isLocksSupported()) {

			assertNotNull(store.getLocks());

		} else {

			assertNull(store.getLocks());

		}

		store.dispose();

	}

	public void testExplorer() throws Exception {

		if (!this.hasExplorer()) {

			return;

		}

		this.testExplorerList(-1);

	}

	public void testSelection() throws Exception {

		DataStoreParameters parameters = this.getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.openStore(parameters

				.getDataStoreName(), parameters);

		FeatureSet set = store.getFeatureSet();

		assertTrue(store.getFeatureSelection().isEmpty());

		store.setSelection(set);

		assertFalse(store.getFeatureSelection().isEmpty());

		assertEquals(set.getSize(), store.getFeatureSelection().getSize());

		DisposableIterator iter = set.iterator();

		while (iter.hasNext()) {

			assertTrue(store.getFeatureSelection().isSelected(

					(Feature) iter.next()));

		}

		iter.dispose();

		store.getFeatureSelection().reverse();

		assertTrue(store.getFeatureSelection().isEmpty());

		assertEquals(0, store.getFeatureSelection().getSize());

		iter = set.iterator();

		while (iter.hasNext()) {

			assertFalse(store.getFeatureSelection().isSelected(

					(Feature) iter.next()));

		}

		iter.dispose();

		store.getFeatureSelection().reverse();

		assertEquals(set.getSize(), store.getFeatureSelection().getSize());

		assertFalse(store.getFeatureSelection().isEmpty());

		set.dispose();

	}

	public void testCustomFTypeSet() throws Exception {

		DataStoreParameters dbfParameters = this

				.getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.openStore(dbfParameters

				.getDataStoreName(), dbfParameters);

		testCustomFTypeSet(store);

		store.dispose();

	}

	public void testCustomFTypeSet(FeatureStore store) throws Exception{

		FeatureSet set, set1;

		FeatureQuery query;

		DisposableIterator iter, iter1;

		Iterator attrIter;

		FeatureAttributeDescriptor attr;

		set = store.getFeatureSet(this.getDefaultQuery(store));

		attrIter = store.getDefaultFeatureType().iterator();

		String[] names;

		while (attrIter.hasNext()) {

			attr = (FeatureAttributeDescriptor) attrIter.next();

			int fieldIndex = attr.getIndex();

			query = this.getDefaultQuery(store);

			String fieldName = store.getDefaultFeatureType()

			.getAttributeDescriptor(fieldIndex).getName();

			names = new String[] { fieldName };

			query.setAttributeNames(names);

			set1 = store.getFeatureSet(query);

			if (getRandom().nextBoolean()) {

				iter = set.fastIterator();

			} else {

				iter = set.iterator();

			}

			if (getRandom().nextBoolean()) {

				iter1 = set1.fastIterator();

			} else {

				iter1 = set1.iterator();

			}

			assertTrue(compareFeatureIterators(iter, iter1, names));

			iter.dispose();

			iter1.dispose();

			set1.dispose();

		}

		int ntimes = getRandom().nextInt(10) + 5;

		FeatureType type = store.getDefaultFeatureType();

		query = this.getDefaultQuery(store);

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

			names = getRandomAttibuteList(type);

			query.setAttributeNames(names);

			set1 = store.getFeatureSet(query);

			if (getRandom().nextBoolean()) {

				iter = set.fastIterator();

			} else {

				iter = set.iterator();

			}

			if (getRandom().nextBoolean()) {

				iter1 = set1.fastIterator();

			} else {

				iter1 = set1.iterator();

			}

			assertTrue(compareFeatureIterators(iter, iter1, names));

			iter.dispose();

			iter1.dispose();

			iter1 = set1.fastIterator();

			assertTrue(checksAttributesPositions(iter1, names));

			iter1.dispose();

			iter1 = set1.iterator();

			assertTrue(checksAttributesPositions(iter1, names));

			iter1.dispose();

			set1.dispose();

		}

		set.dispose();

	}

	protected boolean checksAttributesPositions(DisposableIterator iter,

			String[] names) {

		Feature feature;

		FeatureType type;

		FeatureAttributeDescriptor attr;

		while (iter.hasNext()) {

			feature = (Feature) iter.next();

			type = feature.getType();

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

				attr = type.getAttributeDescriptor(i);

				if (!names[i].equals(attr.getName())) {

					getLogger().error(

							"Error in attribute {} (expected: '{}' have: '{}'",

							new Object[] { new Integer(i), names[i],

									attr.getName() });

					return false;

				}

			}

		}

		return true;

	}

	 public void testPersistence() throws Exception {

		if (ToolsLocator.getPersistenceManager() == null) {

			fail("Default Persistence Manager not register");

		}

		DataStoreParameters params = this.getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.openStore(params

				.getDataStoreName(), params);

		testSimpleIteration(store);

		PersistentState state = ToolsLocator.getPersistenceManager().getState(

				store);

		FeatureStore store2 = (FeatureStore) ToolsLocator

				.getPersistenceManager().create(state);

		testSimpleIteration(store2);

		assertTrue(compareStores(store, store2));

		store.dispose();

		store2.dispose();

	}

	public void testSort() throws Exception {

		DataStoreParameters dbfParameters = this

				.getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.openStore(dbfParameters

				.getDataStoreName(), dbfParameters);

		testSort(store);

		store.dispose();

	}

	public void testSort(FeatureStore store) throws Exception{

		FeatureSet set1;

		FeatureQuery query;

		DisposableIterator iter1;

		Iterator attrIter;

		FeatureAttributeDescriptor attr;

		attrIter = store.getDefaultFeatureType().iterator();

		String[] names;

		while (attrIter.hasNext()) {

			attr = (FeatureAttributeDescriptor) attrIter.next();

			if (attr.getType() == DataTypes.GEOMETRY) {

				continue;

			}

			query = this.getDefaultQuery(store);

			String fieldName = attr.getName();

			names = new String[] { fieldName };

			query.setAttributeNames(names);

			query.getOrder().add(fieldName, getRandom().nextBoolean());

			set1 = store.getFeatureSet(query);

			if (getRandom().nextBoolean()) {

				iter1 = set1.fastIterator();

			} else {

				iter1 = set1.iterator();

			}

			assertTrue(checkSort(iter1, query));

			iter1.dispose();

			set1.dispose();

		}

		int ntimes = getRandom().nextInt(10) + 5;

		FeatureType type = store.getDefaultFeatureType();

		query = this.getDefaultQuery(store);

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

			names = getRandomAttibuteList(type);

			int nShortFields = getRandom().nextInt(names.length) + 1;

			query.getOrder().clear();

			for (int j = 0; j < nShortFields; j++) {

				attr = store.getDefaultFeatureType().getAttributeDescriptor(names[getRandom().nextInt(names.length)]);

				if (attr.getType() == DataTypes.INT

						|| attr.getType() == DataTypes.LONG

						|| attr.getType() == DataTypes.DOUBLE

						|| attr.getType() == DataTypes.STRING

						|| attr.getType() == DataTypes.DATE

						|| attr.getType() == DataTypes.BOOLEAN

						|| attr.getType() == DataTypes.BYTE

						|| attr.getType() == DataTypes.FLOAT) {

					query.getOrder().add(attr.getName(),

							getRandom().nextBoolean());

				}

			}

			query.setAttributeNames(names);

			set1 = store.getFeatureSet(query);

			// if (getRandom().nextBoolean()) {

				iter1 = set1.fastIterator();

				// } else {

				// iter1 = set1.iterator();

				// }

				assertTrue(checkSort(iter1, query));

				iter1.dispose();

				set1.dispose();

		}

	}

	public boolean checkSort(Iterator iter, FeatureQuery query) {

		FeatureQueryOrderMember order;

		Feature prevFeature = null;

		Feature currFeature = null;

		boolean isFirst = true;

		Comparable v1, v2;