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.assertArrayEquals;
11 import static org.junit.Assert.assertEquals;
12 import static org.junit.Assert.assertFalse;
13 import static org.junit.Assert.assertNotNull;
14 import static org.junit.Assert.assertNull;
15 import static org.junit.Assert.assertTrue;
18 import java.io.FileInputStream;
19 import java.io.FileNotFoundException;
20 import java.io.InputStream;
22 import java.text.DateFormat;
23 import java.text.ParseException;
24 import java.text.SimpleDateFormat;
25 import java.util.ArrayList;
26 import java.util.Collection;
27 import java.util.Collections;
28 import java.util.Date;
29 import java.util.Iterator;
30 import java.util.LinkedHashSet;
31 import java.util.List;
34 import org.junit.Before;
35 import org.junit.Test;
36 import org.opendaylight.yangtools.yang.common.QName;
37 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
38 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
39 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
40 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
41 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
42 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.Deviation;
44 import org.opendaylight.yangtools.yang.model.api.Deviation.Deviate;
45 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
46 import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
47 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
48 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
49 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
50 import org.opendaylight.yangtools.yang.model.api.Module;
51 import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
52 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
53 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
54 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
55 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
56 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
57 import org.opendaylight.yangtools.yang.model.api.Status;
58 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
59 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
60 import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
61 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
62 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
63 import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser;
64 import org.opendaylight.yangtools.yang.model.util.Decimal64;
65 import org.opendaylight.yangtools.yang.model.util.ExtendedType;
66 import org.opendaylight.yangtools.yang.model.util.Int16;
67 import org.opendaylight.yangtools.yang.model.util.Int32;
68 import org.opendaylight.yangtools.yang.model.util.StringType;
69 import org.opendaylight.yangtools.yang.model.util.Uint32;
70 import org.opendaylight.yangtools.yang.model.util.UnionType;
71 import org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils;
73 public class YangParserTest {
74 public static final String FS = File.separator;
76 private final URI fooNS = URI.create("urn:opendaylight.foo");
77 private final URI barNS = URI.create("urn:opendaylight.bar");
78 private final URI bazNS = URI.create("urn:opendaylight.baz");
83 private Set<Module> modules;
86 public void init() throws Exception {
87 DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
88 fooRev = simpleDateFormat.parse("2013-02-27");
89 barRev = simpleDateFormat.parse("2013-07-03");
90 bazRev = simpleDateFormat.parse("2013-02-27");
92 modules = TestUtils.loadModules(getClass().getResource("/model").toURI());
93 assertEquals(3, modules.size());
97 public void testHeaders() throws ParseException {
98 Module foo = TestUtils.findModule(modules, "foo");
100 assertEquals("foo", foo.getName());
101 assertEquals("1", foo.getYangVersion());
102 assertEquals(fooNS, foo.getNamespace());
103 assertEquals("foo", foo.getPrefix());
105 Set<ModuleImport> imports = foo.getImports();
106 assertEquals(2, imports.size());
108 ModuleImport import2 = TestUtils.findImport(imports, "br");
109 assertEquals("bar", import2.getModuleName());
110 assertEquals(barRev, import2.getRevision());
112 ModuleImport import3 = TestUtils.findImport(imports, "bz");
113 assertEquals("baz", import3.getModuleName());
114 assertEquals(bazRev, import3.getRevision());
116 assertEquals("opendaylight", foo.getOrganization());
117 assertEquals("http://www.opendaylight.org/", foo.getContact());
118 Date expectedRevision = TestUtils.createDate("2013-02-27");
119 assertEquals(expectedRevision, foo.getRevision());
120 assertEquals(" WILL BE DEFINED LATER", foo.getReference());
124 public void testOrderingTypedef() {
125 Module bar = TestUtils.findModule(modules, "bar");
126 Set<TypeDefinition<?>> typedefs = bar.getTypeDefinitions();
127 String[] expectedOrder = new String[] { "int32-ext1", "int32-ext2", "my-decimal-type", "my-union",
128 "my-union-ext", "nested-union2", "string-ext1", "string-ext2", "string-ext3", "string-ext4" };
129 String[] actualOrder = new String[typedefs.size()];
132 for (TypeDefinition<?> type : typedefs) {
133 actualOrder[i] = type.getQName().getLocalName();
136 assertArrayEquals(expectedOrder, actualOrder);
140 public void testOrderingChildNodes() {
141 Module foo = TestUtils.findModule(modules, "foo");
142 AugmentationSchema augment1 = null;
143 for (AugmentationSchema as : foo.getAugmentations()) {
144 if ("if:ifType='ds0'".equals(as.getWhenCondition().toString())) {
149 assertNotNull(augment1);
151 String[] expectedOrder = new String[] { "ds0ChannelNumber", "interface-id", "my-type", "odl", "schemas" };
152 String[] actualOrder = new String[expectedOrder.length];
155 for (DataSchemaNode augmentChild : augment1.getChildNodes()) {
156 actualOrder[i] = augmentChild.getQName().getLocalName();
160 assertArrayEquals(expectedOrder, actualOrder);
164 public void testOrderingNestedChildNodes1() {
165 Module foo = TestUtils.findModule(modules, "foo");
167 Set<DataSchemaNode> childNodes = foo.getChildNodes();
168 String[] expectedOrder = new String[] { "address", "addresses", "custom-union-leaf", "data", "datas",
169 "decimal-leaf", "decimal-leaf2", "ext", "how", "int32-leaf", "length-leaf", "mycont", "peer", "port",
170 "string-leaf", "transfer", "union-leaf" };
171 String[] actualOrder = new String[childNodes.size()];
174 for (DataSchemaNode child : childNodes) {
175 actualOrder[i] = child.getQName().getLocalName();
178 assertArrayEquals(expectedOrder, actualOrder);
182 public void testOrderingNestedChildNodes2() {
183 Module baz = TestUtils.findModule(modules, "baz");
184 Set<GroupingDefinition> groupings = baz.getGroupings();
185 assertEquals(1, groupings.size());
186 GroupingDefinition target = groupings.iterator().next();
188 Set<DataSchemaNode> childNodes = target.getChildNodes();
189 String[] expectedOrder = new String[] { "address", "addresses", "data", "how", "port" };
190 String[] actualOrder = new String[childNodes.size()];
193 for (DataSchemaNode child : childNodes) {
194 actualOrder[i] = child.getQName().getLocalName();
197 assertArrayEquals(expectedOrder, actualOrder);
201 public void testParseList() {
202 Module bar = TestUtils.findModule(modules, "bar");
203 URI expectedNamespace = URI.create("urn:opendaylight.bar");
204 String expectedPrefix = "bar";
206 ContainerSchemaNode interfaces = (ContainerSchemaNode) bar.getDataChildByName("interfaces");
208 ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry");
209 // test SchemaNode args
210 QName expectedQName = new QName(expectedNamespace, barRev, expectedPrefix, "ifEntry");
211 assertEquals(expectedQName, ifEntry.getQName());
212 SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace, barRev, expectedPrefix, "interfaces",
214 assertEquals(expectedPath, ifEntry.getPath());
215 assertNull(ifEntry.getDescription());
216 assertNull(ifEntry.getReference());
217 assertEquals(Status.CURRENT, ifEntry.getStatus());
218 assertEquals(0, ifEntry.getUnknownSchemaNodes().size());
219 // test DataSchemaNode args
220 assertFalse(ifEntry.isAugmenting());
221 assertTrue(ifEntry.isConfiguration());
222 ConstraintDefinition constraints = ifEntry.getConstraints();
223 assertNull(constraints.getWhenCondition());
224 assertEquals(0, constraints.getMustConstraints().size());
225 assertFalse(constraints.isMandatory());
226 assertEquals(1, (int) constraints.getMinElements());
227 assertEquals(11, (int) constraints.getMaxElements());
228 // test AugmentationTarget args
229 Set<AugmentationSchema> availableAugmentations = ifEntry.getAvailableAugmentations();
230 assertEquals(2, availableAugmentations.size());
231 // test ListSchemaNode args
232 List<QName> expectedKey = new ArrayList<>();
233 expectedKey.add(new QName(expectedNamespace, barRev, expectedPrefix, "ifIndex"));
234 assertEquals(expectedKey, ifEntry.getKeyDefinition());
235 assertFalse(ifEntry.isUserOrdered());
236 // test DataNodeContainer args
237 assertEquals(0, ifEntry.getTypeDefinitions().size());
238 assertEquals(4, ifEntry.getChildNodes().size());
239 assertEquals(0, ifEntry.getGroupings().size());
240 assertEquals(0, ifEntry.getUses().size());
242 LeafSchemaNode ifIndex = (LeafSchemaNode) ifEntry.getDataChildByName("ifIndex");
243 assertEquals(ifEntry.getKeyDefinition().get(0), ifIndex.getQName());
244 assertTrue(ifIndex.getType() instanceof Uint32);
245 LeafSchemaNode ifMtu = (LeafSchemaNode) ifEntry.getDataChildByName("ifMtu");
246 assertTrue(ifMtu.getType() instanceof Int32);
250 public void testTypedefRangesResolving() throws ParseException {
251 Module foo = TestUtils.findModule(modules, "foo");
252 LeafSchemaNode int32Leaf = (LeafSchemaNode) foo.getDataChildByName("int32-leaf");
254 ExtendedType leafType = (ExtendedType) int32Leaf.getType();
255 QName leafTypeQName = leafType.getQName();
256 assertEquals("int32-ext2", leafTypeQName.getLocalName());
257 assertEquals("foo", leafTypeQName.getPrefix());
258 assertEquals(fooNS, leafTypeQName.getNamespace());
259 assertEquals(fooRev, leafTypeQName.getRevision());
260 assertNull(leafType.getUnits());
261 assertNull(leafType.getDefaultValue());
262 assertTrue(leafType.getLengthConstraints().isEmpty());
263 assertTrue(leafType.getPatternConstraints().isEmpty());
264 List<RangeConstraint> ranges = leafType.getRangeConstraints();
265 assertEquals(1, ranges.size());
266 RangeConstraint range = ranges.get(0);
267 assertEquals(12L, range.getMin());
268 assertEquals(20L, range.getMax());
270 ExtendedType baseType = (ExtendedType) leafType.getBaseType();
271 QName baseTypeQName = baseType.getQName();
272 assertEquals("int32-ext2", baseTypeQName.getLocalName());
273 assertEquals("bar", baseTypeQName.getPrefix());
274 assertEquals(barNS, baseTypeQName.getNamespace());
275 assertEquals(barRev, baseTypeQName.getRevision());
276 assertEquals("mile", baseType.getUnits());
277 assertEquals("11", baseType.getDefaultValue());
278 assertTrue(leafType.getLengthConstraints().isEmpty());
279 assertTrue(leafType.getPatternConstraints().isEmpty());
280 List<RangeConstraint> baseTypeRanges = baseType.getRangeConstraints();
281 assertEquals(2, baseTypeRanges.size());
282 RangeConstraint baseTypeRange1 = baseTypeRanges.get(0);
283 assertEquals(3L, baseTypeRange1.getMin());
284 assertEquals(9L, baseTypeRange1.getMax());
285 RangeConstraint baseTypeRange2 = baseTypeRanges.get(1);
286 assertEquals(11L, baseTypeRange2.getMin());
287 assertEquals(20L, baseTypeRange2.getMax());
289 ExtendedType base = (ExtendedType) baseType.getBaseType();
290 QName baseQName = base.getQName();
291 assertEquals("int32-ext1", baseQName.getLocalName());
292 assertEquals("bar", baseQName.getPrefix());
293 assertEquals(barNS, baseQName.getNamespace());
294 assertEquals(barRev, baseQName.getRevision());
295 assertNull(base.getUnits());
296 assertNull(base.getDefaultValue());
297 assertTrue(leafType.getLengthConstraints().isEmpty());
298 assertTrue(leafType.getPatternConstraints().isEmpty());
299 List<RangeConstraint> baseRanges = base.getRangeConstraints();
300 assertEquals(1, baseRanges.size());
301 RangeConstraint baseRange = baseRanges.get(0);
302 assertEquals(2L, baseRange.getMin());
303 assertEquals(20L, baseRange.getMax());
305 assertTrue(base.getBaseType() instanceof Int32);
309 public void testTypedefPatternsResolving() {
310 Module foo = TestUtils.findModule(modules, "foo");
311 LeafSchemaNode stringleaf = (LeafSchemaNode) foo.getDataChildByName("string-leaf");
313 ExtendedType type = (ExtendedType) stringleaf.getType();
314 QName typeQName = type.getQName();
315 assertEquals("string-ext4", typeQName.getLocalName());
316 assertEquals("bar", typeQName.getPrefix());
317 assertEquals(barNS, typeQName.getNamespace());
318 assertEquals(barRev, typeQName.getRevision());
319 assertNull(type.getUnits());
320 assertNull(type.getDefaultValue());
321 List<PatternConstraint> patterns = type.getPatternConstraints();
322 assertEquals(1, patterns.size());
323 PatternConstraint pattern = patterns.iterator().next();
324 assertEquals("[e-z]*", pattern.getRegularExpression());
325 assertTrue(type.getLengthConstraints().isEmpty());
326 assertTrue(type.getRangeConstraints().isEmpty());
328 ExtendedType baseType1 = (ExtendedType) type.getBaseType();
329 QName baseType1QName = baseType1.getQName();
330 assertEquals("string-ext3", baseType1QName.getLocalName());
331 assertEquals("bar", baseType1QName.getPrefix());
332 assertEquals(barNS, baseType1QName.getNamespace());
333 assertEquals(barRev, baseType1QName.getRevision());
334 assertNull(baseType1.getUnits());
335 assertNull(baseType1.getDefaultValue());
336 patterns = baseType1.getPatternConstraints();
337 assertEquals(1, patterns.size());
338 pattern = patterns.iterator().next();
339 assertEquals("[b-u]*", pattern.getRegularExpression());
340 assertTrue(baseType1.getLengthConstraints().isEmpty());
341 assertTrue(baseType1.getRangeConstraints().isEmpty());
343 ExtendedType baseType2 = (ExtendedType) baseType1.getBaseType();
344 QName baseType2QName = baseType2.getQName();
345 assertEquals("string-ext2", baseType2QName.getLocalName());
346 assertEquals("bar", baseType2QName.getPrefix());
347 assertEquals(barNS, baseType2QName.getNamespace());
348 assertEquals(barRev, baseType2QName.getRevision());
349 assertNull(baseType2.getUnits());
350 assertNull(baseType2.getDefaultValue());
351 assertTrue(baseType2.getPatternConstraints().isEmpty());
352 List<LengthConstraint> baseType2Lengths = baseType2.getLengthConstraints();
353 assertEquals(1, baseType2Lengths.size());
354 LengthConstraint length = baseType2Lengths.get(0);
355 assertEquals(6L, length.getMin());
356 assertEquals(10L, length.getMax());
357 assertTrue(baseType2.getRangeConstraints().isEmpty());
359 ExtendedType baseType3 = (ExtendedType) baseType2.getBaseType();
360 QName baseType3QName = baseType3.getQName();
361 assertEquals("string-ext1", baseType3QName.getLocalName());
362 assertEquals("bar", baseType3QName.getPrefix());
363 assertEquals(barNS, baseType3QName.getNamespace());
364 assertEquals(barRev, baseType3QName.getRevision());
365 assertNull(baseType3.getUnits());
366 assertNull(baseType3.getDefaultValue());
367 patterns = baseType3.getPatternConstraints();
368 assertEquals(1, patterns.size());
369 pattern = patterns.iterator().next();
370 assertEquals("[a-k]*", pattern.getRegularExpression());
371 List<LengthConstraint> baseType3Lengths = baseType3.getLengthConstraints();
372 assertEquals(1, baseType3Lengths.size());
373 length = baseType3Lengths.get(0);
374 assertEquals(5L, length.getMin());
375 assertEquals(11L, length.getMax());
376 assertTrue(baseType3.getRangeConstraints().isEmpty());
378 assertTrue(baseType3.getBaseType() instanceof StringType);
382 public void testTypedefLengthsResolving() {
383 Module foo = TestUtils.findModule(modules, "foo");
385 LeafSchemaNode lengthLeaf = (LeafSchemaNode) foo.getDataChildByName("length-leaf");
386 ExtendedType type = (ExtendedType) lengthLeaf.getType();
388 QName typeQName = type.getQName();
389 assertEquals("string-ext2", typeQName.getLocalName());
390 assertEquals("foo", typeQName.getPrefix());
391 assertEquals(fooNS, typeQName.getNamespace());
392 assertEquals(fooRev, typeQName.getRevision());
393 assertNull(type.getUnits());
394 assertNull(type.getDefaultValue());
395 assertTrue(type.getPatternConstraints().isEmpty());
396 List<LengthConstraint> typeLengths = type.getLengthConstraints();
397 assertEquals(1, typeLengths.size());
398 LengthConstraint length = typeLengths.get(0);
399 assertEquals(7L, length.getMin());
400 assertEquals(10L, length.getMax());
401 assertTrue(type.getRangeConstraints().isEmpty());
403 ExtendedType baseType1 = (ExtendedType) type.getBaseType();
404 QName baseType1QName = baseType1.getQName();
405 assertEquals("string-ext2", baseType1QName.getLocalName());
406 assertEquals("bar", baseType1QName.getPrefix());
407 assertEquals(barNS, baseType1QName.getNamespace());
408 assertEquals(barRev, baseType1QName.getRevision());
409 assertNull(baseType1.getUnits());
410 assertNull(baseType1.getDefaultValue());
411 assertTrue(baseType1.getPatternConstraints().isEmpty());
412 List<LengthConstraint> baseType2Lengths = baseType1.getLengthConstraints();
413 assertEquals(1, baseType2Lengths.size());
414 length = baseType2Lengths.get(0);
415 assertEquals(6L, length.getMin());
416 assertEquals(10L, length.getMax());
417 assertTrue(baseType1.getRangeConstraints().isEmpty());
419 ExtendedType baseType2 = (ExtendedType) baseType1.getBaseType();
420 QName baseType2QName = baseType2.getQName();
421 assertEquals("string-ext1", baseType2QName.getLocalName());
422 assertEquals("bar", baseType2QName.getPrefix());
423 assertEquals(barNS, baseType2QName.getNamespace());
424 assertEquals(barRev, baseType2QName.getRevision());
425 assertNull(baseType2.getUnits());
426 assertNull(baseType2.getDefaultValue());
427 List<PatternConstraint> patterns = baseType2.getPatternConstraints();
428 assertEquals(1, patterns.size());
429 PatternConstraint pattern = patterns.iterator().next();
430 assertEquals("[a-k]*", pattern.getRegularExpression());
431 List<LengthConstraint> baseType3Lengths = baseType2.getLengthConstraints();
432 assertEquals(1, baseType3Lengths.size());
433 length = baseType3Lengths.get(0);
434 assertEquals(5L, length.getMin());
435 assertEquals(11L, length.getMax());
436 assertTrue(baseType2.getRangeConstraints().isEmpty());
438 assertTrue(baseType2.getBaseType() instanceof StringType);
442 public void testTypedefDecimal1() {
443 Module foo = TestUtils.findModule(modules, "foo");
444 LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName("decimal-leaf");
446 ExtendedType type = (ExtendedType) testleaf.getType();
447 QName typeQName = type.getQName();
448 assertEquals("my-decimal-type", typeQName.getLocalName());
449 assertEquals("foo", typeQName.getPrefix());
450 assertEquals(fooNS, typeQName.getNamespace());
451 assertEquals(fooRev, typeQName.getRevision());
452 assertNull(type.getUnits());
453 assertNull(type.getDefaultValue());
454 assertEquals(4, (int) type.getFractionDigits());
455 assertTrue(type.getLengthConstraints().isEmpty());
456 assertTrue(type.getPatternConstraints().isEmpty());
457 assertTrue(type.getRangeConstraints().isEmpty());
459 ExtendedType typeBase = (ExtendedType) type.getBaseType();
460 QName typeBaseQName = typeBase.getQName();
461 assertEquals("my-decimal-type", typeBaseQName.getLocalName());
462 assertEquals("bar", typeBaseQName.getPrefix());
463 assertEquals(barNS, typeBaseQName.getNamespace());
464 assertEquals(barRev, typeBaseQName.getRevision());
465 assertNull(typeBase.getUnits());
466 assertNull(typeBase.getDefaultValue());
467 assertNull(typeBase.getFractionDigits());
468 assertTrue(typeBase.getLengthConstraints().isEmpty());
469 assertTrue(typeBase.getPatternConstraints().isEmpty());
470 assertTrue(typeBase.getRangeConstraints().isEmpty());
472 Decimal64 decimal = (Decimal64) typeBase.getBaseType();
473 assertEquals(6, (int) decimal.getFractionDigits());
477 public void testTypedefDecimal2() {
478 Module foo = TestUtils.findModule(modules, "foo");
479 LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName("decimal-leaf2");
481 ExtendedType type = (ExtendedType) testleaf.getType();
482 QName typeQName = type.getQName();
483 assertEquals("my-decimal-type", typeQName.getLocalName());
484 assertEquals("bar", typeQName.getPrefix());
485 assertEquals(barNS, typeQName.getNamespace());
486 assertEquals(barRev, typeQName.getRevision());
487 assertNull(type.getUnits());
488 assertNull(type.getDefaultValue());
489 assertNull(type.getFractionDigits());
490 assertTrue(type.getLengthConstraints().isEmpty());
491 assertTrue(type.getPatternConstraints().isEmpty());
492 assertTrue(type.getRangeConstraints().isEmpty());
494 Decimal64 baseTypeDecimal = (Decimal64) type.getBaseType();
495 assertEquals(6, (int) baseTypeDecimal.getFractionDigits());
499 public void testTypedefUnion() {
500 Module foo = TestUtils.findModule(modules, "foo");
501 LeafSchemaNode unionleaf = (LeafSchemaNode) foo.getDataChildByName("union-leaf");
503 ExtendedType type = (ExtendedType) unionleaf.getType();
504 QName typeQName = type.getQName();
505 assertEquals("my-union-ext", typeQName.getLocalName());
506 assertEquals("bar", typeQName.getPrefix());
507 assertEquals(barNS, typeQName.getNamespace());
508 assertEquals(barRev, typeQName.getRevision());
509 assertNull(type.getUnits());
510 assertNull(type.getDefaultValue());
511 assertNull(type.getFractionDigits());
512 assertTrue(type.getLengthConstraints().isEmpty());
513 assertTrue(type.getPatternConstraints().isEmpty());
514 assertTrue(type.getRangeConstraints().isEmpty());
516 ExtendedType baseType = (ExtendedType) type.getBaseType();
517 QName baseTypeQName = baseType.getQName();
518 assertEquals("my-union", baseTypeQName.getLocalName());
519 assertEquals("bar", baseTypeQName.getPrefix());
520 assertEquals(barNS, baseTypeQName.getNamespace());
521 assertEquals(barRev, baseTypeQName.getRevision());
522 assertNull(baseType.getUnits());
523 assertNull(baseType.getDefaultValue());
524 assertNull(baseType.getFractionDigits());
525 assertTrue(baseType.getLengthConstraints().isEmpty());
526 assertTrue(baseType.getPatternConstraints().isEmpty());
527 assertTrue(baseType.getRangeConstraints().isEmpty());
529 UnionType unionType = (UnionType) baseType.getBaseType();
530 List<TypeDefinition<?>> unionTypes = unionType.getTypes();
531 assertEquals(2, unionTypes.size());
533 ExtendedType unionType1 = (ExtendedType) unionTypes.get(0);
534 QName unionType1QName = baseType.getQName();
535 assertEquals("my-union", unionType1QName.getLocalName());
536 assertEquals("bar", unionType1QName.getPrefix());
537 assertEquals(barNS, unionType1QName.getNamespace());
538 assertEquals(barRev, unionType1QName.getRevision());
539 assertNull(unionType1.getUnits());
540 assertNull(unionType1.getDefaultValue());
541 assertNull(unionType1.getFractionDigits());
542 assertTrue(unionType1.getLengthConstraints().isEmpty());
543 assertTrue(unionType1.getPatternConstraints().isEmpty());
544 List<RangeConstraint> ranges = unionType1.getRangeConstraints();
545 assertEquals(1, ranges.size());
546 RangeConstraint range = ranges.get(0);
547 assertEquals(1L, range.getMin());
548 assertEquals(100L, range.getMax());
549 assertTrue(unionType1.getBaseType() instanceof Int16);
551 assertTrue(unionTypes.get(1) instanceof Int32);
555 public void testNestedUnionResolving() {
556 Module foo = TestUtils.findModule(modules, "foo");
557 LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName("custom-union-leaf");
559 ExtendedType type = (ExtendedType) testleaf.getType();
560 QName testleafTypeQName = type.getQName();
561 assertEquals(bazNS, testleafTypeQName.getNamespace());
562 assertEquals(bazRev, testleafTypeQName.getRevision());
563 assertEquals("baz", testleafTypeQName.getPrefix());
564 assertEquals("union1", testleafTypeQName.getLocalName());
565 assertNull(type.getUnits());
566 assertNull(type.getDefaultValue());
567 assertNull(type.getFractionDigits());
568 assertTrue(type.getLengthConstraints().isEmpty());
569 assertTrue(type.getPatternConstraints().isEmpty());
570 assertTrue(type.getRangeConstraints().isEmpty());
572 ExtendedType typeBase = (ExtendedType) type.getBaseType();
573 QName typeBaseQName = typeBase.getQName();
574 assertEquals(bazNS, typeBaseQName.getNamespace());
575 assertEquals(bazRev, typeBaseQName.getRevision());
576 assertEquals("baz", typeBaseQName.getPrefix());
577 assertEquals("union2", typeBaseQName.getLocalName());
578 assertNull(typeBase.getUnits());
579 assertNull(typeBase.getDefaultValue());
580 assertNull(typeBase.getFractionDigits());
581 assertTrue(typeBase.getLengthConstraints().isEmpty());
582 assertTrue(typeBase.getPatternConstraints().isEmpty());
583 assertTrue(typeBase.getRangeConstraints().isEmpty());
585 UnionType union = (UnionType) typeBase.getBaseType();
586 List<TypeDefinition<?>> unionTypes = union.getTypes();
587 assertEquals(2, unionTypes.size());
588 assertTrue(unionTypes.get(0) instanceof Int32);
589 assertTrue(unionTypes.get(1) instanceof ExtendedType);
591 ExtendedType unionType1 = (ExtendedType) unionTypes.get(1);
592 QName uniontType1QName = unionType1.getQName();
593 assertEquals(barNS, uniontType1QName.getNamespace());
594 assertEquals(barRev, uniontType1QName.getRevision());
595 assertEquals("bar", uniontType1QName.getPrefix());
596 assertEquals("nested-union2", uniontType1QName.getLocalName());
597 assertNull(unionType1.getUnits());
598 assertNull(unionType1.getDefaultValue());
599 assertNull(unionType1.getFractionDigits());
600 assertTrue(unionType1.getLengthConstraints().isEmpty());
601 assertTrue(unionType1.getPatternConstraints().isEmpty());
602 assertTrue(unionType1.getRangeConstraints().isEmpty());
604 UnionType nestedUnion = (UnionType) unionType1.getBaseType();
605 List<TypeDefinition<?>> nestedUnion2Types = nestedUnion.getTypes();
606 assertEquals(2, nestedUnion2Types.size());
607 assertTrue(nestedUnion2Types.get(0) instanceof StringType);
608 assertTrue(nestedUnion2Types.get(1) instanceof ExtendedType);
610 ExtendedType myUnionExt = (ExtendedType) nestedUnion2Types.get(1);
611 QName myUnionExtQName = myUnionExt.getQName();
612 assertEquals(barNS, myUnionExtQName.getNamespace());
613 assertEquals(barRev, myUnionExtQName.getRevision());
614 assertEquals("bar", myUnionExtQName.getPrefix());
615 assertEquals("my-union-ext", myUnionExtQName.getLocalName());
616 assertNull(myUnionExt.getUnits());
617 assertNull(myUnionExt.getDefaultValue());
618 assertNull(myUnionExt.getFractionDigits());
619 assertTrue(myUnionExt.getLengthConstraints().isEmpty());
620 assertTrue(myUnionExt.getPatternConstraints().isEmpty());
621 assertTrue(myUnionExt.getRangeConstraints().isEmpty());
623 ExtendedType myUnion = (ExtendedType) myUnionExt.getBaseType();
624 QName myUnionQName = myUnion.getQName();
625 assertEquals(barNS, myUnionQName.getNamespace());
626 assertEquals(barRev, myUnionQName.getRevision());
627 assertEquals("bar", myUnionQName.getPrefix());
628 assertEquals("my-union", myUnionQName.getLocalName());
629 assertNull(myUnion.getUnits());
630 assertNull(myUnion.getDefaultValue());
631 assertNull(myUnion.getFractionDigits());
632 assertTrue(myUnion.getLengthConstraints().isEmpty());
633 assertTrue(myUnion.getPatternConstraints().isEmpty());
634 assertTrue(myUnion.getRangeConstraints().isEmpty());
636 UnionType myUnionBase = (UnionType) myUnion.getBaseType();
637 List<TypeDefinition<?>> myUnionBaseTypes = myUnionBase.getTypes();
638 assertEquals(2, myUnionBaseTypes.size());
639 assertTrue(myUnionBaseTypes.get(0) instanceof ExtendedType);
640 assertTrue(myUnionBaseTypes.get(1) instanceof Int32);
642 ExtendedType int16Ext = (ExtendedType) myUnionBaseTypes.get(0);
643 QName int16ExtQName = int16Ext.getQName();
644 assertEquals(barNS, int16ExtQName.getNamespace());
645 assertEquals(barRev, int16ExtQName.getRevision());
646 assertEquals("bar", int16ExtQName.getPrefix());
647 assertEquals("int16", int16ExtQName.getLocalName());
648 assertNull(int16Ext.getUnits());
649 assertNull(int16Ext.getDefaultValue());
650 assertNull(int16Ext.getFractionDigits());
651 assertTrue(int16Ext.getLengthConstraints().isEmpty());
652 assertTrue(int16Ext.getPatternConstraints().isEmpty());
653 List<RangeConstraint> ranges = int16Ext.getRangeConstraints();
654 assertEquals(1, ranges.size());
655 RangeConstraint range = ranges.get(0);
656 assertEquals(1L, range.getMin());
657 assertEquals(100L, range.getMax());
659 assertTrue(int16Ext.getBaseType() instanceof Int16);
663 public void testChoice() {
664 Module foo = TestUtils.findModule(modules, "foo");
665 ContainerSchemaNode transfer = (ContainerSchemaNode) foo.getDataChildByName("transfer");
666 ChoiceNode how = (ChoiceNode) transfer.getDataChildByName("how");
667 Set<ChoiceCaseNode> cases = how.getCases();
668 assertEquals(5, cases.size());
669 ChoiceCaseNode input = null;
670 ChoiceCaseNode output = null;
671 for (ChoiceCaseNode caseNode : cases) {
672 if ("input".equals(caseNode.getQName().getLocalName())) {
674 } else if ("output".equals(caseNode.getQName().getLocalName())) {
678 assertNotNull(input);
679 assertNotNull(input.getPath());
680 assertNotNull(output);
681 assertNotNull(output.getPath());
685 public void testDeviation() {
686 Module foo = TestUtils.findModule(modules, "foo");
687 Set<Deviation> deviations = foo.getDeviations();
688 assertEquals(1, deviations.size());
689 Deviation dev = deviations.iterator().next();
690 assertEquals("system/user ref", dev.getReference());
692 List<QName> path = new ArrayList<>();
693 path.add(new QName(barNS, barRev, "br", "interfaces"));
694 path.add(new QName(barNS, barRev, "br", "ifEntry"));
695 SchemaPath expectedPath = SchemaPath.create(path, true);
697 assertEquals(expectedPath, dev.getTargetPath());
698 assertEquals(Deviate.ADD, dev.getDeviate());
702 public void testUnknownNode() {
703 Module baz = TestUtils.findModule(modules, "baz");
704 ContainerSchemaNode network = (ContainerSchemaNode) baz.getDataChildByName("network");
705 List<UnknownSchemaNode> unknownNodes = network.getUnknownSchemaNodes();
706 assertEquals(1, unknownNodes.size());
707 UnknownSchemaNode unknownNode = unknownNodes.get(0);
708 assertNotNull(unknownNode.getNodeType());
709 assertEquals("point", unknownNode.getNodeParameter());
713 public void testFeature() {
714 Module baz = TestUtils.findModule(modules, "baz");
715 Set<FeatureDefinition> features = baz.getFeatures();
716 assertEquals(1, features.size());
720 public void testExtension() {
721 Module baz = TestUtils.findModule(modules, "baz");
722 List<ExtensionDefinition> extensions = baz.getExtensionSchemaNodes();
723 assertEquals(1, extensions.size());
724 ExtensionDefinition extension = extensions.get(0);
725 assertEquals("name", extension.getArgument());
726 assertTrue(extension.isYinElement());
730 public void testNotification() {
731 Module baz = TestUtils.findModule(modules, "baz");
732 String expectedPrefix = "c";
734 Set<NotificationDefinition> notifications = baz.getNotifications();
735 assertEquals(1, notifications.size());
737 NotificationDefinition notification = notifications.iterator().next();
738 // test SchemaNode args
739 QName expectedQName = new QName(bazNS, bazRev, expectedPrefix, "event");
740 assertEquals(expectedQName, notification.getQName());
741 SchemaPath expectedPath = TestUtils.createPath(true, bazNS, bazRev, expectedPrefix, "event");
742 assertEquals(expectedPath, notification.getPath());
743 assertNull(notification.getDescription());
744 assertNull(notification.getReference());
745 assertEquals(Status.CURRENT, notification.getStatus());
746 assertEquals(0, notification.getUnknownSchemaNodes().size());
747 // test DataNodeContainer args
748 assertEquals(0, notification.getTypeDefinitions().size());
749 assertEquals(3, notification.getChildNodes().size());
750 assertEquals(0, notification.getGroupings().size());
751 assertEquals(0, notification.getUses().size());
753 LeafSchemaNode eventClass = (LeafSchemaNode) notification.getDataChildByName("event-class");
754 assertTrue(eventClass.getType() instanceof StringType);
755 LeafSchemaNode severity = (LeafSchemaNode) notification.getDataChildByName("severity");
756 assertTrue(severity.getType() instanceof StringType);
760 public void testRpc() {
761 Module baz = TestUtils.findModule(modules, "baz");
763 Set<RpcDefinition> rpcs = baz.getRpcs();
764 assertEquals(1, rpcs.size());
766 RpcDefinition rpc = rpcs.iterator().next();
767 assertEquals("Retrieve all or part of a specified configuration.", rpc.getDescription());
768 assertEquals("RFC 6241, Section 7.1", rpc.getReference());
772 public void testTypePath() throws ParseException {
773 Module bar = TestUtils.findModule(modules, "bar");
774 Set<TypeDefinition<?>> types = bar.getTypeDefinitions();
777 ExtendedType int32ext1 = (ExtendedType) TestUtils.findTypedef(types, "int32-ext1");
778 QName int32TypedefQName = int32ext1.getQName();
780 assertEquals(barNS, int32TypedefQName.getNamespace());
781 assertEquals(barRev, int32TypedefQName.getRevision());
782 assertEquals("bar", int32TypedefQName.getPrefix());
783 assertEquals("int32-ext1", int32TypedefQName.getLocalName());
785 SchemaPath typeSchemaPath = int32ext1.getPath();
786 Iterable<QName> typePath = typeSchemaPath.getPathFromRoot();
787 Iterator<QName> typePathIt = typePath.iterator();
788 assertEquals(int32TypedefQName, typePathIt.next());
789 assertFalse(typePathIt.hasNext());
793 Int32 int32 = (Int32) int32ext1.getBaseType();
794 assertEquals(Int32.getInstance(), int32);
798 public void testTypePath2() throws ParseException {
799 Module bar = TestUtils.findModule(modules, "bar");
800 Set<TypeDefinition<?>> types = bar.getTypeDefinitions();
803 ExtendedType myDecType = (ExtendedType) TestUtils.findTypedef(types, "my-decimal-type");
804 QName myDecTypeQName = myDecType.getQName();
806 assertEquals(barNS, myDecTypeQName.getNamespace());
807 assertEquals(barRev, myDecTypeQName.getRevision());
808 assertEquals("bar", myDecTypeQName.getPrefix());
809 assertEquals("my-decimal-type", myDecTypeQName.getLocalName());
811 SchemaPath typeSchemaPath = myDecType.getPath();
812 Iterable<QName> typePath = typeSchemaPath.getPathFromRoot();
813 Iterator<QName> typePathIt = typePath.iterator();
814 assertEquals(myDecTypeQName, typePathIt.next());
815 assertFalse(typePathIt.hasNext());
817 // my-base-int32-type/int32
818 Decimal64 dec64 = (Decimal64) myDecType.getBaseType();
819 QName dec64QName = dec64.getQName();
821 assertEquals(URI.create("urn:ietf:params:xml:ns:yang:1"), dec64QName.getNamespace());
822 assertNull(dec64QName.getRevision());
823 assertEquals("", dec64QName.getPrefix());
824 assertEquals("decimal64", dec64QName.getLocalName());
826 SchemaPath dec64SchemaPath = dec64.getPath();
827 Iterable<QName> dec64Path = dec64SchemaPath.getPathFromRoot();
828 Iterator<QName> dec64PathIt = dec64Path.iterator();
829 assertEquals(myDecTypeQName, dec64PathIt.next());
830 assertEquals(dec64QName, dec64PathIt.next());
831 assertFalse(dec64PathIt.hasNext());
835 public void testParseMethod1() throws Exception {
836 File yangFile = new File(getClass().getResource("/parse-methods/m1.yang").toURI());
837 File dependenciesDir = new File(getClass().getResource("/parse-methods").toURI());
838 YangContextParser parser = new YangParserImpl();
839 modules = parser.parseFile(yangFile, dependenciesDir).getModules();
840 assertEquals(6, modules.size());
844 public void testParseMethod2() throws Exception {
845 File yangFile = new File(getClass().getResource("/parse-methods/m1.yang").toURI());
846 File dependenciesDir = new File(getClass().getResource("/parse-methods/dependencies").toURI());
847 YangContextParser parser = new YangParserImpl();
848 modules = parser.parseFile(yangFile, dependenciesDir).getModules();
849 assertEquals(6, modules.size());
853 public void testSorting() throws Exception {
854 // Correct order: m2, m4, m6, m8, m7, m6, m3, m1
855 File yangFile = new File(getClass().getResource("/sorting-test/m1.yang").toURI());
856 File dependenciesDir = new File(getClass().getResource("/sorting-test").toURI());
857 YangContextParser parser = new YangParserImpl();
858 modules = parser.parseFile(yangFile, dependenciesDir).getModules();
859 SchemaContext ctx = new SchemaContextImpl(modules, Collections.<ModuleIdentifier, String>emptyMap());
861 assertSetEquals(modules, ctx.getModules());
864 parser = new YangParserImpl();
865 final File testDir = dependenciesDir;
866 final String[] fileList = testDir.list();
867 final List<File> testFiles = new ArrayList<>();
868 if (fileList == null) {
869 throw new FileNotFoundException(dependenciesDir.getAbsolutePath());
871 for (String fileName : fileList) {
872 testFiles.add(new File(testDir, fileName));
874 Set<Module> newModules = parser.parseFiles(testFiles).getModules();
875 assertSetEquals(newModules, modules);
876 ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
877 assertSetEquals(newModules, ctx.getModules());
879 newModules = parser.parseFiles(testFiles, null).getModules();
880 assertSetEquals(newModules, modules);
881 ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
882 assertSetEquals(newModules, ctx.getModules());
884 List<InputStream> streams = new ArrayList<>();
885 for (File f : testFiles) {
886 streams.add(new FileInputStream(f));
888 newModules = parser.parseSources(BuilderUtils.filesToByteSources(testFiles)).getModules();
889 assertSetEquals(newModules, modules);
890 ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
891 assertSetEquals(newModules, ctx.getModules());
894 for (File f : testFiles) {
895 streams.add(new FileInputStream(f));
897 newModules = parser.parseSources(BuilderUtils.filesToByteSources(testFiles), null).getModules();
898 assertSetEquals(newModules, modules);
899 ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
900 assertSetEquals(newModules, ctx.getModules());
902 Map<File, Module> mapped = parser.parseYangModelsMapped(testFiles);
903 newModules = new LinkedHashSet<>(mapped.values());
904 assertSetEquals(newModules, modules);
905 ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
906 assertSetEquals(newModules, ctx.getModules());
909 for (File f : testFiles) {
910 streams.add(new FileInputStream(f));
912 Map<InputStream, Module> mappedStreams = parser.parseYangModelsFromStreamsMapped(streams);
913 newModules = new LinkedHashSet<>(mappedStreams.values());
914 assertSetEquals(newModules, modules);
915 ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
916 assertSetEquals(newModules, ctx.getModules());
919 private void checkOrder(final Collection<Module> modules) {
920 Iterator<Module> it = modules.iterator();
921 Module m = it.next();
922 assertEquals("m2", m.getName());
924 assertEquals("m4", m.getName());
926 assertEquals("m6", m.getName());
928 assertEquals("m8", m.getName());
930 assertEquals("m7", m.getName());
932 assertEquals("m5", m.getName());
934 assertEquals("m3", m.getName());
936 assertEquals("m1", m.getName());
939 private void assertSetEquals(final Set<Module> s1, final Set<Module> s2) {
940 assertEquals(s1, s2);
941 Iterator<Module> it = s1.iterator();
942 for (Module m : s2) {
943 assertEquals(m, it.next());
948 public void testSubmodules() throws Exception {
949 URI yangFilePath = getClass().getResource("/submodule-test/subfoo.yang").toURI();
950 URI directoryPath = getClass().getResource("/model").toURI();
952 File directory = new File(directoryPath);
953 File yangFile = new File(yangFilePath);
955 Set<Module> modules = new YangParserImpl().parseFile(yangFile, directory).getModules();
956 assertEquals(3, modules.size());
958 Module foo = TestUtils.findModule(modules, "foo");
960 DataSchemaNode id = foo.getDataChildByName("id");
962 DataSchemaNode subExt = foo.getDataChildByName("sub-ext");
963 assertNotNull(subExt);
964 DataSchemaNode subTransfer = foo.getDataChildByName("sub-transfer");
965 assertNotNull(subTransfer);
967 assertEquals(2, foo.getExtensionSchemaNodes().size());
968 assertEquals(2, foo.getAugmentations().size());