binding/binding-model-ri/src/test/java/org/opendaylight/yangtools/binding/model/ri/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.model.ri.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.model.api.Constant;
  19 import org.opendaylight.yangtools.binding.model.api.Enumeration;
  20 import org.opendaylight.yangtools.binding.model.api.GeneratedProperty;
  21 import org.opendaylight.yangtools.binding.model.api.GeneratedTransferObject;
  22 import org.opendaylight.yangtools.binding.model.api.GeneratedType;
  23 import org.opendaylight.yangtools.binding.model.api.JavaTypeName;
  24 import org.opendaylight.yangtools.binding.model.api.MethodSignature;
  25 import org.opendaylight.yangtools.binding.model.api.Restrictions;
  26 import org.opendaylight.yangtools.binding.model.api.Type;
  27 import org.opendaylight.yangtools.binding.model.api.type.builder.EnumBuilder;
  28 import org.opendaylight.yangtools.binding.model.api.type.builder.GeneratedPropertyBuilder;
  29 import org.opendaylight.yangtools.binding.model.api.type.builder.GeneratedTOBuilder;
  30 import org.opendaylight.yangtools.binding.model.api.type.builder.GeneratedTypeBuilder;
  31 import org.opendaylight.yangtools.binding.model.api.type.builder.MethodSignatureBuilder;
  32 import org.opendaylight.yangtools.binding.model.ri.Types;
  33
  34 public class GeneratedTypeBuilderTest {
  35
  36     @Test
  37     public void addConstantTest() {
  38         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
  39             JavaTypeName.create("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.typeForClass(int.class, Restrictions.empty()), "myIntConstant", 1);
  50
  51         Constant constant3 = new ConstantImpl(Types.typeForClass(String.class), "myConstant", "myConstantValue");
  52         final Constant constant4 = new ConstantImpl(Types.typeForClass(String.class), "myConstant2", "myConstantValue");
  53         final Constant constant5 = new ConstantImpl(Types.typeForClass(String.class), "myConstant", "myConstantValue2");
  54
  55         assertNotNull(constant);
  56         assertNotNull(constant2);
  57         assertNotNull(constant3);
  58         assertNotNull(constant4);
  59         assertNotNull(constant5);
  60         // assertNotNull(constantx);
  61         // assertTrue(constant!=constantx);
  62
  63         assertFalse(constant.equals(null));
  64         assertFalse(constant.equals(new Object()));
  65         assertTrue(constant.equals(constant));
  66         assertTrue(constant.equals(constant3));
  67         assertFalse(constant.equals(constant2));
  68         assertFalse(constant.equals(constant4));
  69         assertFalse(constant.equals(constant5));
  70
  71         assertTrue(constant.hashCode() == constant.hashCode());
  72         assertTrue(constant.hashCode() == constant3.hashCode());
  73         assertFalse(constant.hashCode() == constant2.hashCode());
  74         assertFalse(constant.hashCode() == constant4.hashCode());
  75         assertTrue(constant.hashCode() == constant5.hashCode());
  76
  77         assertEquals(
  78             "Constant [type=ConcreteTypeImpl{identifier=java.lang.String}, name=myConstant, value=myConstantValue]",
  79             constant.toString());
  80
  81         GeneratedType instance = generatedTypeBuilder.build();
  82         List<Constant> constantDefinitions = instance.getConstantDefinitions();
  83         assertNotNull(constantDefinitions);
  84         assertEquals(2, constantDefinitions.size());
  85         assertTrue(constantDefinitions.contains(constant));
  86         assertTrue(constantDefinitions.contains(constant2));
  87         assertTrue(constantDefinitions.contains(constant3));
  88         assertFalse(constantDefinitions.contains(constant4));
  89         assertFalse(constantDefinitions.contains(constant5));
  90
  91         assertEquals("myConstant", constant.getName());
  92         assertEquals("myConstantValue", constant.getValue());
  93         assertEquals(Types.typeForClass(String.class), constant.getType());
  94     }
  95
  96     @Test(expected = IllegalArgumentException.class)
  97     public void addConstantIllegalArgumentTest() {
  98         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addConstant(
  99             Types.typeForClass(String.class), null, "myConstantValue");
 100     }
 101
 102     @Test(expected = IllegalArgumentException.class)
 103     public void addConstantIllegalArgumentTest2() {
 104         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addConstant(null, "myConstantName",
 105             "myConstantValue");
 106     }
 107
 108     @Test
 109     public void generatedTypeBuilderEqualsAndHashCodeTest() {
 110         final CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 111             JavaTypeName.create("my.package", "MyName"));
 112         final CodegenGeneratedTypeBuilder generatedTypeBuilder2 = new CodegenGeneratedTypeBuilder(
 113             JavaTypeName.create("my.package", "MyName"));
 114         final CodegenGeneratedTypeBuilder generatedTypeBuilder3 = new CodegenGeneratedTypeBuilder(
 115             JavaTypeName.create("my.package", "MyName2"));
 116         final CodegenGeneratedTypeBuilder generatedTypeBuilder4 = new CodegenGeneratedTypeBuilder(
 117             JavaTypeName.create("my.package2", "MyName"));
 118
 119         assertFalse(generatedTypeBuilder.equals(null));
 120         assertFalse(generatedTypeBuilder.equals(new Object()));
 121         assertTrue(generatedTypeBuilder.equals(generatedTypeBuilder));
 122         assertTrue(generatedTypeBuilder.equals(generatedTypeBuilder2));
 123
 124         assertTrue(generatedTypeBuilder.hashCode() == generatedTypeBuilder.hashCode());
 125         assertTrue(generatedTypeBuilder.hashCode() == generatedTypeBuilder2.hashCode());
 126         assertFalse(generatedTypeBuilder.hashCode() == generatedTypeBuilder3.hashCode());
 127         assertFalse(generatedTypeBuilder.hashCode() == generatedTypeBuilder4.hashCode());
 128
 129     }
 130
 131     @Test
 132     public void addPropertyTest() {
 133         CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 134             JavaTypeName.create("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.build();
 150         List<GeneratedProperty> properties = instance.getProperties();
 151
 152         assertEquals(2, properties.size());
 153
 154         assertTrue(properties.contains(propertyBuilder.toInstance()));
 155         assertTrue(properties.contains(propertyBuilder2.toInstance()));
 156         // assertTrue(properties.contains(propertyBuilderNull.toInstance(instance)));
 157         assertFalse(properties.contains(new GeneratedPropertyBuilderImpl("myProperty3").toInstance()));
 158
 159     }
 160
 161     @Test(expected = IllegalArgumentException.class)
 162     public void addMethodIllegalArgumentTest() {
 163         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addMethod(null);
 164     }
 165
 166     @Test
 167     public void addMethodTest() {
 168         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 169             JavaTypeName.create("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.build();
 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         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnumeration(null);
 195     }
 196
 197     @Test
 198     public void addEnumerationTest() {
 199         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 200             JavaTypeName.create("my.package", "MyName"));
 201
 202         EnumBuilder enumBuilder = new CodegenEnumerationBuilder(generatedTypeBuilder.getIdentifier()
 203             .createEnclosed("myEnumName"));
 204         EnumBuilder enumBuilder2 = new CodegenEnumerationBuilder(generatedTypeBuilder.getIdentifier()
 205             .createEnclosed("myEnumName2"));
 206
 207         generatedTypeBuilder.addEnumeration(enumBuilder.toInstance());
 208         generatedTypeBuilder.addEnumeration(enumBuilder2.toInstance());
 209
 210         GeneratedType instance = generatedTypeBuilder.build();
 211         List<Enumeration> enumerations = instance.getEnumerations();
 212
 213         assertEquals(2, enumerations.size());
 214
 215         assertTrue(enumerations.contains(enumBuilder.toInstance()));
 216         assertTrue(enumerations.contains(enumBuilder2.toInstance()));
 217         assertFalse(enumerations.contains(new CodegenEnumerationBuilder(JavaTypeName.create("my.package",
 218             "myEnumName3")).toInstance()));
 219
 220     }
 221
 222     @Test(expected = IllegalArgumentException.class)
 223     public void addImplementsTypeIllegalArgumentTest() {
 224         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addImplementsType(null);
 225     }
 226
 227     @Test
 228     public void addImplementsTypeTest() {
 229         CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 230             JavaTypeName.create("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.build();
 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     @Test(expected = IllegalArgumentException.class)
 247     public void addEnclosingTransferObjectIllegalArgumentTest2() {
 248         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnclosingTransferObject(
 249             (GeneratedTransferObject) null);
 250     }
 251
 252     @Test
 253     public void addEnclosingTransferObjectTest() {
 254         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 255             JavaTypeName.create("my.package", "MyName"));
 256
 257         GeneratedTOBuilder enclosingTransferObject = new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier()
 258             .createEnclosed("myTOName"));
 259         GeneratedTOBuilder enclosingTransferObject2 = new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier()
 260             .createEnclosed("myTOName2"));
 261         GeneratedTOBuilder enclosingTransferObject3 = new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier()
 262             .createEnclosed("myTOName3"));
 263
 264         generatedTypeBuilder.addEnclosingTransferObject(enclosingTransferObject.build());
 265         generatedTypeBuilder.addEnclosingTransferObject(enclosingTransferObject2.build());
 266         generatedTypeBuilder.addEnclosingTransferObject(enclosingTransferObject3.build());
 267         GeneratedType instance = generatedTypeBuilder.build();
 268         List<GeneratedType> enclosedTypes = instance.getEnclosedTypes();
 269
 270         assertEquals(3, enclosedTypes.size());
 271
 272         assertTrue(enclosedTypes.contains(enclosingTransferObject.build()));
 273         assertTrue(enclosedTypes.contains(enclosingTransferObject2.build()));
 274         assertTrue(enclosedTypes.contains(enclosingTransferObject3.build()));
 275         assertFalse(enclosedTypes.contains(new CodegenGeneratedTOBuilder(
 276             generatedTypeBuilder.getIdentifier().createEnclosed("myTOName4")).build()));
 277     }
 278
 279     @Test
 280     public void generatedTypeTest() {
 281         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
 282             JavaTypeName.create("my.package", "MyName"));
 283
 284         generatedTypeBuilder.setDescription("My description ...");
 285         generatedTypeBuilder.setModuleName("myModuleName");
 286         generatedTypeBuilder.setReference("myReference");
 287         assertNotNull(generatedTypeBuilder.addComment(() -> "My comment.."));
 288
 289         assertEquals("CodegenGeneratedTypeBuilder{identifier=my.package.MyName, comment=My comment.., constants=[], "
 290             + "enumerations=[], methods=[], annotations=[], implements=[]}", generatedTypeBuilder.toString());
 291
 292         GeneratedType instance = generatedTypeBuilder.build();
 293
 294         assertEquals("My description ...", instance.getDescription());
 295         assertEquals("myModuleName", instance.getModuleName());
 296         assertEquals("myReference", instance.getReference());
 297         assertEquals("My comment..", instance.getComment().getJavadoc());
 298     }
 299 }