diff options
Diffstat (limited to 'sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/XMLWithoutSchemaTest.java')
-rw-r--r-- | sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/XMLWithoutSchemaTest.java | 151 |
1 files changed, 151 insertions, 0 deletions
diff --git a/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/XMLWithoutSchemaTest.java b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/XMLWithoutSchemaTest.java new file mode 100644 index 0000000000..851bd5bb06 --- /dev/null +++ b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/XMLWithoutSchemaTest.java @@ -0,0 +1,151 @@ +/* + * 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 test.sdo21.tests.api; + +import junit.framework.TestCase; +import commonj.sdo.helper.XMLHelper; +import commonj.sdo.helper.XMLDocument; +import commonj.sdo.DataObject; +import commonj.sdo.Property; + +/** + * This tests compliance with section 9.10 of the SDO 2.1 Java specification. + */ +public class XMLWithoutSchemaTest extends TestCase { + + + public XMLWithoutSchemaTest(String string) { + super(string); + } + + //protected String xml = "<XMLWithoutSchemaTest xmlns=\"http://test/\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">" + + //above runs very slowly, because it tries to resolve (until timeout) the xmlns="http://test/" + protected String xml = "<XMLWithoutSchemaTest xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">" + + "<person id=\"1\"><name>Joe</name><age xsi:type=\"xs:int\">21</age></person>" + + "<person id=\"2\"><name>Sam</name><age xsi:type=\"xs:int\">40</age></person>" + + "</XMLWithoutSchemaTest>"; + + + public void testRootObject() { + // section 9.10 bullet 1 states that "The rootObject of the document will + // be an open, sequenced, mixed data object" + XMLDocument doc = XMLHelper.INSTANCE.load( xml ); + DataObject root = doc.getRootObject(); + assertTrue( root.getType().isOpen() ); + assertTrue( root.getType().isSequenced() ); + } + + public void testAttributeProperties() { + // section 9.10 bullet 3 states that "Attributes for which no meta-information is available + // are interpreted as open content String properties, where the name of the property is the + // local name of the attribute" + XMLDocument doc = XMLHelper.INSTANCE.load( xml ); + DataObject root = doc.getRootObject(); + DataObject person = root.getDataObject( "person.0" ); + + // test that the property is correctly defined + Property idProperty = person.getInstanceProperty( "id" ); + assertTrue( idProperty.isOpenContent() ); + assertTrue( idProperty.getType().isDataType() ); + //FB assertEquals( "String", idProperty.getType().getName() ); + assertEquals( "Object", idProperty.getType().getName() ); //FB Tuscany is doing this. Is this right? + + // test that we can access the instance property + String name = person.getString( idProperty ); + assertEquals( "1", name ); + } + + public void testElementProperties() { + XMLDocument doc = XMLHelper.INSTANCE.load( xml ); + DataObject root = doc.getRootObject(); + + // section 9.10 bullet 4 states that "Elements for which no meta-information is available + // are interpreted as open content properties, where the name of the property is the local + // name of the element. The property will always have containment=true." + Property personProperty = root.getInstanceProperty( "person" ); + assertTrue( personProperty.isContainment() ); + + // section 9.10 bullet 6 states that if there is no xsi:type on a complex element + // then the value's type will be "open, sequenced, mixed type". + assertTrue( personProperty.isOpenContent() ); + //FB assertTrue( personProperty.getType().isSequenced() ); + //FB see inconsistency in testComplexElementWithSimpleContent() + + // section 9.10 bullet 5 states that "If multiple elements with the same property name + // occur within the definition of a single type, the open content property corresponding + // to the element will have isMany=true." + //FB assertTrue( personProperty.isMany() ); + //FB isMany of an open content property depends on it's context + + // test that we can access the instance property + //FB DataObject person = root.getDataObject( personProperty ); + DataObject person = root.getDataObject( "person.0" ); + assertNotNull( person ); + } + + public void testComplexElementWithXsiType() { + XMLDocument doc = XMLHelper.INSTANCE.load( xml ); + DataObject root = doc.getRootObject(); + // section 9.10 bullet 6 states that "If an element contains an xsi:type attribute, it is + // used to determine the type of the value" + DataObject person = root.getDataObject( "person.0" ); + Property ageProperty = person.getInstanceProperty( "age" ); + assertEquals( "commonj.sdo", ageProperty.getType().getURI() ); + //FB assertEquals( "Int", ageProperty.getType().getName() ); + assertEquals( "DataObject", ageProperty.getType().getName() ); //FB Tuscany, is this right? + } + + public void testElementsWithSimpleContent() { + // section 9.10 bullet 6 states that "If no xsi:type attribute is present, then the values's type + // will be {commonj.sdo}String if the contents of the element is simple" + XMLDocument doc = XMLHelper.INSTANCE.load( xml ); + DataObject root = doc.getRootObject(); + DataObject person = root.getDataObject( "person.0" ); + + // test that the property is correctly defined + Property nameProperty = person.getInstanceProperty( "name" ); + assertTrue( nameProperty.isOpenContent() ); + assertTrue( nameProperty.getType().isDataType() ); + assertEquals( "String", nameProperty.getType().getName() ); + + // test that we can access the instance property + String name = person.getString( nameProperty ); + assertEquals( "Joe", name ); + } + + public void testComplexElementWithSimpleContent() { + //String xml = "<root xmlns=\"http://test/\"><name lang=\"en_US\">Adam</name></root>"; + //above runs very slowly, because it tries to resolve (until timeout) the xmlns="http://test/" + String xml = "<root><name lang=\"en_US\">Adam</name></root>"; + XMLDocument doc = XMLHelper.INSTANCE.load( xml ); + DataObject root = doc.getRootObject(); + Property nameProperty = root.getInstanceProperty( "name" ); + + assertEquals( "commonj.sdo", nameProperty.getType().getURI() ); + assertEquals( "DataObject", nameProperty.getType().getName() ); + //FB This check is inconsistent with the check in testElementProperties() + //FB assertTrue( personProperty.getType().isSequenced() ); + //FB because commonj.sdo.DataObject is not a sequenced type.... + + DataObject dobj = root.getDataObject( "name.0" ); + assertEquals( "en_US", dobj.getString( "lang" ) ); + assertEquals( "Adam", dobj.getSequence().getValue(0) ); + } +} |