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, Map.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         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 461         genCtx.put(parentModule, new ModuleContext());
 462
 463         final Object[] args1 = { typeDef, typeBuilder, leaf, parentModule, typeProvider, schemaContext, new ModuleContext(), genCtx };
 464         final GeneratedTOBuilder result = (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 465         assertEquals(null, result);
 466     }
 467
 468     @Test
 469     public void addTOToTypeBuilderUnionTest() throws Exception {
 470         assertNotNull(addTOToBuilder("/base/test-union.yang"));
 471     }
 472
 473     @Test
 474     public void addTOToTypeBuilderBitsTest() throws Exception {
 475         assertNotNull(addTOToBuilder("/base/test-bits.yang"));
 476     }
 477
 478     @SuppressWarnings({ "rawtypes" })
 479     private GeneratedTOBuilder addTOToBuilder(final String yangPath)
 480             throws NoSuchMethodException, ReactorException, FileNotFoundException, URISyntaxException,
 481             IllegalAccessException, InvocationTargetException {
 482         final Class[] parameterTypes = { TypeDefinition.class, GeneratedTypeBuilder.class, DataSchemaNode.class,
 483                 Module.class, TypeProvider.class, SchemaContext.class, ModuleContext.class, Map.class };
 484         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("addTOToTypeBuilder", parameterTypes);
 485         assertNotNull(generate);
 486         generate.setAccessible(true);
 487
 488         final GeneratedTypeBuilder typeBuilder =
 489                 new GeneratedTypeBuilderImpl("test.boolean.spc.def", "spec-type-def", new ModuleContext());
 490         final SchemaContext schemaContext = YangParserTestUtils.parseYangSource(yangPath);
 491         final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
 492         final LeafSchemaNode leafSchemaNode =
 493                 (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 494         final TypeDefinition<? extends TypeDefinition<?>> typeDef = leafSchemaNode.getType();
 495         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 496         genCtx.put(schemaContext.getModules().iterator().next(), new ModuleContext());
 497
 498         final Object[] args1 = { typeDef, typeBuilder, leafSchemaNode, schemaContext.getModules().iterator().next(),
 499                 typeProvider, schemaContext, new ModuleContext(), genCtx };
 500         return (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 501     }
 502
 503     @SuppressWarnings({ "rawtypes" })
 504     @Test
 505     public void createReturnTypeForUnionTest() throws Exception {
 506         final Class[] parameterTypes = { GeneratedTOBuilder.class, TypeDefinition.class, GeneratedTypeBuilder.class,
 507                 Module.class, TypeProvider.class };
 508         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("createReturnTypeForUnion", parameterTypes);
 509         assertNotNull(generate);
 510         generate.setAccessible(true);
 511
 512         final GeneratedTypeBuilder typeBuilder = new GeneratedTypeBuilderImpl("test.boolean.spc.def",
 513                 "spec-type-def", new ModuleContext());
 514         final SchemaContext schemaContext = YangParserTestUtils.parseYangSource("/base/test-union.yang");
 515         final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
 516         final LeafSchemaNode leafSchemaNode =
 517                 (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 518         final TypeDefinition<? extends TypeDefinition<?>> typeDef = leafSchemaNode.getType();
 519
 520         final Object[] args1 = { addTOToBuilder("/base/test-union.yang"), typeDef, typeBuilder,
 521                 schemaContext.getModules().iterator().next(), typeProvider };
 522         final Type result = (Type) generate.invoke(AuxiliaryGenUtils.class, args1);
 523         assertNotNull(result);
 524     }
 525
 526     @SuppressWarnings({ "rawtypes" })
 527     @Test
 528     public void isInnerTypeTrueTest() throws Exception {
 529         final Class[] parameterTypes = { LeafSchemaNode.class, TypeDefinition.class };
 530         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isInnerType", parameterTypes);
 531         assertNotNull(generate);
 532         generate.setAccessible(true);
 533
 534         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 535         final TypeDefinition type = mock(TypeDefinition.class);
 536         final QName qname = QName.create("namespace", "2017-12-04", "localName");
 537         final SchemaPath path = SchemaPath.create(true, qname);
 538         when(leaf.getPath()).thenReturn(path);
 539         when(type.getPath()).thenReturn(path);
 540
 541         final Object[] args1 = { leaf, type };
 542         boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args1);
 543         assertNotNull(result);
 544         assertTrue(result);
 545
 546         final QName qnameParent = QName.create(qname, "qnameParent");
 547         final SchemaPath parent = SchemaPath.create(true, qname, qnameParent);
 548         when(type.getPath()).thenReturn(parent);
 549
 550         final Object[] args2 = { leaf, type };
 551         result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 552         assertNotNull(result);
 553         assertTrue(result);
 554     }
 555
 556     @SuppressWarnings({ "rawtypes" })
 557     @Test
 558     public void isInnerTypeFalseTest() throws Exception {
 559         final Class[] parameterTypes = { LeafSchemaNode.class, TypeDefinition.class };
 560         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("isInnerType", parameterTypes);
 561         assertNotNull(generate);
 562         generate.setAccessible(true);
 563
 564         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 565         final TypeDefinition type = mock(TypeDefinition.class);
 566         final QName qname = QName.create("namespace", "2017-12-04", "localName");
 567         final SchemaPath path = SchemaPath.create(true, qname);
 568         when(leaf.getPath()).thenReturn(path);
 569
 570         final QName qnameChild = QName.create(qname, "qnameChild");
 571         final QName qnameParent = QName.create(qname, "qnameParent");
 572         final SchemaPath parent = SchemaPath.create(true, qnameChild, qnameParent);
 573
 574         when(type.getPath()).thenReturn(parent);
 575
 576         final Object[] args2 = { leaf, type };
 577         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 578         assertNotNull(result);
 579         assertTrue(!result);
 580     }
 581
 582     @SuppressWarnings({ "rawtypes" })
 583     @Test
 584     public void resolveListKeyTOBuilderTest() throws Exception {
 585         final Class[] parameterTypes = { String.class, ListSchemaNode.class, ModuleContext.class };
 586         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("resolveListKeyTOBuilder", parameterTypes);
 587         assertNotNull(generate);
 588         generate.setAccessible(true);
 589
 590         final String pckgName = "pckg.name.test";
 591         final ListSchemaNode list = mock(ListSchemaNode.class);
 592         final List<QName> keyDefs = new ArrayList<>();
 593         final QName qname = QName.create("namespace", "2017-12-04", "localname");
 594         keyDefs.add(qname);
 595         when(list.getKeyDefinition()).thenReturn(keyDefs);
 596         when(list.getQName()).thenReturn(qname);
 597
 598         final Object[] args1 = { pckgName, list, new ModuleContext() };
 599         final GeneratedTOBuilder result = (GeneratedTOBuilder) generate.invoke(AuxiliaryGenUtils.class, args1);
 600         assertNotNull(result);
 601         assertEquals("LocalnameKey", result.getName());
 602     }
 603
 604     @SuppressWarnings({ "rawtypes" })
 605     @Test
 606     public void resolveLeafSchemaNodeAsPropertyFalseTest() throws Exception {
 607         final Class[] parameterTypes = { String.class, GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
 608         final Method generate =
 609                 AuxiliaryGenUtils.class.getDeclaredMethod("resolveLeafSchemaNodeAsProperty", parameterTypes);
 610         assertNotNull(generate);
 611         generate.setAccessible(true);
 612
 613         final GeneratedTOBuilder gtob = mock(GeneratedTOBuilder.class);
 614         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 615         final boolean isReadOnly = true;
 616         final Type type = null;
 617
 618         final Object[] args2 = { "list", gtob, leaf, type, isReadOnly };
 619         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 620         assertNotNull(result);
 621         assertTrue(!result);
 622     }
 623
 624     @SuppressWarnings({ "rawtypes" })
 625     @Test
 626     public void resolveLeafSchemaNodeAsPropertyTrueTest() throws Exception {
 627         final Class[] parameterTypes = { String.class, GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
 628         final Method generate =
 629                 AuxiliaryGenUtils.class.getDeclaredMethod("resolveLeafSchemaNodeAsProperty", parameterTypes);
 630         assertNotNull(generate);
 631         generate.setAccessible(true);
 632
 633         final GeneratedTOBuilder gtob = new GeneratedTOBuilderImpl("pckg.name.gto.tst", "gto_name", true);
 634         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 635         final boolean isReadOnly = true;
 636         final Type type = mock(Type.class);
 637         when(leaf.getQName()).thenReturn(QName.create("ns", "2017-12-04", "ln"));
 638
 639         final Object[] args2 = { "list", gtob, leaf, type, isReadOnly };
 640         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
 641         assertNotNull(result);
 642         assertTrue(result);
 643     }
 644
 645     @SuppressWarnings({ "rawtypes" })
 646     @Test
 647     public void checkModuleAndModuleNameTest() throws Exception {
 648         final Class[] parameterTypes = { Module.class };
 649         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("checkModuleAndModuleName", parameterTypes);
 650         assertNotNull(generate);
 651         generate.setAccessible(true);
 652
 653         final Module module = mock(Module.class);
 654         when(module.getName()).thenReturn("moduleName");
 655         final Object[] args2 = { module };
 656         generate.invoke(AuxiliaryGenUtils.class, args2);
 657     }
 658
 659     @SuppressWarnings("rawtypes")
 660     private String getterMethodName(final String schemaNodeName, final Type returnType)
 661             throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
 662         final Class[] parameterTypes =
 663                 { String.class, Type.class };
 664         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("getterMethodName", parameterTypes);
 665         assertNotNull(generate);
 666         generate.setAccessible(true);
 667
 668         final Object[] args = { schemaNodeName, returnType };
 669         return (String) generate.invoke(AuxiliaryGenUtils.class, args);
 670     }
 671
 672     @SuppressWarnings("rawtypes")
 673     private <T extends SchemaNode> boolean hasBuilderClass(final Class<T> clazz) throws Exception {
 674         final Class[] parameterTypes = { SchemaNode.class, BindingNamespaceType.class };
 675         final Method generate = AuxiliaryGenUtils.class.getDeclaredMethod("hasBuilderClass", parameterTypes);
 676         assertNotNull(generate);
 677         generate.setAccessible(true);
 678
 679         final T schemaNode = mock(clazz);
 680
 681         final Object[] args = { schemaNode, BindingNamespaceType.Data };
 682         return (boolean) generate.invoke(AuxiliaryGenUtils.class, args);
 683     }
 684 }