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