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