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.assertFalse;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertNull;
  14 import static org.junit.Assert.assertTrue;
  15 import static org.mockito.Mockito.mock;
  16 import static org.mockito.Mockito.when;
  17
  18 import java.lang.reflect.Constructor;
  19 import java.util.ArrayList;
  20 import java.util.Collection;
  21 import java.util.HashMap;
  22 import java.util.HashSet;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Optional;
  26 import java.util.Set;
  27 import org.junit.Test;
  28 import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
  29 import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
  30 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
  31 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
  32 import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
  33 import org.opendaylight.mdsal.binding.javav2.model.api.Constant;
  34 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
  35 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder;
  36 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTOBuilder;
  37 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
  38 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilderBase;
  39 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.MethodSignatureBuilder;
  40 import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
  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.test.util.YangParserTestUtils;
  58
  59 public class AuxiliaryGenUtilsTest {
  60
  61     @Test(expected = UnsupportedOperationException.class)
  62     public void constructorTest() throws Throwable {
  63         final Constructor<AuxiliaryGenUtils> constructor = AuxiliaryGenUtils.class.getDeclaredConstructor();
  64         constructor.setAccessible(true);
  65         try {
  66             constructor.newInstance();
  67         } catch (final Exception e) {
  68             throw e.getCause();
  69         }
  70     }
  71
  72     @Test
  73     public void annotateDeprecatedIfNecessaryNonDepricatedTest() {
  74         final GeneratedTypeBuilderImpl generatedTypeBuilder =
  75                 new GeneratedTypeBuilderImpl("test.deprecated", "Non_Deprecated", new ModuleContext());
  76         final Status status = Status.CURRENT;
  77
  78         AuxiliaryGenUtils.annotateDeprecatedIfNecessary(status, generatedTypeBuilder);
  79         assertTrue(generatedTypeBuilder.toInstance().getAnnotations().isEmpty());
  80     }
  81
  82     @Test
  83     public void annotateDeprecatedIfNecessaryDepricatedTest() {
  84         final GeneratedTypeBuilderImpl generatedTypeBuilder =
  85                 new GeneratedTypeBuilderImpl("test.deprecated", "Deprecated", new ModuleContext());
  86         final Status status = Status.DEPRECATED;
  87
  88         AuxiliaryGenUtils.annotateDeprecatedIfNecessary(status, generatedTypeBuilder);
  89         assertFalse(generatedTypeBuilder.toInstance().getAnnotations().isEmpty());
  90         assertEquals("Deprecated", generatedTypeBuilder.toInstance().getAnnotations().get(0).getName());
  91     }
  92
  93     @Test
  94     public void hasBuilderClassFalseTest() {
  95         assertEquals(false, hasBuilderClass(LeafSchemaNode.class));
  96     }
  97
  98     @Test
  99     public void hasBuilderClassContainerTest() {
 100         assertEquals(true, hasBuilderClass(ContainerSchemaNode.class));
 101     }
 102
 103     @Test
 104     public void hasBuilderClassListTest() {
 105         assertEquals(true, hasBuilderClass(ListSchemaNode.class));
 106     }
 107
 108     @Test
 109     public void hasBuilderClassRpcTest() {
 110         assertEquals(true, hasBuilderClass(RpcDefinition.class));
 111     }
 112
 113     @Test
 114     public void hasBuilderClassNotificationTest() {
 115         assertEquals(true, hasBuilderClass(NotificationDefinition.class));
 116     }
 117
 118     @Test
 119     public void qNameConstantTest() {
 120         final GeneratedTypeBuilderBase<?> gtbb = new GeneratedTypeBuilderImpl("test", "qname_constants",
 121             new ModuleContext());
 122         final String constantName = "ConstantName";
 123         final QName constantQName = QName.create("urn:constant", "2017-04-06", constantName);
 124
 125         final Constant result = AuxiliaryGenUtils.qNameConstant(gtbb, constantName, constantQName);
 126         assertEquals(constantName, result.getName());
 127     }
 128
 129     @Test
 130     public void constructGetterTest() {
 131         final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl("test", "Getter_of", new ModuleContext());
 132         final String schemaNodeName = "schema_node_getter";
 133         final String comment = null;
 134         final Type returnType = Types.STRING;
 135         final Status status = Status.DEPRECATED;
 136
 137         final MethodSignatureBuilder result = AuxiliaryGenUtils.constructGetter(gtb, schemaNodeName, comment,
 138             returnType, status);
 139         assertEquals("getSchemaNodeGetter", result.toInstance(returnType).getName());
 140     }
 141
 142     @Test
 143     public void getterMethodNameBooleanTest() throws Exception {
 144         assertEquals("isBooleanMethod", AuxiliaryGenUtils.getterMethodName("boolean_method", Types.BOOLEAN));
 145     }
 146
 147     @Test
 148     public void getterMethodNameTest() throws Exception {
 149         assertEquals("getClazz", AuxiliaryGenUtils.getterMethodName("clazz", Types.CLASS));
 150     }
 151
 152     @Test
 153     public void isNullOrEmptyIsNullTest() {
 154         assertTrue(AuxiliaryGenUtils.isNullOrEmpty(null));
 155     }
 156
 157     @Test
 158     public void isNullOrEmptyIsEmptyTest() {
 159         assertTrue(AuxiliaryGenUtils.isNullOrEmpty(new ArrayList<>()));
 160     }
 161
 162     @Test
 163     public void isNullOrEmptyNotNullNotEmptyTest() {
 164         final Collection<Object> list = new ArrayList<>();
 165         list.add(new Object());
 166         assertFalse(AuxiliaryGenUtils.isNullOrEmpty(list));
 167     }
 168
 169     @Test
 170     public void augGenTypeNameTest() {
 171         final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
 172         builders.put("genTypeName1", new GeneratedTypeBuilderImpl("pckg.a1", "gen_a_1", new ModuleContext()));
 173         builders.put("genTypeName2", new GeneratedTypeBuilderImpl("pckg.a2", "gen_a_2", new ModuleContext()));
 174         final String genTypeName = "genTypeName";
 175         assertEquals("genTypeName3", AuxiliaryGenUtils.augGenTypeName(builders, genTypeName));
 176     }
 177
 178     @Test
 179     public void getAugmentIdentifierNullTest() {
 180         assertNull(AuxiliaryGenUtils.getAugmentIdentifier(new ArrayList<>()));
 181     }
 182
 183     @Test
 184     public void getAugmentIdentifierTest() {
 185         final List<UnknownSchemaNode> list = new ArrayList<>();
 186         final UnknownSchemaNode unknownSchemaNode = mock(UnknownSchemaNode.class);
 187         final QName qname =
 188                 QName.create("urn:opendaylight:yang:extension:yang-ext", "2017-10-04", "augment-identifier");
 189         when(unknownSchemaNode.getNodeType()).thenReturn(qname);
 190         final String value = "node parameter";
 191         when(unknownSchemaNode.getNodeParameter()).thenReturn(value);
 192         list.add(unknownSchemaNode);
 193
 194         assertEquals(value, AuxiliaryGenUtils.getAugmentIdentifier(list));
 195     }
 196
 197     @Test
 198     public void resolveInnerEnumFromTypeDefinitionNullTest() {
 199         EnumTypeDefinition enumTypeDefinition = null;
 200         final QName qname = null;
 201         final GeneratedTypeBuilder gtb = null;
 202         final Map<Module, ModuleContext> map = new HashMap<>();
 203         final Module module = null;
 204
 205         EnumBuilder result = AuxiliaryGenUtils.resolveInnerEnumFromTypeDefinition(enumTypeDefinition, qname, map, gtb,
 206             module);
 207         assertEquals(null, result);
 208
 209         enumTypeDefinition = mock(EnumTypeDefinition.class);
 210         result = AuxiliaryGenUtils.resolveInnerEnumFromTypeDefinition(enumTypeDefinition, qname, map, gtb, module);
 211         assertEquals(null, result);
 212     }
 213
 214     @Test
 215     public void resolveInnerEnumFromTypeDefinitionTest() {
 216         final QName qname = QName.create("urn:enum:test", "2017-12-04", "enum-test");
 217         final EnumTypeDefinition enumTypeDefinition = mock(EnumTypeDefinition.class);
 218         final QName enumQName = QName.create(qname, "enum-qname-test");
 219         when(enumTypeDefinition.getQName()).thenReturn(enumQName);
 220         final SchemaPath schemaPath = SchemaPath.create(true, enumQName);
 221         when(enumTypeDefinition.getPath()).thenReturn(schemaPath);
 222         when(enumTypeDefinition.getDescription()).thenReturn(Optional.empty());
 223         when(enumTypeDefinition.getReference()).thenReturn(Optional.empty());
 224         final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl("urn.enum.test.pckg", "enum-test",
 225             new ModuleContext());
 226         final Map<Module, ModuleContext> map = new HashMap<>();
 227         final Module module = mock(Module.class);
 228         final ModuleContext moduleContext = new ModuleContext();
 229         map.put(module, moduleContext);
 230
 231         final EnumBuilder result = AuxiliaryGenUtils.resolveInnerEnumFromTypeDefinition(enumTypeDefinition, qname, map,
 232             gtb, module);
 233         assertNotNull(result);
 234     }
 235
 236     @Test
 237     public void addTOToTypeBuilderNullTest() {
 238         final BooleanTypeDefinition typeDef = mock(BooleanTypeDefinition.class);
 239         final GeneratedTypeBuilder typeBuilder =
 240                 new GeneratedTypeBuilderImpl("test.boolean.type.def", "boolean-type-def", new ModuleContext());
 241         final DataSchemaNode leaf = mock(DataSchemaNode.class);
 242         final QName qnameLeaf = QName.create("urn:leaf:qname:test", "2017-12-04", "leaf-qname-test");
 243         when(leaf.getQName()).thenReturn(qnameLeaf);
 244         final Module parentModule = mock(Module.class);
 245         final SchemaContext schemaContext = mock(SchemaContext.class);
 246         final Set<Module> modules = new HashSet<>();
 247         when(schemaContext.getModules()).thenReturn(modules);
 248         final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
 249         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 250         genCtx.put(parentModule, new ModuleContext());
 251
 252         final GeneratedTOBuilder result = AuxiliaryGenUtils.addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule,
 253             typeProvider, schemaContext, new ModuleContext(), genCtx);
 254         assertEquals(null, result);
 255     }
 256
 257     @Test
 258     public void addTOToTypeBuilderUnionTest() {
 259         assertNotNull(addTOToBuilder("/base/test-union.yang"));
 260     }
 261
 262     @Test
 263     public void addTOToTypeBuilderBitsTest() {
 264         assertNotNull(addTOToBuilder("/base/test-bits.yang"));
 265     }
 266
 267     private static GeneratedTOBuilder addTOToBuilder(final String yangPath) {
 268         final GeneratedTypeBuilder typeBuilder = new GeneratedTypeBuilderImpl("test.boolean.spc.def", "spec-type-def",
 269             new ModuleContext());
 270         final SchemaContext schemaContext = YangParserTestUtils.parseYangResource(yangPath);
 271         final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
 272         final LeafSchemaNode leafSchemaNode =
 273                 (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 274         final TypeDefinition<? extends TypeDefinition<?>> typeDef = leafSchemaNode.getType();
 275         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 276         genCtx.put(schemaContext.getModules().iterator().next(), new ModuleContext());
 277
 278         return AuxiliaryGenUtils.addTOToTypeBuilder(typeDef, typeBuilder, leafSchemaNode,
 279             schemaContext.getModules().iterator().next(), typeProvider, schemaContext, new ModuleContext(), genCtx);
 280     }
 281
 282     @Test
 283     public void createReturnTypeForUnionTest() {
 284         final GeneratedTypeBuilder typeBuilder = new GeneratedTypeBuilderImpl("test.boolean.spc.def",
 285                 "spec-type-def", new ModuleContext());
 286         final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/base/test-union.yang");
 287         final TypeProviderImpl typeProvider = new TypeProviderImpl(schemaContext);
 288         final LeafSchemaNode leafSchemaNode =
 289                 (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
 290         final TypeDefinition<? extends TypeDefinition<?>> typeDef = leafSchemaNode.getType();
 291
 292         final Type result = AuxiliaryGenUtils.createReturnTypeForUnion(addTOToBuilder("/base/test-union.yang"), typeDef,
 293             typeBuilder, schemaContext.getModules().iterator().next(), typeProvider, false);
 294         assertNotNull(result);
 295     }
 296
 297     @Test
 298     public void isInnerTypeTrueTest() {
 299         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 300         final TypeDefinition<?> type = mock(TypeDefinition.class);
 301         final QName qname = QName.create("namespace", "2017-12-04", "localName");
 302         final SchemaPath path = SchemaPath.create(true, qname);
 303         when(leaf.getPath()).thenReturn(path);
 304         when(type.getPath()).thenReturn(path);
 305
 306         assertTrue(AuxiliaryGenUtils.isInnerType(leaf, type));
 307
 308         final QName qnameParent = QName.create(qname, "qnameParent");
 309         final SchemaPath parent = SchemaPath.create(true, qname, qnameParent);
 310         when(type.getPath()).thenReturn(parent);
 311
 312         assertTrue(AuxiliaryGenUtils.isInnerType(leaf, type));
 313     }
 314
 315     @Test
 316     public void isInnerTypeFalseTest() {
 317         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 318         final TypeDefinition<?> type = mock(TypeDefinition.class);
 319         final QName qname = QName.create("namespace", "2017-12-04", "localName");
 320         final SchemaPath path = SchemaPath.create(true, qname);
 321         when(leaf.getPath()).thenReturn(path);
 322
 323         final QName qnameChild = QName.create(qname, "qnameChild");
 324         final QName qnameParent = QName.create(qname, "qnameParent");
 325         final SchemaPath parent = SchemaPath.create(true, qnameChild, qnameParent);
 326
 327         when(type.getPath()).thenReturn(parent);
 328
 329         assertFalse(AuxiliaryGenUtils.isInnerType(leaf, type));
 330     }
 331
 332     @Test
 333     public void resolveListKeyTOBuilderTest() {
 334         final String pckgName = "pckg.name.test";
 335         final ListSchemaNode list = mock(ListSchemaNode.class);
 336         final List<QName> keyDefs = new ArrayList<>();
 337         final QName qname = QName.create("namespace", "2017-12-04", "localname");
 338         keyDefs.add(qname);
 339         when(list.getKeyDefinition()).thenReturn(keyDefs);
 340         when(list.getQName()).thenReturn(qname);
 341
 342         final GeneratedTOBuilder result = AuxiliaryGenUtils.resolveListKeyTOBuilder(pckgName, list,
 343             new ModuleContext());
 344         assertNotNull(result);
 345         assertEquals("LocalnameKey", result.getName());
 346     }
 347
 348     @Test
 349     public void resolveLeafSchemaNodeAsPropertyFalseTest() {
 350         final GeneratedTOBuilder gtob = mock(GeneratedTOBuilder.class);
 351         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 352         final boolean isReadOnly = true;
 353         final Type type = null;
 354
 355         assertFalse(AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty("list", gtob, leaf, type, isReadOnly));
 356     }
 357
 358     @Test
 359     public void resolveLeafSchemaNodeAsPropertyTrueTest() {
 360         final GeneratedTOBuilder gtob = new GeneratedTOBuilderImpl("pckg.name.gto.tst", "gto_name", true);
 361         final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
 362         when(leaf.getDescription()).thenReturn(Optional.empty());
 363         when(leaf.getReference()).thenReturn(Optional.empty());
 364
 365         final boolean isReadOnly = true;
 366         final Type type = mock(Type.class);
 367         when(leaf.getQName()).thenReturn(QName.create("ns", "2017-12-04", "ln"));
 368
 369         assertTrue(AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty("list", gtob, leaf, type, isReadOnly));
 370     }
 371
 372     @Test
 373     public void checkModuleAndModuleNameTest() {
 374         final Module module = mock(Module.class);
 375         when(module.getName()).thenReturn("moduleName");
 376         AuxiliaryGenUtils.checkModuleAndModuleName(module);
 377     }
 378
 379     private static <T extends SchemaNode> boolean hasBuilderClass(final Class<T> clazz) {
 380         return AuxiliaryGenUtils.hasBuilderClass(mock(clazz), BindingNamespaceType.Data);
 381     }
 382 }