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