}

    private static class TaskDefinitionTransformer extends CodeVisitorSupport {
        @Override
        public void visitMethodCallExpression(MethodCallExpression call) {
            doVisitMethodCallExpression(call);
            super.visitMethodCallExpression(call);
        }

        private void doVisitMethodCallExpression(MethodCallExpression call) {
            if (!isInstanceMethod(call, "task")) {

                for (Statement statement : block.getStatements()) {
                    statement.visit(this);
                }
            }

            @Override
            public void visitMethodCallExpression(MethodCallExpression call) {
                if (!call.isImplicitThis()) {
                    Expression target = call.getObjectExpression();
                    if (!(target instanceof MethodCallExpression)) {

        || current.name.endsWith("Spec")

    override fun shouldVisitMethod(node: MethodNode): Boolean = isIntegrationTest(node.declaringClass)

    override fun visitMethodCallExpression(mce: MethodCallExpression) {
        if (AstUtil.isMethodNamed(mce, "contains")) {
            checkOutputContains(mce)
        } else if (AstUtil.isMethodNamed(mce, "assertOutputContains")) {

    }

    @Override
    protected boolean shouldVisitMethod(MethodNode node) {
        return isIntegrationTest(node.getDeclaringClass());
    }

    @Override
    public void visitMethodCallExpression(MethodCallExpression mce) {
        if (AstUtil.isMethodNamed(mce, "contains")) {
            checkOutputContains(mce);
        } else if (AstUtil.isMethodNamed(mce, "assertOutputContains")) {

        restrict(statement);
    }

    @Override
    public void visitCatchStatement(CatchStatement statement) {
        restrict(statement);
    }

    @Override
    public void visitMethodCallExpression(MethodCallExpression call) {
        restrict(call);
    }

    @Override
    public void visitStaticMethodCallExpression(StaticMethodCallExpression expression) {
        restrict(expression);
    }

                        return;
                    }
                }
            }
        }
        super.visitExpressionStatement(stat);
    }

    @Override
    public void visitMethodCallExpression(MethodCallExpression call) {
        String methodName = call.getMethodAsString();
        if (call.isImplicitThis() && methodName != null && methodName.equals(DOLLAR)) {
            visitInputMethod(call);

        }
    }

    @Override
    public void visitExpressionStatement(ExpressionStatement statement) {
        statement.getExpression().visit(this);
    }

    @Override
    public void visitMethodCallExpression(MethodCallExpression call) {
        ClosureExpression closureExpression = AstUtils.getSingleClosureArg(call);
        if (closureExpression != null) {
            // path { ... }

    }

    @Override
    public void visitCatchStatement(CatchStatement stat) {
        stat.setCode(replace(stat.getCode()));
    }

    @Override
    public void visitMethodCallExpression(MethodCallExpression expr) {
        expr.setObjectExpression(replaceExpr(expr.getObjectExpression()));
        expr.setMethod(replaceExpr(expr.getMethod()));
        expr.setArguments(replaceExpr(expr.getArguments()));

            void call(SourceUnit source) throws CompilationFailedException {
                source.getAST().getStatementBlock().visit(new CodeVisitorSupport() {
                    @Override
                    void visitMethodCallExpression(MethodCallExpression call) {
                        call.setObjectExpression(new ClassExpression(ClassHelper.make(System.class)))
                        call.setMethod(new ConstantExpression("setProperty"))