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