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