Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.tools.persistence;

import java.io.InputStream;

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.Map;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.exception.BaseException;

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

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

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

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

public class DynObjectFactoryTest extends AbstractBasicTest {

        private static Logger logger = LoggerFactory

                        .getLogger(DynObjectFactoryTest.class);

        private static int counter = 0;

        protected String OBJ1_NAME = "MyObjectBasicTypes";

        protected DynObjectManager dynManager;

        private static Date getDate() {

                return new GregorianCalendar(2010, 8, 5, 12, 5).getTime();

        }

        public void doSetUp() throws Exception {

                this.manager = ToolsLocator.getPersistenceManager();

                manager.setAutoValidation(PersistenceManager.MANDATORY);

                this.dynManager = ToolsLocator.getDynObjectManager();

        }

        protected void register() throws Exception {

                if (this.manager.getDynObjectDefinition(OBJ1_NAME) == null) {

                        InputStream resource = this

                                        .getClass()

                                        .getClassLoader()

                                        .getResourceAsStream(

                                                        "org/gvsig/tools/persistence/BasicTypes2Test.xml");

                        Map definitions = this.dynManager.importDynClassDefinitions(

                                        resource, null);

                        DynClass dynStruct = (DynClass) definitions.get(OBJ1_NAME);

                        this.manager.addDefinition(dynStruct, null, null);

                }

        }

        protected DynObject createDynObject1() {

                return createDynObject1(OBJ1_NAME);

        }

        protected DynObject createDynObject1(String name) {

                DynObject obj = this.dynManager.createDynObject(name,

                                PersistenceManager.PERSISTENCE_DYNOBJECT_NAMESPACE);

                float value = (counter / 3) * 700;

                obj.setDynValue("a", new Integer((int) value));

                obj.setDynValue("b", new Long((long) value));

                obj.setDynValue("c", new Double(value));

                obj.setDynValue("d", new Float(value));

                obj.setDynValue("e", new Boolean((counter % 2) == 0));

                obj.setDynValue("f", String.valueOf(value));

                obj.setDynValue("g", getDate());

                counter++;

                return obj;

        }

        void check(DynObject obj1, DynObject obj2) {

                assertEquals("int value mistmach", obj1.getDynValue("a"),

                                obj2.getDynValue("a"));

                assertEquals("long value mistmach", obj1.getDynValue("b"),

                                obj2.getDynValue("b"));

                assertEquals("double value mistmach",

                                ((Double) obj1.getDynValue("c")).doubleValue(),

                                ((Double) obj2.getDynValue("c")).doubleValue(), 0.01);

                assertEquals("float value mistmach",

                                ((Float) obj1.getDynValue("d")).floatValue(),

                                ((Float) obj2.getDynValue("d")).floatValue(), 0.01);

                assertEquals("boolean value mistmach", obj1.getDynValue("e"),

                                obj2.getDynValue("e"));

                assertEquals("String value mistmach", obj1.getDynValue("f"),

                                obj2.getDynValue("f"));

                assertTrue("Date value mistmach",

                                obj1.getDynValue("g").equals(obj2.getDynValue("g")));

        }

        public void testRegisterFactory() throws Exception {

                register();

        }

        public void testGetState() throws Exception {

                try {

                        register();

                        DynObject obj = createDynObject1();

                        PersistentState state = manager.getState(obj);

                        assertNotNull("Can't retrieve state", state);

                        DynStruct definition = state.getDefinition();

                        assertNotNull("Can't register class", definition);

                        assertEquals("Registration doesn't work, incorrect name", obj

                                        .getDynClass().getName(), definition.getName());

                } catch (BaseException ex) {

                        logger.warn(ex.getMessageStack(), ex);

                        throw ex;

                }

        }

        public void testSetState() throws PersistenceTypeNotSupportedException,

                        PersistenceClassNotRegistered, PersistenceException,

                        PersistenceValidateExceptions {

                DynObject obj1 = createDynObject1();

                PersistentState state = manager.getState(obj1);

                assertNotNull("Can't retrieve state", state);

                DynObject obj2 = (DynObject) manager.create(state);

                check(obj1, obj2);

        }

        public void testSaveState() throws Exception {

                DynObject obj = createDynObject1();

                saveState(obj);

        }

        public void testLoadState() throws Exception {

                DynObject obj1 = createDynObject1();

                PersistentState state = this.saveAndRestoreState(obj1);

                DynObject obj2 = (DynObject) manager.create(state);

                check(obj1, obj2);

        }

        protected String getTestId() {

                return "dopf";

        }

}