Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Gobernment (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.mapcontext.tools.persistence;

import java.awt.Color;

import org.easymock.MockControl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

/**

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

 * 

 * @author gvSIG team

 */

public class ColorPersistenceFactoryTest extends

		AbstractLibraryAutoInitTestCase {

	private ColorPersistenceFactory factory;

	private MockControl stateControl;

	private PersistentState state;

	private Color color;

	protected void doSetUp() throws Exception {

		PersistenceManager persistenceManager = ToolsLocator

				.getPersistenceManager();

		factory = (ColorPersistenceFactory) persistenceManager.getFactories()

				.get(Color.class);

		stateControl = MockControl.createNiceControl(PersistentState.class);

		state = (PersistentState) stateControl.getMock();

		color = Color.magenta;

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.mapcontext.tools.persistence.ColorPersistenceFactory#createFromState(org.gvsig.tools.persistence.PersistentState, java.lang.Class)}

	 * .

	 */

	public void testCreateFromState() throws Exception {

		stateControl.expectAndReturn(state

				.getInt(ColorPersistenceFactory.FIELD_RED), color.getRed());

		stateControl.expectAndReturn(state

				.getInt(ColorPersistenceFactory.FIELD_GREEN), color.getGreen());

		stateControl.expectAndReturn(state

				.getInt(ColorPersistenceFactory.FIELD_BLUE), color.getBlue());

		stateControl.expectAndReturn(state

				.getInt(ColorPersistenceFactory.FIELD_ALPHA), color.getAlpha());

		stateControl.replay();

		Color newColor = (Color) factory.createFromState(state);

		assertTrue(newColor.equals(color));

		stateControl.verify();

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.mapcontext.tools.persistence.ColorPersistenceFactory#saveToState(org.gvsig.tools.persistence.PersistentState, java.lang.Object)}

	 * .

	 */

	public void testSaveToState() throws Exception {

		state.set(ColorPersistenceFactory.FIELD_RED, color.getRed());

		state.set(ColorPersistenceFactory.FIELD_GREEN, color.getGreen());

		state.set(ColorPersistenceFactory.FIELD_BLUE, color.getBlue());

		state.set(ColorPersistenceFactory.FIELD_ALPHA, color.getAlpha());

		stateControl.replay();

		factory.saveToState(state, color);

		stateControl.verify();

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Gobernment (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.mapcontext.tools.persistence;

import java.awt.geom.Point2D;

import org.easymock.MockControl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

/**

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

 * 

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

 */

public class Point2DPersistenceFactoryTest extends

		AbstractLibraryAutoInitTestCase {

	private Point2DPersistenceFactory factory;

	private MockControl stateControl;

	private PersistentState state;

	private Point2D point;

	protected void doSetUp() throws Exception {

		PersistenceManager persistenceManager = ToolsLocator

				.getPersistenceManager();

		factory = (Point2DPersistenceFactory) persistenceManager.getFactories()

				.get(Point2D.class);

		stateControl = MockControl.createNiceControl(PersistentState.class);

		state = (PersistentState) stateControl.getMock();

		double x = Math.random() * 1000d;

		double y = Math.random() * 1000d;

		point = new Point2D.Double(x, y);

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.mapcontext.tools.persistence.Point2DPersistenceFactory#createFromState(PersistentState, Class)}

	 * .

	 */

	public void testCreateFromState() throws Exception {

		stateControl.expectAndReturn(state

				.getDouble(Point2DPersistenceFactory.FIELD_X), point.getX());

		stateControl.expectAndReturn(state

				.getDouble(Point2DPersistenceFactory.FIELD_Y), point.getY());

		stateControl.replay();

		Point2D newPoint = (Point2D) factory.createFromState(state);

		assertTrue(newPoint.equals(point));

		stateControl.verify();

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.mapcontext.tools.persistence.Point2DPersistenceFactory#saveToState(org.gvsig.tools.persistence.PersistentState, java.lang.Object)}

	 * .

	 */

	public void testSaveToState() throws Exception {

		state.set(Point2DPersistenceFactory.FIELD_X, point.getX());

		state.set(Point2DPersistenceFactory.FIELD_Y, point.getY());

		stateControl.replay();

		factory.saveToState(state, point);

		stateControl.verify();

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Gobernment (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.mapcontext.tools.persistence;

import java.awt.Dimension;

import org.easymock.MockControl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

/**

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

 * 

 * @author gvSIG team

 */

public class DimensionPersistenceFactoryTest extends

		AbstractLibraryAutoInitTestCase {

	private DimensionPersistenceFactory factory;

	private MockControl stateControl;

	private PersistentState state;

	private Dimension dimension;

	protected void doSetUp() throws Exception {

		PersistenceManager persistenceManager = ToolsLocator

				.getPersistenceManager();

		factory = (DimensionPersistenceFactory) persistenceManager

				.getFactories().get(Dimension.class);

		stateControl = MockControl.createNiceControl(PersistentState.class);

		state = (PersistentState) stateControl.getMock();

		dimension = new Dimension(320, 200);

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.mapcontext.tools.persistence.DimensionPersistenceFactory#createFromState(org.gvsig.tools.persistence.PersistentState, java.lang.Class)}

	 * .

	 */

	public void testCreateFromState() throws Exception {

		stateControl.expectAndReturn(state

				.getInt(DimensionPersistenceFactory.FIELD_WIDTH), dimension.width);			

		stateControl.expectAndReturn(state

				.getInt(DimensionPersistenceFactory.FIELD_HEIGHT), dimension.height);				

		stateControl.replay();

		Dimension newDimension = (Dimension) factory.createFromState(state);

		assertTrue(newDimension.equals(dimension));

		stateControl.verify();

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.mapcontext.tools.persistence.DimensionPersistenceFactory#saveToState(org.gvsig.tools.persistence.PersistentState, java.lang.Object)}

	 * .

	 */

	public void testSaveToState() throws Exception {

		state.set(DimensionPersistenceFactory.FIELD_WIDTH, dimension.width);

		state.set(DimensionPersistenceFactory.FIELD_HEIGHT, dimension.height);

		stateControl.replay();

		factory.saveToState(state, dimension);

		stateControl.verify();

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Gobernment (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.mapcontext.tools.persistence;

import java.awt.Font;

import org.easymock.MockControl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

/**

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

 * 

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

 */

public class FontPersistenceFactoryTest extends AbstractLibraryAutoInitTestCase {

	private FontPersistenceFactory factory;

	private MockControl stateControl;

	private PersistentState state;

	private Font font;

	protected void doSetUp() throws Exception {

		PersistenceManager persistenceManager = ToolsLocator

				.getPersistenceManager();

		factory = (FontPersistenceFactory) persistenceManager.getFactories()

				.get(Font.class);

		stateControl = MockControl.createNiceControl(PersistentState.class);

		state = (PersistentState) stateControl.getMock();

		font = new Font("Arial", Font.BOLD, 18);

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.mapcontext.tools.persistence.FontPersistenceFactory#createFromState(org.gvsig.tools.persistence.PersistentState, java.lang.Class)}

	 * .

	 */

	public void testCreateFromState() throws Exception {

		stateControl.expectAndReturn(state

				.getString(FontPersistenceFactory.FIELD_NAME), font.getName());

		stateControl.expectAndReturn(state

				.getInt(FontPersistenceFactory.FIELD_STYLE), font.getStyle());

		stateControl.expectAndReturn(state

				.getInt(FontPersistenceFactory.FIELD_SIZE), font.getSize());

		stateControl.replay();

		Font newFont = (Font) factory.createFromState(state);

		assertTrue(newFont.equals(font));

		stateControl.verify();

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.mapcontext.tools.persistence.FontPersistenceFactory#saveToState(org.gvsig.tools.persistence.PersistentState, java.lang.Object)}

	 * .

	 */

	public void testSaveToState() throws Exception {

		state.set(FontPersistenceFactory.FIELD_NAME, font.getName());

		state.set(FontPersistenceFactory.FIELD_STYLE, font.getStyle());

		state.set(FontPersistenceFactory.FIELD_SIZE, font.getSize());

		stateControl.replay();

		factory.saveToState(state, font);

		stateControl.verify();

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Gobernment (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.mapcontext.tools.persistence;

import java.awt.geom.Rectangle2D;

import org.easymock.MockControl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

/**

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

 * 

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

 */

public class Rectangle2DPersistenceFactoryTest extends

		AbstractLibraryAutoInitTestCase {

	private Rectangle2DPersistenceFactory factory;

	private MockControl stateControl;

	private PersistentState state;

	private Rectangle2D rectangle;

	protected void doSetUp() throws Exception {

		PersistenceManager persistenceManager = ToolsLocator

				.getPersistenceManager();

		factory = (Rectangle2DPersistenceFactory) persistenceManager

				.getFactories().get(Rectangle2D.class);

		stateControl = MockControl.createNiceControl(PersistentState.class);

		state = (PersistentState) stateControl.getMock();

		double x = Math.random() * 1000d;

		double y = Math.random() * 1000d;

		rectangle = new Rectangle2D.Double(x, y, 320, 200);

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.mapcontext.tools.persistence.Rectangle2DPersistenceFactory#createFromState(PersistentState, Class)}

	 * .

	 */

	public void testCreateFromState() throws Exception {

		stateControl.expectAndReturn(state

				.getDouble(Rectangle2DPersistenceFactory.FIELD_X), rectangle

				.getX());

		stateControl.expectAndReturn(state

				.getDouble(Rectangle2DPersistenceFactory.FIELD_Y), rectangle

				.getY());

		stateControl.expectAndReturn(state

				.getDouble(Rectangle2DPersistenceFactory.FIELD_WIDTH),

				rectangle.getWidth());

		stateControl.expectAndReturn(state

				.getDouble(Rectangle2DPersistenceFactory.FIELD_HEIGHT),

				rectangle.getHeight());

		stateControl.replay();

		Rectangle2D newRectangle = (Rectangle2D) factory.createFromState(state);

		System.out.println("Orig x = " + rectangle.getX() + " - New x = "

				+ newRectangle.getX());

		assertEquals(rectangle.getX(), newRectangle.getX(), 0.0d);

		System.out.println("Orig y = " + rectangle.getY() + " - New y = "

				+ newRectangle.getY());

		assertEquals(rectangle.getY(), newRectangle.getY(), 0.0d);

		System.out.println("Orig width = " + rectangle.getWidth()

				+ " - New width = " + newRectangle.getWidth());

		assertEquals(rectangle.getWidth(), newRectangle.getWidth(), 0.0d);

		System.out.println("Orig height = " + rectangle.getHeight()

				+ " - New height = " + newRectangle.getHeight());

		assertEquals(rectangle.getHeight(), newRectangle.getHeight(), 0.0d);

		assertTrue(newRectangle.equals(rectangle));

		stateControl.verify();

	}

	/**

	 * Test method for

	 * {@link org.gvsig.fmap.mapcontext.tools.persistence.Rectangle2DPersistenceFactory#saveToState(org.gvsig.tools.persistence.PersistentState, java.lang.Object)}

	 * .

	 */

	public void testSaveToState() throws Exception {

		state.set(Rectangle2DPersistenceFactory.FIELD_X, rectangle.getX());

		state.set(Rectangle2DPersistenceFactory.FIELD_Y, rectangle.getY());

		state.set(Rectangle2DPersistenceFactory.FIELD_WIDTH, rectangle

				.getWidth());

		state.set(Rectangle2DPersistenceFactory.FIELD_HEIGHT, rectangle

				.getHeight());

		stateControl.replay();

		factory.saveToState(state, rectangle);

		stateControl.verify();

	}

}

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

 */

package org.gvsig.fmap.mapcontext.impl;

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import java.util.Map;

import org.cresques.cts.ICoordTrans;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.crs.CRSFactory;

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextDrawer;

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.MapContextRuntimeException;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.driver.ILegendReader;

import org.gvsig.fmap.mapcontext.rendering.legend.driver.ILegendWriter;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendContentsChangedListener;

import org.gvsig.fmap.mapcontext.rendering.legend.events.SymbolLegendEvent;

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

import org.gvsig.tools.evaluator.Evaluator;

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.task.Cancellable;

/**

 * @author <a href="mailto:cordinyana@gvsig.org">C?sar Ordi?ana</a>

 */

public class DefaultMapContextManagerTest extends

AbstractLibraryAutoInitTestCase {

    private DefaultMapContextManager manager;

    protected void doSetUp() throws Exception {

        manager = new DefaultMapContextManager();

        manager.registerLegend("DummyLegend", DummyVectorLegend.class);

        manager.setDefaultVectorLegend("DummyLegend");

        manager.registerLegendReader("Dummy", DummyLegendReader.class);

        manager.registerLegendWriter("DummyLegend", "Dummy", DummyLegendWriter.class);

    }

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    /**

     * Test method for

     * {@link org.gvsig.fmap.mapcontext.impl.DefaultMapContextManager#createDefaultMapContextDrawerInstance()}

     * .

     */

    public void testGetDefaultMapContextDrawerInstance() throws Exception {

        manager.setDefaultMapContextDrawer(DummyMapContextDrawer.class);

        MapContextDrawer drawer = manager

        .createDefaultMapContextDrawerInstance();

        assertNotNull("The created MapContextDrawer instance can't be null",

            drawer);

        assertTrue(

            "The created MapContextDrawer is not instance of the registered class"

            + DummyMapContextDrawer.class,

            drawer instanceof DummyMapContextDrawer);

    }

    /**

     * Test method for

     * {@link org.gvsig.fmap.mapcontext.impl.DefaultMapContextManager#setDefaultMapContextDrawer(java.lang.Class)}

     * .

     */

    public void testSetDefaultMapContextDrawer() throws Exception {

        // First, try to register an invalid class

        try {

            manager.setDefaultMapContextDrawer(Object.class);

            fail("Error, a class that does not implement the MapContextDrawer "

                + "interface has been accepted");

        } catch (MapContextRuntimeException e) {

            // OK

        }

        // Next, try to register a valid class

        manager.setDefaultMapContextDrawer(DummyMapContextDrawer.class);

    }

    public void testCreateGraphicsLayer() throws Exception {

        assertNotNull(manager.createGraphicsLayer(CRSFactory.getCRS("EPSG:23030")));

    }

    public void testCreateDefaultVectorLegend() throws Exception {

        IVectorLegend legend = manager.createDefaultVectorLegend(1);

        assertNotNull(legend);

        assertTrue(legend instanceof DummyVectorLegend);

    }

    public void testRegisterCreateLegend() throws Exception {

        manager.registerLegend("DummyLegend", DummyVectorLegend.class);

        ILegend legend = manager.createLegend("DummyLegend");

        assertNotNull(legend);

        assertTrue(legend instanceof DummyVectorLegend);

        assertNull(manager.createLegend("NONE"));

    }

    public void testRegisterCreateLegendReader() throws Exception {

        manager.registerLegendReader("Dummy", DummyLegendReader.class);

        ILegendReader legendReader = manager.createLegendReader("Dummy");

        assertNotNull(legendReader);

        assertTrue(legendReader instanceof DummyLegendReader);

        assertNull(manager.createLegendReader("NONE"));

    }

    public void testRegisterCreateLegendWriter() throws Exception {

        manager.registerLegend("DummyLegend", DummyVectorLegend.class);

        manager.registerLegendWriter("DummyLegend", "Dummy",

            DummyLegendWriter.class);

        // Test the registered writer is created

        ILegendWriter legendWriter = manager.createLegendWriter("DummyLegend",

        "Dummy");

        assertNotNull(legendWriter);

        assertTrue(legendWriter instanceof DummyLegendWriter);

        // Test non registered cases

        assertNull(manager.createLegendWriter("NONE", "Dummy"));

        assertNull(manager.createLegendWriter("DummyLegend", "NONE"));

        assertNull(manager.createLegendWriter("NONE", "NONE"));

    }

    public static class DummyMapContextDrawer implements MapContextDrawer {

        public void dispose() {

        }

        public void draw(FLayers root, BufferedImage image, Graphics2D g,

            Cancellable cancel, double scale) throws ReadException {

        }

        public void print(FLayers root, Graphics2D g, Cancellable cancel,

            double scale, PrintAttributes properties) throws ReadException {

        }

        public void setMapContext(MapContext mapContext) {

        }

        public void setViewPort(ViewPort viewPort) {

        }

    }

    public static class DummyLegendReader implements ILegendReader {

    }

    public static class DummyLegendWriter implements ILegendWriter {

    }

    public static class DummyVectorLegend implements IVectorLegend {

        public void draw(BufferedImage image, Graphics2D graphics2d,

            ViewPort viewPort, Cancellable cancel, double scale,

            Map queryParameters, ICoordTrans coordTrans,

            FeatureStore featureStore, FeatureQuery featureQuery) throws LegendException {

            // Empty method

        }

        public void draw(BufferedImage image, Graphics2D graphics2d,

            ViewPort viewPort, Cancellable cancel, double scale,

            Map queryParameters, ICoordTrans coordTrans,

            FeatureStore featureStore) throws LegendException {

            // Empty method

        }

        public int getShapeType() {

            // Empty method

            return 0;

        }

        public ISymbol getSymbolByFeature(Feature feat)

        throws MapContextException {

            // Empty method

            return null;

        }

        public boolean isSuitableForShapeType(int shapeType) {

            // Empty method

            return false;

        }

        public boolean isUseDefaultSymbol() {

            // Empty method

            return false;

        }

        public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

            double scale, Map queryParameters, ICoordTrans coordTrans,

            FeatureStore featureStore, PrintAttributes properties)

        throws LegendException {

            // Empty method

        }

        public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

            double scale, Map queryParameters, ICoordTrans coordTrans,

            FeatureStore featureStore, FeatureQuery featureQuery, PrintAttributes properties)

        throws LegendException {

            // Empty method

        }

        public void setDefaultSymbol(ISymbol s) {

            // Empty method

        }

        public void setShapeType(int shapeType) {

            // Empty method

        }

        public void useDefaultSymbol(boolean b) {

            // Empty method

        }

        public void addLegendListener(LegendContentsChangedListener listener) {

            // Empty method

        }

        public ILegend cloneLegend() {

            // Empty method

            return null;

        }

        public Object clone() throws CloneNotSupportedException {

            // TODO Auto-generated method stub

            return super.clone();

        }

        public void fireDefaultSymbolChangedEvent(SymbolLegendEvent event) {

            // Empty method

        }

        public ISymbol getDefaultSymbol() {

            // Empty method

            return null;

        }

        public LegendContentsChangedListener[] getListeners() {

            // Empty method

            return null;

        }

        public void removeLegendListener(LegendContentsChangedListener listener) {

            // Empty method

        }

        public void loadFromState(PersistentState state)

        throws PersistenceException {

            // Empty method

        }

        public void saveToState(PersistentState state)

        throws PersistenceException {

            // Empty method

        }

        public void addDrawingObserver(Observer observer) {

            // Empty method

        }

        public void deleteDrawingObserver(Observer observer) {

            // Empty method

        }

        public void deleteDrawingObservers() {

            // Empty method

        }

    }

}

package org.gvsig.fmap.mapcontext.persistence;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import org.gvsig.fmap.crs.CRSFactory;

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

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

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

import org.gvsig.fmap.geom.primitive.impl.Envelope2D;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

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

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

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

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

import org.gvsig.fmap.mapcontext.rendering.symbol.DummyVectorLegend;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class MapContextPersistenceTest extends AbstractLibraryAutoInitTestCase {

	final static private Logger logger =

			LoggerFactory.getLogger(MapContextPersistenceTest.class);

	protected void doSetUp() throws Exception {

		DummyVectorLegend.registerPersistent();

		DummyDBFeatureStore.registerPersistent();

		DummyFileFeatureStore.registerPersistent();

		MapContextLocator.getMapContextManager().registerLegend("DummyLegend",

				DummyVectorLegend.class);

		MapContextLocator.getMapContextManager().setDefaultVectorLegend(

				"DummyLegend");

	}

	private File getTempFile() throws Exception {

		File tempFile = File.createTempFile("persisted_mapcontext", ".xml");

		if (tempFile.exists())

			tempFile.delete();

		tempFile.createNewFile();

		System.out.println("TEMP FILE: " + tempFile.getAbsolutePath());

		return tempFile;

	}

	public void testMapContext() throws Exception {

		ViewPort vp = getViewPort();

		logger.debug("Creating mapcontext...");

		MapContext mc = new MapContext(vp);

		addDummyLayers(mc);

		doTestPersist(mc);

	}

	public void noTestFLyrs() throws Exception {

		int lyr_count = 3;

		// testPersist(mc);

		FLyrVect[] lyr = new FLyrVect[lyr_count];

		FeatureStore[] fs = new FeatureStore[lyr_count];

		FLayers lyrs = new FLayers();

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

			fs[i] = new DummyFileFeatureStore("" + System.currentTimeMillis());

			lyr[i] = createLayer(fs[i]);

			lyr[i].setName("Layer " + (i+System.currentTimeMillis()));

			lyr[i].setIsLabeled(false);

			try { lyr[i].setLegend(new DummyVectorLegend(TYPES.SOLID)); } catch (LegendLayerException e) {

				assertTrue("Error while creating legend: " + e.getMessage(), false);

			}

			lyrs.addLayer(lyr[i]);

			lyr[i].dispose();

		}

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

			fs[i] = new DummyDBFeatureStore("" + System.currentTimeMillis());

			lyr[i] = createLayer(fs[i]);

			lyr[i].setName("Layer " + (10000 + i + System.currentTimeMillis()));

			lyr[i].setIsLabeled(false);

			try { lyr[i].setLegend(new DummyVectorLegend(TYPES.SOLID)); } catch (LegendLayerException e) {

				assertTrue("Error while creating legend: " + e.getMessage(), false);

			}

			lyrs.addLayer(lyr[i]);

			lyr[i].dispose();

		}

		doTestPersist(lyrs);

	}

	private ViewPort getViewPort() {

		ViewPort vp = new ViewPort(CRSFactory.getCRS("EPSG:4326"));

		vp.setImageSize(new Dimension(640, 480));

		Envelope env = new Envelope2D(0, 0, 1000000, 1000000);

		vp.setEnvelope(env);

		env = new Envelope2D(200000, 200000, 500000, 500000);

		vp.setEnvelope(env);

		env = new Envelope2D(300000, 300000, 300000, 300000);

		vp.setEnvelope(env);

		env = new Envelope2D(400000, 400000, 200000, 200000);

		vp.setEnvelope(env);

		env = new Envelope2D(440000, 440000, 100000, 100000);

		vp.setEnvelope(env);

		env = new Envelope2D(480000, 480000, 30000, 30000);

		vp.setEnvelope(env);

		vp.setBackColor(Color.YELLOW);

		vp.setClipRect(new Rectangle2D.Double(0, 0, 10, 10));

		return vp;

	}

	private void addDummyLayers(MapContext mcon) throws Exception {

		FLayers resp = new FLayers();

		resp.setMapContext(mcon);

		resp.setName("root layer");

		FLayers aux = new FLayers();

		aux.setMapContext(mcon);

		aux.setName("Group");

		FLyrVect lyr = null;

		IVectorLegend lgn = null;

		FeatureStore fs = null;

		logger.debug("Adding dummy layers...");

		fs = new DummyFileFeatureStore("1");

		lyr = createLayer(fs);

		lyr.setName("Layer 1");

		try { lyr.setLegend(new DummyVectorLegend(TYPES.SOLID)); } catch (LegendLayerException e) { }

		aux.addLayer(lyr);

		lyr.dispose();

		fs = new DummyDBFeatureStore("A");

		lyr = createLayer(fs);

		lyr.setName("Layer A");

		try { lyr.setLegend(new DummyVectorLegend(TYPES.SOLID)); } catch (LegendLayerException e) { }

		aux.addLayer(lyr);

		lyr.dispose();

		fs = new DummyFileFeatureStore("2");

		lyr = createLayer(fs);

		lyr.setName("Layer 2");

		try { lyr.setLegend(new DummyVectorLegend(TYPES.SOLID)); } catch (LegendLayerException e) { }

		aux.addLayer(lyr);

		lyr.dispose();

		fs = new DummyDBFeatureStore("B");

		lyr = createLayer(fs);

		lyr.setName("Layer 1");

		try { lyr.setLegend(new DummyVectorLegend(TYPES.SOLID)); } catch (LegendLayerException e) { }

		resp.addLayer(lyr);

		resp.addLayer(aux);

		lyr.dispose();

		aux.dispose();

		mcon.getLayers().addLayer(resp);

		resp.dispose();

	}

	private FLyrVect createLayer(FeatureStore fs) throws Exception {

		FLyrVect resp = new FLyrVect();

		resp.setDataStore(fs);

		resp.wakeUp();

		resp.load();

		return resp;

	}

	private void doTestPersist(Persistent p) throws Exception {

		System.out.println("Starting persistence test for class: " + p.getClass().getName());

		File perfile = getTempFile();

		FileOutputStream fos = new FileOutputStream(perfile);

		System.out.println("Getting state for class: " + p.getClass().getName());

		PersistentState pst = ToolsLocator.getPersistenceManager().getState(p);

		System.out.println("Saving state...");

		System.out.println("Saving state...");

		ToolsLocator.getPersistenceManager().saveState(pst, fos);

		System.out.println("Saving state... done.");

		fos.close();

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

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

		System.out.println("Is now persisted: " + p.getClass().getName());

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

		// if (true) return;

		System.out.println("Opening persistence file...");

		FileInputStream fis = new FileInputStream(perfile);

		System.out.println("Loading state from file...");

		pst = ToolsLocator.getPersistenceManager().loadState(fis);

		System.out.println("Instantiating " + p.getClass().getName()

				+ " from state, pst = " + pst);

		Object p2 = ToolsLocator.getPersistenceManager().create(pst);

		System.out.println("Comparing original and current...");

		comparePersistent(p, p2);

		System.out.println("Successful mapcontext persistence test!");

	}

	// FeatureStore, ILegend, ViewPort

	private void comparePersistent(Persistent p, Object p2) {

		if (p2.getClass().getName().compareTo(p.getClass().getName()) == 0) {

			if (p instanceof MapContext) {

				compareMapContexts((MapContext) p, (MapContext) p2);

			} else {

				if (p instanceof FLayer) {

					compareLayers((FLayer) p, (FLayer) p2);

				} else {

					if (p instanceof FeatureStore) {

						compareStore((FeatureStore) p, (FeatureStore) p2);

					} else {

						if (p instanceof ILegend) {

							compareLegend((ILegend) p, (ILegend) p2);

						} else {

							if (p instanceof ViewPort) {

								compareViewPorts((ViewPort) p, (ViewPort) p2);

							} else {

								fail("Did not compare: " + p.getClass().getName());

							}

						}

					}

				}

			}

		} else {

			fail("Comparing different classes (?)");

		}

	}

	private void compareMapContexts(MapContext m1, MapContext m2) {

		logger.debug("Getting viewports to compare...");

		ViewPort vp1 = m1.getViewPort();

		ViewPort vp2 = m2.getViewPort();

		compareViewPorts(vp1, vp2);

		logger.debug("Getting root flayers to compare...");

		FLayers lyr1 = m1.getLayers();

		FLayers lyr2 = m2.getLayers();

		compareLayers(lyr1, lyr2);

	}

	private void compareLayers(FLayer l1, FLayer l2) {

		logger.debug("Comparing layers...");

		assertTrue("Layers of diff type!", l1.getClass().getName().compareTo(l2.getClass().getName()) == 0);

		if (l1 instanceof FLayers) {

			logger.debug("(type FLayers)...");

			FLayers ls1 = (FLayers) l1;

			FLayers ls2 = (FLayers) l2;

			assertEquals(ls1.getLayersCount(), ls2.getLayersCount());

			int sz = ls2.getLayersCount();

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

				compareLayers(ls1.getLayer(i), ls2.getLayer(i));

			}

		} else {

			if (l1 instanceof FLyrVect) {

				logger.debug("(type FLyrVect)...");

				FLyrVect ls1 = (FLyrVect) l1;

				FLyrVect ls2 = (FLyrVect) l2;

				compareVectLayers(ls1, ls2);

			} else {

			}

		}

	}

	private void compareVectLayers(FLyrVect l1, FLyrVect l2) {

		compareLegend(l1.getLegend(), l2.getLegend());

		compareStore(l1.getFeatureStore(), l2.getFeatureStore());

	}

	private void compareStore(FeatureStore fs1,

			FeatureStore fs2) {

		logger.debug("Comparing stores...");

		assertTrue("Diff stores!", fs1.getName().compareTo(fs2.getName()) == 0);

	}

	private void compareLegend(ILegend l1, ILegend l2) {

		logger.debug("Comparing legends...");

		IVectorLegend vl1 = (IVectorLegend) l1;

		IVectorLegend vl2 = (IVectorLegend) l2;

		assertTrue("Diff legends!", vl1.getShapeType() == vl2.getShapeType());

	}

	private void compareViewPorts(ViewPort vp1, ViewPort vp2) {

		logger.debug("Comparing viewports...");

		assertEquals(

				vp1.getAdjustedEnvelope().getMinimum(0),

				vp2.getAdjustedEnvelope().getMinimum(0),

				0.00000000000001);

		assertEquals(

				vp1.getAdjustedEnvelope().getMinimum(1),

				vp2.getAdjustedEnvelope().getMinimum(1),

				0.00000000000001);

		assertEquals(

				vp1.getAdjustedEnvelope().getMaximum(0),

				vp2.getAdjustedEnvelope().getMaximum(0),

				0.00000000000001);

		assertEquals(

				vp1.getAdjustedEnvelope().getMaximum(1),

				vp2.getAdjustedEnvelope().getMaximum(1),

				0.00000000000001);

	}

}

package org.gvsig.fmap.mapcontext.persistence;

import java.util.Collection;

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.DataSet;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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.primitive.Envelope;

import org.gvsig.timesupport.Interval;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynStruct;

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

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.persistence.PersistenceManager;

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;

public class DummyDBFeatureStore implements FeatureStore {

	private String name = "[empty]";

	public DummyDBFeatureStore() {

	}

	public DummyDBFeatureStore(String id) {

		name = "[DATABASE FEATURE STORE - " + id + "]";

	}

	public boolean allowWrite() {

		// TODO Auto-generated method stub

		return false;

	}

	public void beginEditingGroup(String description)

			throws NeedEditingModeException {

		// TODO Auto-generated method stub

	}

	public boolean canWriteGeometry(int gvSIGgeometryType) throws DataException {

		// TODO Auto-generated method stub

		return false;

	}

	public void cancelEditing() throws DataException {

		// TODO Auto-generated method stub

	}

	public FeatureQuery createFeatureQuery() {

		// TODO Auto-generated method stub

		return null;

	}

	public FeatureSelection createFeatureSelection() throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public FeatureIndex createIndex(FeatureType featureType,

			String attributeName, String indexName) throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public FeatureIndex createIndex(FeatureType featureType,

			String attributeName, String indexName, Observer observer)

			throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public EditableFeature createNewFeature() throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public EditableFeature createNewFeature(FeatureType type,

			Feature defaultValues) throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public EditableFeature createNewFeature(FeatureType type,

			boolean defaultValues) throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public EditableFeature createNewFeature(boolean defaultValues)

			throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public void delete(Feature feature) throws DataException {

		// TODO Auto-generated method stub

	}

	public void edit() throws DataException {

		// TODO Auto-generated method stub

	}

	public void edit(int mode) throws DataException {

		// TODO Auto-generated method stub

	}

	public void endEditingGroup() throws NeedEditingModeException {

		// TODO Auto-generated method stub

	}

	public void export(DataServerExplorer explorer,

			String providerName,

			NewFeatureStoreParameters params) throws DataException {

		// TODO Auto-generated method stub

	}

	public void finishEditing() throws DataException {

		// TODO Auto-generated method stub

	}

	public FeatureType getDefaultFeatureType() throws DataException {

		return new DummyFileFeatureStore.DummyFeatureType();

	}

	public Envelope getEnvelope() throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public Feature getFeatureByReference(FeatureReference reference)

			throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public Feature getFeatureByReference(FeatureReference reference,

			FeatureType featureType) throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public long getFeatureCount() throws DataException {

		// TODO Auto-generated method stub

		return 0;

	}

	public FeatureSelection getFeatureSelection() throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public FeatureSet getFeatureSet() throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public FeatureSet getFeatureSet(FeatureQuery featureQuery)

			throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public void getFeatureSet(FeatureQuery featureQuery, Observer observer)

			throws DataException {

		// TODO Auto-generated method stub

	}

	public void getFeatureSet(Observer observer) throws DataException {

		// TODO Auto-generated method stub

	}

	public FeatureType getFeatureType(String featureTypeId)

			throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public List getFeatureTypes() throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public FeatureIndexes getIndexes() {

		// TODO Auto-generated method stub

		return null;

	}

	public FeatureLocks getLocks() throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public DataStoreParameters getParameters() {

		// TODO Auto-generated method stub

		return null;

	}

	public IProjection getSRSDefaultGeometry() throws DataException {

		// TODO Auto-generated method stub

		return null;

	}

	public FeatureStoreTransforms getTransforms() {

		// TODO Auto-generated method stub

		return null;

	}

	public void insert(EditableFeature feature) throws DataException {

		// TODO Auto-generated method stub

	}

	public boolean isAppendModeSupported() {

		// TODO Auto-generated method stub

		return false;

	}

	public boolean isAppending() {

		// TODO Auto-generated method stub

		return false;

	}

	public boolean isEditing() {

		// TODO Auto-generated method stub

		return false;

	}

	public boolean isLocksSupported() {

		// TODO Auto-generated method stub