--- /dev/null
+/*
+ * Copyright (c) 2017 Cisco Systems, Inc. and others. 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.javav2.generator.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.FileNotFoundException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.junit.Test;
+import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
+import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
+import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
+import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
+import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
+import org.opendaylight.mdsal.binding.javav2.model.api.Constant;
+import org.opendaylight.mdsal.binding.javav2.model.api.Type;
+import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder;
+import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTOBuilder;
+import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
+import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
+
+public class AuxiliaryGenUtilsTest {
+
+ @SuppressWarnings("unchecked")
+ @Test(expected = UnsupportedOperationException.class)
+ public void constructorTest() throws Throwable {
+ final Constructor<AuxiliaryGenUtils> constructor =
+ (Constructor<AuxiliaryGenUtils>) AuxiliaryGenUtils.class.getDeclaredConstructors()[0];
+ constructor.setAccessible(true);
+ final Object[] objs = {};
+ try {
+ constructor.newInstance(objs);
+ } catch (final Exception e) {
+ throw e.getCause();
+ }
+ }
+
+ @SuppressWarnings("rawtypes")
+ @Test
+ public void annotateDeprecatedIfNecessaryNonDepricatedTest() throws Exception {
+ final Class[] parameterTypes = { Status.class, GeneratedTypeBuilder.class };
+ final Method generate =
+ AuxiliaryGenUtils.class.getDeclaredMethod("annotateDeprecatedIfNecessary", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final GeneratedTypeBuilderImpl generatedTypeBuilder =
+ new GeneratedTypeBuilderImpl("test.deprecated", "Non_Deprecated");
+ final Status status = Status.CURRENT;
+
+ final Object[] args = { status, generatedTypeBuilder };
+ generate.invoke(AuxiliaryGenUtils.class, args);
+ assertTrue(generatedTypeBuilder.toInstance().getAnnotations().isEmpty());
+ }
+
+ @SuppressWarnings("rawtypes")
+ @Test
+ public void annotateDeprecatedIfNecessaryDepricatedTest() throws Exception {
+ final Class[] parameterTypes = { Status.class, GeneratedTypeBuilder.class };
+ final Method generate =
+ AuxiliaryGenUtils.class.getDeclaredMethod("annotateDeprecatedIfNecessary", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final GeneratedTypeBuilderImpl generatedTypeBuilder =
+ new GeneratedTypeBuilderImpl("test.deprecated", "Deprecated");
+ final Status status = Status.DEPRECATED;
+
+ final Object[] args = { status, generatedTypeBuilder };
+ generate.invoke(AuxiliaryGenUtils.class, args);
+ assertTrue(!generatedTypeBuilder.toInstance().getAnnotations().isEmpty());
+ assertEquals("Deprecated", generatedTypeBuilder.toInstance().getAnnotations().get(0).getName());
+ }
+
+ @Test
+ public void hasBuilderClassFalseTest() throws Exception {
+ assertEquals(false, hasBuilderClass(LeafSchemaNode.class));
+ }
+
+ @Test
+ public void hasBuilderClassContainerTest() throws Exception {
+ assertEquals(true, hasBuilderClass(ContainerSchemaNode.class));
+ }
+
+ @Test
+ public void hasBuilderClassListTest() throws Exception {
+ assertEquals(true, hasBuilderClass(ListSchemaNode.class));
+ }
+
+ @Test
+ public void hasBuilderClassRpcTest() throws Exception {
+ assertEquals(true, hasBuilderClass(RpcDefinition.class));
+ }
+
+ @Test
+ public void hasBuilderClassNotificationTest() throws Exception {
+ assertEquals(true, hasBuilderClass(NotificationDefinition.class));
+ }
+
+ @SuppressWarnings("rawtypes")
+ @Test
+ public void qNameConstantTest() throws Exception {
+ final Class[] parameterTypes = { GeneratedTypeBuilderBase.class, String.class, QName.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("qNameConstant", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final GeneratedTypeBuilderBase gtbb = new GeneratedTypeBuilderImpl("test", "qname_constants");
+ final String constantName = "ConstantName";
+ final QName constantQName = QName.create("urn:constant", "2017-04-06", constantName);
+
+ final Object[] args = { gtbb, constantName, constantQName };
+ final Constant result = (Constant) generate.invoke(AuxiliaryGenUtils.class, args);
+ assertEquals(constantName, result.getName());
+ }
+
+ @SuppressWarnings("rawtypes")
+ @Test
+ public void constructGetterTest() throws Exception {
+ final Class[] parameterTypes =
+ { GeneratedTypeBuilder.class, String.class, String.class, Type.class, Status.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("constructGetter", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl("test", "Getter_of");
+ final String schemaNodeName = "schema_node_getter";
+ final String comment = null;
+ final Type returnType = Types.STRING;
+ final Status status = Status.DEPRECATED;
+
+ final Object[] args = { gtb, schemaNodeName, comment, returnType, status };
+ final MethodSignatureBuilder result = (MethodSignatureBuilder) generate.invoke(AuxiliaryGenUtils.class, args);
+ assertEquals(new StringBuilder("get").append("SchemaNodeGetter").toString(),
+ result.toInstance(returnType).getName());
+ }
+
+ @Test
+ public void getterMethodNameBooleanTest() throws Exception {
+ assertEquals("isBooleanMethod", getterMethodName("boolean_method", Types.BOOLEAN));
+ }
+
+ @Test
+ public void getterMethodNameTest() throws Exception {
+ assertEquals("getClazz", getterMethodName("clazz", Types.CLASS));
+ }
+
+ @SuppressWarnings("rawtypes")
+ @Test
+ public void createDescriptionWithSchemaNodeTest() throws Exception {
+ final Class[] parameterTypes = { SchemaNode.class, String.class, SchemaContext.class, boolean.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createDescription", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final SchemaContext schemaContext = YangParserTestUtils.parseYangSource("/generator/test-list.yang");
+ final ListSchemaNode containerSchemaNode =
+ (ListSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
+ final String fullyQualifiedName = "test.base.cont.with.leaf.MyList";
+
+ final Object[] args = { containerSchemaNode, fullyQualifiedName, schemaContext, true };
+ final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
+ assertNotNull(result);
+ assertTrue(result.contains("list my-list"));
+ assertTrue(result.contains("leaf key"));
+ assertTrue(result.contains("leaf key1"));
+ assertTrue(result.contains("leaf key2"));
+ assertTrue(result.contains("leaf foo"));
+ assertTrue(result.contains("@see test.base.cont.with.leaf.MyListBuilder"));
+ assertTrue(result.contains("@see test.base.cont.with.leaf.MyListKey"));
+ }
+
+ @SuppressWarnings("rawtypes")
+ @Test
+ public void createDescriptionWithSchemaNodeWithDescriptionTest() throws Exception {
+ final Class[] parameterTypes = { SchemaNode.class, String.class, SchemaContext.class, boolean.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createDescription", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final SchemaContext schemaContext =
+ YangParserTestUtils.parseYangSource("/base/test-leaf-with-description.yang");
+ final LeafSchemaNode containerSchemaNode =
+ (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
+ final String fullyQualifiedName = "test.base.cont.with.leaf.MyList";
+
+ final Object[] args = { containerSchemaNode, fullyQualifiedName, schemaContext, true };
+ final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
+ assertNotNull(result);
+ assertTrue(result.contains("I am leaf."));
+ }
+
+ @SuppressWarnings("rawtypes")
+ @Test
+ public void createDescriptionTest() throws Exception {
+ final Class[] parameterTypes = { Module.class, boolean.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createDescription", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final SchemaContext schemaContext = YangParserTestUtils.parseYangSource("/base/test-module.yang");
+
+ final Object[] args = { schemaContext.getModules().iterator().next(), true };
+ final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
+ assertNotNull(result);
+ assertTrue(result.contains("Base test module description"));
+ assertTrue(result.contains("test-module"));
+ }
+
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ @Test
+ public void createDescriptionWithSchemaNodesTest() throws Exception {
+ final Class[] parameterTypes = { Set.class, Module.class, boolean.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createDescription", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final SchemaContext schemaContext = YangParserTestUtils.parseYangSource("/base/test-rpc-and-notification.yang");
+ final Module module = schemaContext.getModules().iterator().next();
+ Set schemaNodes = new HashSet<>();
+ schemaNodes.add(module.getRpcs().iterator().next());
+
+ final Object[] args = { schemaNodes, module, true };
+ String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
+ assertNotNull(result);
+ assertTrue(result.contains(
+ "Interface for implementing the following YANG RPCs defined in module <b>test-rpc-and-notification-module</b>"));
+ assertTrue(result.contains("rpc my-rpc"));
+ assertTrue(!result.contains("notification my-notification"));
+
+ schemaNodes = new HashSet<>();
+ schemaNodes.add(module.getNotifications().iterator().next());
+
+ final Object[] args_n = { schemaNodes, module, true };
+ result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
+ assertNotNull(result);
+ assertTrue(result.contains(
+ "Interface for receiving the following YANG notifications defined in module <b>test-rpc-and-notification-module</b>"));
+ assertTrue(!result.contains("rpc my-rpc"));
+ assertTrue(result.contains("notification my-notification"));
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void isNullOrEmptyIsNullTest() throws Exception {
+ final Class[] parameterTypes = { Collection.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isNullOrEmpty", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final Collection list = null;
+
+ final Object[] args_n = { list };
+ final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args_n);
+ assertTrue(result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void isNullOrEmptyIsEmptyTest() throws Exception {
+ final Class[] parameterTypes = { Collection.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isNullOrEmpty", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final Collection list = new ArrayList<>();
+
+ final Object[] args_n = { list };
+ final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args_n);
+ assertTrue(result);
+ }
+
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ @Test
+ public void isNullOrEmptyNotNullNotEmptyTest() throws Exception {
+ final Class[] parameterTypes = { Collection.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isNullOrEmpty", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final Collection list = new ArrayList<>();
+ list.add(new Object());
+
+ final Object[] args_n = { list };
+ final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args_n);
+ assertTrue(!result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void augGenTypeNameTest() throws Exception {
+ final Class[] parameterTypes = { Map.class, String.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("augGenTypeName", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
+ builders.put("genTypeName1", new GeneratedTypeBuilderImpl("pckg.a1", "gen_a_1"));
+ builders.put("genTypeName2", new GeneratedTypeBuilderImpl("pckg.a2", "gen_a_2"));
+ final String genTypeName = "genTypeName";
+
+ final Object[] args_n = { builders, genTypeName };
+ final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
+ assertEquals("genTypeName3", result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void getAugmentIdentifierNullTest() throws Exception {
+ final Class[] parameterTypes = { List.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("getAugmentIdentifier", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final List<UnknownSchemaNode> list = new ArrayList<>();
+
+ final Object[] args_n = { list };
+ final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
+ assertEquals(null, result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void getAugmentIdentifierTest() throws Exception {
+ final Class[] parameterTypes = { List.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("getAugmentIdentifier", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final List<UnknownSchemaNode> list = new ArrayList<>();
+ final UnknownSchemaNode unknownSchemaNode = mock(UnknownSchemaNode.class);
+ final QName qname =
+ QName.create("urn:opendaylight:yang:extension:yang-ext", "2017-10-04", "augment-identifier");
+ when(unknownSchemaNode.getNodeType()).thenReturn(qname);
+ final String value = "node parameter";
+ when(unknownSchemaNode.getNodeParameter()).thenReturn(value);
+ list.add(unknownSchemaNode);
+
+ final Object[] args_n = { list };
+ final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
+ assertEquals(value, result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void resolveInnerEnumFromTypeDefinitionNullTest() throws Exception {
+ final Class[] parameterTypes =
+ { EnumTypeDefinition.class, QName.class, Map.class, GeneratedTypeBuilder.class, Module.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("resolveInnerEnumFromTypeDefinition", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ EnumTypeDefinition enumTypeDefinition = null;
+ final QName qname = null;
+ final GeneratedTypeBuilder gtb = null;
+ final Map map = new HashMap<>();
+ final Module module = null;
+
+ final Object[] args_n = { enumTypeDefinition, qname, map, gtb, module };
+ EnumBuilder result = (EnumBuilder) generate.invoke(AuxiliaryGenUtils.class, args_n);
+ assertEquals(null, result);
+
+ enumTypeDefinition = mock(EnumTypeDefinition.class);
+ final Object[] args1 = { enumTypeDefinition, qname, map, gtb, module };
+ result = (EnumBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
+ assertEquals(null, result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void resolveInnerEnumFromTypeDefinitionTest() throws Exception {
+ final Class[] parameterTypes =
+ { EnumTypeDefinition.class, QName.class, Map.class, GeneratedTypeBuilder.class, Module.class };
+ final Method generate =
+ AuxiliaryGenUtils.class.getDeclaredMethod("resolveInnerEnumFromTypeDefinition", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final QName qname = QName.create("urn:enum:test", "2017-12-04", "enum-test");
+ final EnumTypeDefinition enumTypeDefinition = mock(EnumTypeDefinition.class);
+ final QName enumQName = QName.create(qname, "enum-qname-test");
+ when(enumTypeDefinition.getQName()).thenReturn(enumQName);
+ final SchemaPath schemaPath = SchemaPath.create(true, enumQName);
+ when(enumTypeDefinition.getPath()).thenReturn(schemaPath);
+ final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl("urn.enum.test.pckg", "enum-test");
+ final Map<Module, ModuleContext> map = new HashMap<>();
+ final Module module = mock(Module.class);
+ final ModuleContext moduleContext = new ModuleContext();
+ map.put(module, moduleContext);
+
+ final Object[] args1 = { enumTypeDefinition, qname, map, gtb, module };
+ final EnumBuilder result = (EnumBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
+ assertNotNull(result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void addTOToTypeBuilderNullTest() throws Exception {
+ final Class[] parameterTypes =
+ { TypeDefinition.class, GeneratedTypeBuilder.class, DataSchemaNode.class, Module.class,
+ TypeProvider.class, SchemaContext.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("addTOToTypeBuilder", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final BooleanTypeDefinition typeDef = mock(BooleanTypeDefinition.class);
+ final GeneratedTypeBuilder typeBuilder =
+ new GeneratedTypeBuilderImpl("test.boolean.type.def", "boolean-type-def");
+ final DataSchemaNode leaf = mock(DataSchemaNode.class);
+ final QName qnameLeaf = QName.create("urn:leaf:qname:test", "2017-12-04", "leaf-qname-test");
+ when(leaf.getQName()).thenReturn(qnameLeaf);
+ final Module parentModule = mock(Module.class);
+ final SchemaContext schemaContext = mock(SchemaContext.class);
+ final Set<Module> modules = new HashSet<>();
+ when(schemaContext.getModules()).thenReturn(modules);
+ final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
+
+ final Object[] args1 = { typeDef, typeBuilder, leaf, parentModule, typeProvider, schemaContext };
+ final GeneratedTOBuilder result = (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
+ assertEquals(null, result);
+ }
+
+ @Test
+ public void addTOToTypeBuilderUnionTest() throws Exception {
+ assertNotNull(addTOToBuilder("/base/test-union.yang"));
+ }
+
+ @Test
+ public void addTOToTypeBuilderBitsTest() throws Exception {
+ assertNotNull(addTOToBuilder("/base/test-bits.yang"));
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ private GeneratedTOBuilder addTOToBuilder(final String yangPath)
+ throws NoSuchMethodException, ReactorException, FileNotFoundException, URISyntaxException,
+ IllegalAccessException, InvocationTargetException {
+ final Class[] parameterTypes = { TypeDefinition.class, GeneratedTypeBuilder.class, DataSchemaNode.class,
+ Module.class, TypeProvider.class, SchemaContext.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("addTOToTypeBuilder", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final GeneratedTypeBuilder typeBuilder =
+ new GeneratedTypeBuilderImpl("test.boolean.spc.def", "spec-type-def");
+ final SchemaContext schemaContext = YangParserTestUtils.parseYangSource(yangPath);
+ final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
+ final LeafSchemaNode leafSchemaNode =
+ (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
+ final TypeDefinition<? extends TypeDefinition<?>> typeDef = leafSchemaNode.getType();
+ final Object[] args1 = { typeDef, typeBuilder, leafSchemaNode, schemaContext.getModules().iterator().next(),
+ typeProvider, schemaContext };
+ return (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void createReturnTypeForUnionTest() throws Exception {
+ final Class[] parameterTypes = { GeneratedTOBuilder.class, TypeDefinition.class, GeneratedTypeBuilder.class,
+ Module.class, TypeProvider.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createReturnTypeForUnion", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final GeneratedTypeBuilder typeBuilder = new GeneratedTypeBuilderImpl("test.boolean.spc.def", "spec-type-def");
+ final SchemaContext schemaContext = YangParserTestUtils.parseYangSource("/base/test-union.yang");
+ final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
+ final LeafSchemaNode leafSchemaNode =
+ (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
+ final TypeDefinition<? extends TypeDefinition<?>> typeDef = leafSchemaNode.getType();
+
+ final Object[] args1 = { addTOToBuilder("/base/test-union.yang"), typeDef, typeBuilder,
+ schemaContext.getModules().iterator().next(), typeProvider };
+ final Type result = (Type) generate.invoke(AuxiliaryGenUtils.class, args1);
+ assertNotNull(result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void isInnerTypeTrueTest() throws Exception {
+ final Class[] parameterTypes = { LeafSchemaNode.class, TypeDefinition.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isInnerType", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
+ final TypeDefinition type = mock(TypeDefinition.class);
+ final QName qname = QName.create("namespace", "2017-12-04", "localName");
+ final SchemaPath path = SchemaPath.create(true, qname);
+ when(leaf.getPath()).thenReturn(path);
+ when(type.getPath()).thenReturn(path);
+
+ final Object[] args1 = { leaf, type };
+ boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args1);
+ assertNotNull(result);
+ assertTrue(result);
+
+ final QName qnameParent = QName.create(qname, "qnameParent");
+ final SchemaPath parent = SchemaPath.create(true, qname, qnameParent);
+ when(type.getPath()).thenReturn(parent);
+
+ final Object[] args2 = { leaf, type };
+ result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
+ assertNotNull(result);
+ assertTrue(result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void isInnerTypeFalseTest() throws Exception {
+ final Class[] parameterTypes = { LeafSchemaNode.class, TypeDefinition.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isInnerType", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
+ final TypeDefinition type = mock(TypeDefinition.class);
+ final QName qname = QName.create("namespace", "2017-12-04", "localName");
+ final SchemaPath path = SchemaPath.create(true, qname);
+ when(leaf.getPath()).thenReturn(path);
+
+ final QName qnameChild = QName.create(qname, "qnameChild");
+ final QName qnameParent = QName.create(qname, "qnameParent");
+ final SchemaPath parent = SchemaPath.create(true, qnameChild, qnameParent);
+
+ when(type.getPath()).thenReturn(parent);
+
+ final Object[] args2 = { leaf, type };
+ final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
+ assertNotNull(result);
+ assertTrue(!result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void resolveListKeyTOBuilderTest() throws Exception {
+ final Class[] parameterTypes = { String.class, ListSchemaNode.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("resolveListKeyTOBuilder", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final String pckgName = "pckg.name.test";
+ final ListSchemaNode list = mock(ListSchemaNode.class);
+ final List<QName> keyDefs = new ArrayList<>();
+ final QName qname = QName.create("namespace", "2017-12-04", "localname");
+ keyDefs.add(qname);
+ when(list.getKeyDefinition()).thenReturn(keyDefs);
+ when(list.getQName()).thenReturn(qname);
+
+ final Object[] args1 = { pckgName, list };
+ final GeneratedTOBuilder result = (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
+ assertNotNull(result);
+ assertEquals("LocalnameKey", result.getName());
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void resolveLeafSchemaNodeAsPropertyFalseTest() throws Exception {
+ final Class[] parameterTypes = { GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
+ final Method generate =
+ AuxiliaryGenUtils.class.getDeclaredMethod("resolveLeafSchemaNodeAsProperty", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final GeneratedTOBuilder gtob = mock(GeneratedTOBuilder.class);
+ final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
+ final boolean isReadOnly = true;
+ final Type type = null;
+
+ final Object[] args2 = { gtob, leaf, type, isReadOnly };
+ final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
+ assertNotNull(result);
+ assertTrue(!result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void resolveLeafSchemaNodeAsPropertyTrueTest() throws Exception {
+ final Class[] parameterTypes = { GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
+ final Method generate =
+ AuxiliaryGenUtils.class.getDeclaredMethod("resolveLeafSchemaNodeAsProperty", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final GeneratedTOBuilder gtob = new GeneratedTOBuilderImpl("pckg.name.gto.tst", "gto_name");
+ final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
+ final boolean isReadOnly = true;
+ final Type type = mock(Type.class);
+ when(leaf.getQName()).thenReturn(QName.create("ns", "2017-12-04", "ln"));
+
+ final Object[] args2 = { gtob, leaf, type, isReadOnly };
+ final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
+ assertNotNull(result);
+ assertTrue(result);
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void checkModuleAndModuleNameTest() throws Exception {
+ final Class[] parameterTypes = { Module.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("checkModuleAndModuleName", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final Module module = mock(Module.class);
+ when(module.getName()).thenReturn("moduleName");
+ final Object[] args2 = { module };
+ generate.invoke(AuxiliaryGenUtils.class, args2);
+ }
+
+ @SuppressWarnings("rawtypes")
+ private String getterMethodName(final String schemaNodeName, final Type returnType)
+ throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
+ final Class[] parameterTypes =
+ { String.class, Type.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("getterMethodName", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final Object[] args = { schemaNodeName, returnType };
+ return (String) generate.invoke(AuxiliaryGenUtils.class, args);
+ }
+
+ @SuppressWarnings("rawtypes")
+ private <T extends SchemaNode> boolean hasBuilderClass(final Class<T> clazz) throws Exception {
+ final Class[] parameterTypes = { SchemaNode.class };
+ final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("hasBuilderClass", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final T schemaNode = mock(clazz);
+
+ final Object[] args = { schemaNode };
+ return (boolean) generate.invoke(AuxiliaryGenUtils.class, args);
+ }
+}
Code Review / mdsal.git / commitdiff