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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DynObjectFactoryTest extends AbstractBasicTest {

        private static Logger logger = LoggerFactory

                        .getLogger(DynObjectFactoryTest.class);

        private static int counter = 0;

        protected static final 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);

                }

        }

        private DynObject createDynObject1(){

                DynObject obj = this.dynManager.createDynObject(OBJ1_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 don't work, name incorrect", OBJ1_NAME,

                                        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";

        }

}