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=d331cff18d29b5231498f7cacad2e023aa265341;hb=c9006d027a5c5b639e57aa7b8484ec1ff3497dc8;hp=f6240c9a3f9f2d203711a6e4d3f25053367614d8;hpb=aab7c08016dab70136793a108f7d7b8be3edc3c1;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 f6240c9a3f..d331cff18d 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,12 +9,14 @@ 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; import java.util.List; -import java.util.Map; import java.util.Set; import org.junit.Before; @@ -30,19 +32,17 @@ import org.opendaylight.controller.yang.model.api.Deviation; 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.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; import org.opendaylight.controller.yang.model.api.ModuleImport; -import org.opendaylight.controller.yang.model.api.MustDefinition; import org.opendaylight.controller.yang.model.api.NotificationDefinition; import org.opendaylight.controller.yang.model.api.RpcDefinition; -import org.opendaylight.controller.yang.model.api.SchemaNode; import org.opendaylight.controller.yang.model.api.SchemaPath; import org.opendaylight.controller.yang.model.api.Status; import org.opendaylight.controller.yang.model.api.TypeDefinition; import org.opendaylight.controller.yang.model.api.UnknownSchemaNode; -import org.opendaylight.controller.yang.model.api.UsesNode; import org.opendaylight.controller.yang.model.api.type.LengthConstraint; import org.opendaylight.controller.yang.model.api.type.PatternConstraint; import org.opendaylight.controller.yang.model.api.type.RangeConstraint; @@ -50,16 +50,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() { - modules = TestUtils.loadModules("src/test/resources/model"); + public void init() throws FileNotFoundException { + modules = TestUtils.loadModules(getClass().getResource("/model").getPath()); assertEquals(3, modules.size()); } @@ -98,14 +101,12 @@ public class YangParserTest { String expectedPrefix = "t2"; Date expectedRevision = TestUtils.createDate("2013-02-27"); - ContainerSchemaNode interfaces = (ContainerSchemaNode) test - .getDataChildByName("interfaces"); + ContainerSchemaNode interfaces = (ContainerSchemaNode) test.getDataChildByName("interfaces"); // test SchemaNode args - QName expectedQName = new QName(expectedNamespace, expectedRevision, - expectedPrefix, "interfaces"); + QName expectedQName = new QName(expectedNamespace, expectedRevision, expectedPrefix, "interfaces"); assertEquals(expectedQName, interfaces.getQName()); - SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace, - expectedRevision, expectedPrefix, "interfaces"); + SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace, expectedRevision, expectedPrefix, + "interfaces"); assertEquals(expectedPath, interfaces.getPath()); assertNull(interfaces.getDescription()); assertNull(interfaces.getReference()); @@ -113,7 +114,7 @@ public class YangParserTest { assertEquals(0, interfaces.getUnknownSchemaNodes().size()); // test DataSchemaNode args assertFalse(interfaces.isAugmenting()); - assertFalse(interfaces.isConfiguration()); + assertTrue(interfaces.isConfiguration()); ConstraintDefinition constraints = interfaces.getConstraints(); assertNull(constraints.getWhenCondition()); assertEquals(0, constraints.getMustConstraints().size()); @@ -130,8 +131,7 @@ public class YangParserTest { assertEquals(0, interfaces.getGroupings().size()); assertEquals(0, interfaces.getUses().size()); - ListSchemaNode ifEntry = (ListSchemaNode) interfaces - .getDataChildByName("ifEntry"); + ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry"); assertNotNull(ifEntry); } @@ -142,17 +142,14 @@ public class YangParserTest { String expectedPrefix = "t2"; Date expectedRevision = TestUtils.createDate("2013-02-27"); - ContainerSchemaNode interfaces = (ContainerSchemaNode) test - .getDataChildByName("interfaces"); + ContainerSchemaNode interfaces = (ContainerSchemaNode) test.getDataChildByName("interfaces"); - ListSchemaNode ifEntry = (ListSchemaNode) interfaces - .getDataChildByName("ifEntry"); + ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry"); // test SchemaNode args - QName expectedQName = new QName(expectedNamespace, expectedRevision, - expectedPrefix, "ifEntry"); + QName expectedQName = new QName(expectedNamespace, expectedRevision, expectedPrefix, "ifEntry"); assertEquals(expectedQName, ifEntry.getQName()); - SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace, - expectedRevision, expectedPrefix, "interfaces", "ifEntry"); + SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace, expectedRevision, expectedPrefix, + "interfaces", "ifEntry"); assertEquals(expectedPath, ifEntry.getPath()); assertNull(ifEntry.getDescription()); assertNull(ifEntry.getReference()); @@ -160,21 +157,19 @@ public class YangParserTest { assertEquals(0, ifEntry.getUnknownSchemaNodes().size()); // test DataSchemaNode args assertFalse(ifEntry.isAugmenting()); - assertFalse(ifEntry.isConfiguration()); + assertTrue(ifEntry.isConfiguration()); ConstraintDefinition constraints = ifEntry.getConstraints(); assertNull(constraints.getWhenCondition()); assertEquals(0, constraints.getMustConstraints().size()); assertFalse(constraints.isMandatory()); - assertNull(constraints.getMinElements()); - assertNull(constraints.getMaxElements()); + assertEquals(1, (int) constraints.getMinElements()); + assertEquals(11, (int) constraints.getMaxElements()); // test AugmentationTarget args - Set availableAugmentations = ifEntry - .getAvailableAugmentations(); + Set availableAugmentations = ifEntry.getAvailableAugmentations(); assertEquals(2, availableAugmentations.size()); // test ListSchemaNode args List expectedKey = new ArrayList(); - expectedKey.add(new QName(expectedNamespace, expectedRevision, - expectedPrefix, "ifIndex")); + expectedKey.add(new QName(expectedNamespace, expectedRevision, expectedPrefix, "ifIndex")); assertEquals(expectedKey, ifEntry.getKeyDefinition()); assertFalse(ifEntry.isUserOrdered()); // test DataNodeContainer args @@ -183,59 +178,97 @@ public class YangParserTest { assertEquals(0, ifEntry.getGroupings().size()); assertEquals(0, ifEntry.getUses().size()); - LeafSchemaNode ifIndex = (LeafSchemaNode) ifEntry - .getDataChildByName("ifIndex"); + LeafSchemaNode ifIndex = (LeafSchemaNode) ifEntry.getDataChildByName("ifIndex"); assertTrue(ifIndex.getType() instanceof Uint32); - LeafSchemaNode ifMtu = (LeafSchemaNode) ifEntry - .getDataChildByName("ifMtu"); + LeafSchemaNode ifMtu = (LeafSchemaNode) ifEntry.getDataChildByName("ifMtu"); 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 Module module1 = TestUtils.findModule(modules, "types1"); - Set module1Augmentations = module1 - .getAugmentations(); + Set module1Augmentations = module1.getAugmentations(); AugmentationSchema augment1 = module1Augmentations.iterator().next(); - LeafSchemaNode augmentedLeafDefinition = (LeafSchemaNode) augment1 - .getDataChildByName("ds0ChannelNumber"); + LeafSchemaNode augmentedLeafDefinition = (LeafSchemaNode) augment1.getDataChildByName("ds0ChannelNumber"); assertTrue(augmentedLeafDefinition.isAugmenting()); // testfile2 Module module2 = TestUtils.findModule(modules, "types2"); - ContainerSchemaNode interfaces = (ContainerSchemaNode) module2 - .getDataChildByName("interfaces"); - ListSchemaNode ifEntry = (ListSchemaNode) interfaces - .getDataChildByName("ifEntry"); - ContainerSchemaNode augmentedContainer = (ContainerSchemaNode) ifEntry - .getDataChildByName("augment-holder"); + ContainerSchemaNode interfaces = (ContainerSchemaNode) module2.getDataChildByName("interfaces"); + ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry"); + ContainerSchemaNode augmentedContainer = (ContainerSchemaNode) ifEntry.getDataChildByName("augment-holder"); + + ContainerSchemaNode schemas = (ContainerSchemaNode) augmentedContainer.getDataChildByName("schemas"); + LeafSchemaNode linkleaf = (LeafSchemaNode) schemas.getDataChildByName("linkleaf"); + assertNotNull(linkleaf); // augmentation defined in testfile1 and augmentation returned from // augmented container have to be same - Set augmentedContainerAugments = augmentedContainer - .getAvailableAugmentations(); - AugmentationSchema augmentDefinition = augmentedContainerAugments - .iterator().next(); + Set augmentedContainerAugments = augmentedContainer.getAvailableAugmentations(); + AugmentationSchema augmentDefinition = augmentedContainerAugments.iterator().next(); assertEquals(augment1, augmentDefinition); - LeafSchemaNode augmentedLeaf = (LeafSchemaNode) augmentedContainer - .getDataChildByName("ds0ChannelNumber"); + LeafSchemaNode augmentedLeaf = (LeafSchemaNode) augmentedContainer.getDataChildByName("ds0ChannelNumber"); assertTrue(augmentedLeaf.isAugmenting()); assertEquals(augmentedLeafDefinition, augmentedLeaf); - Set ifEntryAugments = ifEntry - .getAvailableAugmentations(); + Set ifEntryAugments = ifEntry.getAvailableAugmentations(); assertEquals(2, ifEntryAugments.size()); // testfile3 Module module3 = TestUtils.findModule(modules, "types3"); - Set module3Augmentations = module3 - .getAugmentations(); - assertEquals(2, module3Augmentations.size()); + Set module3Augmentations = module3.getAugmentations(); + assertEquals(3, module3Augmentations.size()); AugmentationSchema augment3 = null; for (AugmentationSchema as : module3Augmentations) { if ("if:ifType='ds0'".equals(as.getWhenCondition().toString())) { @@ -248,22 +281,16 @@ public class YangParserTest { // check assertEquals(augmentedContainer, augmentedContainerDefinition); - assertEquals(augmentedContainerAugments.iterator().next(), augment1); - assertEquals(augmentedLeaf, augmentedLeafDefinition); - assertEquals(ifEntryAugments.iterator().next(), augment3); } @Test public void testAugmentTarget() { Module test = TestUtils.findModule(modules, "types2"); - ContainerSchemaNode interfaces = (ContainerSchemaNode) test - .getDataChildByName("interfaces"); - ListSchemaNode ifEntry = (ListSchemaNode) interfaces - .getDataChildByName("ifEntry"); - Set augmentations = ifEntry - .getAvailableAugmentations(); + ContainerSchemaNode interfaces = (ContainerSchemaNode) test.getDataChildByName("interfaces"); + ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry"); + Set augmentations = ifEntry.getAvailableAugmentations(); assertEquals(2, augmentations.size()); AugmentationSchema augment = null; @@ -272,34 +299,41 @@ public class YangParserTest { augment = as; } } - ContainerSchemaNode augmentHolder = (ContainerSchemaNode) augment - .getDataChildByName("augment-holder"); + ContainerSchemaNode augmentHolder = (ContainerSchemaNode) augment.getDataChildByName("augment-holder"); assertNotNull(augmentHolder); assertTrue(augmentHolder.isAugmenting()); QName augmentHolderQName = augmentHolder.getQName(); assertEquals("augment-holder", augmentHolderQName.getLocalName()); assertEquals("t3", augmentHolderQName.getPrefix()); - assertEquals("Description for augment holder", - augmentHolder.getDescription()); + assertEquals("Description for augment holder", augmentHolder.getDescription()); } @Test - public void testTypedefRangesResolving() { + public void testTypedefRangesResolving() throws ParseException { Module testModule = TestUtils.findModule(modules, "types1"); - LeafSchemaNode testleaf = (LeafSchemaNode) testModule - .getDataChildByName("testleaf"); + 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()); RangeConstraint range = ranges.get(0); - assertEquals(3L, range.getMin()); + assertEquals(12L, range.getMin()); assertEquals(20L, range.getMax()); } @@ -307,43 +341,34 @@ public class YangParserTest { public void testTypedefPatternsResolving() { Module testModule = TestUtils.findModule(modules, "types1"); - LeafSchemaNode testleaf = (LeafSchemaNode) testModule - .getDataChildByName("test-string-leaf"); + LeafSchemaNode testleaf = (LeafSchemaNode) testModule.getDataChildByName("test-string-leaf"); ExtendedType testleafType = (ExtendedType) testleaf.getType(); QName testleafTypeQName = testleafType.getQName(); 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 public void testTypedefLengthsResolving() { Module testModule = TestUtils.findModule(modules, "types1"); - LeafSchemaNode testleaf = (LeafSchemaNode) testModule - .getDataChildByName("leaf-with-length"); + LeafSchemaNode testleaf = (LeafSchemaNode) testModule.getDataChildByName("leaf-with-length"); ExtendedType testleafType = (ExtendedType) testleaf.getType(); assertEquals("my-string-type", testleafType.getQName().getLocalName()); @@ -359,16 +384,20 @@ public class YangParserTest { public void testTypeDef() { Module testModule = TestUtils.findModule(modules, "types2"); - LeafSchemaNode testleaf = (LeafSchemaNode) testModule - .getDataChildByName("nested-type-leaf"); + LeafSchemaNode testleaf = (LeafSchemaNode) testModule.getDataChildByName("nested-type-leaf"); ExtendedType testleafType = (ExtendedType) testleaf.getType(); assertEquals("my-type1", testleafType.getQName().getLocalName()); 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()); @@ -379,21 +408,23 @@ public class YangParserTest { public void testTypedefDecimal1() { Module testModule = TestUtils.findModule(modules, "types1"); - LeafSchemaNode testleaf = (LeafSchemaNode) testModule - .getDataChildByName("test-decimal-leaf"); + LeafSchemaNode testleaf = (LeafSchemaNode) testModule.getDataChildByName("test-decimal-leaf"); 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 public void testTypedefDecimal2() { Module testModule = TestUtils.findModule(modules, "types1"); - LeafSchemaNode testleaf = (LeafSchemaNode) testModule - .getDataChildByName("test-decimal-leaf2"); + LeafSchemaNode testleaf = (LeafSchemaNode) testModule.getDataChildByName("test-decimal-leaf2"); TypeDefinition baseType = testleaf.getType().getBaseType(); assertTrue(testleaf.getType().getBaseType() instanceof Decimal64); Decimal64 baseTypeCast = (Decimal64) baseType; @@ -404,8 +435,7 @@ public class YangParserTest { public void testTypedefUnion() { Module testModule = TestUtils.findModule(modules, "types1"); - LeafSchemaNode testleaf = (LeafSchemaNode) testModule - .getDataChildByName("union-leaf"); + LeafSchemaNode testleaf = (LeafSchemaNode) testModule.getDataChildByName("union-leaf"); ExtendedType testleafType = (ExtendedType) testleaf.getType(); assertEquals("my-union-ext", testleafType.getQName().getLocalName()); @@ -415,14 +445,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); } @@ -430,8 +460,7 @@ public class YangParserTest { public void testNestedUnionResolving1() { Module testModule = TestUtils.findModule(modules, "types1"); - LeafSchemaNode testleaf = (LeafSchemaNode) testModule - .getDataChildByName("nested-union-leaf"); + LeafSchemaNode testleaf = (LeafSchemaNode) testModule.getDataChildByName("nested-union-leaf"); ExtendedType nestedUnion1 = (ExtendedType) testleaf.getType(); assertEquals("nested-union1", nestedUnion1.getQName().getLocalName()); @@ -446,19 +475,17 @@ public class YangParserTest { assertTrue(unionTypes.get(1) instanceof ExtendedType); ExtendedType extendedUnion = (ExtendedType) unionTypes.get(1); - ExtendedType extendedUnionBase = (ExtendedType) extendedUnion - .getBaseType(); + ExtendedType extendedUnionBase = (ExtendedType) extendedUnion.getBaseType(); assertEquals("my-union", extendedUnionBase.getQName().getLocalName()); - UnionType extendedTargetUnion = (UnionType) extendedUnionBase - .getBaseType(); - List> extendedTargetTypes = extendedTargetUnion - .getTypes(); - assertTrue(extendedTargetTypes.get(0) instanceof Int16); + UnionType extendedTargetUnion = (UnionType) extendedUnionBase.getBaseType(); + List> extendedTargetTypes = extendedTargetUnion.getTypes(); + 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()); @@ -469,24 +496,19 @@ public class YangParserTest { public void testNestedUnionResolving2() { Module testModule = TestUtils.findModule(modules, "types1"); - LeafSchemaNode testleaf = (LeafSchemaNode) testModule - .getDataChildByName("custom-union-leaf"); + LeafSchemaNode testleaf = (LeafSchemaNode) testModule.getDataChildByName("custom-union-leaf"); ExtendedType testleafType = (ExtendedType) testleaf.getType(); QName testleafTypeQName = testleafType.getQName(); - assertEquals(URI.create("urn:simple.container.demo.test"), - testleafTypeQName.getNamespace()); - assertEquals(TestUtils.createDate("2013-02-27"), - testleafTypeQName.getRevision()); + assertEquals(URI.create("urn:simple.container.demo.test"), testleafTypeQName.getNamespace()); + assertEquals(TestUtils.createDate("2013-02-27"), testleafTypeQName.getRevision()); assertEquals("t3", testleafTypeQName.getPrefix()); assertEquals("union1", testleafTypeQName.getLocalName()); ExtendedType union2 = (ExtendedType) testleafType.getBaseType(); QName union2QName = union2.getQName(); - assertEquals(URI.create("urn:simple.container.demo.test"), - union2QName.getNamespace()); - assertEquals(TestUtils.createDate("2013-02-27"), - union2QName.getRevision()); + assertEquals(URI.create("urn:simple.container.demo.test"), union2QName.getNamespace()); + assertEquals(TestUtils.createDate("2013-02-27"), union2QName.getRevision()); assertEquals("t3", union2QName.getPrefix()); assertEquals("union2", union2QName.getLocalName()); @@ -498,10 +520,8 @@ public class YangParserTest { ExtendedType nestedUnion2 = (ExtendedType) unionTypes.get(1); QName nestedUnion2QName = nestedUnion2.getQName(); - assertEquals(URI.create("urn:simple.types.data.demo"), - nestedUnion2QName.getNamespace()); - assertEquals(TestUtils.createDate("2013-02-27"), - nestedUnion2QName.getRevision()); + assertEquals(URI.create("urn:simple.types.data.demo"), nestedUnion2QName.getNamespace()); + assertEquals(TestUtils.createDate("2013-02-27"), nestedUnion2QName.getRevision()); assertEquals("t2", nestedUnion2QName.getPrefix()); assertEquals("nested-union2", nestedUnion2QName.getLocalName()); @@ -513,83 +533,57 @@ public class YangParserTest { ExtendedType myUnionExt = (ExtendedType) nestedUnion2Types.get(1); QName myUnionExtQName = myUnionExt.getQName(); - assertEquals(URI.create("urn:simple.types.data.demo"), - myUnionExtQName.getNamespace()); - assertEquals(TestUtils.createDate("2013-02-27"), - myUnionExtQName.getRevision()); + assertEquals(URI.create("urn:simple.types.data.demo"), myUnionExtQName.getNamespace()); + assertEquals(TestUtils.createDate("2013-02-27"), myUnionExtQName.getRevision()); assertEquals("t2", myUnionExtQName.getPrefix()); assertEquals("my-union-ext", myUnionExtQName.getLocalName()); ExtendedType myUnion = (ExtendedType) myUnionExt.getBaseType(); QName myUnionQName = myUnion.getQName(); - assertEquals(URI.create("urn:simple.types.data.demo"), - myUnionQName.getNamespace()); - assertEquals(TestUtils.createDate("2013-02-27"), - myUnionQName.getRevision()); + assertEquals(URI.create("urn:simple.types.data.demo"), myUnionQName.getNamespace()); + assertEquals(TestUtils.createDate("2013-02-27"), myUnionQName.getRevision()); assertEquals("t2", myUnionQName.getPrefix()); assertEquals("my-union", myUnionQName.getLocalName()); 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()); assertEquals(100L, range.getMax()); } - @Test - public void testRefine() { - Module testModule = TestUtils.findModule(modules, "types2"); - - ContainerSchemaNode peer = (ContainerSchemaNode) testModule - .getDataChildByName("peer"); - ContainerSchemaNode destination = (ContainerSchemaNode) peer - .getDataChildByName("destination"); - Set usesNodes = destination.getUses(); - assertEquals(1, usesNodes.size()); - UsesNode usesNode = usesNodes.iterator().next(); - Map refines = usesNode.getRefines(); - assertEquals(2, refines.size()); - - for (Map.Entry entry : refines.entrySet()) { - SchemaNode value = entry.getValue(); - - if (value instanceof LeafSchemaNode) { - LeafSchemaNode refineLeaf = (LeafSchemaNode) value; - assertNotNull(refineLeaf); - } else { - ContainerSchemaNode refineContainer = (ContainerSchemaNode) value; - 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()); - } - } - } - @Test public void testChoice() { Module testModule = TestUtils.findModule(modules, "types1"); - ContainerSchemaNode peer = (ContainerSchemaNode) testModule - .getDataChildByName("transfer"); + ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName("transfer"); ChoiceNode how = (ChoiceNode) peer.getDataChildByName("how"); Set cases = how.getCases(); - assertEquals(3, cases.size()); + assertEquals(5, cases.size()); + ChoiceCaseNode input = null; + ChoiceCaseNode output = null; + for(ChoiceCaseNode caseNode : cases) { + if("input".equals(caseNode.getQName().getLocalName())) { + input = caseNode; + } else if("output".equals(caseNode.getQName().getLocalName())) { + output = caseNode; + } + } + assertNotNull(input); + assertNotNull(input.getPath()); + assertNotNull(output); + assertNotNull(output.getPath()); } @Test public void testAnyXml() { Module testModule = TestUtils.findModule(modules, "types1"); - AnyXmlSchemaNode data = (AnyXmlSchemaNode) testModule - .getDataChildByName("data"); + AnyXmlSchemaNode data = (AnyXmlSchemaNode) testModule.getDataChildByName("data"); assertNotNull(data); } @@ -600,8 +594,7 @@ public class YangParserTest { assertEquals(1, deviations.size()); Deviation dev = deviations.iterator().next(); - SchemaPath expectedPath = TestUtils.createPath(true, null, null, - "data", "system", "user"); + SchemaPath expectedPath = TestUtils.createPath(true, null, null, "data", "system", "user"); assertEquals(expectedPath, dev.getTargetPath()); assertEquals(Deviate.ADD, dev.getDeviate()); } @@ -609,8 +602,7 @@ public class YangParserTest { @Test public void testUnknownNode() { Module testModule = TestUtils.findModule(modules, "types3"); - ContainerSchemaNode network = (ContainerSchemaNode) testModule - .getDataChildByName("network"); + ContainerSchemaNode network = (ContainerSchemaNode) testModule.getDataChildByName("network"); List unknownNodes = network.getUnknownSchemaNodes(); assertEquals(1, unknownNodes.size()); UnknownSchemaNode unknownNode = unknownNodes.get(0); @@ -628,8 +620,7 @@ public class YangParserTest { @Test public void testExtension() { Module testModule = TestUtils.findModule(modules, "types3"); - List extensions = testModule - .getExtensionSchemaNodes(); + List extensions = testModule.getExtensionSchemaNodes(); assertEquals(1, extensions.size()); ExtensionDefinition extension = extensions.get(0); assertEquals("name", extension.getArgument()); @@ -643,17 +634,15 @@ public class YangParserTest { String expectedPrefix = "t3"; Date expectedRevision = TestUtils.createDate("2013-02-27"); - Set notifications = testModule - .getNotifications(); + Set notifications = testModule.getNotifications(); assertEquals(1, notifications.size()); NotificationDefinition notification = notifications.iterator().next(); // test SchemaNode args - QName expectedQName = new QName(expectedNamespace, expectedRevision, - expectedPrefix, "event"); + QName expectedQName = new QName(expectedNamespace, expectedRevision, expectedPrefix, "event"); assertEquals(expectedQName, notification.getQName()); - SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace, - expectedRevision, expectedPrefix, "event"); + SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace, expectedRevision, expectedPrefix, + "event"); assertEquals(expectedPath, notification.getPath()); assertNull(notification.getDescription()); assertNull(notification.getReference()); @@ -665,14 +654,11 @@ public class YangParserTest { assertEquals(0, notification.getGroupings().size()); assertEquals(0, notification.getUses().size()); - LeafSchemaNode eventClass = (LeafSchemaNode) notification - .getDataChildByName("event-class"); + LeafSchemaNode eventClass = (LeafSchemaNode) notification.getDataChildByName("event-class"); assertTrue(eventClass.getType() instanceof StringType); - AnyXmlSchemaNode reportingEntity = (AnyXmlSchemaNode) notification - .getDataChildByName("reporting-entity"); + AnyXmlSchemaNode reportingEntity = (AnyXmlSchemaNode) notification.getDataChildByName("reporting-entity"); assertNotNull(reportingEntity); - LeafSchemaNode severity = (LeafSchemaNode) notification - .getDataChildByName("severity"); + LeafSchemaNode severity = (LeafSchemaNode) notification.getDataChildByName("severity"); assertTrue(severity.getType() instanceof StringType); } @@ -684,8 +670,7 @@ public class YangParserTest { assertEquals(1, rpcs.size()); RpcDefinition rpc = rpcs.iterator().next(); - assertEquals("Retrieve all or part of a specified configuration.", - rpc.getDescription()); + assertEquals("Retrieve all or part of a specified configuration.", rpc.getDescription()); assertEquals("RFC 6241, Section 7.1", rpc.getReference()); ContainerSchemaNode input = rpc.getInput(); @@ -695,4 +680,122 @@ public class YangParserTest { assertNotNull(output.getDataChildByName("data")); } + @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(); + + 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)); + 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(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)); + } + }