2 * Copyright (c) 2016 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;
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 static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
16 import java.io.IOException;
17 import java.net.URISyntaxException;
18 import java.util.ArrayDeque;
19 import java.util.Collection;
20 import java.util.Deque;
21 import org.junit.Before;
22 import org.junit.Test;
23 import org.opendaylight.yangtools.yang.common.QName;
24 import org.opendaylight.yangtools.yang.common.QNameModule;
25 import org.opendaylight.yangtools.yang.common.Revision;
26 import org.opendaylight.yangtools.yang.common.XMLNamespace;
27 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
28 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
29 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
30 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
31 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
32 import org.opendaylight.yangtools.yang.model.api.Module;
33 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
34 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
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.Uint8TypeDefinition;
38 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
39 import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
40 import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
41 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
43 public class UsesAugmentTest {
45 private static final QNameModule UG = QNameModule.create(
46 XMLNamespace.of("urn:opendaylight:params:xml:ns:yang:uses-grouping"), Revision.of("2013-07-30"));
47 private static final QNameModule GD = QNameModule.create(
48 XMLNamespace.of("urn:opendaylight:params:xml:ns:yang:grouping-definitions"), Revision.of("2013-09-04"));
50 private SchemaContext context;
53 public void init() throws ReactorException, IOException, YangSyntaxErrorException, URISyntaxException {
54 context = TestUtils.loadModules(getClass().getResource("/grouping-test").toURI());
58 * Structure of testing model:
61 * |-- leaf version (U)
64 * |-- |-- container rp
65 * |-- |-- |-- leaf priority (U)
66 * |-- |-- |-- container box (U)
67 * |-- |-- |-- |-- container order (A)
68 * |-- |-- |-- |-- |-- leaf delete (U)
69 * |-- |-- |-- |-- |-- |-- leaf setup (U)
70 * |-- |-- |-- leaf processing-rule (U)
71 * |-- |-- |-- leaf ignore (U)
72 * |-- |-- path-key-expansion
73 * |-- |-- |-- container path-key
74 * |-- |-- |-- |-- list path-keys (U)
75 * |-- |-- |-- |-- |-- leaf version (U)
76 * |-- |-- |-- |-- |-- leaf type (U)
77 * |-- |-- |-- |-- |-- leaf processing-rule (U)
78 * |-- |-- |-- |-- |-- leaf ignore (U)
79 * |-- |-- container segment-computation
80 * |-- |-- |-- container p2p
81 * |-- |-- |-- |-- container endpoints
82 * |-- |-- |-- |-- |-- leaf processing-rule (U)
83 * |-- |-- |-- |-- |-- leaf ignore (U)
84 * |-- |-- |-- |-- |-- container box (U)
85 * |-- |-- |-- |-- |-- choice address-family (U)
86 * |-- |-- |-- |-- |-- |-- case ipv4
87 * |-- |-- |-- |-- |-- |-- |-- leaf source-ipv4-address
88 * |-- |-- |-- |-- |-- |-- case ipv6
89 * |-- |-- |-- |-- |-- |-- |-- leaf source-ipv6-address
90 * |-- |-- |-- |-- container reported-route
91 * |-- |-- |-- |-- |-- container bandwidth
92 * |-- |-- |-- |-- |-- list subobjects(U)
93 * |-- |-- |-- |-- |-- leaf processing-rule (U)
94 * |-- |-- |-- |-- |-- leaf ignore (U)
95 * |-- |-- |-- |-- container bandwidth (U)
96 * |-- |-- |-- |-- |-- container bandwidth (U)
97 * |-- |-- |-- |-- |-- leaf processing-rule (U)
98 * |-- |-- |-- |-- |-- leaf ignore (U)
100 * |-- |-- list metric
101 * |-- |-- |-- leaf metric-type (U)
102 * |-- |-- |-- container box (U)
103 * |-- |-- |-- leaf processing-rule (U)
104 * |-- |-- |-- leaf ignore (U)
105 * |-- |-- leaf link-diverse (U)
106 * |-- |-- leaf processing-rule (U)
107 * |-- |-- leaf ignore (U)
109 * U = added by uses A = added by augment
111 * @throws Exception if exception occurs
114 public void testAugmentInUses() throws Exception {
115 final Module testModule = TestUtils.findModule(context, "uses-grouping").get();
117 final Deque<QName> path = new ArrayDeque<>();
119 // * notification pcreq
120 final Collection<? extends NotificationDefinition> notifications = testModule.getNotifications();
121 assertEquals(1, notifications.size());
122 final NotificationDefinition pcreq = notifications.iterator().next();
123 assertNotNull(pcreq);
124 QName expectedQName = QName.create(UG, "pcreq");
125 path.offer(expectedQName);
126 SchemaPath expectedPath = SchemaPath.create(path, true);
127 assertPathEquals(expectedPath, pcreq);
128 Collection<? extends DataSchemaNode> childNodes = pcreq.getChildNodes();
129 assertEquals(4, childNodes.size());
130 // * |-- leaf version
131 LeafSchemaNode version = (LeafSchemaNode) pcreq.getDataChildByName(QName.create(testModule.getQNameModule(),
133 assertNotNull(version);
134 expectedQName = QName.create(UG, "version");
135 path.offer(expectedQName);
136 expectedPath = SchemaPath.create(path, true);
137 assertPathEquals(expectedPath, version);
138 expectedQName = QName.create(UG, "version");
139 path.offer(expectedQName);
140 assertEquals(expectedQName, version.getType().getQName());
141 assertEquals(BaseTypes.uint8Type(), version.getType().getBaseType().getBaseType());
142 assertTrue(version.isAddedByUses());
144 LeafSchemaNode type = (LeafSchemaNode) pcreq.getDataChildByName(QName.create(testModule.getQNameModule(),
147 expectedQName = QName.create(UG, "type");
148 assertTrue(type.isAddedByUses());
151 path.offer(expectedQName);
152 expectedPath = SchemaPath.create(path, true);
153 assertPathEquals(expectedPath, type);
154 expectedQName = QName.create(GD, "int-ext");
155 path.offer(expectedQName);
156 assertEquals(expectedQName, type.getType().getQName());
157 final UnionTypeDefinition union = (UnionTypeDefinition) type.getType().getBaseType();
158 assertEquals(QName.create(expectedQName, "union"), union.getQName());
159 assertEquals(2, union.getTypes().size());
160 // * |-- list requests
161 final ListSchemaNode requests = (ListSchemaNode) pcreq.getDataChildByName(QName.create(
162 testModule.getQNameModule(), "requests"));
163 assertNotNull(requests);
164 expectedQName = QName.create(UG, "requests");
165 assertEquals(expectedQName, requests.getQName());
168 path.offer(expectedQName);
169 expectedPath = SchemaPath.create(path, true);
170 assertPathEquals(expectedPath, requests);
171 assertFalse(requests.isAddedByUses());
172 childNodes = requests.getChildNodes();
173 assertEquals(3, childNodes.size());
174 // * |-- |-- container rp
175 final ContainerSchemaNode rp = (ContainerSchemaNode) requests.getDataChildByName(QName.create(
176 testModule.getQNameModule(), "rp"));
178 expectedQName = QName.create(UG, "rp");
179 path.offer(expectedQName);
180 expectedPath = SchemaPath.create(path, true);
181 assertPathEquals(expectedPath, rp);
182 assertFalse(rp.isAddedByUses());
183 childNodes = rp.getChildNodes();
184 assertEquals(4, childNodes.size());
185 // * |-- |-- |-- leaf processing-rule
186 LeafSchemaNode processingRule = (LeafSchemaNode) rp.getDataChildByName(QName.create(
187 testModule.getQNameModule(), "processing-rule"));
188 assertNotNull(processingRule);
189 expectedQName = QName.create(UG, "processing-rule");
190 assertEquals(expectedQName, processingRule.getQName());
191 path.offer(expectedQName);
192 expectedPath = SchemaPath.create(path, true);
193 assertPathEquals(expectedPath, processingRule);
194 assertEquals(BaseTypes.booleanType(), processingRule.getType());
195 assertTrue(processingRule.isAddedByUses());
196 // * |-- |-- |-- leaf ignore
197 LeafSchemaNode ignore = (LeafSchemaNode) rp.getDataChildByName(QName.create(testModule.getQNameModule(),
199 assertNotNull(ignore);
200 expectedQName = QName.create(UG, "ignore");
201 assertEquals(expectedQName, ignore.getQName());
203 path.offer(expectedQName);
204 expectedPath = SchemaPath.create(path, true);
205 assertPathEquals(expectedPath, ignore);
206 assertEquals(BaseTypes.booleanType(), ignore.getType());
207 assertTrue(ignore.isAddedByUses());
208 // * |-- |-- |-- leaf priority
209 final LeafSchemaNode priority = (LeafSchemaNode) rp.getDataChildByName(QName.create(
210 testModule.getQNameModule(), "priority"));
211 assertNotNull(priority);
212 expectedQName = QName.create(UG, "priority");
213 assertEquals(expectedQName, priority.getQName());
215 path.offer(expectedQName);
216 expectedPath = SchemaPath.create(path, true);
217 assertPathEquals(expectedPath, priority);
218 expectedQName = QName.create(UG, "uint8");
219 path.offer(expectedQName);
220 expectedPath = SchemaPath.create(path, true);
222 // assertEquals(expectedPath, priority.getType().getPath());
223 assertEquals(BaseTypes.uint8Type(), priority.getType().getBaseType());
224 assertTrue(priority.isAddedByUses());
225 // * |-- |-- |-- container box
226 ContainerSchemaNode box = (ContainerSchemaNode) rp.getDataChildByName(QName.create(testModule.getQNameModule(),
229 expectedQName = QName.create(UG, "box");
230 assertEquals(expectedQName, box.getQName());
233 path.offer(expectedQName);
234 expectedPath = SchemaPath.create(path, true);
235 assertPathEquals(expectedPath, box);
236 assertTrue(box.isAddedByUses());
237 // * |-- |-- |-- |-- container order
238 final ContainerSchemaNode order = (ContainerSchemaNode) box.getDataChildByName(QName.create(
239 testModule.getQNameModule(), "order"));
240 assertNotNull(order);
241 expectedQName = QName.create(UG, "order");
242 assertEquals(expectedQName, order.getQName());
243 path.offer(expectedQName);
244 expectedPath = SchemaPath.create(path, true);
245 assertPathEquals(expectedPath, order);
246 assertTrue(order.isAddedByUses());
247 assertTrue(order.isAugmenting());
248 assertEquals(2, order.getChildNodes().size());
249 // * |-- |-- |-- |-- |-- leaf delete
250 final LeafSchemaNode delete = (LeafSchemaNode) order.getDataChildByName(QName.create(
251 testModule.getQNameModule(), "delete"));
252 assertNotNull(delete);
253 expectedQName = QName.create(UG, "delete");
254 assertEquals(expectedQName, delete.getQName());
255 path.offer(expectedQName);
256 expectedPath = SchemaPath.create(path, true);
257 assertPathEquals(expectedPath, delete);
258 assertEquals(BaseTypes.uint32Type(), delete.getType());
259 assertTrue(delete.isAddedByUses());
260 // * |-- |-- |-- |-- |-- leaf setup
261 final LeafSchemaNode setup = (LeafSchemaNode) order.getDataChildByName(QName.create(
262 testModule.getQNameModule(), "setup"));
263 assertNotNull(setup);
264 expectedQName = QName.create(UG, "setup");
265 assertEquals(expectedQName, setup.getQName());
267 path.offer(expectedQName);
268 expectedPath = SchemaPath.create(path, true);
269 assertPathEquals(expectedPath, setup);
270 assertEquals(BaseTypes.uint32Type(), setup.getType());
271 assertTrue(setup.isAddedByUses());
272 // * |-- |-- path-key-expansion
273 final ContainerSchemaNode pke = (ContainerSchemaNode) requests.getDataChildByName(QName.create(
274 testModule.getQNameModule(), "path-key-expansion"));
276 expectedQName = QName.create(UG, "path-key-expansion");
277 assertEquals(expectedQName, pke.getQName());
282 path.offer(expectedQName);
283 expectedPath = SchemaPath.create(path, true);
284 assertPathEquals(expectedPath, pke);
285 assertFalse(pke.isAddedByUses());
286 // * |-- |-- |-- path-key
287 final ContainerSchemaNode pathKey = (ContainerSchemaNode) pke.getDataChildByName(QName.create(
288 testModule.getQNameModule(), "path-key"));
289 assertNotNull(pathKey);
290 expectedQName = QName.create(UG, "path-key");
291 assertEquals(expectedQName, pathKey.getQName());
292 path.offer(expectedQName);
293 expectedPath = SchemaPath.create(path, true);
294 assertPathEquals(expectedPath, pathKey);
295 assertFalse(pathKey.isAddedByUses());
296 assertEquals(3, pathKey.getChildNodes().size());
297 // * |-- |-- |-- |-- leaf processing-rule
298 processingRule = (LeafSchemaNode) pathKey.getDataChildByName(QName.create(testModule.getQNameModule(),
300 assertNotNull(processingRule);
301 expectedQName = QName.create(UG, "processing-rule");
302 assertEquals(expectedQName, processingRule.getQName());
303 path.offer(expectedQName);
304 expectedPath = SchemaPath.create(path, true);
305 assertPathEquals(expectedPath, processingRule);
306 assertEquals(BaseTypes.booleanType(), processingRule.getType());
307 assertTrue(processingRule.isAddedByUses());
308 // * |-- |-- |-- |-- leaf ignore
309 ignore = (LeafSchemaNode) pathKey.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
310 assertNotNull(ignore);
311 expectedQName = QName.create(UG, "ignore");
312 assertEquals(expectedQName, ignore.getQName());
314 path.offer(expectedQName);
315 expectedPath = SchemaPath.create(path, true);
316 assertPathEquals(expectedPath, ignore);
317 assertEquals(BaseTypes.booleanType(), ignore.getType());
318 assertTrue(ignore.isAddedByUses());
319 // * |-- |-- |-- |-- list path-keys
320 final ListSchemaNode pathKeys = (ListSchemaNode) pathKey.getDataChildByName(QName.create(
321 testModule.getQNameModule(), "path-keys"));
322 assertNotNull(pathKeys);
323 expectedQName = QName.create(UG, "path-keys");
324 assertEquals(expectedQName, pathKeys.getQName());
326 path.offer(expectedQName);
327 expectedPath = SchemaPath.create(path, true);
328 assertPathEquals(expectedPath, pathKeys);
329 assertTrue(pathKeys.isAddedByUses());
330 childNodes = pathKeys.getChildNodes();
331 assertEquals(2, childNodes.size());
332 // * |-- |-- |-- |-- |-- leaf version
333 version = (LeafSchemaNode) pathKeys.getDataChildByName(QName.create(testModule.getQNameModule(), "version"));
334 assertNotNull(version);
335 expectedQName = QName.create(UG, "version");
336 assertEquals(expectedQName, version.getQName());
337 path.offer(expectedQName);
338 expectedPath = SchemaPath.create(path, true);
339 assertPathEquals(expectedPath, version);
340 assertTrue(version.getType() instanceof Uint8TypeDefinition);
341 assertEquals(BaseTypes.uint8Type(), version.getType().getBaseType().getBaseType());
342 assertTrue(version.isAddedByUses());
343 assertTrue(version.isAugmenting());
344 // * |-- |-- |-- |-- |-- leaf type
345 type = (LeafSchemaNode) pathKeys.getDataChildByName(QName.create(testModule.getQNameModule(), "type"));
347 expectedQName = QName.create(UG, "type");
348 assertEquals(expectedQName, type.getQName());
350 path.offer(expectedQName);
351 expectedPath = SchemaPath.create(path, true);
352 assertPathEquals(expectedPath, type);
353 assertTrue(type.getType() instanceof UnionTypeDefinition);
354 assertTrue(type.isAddedByUses());
355 assertTrue(type.isAugmenting());
356 // * |-- |-- container segment-computation
357 final ContainerSchemaNode sc = (ContainerSchemaNode) requests.getDataChildByName(QName.create(
358 testModule.getQNameModule(), "segment-computation"));
360 expectedQName = QName.create(UG, "segment-computation");
361 assertEquals(expectedQName, sc.getQName());
366 path.offer(expectedQName);
367 expectedPath = SchemaPath.create(path, true);
368 assertPathEquals(expectedPath, sc);
369 assertFalse(sc.isAddedByUses());
370 // * |-- |-- |-- container p2p
371 final ContainerSchemaNode p2p = (ContainerSchemaNode) sc.getDataChildByName(QName.create(
372 testModule.getQNameModule(), "p2p"));
374 expectedQName = QName.create(UG, "p2p");
375 assertEquals(expectedQName, p2p.getQName());
376 path.offer(expectedQName);
377 expectedPath = SchemaPath.create(path, true);
378 assertPathEquals(expectedPath, p2p);
379 assertFalse(p2p.isAddedByUses());
380 // * |-- |-- |-- |-- container endpoints
381 final ContainerSchemaNode endpoints = (ContainerSchemaNode) p2p.getDataChildByName(QName.create(
382 testModule.getQNameModule(), "endpoints"));
383 assertNotNull(endpoints);
384 expectedQName = QName.create(UG, "endpoints");
385 assertEquals(expectedQName, endpoints.getQName());
386 path.offer(expectedQName);
387 expectedPath = SchemaPath.create(path, true);
388 assertPathEquals(expectedPath, endpoints);
389 assertFalse(endpoints.isAddedByUses());
390 // * |-- |-- |-- |-- |-- leaf processing-rule
391 processingRule = (LeafSchemaNode) endpoints.getDataChildByName(QName.create(testModule.getQNameModule(),
393 assertNotNull(processingRule);
394 expectedQName = QName.create(UG, "processing-rule");
395 assertEquals(expectedQName, processingRule.getQName());
396 path.offer(expectedQName);
397 expectedPath = SchemaPath.create(path, true);
398 assertPathEquals(expectedPath, processingRule);
399 assertEquals(BaseTypes.booleanType(), processingRule.getType());
400 assertTrue(processingRule.isAddedByUses());
401 // * |-- |-- |-- |-- |-- leaf ignore
402 ignore = (LeafSchemaNode) endpoints.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
403 assertNotNull(ignore);
404 expectedQName = QName.create(UG, "ignore");
405 assertEquals(expectedQName, ignore.getQName());
407 path.offer(expectedQName);
408 expectedPath = SchemaPath.create(path, true);
409 assertPathEquals(expectedPath, ignore);
410 assertEquals(BaseTypes.booleanType(), ignore.getType());
411 assertTrue(ignore.isAddedByUses());
412 // * |-- |-- |-- |-- |-- container box
413 box = (ContainerSchemaNode) endpoints.getDataChildByName(QName.create(testModule.getQNameModule(), "box"));
415 expectedQName = QName.create(UG, "box");
416 assertEquals(expectedQName, box.getQName());
418 path.offer(expectedQName);
419 expectedPath = SchemaPath.create(path, true);
420 assertPathEquals(expectedPath, box);
421 assertTrue(box.isAddedByUses());
422 // * |-- |-- |-- |-- |-- choice address-family
423 final ChoiceSchemaNode af = (ChoiceSchemaNode) endpoints.getDataChildByName(QName.create(
424 testModule.getQNameModule(), "address-family"));
426 expectedQName = QName.create(UG, "address-family");
427 assertEquals(expectedQName, af.getQName());
429 path.offer(expectedQName);
430 expectedPath = SchemaPath.create(path, true);
431 assertPathEquals(expectedPath, af);
432 assertTrue(af.isAddedByUses());
433 // * |-- |-- |-- |-- container reported-route
434 final ContainerSchemaNode reportedRoute = (ContainerSchemaNode) p2p.getDataChildByName(QName.create(
435 testModule.getQNameModule(), "reported-route"));
436 assertNotNull(reportedRoute);
437 expectedQName = QName.create(UG, "reported-route");
438 assertEquals(expectedQName, reportedRoute.getQName());
441 path.offer(expectedQName);
442 expectedPath = SchemaPath.create(path, true);
443 assertPathEquals(expectedPath, reportedRoute);
444 assertFalse(reportedRoute.isAddedByUses());
445 // * |-- |-- |-- |-- |-- leaf processing-rule
446 processingRule = (LeafSchemaNode) reportedRoute.getDataChildByName(QName.create(testModule.getQNameModule(),
448 assertNotNull(processingRule);
449 expectedQName = QName.create(UG, "processing-rule");
450 assertEquals(expectedQName, processingRule.getQName());
451 path.offer(expectedQName);
452 expectedPath = SchemaPath.create(path, true);
453 assertPathEquals(expectedPath, processingRule);
454 assertEquals(BaseTypes.booleanType(), processingRule.getType());
455 assertTrue(processingRule.isAddedByUses());
456 // * |-- |-- |-- |-- |-- leaf ignore
457 ignore = (LeafSchemaNode) reportedRoute.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
458 assertNotNull(ignore);
459 expectedQName = QName.create(UG, "ignore");
460 assertEquals(expectedQName, ignore.getQName());
462 path.offer(expectedQName);
463 expectedPath = SchemaPath.create(path, true);
464 assertPathEquals(expectedPath, ignore);
465 assertEquals(BaseTypes.booleanType(), ignore.getType());
466 assertTrue(ignore.isAddedByUses());
467 // * |-- |-- |-- |-- |-- list subobjects
468 final ListSchemaNode subobjects = (ListSchemaNode) reportedRoute.getDataChildByName(QName.create(
469 testModule.getQNameModule(), "subobjects"));
470 assertNotNull(subobjects);
471 expectedQName = QName.create(UG, "subobjects");
472 assertEquals(expectedQName, subobjects.getQName());
474 path.offer(expectedQName);
475 expectedPath = SchemaPath.create(path, true);
476 assertPathEquals(expectedPath, subobjects);
477 assertTrue(subobjects.isAddedByUses());
478 // * |-- |-- |-- |-- |-- container bandwidth
479 ContainerSchemaNode bandwidth = (ContainerSchemaNode) reportedRoute.getDataChildByName(QName.create(
480 testModule.getQNameModule(), "bandwidth"));
481 assertNotNull(bandwidth);
482 expectedQName = QName.create(UG, "bandwidth");
483 assertEquals(expectedQName, bandwidth.getQName());
485 path.offer(expectedQName);
486 expectedPath = SchemaPath.create(path, true);
487 assertPathEquals(expectedPath, bandwidth);
488 assertFalse(bandwidth.isAddedByUses());
489 // * |-- |-- |-- |-- container bandwidth
490 bandwidth = (ContainerSchemaNode) p2p
491 .getDataChildByName(QName.create(testModule.getQNameModule(), "bandwidth"));
492 assertNotNull(bandwidth);
493 expectedQName = QName.create(UG, "bandwidth");
494 assertEquals(expectedQName, bandwidth.getQName());
497 path.offer(expectedQName);
498 expectedPath = SchemaPath.create(path, true);
499 assertPathEquals(expectedPath, bandwidth);
500 assertTrue(bandwidth.isAddedByUses());
501 // * |-- |-- |-- |-- |-- leaf processing-rule
502 processingRule = (LeafSchemaNode) bandwidth.getDataChildByName(QName.create(testModule.getQNameModule(),
504 assertNotNull(processingRule);
505 expectedQName = QName.create(UG, "processing-rule");
506 assertEquals(expectedQName, processingRule.getQName());
507 path.offer(expectedQName);
508 expectedPath = SchemaPath.create(path, true);
509 assertPathEquals(expectedPath, processingRule);
510 assertEquals(BaseTypes.booleanType(), processingRule.getType());
511 assertTrue(processingRule.isAddedByUses());
512 // * |-- |-- |-- |-- |-- leaf ignore
513 ignore = (LeafSchemaNode) bandwidth.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
514 assertNotNull(ignore);
515 expectedQName = QName.create(UG, "ignore");
516 assertEquals(expectedQName, ignore.getQName());
518 path.offer(expectedQName);
519 expectedPath = SchemaPath.create(path, true);
520 assertPathEquals(expectedPath, ignore);
521 assertEquals(BaseTypes.booleanType(), ignore.getType());
522 assertTrue(ignore.isAddedByUses());
523 // * |-- |-- |-- |-- |-- container bandwidth
524 final ContainerSchemaNode bandwidthInner = (ContainerSchemaNode) bandwidth.getDataChildByName(QName.create(
525 testModule.getQNameModule(), "bandwidth"));
526 assertNotNull(bandwidthInner);
527 expectedQName = QName.create(UG, "bandwidth");
528 assertEquals(expectedQName, bandwidth.getQName());
530 path.offer(expectedQName);
531 expectedPath = SchemaPath.create(path, true);
532 assertPathEquals(expectedPath, bandwidthInner);
533 assertTrue(bandwidthInner.isAddedByUses());
535 final ListSchemaNode svec = (ListSchemaNode) pcreq.getDataChildByName(QName.create(testModule.getQNameModule(),
538 expectedQName = QName.create(UG, "svec");
539 assertEquals(expectedQName, svec.getQName());
545 path.offer(expectedQName);
546 expectedPath = SchemaPath.create(path, true);
547 assertPathEquals(expectedPath, svec);
548 assertFalse(svec.isAddedByUses());
549 // * |-- |-- leaf link-diverse
550 final LeafSchemaNode linkDiverse = (LeafSchemaNode) svec.getDataChildByName(QName.create(
551 testModule.getQNameModule(), "link-diverse"));
552 assertNotNull(linkDiverse);
553 expectedQName = QName.create(UG, "link-diverse");
554 assertEquals(expectedQName, linkDiverse.getQName());
555 path.offer(expectedQName);
556 expectedPath = SchemaPath.create(path, true);
557 assertPathEquals(expectedPath, linkDiverse);
558 assertEquals(BaseTypes.booleanType(), linkDiverse.getType().getBaseType());
559 assertTrue(linkDiverse.isAddedByUses());
560 // * |-- |-- leaf processing-rule
561 processingRule = (LeafSchemaNode) svec.getDataChildByName(QName.create(testModule.getQNameModule(),
563 assertNotNull(processingRule);
564 expectedQName = QName.create(UG, "processing-rule");
565 assertEquals(expectedQName, processingRule.getQName());
567 path.offer(expectedQName);
568 expectedPath = SchemaPath.create(path, true);
569 assertPathEquals(expectedPath, processingRule);
570 assertEquals(BaseTypes.booleanType(), processingRule.getType());
571 assertTrue(processingRule.isAddedByUses());
572 // * |-- |-- leaf ignore
573 ignore = (LeafSchemaNode) svec.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
574 assertNotNull(ignore);
575 expectedQName = QName.create(UG, "ignore");
576 assertEquals(expectedQName, ignore.getQName());
578 path.offer(expectedQName);
579 expectedPath = SchemaPath.create(path, true);
580 assertPathEquals(expectedPath, ignore);
581 assertEquals(BaseTypes.booleanType(), ignore.getType());
582 assertTrue(ignore.isAddedByUses());
583 // * |-- |-- list metric
584 final ListSchemaNode metric = (ListSchemaNode) svec.getDataChildByName(QName.create(
585 testModule.getQNameModule(), "metric"));
586 assertNotNull(metric);
587 expectedQName = QName.create(UG, "metric");
588 assertEquals(expectedQName, metric.getQName());
590 path.offer(expectedQName);
591 expectedPath = SchemaPath.create(path, true);
592 assertPathEquals(expectedPath, metric);
593 assertFalse(metric.isAddedByUses());
594 // * |-- |-- |-- leaf metric-type
595 final LeafSchemaNode metricType = (LeafSchemaNode) metric.getDataChildByName(QName.create(
596 testModule.getQNameModule(), "metric-type"));
597 assertNotNull(metricType);
598 expectedQName = QName.create(UG, "metric-type");
599 assertEquals(expectedQName, metricType.getQName());
600 path.offer(expectedQName);
601 expectedPath = SchemaPath.create(path, true);
602 assertPathEquals(expectedPath, metricType);
603 assertEquals(BaseTypes.uint8Type(), metricType.getType());
604 assertTrue(metricType.isAddedByUses());
606 box = (ContainerSchemaNode) metric.getDataChildByName(QName.create(testModule.getQNameModule(), "box"));
608 expectedQName = QName.create(UG, "box");
609 assertEquals(expectedQName, box.getQName());
611 path.offer(expectedQName);
612 expectedPath = SchemaPath.create(path, true);
613 assertPathEquals(expectedPath, box);
614 assertTrue(box.isAddedByUses());
615 // * |-- |-- |-- leaf processing-rule
616 processingRule = (LeafSchemaNode) metric.getDataChildByName(QName.create(testModule.getQNameModule(),
618 assertNotNull(processingRule);
619 expectedQName = QName.create(UG, "processing-rule");
620 assertEquals(expectedQName, processingRule.getQName());
622 path.offer(expectedQName);
623 expectedPath = SchemaPath.create(path, true);
624 assertPathEquals(expectedPath, processingRule);
625 assertEquals(BaseTypes.booleanType(), processingRule.getType());
626 assertTrue(processingRule.isAddedByUses());
627 // * |-- |-- |-- leaf ignore
628 ignore = (LeafSchemaNode) metric.getDataChildByName(QName.create(testModule.getQNameModule(), "ignore"));
629 assertNotNull(ignore);
630 expectedQName = QName.create(UG, "ignore");
631 assertEquals(expectedQName, ignore.getQName());
633 path.offer(expectedQName);
634 expectedPath = SchemaPath.create(path, true);
635 assertPathEquals(expectedPath, ignore);
636 assertEquals(BaseTypes.booleanType(), ignore.getType());
637 assertTrue(ignore.isAddedByUses());
641 public void testTypedefs() throws Exception {
642 final Module testModule = TestUtils.findModule(context, "grouping-definitions").get();
643 final Collection<? extends TypeDefinition<?>> types = testModule.getTypeDefinitions();
645 TypeDefinition<?> intExt = null;
646 for (final TypeDefinition<?> td : types) {
647 if ("int-ext".equals(td.getQName().getLocalName())) {
651 assertNotNull(intExt);
653 assertEquals(QName.create(GD, "int-ext"), intExt.getQName());
655 final UnionTypeDefinition union = (UnionTypeDefinition) intExt.getBaseType();
657 TypeDefinition<?> uint8 = null;
658 TypeDefinition<?> pv = null;
659 for (final TypeDefinition<?> td : union.getTypes()) {
660 if ("uint8".equals(td.getQName().getLocalName())) {
662 } else if ("protocol-version".equals(td.getQName().getLocalName())) {
666 assertNotNull(uint8);
668 assertEquals(QName.create(GD, "union"), union.getQName());