X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fstmt%2FYangParserTest.java;h=35def2dd0c1319b4185e3a15e231c908df94d427;hb=995d312c14bd31d62d0faa8b11773bc4399cfc4f;hp=bba2e788194f4a3aa19c8b0a8a7b764d20d19090;hpb=6a812b89197f7c15df59a00133377db769570445;p=yangtools.git diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserTest.java index bba2e78819..35def2dd0c 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserTest.java @@ -12,15 +12,14 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource; -import java.io.File; +import com.google.common.collect.Range; +import com.google.common.collect.RangeSet; import java.io.IOException; import java.net.URI; import java.net.URISyntaxException; -import java.text.DateFormat; import java.text.ParseException; -import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Date; @@ -30,7 +29,9 @@ import java.util.Set; import org.junit.Before; import org.junit.Test; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.common.YangConstants; +import org.opendaylight.yangtools.yang.common.YangVersion; import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode; import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; @@ -47,13 +48,13 @@ import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.ModuleImport; import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; import org.opendaylight.yangtools.yang.model.api.RpcDefinition; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.Status; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition; -import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint; import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition; @@ -61,43 +62,38 @@ import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition; import org.opendaylight.yangtools.yang.model.util.type.BaseTypes; import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException; +import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException; +import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource; import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangStatementSourceImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveSchemaContext; -import org.opendaylight.yangtools.yang.parser.util.YangParseException; public class YangParserTest { - public static final String FS = File.separator; - - private final URI fooNS = URI.create("urn:opendaylight.foo"); - private final URI barNS = URI.create("urn:opendaylight.bar"); - private final URI bazNS = URI.create("urn:opendaylight.baz"); - private Date fooRev; - private Date barRev; - private Date bazRev; - - private Set modules; + private static final QNameModule FOO = QNameModule.create( + URI.create("urn:opendaylight.foo"), QName.parseRevision("2013-02-27")); + private static final QNameModule BAR = QNameModule.create( + URI.create("urn:opendaylight.bar"), QName.parseRevision("2013-07-03")); + private static final QNameModule BAZ = QNameModule.create( + URI.create("urn:opendaylight.baz"), QName.parseRevision("2013-02-27")); + + private SchemaContext context; + private Module foo; + private Module bar; + private Module baz; @Before public void init() throws Exception { - final DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); - fooRev = simpleDateFormat.parse("2013-02-27"); - barRev = simpleDateFormat.parse("2013-07-03"); - bazRev = simpleDateFormat.parse("2013-02-27"); - - modules = TestUtils.loadModules(getClass().getResource("/model").toURI()); - assertEquals(3, modules.size()); + context = TestUtils.loadModules(getClass().getResource("/model").toURI()); + foo = TestUtils.findModule(context, "foo").get(); + bar = TestUtils.findModule(context, "bar").get(); + baz = TestUtils.findModule(context, "baz").get(); } @Test public void testHeaders() throws ParseException { - final Module foo = TestUtils.findModule(modules, "foo"); - assertEquals("foo", foo.getName()); - assertEquals("1", foo.getYangVersion()); - assertEquals(fooNS, foo.getNamespace()); + assertEquals(YangVersion.VERSION_1, foo.getYangVersion()); + assertEquals(FOO.getNamespace(), foo.getNamespace()); assertEquals("foo", foo.getPrefix()); final Set imports = foo.getImports(); @@ -105,33 +101,30 @@ public class YangParserTest { final ModuleImport import2 = TestUtils.findImport(imports, "br"); assertEquals("bar", import2.getModuleName()); - assertEquals(barRev, import2.getRevision()); + assertEquals(BAR.getRevision(), import2.getRevision()); final ModuleImport import3 = TestUtils.findImport(imports, "bz"); assertEquals("baz", import3.getModuleName()); - assertEquals(bazRev, import3.getRevision()); + assertEquals(BAZ.getRevision(), import3.getRevision()); assertEquals("opendaylight", foo.getOrganization()); assertEquals("http://www.opendaylight.org/", foo.getContact()); - final Date expectedRevision = TestUtils.createDate("2013-02-27"); + final Date expectedRevision = QName.parseRevision("2013-02-27"); assertEquals(expectedRevision, foo.getRevision()); assertNull(foo.getReference()); } @Test public void testParseList() { - final Module bar = TestUtils.findModule(modules, "bar"); - final URI expectedNamespace = URI.create("urn:opendaylight.bar"); - final String expectedPrefix = "bar"; - - final ContainerSchemaNode interfaces = (ContainerSchemaNode) bar.getDataChildByName(QName.create(bar.getQNameModule(), "interfaces")); + final ContainerSchemaNode interfaces = (ContainerSchemaNode) bar.getDataChildByName(QName.create( + bar.getQNameModule(), "interfaces")); - final ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName(QName.create(bar.getQNameModule(), "ifEntry")); + final ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName(QName.create(bar.getQNameModule(), + "ifEntry")); // test SchemaNode args - final QName expectedQName = QName.create(expectedNamespace, barRev, "ifEntry"); - assertEquals(expectedQName, ifEntry.getQName()); - final SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace, barRev, expectedPrefix, "interfaces", - "ifEntry"); + assertEquals(QName.create(BAR, "ifEntry"), ifEntry.getQName()); + + final SchemaPath expectedPath = TestUtils.createPath(true, BAR, "interfaces", "ifEntry"); assertEquals(expectedPath, ifEntry.getPath()); assertNull(ifEntry.getDescription()); assertNull(ifEntry.getReference()); @@ -153,7 +146,7 @@ public class YangParserTest { assertEquals(2, availableAugmentations.size()); // test ListSchemaNode args final List expectedKey = new ArrayList<>(); - expectedKey.add(QName.create(expectedNamespace, barRev, "ifIndex")); + expectedKey.add(QName.create(BAR, "ifIndex")); assertEquals(expectedKey, ifEntry.getKeyDefinition()); assertFalse(ifEntry.isUserOrdered()); // test DataNodeContainer args @@ -172,14 +165,10 @@ public class YangParserTest { @Test public void testTypedefRangesResolving() throws ParseException { - final Module foo = TestUtils.findModule(modules, "foo"); final LeafSchemaNode int32Leaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "int32-leaf")); final IntegerTypeDefinition leafType = (IntegerTypeDefinition) int32Leaf.getType(); - final QName leafTypeQName = leafType.getQName(); - assertEquals("int32-ext2", leafTypeQName.getLocalName()); - assertEquals(fooNS, leafTypeQName.getNamespace()); - assertEquals(fooRev, leafTypeQName.getRevision()); + assertEquals(QName.create(FOO, "int32-ext2"), leafType.getQName()); assertEquals("mile", leafType.getUnits()); assertEquals("11", leafType.getDefaultValue()); @@ -190,10 +179,7 @@ public class YangParserTest { assertEquals(20, range.getMax().intValue()); final IntegerTypeDefinition baseType = leafType.getBaseType(); - final QName baseTypeQName = baseType.getQName(); - assertEquals("int32-ext2", baseTypeQName.getLocalName()); - assertEquals(barNS, baseTypeQName.getNamespace()); - assertEquals(barRev, baseTypeQName.getRevision()); + assertEquals(QName.create(BAR, "int32-ext2"), baseType.getQName()); assertEquals("mile", baseType.getUnits()); assertEquals("11", baseType.getDefaultValue()); @@ -209,8 +195,7 @@ public class YangParserTest { final IntegerTypeDefinition base = baseType.getBaseType(); final QName baseQName = base.getQName(); assertEquals("int32-ext1", baseQName.getLocalName()); - assertEquals(barNS, baseQName.getNamespace()); - assertEquals(barRev, baseQName.getRevision()); + assertEquals(BAR, baseQName.getModule()); assertNull(base.getUnits()); assertNull(base.getDefaultValue()); @@ -225,80 +210,69 @@ public class YangParserTest { @Test public void testTypedefPatternsResolving() { - final Module foo = TestUtils.findModule(modules, "foo"); final LeafSchemaNode stringleaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "string-leaf")); assertTrue(stringleaf.getType() instanceof StringTypeDefinition); final StringTypeDefinition type = (StringTypeDefinition) stringleaf.getType(); final QName typeQName = type.getQName(); assertEquals("string-ext4", typeQName.getLocalName()); - assertEquals(barNS, typeQName.getNamespace()); - assertEquals(barRev, typeQName.getRevision()); + assertEquals(BAR, typeQName.getModule()); assertNull(type.getUnits()); assertNull(type.getDefaultValue()); List patterns = type.getPatternConstraints(); assertEquals(1, patterns.size()); PatternConstraint pattern = patterns.iterator().next(); assertEquals("^[e-z]*$", pattern.getRegularExpression()); - assertEquals(1, type.getLengthConstraints().size()); + assertEquals(1, type.getLengthConstraint().get().getAllowedRanges().asRanges().size()); final StringTypeDefinition baseType1 = type.getBaseType(); final QName baseType1QName = baseType1.getQName(); assertEquals("string-ext3", baseType1QName.getLocalName()); - assertEquals(barNS, baseType1QName.getNamespace()); - assertEquals(barRev, baseType1QName.getRevision()); + assertEquals(BAR, baseType1QName.getModule()); assertNull(baseType1.getUnits()); assertNull(baseType1.getDefaultValue()); patterns = baseType1.getPatternConstraints(); assertEquals(1, patterns.size()); pattern = patterns.iterator().next(); assertEquals("^[b-u]*$", pattern.getRegularExpression()); - assertEquals(1, baseType1.getLengthConstraints().size()); + assertEquals(1, baseType1.getLengthConstraint().get().getAllowedRanges().asRanges().size()); final StringTypeDefinition baseType2 = baseType1.getBaseType(); final QName baseType2QName = baseType2.getQName(); assertEquals("string-ext2", baseType2QName.getLocalName()); - assertEquals(barNS, baseType2QName.getNamespace()); - assertEquals(barRev, baseType2QName.getRevision()); + assertEquals(BAR, baseType2QName.getModule()); assertNull(baseType2.getUnits()); assertNull(baseType2.getDefaultValue()); assertTrue(baseType2.getPatternConstraints().isEmpty()); - final List baseType2Lengths = baseType2.getLengthConstraints(); - assertEquals(1, baseType2Lengths.size()); - LengthConstraint length = baseType2Lengths.get(0); - assertEquals(6, length.getMin().intValue()); - assertEquals(10, length.getMax().intValue()); + final RangeSet baseType2Lengths = baseType2.getLengthConstraint().get().getAllowedRanges(); + assertEquals(1, baseType2Lengths.asRanges().size()); + Range length = baseType2Lengths.span(); + assertEquals(6, length.lowerEndpoint().intValue()); + assertEquals(10, length.upperEndpoint().intValue()); final StringTypeDefinition baseType3 = baseType2.getBaseType(); - final QName baseType3QName = baseType3.getQName(); - assertEquals("string-ext1", baseType3QName.getLocalName()); - assertEquals(barNS, baseType3QName.getNamespace()); - assertEquals(barRev, baseType3QName.getRevision()); + assertEquals(QName.create(BAR, "string-ext1"), baseType3.getQName()); assertNull(baseType3.getUnits()); assertNull(baseType3.getDefaultValue()); patterns = baseType3.getPatternConstraints(); assertEquals(1, patterns.size()); pattern = patterns.iterator().next(); assertEquals("^[a-k]*$", pattern.getRegularExpression()); - final List baseType3Lengths = baseType3.getLengthConstraints(); - assertEquals(1, baseType3Lengths.size()); - length = baseType3Lengths.get(0); - assertEquals(5, length.getMin().intValue()); - assertEquals(11, length.getMax().intValue()); + final RangeSet baseType3Lengths = baseType3.getLengthConstraint().get().getAllowedRanges(); + assertEquals(1, baseType3Lengths.asRanges().size()); + length = baseType3Lengths.span(); + assertEquals(5, length.lowerEndpoint().intValue()); + assertEquals(11, length.upperEndpoint().intValue()); assertEquals(BaseTypes.stringType(), baseType3.getBaseType()); } @Test public void testTypedefInvalidPatternsResolving() { - final Module foo = TestUtils.findModule(modules, "foo"); final LeafSchemaNode invalidPatternStringLeaf = (LeafSchemaNode) foo .getDataChildByName(QName.create(foo.getQNameModule(), "invalid-pattern-string-leaf")); StringTypeDefinition type = (StringTypeDefinition) invalidPatternStringLeaf.getType(); - QName typeQName = type.getQName(); - assertEquals("invalid-string-pattern", typeQName.getLocalName()); - assertEquals(barNS, typeQName.getNamespace()); - assertEquals(barRev, typeQName.getRevision()); + assertEquals(QName.create(BAR, "invalid-string-pattern"), type.getQName()); assertNull(type.getUnits()); assertNull(type.getDefaultValue()); List patterns = type.getPatternConstraints(); @@ -307,10 +281,8 @@ public class YangParserTest { final LeafSchemaNode invalidDirectStringPatternDefLeaf = (LeafSchemaNode) foo .getDataChildByName(QName.create(foo.getQNameModule(), "invalid-direct-string-pattern-def-leaf")); type = (StringTypeDefinition) invalidDirectStringPatternDefLeaf.getType(); - typeQName = type.getQName(); - assertEquals("string", typeQName.getLocalName()); - assertEquals(YangConstants.RFC6020_YANG_NAMESPACE, typeQName.getNamespace()); - assertNull(typeQName.getRevision()); + + assertEquals(QName.create(YangConstants.RFC6020_YANG_MODULE, "string"), type.getQName()); assertNull(type.getUnits()); assertNull(type.getDefaultValue()); patterns = type.getPatternConstraints(); @@ -319,10 +291,7 @@ public class YangParserTest { final LeafSchemaNode multiplePatternStringLeaf = (LeafSchemaNode) foo .getDataChildByName(QName.create(foo.getQNameModule(), "multiple-pattern-string-leaf")); type = (StringTypeDefinition) multiplePatternStringLeaf.getType(); - typeQName = type.getQName(); - assertEquals("multiple-pattern-string", typeQName.getLocalName()); - assertEquals(barNS, typeQName.getNamespace()); - assertEquals(barRev, typeQName.getRevision()); + assertEquals(QName.create(BAR, "multiple-pattern-string"), type.getQName()); assertNull(type.getUnits()); assertNull(type.getDefaultValue()); patterns = type.getPatternConstraints(); @@ -330,15 +299,12 @@ public class YangParserTest { assertEquals(1, patterns.size()); final PatternConstraint pattern = patterns.iterator().next(); assertEquals("^[e-z]*$", pattern.getRegularExpression()); - assertEquals(1, type.getLengthConstraints().size()); + assertEquals(1, type.getLengthConstraint().get().getAllowedRanges().asRanges().size()); final LeafSchemaNode multiplePatternDirectStringDefLeaf = (LeafSchemaNode) foo .getDataChildByName(QName.create(foo.getQNameModule(), "multiple-pattern-direct-string-def-leaf")); type = (StringTypeDefinition) multiplePatternDirectStringDefLeaf.getType(); - typeQName = type.getQName(); - assertEquals("string", typeQName.getLocalName()); - assertEquals(fooNS, typeQName.getNamespace()); - assertEquals(fooRev, typeQName.getRevision()); + assertEquals(QName.create(FOO, "string"), type.getQName()); assertNull(type.getUnits()); assertNull(type.getDefaultValue()); patterns = type.getPatternConstraints(); @@ -360,79 +326,62 @@ public class YangParserTest { @Test public void testTypedefLengthsResolving() { - final Module foo = TestUtils.findModule(modules, "foo"); - - final LeafSchemaNode lengthLeaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "length-leaf")); + final LeafSchemaNode lengthLeaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), + "length-leaf")); final StringTypeDefinition type = (StringTypeDefinition) lengthLeaf.getType(); - final QName typeQName = type.getQName(); - assertEquals("string-ext2", typeQName.getLocalName()); - assertEquals(fooNS, typeQName.getNamespace()); - assertEquals(fooRev, typeQName.getRevision()); + assertEquals(QName.create(FOO, "string-ext2"), type.getQName()); assertNull(type.getUnits()); assertNull(type.getDefaultValue()); assertTrue(type.getPatternConstraints().isEmpty()); - final List typeLengths = type.getLengthConstraints(); - assertEquals(1, typeLengths.size()); - LengthConstraint length = typeLengths.get(0); - assertEquals(7, length.getMin().intValue()); - assertEquals(10, length.getMax().intValue()); + final RangeSet typeLengths = type.getLengthConstraint().get().getAllowedRanges(); + assertEquals(1, typeLengths.asRanges().size()); + Range length = typeLengths.span(); + assertEquals(7, length.lowerEndpoint().intValue()); + assertEquals(10, length.upperEndpoint().intValue()); final StringTypeDefinition baseType1 = type.getBaseType(); - final QName baseType1QName = baseType1.getQName(); - assertEquals("string-ext2", baseType1QName.getLocalName()); - assertEquals(barNS, baseType1QName.getNamespace()); - assertEquals(barRev, baseType1QName.getRevision()); + assertEquals(QName.create(BAR, "string-ext2"), baseType1.getQName()); assertNull(baseType1.getUnits()); assertNull(baseType1.getDefaultValue()); assertTrue(baseType1.getPatternConstraints().isEmpty()); - final List baseType2Lengths = baseType1.getLengthConstraints(); - assertEquals(1, baseType2Lengths.size()); - length = baseType2Lengths.get(0); - assertEquals(6, length.getMin().intValue()); - assertEquals(10, length.getMax().intValue()); + final RangeSet baseType2Lengths = baseType1.getLengthConstraint().get().getAllowedRanges(); + assertEquals(1, baseType2Lengths.asRanges().size()); + length = baseType2Lengths.span(); + assertEquals(6, length.lowerEndpoint().intValue()); + assertEquals(10, length.upperEndpoint().intValue()); final StringTypeDefinition baseType2 = baseType1.getBaseType(); - final QName baseType2QName = baseType2.getQName(); - assertEquals("string-ext1", baseType2QName.getLocalName()); - assertEquals(barNS, baseType2QName.getNamespace()); - assertEquals(barRev, baseType2QName.getRevision()); + assertEquals(QName.create(BAR, "string-ext1"), baseType2.getQName()); assertNull(baseType2.getUnits()); assertNull(baseType2.getDefaultValue()); final List patterns = baseType2.getPatternConstraints(); assertEquals(1, patterns.size()); final PatternConstraint pattern = patterns.iterator().next(); assertEquals("^[a-k]*$", pattern.getRegularExpression()); - final List baseType3Lengths = baseType2.getLengthConstraints(); - assertEquals(1, baseType3Lengths.size()); - length = baseType3Lengths.get(0); - assertEquals(5, length.getMin().intValue()); - assertEquals(11, length.getMax().intValue()); + final RangeSet baseType3Lengths = baseType2.getLengthConstraint().get().getAllowedRanges(); + assertEquals(1, baseType3Lengths.asRanges().size()); + length = baseType3Lengths.span(); + assertEquals(5, length.lowerEndpoint().intValue()); + assertEquals(11, length.upperEndpoint().intValue()); assertEquals(BaseTypes.stringType(), baseType2.getBaseType()); } @Test public void testTypedefDecimal1() { - final Module foo = TestUtils.findModule(modules, "foo"); final LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "decimal-leaf")); assertTrue(testleaf.getType() instanceof DecimalTypeDefinition); final DecimalTypeDefinition type = (DecimalTypeDefinition) testleaf.getType(); - final QName typeQName = type.getQName(); - assertEquals("my-decimal-type", typeQName.getLocalName()); - assertEquals(barNS, typeQName.getNamespace()); - assertEquals(barRev, typeQName.getRevision()); + assertEquals(QName.create(BAR, "my-decimal-type"), type.getQName()); assertNull(type.getUnits()); assertNull(type.getDefaultValue()); assertEquals(6, type.getFractionDigits().intValue()); assertEquals(1, type.getRangeConstraints().size()); final DecimalTypeDefinition typeBase = type.getBaseType(); - final QName typeBaseQName = typeBase.getQName(); - assertEquals("decimal64", typeBaseQName.getLocalName()); - assertEquals(barNS, typeBaseQName.getNamespace()); - assertEquals(barRev, typeBaseQName.getRevision()); + assertEquals(QName.create(BAR, "decimal64"), typeBase.getQName()); assertNull(typeBase.getUnits()); assertNull(typeBase.getDefaultValue()); assertEquals(6, typeBase.getFractionDigits().intValue()); @@ -443,15 +392,11 @@ public class YangParserTest { @Test public void testTypedefDecimal2() { - final Module foo = TestUtils.findModule(modules, "foo"); final LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "decimal-leaf2")); assertTrue(testleaf.getType() instanceof DecimalTypeDefinition); final DecimalTypeDefinition type = (DecimalTypeDefinition) testleaf.getType(); - final QName typeQName = type.getQName(); - assertEquals("my-decimal-type", typeQName.getLocalName()); - assertEquals(barNS, typeQName.getNamespace()); - assertEquals(barRev, typeQName.getRevision()); + assertEquals(QName.create(BAR, "my-decimal-type"), type.getQName()); assertNull(type.getUnits()); assertNull(type.getDefaultValue()); assertEquals(6, type.getFractionDigits().intValue()); @@ -463,23 +408,16 @@ public class YangParserTest { @Test public void testTypedefUnion() { - final Module foo = TestUtils.findModule(modules, "foo"); final LeafSchemaNode unionleaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "union-leaf")); assertTrue(unionleaf.getType() instanceof UnionTypeDefinition); final UnionTypeDefinition type = (UnionTypeDefinition) unionleaf.getType(); - final QName typeQName = type.getQName(); - assertEquals("my-union-ext", typeQName.getLocalName()); - assertEquals(barNS, typeQName.getNamespace()); - assertEquals(barRev, typeQName.getRevision()); + assertEquals(QName.create(BAR, "my-union-ext"), type.getQName()); assertNull(type.getUnits()); assertNull(type.getDefaultValue()); final UnionTypeDefinition baseType = type.getBaseType(); - final QName baseTypeQName = baseType.getQName(); - assertEquals("my-union", baseTypeQName.getLocalName()); - assertEquals(barNS, baseTypeQName.getNamespace()); - assertEquals(barRev, baseTypeQName.getRevision()); + assertEquals(QName.create(BAR, "my-union"), baseType.getQName()); assertNull(baseType.getUnits()); assertNull(baseType.getDefaultValue()); @@ -488,10 +426,7 @@ public class YangParserTest { assertEquals(2, unionTypes.size()); final IntegerTypeDefinition unionType1 = (IntegerTypeDefinition) unionTypes.get(0); - final QName unionType1QName = baseType.getQName(); - assertEquals("my-union", unionType1QName.getLocalName()); - assertEquals(barNS, unionType1QName.getNamespace()); - assertEquals(barRev, unionType1QName.getRevision()); + assertEquals(QName.create(BAR, "my-union"), baseType.getQName()); assertNull(unionType1.getUnits()); assertNull(unionType1.getDefaultValue()); @@ -507,23 +442,16 @@ public class YangParserTest { @Test public void testNestedUnionResolving() { - final Module foo = TestUtils.findModule(modules, "foo"); final LeafSchemaNode testleaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "custom-union-leaf")); assertTrue(testleaf.getType() instanceof UnionTypeDefinition); final UnionTypeDefinition type = (UnionTypeDefinition) testleaf.getType(); - final QName testleafTypeQName = type.getQName(); - assertEquals(bazNS, testleafTypeQName.getNamespace()); - assertEquals(bazRev, testleafTypeQName.getRevision()); - assertEquals("union1", testleafTypeQName.getLocalName()); + assertEquals(QName.create(BAZ, "union1"), type.getQName()); assertNull(type.getUnits()); assertNull(type.getDefaultValue()); final UnionTypeDefinition typeBase = type.getBaseType(); - final QName typeBaseQName = typeBase.getQName(); - assertEquals(bazNS, typeBaseQName.getNamespace()); - assertEquals(bazRev, typeBaseQName.getRevision()); - assertEquals("union2", typeBaseQName.getLocalName()); + assertEquals(QName.create(BAZ, "union2"), typeBase.getQName()); assertNull(typeBase.getUnits()); assertNull(typeBase.getDefaultValue()); @@ -534,10 +462,7 @@ public class YangParserTest { assertTrue(unionTypes.get(1) instanceof UnionTypeDefinition); final UnionTypeDefinition unionType1 = (UnionTypeDefinition) unionTypes.get(1); - final QName uniontType1QName = unionType1.getQName(); - assertEquals(barNS, uniontType1QName.getNamespace()); - assertEquals(barRev, uniontType1QName.getRevision()); - assertEquals("nested-union2", uniontType1QName.getLocalName()); + assertEquals(QName.create(BAR, "nested-union2"), unionType1.getQName()); assertNull(unionType1.getUnits()); assertNull(unionType1.getDefaultValue()); @@ -548,19 +473,13 @@ public class YangParserTest { assertTrue(nestedUnion2Types.get(0) instanceof UnionTypeDefinition); final UnionTypeDefinition myUnionExt = (UnionTypeDefinition) nestedUnion2Types.get(0); - final QName myUnionExtQName = myUnionExt.getQName(); - assertEquals(barNS, myUnionExtQName.getNamespace()); - assertEquals(barRev, myUnionExtQName.getRevision()); - assertEquals("my-union-ext", myUnionExtQName.getLocalName()); + assertEquals(QName.create(BAR, "my-union-ext"), myUnionExt.getQName()); assertNull(myUnionExt.getUnits()); assertNull(myUnionExt.getDefaultValue()); final UnionTypeDefinition myUnion = myUnionExt.getBaseType(); - final QName myUnionQName = myUnion.getQName(); - assertEquals(barNS, myUnionQName.getNamespace()); - assertEquals(barRev, myUnionQName.getRevision()); - assertEquals("my-union", myUnionQName.getLocalName()); + assertEquals(QName.create(BAR, "my-union"), myUnion.getQName()); assertNull(myUnion.getUnits()); assertNull(myUnion.getDefaultValue()); @@ -571,10 +490,7 @@ public class YangParserTest { assertEquals(BaseTypes.int32Type(), myUnionBaseTypes.get(1)); final IntegerTypeDefinition int16Ext = (IntegerTypeDefinition) myUnionBaseTypes.get(0); - final QName int16ExtQName = int16Ext.getQName(); - assertEquals(barNS, int16ExtQName.getNamespace()); - assertEquals(barRev, int16ExtQName.getRevision()); - assertEquals("int16", int16ExtQName.getLocalName()); + assertEquals(QName.create(BAR, "int16"), int16Ext.getQName()); assertNull(int16Ext.getUnits()); assertNull(int16Ext.getDefaultValue()); final List ranges = int16Ext.getRangeConstraints(); @@ -588,7 +504,6 @@ public class YangParserTest { @Test public void testChoice() { - final Module foo = TestUtils.findModule(modules, "foo"); final ContainerSchemaNode transfer = (ContainerSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "transfer")); final ChoiceSchemaNode how = (ChoiceSchemaNode) transfer.getDataChildByName(QName.create(foo.getQNameModule(), "how")); final Set cases = how.getCases(); @@ -610,16 +525,14 @@ public class YangParserTest { @Test public void testDeviation() { - final Module foo = TestUtils.findModule(modules, "foo"); final Set deviations = foo.getDeviations(); assertEquals(1, deviations.size()); final Deviation dev = deviations.iterator().next(); assertEquals("system/user ref", dev.getReference()); - final List path = new ArrayList<>(); - path.add(QName.create(barNS, barRev, "interfaces")); - path.add(QName.create(barNS, barRev, "ifEntry")); - final SchemaPath expectedPath = SchemaPath.create(path, true); + final SchemaPath expectedPath = SchemaPath.create(true, + QName.create(BAR, "interfaces"), + QName.create(BAR, "ifEntry")); assertEquals(expectedPath, dev.getTargetPath()); assertEquals(DeviateKind.ADD, dev.getDeviates().iterator().next().getDeviateType()); @@ -627,7 +540,6 @@ public class YangParserTest { @Test public void testUnknownNode() { - final Module baz = TestUtils.findModule(modules, "baz"); final ContainerSchemaNode network = (ContainerSchemaNode) baz.getDataChildByName(QName.create(baz.getQNameModule(), "network")); final List unknownNodes = network.getUnknownSchemaNodes(); assertEquals(1, unknownNodes.size()); @@ -638,14 +550,12 @@ public class YangParserTest { @Test public void testFeature() { - final Module baz = TestUtils.findModule(modules, "baz"); final Set features = baz.getFeatures(); assertEquals(1, features.size()); } @Test public void testExtension() { - final Module baz = TestUtils.findModule(modules, "baz"); final List extensions = baz.getExtensionSchemaNodes(); assertEquals(1, extensions.size()); final ExtensionDefinition extension = extensions.get(0); @@ -657,17 +567,13 @@ public class YangParserTest { @Test public void testNotification() { - final Module baz = TestUtils.findModule(modules, "baz"); - final String expectedPrefix = "c"; - final Set notifications = baz.getNotifications(); assertEquals(1, notifications.size()); final NotificationDefinition notification = notifications.iterator().next(); // test SchemaNode args - final QName expectedQName = QName.create(bazNS, bazRev, "event"); - assertEquals(expectedQName, notification.getQName()); - final SchemaPath expectedPath = TestUtils.createPath(true, bazNS, bazRev, expectedPrefix, "event"); + assertEquals(QName.create(BAZ, "event"), notification.getQName()); + final SchemaPath expectedPath = SchemaPath.create(true, QName.create(BAZ, "event")); assertEquals(expectedPath, notification.getPath()); assertNull(notification.getDescription()); assertNull(notification.getReference()); @@ -687,8 +593,6 @@ public class YangParserTest { @Test public void testRpc() { - final Module baz = TestUtils.findModule(modules, "baz"); - final Set rpcs = baz.getRpcs(); assertEquals(1, rpcs.size()); @@ -699,16 +603,12 @@ public class YangParserTest { @Test public void testTypePath() throws ParseException { - final Module bar = TestUtils.findModule(modules, "bar"); final Set> types = bar.getTypeDefinitions(); // int32-ext1 final IntegerTypeDefinition int32ext1 = (IntegerTypeDefinition) TestUtils.findTypedef(types, "int32-ext1"); - final QName int32TypedefQName = int32ext1.getQName(); - - assertEquals(barNS, int32TypedefQName.getNamespace()); - assertEquals(barRev, int32TypedefQName.getRevision()); - assertEquals("int32-ext1", int32TypedefQName.getLocalName()); + final QName int32TypedefQName = QName.create(BAR, "int32-ext1"); + assertEquals(int32TypedefQName, int32ext1.getQName()); final SchemaPath typeSchemaPath = int32ext1.getPath(); final Iterable typePath = typeSchemaPath.getPathFromRoot(); @@ -723,15 +623,13 @@ public class YangParserTest { @Test public void testTypePath2() throws ParseException { - final Module bar = TestUtils.findModule(modules, "bar"); final Set> types = bar.getTypeDefinitions(); // my-decimal-type final DecimalTypeDefinition myDecType = (DecimalTypeDefinition) TestUtils.findTypedef(types, "my-decimal-type"); final QName myDecTypeQName = myDecType.getQName(); - assertEquals(barNS, myDecTypeQName.getNamespace()); - assertEquals(barRev, myDecTypeQName.getRevision()); + assertEquals(BAR, myDecTypeQName.getModule()); assertEquals("my-decimal-type", myDecTypeQName.getLocalName()); final SchemaPath typeSchemaPath = myDecType.getPath(); @@ -744,8 +642,7 @@ public class YangParserTest { final DecimalTypeDefinition dec64 = myDecType.getBaseType(); final QName dec64QName = dec64.getQName(); - assertEquals(barNS, dec64QName.getNamespace()); - assertEquals(barRev, dec64QName.getRevision()); + assertEquals(BAR, dec64QName.getModule()); assertEquals("decimal64", dec64QName.getLocalName()); final SchemaPath dec64SchemaPath = dec64.getPath(); @@ -786,8 +683,6 @@ public class YangParserTest { @Test public void testSubmodules() { - final Module foo = TestUtils.findModule(modules, "foo"); - final DataSchemaNode id = foo.getDataChildByName(QName.create(foo.getQNameModule(), "id")); assertNotNull(id); final DataSchemaNode subExt = foo.getDataChildByName(QName.create(foo.getQNameModule(), "sub-ext")); @@ -801,58 +696,45 @@ public class YangParserTest { @Test public void unknownStatementInSubmoduleHeaderTest() throws IOException, URISyntaxException, ReactorException { - final StatementStreamSource yang1 = new YangStatementSourceImpl("/yang-grammar-test/revisions-extension.yang", false); - final StatementStreamSource yang2 = new YangStatementSourceImpl("/yang-grammar-test/submodule-header-extension.yang", - false); - - try { - TestUtils.parseYangSources(yang1, yang2); - } catch (final YangParseException e) { - e.printStackTrace(); - fail("YangParseException should not be thrown"); - } - + final StatementStreamSource yang1 = sourceForResource("/yang-grammar-test/revisions-extension.yang"); + final StatementStreamSource yang2 = sourceForResource("/yang-grammar-test/submodule-header-extension.yang"); + TestUtils.parseYangSources(yang1, yang2); } @Test public void unknownStatementBetweenRevisionsTest() throws ReactorException { - final YangStatementSourceImpl yangModule = new YangStatementSourceImpl( - "/yang-grammar-test/revisions-extension.yang", false); - final YangStatementSourceImpl yangSubmodule = new YangStatementSourceImpl( - "/yang-grammar-test/submodule-header-extension.yang", false); + final StatementStreamSource yangModule = sourceForResource("/yang-grammar-test/revisions-extension.yang"); + final StatementStreamSource yangSubmodule = sourceForResource( + "/yang-grammar-test/submodule-header-extension.yang"); final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild(); - addSources(reactor, yangModule, yangSubmodule); + reactor.addSources(yangModule, yangSubmodule); - final EffectiveSchemaContext result = reactor.buildEffective(); + final SchemaContext result = reactor.buildEffective(); assertNotNull(result); } @Test public void unknownStatementsInStatementsTest() throws ReactorException { - final YangStatementSourceImpl yangFile1 = new YangStatementSourceImpl( - "/yang-grammar-test/stmtsep-in-statements.yang", false); - final YangStatementSourceImpl yangFile2 = new YangStatementSourceImpl( - "/yang-grammar-test/stmtsep-in-statements2.yang", false); - final YangStatementSourceImpl yangFile3 = new YangStatementSourceImpl( - "/yang-grammar-test/stmtsep-in-statements-sub.yang", false); + final StatementStreamSource yangFile1 = sourceForResource( + "/yang-grammar-test/stmtsep-in-statements.yang"); + final StatementStreamSource yangFile2 = sourceForResource( + "/yang-grammar-test/stmtsep-in-statements2.yang"); + final StatementStreamSource yangFile3 = sourceForResource( + "/yang-grammar-test/stmtsep-in-statements-sub.yang"); final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild(); - addSources(reactor, yangFile1, yangFile2, yangFile3); + reactor.addSources(yangFile1, yangFile2, yangFile3); // TODO: change test or create new module in order to respect new statement parser validations try { - final EffectiveSchemaContext result = reactor.buildEffective(); + final SchemaContext result = reactor.buildEffective(); } catch (final Exception e) { - assertEquals(IllegalArgumentException.class, e.getClass()); - assertTrue(e.getMessage().startsWith("aaa is not a YANG statement or use of extension")); + assertEquals(SomeModifiersUnresolvedException.class, e.getClass()); + assertTrue(e.getCause() instanceof SourceException); + assertTrue(e.getCause().getMessage().startsWith("aaa is not a YANG statement or use of extension")); } } - private static void addSources(final CrossSourceStatementReactor.BuildAction reactor, final YangStatementSourceImpl... sources) { - for (final YangStatementSourceImpl source : sources) { - reactor.addSource(source); - } - } }