private void sortMethodMap(Map<String, List<MethodInfo>> map) { for (List<MethodInfo> list: map.values()) { list.sort(Comparator.comparingInt(meth -> meth.getParams().size())); } }
public static String invokeMethodWithoutConvertingReturn(String target, TypeInfo type, MethodInfo method, Collection<TypeParamInfo> typeParams) { String paramString = String.join(", ", method.getParams().stream() .map(param -> toJavaWithConversion(escapeIfKeyword(param.getName()), param.getType(), typeParams, method.getTypeParams())) .collect(Collectors.toList())); return target + "." + escapeIfKeyword(method.getName()) + assembleTypeParamString(method) + "(" + paramString + ")"; }
private Stream<SimpleMethod> convert(Stream<MethodInfo> meths) { return meths.map(meth -> { List<SimpleParam> simpleParams = new ArrayList<>(); for (ParamInfo param: meth.getParams()) { TypeInfo type = param.getType(); simpleParams.add(new SimpleParam(param.getName(), type.getKind(), param.isNullable(), type.getName())); } return new SimpleMethod(meth.getName(), simpleParams); }); }
@Test public void testInterfaceWithNullableParamOverride() throws Exception { Consumer<ClassModel> test = model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); assertTrue(mi1.getParams().get(0).isNullable()); }; // generateClass(test, MethodWithNullableParamOverride.class, MethodWithNullableParam.class); generateClass(test, MethodWithNullableParamOverride.class); }
@Test public void testMethodWithNullableNonAnnotatedObjectParam() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 1, "void", MethodKind.OTHER); assertTrue(mi1.getParams().get(0).isNullable()); }, MethodWithNullableNonAnnotatedObjectParam.class); }
@Test public void testMethodWithNullableNonAnnotatedTypeVariableParam() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 1, "void", MethodKind.OTHER); assertTrue(mi1.getParams().get(0).isNullable()); }, MethodWithNullableNonAnnotatedTypeVariableParam.class); }
@Test public void testMethodWithNullableHandler() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 1, "void", MethodKind.HANDLER); assertTrue(mi1.getParams().get(0).isNullable()); }, MethodWithNullableHandler.class); }
@Test public void testMethodWithNullableNonAnnotatedTypeVariableHandler() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 1, "void", MethodKind.HANDLER); assertFalse(mi1.getParams().get(0).isNullableCallback()); }, MethodWithNullableNonAnnotatedTypeVariableHandler.class); }
@Test public void testMethodWithNullableParam() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 1, "void", MethodKind.OTHER); assertTrue(mi1.getParams().get(0).isNullable()); }, MethodWithNullableParam.class); }
@Test public void testMethodWithNullableHandlerAsyncResult() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 1, "void", MethodKind.FUTURE); assertTrue(mi1.getParams().get(0).isNullable()); }, MethodWithNullableHandlerAsyncResult.class); }
@Test public void testMethodWithNullableStringHandlerAsyncResult() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 1, "void", MethodKind.FUTURE); assertTrue(mi1.getParams().get(0).isNullableCallback()); }, MethodWithNullableStringHandlerAsyncResult.class); }
@Test public void testMethodWithNullableNonAnnotatedTypeVariableHandlerAsyncResult() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 1, "void", MethodKind.FUTURE); assertFalse(mi1.getParams().get(0).isNullableCallback()); }, MethodWithNullableNonAnnotatedTypeVariableHandlerAsyncResult.class); }
@Test public void testJsonParams() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithValidJSONParams.class); assertEquals(MethodWithValidJSONParams.class.getName(), model.getIfaceFQCN()); assertEquals(MethodWithValidJSONParams.class.getSimpleName(), model.getIfaceSimpleName()); assertTrue(model.getReferencedTypes().isEmpty()); assertTrue(model.getSuperTypes().isEmpty()); List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); checkMethod(methods.get(0), "methodWithJsonParams", 2, "void", MethodKind.OTHER); checkParam(model.getMethods().get(0).getParams().get(0), "jsonObject", JsonObject.class); checkParam(model.getMethods().get(0).getParams().get(1), "jsonArray", JsonArray.class); }
@Test public void testMethodWithNullableTypeVariableParam() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 1, "void", MethodKind.OTHER); assertTrue(mi1.getParams().get(0).isNullable()); }, MethodWithNullableTypeVariableParam.class); }
@Test public void testMethodWithNullableInheritedParams() throws Exception { Consumer<ClassModel> check = model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi2 = methods.get(0); assertTrue(mi2.getParams().get(0).getType().isNullable()); assertTrue(((ParameterizedTypeInfo) mi2.getParams().get(1).getType()).getArg(0).isNullable()); assertTrue(((ParameterizedTypeInfo) ((ParameterizedTypeInfo) mi2.getParams().get(2).getType()).getArg(0)).getArg(0).isNullable()); }; generateClass(check, MethodWithNullableInheritedParams.class, MethodWithNullableParams.class); generateClass(check, MethodWithNullableInheritedParams.class); }
@Test public void testInterfaceWithListNullableParamOverride() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi2 = methods.get(0); assertTrue(((ParameterizedTypeInfo) mi2.getParams().get(0).getType()).getArg(0).isNullable()); }, MethodWithListNullableParamOverride.class, MethodWithListNullableParam.class); }
@Test public void testValidVoidTypeArg() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithValidVoidTypeArg.class); assertEquals(1, model.getMethods().size()); MethodInfo mi = model.getMethods().get(0); assertEquals("foo", mi.getName()); assertEquals(new ParameterizedTypeInfo(new ClassTypeInfo(ClassKind.API, GenericInterface.class.getName(), null, false, Collections.emptyList()), false, Arrays.asList(TypeReflectionFactory.create(Void.class))), mi.getParams().get(0).getType()); ParameterizedTypeInfo genericType = (ParameterizedTypeInfo) mi.getParams().get(0).getType(); ClassTypeInfo voidType = (ClassTypeInfo) genericType.getArgs().get(0); assertEquals(ClassKind.VOID, voidType.getKind()); }
@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 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 testValidExceptionParam() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithValidThrowableParam.class); assertEquals(0, model.getReferencedTypes().size()); assertEquals(1, model.getImportedTypes().size()); assertEquals(ClassKind.THROWABLE, model.getImportedTypes().iterator().next().getKind()); assertEquals(1, model.getMethods().size()); String methodName = "methodWithThrowableParam"; MethodInfo method = model.getMethods().get(0); checkMethod(method, methodName, 1, "void", MethodKind.OTHER); List<ParamInfo> params = method.getParams(); checkParam(params.get(0), "t", Throwable.class); }