public static boolean isLastParamAsyncResultHandler(MethodInfo method) { int size = method.getParams().size(); return isAsyncResultHandler(method.getParam(size-1).getType()); }
@Test public <R> void testInterfaceExtendingGenericInterface() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithParameterizedDeclaredSupertype.class, GenericInterface.class); List<TypeInfo> superTypeArgs = model.getSuperTypeArguments(); assertEquals(1, superTypeArgs.size()); ClassTypeInfo superTypeArg = (ClassTypeInfo) superTypeArgs.get(0); assertEquals(ClassKind.STRING, superTypeArg.getKind()); List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); checkMethod(methods.get(0), "methodWithClassTypeParam", 3, String.class, MethodKind.OTHER); checkParam(methods.get(0).getParam(0), "t", String.class); checkParam(methods.get(0).getParam(1), "handler", new TypeLiteral<Handler<String>>() {}); checkParam(methods.get(0).getParam(2), "asyncResultHandler", new TypeLiteral<Handler<AsyncResult<String>>>() {}); }
public static TypeInfo typeOfReturnedFuture(MethodInfo method) { return ((ParameterizedTypeInfo)((ParameterizedTypeInfo)method.getParam(method.getParams().size()-1).getType()).getArg(0)).getArg(0); }
@Test public void testOverloadedFromParent() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithMethodOverloadedFromParent.class); List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); checkMethod(methods.get(0), "foo", 1, "void", MethodKind.OTHER); checkParam(methods.get(0).getParam(0), "str", String.class); methods = model.getMethodMap().get("foo"); assertEquals(2, methods.size()); checkMethod(methods.get(0), "foo", 0, "void", MethodKind.OTHER); checkMethod(methods.get(1), "foo", 1, "void", MethodKind.OTHER); }
private MethodInfo genFutureMethod(MethodInfo method) { String futMethodName = genFutureMethodName(method); List<ParamInfo> futParams = new ArrayList<>(); int count = 0; int size = method.getParams().size() - 1; while (count < size) { ParamInfo param = method.getParam(count); /* Transform ReadStream -> Flowable */ futParams.add(param); count = count + 1; } ParamInfo futParam = method.getParam(size); TypeInfo futType = ((ParameterizedTypeInfo) ((ParameterizedTypeInfo) futParam.getType()).getArg(0)).getArg(0); TypeInfo futUnresolvedType = ((ParameterizedTypeInfo) ((ParameterizedTypeInfo) futParam.getUnresolvedType()).getArg(0)).getArg(0); TypeInfo futReturnType; if (futUnresolvedType.getKind() == VOID) { futReturnType = io.vertx.codegen.type.TypeReflectionFactory.create(io.reactivex.Completable.class); } else if (futUnresolvedType.isNullable()) { futReturnType = new io.vertx.codegen.type.ParameterizedTypeInfo(io.vertx.codegen.type.TypeReflectionFactory.create(io.reactivex.Maybe.class).getRaw(), false, Collections.singletonList(futType)); } else { futReturnType = new io.vertx.codegen.type.ParameterizedTypeInfo(io.vertx.codegen.type.TypeReflectionFactory.create(io.reactivex.Single.class).getRaw(), false, Collections.singletonList(futType)); } return method.copy().setName(futMethodName).setReturnType(futReturnType).setParams(futParams); }
@Test public void testValidClassTypeParams() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithValidClassTypeParams.class); List<MethodInfo> methods = model.getMethods(); assertEquals(2, methods.size()); MethodInfo methodParam = methods.get(0); checkMethod(methodParam, "methodParam", 2, "void", MethodKind.OTHER); ParamInfo resolved = methodParam.resolveClassTypeParam((TypeVariableInfo) methodParam.getParam(0).getType()); assertSame(resolved, methodParam.getParam(1)); MethodInfo returnParam = methods.get(1); checkMethod(returnParam, "returnParam", 1, "T", MethodKind.OTHER); resolved = methodParam.resolveClassTypeParam((TypeVariableInfo) returnParam.getReturnType()); assertSame(resolved, methodParam.getParam(1)); }
@Test public <T> void testParameterizedClassSuperType() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithParameterizedDeclaredSupertype.class, GenericInterface.class); assertEquals(InterfaceWithParameterizedDeclaredSupertype.class.getName(), model.getIfaceFQCN()); assertEquals(InterfaceWithParameterizedDeclaredSupertype.class.getSimpleName(), model.getIfaceSimpleName()); assertEquals(1, model.getReferencedTypes().size()); assertTrue(model.getReferencedTypes().contains(GenericInterfaceInfo)); assertEquals(1, model.getSuperTypes().size()); assertTrue(model.getSuperTypes().contains(TypeReflectionFactory.create(InterfaceWithParameterizedDeclaredSupertype.class.getGenericInterfaces()[0]))); List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); checkMethod(methods.get(0), "methodWithClassTypeParam", 3, "java.lang.String", MethodKind.OTHER); checkParam(methods.get(0).getParam(0), "t", new TypeLiteral<String>() {}, new TypeLiteral<T>() {}); checkParam(methods.get(0).getParam(1), "handler", new TypeLiteral<Handler<String>>() {}, new TypeLiteral<Handler<T>>() {}); checkParam(methods.get(0).getParam(2), "asyncResultHandler", new TypeLiteral<Handler<AsyncResult<String>>>() {}, new TypeLiteral<Handler<AsyncResult<T>>>() {}); }
@Test public void testMethodWithTypeVarParamByGenericType() throws Exception { Runnable test = () -> { try { ClassModel model = new GeneratorHelper().generateClass(MethodWithTypeVarParamByGenericType.class); MethodInfo meth = model.getMethods().get(0); ParamInfo param = meth.getParam(0); ParameterizedTypeInfo handler = (ParameterizedTypeInfo) param.getType(); assertEquals(Handler.class.getName(), handler.getRaw().getName()); ParameterizedTypeInfo genericInt2 = (ParameterizedTypeInfo) handler.getArg(0); assertEquals(GenericInterface2.class.getName(), genericInt2.getRaw().getName()); TypeVariableInfo k = (TypeVariableInfo) genericInt2.getArg(0); assertEquals("K", k.getName()); TypeVariableInfo v = (TypeVariableInfo) genericInt2.getArg(1); assertEquals("V", v.getName()); } catch (Exception e) { throw new AssertionError(e); } }; blacklist(test, Stream.of(WriteStream.class)); test.run(); }