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