2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.mdsal.binding.model.util.generated.type.builder;
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;
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.JavaTypeName;
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;
36 public class GeneratedTypeBuilderTest {
39 public void addConstantTest() {
40 GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
41 JavaTypeName.create("my.package", "MyName"));
43 // assertNotNull(generatedTypeBuilder.addComment("My comment ..."));
45 Constant constant = generatedTypeBuilder.addConstant(Types.typeForClass(String.class), "myConstant",
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);
53 Constant constant3 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class), "myConstant",
55 Constant constant4 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class), "myConstant2",
57 Constant constant5 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class), "myConstant",
60 assertNotNull(constant);
61 assertNotNull(constant2);
62 assertNotNull(constant3);
63 assertNotNull(constant4);
64 assertNotNull(constant5);
65 // assertNotNull(constantx);
66 // assertTrue(constant!=constantx);
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));
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());
83 "Constant [type=Type (java.lang.String), name=myConstant, value=myConstantValue, definingType=my.package.MyName]",
86 assertEquals("Type (java.lang.String) myConstant myConstantValue", constant.toFormattedString());
88 GeneratedType instance = generatedTypeBuilder.build();
89 List<Constant> constantDefinitions = instance.getConstantDefinitions();
90 assertNotNull(constantDefinitions);
91 assertEquals(2, constantDefinitions.size());
92 assertTrue(constantDefinitions.contains(constant));
93 assertTrue(constantDefinitions.contains(constant2));
94 assertTrue(constantDefinitions.contains(constant3));
95 assertFalse(constantDefinitions.contains(constant4));
96 assertFalse(constantDefinitions.contains(constant5));
98 assertEquals("myConstant", constant.getName());
99 assertEquals("myConstantValue", constant.getValue());
100 assertEquals(Types.typeForClass(String.class), constant.getType());
101 assertEquals(generatedTypeBuilder, constant.getDefiningType());
104 @Test(expected = IllegalArgumentException.class)
105 public void addConstantIllegalArgumentTest() {
106 new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addConstant(
107 Types.typeForClass(String.class), null, "myConstantValue");
110 @Test(expected = IllegalArgumentException.class)
111 public void addConstantIllegalArgumentTest2() {
112 new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addConstant(null, "myConstantName",
117 public void generatedTypeBuilderEqualsAndHashCodeTest() {
118 CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
119 JavaTypeName.create("my.package", "MyName"));
120 CodegenGeneratedTypeBuilder generatedTypeBuilder2 = new CodegenGeneratedTypeBuilder(
121 JavaTypeName.create("my.package", "MyName"));
122 CodegenGeneratedTypeBuilder generatedTypeBuilder3 = new CodegenGeneratedTypeBuilder(
123 JavaTypeName.create("my.package", "MyName2"));
124 CodegenGeneratedTypeBuilder generatedTypeBuilder4 = new CodegenGeneratedTypeBuilder(
125 JavaTypeName.create("my.package2", "MyName"));
127 assertFalse(generatedTypeBuilder.equals(null));
128 assertFalse(generatedTypeBuilder.equals(new Object()));
129 assertTrue(generatedTypeBuilder.equals(generatedTypeBuilder));
130 assertTrue(generatedTypeBuilder.equals(generatedTypeBuilder2));
132 assertTrue(generatedTypeBuilder.hashCode() == generatedTypeBuilder.hashCode());
133 assertTrue(generatedTypeBuilder.hashCode() == generatedTypeBuilder2.hashCode());
134 assertFalse(generatedTypeBuilder.hashCode() == generatedTypeBuilder3.hashCode());
135 assertFalse(generatedTypeBuilder.hashCode() == generatedTypeBuilder4.hashCode());
140 public void addPropertyTest() {
141 CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
142 JavaTypeName.create("my.package", "MyName"));
144 GeneratedPropertyBuilder propertyBuilder = generatedTypeBuilder.addProperty("myProperty");
145 GeneratedPropertyBuilder propertyBuilder2 = generatedTypeBuilder.addProperty("myProperty2");
146 // GeneratedPropertyBuilder propertyBuilderNull =
147 // generatedTypeBuilder.addProperty(null);
149 assertNotNull(propertyBuilder);
150 assertNotNull(propertyBuilder2);
151 // assertNotNull(propertyBuilderNull);
153 assertTrue(generatedTypeBuilder.containsProperty("myProperty"));
154 assertTrue(generatedTypeBuilder.containsProperty("myProperty2"));
155 assertFalse(generatedTypeBuilder.containsProperty("myProperty3"));
157 GeneratedType instance = generatedTypeBuilder.build();
158 List<GeneratedProperty> properties = instance.getProperties();
160 assertEquals(2, properties.size());
162 assertTrue(properties.contains(propertyBuilder.toInstance(instance)));
163 assertTrue(properties.contains(propertyBuilder2.toInstance(instance)));
164 // assertTrue(properties.contains(propertyBuilderNull.toInstance(instance)));
165 assertFalse(properties.contains(new GeneratedPropertyBuilderImpl("myProperty3").toInstance(instance)));
169 @Test(expected = IllegalArgumentException.class)
170 public void addMethodIllegalArgumentTest() {
171 new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addMethod(null);
175 public void addMethodTest() {
176 GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
177 JavaTypeName.create("my.package", "MyName"));
179 MethodSignatureBuilder methodBuilder = generatedTypeBuilder.addMethod("myMethodName");
180 MethodSignatureBuilder methodBuilder2 = generatedTypeBuilder.addMethod("myMethodName2");
182 assertNotNull(methodBuilder);
183 assertNotNull(methodBuilder2);
185 assertTrue(generatedTypeBuilder.containsMethod("myMethodName"));
186 assertTrue(generatedTypeBuilder.containsMethod("myMethodName2"));
187 assertFalse(generatedTypeBuilder.containsMethod("myMethodName3"));
189 GeneratedType instance = generatedTypeBuilder.build();
190 List<MethodSignature> methodDefinitions = instance.getMethodDefinitions();
192 assertEquals(2, methodDefinitions.size());
194 assertTrue(methodDefinitions.contains(methodBuilder.toInstance(instance)));
195 assertTrue(methodDefinitions.contains(methodBuilder2.toInstance(instance)));
196 assertFalse(methodDefinitions.contains(new MethodSignatureBuilderImpl("myMethodName3").toInstance(instance)));
200 @Test(expected = IllegalArgumentException.class)
201 public void addEnumerationIllegalArgumentTest() {
202 new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnumeration(null);
206 public void addEnumerationTest() {
207 GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
208 JavaTypeName.create("my.package", "MyName"));
210 EnumBuilder enumBuilder = generatedTypeBuilder.addEnumeration("myEnumName");
211 EnumBuilder enumBuilder2 = generatedTypeBuilder.addEnumeration("myEnumName2");
213 assertNotNull(enumBuilder);
214 assertNotNull(enumBuilder2);
216 GeneratedType instance = generatedTypeBuilder.build();
217 List<Enumeration> enumerations = instance.getEnumerations();
219 assertEquals(2, enumerations.size());
221 assertTrue(enumerations.contains(enumBuilder.toInstance(instance)));
222 assertTrue(enumerations.contains(enumBuilder2.toInstance(instance)));
223 assertFalse(enumerations.contains(new CodegenEnumerationBuilder(JavaTypeName.create("my.package", "myEnumName3"))
224 .toInstance(instance)));
228 @Test(expected = IllegalArgumentException.class)
229 public void addImplementsTypeIllegalArgumentTest() {
230 new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addImplementsType(null);
234 public void addImplementsTypeTest() {
235 CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
236 JavaTypeName.create("my.package", "MyName"));
238 assertEquals(generatedTypeBuilder,
239 generatedTypeBuilder.addImplementsType(Types.typeForClass(Serializable.class)));
240 assertEquals(generatedTypeBuilder, generatedTypeBuilder.addImplementsType(Types.typeForClass(Runnable.class)));
242 GeneratedType instance = generatedTypeBuilder.build();
243 List<Type> implementTypes = instance.getImplements();
245 assertEquals(2, implementTypes.size());
247 assertTrue(implementTypes.contains(Types.typeForClass(Serializable.class)));
248 assertTrue(implementTypes.contains(Types.typeForClass(Runnable.class)));
249 assertFalse(implementTypes.contains(Types.typeForClass(Throwable.class)));
252 @Test(expected = IllegalArgumentException.class)
253 public void addEnclosingTransferObjectIllegalArgumentTest() {
254 new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName"))
255 .addEnclosingTransferObject((String) null);
258 @Test(expected = IllegalArgumentException.class)
259 public void addEnclosingTransferObjectIllegalArgumentTest2() {
260 new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName"))
261 .addEnclosingTransferObject((GeneratedTOBuilder) null);
265 public void addEnclosingTransferObjectTest() {
266 GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
267 JavaTypeName.create("my.package", "MyName"));
269 GeneratedTOBuilder enclosingTransferObject = generatedTypeBuilder.addEnclosingTransferObject("myTOName");
270 GeneratedTOBuilder enclosingTransferObject2 = generatedTypeBuilder.addEnclosingTransferObject("myTOName2");
271 assertEquals(generatedTypeBuilder, generatedTypeBuilder.addEnclosingTransferObject(
272 new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier().createEnclosed("myTOName3"))));
274 assertNotNull(enclosingTransferObject);
275 assertNotNull(enclosingTransferObject2);
277 GeneratedType instance = generatedTypeBuilder.build();
278 List<GeneratedType> enclosedTypes = instance.getEnclosedTypes();
280 assertEquals(3, enclosedTypes.size());
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()));
291 public void generatedTypeTest() {
292 GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
293 JavaTypeName.create("my.package", "MyName"));
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()));
302 "GeneratedTransferObject [packageName=my.package, name=MyName, comment=My comment.., annotations=[], "
303 + "implements=[], enclosedTypes=[], constants=[], enumerations=[], properties=, methods=[]]",
304 generatedTypeBuilder.toString());
306 GeneratedType instance = generatedTypeBuilder.build();
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(), instance.getSchemaPath());
312 assertEquals("My comment..", instance.getComment().getJavadoc());