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.text.ParseException;
18 import java.util.Collection;
19 import java.util.Collections;
20 import java.util.Date;
21 import java.util.List;
24 import org.junit.Before;
25 import org.junit.Test;
26 import org.opendaylight.yangtools.yang.common.QName;
27 import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
28 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
29 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
30 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
31 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
32 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
33 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
34 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
35 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
36 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
37 import org.opendaylight.yangtools.yang.model.api.Module;
38 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
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.util.SchemaNodeUtils;
45 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
47 public class GroupingTest {
48 private Set<Module> modules;
51 public void init() throws Exception {
52 modules = TestUtils.loadModules(getClass().getResource("/model").toURI());
53 assertEquals(3, modules.size());
57 public void testRefine() {
58 final Module testModule = TestUtils.findModule(modules, "foo");
59 final ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName(QName.create(
60 testModule.getQNameModule(), "peer"));
61 final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
62 testModule.getQNameModule(), "destination"));
64 final Set<UsesNode> usesNodes = destination.getUses();
65 assertEquals(1, usesNodes.size());
66 final UsesNode usesNode = usesNodes.iterator().next();
67 final Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
68 assertEquals(4, refines.size());
70 LeafSchemaNode refineLeaf = null;
71 ContainerSchemaNode refineContainer = null;
72 ListSchemaNode refineList = null;
73 LeafSchemaNode refineInnerLeaf = null;
74 for (final Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
75 final SchemaNode value = entry.getValue();
76 if ("address".equals(value.getQName().getLocalName())) {
77 refineLeaf = (LeafSchemaNode) destination.getDataChildByName(value.getQName());
78 } else if ("port".equals(value.getQName().getLocalName())) {
79 refineContainer = (ContainerSchemaNode) destination.getDataChildByName(value.getQName());
80 } else if ("addresses".equals(value.getQName().getLocalName())) {
81 refineList = (ListSchemaNode) destination.getDataChildByName(value.getQName());
85 assertNotNull(refineList);
86 for (final Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
87 final SchemaNode value = entry.getValue();
88 if ("id".equals(value.getQName().getLocalName())) {
89 refineInnerLeaf = (LeafSchemaNode) refineList.getDataChildByName(value.getQName());
94 assertNotNull(refineLeaf);
95 assertEquals("IP address of target node", refineLeaf.getDescription());
96 assertEquals("address reference added by refine", refineLeaf.getReference());
97 assertFalse(refineLeaf.isConfiguration());
98 assertFalse(refineLeaf.getConstraints().isMandatory());
99 final Set<MustDefinition> leafMustConstraints = refineLeaf.getConstraints().getMustConstraints();
100 assertEquals(1, leafMustConstraints.size());
101 final MustDefinition leafMust = leafMustConstraints.iterator().next();
102 assertEquals("ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)", leafMust.toString());
103 assertEquals(1, refineLeaf.getUnknownSchemaNodes().size());
106 assertNotNull(refineContainer);
107 final Set<MustDefinition> mustConstraints = refineContainer.getConstraints().getMustConstraints();
108 assertTrue(mustConstraints.isEmpty());
109 assertEquals("description of port defined by refine", refineContainer.getDescription());
110 assertEquals("port reference added by refine", refineContainer.getReference());
111 assertFalse(refineContainer.isConfiguration());
112 assertTrue(refineContainer.isPresenceContainer());
115 assertEquals("description of addresses defined by refine", refineList.getDescription());
116 assertEquals("addresses reference added by refine", refineList.getReference());
117 assertFalse(refineList.isConfiguration());
118 assertEquals(2, (int) refineList.getConstraints().getMinElements());
119 assertNull(refineList.getConstraints().getMaxElements());
122 assertNotNull(refineInnerLeaf);
123 assertEquals("id of address", refineInnerLeaf.getDescription());
127 public void testGrouping() {
128 final Module testModule = TestUtils.findModule(modules, "baz");
129 final Set<GroupingDefinition> groupings = testModule.getGroupings();
130 assertEquals(1, groupings.size());
131 final GroupingDefinition grouping = groupings.iterator().next();
132 final Collection<DataSchemaNode> children = grouping.getChildNodes();
133 assertEquals(5, children.size());
137 public void testUses() {
138 // suffix _u = added by uses
139 // suffix _g = defined in grouping
141 final Module baz = TestUtils.findModule(modules, "baz");
144 final Set<GroupingDefinition> groupings = baz.getGroupings();
145 assertEquals(1, groupings.size());
146 final GroupingDefinition grouping = groupings.iterator().next();
148 final Module foo = TestUtils.findModule(modules, "foo");
150 // get node containing uses
151 final ContainerSchemaNode peer = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
152 foo.getQNameModule(), "peer"));
153 final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
154 foo.getQNameModule(), "destination"));
157 final Set<UsesNode> uses = destination.getUses();
158 assertEquals(1, uses.size());
160 // check uses process
161 final AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) destination.getDataChildByName(QName.create(
162 foo.getQNameModule(), "data"));
163 assertNotNull(data_u);
164 assertTrue(data_u.isAddedByUses());
166 final AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName(QName.create(
167 baz.getQNameModule(), "data"));
168 assertNotNull(data_g);
169 assertFalse(data_g.isAddedByUses());
170 assertFalse(data_u.equals(data_g));
171 assertEquals(data_g, SchemaNodeUtils.getRootOriginalIfPossible(data_u));
173 final ChoiceSchemaNode how_u = (ChoiceSchemaNode) destination.getDataChildByName(QName.create(
174 foo.getQNameModule(), "how"));
175 assertNotNull(how_u);
176 TestUtils.checkIsAddedByUses(how_u, true);
177 assertEquals(2, how_u.getCases().size());
179 final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
180 baz.getQNameModule(), "how"));
181 assertNotNull(how_g);
182 TestUtils.checkIsAddedByUses(how_g, false);
183 assertEquals(2, how_g.getCases().size());
184 assertFalse(how_u.equals(how_g));
185 assertEquals(how_g, SchemaNodeUtils.getRootOriginalIfPossible(how_u));
187 final LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName(QName.create(
188 foo.getQNameModule(), "address"));
189 assertNotNull(address_u);
190 assertEquals("1.2.3.4", address_u.getDefault());
191 assertEquals("IP address of target node", address_u.getDescription());
192 assertEquals("address reference added by refine", address_u.getReference());
193 assertFalse(address_u.isConfiguration());
194 assertTrue(address_u.isAddedByUses());
195 assertFalse(address_u.getConstraints().isMandatory());
197 final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
198 baz.getQNameModule(), "address"));
199 assertNotNull(address_g);
200 assertFalse(address_g.isAddedByUses());
201 assertNull(address_g.getDefault());
202 assertEquals("Target IP address", address_g.getDescription());
203 assertNull(address_g.getReference());
204 assertTrue(address_g.isConfiguration());
205 assertFalse(address_u.equals(address_g));
206 assertTrue(address_g.getConstraints().isMandatory());
207 assertEquals(address_g, SchemaNodeUtils.getRootOriginalIfPossible(address_u));
209 final ContainerSchemaNode port_u = (ContainerSchemaNode) destination.getDataChildByName(QName.create(
210 foo.getQNameModule(), "port"));
211 assertNotNull(port_u);
212 TestUtils.checkIsAddedByUses(port_u, true);
214 final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
215 baz.getQNameModule(), "port"));
216 assertNotNull(port_g);
217 TestUtils.checkIsAddedByUses(port_g, false);
218 assertFalse(port_u.equals(port_g));
219 assertEquals(port_g, SchemaNodeUtils.getRootOriginalIfPossible(port_u));
221 final ListSchemaNode addresses_u = (ListSchemaNode) destination.getDataChildByName(QName.create(
222 foo.getQNameModule(), "addresses"));
223 assertNotNull(addresses_u);
224 TestUtils.checkIsAddedByUses(addresses_u, true);
226 final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
227 baz.getQNameModule(), "addresses"));
228 assertNotNull(addresses_g);
229 TestUtils.checkIsAddedByUses(addresses_g, false);
230 assertFalse(addresses_u.equals(addresses_g));
231 assertEquals(addresses_g, SchemaNodeUtils.getRootOriginalIfPossible(addresses_u));
233 // grouping defined by 'uses'
234 final Set<GroupingDefinition> groupings_u = destination.getGroupings();
235 assertEquals(1, groupings_u.size());
236 final GroupingDefinition grouping_u = groupings_u.iterator().next();
237 TestUtils.checkIsAddedByUses(grouping_u, true);
239 // grouping defined in 'grouping' node
240 final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
241 assertEquals(1, groupings_g.size());
242 final GroupingDefinition grouping_g = groupings_g.iterator().next();
243 TestUtils.checkIsAddedByUses(grouping_g, false);
244 assertFalse(grouping_u.equals(grouping_g));
246 final List<UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
247 assertEquals(1, nodes_u.size());
248 final UnknownSchemaNode node_u = nodes_u.get(0);
249 assertTrue(node_u.isAddedByUses());
251 final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
252 assertEquals(1, nodes_g.size());
253 final UnknownSchemaNode node_g = nodes_g.get(0);
254 assertFalse(node_g.isAddedByUses());
255 assertFalse(node_u.equals(node_g));
259 public void testUsesUnderModule() {
260 // suffix _u = added by uses
261 // suffix _g = defined in grouping
263 final Module testModule = TestUtils.findModule(modules, "baz");
266 final Set<GroupingDefinition> groupings = testModule.getGroupings();
267 assertEquals(1, groupings.size());
268 final GroupingDefinition grouping = groupings.iterator().next();
270 // get node containing uses
271 final Module foo = TestUtils.findModule(modules, "foo");
274 final Set<UsesNode> uses = foo.getUses();
275 assertEquals(1, uses.size());
277 // check uses process
278 final AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
280 assertNotNull(data_u);
281 assertTrue(data_u.isAddedByUses());
283 final AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName(QName.create(
284 testModule.getQNameModule(), "data"));
285 assertNotNull(data_g);
286 assertFalse(data_g.isAddedByUses());
287 assertFalse(data_u.equals(data_g));
288 assertEquals(data_g, SchemaNodeUtils.getRootOriginalIfPossible(data_u));
290 final ChoiceSchemaNode how_u = (ChoiceSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
292 assertNotNull(how_u);
293 TestUtils.checkIsAddedByUses(how_u, true);
294 assertFalse(how_u.isAugmenting());
295 final Set<ChoiceCaseNode> cases_u = how_u.getCases();
296 assertEquals(2, cases_u.size());
297 final ChoiceCaseNode interval = how_u.getCaseNodeByName("interval");
298 assertFalse(interval.isAugmenting());
299 final LeafSchemaNode name = (LeafSchemaNode) interval.getDataChildByName(QName.create(foo.getQNameModule(),
301 assertTrue(name.isAugmenting());
302 final LeafSchemaNode intervalLeaf = (LeafSchemaNode) interval.getDataChildByName(QName.create(
303 foo.getQNameModule(), "interval"));
304 assertFalse(intervalLeaf.isAugmenting());
306 final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
307 testModule.getQNameModule(), "how"));
308 assertNotNull(how_g);
309 TestUtils.checkIsAddedByUses(how_g, false);
310 assertFalse(how_u.equals(how_g));
311 assertEquals(how_g, SchemaNodeUtils.getRootOriginalIfPossible(how_u));
313 final LeafSchemaNode address_u = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
315 assertNotNull(address_u);
316 assertNull(address_u.getDefault());
317 assertEquals("Target IP address", address_u.getDescription());
318 assertNull(address_u.getReference());
319 assertTrue(address_u.isConfiguration());
320 assertTrue(address_u.isAddedByUses());
322 final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
323 testModule.getQNameModule(), "address"));
324 assertNotNull(address_g);
325 assertFalse(address_g.isAddedByUses());
326 assertNull(address_g.getDefault());
327 assertEquals("Target IP address", address_g.getDescription());
328 assertNull(address_g.getReference());
329 assertTrue(address_g.isConfiguration());
330 assertFalse(address_u.equals(address_g));
331 assertEquals(address_g, SchemaNodeUtils.getRootOriginalIfPossible(address_u));
333 final ContainerSchemaNode port_u = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
334 foo.getQNameModule(), "port"));
335 assertNotNull(port_u);
336 TestUtils.checkIsAddedByUses(port_u, true);
338 final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
339 testModule.getQNameModule(), "port"));
340 assertNotNull(port_g);
341 TestUtils.checkIsAddedByUses(port_g, false);
342 assertFalse(port_u.equals(port_g));
343 assertEquals(port_g, SchemaNodeUtils.getRootOriginalIfPossible(port_u));
345 final ListSchemaNode addresses_u = (ListSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
347 assertNotNull(addresses_u);
348 TestUtils.checkIsAddedByUses(addresses_u, true);
350 final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
351 testModule.getQNameModule(), "addresses"));
352 assertNotNull(addresses_g);
353 TestUtils.checkIsAddedByUses(addresses_g, false);
354 assertFalse(addresses_u.equals(addresses_g));
355 assertEquals(addresses_g, SchemaNodeUtils.getRootOriginalIfPossible(addresses_u));
357 // grouping defined by 'uses'
358 final Set<GroupingDefinition> groupings_u = foo.getGroupings();
359 assertEquals(1, groupings_u.size());
360 final GroupingDefinition grouping_u = groupings_u.iterator().next();
361 TestUtils.checkIsAddedByUses(grouping_u, true);
363 // grouping defined in 'grouping' node
364 final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
365 assertEquals(1, groupings_g.size());
366 final GroupingDefinition grouping_g = groupings_g.iterator().next();
367 TestUtils.checkIsAddedByUses(grouping_g, false);
368 assertFalse(grouping_u.equals(grouping_g));
370 final List<UnknownSchemaNode> nodes_u = foo.getUnknownSchemaNodes();
371 assertEquals(1, nodes_u.size());
372 final UnknownSchemaNode node_u = nodes_u.get(0);
373 assertTrue(node_u.isAddedByUses());
375 final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
376 assertEquals(1, nodes_g.size());
377 final UnknownSchemaNode node_g = nodes_g.get(0);
378 assertFalse(node_g.isAddedByUses());
379 assertFalse(node_u.equals(node_g));
381 final UsesNode un = uses.iterator().next();
382 final Set<AugmentationSchema> usesAugments = un.getAugmentations();
383 assertEquals(1, usesAugments.size());
384 final AugmentationSchema augment = usesAugments.iterator().next();
385 assertEquals("inner augment", augment.getDescription());
386 final Collection<DataSchemaNode> children = augment.getChildNodes();
387 assertEquals(1, children.size());
388 final DataSchemaNode leaf = children.iterator().next();
389 assertTrue(leaf instanceof LeafSchemaNode);
390 assertEquals("name", leaf.getQName().getLocalName());
394 public void testCascadeUses() throws ReactorException, ParseException {
395 modules = TestUtils.loadModules(Collections.singletonList(getClass().getResourceAsStream(
396 "/grouping-test/cascade-uses.yang")));
397 assertEquals(1, modules.size());
399 final Module testModule = TestUtils.findModule(modules, "cascade-uses");
400 final Set<GroupingDefinition> groupings = testModule.getGroupings();
402 GroupingDefinition gu = null;
403 GroupingDefinition gv = null;
404 GroupingDefinition gx = null;
405 GroupingDefinition gy = null;
406 GroupingDefinition gz = null;
407 GroupingDefinition gzz = null;
408 for (final GroupingDefinition gd : groupings) {
409 final String name = gd.getQName().getLocalName();
438 final URI expectedNS = URI.create("urn:grouping:cascade-uses");
439 final Date expectedRev = SimpleDateFormatUtil.getRevisionFormat().parse("2013-07-18");
440 final String expectedPref = "cu";
441 SchemaPath expectedPath;
444 Collection<DataSchemaNode> childNodes = gu.getChildNodes();
445 assertEquals(7, childNodes.size());
447 final LeafSchemaNode leafGroupingU = (LeafSchemaNode) gu.getDataChildByName(QName.create(
448 testModule.getQNameModule(), "leaf-grouping-U"));
449 assertNotNull(leafGroupingU);
450 assertFalse(leafGroupingU.isAddedByUses());
451 assertFalse(SchemaNodeUtils.getOriginalIfPossible(leafGroupingU).isPresent());
453 for (final DataSchemaNode childNode : childNodes) {
454 if (!(childNode.getQName().equals(leafGroupingU.getQName()))) {
455 TestUtils.checkIsAddedByUses(childNode, true);
460 childNodes = gv.getChildNodes();
461 assertEquals(4, childNodes.size());
462 LeafSchemaNode leafGroupingV = null;
463 ContainerSchemaNode containerGroupingV = null;
464 for (final DataSchemaNode childNode : childNodes) {
465 if ("leaf-grouping-V".equals(childNode.getQName().getLocalName())) {
466 leafGroupingV = (LeafSchemaNode) childNode;
467 } else if ("container-grouping-V".equals(childNode.getQName().getLocalName())) {
468 containerGroupingV = (ContainerSchemaNode) childNode;
470 TestUtils.checkIsAddedByUses(childNode, true);
473 assertNotNull(leafGroupingV);
474 assertFalse(leafGroupingV.isAddedByUses());
476 // grouping-V/container-grouping-V
477 assertNotNull(containerGroupingV);
478 assertFalse(containerGroupingV.isAddedByUses());
479 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-V",
480 "container-grouping-V");
481 assertEquals(expectedPath, containerGroupingV.getPath());
482 childNodes = containerGroupingV.getChildNodes();
483 assertEquals(2, childNodes.size());
484 for (final DataSchemaNode childNode : childNodes) {
485 TestUtils.checkIsAddedByUses(childNode, true);
488 // grouping-V/container-grouping-V/leaf-grouping-X
489 final LeafSchemaNode leafXinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
490 testModule.getQNameModule(), "leaf-grouping-X"));
491 assertNotNull(leafXinContainerV);
492 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-V",
493 "container-grouping-V", "leaf-grouping-X");
494 assertEquals(expectedPath, leafXinContainerV.getPath());
495 // grouping-V/container-grouping-V/leaf-grouping-Y
496 final LeafSchemaNode leafYinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
497 testModule.getQNameModule(), "leaf-grouping-Y"));
498 assertNotNull(leafYinContainerV);
499 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-V",
500 "container-grouping-V", "leaf-grouping-Y");
501 assertEquals(expectedPath, leafYinContainerV.getPath());
504 childNodes = gx.getChildNodes();
505 assertEquals(2, childNodes.size());
507 // grouping-X/leaf-grouping-X
508 final LeafSchemaNode leafXinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
509 testModule.getQNameModule(), "leaf-grouping-X"));
510 assertNotNull(leafXinGX);
511 assertFalse(leafXinGX.isAddedByUses());
512 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-X",
514 assertEquals(expectedPath, leafXinGX.getPath());
516 // grouping-X/leaf-grouping-Y
517 final LeafSchemaNode leafYinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
518 testModule.getQNameModule(), "leaf-grouping-Y"));
519 assertNotNull(leafYinGX);
520 assertTrue(leafYinGX.isAddedByUses());
521 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-X",
523 assertEquals(expectedPath, leafYinGX.getPath());
526 childNodes = gy.getChildNodes();
527 assertEquals(1, childNodes.size());
529 // grouping-Y/leaf-grouping-Y
530 final LeafSchemaNode leafYinGY = (LeafSchemaNode) gy.getDataChildByName(QName.create(
531 testModule.getQNameModule(), "leaf-grouping-Y"));
532 assertNotNull(leafYinGY);
533 assertFalse(leafYinGY.isAddedByUses());
534 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-Y",
536 assertEquals(expectedPath, leafYinGY.getPath());
539 childNodes = gz.getChildNodes();
540 assertEquals(1, childNodes.size());
542 // grouping-Z/leaf-grouping-Z
543 final LeafSchemaNode leafZinGZ = (LeafSchemaNode) gz.getDataChildByName(QName.create(
544 testModule.getQNameModule(), "leaf-grouping-Z"));
545 assertNotNull(leafZinGZ);
546 assertFalse(leafZinGZ.isAddedByUses());
547 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-Z",
549 assertEquals(expectedPath, leafZinGZ.getPath());
552 childNodes = gzz.getChildNodes();
553 assertEquals(1, childNodes.size());
555 // grouping-ZZ/leaf-grouping-ZZ
556 final LeafSchemaNode leafZZinGZZ = (LeafSchemaNode) gzz.getDataChildByName(QName.create(
557 testModule.getQNameModule(), "leaf-grouping-ZZ"));
558 assertNotNull(leafZZinGZZ);
559 assertFalse(leafZZinGZZ.isAddedByUses());
560 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-ZZ",
562 assertEquals(expectedPath, leafZZinGZZ.getPath());
564 // TEST getOriginal from grouping-U
566 gv.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-V")),
567 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
568 testModule.getQNameModule(), "leaf-grouping-V"))));
569 containerGroupingV = (ContainerSchemaNode) gu.getDataChildByName(QName.create(testModule.getQNameModule(),
570 "container-grouping-V"));
571 assertEquals(gv.getDataChildByName(QName.create(testModule.getQNameModule(), "container-grouping-V")),
572 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV));
574 gx.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-X")),
575 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
576 testModule.getQNameModule(), "leaf-grouping-X"))));
578 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
579 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
580 testModule.getQNameModule(), "leaf-grouping-Y"))));
583 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
584 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
585 testModule.getQNameModule(), "leaf-grouping-Z"))));
587 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
588 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
589 testModule.getQNameModule(), "leaf-grouping-ZZ"))));
591 // TEST getOriginal from grouping-V
593 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
594 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
595 testModule.getQNameModule(), "leaf-grouping-Z"))));
597 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
598 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
599 testModule.getQNameModule(), "leaf-grouping-ZZ"))));
601 // TEST getOriginal from grouping-X
603 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
604 SchemaNodeUtils.getRootOriginalIfPossible(gx.getDataChildByName(QName.create(
605 testModule.getQNameModule(), "leaf-grouping-Y"))));
609 public void testAddedByUsesLeafTypeQName() throws Exception {
611 final Set<Module> loadModules = TestUtils.loadModules(getClass().getResource("/added-by-uses-leaf-test")
614 assertEquals(2, loadModules.size());
618 for (final Module module : loadModules) {
619 if (module.getName().equals("foo")) {
622 if (module.getName().equals("import-module")) {
630 final LeafSchemaNode leaf = (LeafSchemaNode) ((ContainerSchemaNode) foo.getDataChildByName(QName.create(
631 foo.getQNameModule(), "my-container")))
632 .getDataChildByName(QName.create(foo.getQNameModule(), "my-leaf"));
634 TypeDefinition<?> impType = null;
635 final Set<TypeDefinition<?>> typeDefinitions = imp.getTypeDefinitions();
636 for (final TypeDefinition<?> typeDefinition : typeDefinitions) {
637 if (typeDefinition.getQName().getLocalName().equals("imp-type")) {
638 impType = typeDefinition;
643 assertNotNull(impType);
644 assertEquals(leaf.getType().getQName(), impType.getQName());