private final Map<String, Map<Optional<Revision>, Map<String, GeneratedType>>> genTypeDefsContextMap =
new HashMap<>();
-
- /**
- * The map which maps schema paths to JAVA <code>Type</code>.
- */
- private final Map<SchemaPath, Type> referencedTypes = new HashMap<>();
private final Map<Module, Set<GeneratedType>> additionalTypes = new HashMap<>();
/**
resolveTypeDefsFromContext();
}
- /**
- * Puts <code>refType</code> to map with key <code>refTypePath</code>.
- *
- * @param refTypePath schema path used as the map key
- * @param refType type which represents the map value
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>refTypePath</code> equal null</li>
- * <li>if <code>refType</code> equal null</li>
- * </ul>
- *
- */
- public void putReferencedType(final SchemaPath refTypePath, final Type refType) {
- Preconditions.checkArgument(refTypePath != null,
- "Path reference of Enumeration Type Definition cannot be NULL!");
- Preconditions.checkArgument(refType != null, "Reference to Enumeration Type cannot be NULL!");
- referencedTypes.put(refTypePath, refType);
- }
-
public Map<Module, Set<GeneratedType>> getAdditionalTypes() {
return additionalTypes;
}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2021 PANTHEON.tech, s.r.o.
+ *
+ * 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.generator.impl;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+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.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
+import org.opendaylight.mdsal.binding.model.ri.Types;
+import org.opendaylight.mdsal.binding.yang.types.TypeProviderTest;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
+
+/**
+ * General test suite revolving around {@link DefaultBindingGenerator}. This class holds tests originally aimed at
+ * specific implementation methods, but now they really are all about integration testing.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class DefaultBindingGeneratorTest {
+ 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 EffectiveModelContext SCHEMA_CONTEXT;
+ public static List<GeneratedType> TYPES;
+
+ @BeforeClass
+ public static void beforeClass() {
+ SCHEMA_CONTEXT = YangParserTestUtils.parseYangResources(TypeProviderTest.class,
+ "/base-yang-types.yang", "/test-type-provider-b.yang", "/test-type-provider.yang");
+ TYPES = DefaultBindingGenerator.generateFor(SCHEMA_CONTEXT);
+ }
+
+ @AfterClass
+ public static void afterClass() {
+ SCHEMA_CONTEXT = null;
+ TYPES = null;
+ }
+
+ @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 bDataMethods = bData.getMethodDefinitions();
+ assertEquals(8, bDataMethods.size());
+
+ final var bEnumType = bDataMethods.stream()
+ .filter(method -> method.getName().equals("getEnum"))
+ .findFirst()
+ .orElseThrow()
+ .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();
+
+ assertThat(bEnumsType, instanceOf(ParameterizedType.class));
+ final var enumsType = (ParameterizedType) bEnumsType;
+
+ assertEquals(Types.typeForClass(List.class), enumsType.getRawType());
+ final var enumsTypeArgs = enumsType.getActualTypeArguments();
+ assertEquals(1, enumsTypeArgs.length);
+ assertEquals(TEST_TYPE_PROVIDER + ".Foo.ListOfEnums", enumsTypeArgs[0].getFullyQualifiedName());
+ }
+}
assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
}
- @Test
- public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() {
- final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
-
- setReferencedTypeForTypeProvider(provider);
-
- final Module module = resolveModule("test-type-provider-b");
-
- final QName leafNode = QName.create(module.getQNameModule(), "enum");
- final DataSchemaNode enumNode = module.findDataChildByName(leafNode).get();
- assertTrue(enumNode instanceof LeafSchemaNode);
- final LeafSchemaNode leaf = (LeafSchemaNode) enumNode;
- final TypeDefinition<?> leafType = leaf.getType();
-
- final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
- assertNotNull(leafrefResolvedType1);
-
- final QName leafListNode = QName.create(module.getQNameModule(), "enums");
- final DataSchemaNode enumListNode = module.findDataChildByName(leafListNode).get();
- assertTrue(enumListNode instanceof LeafListSchemaNode);
- final LeafListSchemaNode leafList = (LeafListSchemaNode) enumListNode;
- final TypeDefinition<?> leafListType = leafList.getType();
-
- final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafListType, leafList);
- assertNotNull(leafrefResolvedType2);
- assertTrue(leafrefResolvedType2 instanceof ParameterizedType);
- }
-
- private static void setReferencedTypeForTypeProvider(final AbstractTypeProvider provider) {
- final LeafSchemaNode enumLeafNode = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
- "resolve-direct-use-of-enum");
- final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
- provider.putReferencedType(enumLeafNode.getPath(),
- Type.of(provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode)));
-
- final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(TEST_TYPE_PROVIDER,
- "foo", "list-of-enums");
- final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
- provider.putReferencedType(enumListNode.getPath(),
- Type.of(provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode)));
- }
-
@Test
public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
leaf conditional-leafref {
type leafref {
- path "/prov:foo/prov:bars/prov:bar-item[prov:id=current()/../id]";
+ path "/prov:foo/prov:bars/prov:bar-item[prov:id=current()/../id]/prov:id";
}
}
- leaf unreslovable-leafref {
- type leafref {
- path "/somewhere/i/bellong";
+ grouping grp {
+ // This has to be in a grouping, otherwise we'll just reject it
+ leaf unresolvable-leafref {
+ type leafref {
+ path "/somewhere/i/bellong";
+ }
}
}
}
Code Review / mdsal.git / commitdiff