return delegate.isRedirected(request, response, context);
    }

    @Override
    public HttpUriRequest getRedirect(HttpRequest request, HttpResponse response, HttpContext context) throws ProtocolException {
        HttpUriRequest redirectRequest = delegate.getRedirect(request, response, context);
        verifier.validateRedirects(Collections.singletonList(redirectRequest.getURI()));
        return redirectRequest;

            getMethod() >> httpMethod
        }
        request.getParams() >> Mock(HttpParams)

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

        then:
        redirect.getClass() == Class.forName("org.apache.http.client.methods.Http${httpMethod.toLowerCase().capitalize()}")

        where:

        request.getRequestLine() >> Mock(RequestLine) {
            getMethod() >> httpMethod
            getUri() >> "http://original.com"
        }

        when:
        def redirectRequest = strategy.getRedirect(request, response, context)

        then:
        def expectedMethod = redirect in METHOD_PRESERVING_REDIRECTS ? httpMethod : httpMethod == "HEAD" ? "HEAD" : "GET"
        redirectRequest.method.toUpperCase() == expectedMethod

    public AlwaysFollowAndPreserveMethodRedirectStrategy() {
    }

    @Override
    protected boolean isRedirectable(String method) {
        return true;
    }

    @Override
    public HttpUriRequest getRedirect(HttpRequest request, HttpResponse response, HttpContext context) throws ProtocolException {
        URI uri = this.getLocationURI(request, response, context);
        String method = request.getRequestLine().getMethod();

            GenericsType gt = genericParameterNames.get(name);
            type.setRedirect(gt.getType());
            type.setGenericsTypes(new GenericsType[]{gt});
            type.setGenericsPlaceHolder(true);
            return true;
        }

        if (currentClass.getNameWithoutPackage().equals(name)) {
            type.setRedirect(currentClass);
            return true;
        }

            abstract class TaskWithInput extends DefaultTask {

                private final NestedBean nested = project.objects.newInstance(NestedBean.class)

                @Input
                URL getDirect() { null }

                @Input
                Provider<URL> getProviderInput() { propertyInput }

                @Input
                abstract Property<URL> getPropertyInput();

                private final NestedBean nested = project.objects.newInstance(NestedBean.class)

                $annotation
                ResolvedArtifactResult getDirect() { null }

                $annotation
                Provider<ResolvedArtifactResult> getProviderInput() { propertyInput }

                $annotation

            public abstract class MyTask extends DefaultTask {

                private final NestedBean nested = getProject().getObjects().newInstance(NestedBean.class);

                @Input
                public URL getDirect() { return null; }

                @Input
                public Provider<URL> getProviderInput() { return getPropertyInput(); }

                @Input
                public abstract Property<URL> getPropertyInput();

                private final NestedBean nested = getProject().getObjects().newInstance(NestedBean.class);

                @$annotation
                public ResolvedArtifactResult getDirect() { return null; }

                @$annotation
                public Provider<ResolvedArtifactResult> getProviderInput() { return getPropertyInput(); }

                @$annotation