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