yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/util/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.parser.util;
   9
  10 import org.junit.Test;
  11 import org.mockito.Mock;
  12 import org.mockito.Mockito;
  13 import org.mockito.MockitoAnnotations;
  14 import org.opendaylight.yangtools.yang.common.QName;
  15 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
  16 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  17 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  18 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  19 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  20 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  21 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  22 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  23 import org.opendaylight.yangtools.yang.model.api.Module;
  24 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  25 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
  26 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  27 import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
  28 import org.opendaylight.yangtools.yang.model.util.Int32;
  29 import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
  30 import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
  31 import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
  32
  33 import java.io.File;
  34 import java.io.IOException;
  35 import java.net.URI;
  36 import java.net.URISyntaxException;
  37 import java.text.ParseException;
  38 import java.util.Collections;
  39 import java.util.Set;
  40
  41 import static org.junit.Assert.*;
  42
  43 public class SchemaContextUtilTest {
  44     @Mock
  45     private SchemaContext mockSchemaContext;
  46     @Mock
  47     private Module mockModule;
  48
  49     @Test
  50     public void testFindDummyData() {
  51         MockitoAnnotations.initMocks(this);
  52
  53         QName qName = QName.create("TestQName");
  54         SchemaPath schemaPath = SchemaPath.create(Collections.singletonList(qName), true);
  55         assertEquals("Should be null. Module TestQName not found", null,
  56                 SchemaContextUtil.findDataSchemaNode(mockSchemaContext, schemaPath));
  57
  58         RevisionAwareXPath xPath = new RevisionAwareXPathImpl("/bookstore/book/title", true);
  59         assertEquals("Should be null. Module bookstore not found", null,
  60                 SchemaContextUtil.findDataSchemaNode(mockSchemaContext, mockModule, xPath));
  61
  62         SchemaNode schemaNode = Int32.getInstance();
  63         RevisionAwareXPath xPathRelative = new RevisionAwareXPathImpl("../prefix", false);
  64         assertEquals("Should be null, Module prefix not found", null,
  65                 SchemaContextUtil.findDataSchemaNodeForRelativeXPath(mockSchemaContext, mockModule, schemaNode,
  66                         xPathRelative));
  67
  68         assertEquals("Should be null. Module TestQName not found", null,
  69                 SchemaContextUtil.findNodeInSchemaContext(mockSchemaContext, Collections.singleton(qName)));
  70
  71         assertEquals("Should be null.", null, SchemaContextUtil.findParentModule(mockSchemaContext, schemaNode));
  72     }
  73
  74     @Test
  75     public void findNodeInSchemaContextTest() throws URISyntaxException, IOException, YangSyntaxErrorException,
  76             ParseException {
  77
  78         File resourceFile = new File(getClass().getResource("/schema-context-util-test/my-module.yang").toURI());
  79         File resourceDir = resourceFile.getParentFile();
  80
  81         YangParserImpl parser = YangParserImpl.getInstance();
  82         SchemaContext context = parser.parseFile(resourceFile, resourceDir);
  83
  84         Module myModule = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
  85                 QName.parseRevision("2014-10-07"));
  86
  87         SchemaNode testNode = ((ContainerSchemaNode) myModule.getDataChildByName("my-container"))
  88                 .getDataChildByName("my-leaf-in-container");
  89
  90         SchemaPath path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
  91                 QName.create(myModule.getQNameModule(), "my-leaf-in-container"));
  92         SchemaNode foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
  93
  94         assertNotNull(testNode);
  95         assertNotNull(foundNode);
  96         assertEquals(testNode, foundNode);
  97
  98         Set<RpcDefinition> rpcs = myModule.getRpcs();
  99         RpcDefinition rpc = rpcs.iterator().next();
 100         testNode = rpc.getInput().getDataChildByName("my-input-leaf");
 101
 102         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
 103                 QName.create(myModule.getQNameModule(), "input"),
 104                 QName.create(myModule.getQNameModule(), "my-input-leaf"));
 105
 106         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 107
 108         assertNotNull(testNode);
 109         assertNotNull(foundNode);
 110         assertEquals(testNode, foundNode);
 111
 112         rpc = myModule.getRpcs().iterator().next();
 113         testNode = rpc.getOutput().getDataChildByName("my-output-leaf");
 114
 115         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
 116                 QName.create(myModule.getQNameModule(), "output"),
 117                 QName.create(myModule.getQNameModule(), "my-output-leaf"));
 118
 119         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 120
 121         assertNotNull(testNode);
 122         assertNotNull(foundNode);
 123         assertEquals(testNode, foundNode);
 124
 125         NotificationDefinition notification = myModule.getNotifications().iterator().next();
 126         testNode = notification.getDataChildByName("my-notification-leaf");
 127
 128         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-notification"),
 129                 QName.create(myModule.getQNameModule(), "my-notification-leaf"));
 130
 131         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 132
 133         assertNotNull(testNode);
 134         assertNotNull(foundNode);
 135         assertEquals(testNode, foundNode);
 136
 137         GroupingDefinition grouping = myModule.getGroupings().iterator().next();
 138         testNode = ((ContainerSchemaNode) grouping.getDataChildByName("my-container-in-grouping"))
 139                 .getDataChildByName("my-leaf-in-grouping");
 140
 141         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-grouping"),
 142                 QName.create(myModule.getQNameModule(), "my-container-in-grouping"),
 143                 QName.create(myModule.getQNameModule(), "my-leaf-in-grouping"));
 144
 145         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 146
 147         assertNotNull(testNode);
 148         assertNotNull(foundNode);
 149         assertEquals(testNode, foundNode);
 150
 151         testNode = ((ChoiceNode) myModule.getDataChildByName("my-choice")).getCaseNodeByName("one").getDataChildByName(
 152                 "my-choice-leaf-one");
 153
 154         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-choice"),
 155                 QName.create(myModule.getQNameModule(), "one"),
 156                 QName.create(myModule.getQNameModule(), "my-choice-leaf-one"));
 157         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 158
 159         assertNotNull(testNode);
 160         assertNotNull(foundNode);
 161         assertEquals(testNode, foundNode);
 162
 163         ListSchemaNode listNode = (ListSchemaNode) ((ContainerSchemaNode) myModule.getDataChildByName("my-container"))
 164                 .getDataChildByName("my-list");
 165
 166         testNode = listNode.getDataChildByName("my-leaf-in-list");
 167
 168         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 169                 QName.create(myModule.getQNameModule(), "my-list"),
 170                 QName.create(myModule.getQNameModule(), "my-leaf-in-list"));
 171         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 172
 173         assertNotNull(testNode);
 174         assertNotNull(foundNode);
 175         assertEquals(testNode, foundNode);
 176
 177         listNode = (ListSchemaNode) ((ContainerSchemaNode) myModule.getDataChildByName("my-container"))
 178                 .getDataChildByName("my-list");
 179
 180         testNode = listNode.getDataChildByName("my-leaf-list-in-list");
 181
 182         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 183                 QName.create(myModule.getQNameModule(), "my-list"),
 184                 QName.create(myModule.getQNameModule(), "my-leaf-list-in-list"));
 185         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 186
 187         assertNotNull(testNode);
 188         assertNotNull(foundNode);
 189         assertEquals(testNode, foundNode);
 190
 191     }
 192
 193     @Test
 194     public void findNodeInSchemaContextTest2() throws URISyntaxException, IOException, YangSyntaxErrorException,
 195             ParseException {
 196
 197         File resourceFile = new File(getClass().getResource("/schema-context-util-test/my-module.yang").toURI());
 198         File resourceDir = resourceFile.getParentFile();
 199
 200         YangParserImpl parser = YangParserImpl.getInstance();
 201         SchemaContext context = parser.parseFile(resourceFile, resourceDir);
 202
 203         Module myModule = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
 204                 QName.parseRevision("2014-10-07"));
 205
 206         SchemaNode testNode = ((ContainerSchemaNode) myModule.getDataChildByName("my-container"))
 207                 .getDataChildByName("my-leaf-not-in-container");
 208
 209         SchemaPath path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 210                 QName.create(myModule.getQNameModule(), "my-leaf-not-in-container"));
 211         SchemaNode foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 212
 213         assertNull(testNode);
 214         assertNull(foundNode);
 215
 216         Set<RpcDefinition> rpcs = myModule.getRpcs();
 217         RpcDefinition rpc = rpcs.iterator().next();
 218         testNode = rpc.getInput().getDataChildByName("no-input-leaf");
 219
 220         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"),
 221                 QName.create(myModule.getQNameModule(), "input"),
 222                 QName.create(myModule.getQNameModule(), "no-input-leaf"));
 223
 224         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 225
 226         assertNull(testNode);
 227         assertNull(foundNode);
 228
 229         NotificationDefinition notification = myModule.getNotifications().iterator().next();
 230         testNode = notification.getDataChildByName("no-notification-leaf");
 231
 232         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-notification"),
 233                 QName.create(myModule.getQNameModule(), "no-notification-leaf"));
 234
 235         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 236
 237         assertNull(testNode);
 238         assertNull(foundNode);
 239
 240         GroupingDefinition grouping = myModule.getGroupings().iterator().next();
 241         testNode = ((ContainerSchemaNode) grouping.getDataChildByName("my-container-in-grouping"))
 242                 .getDataChildByName("no-leaf-in-grouping");
 243
 244         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-grouping"),
 245                 QName.create(myModule.getQNameModule(), "my-container-in-grouping"),
 246                 QName.create(myModule.getQNameModule(), "no-leaf-in-grouping"));
 247
 248         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 249
 250         assertNull(testNode);
 251         assertNull(foundNode);
 252
 253         testNode = ((ChoiceNode) myModule.getDataChildByName("my-choice")).getCaseNodeByName("one").getDataChildByName(
 254                 "no-choice-leaf");
 255
 256         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-choice"),
 257                 QName.create(myModule.getQNameModule(), "one"),
 258                 QName.create(myModule.getQNameModule(), "no-choice-leaf"));
 259         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 260
 261         assertNull(testNode);
 262         assertNull(foundNode);
 263
 264         ListSchemaNode listNode = (ListSchemaNode) ((ContainerSchemaNode) myModule.getDataChildByName("my-container"))
 265                 .getDataChildByName("my-list");
 266
 267         testNode = listNode.getDataChildByName("no-leaf-in-list");
 268
 269         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 270                 QName.create(myModule.getQNameModule(), "my-list"),
 271                 QName.create(myModule.getQNameModule(), "no-leaf-in-list"));
 272         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 273
 274         assertNull(testNode);
 275         assertNull(foundNode);
 276
 277         listNode = (ListSchemaNode) ((ContainerSchemaNode) myModule.getDataChildByName("my-container"))
 278                 .getDataChildByName("my-list");
 279
 280         testNode = listNode.getDataChildByName("no-leaf-list-in-list");
 281
 282         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 283                 QName.create(myModule.getQNameModule(), "my-list"),
 284                 QName.create(myModule.getQNameModule(), "no-leaf-list-in-list"));
 285         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 286
 287         assertNull(testNode);
 288         assertNull(foundNode);
 289
 290     }
 291
 292     @Test
 293     public void findNodeInSchemaContextTest3() throws URISyntaxException, IOException, YangSyntaxErrorException,
 294             ParseException {
 295
 296         File resourceFile = new File(getClass().getResource("/schema-context-util-test/my-module.yang").toURI());
 297         File resourceDir = resourceFile.getParentFile();
 298
 299         YangParserImpl parser = YangParserImpl.getInstance();
 300         SchemaContext context = parser.parseFile(resourceFile, resourceDir);
 301
 302         Module myModule = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
 303                 QName.parseRevision("2014-10-07"));
 304
 305         SchemaNode testNode = myModule.getDataChildByName("my-container");
 306
 307         SchemaPath path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"));
 308         SchemaNode foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 309
 310         assertNotNull(testNode);
 311         assertNotNull(foundNode);
 312         assertEquals(testNode, foundNode);
 313
 314         testNode = myModule.getRpcs().iterator().next();
 315
 316         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"));
 317         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 318
 319         assertNotNull(testNode);
 320         assertNotNull(foundNode);
 321         assertEquals(testNode, foundNode);
 322
 323         testNode = myModule.getNotifications().iterator().next();
 324
 325         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-notification"));
 326         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 327
 328         assertNotNull(testNode);
 329         assertNotNull(foundNode);
 330         assertEquals(testNode, foundNode);
 331
 332         testNode = myModule.getGroupings().iterator().next();
 333
 334         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-grouping"));
 335         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 336
 337         assertNotNull(testNode);
 338         assertNotNull(foundNode);
 339         assertEquals(testNode, foundNode);
 340
 341         testNode = myModule.getDataChildByName("my-choice");
 342
 343         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-choice"));
 344         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 345
 346         assertNotNull(testNode);
 347         assertNotNull(foundNode);
 348         assertEquals(testNode, foundNode);
 349
 350         testNode = ((ContainerSchemaNode) myModule.getDataChildByName("my-container")).getDataChildByName("my-list");
 351
 352         path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
 353                 QName.create(myModule.getQNameModule(), "my-list"));
 354         foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());
 355
 356         assertNotNull(testNode);
 357         assertNotNull(foundNode);
 358         assertEquals(testNode, foundNode);
 359
 360     }
 361
 362     @Test
 363     public void findParentModuleTest() throws URISyntaxException, IOException, YangSyntaxErrorException, ParseException {
 364
 365         File resourceFile = new File(getClass().getResource("/schema-context-util-test/my-module.yang").toURI());
 366         File resourceDir = resourceFile.getParentFile();
 367
 368         YangParserImpl parser = YangParserImpl.getInstance();
 369         SchemaContext context = parser.parseFile(resourceFile, resourceDir);
 370
 371         Module myModule = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
 372                 QName.parseRevision("2014-10-07"));
 373
 374         DataSchemaNode node = myModule.getDataChildByName("my-container");
 375
 376         Module foundModule = SchemaContextUtil.findParentModule(context, node);
 377
 378         assertEquals(myModule, foundModule);
 379     }
 380
 381     @Test(expected = IllegalArgumentException.class)
 382     public void findParentModuleIllegalArgumentTest() {
 383
 384         SchemaContext mockContext = Mockito.mock(SchemaContext.class);
 385         SchemaContextUtil.findParentModule(mockContext, null);
 386
 387     }
 388
 389     @Test(expected = IllegalArgumentException.class)
 390     public void findParentModuleIllegalArgumentTest2() {
 391
 392         SchemaNode mockSchemaNode = Mockito.mock(SchemaNode.class);
 393         SchemaContextUtil.findParentModule(null, mockSchemaNode);
 394
 395     }
 396
 397     @Test(expected = IllegalStateException.class)
 398     public void findParentModuleIllegalStateTest() {
 399
 400         SchemaContext mockContext = Mockito.mock(SchemaContext.class);
 401         SchemaNode mockSchemaNode = Mockito.mock(SchemaNode.class);
 402         Mockito.when(mockSchemaNode.getPath()).thenReturn(null);
 403         SchemaContextUtil.findParentModule(mockContext, mockSchemaNode);
 404
 405     }
 406
 407     @Test(expected = IllegalArgumentException.class)
 408     public void findDataSchemaNodeIllegalArgumentTest() {
 409
 410         SchemaContext mockContext = Mockito.mock(SchemaContext.class);
 411         SchemaContextUtil.findDataSchemaNode(mockContext, null);
 412
 413     }
 414
 415     @Test(expected = IllegalArgumentException.class)
 416     public void findDataSchemaNodeIllegalArgumentTest2() {
 417
 418         SchemaPath mockSchemaPath = Mockito.mock(SchemaPath.class);
 419         SchemaContextUtil.findDataSchemaNode(null, mockSchemaPath);
 420
 421     }
 422
 423     @Test
 424     public void findDataSchemaNodeTest() throws URISyntaxException, IOException, YangSyntaxErrorException {
 425
 426         File resourceFile = new File(getClass().getResource("/schema-context-util-test/my-module.yang").toURI());
 427         File resourceDir = resourceFile.getParentFile();
 428
 429         YangParserImpl parser = YangParserImpl.getInstance();
 430         SchemaContext context = parser.parseFile(resourceFile, resourceDir);
 431
 432         Module module = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
 433                 QName.parseRevision("2014-10-07"));
 434         Module importedModule = context.findModuleByNamespaceAndRevision(new URI("uri:imported-module"),
 435                 QName.parseRevision("2014-10-07"));
 436
 437         SchemaNode testNode = ((ContainerSchemaNode) importedModule.getDataChildByName("my-imported-container"))
 438                 .getDataChildByName("my-imported-leaf");
 439
 440         RevisionAwareXPath xpath = new RevisionAwareXPathImpl("imp:my-imported-container/imp:my-imported-leaf", true);
 441
 442         SchemaNode foundNode = SchemaContextUtil.findDataSchemaNode(context, module, xpath);
 443
 444         assertNotNull(foundNode);
 445         assertNotNull(testNode);
 446         assertEquals(testNode, foundNode);
 447
 448     }
 449
 450     @Test
 451     public void findDataSchemaNodeTest2() throws URISyntaxException, IOException, YangSyntaxErrorException {
 452         // findDataSchemaNode(final SchemaContext context, final Module module,
 453         // final RevisionAwareXPath nonCondXPath) {
 454
 455         File resourceFile = new File(getClass().getResource("/schema-context-util-test/my-module.yang").toURI());
 456         File resourceDir = resourceFile.getParentFile();
 457
 458         YangParserImpl parser = YangParserImpl.getInstance();
 459         SchemaContext context = parser.parseFile(resourceFile, resourceDir);
 460
 461         Module module = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
 462                 QName.parseRevision("2014-10-07"));
 463
 464         GroupingDefinition grouping = module.getGroupings().iterator().next();
 465         SchemaNode testNode = grouping.getDataChildByName("my-leaf-in-gouping2");
 466
 467         RevisionAwareXPath xpath = new RevisionAwareXPathImpl("my:my-grouping/my:my-leaf-in-gouping2", true);
 468
 469         SchemaNode foundNode = SchemaContextUtil.findDataSchemaNode(context, module, xpath);
 470
 471         assertNotNull(foundNode);
 472         assertNotNull(testNode);
 473         assertEquals(testNode, foundNode);
 474
 475     }
 476
 477     @Test(expected = IllegalArgumentException.class)
 478     public void findDataSchemaNodeFromXPathIllegalArgumentTest() {
 479
 480         SchemaContext mockContext = Mockito.mock(SchemaContext.class);
 481         Module module = Mockito.mock(Module.class);
 482
 483         SchemaContextUtil.findDataSchemaNode(mockContext, module, null);
 484
 485     }
 486
 487     @Test(expected = IllegalArgumentException.class)
 488     public void findDataSchemaNodeFromXPathIllegalArgumentTest2() {
 489
 490         SchemaContext mockContext = Mockito.mock(SchemaContext.class);
 491         RevisionAwareXPath xpath = new RevisionAwareXPathImpl("my:my-grouping/my:my-leaf-in-gouping2", true);
 492
 493         SchemaContextUtil.findDataSchemaNode(mockContext, null, xpath);
 494
 495     }
 496
 497     @Test(expected = IllegalArgumentException.class)
 498     public void findDataSchemaNodeFromXPathIllegalArgumentTest3() {
 499
 500         Module module = Mockito.mock(Module.class);
 501         RevisionAwareXPath xpath = new RevisionAwareXPathImpl("my:my-grouping/my:my-leaf-in-gouping2", true);
 502
 503         SchemaContextUtil.findDataSchemaNode(null, module, xpath);
 504
 505     }
 506
 507     @Test(expected = IllegalArgumentException.class)
 508     public void findDataSchemaNodeFromXPathIllegalArgumentTest4() {
 509
 510         SchemaContext mockContext = Mockito.mock(SchemaContext.class);
 511         Module module = Mockito.mock(Module.class);
 512         RevisionAwareXPath xpath = new RevisionAwareXPathImpl("my:my-grouping[@con='NULL']/my:my-leaf-in-gouping2",
 513                 true);
 514
 515         SchemaContextUtil.findDataSchemaNode(mockContext, module, xpath);
 516
 517     }
 518
 519     @Test
 520     public void findDataSchemaNodeFromXPathNullTest() {
 521
 522         SchemaContext mockContext = Mockito.mock(SchemaContext.class);
 523         Module module = Mockito.mock(Module.class);
 524         RevisionAwareXPath xpath = Mockito.mock(RevisionAwareXPath.class);
 525
 526         Mockito.when(xpath.toString()).thenReturn(null);
 527         assertNull(SchemaContextUtil.findDataSchemaNode(mockContext, module, xpath));
 528
 529     }
 530
 531     @Test
 532     public void findDataSchemaNodeFromXPathNullTest2() {
 533
 534         SchemaContext mockContext = Mockito.mock(SchemaContext.class);
 535         Module module = Mockito.mock(Module.class);
 536         RevisionAwareXPath xpath = new RevisionAwareXPathImpl("my:my-grouping/my:my-leaf-in-gouping2", false);
 537
 538         assertNull(SchemaContextUtil.findDataSchemaNode(mockContext, module, xpath));
 539
 540     }
 541
 542 }