+++ /dev/null
-/*
- * 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<String, String> resolveRegExpressions(final List<PatternConstraint> 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);
- }
-}
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;
*/
@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<GeneratedType> TYPES;
@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;
@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());
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<MethodSignature> 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;
+ }
}
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;
/**
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);
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);
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);
- }
}
Code Review / mdsal.git / commitdiff