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.type.builder.EnumBuilder;
@Test
public void addConstantTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
// assertNotNull(generatedTypeBuilder.addComment("My comment ..."));
// generatedTypeBuilder.addConstant(Types.typeForClass(String.class),
// "myConstant", "myConstantValue");
Constant constant2 = generatedTypeBuilder.addConstant(
- Types.primitiveType("int", BindingGeneratorUtil.getRestrictions(null)), "myIntConstant", 1);
+ 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);
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());
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 CodegenGeneratedTypeBuilder("my.package", "MyName");
- generatedTypeBuilder.addConstant(Types.typeForClass(String.class), null, "myConstantValue");
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addConstant(
+ Types.typeForClass(String.class), null, "myConstantValue");
}
@Test(expected = IllegalArgumentException.class)
public void addConstantIllegalArgumentTest2() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
- generatedTypeBuilder.addConstant(null, "myConstantName", "myConstantValue");
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addConstant(null, "myConstantName",
+ "myConstantValue");
}
@Test
public void generatedTypeBuilderEqualsAndHashCodeTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
- CodegenGeneratedTypeBuilder generatedTypeBuilder2 = new CodegenGeneratedTypeBuilder("my.package", "MyName");
- CodegenGeneratedTypeBuilder generatedTypeBuilder3 = new CodegenGeneratedTypeBuilder("my.package", "MyName2");
- CodegenGeneratedTypeBuilder generatedTypeBuilder4 = new CodegenGeneratedTypeBuilder("my.package2", "MyName");
+ final CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
+ final CodegenGeneratedTypeBuilder generatedTypeBuilder2 = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
+ final CodegenGeneratedTypeBuilder generatedTypeBuilder3 = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName2"));
+ final CodegenGeneratedTypeBuilder generatedTypeBuilder4 = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package2", "MyName"));
assertFalse(generatedTypeBuilder.equals(null));
assertFalse(generatedTypeBuilder.equals(new Object()));
@Test
public void addPropertyTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
GeneratedPropertyBuilder propertyBuilder = generatedTypeBuilder.addProperty("myProperty");
GeneratedPropertyBuilder propertyBuilder2 = generatedTypeBuilder.addProperty("myProperty2");
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()));
}
@Test(expected = IllegalArgumentException.class)
public void addMethodIllegalArgumentTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
- generatedTypeBuilder.addMethod(null);
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addMethod(null);
}
@Test
public void addMethodTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
MethodSignatureBuilder methodBuilder = generatedTypeBuilder.addMethod("myMethodName");
MethodSignatureBuilder methodBuilder2 = generatedTypeBuilder.addMethod("myMethodName2");
@Test(expected = IllegalArgumentException.class)
public void addEnumerationIllegalArgumentTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
-
- generatedTypeBuilder.addEnumeration(null);
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnumeration(null);
}
@Test
public void addEnumerationTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ 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("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()));
}
@Test(expected = IllegalArgumentException.class)
public void addImplementsTypeIllegalArgumentTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
-
- generatedTypeBuilder.addImplementsType(null);
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addImplementsType(null);
}
@Test
public void addImplementsTypeTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
assertEquals(generatedTypeBuilder,
generatedTypeBuilder.addImplementsType(Types.typeForClass(Serializable.class)));
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() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
-
- generatedTypeBuilder.addEnclosingTransferObject((String) null);
}
@Test(expected = IllegalArgumentException.class)
public void addEnclosingTransferObjectIllegalArgumentTest2() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
-
- generatedTypeBuilder.addEnclosingTransferObject((GeneratedTOBuilder) null);
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnclosingTransferObject(
+ (GeneratedTransferObject) null);
}
@Test
public void addEnclosingTransferObjectTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
-
- GeneratedTOBuilder enclosingTransferObject = generatedTypeBuilder.addEnclosingTransferObject("myTOName");
- GeneratedTOBuilder enclosingTransferObject2 = generatedTypeBuilder.addEnclosingTransferObject("myTOName2");
- assertEquals(generatedTypeBuilder, generatedTypeBuilder.addEnclosingTransferObject(new CodegenGeneratedTOBuilder(
- generatedTypeBuilder.getFullyQualifiedName(), "myTOName3")));
-
- assertNotNull(enclosingTransferObject);
- assertNotNull(enclosingTransferObject2);
-
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
+
+ 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();
assertTrue(enclosedTypes.contains(enclosingTransferObject.build()));
assertTrue(enclosedTypes.contains(enclosingTransferObject2.build()));
- assertTrue(enclosedTypes.contains(new CodegenGeneratedTOBuilder(generatedTypeBuilder.getFullyQualifiedName(),
- "myTOName3").build()));
- assertFalse(enclosedTypes.contains(new CodegenGeneratedTOBuilder(generatedTypeBuilder.getFullyQualifiedName(),
- "myTOName4").build()));
-
+ assertTrue(enclosedTypes.contains(enclosingTransferObject3.build()));
+ assertFalse(enclosedTypes.contains(new CodegenGeneratedTOBuilder(
+ generatedTypeBuilder.getIdentifier().createEnclosed("myTOName4")).build()));
}
@Test
public void generatedTypeTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
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=[]]",
- generatedTypeBuilder.toString());
+ "GeneratedTransferObject [packageName=my.package, name=MyName, comment=My comment.., annotations=[], "
+ + "implements=[], constants=[], enumerations=[], properties=, methods=[]]",
+ generatedTypeBuilder.toString());
GeneratedType instance = generatedTypeBuilder.build();
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());
}
}
Code Review / mdsal.git / blobdiff