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

import java.util.GregorianCalendar;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

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

                private static int counter = 0;

                private static Date getDate() {

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

                }

                public static  class MyObject implements Persistent {

                        int a;

                        long b;

                        double c;

                        float d;

                        boolean e;

                        String f;

                        Date g;

                        public MyObject() {

                                float value = (counter/3)*700;

                                this.a =  (int)value;

                                this.b = (long) value ;

                                this.c = value;

                                this.d = value;

                                this.e = (counter%2) == 0;

                                this.f = String.valueOf(value);

                                this.g= getDate();

                                counter++;

                        }

                        void check(MyObject other) {

                                assertEquals("int value mistmach", this.a, other.a);

                                assertEquals("long value mistmach", this.b, other.b);

                                assertEquals("double value mistmach", this.c, other.c,0.01);

                                assertEquals("float value mistmach", this.d, other.d, 0.01);

                                assertEquals("boolean value mistmach", this.e, other.e);

                                assertEquals("String value mistmach", this.f, other.f);

                                assertTrue("Date value mistmach", getDate().equals(this.g));

                        }

                        public void loadFromState(PersistentState state)

                                        throws PersistenceException {

                                this.a = state.getInt("a");

                                this.b = state.getLong("b");

                                this.c = state.getDouble("c");

                                this.d = state.getFloat("d");

                                this.e = state.getBoolean("e");

                                this.f = state.getString("f");

                                this.g = (Date) state.get("g");

                        }

                        public void saveToState(PersistentState state)

                                        throws PersistenceException {

                                state.set("a",a);

                                state.set("b",b);

                                state.set("c",c);

                                state.set("d",d);

                                state.set("e",e);

                                state.set("f",f);

                                state.set("g",g);

                        }

                }

                protected void register() {

                        PersistenceManager manager = ToolsLocator.getPersistenceManager();

                        DynStruct definition = manager.addDefinition(

                                        MyObject.class,

                                        "MyObjectBasicTypes",

                                        "MyObjectBasicTypes Persistence definition",

                                        null,

                                        null

                        );

                        definition.addDynFieldInt("a").setMandatory(true);

                        definition.addDynFieldLong("b").setMandatory(true);

                        definition.addDynFieldDouble("c").setMandatory(true);

                        definition.addDynFieldFloat("d").setMandatory(true);

                        definition.addDynFieldBoolean("e").setMandatory(true);

                        definition.addDynFieldString("f").setMandatory(true);

                        definition.addDynFieldDate("g").setMandatory(true);

                }

                protected void unregister() throws PersistenceClassNotRegistered {

                        manager.unregisterClass("MyObjectBasicTypes");

                }

                public void doSetUp() throws Exception {

                        super.doSetUp();

                        register();

                }

                protected void tearDown() throws Exception {

                        super.tearDown();

                        unregister();

                }

                //

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

                //

                protected String getTestId() {

                        return "basictypes";

                }

                public void testRegister() {

                        DynStruct definition = manager.getDefinition(MyObject.class);

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

                        assertEquals(

                                        "Registration didn't work, incorrect name.",

                                        "MyObjectBasicTypes",

                                        definition.getName()

                        );

                        assertEquals(

                                        "Registration didn't work, incorrect namespace.",

                                        PersistenceManager.PERSISTENCE_NAMESPACE,

                                        definition.getNamespace()

                        );

                }

                public void testGetState() throws PersistenceTypeNotSupportedException, PersistenceClassNotRegistered, PersistenceException, PersistenceValidateExceptions {

                        try {

                                MyObject obj = new MyObject();

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

                                                "MyObjectBasicTypes",

                                                definition.getName()

                                );

                        } catch( PersistenceValidateExceptions ex) {

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

                                throw ex;

                        }

                }

                public void testSetState() throws PersistenceTypeNotSupportedException, PersistenceClassNotRegistered, PersistenceException, PersistenceValidateExceptions {

                        MyObject obj1 = new MyObject();

                        PersistentState state = manager.getState(obj1);

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

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

                        obj1.check(obj2);

                }

                public void testSaveState() throws Exception {

                        MyObject obj = new MyObject();

                        saveState(obj);

                }

                public void testLoadState() throws Exception {

                        MyObject obj1 = new MyObject();

                        PersistentState state = this.saveAndRestoreState(obj1);

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

                        obj1.check(obj2);

                }

                public void testPutObject() throws Exception {

                        MyObject obj = new MyObject();

                        saveObject(obj);

                }

                public void testGetObject() throws Exception {

                        MyObject obj1 = new MyObject();

                        MyObject obj2 = (MyObject) this.saveAndRestoreObject(obj1);

                        obj1.check(obj2);

                }

}