2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.yangtools.yang.stmt.retest;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertFalse;
12 import static org.junit.Assert.assertNotNull;
13 import static org.junit.Assert.assertTrue;
14 import java.io.FileNotFoundException;
16 import java.net.URISyntaxException;
17 import java.text.DateFormat;
18 import java.text.ParseException;
19 import java.text.SimpleDateFormat;
20 import java.util.ArrayDeque;
21 import java.util.Collection;
22 import java.util.Date;
23 import java.util.Deque;
25 import org.junit.Before;
26 import org.junit.Test;
27 import org.opendaylight.yangtools.yang.common.QName;
28 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
29 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
30 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
31 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
32 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
33 import org.opendaylight.yangtools.yang.model.api.Module;
34 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
35 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
36 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
37 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
38 import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
39 import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
40 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
41 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
43 public class UsesAugmentTest {
44 private static final URI UG_NS = URI.create("urn:opendaylight:params:xml:ns:yang:uses-grouping");
45 private static final URI GD_NS = URI.create("urn:opendaylight:params:xml:ns:yang:grouping-definitions");
49 private Set<Module> modules;
52 public void init() throws FileNotFoundException, ParseException {
53 DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
54 UG_REV = simpleDateFormat.parse("2013-07-30");
55 GD_REV = simpleDateFormat.parse("2013-09-04");
59 * Structure of testing model:
62 * |-- leaf version (U)
65 * |-- |-- container rp
66 * |-- |-- |-- leaf priority (U)
67 * |-- |-- |-- container box (U)
68 * |-- |-- |-- |-- container order (A)
69 * |-- |-- |-- |-- |-- leaf delete (U)
70 * |-- |-- |-- |-- |-- |-- leaf setup (U)
71 * |-- |-- |-- leaf processing-rule (U)
72 * |-- |-- |-- leaf ignore (U)
73 * |-- |-- path-key-expansion
74 * |-- |-- |-- container path-key
75 * |-- |-- |-- |-- list path-keys (U)
76 * |-- |-- |-- |-- |-- leaf version (U)
77 * |-- |-- |-- |-- |-- leaf type (U)
78 * |-- |-- |-- |-- |-- leaf processing-rule (U)
79 * |-- |-- |-- |-- |-- leaf ignore (U)
80 * |-- |-- container segment-computation
81 * |-- |-- |-- container p2p
82 * |-- |-- |-- |-- container endpoints
83 * |-- |-- |-- |-- |-- leaf processing-rule (U)
84 * |-- |-- |-- |-- |-- leaf ignore (U)
85 * |-- |-- |-- |-- |-- container box (U)
86 * |-- |-- |-- |-- |-- choice address-family (U)
87 * |-- |-- |-- |-- |-- |-- case ipv4
88 * |-- |-- |-- |-- |-- |-- |-- leaf source-ipv4-address
89 * |-- |-- |-- |-- |-- |-- case ipv6
90 * |-- |-- |-- |-- |-- |-- |-- leaf source-ipv6-address
91 * |-- |-- |-- |-- container reported-route
92 * |-- |-- |-- |-- |-- container bandwidth
93 * |-- |-- |-- |-- |-- list subobjects(U)
94 * |-- |-- |-- |-- |-- leaf processing-rule (U)
95 * |-- |-- |-- |-- |-- leaf ignore (U)
96 * |-- |-- |-- |-- container bandwidth (U)
97 * |-- |-- |-- |-- |-- container bandwidth (U)
98 * |-- |-- |-- |-- |-- leaf processing-rule (U)
99 * |-- |-- |-- |-- |-- leaf ignore (U)
101 * |-- |-- list metric
102 * |-- |-- |-- leaf metric-type (U)
103 * |-- |-- |-- container box (U)
104 * |-- |-- |-- leaf processing-rule (U)
105 * |-- |-- |-- leaf ignore (U)
106 * |-- |-- leaf link-diverse (U)
107 * |-- |-- leaf processing-rule (U)
108 * |-- |-- leaf ignore (U)
110 * U = added by uses A = added by augment
113 public void testAugmentInUses() throws Exception {
114 modules = TestUtils.loadModules(getClass().getResource("/grouping-test").toURI());
115 Module testModule = TestUtils.findModule(modules, "uses-grouping");
117 Deque<QName> path = new ArrayDeque<>();
119 // * notification pcreq
120 Set<NotificationDefinition> notifications = testModule.getNotifications();
121 assertEquals(1, notifications.size());
122 NotificationDefinition pcreq = notifications.iterator().next();
123 assertNotNull(pcreq);
124 QName expectedQName = QName.create(UG_NS, UG_REV, "pcreq");
125 path.offer(expectedQName);
126 SchemaPath expectedPath = SchemaPath.create(path, true);
127 assertEquals(expectedPath, pcreq.getPath());
128 Collection<DataSchemaNode> childNodes = pcreq.getChildNodes();
129 assertEquals(4, childNodes.size());
130 // * |-- leaf version
131 LeafSchemaNode version = (LeafSchemaNode) pcreq.getDataChildByName("version");
132 assertNotNull(version);
133 expectedQName = QName.create(UG_NS, UG_REV, "version");
134 path.offer(expectedQName);
135 expectedPath = SchemaPath.create(path, true);
136 assertEquals(expectedPath, version.getPath());
137 expectedQName = QName.create(UG_NS, UG_REV, "version");
138 path.offer(expectedQName);
139 expectedPath = SchemaPath.create(true, pcreq.getQName(), expectedQName);
140 assertEquals(expectedPath, version.getType().getPath());
141 assertEquals(BaseTypes.uint8Type(), version.getType().getBaseType().getBaseType());
142 assertTrue(version.isAddedByUses());
144 LeafSchemaNode type = (LeafSchemaNode) pcreq.getDataChildByName("type");
146 expectedQName = QName.create(UG_NS, UG_REV, "type");
147 assertTrue(type.isAddedByUses());
150 path.offer(expectedQName);
151 expectedPath = SchemaPath.create(path, true);
152 assertEquals(expectedPath, type.getPath());
153 expectedQName = QName.create(GD_NS, GD_REV, "int-ext");
154 path.offer(expectedQName);
155 expectedPath = SchemaPath.create(true, expectedQName);
156 assertEquals(expectedPath, type.getType().getPath());
157 UnionTypeDefinition union = (UnionTypeDefinition) type.getType().getBaseType();
158 assertEquals(SchemaPath.create(true, expectedQName, QName.create(expectedQName, "union")), union.getPath());
159 assertEquals(2, union.getTypes().size());
160 // * |-- list requests
161 ListSchemaNode requests = (ListSchemaNode) pcreq.getDataChildByName("requests");
162 assertNotNull(requests);
163 expectedQName = QName.create(UG_NS, UG_REV, "requests");
164 assertEquals(expectedQName, requests.getQName());
167 path.offer(expectedQName);
168 expectedPath = SchemaPath.create(path, true);
169 assertEquals(expectedPath, requests.getPath());
170 assertFalse(requests.isAddedByUses());
171 childNodes = requests.getChildNodes();
172 assertEquals(3, childNodes.size());
173 // * |-- |-- container rp
174 ContainerSchemaNode rp = (ContainerSchemaNode) requests.getDataChildByName("rp");
176 expectedQName = QName.create(UG_NS, UG_REV, "rp");
177 path.offer(expectedQName);
178 expectedPath = SchemaPath.create(path, true);
179 assertEquals(expectedPath, rp.getPath());
180 assertFalse(rp.isAddedByUses());
181 childNodes = rp.getChildNodes();
182 assertEquals(4, childNodes.size());
183 // * |-- |-- |-- leaf processing-rule
184 LeafSchemaNode processingRule = (LeafSchemaNode) rp.getDataChildByName("processing-rule");
185 assertNotNull(processingRule);
186 expectedQName = QName.create(UG_NS, UG_REV, "processing-rule");
187 assertEquals(expectedQName, processingRule.getQName());
188 path.offer(expectedQName);
189 expectedPath = SchemaPath.create(path, true);
190 assertEquals(expectedPath, processingRule.getPath());
191 assertEquals(BaseTypes.booleanType(), processingRule.getType());
192 assertTrue(processingRule.isAddedByUses());
193 // * |-- |-- |-- leaf ignore
194 LeafSchemaNode ignore = (LeafSchemaNode) rp.getDataChildByName("ignore");
195 assertNotNull(ignore);
196 expectedQName = QName.create(UG_NS, UG_REV, "ignore");
197 assertEquals(expectedQName, ignore.getQName());
199 path.offer(expectedQName);
200 expectedPath = SchemaPath.create(path, true);
201 assertEquals(expectedPath, ignore.getPath());
202 assertEquals(BaseTypes.booleanType(), ignore.getType());
203 assertTrue(ignore.isAddedByUses());
204 // * |-- |-- |-- leaf priority
205 LeafSchemaNode priority = (LeafSchemaNode) rp.getDataChildByName("priority");
206 assertNotNull(priority);
207 expectedQName = QName.create(UG_NS, UG_REV, "priority");
208 assertEquals(expectedQName, priority.getQName());
210 path.offer(expectedQName);
211 expectedPath = SchemaPath.create(path, true);
212 assertEquals(expectedPath, priority.getPath());
213 expectedQName = QName.create(UG_NS, UG_REV, "uint8");
214 path.offer(expectedQName);
215 expectedPath = SchemaPath.create(path, true);
217 //assertEquals(expectedPath, priority.getType().getPath());
218 assertEquals(BaseTypes.uint8Type(), priority.getType().getBaseType());
219 assertTrue(priority.isAddedByUses());
220 // * |-- |-- |-- container box
221 ContainerSchemaNode box = (ContainerSchemaNode) rp.getDataChildByName("box");
223 expectedQName = QName.create(UG_NS, UG_REV, "box");
224 assertEquals(expectedQName, box.getQName());
227 path.offer(expectedQName);
228 expectedPath = SchemaPath.create(path, true);
229 assertEquals(expectedPath, box.getPath());
230 assertTrue(box.isAddedByUses());
231 // * |-- |-- |-- |-- container order
232 ContainerSchemaNode order = (ContainerSchemaNode) box.getDataChildByName("order");
233 assertNotNull(order);
234 expectedQName = QName.create(UG_NS, UG_REV, "order");
235 assertEquals(expectedQName, order.getQName());
236 path.offer(expectedQName);
237 expectedPath = SchemaPath.create(path, true);
238 assertEquals(expectedPath, order.getPath());
239 assertTrue(order.isAddedByUses());
240 assertTrue(order.isAugmenting());
241 assertEquals(2, order.getChildNodes().size());
242 // * |-- |-- |-- |-- |-- leaf delete
243 LeafSchemaNode delete = (LeafSchemaNode) order.getDataChildByName("delete");
244 assertNotNull(delete);
245 expectedQName = QName.create(UG_NS, UG_REV, "delete");
246 assertEquals(expectedQName, delete.getQName());
247 path.offer(expectedQName);
248 expectedPath = SchemaPath.create(path, true);
249 assertEquals(expectedPath, delete.getPath());
250 assertEquals(BaseTypes.uint32Type(), delete.getType());
251 assertTrue(delete.isAddedByUses());
252 // * |-- |-- |-- |-- |-- leaf setup
253 LeafSchemaNode setup = (LeafSchemaNode) order.getDataChildByName("setup");
254 assertNotNull(setup);
255 expectedQName = QName.create(UG_NS, UG_REV, "setup");
256 assertEquals(expectedQName, setup.getQName());
258 path.offer(expectedQName);
259 expectedPath = SchemaPath.create(path, true);
260 assertEquals(expectedPath, setup.getPath());
261 assertEquals(BaseTypes.uint32Type(), setup.getType());
262 assertTrue(setup.isAddedByUses());
263 // * |-- |-- path-key-expansion
264 ContainerSchemaNode pke = (ContainerSchemaNode) requests.getDataChildByName("path-key-expansion");
266 expectedQName = QName.create(UG_NS, UG_REV, "path-key-expansion");
267 assertEquals(expectedQName, pke.getQName());
272 path.offer(expectedQName);
273 expectedPath = SchemaPath.create(path, true);
274 assertEquals(expectedPath, pke.getPath());
275 assertFalse(pke.isAddedByUses());
276 // * |-- |-- |-- path-key
277 ContainerSchemaNode pathKey = (ContainerSchemaNode) pke.getDataChildByName("path-key");
278 assertNotNull(pathKey);
279 expectedQName = QName.create(UG_NS, UG_REV, "path-key");
280 assertEquals(expectedQName, pathKey.getQName());
281 path.offer(expectedQName);
282 expectedPath= SchemaPath.create(path, true);
283 assertEquals(expectedPath, pathKey.getPath());
284 assertFalse(pathKey.isAddedByUses());
285 assertEquals(3, pathKey.getChildNodes().size());
286 // * |-- |-- |-- |-- leaf processing-rule
287 processingRule = (LeafSchemaNode) pathKey.getDataChildByName("processing-rule");
288 assertNotNull(processingRule);
289 expectedQName = QName.create(UG_NS, UG_REV, "processing-rule");
290 assertEquals(expectedQName, processingRule.getQName());
291 path.offer(expectedQName);
292 expectedPath= SchemaPath.create(path, true);
293 assertEquals(expectedPath, processingRule.getPath());
294 assertEquals(BaseTypes.booleanType(), processingRule.getType());
295 assertTrue(processingRule.isAddedByUses());
296 // * |-- |-- |-- |-- leaf ignore
297 ignore = (LeafSchemaNode) pathKey.getDataChildByName("ignore");
298 assertNotNull(ignore);
299 expectedQName = QName.create(UG_NS, UG_REV, "ignore");
300 assertEquals(expectedQName, ignore.getQName());
302 path.offer(expectedQName);
303 expectedPath= SchemaPath.create(path, true);
304 assertEquals(expectedPath, ignore.getPath());
305 assertEquals(BaseTypes.booleanType(), ignore.getType());
306 assertTrue(ignore.isAddedByUses());
307 // * |-- |-- |-- |-- list path-keys
308 ListSchemaNode pathKeys = (ListSchemaNode) pathKey.getDataChildByName("path-keys");
309 assertNotNull(pathKeys);
310 expectedQName = QName.create(UG_NS, UG_REV, "path-keys");
311 assertEquals(expectedQName, pathKeys.getQName());
313 path.offer(expectedQName);
314 expectedPath= SchemaPath.create(path, true);
315 assertEquals(expectedPath, pathKeys.getPath());
316 assertTrue(pathKeys.isAddedByUses());
317 childNodes = pathKeys.getChildNodes();
318 assertEquals(2, childNodes.size());
319 // * |-- |-- |-- |-- |-- leaf version
320 version = (LeafSchemaNode) pathKeys.getDataChildByName("version");
321 assertNotNull(version);
322 expectedQName = QName.create(UG_NS, UG_REV, "version");
323 assertEquals(expectedQName, version.getQName());
324 path.offer(expectedQName);
325 expectedPath= SchemaPath.create(path, true);
326 assertEquals(expectedPath, version.getPath());
327 assertTrue(version.getType() instanceof UnsignedIntegerTypeDefinition);
328 assertEquals(BaseTypes.uint8Type(), version.getType().getBaseType().getBaseType());
329 assertTrue(version.isAddedByUses());
330 assertTrue(version.isAugmenting());
331 // * |-- |-- |-- |-- |-- leaf type
332 type = (LeafSchemaNode) pathKeys.getDataChildByName("type");
334 expectedQName = QName.create(UG_NS, UG_REV, "type");
335 assertEquals(expectedQName, type.getQName());
337 path.offer(expectedQName);
338 expectedPath= SchemaPath.create(path, true);
339 assertEquals(expectedPath, type.getPath());
340 assertTrue(type.getType() instanceof UnionTypeDefinition);
341 assertTrue(type.isAddedByUses());
342 assertTrue(type.isAugmenting());
343 // * |-- |-- container segment-computation
344 ContainerSchemaNode sc = (ContainerSchemaNode) requests.getDataChildByName("segment-computation");
346 expectedQName = QName.create(UG_NS, UG_REV, "segment-computation");
347 assertEquals(expectedQName, sc.getQName());
352 path.offer(expectedQName);
353 expectedPath= SchemaPath.create(path, true);
354 assertEquals(expectedPath, sc.getPath());
355 assertFalse(sc.isAddedByUses());
356 // * |-- |-- |-- container p2p
357 ContainerSchemaNode p2p = (ContainerSchemaNode) sc.getDataChildByName("p2p");
359 expectedQName = QName.create(UG_NS, UG_REV, "p2p");
360 assertEquals(expectedQName, p2p.getQName());
361 path.offer(expectedQName);
362 expectedPath= SchemaPath.create(path, true);
363 assertEquals(expectedPath, p2p.getPath());
364 assertFalse(p2p.isAddedByUses());
365 // * |-- |-- |-- |-- container endpoints
366 ContainerSchemaNode endpoints = (ContainerSchemaNode) p2p.getDataChildByName("endpoints");
367 assertNotNull(endpoints);
368 expectedQName = QName.create(UG_NS, UG_REV, "endpoints");
369 assertEquals(expectedQName, endpoints.getQName());
370 path.offer(expectedQName);
371 expectedPath= SchemaPath.create(path, true);
372 assertEquals(expectedPath, endpoints.getPath());
373 assertFalse(endpoints.isAddedByUses());
374 // * |-- |-- |-- |-- |-- leaf processing-rule
375 processingRule = (LeafSchemaNode) endpoints.getDataChildByName("processing-rule");
376 assertNotNull(processingRule);
377 expectedQName = QName.create(UG_NS, UG_REV, "processing-rule");
378 assertEquals(expectedQName, processingRule.getQName());
379 path.offer(expectedQName);
380 expectedPath= SchemaPath.create(path, true);
381 assertEquals(expectedPath, processingRule.getPath());
382 assertEquals(BaseTypes.booleanType(), processingRule.getType());
383 assertTrue(processingRule.isAddedByUses());
384 // * |-- |-- |-- |-- |-- leaf ignore
385 ignore = (LeafSchemaNode) endpoints.getDataChildByName("ignore");
386 assertNotNull(ignore);
387 expectedQName = QName.create(UG_NS, UG_REV, "ignore");
388 assertEquals(expectedQName, ignore.getQName());
390 path.offer(expectedQName);
391 expectedPath= SchemaPath.create(path, true);
392 assertEquals(expectedPath, ignore.getPath());
393 assertEquals(BaseTypes.booleanType(), ignore.getType());
394 assertTrue(ignore.isAddedByUses());
395 // * |-- |-- |-- |-- |-- container box
396 box = (ContainerSchemaNode) endpoints.getDataChildByName("box");
398 expectedQName = QName.create(UG_NS, UG_REV, "box");
399 assertEquals(expectedQName, box.getQName());
401 path.offer(expectedQName);
402 expectedPath= SchemaPath.create(path, true);
403 assertEquals(expectedPath, box.getPath());
404 assertTrue(box.isAddedByUses());
405 // * |-- |-- |-- |-- |-- choice address-family
406 ChoiceSchemaNode af = (ChoiceSchemaNode) endpoints.getDataChildByName("address-family");
408 expectedQName = QName.create(UG_NS, UG_REV, "address-family");
409 assertEquals(expectedQName, af.getQName());
411 path.offer(expectedQName);
412 expectedPath= SchemaPath.create(path, true);
413 assertEquals(expectedPath, af.getPath());
414 assertTrue(af.isAddedByUses());
415 // * |-- |-- |-- |-- container reported-route
416 ContainerSchemaNode reportedRoute = (ContainerSchemaNode) p2p.getDataChildByName("reported-route");
417 assertNotNull(reportedRoute);
418 expectedQName = QName.create(UG_NS, UG_REV, "reported-route");
419 assertEquals(expectedQName, reportedRoute.getQName());
422 path.offer(expectedQName);
423 expectedPath= SchemaPath.create(path, true);
424 assertEquals(expectedPath, reportedRoute.getPath());
425 assertFalse(reportedRoute.isAddedByUses());
426 // * |-- |-- |-- |-- |-- leaf processing-rule
427 processingRule = (LeafSchemaNode) reportedRoute.getDataChildByName("processing-rule");
428 assertNotNull(processingRule);
429 expectedQName = QName.create(UG_NS, UG_REV, "processing-rule");
430 assertEquals(expectedQName, processingRule.getQName());
431 path.offer(expectedQName);
432 expectedPath= SchemaPath.create(path, true);
433 assertEquals(expectedPath, processingRule.getPath());
434 assertEquals(BaseTypes.booleanType(), processingRule.getType());
435 assertTrue(processingRule.isAddedByUses());
436 // * |-- |-- |-- |-- |-- leaf ignore
437 ignore = (LeafSchemaNode) reportedRoute.getDataChildByName("ignore");
438 assertNotNull(ignore);
439 expectedQName = QName.create(UG_NS, UG_REV, "ignore");
440 assertEquals(expectedQName, ignore.getQName());
442 path.offer(expectedQName);
443 expectedPath= SchemaPath.create(path, true);
444 assertEquals(expectedPath, ignore.getPath());
445 assertEquals(BaseTypes.booleanType(), ignore.getType());
446 assertTrue(ignore.isAddedByUses());
447 // * |-- |-- |-- |-- |-- list subobjects
448 ListSchemaNode subobjects = (ListSchemaNode) reportedRoute.getDataChildByName("subobjects");
449 assertNotNull(subobjects);
450 expectedQName = QName.create(UG_NS, UG_REV, "subobjects");
451 assertEquals(expectedQName, subobjects.getQName());
453 path.offer(expectedQName);
454 expectedPath= SchemaPath.create(path, true);
455 assertEquals(expectedPath, subobjects.getPath());
456 assertTrue(subobjects.isAddedByUses());
457 // * |-- |-- |-- |-- |-- container bandwidth
458 ContainerSchemaNode bandwidth = (ContainerSchemaNode) reportedRoute.getDataChildByName("bandwidth");
459 assertNotNull(bandwidth);
460 expectedQName = QName.create(UG_NS, UG_REV, "bandwidth");
461 assertEquals(expectedQName, bandwidth.getQName());
463 path.offer(expectedQName);
464 expectedPath= SchemaPath.create(path, true);
465 assertEquals(expectedPath, bandwidth.getPath());
466 assertFalse(bandwidth.isAddedByUses());
467 // * |-- |-- |-- |-- container bandwidth
468 bandwidth = (ContainerSchemaNode) p2p.getDataChildByName("bandwidth");
469 assertNotNull(bandwidth);
470 expectedQName = QName.create(UG_NS, UG_REV, "bandwidth");
471 assertEquals(expectedQName, bandwidth.getQName());
474 path.offer(expectedQName);
475 expectedPath= SchemaPath.create(path, true);
476 assertEquals(expectedPath, bandwidth.getPath());
477 assertTrue(bandwidth.isAddedByUses());
478 // * |-- |-- |-- |-- |-- leaf processing-rule
479 processingRule = (LeafSchemaNode) bandwidth.getDataChildByName("processing-rule");
480 assertNotNull(processingRule);
481 expectedQName = QName.create(UG_NS, UG_REV, "processing-rule");
482 assertEquals(expectedQName, processingRule.getQName());
483 path.offer(expectedQName);
484 expectedPath= SchemaPath.create(path, true);
485 assertEquals(expectedPath, processingRule.getPath());
486 assertEquals(BaseTypes.booleanType(), processingRule.getType());
487 assertTrue(processingRule.isAddedByUses());
488 // * |-- |-- |-- |-- |-- leaf ignore
489 ignore = (LeafSchemaNode) bandwidth.getDataChildByName("ignore");
490 assertNotNull(ignore);
491 expectedQName = QName.create(UG_NS, UG_REV, "ignore");
492 assertEquals(expectedQName, ignore.getQName());
494 path.offer(expectedQName);
495 expectedPath= SchemaPath.create(path, true);
496 assertEquals(expectedPath, ignore.getPath());
497 assertEquals(BaseTypes.booleanType(), ignore.getType());
498 assertTrue(ignore.isAddedByUses());
499 // * |-- |-- |-- |-- |-- container bandwidth
500 ContainerSchemaNode bandwidthInner = (ContainerSchemaNode) bandwidth.getDataChildByName("bandwidth");
501 assertNotNull(bandwidthInner);
502 expectedQName = QName.create(UG_NS, UG_REV, "bandwidth");
503 assertEquals(expectedQName, bandwidth.getQName());
505 path.offer(expectedQName);
506 expectedPath= SchemaPath.create(path, true);
507 assertEquals(expectedPath, bandwidthInner.getPath());
508 assertTrue(bandwidthInner.isAddedByUses());
510 ListSchemaNode svec = (ListSchemaNode) pcreq.getDataChildByName("svec");
512 expectedQName = QName.create(UG_NS, UG_REV, "svec");
513 assertEquals(expectedQName, svec.getQName());
519 path.offer(expectedQName);
520 expectedPath= SchemaPath.create(path, true);
521 assertEquals(expectedPath, svec.getPath());
522 assertFalse(svec.isAddedByUses());
523 // * |-- |-- leaf link-diverse
524 LeafSchemaNode linkDiverse = (LeafSchemaNode) svec.getDataChildByName("link-diverse");
525 assertNotNull(linkDiverse);
526 expectedQName = QName.create(UG_NS, UG_REV, "link-diverse");
527 assertEquals(expectedQName, linkDiverse.getQName());
528 path.offer(expectedQName);
529 expectedPath= SchemaPath.create(path, true);
530 assertEquals(expectedPath, linkDiverse.getPath());
531 assertEquals(BaseTypes.booleanType(), linkDiverse.getType().getBaseType());
532 assertTrue(linkDiverse.isAddedByUses());
533 // * |-- |-- leaf processing-rule
534 processingRule = (LeafSchemaNode) svec.getDataChildByName("processing-rule");
535 assertNotNull(processingRule);
536 expectedQName = QName.create(UG_NS, UG_REV, "processing-rule");
537 assertEquals(expectedQName, processingRule.getQName());
539 path.offer(expectedQName);
540 expectedPath= SchemaPath.create(path, true);
541 assertEquals(expectedPath, processingRule.getPath());
542 assertEquals(BaseTypes.booleanType(), processingRule.getType());
543 assertTrue(processingRule.isAddedByUses());
544 // * |-- |-- leaf ignore
545 ignore = (LeafSchemaNode) svec.getDataChildByName("ignore");
546 assertNotNull(ignore);
547 expectedQName = QName.create(UG_NS, UG_REV, "ignore");
548 assertEquals(expectedQName, ignore.getQName());
550 path.offer(expectedQName);
551 expectedPath= SchemaPath.create(path, true);
552 assertEquals(expectedPath, ignore.getPath());
553 assertEquals(BaseTypes.booleanType(), ignore.getType());
554 assertTrue(ignore.isAddedByUses());
555 // * |-- |-- list metric
556 ListSchemaNode metric = (ListSchemaNode) svec.getDataChildByName("metric");
557 assertNotNull(metric);
558 expectedQName = QName.create(UG_NS, UG_REV, "metric");
559 assertEquals(expectedQName, metric.getQName());
561 path.offer(expectedQName);
562 expectedPath= SchemaPath.create(path, true);
563 assertEquals(expectedPath, metric.getPath());
564 assertFalse(metric.isAddedByUses());
565 // * |-- |-- |-- leaf metric-type
566 LeafSchemaNode metricType = (LeafSchemaNode) metric.getDataChildByName("metric-type");
567 assertNotNull(metricType);
568 expectedQName = QName.create(UG_NS, UG_REV, "metric-type");
569 assertEquals(expectedQName, metricType.getQName());
570 path.offer(expectedQName);
571 expectedPath= SchemaPath.create(path, true);
572 assertEquals(expectedPath, metricType.getPath());
573 assertEquals(BaseTypes.uint8Type(), metricType.getType());
574 assertTrue(metricType.isAddedByUses());
576 box = (ContainerSchemaNode) metric.getDataChildByName("box");
578 expectedQName = QName.create(UG_NS, UG_REV, "box");
579 assertEquals(expectedQName, box.getQName());
581 path.offer(expectedQName);
582 expectedPath= SchemaPath.create(path, true);
583 assertEquals(expectedPath, box.getPath());
584 assertTrue(box.isAddedByUses());
585 // * |-- |-- |-- leaf processing-rule
586 processingRule = (LeafSchemaNode) metric.getDataChildByName("processing-rule");
587 assertNotNull(processingRule);
588 expectedQName = QName.create(UG_NS, UG_REV, "processing-rule");
589 assertEquals(expectedQName, processingRule.getQName());
591 path.offer(expectedQName);
592 expectedPath= SchemaPath.create(path, true);
593 assertEquals(expectedPath, processingRule.getPath());
594 assertEquals(BaseTypes.booleanType(), processingRule.getType());
595 assertTrue(processingRule.isAddedByUses());
596 // * |-- |-- |-- leaf ignore
597 ignore = (LeafSchemaNode) metric.getDataChildByName("ignore");
598 assertNotNull(ignore);
599 expectedQName = QName.create(UG_NS, UG_REV, "ignore");
600 assertEquals(expectedQName, ignore.getQName());
602 path.offer(expectedQName);
603 expectedPath= SchemaPath.create(path, true);
604 assertEquals(expectedPath, ignore.getPath());
605 assertEquals(BaseTypes.booleanType(), ignore.getType());
606 assertTrue(ignore.isAddedByUses());
610 public void testTypedefs() throws URISyntaxException, SourceException, ReactorException {
611 modules = TestUtils.loadModules(getClass().getResource("/grouping-test").toURI());
612 Module testModule = TestUtils.findModule(modules, "grouping-definitions");
613 Set<TypeDefinition<?>> types = testModule.getTypeDefinitions();
615 TypeDefinition<?> intExt = null;
616 for(TypeDefinition<?> td : types) {
617 if("int-ext".equals(td.getQName().getLocalName())) {
621 assertNotNull(intExt);
623 SchemaPath expectedPath = SchemaPath.create(true, QName.create(GD_NS, GD_REV, "int-ext"));
624 assertEquals(expectedPath, intExt.getPath());
626 UnionTypeDefinition union = (UnionTypeDefinition)intExt.getBaseType();
628 TypeDefinition<?> uint8 = null;
629 TypeDefinition<?> pv = null;
630 for(TypeDefinition<?> td : union.getTypes()) {
631 if("uint8".equals(td.getQName().getLocalName())) {
633 } else if("protocol-version".equals(td.getQName().getLocalName())) {
637 assertNotNull(uint8);
640 expectedPath = SchemaPath.create(true, QName.create(GD_NS, GD_REV, "int-ext"), QName.create(GD_NS, GD_REV, "union"));
641 assertEquals(expectedPath, union.getPath());