yang/yang-model-util-ut/src/test/java/org/opendaylight/yangtools/yang/model/util/ut/SchemaContextUtilTest.java

   1 /*
   2  * Copyright (c) 2014 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.model.util.ut;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertNull;
  13
  14 import org.junit.BeforeClass;
  15 import org.junit.Test;
  16 import org.opendaylight.yangtools.yang.common.QName;
  17 import org.opendaylight.yangtools.yang.common.Revision;
  18 import org.opendaylight.yangtools.yang.common.XMLNamespace;
  19 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  20 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  21 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  22 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  23 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  24 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  25 import org.opendaylight.yangtools.yang.model.api.Module;
  26 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  27 import org.opendaylight.yangtools.yang.model.api.PathExpression;
  28 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  29 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  30 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  31 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  32 import org.opendaylight.yangtools.yang.model.util.PathExpressionImpl;
  33 import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
  34 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  35
  36 public class SchemaContextUtilTest {
  37     private static SchemaContext context;
  38     private static Module myModule;
  39
  40     @BeforeClass
  41     public static void beforeClass() {
  42         context = YangParserTestUtils.parseYangResourceDirectory("/schema-context-util");
  43         myModule = context.findModule(XMLNamespace.of("uri:my-module"), Revision.of("2014-10-07")).get();
  44     }
  45
  46     @Test
  47     public void findNodeInSchemaContextTest() {
  48         SchemaNode testNode = ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(
  49                 myModule.getQNameModule(), "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(),
  50                 "my-leaf-in-container"));
  51
  52         SchemaPath path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
  53                 QName.create(myModule.getQNameModule(), "my-leaf-in-container"));
  54         SchemaNode foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
  55
  56         assertEquals(testNode, foundNode);
  57
  58         RpcDefinition rpc = getRpcByName(myModule, "my-rpc");
  59         testNode = rpc.getInput().getDataChildByName(QName.create(myModule.getQNameModule(), "my-input-leaf"));
  60
  61         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
  62                 QName.create(myModule.getQNameModule(), "input"),
  63                 QName.create(myModule.getQNameModule(), "my-input-leaf"));
  64
  65         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
  66
  67         assertEquals(testNode, foundNode);
  68
  69         rpc = getRpcByName(myModule, "my-rpc");
  70         testNode = rpc.getOutput().getDataChildByName(QName.create(myModule.getQNameModule(), "my-output-leaf"));
  71
  72         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
  73                 QName.create(myModule.getQNameModule(), "output"),
  74                 QName.create(myModule.getQNameModule(), "my-output-leaf"));
  75
  76         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
  77
  78         assertEquals(testNode, foundNode);
  79
  80         final NotificationDefinition notification = myModule.getNotifications().iterator().next();
  81         testNode = notification.getDataChildByName(QName.create(myModule.getQNameModule(), "my-notification-leaf"));
  82
  83         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-notification"),
  84                 QName.create(myModule.getQNameModule(), "my-notification-leaf"));
  85
  86         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
  87
  88         assertEquals(testNode, foundNode);
  89
  90         final GroupingDefinition grouping = getGroupingByName(myModule, "my-grouping");
  91         testNode = ((ContainerSchemaNode) grouping.getDataChildByName(QName.create(myModule.getQNameModule(),
  92                 "my-container-in-grouping"))).getDataChildByName(QName.create(myModule.getQNameModule(),
  93                 "my-leaf-in-grouping"));
  94
  95         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-grouping"),
  96                 QName.create(myModule.getQNameModule(), "my-container-in-grouping"),
  97                 QName.create(myModule.getQNameModule(), "my-leaf-in-grouping"));
  98
  99         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 100
 101         assertEquals(testNode, foundNode);
 102
 103         testNode = ((ChoiceSchemaNode) myModule
 104                 .getDataChildByName(QName.create(myModule.getQNameModule(), "my-choice")))
 105                 .findCaseNodes("one").iterator().next()
 106                 .getDataChildByName(QName.create(myModule.getQNameModule(), "my-choice-leaf-one"));
 107
 108         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-choice"),
 109                 QName.create(myModule.getQNameModule(), "one"),
 110                 QName.create(myModule.getQNameModule(), "my-choice-leaf-one"));
 111         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 112
 113         assertEquals(testNode, foundNode);
 114
 115         ListSchemaNode listNode = (ListSchemaNode) ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(
 116                 myModule.getQNameModule(), "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(),
 117                 "my-list"));
 118
 119         testNode = listNode.getDataChildByName(QName.create(myModule.getQNameModule(), "my-leaf-in-list"));
 120
 121         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 122                 QName.create(myModule.getQNameModule(), "my-list"),
 123                 QName.create(myModule.getQNameModule(), "my-leaf-in-list"));
 124         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 125
 126         assertEquals(testNode, foundNode);
 127
 128         listNode = (ListSchemaNode) ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(
 129                 myModule.getQNameModule(), "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(),
 130                 "my-list"));
 131
 132         testNode = listNode.getDataChildByName(QName.create(myModule.getQNameModule(), "my-leaf-list-in-list"));
 133
 134         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 135                 QName.create(myModule.getQNameModule(), "my-list"),
 136                 QName.create(myModule.getQNameModule(), "my-leaf-list-in-list"));
 137         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 138
 139         assertEquals(testNode, foundNode);
 140     }
 141
 142     @Test
 143     public void findNodeInSchemaContextTest2() {
 144         SchemaNode testNode = ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(
 145                 myModule.getQNameModule(), "my-container"))).dataChildByName(QName.create(myModule.getQNameModule(),
 146                 "my-leaf-not-in-container"));
 147         assertNull(testNode);
 148
 149         SchemaPath path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 150                 QName.create(myModule.getQNameModule(), "my-leaf-not-in-container"));
 151         SchemaNode foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 152         assertNull(foundNode);
 153
 154         final RpcDefinition rpc = getRpcByName(myModule, "my-rpc");
 155         testNode = rpc.getInput().dataChildByName(QName.create(myModule.getQNameModule(), "no-input-leaf"));
 156         assertNull(testNode);
 157
 158         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
 159                 QName.create(myModule.getQNameModule(), "input"),
 160                 QName.create(myModule.getQNameModule(), "no-input-leaf"));
 161
 162         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 163         assertNull(foundNode);
 164
 165         final NotificationDefinition notification = myModule.getNotifications().iterator().next();
 166         testNode = notification.dataChildByName(QName.create(myModule.getQNameModule(), "no-notification-leaf"));
 167         assertNull(testNode);
 168
 169         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-notification"),
 170                 QName.create(myModule.getQNameModule(), "no-notification-leaf"));
 171
 172         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 173         assertNull(foundNode);
 174
 175         final GroupingDefinition grouping = getGroupingByName(myModule, "my-grouping");
 176         testNode = ((ContainerSchemaNode) grouping.getDataChildByName(QName.create(myModule.getQNameModule(),
 177                 "my-container-in-grouping"))).dataChildByName(QName.create(myModule.getQNameModule(),
 178                 "no-leaf-in-grouping"));
 179         assertNull(testNode);
 180
 181         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-grouping"),
 182                 QName.create(myModule.getQNameModule(), "my-container-in-grouping"),
 183                 QName.create(myModule.getQNameModule(), "no-leaf-in-grouping"));
 184
 185         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 186         assertNull(foundNode);
 187
 188         testNode = ((ChoiceSchemaNode) myModule
 189                 .getDataChildByName(QName.create(myModule.getQNameModule(), "my-choice")))
 190                 .findCaseNodes("one").iterator().next()
 191                 .dataChildByName(QName.create(myModule.getQNameModule(), "no-choice-leaf"));
 192         assertNull(testNode);
 193
 194         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-choice"),
 195                 QName.create(myModule.getQNameModule(), "one"),
 196                 QName.create(myModule.getQNameModule(), "no-choice-leaf"));
 197         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 198         assertNull(foundNode);
 199
 200         ListSchemaNode listNode = (ListSchemaNode) ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(
 201                 myModule.getQNameModule(), "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(),
 202                 "my-list"));
 203
 204         testNode = listNode.dataChildByName(QName.create(myModule.getQNameModule(), "no-leaf-in-list"));
 205         assertNull(testNode);
 206
 207         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 208                 QName.create(myModule.getQNameModule(), "my-list"),
 209                 QName.create(myModule.getQNameModule(), "no-leaf-in-list"));
 210         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 211         assertNull(foundNode);
 212
 213         listNode = (ListSchemaNode) ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(
 214                 myModule.getQNameModule(), "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(),
 215                 "my-list"));
 216
 217         testNode = listNode.dataChildByName(QName.create(myModule.getQNameModule(), "no-leaf-list-in-list"));
 218         assertNull(testNode);
 219
 220         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 221                 QName.create(myModule.getQNameModule(), "my-list"),
 222                 QName.create(myModule.getQNameModule(), "no-leaf-list-in-list"));
 223         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 224         assertNull(foundNode);
 225     }
 226
 227     @Test
 228     public void findNodeInSchemaContextTest3() {
 229         SchemaNode testNode = myModule.getDataChildByName(QName.create(myModule.getQNameModule(), "my-container"));
 230
 231         SchemaPath path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"));
 232         SchemaNode foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 233         assertNotNull(foundNode);
 234         assertEquals(testNode, foundNode);
 235
 236         testNode = getRpcByName(myModule, "my-rpc");
 237         assertNotNull(testNode);
 238
 239         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"));
 240         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 241         assertNotNull(foundNode);
 242         assertEquals(testNode, foundNode);
 243
 244         testNode = myModule.getNotifications().iterator().next();
 245
 246         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-notification"));
 247         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 248         assertNotNull(foundNode);
 249         assertEquals(testNode, foundNode);
 250
 251         testNode = getGroupingByName(myModule, "my-grouping");
 252         assertNotNull(testNode);
 253
 254         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-grouping"));
 255         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 256         assertNotNull(foundNode);
 257         assertEquals(testNode, foundNode);
 258
 259         testNode = myModule.getDataChildByName(QName.create(myModule.getQNameModule(), "my-choice"));
 260
 261         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-choice"));
 262         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 263         assertNotNull(foundNode);
 264         assertEquals(testNode, foundNode);
 265
 266         testNode = ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(myModule.getQNameModule(),
 267                 "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(), "my-list"));
 268
 269         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 270                 QName.create(myModule.getQNameModule(), "my-list"));
 271         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 272         assertNotNull(foundNode);
 273         assertEquals(testNode, foundNode);
 274     }
 275
 276     @Test
 277     public void findParentModuleTest() {
 278         final DataSchemaNode node = myModule.getDataChildByName(QName.create(myModule.getQNameModule(),
 279             "my-container"));
 280
 281         final Module foundModule = SchemaContextUtil.findParentModule(context, node);
 282
 283         assertEquals(myModule, foundModule);
 284     }
 285
 286     @Test
 287     public void findDataSchemaNodeTest() {
 288         final Module importedModule = context.findModule(XMLNamespace.of("uri:imported-module"),
 289             Revision.of("2014-10-07")).get();
 290
 291         final SchemaNode testNode = ((ContainerSchemaNode) importedModule.getDataChildByName(QName.create(
 292                 importedModule.getQNameModule(), "my-imported-container"))).getDataChildByName(QName.create(
 293                 importedModule.getQNameModule(), "my-imported-leaf"));
 294
 295         final PathExpression xpath = new PathExpressionImpl("imp:my-imported-container/imp:my-imported-leaf", true);
 296
 297         final SchemaNode foundNode = SchemaContextUtil.findDataSchemaNode(context, myModule, xpath);
 298         assertNotNull(foundNode);
 299         assertEquals(testNode, foundNode);
 300     }
 301
 302     @Test
 303     public void findDataSchemaNodeTest2() {
 304         final GroupingDefinition grouping = getGroupingByName(myModule, "my-grouping");
 305         final SchemaNode testNode = grouping.getDataChildByName(QName.create(myModule.getQNameModule(),
 306                 "my-leaf-in-gouping2"));
 307
 308         final PathExpression xpath = new PathExpressionImpl("my:my-grouping/my:my-leaf-in-gouping2", true);
 309
 310         final SchemaNode foundNode = SchemaContextUtil.findDataSchemaNode(context, myModule, xpath);
 311
 312         assertNotNull(foundNode);
 313         assertEquals(testNode, foundNode);
 314     }
 315
 316     @Test
 317     public void findNodeInSchemaContextGroupingsTest() {
 318         // find grouping in container
 319         DataNodeContainer dataContainer = (DataNodeContainer) myModule.getDataChildByName(QName.create(
 320                 myModule.getQNameModule(), "my-container"));
 321         SchemaNode testNode = getGroupingByName(dataContainer, "my-grouping-in-container");
 322         assertNotNull(testNode);
 323
 324         SchemaPath path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 325                 QName.create(myModule.getQNameModule(), "my-grouping-in-container"));
 326         SchemaNode foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 327
 328         assertNotNull(foundNode);
 329         assertEquals(testNode, foundNode);
 330
 331         testNode = ((GroupingDefinition) testNode).getDataChildByName(QName.create(myModule.getQNameModule(),
 332                 "my-leaf-in-grouping-in-container"));
 333         path = path.createChild(QName.create(myModule.getQNameModule(), "my-leaf-in-grouping-in-container"));
 334
 335         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 336         assertNotNull(foundNode);
 337         assertEquals(testNode, foundNode);
 338
 339         // find grouping in list
 340         dataContainer = (DataNodeContainer) ((DataNodeContainer) myModule.getDataChildByName(QName.create(
 341                 myModule.getQNameModule(), "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(),
 342                 "my-list"));
 343         testNode = getGroupingByName(dataContainer, "my-grouping-in-list");
 344         assertNotNull(testNode);
 345
 346         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 347                 QName.create(myModule.getQNameModule(), "my-list"),
 348                 QName.create(myModule.getQNameModule(), "my-grouping-in-list"));
 349         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 350         assertNotNull(foundNode);
 351         assertEquals(testNode, foundNode);
 352
 353         testNode = ((GroupingDefinition) testNode).getDataChildByName(QName.create(myModule.getQNameModule(),
 354                 "my-leaf-in-grouping-in-list"));
 355         path = path.createChild(QName.create(myModule.getQNameModule(), "my-leaf-in-grouping-in-list"));
 356
 357         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 358         assertNotNull(foundNode);
 359         assertEquals(testNode, foundNode);
 360
 361         // find grouping in grouping
 362         dataContainer = getGroupingByName(myModule, "my-grouping");
 363         testNode = getGroupingByName(dataContainer, "my-grouping-in-grouping");
 364         assertNotNull(testNode);
 365
 366         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-grouping"),
 367                 QName.create(myModule.getQNameModule(), "my-grouping-in-grouping"));
 368         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 369         assertNotNull(foundNode);
 370         assertEquals(testNode, foundNode);
 371
 372         testNode = ((GroupingDefinition) testNode).getDataChildByName(QName.create(myModule.getQNameModule(),
 373                 "my-leaf-in-grouping-in-grouping"));
 374         path = path.createChild(QName.create(myModule.getQNameModule(), "my-leaf-in-grouping-in-grouping"));
 375
 376         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 377         assertNotNull(foundNode);
 378         assertEquals(testNode, foundNode);
 379
 380         // find grouping in rpc
 381         final RpcDefinition rpc = getRpcByName(myModule, "my-rpc");
 382         for (final GroupingDefinition grouping : rpc.getGroupings()) {
 383             if (grouping.getQName().getLocalName().equals("my-grouping-in-rpc")) {
 384                 testNode = grouping;
 385             }
 386         }
 387         assertNotNull(testNode);
 388
 389         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
 390                 QName.create(myModule.getQNameModule(), "my-grouping-in-rpc"));
 391         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 392         assertNotNull(foundNode);
 393         assertEquals(testNode, foundNode);
 394
 395         testNode = ((GroupingDefinition) testNode).getDataChildByName(QName.create(myModule.getQNameModule(),
 396                 "my-leaf-in-grouping-in-rpc"));
 397         path = path.createChild(QName.create(myModule.getQNameModule(), "my-leaf-in-grouping-in-rpc"));
 398
 399         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 400         assertNotNull(foundNode);
 401         assertEquals(testNode, foundNode);
 402
 403         // find grouping in output
 404         dataContainer = getRpcByName(myModule, "my-rpc").getOutput();
 405         testNode = getGroupingByName(dataContainer, "my-grouping-in-output");
 406         assertNotNull(testNode);
 407
 408         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
 409                 QName.create(myModule.getQNameModule(), "output"),
 410                 QName.create(myModule.getQNameModule(), "my-grouping-in-output"));
 411         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 412         assertNotNull(foundNode);
 413         assertEquals(testNode, foundNode);
 414
 415         testNode = ((GroupingDefinition) testNode).getDataChildByName(QName.create(myModule.getQNameModule(),
 416                 "my-leaf-in-grouping-in-output"));
 417         path = path.createChild(QName.create(myModule.getQNameModule(), "my-leaf-in-grouping-in-output"));
 418
 419         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 420         assertNotNull(foundNode);
 421         assertEquals(testNode, foundNode);
 422
 423         // find grouping in input
 424         dataContainer = getRpcByName(myModule, "my-rpc").getInput();
 425         testNode = getGroupingByName(dataContainer, "my-grouping-in-input");
 426         assertNotNull(testNode);
 427
 428         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
 429                 QName.create(myModule.getQNameModule(), "input"),
 430                 QName.create(myModule.getQNameModule(), "my-grouping-in-input"));
 431         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 432         assertNotNull(foundNode);
 433         assertEquals(testNode, foundNode);
 434
 435         testNode = ((GroupingDefinition) testNode).getDataChildByName(QName.create(myModule.getQNameModule(),
 436                 "my-leaf-in-grouping-in-input"));
 437         path = path.createChild(QName.create(myModule.getQNameModule(), "my-leaf-in-grouping-in-input"));
 438
 439         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 440         assertNotNull(foundNode);
 441         assertEquals(testNode, foundNode);
 442
 443         // find grouping in notification
 444         dataContainer = getNotificationByName(myModule, "my-notification");
 445         testNode = getGroupingByName(dataContainer, "my-grouping-in-notification");
 446         assertNotNull(testNode);
 447
 448         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-notification"),
 449                 QName.create(myModule.getQNameModule(), "my-grouping-in-notification"));
 450         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 451         assertNotNull(foundNode);
 452         assertEquals(testNode, foundNode);
 453
 454         testNode = ((GroupingDefinition) testNode).getDataChildByName(QName.create(myModule.getQNameModule(),
 455                 "my-leaf-in-grouping-in-notification"));
 456         path = path.createChild(QName.create(myModule.getQNameModule(), "my-leaf-in-grouping-in-notification"));
 457
 458         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 459         assertNotNull(foundNode);
 460         assertEquals(testNode, foundNode);
 461
 462         // find grouping in case
 463         dataContainer = (DataNodeContainer) ((ChoiceSchemaNode) myModule.getDataChildByName(
 464             QName.create(myModule.getQNameModule(), "my-choice")))
 465                 .findCaseNodes("one").iterator().next()
 466                 .getDataChildByName(QName.create(myModule.getQNameModule(), "my-container-in-case"));
 467         testNode = getGroupingByName(dataContainer, "my-grouping-in-case");
 468         assertNotNull(testNode);
 469
 470         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-choice"),
 471                 QName.create(myModule.getQNameModule(), "one"),
 472                 QName.create(myModule.getQNameModule(), "my-container-in-case"),
 473                 QName.create(myModule.getQNameModule(), "my-grouping-in-case"));
 474         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 475         assertNotNull(foundNode);
 476         assertEquals(testNode, foundNode);
 477
 478         testNode = ((GroupingDefinition) testNode).getDataChildByName(QName.create(myModule.getQNameModule(),
 479                 "my-leaf-in-grouping-in-case"));
 480         path = path.createChild(QName.create(myModule.getQNameModule(), "my-leaf-in-grouping-in-case"));
 481
 482         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 483         assertNotNull(foundNode);
 484         assertEquals(testNode, foundNode);
 485     }
 486
 487     @Test
 488     public void findNodeInSchemaContextGroupingsTest2() {
 489         // find grouping in container
 490         DataNodeContainer dataContainer = (DataNodeContainer) myModule.getDataChildByName(QName.create(
 491                 myModule.getQNameModule(), "my-container"));
 492         SchemaNode testNode = getGroupingByName(dataContainer, "my-grouping-in-container2");
 493         assertNull(testNode);
 494
 495         SchemaPath path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 496                 QName.create(myModule.getQNameModule(), "my-grouping-in-container2"));
 497         SchemaNode foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 498         assertNull(foundNode);
 499
 500         // find grouping in list
 501         dataContainer = (DataNodeContainer) ((DataNodeContainer) myModule.getDataChildByName(QName.create(
 502                 myModule.getQNameModule(), "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(),
 503                 "my-list"));
 504         testNode = getGroupingByName(dataContainer, "my-grouping-in-list2");
 505         assertNull(testNode);
 506
 507         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 508                 QName.create(myModule.getQNameModule(), "my-list"),
 509                 QName.create(myModule.getQNameModule(), "my-grouping-in-list2"));
 510         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 511         assertNull(foundNode);
 512
 513         // find grouping in grouping
 514         dataContainer = getGroupingByName(myModule, "my-grouping");
 515         testNode = getGroupingByName(dataContainer, "my-grouping-in-grouping2");
 516         assertNull(testNode);
 517
 518         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-grouping"),
 519                 QName.create(myModule.getQNameModule(), "my-grouping-in-grouping2"));
 520         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 521         assertNull(foundNode);
 522
 523         // find grouping in rpc
 524         final RpcDefinition rpc = getRpcByName(myModule, "my-rpc");
 525         for (final GroupingDefinition grouping : rpc.getGroupings()) {
 526             if (grouping.getQName().getLocalName().equals("my-grouping-in-rpc2")) {
 527                 testNode = grouping;
 528             }
 529         }
 530         assertNull(testNode);
 531
 532         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
 533                 QName.create(myModule.getQNameModule(), "my-grouping-in-rpc2"));
 534         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 535         assertNull(foundNode);
 536
 537         // find grouping in output
 538         dataContainer = getRpcByName(myModule, "my-rpc").getOutput();
 539         testNode = getGroupingByName(dataContainer, "my-grouping-in-output2");
 540         assertNull(testNode);
 541
 542         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
 543                 QName.create(myModule.getQNameModule(), "output"),
 544                 QName.create(myModule.getQNameModule(), "my-grouping-in-output2"));
 545         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 546         assertNull(foundNode);
 547
 548         // find grouping in input
 549         dataContainer = getRpcByName(myModule, "my-rpc").getInput();
 550         testNode = getGroupingByName(dataContainer, "my-grouping-in-input2");
 551         assertNull(testNode);
 552
 553         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
 554                 QName.create(myModule.getQNameModule(), "input"),
 555                 QName.create(myModule.getQNameModule(), "my-grouping-in-input2"));
 556         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 557         assertNull(foundNode);
 558
 559         // find grouping in notification
 560         dataContainer = getNotificationByName(myModule, "my-notification");
 561         testNode = getGroupingByName(dataContainer, "my-grouping-in-notification2");
 562         assertNull(testNode);
 563
 564         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-notification"),
 565                 QName.create(myModule.getQNameModule(), "my-grouping-in-notification2"));
 566         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 567         assertNull(foundNode);
 568
 569         // find grouping in case
 570         dataContainer = (DataNodeContainer) ((ChoiceSchemaNode) myModule.getDataChildByName(
 571             QName.create(myModule.getQNameModule(), "my-choice")))
 572                 .findCaseNodes("one").iterator().next()
 573                 .getDataChildByName(QName.create(myModule.getQNameModule(), "my-container-in-case"));
 574         testNode = getGroupingByName(dataContainer, "my-grouping-in-case2");
 575         assertNull(testNode);
 576
 577         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-choice"),
 578                 QName.create(myModule.getQNameModule(), "one"),
 579                 QName.create(myModule.getQNameModule(), "my-container-in-case"),
 580                 QName.create(myModule.getQNameModule(), "my-grouping-in-case2"));
 581         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 582         assertNull(foundNode);
 583     }
 584
 585     private static GroupingDefinition getGroupingByName(final DataNodeContainer dataNodeContainer, final String name) {
 586         for (final GroupingDefinition grouping : dataNodeContainer.getGroupings()) {
 587             if (grouping.getQName().getLocalName().equals(name)) {
 588                 return grouping;
 589             }
 590         }
 591         return null;
 592     }
 593
 594     private static RpcDefinition getRpcByName(final Module module, final String name) {
 595         for (final RpcDefinition rpc : module.getRpcs()) {
 596             if (rpc.getQName().getLocalName().equals(name)) {
 597                 return rpc;
 598             }
 599         }
 600         return null;
 601     }
 602
 603     private static NotificationDefinition getNotificationByName(final Module module, final String name) {
 604         for (final NotificationDefinition notification : module.getNotifications()) {
 605             if (notification.getQName().getLocalName().equals(name)) {
 606                 return notification;
 607             }
 608         }
 609         return null;
 610     }
 611
 612     @Test
 613     public void findNodeInSchemaContextTheSameNameOfSiblingsTest() {
 614         final ChoiceSchemaNode choice = (ChoiceSchemaNode) getRpcByName(myModule, "my-name").getInput()
 615                 .getDataChildByName(QName.create(myModule.getQNameModule(), "my-choice"));
 616         final SchemaNode testNode = choice.findCaseNodes("case-two").iterator().next()
 617                 .getDataChildByName(QName.create(myModule.getQNameModule(), "two"));
 618
 619         final SchemaPath path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-name"),
 620                 QName.create(myModule.getQNameModule(), "input"), QName.create(myModule.getQNameModule(), "my-choice"),
 621                 QName.create(myModule.getQNameModule(), "case-two"), QName.create(myModule.getQNameModule(), "two"));
 622         final SchemaNode foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 623         assertNotNull(foundNode);
 624         assertEquals(testNode, foundNode);
 625     }
 626 }