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