case parse.NodeIf:
		out.Merge(getParams(n.(*parse.IfNode).Pipe))
	case parse.NodeWith:
		out.Merge(getParams(n.(*parse.WithNode).Pipe))
	case parse.NodeRange:
		out.Merge(getParams(n.(*parse.RangeNode).Pipe))
	case parse.NodeAction:
		out.Merge(getParams(n.(*parse.ActionNode).Pipe))
	case parse.NodeCommand:
		for _, arg := range n.(*parse.CommandNode).Args {
			out.Merge(getParams(arg))
		}
	case parse.NodePipe:

            public abstract class SomeTask extends DefaultTask {
                @Nested
                public abstract Params getParams();

                @TaskAction
                public void run() {
                    System.out.println("flag = " + getParams().getFlag().get());
                }
            }
        """
    }

            import ${Inject.name};

            public class SomeTask extends DefaultTask {
                private final Params params;

                @Nested
                public Params getParams() {
                    return params;
                }

                @Inject
                public SomeTask(ObjectFactory objectFactory) {
                    params = objectFactory.newInstance(Params.class);

            public abstract class ProducerTask extends DefaultTask {
                @Nested
                public abstract Params getParams();

                @TaskAction
                public void run() throws IOException {
                    Files.write(getParams().getOutFile().get().getAsFile().toPath(), "content".getBytes());
                }
            }
        """
    }

    public void params(Object... params) {
        Collections.addAll(this.params, params);
    }

    @Override
    public void setParams(Object... params) {
        this.params.clear();
        Collections.addAll(this.params, params);
    }

    @Override
    public Object[] getParams() {
        return this.params.toArray();
    }

            import ${TaskAction.name}
            import ${Nested.name}

            abstract class ProducerTask extends DefaultTask {
                @Nested
                abstract Params getParams()

                @TaskAction
                def run() {
                    params.outFile.get().asFile.text = "content"
                }
            }
        """
    }

            public class SomePlugin implements Plugin<Project> {
                public void apply(Project project) {
                    project.getTasks().register("producer", ProducerTask.class, t -> {
                        t.getParams().getOutFile().set(project.getLayout().getBuildDirectory().file("intermediate.txt"));
                    });
                }
            }
        """
        pluginDir.file("src/main/java/Params.java") << """

            public class ProducerTask extends DefaultTask {
                private final Params params = getProject().getObjects().newInstance(Params.class);

                @Nested
                public Params getParams() {
                    return params;
                }

                @TaskAction
                public void run() throws IOException {

            import ${TaskAction.name}
            import ${Nested.name}

            public abstract class SomeTask extends DefaultTask {
                @Nested
                abstract Params getParams()

                @TaskAction
                void run() {
                    System.out.println("flag = " + params.flag.get())
                }
            }
        """
    }

    @Override

        response.getFirstHeader("location") >> new BasicHeader('location', 'http://redirectTo')
        request.getRequestLine() >> Mock(RequestLine) {
            getMethod() >> httpMethod
        }
        request.getParams() >> Mock(HttpParams)

        when:
        def redirect = new AlwaysFollowAndPreserveMethodRedirectStrategy().getRedirect(request, response, context)

        then: