binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/GeneratedTypeBuilderTest.java

   1 /*
   2  * Copyright (c) 2014 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.model.util.generated.type.builder;
   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.assertTrue;
  14
  15 import java.io.Serializable;
  16 import java.util.List;
  17 import org.junit.Test;
  18 import org.opendaylight.mdsal.binding.model.api.Constant;
  19 import org.opendaylight.mdsal.binding.model.api.Enumeration;
  20 import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
  21 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
  22 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
  23 import org.opendaylight.mdsal.binding.model.api.MethodSignature;
  24 import org.opendaylight.mdsal.binding.model.api.Type;
  25 import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
  26 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
  27 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
  28 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
  29 import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
  30 import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
  31 import org.opendaylight.mdsal.binding.model.util.TypeComments;
  32 import org.opendaylight.mdsal.binding.model.util.Types;
  33 import org.opendaylight.yangtools.yang.common.QName;
  34 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  35
  36 public class GeneratedTypeBuilderTest {
  37
  38     @Test
  39     public void addConstantTest() {
  40         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
  41             JavaTypeName.create("my.package", "MyName"));
  42
  43         // assertNotNull(generatedTypeBuilder.addComment("My comment ..."));
  44
  45         Constant constant = generatedTypeBuilder.addConstant(Types.typeForClass(String.class), "myConstant",
  46                 "myConstantValue");
  47         // Constant constantx =
  48         // generatedTypeBuilder.addConstant(Types.typeForClass(String.class),
  49         // "myConstant", "myConstantValue");
  50         Constant constant2 = generatedTypeBuilder.addConstant(
  51                 Types.typeForClass(int.class, BindingGeneratorUtil.getRestrictions(null)), "myIntConstant", 1);
  52
  53         Constant constant3 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class), "myConstant",
  54                 "myConstantValue");
  55         final Constant constant4 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class),
  56             "myConstant2", "myConstantValue");
  57         final Constant constant5 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class),
  58             "myConstant", "myConstantValue2");
  59
  60         assertNotNull(constant);
  61         assertNotNull(constant2);
  62         assertNotNull(constant3);
  63         assertNotNull(constant4);
  64         assertNotNull(constant5);
  65         // assertNotNull(constantx);
  66         // assertTrue(constant!=constantx);
  67
  68         assertFalse(constant.equals(null));
  69         assertFalse(constant.equals(new Object()));
  70         assertTrue(constant.equals(constant));
  71         assertTrue(constant.equals(constant3));
  72         assertFalse(constant.equals(constant2));
  73         assertFalse(constant.equals(constant4));
  74         assertFalse(constant.equals(constant5));
  75
  76         assertTrue(constant.hashCode() == constant.hashCode());
  77         assertTrue(constant.hashCode() == constant3.hashCode());
  78         assertFalse(constant.hashCode() == constant2.hashCode());
  79         assertFalse(constant.hashCode() == constant4.hashCode());
  80         assertTrue(constant.hashCode() == constant5.hashCode());
  81
  82         assertEquals("Constant [type=Type (java.lang.String), name=myConstant, value=myConstantValue, "
  83                 + "definingType=my.package.MyName]", constant.toString());
  84
  85         assertEquals("Type (java.lang.String) myConstant myConstantValue", constant.toFormattedString());
  86
  87         GeneratedType instance = generatedTypeBuilder.build();
  88         List<Constant> constantDefinitions = instance.getConstantDefinitions();
  89         assertNotNull(constantDefinitions);
  90         assertEquals(2, constantDefinitions.size());
  91         assertTrue(constantDefinitions.contains(constant));
  92         assertTrue(constantDefinitions.contains(constant2));
  93         assertTrue(constantDefinitions.contains(constant3));
  94         assertFalse(constantDefinitions.contains(constant4));
  95         assertFalse(constantDefinitions.contains(constant5));
  96
  97         assertEquals("myConstant", constant.getName());
  98         assertEquals("myConstantValue", constant.getValue());
  99         assertEquals(Types.typeForClass(String.class), constant.getType());
 100         assertEquals(generatedTypeBuilder, constant.getDefiningType());
 101     }
 102
 103     @Test(expected = IllegalArgumentException.class)
 104     public void addConstantIllegalArgumentTest() {
 105         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addConstant(
 106             Types.typeForClass(String.class), null, "myConstantValue");
 107     }
 108
 109     @Test(expected = IllegalArgumentException.class)
 110     public void addConstantIllegalArgumentTest2() {
 111         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addConstant(null, "myConstantName",
 112             "myConstantValue");
 113     }
 114
 115     @Test
 116     public void generatedTypeBuilderEqualsAndHashCodeTest() {
 117         final CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 118             JavaTypeName.create("my.package", "MyName"));
 119         final CodegenGeneratedTypeBuilder generatedTypeBuilder2 = new CodegenGeneratedTypeBuilder(
 120             JavaTypeName.create("my.package", "MyName"));
 121         final CodegenGeneratedTypeBuilder generatedTypeBuilder3 = new CodegenGeneratedTypeBuilder(
 122             JavaTypeName.create("my.package", "MyName2"));
 123         final CodegenGeneratedTypeBuilder generatedTypeBuilder4 = new CodegenGeneratedTypeBuilder(
 124             JavaTypeName.create("my.package2", "MyName"));
 125
 126         assertFalse(generatedTypeBuilder.equals(null));
 127         assertFalse(generatedTypeBuilder.equals(new Object()));
 128         assertTrue(generatedTypeBuilder.equals(generatedTypeBuilder));
 129         assertTrue(generatedTypeBuilder.equals(generatedTypeBuilder2));
 130
 131         assertTrue(generatedTypeBuilder.hashCode() == generatedTypeBuilder.hashCode());
 132         assertTrue(generatedTypeBuilder.hashCode() == generatedTypeBuilder2.hashCode());
 133         assertFalse(generatedTypeBuilder.hashCode() == generatedTypeBuilder3.hashCode());
 134         assertFalse(generatedTypeBuilder.hashCode() == generatedTypeBuilder4.hashCode());
 135
 136     }
 137
 138     @Test
 139     public void addPropertyTest() {
 140         CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 141             JavaTypeName.create("my.package", "MyName"));
 142
 143         GeneratedPropertyBuilder propertyBuilder = generatedTypeBuilder.addProperty("myProperty");
 144         GeneratedPropertyBuilder propertyBuilder2 = generatedTypeBuilder.addProperty("myProperty2");
 145         // GeneratedPropertyBuilder propertyBuilderNull =
 146         // generatedTypeBuilder.addProperty(null);
 147
 148         assertNotNull(propertyBuilder);
 149         assertNotNull(propertyBuilder2);
 150         // assertNotNull(propertyBuilderNull);
 151
 152         assertTrue(generatedTypeBuilder.containsProperty("myProperty"));
 153         assertTrue(generatedTypeBuilder.containsProperty("myProperty2"));
 154         assertFalse(generatedTypeBuilder.containsProperty("myProperty3"));
 155
 156         GeneratedType instance = generatedTypeBuilder.build();
 157         List<GeneratedProperty> properties = instance.getProperties();
 158
 159         assertEquals(2, properties.size());
 160
 161         assertTrue(properties.contains(propertyBuilder.toInstance(instance)));
 162         assertTrue(properties.contains(propertyBuilder2.toInstance(instance)));
 163         // assertTrue(properties.contains(propertyBuilderNull.toInstance(instance)));
 164         assertFalse(properties.contains(new GeneratedPropertyBuilderImpl("myProperty3").toInstance(instance)));
 165
 166     }
 167
 168     @Test(expected = IllegalArgumentException.class)
 169     public void addMethodIllegalArgumentTest() {
 170         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addMethod(null);
 171     }
 172
 173     @Test
 174     public void addMethodTest() {
 175         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 176             JavaTypeName.create("my.package", "MyName"));
 177
 178         MethodSignatureBuilder methodBuilder = generatedTypeBuilder.addMethod("myMethodName");
 179         MethodSignatureBuilder methodBuilder2 = generatedTypeBuilder.addMethod("myMethodName2");
 180
 181         assertNotNull(methodBuilder);
 182         assertNotNull(methodBuilder2);
 183
 184         assertTrue(generatedTypeBuilder.containsMethod("myMethodName"));
 185         assertTrue(generatedTypeBuilder.containsMethod("myMethodName2"));
 186         assertFalse(generatedTypeBuilder.containsMethod("myMethodName3"));
 187
 188         GeneratedType instance = generatedTypeBuilder.build();
 189         List<MethodSignature> methodDefinitions = instance.getMethodDefinitions();
 190
 191         assertEquals(2, methodDefinitions.size());
 192
 193         assertTrue(methodDefinitions.contains(methodBuilder.toInstance(instance)));
 194         assertTrue(methodDefinitions.contains(methodBuilder2.toInstance(instance)));
 195         assertFalse(methodDefinitions.contains(new MethodSignatureBuilderImpl("myMethodName3").toInstance(instance)));
 196
 197     }
 198
 199     @Test(expected = IllegalArgumentException.class)
 200     public void addEnumerationIllegalArgumentTest() {
 201         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnumeration(null);
 202     }
 203
 204     @Test
 205     public void addEnumerationTest() {
 206         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 207             JavaTypeName.create("my.package", "MyName"));
 208
 209         EnumBuilder enumBuilder = generatedTypeBuilder.addEnumeration("myEnumName");
 210         EnumBuilder enumBuilder2 = generatedTypeBuilder.addEnumeration("myEnumName2");
 211
 212         assertNotNull(enumBuilder);
 213         assertNotNull(enumBuilder2);
 214
 215         GeneratedType instance = generatedTypeBuilder.build();
 216         List<Enumeration> enumerations = instance.getEnumerations();
 217
 218         assertEquals(2, enumerations.size());
 219
 220         assertTrue(enumerations.contains(enumBuilder.toInstance(instance)));
 221         assertTrue(enumerations.contains(enumBuilder2.toInstance(instance)));
 222         assertFalse(enumerations.contains(new CodegenEnumerationBuilder(JavaTypeName.create("my.package",
 223             "myEnumName3"))
 224             .toInstance(instance)));
 225
 226     }
 227
 228     @Test(expected = IllegalArgumentException.class)
 229     public void addImplementsTypeIllegalArgumentTest() {
 230         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addImplementsType(null);
 231     }
 232
 233     @Test
 234     public void addImplementsTypeTest() {
 235         CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 236             JavaTypeName.create("my.package", "MyName"));
 237
 238         assertEquals(generatedTypeBuilder,
 239                 generatedTypeBuilder.addImplementsType(Types.typeForClass(Serializable.class)));
 240         assertEquals(generatedTypeBuilder, generatedTypeBuilder.addImplementsType(Types.typeForClass(Runnable.class)));
 241
 242         GeneratedType instance = generatedTypeBuilder.build();
 243         List<Type> implementTypes = instance.getImplements();
 244
 245         assertEquals(2, implementTypes.size());
 246
 247         assertTrue(implementTypes.contains(Types.typeForClass(Serializable.class)));
 248         assertTrue(implementTypes.contains(Types.typeForClass(Runnable.class)));
 249         assertFalse(implementTypes.contains(Types.typeForClass(Throwable.class)));
 250     }
 251
 252     @Test(expected = IllegalArgumentException.class)
 253     public void addEnclosingTransferObjectIllegalArgumentTest() {
 254         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnclosingTransferObject(
 255             (String) null);
 256     }
 257
 258     @Test(expected = IllegalArgumentException.class)
 259     public void addEnclosingTransferObjectIllegalArgumentTest2() {
 260         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnclosingTransferObject(
 261             (GeneratedTOBuilder) null);
 262     }
 263
 264     @Test
 265     public void addEnclosingTransferObjectTest() {
 266         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 267             JavaTypeName.create("my.package", "MyName"));
 268
 269         GeneratedTOBuilder enclosingTransferObject = generatedTypeBuilder.addEnclosingTransferObject("myTOName");
 270         GeneratedTOBuilder enclosingTransferObject2 = generatedTypeBuilder.addEnclosingTransferObject("myTOName2");
 271         assertEquals(generatedTypeBuilder, generatedTypeBuilder.addEnclosingTransferObject(
 272             new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier().createEnclosed("myTOName3"))));
 273
 274         assertNotNull(enclosingTransferObject);
 275         assertNotNull(enclosingTransferObject2);
 276
 277         GeneratedType instance = generatedTypeBuilder.build();
 278         List<GeneratedType> enclosedTypes = instance.getEnclosedTypes();
 279
 280         assertEquals(3, enclosedTypes.size());
 281
 282         assertTrue(enclosedTypes.contains(enclosingTransferObject.build()));
 283         assertTrue(enclosedTypes.contains(enclosingTransferObject2.build()));
 284         assertTrue(enclosedTypes.contains(new CodegenGeneratedTOBuilder(
 285             generatedTypeBuilder.getIdentifier().createEnclosed("myTOName3")).build()));
 286         assertFalse(enclosedTypes.contains(new CodegenGeneratedTOBuilder(
 287             generatedTypeBuilder.getIdentifier().createEnclosed("myTOName4")).build()));
 288     }
 289
 290     @Test
 291     public void generatedTypeTest() {
 292         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 293             JavaTypeName.create("my.package", "MyName"));
 294
 295         generatedTypeBuilder.setDescription("My description ...");
 296         generatedTypeBuilder.setModuleName("myModuleName");
 297         generatedTypeBuilder.setReference("myReference");
 298         generatedTypeBuilder.setSchemaPath(SchemaPath.create(true, QName.create("test", "path")));
 299         assertNotNull(generatedTypeBuilder.addComment(TypeComments.javadoc("My comment..").get()));
 300
 301         assertEquals(
 302                 "GeneratedTransferObject [packageName=my.package, name=MyName, comment=My comment.., annotations=[], "
 303                         + "implements=[], enclosedTypes=[], constants=[], enumerations=[], properties=, methods=[]]",
 304                         generatedTypeBuilder.toString());
 305
 306         GeneratedType instance = generatedTypeBuilder.build();
 307
 308         assertEquals("My description ...", instance.getDescription());
 309         assertEquals("myModuleName", instance.getModuleName());
 310         assertEquals("myReference", instance.getReference());
 311         assertEquals(SchemaPath.create(true, QName.create("test", "path")).getPathFromRoot(),
 312             instance.getSchemaPath());
 313         assertEquals("My comment..", instance.getComment().getJavadoc());
 314     }
 315 }