yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/builder/impl/BuilderUtilsTest.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
   3  * This program and the accompanying materials are made available under the
   4  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   5  * and is available at http://www.eclipse.org/legal/epl-v10.html
   6  */
   7 package org.opendaylight.yangtools.yang.parser.builder.impl;
   8
   9 import static org.junit.Assert.assertEquals;
  10 import static org.junit.Assert.assertFalse;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertNull;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.mockito.Mockito.mock;
  15 import com.google.common.base.Optional;
  16 import java.net.URI;
  17 import java.text.DateFormat;
  18 import java.text.SimpleDateFormat;
  19 import java.util.ArrayList;
  20 import java.util.Collections;
  21 import java.util.Date;
  22 import java.util.HashMap;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.NavigableMap;
  26 import java.util.TreeMap;
  27 import org.junit.Before;
  28 import org.junit.Test;
  29 import org.opendaylight.yangtools.yang.common.QName;
  30 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
  31 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  32 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  33 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  34 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  35 import org.opendaylight.yangtools.yang.model.api.Status;
  36 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  37 import org.opendaylight.yangtools.yang.model.util.Uint16;
  38 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  39 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
  40 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  41 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
  42 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
  43 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  44
  45 /**
  46  * Test suite for increasing of test coverage of BuilderUtils implementation.
  47  *
  48  * @see org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils
  49  *
  50  * @author Lukas Sedlak <lsedlak@cisco.com>
  51  *
  52  * @deprecated Pre-Beryllium implementation, scheduled for removal.
  53  */
  54 @Deprecated
  55 public class BuilderUtilsTest {
  56
  57     private final static String MASTER_MODULE_NAMESPACE = "urn:opendaylight.master-model";
  58     private final static String MODULES_REVISION = "2014-10-06";
  59     private final static String MASTER_MODULE = "master-module";
  60     private final static String DEPENDENT_MODULE_NAMESPACE = "urn:opendaylight.secondary-model";
  61     private final static String DEPENDENT_MODULE = "depend-module";
  62     private final static String MASTER_MODULE_PATH = "test/module/path/master-module@" + MODULES_REVISION + ".yang";
  63     private final static String DEPENDENT_MODULE_PATH = "test/module/path/depend-module@" + MODULES_REVISION + ".yang";
  64     private final static String DEPENDENT_MODULE_PREFIX = "dep";
  65
  66     private final static DateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-mm-dd");
  67
  68     private ModuleBuilder masterModule;
  69     private ModuleBuilder dependentModule;
  70
  71     @Before
  72     public void setUp() throws Exception {
  73         masterModule = new ModuleBuilder(MASTER_MODULE, MASTER_MODULE_PATH);
  74         dependentModule = new ModuleBuilder(DEPENDENT_MODULE, DEPENDENT_MODULE_PATH);
  75
  76         final Date moduleRevision = SIMPLE_DATE_FORMAT.parse(MODULES_REVISION);
  77         masterModule.setRevision(moduleRevision);
  78         dependentModule.setRevision(moduleRevision);
  79
  80         masterModule.setNamespace(URI.create(MASTER_MODULE_NAMESPACE));
  81         dependentModule.setNamespace(URI.create(DEPENDENT_MODULE_NAMESPACE));
  82
  83         masterModule.setNamespace(URI.create(MASTER_MODULE_NAMESPACE));
  84         dependentModule.setNamespace(URI.create(DEPENDENT_MODULE_NAMESPACE));
  85
  86         masterModule.setPrefix("mod");
  87         dependentModule.setPrefix("mod");
  88         masterModule.addModuleImport(dependentModule.getModuleName(), dependentModule.getRevision(), DEPENDENT_MODULE_PREFIX);
  89     }
  90
  91     @Test
  92     public void testFindModuleFromBuildersWithNullPrefix() throws Exception {
  93         final Map<String, NavigableMap<Date, ModuleBuilder>> testModules = initModuleBuildersForTest();
  94
  95         ModuleBuilder result = BuilderUtils.findModuleFromBuilders(testModules, masterModule, null, 12);
  96         assertEquals(masterModule, result);
  97
  98         result = BuilderUtils.findModuleFromBuilders(testModules, masterModule, masterModule.getPrefix(), 12);
  99         assertEquals(masterModule, result);
 100
 101         result = BuilderUtils.findModuleFromBuilders(testModules, masterModule, DEPENDENT_MODULE_PREFIX, 12);
 102         assertEquals(dependentModule, result);
 103     }
 104
 105     private Map<String, NavigableMap<Date, ModuleBuilder>> initModuleBuildersForTest() throws Exception {
 106         final Map<String, NavigableMap<Date, ModuleBuilder>> modules = new HashMap<>();
 107         final String module3Name = "Module3";
 108
 109         ModuleBuilder module3 = new ModuleBuilder(module3Name, "test/module/path/module3.yang");
 110         final Date moduleRevision = SIMPLE_DATE_FORMAT.parse(MODULES_REVISION);
 111
 112         module3.setRevision(moduleRevision);
 113         module3.setNamespace(URI.create("urn:opendaylight.ternary-model"));
 114         module3.setPrefix("mod");
 115
 116         dependentModule.addModuleImport(module3.getModuleName(), module3.getRevision(), "ter");
 117
 118         final NavigableMap<Date, ModuleBuilder> module1Map = new TreeMap<>();
 119         module1Map.put(masterModule.getRevision(), masterModule);
 120
 121         final NavigableMap<Date, ModuleBuilder> module2Map = new TreeMap<>();
 122         module2Map.put(dependentModule.getRevision(), dependentModule);
 123
 124         final NavigableMap<Date, ModuleBuilder> module3Map = new TreeMap<>();
 125         module3Map.put(module3.getRevision(), module3);
 126
 127         modules.put(masterModule.getName(), module1Map);
 128         modules.put(dependentModule.getName(), module2Map);
 129         modules.put(module3Name, module3Map);
 130
 131         return modules;
 132     }
 133
 134     @Test(expected = YangParseException.class)
 135     public void testFindModuleFromBuildersWithNoImportedModule() throws Exception {
 136         final Map<String, NavigableMap<Date, ModuleBuilder>> testModules = initModuleBuildersForTest();
 137
 138         BuilderUtils.findModuleFromBuilders(testModules, masterModule, "eth", 12);
 139     }
 140
 141     @Test(expected = YangParseException.class)
 142     public void testFindModuleFromContextWithDependentModuleImportEqualsToNull() {
 143         final SchemaContext mockContext = mock(SchemaContext.class);
 144
 145         BuilderUtils.findModuleFromContext(mockContext, masterModule, "inalid-prefix", 14);
 146     }
 147
 148     @Test(expected = YangParseException.class)
 149     public void testFindModuleFromContextWhereModuleIsNotPresent() {
 150         final SchemaContext mockContext = mock(SchemaContext.class);
 151
 152         BuilderUtils.findModuleFromContext(mockContext, masterModule, DEPENDENT_MODULE_PREFIX, 14);
 153     }
 154
 155     @Test(expected = YangParseException.class)
 156     public void testFillAugmentTargetForInvalidTarget() {
 157         AugmentationSchemaBuilder augBuilder = mock(AugmentationSchemaBuilder.class);
 158         Builder invalidTarget = mock(Builder.class);
 159         BuilderUtils.fillAugmentTarget(augBuilder, invalidTarget);
 160     }
 161
 162     @Test(expected = YangParseException.class)
 163     public void testFillAugmentTargetWithChoiceBuilderContainingInvalidUsesNodeBuilder() {
 164         final QName usesQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "test-grouping");
 165         final UsesNodeBuilder usesNodeBuilder = new UsesNodeBuilderImpl(masterModule.getModuleName(), 10, SchemaPath.create(true, usesQName));
 166
 167         final QName augTargetQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "target");
 168         final AugmentationSchemaBuilder augBuilder = new AugmentationSchemaBuilderImpl(masterModule.getModuleName(), 12,
 169             "/target", SchemaPath.create(true, augTargetQName), 1);
 170
 171         augBuilder.setParent(usesNodeBuilder);
 172
 173         final QName choiceQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "test-choice");
 174         final ChoiceBuilder choiceBuilder = new ChoiceBuilder(masterModule.getModuleName(), 14, choiceQName,
 175             SchemaPath.create(true, choiceQName));
 176
 177         augBuilder.addUsesNode(usesNodeBuilder);
 178         BuilderUtils.fillAugmentTarget(augBuilder, choiceBuilder);
 179     }
 180
 181     @Test
 182     public void testFillAugmentTargetSetNodeAddedByUses() {
 183         final QName augTargetQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "target");
 184         final AugmentationSchemaBuilder augBuilder = new AugmentationSchemaBuilderImpl(masterModule.getModuleName(), 12,
 185             "/target", SchemaPath.create(true, augTargetQName), 1);
 186
 187         final String containerLocalName = "top-level-container";
 188         final QName containerQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), containerLocalName);
 189         SchemaPath containerPath = SchemaPath.create(true, containerQName);
 190         augBuilder.addChildNode(
 191             new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 10, containerQName, containerPath));
 192
 193         final QName choiceQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "test-choice");
 194         final ChoiceBuilder choiceBuilder = new ChoiceBuilder(masterModule.getModuleName(), 14, choiceQName,
 195             SchemaPath.create(true, choiceQName));
 196
 197         BuilderUtils.fillAugmentTarget(augBuilder, choiceBuilder);
 198
 199         ChoiceCaseBuilder result = choiceBuilder.getCaseNodeByName(containerLocalName);
 200         assertNotNull(result);
 201     }
 202
 203     @Test
 204     public void testFindUnknownNodeInDataNodeContainer() {
 205         final String parentLocalName = "parent";
 206         final QName containerQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), parentLocalName);
 207         SchemaPath containerPath = SchemaPath.create(true, containerQName);
 208
 209         final ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 10,
 210             containerQName, containerPath);
 211
 212         final String unknownLocalName = "unknown-ext-use";
 213         final QName unknownNode = QName.create(masterModule.getNamespace(), masterModule.getRevision(), unknownLocalName);
 214         SchemaPath unknownNodePath = SchemaPath.create(true, containerQName, unknownNode);
 215         UnknownSchemaNodeBuilderImpl unknownNodeBuilder = new UnknownSchemaNodeBuilderImpl(masterModule.getModuleName(),
 216             22, unknownNode, unknownNodePath);
 217         containerBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 218
 219         List<QName> path = new ArrayList<>(2);
 220         path.add(unknownNode);
 221
 222         SchemaNodeBuilder result = BuilderUtils.findSchemaNode(path, containerBuilder);
 223         assertNotNull(result);
 224         assertEquals(unknownNodeBuilder, result);
 225
 226         path.add(QName.create(masterModule.getNamespace(), masterModule.getRevision(), "foo"));
 227         assertNull(BuilderUtils.findSchemaNode(path, containerBuilder));
 228
 229         final QName choiceQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "select");
 230         SchemaPath choicePath = SchemaPath.create(true, choiceQName);
 231
 232         final ChoiceBuilder choiceBuilder = new ChoiceBuilder(masterModule.getModuleName(), 33, choiceQName, choicePath);
 233
 234         final QName caseQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "simple-case");
 235         SchemaPath casePath = SchemaPath.create(true, choiceQName, caseQName);
 236
 237         ChoiceCaseBuilder caseBuilder = new ChoiceCaseBuilder(masterModule.getModuleName(), 35, caseQName, casePath);
 238         choiceBuilder.addCase(caseBuilder);
 239
 240         choiceBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 241
 242         path.clear();
 243         path.add(caseQName);
 244         result = BuilderUtils.findSchemaNode(path, choiceBuilder);
 245         assertNotNull(result);
 246         assertTrue(result instanceof ChoiceCaseBuilder);
 247         assertEquals(caseBuilder, result);
 248
 249         path.clear();
 250         path.add(unknownNode);
 251         result = BuilderUtils.findSchemaNode(path, choiceBuilder);
 252         assertNotNull(result);
 253         assertEquals(unknownNodeBuilder, result);
 254
 255         path.add(QName.create(masterModule.getNamespace(), masterModule.getRevision(), "foo"));
 256         result = BuilderUtils.findSchemaNode(path, choiceBuilder);
 257         assertNull(result);
 258
 259         final QName rpcQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), parentLocalName);
 260         SchemaPath rpcPath = SchemaPath.create(true, rpcQName);
 261         final RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(masterModule.getModuleName(), 45, rpcQName, rpcPath);
 262
 263         final QName inputQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "input");
 264         final SchemaPath inputPath = SchemaPath.create(true, rpcQName, inputQName);
 265
 266         final QName outputQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "output");
 267         final SchemaPath outputPath = SchemaPath.create(true, rpcQName, outputQName);
 268
 269         final ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 46,
 270             inputQName, inputPath);
 271         final ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 76,
 272             outputQName, outputPath);
 273
 274         rpcBuilder.setInput(inputBuilder);
 275         rpcBuilder.setOutput(outputBuilder);
 276         rpcBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 277
 278         path.clear();
 279         path.add(inputQName);
 280         result = BuilderUtils.findSchemaNode(path, rpcBuilder);
 281         assertNotNull(result);
 282         assertEquals(inputBuilder, result);
 283
 284         path.clear();
 285         path.add(outputQName);
 286         result = BuilderUtils.findSchemaNode(path, rpcBuilder);
 287         assertNotNull(result);
 288         assertEquals(outputBuilder, result);
 289
 290         path.clear();
 291         path.add(unknownNode);
 292         result = BuilderUtils.findSchemaNode(path, rpcBuilder);
 293         assertNotNull(result);
 294         assertEquals(unknownNodeBuilder, result);
 295
 296         final QName leafQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "simple-leaf");
 297         SchemaPath leafPath = SchemaPath.create(true, leafQName);
 298
 299         final LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(masterModule.getModuleName(), 10, leafQName, leafPath);
 300         leafBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 301
 302         path.clear();
 303         path.add(unknownNode);
 304         result = BuilderUtils.findSchemaNode(path, leafBuilder);
 305         assertNotNull(result);
 306         assertEquals(unknownNodeBuilder, result);
 307     }
 308
 309     @Test
 310     public void testFindUnknownSchemaNodeInModule() {
 311         final String parentLocalName = "parent";
 312         final QName containerQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), parentLocalName);
 313         SchemaPath containerPath = SchemaPath.create(true, containerQName);
 314
 315         final ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 10,
 316             containerQName, containerPath);
 317
 318         final String unknownLocalName = "unknown-ext-use";
 319         final QName unknownNode = QName.create(masterModule.getNamespace(), masterModule.getRevision(), unknownLocalName);
 320         final SchemaPath unknownNodePath = SchemaPath.create(true, containerQName, unknownNode);
 321         UnknownSchemaNodeBuilderImpl unknownNodeBuilder = new UnknownSchemaNodeBuilderImpl(masterModule.getModuleName(),
 322             22, unknownNode, unknownNodePath);
 323         containerBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 324
 325         masterModule.addChildNode(containerBuilder);
 326
 327         Optional<SchemaNodeBuilder> result = BuilderUtils.findSchemaNodeInModule(unknownNodePath, masterModule);
 328
 329         assertTrue(result.isPresent());
 330         assertEquals(result.get(), unknownNodeBuilder);
 331
 332         final QName invalidUnknownNode = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "invalid-ext-use");
 333         final SchemaPath invalidPath = SchemaPath.create(true, containerQName, invalidUnknownNode);
 334
 335         result = BuilderUtils.findSchemaNodeInModule(invalidPath, masterModule);
 336         assertFalse(result.isPresent());
 337     }
 338
 339     @Test
 340     public void testFindContainerInRPC() {
 341
 342         final QName rpcQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "send-message");
 343         SchemaPath rpcPath = SchemaPath.create(true, rpcQName);
 344         final RpcDefinitionBuilder rpcBuilder = masterModule.addRpc(45, rpcQName, rpcPath);
 345
 346         final QName inputQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "input");
 347         final SchemaPath inputPath = SchemaPath.create(true, rpcQName, inputQName);
 348
 349         final QName outputQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "output");
 350         final SchemaPath outputPath = SchemaPath.create(true, rpcQName, outputQName);
 351
 352         Optional<SchemaNodeBuilder> requestResult = BuilderUtils.findSchemaNodeInModule(inputPath, masterModule);
 353         assertTrue(requestResult.isPresent());
 354
 355         Optional<SchemaNodeBuilder> responseResult = BuilderUtils.findSchemaNodeInModule(outputPath, masterModule);
 356         assertTrue(responseResult.isPresent());
 357
 358         final ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 46,
 359             inputQName, inputPath);
 360         final ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 76,
 361             outputQName, outputPath);
 362
 363         final QName request = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "request");
 364         final SchemaPath requestPath = SchemaPath.create(true, rpcQName, inputQName, request);
 365
 366         final QName response = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "response");
 367         final SchemaPath responsePath = SchemaPath.create(true, rpcQName, outputQName, response);
 368
 369         final ContainerSchemaNodeBuilder requestBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 50,
 370             request, requestPath);
 371         final ContainerSchemaNodeBuilder responseBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 80,
 372             response, responsePath);
 373
 374         inputBuilder.addChildNode(requestBuilder);
 375         outputBuilder.addChildNode(responseBuilder);
 376
 377         rpcBuilder.setInput(inputBuilder);
 378         rpcBuilder.setOutput(outputBuilder);
 379
 380         requestResult = BuilderUtils.findSchemaNodeInModule(requestPath, masterModule);
 381         assertTrue(requestResult.isPresent());
 382
 383         responseResult = BuilderUtils.findSchemaNodeInModule(responsePath, masterModule);
 384         assertTrue(responseResult.isPresent());
 385
 386         final SchemaPath invalidPath = SchemaPath.create(true, rpcQName, response);
 387         Optional<SchemaNodeBuilder> invalidResult = BuilderUtils.findSchemaNodeInModule(invalidPath, masterModule);
 388         assertFalse(invalidResult.isPresent());
 389     }
 390
 391     @Test
 392     public void testFindIdentity() {
 393         assertNull(BuilderUtils.findIdentity(Collections.<IdentitySchemaNodeBuilder>emptySet(), "test-identity"));
 394     }
 395
 396     @Test
 397     public void testGetModuleByPrefix() {
 398         assertEquals(BuilderUtils.getModuleByPrefix(masterModule, null), masterModule);
 399         assertEquals(BuilderUtils.getModuleByPrefix(masterModule, ""), masterModule);
 400         assertEquals(BuilderUtils.getModuleByPrefix(masterModule, masterModule.getPrefix()), masterModule);
 401     }
 402
 403     @Test
 404     public void testFindModule() {
 405         final Map<URI, NavigableMap<Date, ModuleBuilder>> modules = new HashMap<>(1);
 406         final NavigableMap<Date, ModuleBuilder> masterModuleMap = new TreeMap<>();
 407         masterModuleMap.put(masterModule.getRevision(), masterModule);
 408         modules.put(masterModule.getNamespace(), masterModuleMap);
 409
 410         assertNull(BuilderUtils.findModule(QName.create("test-urn:namespace", "2014-10-08", "impossible-module"), modules));
 411
 412         assertEquals(BuilderUtils.findModule(QName.create(masterModule.getNamespace(), null, masterModule.getName()), modules),
 413             masterModule);
 414     }
 415
 416     @Test
 417     public void testFindBaseIdentity() {
 418         assertNull(BuilderUtils.findBaseIdentity(masterModule, "prefix:ident", 27));
 419
 420         final QName identity = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "ident");
 421         masterModule.addIdentity(identity, 22, SchemaPath.create(true, identity));
 422
 423         final IdentitySchemaNodeBuilder result = BuilderUtils
 424             .findBaseIdentity(masterModule, masterModule.getPrefix() + ":ident", 22);
 425         assertNotNull(result);
 426         assertEquals(result.getQName(), identity);
 427     }
 428
 429     @Test
 430     public void testWrapChildNode() {
 431         final QName leafQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "parent-leaf");
 432         final SchemaPath leafPath = SchemaPath.create(true, leafQName);
 433         final LeafListSchemaNodeBuilder leafListBuilder = new LeafListSchemaNodeBuilder(masterModule.getModuleName(),
 434             27, leafQName, leafPath);
 435         leafListBuilder.setType(Uint16.getInstance());
 436
 437         final LeafListSchemaNode leafList = leafListBuilder.build();
 438
 439         DataSchemaNodeBuilder wrapedLeafList = BuilderUtils
 440             .wrapChildNode(masterModule.getModuleName(), 72, leafList, leafPath, leafQName);
 441
 442         assertNotNull(wrapedLeafList);
 443         assertEquals(wrapedLeafList.getQName(), leafList.getQName());
 444     }
 445
 446     @Test(expected = YangParseException.class)
 447     public void wrapChildNodeForUnknownNode() {
 448         final QName qName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "name");
 449         final SchemaPath path = SchemaPath.create(true, qName);
 450
 451         BuilderUtils
 452             .wrapChildNode(masterModule.getModuleName(), 72, new NotExistingDataSchemaNodeImpl(), path, qName);
 453     }
 454
 455     private static class NotExistingDataSchemaNodeImpl implements DataSchemaNode {
 456
 457         @Override public boolean isAugmenting() {
 458             return false;
 459         }
 460
 461         @Override public boolean isAddedByUses() {
 462             return false;
 463         }
 464
 465         @Override public boolean isConfiguration() {
 466             return false;
 467         }
 468
 469         @Override public ConstraintDefinition getConstraints() {
 470             return null;
 471         }
 472
 473         @Override public QName getQName() {
 474             return null;
 475         }
 476
 477         @Override public SchemaPath getPath() {
 478             return null;
 479         }
 480
 481         @Override public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 482             return null;
 483         }
 484
 485         @Override public String getDescription() {
 486             return null;
 487         }
 488
 489         @Override public String getReference() {
 490             return null;
 491         }
 492
 493         @Override public Status getStatus() {
 494             return null;
 495         }
 496     }
 497 }