X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fsal%2Fyang-prototype%2Fcode-generator%2Fbinding-generator-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fbinding%2Fgenerator%2Fimpl%2FGeneratedTypesTest.java;h=a8b3b487af896c82c61f9f019631ead1614d7607;hb=refs%2Fchanges%2F03%2F703%2F1;hp=66c293eebc5beadf52cb7614dacf5f5bad2a5c4e;hpb=0f846fcbc207a4213ac133e1d08a305fc72168ba;p=controller.git diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/java/org/opendaylight/controller/sal/binding/generator/impl/GeneratedTypesTest.java b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/java/org/opendaylight/controller/sal/binding/generator/impl/GeneratedTypesTest.java index 66c293eebc..a8b3b487af 100644 --- a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/java/org/opendaylight/controller/sal/binding/generator/impl/GeneratedTypesTest.java +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/java/org/opendaylight/controller/sal/binding/generator/impl/GeneratedTypesTest.java @@ -8,15 +8,16 @@ package org.opendaylight.controller.sal.binding.generator.impl; import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import java.io.File; import java.util.ArrayList; import java.util.List; import java.util.Set; +import org.junit.Ignore; import org.junit.Test; import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator; -import org.opendaylight.controller.sal.binding.model.api.Enumeration; import org.opendaylight.controller.sal.binding.model.api.GeneratedProperty; import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject; import org.opendaylight.controller.sal.binding.model.api.GeneratedType; @@ -29,8 +30,7 @@ import org.opendaylight.controller.yang.parser.impl.YangParserImpl; public class GeneratedTypesTest { - private SchemaContext resolveSchemaContextFromFiles( - final String... yangFiles) { + private SchemaContext resolveSchemaContextFromFiles(final String... yangFiles) { final YangModelParser parser = new YangParserImpl(); final List inputFiles = new ArrayList(); @@ -42,106 +42,51 @@ public class GeneratedTypesTest { return parser.resolveSchemaContext(modules); } - @Test - public void testLeafEnumResolving() { - final String ietfInterfacesPath = getClass().getResource( - "/enum-test-models/ietf-interfaces@2012-11-15.yang").getPath(); - final String ifTypePath = getClass().getResource( - "/enum-test-models/iana-if-type@2012-06-05.yang").getPath(); - final String yangTypesPath = getClass().getResource( - "/enum-test-models/ietf-yang-types@2010-09-24.yang").getPath(); - - final SchemaContext context = resolveSchemaContextFromFiles( - ietfInterfacesPath, ifTypePath, yangTypesPath); - assertTrue(context != null); - - final BindingGenerator bindingGen = new BindingGeneratorImpl(); - final List genTypes = bindingGen.generateTypes(context); - assertTrue(genTypes != null); - } - - @Test - public void testTypedefEnumResolving() { - final String ianaIfTypePath = getClass().getResource( - "/leafref-test-models/iana-if-type@2012-06-05.yang").getPath(); - - final SchemaContext context = resolveSchemaContextFromFiles(ianaIfTypePath); - assertTrue(context != null); - final BindingGenerator bindingGen = new BindingGeneratorImpl(); - final List genTypes = bindingGen.generateTypes(context); - assertTrue(genTypes != null); - assertEquals(2, genTypes.size()); - - final Type type = genTypes.get(1); - assertTrue(type instanceof GeneratedTransferObject); - - final GeneratedTransferObject genTransObj = (GeneratedTransferObject) type; - final List properties = genTransObj.getProperties(); - assertNotNull(properties); - assertEquals(1, properties.size()); - - GeneratedProperty property = properties.get(0); - assertNotNull(property); - assertNotNull(property.getReturnType()); - - assertTrue(property.getReturnType() instanceof Enumeration); - final Enumeration enumer = (Enumeration) property.getReturnType(); - assertEquals(272, enumer.getValues().size()); - } - @Test public void testMultipleModulesResolving() { - final String topologyPath = getClass().getResource( - "/abstract-topology.yang").getPath(); - final String typesPath = getClass().getResource( - "/ietf-inet-types@2010-09-24.yang").getPath(); - final SchemaContext context = resolveSchemaContextFromFiles( - topologyPath, typesPath); - assertTrue(context != null); + final String topologyPath = getClass().getResource("/abstract-topology.yang").getPath(); + final String typesPath = getClass().getResource("/ietf-inet-types@2010-09-24.yang").getPath(); + final SchemaContext context = resolveSchemaContextFromFiles(topologyPath, typesPath); + assertNotNull(context); final BindingGenerator bindingGen = new BindingGeneratorImpl(); final List genTypes = bindingGen.generateTypes(context); - assertTrue(genTypes != null); - assertEquals(24, genTypes.size()); + assertNotNull(genTypes); + assertEquals(29, genTypes.size()); } @Test public void testLeafrefResolving() { - final String topologyPath = getClass().getResource( - "/leafref-test-models/abstract-topology@2013-02-08.yang") + final String topologyPath = getClass().getResource("/leafref-test-models/abstract-topology@2013-02-08.yang") .getPath(); - final String interfacesPath = getClass().getResource( - "/leafref-test-models/ietf-interfaces@2012-11-15.yang") + final String interfacesPath = getClass().getResource("/leafref-test-models/ietf-interfaces@2012-11-15.yang") .getPath(); // final String ifTypePath = getClass().getResource( // "/leafref-test-models/iana-if-type@2012-06-05.yang").getPath(); - final String inetTypesPath = getClass().getResource( - "/leafref-test-models/ietf-inet-types@2010-09-24.yang") + final String inetTypesPath = getClass().getResource("/leafref-test-models/ietf-inet-types@2010-09-24.yang") .getPath(); - final String yangTypesPath = getClass().getResource( - "/leafref-test-models/ietf-yang-types@2010-09-24.yang") + final String yangTypesPath = getClass().getResource("/leafref-test-models/ietf-yang-types@2010-09-24.yang") .getPath(); - assertTrue(topologyPath != null); - assertTrue(interfacesPath != null); + assertNotNull(topologyPath); + assertNotNull(interfacesPath); // assertTrue(ifTypePath != null); - assertTrue(inetTypesPath != null); - assertTrue(yangTypesPath != null); - - // final SchemaContext context = resolveSchemaContextFromFiles( - // topologyPath, interfacesPath, ifTypePath, inetTypesPath, - // yangTypesPath); - final SchemaContext context = resolveSchemaContextFromFiles( - topologyPath, interfacesPath, inetTypesPath, yangTypesPath); - assertTrue(context != null); + assertNotNull(inetTypesPath); + assertNotNull(yangTypesPath); + + // final SchemaContext context = resolveSchemaContextFromFiles(topologyPath, interfacesPath, ifTypePath, + // inetTypesPath, yangTypesPath); + final SchemaContext context = resolveSchemaContextFromFiles(topologyPath, interfacesPath, inetTypesPath, + yangTypesPath); + assertNotNull(context); assertEquals(4, context.getModules().size()); final BindingGenerator bindingGen = new BindingGeneratorImpl(); final List genTypes = bindingGen.generateTypes(context); - assertEquals(50, genTypes.size()); - assertTrue(genTypes != null); + assertEquals(57, genTypes.size()); + assertNotNull(genTypes); GeneratedTransferObject gtIfcKey = null; GeneratedType gtIfc = null; @@ -150,6 +95,7 @@ public class GeneratedTypesTest { GeneratedType gtDest = null; GeneratedType gtTunnel = null; GeneratedTransferObject gtTunnelKey = null; + GeneratedType gtTopology = null; for (final Type type : genTypes) { String name = type.getName(); if ("InterfaceKey".equals(name)) { @@ -166,6 +112,8 @@ public class GeneratedTypesTest { gtTunnel = (GeneratedType) type; } else if ("TunnelKey".equals(name)) { gtTunnelKey = (GeneratedTransferObject) type; + } else if ("Topology".equals(name)) { + gtTopology = (GeneratedType) type; } } @@ -176,6 +124,21 @@ public class GeneratedTypesTest { assertNotNull(gtDest); assertNotNull(gtTunnel); assertNotNull(gtTunnelKey); + assertNotNull(gtTopology); + + // Topology + final List gtTopoMethods = gtTopology.getMethodDefinitions(); + assertNotNull(gtTopoMethods); + MethodSignature condLeafref = null; + for (final MethodSignature method : gtTopoMethods) { + if (method.getName().equals("getCondLeafref")) { + condLeafref = method; + } + } + assertNotNull(condLeafref); + Type condLeafRT = condLeafref.getReturnType(); + assertNotNull(condLeafRT); + assertEquals("java.lang.Object", condLeafRT.getFullyQualifiedName()); // InterfaceId final List gtIfcKeyProps = gtIfcKey.getProperties(); @@ -189,8 +152,7 @@ public class GeneratedTypesTest { assertNotNull(ifcIdProp); Type ifcIdPropType = ifcIdProp.getReturnType(); assertNotNull(ifcIdPropType); - assertFalse(ifcIdPropType.equals("java.lang.Void")); - assertTrue(ifcIdPropType.getName().equals("String")); + assertEquals("java.lang.String", ifcIdPropType.getFullyQualifiedName()); // Interface final List gtIfcMethods = gtIfc.getMethodDefinitions(); @@ -207,18 +169,17 @@ public class GeneratedTypesTest { assertNotNull(getIfcKey); Type getIfcKeyType = getIfcKey.getReturnType(); assertNotNull(getIfcKeyType); - assertFalse(getIfcKeyType.equals("java.lang.Void")); - assertTrue(getIfcKeyType.getName().equals("InterfaceKey")); + assertNotSame("java.lang.Void", getIfcKeyType); + assertEquals("InterfaceKey", getIfcKeyType.getName()); assertNotNull(getHigherLayerIf); Type getHigherLayerIfType = getHigherLayerIf.getReturnType(); assertNotNull(getHigherLayerIfType); - assertFalse(getHigherLayerIfType.equals("java.lang.Void")); - assertTrue(getHigherLayerIfType.getName().equals("List")); + assertNotSame("java.lang.Void", getHigherLayerIfType); + assertEquals("List", getHigherLayerIfType.getName()); // NetworkLink - final List gtNetworkLinkMethods = gtNetworkLink - .getMethodDefinitions(); + final List gtNetworkLinkMethods = gtNetworkLink.getMethodDefinitions(); assertNotNull(gtNetworkLinkMethods); MethodSignature getIfc = null; for (MethodSignature method : gtNetworkLinkMethods) { @@ -229,12 +190,11 @@ public class GeneratedTypesTest { assertNotNull(getIfc); Type getIfcType = getIfc.getReturnType(); assertNotNull(getIfcType); - assertFalse(getIfcType.equals("java.lang.Void")); - assertTrue(getIfcType.getName().equals("String")); + assertNotSame("java.lang.Void", getIfcType); + assertEquals("String", getIfcType.getName()); // SourceNode - final List gtSourceMethods = gtSource - .getMethodDefinitions(); + final List gtSourceMethods = gtSource.getMethodDefinitions(); assertNotNull(gtSourceMethods); MethodSignature getIdSource = null; for (MethodSignature method : gtSourceMethods) { @@ -245,12 +205,11 @@ public class GeneratedTypesTest { assertNotNull(getIdSource); Type getIdType = getIdSource.getReturnType(); assertNotNull(getIdType); - assertFalse(getIdType.equals("java.lang.Void")); - assertTrue(getIdType.getName().equals("Uri")); + assertNotSame("java.lang.Void", getIdType); + assertEquals("Uri", getIdType.getName()); // DestinationNode - final List gtDestMethods = gtDest - .getMethodDefinitions(); + final List gtDestMethods = gtDest.getMethodDefinitions(); assertNotNull(gtDestMethods); MethodSignature getIdDest = null; for (MethodSignature method : gtDestMethods) { @@ -261,12 +220,11 @@ public class GeneratedTypesTest { assertNotNull(getIdDest); Type getIdDestType = getIdDest.getReturnType(); assertNotNull(getIdDestType); - assertFalse(getIdDestType.equals("java.lang.Void")); - assertTrue(getIdDestType.getName().equals("Uri")); + assertNotSame("java.lang.Void", getIdDestType); + assertEquals("Uri", getIdDestType.getName()); // Tunnel - final List gtTunnelMethods = gtTunnel - .getMethodDefinitions(); + final List gtTunnelMethods = gtTunnel.getMethodDefinitions(); assertNotNull(gtTunnelMethods); MethodSignature getTunnelKey = null; for (MethodSignature method : gtTunnelMethods) { @@ -277,12 +235,11 @@ public class GeneratedTypesTest { assertNotNull(getTunnelKey); Type getTunnelKeyType = getTunnelKey.getReturnType(); assertNotNull(getTunnelKeyType); - assertFalse(getTunnelKeyType.equals("java.lang.Void")); - assertTrue(getTunnelKeyType.getName().equals("TunnelKey")); + assertNotSame("java.lang.Void", getTunnelKeyType); + assertEquals("TunnelKey", getTunnelKeyType.getName()); // TunnelKey - final List gtTunnelKeyProps = gtTunnelKey - .getProperties(); + final List gtTunnelKeyProps = gtTunnelKey.getProperties(); assertNotNull(gtTunnelKeyProps); GeneratedProperty tunnelId = null; for (final GeneratedProperty property : gtTunnelKeyProps) { @@ -293,318 +250,366 @@ public class GeneratedTypesTest { assertNotNull(tunnelId); Type tunnelIdType = tunnelId.getReturnType(); assertNotNull(tunnelIdType); - assertFalse(tunnelIdType.equals("java.lang.Void")); - assertTrue(tunnelIdType.getName().equals("Uri")); + assertNotSame("java.lang.Void", tunnelIdType); + assertEquals("Uri", tunnelIdType.getName()); } @Test public void testContainerResolving() { - final String filePath = getClass().getResource( - "/simple-container-demo.yang").getPath(); + final String filePath = getClass().getResource("/simple-container-demo.yang").getPath(); final SchemaContext context = resolveSchemaContextFromFiles(filePath); - assertTrue(context != null); + assert (context != null); final BindingGenerator bindingGen = new BindingGeneratorImpl(); final List genTypes = bindingGen.generateTypes(context); - assertTrue(genTypes != null); - assertEquals(3, genTypes.size()); + assertNotNull(genTypes); + assertEquals(4, genTypes.size()); - final GeneratedType simpleContainer = (GeneratedType) genTypes.get(0); - final GeneratedType nestedContainer = (GeneratedType) genTypes.get(1); + final GeneratedType simpleContainer = (GeneratedType) genTypes.get(1); + final GeneratedType nestedContainer = (GeneratedType) genTypes.get(2); assertEquals("SimpleContainer", simpleContainer.getName()); assertEquals("NestedContainer", nestedContainer.getName()); - assertEquals(5, simpleContainer.getMethodDefinitions().size()); - assertEquals(4, nestedContainer.getMethodDefinitions().size()); + assertEquals(3, simpleContainer.getMethodDefinitions().size()); + assertEquals(2, nestedContainer.getMethodDefinitions().size()); - int methodsCount = 0; - for (final MethodSignature method : simpleContainer - .getMethodDefinitions()) { - if (method.getName().equals("getFoo")) { - method.getReturnType().getName().equals("Integer"); - methodsCount++; - } + int getFooMethodCounter = 0; + int getBarMethodCounter = 0; + int getNestedContainerCounter = 0; - if (method.getName().equals("setFoo")) { - methodsCount++; - final MethodSignature.Parameter param = method.getParameters() - .get(0); - assertEquals("foo", param.getName()); - assertEquals("Integer", param.getType().getName()); + String getFooMethodReturnTypeName = ""; + String getBarMethodReturnTypeName = ""; + String getNestedContainerReturnTypeName = ""; + for (final MethodSignature method : simpleContainer.getMethodDefinitions()) { + if (method.getName().equals("getFoo")) { + getFooMethodCounter++; + getFooMethodReturnTypeName = method.getReturnType().getName(); } if (method.getName().equals("getBar")) { - method.getReturnType().getName().equals("String"); - methodsCount++; + getBarMethodCounter++; + getBarMethodReturnTypeName = method.getReturnType().getName(); } if (method.getName().equals("getNestedContainer")) { - method.getReturnType().getName().equals("NestedContainer"); - methodsCount++; + getNestedContainerCounter++; + getNestedContainerReturnTypeName = method.getReturnType().getName(); } } - assertEquals(4, methodsCount); - methodsCount = 0; - for (final MethodSignature method : nestedContainer - .getMethodDefinitions()) { - if (method.getName().equals("getFoo")) { - method.getReturnType().getName().equals("Short"); - methodsCount++; - } + assertEquals(1, getFooMethodCounter); + assertEquals("Integer", getFooMethodReturnTypeName); - if (method.getName().equals("setFoo")) { - methodsCount++; - final MethodSignature.Parameter param = method.getParameters() - .get(0); - assertEquals("foo", param.getName()); - assertEquals("Short", param.getType().getName()); - } + assertEquals(1, getBarMethodCounter); + assertEquals("String", getBarMethodReturnTypeName); - if (method.getName().equals("getBar")) { - method.getReturnType().getName().equals("String"); - methodsCount++; + assertEquals(1, getNestedContainerCounter); + assertEquals("NestedContainer", getNestedContainerReturnTypeName); + + getFooMethodCounter = 0; + getBarMethodCounter = 0; + + getFooMethodReturnTypeName = ""; + getBarMethodReturnTypeName = ""; + + for (final MethodSignature method : nestedContainer.getMethodDefinitions()) { + + if (method.getName().equals("getFoo")) { + getFooMethodCounter++; + getFooMethodReturnTypeName = method.getReturnType().getName(); } - if (method.getName().equals("setBar")) { - method.getReturnType().getName().equals("String"); - methodsCount++; + if (method.getName().equals("getBar")) { + getBarMethodCounter++; + getBarMethodReturnTypeName = method.getReturnType().getName(); } } - assertEquals(4, methodsCount); + + assertEquals(1, getFooMethodCounter); + assertEquals("Short", getFooMethodReturnTypeName); + + assertEquals(1, getBarMethodCounter); + assertEquals("String", getBarMethodReturnTypeName); } @Test public void testLeafListResolving() { - final String filePath = getClass().getResource( - "/simple-leaf-list-demo.yang").getPath(); + final String filePath = getClass().getResource("/simple-leaf-list-demo.yang").getPath(); final SchemaContext context = resolveSchemaContextFromFiles(filePath); - assertTrue(context != null); + assertNotNull(context); final BindingGenerator bindingGen = new BindingGeneratorImpl(); final List genTypes = bindingGen.generateTypes(context); - assertTrue(genTypes != null); - assertEquals(3, genTypes.size()); + assertNotNull(genTypes); + assertEquals(4, genTypes.size()); - final GeneratedType simpleContainer = (GeneratedType) genTypes.get(0); - final GeneratedType nestedContainer = (GeneratedType) genTypes.get(1); + final GeneratedType simpleContainer = (GeneratedType) genTypes.get(1); + final GeneratedType nestedContainer = (GeneratedType) genTypes.get(2); assertEquals("SimpleContainer", simpleContainer.getName()); assertEquals("NestedContainer", nestedContainer.getName()); - assertEquals(5, simpleContainer.getMethodDefinitions().size()); - assertEquals(3, nestedContainer.getMethodDefinitions().size()); + assertEquals(3, simpleContainer.getMethodDefinitions().size()); + assertEquals(2, nestedContainer.getMethodDefinitions().size()); - int methodsCount = 0; - for (final MethodSignature method : simpleContainer - .getMethodDefinitions()) { - if (method.getName().equals("getFoo")) { - method.getReturnType().getName().equals("List"); - methodsCount++; - } + int getFooMethodCounter = 0; + int getBarMethodCounter = 0; + int getNestedContainerCounter = 0; - if (method.getName().equals("setFoo")) { - methodsCount++; - final MethodSignature.Parameter param = method.getParameters() - .get(0); - assertEquals("foo", param.getName()); - assertEquals("List", param.getType().getName()); + String getFooMethodReturnTypeName = ""; + String getBarMethodReturnTypeName = ""; + String getNestedContainerReturnTypeName = ""; + for (final MethodSignature method : simpleContainer.getMethodDefinitions()) { + if (method.getName().equals("getFoo")) { + getFooMethodCounter++; + getFooMethodReturnTypeName = method.getReturnType().getName(); } if (method.getName().equals("getBar")) { - method.getReturnType().getName().equals("String"); - methodsCount++; + getBarMethodCounter++; + getBarMethodReturnTypeName = method.getReturnType().getName(); } if (method.getName().equals("getNestedContainer")) { - method.getReturnType().getName().equals("NestedContainer"); - methodsCount++; + getNestedContainerCounter++; + getNestedContainerReturnTypeName = method.getReturnType().getName(); } } - assertEquals(4, methodsCount); - methodsCount = 0; - for (final MethodSignature method : nestedContainer - .getMethodDefinitions()) { - if (method.getName().equals("getFoo")) { - method.getReturnType().getName().equals("Short"); - methodsCount++; - } + assertEquals(1, getFooMethodCounter); + assertEquals("List", getFooMethodReturnTypeName); + + assertEquals(1, getBarMethodCounter); + assertEquals("String", getBarMethodReturnTypeName); + + assertEquals(1, getNestedContainerCounter); + assertEquals("NestedContainer", getNestedContainerReturnTypeName); - if (method.getName().equals("setFoo")) { - methodsCount++; - final MethodSignature.Parameter param = method.getParameters() - .get(0); - assertEquals("foo", param.getName()); - assertEquals("Short", param.getType().getName()); + getFooMethodCounter = 0; + getBarMethodCounter = 0; + + getFooMethodReturnTypeName = ""; + getBarMethodReturnTypeName = ""; + + for (final MethodSignature method : nestedContainer.getMethodDefinitions()) { + if (method.getName().equals("getFoo")) { + getFooMethodCounter++; + getFooMethodReturnTypeName = method.getReturnType().getName(); } if (method.getName().equals("getBar")) { - method.getReturnType().getName().equals("List"); - methodsCount++; + getBarMethodCounter++; + getBarMethodReturnTypeName = method.getReturnType().getName(); } } - assertEquals(3, methodsCount); + + assertEquals(1, getFooMethodCounter); + assertEquals("Short", getFooMethodReturnTypeName); + + assertEquals(1, getBarMethodCounter); + assertEquals("List", getBarMethodReturnTypeName); } @Test public void testListResolving() { - final String filePath = getClass() - .getResource("/simple-list-demo.yang").getPath(); + final String filePath = getClass().getResource("/simple-list-demo.yang").getPath(); final SchemaContext context = resolveSchemaContextFromFiles(filePath); - assertTrue(context != null); + assertNotNull(context); final BindingGenerator bindingGen = new BindingGeneratorImpl(); final List genTypes = bindingGen.generateTypes(context); - assertTrue(genTypes != null); - assertEquals(5, genTypes.size()); + assertNotNull(genTypes); + assertEquals(6, genTypes.size()); + + int listParentContainerMethodsCount = 0; + int simpleListMethodsCount = 0; + int listChildContainerMethodsCount = 0; + int listKeyClassCount = 0; + + int getSimpleListKeyMethodCount = 0; + int getListChildContainerMethodCount = 0; + int getFooMethodCount = 0; + int setFooMethodCount = 0; + int getSimpleLeafListMethodCount = 0; + int setSimpleLeafListMethodCount = 0; + int getBarMethodCount = 0; + + String getSimpleListKeyMethodReturnTypeName = ""; + String getListChildContainerMethodReturnTypeName = ""; + + int listKeyClassPropertyCount = 0; + String listKeyClassPropertyName = ""; + String listKeyClassPropertyTypeName = ""; + boolean listKeyClassPropertyReadOnly = false; + + int hashMethodParameterCount = 0; + String hashMethodParameterName = ""; + String hashMethodParameterReturnTypeName = ""; + + int equalMethodParameterCount = 0; + String equalMethodParameterName = ""; + String equalMethodParameterReturnTypeName = ""; - int genTypesCount = 0; - int genTOsCount = 0; for (final Type type : genTypes) { - if (type instanceof GeneratedType - && !(type instanceof GeneratedTransferObject)) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { final GeneratedType genType = (GeneratedType) type; if (genType.getName().equals("ListParentContainer")) { - assertEquals(2, genType.getMethodDefinitions().size()); - genTypesCount++; + listParentContainerMethodsCount = genType.getMethodDefinitions().size(); } else if (genType.getName().equals("SimpleList")) { - assertEquals(8, genType.getMethodDefinitions().size()); - final List methods = genType - .getMethodDefinitions(); - int methodsCount = 0; + simpleListMethodsCount = genType.getMethodDefinitions().size(); + final List methods = genType.getMethodDefinitions(); for (final MethodSignature method : methods) { if (method.getName().equals("getSimpleListKey")) { - assertEquals("SimpleListKey", method - .getReturnType().getName()); - methodsCount++; - } else if (method.getName().equals( - "getListChildContainer")) { - assertEquals("ListChildContainer", method - .getReturnType().getName()); - methodsCount++; + getSimpleListKeyMethodCount++; + getSimpleListKeyMethodReturnTypeName = method.getReturnType().getName(); + } else if (method.getName().equals("getListChildContainer")) { + getListChildContainerMethodCount++; + getListChildContainerMethodReturnTypeName = method.getReturnType().getName(); } else if (method.getName().equals("getFoo")) { - methodsCount++; + getFooMethodCount++; } else if (method.getName().equals("setFoo")) { - methodsCount++; + setFooMethodCount++; } else if (method.getName().equals("getSimpleLeafList")) { - methodsCount++; + getSimpleLeafListMethodCount++; } else if (method.getName().equals("setSimpleLeafList")) { - methodsCount++; + setSimpleLeafListMethodCount++; } else if (method.getName().equals("getBar")) { - methodsCount++; + getBarMethodCount++; } } - assertEquals(7, methodsCount); - genTypesCount++; } else if (genType.getName().equals("ListChildContainer")) { - assertEquals(2, genType.getMethodDefinitions().size()); - genTypesCount++; + listChildContainerMethodsCount = genType.getMethodDefinitions().size(); } } else if (type instanceof GeneratedTransferObject) { - genTOsCount++; final GeneratedTransferObject genTO = (GeneratedTransferObject) type; - final List properties = genTO - .getProperties(); - final List hashProps = genTO - .getHashCodeIdentifiers(); - final List equalProps = genTO - .getEqualsIdentifiers(); - - assertEquals(1, properties.size()); - assertEquals("ListKey", properties.get(0).getName()); - assertEquals("Byte", properties.get(0).getReturnType() - .getName()); - assertEquals(true, properties.get(0).isReadOnly()); - assertEquals(1, hashProps.size()); - assertEquals("ListKey", hashProps.get(0).getName()); - assertEquals("Byte", hashProps.get(0).getReturnType().getName()); - assertEquals(1, equalProps.size()); - assertEquals("ListKey", equalProps.get(0).getName()); - assertEquals("Byte", equalProps.get(0).getReturnType() - .getName()); + final List properties = genTO.getProperties(); + final List hashProps = genTO.getHashCodeIdentifiers(); + final List equalProps = genTO.getEqualsIdentifiers(); + + listKeyClassCount++; + listKeyClassPropertyCount = properties.size(); + listKeyClassPropertyName = properties.get(0).getName(); + listKeyClassPropertyTypeName = properties.get(0).getReturnType().getName(); + listKeyClassPropertyReadOnly = properties.get(0).isReadOnly(); + + hashMethodParameterCount = hashProps.size(); + hashMethodParameterName = hashProps.get(0).getName(); + hashMethodParameterReturnTypeName = hashProps.get(0).getReturnType().getName(); + + equalMethodParameterCount = equalProps.size(); + equalMethodParameterName = equalProps.get(0).getName(); + equalMethodParameterReturnTypeName = equalProps.get(0).getReturnType().getName(); + } } - assertEquals(3, genTypesCount); - assertEquals(1, genTOsCount); + + assertEquals(1, listParentContainerMethodsCount); + assertEquals(1, listChildContainerMethodsCount); + assertEquals(1, getSimpleListKeyMethodCount); + assertEquals(1, listKeyClassCount); + + assertEquals(1, listKeyClassPropertyCount); + assertEquals("ListKey", listKeyClassPropertyName); + assertEquals("Byte", listKeyClassPropertyTypeName); + assertEquals(true, listKeyClassPropertyReadOnly); + assertEquals(1, hashMethodParameterCount); + assertEquals("ListKey", hashMethodParameterName); + assertEquals("Byte", hashMethodParameterReturnTypeName); + assertEquals(1, equalMethodParameterCount); + assertEquals("ListKey", equalMethodParameterName); + assertEquals("Byte", equalMethodParameterReturnTypeName); + + assertEquals("SimpleListKey", getSimpleListKeyMethodReturnTypeName); + + assertEquals(1, getListChildContainerMethodCount); + assertEquals("ListChildContainer", getListChildContainerMethodReturnTypeName); + assertEquals(1, getFooMethodCount); + assertEquals(0, setFooMethodCount); + assertEquals(1, getSimpleLeafListMethodCount); + assertEquals(0, setSimpleLeafListMethodCount); + assertEquals(1, getBarMethodCount); + + assertEquals(5, simpleListMethodsCount); } @Test public void testListCompositeKeyResolving() { - final String filePath = getClass().getResource( - "/list-composite-key.yang").getPath(); + final String filePath = getClass().getResource("/list-composite-key.yang").getPath(); final SchemaContext context = resolveSchemaContextFromFiles(filePath); - assertTrue(context != null); + assertNotNull(context); final BindingGenerator bindingGen = new BindingGeneratorImpl(); final List genTypes = bindingGen.generateTypes(context); - assertTrue(genTypes != null); - assertEquals(7, genTypes.size()); + assertNotNull(genTypes); + assertEquals(8, genTypes.size()); int genTypesCount = 0; int genTOsCount = 0; + + int compositeKeyListKeyPropertyCount = 0; + int compositeKeyListKeyCount = 0; + int innerListKeyPropertyCount = 0; + for (final Type type : genTypes) { - if (type instanceof GeneratedType - && !(type instanceof GeneratedTransferObject)) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { genTypesCount++; } else if (type instanceof GeneratedTransferObject) { final GeneratedTransferObject genTO = (GeneratedTransferObject) type; if (genTO.getName().equals("CompositeKeyListKey")) { - final List properties = genTO - .getProperties(); - int propertyCount = 0; + compositeKeyListKeyCount++; + final List properties = genTO.getProperties(); for (final GeneratedProperty prop : properties) { if (prop.getName().equals("Key1")) { - propertyCount++; + compositeKeyListKeyPropertyCount++; } else if (prop.getName().equals("Key2")) { - propertyCount++; + compositeKeyListKeyPropertyCount++; } } - assertEquals(2, propertyCount); genTOsCount++; } else if (genTO.getName().equals("InnerListKey")) { - final List properties = genTO - .getProperties(); - assertEquals(1, properties.size()); + final List properties = genTO.getProperties(); + innerListKeyPropertyCount = properties.size(); genTOsCount++; } } } + assertEquals(1, compositeKeyListKeyCount); + assertEquals(2, compositeKeyListKeyPropertyCount); + + assertEquals(1, innerListKeyPropertyCount); - assertEquals(5, genTypesCount); + assertEquals(6, genTypesCount); assertEquals(2, genTOsCount); } @Test public void testGeneratedTypes() { - final String filePath = getClass().getResource("/demo-topology.yang") - .getPath(); + final String filePath = getClass().getResource("/demo-topology.yang").getPath(); final SchemaContext context = resolveSchemaContextFromFiles(filePath); - assertTrue(context != null); + assertNotNull(context); final BindingGenerator bindingGen = new BindingGeneratorImpl(); final List genTypes = bindingGen.generateTypes(context); - assertTrue(genTypes != null); - assertEquals(14, genTypes.size()); + assertNotNull(genTypes); + assertEquals(15, genTypes.size()); int genTypesCount = 0; int genTOsCount = 0; for (final Type type : genTypes) { - if (type instanceof GeneratedType - && !(type instanceof GeneratedTransferObject)) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { genTypesCount++; } else if (type instanceof GeneratedTransferObject) { genTOsCount++; } } - assertEquals(11, genTypesCount); + assertEquals(12, genTypesCount); assertEquals(3, genTOsCount); } }