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;
17 import java.net.URISyntaxException;
18 import java.text.ParseException;
19 import java.text.SimpleDateFormat;
20 import java.util.Collection;
21 import java.util.Collections;
22 import java.util.Date;
23 import java.util.List;
26 import org.junit.Before;
27 import org.junit.Test;
28 import org.opendaylight.yangtools.yang.common.QName;
29 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
30 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
31 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
32 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
33 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
34 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
35 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
36 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
37 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
38 import org.opendaylight.yangtools.yang.model.api.Module;
39 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
40 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
41 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
42 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
43 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
44 import org.opendaylight.yangtools.yang.model.api.UsesNode;
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 Set<Module> modules;
52 public void init() throws URISyntaxException, ReactorException {
53 modules = TestUtils.loadModules(getClass().getResource("/model").toURI());
54 assertEquals(3, modules.size());
58 public void testRefine() {
59 final Module testModule = TestUtils.findModule(modules, "foo");
60 final ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName(QName.create(
61 testModule.getQNameModule(), "peer"));
62 final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
63 testModule.getQNameModule(), "destination"));
65 final Set<UsesNode> usesNodes = destination.getUses();
66 assertEquals(1, usesNodes.size());
67 final UsesNode usesNode = usesNodes.iterator().next();
68 final Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
69 assertEquals(4, refines.size());
71 LeafSchemaNode refineLeaf = null;
72 ContainerSchemaNode refineContainer = null;
73 ListSchemaNode refineList = null;
74 LeafSchemaNode refineInnerLeaf = null;
75 for (final Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
76 final SchemaNode value = entry.getValue();
77 if ("address".equals(value.getQName().getLocalName())) {
78 refineLeaf = (LeafSchemaNode) destination.getDataChildByName(value.getQName());
79 } else if ("port".equals(value.getQName().getLocalName())) {
80 refineContainer = (ContainerSchemaNode) destination.getDataChildByName(value.getQName());
81 } else if ("addresses".equals(value.getQName().getLocalName())) {
82 refineList = (ListSchemaNode) destination.getDataChildByName(value.getQName());
86 assertNotNull(refineList);
87 for (final Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
88 final SchemaNode value = entry.getValue();
89 if ("id".equals(value.getQName().getLocalName())) {
90 refineInnerLeaf = (LeafSchemaNode) refineList.getDataChildByName(value.getQName());
95 assertNotNull(refineLeaf);
96 assertEquals("IP address of target node", refineLeaf.getDescription());
97 assertEquals("address reference added by refine", refineLeaf.getReference());
98 assertFalse(refineLeaf.isConfiguration());
99 assertFalse(refineLeaf.getConstraints().isMandatory());
100 final Set<MustDefinition> leafMustConstraints = refineLeaf.getConstraints().getMustConstraints();
101 assertEquals(1, leafMustConstraints.size());
102 final MustDefinition leafMust = leafMustConstraints.iterator().next();
103 assertEquals("ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)", leafMust.toString());
104 assertEquals(1, refineLeaf.getUnknownSchemaNodes().size());
107 assertNotNull(refineContainer);
108 final Set<MustDefinition> mustConstraints = refineContainer.getConstraints().getMustConstraints();
109 assertTrue(mustConstraints.isEmpty());
110 assertEquals("description of port defined by refine", refineContainer.getDescription());
111 assertEquals("port reference added by refine", refineContainer.getReference());
112 assertFalse(refineContainer.isConfiguration());
113 assertTrue(refineContainer.isPresenceContainer());
116 assertEquals("description of addresses defined by refine", refineList.getDescription());
117 assertEquals("addresses reference added by refine", refineList.getReference());
118 assertFalse(refineList.isConfiguration());
119 assertEquals(2, (int) refineList.getConstraints().getMinElements());
120 assertNull(refineList.getConstraints().getMaxElements());
123 assertNotNull(refineInnerLeaf);
124 assertEquals("id of address", refineInnerLeaf.getDescription());
128 public void testGrouping() {
129 final Module testModule = TestUtils.findModule(modules, "baz");
130 final Set<GroupingDefinition> groupings = testModule.getGroupings();
131 assertEquals(1, groupings.size());
132 final GroupingDefinition grouping = groupings.iterator().next();
133 final Collection<DataSchemaNode> children = grouping.getChildNodes();
134 assertEquals(5, children.size());
138 public void testUses() {
139 // suffix _u = added by uses
140 // suffix _g = defined in grouping
142 final Module baz = TestUtils.findModule(modules, "baz");
145 final Set<GroupingDefinition> groupings = baz.getGroupings();
146 assertEquals(1, groupings.size());
147 final GroupingDefinition grouping = groupings.iterator().next();
149 final Module foo = TestUtils.findModule(modules, "foo");
151 // get node containing uses
152 final ContainerSchemaNode peer = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
153 foo.getQNameModule(), "peer"));
154 final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
155 foo.getQNameModule(), "destination"));
158 final Set<UsesNode> uses = destination.getUses();
159 assertEquals(1, uses.size());
161 // check uses process
162 final AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) destination.getDataChildByName(QName.create(
163 foo.getQNameModule(), "data"));
164 assertNotNull(data_u);
165 assertTrue(data_u.isAddedByUses());
167 final AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName(QName.create(
168 baz.getQNameModule(), "data"));
169 assertNotNull(data_g);
170 assertFalse(data_g.isAddedByUses());
171 assertFalse(data_u.equals(data_g));
172 assertEquals(data_g, SchemaNodeUtils.getRootOriginalIfPossible(data_u));
174 final ChoiceSchemaNode how_u = (ChoiceSchemaNode) destination.getDataChildByName(QName.create(
175 foo.getQNameModule(), "how"));
176 assertNotNull(how_u);
177 TestUtils.checkIsAddedByUses(how_u, true);
178 assertEquals(2, how_u.getCases().size());
180 final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
181 baz.getQNameModule(), "how"));
182 assertNotNull(how_g);
183 TestUtils.checkIsAddedByUses(how_g, false);
184 assertEquals(2, how_g.getCases().size());
185 assertFalse(how_u.equals(how_g));
186 assertEquals(how_g, SchemaNodeUtils.getRootOriginalIfPossible(how_u));
188 final LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName(QName.create(
189 foo.getQNameModule(), "address"));
190 assertNotNull(address_u);
191 assertEquals("1.2.3.4", address_u.getDefault());
192 assertEquals("IP address of target node", address_u.getDescription());
193 assertEquals("address reference added by refine", address_u.getReference());
194 assertFalse(address_u.isConfiguration());
195 assertTrue(address_u.isAddedByUses());
196 assertFalse(address_u.getConstraints().isMandatory());
198 final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
199 baz.getQNameModule(), "address"));
200 assertNotNull(address_g);
201 assertFalse(address_g.isAddedByUses());
202 assertNull(address_g.getDefault());
203 assertEquals("Target IP address", address_g.getDescription());
204 assertNull(address_g.getReference());
205 assertTrue(address_g.isConfiguration());
206 assertFalse(address_u.equals(address_g));
207 assertTrue(address_g.getConstraints().isMandatory());
208 assertEquals(address_g, SchemaNodeUtils.getRootOriginalIfPossible(address_u));
210 final ContainerSchemaNode port_u = (ContainerSchemaNode) destination.getDataChildByName(QName.create(
211 foo.getQNameModule(), "port"));
212 assertNotNull(port_u);
213 TestUtils.checkIsAddedByUses(port_u, true);
215 final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
216 baz.getQNameModule(), "port"));
217 assertNotNull(port_g);
218 TestUtils.checkIsAddedByUses(port_g, false);
219 assertFalse(port_u.equals(port_g));
220 assertEquals(port_g, SchemaNodeUtils.getRootOriginalIfPossible(port_u));
222 final ListSchemaNode addresses_u = (ListSchemaNode) destination.getDataChildByName(QName.create(
223 foo.getQNameModule(), "addresses"));
224 assertNotNull(addresses_u);
225 TestUtils.checkIsAddedByUses(addresses_u, true);
227 final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
228 baz.getQNameModule(), "addresses"));
229 assertNotNull(addresses_g);
230 TestUtils.checkIsAddedByUses(addresses_g, false);
231 assertFalse(addresses_u.equals(addresses_g));
232 assertEquals(addresses_g, SchemaNodeUtils.getRootOriginalIfPossible(addresses_u));
234 // grouping defined by 'uses'
235 final Set<GroupingDefinition> groupings_u = destination.getGroupings();
236 assertEquals(1, groupings_u.size());
237 final GroupingDefinition grouping_u = groupings_u.iterator().next();
238 TestUtils.checkIsAddedByUses(grouping_u, true);
240 // grouping defined in 'grouping' node
241 final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
242 assertEquals(1, groupings_g.size());
243 final GroupingDefinition grouping_g = groupings_g.iterator().next();
244 TestUtils.checkIsAddedByUses(grouping_g, false);
245 assertFalse(grouping_u.equals(grouping_g));
247 final List<UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
248 assertEquals(1, nodes_u.size());
249 final UnknownSchemaNode node_u = nodes_u.get(0);
250 assertTrue(node_u.isAddedByUses());
252 final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
253 assertEquals(1, nodes_g.size());
254 final UnknownSchemaNode node_g = nodes_g.get(0);
255 assertFalse(node_g.isAddedByUses());
256 assertFalse(node_u.equals(node_g));
260 public void testUsesUnderModule() {
261 // suffix _u = added by uses
262 // suffix _g = defined in grouping
264 final Module testModule = TestUtils.findModule(modules, "baz");
267 final Set<GroupingDefinition> groupings = testModule.getGroupings();
268 assertEquals(1, groupings.size());
269 final GroupingDefinition grouping = groupings.iterator().next();
271 // get node containing uses
272 final Module foo = TestUtils.findModule(modules, "foo");
275 final Set<UsesNode> uses = foo.getUses();
276 assertEquals(1, uses.size());
278 // check uses process
279 final AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
281 assertNotNull(data_u);
282 assertTrue(data_u.isAddedByUses());
284 final AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName(QName.create(
285 testModule.getQNameModule(), "data"));
286 assertNotNull(data_g);
287 assertFalse(data_g.isAddedByUses());
288 assertFalse(data_u.equals(data_g));
289 assertEquals(data_g, SchemaNodeUtils.getRootOriginalIfPossible(data_u));
291 final ChoiceSchemaNode how_u = (ChoiceSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
293 assertNotNull(how_u);
294 TestUtils.checkIsAddedByUses(how_u, true);
295 assertFalse(how_u.isAugmenting());
296 final Set<ChoiceCaseNode> cases_u = how_u.getCases();
297 assertEquals(2, cases_u.size());
298 final ChoiceCaseNode interval = how_u.getCaseNodeByName("interval");
299 assertFalse(interval.isAugmenting());
300 final LeafSchemaNode name = (LeafSchemaNode) interval.getDataChildByName(QName.create(foo.getQNameModule(),
302 assertTrue(name.isAugmenting());
303 final LeafSchemaNode intervalLeaf = (LeafSchemaNode) interval.getDataChildByName(QName.create(
304 foo.getQNameModule(), "interval"));
305 assertFalse(intervalLeaf.isAugmenting());
307 final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
308 testModule.getQNameModule(), "how"));
309 assertNotNull(how_g);
310 TestUtils.checkIsAddedByUses(how_g, false);
311 assertFalse(how_u.equals(how_g));
312 assertEquals(how_g, SchemaNodeUtils.getRootOriginalIfPossible(how_u));
314 final LeafSchemaNode address_u = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
316 assertNotNull(address_u);
317 assertNull(address_u.getDefault());
318 assertEquals("Target IP address", address_u.getDescription());
319 assertNull(address_u.getReference());
320 assertTrue(address_u.isConfiguration());
321 assertTrue(address_u.isAddedByUses());
323 final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
324 testModule.getQNameModule(), "address"));
325 assertNotNull(address_g);
326 assertFalse(address_g.isAddedByUses());
327 assertNull(address_g.getDefault());
328 assertEquals("Target IP address", address_g.getDescription());
329 assertNull(address_g.getReference());
330 assertTrue(address_g.isConfiguration());
331 assertFalse(address_u.equals(address_g));
332 assertEquals(address_g, SchemaNodeUtils.getRootOriginalIfPossible(address_u));
334 final ContainerSchemaNode port_u = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
335 foo.getQNameModule(), "port"));
336 assertNotNull(port_u);
337 TestUtils.checkIsAddedByUses(port_u, true);
339 final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
340 testModule.getQNameModule(), "port"));
341 assertNotNull(port_g);
342 TestUtils.checkIsAddedByUses(port_g, false);
343 assertFalse(port_u.equals(port_g));
344 assertEquals(port_g, SchemaNodeUtils.getRootOriginalIfPossible(port_u));
346 final ListSchemaNode addresses_u = (ListSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
348 assertNotNull(addresses_u);
349 TestUtils.checkIsAddedByUses(addresses_u, true);
351 final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
352 testModule.getQNameModule(), "addresses"));
353 assertNotNull(addresses_g);
354 TestUtils.checkIsAddedByUses(addresses_g, false);
355 assertFalse(addresses_u.equals(addresses_g));
356 assertEquals(addresses_g, SchemaNodeUtils.getRootOriginalIfPossible(addresses_u));
358 // grouping defined by 'uses'
359 final Set<GroupingDefinition> groupings_u = foo.getGroupings();
360 assertEquals(1, groupings_u.size());
361 final GroupingDefinition grouping_u = groupings_u.iterator().next();
362 TestUtils.checkIsAddedByUses(grouping_u, true);
364 // grouping defined in 'grouping' node
365 final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
366 assertEquals(1, groupings_g.size());
367 final GroupingDefinition grouping_g = groupings_g.iterator().next();
368 TestUtils.checkIsAddedByUses(grouping_g, false);
369 assertFalse(grouping_u.equals(grouping_g));
371 final List<UnknownSchemaNode> nodes_u = foo.getUnknownSchemaNodes();
372 assertEquals(1, nodes_u.size());
373 final UnknownSchemaNode node_u = nodes_u.get(0);
374 assertTrue(node_u.isAddedByUses());
376 final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
377 assertEquals(1, nodes_g.size());
378 final UnknownSchemaNode node_g = nodes_g.get(0);
379 assertFalse(node_g.isAddedByUses());
380 assertFalse(node_u.equals(node_g));
382 final UsesNode un = uses.iterator().next();
383 final Set<AugmentationSchema> usesAugments = un.getAugmentations();
384 assertEquals(1, usesAugments.size());
385 final AugmentationSchema augment = usesAugments.iterator().next();
386 assertEquals("inner augment", augment.getDescription());
387 final Collection<DataSchemaNode> children = augment.getChildNodes();
388 assertEquals(1, children.size());
389 final DataSchemaNode leaf = children.iterator().next();
390 assertTrue(leaf instanceof LeafSchemaNode);
391 assertEquals("name", leaf.getQName().getLocalName());
395 public void testCascadeUses() throws ReactorException, ParseException {
396 modules = TestUtils.loadModules(Collections.singletonList(getClass().getResourceAsStream(
397 "/grouping-test/cascade-uses.yang")));
398 assertEquals(1, modules.size());
400 final Module testModule = TestUtils.findModule(modules, "cascade-uses");
401 final Set<GroupingDefinition> groupings = testModule.getGroupings();
403 GroupingDefinition gu = null;
404 GroupingDefinition gv = null;
405 GroupingDefinition gx = null;
406 GroupingDefinition gy = null;
407 GroupingDefinition gz = null;
408 GroupingDefinition gzz = null;
409 for (final GroupingDefinition gd : groupings) {
410 final String name = gd.getQName().getLocalName();
439 final URI expectedNS = URI.create("urn:grouping:cascade-uses");
440 final Date expectedRev = new SimpleDateFormat("yyyy-MM-dd").parse("2013-07-18");
441 final String expectedPref = "cu";
442 SchemaPath expectedPath;
445 Collection<DataSchemaNode> childNodes = gu.getChildNodes();
446 assertEquals(7, childNodes.size());
448 final LeafSchemaNode leafGroupingU = (LeafSchemaNode) gu.getDataChildByName(QName.create(
449 testModule.getQNameModule(), "leaf-grouping-U"));
450 assertNotNull(leafGroupingU);
451 assertFalse(leafGroupingU.isAddedByUses());
452 assertFalse(SchemaNodeUtils.getOriginalIfPossible(leafGroupingU).isPresent());
454 for (final DataSchemaNode childNode : childNodes) {
455 if (!(childNode.getQName().equals(leafGroupingU.getQName()))) {
456 TestUtils.checkIsAddedByUses(childNode, true);
461 childNodes = gv.getChildNodes();
462 assertEquals(4, childNodes.size());
463 LeafSchemaNode leafGroupingV = null;
464 ContainerSchemaNode containerGroupingV = null;
465 for (final DataSchemaNode childNode : childNodes) {
466 if ("leaf-grouping-V".equals(childNode.getQName().getLocalName())) {
467 leafGroupingV = (LeafSchemaNode) childNode;
468 } else if ("container-grouping-V".equals(childNode.getQName().getLocalName())) {
469 containerGroupingV = (ContainerSchemaNode) childNode;
471 TestUtils.checkIsAddedByUses(childNode, true);
474 assertNotNull(leafGroupingV);
475 assertFalse(leafGroupingV.isAddedByUses());
477 // grouping-V/container-grouping-V
478 assertNotNull(containerGroupingV);
479 assertFalse(containerGroupingV.isAddedByUses());
480 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-V",
481 "container-grouping-V");
482 assertEquals(expectedPath, containerGroupingV.getPath());
483 childNodes = containerGroupingV.getChildNodes();
484 assertEquals(2, childNodes.size());
485 for (final DataSchemaNode childNode : childNodes) {
486 TestUtils.checkIsAddedByUses(childNode, true);
489 // grouping-V/container-grouping-V/leaf-grouping-X
490 final LeafSchemaNode leafXinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
491 testModule.getQNameModule(), "leaf-grouping-X"));
492 assertNotNull(leafXinContainerV);
493 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-V",
494 "container-grouping-V", "leaf-grouping-X");
495 assertEquals(expectedPath, leafXinContainerV.getPath());
496 // grouping-V/container-grouping-V/leaf-grouping-Y
497 final LeafSchemaNode leafYinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
498 testModule.getQNameModule(), "leaf-grouping-Y"));
499 assertNotNull(leafYinContainerV);
500 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-V",
501 "container-grouping-V", "leaf-grouping-Y");
502 assertEquals(expectedPath, leafYinContainerV.getPath());
505 childNodes = gx.getChildNodes();
506 assertEquals(2, childNodes.size());
508 // grouping-X/leaf-grouping-X
509 final LeafSchemaNode leafXinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
510 testModule.getQNameModule(), "leaf-grouping-X"));
511 assertNotNull(leafXinGX);
512 assertFalse(leafXinGX.isAddedByUses());
513 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-X",
515 assertEquals(expectedPath, leafXinGX.getPath());
517 // grouping-X/leaf-grouping-Y
518 final LeafSchemaNode leafYinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
519 testModule.getQNameModule(), "leaf-grouping-Y"));
520 assertNotNull(leafYinGX);
521 assertTrue(leafYinGX.isAddedByUses());
522 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-X",
524 assertEquals(expectedPath, leafYinGX.getPath());
527 childNodes = gy.getChildNodes();
528 assertEquals(1, childNodes.size());
530 // grouping-Y/leaf-grouping-Y
531 final LeafSchemaNode leafYinGY = (LeafSchemaNode) gy.getDataChildByName(QName.create(
532 testModule.getQNameModule(), "leaf-grouping-Y"));
533 assertNotNull(leafYinGY);
534 assertFalse(leafYinGY.isAddedByUses());
535 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-Y",
537 assertEquals(expectedPath, leafYinGY.getPath());
540 childNodes = gz.getChildNodes();
541 assertEquals(1, childNodes.size());
543 // grouping-Z/leaf-grouping-Z
544 final LeafSchemaNode leafZinGZ = (LeafSchemaNode) gz.getDataChildByName(QName.create(
545 testModule.getQNameModule(), "leaf-grouping-Z"));
546 assertNotNull(leafZinGZ);
547 assertFalse(leafZinGZ.isAddedByUses());
548 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-Z",
550 assertEquals(expectedPath, leafZinGZ.getPath());
553 childNodes = gzz.getChildNodes();
554 assertEquals(1, childNodes.size());
556 // grouping-ZZ/leaf-grouping-ZZ
557 final LeafSchemaNode leafZZinGZZ = (LeafSchemaNode) gzz.getDataChildByName(QName.create(
558 testModule.getQNameModule(), "leaf-grouping-ZZ"));
559 assertNotNull(leafZZinGZZ);
560 assertFalse(leafZZinGZZ.isAddedByUses());
561 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-ZZ",
563 assertEquals(expectedPath, leafZZinGZZ.getPath());
565 // TEST getOriginal from grouping-U
567 gv.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-V")),
568 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
569 testModule.getQNameModule(), "leaf-grouping-V"))));
570 containerGroupingV = (ContainerSchemaNode) gu.getDataChildByName(QName.create(testModule.getQNameModule(),
571 "container-grouping-V"));
572 assertEquals(gv.getDataChildByName(QName.create(testModule.getQNameModule(), "container-grouping-V")),
573 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV));
575 gx.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-X")),
576 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
577 testModule.getQNameModule(), "leaf-grouping-X"))));
579 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
580 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
581 testModule.getQNameModule(), "leaf-grouping-Y"))));
584 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
585 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
586 testModule.getQNameModule(), "leaf-grouping-Z"))));
588 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
589 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
590 testModule.getQNameModule(), "leaf-grouping-ZZ"))));
592 // TEST getOriginal from grouping-V
594 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
595 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
596 testModule.getQNameModule(), "leaf-grouping-Z"))));
598 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
599 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
600 testModule.getQNameModule(), "leaf-grouping-ZZ"))));
602 // TEST getOriginal from grouping-X
604 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
605 SchemaNodeUtils.getRootOriginalIfPossible(gx.getDataChildByName(QName.create(
606 testModule.getQNameModule(), "leaf-grouping-Y"))));
610 public void testAddedByUsesLeafTypeQName() throws URISyntaxException, ReactorException {
612 final Set<Module> loadModules = TestUtils.loadModules(getClass().getResource("/added-by-uses-leaf-test")
615 assertEquals(2, loadModules.size());
619 for (final Module module : loadModules) {
620 if (module.getName().equals("foo")) {
623 if (module.getName().equals("import-module")) {
631 final LeafSchemaNode leaf = (LeafSchemaNode) ((ContainerSchemaNode) foo.getDataChildByName(QName.create(
632 foo.getQNameModule(), "my-container")))
633 .getDataChildByName(QName.create(foo.getQNameModule(), "my-leaf"));
635 TypeDefinition<?> impType = null;
636 final Set<TypeDefinition<?>> typeDefinitions = imp.getTypeDefinitions();
637 for (final TypeDefinition<?> typeDefinition : typeDefinitions) {
638 if (typeDefinition.getQName().getLocalName().equals("imp-type")) {
639 impType = typeDefinition;
644 assertNotNull(impType);
645 assertEquals(leaf.getType().getQName(), impType.getQName());