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