*/
package org.opendaylight.yangtools.binding.generator.util.generated.type.builder;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import org.opendaylight.yangtools.binding.generator.util.Types;
import org.opendaylight.yangtools.sal.binding.model.api.AnnotationType;
+import org.opendaylight.yangtools.sal.binding.model.api.AnnotationType.Parameter;
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.AnnotationTypeBuilder;
@Test
public void generatedTypeAnnotationTest() {
- final GeneratedTypeBuilder genTypeBuilder = new GeneratedTypeBuilderImpl(
- "org.opendaylight.controller", "AnnotInterface");
+ final GeneratedTypeBuilder genTypeBuilder = new GeneratedTypeBuilderImpl("org.opendaylight.controller",
+ "AnnotInterface");
genTypeBuilder.addAnnotation("javax.management", "MXBean");
- final AnnotationTypeBuilder annotDesc = genTypeBuilder.addAnnotation(
- "javax.management", "Description");
+ final AnnotationTypeBuilder annotDesc = genTypeBuilder.addAnnotation("javax.management", "Description");
annotDesc.addParameter("description", "some sort of interface");
final GeneratedType genType = genTypeBuilder.toInstance();
int annotCount = 0;
for (final AnnotationType annotation : genType.getAnnotations()) {
- if (annotation.getPackageName().equals("javax.management")
- && annotation.getName().equals("MXBean")) {
+ if (annotation.getPackageName().equals("javax.management") && annotation.getName().equals("MXBean")) {
annotCount++;
assertEquals(0, annotation.getParameters().size());
}
- if (annotation.getPackageName().equals("javax.management")
- && annotation.getName().equals("Description")) {
+ if (annotation.getPackageName().equals("javax.management") && annotation.getName().equals("Description")) {
annotCount++;
assertEquals(1, annotation.getParameters().size());
- AnnotationType.Parameter param = annotation
- .getParameter("description");
+ AnnotationType.Parameter param = annotation.getParameter("description");
assertNotNull(param);
assertEquals("description", param.getName());
assertNotNull(param.getValue());
@Test
public void methodSignatureAnnotationTest() {
- final GeneratedTypeBuilder genTypeBuilder = new GeneratedTypeBuilderImpl(
- "org.opendaylight.controller", "TransferObject");
+ final GeneratedTypeBuilder genTypeBuilder = new GeneratedTypeBuilderImpl("org.opendaylight.controller",
+ "TransferObject");
- final MethodSignatureBuilder methodBuilder = genTypeBuilder
- .addMethod("simpleMethod");
+ final MethodSignatureBuilder methodBuilder = genTypeBuilder.addMethod("simpleMethod");
methodBuilder.setReturnType(Types.typeForClass(Integer.class));
- final AnnotationTypeBuilder annotManAttr = methodBuilder
- .addAnnotation("org.springframework.jmx.export.annotation",
- "ManagedAttribute");
+ final AnnotationTypeBuilder annotManAttr = methodBuilder.addAnnotation(
+ "org.springframework.jmx.export.annotation", "ManagedAttribute");
annotManAttr.addParameter("description", "\"The Name Attribute\"");
annotManAttr.addParameter("currencyTimeLimit", "20");
annotManAttr.addParameter("defaultValue", "\"bar\"");
annotManAttr.addParameter("persistPolicy", "\"OnUpdate\"");
- final AnnotationTypeBuilder annotManProp = methodBuilder
- .addAnnotation("org.springframework.jmx.export.annotation",
- "ManagedOperation");
+ final AnnotationTypeBuilder annotManProp = methodBuilder.addAnnotation(
+ "org.springframework.jmx.export.annotation", "ManagedOperation");
final List<String> typeValues = new ArrayList<String>();
typeValues.add("\"val1\"");
assertNotNull(genType.getMethodDefinitions());
assertNotNull(genType.getMethodDefinitions().get(0));
assertNotNull(genType.getMethodDefinitions().get(0).getAnnotations());
- final List<AnnotationType> annotations = genType.getMethodDefinitions()
- .get(0).getAnnotations();
+ final List<AnnotationType> annotations = genType.getMethodDefinitions().get(0).getAnnotations();
assertEquals(2, annotations.size());
int annotCount = 0;
@Test
public void generatedPropertyAnnotationTest() {
- final GeneratedTOBuilder genTOBuilder = new GeneratedTOBuilderImpl(
- "org.opendaylight.controller", "AnnotInterface");
+ final GeneratedTOBuilder genTOBuilder = new GeneratedTOBuilderImpl("org.opendaylight.controller",
+ "AnnotInterface");
- final GeneratedPropertyBuilder propertyBuilder = genTOBuilder
- .addProperty("simpleProperty");
+ final GeneratedPropertyBuilder propertyBuilder = genTOBuilder.addProperty("simpleProperty");
propertyBuilder.setReturnType(Types.typeForClass(Integer.class));
- final AnnotationTypeBuilder annotManAttr = propertyBuilder
- .addAnnotation("org.springframework.jmx.export.annotation",
- "ManagedAttribute");
+ final AnnotationTypeBuilder annotManAttr = propertyBuilder.addAnnotation(
+ "org.springframework.jmx.export.annotation", "ManagedAttribute");
annotManAttr.addParameter("description", "\"The Name Attribute\"");
annotManAttr.addParameter("currencyTimeLimit", "20");
annotManAttr.addParameter("defaultValue", "\"bar\"");
annotManAttr.addParameter("persistPolicy", "\"OnUpdate\"");
- final AnnotationTypeBuilder annotManProp = propertyBuilder
- .addAnnotation("org.springframework.jmx.export.annotation",
- "ManagedOperation");
+ final AnnotationTypeBuilder annotManProp = propertyBuilder.addAnnotation(
+ "org.springframework.jmx.export.annotation", "ManagedOperation");
final List<String> typeValues = new ArrayList<String>();
typeValues.add("\"val1\"");
assertNotNull(genTransObj.getProperties());
assertNotNull(genTransObj.getProperties().get(0));
assertNotNull(genTransObj.getProperties().get(0).getAnnotations());
- final List<AnnotationType> annotations = genTransObj.getProperties()
- .get(0).getAnnotations();
+ final List<AnnotationType> annotations = genTransObj.getProperties().get(0).getAnnotations();
assertEquals(2, annotations.size());
int annotCount = 0;
@Test
public void generatedTransfeObjectAnnotationTest() {
- final GeneratedTOBuilder genTypeBuilder = new GeneratedTOBuilderImpl(
- "org.opendaylight.controller", "AnnotClassCache");
+ final GeneratedTOBuilder genTypeBuilder = new GeneratedTOBuilderImpl("org.opendaylight.controller",
+ "AnnotClassCache");
genTypeBuilder.addAnnotation("javax.management", "MBean");
- final AnnotationTypeBuilder annotNotify = genTypeBuilder.addAnnotation(
- "javax.management", "NotificationInfo");
+ final AnnotationTypeBuilder annotNotify = genTypeBuilder.addAnnotation("javax.management", "NotificationInfo");
final List<String> notifyList = new ArrayList<String>();
notifyList.add("\"my.notif.type\"");
annotNotify.addParameters("types", notifyList);
- annotNotify.addParameter("description",
- "@Description(\"my notification\")");
+ annotNotify.addParameter("description", "@Description(\"my notification\")");
GeneratedTransferObject genTO = genTypeBuilder.toInstance();
int annotCount = 0;
for (final AnnotationType annotation : genTO.getAnnotations()) {
- if (annotation.getPackageName().equals("javax.management")
- && annotation.getName().equals("MBean")) {
+ if (annotation.getPackageName().equals("javax.management") && annotation.getName().equals("MBean")) {
annotCount++;
assertEquals(0, annotation.getParameters().size());
}
&& annotation.getName().equals("NotificationInfo")) {
annotCount++;
assertEquals(2, annotation.getParameters().size());
- AnnotationType.Parameter param = annotation
- .getParameter("types");
+ AnnotationType.Parameter param = annotation.getParameter("types");
assertNotNull(param);
assertEquals("types", param.getName());
assertNull(param.getValue());
assertNotNull(param);
assertEquals("description", param.getName());
assertNotNull(param.getValue());
- assertEquals("@Description(\"my notification\")",
- param.getValue());
+ assertEquals("@Description(\"my notification\")", param.getValue());
}
}
assertEquals(2, annotCount);
}
+
+ @Test
+ public void annotationTypeBuilderAddAnnotationTest() {
+ AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl("my.package", "MyName");
+
+ assertNull(annotationTypeBuilder.addAnnotation("my.package", null));
+ assertNull(annotationTypeBuilder.addAnnotation(null, "MyName"));
+
+ assertNotNull(annotationTypeBuilder.addAnnotation("", ""));
+
+ assertNotNull(annotationTypeBuilder.addAnnotation("my.package2", "MyName2"));
+ assertNull(annotationTypeBuilder.addAnnotation("my.package2", "MyName2"));
+
+ AnnotationType annotationTypeInstance = annotationTypeBuilder.toInstance();
+
+ assertEquals(2, annotationTypeInstance.getAnnotations().size());
+
+ assertEquals("my.package", annotationTypeInstance.getPackageName());
+ assertEquals("MyName", annotationTypeInstance.getName());
+
+ }
+
+ @Test
+ public void annotationTypeBuilderEqualsTest() {
+ AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl("my.package", "MyName");
+ AnnotationTypeBuilder annotationTypeBuilder2 = new AnnotationTypeBuilderImpl("my.package2", "MyName");
+ AnnotationTypeBuilder annotationTypeBuilder3 = new AnnotationTypeBuilderImpl("my.package", "MyName2");
+ AnnotationTypeBuilder annotationTypeBuilder4 = new AnnotationTypeBuilderImpl("my.package", "MyName");
+
+ assertFalse(annotationTypeBuilder.equals(null));
+ assertFalse(annotationTypeBuilder.equals(new Object()));
+
+ assertTrue(annotationTypeBuilder.equals(annotationTypeBuilder));
+
+ assertTrue(annotationTypeBuilder.equals(annotationTypeBuilder4));
+ assertFalse(annotationTypeBuilder.equals(annotationTypeBuilder2));
+ assertFalse(annotationTypeBuilder.equals(annotationTypeBuilder3));
+
+ AnnotationType instance = annotationTypeBuilder.toInstance();
+ AnnotationType instance2 = annotationTypeBuilder2.toInstance();
+ AnnotationType instance3 = annotationTypeBuilder3.toInstance();
+ AnnotationType instance4 = annotationTypeBuilder4.toInstance();
+
+ assertFalse(instance.equals(null));
+ assertFalse(instance.equals(new Object()));
+ assertTrue(instance.equals(instance));
+
+ assertFalse(instance.equals(instance2));
+ assertFalse(instance.equals(instance3));
+ assertTrue(instance.equals(instance4));
+
+ annotationTypeBuilder.addParameter("myName", "myValue1");
+ annotationTypeBuilder.addParameter("myName2", "myValue2");
+ annotationTypeBuilder2.addParameter("myName", "myValue3");
+
+ instance = annotationTypeBuilder.toInstance();
+ instance2 = annotationTypeBuilder2.toInstance();
+
+ Parameter parameter = instance.getParameter("myName");
+ Parameter parameter2 = instance.getParameter("myName2");
+ Parameter parameter3 = instance2.getParameter("myName");
+
+ assertFalse(parameter.equals(null));
+ assertFalse(parameter.equals(new Object()));
+ assertTrue(parameter.equals(parameter));
+ assertTrue(parameter.equals(parameter3));
+ assertFalse(parameter.equals(parameter2));
+ }
+
+ @Test
+ public void annotationTypeBuilderHashCodeTest() {
+ AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl("my.package", "MyName");
+ AnnotationTypeBuilder annotationTypeBuilder2 = new AnnotationTypeBuilderImpl("my.package2", "MyName");
+ AnnotationTypeBuilder annotationTypeBuilder3 = new AnnotationTypeBuilderImpl("my.package", "MyName2");
+ AnnotationTypeBuilder annotationTypeBuilder4 = new AnnotationTypeBuilderImpl("my.package", "MyName");
+
+ assertFalse(annotationTypeBuilder.hashCode() == annotationTypeBuilder2.hashCode());
+ assertFalse(annotationTypeBuilder.hashCode() == annotationTypeBuilder3.hashCode());
+
+ assertTrue(annotationTypeBuilder.hashCode() == annotationTypeBuilder4.hashCode());
+ assertTrue(annotationTypeBuilder.hashCode() == annotationTypeBuilder.hashCode());
+
+ AnnotationType instance = annotationTypeBuilder.toInstance();
+ AnnotationType instance2 = annotationTypeBuilder2.toInstance();
+ AnnotationType instance3 = annotationTypeBuilder3.toInstance();
+ AnnotationType instance4 = annotationTypeBuilder4.toInstance();
+
+ assertFalse(instance.hashCode() == instance2.hashCode());
+ assertFalse(instance.hashCode() == instance3.hashCode());
+
+ assertTrue(instance.hashCode() == instance4.hashCode());
+ assertTrue(instance.hashCode() == instance.hashCode());
+
+ annotationTypeBuilder.addParameter("myName", "myValue1");
+ annotationTypeBuilder.addParameter("myName2", "myValue2");
+ annotationTypeBuilder2.addParameter("myName", "myValue3");
+
+ instance = annotationTypeBuilder.toInstance();
+ instance2 = annotationTypeBuilder2.toInstance();
+
+ Parameter parameter = instance.getParameter("myName");
+ Parameter parameter2 = instance.getParameter("myName2");
+ Parameter parameter3 = instance2.getParameter("myName");
+
+ assertTrue(parameter.hashCode() == parameter.hashCode());
+ assertTrue(parameter.hashCode() == parameter3.hashCode());
+ assertFalse(parameter.hashCode() == parameter2.hashCode());
+
+ }
+
+ @Test
+ public void annotationTypeBuilderAddParameterTest() {
+ AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl("my.package", "MyName");
+
+ assertFalse(annotationTypeBuilder.addParameter(null, "myValue"));
+ assertFalse(annotationTypeBuilder.addParameter("myName", null));
+
+ assertFalse(annotationTypeBuilder.addParameters(null, new ArrayList<String>()));
+ assertFalse(annotationTypeBuilder.addParameters("myName", null));
+
+ assertTrue(annotationTypeBuilder.addParameter("myName", "myValue"));
+ assertFalse(annotationTypeBuilder.addParameter("myName", "myValue"));
+ assertFalse(annotationTypeBuilder.addParameters("myName", new ArrayList<String>()));
+
+ ArrayList<String> values = new ArrayList<String>();
+ values.add("myValue");
+ assertTrue(annotationTypeBuilder.addParameters("myName2", values));
+
+ AnnotationType annotationTypeInstance = annotationTypeBuilder.toInstance();
+ assertTrue(annotationTypeInstance.containsParameters());
+ assertEquals(2, annotationTypeInstance.getParameters().size());
+ assertEquals(2, annotationTypeInstance.getParameterNames().size());
+ assertTrue(annotationTypeInstance.getParameterNames().contains("myName"));
+ assertTrue(annotationTypeInstance.getParameterNames().contains("myName2"));
+ assertFalse(annotationTypeInstance.getParameterNames().contains("myName3"));
+
+ Parameter parameter = annotationTypeInstance.getParameter("myName");
+ Parameter parameter2 = annotationTypeInstance.getParameter("myName2");
+ Parameter parameter3 = annotationTypeInstance.getParameter("myName3");
+
+ assertNotNull(parameter);
+ assertNotNull(parameter2);
+ assertNull(parameter3);
+
+ assertEquals(parameter.getValue(), "myValue");
+ assertTrue(parameter.getValues().isEmpty());
+
+ assertEquals(1, parameter2.getValues().size());
+ assertTrue(parameter2.getValues().contains("myValue"));
+
+ }
+
+ @Test
+ public void annotationTypeBuilderToStringTest() {
+ AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl("my.package", "MyAnnotationName");
+ annotationTypeBuilder.addAnnotation("my.package", "MySubAnnotationName");
+ annotationTypeBuilder.addParameter("MyParameter", "myValue");
+
+ assertEquals(
+ "AnnotationTypeBuilder [packageName=my.package, name=MyAnnotationName, annotationBuilders=[AnnotationTypeBuilder [packageName=my.package, name=MySubAnnotationName, annotationBuilders=[], parameters=[]]], parameters=[ParameterImpl [name=MyParameter, value=myValue, values=[]]]]",
+ annotationTypeBuilder.toString());
+
+ AnnotationType annotationTypeInstance = annotationTypeBuilder.toInstance();
+
+ assertEquals("my.package.MyAnnotationName", annotationTypeInstance.getFullyQualifiedName());
+ assertEquals(
+ "AnnotationType [packageName=my.package, name=MyAnnotationName, annotations=[AnnotationType [packageName=my.package, name=MySubAnnotationName, annotations=[], parameters=[]]], parameters=[ParameterImpl [name=MyParameter, value=myValue, values=[]]]]",
+ annotationTypeInstance.toString());
+
+ }
+
}
--- /dev/null
+/**
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ */
+package org.opendaylight.yangtools.binding.generator.util.generated.type.builder;
+
+import static org.junit.Assert.*;
+
+import java.io.Serializable;
+import java.util.List;
+
+import org.junit.Test;
+import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil;
+import org.opendaylight.yangtools.binding.generator.util.Types;
+import org.opendaylight.yangtools.sal.binding.model.api.Constant;
+import org.opendaylight.yangtools.sal.binding.model.api.Enumeration;
+import org.opendaylight.yangtools.sal.binding.model.api.GeneratedProperty;
+import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
+import org.opendaylight.yangtools.sal.binding.model.api.MethodSignature;
+import org.opendaylight.yangtools.sal.binding.model.api.Type;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.EnumBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+
+public class GeneratedTypeBuilderTest {
+
+ @Test
+ public void addConstantTest() {
+ GeneratedTypeBuilder generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ // assertNotNull(generatedTypeBuilder.addComment("My comment ..."));
+
+ Constant constant = generatedTypeBuilder.addConstant(Types.typeForClass(String.class), "myConstant",
+ "myConstantValue");
+ // Constant constantx =
+ // generatedTypeBuilder.addConstant(Types.typeForClass(String.class),
+ // "myConstant", "myConstantValue");
+ Constant constant2 = generatedTypeBuilder.addConstant(
+ Types.primitiveType("int", BindingGeneratorUtil.getRestrictions(null)), "myIntConstant", 1);
+
+ Constant constant3 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class), "myConstant",
+ "myConstantValue");
+ Constant constant4 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class), "myConstant2",
+ "myConstantValue");
+ Constant constant5 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class), "myConstant",
+ "myConstantValue2");
+
+ assertNotNull(constant);
+ assertNotNull(constant2);
+ assertNotNull(constant3);
+ assertNotNull(constant4);
+ assertNotNull(constant5);
+ // assertNotNull(constantx);
+ // assertTrue(constant!=constantx);
+
+ assertFalse(constant.equals(null));
+ assertFalse(constant.equals(new Object()));
+ assertTrue(constant.equals(constant));
+ assertTrue(constant.equals(constant3));
+ assertFalse(constant.equals(constant2));
+ assertFalse(constant.equals(constant4));
+ assertFalse(constant.equals(constant5));
+
+ assertTrue(constant.hashCode() == constant.hashCode());
+ assertTrue(constant.hashCode() == constant3.hashCode());
+ assertFalse(constant.hashCode() == constant2.hashCode());
+ assertFalse(constant.hashCode() == constant4.hashCode());
+ assertTrue(constant.hashCode() == constant5.hashCode());
+
+ assertEquals(
+ "Constant [type=Type (java.lang.String), name=myConstant, value=myConstantValue, definingType=my.package.MyName]",
+ constant.toString());
+
+ assertEquals("Type (java.lang.String) myConstant myConstantValue", constant.toFormattedString());
+
+ GeneratedType instance = generatedTypeBuilder.toInstance();
+ List<Constant> constantDefinitions = instance.getConstantDefinitions();
+ assertNotNull(constantDefinitions);
+ assertEquals(2, constantDefinitions.size());
+ assertTrue(constantDefinitions.contains(constant));
+ assertTrue(constantDefinitions.contains(constant2));
+ assertTrue(constantDefinitions.contains(constant3));
+ assertFalse(constantDefinitions.contains(constant4));
+ assertFalse(constantDefinitions.contains(constant5));
+
+ assertEquals("myConstant", constant.getName());
+ assertEquals("myConstantValue", constant.getValue());
+ assertEquals(Types.typeForClass(String.class), constant.getType());
+ assertEquals(generatedTypeBuilder, constant.getDefiningType());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void addConstantIllegalArgumentTest() {
+ GeneratedTypeBuilder generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ Constant constant = generatedTypeBuilder.addConstant(Types.typeForClass(String.class), null, "myConstantValue");
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void addConstantIllegalArgumentTest2() {
+ GeneratedTypeBuilder generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ Constant constant = generatedTypeBuilder.addConstant(null, "myConstantName", "myConstantValue");
+ }
+
+ @Test
+ public void generatedTypeBuilderEqualsAndHashCodeTest() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+ GeneratedTypeBuilderImpl generatedTypeBuilder2 = new GeneratedTypeBuilderImpl("my.package", "MyName");
+ GeneratedTypeBuilderImpl generatedTypeBuilder3 = new GeneratedTypeBuilderImpl("my.package", "MyName2");
+ GeneratedTypeBuilderImpl generatedTypeBuilder4 = new GeneratedTypeBuilderImpl("my.package2", "MyName");
+
+ assertFalse(generatedTypeBuilder.equals(null));
+ assertFalse(generatedTypeBuilder.equals(new Object()));
+ assertTrue(generatedTypeBuilder.equals(generatedTypeBuilder));
+ assertTrue(generatedTypeBuilder.equals(generatedTypeBuilder2));
+
+ assertTrue(generatedTypeBuilder.hashCode() == generatedTypeBuilder.hashCode());
+ assertTrue(generatedTypeBuilder.hashCode() == generatedTypeBuilder2.hashCode());
+ assertFalse(generatedTypeBuilder.hashCode() == generatedTypeBuilder3.hashCode());
+ assertFalse(generatedTypeBuilder.hashCode() == generatedTypeBuilder4.hashCode());
+
+ }
+
+ @Test
+ public void addPropertyTest() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ GeneratedPropertyBuilder propertyBuilder = generatedTypeBuilder.addProperty("myProperty");
+ GeneratedPropertyBuilder propertyBuilder2 = generatedTypeBuilder.addProperty("myProperty2");
+ // GeneratedPropertyBuilder propertyBuilderNull =
+ // generatedTypeBuilder.addProperty(null);
+
+ assertNotNull(propertyBuilder);
+ assertNotNull(propertyBuilder2);
+ // assertNotNull(propertyBuilderNull);
+
+ assertTrue(generatedTypeBuilder.containsProperty("myProperty"));
+ assertTrue(generatedTypeBuilder.containsProperty("myProperty2"));
+ assertFalse(generatedTypeBuilder.containsProperty("myProperty3"));
+
+ GeneratedType instance = generatedTypeBuilder.toInstance();
+ List<GeneratedProperty> properties = instance.getProperties();
+
+ assertEquals(2, properties.size());
+
+ assertTrue(properties.contains(propertyBuilder.toInstance(instance)));
+ assertTrue(properties.contains(propertyBuilder2.toInstance(instance)));
+ // assertTrue(properties.contains(propertyBuilderNull.toInstance(instance)));
+ assertFalse(properties.contains(new GeneratedPropertyBuilderImpl("myProperty3").toInstance(instance)));
+
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void addMethodIllegalArgumentTest() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ generatedTypeBuilder.addMethod(null);
+ }
+
+ @Test
+ public void addMethodTest() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ MethodSignatureBuilder methodBuilder = generatedTypeBuilder.addMethod("myMethodName");
+ MethodSignatureBuilder methodBuilder2 = generatedTypeBuilder.addMethod("myMethodName2");
+
+ assertNotNull(methodBuilder);
+ assertNotNull(methodBuilder2);
+
+ assertTrue(generatedTypeBuilder.containsMethod("myMethodName"));
+ assertTrue(generatedTypeBuilder.containsMethod("myMethodName2"));
+ assertFalse(generatedTypeBuilder.containsMethod("myMethodName3"));
+
+ GeneratedType instance = generatedTypeBuilder.toInstance();
+ List<MethodSignature> methodDefinitions = instance.getMethodDefinitions();
+
+ assertEquals(2, methodDefinitions.size());
+
+ assertTrue(methodDefinitions.contains(methodBuilder.toInstance(instance)));
+ assertTrue(methodDefinitions.contains(methodBuilder2.toInstance(instance)));
+ assertFalse(methodDefinitions.contains(new MethodSignatureBuilderImpl("myMethodName3").toInstance(instance)));
+
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void addEnumerationIllegalArgumentTest() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ generatedTypeBuilder.addEnumeration(null);
+ }
+
+ @Test
+ public void addEnumerationTest() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ EnumBuilder enumBuilder = generatedTypeBuilder.addEnumeration("myEnumName");
+ EnumBuilder enumBuilder2 = generatedTypeBuilder.addEnumeration("myEnumName2");
+
+ assertNotNull(enumBuilder);
+ assertNotNull(enumBuilder2);
+
+ GeneratedType instance = generatedTypeBuilder.toInstance();
+ List<Enumeration> enumerations = instance.getEnumerations();
+
+ assertEquals(2, enumerations.size());
+
+ assertTrue(enumerations.contains(enumBuilder.toInstance(instance)));
+ assertTrue(enumerations.contains(enumBuilder2.toInstance(instance)));
+ assertFalse(enumerations.contains(new EnumerationBuilderImpl("my.package", "myEnumName3").toInstance(instance)));
+
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void addImplementsTypeIllegalArgumentTest() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ generatedTypeBuilder.addImplementsType(null);
+ }
+
+ @Test
+ public void addImplementsTypeTest() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ assertEquals(generatedTypeBuilder,
+ generatedTypeBuilder.addImplementsType(Types.typeForClass(Serializable.class)));
+ assertEquals(generatedTypeBuilder, generatedTypeBuilder.addImplementsType(Types.typeForClass(Runnable.class)));
+
+ GeneratedType instance = generatedTypeBuilder.toInstance();
+ List<Type> implementTypes = instance.getImplements();
+
+ assertEquals(2, implementTypes.size());
+
+ assertTrue(implementTypes.contains(Types.typeForClass(Serializable.class)));
+ assertTrue(implementTypes.contains(Types.typeForClass(Runnable.class)));
+ assertFalse(implementTypes.contains(Types.typeForClass(Throwable.class)));
+
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void addEnclosingTransferObjectIllegalArgumentTest() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ generatedTypeBuilder.addEnclosingTransferObject((String) null);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void addEnclosingTransferObjectIllegalArgumentTest2() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ generatedTypeBuilder.addEnclosingTransferObject((GeneratedTOBuilder) null);
+ }
+
+ @Test
+ public void addEnclosingTransferObjectTest() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ GeneratedTOBuilder enclosingTransferObject = generatedTypeBuilder.addEnclosingTransferObject("myTOName");
+ GeneratedTOBuilder enclosingTransferObject2 = generatedTypeBuilder.addEnclosingTransferObject("myTOName2");
+ assertEquals(generatedTypeBuilder, generatedTypeBuilder.addEnclosingTransferObject(new GeneratedTOBuilderImpl(
+ generatedTypeBuilder.getFullyQualifiedName(), "myTOName3")));
+
+ assertNotNull(enclosingTransferObject);
+ assertNotNull(enclosingTransferObject2);
+
+ GeneratedType instance = generatedTypeBuilder.toInstance();
+ List<GeneratedType> enclosedTypes = instance.getEnclosedTypes();
+
+ assertEquals(3, enclosedTypes.size());
+
+ assertTrue(enclosedTypes.contains(enclosingTransferObject.toInstance()));
+ assertTrue(enclosedTypes.contains(enclosingTransferObject2.toInstance()));
+ assertTrue(enclosedTypes.contains(new GeneratedTOBuilderImpl(generatedTypeBuilder.getFullyQualifiedName(),
+ "myTOName3").toInstance()));
+ assertFalse(enclosedTypes.contains(new GeneratedTOBuilderImpl(generatedTypeBuilder.getFullyQualifiedName(),
+ "myTOName4").toInstance()));
+
+ }
+
+ @Test
+ public void generatedTypeTest() {
+ GeneratedTypeBuilderImpl generatedTypeBuilder = new GeneratedTypeBuilderImpl("my.package", "MyName");
+
+ generatedTypeBuilder.setDescription("My description ...");
+ generatedTypeBuilder.setModuleName("myModuleName");
+ generatedTypeBuilder.setReference("myReference");
+ generatedTypeBuilder.setSchemaPath(SchemaPath.create(true, QName.create("/path")).getPathFromRoot());
+ assertNotNull(generatedTypeBuilder.addComment("My comment.."));
+
+ assertEquals(
+ "GeneratedTransferObject [packageName=my.package, name=MyName, comment=My comment.., annotations=[], implements=[], enclosedTypes=[], constants=[], enumerations=[], properties=, methods=[]]",
+ generatedTypeBuilder.toString());
+
+ GeneratedType instance = generatedTypeBuilder.toInstance();
+
+ assertEquals("My description ...", instance.getDescription());
+ assertEquals("myModuleName", instance.getModuleName());
+ assertEquals("myReference", instance.getReference());
+ assertEquals(SchemaPath.create(true, QName.create("/path")).getPathFromRoot(), instance.getSchemaPath());
+ assertEquals("My comment..", instance.getComment());
+ }
+
+}
Code Review / yangtools.git / commitdiff