X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;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=23bb4a41d2f25fc16c501f06ed9d65b316206d53;hp=910a360c9be920ecab6efe819656828e5d582b28;hb=9ceed566491d172e02220b04ec6869867f2f2473;hpb=53e740af349a154f3f1a6b8c041303446f599718 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 910a360c9b..23bb4a41d2 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 @@ -9,7 +9,11 @@ package org.opendaylight.controller.yang.parser.impl; 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; @@ -32,6 +36,7 @@ import org.opendaylight.controller.yang.model.api.Deviation.Deviate; import org.opendaylight.controller.yang.model.api.ExtensionDefinition; import org.opendaylight.controller.yang.model.api.FeatureDefinition; import org.opendaylight.controller.yang.model.api.GroupingDefinition; +import org.opendaylight.controller.yang.model.api.LeafListSchemaNode; import org.opendaylight.controller.yang.model.api.LeafSchemaNode; import org.opendaylight.controller.yang.model.api.ListSchemaNode; import org.opendaylight.controller.yang.model.api.Module; @@ -52,15 +57,19 @@ 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() { + public void init() throws FileNotFoundException { modules = TestUtils.loadModules("src/test/resources/model"); assertEquals(3, modules.size()); } @@ -167,8 +176,8 @@ public class YangParserTest { assertNull(constraints.getWhenCondition()); assertEquals(0, constraints.getMustConstraints().size()); assertFalse(constraints.isMandatory()); - assertEquals(1, (int)constraints.getMinElements()); - assertEquals(11, (int)constraints.getMaxElements()); + assertEquals(1, (int) constraints.getMinElements()); + assertEquals(11, (int) constraints.getMaxElements()); // test AugmentationTarget args Set availableAugmentations = ifEntry .getAvailableAugmentations(); @@ -193,6 +202,55 @@ 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 @@ -366,8 +424,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(); + ExtendedType int32Type = (ExtendedType) baseType.getBaseType(); + Int32 int32TypeBase = (Int32)int32Type.getBaseType(); + QName qname = int32TypeBase.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 = int32Type.getRanges(); assertEquals(1, ranges.size()); RangeConstraint range = ranges.get(0); assertEquals(2L, range.getMin()); @@ -414,14 +478,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); } @@ -453,11 +517,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()); @@ -531,10 +596,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()); @@ -564,14 +629,14 @@ public class YangParserTest { SchemaNode value = entry.getValue(); if (value instanceof LeafSchemaNode) { refineLeaf = (LeafSchemaNode) value; - } else if(value instanceof ContainerSchemaNode) { + } else if (value instanceof ContainerSchemaNode) { refineContainer = (ContainerSchemaNode) value; - } else if(value instanceof ListSchemaNode) { - refineList = (ListSchemaNode)value; - } else if(value instanceof GroupingDefinition) { - refineGrouping = (GroupingDefinition)value; - } else if(value instanceof TypeDefinition) { - typedef = (TypeDefinition)value; + } else if (value instanceof ListSchemaNode) { + refineList = (ListSchemaNode) value; + } else if (value instanceof GroupingDefinition) { + refineGrouping = (GroupingDefinition) value; + } else if (value instanceof TypeDefinition) { + typedef = (TypeDefinition) value; } } @@ -596,11 +661,7 @@ public class YangParserTest { assertNotNull(refineContainer); Set mustConstraints = refineContainer.getConstraints() .getMustConstraints(); - assertEquals(1, mustConstraints.size()); - MustDefinition must = mustConstraints.iterator().next(); - assertEquals("must-condition", must.toString()); - assertEquals("An error message test", must.getErrorMessage()); - assertEquals(("An error app tag test"), must.getErrorAppTag()); + assertTrue(mustConstraints.isEmpty()); assertEquals("description of port defined by refine", refineContainer.getDescription()); assertEquals("port reference added by refine", @@ -610,19 +671,25 @@ public class YangParserTest { // list addresses assertNotNull(refineList); - assertEquals("description of addresses defined by refine", refineList.getDescription()); - assertEquals("addresses reference added by refine", refineList.getReference()); + assertEquals("description of addresses defined by refine", + refineList.getDescription()); + assertEquals("addresses reference added by refine", + refineList.getReference()); assertFalse(refineList.isConfiguration()); - assertEquals(2, (int)refineList.getConstraints().getMinElements()); - assertEquals(12, (int)refineList.getConstraints().getMaxElements()); + assertEquals(2, (int) refineList.getConstraints().getMinElements()); + assertEquals(12, (int) refineList.getConstraints().getMaxElements()); // grouping target-inner assertNotNull(refineGrouping); - Set refineGroupingChildren = refineGrouping.getChildNodes(); + Set refineGroupingChildren = refineGrouping + .getChildNodes(); assertEquals(1, refineGroupingChildren.size()); - LeafSchemaNode refineGroupingLeaf = (LeafSchemaNode)refineGroupingChildren.iterator().next(); - assertEquals("inner-grouping-id", refineGroupingLeaf.getQName().getLocalName()); - assertEquals("new target-inner grouping description", refineGrouping.getDescription()); + LeafSchemaNode refineGroupingLeaf = (LeafSchemaNode) refineGroupingChildren + .iterator().next(); + assertEquals("inner-grouping-id", refineGroupingLeaf.getQName() + .getLocalName()); + assertEquals("new target-inner grouping description", + refineGrouping.getDescription()); // typedef group-type assertNotNull(typedef); @@ -761,4 +828,131 @@ public class YangParserTest { assertEquals(5, children.size()); } + @Test + public void testAugmentNodesTypesSchemaPath() throws Exception { + Module testModule = TestUtils.findModule(modules, "types1"); + Set augments = testModule.getAugmentations(); + assertEquals(1, augments.size()); + AugmentationSchema augment = augments.iterator().next(); + + LeafSchemaNode ifcId = (LeafSchemaNode) augment + .getDataChildByName("interface-id"); + 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"); + assertEquals(q0, ifcIdTypePath.get(0)); + assertEquals(q1, ifcIdTypePath.get(1)); + assertEquals(q2, ifcIdTypePath.get(2)); + assertEquals(q3, ifcIdTypePath.get(3)); + + LeafListSchemaNode higherLayer = (LeafListSchemaNode) augment + .getDataChildByName("higher-layer-if"); + Leafref higherLayerType = (Leafref) higherLayer.getType(); + SchemaPath higherLayerTypeSchemaPath = higherLayerType.getPath(); + List higherLayerTypePath = higherLayerTypeSchemaPath.getPath(); + 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"); + assertEquals(q3, higherLayerTypePath.get(3)); + } + + @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 + ExtendedType int32Ext = (ExtendedType)int32Typedef.getBaseType(); + QName int32ExtQName = int32Ext.getQName(); + + assertEquals(expectedNS, int32ExtQName.getNamespace()); + assertEquals(expectedDate, int32ExtQName.getRevision()); + assertEquals("t2", int32ExtQName.getPrefix()); + assertEquals("int32", int32ExtQName.getLocalName()); + + SchemaPath int32ExtSchemaPath = int32Ext.getPath(); + List int32ExtPath = int32ExtSchemaPath.getPath(); + assertEquals(2, int32ExtPath.size()); + assertEquals(int32TypedefQName, int32ExtPath.get(0)); + assertEquals(int32ExtQName, int32ExtPath.get(1)); + + // my-base-int32-type/int32/int32 + Int32 int32 = (Int32)int32Ext.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(int32ExtQName, int32Path.get(1)); + 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)); + } + }