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

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