X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fimpl%2FYangParserTest.java;h=a8da2ba4f207063f67ed99938e789cb6a3ac189d;hb=abced3230f02588c577c17c0cc039c5707c85081;hp=3c55d4d9d6cf0cca5b377bf521349810fb09543f;hpb=f426b3147e6b1e06f7f54b161252c41a34ce5985;p=yangtools.git diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserTest.java index 3c55d4d9d6..a8da2ba4f2 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserTest.java @@ -7,26 +7,36 @@ */ package org.opendaylight.yangtools.yang.parser.impl; -import static org.junit.Assert.*; - +import static org.junit.Assert.assertEquals; +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 java.io.File; +import java.io.FileInputStream; import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.math.BigInteger; 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.Collections; import java.util.Date; +import java.util.Iterator; import java.util.List; import java.util.Set; - import org.junit.Before; import org.junit.Test; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode; import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode; -import org.opendaylight.yangtools.yang.model.api.ChoiceNode; +import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition; import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; @@ -34,13 +44,14 @@ import org.opendaylight.yangtools.yang.model.api.Deviation; import org.opendaylight.yangtools.yang.model.api.Deviation.Deviate; import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition; import org.opendaylight.yangtools.yang.model.api.FeatureDefinition; -import org.opendaylight.yangtools.yang.model.api.GroupingDefinition; import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; import org.opendaylight.yangtools.yang.model.api.Module; +import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier; 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; @@ -48,7 +59,8 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; 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.parser.api.YangModelParser; +import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser; +import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException; import org.opendaylight.yangtools.yang.model.util.Decimal64; import org.opendaylight.yangtools.yang.model.util.ExtendedType; import org.opendaylight.yangtools.yang.model.util.Int16; @@ -56,8 +68,12 @@ import org.opendaylight.yangtools.yang.model.util.Int32; import org.opendaylight.yangtools.yang.model.util.StringType; import org.opendaylight.yangtools.yang.model.util.Uint32; import org.opendaylight.yangtools.yang.model.util.UnionType; +import org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils; +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"); @@ -68,13 +84,13 @@ public class YangParserTest { private Set modules; @Before - public void init() throws FileNotFoundException, ParseException { + public void init() throws Exception { 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").getPath()); + modules = TestUtils.loadModules(getClass().getResource("/model").toURI()); assertEquals(3, modules.size()); } @@ -105,83 +121,6 @@ public class YangParserTest { assertEquals(" WILL BE DEFINED LATER", foo.getReference()); } - @Test - public void testOrderingTypedef() { - Module bar = TestUtils.findModule(modules, "bar"); - Set> typedefs = bar.getTypeDefinitions(); - String[] expectedOrder = new String[] { "int32-ext1", "int32-ext2", "my-decimal-type", "my-union", - "my-union-ext", "nested-union2", "string-ext1", "string-ext2", "string-ext3", "string-ext4" }; - String[] actualOrder = new String[typedefs.size()]; - - int i = 0; - for (TypeDefinition type : typedefs) { - actualOrder[i] = type.getQName().getLocalName(); - i++; - } - assertArrayEquals(expectedOrder, actualOrder); - } - - @Test - public void testOrderingChildNodes() { - Module foo = TestUtils.findModule(modules, "foo"); - AugmentationSchema augment1 = null; - for (AugmentationSchema as : foo.getAugmentations()) { - if ("if:ifType='ds0'".equals(as.getWhenCondition().toString())) { - augment1 = as; - break; - } - } - assertNotNull(augment1); - - String[] expectedOrder = new String[] { "ds0ChannelNumber", "interface-id", "my-type", "odl", "schemas" }; - String[] actualOrder = new String[expectedOrder.length]; - - int i = 0; - for (DataSchemaNode augmentChild : augment1.getChildNodes()) { - actualOrder[i] = augmentChild.getQName().getLocalName(); - i++; - } - - assertArrayEquals(expectedOrder, actualOrder); - } - - @Test - public void testOrderingNestedChildNodes1() { - Module foo = TestUtils.findModule(modules, "foo"); - - Set childNodes = foo.getChildNodes(); - String[] expectedOrder = new String[] { "address", "addresses", "custom-union-leaf", "data", "datas", - "decimal-leaf", "decimal-leaf2", "ext", "how", "int32-leaf", "length-leaf", "mycont", "peer", "port", - "string-leaf", "transfer", "union-leaf" }; - String[] actualOrder = new String[childNodes.size()]; - - int i = 0; - for (DataSchemaNode child : childNodes) { - actualOrder[i] = child.getQName().getLocalName(); - i++; - } - assertArrayEquals(expectedOrder, actualOrder); - } - - @Test - public void testOrderingNestedChildNodes2() { - Module baz = TestUtils.findModule(modules, "baz"); - Set groupings = baz.getGroupings(); - assertEquals(1, groupings.size()); - GroupingDefinition target = groupings.iterator().next(); - - Set childNodes = target.getChildNodes(); - String[] expectedOrder = new String[] { "address", "addresses", "data", "how", "port" }; - String[] actualOrder = new String[childNodes.size()]; - - int i = 0; - for (DataSchemaNode child : childNodes) { - actualOrder[i] = child.getQName().getLocalName(); - i++; - } - assertArrayEquals(expectedOrder, actualOrder); - } - @Test public void testParseList() { Module bar = TestUtils.findModule(modules, "bar"); @@ -192,7 +131,7 @@ public class YangParserTest { ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry"); // test SchemaNode args - QName expectedQName = new QName(expectedNamespace, barRev, expectedPrefix, "ifEntry"); + QName expectedQName = QName.create(expectedNamespace, barRev, "ifEntry"); assertEquals(expectedQName, ifEntry.getQName()); SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace, barRev, expectedPrefix, "interfaces", "ifEntry"); @@ -202,13 +141,12 @@ public class YangParserTest { assertEquals(Status.CURRENT, ifEntry.getStatus()); assertEquals(0, ifEntry.getUnknownSchemaNodes().size()); // test DataSchemaNode args - assertEquals(interfaces, ifEntry.getParent()); assertFalse(ifEntry.isAugmenting()); assertTrue(ifEntry.isConfiguration()); ConstraintDefinition constraints = ifEntry.getConstraints(); assertNull(constraints.getWhenCondition()); assertEquals(0, constraints.getMustConstraints().size()); - assertFalse(constraints.isMandatory()); + assertTrue(constraints.isMandatory()); assertEquals(1, (int) constraints.getMinElements()); assertEquals(11, (int) constraints.getMaxElements()); // test AugmentationTarget args @@ -216,7 +154,7 @@ public class YangParserTest { assertEquals(2, availableAugmentations.size()); // test ListSchemaNode args List expectedKey = new ArrayList<>(); - expectedKey.add(new QName(expectedNamespace, barRev, expectedPrefix, "ifIndex")); + expectedKey.add(QName.create(expectedNamespace, barRev, "ifIndex")); assertEquals(expectedKey, ifEntry.getKeyDefinition()); assertFalse(ifEntry.isUserOrdered()); // test DataNodeContainer args @@ -226,6 +164,7 @@ public class YangParserTest { assertEquals(0, ifEntry.getUses().size()); LeafSchemaNode ifIndex = (LeafSchemaNode) ifEntry.getDataChildByName("ifIndex"); + assertEquals(ifEntry.getKeyDefinition().get(0), ifIndex.getQName()); assertTrue(ifIndex.getType() instanceof Uint32); LeafSchemaNode ifMtu = (LeafSchemaNode) ifEntry.getDataChildByName("ifMtu"); assertTrue(ifMtu.getType() instanceof Int32); @@ -239,7 +178,6 @@ public class YangParserTest { ExtendedType leafType = (ExtendedType) int32Leaf.getType(); QName leafTypeQName = leafType.getQName(); assertEquals("int32-ext2", leafTypeQName.getLocalName()); - assertEquals("foo", leafTypeQName.getPrefix()); assertEquals(fooNS, leafTypeQName.getNamespace()); assertEquals(fooRev, leafTypeQName.getRevision()); assertNull(leafType.getUnits()); @@ -249,13 +187,12 @@ public class YangParserTest { List ranges = leafType.getRangeConstraints(); assertEquals(1, ranges.size()); RangeConstraint range = ranges.get(0); - assertEquals(12L, range.getMin()); - assertEquals(20L, range.getMax()); + assertEquals(BigInteger.valueOf(12), range.getMin()); + assertEquals(BigInteger.valueOf(20), range.getMax()); ExtendedType baseType = (ExtendedType) leafType.getBaseType(); QName baseTypeQName = baseType.getQName(); assertEquals("int32-ext2", baseTypeQName.getLocalName()); - assertEquals("bar", baseTypeQName.getPrefix()); assertEquals(barNS, baseTypeQName.getNamespace()); assertEquals(barRev, baseTypeQName.getRevision()); assertEquals("mile", baseType.getUnits()); @@ -265,16 +202,15 @@ public class YangParserTest { List baseTypeRanges = baseType.getRangeConstraints(); assertEquals(2, baseTypeRanges.size()); RangeConstraint baseTypeRange1 = baseTypeRanges.get(0); - assertEquals(3L, baseTypeRange1.getMin()); - assertEquals(9L, baseTypeRange1.getMax()); + assertEquals(BigInteger.valueOf(3), baseTypeRange1.getMin()); + assertEquals(BigInteger.valueOf(9), baseTypeRange1.getMax()); RangeConstraint baseTypeRange2 = baseTypeRanges.get(1); - assertEquals(11L, baseTypeRange2.getMin()); - assertEquals(20L, baseTypeRange2.getMax()); + assertEquals(BigInteger.valueOf(11), baseTypeRange2.getMin()); + assertEquals(BigInteger.valueOf(20), baseTypeRange2.getMax()); ExtendedType base = (ExtendedType) baseType.getBaseType(); QName baseQName = base.getQName(); assertEquals("int32-ext1", baseQName.getLocalName()); - assertEquals("bar", baseQName.getPrefix()); assertEquals(barNS, baseQName.getNamespace()); assertEquals(barRev, baseQName.getRevision()); assertNull(base.getUnits()); @@ -284,8 +220,8 @@ public class YangParserTest { List baseRanges = base.getRangeConstraints(); assertEquals(1, baseRanges.size()); RangeConstraint baseRange = baseRanges.get(0); - assertEquals(2L, baseRange.getMin()); - assertEquals(20L, baseRange.getMax()); + assertEquals(BigInteger.valueOf(2), baseRange.getMin()); + assertEquals(BigInteger.valueOf(20), baseRange.getMax()); assertTrue(base.getBaseType() instanceof Int32); } @@ -298,7 +234,6 @@ public class YangParserTest { ExtendedType type = (ExtendedType) stringleaf.getType(); QName typeQName = type.getQName(); assertEquals("string-ext4", typeQName.getLocalName()); - assertEquals("bar", typeQName.getPrefix()); assertEquals(barNS, typeQName.getNamespace()); assertEquals(barRev, typeQName.getRevision()); assertNull(type.getUnits()); @@ -306,14 +241,13 @@ public class YangParserTest { List patterns = type.getPatternConstraints(); assertEquals(1, patterns.size()); PatternConstraint pattern = patterns.iterator().next(); - assertEquals("[e-z]*", pattern.getRegularExpression()); + assertEquals("^[e-z]*$", pattern.getRegularExpression()); assertTrue(type.getLengthConstraints().isEmpty()); assertTrue(type.getRangeConstraints().isEmpty()); ExtendedType baseType1 = (ExtendedType) type.getBaseType(); QName baseType1QName = baseType1.getQName(); assertEquals("string-ext3", baseType1QName.getLocalName()); - assertEquals("bar", baseType1QName.getPrefix()); assertEquals(barNS, baseType1QName.getNamespace()); assertEquals(barRev, baseType1QName.getRevision()); assertNull(baseType1.getUnits()); @@ -321,14 +255,13 @@ public class YangParserTest { patterns = baseType1.getPatternConstraints(); assertEquals(1, patterns.size()); pattern = patterns.iterator().next(); - assertEquals("[b-u]*", pattern.getRegularExpression()); + assertEquals("^[b-u]*$", pattern.getRegularExpression()); assertTrue(baseType1.getLengthConstraints().isEmpty()); assertTrue(baseType1.getRangeConstraints().isEmpty()); ExtendedType baseType2 = (ExtendedType) baseType1.getBaseType(); QName baseType2QName = baseType2.getQName(); assertEquals("string-ext2", baseType2QName.getLocalName()); - assertEquals("bar", baseType2QName.getPrefix()); assertEquals(barNS, baseType2QName.getNamespace()); assertEquals(barRev, baseType2QName.getRevision()); assertNull(baseType2.getUnits()); @@ -337,14 +270,13 @@ public class YangParserTest { List baseType2Lengths = baseType2.getLengthConstraints(); assertEquals(1, baseType2Lengths.size()); LengthConstraint length = baseType2Lengths.get(0); - assertEquals(6L, length.getMin()); - assertEquals(10L, length.getMax()); + assertEquals(BigInteger.valueOf(6), length.getMin()); + assertEquals(BigInteger.TEN, length.getMax()); assertTrue(baseType2.getRangeConstraints().isEmpty()); ExtendedType baseType3 = (ExtendedType) baseType2.getBaseType(); QName baseType3QName = baseType3.getQName(); assertEquals("string-ext1", baseType3QName.getLocalName()); - assertEquals("bar", baseType3QName.getPrefix()); assertEquals(barNS, baseType3QName.getNamespace()); assertEquals(barRev, baseType3QName.getRevision()); assertNull(baseType3.getUnits()); @@ -352,17 +284,83 @@ public class YangParserTest { patterns = baseType3.getPatternConstraints(); assertEquals(1, patterns.size()); pattern = patterns.iterator().next(); - assertEquals("[a-k]*", pattern.getRegularExpression()); + assertEquals("^[a-k]*$", pattern.getRegularExpression()); List baseType3Lengths = baseType3.getLengthConstraints(); assertEquals(1, baseType3Lengths.size()); length = baseType3Lengths.get(0); - assertEquals(5L, length.getMin()); - assertEquals(11L, length.getMax()); + assertEquals(BigInteger.valueOf(5), length.getMin()); + assertEquals(BigInteger.valueOf(11), length.getMax()); assertTrue(baseType3.getRangeConstraints().isEmpty()); assertTrue(baseType3.getBaseType() instanceof StringType); } + @Test + public void testTypedefInvalidPatternsResolving() { + Module foo = TestUtils.findModule(modules, "foo"); + final LeafSchemaNode invalidPatternStringLeaf = (LeafSchemaNode) foo.getDataChildByName("invalid-pattern-string-leaf"); + ExtendedType type = (ExtendedType) invalidPatternStringLeaf.getType(); + QName typeQName = type.getQName(); + assertEquals("invalid-string-pattern", typeQName.getLocalName()); + assertEquals(barNS, typeQName.getNamespace()); + assertEquals(barRev, typeQName.getRevision()); + assertNull(type.getUnits()); + assertNull(type.getDefaultValue()); + List patterns = type.getPatternConstraints(); + assertTrue(patterns.isEmpty()); + + final LeafSchemaNode invalidDirectStringPatternDefLeaf = (LeafSchemaNode) foo.getDataChildByName("invalid-direct-string-pattern-def-leaf"); + type = (ExtendedType) invalidDirectStringPatternDefLeaf.getType(); + typeQName = type.getQName(); + assertEquals("string", typeQName.getLocalName()); + assertEquals(fooNS, typeQName.getNamespace()); + assertEquals(fooRev, typeQName.getRevision()); + assertNull(type.getUnits()); + assertNull(type.getDefaultValue()); + patterns = type.getPatternConstraints(); + assertTrue(patterns.isEmpty()); + + final LeafSchemaNode multiplePatternStringLeaf = (LeafSchemaNode) foo.getDataChildByName("multiple-pattern-string-leaf"); + type = (ExtendedType) multiplePatternStringLeaf.getType(); + typeQName = type.getQName(); + assertEquals("multiple-pattern-string", typeQName.getLocalName()); + assertEquals(barNS, typeQName.getNamespace()); + assertEquals(barRev, typeQName.getRevision()); + assertNull(type.getUnits()); + assertNull(type.getDefaultValue()); + patterns = type.getPatternConstraints(); + assertTrue(!patterns.isEmpty()); + assertEquals(1, patterns.size()); + PatternConstraint pattern = patterns.iterator().next(); + assertEquals("^[e-z]*$", pattern.getRegularExpression()); + assertTrue(type.getLengthConstraints().isEmpty()); + assertTrue(type.getRangeConstraints().isEmpty()); + + final LeafSchemaNode multiplePatternDirectStringDefLeaf = (LeafSchemaNode) foo.getDataChildByName("multiple-pattern-direct-string-def-leaf"); + type = (ExtendedType) multiplePatternDirectStringDefLeaf.getType(); + typeQName = type.getQName(); + assertEquals("string", typeQName.getLocalName()); + assertEquals(fooNS, typeQName.getNamespace()); + assertEquals(fooRev, typeQName.getRevision()); + assertNull(type.getUnits()); + assertNull(type.getDefaultValue()); + patterns = type.getPatternConstraints(); + assertTrue(!patterns.isEmpty()); + assertEquals(2, patterns.size()); + + boolean isEZPattern = false; + boolean isADPattern = false; + for (final PatternConstraint patternConstraint : patterns) { + if (patternConstraint.getRegularExpression().equals("^[e-z]*$")) { + isEZPattern = true; + } else if (patternConstraint.getRegularExpression().equals("^[a-d]*$")) { + isADPattern = true; + } + } + assertTrue(isEZPattern); + assertTrue( isADPattern); + } + @Test public void testTypedefLengthsResolving() { Module foo = TestUtils.findModule(modules, "foo"); @@ -372,7 +370,6 @@ public class YangParserTest { QName typeQName = type.getQName(); assertEquals("string-ext2", typeQName.getLocalName()); - assertEquals("foo", typeQName.getPrefix()); assertEquals(fooNS, typeQName.getNamespace()); assertEquals(fooRev, typeQName.getRevision()); assertNull(type.getUnits()); @@ -381,14 +378,13 @@ public class YangParserTest { List typeLengths = type.getLengthConstraints(); assertEquals(1, typeLengths.size()); LengthConstraint length = typeLengths.get(0); - assertEquals(7L, length.getMin()); - assertEquals(10L, length.getMax()); + assertEquals(BigInteger.valueOf(7), length.getMin()); + assertEquals(BigInteger.TEN, length.getMax()); assertTrue(type.getRangeConstraints().isEmpty()); ExtendedType baseType1 = (ExtendedType) type.getBaseType(); QName baseType1QName = baseType1.getQName(); assertEquals("string-ext2", baseType1QName.getLocalName()); - assertEquals("bar", baseType1QName.getPrefix()); assertEquals(barNS, baseType1QName.getNamespace()); assertEquals(barRev, baseType1QName.getRevision()); assertNull(baseType1.getUnits()); @@ -397,14 +393,13 @@ public class YangParserTest { List baseType2Lengths = baseType1.getLengthConstraints(); assertEquals(1, baseType2Lengths.size()); length = baseType2Lengths.get(0); - assertEquals(6L, length.getMin()); - assertEquals(10L, length.getMax()); + assertEquals(BigInteger.valueOf(6), length.getMin()); + assertEquals(BigInteger.TEN, length.getMax()); assertTrue(baseType1.getRangeConstraints().isEmpty()); ExtendedType baseType2 = (ExtendedType) baseType1.getBaseType(); QName baseType2QName = baseType2.getQName(); assertEquals("string-ext1", baseType2QName.getLocalName()); - assertEquals("bar", baseType2QName.getPrefix()); assertEquals(barNS, baseType2QName.getNamespace()); assertEquals(barRev, baseType2QName.getRevision()); assertNull(baseType2.getUnits()); @@ -412,12 +407,12 @@ public class YangParserTest { List patterns = baseType2.getPatternConstraints(); assertEquals(1, patterns.size()); PatternConstraint pattern = patterns.iterator().next(); - assertEquals("[a-k]*", pattern.getRegularExpression()); + assertEquals("^[a-k]*$", pattern.getRegularExpression()); List baseType3Lengths = baseType2.getLengthConstraints(); assertEquals(1, baseType3Lengths.size()); length = baseType3Lengths.get(0); - assertEquals(5L, length.getMin()); - assertEquals(11L, length.getMax()); + assertEquals(BigInteger.valueOf(5), length.getMin()); + assertEquals(BigInteger.valueOf(11), length.getMax()); assertTrue(baseType2.getRangeConstraints().isEmpty()); assertTrue(baseType2.getBaseType() instanceof StringType); @@ -431,7 +426,6 @@ public class YangParserTest { ExtendedType type = (ExtendedType) testleaf.getType(); QName typeQName = type.getQName(); assertEquals("my-decimal-type", typeQName.getLocalName()); - assertEquals("foo", typeQName.getPrefix()); assertEquals(fooNS, typeQName.getNamespace()); assertEquals(fooRev, typeQName.getRevision()); assertNull(type.getUnits()); @@ -444,7 +438,6 @@ public class YangParserTest { ExtendedType typeBase = (ExtendedType) type.getBaseType(); QName typeBaseQName = typeBase.getQName(); assertEquals("my-decimal-type", typeBaseQName.getLocalName()); - assertEquals("bar", typeBaseQName.getPrefix()); assertEquals(barNS, typeBaseQName.getNamespace()); assertEquals(barRev, typeBaseQName.getRevision()); assertNull(typeBase.getUnits()); @@ -466,7 +459,6 @@ public class YangParserTest { ExtendedType type = (ExtendedType) testleaf.getType(); QName typeQName = type.getQName(); assertEquals("my-decimal-type", typeQName.getLocalName()); - assertEquals("bar", typeQName.getPrefix()); assertEquals(barNS, typeQName.getNamespace()); assertEquals(barRev, typeQName.getRevision()); assertNull(type.getUnits()); @@ -488,7 +480,6 @@ public class YangParserTest { ExtendedType type = (ExtendedType) unionleaf.getType(); QName typeQName = type.getQName(); assertEquals("my-union-ext", typeQName.getLocalName()); - assertEquals("bar", typeQName.getPrefix()); assertEquals(barNS, typeQName.getNamespace()); assertEquals(barRev, typeQName.getRevision()); assertNull(type.getUnits()); @@ -501,7 +492,6 @@ public class YangParserTest { ExtendedType baseType = (ExtendedType) type.getBaseType(); QName baseTypeQName = baseType.getQName(); assertEquals("my-union", baseTypeQName.getLocalName()); - assertEquals("bar", baseTypeQName.getPrefix()); assertEquals(barNS, baseTypeQName.getNamespace()); assertEquals(barRev, baseTypeQName.getRevision()); assertNull(baseType.getUnits()); @@ -518,7 +508,6 @@ public class YangParserTest { ExtendedType unionType1 = (ExtendedType) unionTypes.get(0); QName unionType1QName = baseType.getQName(); assertEquals("my-union", unionType1QName.getLocalName()); - assertEquals("bar", unionType1QName.getPrefix()); assertEquals(barNS, unionType1QName.getNamespace()); assertEquals(barRev, unionType1QName.getRevision()); assertNull(unionType1.getUnits()); @@ -529,8 +518,8 @@ public class YangParserTest { List ranges = unionType1.getRangeConstraints(); assertEquals(1, ranges.size()); RangeConstraint range = ranges.get(0); - assertEquals(1L, range.getMin()); - assertEquals(100L, range.getMax()); + assertEquals(BigInteger.ONE, range.getMin()); + assertEquals(BigInteger.valueOf(100), range.getMax()); assertTrue(unionType1.getBaseType() instanceof Int16); assertTrue(unionTypes.get(1) instanceof Int32); @@ -545,7 +534,6 @@ public class YangParserTest { QName testleafTypeQName = type.getQName(); assertEquals(bazNS, testleafTypeQName.getNamespace()); assertEquals(bazRev, testleafTypeQName.getRevision()); - assertEquals("baz", testleafTypeQName.getPrefix()); assertEquals("union1", testleafTypeQName.getLocalName()); assertNull(type.getUnits()); assertNull(type.getDefaultValue()); @@ -558,7 +546,6 @@ public class YangParserTest { QName typeBaseQName = typeBase.getQName(); assertEquals(bazNS, typeBaseQName.getNamespace()); assertEquals(bazRev, typeBaseQName.getRevision()); - assertEquals("baz", typeBaseQName.getPrefix()); assertEquals("union2", typeBaseQName.getLocalName()); assertNull(typeBase.getUnits()); assertNull(typeBase.getDefaultValue()); @@ -577,7 +564,6 @@ public class YangParserTest { QName uniontType1QName = unionType1.getQName(); assertEquals(barNS, uniontType1QName.getNamespace()); assertEquals(barRev, uniontType1QName.getRevision()); - assertEquals("bar", uniontType1QName.getPrefix()); assertEquals("nested-union2", uniontType1QName.getLocalName()); assertNull(unionType1.getUnits()); assertNull(unionType1.getDefaultValue()); @@ -596,7 +582,6 @@ public class YangParserTest { QName myUnionExtQName = myUnionExt.getQName(); assertEquals(barNS, myUnionExtQName.getNamespace()); assertEquals(barRev, myUnionExtQName.getRevision()); - assertEquals("bar", myUnionExtQName.getPrefix()); assertEquals("my-union-ext", myUnionExtQName.getLocalName()); assertNull(myUnionExt.getUnits()); assertNull(myUnionExt.getDefaultValue()); @@ -609,7 +594,6 @@ public class YangParserTest { QName myUnionQName = myUnion.getQName(); assertEquals(barNS, myUnionQName.getNamespace()); assertEquals(barRev, myUnionQName.getRevision()); - assertEquals("bar", myUnionQName.getPrefix()); assertEquals("my-union", myUnionQName.getLocalName()); assertNull(myUnion.getUnits()); assertNull(myUnion.getDefaultValue()); @@ -628,7 +612,6 @@ public class YangParserTest { QName int16ExtQName = int16Ext.getQName(); assertEquals(barNS, int16ExtQName.getNamespace()); assertEquals(barRev, int16ExtQName.getRevision()); - assertEquals("bar", int16ExtQName.getPrefix()); assertEquals("int16", int16ExtQName.getLocalName()); assertNull(int16Ext.getUnits()); assertNull(int16Ext.getDefaultValue()); @@ -638,8 +621,8 @@ public class YangParserTest { List ranges = int16Ext.getRangeConstraints(); assertEquals(1, ranges.size()); RangeConstraint range = ranges.get(0); - assertEquals(1L, range.getMin()); - assertEquals(100L, range.getMax()); + assertEquals(BigInteger.ONE, range.getMin()); + assertEquals(BigInteger.valueOf(100), range.getMax()); assertTrue(int16Ext.getBaseType() instanceof Int16); } @@ -648,8 +631,7 @@ public class YangParserTest { public void testChoice() { Module foo = TestUtils.findModule(modules, "foo"); ContainerSchemaNode transfer = (ContainerSchemaNode) foo.getDataChildByName("transfer"); - ChoiceNode how = (ChoiceNode) transfer.getDataChildByName("how"); - assertEquals(transfer, how.getParent()); + ChoiceSchemaNode how = (ChoiceSchemaNode) transfer.getDataChildByName("how"); Set cases = how.getCases(); assertEquals(5, cases.size()); ChoiceCaseNode input = null; @@ -676,9 +658,9 @@ public class YangParserTest { assertEquals("system/user ref", dev.getReference()); List path = new ArrayList<>(); - path.add(new QName(barNS, barRev, "br", "interfaces")); - path.add(new QName(barNS, barRev, "br", "ifEntry")); - SchemaPath expectedPath = new SchemaPath(path, true); + path.add(QName.create(barNS, barRev, "interfaces")); + path.add(QName.create(barNS, barRev, "ifEntry")); + SchemaPath expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, dev.getTargetPath()); assertEquals(Deviate.ADD, dev.getDeviate()); @@ -709,6 +691,8 @@ public class YangParserTest { assertEquals(1, extensions.size()); ExtensionDefinition extension = extensions.get(0); assertEquals("name", extension.getArgument()); + assertEquals("Takes as argument a name string. Makes the code generator use the given name in the #define.", + extension.getDescription()); assertTrue(extension.isYinElement()); } @@ -722,7 +706,7 @@ public class YangParserTest { NotificationDefinition notification = notifications.iterator().next(); // test SchemaNode args - QName expectedQName = new QName(bazNS, bazRev, expectedPrefix, "event"); + QName expectedQName = QName.create(bazNS, bazRev, "event"); assertEquals(expectedQName, notification.getQName()); SchemaPath expectedPath = TestUtils.createPath(true, bazNS, bazRev, expectedPrefix, "event"); assertEquals(expectedPath, notification.getPath()); @@ -737,12 +721,8 @@ public class YangParserTest { assertEquals(0, notification.getUses().size()); LeafSchemaNode eventClass = (LeafSchemaNode) notification.getDataChildByName("event-class"); - assertEquals(notification, eventClass.getParent()); assertTrue(eventClass.getType() instanceof StringType); - AnyXmlSchemaNode reportingEntity = (AnyXmlSchemaNode) notification.getDataChildByName("reporting-entity"); - assertEquals(notification, reportingEntity.getParent()); LeafSchemaNode severity = (LeafSchemaNode) notification.getDataChildByName("severity"); - assertEquals(notification, severity.getParent()); assertTrue(severity.getType() instanceof StringType); } @@ -756,17 +736,6 @@ public class YangParserTest { RpcDefinition rpc = rpcs.iterator().next(); assertEquals("Retrieve all or part of a specified configuration.", rpc.getDescription()); assertEquals("RFC 6241, Section 7.1", rpc.getReference()); - - ContainerSchemaNode input = rpc.getInput(); - assertEquals(rpc, input.getParent()); - DataSchemaNode source = input.getDataChildByName("source"); - assertEquals(input, source.getParent()); - DataSchemaNode filter = input.getDataChildByName("filter"); - assertEquals(input, filter.getParent()); - ContainerSchemaNode output = rpc.getOutput(); - assertEquals(rpc, output.getParent()); - DataSchemaNode data = output.getDataChildByName("data"); - assertEquals(output, data.getParent()); } @Test @@ -780,13 +749,13 @@ public class YangParserTest { assertEquals(barNS, int32TypedefQName.getNamespace()); assertEquals(barRev, int32TypedefQName.getRevision()); - assertEquals("bar", int32TypedefQName.getPrefix()); assertEquals("int32-ext1", int32TypedefQName.getLocalName()); SchemaPath typeSchemaPath = int32ext1.getPath(); - List typePath = typeSchemaPath.getPath(); - assertEquals(1, typePath.size()); - assertEquals(int32TypedefQName, typePath.get(0)); + Iterable typePath = typeSchemaPath.getPathFromRoot(); + Iterator typePathIt = typePath.iterator(); + assertEquals(int32TypedefQName, typePathIt.next()); + assertFalse(typePathIt.hasNext()); // int32-ext1/int32 Int32 int32 = (Int32) int32ext1.getBaseType(); @@ -804,13 +773,13 @@ public class YangParserTest { assertEquals(barNS, myDecTypeQName.getNamespace()); assertEquals(barRev, myDecTypeQName.getRevision()); - assertEquals("bar", myDecTypeQName.getPrefix()); assertEquals("my-decimal-type", myDecTypeQName.getLocalName()); SchemaPath typeSchemaPath = myDecType.getPath(); - List typePath = typeSchemaPath.getPath(); - assertEquals(1, typePath.size()); - assertEquals(myDecTypeQName, typePath.get(0)); + Iterable typePath = typeSchemaPath.getPathFromRoot(); + Iterator typePathIt = typePath.iterator(); + assertEquals(myDecTypeQName, typePathIt.next()); + assertFalse(typePathIt.hasNext()); // my-base-int32-type/int32 Decimal64 dec64 = (Decimal64) myDecType.getBaseType(); @@ -818,32 +787,177 @@ public class YangParserTest { assertEquals(URI.create("urn:ietf:params:xml:ns:yang:1"), dec64QName.getNamespace()); assertNull(dec64QName.getRevision()); - assertEquals("", dec64QName.getPrefix()); assertEquals("decimal64", dec64QName.getLocalName()); SchemaPath dec64SchemaPath = dec64.getPath(); - List dec64Path = dec64SchemaPath.getPath(); - assertEquals(2, dec64Path.size()); - assertEquals(myDecTypeQName, dec64Path.get(0)); - assertEquals(dec64QName, dec64Path.get(1)); + Iterable dec64Path = dec64SchemaPath.getPathFromRoot(); + Iterator dec64PathIt = dec64Path.iterator(); + assertEquals(myDecTypeQName, dec64PathIt.next()); + assertEquals(dec64QName, dec64PathIt.next()); + assertFalse(dec64PathIt.hasNext()); } @Test - public void testParseMethod1() throws ParseException { - File yangFile = new File(getClass().getResource("/parse-methods/m1.yang").getPath()); - File dependenciesDir = new File(getClass().getResource("/parse-methods").getPath()); - YangModelParser parser = new YangParserImpl(); - modules = parser.parseYangModels(yangFile, dependenciesDir); + public void testParseMethod1() throws Exception { + File yangFile = new File(getClass().getResource("/parse-methods/m1.yang").toURI()); + File dependenciesDir = new File(getClass().getResource("/parse-methods").toURI()); + YangContextParser parser = new YangParserImpl(); + modules = parser.parseFile(yangFile, dependenciesDir).getModules(); assertEquals(6, modules.size()); } @Test - public void testParseMethod2() throws ParseException { - File yangFile = new File(getClass().getResource("/parse-methods/m1.yang").getPath()); - File dependenciesDir = new File(getClass().getResource("/parse-methods/dependencies").getPath()); - YangModelParser parser = new YangParserImpl(); - modules = parser.parseYangModels(yangFile, dependenciesDir); + public void testParseMethod2() throws Exception { + File yangFile = new File(getClass().getResource("/parse-methods/m1.yang").toURI()); + File dependenciesDir = new File(getClass().getResource("/parse-methods/dependencies").toURI()); + YangContextParser parser = new YangParserImpl(); + modules = parser.parseFile(yangFile, dependenciesDir).getModules(); assertEquals(6, modules.size()); } + @Test + public void testSorting() throws Exception { + // Correct order: m2, m4, m6, m8, m7, m6, m3, m1 + File yangFile = new File(getClass().getResource("/sorting-test/m1.yang").toURI()); + File dependenciesDir = new File(getClass().getResource("/sorting-test").toURI()); + YangContextParser parser = new YangParserImpl(); + modules = parser.parseFile(yangFile, dependenciesDir).getModules(); + SchemaContext ctx = new SchemaContextImpl(modules, Collections.emptyMap()); + checkOrder(modules); + assertSetEquals(modules, ctx.getModules()); + + // ########## + parser = new YangParserImpl(); + final File testDir = dependenciesDir; + final String[] fileList = testDir.list(); + final List testFiles = new ArrayList<>(); + if (fileList == null) { + throw new FileNotFoundException(dependenciesDir.getAbsolutePath()); + } + for (String fileName : fileList) { + testFiles.add(new File(testDir, fileName)); + } + Set newModules = parser.parseFiles(testFiles).getModules(); + assertSetEquals(newModules, modules); + ctx = new SchemaContextImpl(newModules, Collections.emptyMap()); + assertSetEquals(newModules, ctx.getModules()); + // ########## + newModules = parser.parseFiles(testFiles, null).getModules(); + assertSetEquals(newModules, modules); + ctx = new SchemaContextImpl(newModules, Collections.emptyMap()); + assertSetEquals(newModules, ctx.getModules()); + // ########## + List streams = new ArrayList<>(); + for (File f : testFiles) { + streams.add(new FileInputStream(f)); + } + newModules = parser.parseSources(BuilderUtils.filesToByteSources(testFiles)).getModules(); + assertSetEquals(newModules, modules); + ctx = new SchemaContextImpl(newModules, Collections.emptyMap()); + assertSetEquals(newModules, ctx.getModules()); + // ########## + streams.clear(); + for (File f : testFiles) { + streams.add(new FileInputStream(f)); + } + newModules = parser.parseSources(BuilderUtils.filesToByteSources(testFiles), null).getModules(); + assertSetEquals(newModules, modules); + ctx = new SchemaContextImpl(newModules, Collections.emptyMap()); + assertSetEquals(newModules, ctx.getModules()); + } + + private static void checkOrder(final Collection modules) { + Iterator it = modules.iterator(); + Module m = it.next(); + assertEquals("m2", m.getName()); + m = it.next(); + assertEquals("m4", m.getName()); + m = it.next(); + assertEquals("m6", m.getName()); + m = it.next(); + assertEquals("m8", m.getName()); + m = it.next(); + assertEquals("m7", m.getName()); + m = it.next(); + assertEquals("m5", m.getName()); + m = it.next(); + assertEquals("m3", m.getName()); + m = it.next(); + assertEquals("m1", m.getName()); + } + + private static void assertSetEquals(final Set s1, final Set s2) { + assertEquals(s1, s2); + Iterator it = s1.iterator(); + for (Module m : s2) { + assertEquals(m, it.next()); + } + } + + @Test + public void testSubmodules() throws Exception { + Module foo = TestUtils.findModule(modules, "foo"); + + DataSchemaNode id = foo.getDataChildByName("id"); + assertNotNull(id); + DataSchemaNode subExt = foo.getDataChildByName("sub-ext"); + assertNotNull(subExt); + DataSchemaNode subTransfer = foo.getDataChildByName("sub-transfer"); + assertNotNull(subTransfer); + + assertEquals(2, foo.getExtensionSchemaNodes().size()); + assertEquals(2, foo.getAugmentations().size()); + } + + @Test + public void unknownStatementInSubmoduleHeaderTest() throws IOException, URISyntaxException { + + File yang = new File(getClass().getResource("/yang-grammar-test/submodule-header-extension.yang").toURI()); + + try { + YangParserImpl.getInstance().parseFile(yang, yang.getParentFile()); + } catch (YangSyntaxErrorException | YangParseException e) { + e.printStackTrace(); + fail("YangSyntaxErrorException or YangParseException should not be thrown"); + } + + } + + @Test + public void unknownStatementBetweenRevisionsTest() throws IOException, URISyntaxException { + + File yangModul = new File(getClass().getResource("/yang-grammar-test/revisions-extension.yang").toURI()); + File yangSubmodul = new File(getClass().getResource("/yang-grammar-test/submodule-header-extension.yang") + .toURI()); + + List yangs = new ArrayList<>(); + yangs.add(yangModul); + yangs.add(yangSubmodul); + + try { + YangParserImpl.getInstance().parseFiles(yangs); + } catch (YangParseException e) { + e.printStackTrace(); + fail("YangParseException should not be thrown"); + } + } + + @Test + public void unknownStatementsInStatementsTest() throws IOException, URISyntaxException { + File yangModule1 = new File(getClass().getResource("/yang-grammar-test/stmtsep-in-statements.yang").toURI()); + File yangModule2 = new File(getClass().getResource("/yang-grammar-test/stmtsep-in-statements2.yang").toURI()); + File yangSubModule = new File(getClass().getResource("/yang-grammar-test/stmtsep-in-statements-sub.yang").toURI()); + + List yangs = new ArrayList<>(); + yangs.add(yangModule1); + yangs.add(yangModule2); + yangs.add(yangSubModule); + + try { + YangParserImpl.getInstance().parseFiles(yangs); + } catch (YangParseException e) { + e.printStackTrace(); + fail("YangParseException should not be thrown"); + } + } }