void checkConstant(ConstantInfo param, String name, Type expectedType) { TypeInfo expectedTypeInfo = TypeReflectionFactory.create(expectedType); checkConstant(param, name, expectedTypeInfo); }
private void doTest(Class<?> container, Consumer<Map<String, TypeInfo>> assertion) throws Exception { Map<String, TypeInfo> reflectedMap = Stream.of(container.getDeclaredMethods()).filter(m -> Modifier.isPublic(m.getModifiers())). collect(Collectors.toMap(Method::getName, m -> TypeReflectionFactory.create(m.getGenericReturnType()))); assertion.accept(reflectedMap); Utils.assertProcess((proc, env) -> { TypeMirrorFactory factory = new TypeMirrorFactory(proc.getElementUtils(), proc.getTypeUtils()); TypeElement modelMap = proc.getElementUtils().getTypeElement(container.getName()); Map<String, TypeInfo> collect = modelMap.getEnclosedElements().stream(). flatMap(Helper.FILTER_METHOD). filter(elt -> elt.getModifiers().contains(javax.lang.model.element.Modifier.PUBLIC)). collect(Collectors.toMap(m -> m.getSimpleName().toString(), m -> factory.create(m.getReturnType()))); assertion.accept(collect); }); }
@Test public void testGetErased() { abstract class Container<M> implements AsyncResult<List<M>> {} abstract class Expected implements AsyncResult<List<Object>> {} ParameterizedTypeInfo info = (ParameterizedTypeInfo) TypeReflectionFactory.create(Container.class.getGenericInterfaces()[0]); ParameterizedTypeInfo expected = (ParameterizedTypeInfo) TypeReflectionFactory.create(Expected.class.getGenericInterfaces()[0]); assertEquals(expected, info.getErased()); } }
@Test public void testMethodWithDiamond() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithDiamond.class, DiamondMethod1.class, DiamondMethod2.class, DiamondMethod3.class); List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); checkMethod(methods.get(0), "foo", 0, "U", MethodKind.OTHER); assertEquals(set(TypeReflectionFactory.create(DiamondMethod1.class), TypeReflectionFactory.create(DiamondMethod2.class), TypeReflectionFactory.create(DiamondMethod3.class)), methods.get(0).getOwnerTypes()); }
@Test public void testSetterNormalizationRules() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(SetterNormalizationRules.class); assertNotNull(model); assertEquals(3, model.getPropertyMap().size()); assertProperty(model.getPropertyMap().get("ha"), "ha", "setHA", null, null, TypeReflectionFactory.create(boolean.class), true, PropertyKind.VALUE, true); assertProperty(model.getPropertyMap().get("haGroup"), "haGroup", "setHAGroup", null, null, TypeReflectionFactory.create(boolean.class), true, PropertyKind.VALUE, true); assertProperty(model.getPropertyMap().get("group"), "group", "setGroup", null, null, TypeReflectionFactory.create(boolean.class), true, PropertyKind.VALUE, true); }
@Test public void testAdderNormalizationRules() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(AdderNormalizationRules.class); assertNotNull(model); assertEquals(3, model.getPropertyMap().size()); assertProperty(model.getPropertyMap().get("urls"), "urls", null, "addURL", null, TypeReflectionFactory.create(boolean.class), true, PropertyKind.LIST, true); assertProperty(model.getPropertyMap().get("urlLocators"), "urlLocators", null, "addURLLocator", null, TypeReflectionFactory.create(boolean.class), true, PropertyKind.LIST, true); assertProperty(model.getPropertyMap().get("locators"), "locators", null, "addLocator", null, TypeReflectionFactory.create(boolean.class), true, PropertyKind.LIST, true); }
@Test public void testInterfaceWithTypeVariableArgument() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithTypeVariableArgument3.class, InterfaceWithTypeVariableArgument2.class, InterfaceWithTypeVariableArgument1.class); List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); checkMethod(methods.get(0), "foo", 0, InterfaceWithTypeVariableArgument3.class, MethodKind.OTHER); assertEquals(set( TypeReflectionFactory.create(InterfaceWithTypeVariableArgument1.class), TypeReflectionFactory.create(InterfaceWithTypeVariableArgument2.class) ), methods.get(0).getOwnerTypes()); }
@Test public void testMethodOverride() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithMethodOverride.class, VertxGenInterface.class); List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); checkMethod(methods.get(0), "bar", 1, "void", MethodKind.OTHER); assertEquals(set( TypeReflectionFactory.create(InterfaceWithMethodOverride.class), TypeReflectionFactory.create(VertxGenInterface.class) ), methods.get(0).getOwnerTypes()); checkParam(methods.get(0).getParams().get(0), "str", String.class); }
@Test public void testMethodWithSameSignatureInheritedFromDistinctInterfaces() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithSameSignatureInheritedFromDistinctInterfaces.class, SameSignatureMethod1.class, SameSignatureMethod2.class); List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); checkMethod(methods.get(0), "foo", 0, "U", MethodKind.OTHER); assertEquals(set(TypeReflectionFactory.create(SameSignatureMethod1.class), TypeReflectionFactory.create(SameSignatureMethod2.class)), methods.get(0).getOwnerTypes()); }
@Test public void testMethodOverrideParameterRenamed() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithMethodOverrideParameterRenamed.class, VertxGenInterface.class); List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); checkMethod(methods.get(0), "bar", 1, "void", MethodKind.OTHER); assertEquals(set( TypeReflectionFactory.create(InterfaceWithMethodOverrideParameterRenamed.class), TypeReflectionFactory.create(VertxGenInterface.class) ), methods.get(0).getOwnerTypes()); checkParam(methods.get(0).getParams().get(0), "str_renamed", String.class); }
@Test public void testConcreteOverridesFromAbstractDataObject() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(ConcreteOverridesFromAbstractDataObject.class); assertNotNull(model); assertTrue(model.isConcrete()); assertEquals(3, model.getPropertyMap().size()); assertProperty(model.getPropertyMap().get("inheritedProperty"), "inheritedProperty", "setInheritedProperty", null, null, TypeReflectionFactory.create(String.class), false, PropertyKind.VALUE, true); assertProperty(model.getPropertyMap().get("overriddenProperty"), "overriddenProperty", "setOverriddenProperty", null, null, TypeReflectionFactory.create(String.class), false, PropertyKind.VALUE, true); assertProperty(model.getPropertyMap().get("abstractProperty"), "abstractProperty", "setAbstractProperty", null, null, TypeReflectionFactory.create(String.class), true, PropertyKind.VALUE, true); }
@Test public void testSetterWithNonFluentReturnType() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(SetterWithNonFluentReturnType.class); assertNotNull(model); assertEquals(2, model.getPropertyMap().size()); assertProperty(model.getPropertyMap().get("string"), "string", "setString", null, null, TypeReflectionFactory.create(String.class), true, PropertyKind.VALUE, true); assertProperty(model.getPropertyMap().get("primitiveBoolean"), "primitiveBoolean", "setPrimitiveBoolean", null, null, TypeReflectionFactory.create(boolean.class), true, PropertyKind.VALUE, true); }
@Test public void testFluentMethodOverrideFromConcrete() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithFluentMethodOverrideFromConcrete.class); assertEquals(InterfaceWithFluentMethodOverrideFromConcrete.class.getName(), model.getIfaceFQCN()); assertEquals(InterfaceWithFluentMethodOverrideFromConcrete.class.getSimpleName(), model.getIfaceSimpleName()); assertEquals(Collections.singleton((ClassTypeInfo) TypeReflectionFactory.create(ConcreteInterfaceWithFluentMethods.class)), model.getReferencedTypes()); assertEquals(Collections.singletonList(TypeReflectionFactory.create(ConcreteInterfaceWithFluentMethods.class)), model.getSuperTypes()); List<MethodInfo> methods = model.getMethods(); assertEquals(2, methods.size()); checkMethod(methods.get(0), "foo", 1, InterfaceWithFluentMethodOverrideFromConcrete.class, MethodKind.OTHER, MethodCheck.FLUENT); checkMethod(methods.get(1), "bar", 1, InterfaceWithFluentMethodOverrideFromConcrete.class, MethodKind.OTHER, MethodCheck.FLUENT); }
@Test public void testFluentMethodOverrideFromAbstract() throws Exception { GeneratorHelper gen = new GeneratorHelper(); ClassModel model = gen.generateClass(InterfaceWithFluentMethodOverrideFromAbstract.class); assertEquals(InterfaceWithFluentMethodOverrideFromAbstract.class.getName(), model.getIfaceFQCN()); assertEquals(InterfaceWithFluentMethodOverrideFromAbstract.class.getSimpleName(), model.getIfaceSimpleName()); assertEquals(Collections.singleton((ClassTypeInfo) TypeReflectionFactory.create(AbstractInterfaceWithFluentMethods.class)), model.getReferencedTypes()); assertEquals(Collections.singletonList(TypeReflectionFactory.create(AbstractInterfaceWithFluentMethods.class)), model.getSuperTypes()); List<MethodInfo> methods = model.getMethods(); assertEquals(2, methods.size()); checkMethod(methods.get(0), "foo", 1, InterfaceWithFluentMethodOverrideFromAbstract.class, MethodKind.OTHER, MethodCheck.FLUENT); checkMethod(methods.get(1), "bar", 1, InterfaceWithFluentMethodOverrideFromAbstract.class, MethodKind.OTHER, MethodCheck.FLUENT); }
@Test public void testStaticSuperStaticMethods() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithSuperStaticMethods.class); assertEquals(InterfaceWithSuperStaticMethods.class.getName(), model.getIfaceFQCN()); assertEquals(InterfaceWithSuperStaticMethods.class.getSimpleName(), model.getIfaceSimpleName()); assertEquals(Collections.singletonList(TypeReflectionFactory.create(InterfaceWithStaticMethods.class)), model.getSuperTypes()); assertEquals(0, model.getMethods().size()); }
@Test public void testImportedSubinterface() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(ImportedSubinterface.class); assertNotNull(model); assertEquals(Collections.singleton((ClassTypeInfo) TypeReflectionFactory.create(Imported.class)), model.getImportedTypes()); }
@Test public void testConcreteInheritsConcrete() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(ConcreteExtendsConcrete.class); assertNotNull(model); assertTrue(model.isConcrete()); assertEquals(0, model.getPropertyMap().size()); assertEquals(Collections.singleton((ClassTypeInfo) TypeReflectionFactory.create(Concrete.class)), model.getSuperTypes()); assertEquals(TypeReflectionFactory.create(Concrete.class), model.getSuperType()); assertEquals(Collections.<ClassTypeInfo>emptySet(), model.getAbstractSuperTypes()); }
@Test public void testConcreteImplementsAbstract() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(ConcreteInheritsAbstract.class); assertNotNull(model); assertTrue(model.isConcrete()); assertEquals(0, model.getPropertyMap().size()); assertEquals(Collections.singleton((ClassTypeInfo) TypeReflectionFactory.create(Abstract.class)), model.getSuperTypes()); assertEquals(Collections.singleton((ClassTypeInfo) TypeReflectionFactory.create(Abstract.class)), model.getAbstractSuperTypes()); assertNull(model.getSuperType()); }
@Test public void testImportedNested() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(ImportedNested.class); assertNotNull(model); assertEquals(Collections.singleton((ClassTypeInfo) TypeReflectionFactory.create(Imported.class)), model.getImportedTypes()); }
@Test public void testJsonObjectSetter() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(JsonObjectSetter.class); assertNotNull(model); assertEquals(1, model.getPropertyMap().size()); assertProperty(model.getPropertyMap().get("jsonObject"), "jsonObject", "setJsonObject", null, null, TypeReflectionFactory.create(JsonObject.class), true, PropertyKind.VALUE, true); }