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