Application: gvSIG desktop

package com.iver.cit.gvsig.fmap.core.symbols;

import java.io.File;

import java.io.IOException;

import java.lang.reflect.Field;

import java.util.ArrayList;

import junit.framework.Test;

import junit.framework.TestCase;

import junit.framework.TestSuite;

import com.iver.cit.gvsig.fmap.core.FPoint2D;

import com.iver.cit.gvsig.fmap.core.GeneralPathX;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.ShapeFactory;

import com.iver.cit.gvsig.fmap.core.SymbologyFactory;

/**

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

 * managing of them by the application.

 *

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

 */

public class TestISymbol extends TestCase {

        private static ArrayList classesToTest;

        transient private ISymbol[] symbols;

        public static Test suite() {

                TestSuite suite = new TestSuite("Integration test for com.iver.cit.gvsig.fmap.core.ISymbol");

                suite.addTestSuite(TestDrawMarkers.class);

                suite.addTestSuite(TestDrawLines.class);

                suite.addTestSuite(TestDrawFills.class);

                return suite;

        }

        private static ArrayList getClassesToTest() {

                if (classesToTest == null) {

                        classesToTest = new ArrayList();

                        TestISymbol.addSymbolToTest(SimpleMarkerSymbol.class);

                        TestISymbol.addSymbolToTest(CharacterMarkerSymbol.class);

                        TestISymbol.addSymbolToTest(PictureMarkerSymbol.class);

                        TestISymbol.addSymbolToTest(DotDensityFillSymbol.class);

                        TestISymbol.addSymbolToTest(MarkerFillSymbol.class);

                        TestISymbol.addSymbolToTest(SimpleFillSymbol.class);

                        TestISymbol.addSymbolToTest(SimpleLineSymbol.class);

                        TestISymbol.addSymbolToTest(SimpleTextSymbol.class);

                        TestISymbol.addSymbolToTest(SmartTextSymbol.class);

                        TestISymbol.addSymbolToTest(SimpleMarkerSymbol.class);

                }

                return classesToTest;

        }

        public static void addSymbolToTest(Class symbolClass) {

                try {

                        ISymbol sym = (ISymbol) symbolClass.newInstance();

                        sym.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");

                }

                getClassesToTest().add(symbolClass);

        }

        public static ISymbol[] getNewSymbolInstances() {

                ISymbol[] symbols = new ISymbol[getClassesToTest().size()];

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

                        try {

                                symbols[i] = (ISymbol) ((Class) getClassesToTest().get(i)).newInstance();

                                if (symbols[i] instanceof PictureMarkerSymbol) {

                                        PictureMarkerSymbol pms = (PictureMarkerSymbol) symbols[i];

                                        try {

                                                pms.setImage(new File(TestISymbol.class.getResource("picture-marker.png").getFile()));

                                        } catch (IOException e) {

                                                fail("setting up a PictureMarkerSymbol");

                                        }

                                }

                        } catch (InstantiationException e) {

                                fail("Instantiating class");

                        } catch (IllegalAccessException e) {

                                fail("Class not instantiable");

                        }

                }

                return symbols;

        }

        protected void setUp() throws Exception {

                symbols = getNewSymbolInstances();

        }

        public void testPointSuitability() {

                final IGeometry dummyPointGeom = ShapeFactory.createPoint2D(new FPoint2D());

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

                        // text symbols are suitable for everything

                        if (symbols[i] instanceof ITextSymbol) {

                                assertTrue(symbols[i].getClassName()+" should be suitable for "+dummyPointGeom,

                                                symbols[i].isSuitableFor(dummyPointGeom));

                        } else

                        // marker symbols are suitable for points

                        if (symbols[i] instanceof IMarkerSymbol) {

                                assertTrue(symbols[i].getClassName()+" should be suitable for "+dummyPointGeom,

                                                symbols[i].isSuitableFor(dummyPointGeom));

                        } else {

                                assertFalse(symbols[i].getClassName()+" should NOT be suitable for "+dummyPointGeom,

                                                symbols[i].isSuitableFor(dummyPointGeom));

                        }

                }

        }

        public void testLineSuitability() {

                final IGeometry dummyLineGeom = ShapeFactory.createPolyline2D(new GeneralPathX());

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

                        // text symbols are suitable for everything

                        if (symbols[i] instanceof ITextSymbol) {

                                assertTrue(symbols[i].getClassName()+" should be suitable for "+dummyLineGeom,

                                                symbols[i].isSuitableFor(dummyLineGeom));

                        } else

                        // line symbols are suitable for line

                        if (symbols[i] instanceof ILineSymbol) {

                                assertTrue(symbols[i].getClassName()+" should be suitable for "+dummyLineGeom,

                                                symbols[i].isSuitableFor(dummyLineGeom));

                        } else {

                                assertFalse(symbols[i].getClassName()+" should NOT be suitable for "+dummyLineGeom,

                                                symbols[i].isSuitableFor(dummyLineGeom));

                        }

                }

        }

        public void testPolygonSuitability() {

                final IGeometry dummyPolygonGeom = ShapeFactory.createPolygon2D(new GeneralPathX());

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

                        // text symbols are suitable for everything

                        if (symbols[i] instanceof ITextSymbol) {

                                assertTrue(symbols[i].getClassName()+" should be suitable for "+dummyPolygonGeom,

                                                symbols[i].isSuitableFor(dummyPolygonGeom));

                        } else

                        // fill symbols are suitable for polygons

                        if (symbols[i] instanceof IFillSymbol) {

                                assertTrue(symbols[i].getClassName()+" should be suitable for "+dummyPolygonGeom,

                                                symbols[i].isSuitableFor(dummyPolygonGeom));

                        } else {

                                assertFalse(symbols[i].getClassName()+" should NOT be suitable for "+dummyPolygonGeom,

                                                symbols[i].isSuitableFor(dummyPolygonGeom));

                        }

                }

        }

        /**

         * tests whether the symbols were correctly configured to work with

         * different kinds of shapes.

         */

        public void testGeneralSuitability() {

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

                        // text symbols are suitable for everything

                        if (symbols[i] instanceof ITextSymbol) {

                                assertTrue(symbols[i].getClassName()+" should be suitable for "+null,

                                                symbols[i].isSuitableFor(null));

                        } else {

                                try {

                                        symbols[i].isSuitableFor(null);

                                        fail("Exception was not thrown");

                                } catch (NullPointerException npEx) {

                                        // this is correct!

                                }

                        }

                }

        }

        /**

         * ensures that symbols defined which can of FShape is the symbol

         */

        public void testSymbolTypeDefinition() {

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

                        assertFalse("Symbol no. "+i+" '"+symbols[i].getClassName()+"'",

                                                symbols[i].getSymbolType() == 0);

                }

        }

        /**

         * ensures that any symbol has a description in its persistence

         * (very important)

         */

        public void testDescription() {

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

                        assertTrue(symbols[i].getClassName() + " does not declare a description in its XMLEntity",

                                        symbols[i].getXMLEntity().contains("desc"));

                }

        }

        /**

         * ensures that any symbol has an isShapeVisible field in its persistence

         * (very important)

         */

        public void testIsShapeVisible() {

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

                        assertTrue(symbols[i].getClassName() + " does not declare a description in its XMLEntity",

                                        symbols[i].getXMLEntity().contains("isShapeVisible"));

                }

        }

        /**

         * ensures that the symbol is self-defining

         */

        public void testSymbolSelfDefinition() {

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

                        final ISymbol theSymbol = symbols[i];

                        final ISymbol cloneSymbol = SymbologyFactory.createSymbolFromXML(theSymbol.getXMLEntity(), null);

                        assertTrue(theSymbol.getClassName()+ " wrong class name declaration in getXMLEntity() ",

                                        cloneSymbol.getClass().equals(theSymbol.getClass()));

                        final Field[] theSymbolFields = theSymbol.getClass().getFields();

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

                                final Field fi = theSymbolFields[j];

                                final boolean wasAccessible = fi.isAccessible();

                                fi.setAccessible(true);

                                try {

                                        assertTrue(theSymbol.getClassName() + " fails or misses clonning the field " +fi.getName(),

                                                        fi.get(theSymbol).equals(fi.get(cloneSymbol)));

                                } catch (IllegalArgumentException e) {

                                        fail();

                                } catch (IllegalAccessException e) {

                                        fail();

                                }

                                fi.setAccessible(wasAccessible);

                        }

                }

        }

}