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