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

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.persistence;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

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.case1.model.ModelManager;

import org.gvsig.tools.persistence.case1.model.Projection;

import org.gvsig.tools.persistence.case1.model.ViewPort;

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 DynObjectFactory3Test extends AbstractBasicTest {

        private static Logger logger = LoggerFactory

                        .getLogger(DynObjectFactory3Test.class);

//        private static int counter = 0;

        protected static final String OBJ1_NAME = "MyObjectDynTypes";

        protected DynObjectManager dynManager;

        ModelManager modelmgr;

        public void doSetUp() throws Exception {

                this.manager = ToolsLocator.getPersistenceManager();

                manager.setAutoValidation(PersistenceManager.MANDATORY);

                this.dynManager = ToolsLocator.getDynObjectManager();

                modelmgr = new ModelManager();

                modelmgr.registerPersistence();

        }

        protected void tearDown() throws Exception {

                super.tearDown();

                this.manager.unregisterClass(ViewPort.class);

                modelmgr.unregisterPersistence();

        }

        protected void register() throws Exception {

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

                        InputStream resource = this

                        .getClass()

                        .getClassLoader()

                        .getResourceAsStream(

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

                        Map definitions = this.dynManager.importDynClassDefinitions(resource, null);

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

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

//                        this.manager.addDefinition(DynObject.class, OBJ1_NAME, resource, null, null, null);

                }

        }

        private DynObject createDynObject1(){

                DynObject obj = this.dynManager.createDynObject(OBJ1_NAME, PersistenceManager.PERSISTENCE_DYNOBJECT_NAMESPACE);

                Map m = new HashMap();

                m.put("a", "A1");

                m.put("b", "B2");

                obj.setDynValue("mapa", m);

                Set s = new HashSet();

                s.add("elementoConjunto1");

                s.add("elementoConjunto2");

                obj.setDynValue("conjunto", s);

                List l = new ArrayList();

                l.add("elementoLista1");

                l.add("elementoLista2");

                obj.setDynValue("lista", l);

                ViewPort vp = new ViewPort(new Projection());

                obj.setDynValue("viewPort", vp);

//                counter++;

                return obj;

        }

        void check(DynObject obj1, DynObject obj2) {

                assertEquals("map value mistmach", obj1.getDynValue("mapa"), obj2.getDynValue("mapa"));

                assertEquals("set value mistmach", obj1.getDynValue("conjunto"), obj2.getDynValue("conjunto"));

                assertEquals("list value mistmach", obj1.getDynValue("lista"), obj2.getDynValue("lista"));

                assertEquals("object value mistmach", ((ViewPort)obj1.getDynValue("viewPort")).getCode(), ((ViewPort)obj2.getDynValue("viewPort")).getCode());

        }

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

        }

}