From fddbed976d929d48d703fe4c7de33a77c41964f1 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Sat, 16 Oct 2021 13:55:10 +0200 Subject: [PATCH] Remove RuntimeTypeProvider Migrate all disabled tests which rely on it and remove it. This increases our assertion coverage and reduces the amount of code we lug around. Change-Id: I5ecd83b953f021786a7fb9bd8a228c67e528ea7b Signed-off-by: Robert Varga --- .../yang/types/RuntimeTypeProvider.java | 65 ----- .../impl/DefaultBindingGeneratorTest.java | 179 ++++++++++-- .../binding/yang/types/TypeProviderTest.java | 254 ------------------ 3 files changed, 150 insertions(+), 348 deletions(-) delete mode 100644 binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/yang/types/RuntimeTypeProvider.java diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/yang/types/RuntimeTypeProvider.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/yang/types/RuntimeTypeProvider.java deleted file mode 100644 index a0ea7ad874..0000000000 --- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/yang/types/RuntimeTypeProvider.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright (c) 2018 Pantheon Technologies, s.r.o. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.mdsal.binding.yang.types; - -import com.google.common.annotations.VisibleForTesting; -import com.google.common.collect.ImmutableMap; -import java.util.List; -import java.util.Map; -import org.opendaylight.mdsal.binding.model.api.JavaTypeName; -import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder; -import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder; -import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder; -import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase; -import org.opendaylight.mdsal.binding.model.ri.generated.type.builder.AbstractEnumerationBuilder; -import org.opendaylight.mdsal.binding.model.ri.generated.type.builder.RuntimeEnumerationBuilder; -import org.opendaylight.mdsal.binding.model.ri.generated.type.builder.RuntimeGeneratedTOBuilder; -import org.opendaylight.mdsal.binding.model.ri.generated.type.builder.RuntimeGeneratedTypeBuilder; -import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; -import org.opendaylight.yangtools.yang.model.api.TypeDefinition; -import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition; -import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; - -// FIXME: remove this class -@Deprecated(forRemoval = true) -final class RuntimeTypeProvider extends AbstractTypeProvider { - @VisibleForTesting - RuntimeTypeProvider(final EffectiveModelContext schemaContext) { - super(schemaContext); - } - - @Override - public void addEnumDescription(final EnumBuilder enumBuilder, final EnumTypeDefinition enumTypeDef) { - // No-op - } - - @Override - void addCodegenInformation(final GeneratedTypeBuilderBase genTOBuilder, final TypeDefinition typeDef) { - // No-op - } - - @Override - public Map resolveRegExpressions(final List patternConstraints) { - return ImmutableMap.of(); - } - - @Override - public GeneratedTOBuilder newGeneratedTOBuilder(final JavaTypeName identifier) { - return new RuntimeGeneratedTOBuilder(identifier); - } - - @Override - public GeneratedTypeBuilder newGeneratedTypeBuilder(final JavaTypeName identifier) { - return new RuntimeGeneratedTypeBuilder(identifier); - } - - @Override - public AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) { - return new RuntimeEnumerationBuilder(identifier); - } -} diff --git a/binding/mdsal-binding-generator/src/test/java/org/opendaylight/mdsal/binding/generator/impl/DefaultBindingGeneratorTest.java b/binding/mdsal-binding-generator/src/test/java/org/opendaylight/mdsal/binding/generator/impl/DefaultBindingGeneratorTest.java index 45a3165acb..98792e377e 100644 --- a/binding/mdsal-binding-generator/src/test/java/org/opendaylight/mdsal/binding/generator/impl/DefaultBindingGeneratorTest.java +++ b/binding/mdsal-binding-generator/src/test/java/org/opendaylight/mdsal/binding/generator/impl/DefaultBindingGeneratorTest.java @@ -19,8 +19,10 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.junit.MockitoJUnitRunner; import org.opendaylight.mdsal.binding.model.api.Enumeration; +import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject; import org.opendaylight.mdsal.binding.model.api.GeneratedType; import org.opendaylight.mdsal.binding.model.api.JavaTypeName; +import org.opendaylight.mdsal.binding.model.api.MethodSignature; import org.opendaylight.mdsal.binding.model.api.ParameterizedType; import org.opendaylight.mdsal.binding.model.ri.Types; import org.opendaylight.mdsal.binding.yang.types.TypeProviderTest; @@ -33,10 +35,15 @@ import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; */ @RunWith(MockitoJUnitRunner.class) public class DefaultBindingGeneratorTest { + public static final String BASE_YANG_TYPES = + "org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914"; public static final String TEST_TYPE_PROVIDER = "org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912"; public static final String TEST_TYPE_PROVIDER_B = "org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.b.model.rev140915"; + public static final JavaTypeName CONSTRUCTION_TYPE_TEST = + JavaTypeName.create(TEST_TYPE_PROVIDER, "ConstructionTypeTest"); + public static EffectiveModelContext SCHEMA_CONTEXT; public static List TYPES; @@ -55,28 +62,15 @@ public class DefaultBindingGeneratorTest { @Test public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() { - final var bDataName = JavaTypeName.create(TEST_TYPE_PROVIDER_B, "TestTypeProviderBData"); - final var bData = TYPES.stream() - .filter(type -> type.getIdentifier().equals(bDataName)) - .findFirst() - .orElseThrow(); - + final var bData = assertGeneratedType(JavaTypeName.create(TEST_TYPE_PROVIDER_B, "TestTypeProviderBData")); final var bDataMethods = bData.getMethodDefinitions(); assertEquals(8, bDataMethods.size()); - final var bEnumType = bDataMethods.stream() - .filter(method -> method.getName().equals("getEnum")) - .findFirst() - .orElseThrow() - .getReturnType(); + final var bEnumType = assertGeneratedMethod(bDataMethods, "getEnum").getReturnType(); assertThat(bEnumType, instanceOf(Enumeration.class)); assertEquals(TEST_TYPE_PROVIDER + ".Foo.ResolveDirectUseOfEnum", bEnumType.getFullyQualifiedName()); - final var bEnumsType = bDataMethods.stream() - .filter(method -> method.getName().equals("getEnums")) - .findFirst() - .orElseThrow() - .getReturnType(); + final var bEnumsType = assertGeneratedMethod(bDataMethods, "getEnums").getReturnType(); assertThat(bEnumsType, instanceOf(ParameterizedType.class)); final var enumsType = (ParameterizedType) bEnumsType; @@ -89,19 +83,7 @@ public class DefaultBindingGeneratorTest { @Test public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() { - final var cttName = JavaTypeName.create(TEST_TYPE_PROVIDER, "ConstructionTypeTest"); - final var ctt = TYPES.stream() - .filter(type -> type.getIdentifier().equals(cttName)) - .findFirst() - .orElseThrow(); - - final var methods = ctt.getMethodDefinitions(); - assertEquals(56, methods.size()); - - final var type = methods.stream().filter(method -> method.getName().equals("getAesIdentityrefType")) - .findFirst() - .orElseThrow() - .getReturnType(); + final var type = assertGeneratedMethod(CONSTRUCTION_TYPE_TEST, "getAesIdentityrefType").getReturnType(); assertThat(type, instanceOf(ParameterizedType.class)); final var pType = (ParameterizedType) type; assertEquals(Types.CLASS, pType.getRawType()); @@ -109,4 +91,143 @@ public class DefaultBindingGeneratorTest { assertEquals(1, pTypeArgs.length); assertEquals(TEST_TYPE_PROVIDER + ".Aes", pTypeArgs[0].getFullyQualifiedName()); } + + @Test + public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() { + final var type = assertGeneratedMethod(CONSTRUCTION_TYPE_TEST, "getBarId").getReturnType(); + assertThat(type, instanceOf(GeneratedTransferObject.class)); + final var gto = (GeneratedTransferObject) type; + assertEquals(JavaTypeName.create(BASE_YANG_TYPES, "YangInt16"), gto.getIdentifier()); + } + + @Test + public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() { + assertGTO(JavaTypeName.create(TEST_TYPE_PROVIDER, "ExtendedYangInt8")); + } + + @Test + public void generatedTypeForExtendedDefinitionTypeTest() { + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangBoolean")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangEmpty")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInt8")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInt8Restricted")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInt16")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInt32")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInt64")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangString")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangDecimal64")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangUint8")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangUint16")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangUint32")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangUint64")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangUnion")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangBinary")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInstanceIdentifier")); + assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangBits")); + assertEnumeration(JavaTypeName.create(BASE_YANG_TYPES, "YangEnumeration")); + } + + @Test + public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() { + final var gto = assertGTO(JavaTypeName.create(TEST_TYPE_PROVIDER, "ComplexUnion")); + assertEquals(3, gto.getProperties().size()); + assertEquals(List.of(), gto.getEnumerations()); + final var enclosed = gto.getEnclosedTypes(); + assertEquals(1, enclosed.size()); + + final var union1 = enclosed.get(0); + assertThat(union1, instanceOf(GeneratedTransferObject.class)); + assertEquals(TEST_TYPE_PROVIDER + ".ComplexUnion.ComplexUnion$1", union1.getFullyQualifiedName()); + assertEquals(1, union1.getProperties().size()); + assertEquals(List.of(), union1.getEnclosedTypes()); + + final var enums = union1.getEnumerations(); + assertEquals(1, enums.size()); + assertEquals(TEST_TYPE_PROVIDER + ".ComplexUnion.ComplexUnion$1.Enumeration", + enums.get(0).getFullyQualifiedName()); + } + + @Test + public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() { + final var gto = assertGTO(JavaTypeName.create(TEST_TYPE_PROVIDER, "ComplexStringIntUnion")); + assertEquals(2, gto.getProperties().size()); + assertEquals(List.of(), gto.getEnumerations()); + assertEquals(List.of(), gto.getEnclosedTypes()); + } + + @Test + public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() { + final var type = assertGeneratedMethod( + JavaTypeName.create(TEST_TYPE_PROVIDER, "UseOfUnions"), "getSimpleIntTypesUnion").getReturnType(); + assertThat(type, instanceOf(GeneratedTransferObject.class)); + assertEquals(JavaTypeName.create(BASE_YANG_TYPES, "YangUnion"), type.getIdentifier()); + } + + @Test + public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() { + final var type = assertGeneratedMethod( + JavaTypeName.create(TEST_TYPE_PROVIDER, "UseOfUnions"), "getComplexStringIntUnion").getReturnType(); + assertThat(type, instanceOf(GeneratedTransferObject.class)); + assertEquals(JavaTypeName.create(TEST_TYPE_PROVIDER, "ComplexStringIntUnion"), type.getIdentifier()); + } + + @Test + public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() { + final var type = assertGeneratedMethod( + JavaTypeName.create(TEST_TYPE_PROVIDER, "UseOfUnions"), "getComplexUnion").getReturnType(); + assertThat(type, instanceOf(GeneratedTransferObject.class)); + assertEquals(JavaTypeName.create(TEST_TYPE_PROVIDER, "ComplexUnion"), type.getIdentifier()); + } + + @Test + public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() { + final var type = assertGeneratedMethod(JavaTypeName.create(TEST_TYPE_PROVIDER, "Foo"), "getCrypto") + .getReturnType(); + assertThat(type, instanceOf(ParameterizedType.class)); + final var param = (ParameterizedType) type; + assertEquals(JavaTypeName.create(Class.class), param.getIdentifier()); + final var params = param.getActualTypeArguments(); + assertEquals(1, params.length); + assertEquals(Types.wildcardTypeFor(JavaTypeName.create(TEST_TYPE_PROVIDER, "CryptoAlg")), params[0]); + } + + @Test + public void javaTypeForSchemaDefinitionEmptyStringPatternTypeTest() { + final var restrictions = assertGTO(JavaTypeName.create(TEST_TYPE_PROVIDER, "EmptyPatternString")) + .getRestrictions(); + final var patterns = restrictions.getPatternConstraints(); + assertEquals(1, patterns.size()); + final var pattern = patterns.get(0); + assertEquals("", pattern.getRegularExpressionString()); + assertEquals("^(?:)$", pattern.getJavaPatternString()); + } + + private static MethodSignature assertGeneratedMethod(final JavaTypeName typeName, final String methodName) { + return assertGeneratedMethod(assertGeneratedType(typeName).getMethodDefinitions(), methodName); + } + + private static MethodSignature assertGeneratedMethod(final List methods, final String name) { + return methods.stream().filter(method -> name.equals(method.getName())) + .findFirst() + .orElseThrow(() -> new AssertionError("Method " + name + " not present")); + } + + private static GeneratedType assertGeneratedType(final JavaTypeName name) { + return TYPES.stream() + .filter(type -> name.equals(type.getIdentifier())) + .findFirst() + .orElseThrow(() -> new AssertionError("Generated type " + name + " not present")); + } + + private static Enumeration assertEnumeration(final JavaTypeName name) { + final var type = assertGeneratedType(name); + assertThat(type, instanceOf(Enumeration.class)); + return (Enumeration) type; + } + + private static GeneratedTransferObject assertGTO(final JavaTypeName name) { + final var type = assertGeneratedType(name); + assertThat(type, instanceOf(GeneratedTransferObject.class)); + return (GeneratedTransferObject) type; + } } diff --git a/binding/mdsal-binding-generator/src/test/java/org/opendaylight/mdsal/binding/yang/types/TypeProviderTest.java b/binding/mdsal-binding-generator/src/test/java/org/opendaylight/mdsal/binding/yang/types/TypeProviderTest.java index 26cdb2ceaf..d3109f131a 100644 --- a/binding/mdsal-binding-generator/src/test/java/org/opendaylight/mdsal/binding/yang/types/TypeProviderTest.java +++ b/binding/mdsal-binding-generator/src/test/java/org/opendaylight/mdsal/binding/yang/types/TypeProviderTest.java @@ -25,24 +25,18 @@ import org.opendaylight.mdsal.binding.generator.BindingGeneratorUtil; import org.opendaylight.mdsal.binding.model.api.ConcreteType; import org.opendaylight.mdsal.binding.model.api.Enumeration; import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject; -import org.opendaylight.mdsal.binding.model.api.JavaTypeName; -import org.opendaylight.mdsal.binding.model.api.ParameterizedType; import org.opendaylight.mdsal.binding.model.api.Restrictions; import org.opendaylight.mdsal.binding.model.api.Type; -import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder; -import org.opendaylight.mdsal.binding.spec.naming.BindingMapping; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; -import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint; -import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition; import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; /** @@ -94,19 +88,6 @@ public class TypeProviderTest { return (LeafSchemaNode) node; } - private static LeafListSchemaNode provideLeafListNodeFromTopLevelContainer(final Module module, - final String containerName, final String leafListNodeName) { - final QName containerNode = QName.create(module.getQNameModule(), containerName); - final DataSchemaNode rootNode = module.findDataChildByName(containerNode).get(); - assertTrue(rootNode instanceof DataNodeContainer); - - final DataNodeContainer rootContainer = (DataNodeContainer) rootNode; - final QName leafListNode = QName.create(module.getQNameModule(), leafListNodeName); - final DataSchemaNode node = rootContainer.findDataChildByName(leafListNode).get(); - assertTrue(node instanceof LeafListSchemaNode); - return (LeafListSchemaNode) node; - } - @Test public void javaTypeForSchemaDefinitionExtTypeTest() { final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT); @@ -152,36 +133,6 @@ public class TypeProviderTest { assertEquals((byte) 100, constraint.upperEndpoint()); } - @Test - public void javaTypeForSchemaDefinitionEmptyStringPatternTypeTest() { - final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT); - - final Module testTypeProvider = resolveModule("test-type-provider"); - final TypeDefinition emptyPatternString = resolveTypeDefinitionFromModule(testTypeProvider, - "empty-pattern-string"); - - assertNotNull(emptyPatternString); - final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(emptyPatternString); - - Type result = provider.javaTypeForSchemaDefinitionType(emptyPatternString, emptyPatternString, restrictions); - assertNotNull(result); - assertTrue(result instanceof GeneratedTransferObject); - - result = provider.generatedTypeForExtendedDefinitionType(emptyPatternString, emptyPatternString); - assertNotNull(result); - assertTrue(result instanceof GeneratedTransferObject); - } - - private static TypeDefinition resolveTypeDefinitionFromModule(final Module module, final String typedefName) { - TypeDefinition result = null; - for (final TypeDefinition typedef : module.getTypeDefinitions()) { - if (typedef.getQName().getLocalName().equals(typedefName)) { - result = typedef; - } - } - return result; - } - @Test public void javaTypeForSchemaDefinitionEnumExtTypeTest() { final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT); @@ -262,209 +213,4 @@ public class TypeProviderTest { provider.javaTypeForSchemaDefinitionType(leafType, leaf); } - - @Test - public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() { - final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT); - final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "crypto"); - final TypeDefinition leafType = leaf.getType(); - - final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf); - assertNotNull(result); - assertTrue(result instanceof ParameterizedType); - } - - @Test - public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() { - final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT); - final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions", - "simple-int-types-union"); - final TypeDefinition leafType = leaf.getType(); - - final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf); - assertNotNull(result); - assertTrue(result instanceof GeneratedTransferObject); - assertEquals("YangUnion", result.getName()); - //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition - } - - @Test - public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() { - final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT); - final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions", - "complex-union"); - final TypeDefinition leafType = leaf.getType(); - - final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf); - assertNotNull(result); - assertTrue(result instanceof GeneratedTransferObject); - assertEquals("ComplexUnion", result.getName()); - //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition - } - - @Test - public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() { - final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT); - final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions", - "complex-string-int-union"); - final TypeDefinition leafType = leaf.getType(); - - final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf); - assertNotNull(result); - assertTrue(result instanceof GeneratedTransferObject); - assertEquals("ComplexStringIntUnion", result.getName()); - //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition - } - - @Test - public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() { - final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT); - - final TypeDefinition unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER, "complex-union"); - - assertNotNull(unionTypeDef); - assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition); - GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef( - JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())), - (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef); - - assertNotNull(unionTypeBuilder); - - GeneratedTransferObject unionType = unionTypeBuilder.build(); - assertEquals("ComplexUnion", unionType.getName()); - } - - @Test - public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() { - final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT); - - final TypeDefinition unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER, - "complex-string-int-union"); - - assertNotNull(unionTypeDef); - assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition); - final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef( - JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())), - (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef); - - assertNotNull(unionTypeBuilder); - - final GeneratedTransferObject unionType = unionTypeBuilder.build(); - assertEquals("ComplexStringIntUnion", unionType.getName()); - } - - @Test - public void generatedTypeForExtendedDefinitionTypeTest() { - final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT); - - final Module baseYangTypes = resolveModule("base-yang-types"); - - Type yangBoolean = null; - Type yangEmpty = null; - Type yangEnumeration = null; - Type yangInt8 = null; - Type yangInt8Restricted = null; - Type yangInt16 = null; - Type yangInt32 = null; - Type yangInt64 = null; - Type yangString = null; - Type yangDecimal = null; - Type yangUint8 = null; - Type yangUint16 = null; - Type yangUint32 = null; - Type yangUint64 = null; - Type yangUnion = null; - Type yangBinary = null; - Type yangBits = null; - Type yangInstanceIdentifier = null; - - for (final TypeDefinition typedef : baseYangTypes.getTypeDefinitions()) { - final Type type = provider.generatedTypeForExtendedDefinitionType(typedef, typedef); - if (type instanceof GeneratedTransferObject) { - if (type.getName().equals("YangBoolean")) { - yangBoolean = type; - } else if (type.getName().equals("YangEmpty")) { - yangEmpty = type; - } else if (type.getName().equals("YangInt8")) { - yangInt8 = type; - } else if (type.getName().equals("YangInt8Restricted")) { - yangInt8Restricted = type; - } else if (type.getName().equals("YangInt16")) { - yangInt16 = type; - } else if (type.getName().equals("YangInt32")) { - yangInt32 = type; - } else if (type.getName().equals("YangInt64")) { - yangInt64 = type; - } else if (type.getName().equals("YangString")) { - yangString = type; - } else if (type.getName().equals("YangDecimal64")) { - yangDecimal = type; - } else if (type.getName().equals("YangUint8")) { - yangUint8 = type; - } else if (type.getName().equals("YangUint16")) { - yangUint16 = type; - } else if (type.getName().equals("YangUint32")) { - yangUint32 = type; - } else if (type.getName().equals("YangUint64")) { - yangUint64 = type; - } else if (type.getName().equals("YangUnion")) { - yangUnion = type; - } else if (type.getName().equals("YangBinary")) { - yangBinary = type; - } else if (type.getName().equals("YangInstanceIdentifier")) { - yangInstanceIdentifier = type; - } else if (type.getName().equals("YangBits")) { - yangBits = type; - } - } else if (type instanceof Enumeration) { - if (type.getName().equals("YangEnumeration")) { - yangEnumeration = type; - } - } - } - - assertNotNull(yangBoolean); - assertNotNull(yangEmpty); - assertNotNull(yangEnumeration); - assertNotNull(yangInt8); - assertNotNull(yangInt8Restricted); - assertNotNull(yangInt16); - assertNotNull(yangInt32); - assertNotNull(yangInt64); - assertNotNull(yangString); - assertNotNull(yangDecimal); - assertNotNull(yangUint8); - assertNotNull(yangUint16); - assertNotNull(yangUint32); - assertNotNull(yangUint64); - assertNotNull(yangUnion); - assertNotNull(yangBinary); - assertNotNull(yangBits); - assertNotNull(yangInstanceIdentifier); - } - - @Test - public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() { - final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT); - - final Module baseYangTypes = resolveModule("test-type-provider"); - final TypeDefinition extYangInt8Typedef = resolveTypeDefinitionFromModule(baseYangTypes, - "extended-yang-int8"); - assertNotNull(extYangInt8Typedef); - final Type extType = provider.generatedTypeForExtendedDefinitionType(extYangInt8Typedef, extYangInt8Typedef); - assertNotNull(extType); - assertTrue(extType instanceof GeneratedTransferObject); - } - - @Test - public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() { - final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT); - - final Module baseYangTypes = resolveModule("test-type-provider"); - final TypeDefinition barItemLeafrefId = resolveTypeDefinitionFromModule(baseYangTypes, - "bar-item-leafref-id"); - assertNotNull(barItemLeafrefId); - final Type extType = provider.generatedTypeForExtendedDefinitionType(barItemLeafrefId, barItemLeafrefId); - assertEquals(null, extType); - } } -- 2.36.6