X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fsal%2Fyang-prototype%2Fcode-generator%2Fyang-model-parser-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fyang%2Fparser%2Fimpl%2FYangParserTest.java;h=ba31e51922a62c2d3fc6b352a2e3aa8110d3d216;hb=9c8108faabf300747a2a5529dc7a8ef76e79c2bc;hp=fd2593ba4805fade12bb2193e7a3d4cf94a5b097;hpb=3e5e76a2f54b01d0aa265c60f7475dcf381e8b1a;p=controller.git diff --git a/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/test/java/org/opendaylight/controller/yang/parser/impl/YangParserTest.java b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/test/java/org/opendaylight/controller/yang/parser/impl/YangParserTest.java index fd2593ba48..ba31e51922 100644 --- a/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/test/java/org/opendaylight/controller/yang/parser/impl/YangParserTest.java +++ b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/test/java/org/opendaylight/controller/yang/parser/impl/YangParserTest.java @@ -12,10 +12,10 @@ import static org.junit.Assert.*; import java.io.FileNotFoundException; import java.net.URI; import java.text.DateFormat; +import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; -import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -56,17 +56,21 @@ import org.opendaylight.controller.yang.model.util.Decimal64; import org.opendaylight.controller.yang.model.util.ExtendedType; import org.opendaylight.controller.yang.model.util.Int16; import org.opendaylight.controller.yang.model.util.Int32; +import org.opendaylight.controller.yang.model.util.Int8; import org.opendaylight.controller.yang.model.util.Leafref; import org.opendaylight.controller.yang.model.util.StringType; import org.opendaylight.controller.yang.model.util.Uint32; import org.opendaylight.controller.yang.model.util.UnionType; public class YangParserTest { + private final DateFormat simpleDateFormat = new SimpleDateFormat( + "yyyy-MM-dd"); + private Set modules; @Before public void init() throws FileNotFoundException { - modules = TestUtils.loadModules("src/test/resources/model"); + modules = TestUtils.loadModules(getClass().getResource("/model").getPath()); assertEquals(3, modules.size()); } @@ -198,6 +202,54 @@ public class YangParserTest { assertTrue(ifMtu.getType() instanceof Int32); } + @Test + public void testParseLeaf() throws ParseException { + Module test = TestUtils.findModule(modules, "types2"); + + // leaf if-name + LeafSchemaNode ifName = (LeafSchemaNode) test + .getDataChildByName("if-name"); + Leafref ifNameType = (Leafref) ifName.getType(); + QName qname = ifNameType.getQName(); + + URI baseYangTypeNS = URI.create("urn:ietf:params:xml:ns:yang:1"); + assertEquals(baseYangTypeNS, qname.getNamespace()); + assertNull(qname.getRevision()); + assertEquals("", qname.getPrefix()); + assertEquals("leafref", qname.getLocalName()); + + // leaf name + LeafSchemaNode name = (LeafSchemaNode) test.getDataChildByName("name"); + StringType nameType = (StringType) name.getType(); + QName nameQName = nameType.getQName(); + + assertEquals(baseYangTypeNS, nameQName.getNamespace()); + assertNull(nameQName.getRevision()); + assertEquals("", nameQName.getPrefix()); + assertEquals("string", nameQName.getLocalName()); + + // leaf count + LeafSchemaNode count = (LeafSchemaNode) test + .getDataChildByName("count"); + ExtendedType countType = (ExtendedType) count.getType(); + QName countTypeQName = countType.getQName(); + + URI expectedNS = URI.create("urn:simple.types.data.demo"); + Date expectedDate = simpleDateFormat.parse("2013-02-27"); + assertEquals(expectedNS, countTypeQName.getNamespace()); + assertEquals(expectedDate, countTypeQName.getRevision()); + assertEquals("t2", countTypeQName.getPrefix()); + assertEquals("int8", countTypeQName.getLocalName()); + + Int8 countTypeBase = (Int8) countType.getBaseType(); + QName countTypeBaseQName = countTypeBase.getQName(); + + assertEquals(baseYangTypeNS, countTypeBaseQName.getNamespace()); + assertNull(countTypeBaseQName.getRevision()); + assertEquals("", countTypeBaseQName.getPrefix()); + assertEquals("int8", countTypeBaseQName.getLocalName()); + } + @Test public void testAugmentResolving() { // testfile1 @@ -288,17 +340,29 @@ public class YangParserTest { } @Test - public void testTypedefRangesResolving() { + public void testTypedefRangesResolving() throws ParseException { Module testModule = TestUtils.findModule(modules, "types1"); LeafSchemaNode testleaf = (LeafSchemaNode) testModule .getDataChildByName("testleaf"); ExtendedType leafType = (ExtendedType) testleaf.getType(); - assertEquals("my-type1", leafType.getQName().getLocalName()); - assertEquals("t2", leafType.getQName().getPrefix()); + QName leafTypeQName = leafType.getQName(); + assertEquals("my-type1", leafTypeQName.getLocalName()); + assertEquals("t1", leafTypeQName.getPrefix()); + assertEquals(URI.create("urn:simple.container.demo"), + leafTypeQName.getNamespace()); + Date expectedDate = simpleDateFormat.parse("2013-02-27"); + assertEquals(expectedDate, leafTypeQName.getRevision()); + assertEquals(1, leafType.getRanges().size()); + ExtendedType baseType = (ExtendedType) leafType.getBaseType(); - assertEquals("my-base-int32-type", baseType.getQName().getLocalName()); - assertEquals("t2", baseType.getQName().getPrefix()); + QName baseTypeQName = baseType.getQName(); + assertEquals("my-type1", baseTypeQName.getLocalName()); + assertEquals("t2", baseTypeQName.getPrefix()); + assertEquals(URI.create("urn:simple.types.data.demo"), + baseTypeQName.getNamespace()); + assertEquals(expectedDate, baseTypeQName.getRevision()); + assertEquals(2, baseType.getRanges().size()); List ranges = leafType.getRanges(); assertEquals(1, ranges.size()); @@ -318,28 +382,21 @@ public class YangParserTest { assertEquals("my-string-type-ext", testleafTypeQName.getLocalName()); assertEquals("t2", testleafTypeQName.getPrefix()); - Set expectedRegex = new HashSet(); - expectedRegex.add("[a-k]*"); - expectedRegex.add("[b-u]*"); - expectedRegex.add("[e-z]*"); - - Set actualRegex = new HashSet(); List patterns = testleafType.getPatterns(); - assertEquals(3, patterns.size()); - for (PatternConstraint pc : patterns) { - actualRegex.add(pc.getRegularExpression()); - } - assertEquals(expectedRegex, actualRegex); + assertEquals(1, patterns.size()); + PatternConstraint pattern = patterns.iterator().next(); + assertEquals("[e-z]*", pattern.getRegularExpression()); - TypeDefinition baseType = testleafType.getBaseType(); + ExtendedType baseType = (ExtendedType) testleafType.getBaseType(); assertEquals("my-string-type2", baseType.getQName().getLocalName()); - List lengths = testleafType.getLengths(); - assertEquals(1, lengths.size()); + patterns = baseType.getPatterns(); + assertEquals(1, patterns.size()); + pattern = patterns.iterator().next(); + assertEquals("[b-u]*", pattern.getRegularExpression()); - LengthConstraint length = lengths.get(0); - assertEquals(5L, length.getMin()); - assertEquals(10L, length.getMax()); + List lengths = testleafType.getLengths(); + assertTrue(lengths.isEmpty()); } @Test @@ -371,8 +428,14 @@ public class YangParserTest { ExtendedType baseType = (ExtendedType) testleafType.getBaseType(); assertEquals("my-base-int32-type", baseType.getQName().getLocalName()); - Int32 int32base = (Int32) baseType.getBaseType(); - List ranges = int32base.getRangeStatements(); + Int32 int32Type = (Int32) baseType.getBaseType(); + QName qname = int32Type.getQName(); + assertEquals(URI.create("urn:ietf:params:xml:ns:yang:1"), + qname.getNamespace()); + assertNull(qname.getRevision()); + assertEquals("", qname.getPrefix()); + assertEquals("int32", qname.getLocalName()); + List ranges = baseType.getRanges(); assertEquals(1, ranges.size()); RangeConstraint range = ranges.get(0); assertEquals(2L, range.getMin()); @@ -388,8 +451,12 @@ public class YangParserTest { ExtendedType type = (ExtendedType) testleaf.getType(); assertEquals(4, (int) type.getFractionDigits()); - Decimal64 baseType = (Decimal64) type.getBaseType(); - assertEquals(6, (int) baseType.getFractionDigits()); + ExtendedType typeBase = (ExtendedType) type.getBaseType(); + assertEquals("my-decimal-type", typeBase.getQName().getLocalName()); + assertNull(typeBase.getFractionDigits()); + + Decimal64 decimal = (Decimal64) typeBase.getBaseType(); + assertEquals(6, (int) decimal.getFractionDigits()); } @Test @@ -419,14 +486,14 @@ public class YangParserTest { UnionType unionBase = (UnionType) baseType.getBaseType(); List> unionTypes = unionBase.getTypes(); - Int16 unionType1 = (Int16) unionTypes.get(0); - List ranges = unionType1.getRangeStatements(); + ExtendedType unionType1 = (ExtendedType) unionTypes.get(0); + List ranges = unionType1.getRanges(); assertEquals(1, ranges.size()); RangeConstraint range = ranges.get(0); assertEquals(1L, range.getMin()); assertEquals(100L, range.getMax()); - assertTrue(unionTypes.get(0) instanceof Int16); + assertTrue(unionType1.getBaseType() instanceof Int16); assertTrue(unionTypes.get(1) instanceof Int32); } @@ -458,11 +525,12 @@ public class YangParserTest { .getBaseType(); List> extendedTargetTypes = extendedTargetUnion .getTypes(); - assertTrue(extendedTargetTypes.get(0) instanceof Int16); + assertTrue(extendedTargetTypes.get(0).getBaseType() instanceof Int16); assertTrue(extendedTargetTypes.get(1) instanceof Int32); - Int16 int16 = (Int16) extendedTargetTypes.get(0); - List ranges = int16.getRangeStatements(); + ExtendedType int16 = (ExtendedType) extendedTargetTypes.get(0); + assertTrue(int16.getBaseType() instanceof Int16); + List ranges = int16.getRanges(); assertEquals(1, ranges.size()); RangeConstraint range = ranges.get(0); assertEquals(1L, range.getMin()); @@ -536,10 +604,10 @@ public class YangParserTest { UnionType myUnionBase = (UnionType) myUnion.getBaseType(); List> myUnionBaseTypes = myUnionBase.getTypes(); assertEquals(2, myUnionBaseTypes.size()); - assertTrue(myUnionBaseTypes.get(0) instanceof Int16); + assertTrue(myUnionBaseTypes.get(0).getBaseType() instanceof Int16); assertTrue(myUnionBaseTypes.get(1) instanceof Int32); - Int16 int16 = (Int16) myUnionBaseTypes.get(0); - List ranges = int16.getRangeStatements(); + ExtendedType int16 = (ExtendedType) myUnionBaseTypes.get(0); + List ranges = int16.getRanges(); assertEquals(1, ranges.size()); RangeConstraint range = ranges.get(0); assertEquals(1L, range.getMin()); @@ -770,7 +838,6 @@ public class YangParserTest { @Test public void testAugmentNodesTypesSchemaPath() throws Exception { - final DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); Module testModule = TestUtils.findModule(modules, "types1"); Set augments = testModule.getAugmentations(); assertEquals(1, augments.size()); @@ -781,14 +848,20 @@ public class YangParserTest { Leafref ifcIdType = (Leafref) ifcId.getType(); SchemaPath ifcIdTypeSchemaPath = ifcIdType.getPath(); List ifcIdTypePath = ifcIdTypeSchemaPath.getPath(); - QName q0 = new QName(new URI("urn:simple.types.data.demo"), - simpleDateFormat.parse("2013-02-27"), "data", "interfaces"); - QName q1 = new QName(new URI("urn:simple.types.data.demo"), - simpleDateFormat.parse("2013-02-27"), "data", "ifEntry"); - QName q2 = new QName(new URI("urn:simple.container.demo.test"), - simpleDateFormat.parse("2013-02-27"), "data", "augment-holder"); - QName q3 = new QName(new URI("urn:simple.container.demo"), - simpleDateFormat.parse("2013-02-27"), "data", "interface-id"); + + URI types1URI = URI.create("urn:simple.container.demo"); + URI types2URI = URI.create("urn:simple.types.data.demo"); + URI types3URI = URI.create("urn:simple.container.demo.test"); + Date expectedDate = simpleDateFormat.parse("2013-02-27"); + + QName q0 = new QName(types2URI, + expectedDate, "data", "interfaces"); + QName q1 = new QName(types2URI, + expectedDate, "data", "ifEntry"); + QName q2 = new QName(types3URI, + expectedDate, "data", "augment-holder"); + QName q3 = new QName(types1URI, + expectedDate, "data", "interface-id"); assertEquals(q0, ifcIdTypePath.get(0)); assertEquals(q1, ifcIdTypePath.get(1)); assertEquals(q2, ifcIdTypePath.get(2)); @@ -802,9 +875,95 @@ public class YangParserTest { assertEquals(q0, higherLayerTypePath.get(0)); assertEquals(q1, higherLayerTypePath.get(1)); assertEquals(q2, higherLayerTypePath.get(2)); - q3 = new QName(new URI("urn:simple.container.demo"), - simpleDateFormat.parse("2013-02-27"), "data", "higher-layer-if"); + q3 = new QName(types1URI, + expectedDate, "data", "higher-layer-if"); assertEquals(q3, higherLayerTypePath.get(3)); + + LeafSchemaNode myType = (LeafSchemaNode) augment + .getDataChildByName("my-type"); + ExtendedType leafType = (ExtendedType)myType.getType(); + + testModule = TestUtils.findModule(modules, "types2"); + TypeDefinition typedef = TestUtils.findTypedef(testModule.getTypeDefinitions(), "my-type1"); + + assertEquals(typedef, leafType); + } + + @Test + public void testTypePath() throws ParseException { + Module test = TestUtils.findModule(modules, "types2"); + Set> types = test.getTypeDefinitions(); + + // my-base-int32-type + ExtendedType int32Typedef = (ExtendedType) TestUtils.findTypedef(types, + "my-base-int32-type"); + QName int32TypedefQName = int32Typedef.getQName(); + + URI expectedNS = URI.create("urn:simple.types.data.demo"); + Date expectedDate = simpleDateFormat.parse("2013-02-27"); + assertEquals(expectedNS, int32TypedefQName.getNamespace()); + assertEquals(expectedDate, int32TypedefQName.getRevision()); + assertEquals("t2", int32TypedefQName.getPrefix()); + assertEquals("my-base-int32-type", int32TypedefQName.getLocalName()); + + SchemaPath typeSchemaPath = int32Typedef.getPath(); + List typePath = typeSchemaPath.getPath(); + assertEquals(1, typePath.size()); + assertEquals(int32TypedefQName, typePath.get(0)); + + // my-base-int32-type/int32 + Int32 int32 = (Int32) int32Typedef.getBaseType(); + QName int32QName = int32.getQName(); + assertEquals(URI.create("urn:ietf:params:xml:ns:yang:1"), + int32QName.getNamespace()); + assertNull(int32QName.getRevision()); + assertEquals("", int32QName.getPrefix()); + assertEquals("int32", int32QName.getLocalName()); + + SchemaPath int32SchemaPath = int32.getPath(); + List int32Path = int32SchemaPath.getPath(); + assertEquals(3, int32Path.size()); + assertEquals(int32TypedefQName, int32Path.get(0)); + assertEquals(int32QName, int32Path.get(2)); + } + + @Test + public void testTypePath2() throws ParseException { + Module test = TestUtils.findModule(modules, "types2"); + Set> types = test.getTypeDefinitions(); + + // my-base-int32-type + ExtendedType myDecType = (ExtendedType) TestUtils.findTypedef(types, + "my-decimal-type"); + QName myDecTypeQName = myDecType.getQName(); + + URI expectedNS = URI.create("urn:simple.types.data.demo"); + Date expectedDate = simpleDateFormat.parse("2013-02-27"); + assertEquals(expectedNS, myDecTypeQName.getNamespace()); + assertEquals(expectedDate, myDecTypeQName.getRevision()); + assertEquals("t2", 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)); + + // my-base-int32-type/int32 + Decimal64 dec64 = (Decimal64) myDecType.getBaseType(); + QName dec64QName = dec64.getQName(); + + 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)); } }