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