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