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

/* 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):

 * 2008 {DiSiD Technologies}  {{Task}}

 */

package org.gvsig.tools.dynobject.impl;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import org.easymock.MockControl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

/**

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

 * 

 * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>

 */

public class DefaultDynClassTest extends AbstractLibraryAutoInitTestCase {

        private MockControl managerControl;

        private DynObjectManager manager;

        private DefaultDynClass dynClass;

        protected void doSetUp() throws Exception {

                managerControl = MockControl.createNiceControl(DynObjectManager.class);

                manager = (DynObjectManager) managerControl.getMock();

                dynClass = new DefaultDynClass(manager, new DefaultDynClassName(

                                "dynclass"), "description");

        }

        /**

         * Test method for

         * {@link org.gvsig.tools.dynobject.impl.DefaultDynClass#newInstance()}.

         */

        // public void testNewInstance() {

        // TODO: solve

        // MockControl dynObjControl = MockControl

        // .createNiceControl(DynObject.class);

        // DynObject dynObj = (DynObject) dynObjControl.getMock();

        // dynObjControl.expectAndReturn(dynObj.getDynClass(), dynClass);

        // dynObjControl.replay();

        //

        // managerControl.expectAndReturn(manager.createDynObject(dynClass),

        // dynObj);

        // managerControl.replay();

        //

        // DynObject newDynObj = dynClass.newInstance();

        // assertTrue(dynClass.isInstance(newDynObj));

        // }

        /**

         * Test method for

         * {@link org.gvsig.tools.dynobject.impl.DefaultDynClass#extend(org.gvsig.tools.dynobject.DynClass)}

         * .

         */

        public void testExtendDynClass() {

                final String parent = "parent";

                DefaultDynClassName name = new DefaultDynClassName(parent);

                DefaultDynClass parentDynClass = new DefaultDynClass(manager, name,

                                "parent description");

                managerControl.expectAndReturn(manager.has(parent), true);

                managerControl.expectAndReturn(manager.get(parent), parentDynClass);

                managerControl.replay();

                dynClass.extend(parentDynClass);

                DynClass[] parents = dynClass.getSuperDynClasses();

                assertEquals(parentDynClass, parents[0]);

        }

        /**

         * Test method for

         * {@link org.gvsig.tools.dynobject.impl.DefaultDynClass#extend(java.lang.String)}

         * .

         */

        public void testExtendString() {

                final String parent = "parent";

                DefaultDynClassName name = new DefaultDynClassName(parent);

                DefaultDynClass parentDynClass = new DefaultDynClass(manager, name,

                                "parent description");

                managerControl.expectAndReturn(manager.has(parent), true);

                managerControl.expectAndReturn(manager.get(parent), parentDynClass);

                managerControl.replay();

                dynClass.extend(parent);

                DynClass[] parents = dynClass.getSuperDynClasses();

                assertEquals(parentDynClass, parents[0]);

        }

        /**

         * Test method for

         * {@link org.gvsig.tools.dynobject.impl.DefaultDynClass#getDynField(java.lang.String)}

         * ,

         * {@link org.gvsig.tools.dynobject.impl.DefaultDynClass#addDynField(java.lang.String)}

         * ,

         * {@link org.gvsig.tools.dynobject.impl.DefaultDynClass#removeDynField(java.lang.String)}

         * ,

         * {@link org.gvsig.tools.dynobject.impl.DefaultDynClass#getDeclaredDynFields()}

         * .

         */

        public void testDynFields() {

                final String field1 = "field1";

                final String field2 = "field2";

                DynField dynField1 = dynClass.addDynField(field1);

                assertEquals(dynField1, dynClass.getDynField(field1));

                DynField dynField2 = dynClass.addDynField(field2);

                assertEquals(dynField2, dynClass.getDynField(field2));

                DynField[] fields = dynClass.getDeclaredDynFields();

                assertEquals(2, fields.length);

                dynClass.removeDynField(field1);

                assertNull(dynClass.getDynField(field1));

        }

        /**

         * Test method for

         * {@link org.gvsig.tools.dynobject.impl.DefaultDynClass#equals(Object)}.

         */

        public void testEquals() {

                DefaultDynClass dynClass2 = new DefaultDynClass(manager,

                                new DefaultDynClassName("dynclass2"), "description2");

                DefaultDynClass dynClassB = new DefaultDynClass(manager,

                                new DefaultDynClassName("dynclass"), "description");

                assertTrue(dynClass.equals(dynClassB));

                assertFalse(dynClass.equals(dynClass2));

                assertFalse(dynClass.equals(null));

        }

        /**

         * Validation test: DynObjects as dynfields within a dynObject.

         * 

         * Metadata A will have metadata B as porperty. for each dynField, a

         * validate function will be triggered with the current

         * 

         * @throws Exception

         * 

         */

        public void testValidate() throws Exception {

                /**

                 * Creating and registering both dynClasses

                 */

                DynObjectManager dynManager = ToolsLocator.getDynObjectManager();

                DynClass dynClassA = new DefaultDynClass(manager,

                                new DefaultDynClassName("metadata", "DynclassA"),

                                "descriptionA");

                dynManager.add(dynClassA);

                DynClass dynClassB = new DefaultDynClass(manager,

                                new DefaultDynClassName("metadata", "DynclassB"),

                                "descriptionB");

                dynManager.add(dynClassB);

                /**

                 * Filling dynClass B with "Name" and "Street"

                 */

                dynClassB.addDynFieldString("name");

                dynClassB.addDynFieldString("street");

                /**

                 * Filling dynClass A with "Name" and the dynClass B named "dynObjB"

                 */

                dynClassA.addDynFieldString("name");

                dynClassA.addDynField("dynObjB").setType(DataTypes.DYNOBJECT)

                                .setSubtype(dynClassB.getFullName());

                /**

                 * Creating dynObjects for current dynClasses and applying dynObject B

                 * as a property of A

                 */

                DynObject dynObjA = new DefaultDynObject(dynClassA);

                DynObject dynObjB = new DefaultDynObject(dynClassB);

                // TODO: Note that even specified a subType, if we set a different

                // dynObject, it will not check if the subType is correct.

                dynObjA.setDynValue("dynObjB", dynObjB);

                /**

                 * Once the structure has been created, we will validate each field of

                 * dynObject A, which also contains B as a property.

                 */

                DynField[] fields = dynObjA.getDynClass().getDynFields();

                DynField field;

                Object value;

                for (int i = 0; i < fields.length; ++i) {

                        field = fields[i];

                        value = dynObjA.getDynValue(field.getName());

                        // Checking that it actually contains the DynObject B as a

                        // property

                        if (field.getType() == DataTypes.DYNOBJECT) {

                                assertTrue(dynClassB.equals(((DynObject) value).getDynClass()));

                        }

                        // Performing validation

                        field.validate(value);

                }

        }

        /**

         * 

         * Duplicate test: checking if, given two dynClasses A and B, dynFields from

         * class A can be duplicated into dynClass B by using setters in B with the

         * returned values of getters of A as input.

         * 

         */

        public void testSetters() {

                /**

                 * Creating and registering both dynClasses

                 */

                DynObjectManager dynManager = ToolsLocator.getDynObjectManager();

                DynClass dynClassA = new DefaultDynClass(manager,

                                new DefaultDynClassName("metadata", "DynclassA"),

                                "descriptionA");

                DynClass dynClassB = new DefaultDynClass(manager,

                                new DefaultDynClassName("metadata", "DynclassB"),

                                "descriptionB");

                /**

                 * Filling dynClass B with "Name" and "Street"

                 */

                dynClassB.addDynFieldString("name");

                dynClassB.addDynFieldString("street");

                fillInitialDynfields(dynClassA, dynClassB.getFullName());

                // /**

                // * Creating dynObjects for current dynClasses and applying dynObject B

                // * as a property of A

                // */

                // DynObject dynObjA = new DefaultDynObject(dynClassA);

                // DynObject dynObjB = new DefaultDynObject(dynClassB);

                copyDefinitions(dynClassA, dynClassB);

                checkValues(dynClassA, dynClassB);

        }

        private List createList(Object[] values) {

                DynObjectValueItem[] valueItems = new DynObjectValueItem[values.length];

                for (int i = 0; i < values.length; i++) {

                        valueItems[i] = new DynObjectValueItem(values[i]);

                }

                return Arrays.asList(valueItems);

        }

        /**

         * Filling dynClass A with different parameters that will be duplicated into

         * dynClass B afterwards.

         */

        private void fillInitialDynfields(DynClass definition,

                        String dynClassBFullName) {

                List items = new ArrayList();

                definition.addDynFieldString("name");

                definition.addDynField("dynObjB").setType(DataTypes.DYNOBJECT)

                                .setSubtype(dynClassBFullName);

                definition.addDynFieldString("id").setReadOnly(true); // optional

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

                definition.addDynFieldString("charachterset").setMandatory(true)

                                .setAvailableValues(createList(new String[] { "a", "b", "c" }));

                definition

                                .addDynFieldList("hierarchyLevels")

                                .setElementsType(DataTypes.STRING)

                                .setMandatory(true)

                                .getElementsType()

                                .setAvailableValues(

                                                createList(new String[] { "hier1", "hier2", "hier3" }));

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

                definition.addDynFieldList("keywords")

                                .setElementsType(DataTypes.STRING);

                definition.addDynFieldList("dynObjects")

                                .setElementsType(DataTypes.DYNOBJECT).setMandatory(true)

                                .setSubtype(dynClassBFullName).getElementsType()

                                .setSubtype(dynClassBFullName);

        }

        private void copyDefinitions(DynClass dynClassA, DynClass dynClassB) {

                DynField field;

                DynField fields[] = dynClassA.getDynFields();

                for (int i = 0; i < fields.length; i++) {

                        field = fields[i];

                        ;

                        if (dynClassB.getDynField(field.getName()) == null) {

                                addDynField(dynClassB, field);

                        }

                }

                // dynFields must have the same number of items or more if some items

                // have been previously defined.

                assertTrue(dynClassB.getDynFields().length >= fields.length);

        }

        private void copyValues(DynObject oldDefinition, DynObject newDefinition) {

                Object value;

                DynField field;

                DynField fields[] = oldDefinition.getDynClass().getDynFields();

                for (int i = 0; i < fields.length; i++) {

                        field = fields[i];

                        value = oldDefinition.getDynValue(field.getName());

                        if (newDefinition.getDynClass().getDynField(field.getName()) == null) {

                                addDynField(newDefinition.getDynClass(), field);

                        }

                        if (value == null) {

                                continue;

                        }

                        if (value instanceof DynObject) {

                                DynObject parent = (DynObject) value;

                                DynStruct parentDefinition = parent.getDynClass();

                                DynClass childDefinition = manager.get(

                                                parentDefinition.getName(),

                                                parentDefinition.getNamespace());

                                DynObject child = manager.createDynObject(childDefinition);

                                copyValues(child, parent);

                                newDefinition.setDynValue(field.getName(), child);

                        } else {

                                newDefinition.setDynValue(field.getName(), value);

                        }

                }

        }

        private void addDynField(DynStruct definition, DynField field) {

                DynField dynField = definition.addDynField(field.getName())

                                .setType(field.getType()).setSubtype(field.getSubtype())

                                .setAvailableValues(field.getAvailableValues())

                                .setClassOfItems(field.getClassOfItems())

                                .setClassOfValue(field.getClassOfValue())

                                .setDefaultFieldValue(field.getDefaultValue())

                                .setDescription(field.getDescription())

                                .setGroup(field.getGroup()).setHidden(field.isHidden())

                                .setMandatory(field.isMandatory())

                                .setMaxValue(field.getMaxValue())

                                .setMinValue(field.getMinValue()).setOrder(field.getOder())

                                .setPersistent(field.isPersistent())

                                .setReadOnly(field.isReadOnly());

                copyElementsType(dynField, field.getElementsType());

        }

        private void copyElementsType(DynField dynField, DynField elementsType) {

                if (elementsType == null) {

                        return;

                }

                dynField.setElementsType(elementsType.getType());

                dynField.getElementsType().setSubtype(elementsType.getSubtype())

                                .setAvailableValues(elementsType.getAvailableValues())

                                .setClassOfItems(elementsType.getClassOfItems())

                                .setClassOfValue(elementsType.getClassOfValue())

                                .setDefaultFieldValue(elementsType.getDefaultValue())

                                .setDescription(elementsType.getDescription())

                                .setGroup(elementsType.getGroup())

                                .setHidden(elementsType.isHidden())

                                .setMandatory(elementsType.isMandatory())

                                .setMaxValue(elementsType.getMaxValue())

                                .setMinValue(elementsType.getMinValue())

                                .setOrder(elementsType.getOder())

                                .setPersistent(elementsType.isPersistent())

                                .setReadOnly(elementsType.isReadOnly());

        }

        private void checkValues(DynClass dynObjA, DynClass dynObjB) {

                DynField[] dynFieldsA = dynObjA.getDynFields();

                DynField[] dynFieldsB = dynObjB.getDynFields();

                DynField field;

                boolean done = false;

                for (int i = 0; i < dynFieldsA.length; ++i) {

                        field = dynFieldsA[i];

                        for (int j = 0; j < dynFieldsB.length; ++j) {

                                if (dynFieldsB[j].getName().equals(field.getName())) {

                                        checkDynField(field, dynFieldsB[j]);

                                        done = true;

                                }

                        }

                        // dynField must be defined in both lists.

                        assertTrue(done);

                }

        }

        private void checkDynField(DynField fieldA, DynField fieldB) {

                assertEquals(fieldA.getName(), fieldA.getName());

                assertEquals(fieldA.getType(), fieldB.getType());

                assertEquals(fieldA.getSubtype(), fieldB.getSubtype());

                assertEquals(fieldA.getAvailableValues(), fieldB.getAvailableValues());

                assertEquals(fieldA.getClassOfItems(), fieldB.getClassOfItems());

                assertEquals(fieldA.getClassOfValue(), fieldB.getClassOfValue());

                assertEquals(fieldA.getDefaultValue(), fieldB.getDefaultValue());

                assertEquals(fieldA.getDescription(), fieldB.getDescription());

                assertEquals(fieldA.getGroup(), fieldB.getGroup());

                assertEquals(fieldA.isHidden(), fieldB.isHidden());

                assertEquals(fieldA.isMandatory(), fieldB.isMandatory());

                assertEquals(fieldA.getMaxValue(), fieldB.getMaxValue());

                assertEquals(fieldA.getMinValue(), fieldB.getMinValue());

                assertEquals(fieldA.getOder(), fieldB.getOder());

                assertEquals(fieldA.isPersistent(), fieldB.isPersistent());

                assertEquals(fieldA.isReadOnly(), fieldB.isReadOnly());

        }

}