Cleanup GeneratedTypeBuilder/enclosing mechanics

[mdsal.git] / binding / mdsal-binding-generator-util / src / test / java / org / opendaylight / mdsal / binding / model / util / generated / type / builder / GeneratedTypeBuilderTest.java

diff --git a/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/GeneratedTypeBuilderTest.java b/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/GeneratedTypeBuilderTest.java
index f77af510ad3e01cd073f5d6d0b4246db07870cef..6c4980e3d9e40dad199af29794d556ec40b43dbd 100644 (file)
--- a/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/GeneratedTypeBuilderTest.java
+++ b/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/GeneratedTypeBuilderTest.java
@@ -18,10 +18,11 @@ import org.junit.Test;
 import org.opendaylight.mdsal.binding.model.api.Constant;
 import org.opendaylight.mdsal.binding.model.api.Enumeration;
 import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
+import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
 import org.opendaylight.mdsal.binding.model.api.MethodSignature;
 import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
 import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
@@ -50,12 +51,9 @@ public class GeneratedTypeBuilderTest {
         Constant constant2 = generatedTypeBuilder.addConstant(
                 Types.typeForClass(int.class, 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");
+        Constant constant3 = new ConstantImpl(Types.typeForClass(String.class), "myConstant", "myConstantValue");
+        final Constant constant4 = new ConstantImpl(Types.typeForClass(String.class), "myConstant2", "myConstantValue");
+        final Constant constant5 = new ConstantImpl(Types.typeForClass(String.class), "myConstant", "myConstantValue2");
 
         assertNotNull(constant);
         assertNotNull(constant2);
@@ -79,9 +77,8 @@ public class GeneratedTypeBuilderTest {
         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("Constant [type=Type (java.lang.String), name=myConstant, value=myConstantValue]",
+            constant.toString());
 
         assertEquals("Type (java.lang.String) myConstant myConstantValue", constant.toFormattedString());
 
@@ -98,7 +95,6 @@ public class GeneratedTypeBuilderTest {
         assertEquals("myConstant", constant.getName());
         assertEquals("myConstantValue", constant.getValue());
         assertEquals(Types.typeForClass(String.class), constant.getType());
-        assertEquals(generatedTypeBuilder, constant.getDefiningType());
     }
 
     @Test(expected = IllegalArgumentException.class)
@@ -115,13 +111,13 @@ public class GeneratedTypeBuilderTest {
 
     @Test
     public void generatedTypeBuilderEqualsAndHashCodeTest() {
-        CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+        final CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
             JavaTypeName.create("my.package", "MyName"));
-        CodegenGeneratedTypeBuilder generatedTypeBuilder2 = new CodegenGeneratedTypeBuilder(
+        final CodegenGeneratedTypeBuilder generatedTypeBuilder2 = new CodegenGeneratedTypeBuilder(
             JavaTypeName.create("my.package", "MyName"));
-        CodegenGeneratedTypeBuilder generatedTypeBuilder3 = new CodegenGeneratedTypeBuilder(
+        final CodegenGeneratedTypeBuilder generatedTypeBuilder3 = new CodegenGeneratedTypeBuilder(
             JavaTypeName.create("my.package", "MyName2"));
-        CodegenGeneratedTypeBuilder generatedTypeBuilder4 = new CodegenGeneratedTypeBuilder(
+        final CodegenGeneratedTypeBuilder generatedTypeBuilder4 = new CodegenGeneratedTypeBuilder(
             JavaTypeName.create("my.package2", "MyName"));
 
         assertFalse(generatedTypeBuilder.equals(null));
@@ -159,10 +155,10 @@ public class GeneratedTypeBuilderTest {
 
         assertEquals(2, properties.size());
 
-        assertTrue(properties.contains(propertyBuilder.toInstance(instance)));
-        assertTrue(properties.contains(propertyBuilder2.toInstance(instance)));
+        assertTrue(properties.contains(propertyBuilder.toInstance()));
+        assertTrue(properties.contains(propertyBuilder2.toInstance()));
         // assertTrue(properties.contains(propertyBuilderNull.toInstance(instance)));
-        assertFalse(properties.contains(new GeneratedPropertyBuilderImpl("myProperty3").toInstance(instance)));
+        assertFalse(properties.contains(new GeneratedPropertyBuilderImpl("myProperty3").toInstance()));
 
     }
 
@@ -207,21 +203,23 @@ public class GeneratedTypeBuilderTest {
         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
             JavaTypeName.create("my.package", "MyName"));
 
-        EnumBuilder enumBuilder = generatedTypeBuilder.addEnumeration("myEnumName");
-        EnumBuilder enumBuilder2 = generatedTypeBuilder.addEnumeration("myEnumName2");
+        EnumBuilder enumBuilder = new CodegenEnumerationBuilder(generatedTypeBuilder.getIdentifier()
+            .createEnclosed("myEnumName"));
+        EnumBuilder enumBuilder2 = new CodegenEnumerationBuilder(generatedTypeBuilder.getIdentifier()
+            .createEnclosed("myEnumName2"));
 
-        assertNotNull(enumBuilder);
-        assertNotNull(enumBuilder2);
+        generatedTypeBuilder.addEnumeration(enumBuilder.toInstance());
+        generatedTypeBuilder.addEnumeration(enumBuilder2.toInstance());
 
         GeneratedType instance = generatedTypeBuilder.build();
         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 CodegenEnumerationBuilder(JavaTypeName.create("my.package", "myEnumName3"))
-            .toInstance(instance)));
+        assertTrue(enumerations.contains(enumBuilder.toInstance()));
+        assertTrue(enumerations.contains(enumBuilder2.toInstance()));
+        assertFalse(enumerations.contains(new CodegenEnumerationBuilder(JavaTypeName.create("my.package",
+            "myEnumName3")).toInstance()));
 
     }
 
@@ -249,16 +247,10 @@ public class GeneratedTypeBuilderTest {
         assertFalse(implementTypes.contains(Types.typeForClass(Throwable.class)));
     }
 
-    @Test(expected = IllegalArgumentException.class)
-    public void addEnclosingTransferObjectIllegalArgumentTest() {
-        new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName"))
-        .addEnclosingTransferObject((String) null);
-    }
-
     @Test(expected = IllegalArgumentException.class)
     public void addEnclosingTransferObjectIllegalArgumentTest2() {
-        new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName"))
-        .addEnclosingTransferObject((GeneratedTOBuilder) null);
+        new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnclosingTransferObject(
+            (GeneratedTransferObject) null);
     }
 
     @Test
@@ -266,14 +258,16 @@ public class GeneratedTypeBuilderTest {
         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
             JavaTypeName.create("my.package", "MyName"));
 
-        GeneratedTOBuilder enclosingTransferObject = generatedTypeBuilder.addEnclosingTransferObject("myTOName");
-        GeneratedTOBuilder enclosingTransferObject2 = generatedTypeBuilder.addEnclosingTransferObject("myTOName2");
-        assertEquals(generatedTypeBuilder, generatedTypeBuilder.addEnclosingTransferObject(
-            new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier().createEnclosed("myTOName3"))));
-
-        assertNotNull(enclosingTransferObject);
-        assertNotNull(enclosingTransferObject2);
+        GeneratedTOBuilder enclosingTransferObject = new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier()
+            .createEnclosed("myTOName"));
+        GeneratedTOBuilder enclosingTransferObject2 = new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier()
+            .createEnclosed("myTOName2"));
+        GeneratedTOBuilder enclosingTransferObject3 = new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier()
+            .createEnclosed("myTOName3"));
 
+        generatedTypeBuilder.addEnclosingTransferObject(enclosingTransferObject.build());
+        generatedTypeBuilder.addEnclosingTransferObject(enclosingTransferObject2.build());
+        generatedTypeBuilder.addEnclosingTransferObject(enclosingTransferObject3.build());
         GeneratedType instance = generatedTypeBuilder.build();
         List<GeneratedType> enclosedTypes = instance.getEnclosedTypes();
 
@@ -281,8 +275,7 @@ public class GeneratedTypeBuilderTest {
 
         assertTrue(enclosedTypes.contains(enclosingTransferObject.build()));
         assertTrue(enclosedTypes.contains(enclosingTransferObject2.build()));
-        assertTrue(enclosedTypes.contains(new CodegenGeneratedTOBuilder(
-            generatedTypeBuilder.getIdentifier().createEnclosed("myTOName3")).build()));
+        assertTrue(enclosedTypes.contains(enclosingTransferObject3.build()));
         assertFalse(enclosedTypes.contains(new CodegenGeneratedTOBuilder(
             generatedTypeBuilder.getIdentifier().createEnclosed("myTOName4")).build()));
     }
@@ -295,12 +288,12 @@ public class GeneratedTypeBuilderTest {
         generatedTypeBuilder.setDescription("My description ...");
         generatedTypeBuilder.setModuleName("myModuleName");
         generatedTypeBuilder.setReference("myReference");
-        generatedTypeBuilder.setSchemaPath(SchemaPath.create(true, QName.create("test", "/path")));
+        generatedTypeBuilder.setSchemaPath(SchemaPath.create(true, QName.create("test", "path")));
         assertNotNull(generatedTypeBuilder.addComment(TypeComments.javadoc("My comment..").get()));
 
         assertEquals(
                 "GeneratedTransferObject [packageName=my.package, name=MyName, comment=My comment.., annotations=[], "
-                        + "implements=[], enclosedTypes=[], constants=[], enumerations=[], properties=, methods=[]]",
+                        + "implements=[], constants=[], enumerations=[], properties=, methods=[]]",
                         generatedTypeBuilder.toString());
 
         GeneratedType instance = generatedTypeBuilder.build();
@@ -308,7 +301,8 @@ public class GeneratedTypeBuilderTest {
         assertEquals("My description ...", instance.getDescription());
         assertEquals("myModuleName", instance.getModuleName());
         assertEquals("myReference", instance.getReference());
-        assertEquals(SchemaPath.create(true, QName.create("test", "/path")).getPathFromRoot(), instance.getSchemaPath());
+        assertEquals(SchemaPath.create(true, QName.create("test", "path")).getPathFromRoot(),
+            instance.getSchemaPath());
         assertEquals("My comment..", instance.getComment().getJavadoc());
     }
 }