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.assertNull;
14 import static org.junit.Assert.assertTrue;
16 import java.io.IOException;
18 import java.text.ParseException;
19 import java.util.Collection;
20 import java.util.List;
23 import org.junit.Before;
24 import org.junit.Test;
25 import org.opendaylight.yangtools.yang.common.QName;
26 import org.opendaylight.yangtools.yang.common.QNameModule;
27 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
28 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
29 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
30 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
31 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
32 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
33 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
34 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
35 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
36 import org.opendaylight.yangtools.yang.model.api.Module;
37 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
38 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
39 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
40 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
41 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
42 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.UsesNode;
44 import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
45 import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
46 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
48 public class GroupingTest {
49 private SchemaContext ctx;
54 public void init() throws Exception {
55 ctx = TestUtils.loadModules(getClass().getResource("/model").toURI());
56 foo = TestUtils.findModule(ctx, "foo").get();
57 baz = TestUtils.findModule(ctx, "baz").get();
58 assertEquals(3, ctx.getModules().size());
62 public void testRefine() {
63 final Module testModule = TestUtils.findModule(ctx, "foo").get();
64 final ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName(QName.create(
65 testModule.getQNameModule(), "peer"));
66 final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
67 testModule.getQNameModule(), "destination"));
69 final Set<UsesNode> usesNodes = destination.getUses();
70 assertEquals(1, usesNodes.size());
71 final UsesNode usesNode = usesNodes.iterator().next();
72 final Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
73 assertEquals(4, refines.size());
75 LeafSchemaNode refineLeaf = null;
76 ContainerSchemaNode refineContainer = null;
77 ListSchemaNode refineList = null;
78 LeafSchemaNode refineInnerLeaf = null;
79 for (final Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
80 final SchemaNode value = entry.getValue();
81 if ("address".equals(value.getQName().getLocalName())) {
82 refineLeaf = (LeafSchemaNode) destination.getDataChildByName(value.getQName());
83 } else if ("port".equals(value.getQName().getLocalName())) {
84 refineContainer = (ContainerSchemaNode) destination.getDataChildByName(value.getQName());
85 } else if ("addresses".equals(value.getQName().getLocalName())) {
86 refineList = (ListSchemaNode) destination.getDataChildByName(value.getQName());
90 assertNotNull(refineList);
91 for (final Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
92 final SchemaNode value = entry.getValue();
93 if ("id".equals(value.getQName().getLocalName())) {
94 refineInnerLeaf = (LeafSchemaNode) refineList.getDataChildByName(value.getQName());
99 assertNotNull(refineLeaf);
100 assertEquals("IP address of target node", refineLeaf.getDescription());
101 assertEquals("address reference added by refine", refineLeaf.getReference());
102 assertFalse(refineLeaf.isConfiguration());
103 assertFalse(refineLeaf.getConstraints().isMandatory());
104 final Set<MustDefinition> leafMustConstraints = refineLeaf.getConstraints().getMustConstraints();
105 assertEquals(1, leafMustConstraints.size());
106 final MustDefinition leafMust = leafMustConstraints.iterator().next();
107 assertEquals("ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)", leafMust.toString());
108 assertEquals(1, refineLeaf.getUnknownSchemaNodes().size());
111 assertNotNull(refineContainer);
112 final Set<MustDefinition> mustConstraints = refineContainer.getConstraints().getMustConstraints();
113 assertTrue(mustConstraints.isEmpty());
114 assertEquals("description of port defined by refine", refineContainer.getDescription());
115 assertEquals("port reference added by refine", refineContainer.getReference());
116 assertFalse(refineContainer.isConfiguration());
117 assertTrue(refineContainer.isPresenceContainer());
120 assertEquals("description of addresses defined by refine", refineList.getDescription());
121 assertEquals("addresses reference added by refine", refineList.getReference());
122 assertFalse(refineList.isConfiguration());
123 assertEquals(2, (int) refineList.getConstraints().getMinElements());
124 assertNull(refineList.getConstraints().getMaxElements());
127 assertNotNull(refineInnerLeaf);
128 assertEquals("id of address", refineInnerLeaf.getDescription());
132 public void testGrouping() {
133 final Module testModule = TestUtils.findModule(ctx, "baz").get();
134 final Set<GroupingDefinition> groupings = testModule.getGroupings();
135 assertEquals(1, groupings.size());
136 final GroupingDefinition grouping = groupings.iterator().next();
137 final Collection<DataSchemaNode> children = grouping.getChildNodes();
138 assertEquals(5, children.size());
142 public void testUses() {
143 // suffix _u = added by uses
144 // suffix _g = defined in grouping
148 final Set<GroupingDefinition> groupings = baz.getGroupings();
149 assertEquals(1, groupings.size());
150 final GroupingDefinition grouping = groupings.iterator().next();
152 // get node containing uses
153 final ContainerSchemaNode peer = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
154 foo.getQNameModule(), "peer"));
155 final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
156 foo.getQNameModule(), "destination"));
159 final Set<UsesNode> uses = destination.getUses();
160 assertEquals(1, uses.size());
162 // check uses process
163 final AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) destination.getDataChildByName(QName.create(
164 foo.getQNameModule(), "data"));
165 assertNotNull(data_u);
166 assertTrue(data_u.isAddedByUses());
168 final AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName(QName.create(
169 baz.getQNameModule(), "data"));
170 assertNotNull(data_g);
171 assertFalse(data_g.isAddedByUses());
172 assertFalse(data_u.equals(data_g));
173 assertEquals(data_g, SchemaNodeUtils.getRootOriginalIfPossible(data_u));
175 final ChoiceSchemaNode how_u = (ChoiceSchemaNode) destination.getDataChildByName(QName.create(
176 foo.getQNameModule(), "how"));
177 assertNotNull(how_u);
178 TestUtils.checkIsAddedByUses(how_u, true);
179 assertEquals(2, how_u.getCases().size());
181 final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
182 baz.getQNameModule(), "how"));
183 assertNotNull(how_g);
184 TestUtils.checkIsAddedByUses(how_g, false);
185 assertEquals(2, how_g.getCases().size());
186 assertFalse(how_u.equals(how_g));
187 assertEquals(how_g, SchemaNodeUtils.getRootOriginalIfPossible(how_u));
189 final LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName(QName.create(
190 foo.getQNameModule(), "address"));
191 assertNotNull(address_u);
192 assertEquals("1.2.3.4", address_u.getDefault());
193 assertEquals("IP address of target node", address_u.getDescription());
194 assertEquals("address reference added by refine", address_u.getReference());
195 assertFalse(address_u.isConfiguration());
196 assertTrue(address_u.isAddedByUses());
197 assertFalse(address_u.getConstraints().isMandatory());
199 final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
200 baz.getQNameModule(), "address"));
201 assertNotNull(address_g);
202 assertFalse(address_g.isAddedByUses());
203 assertNull(address_g.getDefault());
204 assertEquals("Target IP address", address_g.getDescription());
205 assertNull(address_g.getReference());
206 assertTrue(address_g.isConfiguration());
207 assertFalse(address_u.equals(address_g));
208 assertTrue(address_g.getConstraints().isMandatory());
209 assertEquals(address_g, SchemaNodeUtils.getRootOriginalIfPossible(address_u));
211 final ContainerSchemaNode port_u = (ContainerSchemaNode) destination.getDataChildByName(QName.create(
212 foo.getQNameModule(), "port"));
213 assertNotNull(port_u);
214 TestUtils.checkIsAddedByUses(port_u, true);
216 final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
217 baz.getQNameModule(), "port"));
218 assertNotNull(port_g);
219 TestUtils.checkIsAddedByUses(port_g, false);
220 assertFalse(port_u.equals(port_g));
221 assertEquals(port_g, SchemaNodeUtils.getRootOriginalIfPossible(port_u));
223 final ListSchemaNode addresses_u = (ListSchemaNode) destination.getDataChildByName(QName.create(
224 foo.getQNameModule(), "addresses"));
225 assertNotNull(addresses_u);
226 TestUtils.checkIsAddedByUses(addresses_u, true);
228 final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
229 baz.getQNameModule(), "addresses"));
230 assertNotNull(addresses_g);
231 TestUtils.checkIsAddedByUses(addresses_g, false);
232 assertFalse(addresses_u.equals(addresses_g));
233 assertEquals(addresses_g, SchemaNodeUtils.getRootOriginalIfPossible(addresses_u));
235 // grouping defined by 'uses'
236 final Set<GroupingDefinition> groupings_u = destination.getGroupings();
237 assertEquals(1, groupings_u.size());
238 final GroupingDefinition grouping_u = groupings_u.iterator().next();
239 TestUtils.checkIsAddedByUses(grouping_u, true);
241 // grouping defined in 'grouping' node
242 final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
243 assertEquals(1, groupings_g.size());
244 final GroupingDefinition grouping_g = groupings_g.iterator().next();
245 TestUtils.checkIsAddedByUses(grouping_g, false);
246 assertFalse(grouping_u.equals(grouping_g));
248 final List<UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
249 assertEquals(1, nodes_u.size());
250 final UnknownSchemaNode node_u = nodes_u.get(0);
251 assertTrue(node_u.isAddedByUses());
253 final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
254 assertEquals(1, nodes_g.size());
255 final UnknownSchemaNode node_g = nodes_g.get(0);
256 assertFalse(node_g.isAddedByUses());
257 assertFalse(node_u.equals(node_g));
261 public void testUsesUnderModule() {
262 // suffix _u = added by uses
263 // suffix _g = defined in grouping
266 final Set<GroupingDefinition> groupings = baz.getGroupings();
267 assertEquals(1, groupings.size());
268 final GroupingDefinition grouping = groupings.iterator().next();
271 final Set<UsesNode> uses = foo.getUses();
272 assertEquals(1, uses.size());
274 // check uses process
275 final AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
277 assertNotNull(data_u);
278 assertTrue(data_u.isAddedByUses());
280 final AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName(QName.create(
281 baz.getQNameModule(), "data"));
282 assertNotNull(data_g);
283 assertFalse(data_g.isAddedByUses());
284 assertFalse(data_u.equals(data_g));
285 assertEquals(data_g, SchemaNodeUtils.getRootOriginalIfPossible(data_u));
287 final ChoiceSchemaNode how_u = (ChoiceSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
289 assertNotNull(how_u);
290 TestUtils.checkIsAddedByUses(how_u, true);
291 assertFalse(how_u.isAugmenting());
292 final Set<ChoiceCaseNode> cases_u = how_u.getCases();
293 assertEquals(2, cases_u.size());
294 final ChoiceCaseNode interval = how_u.getCaseNodeByName("interval");
295 assertFalse(interval.isAugmenting());
296 final LeafSchemaNode name = (LeafSchemaNode) interval.getDataChildByName(QName.create(foo.getQNameModule(),
298 assertTrue(name.isAugmenting());
299 final LeafSchemaNode intervalLeaf = (LeafSchemaNode) interval.getDataChildByName(QName.create(
300 foo.getQNameModule(), "interval"));
301 assertFalse(intervalLeaf.isAugmenting());
303 final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
304 baz.getQNameModule(), "how"));
305 assertNotNull(how_g);
306 TestUtils.checkIsAddedByUses(how_g, false);
307 assertFalse(how_u.equals(how_g));
308 assertEquals(how_g, SchemaNodeUtils.getRootOriginalIfPossible(how_u));
310 final LeafSchemaNode address_u = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
312 assertNotNull(address_u);
313 assertNull(address_u.getDefault());
314 assertEquals("Target IP address", address_u.getDescription());
315 assertNull(address_u.getReference());
316 assertTrue(address_u.isConfiguration());
317 assertTrue(address_u.isAddedByUses());
319 final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
320 baz.getQNameModule(), "address"));
321 assertNotNull(address_g);
322 assertFalse(address_g.isAddedByUses());
323 assertNull(address_g.getDefault());
324 assertEquals("Target IP address", address_g.getDescription());
325 assertNull(address_g.getReference());
326 assertTrue(address_g.isConfiguration());
327 assertFalse(address_u.equals(address_g));
328 assertEquals(address_g, SchemaNodeUtils.getRootOriginalIfPossible(address_u));
330 final ContainerSchemaNode port_u = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
331 foo.getQNameModule(), "port"));
332 assertNotNull(port_u);
333 TestUtils.checkIsAddedByUses(port_u, true);
335 final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
336 baz.getQNameModule(), "port"));
337 assertNotNull(port_g);
338 TestUtils.checkIsAddedByUses(port_g, false);
339 assertFalse(port_u.equals(port_g));
340 assertEquals(port_g, SchemaNodeUtils.getRootOriginalIfPossible(port_u));
342 final ListSchemaNode addresses_u = (ListSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
344 assertNotNull(addresses_u);
345 TestUtils.checkIsAddedByUses(addresses_u, true);
347 final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
348 baz.getQNameModule(), "addresses"));
349 assertNotNull(addresses_g);
350 TestUtils.checkIsAddedByUses(addresses_g, false);
351 assertFalse(addresses_u.equals(addresses_g));
352 assertEquals(addresses_g, SchemaNodeUtils.getRootOriginalIfPossible(addresses_u));
354 // grouping defined by 'uses'
355 final Set<GroupingDefinition> groupings_u = foo.getGroupings();
356 assertEquals(1, groupings_u.size());
357 final GroupingDefinition grouping_u = groupings_u.iterator().next();
358 TestUtils.checkIsAddedByUses(grouping_u, true);
360 // grouping defined in 'grouping' node
361 final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
362 assertEquals(1, groupings_g.size());
363 final GroupingDefinition grouping_g = groupings_g.iterator().next();
364 TestUtils.checkIsAddedByUses(grouping_g, false);
365 assertFalse(grouping_u.equals(grouping_g));
367 final List<UnknownSchemaNode> nodes_u = foo.getUnknownSchemaNodes();
368 assertEquals(1, nodes_u.size());
369 final UnknownSchemaNode node_u = nodes_u.get(0);
370 assertTrue(node_u.isAddedByUses());
372 final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
373 assertEquals(1, nodes_g.size());
374 final UnknownSchemaNode node_g = nodes_g.get(0);
375 assertFalse(node_g.isAddedByUses());
376 assertFalse(node_u.equals(node_g));
378 final UsesNode un = uses.iterator().next();
379 final Set<AugmentationSchema> usesAugments = un.getAugmentations();
380 assertEquals(1, usesAugments.size());
381 final AugmentationSchema augment = usesAugments.iterator().next();
382 assertEquals("inner augment", augment.getDescription());
383 final Collection<DataSchemaNode> children = augment.getChildNodes();
384 assertEquals(1, children.size());
385 final DataSchemaNode leaf = children.iterator().next();
386 assertTrue(leaf instanceof LeafSchemaNode);
387 assertEquals("name", leaf.getQName().getLocalName());
391 public void testCascadeUses() throws ReactorException, ParseException, IOException, YangSyntaxErrorException {
392 ctx = TestUtils.loadModuleResources(getClass(), "/grouping-test/cascade-uses.yang");
393 assertEquals(1, ctx.getModules().size());
395 final Module testModule = TestUtils.findModule(ctx, "cascade-uses").get();
396 final Set<GroupingDefinition> groupings = testModule.getGroupings();
398 GroupingDefinition gu = null;
399 GroupingDefinition gv = null;
400 GroupingDefinition gx = null;
401 GroupingDefinition gy = null;
402 GroupingDefinition gz = null;
403 GroupingDefinition gzz = null;
404 for (final GroupingDefinition gd : groupings) {
405 final String name = gd.getQName().getLocalName();
434 final QNameModule expectedModule = QNameModule.create(
435 URI.create("urn:grouping:cascade-uses"), QName.parseRevision("2013-07-18"));
436 SchemaPath expectedPath;
439 Collection<DataSchemaNode> childNodes = gu.getChildNodes();
440 assertEquals(7, childNodes.size());
442 final LeafSchemaNode leafGroupingU = (LeafSchemaNode) gu.getDataChildByName(QName.create(
443 testModule.getQNameModule(), "leaf-grouping-U"));
444 assertNotNull(leafGroupingU);
445 assertFalse(leafGroupingU.isAddedByUses());
446 assertFalse(SchemaNodeUtils.getOriginalIfPossible(leafGroupingU).isPresent());
448 for (final DataSchemaNode childNode : childNodes) {
449 if (!childNode.getQName().equals(leafGroupingU.getQName())) {
450 TestUtils.checkIsAddedByUses(childNode, true);
455 childNodes = gv.getChildNodes();
456 assertEquals(4, childNodes.size());
457 LeafSchemaNode leafGroupingV = null;
458 ContainerSchemaNode containerGroupingV = null;
459 for (final DataSchemaNode childNode : childNodes) {
460 if ("leaf-grouping-V".equals(childNode.getQName().getLocalName())) {
461 leafGroupingV = (LeafSchemaNode) childNode;
462 } else if ("container-grouping-V".equals(childNode.getQName().getLocalName())) {
463 containerGroupingV = (ContainerSchemaNode) childNode;
465 TestUtils.checkIsAddedByUses(childNode, true);
468 assertNotNull(leafGroupingV);
469 assertFalse(leafGroupingV.isAddedByUses());
471 // grouping-V/container-grouping-V
472 assertNotNull(containerGroupingV);
473 assertFalse(containerGroupingV.isAddedByUses());
474 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V");
475 assertEquals(expectedPath, containerGroupingV.getPath());
476 childNodes = containerGroupingV.getChildNodes();
477 assertEquals(2, childNodes.size());
478 for (final DataSchemaNode childNode : childNodes) {
479 TestUtils.checkIsAddedByUses(childNode, true);
482 // grouping-V/container-grouping-V/leaf-grouping-X
483 final LeafSchemaNode leafXinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
484 testModule.getQNameModule(), "leaf-grouping-X"));
485 assertNotNull(leafXinContainerV);
486 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V",
488 assertEquals(expectedPath, leafXinContainerV.getPath());
489 // grouping-V/container-grouping-V/leaf-grouping-Y
490 final LeafSchemaNode leafYinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
491 testModule.getQNameModule(), "leaf-grouping-Y"));
492 assertNotNull(leafYinContainerV);
493 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V",
495 assertEquals(expectedPath, leafYinContainerV.getPath());
498 childNodes = gx.getChildNodes();
499 assertEquals(2, childNodes.size());
501 // grouping-X/leaf-grouping-X
502 final LeafSchemaNode leafXinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
503 testModule.getQNameModule(), "leaf-grouping-X"));
504 assertNotNull(leafXinGX);
505 assertFalse(leafXinGX.isAddedByUses());
506 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-X", "leaf-grouping-X");
507 assertEquals(expectedPath, leafXinGX.getPath());
509 // grouping-X/leaf-grouping-Y
510 final LeafSchemaNode leafYinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
511 testModule.getQNameModule(), "leaf-grouping-Y"));
512 assertNotNull(leafYinGX);
513 assertTrue(leafYinGX.isAddedByUses());
514 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-X", "leaf-grouping-Y");
515 assertEquals(expectedPath, leafYinGX.getPath());
518 childNodes = gy.getChildNodes();
519 assertEquals(1, childNodes.size());
521 // grouping-Y/leaf-grouping-Y
522 final LeafSchemaNode leafYinGY = (LeafSchemaNode) gy.getDataChildByName(QName.create(
523 testModule.getQNameModule(), "leaf-grouping-Y"));
524 assertNotNull(leafYinGY);
525 assertFalse(leafYinGY.isAddedByUses());
526 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-Y", "leaf-grouping-Y");
527 assertEquals(expectedPath, leafYinGY.getPath());
530 childNodes = gz.getChildNodes();
531 assertEquals(1, childNodes.size());
533 // grouping-Z/leaf-grouping-Z
534 final LeafSchemaNode leafZinGZ = (LeafSchemaNode) gz.getDataChildByName(QName.create(
535 testModule.getQNameModule(), "leaf-grouping-Z"));
536 assertNotNull(leafZinGZ);
537 assertFalse(leafZinGZ.isAddedByUses());
538 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-Z", "leaf-grouping-Z");
539 assertEquals(expectedPath, leafZinGZ.getPath());
542 childNodes = gzz.getChildNodes();
543 assertEquals(1, childNodes.size());
545 // grouping-ZZ/leaf-grouping-ZZ
546 final LeafSchemaNode leafZZinGZZ = (LeafSchemaNode) gzz.getDataChildByName(QName.create(
547 testModule.getQNameModule(), "leaf-grouping-ZZ"));
548 assertNotNull(leafZZinGZZ);
549 assertFalse(leafZZinGZZ.isAddedByUses());
550 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-ZZ", "leaf-grouping-ZZ");
551 assertEquals(expectedPath, leafZZinGZZ.getPath());
553 // TEST getOriginal from grouping-U
555 gv.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-V")),
556 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
557 testModule.getQNameModule(), "leaf-grouping-V"))));
558 containerGroupingV = (ContainerSchemaNode) gu.getDataChildByName(QName.create(testModule.getQNameModule(),
559 "container-grouping-V"));
560 assertEquals(gv.getDataChildByName(QName.create(testModule.getQNameModule(), "container-grouping-V")),
561 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV));
563 gx.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-X")),
564 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
565 testModule.getQNameModule(), "leaf-grouping-X"))));
567 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
568 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
569 testModule.getQNameModule(), "leaf-grouping-Y"))));
572 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
573 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
574 testModule.getQNameModule(), "leaf-grouping-Z"))));
576 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
577 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
578 testModule.getQNameModule(), "leaf-grouping-ZZ"))));
580 // TEST getOriginal from grouping-V
582 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
583 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
584 testModule.getQNameModule(), "leaf-grouping-Z"))));
586 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
587 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
588 testModule.getQNameModule(), "leaf-grouping-ZZ"))));
590 // TEST getOriginal from grouping-X
592 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
593 SchemaNodeUtils.getRootOriginalIfPossible(gx.getDataChildByName(QName.create(
594 testModule.getQNameModule(), "leaf-grouping-Y"))));
598 public void testAddedByUsesLeafTypeQName() throws Exception {
599 final SchemaContext loadModules = TestUtils.loadModules(getClass().getResource("/added-by-uses-leaf-test")
601 assertEquals(2, loadModules.getModules().size());
602 foo = TestUtils.findModule(loadModules, "foo").get();
603 final Module imp = TestUtils.findModule(loadModules, "import-module").get();
605 final LeafSchemaNode leaf = (LeafSchemaNode) ((ContainerSchemaNode) foo.getDataChildByName(QName.create(
606 foo.getQNameModule(), "my-container")))
607 .getDataChildByName(QName.create(foo.getQNameModule(), "my-leaf"));
609 TypeDefinition<?> impType = null;
610 final Set<TypeDefinition<?>> typeDefinitions = imp.getTypeDefinitions();
611 for (final TypeDefinition<?> typeDefinition : typeDefinitions) {
612 if (typeDefinition.getQName().getLocalName().equals("imp-type")) {
613 impType = typeDefinition;
618 assertNotNull(impType);
619 assertEquals(leaf.getType().getQName(), impType.getQName());