/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.resource.metadata.impl;
import java.io.ByteArrayInputStream;
import java.io.StringWriter;
import java.util.HashSet;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import junit.framework.Assert;
import junit.framework.TestCase;
import org.w3c.dom.Document;
import org.apache.uima.UIMAFramework;
import org.apache.uima.internal.util.SerializationUtils;
import org.apache.uima.resource.metadata.impl.MetaDataObject_impl;
import org.apache.uima.test.junit_extension.JUnitExtension;
import org.apache.uima.util.XMLParser;
/**
* Tests the MetaDataObject_impl class.
*
*/
public class MetaDataObject_implTest extends TestCase {
/**
* Constructor for MetaDataObject_implTest.
*
* @param arg0
*/
public MetaDataObject_implTest(String arg0) {
super(arg0);
}
/**
* @see TestCase#setUp()
*/
protected void setUp() throws Exception {
super.setUp();
// create an object that can represent a fruit
unknownFruit = new TestFruitObject();
// create two identical apples and an orange
apple1 = new TestFruitObject();
apple1.setAttributeValue("name", "Apple");
apple1.setAttributeValue("color", "red");
apple1.setAttributeValue("avgWeightLbs", new Float(0.3));
apple1.setAttributeValue("avgCostCents", new Integer(40));
apple1.setAttributeValue("citrus", new Boolean(false));
apple1.setAttributeValue("commonUses", new String[] { "baking", "snack" });
apple2 = new TestFruitObject();
apple2.setAttributeValue("name", "Apple");
apple2.setAttributeValue("color", "red");
apple2.setAttributeValue("avgWeightLbs", new Float(0.3));
apple2.setAttributeValue("avgCostCents", new Integer(40));
apple2.setAttributeValue("citrus", new Boolean(false));
apple2.setAttributeValue("commonUses", new String[] { "baking", "snack" });
orange = new TestFruitObject();
orange.setAttributeValue("name", "Orange");
orange.setAttributeValue("color", "orange");
orange.setAttributeValue("avgWeightLbs", new Float(0.2));
orange.setAttributeValue("avgCostCents", new Integer(50));
orange.setAttributeValue("citrus", new Boolean(true));
orange.setAttributeValue("commonUses", new String[] { "snack", "juice" });
// create a fruit bag containing these three objects
fruitBag = new TestFruitBagObject();
TestFruitObject[] fruitArray = { apple1, apple2, orange };
fruitBag.setAttributeValue("fruits", fruitArray);
}
/**
* Tests the {@link MetaDataObject#listAttributes()} method.
*/
public void testListAttributes() throws Exception {
try {
HashSet apple1Attrs = new HashSet(apple1.listAttributes());
HashSet orangeAttrs = new HashSet(orange.listAttributes());
HashSet bagAttrs = new HashSet(fruitBag.listAttributes());
Assert.assertEquals(TestFruitObject.getAttributeSet(), apple1Attrs);
Assert.assertEquals(TestFruitObject.getAttributeSet(), orangeAttrs);
Assert.assertEquals(TestFruitBagObject.getAttributeSet(), bagAttrs);
} catch (RuntimeException e) {
JUnitExtension.handleException(e);
}
}
/**
* Tests the {@link MetaDataObject#equals(Object)} method.
*/
public void testEquals() throws Exception {
try {
Assert.assertEquals(unknownFruit, unknownFruit);
Assert.assertEquals(apple1, apple2);
Assert.assertEquals(apple2, apple1);
Assert.assertTrue(!unknownFruit.equals(apple1));
Assert.assertTrue(!apple1.equals(orange));
Assert.assertTrue(!apple1.equals(null));
Assert.assertEquals(apple1, apple1.clone());
Assert.assertEquals(fruitBag, fruitBag.clone());
Assert.assertTrue(!apple1.equals(orange.clone()));
} catch (RuntimeException e) {
JUnitExtension.handleException(e);
}
}
/**
* Tests the {@link MetaDataObject#toString()} method.
*/
public void testToString() throws Exception {
try {
String apple1Str = apple1.toString();
String apple2Str = apple2.toString();
String orangeStr = orange.toString();
Assert.assertEquals(apple1Str, apple2Str);
Assert.assertTrue(!apple1Str.equals(orangeStr));
} catch (RuntimeException e) {
JUnitExtension.handleException(e);
}
}
/**
* Tests the {@link MetaDataObject#toXML(Writer)} and
* {@link MetaDataObject#buildFromXMLElement(Element,XMLParser)} methods. These also sufficiently
* excercise the {@link MetaDataObject#getAttributeValue(String)} and
* {@link MetaDataObject#setAttributeValue(String,Object)} methods.
*/
public void testXMLization() throws Exception {
try {
// write objects to XML
StringWriter writer = new StringWriter();
apple1.toXML(writer);
String apple1xml = writer.getBuffer().toString();
// System.out.println(apple1xml);
writer = new StringWriter();
apple2.toXML(writer);
String apple2xml = writer.getBuffer().toString();
writer = new StringWriter();
orange.toXML(writer);
String orangeXml = writer.getBuffer().toString();
writer = new StringWriter();
fruitBag.toXML(writer);
String fruitBagXml = writer.getBuffer().toString();
// identical objects should have identical XML
Assert.assertEquals(apple1xml, apple2xml);
// parse the XML
DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
Document apple1xmlDoc = docBuilder.parse(new ByteArrayInputStream(apple1xml.getBytes()));
Document apple2xmlDoc = docBuilder.parse(new ByteArrayInputStream(apple2xml.getBytes()));
Document orangeXmlDoc = docBuilder.parse(new ByteArrayInputStream(orangeXml.getBytes()));
Document fruitBagXmlDoc = docBuilder.parse(new ByteArrayInputStream(fruitBagXml.getBytes()));
// construct new objects from the XML
XMLParser xmlp = UIMAFramework.getXMLParser();
MetaDataObject_impl newApple1 = (MetaDataObject_impl) unknownFruit.clone();
newApple1.buildFromXMLElement(apple1xmlDoc.getDocumentElement(), xmlp);
MetaDataObject_impl newApple2 = (MetaDataObject_impl) unknownFruit.clone();
newApple2.buildFromXMLElement(apple2xmlDoc.getDocumentElement(), xmlp);
MetaDataObject_impl newOrange = (MetaDataObject_impl) unknownFruit.clone();
newOrange.buildFromXMLElement(orangeXmlDoc.getDocumentElement(), xmlp);
xmlp.addMapping("fruit", TestFruitObject.class.getName());
MetaDataObject_impl newFruitBag = new TestFruitBagObject();
newFruitBag.buildFromXMLElement(fruitBagXmlDoc.getDocumentElement(), xmlp);
// new objects should be equal to the originals
Assert.assertEquals(apple1, newApple1);
Assert.assertEquals(apple2, newApple2);
Assert.assertEquals(orange, newOrange);
Assert.assertTrue(fruitBag.equals(newFruitBag));
// test special cases
// single-property object where propety name is ommitted from XML
String xmlStr = "<fruitBag><fruit><name>banana</name><color>yellow</color></fruit>"
+ "<fruit><name>raspberry</name><color>red</color></fruit></fruitBag>";
Document xmlDoc = docBuilder.parse(new ByteArrayInputStream(xmlStr.getBytes()));
TestFruitBagObject bag = new TestFruitBagObject();
bag.buildFromXMLElement(xmlDoc.getDocumentElement(), xmlp);
TestFruitObject[] fruits = bag.getFruits();
Assert.assertEquals(2, fruits.length);
Assert.assertEquals("banana", fruits[0].getName());
Assert.assertEquals("raspberry", fruits[1].getName());
// property name ommitted but can be inferred from type of value
xmlStr = "<fruit><name>banana</name><string>yellow</string></fruit>";
xmlDoc = docBuilder.parse(new ByteArrayInputStream(xmlStr.getBytes()));
TestFruitObject banana = new TestFruitObject();
banana.buildFromXMLElement(xmlDoc.getDocumentElement(), xmlp);
Assert.assertEquals("yellow", banana.getColor());
Assert.assertEquals("banana", banana.getName());
// env var reference
xmlStr = "<fruit><name>raspberry</name><string><envVarRef>test.raspberry.color</envVarRef></string></fruit>";
System.setProperty("test.raspberry.color", "red");
xmlDoc = docBuilder.parse(new ByteArrayInputStream(xmlStr.getBytes()));
TestFruitObject raspberry = new TestFruitObject();
raspberry.buildFromXMLElement(xmlDoc.getDocumentElement(), xmlp);
Assert.assertEquals("red", raspberry.getColor());
Assert.assertEquals("raspberry", raspberry.getName());
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testSerialization() throws Exception {
try {
byte[] apple1Bytes = SerializationUtils.serialize(apple1);
TestFruitObject apple1a = (TestFruitObject) SerializationUtils.deserialize(apple1Bytes);
Assert.assertEquals(apple1, apple1a);
byte[] apple2Bytes = SerializationUtils.serialize(apple2);
TestFruitObject apple2a = (TestFruitObject) SerializationUtils.deserialize(apple2Bytes);
Assert.assertEquals(apple2, apple2a);
byte[] orangeBytes = SerializationUtils.serialize(orange);
TestFruitObject orange2 = (TestFruitObject) SerializationUtils.deserialize(orangeBytes);
Assert.assertEquals(orange, orange2);
// make sure XMLization still works
StringWriter sw = new StringWriter();
orange.toXML(sw);
String orange1xml = sw.getBuffer().toString();
sw.getBuffer().setLength(0);
orange2.toXML(sw);
String orange2xml = sw.getBuffer().toString();
assertEquals(orange1xml, orange2xml);
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
private TestFruitObject unknownFruit;
private TestFruitObject apple1;
private TestFruitObject apple2;
private TestFruitObject orange;
private TestFruitBagObject fruitBag;
}