binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AuxiliaryGenUtilsTest.java

   1 /*
   2  * Copyright (c) 2017 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.binding.javav2.generator.impl;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.mockito.Mockito.mock;
  14 import static org.mockito.Mockito.when;
  15 import java.io.File;
  16 import java.io.FileNotFoundException;
  17 import java.lang.reflect.Constructor;
  18 import java.lang.reflect.InvocationTargetException;
  19 import java.lang.reflect.Method;
  20 import java.net.URISyntaxException;
  21 import java.util.ArrayList;
  22 import java.util.Collection;
  23 import java.util.HashMap;
  24 import java.util.HashSet;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.Set;
  28 import org.junit.Test;
  29 import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
  30 import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
  31 import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
  32 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
  33 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
  34 import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
  35 import org.opendaylight.mdsal.binding.javav2.model.api.Constant;
  36 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
  37 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder;
  38 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTOBuilder;
  39 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
  40 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilderBase;
  41 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.MethodSignatureBuilder;
  42 import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
  43 import org.opendaylight.yangtools.yang.common.QName;
  44 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  45 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  46 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  47 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  48 import org.opendaylight.yangtools.yang.model.api.Module;
  49 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  50 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  51 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  52 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  53 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  54 import org.opendaylight.yangtools.yang.model.api.Status;
  55 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  56 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  57 import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
  58 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  59 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  60 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  61
  62 public class AuxiliaryGenUtilsTest {
  63
  64     @SuppressWarnings("unchecked")
  65     @Test(expected = UnsupportedOperationException.class)
  66     public void constructorTest() throws Throwable {
  67         final Constructor<AuxiliaryGenUtils> constructor =
  68                 (Constructor<AuxiliaryGenUtils>) AuxiliaryGenUtils.class.getDeclaredConstructors()[0];
  69         constructor.setAccessible(true);
  70         final Object[] objs = {};
  71         try {
  72             constructor.newInstance(objs);
  73         } catch (final Exception e) {
  74             throw e.getCause();
  75         }
  76     }
  77
  78     @SuppressWarnings("rawtypes")
  79     @Test
  80     public void annotateDeprecatedIfNecessaryNonDepricatedTest() throws Exception {
  81         final Class[] parameterTypes = { Status.class, GeneratedTypeBuilder.class };
  82         final Method generate =
  83                 AuxiliaryGenUtils.class.getDeclaredMethod("annotateDeprecatedIfNecessary", parameterTypes);
  84         assertNotNull(generate);
  85         generate.setAccessible(true);
  86
  87         final GeneratedTypeBuilderImpl generatedTypeBuilder =
  88                 new GeneratedTypeBuilderImpl("test.deprecated", "Non_Deprecated", new ModuleContext());
  89         final Status status = Status.CURRENT;
  90
  91         final Object[] args = { status, generatedTypeBuilder };
  92         generate.invoke(AuxiliaryGenUtils.class, args);
  93         assertTrue(generatedTypeBuilder.toInstance().getAnnotations().isEmpty());
  94     }
  95
  96     @SuppressWarnings("rawtypes")
  97     @Test
  98     public void annotateDeprecatedIfNecessaryDepricatedTest() throws Exception {
  99         final Class[] parameterTypes = { Status.class, GeneratedTypeBuilder.class };
 100         final Method generate =
 101                 AuxiliaryGenUtils.class.getDeclaredMethod("annotateDeprecatedIfNecessary", parameterTypes);
 102         assertNotNull(generate);
 103         generate.setAccessible(true);
 104
 105         final GeneratedTypeBuilderImpl generatedTypeBuilder =
 106                 new GeneratedTypeBuilderImpl("test.deprecated", "Deprecated", new ModuleContext());
 107         final Status status = Status.DEPRECATED;
 108
 109         final Object[] args = { status, generatedTypeBuilder };
 110         generate.invoke(AuxiliaryGenUtils.class, args);
 111         assertTrue(!generatedTypeBuilder.toInstance().getAnnotations().isEmpty());
 112         assertEquals("Deprecated", generatedTypeBuilder.toInstance().getAnnotations().get(0).getName());
 113     }
 114
 115     @Test
 116     public void hasBuilderClassFalseTest() throws Exception {
 117         assertEquals(false, hasBuilderClass(LeafSchemaNode.class));
 118     }
 119
 120     @Test
 121     public void hasBuilderClassContainerTest() throws Exception {
 122         assertEquals(true, hasBuilderClass(ContainerSchemaNode.class));
 123     }
 124
 125     @Test
 126     public void hasBuilderClassListTest() throws Exception {
 127         assertEquals(true, hasBuilderClass(ListSchemaNode.class));
 128     }
 129
 130     @Test
 131     public void hasBuilderClassRpcTest() throws Exception {
 132         assertEquals(true, hasBuilderClass(RpcDefinition.class));
 133     }
 134
 135     @Test
 136     public void hasBuilderClassNotificationTest() throws Exception {
 137         assertEquals(true, hasBuilderClass(NotificationDefinition.class));
 138     }
 139
 140     @SuppressWarnings("rawtypes")
 141     @Test
 142     public void qNameConstantTest() throws Exception {
 143         final Class[] parameterTypes = { GeneratedTypeBuilderBase.class, String.class, QName.class };
 144         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("qNameConstant", parameterTypes);
 145         assertNotNull(generate);
 146         generate.setAccessible(true);
 147
 148         final GeneratedTypeBuilderBase gtbb = new GeneratedTypeBuilderImpl("test", "qname_constants", new ModuleContext());
 149         final String constantName = "ConstantName";
 150         final QName constantQName = QName.create("urn:constant", "2017-04-06", constantName);
 151
 152         final Object[] args = { gtbb, constantName, constantQName };
 153         final Constant result = (Constant) generate.invoke(AuxiliaryGenUtils.class, args);
 154         assertEquals(constantName, result.getName());
 155     }
 156
 157     @SuppressWarnings("rawtypes")
 158     @Test
 159     public void constructGetterTest() throws Exception {
 160         final Class[] parameterTypes =
 161                 { GeneratedTypeBuilder.class, String.class, String.class, Type.class, Status.class };
 162         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("constructGetter", parameterTypes);
 163         assertNotNull(generate);
 164         generate.setAccessible(true);
 165
 166         final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl("test", "Getter_of", new ModuleContext());
 167         final String schemaNodeName = "schema_node_getter";
 168         final String comment = null;
 169         final Type returnType = Types.STRING;
 170         final Status status = Status.DEPRECATED;
 171
 172         final Object[] args = { gtb, schemaNodeName, comment, returnType, status };
 173         final MethodSignatureBuilder result = (MethodSignatureBuilder) generate.invoke(AuxiliaryGenUtils.class, args);
 174         assertEquals(new StringBuilder("get").append("SchemaNodeGetter").toString(),
 175                 result.toInstance(returnType).getName());
 176     }
 177
 178     @Test
 179     public void getterMethodNameBooleanTest() throws Exception {
 180         assertEquals("isBooleanMethod", getterMethodName("boolean_method", Types.BOOLEAN));
 181     }
 182
 183     @Test
 184     public void getterMethodNameTest() throws Exception {
 185         assertEquals("getClazz", getterMethodName("clazz", Types.CLASS));
 186     }
 187
 188     @SuppressWarnings("rawtypes")
 189     @Test
 190     public void createDescriptionWithSchemaNodeTest() throws Exception {
 191         final Class[] parameterTypes = { SchemaNode.class, String.class, SchemaContext.class, boolean.class,
 192         BindingNamespaceType.class};
 193         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createDescription", parameterTypes);
 194         assertNotNull(generate);
 195         generate.setAccessible(true);
 196
 197         final SchemaContext schemaContext = YangParserTestUtils
 198                 .parseYangFiles(new File(getClass().getResource("/generator/test-list.yang").toURI()));
 199         final ListSchemaNode containerSchemaNode =
 200                 (ListSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 201         final String fullyQualifiedName =
 202                 "org.opendaylight.mdsal.gen.javav2.urn.test.simple.test.list.rev170314.data.MyList";
 203
 204         final Object[] args = { containerSchemaNode, fullyQualifiedName, schemaContext, true, BindingNamespaceType.Data };
 205         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
 206         assertNotNull(result);
 207         assertTrue(result.contains("list my-list"));
 208         assertTrue(result.contains("leaf key"));
 209         assertTrue(result.contains("leaf key1"));
 210         assertTrue(result.contains("leaf key2"));
 211         assertTrue(result.contains("leaf foo"));
 212         assertTrue(result.contains("@see org.opendaylight.mdsal.gen.javav2.urn.test.simple.test.list.rev170314.dto.MyListBuilder"));
 213         assertTrue(result.contains("@see org.opendaylight.mdsal.gen.javav2.urn.test.simple.test.list.rev170314.key.my_list.MyListKey"));
 214     }
 215
 216     @SuppressWarnings("rawtypes")
 217     @Test
 218     public void createDescriptionWithSchemaNodeWithDescriptionTest() throws Exception {
 219         final Class[] parameterTypes = { SchemaNode.class, String.class, SchemaContext.class, boolean.class,
 220                 BindingNamespaceType.class};
 221         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createDescription", parameterTypes);
 222         assertNotNull(generate);
 223         generate.setAccessible(true);
 224
 225         final SchemaContext schemaContext =
 226                 YangParserTestUtils.parseYangFiles(
 227                         new File(getClass().getResource("/base/test-leaf-with-description.yang").toURI()));
 228         final LeafSchemaNode containerSchemaNode =
 229                 (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 230         final String fullyQualifiedName = "test.base.cont.with.leaf.MyList";
 231
 232         final Object[] args = { containerSchemaNode, fullyQualifiedName, schemaContext, true, BindingNamespaceType.Data};
 233         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
 234         assertNotNull(result);
 235         assertTrue(result.contains("I am leaf."));
 236     }
 237
 238     @SuppressWarnings("rawtypes")
 239     @Test
 240     public void createDescriptionTest() throws Exception {
 241         final Class[] parameterTypes = { Module.class, boolean.class };
 242         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createDescription", parameterTypes);
 243         assertNotNull(generate);
 244         generate.setAccessible(true);
 245
 246         final SchemaContext schemaContext =
 247                 YangParserTestUtils.parseYangFiles(new File(getClass().getResource("/base/test-module.yang").toURI()));
 248
 249         final Object[] args = { schemaContext.getModules().iterator().next(), true };
 250         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
 251         assertNotNull(result);
 252         assertTrue(result.contains("Base test module description"));
 253         assertTrue(result.contains("test-module"));
 254     }
 255
 256     @SuppressWarnings({ "rawtypes", "unchecked" })
 257     @Test
 258     public void createDescriptionWithSchemaNodesTest() throws Exception {
 259         final Class[] parameterTypes = { Set.class, Module.class, boolean.class };
 260         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createDescription", parameterTypes);
 261         assertNotNull(generate);
 262         generate.setAccessible(true);
 263
 264         final SchemaContext schemaContext = YangParserTestUtils
 265                 .parseYangFiles(new File(getClass().getResource("/base/test-rpc-and-notification.yang").toURI()));
 266         final Module module = schemaContext.getModules().iterator().next();
 267         Set schemaNodes = new HashSet<>();
 268         schemaNodes.add(module.getRpcs().iterator().next());
 269
 270         final Object[] args = { schemaNodes, module, true };
 271         String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
 272         assertNotNull(result);
 273         assertTrue(result.contains(
 274                 "Interface for implementing the following YANG RPCs defined in module <b>test-rpc-and-notification-module</b>"));
 275         assertTrue(result.contains("rpc my-rpc"));
 276         assertTrue(!result.contains("notification my-notification"));
 277
 278         schemaNodes = new HashSet<>();
 279         schemaNodes.add(module.getNotifications().iterator().next());
 280
 281         final Object[] args_n = { schemaNodes, module, true };
 282         result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
 283         assertNotNull(result);
 284         assertTrue(result.contains(
 285                 "Interface for receiving the following YANG notifications defined in module <b>test-rpc-and-notification-module</b>"));
 286         assertTrue(!result.contains("rpc my-rpc"));
 287         assertTrue(result.contains("notification my-notification"));
 288     }
 289
 290     @SuppressWarnings({ "rawtypes" })
 291     @Test
 292     public void isNullOrEmptyIsNullTest() throws Exception {
 293         final Class[] parameterTypes = { Collection.class };
 294         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isNullOrEmpty", parameterTypes);
 295         assertNotNull(generate);
 296         generate.setAccessible(true);
 297
 298         final Collection list = null;
 299
 300         final Object[] args_n = { list };
 301         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args_n);
 302         assertTrue(result);
 303     }
 304
 305     @SuppressWarnings({ "rawtypes" })
 306     @Test
 307     public void isNullOrEmptyIsEmptyTest() throws Exception {
 308         final Class[] parameterTypes = { Collection.class };
 309         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isNullOrEmpty", parameterTypes);
 310         assertNotNull(generate);
 311         generate.setAccessible(true);
 312
 313         final Collection list = new ArrayList<>();
 314
 315         final Object[] args_n = { list };
 316         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args_n);
 317         assertTrue(result);
 318     }
 319
 320     @SuppressWarnings({ "rawtypes", "unchecked" })
 321     @Test
 322     public void isNullOrEmptyNotNullNotEmptyTest() throws Exception {
 323         final Class[] parameterTypes = { Collection.class };
 324         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isNullOrEmpty", parameterTypes);
 325         assertNotNull(generate);
 326         generate.setAccessible(true);
 327
 328         final Collection list = new ArrayList<>();
 329         list.add(new Object());
 330
 331         final Object[] args_n = { list };
 332         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args_n);
 333         assertTrue(!result);
 334     }
 335
 336     @SuppressWarnings({ "rawtypes" })
 337     @Test
 338     public void augGenTypeNameTest() throws Exception {
 339         final Class[] parameterTypes = { Map.class, String.class };
 340         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("augGenTypeName", parameterTypes);
 341         assertNotNull(generate);
 342         generate.setAccessible(true);
 343
 344         final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
 345         builders.put("genTypeName1", new GeneratedTypeBuilderImpl("pckg.a1", "gen_a_1", new ModuleContext()));
 346         builders.put("genTypeName2", new GeneratedTypeBuilderImpl("pckg.a2", "gen_a_2", new ModuleContext()));
 347         final String genTypeName = "genTypeName";
 348
 349         final Object[] args_n = { builders, genTypeName };
 350         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
 351         assertEquals("genTypeName3", result);
 352     }
 353
 354     @SuppressWarnings({ "rawtypes" })
 355     @Test
 356     public void getAugmentIdentifierNullTest() throws Exception {
 357         final Class[] parameterTypes = { List.class };
 358         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("getAugmentIdentifier", parameterTypes);
 359         assertNotNull(generate);
 360         generate.setAccessible(true);
 361
 362         final List<UnknownSchemaNode> list = new ArrayList<>();
 363
 364         final Object[] args_n = { list };
 365         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
 366         assertEquals(null, result);
 367     }
 368
 369     @SuppressWarnings({ "rawtypes" })
 370     @Test
 371     public void getAugmentIdentifierTest() throws Exception {
 372         final Class[] parameterTypes = { List.class };
 373         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("getAugmentIdentifier", parameterTypes);
 374         assertNotNull(generate);
 375         generate.setAccessible(true);
 376
 377         final List<UnknownSchemaNode> list = new ArrayList<>();
 378         final UnknownSchemaNode unknownSchemaNode = mock(UnknownSchemaNode.class);
 379         final QName qname =
 380                 QName.create("urn:opendaylight:yang:extension:yang-ext", "2017-10-04", "augment-identifier");
 381         when(unknownSchemaNode.getNodeType()).thenReturn(qname);
 382         final String value = "node parameter";
 383         when(unknownSchemaNode.getNodeParameter()).thenReturn(value);
 384         list.add(unknownSchemaNode);
 385
 386         final Object[] args_n = { list };
 387         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
 388         assertEquals(value, result);
 389     }
 390
 391     @SuppressWarnings({ "rawtypes" })
 392     @Test
 393     public void resolveInnerEnumFromTypeDefinitionNullTest() throws Exception {
 394         final Class[] parameterTypes =
 395                 { EnumTypeDefinition.class, QName.class, Map.class, GeneratedTypeBuilder.class, Module.class };
 396         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("resolveInnerEnumFromTypeDefinition", parameterTypes);
 397         assertNotNull(generate);
 398         generate.setAccessible(true);
 399
 400         EnumTypeDefinition enumTypeDefinition = null;
 401         final QName qname = null;
 402         final GeneratedTypeBuilder gtb = null;
 403         final Map map = new HashMap<>();
 404         final Module module = null;
 405
 406         final Object[] args_n = { enumTypeDefinition, qname, map, gtb, module };
 407         EnumBuilder result = (EnumBuilder) generate.invoke(AuxiliaryGenUtils.class, args_n);
 408         assertEquals(null, result);
 409
 410         enumTypeDefinition = mock(EnumTypeDefinition.class);
 411         final Object[] args1 = { enumTypeDefinition, qname, map, gtb, module };
 412         result = (EnumBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 413         assertEquals(null, result);
 414     }
 415
 416     @SuppressWarnings({ "rawtypes" })
 417     @Test
 418     public void resolveInnerEnumFromTypeDefinitionTest() throws Exception {
 419         final Class[] parameterTypes =
 420                 { EnumTypeDefinition.class, QName.class, Map.class, GeneratedTypeBuilder.class, Module.class };
 421         final Method generate =
 422                 AuxiliaryGenUtils.class.getDeclaredMethod("resolveInnerEnumFromTypeDefinition", parameterTypes);
 423         assertNotNull(generate);
 424         generate.setAccessible(true);
 425
 426         final QName qname = QName.create("urn:enum:test", "2017-12-04", "enum-test");
 427         final EnumTypeDefinition enumTypeDefinition = mock(EnumTypeDefinition.class);
 428         final QName enumQName = QName.create(qname, "enum-qname-test");
 429         when(enumTypeDefinition.getQName()).thenReturn(enumQName);
 430         final SchemaPath schemaPath = SchemaPath.create(true, enumQName);
 431         when(enumTypeDefinition.getPath()).thenReturn(schemaPath);
 432         final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl("urn.enum.test.pckg", "enum-test", new ModuleContext());
 433         final Map<Module, ModuleContext> map = new HashMap<>();
 434         final Module module = mock(Module.class);
 435         final ModuleContext moduleContext = new ModuleContext();
 436         map.put(module, moduleContext);
 437
 438         final Object[] args1 = { enumTypeDefinition, qname, map, gtb, module };
 439         final EnumBuilder result = (EnumBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 440         assertNotNull(result);
 441     }
 442
 443     @SuppressWarnings({ "rawtypes" })
 444     @Test
 445     public void addTOToTypeBuilderNullTest() throws Exception {
 446         final Class[] parameterTypes =
 447                 { TypeDefinition.class, GeneratedTypeBuilder.class, DataSchemaNode.class, Module.class,
 448                         TypeProvider.class, SchemaContext.class, ModuleContext.class, Map.class };
 449         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("addTOToTypeBuilder", parameterTypes);
 450         assertNotNull(generate);
 451         generate.setAccessible(true);
 452
 453         final BooleanTypeDefinition typeDef = mock(BooleanTypeDefinition.class);
 454         final GeneratedTypeBuilder typeBuilder =
 455                 new GeneratedTypeBuilderImpl("test.boolean.type.def", "boolean-type-def", new ModuleContext());
 456         final DataSchemaNode leaf = mock(DataSchemaNode.class);
 457         final QName qnameLeaf = QName.create("urn:leaf:qname:test", "2017-12-04", "leaf-qname-test");
 458         when(leaf.getQName()).thenReturn(qnameLeaf);
 459         final Module parentModule = mock(Module.class);
 460         final SchemaContext schemaContext = mock(SchemaContext.class);
 461         final Set<Module> modules = new HashSet<>();
 462         when(schemaContext.getModules()).thenReturn(modules);
 463         final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
 464         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 465         genCtx.put(parentModule, new ModuleContext());
 466
 467         final Object[] args1 = { typeDef, typeBuilder, leaf, parentModule, typeProvider, schemaContext, new ModuleContext(), genCtx };
 468         final GeneratedTOBuilder result = (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 469         assertEquals(null, result);
 470     }
 471
 472     @Test
 473     public void addTOToTypeBuilderUnionTest() throws Exception {
 474         assertNotNull(addTOToBuilder("/base/test-union.yang"));
 475     }
 476
 477     @Test
 478     public void addTOToTypeBuilderBitsTest() throws Exception {
 479         assertNotNull(addTOToBuilder("/base/test-bits.yang"));
 480     }
 481
 482     @SuppressWarnings({ "rawtypes" })
 483     private GeneratedTOBuilder addTOToBuilder(final String yangPath)
 484             throws NoSuchMethodException, ReactorException, FileNotFoundException, URISyntaxException,
 485             IllegalAccessException, InvocationTargetException {
 486         final Class[] parameterTypes = { TypeDefinition.class, GeneratedTypeBuilder.class, DataSchemaNode.class,
 487                 Module.class, TypeProvider.class, SchemaContext.class, ModuleContext.class, Map.class };
 488         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("addTOToTypeBuilder", parameterTypes);
 489         assertNotNull(generate);
 490         generate.setAccessible(true);
 491
 492         final GeneratedTypeBuilder typeBuilder =
 493                 new GeneratedTypeBuilderImpl("test.boolean.spc.def", "spec-type-def", new ModuleContext());
 494         final SchemaContext schemaContext =
 495                 YangParserTestUtils.parseYangFiles(new File(getClass().getResource(yangPath).toURI()));
 496         final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
 497         final LeafSchemaNode leafSchemaNode =
 498                 (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 499         final TypeDefinition<? extends TypeDefinition<?>> typeDef = leafSchemaNode.getType();
 500         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 501         genCtx.put(schemaContext.getModules().iterator().next(), new ModuleContext());
 502
 503         final Object[] args1 = { typeDef, typeBuilder, leafSchemaNode, schemaContext.getModules().iterator().next(),
 504                 typeProvider, schemaContext, new ModuleContext(), genCtx };
 505         return (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 506     }
 507
 508     @SuppressWarnings({ "rawtypes" })
 509     @Test
 510     public void createReturnTypeForUnionTest() throws Exception {
 511         final Class[] parameterTypes = { GeneratedTOBuilder.class, TypeDefinition.class, GeneratedTypeBuilder.class,
 512                 Module.class, TypeProvider.class };
 513         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createReturnTypeForUnion", parameterTypes);
 514         assertNotNull(generate);
 515         generate.setAccessible(true);
 516
 517         final GeneratedTypeBuilder typeBuilder = new GeneratedTypeBuilderImpl("test.boolean.spc.def",
 518                 "spec-type-def", new ModuleContext());
 519         final SchemaContext schemaContext =
 520                 YangParserTestUtils.parseYangFiles(new File(getClass().getResource("/base/test-union.yang").toURI()));
 521         final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
 522         final LeafSchemaNode leafSchemaNode =
 523                 (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 524         final TypeDefinition<? extends TypeDefinition<?>> typeDef = leafSchemaNode.getType();
 525
 526         final Object[] args1 = { addTOToBuilder("/base/test-union.yang"), typeDef, typeBuilder,
 527                 schemaContext.getModules().iterator().next(), typeProvider };
 528         final Type result = (Type) generate.invoke(AuxiliaryGenUtils.class, args1);
 529         assertNotNull(result);
 530     }
 531
 532     @SuppressWarnings({ "rawtypes" })
 533     @Test
 534     public void isInnerTypeTrueTest() throws Exception {
 535         final Class[] parameterTypes = { LeafSchemaNode.class, TypeDefinition.class };
 536         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isInnerType", parameterTypes);
 537         assertNotNull(generate);
 538         generate.setAccessible(true);
 539
 540         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 541         final TypeDefinition type = mock(TypeDefinition.class);
 542         final QName qname = QName.create("namespace", "2017-12-04", "localName");
 543         final SchemaPath path = SchemaPath.create(true, qname);
 544         when(leaf.getPath()).thenReturn(path);
 545         when(type.getPath()).thenReturn(path);
 546
 547         final Object[] args1 = { leaf, type };
 548         boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args1);
 549         assertNotNull(result);
 550         assertTrue(result);
 551
 552         final QName qnameParent = QName.create(qname, "qnameParent");
 553         final SchemaPath parent = SchemaPath.create(true, qname, qnameParent);
 554         when(type.getPath()).thenReturn(parent);
 555
 556         final Object[] args2 = { leaf, type };
 557         result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 558         assertNotNull(result);
 559         assertTrue(result);
 560     }
 561
 562     @SuppressWarnings({ "rawtypes" })
 563     @Test
 564     public void isInnerTypeFalseTest() throws Exception {
 565         final Class[] parameterTypes = { LeafSchemaNode.class, TypeDefinition.class };
 566         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isInnerType", parameterTypes);
 567         assertNotNull(generate);
 568         generate.setAccessible(true);
 569
 570         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 571         final TypeDefinition type = mock(TypeDefinition.class);
 572         final QName qname = QName.create("namespace", "2017-12-04", "localName");
 573         final SchemaPath path = SchemaPath.create(true, qname);
 574         when(leaf.getPath()).thenReturn(path);
 575
 576         final QName qnameChild = QName.create(qname, "qnameChild");
 577         final QName qnameParent = QName.create(qname, "qnameParent");
 578         final SchemaPath parent = SchemaPath.create(true, qnameChild, qnameParent);
 579
 580         when(type.getPath()).thenReturn(parent);
 581
 582         final Object[] args2 = { leaf, type };
 583         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 584         assertNotNull(result);
 585         assertTrue(!result);
 586     }
 587
 588     @SuppressWarnings({ "rawtypes" })
 589     @Test
 590     public void resolveListKeyTOBuilderTest() throws Exception {
 591         final Class[] parameterTypes = { String.class, ListSchemaNode.class, ModuleContext.class };
 592         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("resolveListKeyTOBuilder", parameterTypes);
 593         assertNotNull(generate);
 594         generate.setAccessible(true);
 595
 596         final String pckgName = "pckg.name.test";
 597         final ListSchemaNode list = mock(ListSchemaNode.class);
 598         final List<QName> keyDefs = new ArrayList<>();
 599         final QName qname = QName.create("namespace", "2017-12-04", "localname");
 600         keyDefs.add(qname);
 601         when(list.getKeyDefinition()).thenReturn(keyDefs);
 602         when(list.getQName()).thenReturn(qname);
 603
 604         final Object[] args1 = { pckgName, list, new ModuleContext() };
 605         final GeneratedTOBuilder result = (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 606         assertNotNull(result);
 607         assertEquals("LocalnameKey", result.getName());
 608     }
 609
 610     @SuppressWarnings({ "rawtypes" })
 611     @Test
 612     public void resolveLeafSchemaNodeAsPropertyFalseTest() throws Exception {
 613         final Class[] parameterTypes = { String.class, GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
 614         final Method generate =
 615                 AuxiliaryGenUtils.class.getDeclaredMethod("resolveLeafSchemaNodeAsProperty", parameterTypes);
 616         assertNotNull(generate);
 617         generate.setAccessible(true);
 618
 619         final GeneratedTOBuilder gtob = mock(GeneratedTOBuilder.class);
 620         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 621         final boolean isReadOnly = true;
 622         final Type type = null;
 623
 624         final Object[] args2 = { "list", gtob, leaf, type, isReadOnly };
 625         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 626         assertNotNull(result);
 627         assertTrue(!result);
 628     }
 629
 630     @SuppressWarnings({ "rawtypes" })
 631     @Test
 632     public void resolveLeafSchemaNodeAsPropertyTrueTest() throws Exception {
 633         final Class[] parameterTypes = { String.class, GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
 634         final Method generate =
 635                 AuxiliaryGenUtils.class.getDeclaredMethod("resolveLeafSchemaNodeAsProperty", parameterTypes);
 636         assertNotNull(generate);
 637         generate.setAccessible(true);
 638
 639         final GeneratedTOBuilder gtob = new GeneratedTOBuilderImpl("pckg.name.gto.tst", "gto_name", true);
 640         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 641         final boolean isReadOnly = true;
 642         final Type type = mock(Type.class);
 643         when(leaf.getQName()).thenReturn(QName.create("ns", "2017-12-04", "ln"));
 644
 645         final Object[] args2 = { "list", gtob, leaf, type, isReadOnly };
 646         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 647         assertNotNull(result);
 648         assertTrue(result);
 649     }
 650
 651     @SuppressWarnings({ "rawtypes" })
 652     @Test
 653     public void checkModuleAndModuleNameTest() throws Exception {
 654         final Class[] parameterTypes = { Module.class };
 655         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("checkModuleAndModuleName", parameterTypes);
 656         assertNotNull(generate);
 657         generate.setAccessible(true);
 658
 659         final Module module = mock(Module.class);
 660         when(module.getName()).thenReturn("moduleName");
 661         final Object[] args2 = { module };
 662         generate.invoke(AuxiliaryGenUtils.class, args2);
 663     }
 664
 665     @SuppressWarnings("rawtypes")
 666     private String getterMethodName(final String schemaNodeName, final Type returnType)
 667             throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
 668         final Class[] parameterTypes =
 669                 { String.class, Type.class };
 670         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("getterMethodName", parameterTypes);
 671         assertNotNull(generate);
 672         generate.setAccessible(true);
 673
 674         final Object[] args = { schemaNodeName, returnType };
 675         return (String) generate.invoke(AuxiliaryGenUtils.class, args);
 676     }
 677
 678     @SuppressWarnings("rawtypes")
 679     private <T extends SchemaNode> boolean hasBuilderClass(final Class<T> clazz) throws Exception {
 680         final Class[] parameterTypes = { SchemaNode.class, BindingNamespaceType.class };
 681         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("hasBuilderClass", parameterTypes);
 682         assertNotNull(generate);
 683         generate.setAccessible(true);
 684
 685         final T schemaNode = mock(clazz);
 686
 687         final Object[] args = { schemaNode, BindingNamespaceType.Data };
 688         return (boolean) generate.invoke(AuxiliaryGenUtils.class, args);
 689     }
 690 }