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.yangtools.yang.parser.impl;
10 import static org.junit.Assert.*;
13 import java.io.FileNotFoundException;
15 import java.text.ParseException;
16 import java.util.ArrayList;
17 import java.util.Date;
18 import java.util.List;
21 import org.junit.Before;
22 import org.junit.Test;
23 import org.opendaylight.yangtools.yang.common.QName;
24 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
25 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
26 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
27 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
28 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
29 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
30 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
31 import org.opendaylight.yangtools.yang.model.api.Deviation;
32 import org.opendaylight.yangtools.yang.model.api.Deviation.Deviate;
33 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
34 import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
35 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
36 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
37 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
38 import org.opendaylight.yangtools.yang.model.api.Module;
39 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
40 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
41 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
42 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
43 import org.opendaylight.yangtools.yang.model.api.Status;
44 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
45 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
46 import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
47 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
48 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
49 import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
50 import org.opendaylight.yangtools.yang.model.util.Decimal64;
51 import org.opendaylight.yangtools.yang.model.util.ExtendedType;
52 import org.opendaylight.yangtools.yang.model.util.Int16;
53 import org.opendaylight.yangtools.yang.model.util.Int32;
54 import org.opendaylight.yangtools.yang.model.util.StringType;
55 import org.opendaylight.yangtools.yang.model.util.Uint32;
56 import org.opendaylight.yangtools.yang.model.util.UnionType;
58 public class YangParserTest {
59 private final URI fooNS = URI.create("urn:opendaylight.foo");
60 private final URI barNS = URI.create("urn:opendaylight.bar");
61 private final URI bazNS = URI.create("urn:opendaylight.baz");
66 private Set<Module> modules;
69 public void init() throws FileNotFoundException, ParseException {
70 fooRev = TestUtils.simpleDateFormat.parse("2013-02-27");
71 barRev = TestUtils.simpleDateFormat.parse("2013-07-03");
72 bazRev = TestUtils.simpleDateFormat.parse("2013-02-27");
74 modules = TestUtils.loadModules(getClass().getResource("/model").getPath());
75 assertEquals(3, modules.size());
79 public void testHeaders() throws ParseException {
80 Module foo = TestUtils.findModule(modules, "foo");
82 assertEquals("foo", foo.getName());
83 assertEquals("1", foo.getYangVersion());
84 assertEquals(fooNS, foo.getNamespace());
85 assertEquals("foo", foo.getPrefix());
87 Set<ModuleImport> imports = foo.getImports();
88 assertEquals(2, imports.size());
90 ModuleImport import2 = TestUtils.findImport(imports, "br");
91 assertEquals("bar", import2.getModuleName());
92 assertEquals(barRev, import2.getRevision());
94 ModuleImport import3 = TestUtils.findImport(imports, "bz");
95 assertEquals("baz", import3.getModuleName());
96 assertEquals(bazRev, import3.getRevision());
98 assertEquals("opendaylight", foo.getOrganization());
99 assertEquals("http://www.opendaylight.org/", foo.getContact());
100 Date expectedRevision = TestUtils.createDate("2013-02-27");
101 assertEquals(expectedRevision, foo.getRevision());
102 assertEquals(" WILL BE DEFINED LATER", foo.getReference());
106 public void testOrderingTypedef() {
107 Module bar = TestUtils.findModule(modules, "bar");
108 Set<TypeDefinition<?>> typedefs = bar.getTypeDefinitions();
109 String[] expectedOrder = new String[] { "int32-ext1", "int32-ext2", "my-decimal-type", "my-union",
110 "my-union-ext", "nested-union2", "string-ext1", "string-ext2", "string-ext3", "string-ext4" };
111 String[] actualOrder = new String[typedefs.size()];
114 for (TypeDefinition<?> type : typedefs) {
115 actualOrder[i] = type.getQName().getLocalName();
118 assertArrayEquals(expectedOrder, actualOrder);
122 public void testOrderingChildNodes() {
123 Module foo = TestUtils.findModule(modules, "foo");
124 AugmentationSchema augment1 = null;
125 for (AugmentationSchema as : foo.getAugmentations()) {
126 if ("if:ifType='ds0'".equals(as.getWhenCondition().toString())) {
131 assertNotNull(augment1);
133 String[] expectedOrder = new String[] { "ds0ChannelNumber", "interface-id", "my-type", "odl", "schemas" };
134 String[] actualOrder = new String[expectedOrder.length];
137 for (DataSchemaNode augmentChild : augment1.getChildNodes()) {
138 actualOrder[i] = augmentChild.getQName().getLocalName();
142 assertArrayEquals(expectedOrder, actualOrder);
146 public void testOrderingNestedChildNodes1() {
147 Module foo = TestUtils.findModule(modules, "foo");
149 Set<DataSchemaNode> childNodes = foo.getChildNodes();
150 String[] expectedOrder = new String[] { "address", "addresses", "custom-union-leaf", "data", "datas",
151 "decimal-leaf", "decimal-leaf2", "ext", "how", "int32-leaf", "length-leaf", "mycont", "peer", "port",
152 "string-leaf", "transfer", "union-leaf" };
153 String[] actualOrder = new String[childNodes.size()];
156 for (DataSchemaNode child : childNodes) {
157 actualOrder[i] = child.getQName().getLocalName();
160 assertArrayEquals(expectedOrder, actualOrder);
164 public void testOrderingNestedChildNodes2() {
165 Module baz = TestUtils.findModule(modules, "baz");
166 Set<GroupingDefinition> groupings = baz.getGroupings();
167 assertEquals(1, groupings.size());
168 GroupingDefinition target = groupings.iterator().next();
170 Set<DataSchemaNode> childNodes = target.getChildNodes();
171 String[] expectedOrder = new String[] { "address", "addresses", "data", "how", "port" };
172 String[] actualOrder = new String[childNodes.size()];
175 for (DataSchemaNode child : childNodes) {
176 actualOrder[i] = child.getQName().getLocalName();
179 assertArrayEquals(expectedOrder, actualOrder);
183 public void testParseList() {
184 Module bar = TestUtils.findModule(modules, "bar");
185 URI expectedNamespace = URI.create("urn:opendaylight.bar");
186 String expectedPrefix = "bar";
188 ContainerSchemaNode interfaces = (ContainerSchemaNode) bar.getDataChildByName("interfaces");
190 ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry");
191 // test SchemaNode args
192 QName expectedQName = new QName(expectedNamespace, barRev, expectedPrefix, "ifEntry");
193 assertEquals(expectedQName, ifEntry.getQName());
194 SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace, barRev, expectedPrefix, "interfaces",
196 assertEquals(expectedPath, ifEntry.getPath());
197 assertNull(ifEntry.getDescription());
198 assertNull(ifEntry.getReference());
199 assertEquals(Status.CURRENT, ifEntry.getStatus());
200 assertEquals(0, ifEntry.getUnknownSchemaNodes().size());
201 // test DataSchemaNode args
202 assertFalse(ifEntry.isAugmenting());
203 assertTrue(ifEntry.isConfiguration());
204 ConstraintDefinition constraints = ifEntry.getConstraints();
205 assertNull(constraints.getWhenCondition());
206 assertEquals(0, constraints.getMustConstraints().size());
207 assertFalse(constraints.isMandatory());
208 assertEquals(1, (int) constraints.getMinElements());
209 assertEquals(11, (int) constraints.getMaxElements());
210 // test AugmentationTarget args
211 Set<AugmentationSchema> availableAugmentations = ifEntry.getAvailableAugmentations();
212 assertEquals(2, availableAugmentations.size());
213 // test ListSchemaNode args
214 List<QName> expectedKey = new ArrayList<>();
215 expectedKey.add(new QName(expectedNamespace, barRev, expectedPrefix, "ifIndex"));
216 assertEquals(expectedKey, ifEntry.getKeyDefinition());
217 assertFalse(ifEntry.isUserOrdered());
218 // test DataNodeContainer args
219 assertEquals(0, ifEntry.getTypeDefinitions().size());
220 assertEquals(4, ifEntry.getChildNodes().size());
221 assertEquals(0, ifEntry.getGroupings().size());
222 assertEquals(0, ifEntry.getUses().size());
224 LeafSchemaNode ifIndex = (LeafSchemaNode) ifEntry.getDataChildByName("ifIndex");
225 assertTrue(ifIndex.getType() instanceof Uint32);
226 LeafSchemaNode ifMtu = (LeafSchemaNode) ifEntry.getDataChildByName("ifMtu");
227 assertTrue(ifMtu.getType() instanceof Int32);
231 public void testTypedefRangesResolving() throws ParseException {
232 Module foo = TestUtils.findModule(modules, "foo");
233 LeafSchemaNode int32Leaf = (LeafSchemaNode) foo.getDataChildByName("int32-leaf");
235 ExtendedType leafType = (ExtendedType) int32Leaf.getType();
236 QName leafTypeQName = leafType.getQName();
237 assertEquals("int32-ext2", leafTypeQName.getLocalName());
238 assertEquals("foo", leafTypeQName.getPrefix());
239 assertEquals(fooNS, leafTypeQName.getNamespace());
240 assertEquals(fooRev, leafTypeQName.getRevision());
241 assertNull(leafType.getUnits());
242 assertNull(leafType.getDefaultValue());
243 assertTrue(leafType.getLengthConstraints().isEmpty());
244 assertTrue(leafType.getPatternConstraints().isEmpty());
245 List<RangeConstraint> ranges = leafType.getRangeConstraints();
246 assertEquals(1, ranges.size());
247 RangeConstraint range = ranges.get(0);
248 assertEquals(12L, range.getMin());
249 assertEquals(20L, range.getMax());
251 ExtendedType baseType = (ExtendedType) leafType.getBaseType();
252 QName baseTypeQName = baseType.getQName();
253 assertEquals("int32-ext2", baseTypeQName.getLocalName());
254 assertEquals("bar", baseTypeQName.getPrefix());
255 assertEquals(barNS, baseTypeQName.getNamespace());
256 assertEquals(barRev, baseTypeQName.getRevision());
257 assertEquals("mile", baseType.getUnits());
258 assertEquals("11", baseType.getDefaultValue());
259 assertTrue(leafType.getLengthConstraints().isEmpty());
260 assertTrue(leafType.getPatternConstraints().isEmpty());
261 List<RangeConstraint> baseTypeRanges = baseType.getRangeConstraints();
262 assertEquals(2, baseTypeRanges.size());
263 RangeConstraint baseTypeRange1 = baseTypeRanges.get(0);
264 assertEquals(3L, baseTypeRange1.getMin());
265 assertEquals(9L, baseTypeRange1.getMax());
266 RangeConstraint baseTypeRange2 = baseTypeRanges.get(1);
267 assertEquals(11L, baseTypeRange2.getMin());
268 assertEquals(20L, baseTypeRange2.getMax());
270 ExtendedType base = (ExtendedType) baseType.getBaseType();
271 QName baseQName = base.getQName();
272 assertEquals("int32-ext1", baseQName.getLocalName());
273 assertEquals("bar", baseQName.getPrefix());
274 assertEquals(barNS, baseQName.getNamespace());
275 assertEquals(barRev, baseQName.getRevision());
276 assertNull(base.getUnits());
277 assertNull(base.getDefaultValue());
278 assertTrue(leafType.getLengthConstraints().isEmpty());
279 assertTrue(leafType.getPatternConstraints().isEmpty());
280 List<RangeConstraint> baseRanges = base.getRangeConstraints();
281 assertEquals(1, baseRanges.size());
282 RangeConstraint baseRange = baseRanges.get(0);
283 assertEquals(2L, baseRange.getMin());
284 assertEquals(20L, baseRange.getMax());
286 assertTrue(base.getBaseType() instanceof Int32);
290 public void testTypedefPatternsResolving() {
291 Module foo = TestUtils.findModule(modules, "foo");
292 LeafSchemaNode stringleaf = (LeafSchemaNode) foo.getDataChildByName("string-leaf");
294 ExtendedType type = (ExtendedType) stringleaf.getType();
295 QName typeQName = type.getQName();
296 assertEquals("string-ext4", typeQName.getLocalName());
297 assertEquals("bar", typeQName.getPrefix());
298 assertEquals(barNS, typeQName.getNamespace());
299 assertEquals(barRev, typeQName.getRevision());
300 assertNull(type.getUnits());
301 assertNull(type.getDefaultValue());
302 List<PatternConstraint> patterns = type.getPatternConstraints();
303 assertEquals(1, patterns.size());
304 PatternConstraint pattern = patterns.iterator().next();
305 assertEquals("[e-z]*", pattern.getRegularExpression());
306 assertTrue(type.getLengthConstraints().isEmpty());
307 assertTrue(type.getRangeConstraints().isEmpty());
309 ExtendedType baseType1 = (ExtendedType) type.getBaseType();
310 QName baseType1QName = baseType1.getQName();
311 assertEquals("string-ext3", baseType1QName.getLocalName());
312 assertEquals("bar", baseType1QName.getPrefix());
313 assertEquals(barNS, baseType1QName.getNamespace());
314 assertEquals(barRev, baseType1QName.getRevision());
315 assertNull(baseType1.getUnits());
316 assertNull(baseType1.getDefaultValue());
317 patterns = baseType1.getPatternConstraints();
318 assertEquals(1, patterns.size());
319 pattern = patterns.iterator().next();
320 assertEquals("[b-u]*", pattern.getRegularExpression());
321 assertTrue(baseType1.getLengthConstraints().isEmpty());
322 assertTrue(baseType1.getRangeConstraints().isEmpty());
324 ExtendedType baseType2 = (ExtendedType) baseType1.getBaseType();
325 QName baseType2QName = baseType2.getQName();
326 assertEquals("string-ext2", baseType2QName.getLocalName());
327 assertEquals("bar", baseType2QName.getPrefix());
328 assertEquals(barNS, baseType2QName.getNamespace());
329 assertEquals(barRev, baseType2QName.getRevision());
330 assertNull(baseType2.getUnits());
331 assertNull(baseType2.getDefaultValue());
332 assertTrue(baseType2.getPatternConstraints().isEmpty());
333 List<LengthConstraint> baseType2Lengths = baseType2.getLengthConstraints();
334 assertEquals(1, baseType2Lengths.size());
335 LengthConstraint length = baseType2Lengths.get(0);
336 assertEquals(6L, length.getMin());
337 assertEquals(10L, length.getMax());
338 assertTrue(baseType2.getRangeConstraints().isEmpty());
340 ExtendedType baseType3 = (ExtendedType) baseType2.getBaseType();
341 QName baseType3QName = baseType3.getQName();
342 assertEquals("string-ext1", baseType3QName.getLocalName());
343 assertEquals("bar", baseType3QName.getPrefix());
344 assertEquals(barNS, baseType3QName.getNamespace());
345 assertEquals(barRev, baseType3QName.getRevision());
346 assertNull(baseType3.getUnits());
347 assertNull(baseType3.getDefaultValue());
348 patterns = baseType3.getPatternConstraints();
349 assertEquals(1, patterns.size());
350 pattern = patterns.iterator().next();
351 assertEquals("[a-k]*", pattern.getRegularExpression());
352 List<LengthConstraint> baseType3Lengths = baseType3.getLengthConstraints();
353 assertEquals(1, baseType3Lengths.size());
354 length = baseType3Lengths.get(0);
355 assertEquals(5L, length.getMin());
356 assertEquals(11L, length.getMax());
357 assertTrue(baseType3.getRangeConstraints().isEmpty());
359 assertTrue(baseType3.getBaseType() instanceof StringType);
363 public void testTypedefLengthsResolving() {
364 Module foo = TestUtils.findModule(modules, "foo");
366 LeafSchemaNode lengthLeaf = (LeafSchemaNode) foo.getDataChildByName("length-leaf");
367 ExtendedType type = (ExtendedType) lengthLeaf.getType();
369 QName typeQName = type.getQName();
370 assertEquals("string-ext2", typeQName.getLocalName());
371 assertEquals("foo", typeQName.getPrefix());
372 assertEquals(fooNS, typeQName.getNamespace());
373 assertEquals(fooRev, typeQName.getRevision());
374 assertNull(type.getUnits());
375 assertNull(type.getDefaultValue());
376 assertTrue(type.getPatternConstraints().isEmpty());
377 List<LengthConstraint> typeLengths = type.getLengthConstraints();
378 assertEquals(1, typeLengths.size());
379 LengthConstraint length = typeLengths.get(0);
380 assertEquals(7L, length.getMin());
381 assertEquals(10L, length.getMax());
382 assertTrue(type.getRangeConstraints().isEmpty());
384 ExtendedType baseType1 = (ExtendedType) type.getBaseType();
385 QName baseType1QName = baseType1.getQName();
386 assertEquals("string-ext2", baseType1QName.getLocalName());
387 assertEquals("bar", baseType1QName.getPrefix());
388 assertEquals(barNS, baseType1QName.getNamespace());
389 assertEquals(barRev, baseType1QName.getRevision());
390 assertNull(baseType1.getUnits());
391 assertNull(baseType1.getDefaultValue());
392 assertTrue(baseType1.getPatternConstraints().isEmpty());
393 List<LengthConstraint> baseType2Lengths = baseType1.getLengthConstraints();
394 assertEquals(1, baseType2Lengths.size());
395 length = baseType2Lengths.get(0);
396 assertEquals(6L, length.getMin());
397 assertEquals(10L, length.getMax());
398 assertTrue(baseType1.getRangeConstraints().isEmpty());
400 ExtendedType baseType2 = (ExtendedType) baseType1.getBaseType();
401 QName baseType2QName = baseType2.getQName();
402 assertEquals("string-ext1", baseType2QName.getLocalName());
403 assertEquals("bar", baseType2QName.getPrefix());
404 assertEquals(barNS, baseType2QName.getNamespace());
405 assertEquals(barRev, baseType2QName.getRevision());
406 assertNull(baseType2.getUnits());
407 assertNull(baseType2.getDefaultValue());
408 List<PatternConstraint> patterns = baseType2.getPatternConstraints();
409 assertEquals(1, patterns.size());
410 PatternConstraint pattern = patterns.iterator().next();
411 assertEquals("[a-k]*", pattern.getRegularExpression());
412 List<LengthConstraint> baseType3Lengths = baseType2.getLengthConstraints();
413 assertEquals(1, baseType3Lengths.size());
414 length = baseType3Lengths.get(0);
415 assertEquals(5L, length.getMin());
416 assertEquals(11L, length.getMax());
417 assertTrue(baseType2.getRangeConstraints().isEmpty());
419 assertTrue(baseType2.getBaseType() instanceof StringType);
423 public void testTypedefDecimal1() {
424 Module foo = TestUtils.findModule(modules, "foo");
425 LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName("decimal-leaf");
427 ExtendedType type = (ExtendedType) testleaf.getType();
428 QName typeQName = type.getQName();
429 assertEquals("my-decimal-type", typeQName.getLocalName());
430 assertEquals("foo", typeQName.getPrefix());
431 assertEquals(fooNS, typeQName.getNamespace());
432 assertEquals(fooRev, typeQName.getRevision());
433 assertNull(type.getUnits());
434 assertNull(type.getDefaultValue());
435 assertEquals(4, (int) type.getFractionDigits());
436 assertTrue(type.getLengthConstraints().isEmpty());
437 assertTrue(type.getPatternConstraints().isEmpty());
438 assertTrue(type.getRangeConstraints().isEmpty());
440 ExtendedType typeBase = (ExtendedType) type.getBaseType();
441 QName typeBaseQName = typeBase.getQName();
442 assertEquals("my-decimal-type", typeBaseQName.getLocalName());
443 assertEquals("bar", typeBaseQName.getPrefix());
444 assertEquals(barNS, typeBaseQName.getNamespace());
445 assertEquals(barRev, typeBaseQName.getRevision());
446 assertNull(typeBase.getUnits());
447 assertNull(typeBase.getDefaultValue());
448 assertNull(typeBase.getFractionDigits());
449 assertTrue(typeBase.getLengthConstraints().isEmpty());
450 assertTrue(typeBase.getPatternConstraints().isEmpty());
451 assertTrue(typeBase.getRangeConstraints().isEmpty());
453 Decimal64 decimal = (Decimal64) typeBase.getBaseType();
454 assertEquals(6, (int) decimal.getFractionDigits());
458 public void testTypedefDecimal2() {
459 Module foo = TestUtils.findModule(modules, "foo");
460 LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName("decimal-leaf2");
462 ExtendedType type = (ExtendedType) testleaf.getType();
463 QName typeQName = type.getQName();
464 assertEquals("my-decimal-type", typeQName.getLocalName());
465 assertEquals("bar", typeQName.getPrefix());
466 assertEquals(barNS, typeQName.getNamespace());
467 assertEquals(barRev, typeQName.getRevision());
468 assertNull(type.getUnits());
469 assertNull(type.getDefaultValue());
470 assertNull(type.getFractionDigits());
471 assertTrue(type.getLengthConstraints().isEmpty());
472 assertTrue(type.getPatternConstraints().isEmpty());
473 assertTrue(type.getRangeConstraints().isEmpty());
475 Decimal64 baseTypeDecimal = (Decimal64) type.getBaseType();
476 assertEquals(6, (int) baseTypeDecimal.getFractionDigits());
480 public void testTypedefUnion() {
481 Module foo = TestUtils.findModule(modules, "foo");
482 LeafSchemaNode unionleaf = (LeafSchemaNode) foo.getDataChildByName("union-leaf");
484 ExtendedType type = (ExtendedType) unionleaf.getType();
485 QName typeQName = type.getQName();
486 assertEquals("my-union-ext", typeQName.getLocalName());
487 assertEquals("bar", typeQName.getPrefix());
488 assertEquals(barNS, typeQName.getNamespace());
489 assertEquals(barRev, typeQName.getRevision());
490 assertNull(type.getUnits());
491 assertNull(type.getDefaultValue());
492 assertNull(type.getFractionDigits());
493 assertTrue(type.getLengthConstraints().isEmpty());
494 assertTrue(type.getPatternConstraints().isEmpty());
495 assertTrue(type.getRangeConstraints().isEmpty());
497 ExtendedType baseType = (ExtendedType) type.getBaseType();
498 QName baseTypeQName = baseType.getQName();
499 assertEquals("my-union", baseTypeQName.getLocalName());
500 assertEquals("bar", baseTypeQName.getPrefix());
501 assertEquals(barNS, baseTypeQName.getNamespace());
502 assertEquals(barRev, baseTypeQName.getRevision());
503 assertNull(baseType.getUnits());
504 assertNull(baseType.getDefaultValue());
505 assertNull(baseType.getFractionDigits());
506 assertTrue(baseType.getLengthConstraints().isEmpty());
507 assertTrue(baseType.getPatternConstraints().isEmpty());
508 assertTrue(baseType.getRangeConstraints().isEmpty());
510 UnionType unionType = (UnionType) baseType.getBaseType();
511 List<TypeDefinition<?>> unionTypes = unionType.getTypes();
512 assertEquals(2, unionTypes.size());
514 ExtendedType unionType1 = (ExtendedType) unionTypes.get(0);
515 QName unionType1QName = baseType.getQName();
516 assertEquals("my-union", unionType1QName.getLocalName());
517 assertEquals("bar", unionType1QName.getPrefix());
518 assertEquals(barNS, unionType1QName.getNamespace());
519 assertEquals(barRev, unionType1QName.getRevision());
520 assertNull(unionType1.getUnits());
521 assertNull(unionType1.getDefaultValue());
522 assertNull(unionType1.getFractionDigits());
523 assertTrue(unionType1.getLengthConstraints().isEmpty());
524 assertTrue(unionType1.getPatternConstraints().isEmpty());
525 List<RangeConstraint> ranges = unionType1.getRangeConstraints();
526 assertEquals(1, ranges.size());
527 RangeConstraint range = ranges.get(0);
528 assertEquals(1L, range.getMin());
529 assertEquals(100L, range.getMax());
530 assertTrue(unionType1.getBaseType() instanceof Int16);
532 assertTrue(unionTypes.get(1) instanceof Int32);
536 public void testNestedUnionResolving() {
537 Module foo = TestUtils.findModule(modules, "foo");
538 LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName("custom-union-leaf");
540 ExtendedType type = (ExtendedType) testleaf.getType();
541 QName testleafTypeQName = type.getQName();
542 assertEquals(bazNS, testleafTypeQName.getNamespace());
543 assertEquals(bazRev, testleafTypeQName.getRevision());
544 assertEquals("baz", testleafTypeQName.getPrefix());
545 assertEquals("union1", testleafTypeQName.getLocalName());
546 assertNull(type.getUnits());
547 assertNull(type.getDefaultValue());
548 assertNull(type.getFractionDigits());
549 assertTrue(type.getLengthConstraints().isEmpty());
550 assertTrue(type.getPatternConstraints().isEmpty());
551 assertTrue(type.getRangeConstraints().isEmpty());
553 ExtendedType typeBase = (ExtendedType) type.getBaseType();
554 QName typeBaseQName = typeBase.getQName();
555 assertEquals(bazNS, typeBaseQName.getNamespace());
556 assertEquals(bazRev, typeBaseQName.getRevision());
557 assertEquals("baz", typeBaseQName.getPrefix());
558 assertEquals("union2", typeBaseQName.getLocalName());
559 assertNull(typeBase.getUnits());
560 assertNull(typeBase.getDefaultValue());
561 assertNull(typeBase.getFractionDigits());
562 assertTrue(typeBase.getLengthConstraints().isEmpty());
563 assertTrue(typeBase.getPatternConstraints().isEmpty());
564 assertTrue(typeBase.getRangeConstraints().isEmpty());
566 UnionType union = (UnionType) typeBase.getBaseType();
567 List<TypeDefinition<?>> unionTypes = union.getTypes();
568 assertEquals(2, unionTypes.size());
569 assertTrue(unionTypes.get(0) instanceof Int32);
570 assertTrue(unionTypes.get(1) instanceof ExtendedType);
572 ExtendedType unionType1 = (ExtendedType) unionTypes.get(1);
573 QName uniontType1QName = unionType1.getQName();
574 assertEquals(barNS, uniontType1QName.getNamespace());
575 assertEquals(barRev, uniontType1QName.getRevision());
576 assertEquals("bar", uniontType1QName.getPrefix());
577 assertEquals("nested-union2", uniontType1QName.getLocalName());
578 assertNull(unionType1.getUnits());
579 assertNull(unionType1.getDefaultValue());
580 assertNull(unionType1.getFractionDigits());
581 assertTrue(unionType1.getLengthConstraints().isEmpty());
582 assertTrue(unionType1.getPatternConstraints().isEmpty());
583 assertTrue(unionType1.getRangeConstraints().isEmpty());
585 UnionType nestedUnion = (UnionType) unionType1.getBaseType();
586 List<TypeDefinition<?>> nestedUnion2Types = nestedUnion.getTypes();
587 assertEquals(2, nestedUnion2Types.size());
588 assertTrue(nestedUnion2Types.get(0) instanceof StringType);
589 assertTrue(nestedUnion2Types.get(1) instanceof ExtendedType);
591 ExtendedType myUnionExt = (ExtendedType) nestedUnion2Types.get(1);
592 QName myUnionExtQName = myUnionExt.getQName();
593 assertEquals(barNS, myUnionExtQName.getNamespace());
594 assertEquals(barRev, myUnionExtQName.getRevision());
595 assertEquals("bar", myUnionExtQName.getPrefix());
596 assertEquals("my-union-ext", myUnionExtQName.getLocalName());
597 assertNull(myUnionExt.getUnits());
598 assertNull(myUnionExt.getDefaultValue());
599 assertNull(myUnionExt.getFractionDigits());
600 assertTrue(myUnionExt.getLengthConstraints().isEmpty());
601 assertTrue(myUnionExt.getPatternConstraints().isEmpty());
602 assertTrue(myUnionExt.getRangeConstraints().isEmpty());
604 ExtendedType myUnion = (ExtendedType) myUnionExt.getBaseType();
605 QName myUnionQName = myUnion.getQName();
606 assertEquals(barNS, myUnionQName.getNamespace());
607 assertEquals(barRev, myUnionQName.getRevision());
608 assertEquals("bar", myUnionQName.getPrefix());
609 assertEquals("my-union", myUnionQName.getLocalName());
610 assertNull(myUnion.getUnits());
611 assertNull(myUnion.getDefaultValue());
612 assertNull(myUnion.getFractionDigits());
613 assertTrue(myUnion.getLengthConstraints().isEmpty());
614 assertTrue(myUnion.getPatternConstraints().isEmpty());
615 assertTrue(myUnion.getRangeConstraints().isEmpty());
617 UnionType myUnionBase = (UnionType) myUnion.getBaseType();
618 List<TypeDefinition<?>> myUnionBaseTypes = myUnionBase.getTypes();
619 assertEquals(2, myUnionBaseTypes.size());
620 assertTrue(myUnionBaseTypes.get(0) instanceof ExtendedType);
621 assertTrue(myUnionBaseTypes.get(1) instanceof Int32);
623 ExtendedType int16Ext = (ExtendedType) myUnionBaseTypes.get(0);
624 QName int16ExtQName = int16Ext.getQName();
625 assertEquals(barNS, int16ExtQName.getNamespace());
626 assertEquals(barRev, int16ExtQName.getRevision());
627 assertEquals("bar", int16ExtQName.getPrefix());
628 assertEquals("int16", int16ExtQName.getLocalName());
629 assertNull(int16Ext.getUnits());
630 assertNull(int16Ext.getDefaultValue());
631 assertNull(int16Ext.getFractionDigits());
632 assertTrue(int16Ext.getLengthConstraints().isEmpty());
633 assertTrue(int16Ext.getPatternConstraints().isEmpty());
634 List<RangeConstraint> ranges = int16Ext.getRangeConstraints();
635 assertEquals(1, ranges.size());
636 RangeConstraint range = ranges.get(0);
637 assertEquals(1L, range.getMin());
638 assertEquals(100L, range.getMax());
640 assertTrue(int16Ext.getBaseType() instanceof Int16);
644 public void testChoice() {
645 Module foo = TestUtils.findModule(modules, "foo");
646 ContainerSchemaNode transfer = (ContainerSchemaNode) foo.getDataChildByName("transfer");
647 ChoiceNode how = (ChoiceNode) transfer.getDataChildByName("how");
648 Set<ChoiceCaseNode> cases = how.getCases();
649 assertEquals(5, cases.size());
650 ChoiceCaseNode input = null;
651 ChoiceCaseNode output = null;
652 for (ChoiceCaseNode caseNode : cases) {
653 if ("input".equals(caseNode.getQName().getLocalName())) {
655 } else if ("output".equals(caseNode.getQName().getLocalName())) {
659 assertNotNull(input);
660 assertNotNull(input.getPath());
661 assertNotNull(output);
662 assertNotNull(output.getPath());
666 public void testDeviation() {
667 Module foo = TestUtils.findModule(modules, "foo");
668 Set<Deviation> deviations = foo.getDeviations();
669 assertEquals(1, deviations.size());
670 Deviation dev = deviations.iterator().next();
671 assertEquals("system/user ref", dev.getReference());
673 List<QName> path = new ArrayList<>();
674 path.add(new QName(barNS, barRev, "br", "interfaces"));
675 path.add(new QName(barNS, barRev, "br", "ifEntry"));
676 SchemaPath expectedPath = new SchemaPath(path, true);
678 assertEquals(expectedPath, dev.getTargetPath());
679 assertEquals(Deviate.ADD, dev.getDeviate());
683 public void testUnknownNode() {
684 Module baz = TestUtils.findModule(modules, "baz");
685 ContainerSchemaNode network = (ContainerSchemaNode) baz.getDataChildByName("network");
686 List<UnknownSchemaNode> unknownNodes = network.getUnknownSchemaNodes();
687 assertEquals(1, unknownNodes.size());
688 UnknownSchemaNode unknownNode = unknownNodes.get(0);
689 assertNotNull(unknownNode.getNodeType());
690 assertEquals("point", unknownNode.getNodeParameter());
694 public void testFeature() {
695 Module baz = TestUtils.findModule(modules, "baz");
696 Set<FeatureDefinition> features = baz.getFeatures();
697 assertEquals(1, features.size());
701 public void testExtension() {
702 Module baz = TestUtils.findModule(modules, "baz");
703 List<ExtensionDefinition> extensions = baz.getExtensionSchemaNodes();
704 assertEquals(1, extensions.size());
705 ExtensionDefinition extension = extensions.get(0);
706 assertEquals("name", extension.getArgument());
707 assertTrue(extension.isYinElement());
711 public void testNotification() {
712 Module baz = TestUtils.findModule(modules, "baz");
713 String expectedPrefix = "c";
715 Set<NotificationDefinition> notifications = baz.getNotifications();
716 assertEquals(1, notifications.size());
718 NotificationDefinition notification = notifications.iterator().next();
719 // test SchemaNode args
720 QName expectedQName = new QName(bazNS, bazRev, expectedPrefix, "event");
721 assertEquals(expectedQName, notification.getQName());
722 SchemaPath expectedPath = TestUtils.createPath(true, bazNS, bazRev, expectedPrefix, "event");
723 assertEquals(expectedPath, notification.getPath());
724 assertNull(notification.getDescription());
725 assertNull(notification.getReference());
726 assertEquals(Status.CURRENT, notification.getStatus());
727 assertEquals(0, notification.getUnknownSchemaNodes().size());
728 // test DataNodeContainer args
729 assertEquals(0, notification.getTypeDefinitions().size());
730 assertEquals(3, notification.getChildNodes().size());
731 assertEquals(0, notification.getGroupings().size());
732 assertEquals(0, notification.getUses().size());
734 LeafSchemaNode eventClass = (LeafSchemaNode) notification.getDataChildByName("event-class");
735 assertTrue(eventClass.getType() instanceof StringType);
736 AnyXmlSchemaNode reportingEntity = (AnyXmlSchemaNode) notification.getDataChildByName("reporting-entity");
737 assertNotNull(reportingEntity);
738 LeafSchemaNode severity = (LeafSchemaNode) notification.getDataChildByName("severity");
739 assertTrue(severity.getType() instanceof StringType);
743 public void testRpc() {
744 Module baz = TestUtils.findModule(modules, "baz");
746 Set<RpcDefinition> rpcs = baz.getRpcs();
747 assertEquals(1, rpcs.size());
749 RpcDefinition rpc = rpcs.iterator().next();
750 assertEquals("Retrieve all or part of a specified configuration.", rpc.getDescription());
751 assertEquals("RFC 6241, Section 7.1", rpc.getReference());
753 ContainerSchemaNode input = rpc.getInput();
754 assertNotNull(input.getDataChildByName("source"));
755 assertNotNull(input.getDataChildByName("filter"));
756 ContainerSchemaNode output = rpc.getOutput();
757 assertNotNull(output.getDataChildByName("data"));
761 public void testTypePath() throws ParseException {
762 Module bar = TestUtils.findModule(modules, "bar");
763 Set<TypeDefinition<?>> types = bar.getTypeDefinitions();
766 ExtendedType int32ext1 = (ExtendedType) TestUtils.findTypedef(types, "int32-ext1");
767 QName int32TypedefQName = int32ext1.getQName();
769 assertEquals(barNS, int32TypedefQName.getNamespace());
770 assertEquals(barRev, int32TypedefQName.getRevision());
771 assertEquals("bar", int32TypedefQName.getPrefix());
772 assertEquals("int32-ext1", int32TypedefQName.getLocalName());
774 SchemaPath typeSchemaPath = int32ext1.getPath();
775 List<QName> typePath = typeSchemaPath.getPath();
776 assertEquals(1, typePath.size());
777 assertEquals(int32TypedefQName, typePath.get(0));
780 Int32 int32 = (Int32) int32ext1.getBaseType();
781 assertEquals(Int32.getInstance(), int32);
785 public void testTypePath2() throws ParseException {
786 Module bar = TestUtils.findModule(modules, "bar");
787 Set<TypeDefinition<?>> types = bar.getTypeDefinitions();
790 ExtendedType myDecType = (ExtendedType) TestUtils.findTypedef(types, "my-decimal-type");
791 QName myDecTypeQName = myDecType.getQName();
793 assertEquals(barNS, myDecTypeQName.getNamespace());
794 assertEquals(barRev, myDecTypeQName.getRevision());
795 assertEquals("bar", myDecTypeQName.getPrefix());
796 assertEquals("my-decimal-type", myDecTypeQName.getLocalName());
798 SchemaPath typeSchemaPath = myDecType.getPath();
799 List<QName> typePath = typeSchemaPath.getPath();
800 assertEquals(1, typePath.size());
801 assertEquals(myDecTypeQName, typePath.get(0));
803 // my-base-int32-type/int32
804 Decimal64 dec64 = (Decimal64) myDecType.getBaseType();
805 QName dec64QName = dec64.getQName();
807 assertEquals(URI.create("urn:ietf:params:xml:ns:yang:1"), dec64QName.getNamespace());
808 assertNull(dec64QName.getRevision());
809 assertEquals("", dec64QName.getPrefix());
810 assertEquals("decimal64", dec64QName.getLocalName());
812 SchemaPath dec64SchemaPath = dec64.getPath();
813 List<QName> dec64Path = dec64SchemaPath.getPath();
814 assertEquals(2, dec64Path.size());
815 assertEquals(myDecTypeQName, dec64Path.get(0));
816 assertEquals(dec64QName, dec64Path.get(1));
820 public void testParseMethod1() throws ParseException {
821 File yangFile = new File(getClass().getResource("/parse-methods/m1.yang").getPath());
822 File dependenciesDir = new File(getClass().getResource("/parse-methods").getPath());
823 YangModelParser parser = new YangParserImpl();
824 modules = parser.parseYangModels(yangFile, dependenciesDir);
825 assertEquals(6, modules.size());
829 public void testParseMethod2() throws ParseException {
830 File yangFile = new File(getClass().getResource("/parse-methods/m1.yang").getPath());
831 File dependenciesDir = new File(getClass().getResource("/parse-methods/dependencies").getPath());
832 YangModelParser parser = new YangParserImpl();
833 modules = parser.parseYangModels(yangFile, dependenciesDir);
834 assertEquals(6, modules.size());