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

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.parser.impl;
   9
  10 import static org.junit.Assert.*;
  11
  12 import java.io.File;
  13 import java.io.FileNotFoundException;
  14 import java.net.URI;
  15 import java.text.ParseException;
  16 import java.util.ArrayList;
  17 import java.util.Date;
  18 import java.util.List;
  19 import java.util.Set;
  20
  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;
  57
  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");
  62     private Date fooRev;
  63     private Date barRev;
  64     private Date bazRev;
  65
  66     private Set<Module> modules;
  67
  68     @Before
  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");
  73
  74         modules = TestUtils.loadModules(getClass().getResource("/model").getPath());
  75         assertEquals(3, modules.size());
  76     }
  77
  78     @Test
  79     public void testHeaders() throws ParseException {
  80         Module foo = TestUtils.findModule(modules, "foo");
  81
  82         assertEquals("foo", foo.getName());
  83         assertEquals("1", foo.getYangVersion());
  84         assertEquals(fooNS, foo.getNamespace());
  85         assertEquals("foo", foo.getPrefix());
  86
  87         Set<ModuleImport> imports = foo.getImports();
  88         assertEquals(2, imports.size());
  89
  90         ModuleImport import2 = TestUtils.findImport(imports, "br");
  91         assertEquals("bar", import2.getModuleName());
  92         assertEquals(barRev, import2.getRevision());
  93
  94         ModuleImport import3 = TestUtils.findImport(imports, "bz");
  95         assertEquals("baz", import3.getModuleName());
  96         assertEquals(bazRev, import3.getRevision());
  97
  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());
 103     }
 104
 105     @Test
 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()];
 112
 113         int i = 0;
 114         for (TypeDefinition<?> type : typedefs) {
 115             actualOrder[i] = type.getQName().getLocalName();
 116             i++;
 117         }
 118         assertArrayEquals(expectedOrder, actualOrder);
 119     }
 120
 121     @Test
 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())) {
 127                 augment1 = as;
 128                 break;
 129             }
 130         }
 131         assertNotNull(augment1);
 132
 133         String[] expectedOrder = new String[] { "ds0ChannelNumber", "interface-id", "my-type", "odl", "schemas" };
 134         String[] actualOrder = new String[expectedOrder.length];
 135
 136         int i = 0;
 137         for (DataSchemaNode augmentChild : augment1.getChildNodes()) {
 138             actualOrder[i] = augmentChild.getQName().getLocalName();
 139             i++;
 140         }
 141
 142         assertArrayEquals(expectedOrder, actualOrder);
 143     }
 144
 145     @Test
 146     public void testOrderingNestedChildNodes1() {
 147         Module foo = TestUtils.findModule(modules, "foo");
 148
 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()];
 154
 155         int i = 0;
 156         for (DataSchemaNode child : childNodes) {
 157             actualOrder[i] = child.getQName().getLocalName();
 158             i++;
 159         }
 160         assertArrayEquals(expectedOrder, actualOrder);
 161     }
 162
 163     @Test
 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();
 169
 170         Set<DataSchemaNode> childNodes = target.getChildNodes();
 171         String[] expectedOrder = new String[] { "address", "addresses", "data", "how", "port" };
 172         String[] actualOrder = new String[childNodes.size()];
 173
 174         int i = 0;
 175         for (DataSchemaNode child : childNodes) {
 176             actualOrder[i] = child.getQName().getLocalName();
 177             i++;
 178         }
 179         assertArrayEquals(expectedOrder, actualOrder);
 180     }
 181
 182     @Test
 183     public void testParseList() {
 184         Module bar = TestUtils.findModule(modules, "bar");
 185         URI expectedNamespace = URI.create("urn:opendaylight.bar");
 186         String expectedPrefix = "bar";
 187
 188         ContainerSchemaNode interfaces = (ContainerSchemaNode) bar.getDataChildByName("interfaces");
 189
 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",
 195                 "ifEntry");
 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());
 223
 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);
 228     }
 229
 230     @Test
 231     public void testTypedefRangesResolving() throws ParseException {
 232         Module foo = TestUtils.findModule(modules, "foo");
 233         LeafSchemaNode int32Leaf = (LeafSchemaNode) foo.getDataChildByName("int32-leaf");
 234
 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());
 250
 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());
 269
 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());
 285
 286         assertTrue(base.getBaseType() instanceof Int32);
 287     }
 288
 289     @Test
 290     public void testTypedefPatternsResolving() {
 291         Module foo = TestUtils.findModule(modules, "foo");
 292         LeafSchemaNode stringleaf = (LeafSchemaNode) foo.getDataChildByName("string-leaf");
 293
 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());
 308
 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());
 323
 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());
 339
 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());
 358
 359         assertTrue(baseType3.getBaseType() instanceof StringType);
 360     }
 361
 362     @Test
 363     public void testTypedefLengthsResolving() {
 364         Module foo = TestUtils.findModule(modules, "foo");
 365
 366         LeafSchemaNode lengthLeaf = (LeafSchemaNode) foo.getDataChildByName("length-leaf");
 367         ExtendedType type = (ExtendedType) lengthLeaf.getType();
 368
 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());
 383
 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());
 399
 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());
 418
 419         assertTrue(baseType2.getBaseType() instanceof StringType);
 420     }
 421
 422     @Test
 423     public void testTypedefDecimal1() {
 424         Module foo = TestUtils.findModule(modules, "foo");
 425         LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName("decimal-leaf");
 426
 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());
 439
 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());
 452
 453         Decimal64 decimal = (Decimal64) typeBase.getBaseType();
 454         assertEquals(6, (int) decimal.getFractionDigits());
 455     }
 456
 457     @Test
 458     public void testTypedefDecimal2() {
 459         Module foo = TestUtils.findModule(modules, "foo");
 460         LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName("decimal-leaf2");
 461
 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());
 474
 475         Decimal64 baseTypeDecimal = (Decimal64) type.getBaseType();
 476         assertEquals(6, (int) baseTypeDecimal.getFractionDigits());
 477     }
 478
 479     @Test
 480     public void testTypedefUnion() {
 481         Module foo = TestUtils.findModule(modules, "foo");
 482         LeafSchemaNode unionleaf = (LeafSchemaNode) foo.getDataChildByName("union-leaf");
 483
 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());
 496
 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());
 509
 510         UnionType unionType = (UnionType) baseType.getBaseType();
 511         List<TypeDefinition<?>> unionTypes = unionType.getTypes();
 512         assertEquals(2, unionTypes.size());
 513
 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);
 531
 532         assertTrue(unionTypes.get(1) instanceof Int32);
 533     }
 534
 535     @Test
 536     public void testNestedUnionResolving() {
 537         Module foo = TestUtils.findModule(modules, "foo");
 538         LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName("custom-union-leaf");
 539
 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());
 552
 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());
 565
 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);
 571
 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());
 584
 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);
 590
 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());
 603
 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());
 616
 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);
 622
 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());
 639
 640         assertTrue(int16Ext.getBaseType() instanceof Int16);
 641     }
 642
 643     @Test
 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())) {
 654                 input = caseNode;
 655             } else if ("output".equals(caseNode.getQName().getLocalName())) {
 656                 output = caseNode;
 657             }
 658         }
 659         assertNotNull(input);
 660         assertNotNull(input.getPath());
 661         assertNotNull(output);
 662         assertNotNull(output.getPath());
 663     }
 664
 665     @Test
 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());
 672
 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);
 677
 678         assertEquals(expectedPath, dev.getTargetPath());
 679         assertEquals(Deviate.ADD, dev.getDeviate());
 680     }
 681
 682     @Test
 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());
 691     }
 692
 693     @Test
 694     public void testFeature() {
 695         Module baz = TestUtils.findModule(modules, "baz");
 696         Set<FeatureDefinition> features = baz.getFeatures();
 697         assertEquals(1, features.size());
 698     }
 699
 700     @Test
 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());
 708     }
 709
 710     @Test
 711     public void testNotification() {
 712         Module baz = TestUtils.findModule(modules, "baz");
 713         String expectedPrefix = "c";
 714
 715         Set<NotificationDefinition> notifications = baz.getNotifications();
 716         assertEquals(1, notifications.size());
 717
 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());
 733
 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);
 740     }
 741
 742     @Test
 743     public void testRpc() {
 744         Module baz = TestUtils.findModule(modules, "baz");
 745
 746         Set<RpcDefinition> rpcs = baz.getRpcs();
 747         assertEquals(1, rpcs.size());
 748
 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());
 752
 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"));
 758     }
 759
 760     @Test
 761     public void testTypePath() throws ParseException {
 762         Module bar = TestUtils.findModule(modules, "bar");
 763         Set<TypeDefinition<?>> types = bar.getTypeDefinitions();
 764
 765         // int32-ext1
 766         ExtendedType int32ext1 = (ExtendedType) TestUtils.findTypedef(types, "int32-ext1");
 767         QName int32TypedefQName = int32ext1.getQName();
 768
 769         assertEquals(barNS, int32TypedefQName.getNamespace());
 770         assertEquals(barRev, int32TypedefQName.getRevision());
 771         assertEquals("bar", int32TypedefQName.getPrefix());
 772         assertEquals("int32-ext1", int32TypedefQName.getLocalName());
 773
 774         SchemaPath typeSchemaPath = int32ext1.getPath();
 775         List<QName> typePath = typeSchemaPath.getPath();
 776         assertEquals(1, typePath.size());
 777         assertEquals(int32TypedefQName, typePath.get(0));
 778
 779         // int32-ext1/int32
 780         Int32 int32 = (Int32) int32ext1.getBaseType();
 781         assertEquals(Int32.getInstance(), int32);
 782     }
 783
 784     @Test
 785     public void testTypePath2() throws ParseException {
 786         Module bar = TestUtils.findModule(modules, "bar");
 787         Set<TypeDefinition<?>> types = bar.getTypeDefinitions();
 788
 789         // my-decimal-type
 790         ExtendedType myDecType = (ExtendedType) TestUtils.findTypedef(types, "my-decimal-type");
 791         QName myDecTypeQName = myDecType.getQName();
 792
 793         assertEquals(barNS, myDecTypeQName.getNamespace());
 794         assertEquals(barRev, myDecTypeQName.getRevision());
 795         assertEquals("bar", myDecTypeQName.getPrefix());
 796         assertEquals("my-decimal-type", myDecTypeQName.getLocalName());
 797
 798         SchemaPath typeSchemaPath = myDecType.getPath();
 799         List<QName> typePath = typeSchemaPath.getPath();
 800         assertEquals(1, typePath.size());
 801         assertEquals(myDecTypeQName, typePath.get(0));
 802
 803         // my-base-int32-type/int32
 804         Decimal64 dec64 = (Decimal64) myDecType.getBaseType();
 805         QName dec64QName = dec64.getQName();
 806
 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());
 811
 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));
 817     }
 818
 819     @Test
 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());
 826     }
 827
 828     @Test
 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());
 835     }
 836
 837 }