2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.controller.yang.parser.impl;
10 import static org.junit.Assert.*;
13 import java.util.ArrayList;
14 import java.util.Date;
15 import java.util.HashSet;
16 import java.util.List;
20 import org.junit.Before;
21 import org.junit.Test;
22 import org.opendaylight.controller.yang.common.QName;
23 import org.opendaylight.controller.yang.model.api.AnyXmlSchemaNode;
24 import org.opendaylight.controller.yang.model.api.AugmentationSchema;
25 import org.opendaylight.controller.yang.model.api.ChoiceCaseNode;
26 import org.opendaylight.controller.yang.model.api.ChoiceNode;
27 import org.opendaylight.controller.yang.model.api.ConstraintDefinition;
28 import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
29 import org.opendaylight.controller.yang.model.api.DataSchemaNode;
30 import org.opendaylight.controller.yang.model.api.Deviation;
31 import org.opendaylight.controller.yang.model.api.Deviation.Deviate;
32 import org.opendaylight.controller.yang.model.api.ExtensionDefinition;
33 import org.opendaylight.controller.yang.model.api.FeatureDefinition;
34 import org.opendaylight.controller.yang.model.api.GroupingDefinition;
35 import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
36 import org.opendaylight.controller.yang.model.api.ListSchemaNode;
37 import org.opendaylight.controller.yang.model.api.Module;
38 import org.opendaylight.controller.yang.model.api.ModuleImport;
39 import org.opendaylight.controller.yang.model.api.MustDefinition;
40 import org.opendaylight.controller.yang.model.api.NotificationDefinition;
41 import org.opendaylight.controller.yang.model.api.RpcDefinition;
42 import org.opendaylight.controller.yang.model.api.SchemaNode;
43 import org.opendaylight.controller.yang.model.api.SchemaPath;
44 import org.opendaylight.controller.yang.model.api.Status;
45 import org.opendaylight.controller.yang.model.api.TypeDefinition;
46 import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
47 import org.opendaylight.controller.yang.model.api.UsesNode;
48 import org.opendaylight.controller.yang.model.api.type.LengthConstraint;
49 import org.opendaylight.controller.yang.model.api.type.PatternConstraint;
50 import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
51 import org.opendaylight.controller.yang.model.util.Decimal64;
52 import org.opendaylight.controller.yang.model.util.ExtendedType;
53 import org.opendaylight.controller.yang.model.util.Int16;
54 import org.opendaylight.controller.yang.model.util.Int32;
55 import org.opendaylight.controller.yang.model.util.StringType;
56 import org.opendaylight.controller.yang.model.util.Uint32;
57 import org.opendaylight.controller.yang.model.util.UnionType;
59 public class YangParserTest {
60 private Set<Module> modules;
64 modules = TestUtils.loadModules("src/test/resources/model");
65 assertEquals(3, modules.size());
69 public void testHeaders() {
70 Module test = TestUtils.findModule(modules, "types1");
72 assertEquals("types1", test.getName());
73 assertEquals("1", test.getYangVersion());
74 URI expectedNamespace = URI.create("urn:simple.container.demo");
75 assertEquals(expectedNamespace, test.getNamespace());
76 assertEquals("t1", test.getPrefix());
78 Set<ModuleImport> imports = test.getImports();
79 assertEquals(2, imports.size());
81 ModuleImport import2 = TestUtils.findImport(imports, "data");
82 assertEquals("types2", import2.getModuleName());
83 assertEquals(TestUtils.createDate("2013-02-27"), import2.getRevision());
85 ModuleImport import3 = TestUtils.findImport(imports, "t3");
86 assertEquals("types3", import3.getModuleName());
87 assertEquals(TestUtils.createDate("2013-02-27"), import3.getRevision());
89 assertEquals("opendaylight", test.getOrganization());
90 assertEquals("http://www.opendaylight.org/", test.getContact());
91 Date expectedRevision = TestUtils.createDate("2013-02-27");
92 assertEquals(expectedRevision, test.getRevision());
93 assertEquals(" WILL BE DEFINED LATER", test.getReference());
97 public void testParseContainer() {
98 Module test = TestUtils.findModule(modules, "types2");
99 URI expectedNamespace = URI.create("urn:simple.types.data.demo");
100 String expectedPrefix = "t2";
101 Date expectedRevision = TestUtils.createDate("2013-02-27");
103 ContainerSchemaNode interfaces = (ContainerSchemaNode) test
104 .getDataChildByName("interfaces");
105 // test SchemaNode args
106 QName expectedQName = new QName(expectedNamespace, expectedRevision,
107 expectedPrefix, "interfaces");
108 assertEquals(expectedQName, interfaces.getQName());
109 SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace,
110 expectedRevision, expectedPrefix, "interfaces");
111 assertEquals(expectedPath, interfaces.getPath());
112 assertNull(interfaces.getDescription());
113 assertNull(interfaces.getReference());
114 assertEquals(Status.CURRENT, interfaces.getStatus());
115 assertEquals(0, interfaces.getUnknownSchemaNodes().size());
116 // test DataSchemaNode args
117 assertFalse(interfaces.isAugmenting());
118 assertFalse(interfaces.isConfiguration());
119 ConstraintDefinition constraints = interfaces.getConstraints();
120 assertNull(constraints.getWhenCondition());
121 assertEquals(0, constraints.getMustConstraints().size());
122 assertFalse(constraints.isMandatory());
123 assertNull(constraints.getMinElements());
124 assertNull(constraints.getMaxElements());
125 // test AugmentationTarget args
126 assertEquals(0, interfaces.getAvailableAugmentations().size());
127 // test ContainerSchemaNode args
128 assertFalse(interfaces.isPresenceContainer());
129 // test DataNodeContainer args
130 assertEquals(0, interfaces.getTypeDefinitions().size());
131 assertEquals(1, interfaces.getChildNodes().size());
132 assertEquals(0, interfaces.getGroupings().size());
133 assertEquals(0, interfaces.getUses().size());
135 ListSchemaNode ifEntry = (ListSchemaNode) interfaces
136 .getDataChildByName("ifEntry");
137 assertNotNull(ifEntry);
141 public void testParseList() {
142 Module test = TestUtils.findModule(modules, "types2");
143 URI expectedNamespace = URI.create("urn:simple.types.data.demo");
144 String expectedPrefix = "t2";
145 Date expectedRevision = TestUtils.createDate("2013-02-27");
147 ContainerSchemaNode interfaces = (ContainerSchemaNode) test
148 .getDataChildByName("interfaces");
150 ListSchemaNode ifEntry = (ListSchemaNode) interfaces
151 .getDataChildByName("ifEntry");
152 // test SchemaNode args
153 QName expectedQName = new QName(expectedNamespace, expectedRevision,
154 expectedPrefix, "ifEntry");
155 assertEquals(expectedQName, ifEntry.getQName());
156 SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace,
157 expectedRevision, expectedPrefix, "interfaces", "ifEntry");
158 assertEquals(expectedPath, ifEntry.getPath());
159 assertNull(ifEntry.getDescription());
160 assertNull(ifEntry.getReference());
161 assertEquals(Status.CURRENT, ifEntry.getStatus());
162 assertEquals(0, ifEntry.getUnknownSchemaNodes().size());
163 // test DataSchemaNode args
164 assertFalse(ifEntry.isAugmenting());
165 assertFalse(ifEntry.isConfiguration());
166 ConstraintDefinition constraints = ifEntry.getConstraints();
167 assertNull(constraints.getWhenCondition());
168 assertEquals(0, constraints.getMustConstraints().size());
169 assertFalse(constraints.isMandatory());
170 assertEquals(1, (int)constraints.getMinElements());
171 assertEquals(11, (int)constraints.getMaxElements());
172 // test AugmentationTarget args
173 Set<AugmentationSchema> availableAugmentations = ifEntry
174 .getAvailableAugmentations();
175 assertEquals(2, availableAugmentations.size());
176 // test ListSchemaNode args
177 List<QName> expectedKey = new ArrayList<QName>();
178 expectedKey.add(new QName(expectedNamespace, expectedRevision,
179 expectedPrefix, "ifIndex"));
180 assertEquals(expectedKey, ifEntry.getKeyDefinition());
181 assertFalse(ifEntry.isUserOrdered());
182 // test DataNodeContainer args
183 assertEquals(0, ifEntry.getTypeDefinitions().size());
184 assertEquals(4, ifEntry.getChildNodes().size());
185 assertEquals(0, ifEntry.getGroupings().size());
186 assertEquals(0, ifEntry.getUses().size());
188 LeafSchemaNode ifIndex = (LeafSchemaNode) ifEntry
189 .getDataChildByName("ifIndex");
190 assertTrue(ifIndex.getType() instanceof Uint32);
191 LeafSchemaNode ifMtu = (LeafSchemaNode) ifEntry
192 .getDataChildByName("ifMtu");
193 assertTrue(ifMtu.getType() instanceof Int32);
197 public void testAugmentResolving() {
199 Module module1 = TestUtils.findModule(modules, "types1");
201 Set<AugmentationSchema> module1Augmentations = module1
203 AugmentationSchema augment1 = module1Augmentations.iterator().next();
204 LeafSchemaNode augmentedLeafDefinition = (LeafSchemaNode) augment1
205 .getDataChildByName("ds0ChannelNumber");
206 assertTrue(augmentedLeafDefinition.isAugmenting());
209 Module module2 = TestUtils.findModule(modules, "types2");
211 ContainerSchemaNode interfaces = (ContainerSchemaNode) module2
212 .getDataChildByName("interfaces");
213 ListSchemaNode ifEntry = (ListSchemaNode) interfaces
214 .getDataChildByName("ifEntry");
215 ContainerSchemaNode augmentedContainer = (ContainerSchemaNode) ifEntry
216 .getDataChildByName("augment-holder");
218 // augmentation defined in testfile1 and augmentation returned from
219 // augmented container have to be same
220 Set<AugmentationSchema> augmentedContainerAugments = augmentedContainer
221 .getAvailableAugmentations();
222 AugmentationSchema augmentDefinition = augmentedContainerAugments
224 assertEquals(augment1, augmentDefinition);
226 LeafSchemaNode augmentedLeaf = (LeafSchemaNode) augmentedContainer
227 .getDataChildByName("ds0ChannelNumber");
228 assertTrue(augmentedLeaf.isAugmenting());
229 assertEquals(augmentedLeafDefinition, augmentedLeaf);
231 Set<AugmentationSchema> ifEntryAugments = ifEntry
232 .getAvailableAugmentations();
233 assertEquals(2, ifEntryAugments.size());
236 Module module3 = TestUtils.findModule(modules, "types3");
238 Set<AugmentationSchema> module3Augmentations = module3
240 assertEquals(2, module3Augmentations.size());
241 AugmentationSchema augment3 = null;
242 for (AugmentationSchema as : module3Augmentations) {
243 if ("if:ifType='ds0'".equals(as.getWhenCondition().toString())) {
247 ContainerSchemaNode augmentedContainerDefinition = (ContainerSchemaNode) augment3
248 .getDataChildByName("augment-holder");
249 assertTrue(augmentedContainerDefinition.isAugmenting());
252 assertEquals(augmentedContainer, augmentedContainerDefinition);
253 assertEquals(augmentedLeaf, augmentedLeafDefinition);
257 public void testAugmentTarget() {
258 Module test = TestUtils.findModule(modules, "types2");
260 ContainerSchemaNode interfaces = (ContainerSchemaNode) test
261 .getDataChildByName("interfaces");
262 ListSchemaNode ifEntry = (ListSchemaNode) interfaces
263 .getDataChildByName("ifEntry");
264 Set<AugmentationSchema> augmentations = ifEntry
265 .getAvailableAugmentations();
266 assertEquals(2, augmentations.size());
268 AugmentationSchema augment = null;
269 for (AugmentationSchema as : augmentations) {
270 if ("if:ifType='ds0'".equals(as.getWhenCondition().toString())) {
274 ContainerSchemaNode augmentHolder = (ContainerSchemaNode) augment
275 .getDataChildByName("augment-holder");
276 assertNotNull(augmentHolder);
277 assertTrue(augmentHolder.isAugmenting());
278 QName augmentHolderQName = augmentHolder.getQName();
279 assertEquals("augment-holder", augmentHolderQName.getLocalName());
280 assertEquals("t3", augmentHolderQName.getPrefix());
281 assertEquals("Description for augment holder",
282 augmentHolder.getDescription());
286 public void testTypedefRangesResolving() {
287 Module testModule = TestUtils.findModule(modules, "types1");
289 LeafSchemaNode testleaf = (LeafSchemaNode) testModule
290 .getDataChildByName("testleaf");
291 ExtendedType leafType = (ExtendedType) testleaf.getType();
292 assertEquals("my-type1", leafType.getQName().getLocalName());
293 assertEquals("t2", leafType.getQName().getPrefix());
294 ExtendedType baseType = (ExtendedType) leafType.getBaseType();
295 assertEquals("my-base-int32-type", baseType.getQName().getLocalName());
296 assertEquals("t2", baseType.getQName().getPrefix());
298 List<RangeConstraint> ranges = leafType.getRanges();
299 assertEquals(1, ranges.size());
300 RangeConstraint range = ranges.get(0);
301 assertEquals(3L, range.getMin());
302 assertEquals(20L, range.getMax());
306 public void testTypedefPatternsResolving() {
307 Module testModule = TestUtils.findModule(modules, "types1");
309 LeafSchemaNode testleaf = (LeafSchemaNode) testModule
310 .getDataChildByName("test-string-leaf");
311 ExtendedType testleafType = (ExtendedType) testleaf.getType();
312 QName testleafTypeQName = testleafType.getQName();
313 assertEquals("my-string-type-ext", testleafTypeQName.getLocalName());
314 assertEquals("t2", testleafTypeQName.getPrefix());
316 Set<String> expectedRegex = new HashSet<String>();
317 expectedRegex.add("[a-k]*");
318 expectedRegex.add("[b-u]*");
319 expectedRegex.add("[e-z]*");
321 Set<String> actualRegex = new HashSet<String>();
322 List<PatternConstraint> patterns = testleafType.getPatterns();
323 assertEquals(3, patterns.size());
324 for (PatternConstraint pc : patterns) {
325 actualRegex.add(pc.getRegularExpression());
327 assertEquals(expectedRegex, actualRegex);
329 TypeDefinition<?> baseType = testleafType.getBaseType();
330 assertEquals("my-string-type2", baseType.getQName().getLocalName());
332 List<LengthConstraint> lengths = testleafType.getLengths();
333 assertEquals(1, lengths.size());
335 LengthConstraint length = lengths.get(0);
336 assertEquals(5L, length.getMin());
337 assertEquals(10L, length.getMax());
341 public void testTypedefLengthsResolving() {
342 Module testModule = TestUtils.findModule(modules, "types1");
344 LeafSchemaNode testleaf = (LeafSchemaNode) testModule
345 .getDataChildByName("leaf-with-length");
346 ExtendedType testleafType = (ExtendedType) testleaf.getType();
347 assertEquals("my-string-type", testleafType.getQName().getLocalName());
349 List<LengthConstraint> lengths = testleafType.getLengths();
350 assertEquals(1, lengths.size());
352 LengthConstraint length = lengths.get(0);
353 assertEquals(7L, length.getMin());
354 assertEquals(10L, length.getMax());
358 public void testTypeDef() {
359 Module testModule = TestUtils.findModule(modules, "types2");
361 LeafSchemaNode testleaf = (LeafSchemaNode) testModule
362 .getDataChildByName("nested-type-leaf");
363 ExtendedType testleafType = (ExtendedType) testleaf.getType();
364 assertEquals("my-type1", testleafType.getQName().getLocalName());
366 ExtendedType baseType = (ExtendedType) testleafType.getBaseType();
367 assertEquals("my-base-int32-type", baseType.getQName().getLocalName());
369 Int32 int32base = (Int32) baseType.getBaseType();
370 List<RangeConstraint> ranges = int32base.getRangeStatements();
371 assertEquals(1, ranges.size());
372 RangeConstraint range = ranges.get(0);
373 assertEquals(2L, range.getMin());
374 assertEquals(20L, range.getMax());
378 public void testTypedefDecimal1() {
379 Module testModule = TestUtils.findModule(modules, "types1");
381 LeafSchemaNode testleaf = (LeafSchemaNode) testModule
382 .getDataChildByName("test-decimal-leaf");
383 ExtendedType type = (ExtendedType) testleaf.getType();
384 assertEquals(4, (int) type.getFractionDigits());
386 Decimal64 baseType = (Decimal64) type.getBaseType();
387 assertEquals(6, (int) baseType.getFractionDigits());
391 public void testTypedefDecimal2() {
392 Module testModule = TestUtils.findModule(modules, "types1");
394 LeafSchemaNode testleaf = (LeafSchemaNode) testModule
395 .getDataChildByName("test-decimal-leaf2");
396 TypeDefinition<?> baseType = testleaf.getType().getBaseType();
397 assertTrue(testleaf.getType().getBaseType() instanceof Decimal64);
398 Decimal64 baseTypeCast = (Decimal64) baseType;
399 assertEquals(5, (int) baseTypeCast.getFractionDigits());
403 public void testTypedefUnion() {
404 Module testModule = TestUtils.findModule(modules, "types1");
406 LeafSchemaNode testleaf = (LeafSchemaNode) testModule
407 .getDataChildByName("union-leaf");
408 ExtendedType testleafType = (ExtendedType) testleaf.getType();
409 assertEquals("my-union-ext", testleafType.getQName().getLocalName());
411 ExtendedType baseType = (ExtendedType) testleafType.getBaseType();
412 assertEquals("my-union", baseType.getQName().getLocalName());
414 UnionType unionBase = (UnionType) baseType.getBaseType();
416 List<TypeDefinition<?>> unionTypes = unionBase.getTypes();
417 Int16 unionType1 = (Int16) unionTypes.get(0);
418 List<RangeConstraint> ranges = unionType1.getRangeStatements();
419 assertEquals(1, ranges.size());
420 RangeConstraint range = ranges.get(0);
421 assertEquals(1L, range.getMin());
422 assertEquals(100L, range.getMax());
424 assertTrue(unionTypes.get(0) instanceof Int16);
425 assertTrue(unionTypes.get(1) instanceof Int32);
429 public void testNestedUnionResolving1() {
430 Module testModule = TestUtils.findModule(modules, "types1");
432 LeafSchemaNode testleaf = (LeafSchemaNode) testModule
433 .getDataChildByName("nested-union-leaf");
435 ExtendedType nestedUnion1 = (ExtendedType) testleaf.getType();
436 assertEquals("nested-union1", nestedUnion1.getQName().getLocalName());
438 ExtendedType nestedUnion2 = (ExtendedType) nestedUnion1.getBaseType();
439 assertEquals("nested-union2", nestedUnion2.getQName().getLocalName());
441 UnionType unionType1 = (UnionType) nestedUnion2.getBaseType();
442 List<TypeDefinition<?>> unionTypes = unionType1.getTypes();
443 assertEquals(2, unionTypes.size());
444 assertTrue(unionTypes.get(0) instanceof StringType);
445 assertTrue(unionTypes.get(1) instanceof ExtendedType);
447 ExtendedType extendedUnion = (ExtendedType) unionTypes.get(1);
448 ExtendedType extendedUnionBase = (ExtendedType) extendedUnion
450 assertEquals("my-union", extendedUnionBase.getQName().getLocalName());
452 UnionType extendedTargetUnion = (UnionType) extendedUnionBase
454 List<TypeDefinition<?>> extendedTargetTypes = extendedTargetUnion
456 assertTrue(extendedTargetTypes.get(0) instanceof Int16);
457 assertTrue(extendedTargetTypes.get(1) instanceof Int32);
459 Int16 int16 = (Int16) extendedTargetTypes.get(0);
460 List<RangeConstraint> ranges = int16.getRangeStatements();
461 assertEquals(1, ranges.size());
462 RangeConstraint range = ranges.get(0);
463 assertEquals(1L, range.getMin());
464 assertEquals(100L, range.getMax());
468 public void testNestedUnionResolving2() {
469 Module testModule = TestUtils.findModule(modules, "types1");
471 LeafSchemaNode testleaf = (LeafSchemaNode) testModule
472 .getDataChildByName("custom-union-leaf");
474 ExtendedType testleafType = (ExtendedType) testleaf.getType();
475 QName testleafTypeQName = testleafType.getQName();
476 assertEquals(URI.create("urn:simple.container.demo.test"),
477 testleafTypeQName.getNamespace());
478 assertEquals(TestUtils.createDate("2013-02-27"),
479 testleafTypeQName.getRevision());
480 assertEquals("t3", testleafTypeQName.getPrefix());
481 assertEquals("union1", testleafTypeQName.getLocalName());
483 ExtendedType union2 = (ExtendedType) testleafType.getBaseType();
484 QName union2QName = union2.getQName();
485 assertEquals(URI.create("urn:simple.container.demo.test"),
486 union2QName.getNamespace());
487 assertEquals(TestUtils.createDate("2013-02-27"),
488 union2QName.getRevision());
489 assertEquals("t3", union2QName.getPrefix());
490 assertEquals("union2", union2QName.getLocalName());
492 UnionType union2Base = (UnionType) union2.getBaseType();
493 List<TypeDefinition<?>> unionTypes = union2Base.getTypes();
494 assertEquals(2, unionTypes.size());
495 assertTrue(unionTypes.get(0) instanceof Int32);
496 assertTrue(unionTypes.get(1) instanceof ExtendedType);
498 ExtendedType nestedUnion2 = (ExtendedType) unionTypes.get(1);
499 QName nestedUnion2QName = nestedUnion2.getQName();
500 assertEquals(URI.create("urn:simple.types.data.demo"),
501 nestedUnion2QName.getNamespace());
502 assertEquals(TestUtils.createDate("2013-02-27"),
503 nestedUnion2QName.getRevision());
504 assertEquals("t2", nestedUnion2QName.getPrefix());
505 assertEquals("nested-union2", nestedUnion2QName.getLocalName());
507 UnionType nestedUnion2Base = (UnionType) nestedUnion2.getBaseType();
508 List<TypeDefinition<?>> nestedUnion2Types = nestedUnion2Base.getTypes();
509 assertEquals(2, nestedUnion2Types.size());
510 assertTrue(nestedUnion2Types.get(0) instanceof StringType);
511 assertTrue(nestedUnion2Types.get(1) instanceof ExtendedType);
513 ExtendedType myUnionExt = (ExtendedType) nestedUnion2Types.get(1);
514 QName myUnionExtQName = myUnionExt.getQName();
515 assertEquals(URI.create("urn:simple.types.data.demo"),
516 myUnionExtQName.getNamespace());
517 assertEquals(TestUtils.createDate("2013-02-27"),
518 myUnionExtQName.getRevision());
519 assertEquals("t2", myUnionExtQName.getPrefix());
520 assertEquals("my-union-ext", myUnionExtQName.getLocalName());
522 ExtendedType myUnion = (ExtendedType) myUnionExt.getBaseType();
523 QName myUnionQName = myUnion.getQName();
524 assertEquals(URI.create("urn:simple.types.data.demo"),
525 myUnionQName.getNamespace());
526 assertEquals(TestUtils.createDate("2013-02-27"),
527 myUnionQName.getRevision());
528 assertEquals("t2", myUnionQName.getPrefix());
529 assertEquals("my-union", myUnionQName.getLocalName());
531 UnionType myUnionBase = (UnionType) myUnion.getBaseType();
532 List<TypeDefinition<?>> myUnionBaseTypes = myUnionBase.getTypes();
533 assertEquals(2, myUnionBaseTypes.size());
534 assertTrue(myUnionBaseTypes.get(0) instanceof Int16);
535 assertTrue(myUnionBaseTypes.get(1) instanceof Int32);
536 Int16 int16 = (Int16) myUnionBaseTypes.get(0);
537 List<RangeConstraint> ranges = int16.getRangeStatements();
538 assertEquals(1, ranges.size());
539 RangeConstraint range = ranges.get(0);
540 assertEquals(1L, range.getMin());
541 assertEquals(100L, range.getMax());
545 public void testRefine() {
546 Module testModule = TestUtils.findModule(modules, "types2");
548 ContainerSchemaNode peer = (ContainerSchemaNode) testModule
549 .getDataChildByName("peer");
550 ContainerSchemaNode destination = (ContainerSchemaNode) peer
551 .getDataChildByName("destination");
552 Set<UsesNode> usesNodes = destination.getUses();
553 assertEquals(1, usesNodes.size());
554 UsesNode usesNode = usesNodes.iterator().next();
555 Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
556 assertEquals(5, refines.size());
558 LeafSchemaNode refineLeaf = null;
559 ContainerSchemaNode refineContainer = null;
560 ListSchemaNode refineList = null;
561 GroupingDefinition refineGrouping = null;
562 TypeDefinition<?> typedef = null;
563 for (Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
564 SchemaNode value = entry.getValue();
565 if (value instanceof LeafSchemaNode) {
566 refineLeaf = (LeafSchemaNode) value;
567 } else if(value instanceof ContainerSchemaNode) {
568 refineContainer = (ContainerSchemaNode) value;
569 } else if(value instanceof ListSchemaNode) {
570 refineList = (ListSchemaNode)value;
571 } else if(value instanceof GroupingDefinition) {
572 refineGrouping = (GroupingDefinition)value;
573 } else if(value instanceof TypeDefinition<?>) {
574 typedef = (TypeDefinition<?>)value;
579 assertNotNull(refineLeaf);
580 assertEquals("address", refineLeaf.getQName().getLocalName());
581 assertEquals("description of address defined by refine",
582 refineLeaf.getDescription());
583 assertEquals("address reference added by refine",
584 refineLeaf.getReference());
585 assertFalse(refineLeaf.isConfiguration());
586 assertTrue(refineLeaf.getConstraints().isMandatory());
587 Set<MustDefinition> leafMustConstraints = refineLeaf.getConstraints()
588 .getMustConstraints();
589 assertEquals(1, leafMustConstraints.size());
590 MustDefinition leafMust = leafMustConstraints.iterator().next();
592 "\"ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)\"",
593 leafMust.toString());
596 assertNotNull(refineContainer);
597 Set<MustDefinition> mustConstraints = refineContainer.getConstraints()
598 .getMustConstraints();
599 assertEquals(1, mustConstraints.size());
600 MustDefinition must = mustConstraints.iterator().next();
601 assertEquals("must-condition", must.toString());
602 assertEquals("An error message test", must.getErrorMessage());
603 assertEquals(("An error app tag test"), must.getErrorAppTag());
604 assertEquals("description of port defined by refine",
605 refineContainer.getDescription());
606 assertEquals("port reference added by refine",
607 refineContainer.getReference());
608 assertFalse(refineContainer.isConfiguration());
609 assertTrue(refineContainer.isPresenceContainer());
612 assertNotNull(refineList);
613 assertEquals("description of addresses defined by refine", refineList.getDescription());
614 assertEquals("addresses reference added by refine", refineList.getReference());
615 assertFalse(refineList.isConfiguration());
616 assertEquals(2, (int)refineList.getConstraints().getMinElements());
617 assertEquals(12, (int)refineList.getConstraints().getMaxElements());
619 // grouping target-inner
620 assertNotNull(refineGrouping);
621 Set<DataSchemaNode> refineGroupingChildren = refineGrouping.getChildNodes();
622 assertEquals(1, refineGroupingChildren.size());
623 LeafSchemaNode refineGroupingLeaf = (LeafSchemaNode)refineGroupingChildren.iterator().next();
624 assertEquals("inner-grouping-id", refineGroupingLeaf.getQName().getLocalName());
625 assertEquals("new target-inner grouping description", refineGrouping.getDescription());
627 // typedef group-type
628 assertNotNull(typedef);
629 assertEquals("new group-type description", typedef.getDescription());
630 assertEquals("new group-type reference", typedef.getReference());
631 assertTrue(typedef.getBaseType() instanceof ExtendedType);
635 public void testChoice() {
636 Module testModule = TestUtils.findModule(modules, "types1");
637 ContainerSchemaNode peer = (ContainerSchemaNode) testModule
638 .getDataChildByName("transfer");
639 ChoiceNode how = (ChoiceNode) peer.getDataChildByName("how");
640 Set<ChoiceCaseNode> cases = how.getCases();
641 assertEquals(3, cases.size());
645 public void testAnyXml() {
646 Module testModule = TestUtils.findModule(modules, "types1");
647 AnyXmlSchemaNode data = (AnyXmlSchemaNode) testModule
648 .getDataChildByName("data");
653 public void testDeviation() {
654 Module testModule = TestUtils.findModule(modules, "types1");
655 Set<Deviation> deviations = testModule.getDeviations();
656 assertEquals(1, deviations.size());
658 Deviation dev = deviations.iterator().next();
659 SchemaPath expectedPath = TestUtils.createPath(true, null, null,
660 "data", "system", "user");
661 assertEquals(expectedPath, dev.getTargetPath());
662 assertEquals(Deviate.ADD, dev.getDeviate());
666 public void testUnknownNode() {
667 Module testModule = TestUtils.findModule(modules, "types3");
668 ContainerSchemaNode network = (ContainerSchemaNode) testModule
669 .getDataChildByName("network");
670 List<UnknownSchemaNode> unknownNodes = network.getUnknownSchemaNodes();
671 assertEquals(1, unknownNodes.size());
672 UnknownSchemaNode unknownNode = unknownNodes.get(0);
673 assertNotNull(unknownNode.getNodeType());
674 assertEquals("point", unknownNode.getNodeParameter());
678 public void testFeature() {
679 Module testModule = TestUtils.findModule(modules, "types3");
680 Set<FeatureDefinition> features = testModule.getFeatures();
681 assertEquals(1, features.size());
685 public void testExtension() {
686 Module testModule = TestUtils.findModule(modules, "types3");
687 List<ExtensionDefinition> extensions = testModule
688 .getExtensionSchemaNodes();
689 assertEquals(1, extensions.size());
690 ExtensionDefinition extension = extensions.get(0);
691 assertEquals("name", extension.getArgument());
692 assertFalse(extension.isYinElement());
696 public void testNotification() {
697 Module testModule = TestUtils.findModule(modules, "types3");
698 URI expectedNamespace = URI.create("urn:simple.container.demo.test");
699 String expectedPrefix = "t3";
700 Date expectedRevision = TestUtils.createDate("2013-02-27");
702 Set<NotificationDefinition> notifications = testModule
704 assertEquals(1, notifications.size());
706 NotificationDefinition notification = notifications.iterator().next();
707 // test SchemaNode args
708 QName expectedQName = new QName(expectedNamespace, expectedRevision,
709 expectedPrefix, "event");
710 assertEquals(expectedQName, notification.getQName());
711 SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace,
712 expectedRevision, expectedPrefix, "event");
713 assertEquals(expectedPath, notification.getPath());
714 assertNull(notification.getDescription());
715 assertNull(notification.getReference());
716 assertEquals(Status.CURRENT, notification.getStatus());
717 assertEquals(0, notification.getUnknownSchemaNodes().size());
718 // test DataNodeContainer args
719 assertEquals(0, notification.getTypeDefinitions().size());
720 assertEquals(3, notification.getChildNodes().size());
721 assertEquals(0, notification.getGroupings().size());
722 assertEquals(0, notification.getUses().size());
724 LeafSchemaNode eventClass = (LeafSchemaNode) notification
725 .getDataChildByName("event-class");
726 assertTrue(eventClass.getType() instanceof StringType);
727 AnyXmlSchemaNode reportingEntity = (AnyXmlSchemaNode) notification
728 .getDataChildByName("reporting-entity");
729 assertNotNull(reportingEntity);
730 LeafSchemaNode severity = (LeafSchemaNode) notification
731 .getDataChildByName("severity");
732 assertTrue(severity.getType() instanceof StringType);
736 public void testRpc() {
737 Module testModule = TestUtils.findModule(modules, "types3");
739 Set<RpcDefinition> rpcs = testModule.getRpcs();
740 assertEquals(1, rpcs.size());
742 RpcDefinition rpc = rpcs.iterator().next();
743 assertEquals("Retrieve all or part of a specified configuration.",
744 rpc.getDescription());
745 assertEquals("RFC 6241, Section 7.1", rpc.getReference());
747 ContainerSchemaNode input = rpc.getInput();
748 assertNotNull(input.getDataChildByName("source"));
749 assertNotNull(input.getDataChildByName("filter"));
750 ContainerSchemaNode output = rpc.getOutput();
751 assertNotNull(output.getDataChildByName("data"));
755 public void testGrouping() {
756 Module testModule = TestUtils.findModule(modules, "types2");
757 Set<GroupingDefinition> groupings = testModule.getGroupings();
758 assertEquals(1, groupings.size());
759 GroupingDefinition grouping = groupings.iterator().next();
760 Set<DataSchemaNode> children = grouping.getChildNodes();
761 assertEquals(5, children.size());