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