|
1
16
17 package org.apache.commons.betwixt.introspection;
18
19 import java.util.List  ;
20
21 import org.apache.commons.betwixt.AbstractTestCase;
22 import org.apache.commons.betwixt.ElementDescriptor;
23 import org.apache.commons.betwixt.XMLBeanInfo;
24 import org.apache.commons.betwixt.XMLIntrospector;
25 import org.apache.commons.betwixt.examples.rss.Channel;
26
27
32 public class TestDeclarativeIntrospection extends AbstractTestCase{
33 public TestDeclarativeIntrospection(String name) {
34 super(name);
35 }
36
37
38 public void testStandardPropertyIsHollow() throws Exception {
39 XMLIntrospector introspector = new XMLIntrospector();
40 introspector.getConfiguration().setAttributesForPrimitives(true);
41 XMLBeanInfo out = introspector.introspect(CompanyBean.class);
42
43 ElementDescriptor companyBeanDescriptor = out.getElementDescriptor();
44 ElementDescriptor[] childDescriptors = companyBeanDescriptor.getElementDescriptors();
45 assertEquals("Correct number of child descriptors", 1, childDescriptors.length);
46
47 ElementDescriptor addressDescriptor = childDescriptors[0];
48 assertEquals("standard property is hollow", true, addressDescriptor.isHollow());
49 }
50
51
52
53 public void testSimpleElementIsHollow() throws Exception {
54 XMLIntrospector introspector = new XMLIntrospector();
55 introspector.getConfiguration().setAttributesForPrimitives(false);
56 XMLBeanInfo out = introspector.introspect(CompanyBean.class);
57
58 ElementDescriptor companyBeanDescriptor = out.getElementDescriptor();
59 ElementDescriptor[] childDescriptors = companyBeanDescriptor.getElementDescriptors();
60 assertEquals("Correct number of child descriptors", 2, childDescriptors.length);
61
62 ElementDescriptor nameDescriptor = null;
63 for (int i=0, size=childDescriptors.length; i<size; i++)
64 {
65 if ("name".equals(childDescriptors[i].getLocalName())) {
66 nameDescriptor = childDescriptors[i];
67 }
68 }
69
70 assertNotNull("Expected to find an element descriptor for 'name'", nameDescriptor);
71 assertFalse("Expected simple element not to be hollow", nameDescriptor.isHollow());
72 }
73
74 public void testWrappedCollective() throws Exception {
75 XMLIntrospector introspector = new XMLIntrospector();
76 introspector.getConfiguration().setWrapCollectionsInElement(true);
77 introspector.getConfiguration().setAttributesForPrimitives(true);
78 XMLBeanInfo out = introspector.introspect(PhoneBookBean.class);
79
80 ElementDescriptor phoneBookBeanDescriptor = out.getElementDescriptor();
83 ElementDescriptor[] phoneBookChildDescriptors = phoneBookBeanDescriptor.getElementDescriptors();
84 assertEquals("Expected single wrapping descriptor", 1, phoneBookChildDescriptors.length);
85
86 ElementDescriptor wrappingDescriptor = phoneBookChildDescriptors[0];
87 assertNull("Spacer should not have an updater", wrappingDescriptor.getUpdater());
88 assertEquals("Wrapper element name should match getter", "numbers" , wrappingDescriptor.getQualifiedName());
89
90 ElementDescriptor[] wrappingChildDescriptors = wrappingDescriptor.getElementDescriptors();
91 assertEquals("Expected single child for wrapping descriptor", 1, wrappingChildDescriptors.length);
92
93 ElementDescriptor hollowPhoneNumberDescriptor = wrappingChildDescriptors[0];
94 assertTrue("Expected wrapped descriptor to be hollow", hollowPhoneNumberDescriptor.isHollow());
95 assertEquals("Expected the collective property type to be a list",
96 List .class,
97 hollowPhoneNumberDescriptor.getPropertyType());
98 assertEquals("Expected the singular property type to be the phone number",
99 PhoneNumberBean.class,
100 hollowPhoneNumberDescriptor.getSingularPropertyType());
101
102 assertEquals("Collective element name should match adder", "number" , hollowPhoneNumberDescriptor.getQualifiedName());
103
104 }
105
106 public void testUnwrappedCollective() throws Exception {
107 XMLIntrospector introspector = new XMLIntrospector();
108 introspector.getConfiguration().setWrapCollectionsInElement(false);
109 introspector.getConfiguration().setAttributesForPrimitives(true);
110 XMLBeanInfo out = introspector.introspect(PhoneBookBean.class);
111
112 ElementDescriptor phoneBookBeanDescriptor = out.getElementDescriptor();
115 ElementDescriptor[] phoneBookChildDescriptors = phoneBookBeanDescriptor.getElementDescriptors();
116 assertEquals("Expected single child descriptor", 1, phoneBookChildDescriptors.length);
117
118 ElementDescriptor hollowPhoneNumberDescriptor = phoneBookChildDescriptors[0];
119
120 assertTrue("Expected collective element descriptor to be hollow", hollowPhoneNumberDescriptor.isHollow());
121 assertEquals("Expected the collective property type to be a list",
122 List .class,
123 hollowPhoneNumberDescriptor.getPropertyType());
124 assertEquals("Expected the singular property type to be the phone number",
125 PhoneNumberBean.class,
126 hollowPhoneNumberDescriptor.getSingularPropertyType());
127 assertEquals("Collective element name should match adder", "number" , hollowPhoneNumberDescriptor.getQualifiedName());
128 }
129
130 public void testUnwrappedMap() throws Exception {
131 XMLIntrospector introspector = new XMLIntrospector();
132 introspector.getConfiguration().setWrapCollectionsInElement(false);
133 introspector.getConfiguration().setAttributesForPrimitives(true);
134 XMLBeanInfo out = introspector.introspect(DateFormatterBean.class);
135
136 ElementDescriptor formatterDescriptor = out.getElementDescriptor();
137 ElementDescriptor[] formatterChildDescriptors = formatterDescriptor.getElementDescriptors();
138
139 assertEquals("Only one top level child", 1, formatterChildDescriptors.length);
140
141 ElementDescriptor entryDescriptor = formatterChildDescriptors[0];
142 assertEquals("Must be called entry", "entry" , entryDescriptor.getLocalName());
143 assertFalse("Is not hollow", entryDescriptor.isHollow());
144 assertNull("No updater for entry spacer", entryDescriptor.getUpdater());
145
146 ElementDescriptor[] entryChildDesciptors = entryDescriptor.getElementDescriptors();
147 assertEquals("Entry has two children", 2, entryChildDesciptors.length);
148
149 ElementDescriptor keyDescriptor = entryChildDesciptors[0];
150 assertEquals("Must be called key", "key", keyDescriptor.getLocalName());
151 assertTrue("Is not simple therefore hollow", keyDescriptor.isHollow());
152 assertNotNull("Key should have an updater", keyDescriptor.getUpdater());
153
154 ElementDescriptor valueDescriptor = entryChildDesciptors[1];
155 assertEquals("Must be called key", "value", valueDescriptor.getLocalName());
156 assertTrue("Is not simple therefore hollow", valueDescriptor.isHollow());
157 assertNotNull("Value should have an updater", valueDescriptor.getUpdater());
158 }
159
160 public void testWrappedMap() throws Exception {
161 XMLIntrospector introspector = new XMLIntrospector();
162 introspector.getConfiguration().setWrapCollectionsInElement(true);
163 introspector.getConfiguration().setAttributesForPrimitives(true);
164 XMLBeanInfo out = introspector.introspect(DateFormatterBean.class);
165
166 ElementDescriptor formatterDescriptor = out.getElementDescriptor();
167 ElementDescriptor[] formatterChildDescriptors = formatterDescriptor.getElementDescriptors();
168
169 assertEquals("Only one top level child", 1, formatterChildDescriptors.length);
170
171 ElementDescriptor spacerDescriptor = formatterChildDescriptors[0];
172 assertEquals("Spacer must be called formats", "formats" , spacerDescriptor.getLocalName());
173 assertFalse("Is not hollow", spacerDescriptor.isHollow());
174 assertNull("No updater for entry spacer", spacerDescriptor.getUpdater());
175
176 ElementDescriptor[] spacerChildDescriptors = spacerDescriptor.getElementDescriptors();
177 assertEquals("Only one top level child", 1, spacerChildDescriptors.length);
178
179 ElementDescriptor entryDescriptor = spacerChildDescriptors[0];
180 assertEquals("Must be called entry", "entry" , entryDescriptor.getLocalName());
181 assertFalse("Is not hollow", entryDescriptor.isHollow());
182 assertNull("No updater for entry spacer", entryDescriptor.getUpdater());
183
184 ElementDescriptor[] entryChildDesciptors = entryDescriptor.getElementDescriptors();
185 assertEquals("Entry has two children", 2, entryChildDesciptors.length);
186
187 ElementDescriptor keyDescriptor = entryChildDesciptors[0];
188 assertEquals("Must be called key", "key", keyDescriptor.getLocalName());
189 assertTrue("Is not simple therefore hollow", keyDescriptor.isHollow());
190 assertNotNull("Key should have an updater", keyDescriptor.getUpdater());
191
192 ElementDescriptor valueDescriptor = entryChildDesciptors[1];
193 assertEquals("Must be called key", "value", valueDescriptor.getLocalName());
194 assertTrue("Is not simple therefore hollow", valueDescriptor.isHollow());
195 assertNotNull("Value should have an updater", valueDescriptor.getUpdater());
196 }
197
198 public void testIsSimpleForPrimitives() throws Exception {
199 XMLIntrospector introspector = new XMLIntrospector();
200 introspector.getConfiguration().setWrapCollectionsInElement(true);
201 introspector.getConfiguration().setAttributesForPrimitives(false);
202 XMLBeanInfo out = introspector.introspect(PhoneNumberBean.class);
203
204 ElementDescriptor phoneNumberDescriptor = out.getElementDescriptor();
206
207 assertFalse("Phone number descriptor is complex", phoneNumberDescriptor.isSimple());
208
209 ElementDescriptor[] phoneNumberChildDescriptors = phoneNumberDescriptor.getElementDescriptors();
210 assertEquals("Expected three child elements", 3, phoneNumberChildDescriptors.length);
211
212 assertTrue("Descriptor " + phoneNumberChildDescriptors[0] + " should be simple",
214 phoneNumberChildDescriptors[0].isSimple());
215 assertTrue("Descriptor " + phoneNumberChildDescriptors[1] + " should be simple",
216 phoneNumberChildDescriptors[1].isSimple());
217 assertTrue("Descriptor " + phoneNumberChildDescriptors[2] + " should be simple",
218 phoneNumberChildDescriptors[2].isSimple());
219 }
220
221 public void testSimpleForRSS() throws Exception {
222 XMLIntrospector introspector = new XMLIntrospector();
223 introspector.getConfiguration().setWrapCollectionsInElement(true);
224 introspector.getConfiguration().setAttributesForPrimitives(false);
225 XMLBeanInfo out = introspector.introspect(Channel.class);
226
227 ElementDescriptor channelDescriptor = out.getElementDescriptor();
228 ElementDescriptor[] childNodesOfRSS = channelDescriptor.getElementDescriptors();
229 assertEquals("RSS has only one child, channel", 1, childNodesOfRSS.length);
230 ElementDescriptor[] childNodesOfChannel = childNodesOfRSS[0].getElementDescriptors();
231
232 boolean matched = false;
233 for (int i=0, size=childNodesOfChannel.length; i<size; i++) {
234 if ("item".equals(childNodesOfChannel[i].getLocalName())) {
235 matched = true;
236 }
237 }
238 assertTrue("Local element named item", matched);
239
240 for (int i=0, size=childNodesOfChannel.length; i<size; i++) {
241 if ("title".equals(childNodesOfChannel[i].getLocalName())) {
242 assertFalse("Title is not hollow", childNodesOfChannel[i].isHollow());
243 } else if ("item".equals(childNodesOfChannel[i].getLocalName())) {
244 assertTrue("Item is hollow", childNodesOfChannel[i].isHollow());
245 } else if ("textinput".equals(childNodesOfChannel[i].getLocalName())) {
246 assertTrue("TextInput is hollow", childNodesOfChannel[i].isHollow());
247 } else if ("skipDays".equals(childNodesOfChannel[i].getLocalName())) {
248 assertFalse("skipDays is not hollow", childNodesOfChannel[i].isHollow());
249 assertFalse("day is not hollow", childNodesOfChannel[i].getElementDescriptors()[0].isHollow());
250 } else if ("skipHours".equals(childNodesOfChannel[i].getLocalName())) {
251 assertFalse("skipHours is not hollow", childNodesOfChannel[i].isHollow());
252 assertFalse("hour is not hollow", childNodesOfChannel[i].getElementDescriptors()[0].isHollow());
253 }
254 }
255 }
256
257
258 public void testMapWithSimpleKey() throws Exception {
259 XMLIntrospector introspector = new XMLIntrospector();
260 introspector.getConfiguration().setWrapCollectionsInElement(false);
261 introspector.getConfiguration().setAttributesForPrimitives(true);
262 XMLBeanInfo out = introspector.introspect(AddressBook.class);
263
264 ElementDescriptor formatterDescriptor = out.getElementDescriptor();
265 ElementDescriptor[] formatterChildDescriptors = formatterDescriptor.getElementDescriptors();
266
267 assertEquals("Two top level children", 2, formatterChildDescriptors.length);
268
269 ElementDescriptor entryDescriptor = formatterChildDescriptors[0];
270 assertEquals("Must be called entry", "entry" , entryDescriptor.getLocalName());
271 assertFalse("Is not hollow", entryDescriptor.isHollow());
272 assertNull("No updater for entry spacer", entryDescriptor.getUpdater());
273
274 ElementDescriptor[] entryChildDesciptors = entryDescriptor.getElementDescriptors();
275 assertEquals("Entry has two children", 2, entryChildDesciptors.length);
276
277 ElementDescriptor keyDescriptor = entryChildDesciptors[0];
278 assertEquals("Must be called key", "key", keyDescriptor.getLocalName());
279 assertFalse("Is simple therefore not hollow", keyDescriptor.isHollow());
280 assertNotNull("Key should have an updater", keyDescriptor.getUpdater());
281
282 ElementDescriptor valueDescriptor = entryChildDesciptors[1];
283 assertEquals("Must be called key", "value", valueDescriptor.getLocalName());
284 assertTrue("Is not simple therefore hollow", valueDescriptor.isHollow());
285 assertNotNull("Value should have an updater", valueDescriptor.getUpdater());
286 }
287
288
289 public void testMapWithSimpleEntry() throws Exception {
290 XMLIntrospector introspector = new XMLIntrospector();
291 introspector.getConfiguration().setWrapCollectionsInElement(false);
292 introspector.getConfiguration().setAttributesForPrimitives(true);
293 XMLBeanInfo out = introspector.introspect(AddressBook.class);
294
295 ElementDescriptor formatterDescriptor = out.getElementDescriptor();
296 ElementDescriptor[] formatterChildDescriptors = formatterDescriptor.getElementDescriptors();
297
298 assertEquals("Two top level children", 2, formatterChildDescriptors.length);
299
300 ElementDescriptor entryDescriptor = formatterChildDescriptors[1];
301 assertEquals("Must be called entry", "entry" , entryDescriptor.getLocalName());
302 assertFalse("Is not hollow", entryDescriptor.isHollow());
303 assertNull("No updater for entry spacer", entryDescriptor.getUpdater());
304
305 ElementDescriptor[] entryChildDesciptors = entryDescriptor.getElementDescriptors();
306 assertEquals("Entry has two children", 2, entryChildDesciptors.length);
307
308 ElementDescriptor keyDescriptor = entryChildDesciptors[0];
309 assertEquals("Must be called key", "key", keyDescriptor.getLocalName());
310 assertTrue("Is not simple therefore hollow", keyDescriptor.isHollow());
311 assertNotNull("Key should have an updater", keyDescriptor.getUpdater());
312
313 ElementDescriptor valueDescriptor = entryChildDesciptors[1];
314 assertEquals("Must be called key", "value", valueDescriptor.getLocalName());
315 assertFalse("Is simple therefore not hollow", valueDescriptor.isHollow());
316 assertNotNull("Value should have an updater", valueDescriptor.getUpdater());
317 }
318
319 public void testConcreteMapNoWrap() throws Exception {
320 XMLIntrospector introspector = new XMLIntrospector();
321 introspector.getConfiguration().setWrapCollectionsInElement(false);
322 XMLBeanInfo beanInfo = introspector.introspect(BeanWithConcreteMap.class);
323 ElementDescriptor beanDescriptor = beanInfo.getElementDescriptor();
324
325 ElementDescriptor[] beanChildDescriptors = beanDescriptor.getElementDescriptors();
326 assertEquals("One Entry element", 1, beanChildDescriptors.length);
327
328 ElementDescriptor entry = beanChildDescriptors[0];
329 ElementDescriptor[] entryChildren = entry.getElementDescriptors();
330 assertEquals("Expected key and entry elements", 2 , entryChildren.length);
331 }
332
333 public void testConcreteMapWithWrap() throws Exception {
334 XMLIntrospector introspector = new XMLIntrospector();
335 introspector.getConfiguration().setWrapCollectionsInElement(true);
336 XMLBeanInfo beanInfo = introspector.introspect(BeanWithConcreteMap.class);
337
338 ElementDescriptor beanDescriptor = beanInfo.getElementDescriptor();
339
340 ElementDescriptor[] beanChildDescriptors = beanDescriptor.getElementDescriptors();
341 assertEquals("One wrapper element", 1, beanChildDescriptors.length);
342
343 ElementDescriptor wrapper = beanChildDescriptors[0];
344 ElementDescriptor[] wrapperChildren = wrapper.getElementDescriptors();
345 assertEquals("One Entry element", 1, wrapperChildren.length);
346
347 ElementDescriptor entry = wrapperChildren[0];
348 ElementDescriptor[] entryChildren = entry.getElementDescriptors();
349 assertEquals("Expected key and entry elements", 2 , entryChildren.length);
350
351
352 }
353 }
354 |
Popular Tags |
Java API By Example, From Geeks To Geeks.