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

   1 /*
   2  * Copyright (c) 2016 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.stmt;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertNull;
  14 import static org.junit.Assert.assertTrue;
  15 import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
  16
  17 import java.io.IOException;
  18 import java.net.URI;
  19 import java.net.URISyntaxException;
  20 import java.text.ParseException;
  21 import java.util.ArrayList;
  22 import java.util.Collection;
  23 import java.util.Date;
  24 import java.util.Iterator;
  25 import java.util.List;
  26 import java.util.Set;
  27 import org.junit.Before;
  28 import org.junit.Test;
  29 import org.opendaylight.yangtools.yang.common.QName;
  30 import org.opendaylight.yangtools.yang.common.QNameModule;
  31 import org.opendaylight.yangtools.yang.common.YangConstants;
  32 import org.opendaylight.yangtools.yang.common.YangVersion;
  33 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  34 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  35 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  36 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
  37 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  38 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  39 import org.opendaylight.yangtools.yang.model.api.DeviateKind;
  40 import org.opendaylight.yangtools.yang.model.api.Deviation;
  41 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
  42 import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
  43 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  44 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  45 import org.opendaylight.yangtools.yang.model.api.Module;
  46 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
  47 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  48 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  49 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  50 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  51 import org.opendaylight.yangtools.yang.model.api.Status;
  52 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  53 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  54 import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
  55 import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
  56 import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
  57 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
  58 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
  59 import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
  60 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  61 import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
  62 import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
  63 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  64 import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
  65 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
  66 import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
  67 import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
  68 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
  69
  70 public class YangParserTest {
  71     private static final QNameModule FOO = QNameModule.create(
  72         URI.create("urn:opendaylight.foo"), QName.parseRevision("2013-02-27"));
  73     private static final QNameModule BAR = QNameModule.create(
  74         URI.create("urn:opendaylight.bar"), QName.parseRevision("2013-07-03"));
  75     private static final QNameModule BAZ = QNameModule.create(
  76         URI.create("urn:opendaylight.baz"), QName.parseRevision("2013-02-27"));
  77
  78     private SchemaContext context;
  79     private Module foo;
  80     private Module bar;
  81     private Module baz;
  82
  83     @Before
  84     public void init() throws Exception {
  85         context = TestUtils.loadModules(getClass().getResource("/model").toURI());
  86         foo = TestUtils.findModule(context, "foo").get();
  87         bar = TestUtils.findModule(context, "bar").get();
  88         baz = TestUtils.findModule(context, "baz").get();
  89     }
  90
  91     @Test
  92     public void testHeaders() throws ParseException {
  93         assertEquals("foo", foo.getName());
  94         assertEquals(YangVersion.VERSION_1.toString(), foo.getYangVersion());
  95         assertEquals(FOO.getNamespace(), foo.getNamespace());
  96         assertEquals("foo", foo.getPrefix());
  97
  98         final Set<ModuleImport> imports = foo.getImports();
  99         assertEquals(2, imports.size());
 100
 101         final ModuleImport import2 = TestUtils.findImport(imports, "br");
 102         assertEquals("bar", import2.getModuleName());
 103         assertEquals(BAR.getRevision(), import2.getRevision());
 104
 105         final ModuleImport import3 = TestUtils.findImport(imports, "bz");
 106         assertEquals("baz", import3.getModuleName());
 107         assertEquals(BAZ.getRevision(), import3.getRevision());
 108
 109         assertEquals("opendaylight", foo.getOrganization());
 110         assertEquals("http://www.opendaylight.org/", foo.getContact());
 111         final Date expectedRevision = TestUtils.createDate("2013-02-27");
 112         assertEquals(expectedRevision, foo.getRevision());
 113         assertNull(foo.getReference());
 114     }
 115
 116     @Test
 117     public void testParseList() {
 118         final ContainerSchemaNode interfaces = (ContainerSchemaNode) bar.getDataChildByName(QName.create(
 119             bar.getQNameModule(), "interfaces"));
 120
 121         final ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName(QName.create(bar.getQNameModule(),
 122             "ifEntry"));
 123         // test SchemaNode args
 124         assertEquals(QName.create(BAR, "ifEntry"), ifEntry.getQName());
 125
 126         final SchemaPath expectedPath = TestUtils.createPath(true, BAR, "interfaces", "ifEntry");
 127         assertEquals(expectedPath, ifEntry.getPath());
 128         assertNull(ifEntry.getDescription());
 129         assertNull(ifEntry.getReference());
 130         assertEquals(Status.CURRENT, ifEntry.getStatus());
 131         assertEquals(0, ifEntry.getUnknownSchemaNodes().size());
 132         // test DataSchemaNode args
 133         assertFalse(ifEntry.isAugmenting());
 134         assertTrue(ifEntry.isConfiguration());
 135         final ConstraintDefinition constraints = ifEntry.getConstraints();
 136         // :TODO augment to ifEntry have when condition and so in consequence
 137         // ifEntry should be a context node ?
 138         // assertNull(constraints.getWhenCondition());
 139         assertEquals(0, constraints.getMustConstraints().size());
 140         assertTrue(constraints.isMandatory());
 141         assertEquals(1, (int) constraints.getMinElements());
 142         assertEquals(11, (int) constraints.getMaxElements());
 143         // test AugmentationTarget args
 144         final Set<AugmentationSchema> availableAugmentations = ifEntry.getAvailableAugmentations();
 145         assertEquals(2, availableAugmentations.size());
 146         // test ListSchemaNode args
 147         final List<QName> expectedKey = new ArrayList<>();
 148         expectedKey.add(QName.create(BAR, "ifIndex"));
 149         assertEquals(expectedKey, ifEntry.getKeyDefinition());
 150         assertFalse(ifEntry.isUserOrdered());
 151         // test DataNodeContainer args
 152         assertEquals(0, ifEntry.getTypeDefinitions().size());
 153         assertEquals(4, ifEntry.getChildNodes().size());
 154         assertEquals(0, ifEntry.getGroupings().size());
 155         assertEquals(0, ifEntry.getUses().size());
 156
 157         final LeafSchemaNode ifIndex = (LeafSchemaNode) ifEntry.getDataChildByName(QName.create(bar.getQNameModule(), "ifIndex"));
 158         assertEquals(ifEntry.getKeyDefinition().get(0), ifIndex.getQName());
 159         assertTrue(ifIndex.getType() instanceof UnsignedIntegerTypeDefinition);
 160         assertEquals("minutes", ifIndex.getUnits());
 161         final LeafSchemaNode ifMtu = (LeafSchemaNode) ifEntry.getDataChildByName(QName.create(bar.getQNameModule(), "ifMtu"));
 162         assertEquals(BaseTypes.int32Type(), ifMtu.getType());
 163     }
 164
 165     @Test
 166     public void testTypedefRangesResolving() throws ParseException {
 167         final LeafSchemaNode int32Leaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "int32-leaf"));
 168
 169         final IntegerTypeDefinition leafType = (IntegerTypeDefinition) int32Leaf.getType();
 170         assertEquals(QName.create(FOO, "int32-ext2"), leafType.getQName());
 171         assertEquals("mile", leafType.getUnits());
 172         assertEquals("11", leafType.getDefaultValue());
 173
 174         final List<RangeConstraint> ranges = leafType.getRangeConstraints();
 175         assertEquals(1, ranges.size());
 176         final RangeConstraint range = ranges.get(0);
 177         assertEquals(12, range.getMin().intValue());
 178         assertEquals(20, range.getMax().intValue());
 179
 180         final IntegerTypeDefinition baseType = leafType.getBaseType();
 181         assertEquals(QName.create(BAR, "int32-ext2"), baseType.getQName());
 182         assertEquals("mile", baseType.getUnits());
 183         assertEquals("11", baseType.getDefaultValue());
 184
 185         final List<RangeConstraint> baseTypeRanges = baseType.getRangeConstraints();
 186         assertEquals(2, baseTypeRanges.size());
 187         final RangeConstraint baseTypeRange1 = baseTypeRanges.get(0);
 188         assertEquals(3, baseTypeRange1.getMin().intValue());
 189         assertEquals(9, baseTypeRange1.getMax().intValue());
 190         final RangeConstraint baseTypeRange2 = baseTypeRanges.get(1);
 191         assertEquals(11, baseTypeRange2.getMin().intValue());
 192         assertEquals(20, baseTypeRange2.getMax().intValue());
 193
 194         final IntegerTypeDefinition base = baseType.getBaseType();
 195         final QName baseQName = base.getQName();
 196         assertEquals("int32-ext1", baseQName.getLocalName());
 197         assertEquals(BAR, baseQName.getModule());
 198         assertNull(base.getUnits());
 199         assertNull(base.getDefaultValue());
 200
 201         final List<RangeConstraint> baseRanges = base.getRangeConstraints();
 202         assertEquals(1, baseRanges.size());
 203         final RangeConstraint baseRange = baseRanges.get(0);
 204         assertEquals(2, baseRange.getMin().intValue());
 205         assertEquals(20, baseRange.getMax().intValue());
 206
 207         assertEquals(BaseTypes.int32Type(), base.getBaseType());
 208     }
 209
 210     @Test
 211     public void testTypedefPatternsResolving() {
 212         final LeafSchemaNode stringleaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "string-leaf"));
 213
 214         assertTrue(stringleaf.getType() instanceof StringTypeDefinition);
 215         final StringTypeDefinition type = (StringTypeDefinition) stringleaf.getType();
 216         final QName typeQName = type.getQName();
 217         assertEquals("string-ext4", typeQName.getLocalName());
 218         assertEquals(BAR, typeQName.getModule());
 219         assertNull(type.getUnits());
 220         assertNull(type.getDefaultValue());
 221         List<PatternConstraint> patterns = type.getPatternConstraints();
 222         assertEquals(1, patterns.size());
 223         PatternConstraint pattern = patterns.iterator().next();
 224         assertEquals("^[e-z]*$", pattern.getRegularExpression());
 225         assertEquals(1, type.getLengthConstraints().size());
 226
 227         final StringTypeDefinition baseType1 = type.getBaseType();
 228         final QName baseType1QName = baseType1.getQName();
 229         assertEquals("string-ext3", baseType1QName.getLocalName());
 230         assertEquals(BAR, baseType1QName.getModule());
 231         assertNull(baseType1.getUnits());
 232         assertNull(baseType1.getDefaultValue());
 233         patterns = baseType1.getPatternConstraints();
 234         assertEquals(1, patterns.size());
 235         pattern = patterns.iterator().next();
 236         assertEquals("^[b-u]*$", pattern.getRegularExpression());
 237         assertEquals(1, baseType1.getLengthConstraints().size());
 238
 239         final StringTypeDefinition baseType2 = baseType1.getBaseType();
 240         final QName baseType2QName = baseType2.getQName();
 241         assertEquals("string-ext2", baseType2QName.getLocalName());
 242         assertEquals(BAR, baseType2QName.getModule());
 243         assertNull(baseType2.getUnits());
 244         assertNull(baseType2.getDefaultValue());
 245         assertTrue(baseType2.getPatternConstraints().isEmpty());
 246         final List<LengthConstraint> baseType2Lengths = baseType2.getLengthConstraints();
 247         assertEquals(1, baseType2Lengths.size());
 248         LengthConstraint length = baseType2Lengths.get(0);
 249         assertEquals(6, length.getMin().intValue());
 250         assertEquals(10, length.getMax().intValue());
 251
 252         final StringTypeDefinition baseType3 = baseType2.getBaseType();
 253         assertEquals(QName.create(BAR, "string-ext1"), baseType3.getQName());
 254         assertNull(baseType3.getUnits());
 255         assertNull(baseType3.getDefaultValue());
 256         patterns = baseType3.getPatternConstraints();
 257         assertEquals(1, patterns.size());
 258         pattern = patterns.iterator().next();
 259         assertEquals("^[a-k]*$", pattern.getRegularExpression());
 260         final List<LengthConstraint> baseType3Lengths = baseType3.getLengthConstraints();
 261         assertEquals(1, baseType3Lengths.size());
 262         length = baseType3Lengths.get(0);
 263         assertEquals(5, length.getMin().intValue());
 264         assertEquals(11, length.getMax().intValue());
 265
 266         assertEquals(BaseTypes.stringType(), baseType3.getBaseType());
 267     }
 268
 269     @Test
 270     public void testTypedefInvalidPatternsResolving() {
 271         final LeafSchemaNode invalidPatternStringLeaf = (LeafSchemaNode) foo
 272                 .getDataChildByName(QName.create(foo.getQNameModule(), "invalid-pattern-string-leaf"));
 273         StringTypeDefinition type = (StringTypeDefinition) invalidPatternStringLeaf.getType();
 274         assertEquals(QName.create(BAR, "invalid-string-pattern"), type.getQName());
 275         assertNull(type.getUnits());
 276         assertNull(type.getDefaultValue());
 277         List<PatternConstraint> patterns = type.getPatternConstraints();
 278         assertTrue(patterns.isEmpty());
 279
 280         final LeafSchemaNode invalidDirectStringPatternDefLeaf = (LeafSchemaNode) foo
 281                 .getDataChildByName(QName.create(foo.getQNameModule(), "invalid-direct-string-pattern-def-leaf"));
 282         type = (StringTypeDefinition) invalidDirectStringPatternDefLeaf.getType();
 283
 284         assertEquals(QName.create(YangConstants.RFC6020_YANG_MODULE, "string"), type.getQName());
 285         assertNull(type.getUnits());
 286         assertNull(type.getDefaultValue());
 287         patterns = type.getPatternConstraints();
 288         assertTrue(patterns.isEmpty());
 289
 290         final LeafSchemaNode multiplePatternStringLeaf = (LeafSchemaNode) foo
 291                 .getDataChildByName(QName.create(foo.getQNameModule(), "multiple-pattern-string-leaf"));
 292         type = (StringTypeDefinition) multiplePatternStringLeaf.getType();
 293         assertEquals(QName.create(BAR, "multiple-pattern-string"), type.getQName());
 294         assertNull(type.getUnits());
 295         assertNull(type.getDefaultValue());
 296         patterns = type.getPatternConstraints();
 297         assertTrue(!patterns.isEmpty());
 298         assertEquals(1, patterns.size());
 299         final PatternConstraint pattern = patterns.iterator().next();
 300         assertEquals("^[e-z]*$", pattern.getRegularExpression());
 301         assertEquals(1, type.getLengthConstraints().size());
 302
 303         final LeafSchemaNode multiplePatternDirectStringDefLeaf = (LeafSchemaNode) foo
 304                 .getDataChildByName(QName.create(foo.getQNameModule(), "multiple-pattern-direct-string-def-leaf"));
 305         type = (StringTypeDefinition) multiplePatternDirectStringDefLeaf.getType();
 306         assertEquals(QName.create(FOO, "string"), type.getQName());
 307         assertNull(type.getUnits());
 308         assertNull(type.getDefaultValue());
 309         patterns = type.getPatternConstraints();
 310         assertTrue(!patterns.isEmpty());
 311         assertEquals(2, patterns.size());
 312
 313         boolean isEZPattern = false;
 314         boolean isADPattern = false;
 315         for (final PatternConstraint patternConstraint : patterns) {
 316             if (patternConstraint.getRegularExpression().equals("^[e-z]*$")) {
 317                 isEZPattern = true;
 318             } else if (patternConstraint.getRegularExpression().equals("^[a-d]*$")) {
 319                 isADPattern = true;
 320             }
 321         }
 322         assertTrue(isEZPattern);
 323         assertTrue(isADPattern);
 324     }
 325
 326     @Test
 327     public void testTypedefLengthsResolving() {
 328         final LeafSchemaNode lengthLeaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "length-leaf"));
 329         final StringTypeDefinition type = (StringTypeDefinition) lengthLeaf.getType();
 330
 331         assertEquals(QName.create(FOO, "string-ext2"), type.getQName());
 332         assertNull(type.getUnits());
 333         assertNull(type.getDefaultValue());
 334         assertTrue(type.getPatternConstraints().isEmpty());
 335         final List<LengthConstraint> typeLengths = type.getLengthConstraints();
 336         assertEquals(1, typeLengths.size());
 337         LengthConstraint length = typeLengths.get(0);
 338         assertEquals(7, length.getMin().intValue());
 339         assertEquals(10, length.getMax().intValue());
 340
 341         final StringTypeDefinition baseType1 = type.getBaseType();
 342         assertEquals(QName.create(BAR, "string-ext2"), baseType1.getQName());
 343         assertNull(baseType1.getUnits());
 344         assertNull(baseType1.getDefaultValue());
 345         assertTrue(baseType1.getPatternConstraints().isEmpty());
 346         final List<LengthConstraint> baseType2Lengths = baseType1.getLengthConstraints();
 347         assertEquals(1, baseType2Lengths.size());
 348         length = baseType2Lengths.get(0);
 349         assertEquals(6, length.getMin().intValue());
 350         assertEquals(10, length.getMax().intValue());
 351
 352         final StringTypeDefinition baseType2 = baseType1.getBaseType();
 353         assertEquals(QName.create(BAR, "string-ext1"), baseType2.getQName());
 354         assertNull(baseType2.getUnits());
 355         assertNull(baseType2.getDefaultValue());
 356         final List<PatternConstraint> patterns = baseType2.getPatternConstraints();
 357         assertEquals(1, patterns.size());
 358         final PatternConstraint pattern = patterns.iterator().next();
 359         assertEquals("^[a-k]*$", pattern.getRegularExpression());
 360         final List<LengthConstraint> baseType3Lengths = baseType2.getLengthConstraints();
 361         assertEquals(1, baseType3Lengths.size());
 362         length = baseType3Lengths.get(0);
 363         assertEquals(5, length.getMin().intValue());
 364         assertEquals(11, length.getMax().intValue());
 365
 366         assertEquals(BaseTypes.stringType(), baseType2.getBaseType());
 367     }
 368
 369     @Test
 370     public void testTypedefDecimal1() {
 371         final LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "decimal-leaf"));
 372
 373         assertTrue(testleaf.getType() instanceof DecimalTypeDefinition);
 374         final DecimalTypeDefinition type = (DecimalTypeDefinition) testleaf.getType();
 375         assertEquals(QName.create(BAR, "my-decimal-type"), type.getQName());
 376         assertNull(type.getUnits());
 377         assertNull(type.getDefaultValue());
 378         assertEquals(6, type.getFractionDigits().intValue());
 379         assertEquals(1, type.getRangeConstraints().size());
 380
 381         final DecimalTypeDefinition typeBase = type.getBaseType();
 382         assertEquals(QName.create(BAR, "decimal64"), typeBase.getQName());
 383         assertNull(typeBase.getUnits());
 384         assertNull(typeBase.getDefaultValue());
 385         assertEquals(6, typeBase.getFractionDigits().intValue());
 386         assertEquals(1, typeBase.getRangeConstraints().size());
 387
 388         assertNull(typeBase.getBaseType());
 389     }
 390
 391     @Test
 392     public void testTypedefDecimal2() {
 393         final LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "decimal-leaf2"));
 394
 395         assertTrue(testleaf.getType() instanceof DecimalTypeDefinition);
 396         final DecimalTypeDefinition type = (DecimalTypeDefinition) testleaf.getType();
 397         assertEquals(QName.create(BAR, "my-decimal-type"), type.getQName());
 398         assertNull(type.getUnits());
 399         assertNull(type.getDefaultValue());
 400         assertEquals(6, type.getFractionDigits().intValue());
 401         assertEquals(1, type.getRangeConstraints().size());
 402
 403         final DecimalTypeDefinition baseTypeDecimal = type.getBaseType();
 404         assertEquals(6, baseTypeDecimal.getFractionDigits().intValue());
 405     }
 406
 407     @Test
 408     public void testTypedefUnion() {
 409         final LeafSchemaNode unionleaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "union-leaf"));
 410
 411         assertTrue(unionleaf.getType() instanceof UnionTypeDefinition);
 412         final UnionTypeDefinition type = (UnionTypeDefinition) unionleaf.getType();
 413         assertEquals(QName.create(BAR, "my-union-ext"), type.getQName());
 414         assertNull(type.getUnits());
 415         assertNull(type.getDefaultValue());
 416
 417         final UnionTypeDefinition baseType = type.getBaseType();
 418         assertEquals(QName.create(BAR, "my-union"), baseType.getQName());
 419         assertNull(baseType.getUnits());
 420         assertNull(baseType.getDefaultValue());
 421
 422         final UnionTypeDefinition unionType = baseType.getBaseType();
 423         final List<TypeDefinition<?>> unionTypes = unionType.getTypes();
 424         assertEquals(2, unionTypes.size());
 425
 426         final IntegerTypeDefinition unionType1 = (IntegerTypeDefinition) unionTypes.get(0);
 427         assertEquals(QName.create(BAR, "my-union"), baseType.getQName());
 428         assertNull(unionType1.getUnits());
 429         assertNull(unionType1.getDefaultValue());
 430
 431         final List<RangeConstraint> ranges = unionType1.getRangeConstraints();
 432         assertEquals(1, ranges.size());
 433         final RangeConstraint range = ranges.get(0);
 434         assertEquals(1, range.getMin().intValue());
 435         assertEquals(100, range.getMax().intValue());
 436         assertEquals(BaseTypes.int16Type(), unionType1.getBaseType());
 437
 438         assertEquals(BaseTypes.int32Type(), unionTypes.get(1));
 439     }
 440
 441     @Test
 442     public void testNestedUnionResolving() {
 443         final LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "custom-union-leaf"));
 444
 445         assertTrue(testleaf.getType() instanceof UnionTypeDefinition);
 446         final UnionTypeDefinition type = (UnionTypeDefinition) testleaf.getType();
 447         assertEquals(QName.create(BAZ, "union1"), type.getQName());
 448         assertNull(type.getUnits());
 449         assertNull(type.getDefaultValue());
 450
 451         final UnionTypeDefinition typeBase = type.getBaseType();
 452         assertEquals(QName.create(BAZ, "union2"), typeBase.getQName());
 453         assertNull(typeBase.getUnits());
 454         assertNull(typeBase.getDefaultValue());
 455
 456         final UnionTypeDefinition union = typeBase.getBaseType();
 457         final List<TypeDefinition<?>> unionTypes = union.getTypes();
 458         assertEquals(2, unionTypes.size());
 459         assertEquals(BaseTypes.int32Type(), unionTypes.get(0));
 460         assertTrue(unionTypes.get(1) instanceof UnionTypeDefinition);
 461
 462         final UnionTypeDefinition unionType1 = (UnionTypeDefinition) unionTypes.get(1);
 463         assertEquals(QName.create(BAR, "nested-union2"), unionType1.getQName());
 464         assertNull(unionType1.getUnits());
 465         assertNull(unionType1.getDefaultValue());
 466
 467         final UnionTypeDefinition nestedUnion = unionType1.getBaseType();
 468         final List<TypeDefinition<?>> nestedUnion2Types = nestedUnion.getTypes();
 469         assertEquals(2, nestedUnion2Types.size());
 470         assertTrue(nestedUnion2Types.get(1) instanceof StringTypeDefinition);
 471         assertTrue(nestedUnion2Types.get(0) instanceof UnionTypeDefinition);
 472
 473         final UnionTypeDefinition myUnionExt = (UnionTypeDefinition) nestedUnion2Types.get(0);
 474         assertEquals(QName.create(BAR, "my-union-ext"), myUnionExt.getQName());
 475         assertNull(myUnionExt.getUnits());
 476         assertNull(myUnionExt.getDefaultValue());
 477
 478
 479         final UnionTypeDefinition myUnion = myUnionExt.getBaseType();
 480         assertEquals(QName.create(BAR, "my-union"), myUnion.getQName());
 481         assertNull(myUnion.getUnits());
 482         assertNull(myUnion.getDefaultValue());
 483
 484         final UnionTypeDefinition myUnionBase = myUnion.getBaseType();
 485         final List<TypeDefinition<?>> myUnionBaseTypes = myUnionBase.getTypes();
 486         assertEquals(2, myUnionBaseTypes.size());
 487         assertTrue(myUnionBaseTypes.get(0) instanceof IntegerTypeDefinition);
 488         assertEquals(BaseTypes.int32Type(), myUnionBaseTypes.get(1));
 489
 490         final IntegerTypeDefinition int16Ext = (IntegerTypeDefinition) myUnionBaseTypes.get(0);
 491         assertEquals(QName.create(BAR, "int16"), int16Ext.getQName());
 492         assertNull(int16Ext.getUnits());
 493         assertNull(int16Ext.getDefaultValue());
 494         final List<RangeConstraint> ranges = int16Ext.getRangeConstraints();
 495         assertEquals(1, ranges.size());
 496         final RangeConstraint range = ranges.get(0);
 497         assertEquals(1, range.getMin().intValue());
 498         assertEquals(100, range.getMax().intValue());
 499
 500         assertEquals(BaseTypes.int16Type(), int16Ext.getBaseType());
 501     }
 502
 503     @Test
 504     public void testChoice() {
 505         final ContainerSchemaNode transfer = (ContainerSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "transfer"));
 506         final ChoiceSchemaNode how = (ChoiceSchemaNode) transfer.getDataChildByName(QName.create(foo.getQNameModule(), "how"));
 507         final Set<ChoiceCaseNode> cases = how.getCases();
 508         assertEquals(5, cases.size());
 509         ChoiceCaseNode input = null;
 510         ChoiceCaseNode output = null;
 511         for (final ChoiceCaseNode caseNode : cases) {
 512             if ("input".equals(caseNode.getQName().getLocalName())) {
 513                 input = caseNode;
 514             } else if ("output".equals(caseNode.getQName().getLocalName())) {
 515                 output = caseNode;
 516             }
 517         }
 518         assertNotNull(input);
 519         assertNotNull(input.getPath());
 520         assertNotNull(output);
 521         assertNotNull(output.getPath());
 522     }
 523
 524     @Test
 525     public void testDeviation() {
 526         final Set<Deviation> deviations = foo.getDeviations();
 527         assertEquals(1, deviations.size());
 528         final Deviation dev = deviations.iterator().next();
 529         assertEquals("system/user ref", dev.getReference());
 530
 531         final SchemaPath expectedPath = SchemaPath.create(true,
 532             QName.create(BAR, "interfaces"),
 533             QName.create(BAR, "ifEntry"));
 534
 535         assertEquals(expectedPath, dev.getTargetPath());
 536         assertEquals(DeviateKind.ADD, dev.getDeviates().iterator().next().getDeviateType());
 537     }
 538
 539     @Test
 540     public void testUnknownNode() {
 541         final ContainerSchemaNode network = (ContainerSchemaNode) baz.getDataChildByName(QName.create(baz.getQNameModule(), "network"));
 542         final List<UnknownSchemaNode> unknownNodes = network.getUnknownSchemaNodes();
 543         assertEquals(1, unknownNodes.size());
 544         final UnknownSchemaNode unknownNode = unknownNodes.get(0);
 545         assertNotNull(unknownNode.getNodeType());
 546         assertEquals("point", unknownNode.getNodeParameter());
 547     }
 548
 549     @Test
 550     public void testFeature() {
 551         final Set<FeatureDefinition> features = baz.getFeatures();
 552         assertEquals(1, features.size());
 553     }
 554
 555     @Test
 556     public void testExtension() {
 557         final List<ExtensionDefinition> extensions = baz.getExtensionSchemaNodes();
 558         assertEquals(1, extensions.size());
 559         final ExtensionDefinition extension = extensions.get(0);
 560         assertEquals("name", extension.getArgument());
 561         assertEquals("Takes as argument a name string. Makes the code generator use the given name in the #define.",
 562                 extension.getDescription());
 563         assertTrue(extension.isYinElement());
 564     }
 565
 566     @Test
 567     public void testNotification() {
 568         final Set<NotificationDefinition> notifications = baz.getNotifications();
 569         assertEquals(1, notifications.size());
 570
 571         final NotificationDefinition notification = notifications.iterator().next();
 572         // test SchemaNode args
 573         assertEquals(QName.create(BAZ, "event"), notification.getQName());
 574         final SchemaPath expectedPath = SchemaPath.create(true,  QName.create(BAZ, "event"));
 575         assertEquals(expectedPath, notification.getPath());
 576         assertNull(notification.getDescription());
 577         assertNull(notification.getReference());
 578         assertEquals(Status.CURRENT, notification.getStatus());
 579         assertEquals(0, notification.getUnknownSchemaNodes().size());
 580         // test DataNodeContainer args
 581         assertEquals(0, notification.getTypeDefinitions().size());
 582         assertEquals(3, notification.getChildNodes().size());
 583         assertEquals(0, notification.getGroupings().size());
 584         assertEquals(0, notification.getUses().size());
 585
 586         final LeafSchemaNode eventClass = (LeafSchemaNode) notification.getDataChildByName(QName.create(baz.getQNameModule(), "event-class"));
 587         assertTrue(eventClass.getType() instanceof StringTypeDefinition);
 588         final LeafSchemaNode severity = (LeafSchemaNode) notification.getDataChildByName(QName.create(baz.getQNameModule(), "severity"));
 589         assertTrue(severity.getType() instanceof StringTypeDefinition);
 590     }
 591
 592     @Test
 593     public void testRpc() {
 594         final Set<RpcDefinition> rpcs = baz.getRpcs();
 595         assertEquals(1, rpcs.size());
 596
 597         final RpcDefinition rpc = rpcs.iterator().next();
 598         assertEquals("Retrieve all or part of a specified configuration.", rpc.getDescription());
 599         assertEquals("RFC 6241, Section 7.1", rpc.getReference());
 600     }
 601
 602     @Test
 603     public void testTypePath() throws ParseException {
 604         final Set<TypeDefinition<?>> types = bar.getTypeDefinitions();
 605
 606         // int32-ext1
 607         final IntegerTypeDefinition int32ext1 = (IntegerTypeDefinition) TestUtils.findTypedef(types, "int32-ext1");
 608         final QName int32TypedefQName = QName.create(BAR, "int32-ext1");
 609         assertEquals(int32TypedefQName, int32ext1.getQName());
 610
 611         final SchemaPath typeSchemaPath = int32ext1.getPath();
 612         final Iterable<QName> typePath = typeSchemaPath.getPathFromRoot();
 613         final Iterator<QName> typePathIt = typePath.iterator();
 614         assertEquals(int32TypedefQName, typePathIt.next());
 615         assertFalse(typePathIt.hasNext());
 616
 617         // int32-ext1/int32
 618         final IntegerTypeDefinition int32 = int32ext1.getBaseType();
 619         assertEquals(BaseTypes.int32Type(), int32);
 620     }
 621
 622     @Test
 623     public void testTypePath2() throws ParseException {
 624         final Set<TypeDefinition<?>> types = bar.getTypeDefinitions();
 625
 626         // my-decimal-type
 627         final DecimalTypeDefinition myDecType = (DecimalTypeDefinition) TestUtils.findTypedef(types, "my-decimal-type");
 628         final QName myDecTypeQName = myDecType.getQName();
 629
 630         assertEquals(BAR, myDecTypeQName.getModule());
 631         assertEquals("my-decimal-type", myDecTypeQName.getLocalName());
 632
 633         final SchemaPath typeSchemaPath = myDecType.getPath();
 634         final Iterable<QName> typePath = typeSchemaPath.getPathFromRoot();
 635         final Iterator<QName> typePathIt = typePath.iterator();
 636         assertEquals(myDecTypeQName, typePathIt.next());
 637         assertFalse(typePathIt.hasNext());
 638
 639         // my-base-int32-type/int32
 640         final DecimalTypeDefinition dec64 = myDecType.getBaseType();
 641         final QName dec64QName = dec64.getQName();
 642
 643         assertEquals(BAR, dec64QName.getModule());
 644         assertEquals("decimal64", dec64QName.getLocalName());
 645
 646         final SchemaPath dec64SchemaPath = dec64.getPath();
 647         final Iterable<QName> dec64Path = dec64SchemaPath.getPathFromRoot();
 648         final Iterator<QName> dec64PathIt = dec64Path.iterator();
 649         assertEquals(myDecTypeQName, dec64PathIt.next());
 650         assertEquals(dec64QName, dec64PathIt.next());
 651         assertFalse(dec64PathIt.hasNext());
 652     }
 653
 654     private static void checkOrder(final Collection<Module> modules) {
 655         final Iterator<Module> it = modules.iterator();
 656         Module m = it.next();
 657         assertEquals("m2", m.getName());
 658         m = it.next();
 659         assertEquals("m4", m.getName());
 660         m = it.next();
 661         assertEquals("m6", m.getName());
 662         m = it.next();
 663         assertEquals("m8", m.getName());
 664         m = it.next();
 665         assertEquals("m7", m.getName());
 666         m = it.next();
 667         assertEquals("m5", m.getName());
 668         m = it.next();
 669         assertEquals("m3", m.getName());
 670         m = it.next();
 671         assertEquals("m1", m.getName());
 672     }
 673
 674     private static void assertSetEquals(final Set<Module> s1, final Set<Module> s2) {
 675         assertEquals(s1, s2);
 676         final Iterator<Module> it = s1.iterator();
 677         for (final Module m : s2) {
 678             assertEquals(m, it.next());
 679         }
 680     }
 681
 682     @Test
 683     public void testSubmodules() {
 684         final DataSchemaNode id = foo.getDataChildByName(QName.create(foo.getQNameModule(), "id"));
 685         assertNotNull(id);
 686         final DataSchemaNode subExt = foo.getDataChildByName(QName.create(foo.getQNameModule(), "sub-ext"));
 687         assertNotNull(subExt);
 688         final DataSchemaNode subTransfer = foo.getDataChildByName(QName.create(foo.getQNameModule(), "sub-transfer"));
 689         assertNotNull(subTransfer);
 690
 691         assertEquals(2, foo.getExtensionSchemaNodes().size());
 692         assertEquals(2, foo.getAugmentations().size());
 693     }
 694
 695     @Test
 696     public void unknownStatementInSubmoduleHeaderTest() throws IOException, URISyntaxException, ReactorException {
 697         final StatementStreamSource yang1 = sourceForResource("/yang-grammar-test/revisions-extension.yang");
 698         final StatementStreamSource yang2 = sourceForResource("/yang-grammar-test/submodule-header-extension.yang");
 699         TestUtils.parseYangSources(yang1, yang2);
 700     }
 701
 702     @Test
 703     public void unknownStatementBetweenRevisionsTest() throws ReactorException {
 704
 705         final StatementStreamSource yangModule = sourceForResource("/yang-grammar-test/revisions-extension.yang");
 706         final StatementStreamSource yangSubmodule = sourceForResource(
 707                 "/yang-grammar-test/submodule-header-extension.yang");
 708
 709         final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
 710         reactor.addSources(yangModule, yangSubmodule);
 711
 712         final SchemaContext result = reactor.buildEffective();
 713         assertNotNull(result);
 714     }
 715
 716     @Test
 717     public void unknownStatementsInStatementsTest() throws ReactorException {
 718
 719         final StatementStreamSource yangFile1 = sourceForResource(
 720                 "/yang-grammar-test/stmtsep-in-statements.yang");
 721         final StatementStreamSource yangFile2 = sourceForResource(
 722                 "/yang-grammar-test/stmtsep-in-statements2.yang");
 723         final StatementStreamSource yangFile3 = sourceForResource(
 724                 "/yang-grammar-test/stmtsep-in-statements-sub.yang");
 725
 726         final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
 727         reactor.addSources(yangFile1, yangFile2, yangFile3);
 728         // TODO: change test or create new module in order to respect new statement parser validations
 729         try {
 730             final SchemaContext result = reactor.buildEffective();
 731         } catch (final Exception e) {
 732             assertEquals(SomeModifiersUnresolvedException.class, e.getClass());
 733             assertTrue(e.getCause() instanceof SourceException);
 734             assertTrue(e.getCause().getMessage().startsWith("aaa is not a YANG statement or use of extension"));
 735         }
 736     }
 737
 738 }