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;
22 import java.util.Optional;
24 import java.util.SortedMap;
25 import org.junit.Before;
26 import org.junit.Test;
27 import org.opendaylight.yangtools.yang.common.QName;
28 import org.opendaylight.yangtools.yang.common.QNameModule;
29 import org.opendaylight.yangtools.yang.common.Revision;
30 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
31 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
32 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
33 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
34 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
35 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
36 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
37 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
38 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
39 import org.opendaylight.yangtools.yang.model.api.Module;
40 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
41 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
42 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
44 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
45 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
46 import org.opendaylight.yangtools.yang.model.api.UsesNode;
47 import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
48 import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
49 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
51 public class GroupingTest {
52 private SchemaContext ctx;
57 public void init() throws Exception {
58 ctx = TestUtils.loadModules(getClass().getResource("/model").toURI());
59 foo = TestUtils.findModule(ctx, "foo").get();
60 baz = TestUtils.findModule(ctx, "baz").get();
61 assertEquals(3, ctx.getModules().size());
65 public void testRefine() {
66 final Module testModule = TestUtils.findModule(ctx, "foo").get();
67 final ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName(QName.create(
68 testModule.getQNameModule(), "peer"));
69 final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
70 testModule.getQNameModule(), "destination"));
72 final Set<UsesNode> usesNodes = destination.getUses();
73 assertEquals(1, usesNodes.size());
74 final UsesNode usesNode = usesNodes.iterator().next();
75 final Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
76 assertEquals(4, refines.size());
78 LeafSchemaNode refineLeaf = null;
79 ContainerSchemaNode refineContainer = null;
80 ListSchemaNode refineList = null;
81 LeafSchemaNode refineInnerLeaf = null;
82 for (final Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
83 final SchemaNode value = entry.getValue();
84 if ("address".equals(value.getQName().getLocalName())) {
85 refineLeaf = (LeafSchemaNode) destination.getDataChildByName(value.getQName());
86 } else if ("port".equals(value.getQName().getLocalName())) {
87 refineContainer = (ContainerSchemaNode) destination.getDataChildByName(value.getQName());
88 } else if ("addresses".equals(value.getQName().getLocalName())) {
89 refineList = (ListSchemaNode) destination.getDataChildByName(value.getQName());
93 assertNotNull(refineList);
94 for (final Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
95 final SchemaNode value = entry.getValue();
96 if ("id".equals(value.getQName().getLocalName())) {
97 refineInnerLeaf = (LeafSchemaNode) refineList.getDataChildByName(value.getQName());
102 assertNotNull(refineLeaf);
103 assertEquals(Optional.of("IP address of target node"), refineLeaf.getDescription());
104 assertEquals(Optional.of("address reference added by refine"), refineLeaf.getReference());
105 assertFalse(refineLeaf.isConfiguration());
106 assertFalse(refineLeaf.getConstraints().isMandatory());
107 final Set<MustDefinition> leafMustConstraints = refineLeaf.getConstraints().getMustConstraints();
108 assertEquals(1, leafMustConstraints.size());
109 final MustDefinition leafMust = leafMustConstraints.iterator().next();
110 assertEquals("ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)", leafMust.toString());
111 assertEquals(1, refineLeaf.getUnknownSchemaNodes().size());
114 assertNotNull(refineContainer);
115 final Set<MustDefinition> mustConstraints = refineContainer.getConstraints().getMustConstraints();
116 assertTrue(mustConstraints.isEmpty());
117 assertEquals(Optional.of("description of port defined by refine"), refineContainer.getDescription());
118 assertEquals(Optional.of("port reference added by refine"), refineContainer.getReference());
119 assertFalse(refineContainer.isConfiguration());
120 assertTrue(refineContainer.isPresenceContainer());
123 assertEquals(Optional.of("description of addresses defined by refine"), refineList.getDescription());
124 assertEquals(Optional.of("addresses reference added by refine"), refineList.getReference());
125 assertFalse(refineList.isConfiguration());
126 assertEquals(2, (int) refineList.getConstraints().getMinElements());
127 assertNull(refineList.getConstraints().getMaxElements());
130 assertNotNull(refineInnerLeaf);
131 assertEquals(Optional.of("id of address"), refineInnerLeaf.getDescription());
135 public void testGrouping() {
136 final Module testModule = TestUtils.findModule(ctx, "baz").get();
137 final Set<GroupingDefinition> groupings = testModule.getGroupings();
138 assertEquals(1, groupings.size());
139 final GroupingDefinition grouping = groupings.iterator().next();
140 final Collection<DataSchemaNode> children = grouping.getChildNodes();
141 assertEquals(5, children.size());
145 public void testUses() {
146 // suffix _u = added by uses
147 // suffix _g = defined in grouping
151 final Set<GroupingDefinition> groupings = baz.getGroupings();
152 assertEquals(1, groupings.size());
153 final GroupingDefinition grouping = groupings.iterator().next();
155 // get node containing uses
156 final ContainerSchemaNode peer = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
157 foo.getQNameModule(), "peer"));
158 final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
159 foo.getQNameModule(), "destination"));
162 final Set<UsesNode> uses = destination.getUses();
163 assertEquals(1, uses.size());
165 // check uses process
166 final AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) destination.getDataChildByName(QName.create(
167 foo.getQNameModule(), "data"));
168 assertNotNull(data_u);
169 assertTrue(data_u.isAddedByUses());
171 final AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName(QName.create(
172 baz.getQNameModule(), "data"));
173 assertNotNull(data_g);
174 assertFalse(data_g.isAddedByUses());
175 assertFalse(data_u.equals(data_g));
176 assertEquals(data_g, SchemaNodeUtils.getRootOriginalIfPossible(data_u));
178 final ChoiceSchemaNode how_u = (ChoiceSchemaNode) destination.getDataChildByName(QName.create(
179 foo.getQNameModule(), "how"));
180 assertNotNull(how_u);
181 TestUtils.checkIsAddedByUses(how_u, true);
182 assertEquals(2, how_u.getCases().size());
184 final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
185 baz.getQNameModule(), "how"));
186 assertNotNull(how_g);
187 TestUtils.checkIsAddedByUses(how_g, false);
188 assertEquals(2, how_g.getCases().size());
189 assertFalse(how_u.equals(how_g));
190 assertEquals(how_g, SchemaNodeUtils.getRootOriginalIfPossible(how_u));
192 final LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName(QName.create(
193 foo.getQNameModule(), "address"));
194 assertNotNull(address_u);
195 assertEquals("1.2.3.4", address_u.getType().getDefaultValue());
196 assertEquals(Optional.of("IP address of target node"), address_u.getDescription());
197 assertEquals(Optional.of("address reference added by refine"), address_u.getReference());
198 assertFalse(address_u.isConfiguration());
199 assertTrue(address_u.isAddedByUses());
200 assertFalse(address_u.getConstraints().isMandatory());
202 final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
203 baz.getQNameModule(), "address"));
204 assertNotNull(address_g);
205 assertFalse(address_g.isAddedByUses());
206 assertNull(address_g.getType().getDefaultValue());
207 assertEquals(Optional.of("Target IP address"), address_g.getDescription());
208 assertFalse(address_g.getReference().isPresent());
209 assertTrue(address_g.isConfiguration());
210 assertFalse(address_u.equals(address_g));
211 assertTrue(address_g.getConstraints().isMandatory());
212 assertEquals(address_g, SchemaNodeUtils.getRootOriginalIfPossible(address_u));
214 final ContainerSchemaNode port_u = (ContainerSchemaNode) destination.getDataChildByName(QName.create(
215 foo.getQNameModule(), "port"));
216 assertNotNull(port_u);
217 TestUtils.checkIsAddedByUses(port_u, true);
219 final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
220 baz.getQNameModule(), "port"));
221 assertNotNull(port_g);
222 TestUtils.checkIsAddedByUses(port_g, false);
223 assertFalse(port_u.equals(port_g));
224 assertEquals(port_g, SchemaNodeUtils.getRootOriginalIfPossible(port_u));
226 final ListSchemaNode addresses_u = (ListSchemaNode) destination.getDataChildByName(QName.create(
227 foo.getQNameModule(), "addresses"));
228 assertNotNull(addresses_u);
229 TestUtils.checkIsAddedByUses(addresses_u, true);
231 final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
232 baz.getQNameModule(), "addresses"));
233 assertNotNull(addresses_g);
234 TestUtils.checkIsAddedByUses(addresses_g, false);
235 assertFalse(addresses_u.equals(addresses_g));
236 assertEquals(addresses_g, SchemaNodeUtils.getRootOriginalIfPossible(addresses_u));
238 // grouping defined by 'uses'
239 final Set<GroupingDefinition> groupings_u = destination.getGroupings();
240 assertEquals(1, groupings_u.size());
241 final GroupingDefinition grouping_u = groupings_u.iterator().next();
242 TestUtils.checkIsAddedByUses(grouping_u, true);
244 // grouping defined in 'grouping' node
245 final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
246 assertEquals(1, groupings_g.size());
247 final GroupingDefinition grouping_g = groupings_g.iterator().next();
248 TestUtils.checkIsAddedByUses(grouping_g, false);
249 assertFalse(grouping_u.equals(grouping_g));
251 final List<UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
252 assertEquals(1, nodes_u.size());
253 final UnknownSchemaNode node_u = nodes_u.get(0);
254 assertTrue(node_u.isAddedByUses());
256 final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
257 assertEquals(1, nodes_g.size());
258 final UnknownSchemaNode node_g = nodes_g.get(0);
259 assertFalse(node_g.isAddedByUses());
260 assertFalse(node_u.equals(node_g));
264 public void testUsesUnderModule() {
265 // suffix _u = added by uses
266 // suffix _g = defined in grouping
269 final Set<GroupingDefinition> groupings = baz.getGroupings();
270 assertEquals(1, groupings.size());
271 final GroupingDefinition grouping = groupings.iterator().next();
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 baz.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 SortedMap<QName, ChoiceCaseNode> cases_u = how_u.getCases();
296 assertEquals(2, cases_u.size());
297 final ChoiceCaseNode interval = how_u.findCaseNodes("interval").iterator().next();
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 baz.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.getType().getDefaultValue());
317 assertEquals(Optional.of("Target IP address"), address_u.getDescription());
318 assertFalse(address_u.getReference().isPresent());
319 assertTrue(address_u.isConfiguration());
320 assertTrue(address_u.isAddedByUses());
322 final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
323 baz.getQNameModule(), "address"));
324 assertNotNull(address_g);
325 assertFalse(address_g.isAddedByUses());
326 assertNull(address_g.getType().getDefaultValue());
327 assertEquals(Optional.of("Target IP address"), address_g.getDescription());
328 assertFalse(address_g.getReference().isPresent());
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 baz.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 baz.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<AugmentationSchemaNode> usesAugments = un.getAugmentations();
383 assertEquals(1, usesAugments.size());
384 final AugmentationSchemaNode augment = usesAugments.iterator().next();
385 assertEquals(Optional.of("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, IOException, YangSyntaxErrorException {
395 ctx = TestUtils.loadModuleResources(getClass(), "/grouping-test/cascade-uses.yang");
396 assertEquals(1, ctx.getModules().size());
398 final Module testModule = TestUtils.findModule(ctx, "cascade-uses").get();
399 final Set<GroupingDefinition> groupings = testModule.getGroupings();
401 GroupingDefinition gu = null;
402 GroupingDefinition gv = null;
403 GroupingDefinition gx = null;
404 GroupingDefinition gy = null;
405 GroupingDefinition gz = null;
406 GroupingDefinition gzz = null;
407 for (final GroupingDefinition gd : groupings) {
408 final String name = gd.getQName().getLocalName();
439 final QNameModule expectedModule = QNameModule.create(URI.create("urn:grouping:cascade-uses"),
440 Revision.of("2013-07-18"));
443 Collection<DataSchemaNode> childNodes = gu.getChildNodes();
444 assertEquals(7, childNodes.size());
446 final LeafSchemaNode leafGroupingU = (LeafSchemaNode) gu.getDataChildByName(QName.create(
447 testModule.getQNameModule(), "leaf-grouping-U"));
448 assertNotNull(leafGroupingU);
449 assertFalse(leafGroupingU.isAddedByUses());
450 assertFalse(SchemaNodeUtils.getOriginalIfPossible(leafGroupingU).isPresent());
452 for (final DataSchemaNode childNode : childNodes) {
453 if (!childNode.getQName().equals(leafGroupingU.getQName())) {
454 TestUtils.checkIsAddedByUses(childNode, true);
459 childNodes = gv.getChildNodes();
460 assertEquals(4, childNodes.size());
461 LeafSchemaNode leafGroupingV = null;
462 ContainerSchemaNode containerGroupingV = null;
463 for (final DataSchemaNode childNode : childNodes) {
464 if ("leaf-grouping-V".equals(childNode.getQName().getLocalName())) {
465 leafGroupingV = (LeafSchemaNode) childNode;
466 } else if ("container-grouping-V".equals(childNode.getQName().getLocalName())) {
467 containerGroupingV = (ContainerSchemaNode) childNode;
469 TestUtils.checkIsAddedByUses(childNode, true);
472 assertNotNull(leafGroupingV);
473 assertFalse(leafGroupingV.isAddedByUses());
475 // grouping-V/container-grouping-V
476 assertNotNull(containerGroupingV);
477 assertFalse(containerGroupingV.isAddedByUses());
478 SchemaPath expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V");
479 assertEquals(expectedPath, containerGroupingV.getPath());
480 childNodes = containerGroupingV.getChildNodes();
481 assertEquals(2, childNodes.size());
482 for (final DataSchemaNode childNode : childNodes) {
483 TestUtils.checkIsAddedByUses(childNode, true);
486 // grouping-V/container-grouping-V/leaf-grouping-X
487 final LeafSchemaNode leafXinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
488 testModule.getQNameModule(), "leaf-grouping-X"));
489 assertNotNull(leafXinContainerV);
490 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V",
492 assertEquals(expectedPath, leafXinContainerV.getPath());
493 // grouping-V/container-grouping-V/leaf-grouping-Y
494 final LeafSchemaNode leafYinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
495 testModule.getQNameModule(), "leaf-grouping-Y"));
496 assertNotNull(leafYinContainerV);
497 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V",
499 assertEquals(expectedPath, leafYinContainerV.getPath());
502 childNodes = gx.getChildNodes();
503 assertEquals(2, childNodes.size());
505 // grouping-X/leaf-grouping-X
506 final LeafSchemaNode leafXinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
507 testModule.getQNameModule(), "leaf-grouping-X"));
508 assertNotNull(leafXinGX);
509 assertFalse(leafXinGX.isAddedByUses());
510 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-X", "leaf-grouping-X");
511 assertEquals(expectedPath, leafXinGX.getPath());
513 // grouping-X/leaf-grouping-Y
514 final LeafSchemaNode leafYinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
515 testModule.getQNameModule(), "leaf-grouping-Y"));
516 assertNotNull(leafYinGX);
517 assertTrue(leafYinGX.isAddedByUses());
518 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-X", "leaf-grouping-Y");
519 assertEquals(expectedPath, leafYinGX.getPath());
522 childNodes = gy.getChildNodes();
523 assertEquals(1, childNodes.size());
525 // grouping-Y/leaf-grouping-Y
526 final LeafSchemaNode leafYinGY = (LeafSchemaNode) gy.getDataChildByName(QName.create(
527 testModule.getQNameModule(), "leaf-grouping-Y"));
528 assertNotNull(leafYinGY);
529 assertFalse(leafYinGY.isAddedByUses());
530 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-Y", "leaf-grouping-Y");
531 assertEquals(expectedPath, leafYinGY.getPath());
534 childNodes = gz.getChildNodes();
535 assertEquals(1, childNodes.size());
537 // grouping-Z/leaf-grouping-Z
538 final LeafSchemaNode leafZinGZ = (LeafSchemaNode) gz.getDataChildByName(QName.create(
539 testModule.getQNameModule(), "leaf-grouping-Z"));
540 assertNotNull(leafZinGZ);
541 assertFalse(leafZinGZ.isAddedByUses());
542 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-Z", "leaf-grouping-Z");
543 assertEquals(expectedPath, leafZinGZ.getPath());
546 childNodes = gzz.getChildNodes();
547 assertEquals(1, childNodes.size());
549 // grouping-ZZ/leaf-grouping-ZZ
550 final LeafSchemaNode leafZZinGZZ = (LeafSchemaNode) gzz.getDataChildByName(QName.create(
551 testModule.getQNameModule(), "leaf-grouping-ZZ"));
552 assertNotNull(leafZZinGZZ);
553 assertFalse(leafZZinGZZ.isAddedByUses());
554 expectedPath = TestUtils.createPath(true, expectedModule, "grouping-ZZ", "leaf-grouping-ZZ");
555 assertEquals(expectedPath, leafZZinGZZ.getPath());
557 // TEST getOriginal from grouping-U
559 gv.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-V")),
560 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
561 testModule.getQNameModule(), "leaf-grouping-V"))));
562 containerGroupingV = (ContainerSchemaNode) gu.getDataChildByName(QName.create(testModule.getQNameModule(),
563 "container-grouping-V"));
564 assertEquals(gv.getDataChildByName(QName.create(testModule.getQNameModule(), "container-grouping-V")),
565 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV));
567 gx.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-X")),
568 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
569 testModule.getQNameModule(), "leaf-grouping-X"))));
571 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
572 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
573 testModule.getQNameModule(), "leaf-grouping-Y"))));
576 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
577 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
578 testModule.getQNameModule(), "leaf-grouping-Z"))));
580 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
581 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
582 testModule.getQNameModule(), "leaf-grouping-ZZ"))));
584 // TEST getOriginal from grouping-V
586 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
587 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
588 testModule.getQNameModule(), "leaf-grouping-Z"))));
590 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
591 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
592 testModule.getQNameModule(), "leaf-grouping-ZZ"))));
594 // TEST getOriginal from grouping-X
596 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
597 SchemaNodeUtils.getRootOriginalIfPossible(gx.getDataChildByName(QName.create(
598 testModule.getQNameModule(), "leaf-grouping-Y"))));
602 public void testAddedByUsesLeafTypeQName() throws Exception {
603 final SchemaContext loadModules = TestUtils.loadModules(getClass().getResource("/added-by-uses-leaf-test")
605 assertEquals(2, loadModules.getModules().size());
606 foo = TestUtils.findModule(loadModules, "foo").get();
607 final Module imp = TestUtils.findModule(loadModules, "import-module").get();
609 final LeafSchemaNode leaf = (LeafSchemaNode) ((ContainerSchemaNode) foo.getDataChildByName(QName.create(
610 foo.getQNameModule(), "my-container")))
611 .getDataChildByName(QName.create(foo.getQNameModule(), "my-leaf"));
613 TypeDefinition<?> impType = null;
614 final Set<TypeDefinition<?>> typeDefinitions = imp.getTypeDefinitions();
615 for (final TypeDefinition<?> typeDefinition : typeDefinitions) {
616 if (typeDefinition.getQName().getLocalName().equals("imp-type")) {
617 impType = typeDefinition;
622 assertNotNull(impType);
623 assertEquals(leaf.getType().getQName(), impType.getQName());