1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
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) );
}
}
|
