super(
                String.format("Parameter %s of iteration %s of method '%s' toString() method threw exception",
                        paramIndex + 1, iTestResult.getMethod().getCurrentInvocationCount() + 1, iTestResult.getName()
                ),
                cause
        );
    }

     *
     * @see org.codelibs.fess.crawler.entity.AccessResult#getMethod()
     */
    @Override
    public String getMethod() {
        return method;
    }

    /*
     * (non-Javadoc)
     *
     * @see org.codelibs.fess.crawler.entity.AccessResult#setMethod(java.lang.String)
     */
    @Override
    public void setMethod(final String method) {
        this.method = method;
    }

    public ReflectionDispatch(Object target) {
        this.target = target;
    }

    @Override
    public void dispatch(MethodInvocation message) {
        try {
            Method method = message.getMethod();
            method.setAccessible(true);
            method.invoke(target, message.getArguments());
        } catch (InvocationTargetException e) {
            throw UncheckedException.throwAsUncheckedException(e.getCause());

                def type = o.getClass()
                def originalClassName = type.getMethod('getOriginalClassName').invoke(o)
                def contentHash = type.getMethod('getContentHash').invoke(o)
                println "\${title} class name: \${originalClassName} (remapped: \${type.name})"
                println "\${title} class hash: \${contentHash}"

        return new DefaultMethodRuleDefinition<T, R, S>(method, ModelType.of(source), returnType);
    }

    @Override
    public WeaklyTypeReferencingMethod<?, R> getMethod() {
        return method;
    }

    @Override
    public String getMethodName() {
        return method.getName();
    }

    @Override
    public ModelType<R> getReturnType() {

            executor.execute(runnable);
          }
        };
    Future<?> future = newFutureInstance();
    future
        .getClass()
        .getMethod(
            "setFuture",
            future.getClass().getClassLoader().loadClass(ListenableFuture.class.getName()))
        .invoke(future, badFuture);

            executor.execute(runnable);
          }
        };
    Future<?> future = newFutureInstance();
    future
        .getClass()
        .getMethod(
            "setFuture",
            future.getClass().getClassLoader().loadClass(ListenableFuture.class.getName()))
        .invoke(future, badFuture);

    }

    def "formats message with a single method problem"() {
        given:
        def collector = new FormattingValidationProblemCollector("<thing>", ModelType.of(String))
        collector.add(String.class.getMethod("indexOf", String), "rule", "is not annotated with anything.")

        expect:
        collector.format() == '''Type java.lang.String is not a valid <thing>:

    }

    @Override
    public Class<?> getOwner() {
        return owner;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Method getMethod() {
        return method;
    }

    RespondWithPathToParent(String pathToParent) {
        this.pathToParent = pathToParent
    }

    @Override
    Object respond(IMockInvocation invocation) {
        if (invocation.getMethod().name == "getPathToParent") {
            return pathToParent
        }
        return EmptyOrDummyResponse.INSTANCE.respond(invocation)
    }