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

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.dynobject.DynStruct;

	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("street");

		/**

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

		 */

		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());

	}