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             }
 427         }
 428         assertNotNull(gu);
 429         assertNotNull(gv);
 430         assertNotNull(gx);
 431         assertNotNull(gy);
 432         assertNotNull(gz);
 433         assertNotNull(gzz);
 434
 435         final QNameModule expectedModule = QNameModule.create(URI.create("urn:grouping:cascade-uses"),
 436             Revision.valueOf("2013-07-18"));
 437         SchemaPath expectedPath;
 438
 439         // grouping-U
 440         Collection<DataSchemaNode> childNodes = gu.getChildNodes();
 441         assertEquals(7, childNodes.size());
 442
 443         final LeafSchemaNode leafGroupingU = (LeafSchemaNode) gu.getDataChildByName(QName.create(
 444                 testModule.getQNameModule(), "leaf-grouping-U"));
 445         assertNotNull(leafGroupingU);
 446         assertFalse(leafGroupingU.isAddedByUses());
 447         assertFalse(SchemaNodeUtils.getOriginalIfPossible(leafGroupingU).isPresent());
 448
 449         for (final DataSchemaNode childNode : childNodes) {
 450             if (!childNode.getQName().equals(leafGroupingU.getQName())) {
 451                 TestUtils.checkIsAddedByUses(childNode, true);
 452             }
 453         }
 454
 455         // grouping-V
 456         childNodes = gv.getChildNodes();
 457         assertEquals(4, childNodes.size());
 458         LeafSchemaNode leafGroupingV = null;
 459         ContainerSchemaNode containerGroupingV = null;
 460         for (final DataSchemaNode childNode : childNodes) {
 461             if ("leaf-grouping-V".equals(childNode.getQName().getLocalName())) {
 462                 leafGroupingV = (LeafSchemaNode) childNode;
 463             } else if ("container-grouping-V".equals(childNode.getQName().getLocalName())) {
 464                 containerGroupingV = (ContainerSchemaNode) childNode;
 465             } else {
 466                 TestUtils.checkIsAddedByUses(childNode, true);
 467             }
 468         }
 469         assertNotNull(leafGroupingV);
 470         assertFalse(leafGroupingV.isAddedByUses());
 471
 472         // grouping-V/container-grouping-V
 473         assertNotNull(containerGroupingV);
 474         assertFalse(containerGroupingV.isAddedByUses());
 475         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V");
 476         assertEquals(expectedPath, containerGroupingV.getPath());
 477         childNodes = containerGroupingV.getChildNodes();
 478         assertEquals(2, childNodes.size());
 479         for (final DataSchemaNode childNode : childNodes) {
 480             TestUtils.checkIsAddedByUses(childNode, true);
 481         }
 482
 483         // grouping-V/container-grouping-V/leaf-grouping-X
 484         final LeafSchemaNode leafXinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
 485                 testModule.getQNameModule(), "leaf-grouping-X"));
 486         assertNotNull(leafXinContainerV);
 487         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V",
 488             "leaf-grouping-X");
 489         assertEquals(expectedPath, leafXinContainerV.getPath());
 490         // grouping-V/container-grouping-V/leaf-grouping-Y
 491         final LeafSchemaNode leafYinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(QName.create(
 492                 testModule.getQNameModule(), "leaf-grouping-Y"));
 493         assertNotNull(leafYinContainerV);
 494         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-V", "container-grouping-V",
 495             "leaf-grouping-Y");
 496         assertEquals(expectedPath, leafYinContainerV.getPath());
 497
 498         // grouping-X
 499         childNodes = gx.getChildNodes();
 500         assertEquals(2, childNodes.size());
 501
 502         // grouping-X/leaf-grouping-X
 503         final LeafSchemaNode leafXinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
 504                 testModule.getQNameModule(), "leaf-grouping-X"));
 505         assertNotNull(leafXinGX);
 506         assertFalse(leafXinGX.isAddedByUses());
 507         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-X", "leaf-grouping-X");
 508         assertEquals(expectedPath, leafXinGX.getPath());
 509
 510         // grouping-X/leaf-grouping-Y
 511         final LeafSchemaNode leafYinGX = (LeafSchemaNode) gx.getDataChildByName(QName.create(
 512                 testModule.getQNameModule(), "leaf-grouping-Y"));
 513         assertNotNull(leafYinGX);
 514         assertTrue(leafYinGX.isAddedByUses());
 515         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-X", "leaf-grouping-Y");
 516         assertEquals(expectedPath, leafYinGX.getPath());
 517
 518         // grouping-Y
 519         childNodes = gy.getChildNodes();
 520         assertEquals(1, childNodes.size());
 521
 522         // grouping-Y/leaf-grouping-Y
 523         final LeafSchemaNode leafYinGY = (LeafSchemaNode) gy.getDataChildByName(QName.create(
 524                 testModule.getQNameModule(), "leaf-grouping-Y"));
 525         assertNotNull(leafYinGY);
 526         assertFalse(leafYinGY.isAddedByUses());
 527         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-Y", "leaf-grouping-Y");
 528         assertEquals(expectedPath, leafYinGY.getPath());
 529
 530         // grouping-Z
 531         childNodes = gz.getChildNodes();
 532         assertEquals(1, childNodes.size());
 533
 534         // grouping-Z/leaf-grouping-Z
 535         final LeafSchemaNode leafZinGZ = (LeafSchemaNode) gz.getDataChildByName(QName.create(
 536                 testModule.getQNameModule(), "leaf-grouping-Z"));
 537         assertNotNull(leafZinGZ);
 538         assertFalse(leafZinGZ.isAddedByUses());
 539         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-Z", "leaf-grouping-Z");
 540         assertEquals(expectedPath, leafZinGZ.getPath());
 541
 542         // grouping-ZZ
 543         childNodes = gzz.getChildNodes();
 544         assertEquals(1, childNodes.size());
 545
 546         // grouping-ZZ/leaf-grouping-ZZ
 547         final LeafSchemaNode leafZZinGZZ = (LeafSchemaNode) gzz.getDataChildByName(QName.create(
 548                 testModule.getQNameModule(), "leaf-grouping-ZZ"));
 549         assertNotNull(leafZZinGZZ);
 550         assertFalse(leafZZinGZZ.isAddedByUses());
 551         expectedPath = TestUtils.createPath(true, expectedModule, "grouping-ZZ", "leaf-grouping-ZZ");
 552         assertEquals(expectedPath, leafZZinGZZ.getPath());
 553
 554         // TEST getOriginal from grouping-U
 555         assertEquals(
 556                 gv.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-V")),
 557                 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
 558                         testModule.getQNameModule(), "leaf-grouping-V"))));
 559         containerGroupingV = (ContainerSchemaNode) gu.getDataChildByName(QName.create(testModule.getQNameModule(),
 560                 "container-grouping-V"));
 561         assertEquals(gv.getDataChildByName(QName.create(testModule.getQNameModule(), "container-grouping-V")),
 562                 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV));
 563         assertEquals(
 564                 gx.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-X")),
 565                 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
 566                         testModule.getQNameModule(), "leaf-grouping-X"))));
 567         assertEquals(
 568                 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
 569                 SchemaNodeUtils.getRootOriginalIfPossible(containerGroupingV.getDataChildByName(QName.create(
 570                         testModule.getQNameModule(), "leaf-grouping-Y"))));
 571
 572         assertEquals(
 573                 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
 574                 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
 575                         testModule.getQNameModule(), "leaf-grouping-Z"))));
 576         assertEquals(
 577                 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
 578                 SchemaNodeUtils.getRootOriginalIfPossible(gu.getDataChildByName(QName.create(
 579                         testModule.getQNameModule(), "leaf-grouping-ZZ"))));
 580
 581         // TEST getOriginal from grouping-V
 582         assertEquals(
 583                 gz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Z")),
 584                 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
 585                         testModule.getQNameModule(), "leaf-grouping-Z"))));
 586         assertEquals(
 587                 gzz.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-ZZ")),
 588                 SchemaNodeUtils.getRootOriginalIfPossible(gv.getDataChildByName(QName.create(
 589                         testModule.getQNameModule(), "leaf-grouping-ZZ"))));
 590
 591         // TEST getOriginal from grouping-X
 592         assertEquals(
 593                 gy.getDataChildByName(QName.create(testModule.getQNameModule(), "leaf-grouping-Y")),
 594                 SchemaNodeUtils.getRootOriginalIfPossible(gx.getDataChildByName(QName.create(
 595                         testModule.getQNameModule(), "leaf-grouping-Y"))));
 596     }
 597
 598     @Test
 599     public void testAddedByUsesLeafTypeQName() throws Exception {
 600         final SchemaContext loadModules = TestUtils.loadModules(getClass().getResource("/added-by-uses-leaf-test")
 601                 .toURI());
 602         assertEquals(2, loadModules.getModules().size());
 603         foo = TestUtils.findModule(loadModules, "foo").get();
 604         final Module imp = TestUtils.findModule(loadModules, "import-module").get();
 605
 606         final LeafSchemaNode leaf = (LeafSchemaNode) ((ContainerSchemaNode) foo.getDataChildByName(QName.create(
 607                 foo.getQNameModule(), "my-container")))
 608                 .getDataChildByName(QName.create(foo.getQNameModule(), "my-leaf"));
 609
 610         TypeDefinition<?> impType = null;
 611         final Set<TypeDefinition<?>> typeDefinitions = imp.getTypeDefinitions();
 612         for (final TypeDefinition<?> typeDefinition : typeDefinitions) {
 613             if (typeDefinition.getQName().getLocalName().equals("imp-type")) {
 614                 impType = typeDefinition;
 615                 break;
 616             }
 617         }
 618
 619         assertNotNull(impType);
 620         assertEquals(leaf.getType().getQName(), impType.getQName());
 621     }
 622 }