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