Application: gvSIG desktop

<assembly>

	<id>distribution</id>

	<formats>

		<format>dir</format>

	</formats>

	<fileSets>

		<!-- Extructure for the extension -->

		<fileSet>

			<directory>src/main/resources/config</directory>

			<outputDirectory>${extension.install.dir.name}

			</outputDirectory>

		</fileSet>

		<fileSet>

			<directory>src/main/resources/images</directory>

			<outputDirectory>${extension.install.dir.name}/images

			</outputDirectory>

		</fileSet>

		<fileSet>

			<directory>src/main/resources/about</directory>

			<outputDirectory>${extension.install.dir.name}

			</outputDirectory>

		</fileSet>

		<fileSet>

			<directory>src/main/resources/locale</directory>

			<outputDirectory>${extension.install.dir.name}

			</outputDirectory>

		</fileSet>

	</fileSets>

	<files>

		<file>

			<source>src/main/resources/build.number</source>

			<outputDirectory>${extension.install.dir.name}

			</outputDirectory>

		</file>

	</files>

	<dependencySets>

		<dependencySet>

			<outputDirectory>${extension.install.dir.name}/${library-dir}

			</outputDirectory>

			<includes>

				<include>org.gvsig:org.gvsig.symbology</include>

			</includes>

		</dependencySet>

	</dependencySets>

</assembly>

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<!-- 

Log4J configuration file for unit tests execution.

 -->

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appender configuration to show logging messages through the console -->

	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">

		<layout class="org.apache.log4j.PatternLayout">

			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />

		</layout>

	</appender>

	<!-- 

	Activate logging messages of DEBUG level of higher only for the

	InputCoordinatesPanel class.

	You can put full classes names or packages instead, to configure

	logging for all the classes and subpackages of the package.

	-->

	<category name="org.gvsig.symbology.gui.InputCoordinatesPanel">

		<priority value="DEBUG" />

	</category>

	<!-- 

	By default, show only logging messages of INFO level or higher, 

	through the previously configured CONSOLE appender. 

	-->

	<root>

		<priority value="INFO" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

Put into this folder the resources needed by your test classes.

This folder is added to the Tests classpath, so you can load any resources 

through the ClassLoader.

By default, in this folder you can find an example of log4j configuration,

prepared to log messages through the console, so logging works when you

run your tests classes.

package org.gvsig.symbology.fmap.mapcontext.rendering;

import java.io.File;

import junit.framework.Test;

import junit.framework.TestCase;

import junit.framework.TestSuite;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.TestDrawFills;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.TestDrawLines;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.TestDrawMarkers;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.TestISymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.TestMultiLayerSymbol;

public class AllTests extends TestCase{

	/**

	 * The EPSG:4326 projection

	 */

	public static IProjection TEST_DEFAULT_PROJECTION =

		CRSFactory.getCRS("EPSG:4326");

	/**

	 * The EPSG:23030 projection

	 */

	public static IProjection TEST_DEFAULT_MERCATOR_PROJECTION =

		CRSFactory.getCRS("EPSG:23030");

	/**

	 * The EPSG:23029 projection

	 */

	public static IProjection test_newProjection =

		CRSFactory.getCRS("EPSG:23029");

	public static Test suite() {

		TestSuite suite = new TestSuite("Test for com.iver.cit.gvsig.fmap");

		//$JUnit-BEGIN$

		/* Symbols (jaume) */

			// integration tests

				// ISymbol

				suite.addTestSuite(TestISymbol.class);

				suite.addTestSuite(TestMultiLayerSymbol.class);

				// CartographicSupport

				suite.addTestSuite(TestCartographicSupportForSymbol.class);

		//

		/*

		 * Feature iterators

		 * */

//		suite.addTestSuite(FeatureIteratorTest.class);

		/*

		 * Other Tests present in FMap (cesar)

		 * Remove them from here and the src-test dir if they are not

		 * useful anymore.

		 */

//		suite.addTestSuite(TestAbstractIntervalLegend.class);

		suite.addTestSuite(TestCartographicSupportForSymbol.class);

		suite.addTestSuite(TestDrawFills.class);

		suite.addTestSuite(TestDrawLines.class);

		suite.addTestSuite(TestDrawMarkers.class);

//		suite.addTestSuite(TestIClassifiedLegend.class);

//		suite.addTestSuite(TestILegend.class);

		suite.addTestSuite(TestMultiLayerSymbol.class);

		//$JUnit-END$

		return suite;

	}

//// jaume

//// PASTED FROM FeatureIteratorTest.java to be globally accessible

	static final String fwAndamiDriverPath = "../_fwAndami/gvSIG/extensiones/com.iver.cit.gvsig/drivers";

	private static File baseDataPath;

	private static File baseDriversPath;

	public static void setUpDrivers() {

//		try {

//			URL url = AllTests.class.getResource("testdata");

//			if (url == null)

//				throw new Exception("No se encuentra el directorio con datos de prueba");

//

//			baseDataPath = new File(url.getFile());

//			if (!baseDataPath.exists())

//				throw new Exception("No se encuentra el directorio con datos de prueba");

//

//			baseDriversPath = new File(fwAndamiDriverPath);

//			if (!baseDriversPath.exists())

//				throw new Exception("Can't find drivers path: " + fwAndamiDriverPath);

//

//			LayerFactory.setDriversPath(baseDriversPath.getAbsolutePath());

//			if (LayerFactory.getDM().getDriverNames().length < 1)

//				throw new Exception("Can't find drivers in path: " + fwAndamiDriverPath);

//		} catch (Exception e) {

//			throw new RuntimeException(e);

//		}

	}

	public static FLayer newLayer(String fileName,

			String driverName)

	throws LoadLayerException {

//		File file = new File(baseDataPath, fileName);

//		return LayerFactory.createLayer(fileName,

//				driverName,

//				file, TEST_DEFAULT_MERCATOR_PROJECTION);

	return null;

	}

	public static MapContext newMapContext(IProjection projection) {

		ViewPort vp = new ViewPort(projection);

		return new MapContext(vp);

	}

//// end past

}

 /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.legend;

import java.awt.Dimension;

import java.awt.Rectangle;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataQuery;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataSet;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.NeedEditingModeException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.primitive.Curve;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.GeneralPathX;

import org.gvsig.fmap.mapcontext.rendering.legend.IClassifiedVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.AbstractIntervalLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.FInterval;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.TestISymbol;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.undo.RedoException;

import org.gvsig.tools.undo.UndoException;

import org.gvsig.tools.visitor.Visitor;

/**

 * Integration test to ensure that the legends which implements the

 * IVectorialIntervalLegend interface follow the rules that follow the managing

 * of them by the application.

 *

 * @author pepe vidal salvador - jose.vidal.salvador@iver.es

 */

public class TestAbstractIntervalLegend extends AbstractLibraryAutoInitTestCase {

	private static final Integer v0 = new Integer(0);

	private static final Integer v1 = new Integer(1);

	private static final Integer v2 = new Integer(2);

	private static final Integer v3 = new Integer(3);

	private static final String FIELD3 = "field3";

	private static final String FIELD2 = "field2";

	private static final String FIELD1 = "field1";

	private static final String FIELD0 = "field0";

	private static final int FIELDID = 0;

	private static final Integer[] feature0Values = new Integer[] { v0, v1, v2, v3, };

	private static final Integer[] feature1Values = new Integer[] { v3, v0, v1, v2, };

	private static final Integer[] feature2Values = new Integer[] { v2, v3, v0, v1, };

	private static final Integer[] feature3Values = new Integer[] { v1, v2, v3, v0, };

	private static final Integer[][] featureValues = new Integer[][] {

		feature0Values,

		feature1Values,

		feature2Values,

		feature3Values,};

	private static String[] fieldNames = new String[] {FIELD0,FIELD1,FIELD2,FIELD3,};

	// private static final Value v4 = (Value)ValueFactory.createValue(4);

	// private static final Value v5 = (Value)ValueFactory.createValue(5);

	// private static final Value v6 = (Value)ValueFactory.createValue(6);

	// private static final Value v7 = (Value)ValueFactory.createValue(7);

	// private static final Value v8 = (Value)ValueFactory.createValue(8);

	// private static final Value v9 = (Value)ValueFactory.createValue(9);

	private AbstractIntervalLegend[] intervalLegends;

	private MockDataSource mockDataSource = new MockDataSource();

	/**

	 * To avoid duplicated validation logic in the test a mock object is created

	 * to use a DataSource for this test.

	 *

	 */

	private class MockDataSource implements FeatureStore {

		public boolean allowWrite() {

			return false;

		}

		public void beginEditingGroup(String description)

				throws NeedEditingModeException {

		}

		public boolean canWriteGeometry(int gvSIGgeometryType)

				throws DataException {

			return false;

		}

		public void cancelEditing() throws DataException {

		}

		public FeatureSelection createFeatureSelection() throws DataException {

			return null;

		}

		public FeatureIndex createIndex(FeatureType featureType,

				String attributeName, String indexName) throws DataException {

			return null;

		}

		public EditableFeature createNewFeature() throws DataException {

			return null;

		}

		public EditableFeature createNewFeature(FeatureType type,

				Feature defaultValues) throws DataException {

			return null;

		}

		public EditableFeature createNewFeature(FeatureType type,

				boolean defaultValues) throws DataException {

			return null;

		}

		public EditableFeature createNewFeature(boolean defaultValues)

				throws DataException {

			return null;

		}

		public void delete(Feature feature) throws DataException {

		}

		public void edit() throws DataException {

		}

		public void edit(int mode) throws DataException {

		}

		public void endEditingGroup() throws NeedEditingModeException {

		}

		public void finishEditing() throws DataException {

		}

		public FeatureType getDefaultFeatureType() throws DataException {

			return null;

		}

		public Envelope getEnvelope() {

			return null;

		}

		public Feature getFeatureByReference(FeatureReference reference)

				throws DataException {

			return null;

		}

		public Feature getFeatureByReference(FeatureReference reference,

				FeatureType featureType) throws DataException {

			return null;

		}

		public FeatureSelection getFeatureSelection() throws DataException {

			return null;

		}

		public FeatureSet getFeatureSet() throws DataException {

			return null;

		}

		public FeatureSet getFeatureSet(FeatureQuery featureQuery)

				throws DataException {

			return null;

		}

		public void getFeatureSet(FeatureQuery featureQuery, Observer observer)

				throws DataException {

		}

		public void getFeatureSet(Observer observer) throws DataException {

		}

		public List getFeatureTypes() throws DataException {

			return null;

		}

		public FeatureIndexes getIndexes() {

			return null;

		}

		public FeatureLocks getLocks() throws DataException {

			return null;

		}

		public DataStoreParameters getParameters() {

			return null;

		}

		public IProjection getSRSDefaultGeometry() throws DataException {

			return null;

		}

		public FeatureStoreTransforms getTransforms() {

			return null;

		}

		public void insert(EditableFeature feature) throws DataException {

		}

		public boolean isAppendModeSupported() {

			return false;

		}

		public boolean isAppending() {

			return false;

		}

		public boolean isEditing() {

			return false;

		}

		public boolean isLocksSupported() {

			return false;

		}

		public void setSelection(FeatureSet selection) throws DataException {

		}

		public void update(EditableFeatureType featureType)

				throws DataException {

		}

		public void update(EditableFeature feature) throws DataException {

		}

		public void validateFeatures(int mode) throws DataException {

		}

		public DataSet createSelection() throws DataException {

			return null;

		}

		public void dispose() {

		}

		public Iterator getChildren() {

			return null;

		}

		public DataSet getDataSet() throws DataException {

			return null;

		}

		public DataSet getDataSet(DataQuery dataQuery) throws DataException {

			return null;

		}

		public void getDataSet(Observer observer) throws DataException {

		}

		public void getDataSet(DataQuery dataQuery, Observer observer)

				throws DataException {

		}

		public DataServerExplorer getExplorer() throws DataException {

			return null;

		}

		public String getName() {

			return null;

		}

		public DataSet getSelection() throws DataException {

			return null;

		}

		public void refresh() throws DataException {

		}

		public void setSelection(DataSet selection) throws DataException {

		}

		public void beginComplexNotification() {

		}

		public void disableNotifications() {

		}

		public void enableNotifications() {

		}

		public void endComplexNotification() {

		}

		public void addObserver(Observer o) {

		}

		public void deleteObserver(Observer o) {

		}

		public void deleteObservers() {

		}

		public void saveToState(PersistentState state)

				throws PersistenceException {

		}

		public void loadFromState(PersistentState state) throws PersistenceException {

		}

		public FeatureQuery createFeatureQuery() {

			return null;

		}

		public boolean canRedo() {

			return false;

		}

		public boolean canUndo() {

			return false;

		}

		public List getRedoInfos() {

			return null;

		}

		public List getUndoInfos() {

			return null;

		}

		public void redo() throws RedoException {

		}

		public void redo(int num) throws RedoException {

		}

		public void undo() throws UndoException {

		}

		public void undo(int num) throws UndoException {

		}

		public FeatureIndex createIndex(FeatureType featureType,

				String attributeName, String indexName, Observer observer)

				throws DataException {

			return null;

		}

		public Object getMetadataID() {

			return null;

		}

		public void delegate(DynObject dynObject) {

		}

		public DynClass getDynClass() {

			return null;

		}

		public Object getDynValue(String name) throws DynFieldNotFoundException {

			return null;

		}

		public boolean hasDynValue(String name) {

			return false;

		}

		public void implement(DynClass dynClass) {

		}

		public Object invokeDynMethod(String name, DynObject context)

				throws DynMethodException {

			return null;

		}

		public Object invokeDynMethod(int code, DynObject context)

				throws DynMethodException {

			return null;

		}

		public void setDynValue(String name, Object value)

				throws DynFieldNotFoundException {

		}

		/*

		 * (non-Javadoc)

		 *

		 * @see org.gvsig.metadata.Metadata#getMetadataChildren()

		 */

		public Set getMetadataChildren() {

			return null;

		}

		/*

		 * (non-Javadoc)

		 *

		 * @see org.gvsig.metadata.Metadata#getMetadataName()

		 */

		public String getMetadataName() {

			return null;

		}

		public FeatureType getFeatureType(String featureTypeId)

				throws DataException {

			return null;

		}

		public DataQuery createQuery() {

			return null;

		}

		public long getFeatureCount() throws DataException {

			return 0;

		}

		public void accept(Visitor visitor, DataQuery dataQuery)

				throws BaseException {

		}

		public void accept(Visitor visitor) throws BaseException {

		}

		public void createCache(String name,

				DynObject parameters) throws DataException {

			// Do nothing

		}

		public FeatureCache getCache() {

			return null;

		}

		public void clear() {

			// Nothing to do

		}

		public void export(DataServerExplorer explorer, String provider,

				NewFeatureStoreParameters params) throws DataException {

			// Nothing to do

		}

		public String getProviderName() {

			return null;

		}

	}

	 private static final FInterval interval0=new FInterval(0,2);

	 private static final FInterval interval1=new FInterval(3,5);

	 private static final FInterval interval2=new FInterval(6,8);

	 private static final FInterval interval3=new FInterval(9,11);

	// private static final Value interval4;

	// private static final Value interval5;

	// private static final Value interval6;

	// private static final Value interval7;

	// private static final Value interval8;

	// private static final Value interval9;

	Hashtable symTable;

	private ISymbol[] symbols;

	private FInterval[] sampleIntervals = new FInterval[] { interval0, interval1, interval2, interval3, };

	private Feature[] features;

	// private FInterval[] intervals = new FInterval[] {

	// interval0,

	// interval1,

	// interval2,

	// interval3,

	// interval4,

	// interval5,

	// interval6,

	// interval7,

	// interval8,

	// interval9,

	// };

	protected void doSetUp() throws Exception {

		features = new Feature[4];

		// initialize test values

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

			// create the geometry associated to the feature

			int size = 200;

			Dimension d = new Dimension(size, size);

			Rectangle aShape = new Rectangle(i * size, i * size, d.width,

					d.height);

			GeometryManager geomManager = GeometryLocator.getGeometryManager();

			Curve curve = (Curve)geomManager.create(TYPES.CURVE, SUBTYPES.GEOM2D);

			curve.setGeneralPath(new GeneralPathX(aShape.getPathIterator(null)));

			/*

			 * create a full-featured Feature with randomed values at its fields

			 * to avoid testing over the same values each time

			 */

			//TODO

//			features[i] = new MemoryFeature(geom, featureValues[i], "[" + i

//					+ "]");

		}

		// initialize the symbol subset for this test

		TestISymbol.addSymbols();

		symbols = TestISymbol.getNewSymbolInstances();

		// initialize the legends for this test

		ILegend[] allLegends = TestILegend.getNewLegendInstances();

		ArrayList intervalLegends = new ArrayList();

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

			if (allLegends[i] instanceof AbstractIntervalLegend) {

				intervalLegends.add(allLegends[i]);

			}

			if (allLegends[i] instanceof IClassifiedVectorLegend) {

				IClassifiedVectorLegend cvl = (IClassifiedVectorLegend) allLegends[i];

				cvl.setClassifyingFieldNames(new String[] { fieldNames[FIELDID] });

//				cvl.setFeatureStore(mockDataSource);

			}

		}

		this.intervalLegends = (AbstractIntervalLegend[]) intervalLegends

				.toArray(new AbstractIntervalLegend[intervalLegends.size()]);

	}

	/**

	 * This method is used to add symbols to a legend.That is, it takes an array

	 * of AbstractIntervalLegend which is empty and, using a second array

	 * of FIntervals(values), the first one is filled.Also, a hash table is filled

	 * using the array of FIntervals (it will be useful in some tests to check

	 * that a symbol can be taken using a feature) .

	 *

	 * @param legend

	 * @return

	 */

	private void fillClassifiedLegend(AbstractIntervalLegend legend,

			FInterval[] values) {

		// initialize the hash table

		symTable = new Hashtable();

		// to add symbols to the legend and the hash table

		for (int j = 0; j < values.length; j++) {

			ISymbol sym = symbols[j % symbols.length];

			legend.addSymbol(values[j], sym);

			symTable.put(values[j], sym);

		}

	}

	/**

	 * This test ensures that when a legend is filled, the number of symbols

	 * added is correct. To do it, is checked that the number of symbols of a

	 * legend is the same as the length of the array of example values that we

	 * have.

	 *

	 * @throws ReadDriverException

	 */

	public void testICLAdittion() throws ReadException {

		// Fills the legend

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

			fillClassifiedLegend(intervalLegends[i], sampleIntervals);

		}

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

			assertEquals(intervalLegends[i].getClass().getName()

					+ " fails with the comparation of the number of symbols",

					intervalLegends[i].getSymbols().length,

					sampleIntervals.length);

		}

	}

	/**

	 * This test ensures that the symbols that we have previously added to a

	 * legend are accessible using its features.To do it, this test compares the

	 * symbol taken from the legend with the symbol taken from the hashTable

	 * (using the same feature).

	 * @throws Exception 

	 */

	public void testICLCheckValueSymbols() throws Exception {

		ISymbol tableSym =null;

		// fills the legends

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

			fillClassifiedLegend(intervalLegends[i], sampleIntervals);

		}

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

			// For each feature

			for (int j = 0; j < features.length; j++) {

				Feature myFeature = features[i];

				// takes the value of the field that identifies the feature

				Object val = myFeature.get(FIELDID);

				// the last value is used to access to the hash table to obtain

				// a symbol

				if(interval0.isInInterval(val)) {

					tableSym = (ISymbol) symTable.get(interval0);

				} else if(interval1.isInInterval(val)) {

					tableSym = (ISymbol) symTable.get(interval1);

				} else if(interval2.isInInterval(val)) {

					tableSym = (ISymbol) symTable.get(interval2);

				} else if(interval3.isInInterval(val)) {

					tableSym = (ISymbol) symTable.get(interval3);

				}

				AbstractIntervalLegend leg = intervalLegends[i];

				// takes the symbol from a legend using the feature

				ISymbol legendSym = leg.getSymbolByFeature(myFeature);

				// compares that both symbols are the same

				assertEquals(legendSym.getClass().getName()

						+ " fails with the comparation of the class symbols",

						legendSym, tableSym);

			}

		}

	}

}

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.legend;

import java.awt.Color;

import java.lang.reflect.Field;

import java.util.ArrayList;

import junit.framework.TestCase;

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.rendering.legend.IClassifiedVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorialIntervalLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorialUniqueValueLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.SingleSymbolLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.VectorialIntervalLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.VectorialUniqueValueLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.SimpleFillSymbol;

import org.gvsig.utils.XMLException;

/**

 * Integration test to ensure that the legends follow the rules that follow the

 * managing of them by the application.

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 */

public class TestILegend extends TestCase {

	 private static ArrayList classesToTest;

	 transient private ILegend[] legends;

	 private static ArrayList getClassesToTest() throws MapContextException {

	        if (classesToTest == null) {

	            classesToTest = new ArrayList();

	          TestILegend.addLegendToTest(VectorialIntervalLegend.class);

	          TestILegend.addLegendToTest(VectorialUniqueValueLegend.class);

	          TestILegend.addLegendToTest(SingleSymbolLegend.class);

//	          TestILegend.addLegendToTest(QuantityByCategoryLegend.class);

//	          TestILegend.addLegendToTest(DotDensityLegend.class);

//	          TestILegend.addLegendToTest(ProportionalSymbolsLegend.class);

//	          TestILegend.addLegendToTest(GraduatedSymbolLegend.class);

	        }

	        return classesToTest;

	    }

	 /**

	  * This method fills the attributes of a legend.The purpose is to ensure that the new

	  * legend is 'full' and ready to be used for a test.

	  * @param le

	  * @return

	 * @throws MapContextException 

	  */

	 private static ILegend fillthelegend(ILegend le) throws MapContextException {

		 SimpleFillSymbol mfs = new SimpleFillSymbol();

		 mfs.setFillColor(Color.ORANGE.darker());

		 mfs.setDescription("hola");

		 mfs.setIsShapeVisible(true);

		 String[] cad = new String[] {"Pepe","Juan"};

		 if(le instanceof IVectorLegend) {

			 IVectorLegend ssl=(IVectorLegend)le;

			 ssl.setDefaultSymbol(mfs);

		 }

		 if(le instanceof IVectorialUniqueValueLegend) {

			 IVectorialUniqueValueLegend ivuvl= (IVectorialUniqueValueLegend)le;

			 ivuvl.setClassifyingFieldNames(cad);

			 }

		 if(le instanceof IVectorialIntervalLegend) {

			 IVectorialIntervalLegend ivil=(IVectorialIntervalLegend)le;

			 ivil.setClassifyingFieldNames(cad);

			 }

		 if(le instanceof IClassifiedVectorLegend) {

			 IClassifiedVectorLegend icvl=(IClassifiedVectorLegend)le;

			 icvl.setClassifyingFieldNames(cad);

		 }

		 return le;

	 }

	 public static void addLegendToTest(Class legendClass) throws MapContextException {

	        try {

	            ILegend len = (ILegend) legendClass.newInstance();

	            fillthelegend(len);

//	            len.getXMLEntity();

	        } catch (InstantiationException e) {

	            // TODO Auto-generated catch block

	            fail("Instantiating class, cannot test a non-instantiable symbol");

	        } catch (IllegalAccessException e) {

	            // TODO Auto-generated catch block

	            fail("Class not instantiable");

	        } catch (ClassCastException ccEx) {

	            fail("Cannot test a non symbol class");

//	        } catch (XMLException e) {

//	        	fail("Cannot test a non symbol class");

			}

	        getClassesToTest().add(legendClass);

	    }

	 /**

	  * The main purpose of this method is to create new legend instances to be used for

	  * other test methods.The new instances will be filled for the fillthelegend method.

	  * @return

	 * @throws MapContextException 

	  * @throws FieldNotFoundException

	  */

	 public static ILegend[] getNewLegendInstances() throws MapContextException{

	        ILegend[] legends = new ILegend[getClassesToTest().size()];

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

	            try {

	            	legends[i] = (ILegend) ((Class) getClassesToTest().get(i)).newInstance();

	            	fillthelegend(legends[i]);

	            } catch (InstantiationException e) {

	                fail("Instantiating class");

	            } catch (IllegalAccessException e) {

	                fail("Class not instantiable");

	            }

	        }

	        return legends;

	    }

	  protected void setUp() throws Exception {

	      legends = getNewLegendInstances();

	    }

	/**

	 * this test ensures that the legend is self-defining. Checks that

	 * the symbols contained by it can be replicated, and the rules for

	 * such symbols as well.

	 * @throws XMLException

	 */

	public void testILegendSelfDefinition() throws XMLException{

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

			final ILegend theLegend = legends[i];

			final ILegend cloneLegend =theLegend.cloneLegend();

			assertTrue(theLegend.getClass().getName()+ " wrong class name declaration in getXMLEntity() ",

					cloneLegend.getClass().equals(theLegend.getClass()));

	        final Field[] theLegendFields = theLegend.getClass().getFields();

            for (int j = 0; j < theLegendFields.length; j++) {

                final Field fi = theLegendFields[j];

                final boolean wasAccessible = fi.isAccessible();

                fi.setAccessible(true);

                try {

                    assertTrue(theLegend.getClass().getName() + " fails or misses clonning the field " +fi.getName(),

                            fi.get(theLegend).equals(fi.get(cloneLegend)));

                } catch (IllegalArgumentException e) {

                    fail();

                } catch (IllegalAccessException e) {

                    fail();

                }

                fi.setAccessible(wasAccessible);

            }

			}

		}

	/**

	 * this test ensures that any legend always have a symbol ready to be used.

	 * an empty legend is incorrect.

	 * @throws Exception 

	 *

	 */

	public void testSymbolAvailability() throws Exception {

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

			assertNotNull("Legend no. "+i+" '"+legends[i].getClass().getName()+" does not have a symbol ready to be used", legends[i].getDefaultSymbol());

		}

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

			if (legends[i] instanceof IVectorLegend) {

				IVectorLegend vectLegend = (IVectorLegend) legends[i];

				try {

					vectLegend.setDefaultSymbol(null);

					fail("setDefaultSymbol(ISymbol) should not accept null values");

				} catch (NullPointerException e) {

					// correct

				}

			}

		}

	}

}

 /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.legend;

import java.awt.Dimension;

import java.awt.Rectangle;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataQuery;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataSet;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.NeedEditingModeException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.primitive.Curve;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.GeneralPathX;

import org.gvsig.fmap.mapcontext.rendering.legend.IClassifiedLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IClassifiedVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.AbstractIntervalLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.TestISymbol;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.undo.RedoException;

import org.gvsig.tools.undo.UndoException;

import org.gvsig.tools.visitor.Visitor;

/**

 * Integration test to ensure that the legends which implements the

 * IClassifiedLegend interface follow the rules that follow the managing of them

 * by the application.

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 * @author pepe vidal salvador - jose.vidal.salvador@iver.es

 */

public class TestIClassifiedLegend extends AbstractLibraryAutoInitTestCase {

	private static final Integer v0 = new Integer(0);

	private static final Integer v1 = new Integer(1);

	private static final Integer v2 = new Integer(2);

	private static final Integer v3 = new Integer(3);

	private static final String FIELD3 = "field3";

	private static final String FIELD2 = "field2";

	private static final String FIELD1 = "field1";

	private static final String FIELD0 = "field0";

	private static final int FIELDID = 0;

//	private static final Integer[] feature0Values = new Integer[] { v0, v1, v2, v3, };

//	private static final Integer[] feature1Values = new Integer[] { v3, v0, v1, v2, };

//	private static final Integer[] feature2Values = new Integer[] { v2, v3, v0, v1, };

//	private static final Integer[] feature3Values = new Integer[] { v1, v2, v3, v0, };

//

//	private static final Integer[][] featureValues = new Integer[][] {

//		feature0Values,

//		feature1Values,

//		feature2Values,

//		feature3Values,};

	private static String[] fieldNames = new String[] {FIELD0,FIELD1,FIELD2,FIELD3,};

	// private static final Value v4 = (Value)ValueFactory.createValue(4);

	// private static final Value v5 = (Value)ValueFactory.createValue(5);

	// private static final Value v6 = (Value)ValueFactory.createValue(6);

	// private static final Value v7 = (Value)ValueFactory.createValue(7);

	// private static final Value v8 = (Value)ValueFactory.createValue(8);

	// private static final Value v9 = (Value)ValueFactory.createValue(9);

	private AbstractIntervalLegend[] intervalLegends;

//	private MockDataSource mockDataSource = new MockDataSource();

	/**

	 * To avoid duplicated validation logic in the test a mock object is created

	 * to use a DataSource for this test.

	 *

	 */

	private class MockDataSource implements FeatureStore {

		public boolean allowWrite() {

			return false;

		}

		public void beginEditingGroup(String description)

				throws NeedEditingModeException {

		}

		public boolean canWriteGeometry(int gvSIGgeometryType)

				throws DataException {

			return false;

		}

		public void cancelEditing() throws DataException {

		}

		public FeatureSelection createFeatureSelection() throws DataException {

			return null;

		}

		public FeatureIndex createIndex(FeatureType featureType,

				String attributeName, String indexName) throws DataException {

			return null;

		}

		public EditableFeature createNewFeature() throws DataException {

			return null;

		}

		public EditableFeature createNewFeature(FeatureType type,

				Feature defaultValues) throws DataException {

			return null;

		}

		public EditableFeature createNewFeature(FeatureType type,

				boolean defaultValues) throws DataException {

			return null;

		}