yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.yangtools.yang.stmt;
   9
  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;
  15
  16 import java.io.IOException;
  17 import java.net.URI;
  18 import java.text.ParseException;
  19 import java.util.Collection;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.Set;
  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.common.Revision;
  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.SchemaContext;
  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.parser.api.YangSyntaxErrorException;
  46 import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
  47 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  48
  49 public class GroupingTest {
  50     private SchemaContext ctx;
  51     private Module foo;
  52     private Module baz;
  53
  54     @Before
  55     public void init() throws Exception {
  56         ctx = TestUtils.loadModules(getClass().getResource("/model").toURI());
  57         foo = TestUtils.findModule(ctx, "foo").get();
  58         baz = TestUtils.findModule(ctx, "baz").get();
  59         assertEquals(3, ctx.getModules().size());
  60     }
  61
  62     @Test
  63     public void testRefine() {
  64         final Module testModule = TestUtils.findModule(ctx, "foo").get();
  65         final ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName(QName.create(
  66                 testModule.getQNameModule(), "peer"));
  67         final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
  68                 testModule.getQNameModule(), "destination"));
  69
  70         final Set<UsesNode> usesNodes = destination.getUses();
  71         assertEquals(1, usesNodes.size());
  72         final UsesNode usesNode = usesNodes.iterator().next();
  73         final Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
  74         assertEquals(4, refines.size());
  75
  76         LeafSchemaNode refineLeaf = null;
  77         ContainerSchemaNode refineContainer = null;
  78         ListSchemaNode refineList = null;
  79         LeafSchemaNode refineInnerLeaf = null;
  80         for (final Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
  81             final SchemaNode value = entry.getValue();
  82             if ("address".equals(value.getQName().getLocalName())) {
  83                 refineLeaf = (LeafSchemaNode) destination.getDataChildByName(value.getQName());
  84             } else if ("port".equals(value.getQName().getLocalName())) {
  85                 refineContainer = (ContainerSchemaNode) destination.getDataChildByName(value.getQName());
  86             } else if ("addresses".equals(value.getQName().getLocalName())) {
  87                 refineList = (ListSchemaNode) destination.getDataChildByName(value.getQName());
  88             }
  89         }
  90
  91         assertNotNull(refineList);
  92         for (final Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
  93             final SchemaNode value = entry.getValue();
  94             if ("id".equals(value.getQName().getLocalName())) {
  95                 refineInnerLeaf = (LeafSchemaNode) refineList.getDataChildByName(value.getQName());
  96             }
  97         }
  98
  99         // leaf address
 100         assertNotNull(refineLeaf);
 101         assertEquals("IP address of target node", refineLeaf.getDescription());
 102         assertEquals("address reference added by refine", refineLeaf.getReference());
 103         assertFalse(refineLeaf.isConfiguration());
 104         assertFalse(refineLeaf.getConstraints().isMandatory());
 105         final Set<MustDefinition> leafMustConstraints = refineLeaf.getConstraints().getMustConstraints();
 106         assertEquals(1, leafMustConstraints.size());
 107         final MustDefinition leafMust = leafMustConstraints.iterator().next();
 108         assertEquals("ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)", leafMust.toString());
 109         assertEquals(1, refineLeaf.getUnknownSchemaNodes().size());
 110
 111         // container port
 112         assertNotNull(refineContainer);
 113         final Set<MustDefinition> mustConstraints = refineContainer.getConstraints().getMustConstraints();
 114         assertTrue(mustConstraints.isEmpty());
 115         assertEquals("description of port defined by refine", refineContainer.getDescription());
 116         assertEquals("port reference added by refine", refineContainer.getReference());
 117         assertFalse(refineContainer.isConfiguration());
 118         assertTrue(refineContainer.isPresenceContainer());
 119
 120         // list addresses
 121         assertEquals("description of addresses defined by refine", refineList.getDescription());
 122         assertEquals("addresses reference added by refine", refineList.getReference());
 123         assertFalse(refineList.isConfiguration());
 124         assertEquals(2, (int) refineList.getConstraints().getMinElements());
 125         assertNull(refineList.getConstraints().getMaxElements());
 126
 127         // leaf id
 128         assertNotNull(refineInnerLeaf);
 129         assertEquals("id of address", refineInnerLeaf.getDescription());
 130     }
 131
 132     @Test
 133     public void testGrouping() {
 134         final Module testModule = TestUtils.findModule(ctx, "baz").get();
 135         final Set<GroupingDefinition> groupings = testModule.getGroupings();
 136         assertEquals(1, groupings.size());
 137         final GroupingDefinition grouping = groupings.iterator().next();
 138         final Collection<DataSchemaNode> children = grouping.getChildNodes();
 139         assertEquals(5, children.size());
 140     }
 141
 142     @Test
 143     public void testUses() {
 144         // suffix _u = added by uses
 145         // suffix _g = defined in grouping
 146
 147
 148         // get grouping
 149         final Set<GroupingDefinition> groupings = baz.getGroupings();
 150         assertEquals(1, groupings.size());
 151         final GroupingDefinition grouping = groupings.iterator().next();
 152
 153         // get node containing uses
 154         final ContainerSchemaNode peer = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
 155                 foo.getQNameModule(), "peer"));
 156         final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
 157                 foo.getQNameModule(), "destination"));
 158
 159         // check uses
 160         final Set<UsesNode> uses = destination.getUses();
 161         assertEquals(1, uses.size());
 162
 163         // check uses process
 164         final AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) destination.getDataChildByName(QName.create(
 165                 foo.getQNameModule(), "data"));
 166         assertNotNull(data_u);
 167         assertTrue(data_u.isAddedByUses());
 168
 169         final AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName(QName.create(
 170                 baz.getQNameModule(), "data"));
 171         assertNotNull(data_g);
 172         assertFalse(data_g.isAddedByUses());
 173         assertFalse(data_u.equals(data_g));
 174         assertEquals(data_g, SchemaNodeUtils.getRootOriginalIfPossible(data_u));
 175
 176         final ChoiceSchemaNode how_u = (ChoiceSchemaNode) destination.getDataChildByName(QName.create(
 177                 foo.getQNameModule(), "how"));
 178         assertNotNull(how_u);
 179         TestUtils.checkIsAddedByUses(how_u, true);
 180         assertEquals(2, how_u.getCases().size());
 181
 182         final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
 183                 baz.getQNameModule(), "how"));
 184         assertNotNull(how_g);
 185         TestUtils.checkIsAddedByUses(how_g, false);
 186         assertEquals(2, how_g.getCases().size());
 187         assertFalse(how_u.equals(how_g));
 188         assertEquals(how_g, SchemaNodeUtils.getRootOriginalIfPossible(how_u));
 189
 190         final LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName(QName.create(
 191                 foo.getQNameModule(), "address"));
 192         assertNotNull(address_u);
 193         assertEquals("1.2.3.4", address_u.getDefault());
 194         assertEquals("IP address of target node", address_u.getDescription());
 195         assertEquals("address reference added by refine", address_u.getReference());
 196         assertFalse(address_u.isConfiguration());
 197         assertTrue(address_u.isAddedByUses());
 198         assertFalse(address_u.getConstraints().isMandatory());
 199
 200         final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
 201                 baz.getQNameModule(), "address"));
 202         assertNotNull(address_g);
 203         assertFalse(address_g.isAddedByUses());
 204         assertNull(address_g.getDefault());
 205         assertEquals("Target IP address", address_g.getDescription());
 206         assertNull(address_g.getReference());
 207         assertTrue(address_g.isConfiguration());
 208         assertFalse(address_u.equals(address_g));
 209         assertTrue(address_g.getConstraints().isMandatory());
 210         assertEquals(address_g, SchemaNodeUtils.getRootOriginalIfPossible(address_u));
 211
 212         final ContainerSchemaNode port_u = (ContainerSchemaNode) destination.getDataChildByName(QName.create(
 213                 foo.getQNameModule(), "port"));
 214         assertNotNull(port_u);
 215         TestUtils.checkIsAddedByUses(port_u, true);
 216
 217         final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
 218                 baz.getQNameModule(), "port"));
 219         assertNotNull(port_g);
 220         TestUtils.checkIsAddedByUses(port_g, false);
 221         assertFalse(port_u.equals(port_g));
 222         assertEquals(port_g, SchemaNodeUtils.getRootOriginalIfPossible(port_u));
 223
 224         final ListSchemaNode addresses_u = (ListSchemaNode) destination.getDataChildByName(QName.create(
 225                 foo.getQNameModule(), "addresses"));
 226         assertNotNull(addresses_u);
 227         TestUtils.checkIsAddedByUses(addresses_u, true);
 228
 229         final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
 230                 baz.getQNameModule(), "addresses"));
 231         assertNotNull(addresses_g);
 232         TestUtils.checkIsAddedByUses(addresses_g, false);
 233         assertFalse(addresses_u.equals(addresses_g));
 234         assertEquals(addresses_g, SchemaNodeUtils.getRootOriginalIfPossible(addresses_u));
 235
 236         // grouping defined by 'uses'
 237         final Set<GroupingDefinition> groupings_u = destination.getGroupings();
 238         assertEquals(1, groupings_u.size());
 239         final GroupingDefinition grouping_u = groupings_u.iterator().next();
 240         TestUtils.checkIsAddedByUses(grouping_u, true);
 241
 242         // grouping defined in 'grouping' node
 243         final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
 244         assertEquals(1, groupings_g.size());
 245         final GroupingDefinition grouping_g = groupings_g.iterator().next();
 246         TestUtils.checkIsAddedByUses(grouping_g, false);
 247         assertFalse(grouping_u.equals(grouping_g));
 248
 249         final List<UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
 250         assertEquals(1, nodes_u.size());
 251         final UnknownSchemaNode node_u = nodes_u.get(0);
 252         assertTrue(node_u.isAddedByUses());
 253
 254         final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
 255         assertEquals(1, nodes_g.size());
 256         final UnknownSchemaNode node_g = nodes_g.get(0);
 257         assertFalse(node_g.isAddedByUses());
 258         assertFalse(node_u.equals(node_g));
 259     }
 260
 261     @Test
 262     public void testUsesUnderModule() {
 263         // suffix _u = added by uses
 264         // suffix _g = defined in grouping
 265
 266         // get grouping
 267         final Set<GroupingDefinition> groupings = baz.getGroupings();
 268         assertEquals(1, groupings.size());
 269         final GroupingDefinition grouping = groupings.iterator().next();
 270
 271         // check uses
 272         final Set<UsesNode> uses = foo.getUses();
 273         assertEquals(1, uses.size());
 274
 275         // check uses process
 276         final AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
 277                 "data"));
 278         assertNotNull(data_u);
 279         assertTrue(data_u.isAddedByUses());
 280
 281         final AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName(QName.create(
 282             baz.getQNameModule(), "data"));
 283         assertNotNull(data_g);
 284         assertFalse(data_g.isAddedByUses());
 285         assertFalse(data_u.equals(data_g));
 286         assertEquals(data_g, SchemaNodeUtils.getRootOriginalIfPossible(data_u));
 287
 288         final ChoiceSchemaNode how_u = (ChoiceSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
 289                 "how"));
 290         assertNotNull(how_u);
 291         TestUtils.checkIsAddedByUses(how_u, true);
 292         assertFalse(how_u.isAugmenting());
 293         final Set<ChoiceCaseNode> cases_u = how_u.getCases();
 294         assertEquals(2, cases_u.size());
 295         final ChoiceCaseNode interval = how_u.getCaseNodeByName("interval");
 296         assertFalse(interval.isAugmenting());
 297         final LeafSchemaNode name = (LeafSchemaNode) interval.getDataChildByName(QName.create(foo.getQNameModule(),
 298                 "name"));
 299         assertTrue(name.isAugmenting());
 300         final LeafSchemaNode intervalLeaf = (LeafSchemaNode) interval.getDataChildByName(QName.create(
 301                 foo.getQNameModule(), "interval"));
 302         assertFalse(intervalLeaf.isAugmenting());
 303
 304         final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
 305                 baz.getQNameModule(), "how"));
 306         assertNotNull(how_g);
 307         TestUtils.checkIsAddedByUses(how_g, false);
 308         assertFalse(how_u.equals(how_g));
 309         assertEquals(how_g, SchemaNodeUtils.getRootOriginalIfPossible(how_u));
 310
 311         final LeafSchemaNode address_u = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
 312                 "address"));
 313         assertNotNull(address_u);
 314         assertNull(address_u.getDefault());
 315         assertEquals("Target IP address", address_u.getDescription());
 316         assertNull(address_u.getReference());
 317         assertTrue(address_u.isConfiguration());
 318         assertTrue(address_u.isAddedByUses());
 319
 320         final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
 321                 baz.getQNameModule(), "address"));
 322         assertNotNull(address_g);
 323         assertFalse(address_g.isAddedByUses());
 324         assertNull(address_g.getDefault());
 325         assertEquals("Target IP address", address_g.getDescription());
 326         assertNull(address_g.getReference());
 327         assertTrue(address_g.isConfiguration());
 328         assertFalse(address_u.equals(address_g));
 329         assertEquals(address_g, SchemaNodeUtils.getRootOriginalIfPossible(address_u));
 330
 331         final ContainerSchemaNode port_u = (ContainerSchemaNode) foo.getDataChildByName(QName.create(
 332                 foo.getQNameModule(), "port"));
 333         assertNotNull(port_u);
 334         TestUtils.checkIsAddedByUses(port_u, true);
 335
 336         final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
 337                 baz.getQNameModule(), "port"));
 338         assertNotNull(port_g);
 339         TestUtils.checkIsAddedByUses(port_g, false);
 340         assertFalse(port_u.equals(port_g));
 341         assertEquals(port_g, SchemaNodeUtils.getRootOriginalIfPossible(port_u));
 342
 343         final ListSchemaNode addresses_u = (ListSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
 344                 "addresses"));
 345         assertNotNull(addresses_u);
 346         TestUtils.checkIsAddedByUses(addresses_u, true);
 347
 348         final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
 349                 baz.getQNameModule(), "addresses"));
 350         assertNotNull(addresses_g);
 351         TestUtils.checkIsAddedByUses(addresses_g, false);
 352         assertFalse(addresses_u.equals(addresses_g));
 353         assertEquals(addresses_g, SchemaNodeUtils.getRootOriginalIfPossible(addresses_u));
 354
 355         // grouping defined by 'uses'
 356         final Set<GroupingDefinition> groupings_u = foo.getGroupings();
 357         assertEquals(1, groupings_u.size());
 358         final GroupingDefinition grouping_u = groupings_u.iterator().next();
 359         TestUtils.checkIsAddedByUses(grouping_u, true);
 360
 361         // grouping defined in 'grouping' node
 362         final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
 363         assertEquals(1, groupings_g.size());
 364         final GroupingDefinition grouping_g = groupings_g.iterator().next();
 365         TestUtils.checkIsAddedByUses(grouping_g, false);
 366         assertFalse(grouping_u.equals(grouping_g));
 367
 368         final List<UnknownSchemaNode> nodes_u = foo.getUnknownSchemaNodes();
 369         assertEquals(1, nodes_u.size());
 370         final UnknownSchemaNode node_u = nodes_u.get(0);
 371         assertTrue(node_u.isAddedByUses());
 372
 373         final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
 374         assertEquals(1, nodes_g.size());
 375         final UnknownSchemaNode node_g = nodes_g.get(0);
 376         assertFalse(node_g.isAddedByUses());
 377         assertFalse(node_u.equals(node_g));
 378
 379         final UsesNode un = uses.iterator().next();
 380         final Set<AugmentationSchema> usesAugments = un.getAugmentations();
 381         assertEquals(1, usesAugments.size());
 382         final AugmentationSchema augment = usesAugments.iterator().next();
 383         assertEquals("inner augment", augment.getDescription());
 384         final Collection<DataSchemaNode> children = augment.getChildNodes();
 385         assertEquals(1, children.size());
 386         final DataSchemaNode leaf = children.iterator().next();
 387         assertTrue(leaf instanceof LeafSchemaNode);
 388         assertEquals("name", leaf.getQName().getLocalName());
 389     }
 390
 391     @Test
 392     public void testCascadeUses() throws ReactorException, ParseException, IOException, YangSyntaxErrorException {
 393         ctx = TestUtils.loadModuleResources(getClass(), "/grouping-test/cascade-uses.yang");
 394         assertEquals(1, ctx.getModules().size());
 395
 396         final Module testModule = TestUtils.findModule(ctx, "cascade-uses").get();
 397         final Set<GroupingDefinition> groupings = testModule.getGroupings();
 398
 399         GroupingDefinition gu = null;
 400         GroupingDefinition gv = null;
 401         GroupingDefinition gx = null;
 402         GroupingDefinition gy = null;
 403         GroupingDefinition gz = null;
 404         GroupingDefinition gzz = null;
 405         for (final GroupingDefinition gd : groupings) {
 406             final String name = gd.getQName().getLocalName();
 407             switch (name) {
 408                 case "grouping-U":
 409                     gu = gd;
 410                     break;
 411                 case "grouping-V":
 412                     gv = gd;
 413                     break;
 414                 case "grouping-X":
 415                     gx = gd;
 416                     break;
 417                 case "grouping-Y":
 418                     gy = gd;
 419                     break;
 420                 case "grouping-Z":
 421                     gz = gd;
 422                     break;
 423                 case "grouping-ZZ":
 424                     gzz = gd;
 425                     break;
 426                 default:
 427                     break;
 428             }
 429         }
 430         assertNotNull(gu);
 431         assertNotNull(gv);
 432         assertNotNull(gx);
 433         assertNotNull(gy);
 434         assertNotNull(gz);
 435         assertNotNull(gzz);
 436
 437         final QNameModule expectedModule = QNameModule.create(URI.create("urn:grouping:cascade-uses"),
 438             Revision.valueOf("2013-07-18"));
 439
 440         // grouping-U
 441         Collection<DataSchemaNode> childNodes = gu.getChildNodes();
 442         assertEquals(7, childNodes.size());
 443
 444         final LeafSchemaNode leafGroupingU = (LeafSchemaNode) gu.getDataChildByName(QName.create(
 445                 testModule.getQNameModule(), "leaf-grouping-U"));
 446         assertNotNull(leafGroupingU);
 447         assertFalse(leafGroupingU.isAddedByUses());
 448         assertFalse(SchemaNodeUtils.getOriginalIfPossible(leafGroupingU).isPresent());
 449
 450         for (final DataSchemaNode childNode : childNodes) {
 451             if (!childNode.getQName().equals(leafGroupingU.getQName())) {
 452                 TestUtils.checkIsAddedByUses(childNode, true);
 453             }
 454         }
 455
 456         // grouping-V
 457         childNodes = gv.getChildNodes();
 458         assertEquals(4, childNodes.size());
 459         LeafSchemaNode leafGroupingV = null;
 460         ContainerSchemaNode containerGroupingV = null;
 461         for (final DataSchemaNode childNode : childNodes) {
 462             if ("leaf-grouping-V".equals(childNode.getQName().getLocalName())) {
 463                 leafGroupingV = (LeafSchemaNode) childNode;
 464             } else if ("container-grouping-V".equals(childNode.getQName().getLocalName())) {
 465                 containerGroupingV = (ContainerSchemaNode) childNode;
 466             } else {
 467                 TestUtils.checkIsAddedByUses(childNode, true);
 468             }
 469         }
 470         assertNotNull(leafGroupingV);
 471         assertFalse(leafGroupingV.isAddedByUses());
 472
 473         // grouping-V/container-grouping-V
 474         assertNotNull(containerGroupingV);
 475         assertFalse(containerGroupingV.isAddedByUses());
 476         SchemaPath expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V");
 477         assertEquals(expectedPath, containerGroupingV.getPath());
 478         childNodes = containerGroupingV.getChildNodes();
 479         assertEquals(2, childNodes.size());
 480         for (final DataSchemaNode childNode : childNodes) {
 481             TestUtils.checkIsAddedByUses(childNode, true);
 482         }
 483
 484         // grouping-V/container-grouping-V/leaf-grouping-X
 485         final LeafSchemaNode leafXinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
 486                 testModule.getQNameModule(), "leaf-grouping-X"));
 487         assertNotNull(leafXinContainerV);
 488         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V",
 489             "leaf-grouping-X");
 490         assertEquals(expectedPath, leafXinContainerV.getPath());
 491         // grouping-V/container-grouping-V/leaf-grouping-Y
 492         final LeafSchemaNode leafYinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
 493                 testModule.getQNameModule(), "leaf-grouping-Y"));
 494         assertNotNull(leafYinContainerV);
 495         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V",
 496             "leaf-grouping-Y");
 497         assertEquals(expectedPath, leafYinContainerV.getPath());
 498
 499         // grouping-X
 500         childNodes = gx.getChildNodes();
 501         assertEquals(2, childNodes.size());
 502
 503         // grouping-X/leaf-grouping-X
 504         final LeafSchemaNode leafXinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
 505                 testModule.getQNameModule(), "leaf-grouping-X"));
 506         assertNotNull(leafXinGX);
 507         assertFalse(leafXinGX.isAddedByUses());
 508         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-X", "leaf-grouping-X");
 509         assertEquals(expectedPath, leafXinGX.getPath());
 510
 511         // grouping-X/leaf-grouping-Y
 512         final LeafSchemaNode leafYinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
 513                 testModule.getQNameModule(), "leaf-grouping-Y"));
 514         assertNotNull(leafYinGX);
 515         assertTrue(leafYinGX.isAddedByUses());
 516         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-X", "leaf-grouping-Y");
 517         assertEquals(expectedPath, leafYinGX.getPath());
 518
 519         // grouping-Y
 520         childNodes = gy.getChildNodes();
 521         assertEquals(1, childNodes.size());
 522
 523         // grouping-Y/leaf-grouping-Y
 524         final LeafSchemaNode leafYinGY = (LeafSchemaNode) gy.getDataChildByName(QName.create(
 525                 testModule.getQNameModule(), "leaf-grouping-Y"));
 526         assertNotNull(leafYinGY);
 527         assertFalse(leafYinGY.isAddedByUses());
 528         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-Y", "leaf-grouping-Y");
 529         assertEquals(expectedPath, leafYinGY.getPath());
 530
 531         // grouping-Z
 532         childNodes = gz.getChildNodes();
 533         assertEquals(1, childNodes.size());
 534
 535         // grouping-Z/leaf-grouping-Z
 536         final LeafSchemaNode leafZinGZ = (LeafSchemaNode) gz.getDataChildByName(QName.create(
 537                 testModule.getQNameModule(), "leaf-grouping-Z"));
 538         assertNotNull(leafZinGZ);
 539         assertFalse(leafZinGZ.isAddedByUses());
 540         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-Z", "leaf-grouping-Z");
 541         assertEquals(expectedPath, leafZinGZ.getPath());
 542
 543         // grouping-ZZ
 544         childNodes = gzz.getChildNodes();
 545         assertEquals(1, childNodes.size());
 546
 547         // grouping-ZZ/leaf-grouping-ZZ
 548         final LeafSchemaNode leafZZinGZZ = (LeafSchemaNode) gzz.getDataChildByName(QName.create(
 549                 testModule.getQNameModule(), "leaf-grouping-ZZ"));
 550         assertNotNull(leafZZinGZZ);
 551         assertFalse(leafZZinGZZ.isAddedByUses());
 552         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-ZZ", "leaf-grouping-ZZ");
 553         assertEquals(expectedPath, leafZZinGZZ.getPath());
 554
 555         // TEST getOriginal from grouping-U
 556         assertEquals(
 557                 gv.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-V")),
 558                 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
 559                         testModule.getQNameModule(), "leaf-grouping-V"))));
 560         containerGroupingV = (ContainerSchemaNode) gu.getDataChildByName(QName.create(testModule.getQNameModule(),
 561                 "container-grouping-V"));
 562         assertEquals(gv.getDataChildByName(QName.create(testModule.getQNameModule(), "container-grouping-V")),
 563                 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV));
 564         assertEquals(
 565                 gx.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-X")),
 566                 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
 567                         testModule.getQNameModule(), "leaf-grouping-X"))));
 568         assertEquals(
 569                 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
 570                 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
 571                         testModule.getQNameModule(), "leaf-grouping-Y"))));
 572
 573         assertEquals(
 574                 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
 575                 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
 576                         testModule.getQNameModule(), "leaf-grouping-Z"))));
 577         assertEquals(
 578                 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
 579                 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
 580                         testModule.getQNameModule(), "leaf-grouping-ZZ"))));
 581
 582         // TEST getOriginal from grouping-V
 583         assertEquals(
 584                 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
 585                 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
 586                         testModule.getQNameModule(), "leaf-grouping-Z"))));
 587         assertEquals(
 588                 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
 589                 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
 590                         testModule.getQNameModule(), "leaf-grouping-ZZ"))));
 591
 592         // TEST getOriginal from grouping-X
 593         assertEquals(
 594                 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
 595                 SchemaNodeUtils.getRootOriginalIfPossible(gx.getDataChildByName(QName.create(
 596                         testModule.getQNameModule(), "leaf-grouping-Y"))));
 597     }
 598
 599     @Test
 600     public void testAddedByUsesLeafTypeQName() throws Exception {
 601         final SchemaContext loadModules = TestUtils.loadModules(getClass().getResource("/added-by-uses-leaf-test")
 602                 .toURI());
 603         assertEquals(2, loadModules.getModules().size());
 604         foo = TestUtils.findModule(loadModules, "foo").get();
 605         final Module imp = TestUtils.findModule(loadModules, "import-module").get();
 606
 607         final LeafSchemaNode leaf = (LeafSchemaNode) ((ContainerSchemaNode) foo.getDataChildByName(QName.create(
 608                 foo.getQNameModule(), "my-container")))
 609                 .getDataChildByName(QName.create(foo.getQNameModule(), "my-leaf"));
 610
 611         TypeDefinition<?> impType = null;
 612         final Set<TypeDefinition<?>> typeDefinitions = imp.getTypeDefinitions();
 613         for (final TypeDefinition<?> typeDefinition : typeDefinitions) {
 614             if (typeDefinition.getQName().getLocalName().equals("imp-type")) {
 615                 impType = typeDefinition;
 616                 break;
 617             }
 618         }
 619
 620         assertNotNull(impType);
 621         assertEquals(leaf.getType().getQName(), impType.getQName());
 622     }
 623 }