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.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.parseYangSource("/generator/test-list.yang");
 198         final ListSchemaNode containerSchemaNode =
 199                 (ListSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 200         final String fullyQualifiedName =
 201                 "org.opendaylight.mdsal.gen.javav2.urn.test.simple.test.list.rev170314.data.MyList";
 202
 203         final Object[] args = { containerSchemaNode, fullyQualifiedName, schemaContext, true, BindingNamespaceType.Data };
 204         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
 205         assertNotNull(result);
 206         assertTrue(result.contains("list my-list"));
 207         assertTrue(result.contains("leaf key"));
 208         assertTrue(result.contains("leaf key1"));
 209         assertTrue(result.contains("leaf key2"));
 210         assertTrue(result.contains("leaf foo"));
 211         assertTrue(result.contains("@see org.opendaylight.mdsal.gen.javav2.urn.test.simple.test.list.rev170314.dto.MyListBuilder"));
 212         assertTrue(result.contains("@see org.opendaylight.mdsal.gen.javav2.urn.test.simple.test.list.rev170314.key.my_list.MyListKey"));
 213     }
 214
 215     @SuppressWarnings("rawtypes")
 216     @Test
 217     public void createDescriptionWithSchemaNodeWithDescriptionTest() throws Exception {
 218         final Class[] parameterTypes = { SchemaNode.class, String.class, SchemaContext.class, boolean.class,
 219                 BindingNamespaceType.class};
 220         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createDescription", parameterTypes);
 221         assertNotNull(generate);
 222         generate.setAccessible(true);
 223
 224         final SchemaContext schemaContext =
 225                 YangParserTestUtils.parseYangSource("/base/test-leaf-with-description.yang");
 226         final LeafSchemaNode containerSchemaNode =
 227                 (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 228         final String fullyQualifiedName = "test.base.cont.with.leaf.MyList";
 229
 230         final Object[] args = { containerSchemaNode, fullyQualifiedName, schemaContext, true, BindingNamespaceType.Data};
 231         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
 232         assertNotNull(result);
 233         assertTrue(result.contains("I am leaf."));
 234     }
 235
 236     @SuppressWarnings("rawtypes")
 237     @Test
 238     public void createDescriptionTest() throws Exception {
 239         final Class[] parameterTypes = { Module.class, boolean.class };
 240         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createDescription", parameterTypes);
 241         assertNotNull(generate);
 242         generate.setAccessible(true);
 243
 244         final SchemaContext schemaContext = YangParserTestUtils.parseYangSource("/base/test-module.yang");
 245
 246         final Object[] args = { schemaContext.getModules().iterator().next(), true };
 247         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
 248         assertNotNull(result);
 249         assertTrue(result.contains("Base test module description"));
 250         assertTrue(result.contains("test-module"));
 251     }
 252
 253     @SuppressWarnings({ "rawtypes", "unchecked" })
 254     @Test
 255     public void createDescriptionWithSchemaNodesTest() throws Exception {
 256         final Class[] parameterTypes = { Set.class, Module.class, boolean.class };
 257         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createDescription", parameterTypes);
 258         assertNotNull(generate);
 259         generate.setAccessible(true);
 260
 261         final SchemaContext schemaContext = YangParserTestUtils.parseYangSource("/base/test-rpc-and-notification.yang");
 262         final Module module = schemaContext.getModules().iterator().next();
 263         Set schemaNodes = new HashSet<>();
 264         schemaNodes.add(module.getRpcs().iterator().next());
 265
 266         final Object[] args = { schemaNodes, module, true };
 267         String result = (String) generate.invoke(AuxiliaryGenUtils.class, args);
 268         assertNotNull(result);
 269         assertTrue(result.contains(
 270                 "Interface for implementing the following YANG RPCs defined in module <b>test-rpc-and-notification-module</b>"));
 271         assertTrue(result.contains("rpc my-rpc"));
 272         assertTrue(!result.contains("notification my-notification"));
 273
 274         schemaNodes = new HashSet<>();
 275         schemaNodes.add(module.getNotifications().iterator().next());
 276
 277         final Object[] args_n = { schemaNodes, module, true };
 278         result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
 279         assertNotNull(result);
 280         assertTrue(result.contains(
 281                 "Interface for receiving the following YANG notifications defined in module <b>test-rpc-and-notification-module</b>"));
 282         assertTrue(!result.contains("rpc my-rpc"));
 283         assertTrue(result.contains("notification my-notification"));
 284     }
 285
 286     @SuppressWarnings({ "rawtypes" })
 287     @Test
 288     public void isNullOrEmptyIsNullTest() throws Exception {
 289         final Class[] parameterTypes = { Collection.class };
 290         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isNullOrEmpty", parameterTypes);
 291         assertNotNull(generate);
 292         generate.setAccessible(true);
 293
 294         final Collection list = null;
 295
 296         final Object[] args_n = { list };
 297         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args_n);
 298         assertTrue(result);
 299     }
 300
 301     @SuppressWarnings({ "rawtypes" })
 302     @Test
 303     public void isNullOrEmptyIsEmptyTest() throws Exception {
 304         final Class[] parameterTypes = { Collection.class };
 305         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isNullOrEmpty", parameterTypes);
 306         assertNotNull(generate);
 307         generate.setAccessible(true);
 308
 309         final Collection list = new ArrayList<>();
 310
 311         final Object[] args_n = { list };
 312         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args_n);
 313         assertTrue(result);
 314     }
 315
 316     @SuppressWarnings({ "rawtypes", "unchecked" })
 317     @Test
 318     public void isNullOrEmptyNotNullNotEmptyTest() throws Exception {
 319         final Class[] parameterTypes = { Collection.class };
 320         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isNullOrEmpty", parameterTypes);
 321         assertNotNull(generate);
 322         generate.setAccessible(true);
 323
 324         final Collection list = new ArrayList<>();
 325         list.add(new Object());
 326
 327         final Object[] args_n = { list };
 328         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args_n);
 329         assertTrue(!result);
 330     }
 331
 332     @SuppressWarnings({ "rawtypes" })
 333     @Test
 334     public void augGenTypeNameTest() throws Exception {
 335         final Class[] parameterTypes = { Map.class, String.class };
 336         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("augGenTypeName", parameterTypes);
 337         assertNotNull(generate);
 338         generate.setAccessible(true);
 339
 340         final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
 341         builders.put("genTypeName1", new GeneratedTypeBuilderImpl("pckg.a1", "gen_a_1", new ModuleContext()));
 342         builders.put("genTypeName2", new GeneratedTypeBuilderImpl("pckg.a2", "gen_a_2", new ModuleContext()));
 343         final String genTypeName = "genTypeName";
 344
 345         final Object[] args_n = { builders, genTypeName };
 346         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
 347         assertEquals("genTypeName3", result);
 348     }
 349
 350     @SuppressWarnings({ "rawtypes" })
 351     @Test
 352     public void getAugmentIdentifierNullTest() throws Exception {
 353         final Class[] parameterTypes = { List.class };
 354         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("getAugmentIdentifier", parameterTypes);
 355         assertNotNull(generate);
 356         generate.setAccessible(true);
 357
 358         final List<UnknownSchemaNode> list = new ArrayList<>();
 359
 360         final Object[] args_n = { list };
 361         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
 362         assertEquals(null, result);
 363     }
 364
 365     @SuppressWarnings({ "rawtypes" })
 366     @Test
 367     public void getAugmentIdentifierTest() throws Exception {
 368         final Class[] parameterTypes = { List.class };
 369         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("getAugmentIdentifier", parameterTypes);
 370         assertNotNull(generate);
 371         generate.setAccessible(true);
 372
 373         final List<UnknownSchemaNode> list = new ArrayList<>();
 374         final UnknownSchemaNode unknownSchemaNode = mock(UnknownSchemaNode.class);
 375         final QName qname =
 376                 QName.create("urn:opendaylight:yang:extension:yang-ext", "2017-10-04", "augment-identifier");
 377         when(unknownSchemaNode.getNodeType()).thenReturn(qname);
 378         final String value = "node parameter";
 379         when(unknownSchemaNode.getNodeParameter()).thenReturn(value);
 380         list.add(unknownSchemaNode);
 381
 382         final Object[] args_n = { list };
 383         final String result = (String) generate.invoke(AuxiliaryGenUtils.class, args_n);
 384         assertEquals(value, result);
 385     }
 386
 387     @SuppressWarnings({ "rawtypes" })
 388     @Test
 389     public void resolveInnerEnumFromTypeDefinitionNullTest() throws Exception {
 390         final Class[] parameterTypes =
 391                 { EnumTypeDefinition.class, QName.class, Map.class, GeneratedTypeBuilder.class, Module.class };
 392         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("resolveInnerEnumFromTypeDefinition", parameterTypes);
 393         assertNotNull(generate);
 394         generate.setAccessible(true);
 395
 396         EnumTypeDefinition enumTypeDefinition = null;
 397         final QName qname = null;
 398         final GeneratedTypeBuilder gtb = null;
 399         final Map map = new HashMap<>();
 400         final Module module = null;
 401
 402         final Object[] args_n = { enumTypeDefinition, qname, map, gtb, module };
 403         EnumBuilder result = (EnumBuilder) generate.invoke(AuxiliaryGenUtils.class, args_n);
 404         assertEquals(null, result);
 405
 406         enumTypeDefinition = mock(EnumTypeDefinition.class);
 407         final Object[] args1 = { enumTypeDefinition, qname, map, gtb, module };
 408         result = (EnumBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 409         assertEquals(null, result);
 410     }
 411
 412     @SuppressWarnings({ "rawtypes" })
 413     @Test
 414     public void resolveInnerEnumFromTypeDefinitionTest() throws Exception {
 415         final Class[] parameterTypes =
 416                 { EnumTypeDefinition.class, QName.class, Map.class, GeneratedTypeBuilder.class, Module.class };
 417         final Method generate =
 418                 AuxiliaryGenUtils.class.getDeclaredMethod("resolveInnerEnumFromTypeDefinition", parameterTypes);
 419         assertNotNull(generate);
 420         generate.setAccessible(true);
 421
 422         final QName qname = QName.create("urn:enum:test", "2017-12-04", "enum-test");
 423         final EnumTypeDefinition enumTypeDefinition = mock(EnumTypeDefinition.class);
 424         final QName enumQName = QName.create(qname, "enum-qname-test");
 425         when(enumTypeDefinition.getQName()).thenReturn(enumQName);
 426         final SchemaPath schemaPath = SchemaPath.create(true, enumQName);
 427         when(enumTypeDefinition.getPath()).thenReturn(schemaPath);
 428         final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl("urn.enum.test.pckg", "enum-test", new ModuleContext());
 429         final Map<Module, ModuleContext> map = new HashMap<>();
 430         final Module module = mock(Module.class);
 431         final ModuleContext moduleContext = new ModuleContext();
 432         map.put(module, moduleContext);
 433
 434         final Object[] args1 = { enumTypeDefinition, qname, map, gtb, module };
 435         final EnumBuilder result = (EnumBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 436         assertNotNull(result);
 437     }
 438
 439     @SuppressWarnings({ "rawtypes" })
 440     @Test
 441     public void addTOToTypeBuilderNullTest() throws Exception {
 442         final Class[] parameterTypes =
 443                 { TypeDefinition.class, GeneratedTypeBuilder.class, DataSchemaNode.class, Module.class,
 444                         TypeProvider.class, SchemaContext.class, ModuleContext.class };
 445         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("addTOToTypeBuilder", parameterTypes);
 446         assertNotNull(generate);
 447         generate.setAccessible(true);
 448
 449         final BooleanTypeDefinition typeDef = mock(BooleanTypeDefinition.class);
 450         final GeneratedTypeBuilder typeBuilder =
 451                 new GeneratedTypeBuilderImpl("test.boolean.type.def", "boolean-type-def", new ModuleContext());
 452         final DataSchemaNode leaf = mock(DataSchemaNode.class);
 453         final QName qnameLeaf = QName.create("urn:leaf:qname:test", "2017-12-04", "leaf-qname-test");
 454         when(leaf.getQName()).thenReturn(qnameLeaf);
 455         final Module parentModule = mock(Module.class);
 456         final SchemaContext schemaContext = mock(SchemaContext.class);
 457         final Set<Module> modules = new HashSet<>();
 458         when(schemaContext.getModules()).thenReturn(modules);
 459         final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
 460
 461         final Object[] args1 = { typeDef, typeBuilder, leaf, parentModule, typeProvider, schemaContext, new ModuleContext() };
 462         final GeneratedTOBuilder result = (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 463         assertEquals(null, result);
 464     }
 465
 466     @Test
 467     public void addTOToTypeBuilderUnionTest() throws Exception {
 468         assertNotNull(addTOToBuilder("/base/test-union.yang"));
 469     }
 470
 471     @Test
 472     public void addTOToTypeBuilderBitsTest() throws Exception {
 473         assertNotNull(addTOToBuilder("/base/test-bits.yang"));
 474     }
 475
 476     @SuppressWarnings({ "rawtypes" })
 477     private GeneratedTOBuilder addTOToBuilder(final String yangPath)
 478             throws NoSuchMethodException, ReactorException, FileNotFoundException, URISyntaxException,
 479             IllegalAccessException, InvocationTargetException {
 480         final Class[] parameterTypes = { TypeDefinition.class, GeneratedTypeBuilder.class, DataSchemaNode.class,
 481                 Module.class, TypeProvider.class, SchemaContext.class, ModuleContext.class };
 482         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("addTOToTypeBuilder", parameterTypes);
 483         assertNotNull(generate);
 484         generate.setAccessible(true);
 485
 486         final GeneratedTypeBuilder typeBuilder =
 487                 new GeneratedTypeBuilderImpl("test.boolean.spc.def", "spec-type-def", new ModuleContext());
 488         final SchemaContext schemaContext = YangParserTestUtils.parseYangSource(yangPath);
 489         final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
 490         final LeafSchemaNode leafSchemaNode =
 491                 (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 492         final TypeDefinition<? extends TypeDefinition<?>> typeDef = leafSchemaNode.getType();
 493         final Object[] args1 = { typeDef, typeBuilder, leafSchemaNode, schemaContext.getModules().iterator().next(),
 494                 typeProvider, schemaContext, new ModuleContext() };
 495         return (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 496     }
 497
 498     @SuppressWarnings({ "rawtypes" })
 499     @Test
 500     public void createReturnTypeForUnionTest() throws Exception {
 501         final Class[] parameterTypes = { GeneratedTOBuilder.class, TypeDefinition.class, GeneratedTypeBuilder.class,
 502                 Module.class, TypeProvider.class };
 503         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createReturnTypeForUnion", parameterTypes);
 504         assertNotNull(generate);
 505         generate.setAccessible(true);
 506
 507         final GeneratedTypeBuilder typeBuilder = new GeneratedTypeBuilderImpl("test.boolean.spc.def",
 508                 "spec-type-def", new ModuleContext());
 509         final SchemaContext schemaContext = YangParserTestUtils.parseYangSource("/base/test-union.yang");
 510         final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
 511         final LeafSchemaNode leafSchemaNode =
 512                 (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 513         final TypeDefinition<? extends TypeDefinition<?>> typeDef = leafSchemaNode.getType();
 514
 515         final Object[] args1 = { addTOToBuilder("/base/test-union.yang"), typeDef, typeBuilder,
 516                 schemaContext.getModules().iterator().next(), typeProvider };
 517         final Type result = (Type) generate.invoke(AuxiliaryGenUtils.class, args1);
 518         assertNotNull(result);
 519     }
 520
 521     @SuppressWarnings({ "rawtypes" })
 522     @Test
 523     public void isInnerTypeTrueTest() throws Exception {
 524         final Class[] parameterTypes = { LeafSchemaNode.class, TypeDefinition.class };
 525         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isInnerType", parameterTypes);
 526         assertNotNull(generate);
 527         generate.setAccessible(true);
 528
 529         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 530         final TypeDefinition type = mock(TypeDefinition.class);
 531         final QName qname = QName.create("namespace", "2017-12-04", "localName");
 532         final SchemaPath path = SchemaPath.create(true, qname);
 533         when(leaf.getPath()).thenReturn(path);
 534         when(type.getPath()).thenReturn(path);
 535
 536         final Object[] args1 = { leaf, type };
 537         boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args1);
 538         assertNotNull(result);
 539         assertTrue(result);
 540
 541         final QName qnameParent = QName.create(qname, "qnameParent");
 542         final SchemaPath parent = SchemaPath.create(true, qname, qnameParent);
 543         when(type.getPath()).thenReturn(parent);
 544
 545         final Object[] args2 = { leaf, type };
 546         result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 547         assertNotNull(result);
 548         assertTrue(result);
 549     }
 550
 551     @SuppressWarnings({ "rawtypes" })
 552     @Test
 553     public void isInnerTypeFalseTest() throws Exception {
 554         final Class[] parameterTypes = { LeafSchemaNode.class, TypeDefinition.class };
 555         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isInnerType", parameterTypes);
 556         assertNotNull(generate);
 557         generate.setAccessible(true);
 558
 559         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 560         final TypeDefinition type = mock(TypeDefinition.class);
 561         final QName qname = QName.create("namespace", "2017-12-04", "localName");
 562         final SchemaPath path = SchemaPath.create(true, qname);
 563         when(leaf.getPath()).thenReturn(path);
 564
 565         final QName qnameChild = QName.create(qname, "qnameChild");
 566         final QName qnameParent = QName.create(qname, "qnameParent");
 567         final SchemaPath parent = SchemaPath.create(true, qnameChild, qnameParent);
 568
 569         when(type.getPath()).thenReturn(parent);
 570
 571         final Object[] args2 = { leaf, type };
 572         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 573         assertNotNull(result);
 574         assertTrue(!result);
 575     }
 576
 577     @SuppressWarnings({ "rawtypes" })
 578     @Test
 579     public void resolveListKeyTOBuilderTest() throws Exception {
 580         final Class[] parameterTypes = { String.class, ListSchemaNode.class, ModuleContext.class };
 581         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("resolveListKeyTOBuilder", parameterTypes);
 582         assertNotNull(generate);
 583         generate.setAccessible(true);
 584
 585         final String pckgName = "pckg.name.test";
 586         final ListSchemaNode list = mock(ListSchemaNode.class);
 587         final List<QName> keyDefs = new ArrayList<>();
 588         final QName qname = QName.create("namespace", "2017-12-04", "localname");
 589         keyDefs.add(qname);
 590         when(list.getKeyDefinition()).thenReturn(keyDefs);
 591         when(list.getQName()).thenReturn(qname);
 592
 593         final Object[] args1 = { pckgName, list, new ModuleContext() };
 594         final GeneratedTOBuilder result = (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 595         assertNotNull(result);
 596         assertEquals("LocalnameKey", result.getName());
 597     }
 598
 599     @SuppressWarnings({ "rawtypes" })
 600     @Test
 601     public void resolveLeafSchemaNodeAsPropertyFalseTest() throws Exception {
 602         final Class[] parameterTypes = { String.class, GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
 603         final Method generate =
 604                 AuxiliaryGenUtils.class.getDeclaredMethod("resolveLeafSchemaNodeAsProperty", parameterTypes);
 605         assertNotNull(generate);
 606         generate.setAccessible(true);
 607
 608         final GeneratedTOBuilder gtob = mock(GeneratedTOBuilder.class);
 609         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 610         final boolean isReadOnly = true;
 611         final Type type = null;
 612
 613         final Object[] args2 = { "list", gtob, leaf, type, isReadOnly };
 614         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 615         assertNotNull(result);
 616         assertTrue(!result);
 617     }
 618
 619     @SuppressWarnings({ "rawtypes" })
 620     @Test
 621     public void resolveLeafSchemaNodeAsPropertyTrueTest() throws Exception {
 622         final Class[] parameterTypes = { String.class, GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
 623         final Method generate =
 624                 AuxiliaryGenUtils.class.getDeclaredMethod("resolveLeafSchemaNodeAsProperty", parameterTypes);
 625         assertNotNull(generate);
 626         generate.setAccessible(true);
 627
 628         final GeneratedTOBuilder gtob = new GeneratedTOBuilderImpl("pckg.name.gto.tst", "gto_name", true);
 629         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 630         final boolean isReadOnly = true;
 631         final Type type = mock(Type.class);
 632         when(leaf.getQName()).thenReturn(QName.create("ns", "2017-12-04", "ln"));
 633
 634         final Object[] args2 = { "list", gtob, leaf, type, isReadOnly };
 635         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 636         assertNotNull(result);
 637         assertTrue(result);
 638     }
 639
 640     @SuppressWarnings({ "rawtypes" })
 641     @Test
 642     public void checkModuleAndModuleNameTest() throws Exception {
 643         final Class[] parameterTypes = { Module.class };
 644         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("checkModuleAndModuleName", parameterTypes);
 645         assertNotNull(generate);
 646         generate.setAccessible(true);
 647
 648         final Module module = mock(Module.class);
 649         when(module.getName()).thenReturn("moduleName");
 650         final Object[] args2 = { module };
 651         generate.invoke(AuxiliaryGenUtils.class, args2);
 652     }
 653
 654     @SuppressWarnings("rawtypes")
 655     private String getterMethodName(final String schemaNodeName, final Type returnType)
 656             throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
 657         final Class[] parameterTypes =
 658                 { String.class, Type.class };
 659         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("getterMethodName", parameterTypes);
 660         assertNotNull(generate);
 661         generate.setAccessible(true);
 662
 663         final Object[] args = { schemaNodeName, returnType };
 664         return (String) generate.invoke(AuxiliaryGenUtils.class, args);
 665     }
 666
 667     @SuppressWarnings("rawtypes")
 668     private <T extends SchemaNode> boolean hasBuilderClass(final Class<T> clazz) throws Exception {
 669         final Class[] parameterTypes = { SchemaNode.class, BindingNamespaceType.class };
 670         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("hasBuilderClass", parameterTypes);
 671         assertNotNull(generate);
 672         generate.setAccessible(true);
 673
 674         final T schemaNode = mock(clazz);
 675
 676         final Object[] args = { schemaNode, BindingNamespaceType.Data };
 677         return (boolean) generate.invoke(AuxiliaryGenUtils.class, args);
 678     }
 679 }