/**
 *
 * Copyright (C) 2009 Cloud Conscious, LLC. <info@cloudconscious.com>
 *
 * ====================================================================
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ====================================================================
 */
package org.jclouds.rest.internal;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.util.concurrent.Executors.sameThreadExecutor;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNull;

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URLEncoder;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Map;

import javax.annotation.Nullable;
import javax.inject.Named;
import javax.inject.Qualifier;
import javax.ws.rs.Consumes;
import javax.ws.rs.FormParam;
import javax.ws.rs.GET;
import javax.ws.rs.HeaderParam;
import javax.ws.rs.HttpMethod;
import javax.ws.rs.MatrixParam;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;

import org.jclouds.PropertiesBuilder;
import org.jclouds.concurrent.config.ExecutorServiceModule;
import org.jclouds.date.DateService;
import org.jclouds.date.internal.SimpleDateFormatDateService;
import org.jclouds.http.HttpException;
import org.jclouds.http.HttpRequest;
import org.jclouds.http.HttpRequestFilter;
import org.jclouds.http.HttpResponse;
import org.jclouds.http.HttpUtils;
import org.jclouds.http.config.JavaUrlHttpCommandExecutorServiceModule;
import org.jclouds.http.functions.CloseContentAndReturn;
import org.jclouds.http.functions.ParseURIFromListOrLocationHeaderIf20x;
import org.jclouds.http.functions.ReturnInputStream;
import org.jclouds.http.functions.ReturnStringIf200;
import org.jclouds.http.functions.ReturnTrueIf2xx;
import org.jclouds.http.options.BaseHttpRequestOptions;
import org.jclouds.http.options.GetOptions;
import org.jclouds.http.options.HttpRequestOptions;
import org.jclouds.logging.Logger;
import org.jclouds.logging.Logger.LoggerFactory;
import org.jclouds.rest.InvocationContext;
import org.jclouds.rest.annotations.BinderParam;
import org.jclouds.rest.annotations.Endpoint;
import org.jclouds.rest.annotations.EndpointParam;
import org.jclouds.rest.annotations.FormParams;
import org.jclouds.rest.annotations.Headers;
import org.jclouds.rest.annotations.HostPrefixParam;
import org.jclouds.rest.annotations.MapBinder;
import org.jclouds.rest.annotations.MapPayloadParam;
import org.jclouds.rest.annotations.MatrixParams;
import org.jclouds.rest.annotations.OverrideRequestFilters;
import org.jclouds.rest.annotations.ParamParser;
import org.jclouds.rest.annotations.QueryParams;
import org.jclouds.rest.annotations.RequestFilters;
import org.jclouds.rest.annotations.ResponseParser;
import org.jclouds.rest.annotations.SkipEncoding;
import org.jclouds.rest.annotations.VirtualHost;
import org.jclouds.rest.binders.BindMapToMatrixParams;
import org.jclouds.rest.binders.BindToJsonPayload;
import org.jclouds.rest.binders.BindToStringPayload;
import org.jclouds.rest.config.RestModule;
import org.jclouds.util.Jsr330;
import org.jclouds.util.Utils;
import org.mortbay.jetty.HttpHeaders;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import com.google.common.base.Function;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.LinkedHashMultimap;
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.Multimap;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.TypeLiteral;
import com.google.inject.util.Types;

/**
 * Tests behavior of {@code JaxrsAnnotationProcessor}
 * 
 * @author Adrian Cole
 */
@Test(groups = "unit", testName = "jaxrs.JaxrsUtilTest")
public class RestAnnotationProcessorTest {
   @Target( { ElementType.METHOD })
   @Retention(RetentionPolicy.RUNTIME)
   @javax.ws.rs.HttpMethod("FOO")
   public @interface FOO {
   }

   @Retention(value = RetentionPolicy.RUNTIME)
   @Target(value = { ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
   @Qualifier
   public @interface Localhost {
   }

   @Retention(value = RetentionPolicy.RUNTIME)
   @Target(value = { ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
   @Qualifier
   public @interface Localhost2 {
   }

   @QueryParams(keys = "x-ms-version", values = "2009-07-17")
   @Endpoint(Localhost.class)
   public class TestQuery {
      @FOO
      @QueryParams(keys = "x-ms-rubbish", values = "bin")
      public void foo() {
      }

      @FOO
      @QueryParams(keys = { "foo", "fooble" }, values = { "bar", "baz" })
      public void foo2() {
      }

      @FOO
      @QueryParams(keys = { "foo", "fooble" }, values = { "bar", "baz" })
      public void foo3(@QueryParam("robbie") String robbie) {
      }
   }

   public void testUnEncodeQuery() {
      URI expects = URI
               .create("http://services.nirvanix.com/ws/Metadata/SetMetadata.ashx?output=json&path=adriancole-compute.testObjectOperations&metadata=chef:sushi&metadata=foo:bar&sessionToken=775ef26e-0740-4707-ad92-afe9814bc436");

      URI start = URI
               .create("http://services.nirvanix.com/ws/Metadata/SetMetadata.ashx?output=json&path=adriancole-compute.testObjectOperations&metadata=chef%3Asushi&metadata=foo%3Abar&sessionToken=775ef26e-0740-4707-ad92-afe9814bc436");
      URI value = RestAnnotationProcessor.replaceQuery(start, start.getQuery(), null, '/', ':');
      assertEquals(value, expects);
   }

   public void testQuery() throws SecurityException, NoSuchMethodException {
      Method method = TestQuery.class.getMethod("foo");
      GeneratedHttpRequest<?> httpMethod = factory(TestQuery.class).createRequest(method,
               new Object[] {});
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "");
      assertEquals(httpMethod.getEndpoint().getQuery(), "x-ms-version=2009-07-17&x-ms-rubbish=bin");
      assertEquals(httpMethod.getMethod(), "FOO");
   }

   public void testQuery2() throws SecurityException, NoSuchMethodException {
      Method method = TestQuery.class.getMethod("foo2");
      GeneratedHttpRequest<?> httpMethod = factory(TestQuery.class).createRequest(method,
               new Object[] {});
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "");
      assertEquals(httpMethod.getEndpoint().getQuery(),
               "x-ms-version=2009-07-17&foo=bar&fooble=baz");
      assertEquals(httpMethod.getMethod(), "FOO");
   }

   public void testQuery3() throws SecurityException, NoSuchMethodException {
      Method method = TestQuery.class.getMethod("foo3", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestQuery.class).createRequest(method,
               new Object[] { "wonder" });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "");
      assertEquals(httpMethod.getEndpoint().getQuery(),
               "x-ms-version=2009-07-17&foo=bar&fooble=baz&robbie=wonder");
      assertEquals(httpMethod.getMethod(), "FOO");
   }

   @Endpoint(Localhost.class)
   public interface TestPayloadParamVarargs {
      @POST
      public void varargs(HttpRequestOptions... options);

      @POST
      public void post(HttpRequestOptions options);

   }

   public void testHttpRequestOptionsPayloadParam() throws SecurityException, NoSuchMethodException {
      Method method = TestPayloadParamVarargs.class.getMethod("post", HttpRequestOptions.class);
      verifyTestPostOptions(method);
   }

   public void testPayloadParamVarargs() throws SecurityException, NoSuchMethodException {
      Method method = TestPayloadParamVarargs.class.getMethod("varargs", Array.newInstance(
               HttpRequestOptions.class, 0).getClass());
      verifyTestPostOptions(method);
   }

   private void verifyTestPostOptions(Method method) {
      GeneratedHttpRequest<?> httpMethod = factory(TestPayloadParamVarargs.class).createRequest(
               method, new Object[] { new HttpRequestOptions() {

                  public Multimap<String, String> buildMatrixParameters() {
                     return LinkedHashMultimap.create();
                  }

                  public String buildPathSuffix() {
                     return null;
                  }

                  public Multimap<String, String> buildQueryParameters() {
                     return LinkedHashMultimap.create();
                  }

                  public Multimap<String, String> buildFormParameters() {
                     return LinkedHashMultimap.create();
                  }

                  public Multimap<String, String> buildRequestHeaders() {
                     return LinkedHashMultimap.create();
                  }

                  public String buildStringPayload() {
                     return "fooya";
                  }

               } });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "");
      assertEquals(httpMethod.getMethod(), HttpMethod.POST);
      assertEquals(httpMethod.getHeaders().size(), 2);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("application/unknown"));
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList("fooya".getBytes().length + ""));
      assertEquals(httpMethod.getPayload().toString(), "fooya");
   }

   @Endpoint(Localhost.class)
   public class TestCustomMethod {
      @FOO
      public void foo() {
      }
   }

   public void testCustomMethod() throws SecurityException, NoSuchMethodException {
      Method method = TestCustomMethod.class.getMethod("foo");
      GeneratedHttpRequest<?> httpMethod = factory(TestCustomMethod.class).createRequest(method,
               new Object[] {});
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "");
      assertEquals(httpMethod.getMethod(), "FOO");
   }

   public interface Parent {
      public void foo();
   }

   @Endpoint(Localhost.class)
   public class TestOverridden implements Parent {
      @POST
      public void foo() {
      }
   }

   public void testOverriddenMethod() throws SecurityException, NoSuchMethodException {
      Method method = TestOverridden.class.getMethod("foo");
      GeneratedHttpRequest<?> httpMethod = factory(TestOverridden.class).createRequest(method,
               new Object[] {});
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "");
      assertEquals(httpMethod.getMethod(), "POST");
   }

   @Endpoint(Localhost.class)
   public class TestOverriddenEndpoint implements Parent {

      @POST
      @Endpoint(Localhost2.class)
      public void foo() {
      }

      @POST
      public void foo(@EndpointParam URI endpoint) {
      }
   }

   public void testOverriddenEndpointMethod() throws SecurityException, NoSuchMethodException {
      Method method = TestOverriddenEndpoint.class.getMethod("foo");
      GeneratedHttpRequest<?> httpMethod = factory(TestOverriddenEndpoint.class).createRequest(
               method, new Object[] {});
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPort(), 8081);
      assertEquals(httpMethod.getEndpoint().getPath(), "");
      assertEquals(httpMethod.getMethod(), "POST");
   }

   public void testOverriddenEndpointParameter() throws SecurityException, NoSuchMethodException {
      Method method = TestOverriddenEndpoint.class.getMethod("foo", URI.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestOverriddenEndpoint.class).createRequest(
               method, new Object[] { URI.create("http://wowsa:8001") });
      assertEquals(httpMethod.getEndpoint().getHost(), "wowsa");
      assertEquals(httpMethod.getEndpoint().getPort(), 8001);
      assertEquals(httpMethod.getEndpoint().getPath(), "");
      assertEquals(httpMethod.getMethod(), "POST");
   }

   @Endpoint(Localhost.class)
   public class TestPost {
      @POST
      public void post(@Nullable @BinderParam(BindToStringPayload.class) String content) {
      }

      @POST
      public void postAsJson(@BinderParam(BindToJsonPayload.class) String content) {
      }

      @POST
      @Path("{foo}")
      public void postWithPath(@PathParam("foo") @MapPayloadParam("fooble") String path,
               MapBinder content) {
      }

      @POST
      @Path("{foo}")
      @MapBinder(BindToJsonPayload.class)
      public void postWithMethodBinder(@PathParam("foo") @MapPayloadParam("fooble") String path) {
      }
   }

   public void testCreatePostRequest() throws SecurityException, NoSuchMethodException {
      Method method = TestPost.class.getMethod("post", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPost.class).createRequest(method, "data");
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "");
      assertEquals(httpMethod.getMethod(), HttpMethod.POST);
      assertEquals(httpMethod.getHeaders().size(), 2);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("application/unknown"));
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList("data".getBytes().length + ""));
      assertEquals(httpMethod.getPayload().toString(), "data");
   }

   public void testCreatePostRequestNullOk() throws SecurityException, NoSuchMethodException {
      Method method = TestPost.class.getMethod("post", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPost.class).createRequest(method,
               new Object[] { null });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "");
      assertEquals(httpMethod.getMethod(), HttpMethod.POST);
      assertEquals(httpMethod.getHeaders().size(), 0);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_TYPE).size(), 0);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_LENGTH).size(), 0);
      assertEquals(httpMethod.getPayload(), null);
   }

   public void testCreatePostJsonRequest() throws SecurityException, NoSuchMethodException {
      Method method = TestPost.class.getMethod("postAsJson", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPost.class).createRequest(method,
               new Object[] { "data" });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "");
      assertEquals(httpMethod.getMethod(), HttpMethod.POST);
      assertEquals(httpMethod.getHeaders().size(), 2);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("application/json"));
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList("\"data\"".getBytes().length + ""));
      assertEquals(httpMethod.getPayload().toString(), "\"data\"");
   }

   public void testCreatePostWithPathRequest() throws SecurityException, NoSuchMethodException {
      Method method = TestPost.class.getMethod("postWithPath", String.class, MapBinder.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPost.class).createRequest(method,
               new Object[] { "data", new org.jclouds.rest.MapBinder() {
                  public void bindToRequest(HttpRequest request, Map<String, String> postParams) {
                     request.setPayload(postParams.get("fooble"));
                  }

                  public void bindToRequest(HttpRequest request, Object toBind) {
                     throw new RuntimeException("this shouldn't be used in POST");
                  }
               } });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/data");
      assertEquals(httpMethod.getMethod(), HttpMethod.POST);
      assertEquals(httpMethod.getHeaders().size(), 1);
      assertEquals(httpMethod.getPayload().toString(), "data");
   }

   public void testCreatePostWithMethodBinder() throws SecurityException, NoSuchMethodException {
      Method method = TestPost.class.getMethod("postWithMethodBinder", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPost.class).createRequest(method,
               new Object[] { "data", });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/data");
      assertEquals(httpMethod.getMethod(), HttpMethod.POST);
      assertEquals(httpMethod.getHeaders().size(), 2);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("application/json"));
      String expected = "{\"fooble\":\"data\"}";
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList(expected.getBytes().length + ""));
      assertEquals(httpMethod.getPayload().toString(), expected);
   }

   @Endpoint(Localhost.class)
   public class TestPut {
      @PUT
      @Path("{foo}")
      @MapBinder(BindToJsonPayload.class)
      public void putWithMethodBinder(@PathParam("foo") @MapPayloadParam("fooble") String path) {
      }

      @PUT
      @Path("{foo}")
      @Produces(MediaType.TEXT_PLAIN)
      public void putWithMethodBinderProduces(
               @PathParam("foo") @BinderParam(BindToStringPayload.class) String path) {
      }

      @PUT
      @Path("{foo}")
      @MapBinder(BindToJsonPayload.class)
      @Consumes(MediaType.APPLICATION_JSON)
      public void putWithMethodBinderConsumes(
               @PathParam("foo") @MapPayloadParam("fooble") String path) {
      }
   }

   public void testCreatePutWithMethodBinder() throws SecurityException, NoSuchMethodException {
      Method method = TestPut.class.getMethod("putWithMethodBinder", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPut.class).createRequest(method,
               new Object[] { "data", });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/data");
      assertEquals(httpMethod.getMethod(), HttpMethod.PUT);
      assertEquals(httpMethod.getHeaders().size(), 2);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("application/json"));
      String expected = "{\"fooble\":\"data\"}";
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList(expected.getBytes().length + ""));
      assertEquals(httpMethod.getPayload().toString(), expected);
   }

   public void testCreatePutWithMethodProduces() throws SecurityException, NoSuchMethodException {
      Method method = TestPut.class.getMethod("putWithMethodBinderProduces", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPut.class).createRequest(method,
               new Object[] { "data", });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/data");
      assertEquals(httpMethod.getMethod(), HttpMethod.PUT);
      assertEquals(httpMethod.getHeaders().size(), 2);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("text/plain"));
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList("data".getBytes().length + ""));
      assertEquals(httpMethod.getPayload().toString(), "data");
   }

   public void testCreatePutWithMethodConsumes() throws SecurityException, NoSuchMethodException {
      Method method = TestPut.class.getMethod("putWithMethodBinderConsumes", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPut.class).createRequest(method,
               new Object[] { "data", });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/data");
      assertEquals(httpMethod.getMethod(), HttpMethod.PUT);
      assertEquals(httpMethod.getHeaders().size(), 3);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("application/json"));
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.ACCEPT), Collections
               .singletonList("application/json"));
      String expected = "{\"fooble\":\"data\"}";
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList(expected.getBytes().length + ""));
      assertEquals(httpMethod.getPayload().toString(), expected);
   }

   static class TestRequestFilter1 implements HttpRequestFilter {
      public void filter(HttpRequest request) throws HttpException {
      }
   }

   static class TestRequestFilter2 implements HttpRequestFilter {
      public void filter(HttpRequest request) throws HttpException {
      }
   }

   @RequestFilters(TestRequestFilter1.class)
   @Endpoint(Localhost.class)
   static class TestRequestFilter {
      @GET
      @RequestFilters(TestRequestFilter2.class)
      public void get() {
      }

      @GET
      @OverrideRequestFilters
      @RequestFilters(TestRequestFilter2.class)
      public void getOverride() {
      }
   }

   @Test
   public void testRequestFilter() throws SecurityException, NoSuchMethodException {
      Method method = TestRequestFilter.class.getMethod("get");
      GeneratedHttpRequest<?> httpMethod = factory(TestRequestFilter.class).createRequest(method,
               new Object[] {});
      assertEquals(httpMethod.getFilters().size(), 2);
      assertEquals(httpMethod.getFilters().get(0).getClass(), TestRequestFilter1.class);
      assertEquals(httpMethod.getFilters().get(1).getClass(), TestRequestFilter2.class);
   }

   public void testRequestFilterOverride() throws SecurityException, NoSuchMethodException {
      Method method = TestRequestFilter.class.getMethod("getOverride");
      GeneratedHttpRequest<?> httpMethod = factory(TestRequestFilter.class).createRequest(method,
               new Object[] {});
      assertEquals(httpMethod.getFilters().size(), 1);
      assertEquals(httpMethod.getFilters().get(0).getClass(), TestRequestFilter2.class);
   }

   @SkipEncoding('/')
   @Endpoint(Localhost.class)
   public class TestEncoding {
      @GET
      @Path("{path1}/{path2}")
      public void twoPaths(@PathParam("path1") String path, @PathParam("path2") String path2) {
      }
   }

   @Test
   public void testSkipEncoding() throws SecurityException, NoSuchMethodException {
      Method method = TestEncoding.class.getMethod("twoPaths", String.class, String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestEncoding.class).createRequest(method,
               new Object[] { "1", "localhost" });
      assertEquals(httpMethod.getEndpoint().getPath(), "/1/localhost");
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 0);
   }

   @Test
   public void testEncodingPath() throws SecurityException, NoSuchMethodException {
      Method method = TestEncoding.class.getMethod("twoPaths", String.class, String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestEncoding.class).createRequest(method,
               new Object[] { "/", "localhost" });
      assertEquals(httpMethod.getEndpoint().getPath(), "///localhost");
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 0);
   }

   @SkipEncoding('/')
   @Path("/v1/{account}")
   @Endpoint(Localhost.class)
   public interface TestConstantPathParam {
      @Named("testaccount")
      @PathParam("account")
      void setUsername();

      @GET
      @Path("{path1}/{path2}")
      public void twoPaths(@PathParam("path1") String path, @PathParam("path2") String path2);
   }

   @Test(enabled = false)
   public void testConstantPathParam() throws SecurityException, NoSuchMethodException, IOException {
      Method method = TestConstantPathParam.class.getMethod("twoPaths", String.class, String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestConstantPathParam.class).createRequest(
               method, new Object[] { "1", "localhost" });
      assertRequestLineEquals(httpMethod,
               "GET http://localhost:8080/v1/ralphie/1/localhost HTTP/1.1");
      assertHeadersEqual(httpMethod, "");
      assertPayloadEquals(httpMethod, null);
   }

   @Endpoint(Localhost.class)
   public class TestPath {
      @GET
      @Path("{path}")
      public void onePath(@PathParam("path") String path) {
      }

      @GET
      @Path("{path1}/{path2}")
      public void twoPaths(@PathParam("path1") String path, @PathParam("path2") String path2) {
      }

      @GET
      @Path("{path2}/{path1}")
      public void twoPathsOutOfOrder(@PathParam("path1") String path,
               @PathParam("path2") String path2) {
      }

      @GET
      @Path("{path}")
      public void onePathParamExtractor(
               @PathParam("path") @ParamParser(FirstCharacter.class) String path) {
      }

      @GET
      @Path("/")
      public void oneQueryParamExtractor(
               @QueryParam("one") @ParamParser(FirstCharacter.class) String one) {
      }

      @POST
      @Path("/")
      public void oneFormParamExtractor(
               @FormParam("one") @ParamParser(FirstCharacter.class) String one) {
      }

      @GET
      @Path("/")
      public void oneMatrixParamExtractor(
               @MatrixParam("one") @ParamParser(FirstCharacter.class) String one) {
      }

      @GET
      @Path("{path}")
      @PathParam("path")
      @ParamParser(FirstCharacterFirstElement.class)
      public void onePathParamExtractorMethod(String path) {
      }
   }

   @Test
   public void testPathParamExtractor() throws SecurityException, NoSuchMethodException,
            IOException {
      Method method = TestPath.class.getMethod("onePathParamExtractor", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPath.class).createRequest(method,
               new Object[] { "localhost" });
      assertRequestLineEquals(httpMethod, "GET http://localhost:8080/l HTTP/1.1");
      assertHeadersEqual(httpMethod, "");
      assertPayloadEquals(httpMethod, null);
   }

   @Test
   public void testQueryParamExtractor() throws SecurityException, NoSuchMethodException,
            IOException {
      Method method = TestPath.class.getMethod("oneQueryParamExtractor", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPath.class).createRequest(method,
               "localhost");
      assertRequestLineEquals(httpMethod, "GET http://localhost:8080/?one=l HTTP/1.1");
      assertHeadersEqual(httpMethod, "");
      assertPayloadEquals(httpMethod, null);
   }

   @Test
   public void testMatrixParamExtractor() throws SecurityException, NoSuchMethodException,
            IOException {
      Method method = TestPath.class.getMethod("oneMatrixParamExtractor", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPath.class).createRequest(method,
               new Object[] { "localhost" });
      assertRequestLineEquals(httpMethod, "GET http://localhost:8080/;one=l HTTP/1.1");
      assertHeadersEqual(httpMethod, "");
      assertPayloadEquals(httpMethod, null);
   }

   @Test
   public void testFormParamExtractor() throws SecurityException, NoSuchMethodException,
            IOException {
      Method method = TestPath.class.getMethod("oneFormParamExtractor", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPath.class).createRequest(method,
               new Object[] { "localhost" });
      assertRequestLineEquals(httpMethod, "POST http://localhost:8080/ HTTP/1.1");
      assertHeadersEqual(httpMethod,
               "Content-Length: 5\nContent-Type: application/x-www-form-urlencoded\n");
      assertPayloadEquals(httpMethod, "one=l");
   }

   @Test
   public void testParamExtractorMethod() throws SecurityException, NoSuchMethodException {
      Method method = TestPath.class.getMethod("onePathParamExtractorMethod", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestPath.class).createRequest(method,
               new Object[] { "localhost" });
      assertEquals(httpMethod.getEndpoint().getPath(), "/l");
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 0);
   }

   static class FirstCharacter implements Function<Object, String> {
      public String apply(Object from) {
         return from.toString().substring(0, 1);
      }
   }

   static class FirstCharacterFirstElement implements Function<Object, String> {
      public String apply(Object from) {
         return ((String) ((Object[]) from)[0]).substring(0, 1);
      }
   }

   @Endpoint(Localhost.class)
   public class TestHeader {
      @GET
      @Headers(keys = "x-amz-copy-source", values = "/{bucket}")
      public void oneHeader(@PathParam("bucket") String path) {
      }

      @GET
      @Headers(keys = { "slash", "hyphen" }, values = { "/{bucket}", "-{bucket}" })
      public void twoHeader(@PathParam("bucket") String path) {
      }

      @GET
      @Headers(keys = "x-amz-copy-source", values = "/{bucket}/{key}")
      public void twoHeaders(@PathParam("bucket") String path, @PathParam("key") String path2) {
      }

      @GET
      @Headers(keys = "x-amz-copy-source", values = "/{bucket}/{key}")
      public void twoHeadersOutOfOrder(@PathParam("key") String path,
               @PathParam("bucket") String path2) {
      }
   }

   @Test
   public void testBuildTwoHeader() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneHeader = TestHeader.class.getMethod("twoHeader", String.class);
      Multimap<String, String> headers = factory(TestHeader.class).createRequest(oneHeader,
               new Object[] { "robot" }).getHeaders();
      assertEquals(headers.size(), 2);
      assertEquals(headers.get("slash"), Collections.singletonList("/robot"));
      assertEquals(headers.get("hyphen"), Collections.singletonList("-robot"));
   }

   @Headers(keys = "x-amz-copy-source", values = "/{bucket}")
   @Endpoint(Localhost.class)
   public class TestClassHeader {
      @GET
      public void oneHeader(@PathParam("bucket") String path) {
      }
   }

   @Test
   public void testBuildOneClassHeader() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneHeader = TestClassHeader.class.getMethod("oneHeader", String.class);
      Multimap<String, String> headers = factory(TestClassHeader.class).createRequest(oneHeader,
               new Object[] { "robot" }).getHeaders();
      assertEquals(headers.size(), 1);
      assertEquals(headers.get("x-amz-copy-source"), Collections.singletonList("/robot"));
   }

   @Test
   public void testBuildOneHeader() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneHeader = TestHeader.class.getMethod("oneHeader", String.class);
      Multimap<String, String> headers = factory(TestHeader.class).createRequest(oneHeader,
               new Object[] { "robot" }).getHeaders();
      assertEquals(headers.size(), 1);
      assertEquals(headers.get("x-amz-copy-source"), Collections.singletonList("/robot"));
   }

   @Test
   public void testBuildTwoHeaders() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method twoHeaders = TestHeader.class.getMethod("twoHeaders", String.class, String.class);
      Multimap<String, String> headers = factory(TestHeader.class).createRequest(twoHeaders,
               new Object[] { "robot", "eggs" }).getHeaders();
      assertEquals(headers.size(), 1);
      assertEquals(headers.get("x-amz-copy-source"), Collections.singletonList("/robot/eggs"));
   }

   @Test
   public void testBuildTwoHeadersOutOfOrder() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method twoHeadersOutOfOrder = TestHeader.class.getMethod("twoHeadersOutOfOrder",
               String.class, String.class);
      Multimap<String, String> headers = factory(TestHeader.class).createRequest(
               twoHeadersOutOfOrder, new Object[] { "robot", "eggs" }).getHeaders();
      assertEquals(headers.size(), 1);
      assertEquals(headers.get("x-amz-copy-source"), Collections.singletonList("/eggs/robot"));
   }

   public class TestReplaceQueryOptions extends BaseHttpRequestOptions {
      public TestReplaceQueryOptions() {
         this.queryParameters.put("x-amz-copy-source", "/{bucket}");
      }
   }

   @Test
   public void testQueryInOptions() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneQuery = TestQueryReplace.class.getMethod("queryInOptions", String.class,
               TestReplaceQueryOptions.class);
      String query = factory(TestQueryReplace.class).createRequest(oneQuery,
               new Object[] { "robot", new TestReplaceQueryOptions() }).getEndpoint().getQuery();
      assertEquals(query, "x-amz-copy-source=/robot");
   }

   @Endpoint(Localhost.class)
   private interface TestMapMatrixParams {
      @POST
      @Path("objects/{id}/action/{action}")
      ListenableFuture<String> action(@PathParam("id") String id,
               @PathParam("action") String action,
               @BinderParam(BindMapToMatrixParams.class) Map<String, String> options);
   }

   public void testTestMapMatrixParams() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method method = TestMapMatrixParams.class.getMethod("action", String.class, String.class,
               Map.class);
      GeneratedHttpRequest<TestMapMatrixParams> httpMethod = factory(TestMapMatrixParams.class)
               .createRequest(method,
                        new Object[] { "robot", "kill", ImmutableMap.of("death", "slow") });
      assertEquals(httpMethod.getRequestLine(),
               "POST http://localhost:8080/objects/robot/action/kill;death=slow HTTP/1.1");
      assertEquals(httpMethod.getHeaders().size(), 0);
   }

   public void testParseBase64InForm() {
      Multimap<String, String> expects = LinkedListMultimap.create();
      expects.put("Version", "2009-11-30");
      expects.put("Action", "ModifyInstanceAttribute");
      expects.put("Attribute", "userData");
      expects.put("Value", "dGVzdA==");
      expects.put("InstanceId", "1");
      assertEquals(
               expects,
               RestAnnotationProcessor
                        .parseQueryToMap("Version=2009-11-30&Action=ModifyInstanceAttribute&Attribute=userData&Value=dGVzdA%3D%3D&InstanceId=1"));
   }

   @Endpoint(Localhost.class)
   @SkipEncoding('/')
   public class TestQueryReplace {

      @GET
      public void queryInOptions(@PathParam("bucket") String path, TestReplaceQueryOptions options) {
      }

      @GET
      @QueryParams(keys = "x-amz-copy-source", values = "/{bucket}")
      public void oneQuery(@PathParam("bucket") String path) {
      }

      @GET
      @QueryParams(keys = { "slash", "hyphen" }, values = { "/{bucket}", "-{bucket}" })
      public void twoQuery(@PathParam("bucket") String path) {
      }

      @GET
      @QueryParams(keys = "x-amz-copy-source", values = "/{bucket}/{key}")
      public void twoQuerys(@PathParam("bucket") String path, @PathParam("key") String path2) {
      }

      @GET
      @QueryParams(keys = "x-amz-copy-source", values = "/{bucket}/{key}")
      public void twoQuerysOutOfOrder(@PathParam("key") String path,
               @PathParam("bucket") String path2) {
      }
   }

   @Test
   public void testBuildTwoQuery() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneQuery = TestQueryReplace.class.getMethod("twoQuery", String.class);
      String query = factory(TestQueryReplace.class).createRequest(oneQuery,
               new Object[] { "robot" }).getEndpoint().getQuery();
      assertEquals(query, "slash=/robot&hyphen=-robot");
   }

   @QueryParams(keys = "x-amz-copy-source", values = "/{bucket}")
   @Endpoint(Localhost.class)
   public class TestClassQuery {
      @GET
      public void oneQuery(@PathParam("bucket") String path) {
      }
   }

   @Test
   public void testBuildOneClassQuery() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneQuery = TestClassQuery.class.getMethod("oneQuery", String.class);
      String query = factory(TestClassQuery.class)
               .createRequest(oneQuery, new Object[] { "robot" }).getEndpoint().getQuery();
      assertEquals(query, "x-amz-copy-source=/robot");
   }

   @Test
   public void testBuildOneQuery() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneQuery = TestQueryReplace.class.getMethod("oneQuery", String.class);
      String query = factory(TestQueryReplace.class).createRequest(oneQuery,
               new Object[] { "robot" }).getEndpoint().getQuery();
      assertEquals(query, "x-amz-copy-source=/robot");
   }

   @Test
   public void testBuildTwoQuerys() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method twoQuerys = TestQueryReplace.class.getMethod("twoQuerys", String.class, String.class);
      String query = factory(TestQueryReplace.class).createRequest(twoQuerys,
               new Object[] { "robot", "eggs" }).getEndpoint().getQuery();
      assertEquals(query, "x-amz-copy-source=/robot/eggs");
   }

   @Test
   public void testBuildTwoQuerysOutOfOrder() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method twoQuerysOutOfOrder = TestQueryReplace.class.getMethod("twoQuerysOutOfOrder",
               String.class, String.class);
      String query = factory(TestQueryReplace.class).createRequest(twoQuerysOutOfOrder,
               new Object[] { "robot", "eggs" }).getEndpoint().getQuery();
      assertEquals(query, "x-amz-copy-source=/eggs/robot");
   }

   public class TestReplaceMatrixOptions extends BaseHttpRequestOptions {
      public TestReplaceMatrixOptions() {
         this.matrixParameters.put("x-amz-copy-source", "/{bucket}");
      }
   }

   @Test
   public void testMatrixInOptions() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneMatrix = TestMatrixReplace.class.getMethod("matrixInOptions", String.class,
               TestReplaceMatrixOptions.class);
      String path = factory(TestMatrixReplace.class).createRequest(oneMatrix,
               new Object[] { "robot", new TestReplaceMatrixOptions() }).getEndpoint().getPath();
      assertEquals(path, "/;x-amz-copy-source=/robot");
   }

   @Endpoint(Localhost.class)
   @Path("/")
   public class TestMatrixReplace {

      @GET
      public void matrixInOptions(@PathParam("bucket") String path, TestReplaceMatrixOptions options) {
      }

      @GET
      @MatrixParams(keys = "x-amz-copy-source", values = "/{bucket}")
      public void oneMatrix(@PathParam("bucket") String path) {
      }

      @GET
      @MatrixParams(keys = { "slash", "hyphen" }, values = { "/{bucket}", "-{bucket}" })
      public void twoMatrix(@PathParam("bucket") String path) {
      }

      @GET
      @MatrixParams(keys = "x-amz-copy-source", values = "/{bucket}/{key}")
      public void twoMatrixs(@PathParam("bucket") String path, @PathParam("key") String path2) {
      }

      @GET
      @MatrixParams(keys = "x-amz-copy-source", values = "/{bucket}/{key}")
      public void twoMatrixsOutOfOrder(@PathParam("key") String path,
               @PathParam("bucket") String path2) {
      }
   }

   @Test
   public void testBuildTwoMatrix() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneMatrix = TestMatrixReplace.class.getMethod("twoMatrix", String.class);
      String path = factory(TestMatrixReplace.class).createRequest(oneMatrix,
               new Object[] { "robot" }).getEndpoint().getPath();
      assertEquals(path, "/;slash=/robot;hyphen=-robot");
   }

   @MatrixParams(keys = "x-amz-copy-source", values = "/{bucket}")
   @Endpoint(Localhost.class)
   @Path("/")
   public class TestClassMatrix {
      @GET
      public void oneMatrix(@PathParam("bucket") String path) {
      }
   }

   @Test
   public void testBuildOneClassMatrix() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneMatrix = TestClassMatrix.class.getMethod("oneMatrix", String.class);
      String path = factory(TestClassMatrix.class).createRequest(oneMatrix,
               new Object[] { "robot" }).getEndpoint().getPath();
      assertEquals(path, "/;x-amz-copy-source=/robot");
   }

   @Test
   public void testBuildOneMatrix() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneMatrix = TestMatrixReplace.class.getMethod("oneMatrix", String.class);
      String path = factory(TestMatrixReplace.class).createRequest(oneMatrix,
               new Object[] { "robot" }).getEndpoint().getPath();
      assertEquals(path, "/;x-amz-copy-source=/robot");
   }

   @Test
   public void testBuildTwoMatrixs() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method twoMatrixs = TestMatrixReplace.class.getMethod("twoMatrixs", String.class,
               String.class);
      String path = factory(TestMatrixReplace.class).createRequest(twoMatrixs,
               new Object[] { "robot", "eggs" }).getEndpoint().getPath();
      assertEquals(path, "/;x-amz-copy-source=/robot/eggs");
   }

   @Test
   public void testBuildTwoMatrixsOutOfOrder() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method twoMatrixsOutOfOrder = TestMatrixReplace.class.getMethod("twoMatrixsOutOfOrder",
               String.class, String.class);
      String path = factory(TestMatrixReplace.class).createRequest(twoMatrixsOutOfOrder,
               new Object[] { "robot", "eggs" }).getEndpoint().getPath();
      assertEquals(path, "/;x-amz-copy-source=/eggs/robot");
   }

   @Endpoint(Localhost.class)
   public interface TestTransformers {
      @GET
      public int noTransformer();

      @GET
      @ResponseParser(ReturnStringIf200.class)
      public void oneTransformer();

      @GET
      @ResponseParser(ReturnStringIf200Context.class)
      public void oneTransformerWithContext();

      @GET
      public InputStream inputStream();

      @GET
      public ListenableFuture<InputStream> futureInputStream();

      @GET
      public URI uri();

      @GET
      public ListenableFuture<URI> futureUri();
   }

   @SuppressWarnings("static-access")
   public void testInputStream() throws SecurityException, NoSuchMethodException {
      Method method = TestTransformers.class.getMethod("inputStream");
      Class<? extends Function<HttpResponse, ?>> transformer = factory(TestTransformers.class)
               .getParserOrThrowException(method);
      assertEquals(transformer, ReturnInputStream.class);
   }

   @SuppressWarnings("static-access")
   public void testInputStreamListenableFuture() throws SecurityException, NoSuchMethodException {
      Method method = TestTransformers.class.getMethod("futureInputStream");
      Class<? extends Function<HttpResponse, ?>> transformer = factory(TestTransformers.class)
               .getParserOrThrowException(method);
      assertEquals(transformer, ReturnInputStream.class);
   }

   @SuppressWarnings("static-access")
   public void testURI() throws SecurityException, NoSuchMethodException {
      Method method = TestTransformers.class.getMethod("uri");
      Class<? extends Function<HttpResponse, ?>> transformer = factory(TestTransformers.class)
               .getParserOrThrowException(method);
      assertEquals(transformer, ParseURIFromListOrLocationHeaderIf20x.class);
   }

   @SuppressWarnings("static-access")
   public void testURIListenableFuture() throws SecurityException, NoSuchMethodException {
      Method method = TestTransformers.class.getMethod("futureUri");
      Class<? extends Function<HttpResponse, ?>> transformer = factory(TestTransformers.class)
               .getParserOrThrowException(method);
      assertEquals(transformer, ParseURIFromListOrLocationHeaderIf20x.class);
   }

   public static class ReturnStringIf200Context extends ReturnStringIf200 implements
            InvocationContext {
      public HttpRequest request;

      public void setContext(GeneratedHttpRequest<?> request) {
         this.request = request;
      }

   }

   @SuppressWarnings("static-access")
   @Test(expectedExceptions = { RuntimeException.class })
   public void testNoTransformer() throws SecurityException, NoSuchMethodException {
      Method method = TestTransformers.class.getMethod("noTransformer");
      factory(TestTransformers.class).getParserOrThrowException(method);
   }

   public void oneTransformerWithContext() throws SecurityException, NoSuchMethodException {
      RestAnnotationProcessor<TestTransformers> processor = factory(TestTransformers.class);
      Method method = TestTransformers.class.getMethod("oneTransformerWithContext");
      GeneratedHttpRequest<TestTransformers> request = new GeneratedHttpRequest<TestTransformers>(
               "GET", URI.create("http://localhost"), processor, TestTransformers.class, method);
      Function<HttpResponse, ?> transformer = processor.createResponseParser(method, request);
      assertEquals(transformer.getClass(), ReturnStringIf200Context.class);
      assertEquals(((ReturnStringIf200Context) transformer).request, request);
   }

   @SuppressWarnings("static-access")
   public void testOneTransformer() throws SecurityException, NoSuchMethodException {
      Method method = TestTransformers.class.getMethod("oneTransformer");
      Class<? extends Function<HttpResponse, ?>> transformer = factory(TestTransformers.class)
               .getParserOrThrowException(method);
      assertEquals(transformer, ReturnStringIf200.class);
   }

   @Endpoint(Localhost.class)
   public class TestRequest {
      @GET
      @VirtualHost
      @Path("/{id}")
      public ListenableFuture<String> get(@PathParam("id") String id, HttpRequestOptions options) {
         return null;
      }

      @GET
      @VirtualHost
      @Path("/{id}")
      public ListenableFuture<String> get(@PathParam("id") String id, HttpRequestOptions... options) {
         return null;
      }

      @GET
      @Path("/{id}")
      @ResponseParser(ReturnStringIf200.class)
      public ListenableFuture<String> get(@PathParam("id") String id,
               @HeaderParam(HttpHeaders.HOST) String host) {
         return null;
      }

      @GET
      @Path("/{id}")
      @QueryParams(keys = "max-keys", values = "0")
      public ListenableFuture<String> getQuery(@PathParam("id") String id) {
         return null;
      }

      @GET
      @Path("/{id}")
      @QueryParams(keys = "acl")
      public ListenableFuture<String> getQueryNull(@PathParam("id") String id) {
         return null;
      }

      @PUT
      @Path("/{id}")
      public ListenableFuture<String> put(
               @PathParam("id") @ParamParser(FirstCharacter.class) String id,
               @BinderParam(BindToStringPayload.class) String payload) {
         return null;
      }

      @PUT
      @Path("/{id}")
      @VirtualHost
      public ListenableFuture<String> putOptions(@PathParam("id") String id,
               HttpRequestOptions options) {
         return null;
      }

      @PUT
      @Path("/{id}")
      @Headers(keys = "foo", values = "--{id}--")
      @ResponseParser(ReturnTrueIf2xx.class)
      public ListenableFuture<String> putHeader(@PathParam("id") String id,
               @BinderParam(BindToStringPayload.class) String payload) {
         return null;
      }
   }

   public void testCreateGetVarArgOptionsThatProducesHeaders() throws SecurityException,
            NoSuchMethodException {
      Date date = new Date();
      GetOptions options = GetOptions.Builder.ifModifiedSince(date);
      HttpRequestOptions[] optionsHolder = new HttpRequestOptions[] {};
      Method method = TestRequest.class.getMethod("get", String.class, optionsHolder.getClass());
      GeneratedHttpRequest<?> httpMethod = factory(TestRequest.class).createRequest(method,
               new Object[] { "1", options });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/1");
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 2);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.HOST), Collections
               .singletonList("localhost"));
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.IF_MODIFIED_SINCE), Collections
               .singletonList(dateService.rfc822DateFormat(date)));
   }

   public void testCreateGetOptionsThatProducesHeaders() throws SecurityException,
            NoSuchMethodException {
      Date date = new Date();
      GetOptions options = GetOptions.Builder.ifModifiedSince(date);
      Method method = TestRequest.class.getMethod("get", String.class, HttpRequestOptions.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestRequest.class).createRequest(method,
               new Object[] { "1", options });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/1");
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 2);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.HOST), Collections
               .singletonList("localhost"));
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.IF_MODIFIED_SINCE), Collections
               .singletonList(dateService.rfc822DateFormat(date)));
   }

   @Endpoint(Localhost.class)
   public class PrefixOptions extends BaseHttpRequestOptions {
      public PrefixOptions withPrefix(String prefix) {
         queryParameters.put("prefix", checkNotNull(prefix, "prefix"));
         return this;
      }
   }

   public void testCreateGetOptionsThatProducesQuery() throws SecurityException,
            NoSuchMethodException, IOException {
      PrefixOptions options = new PrefixOptions().withPrefix("1");
      Method method = TestRequest.class.getMethod("get", String.class, HttpRequestOptions.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestRequest.class).createRequest(method,
               new Object[] { "1", options });
      assertRequestLineEquals(httpMethod, "GET http://localhost:8080/1?prefix=1 HTTP/1.1");
      assertHeadersEqual(httpMethod, "Host: localhost\n");
      assertPayloadEquals(httpMethod, null);
   }

   public void testCreateGetQuery() throws SecurityException, NoSuchMethodException {
      Method method = TestRequest.class.getMethod("getQuery", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestRequest.class).createRequest(method,
               new Object[] { "1" });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/1");
      assertEquals(httpMethod.getEndpoint().getQuery(), "max-keys=0");
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 0);
   }

   public void testCreateGetQueryNull() throws SecurityException, NoSuchMethodException {
      Method method = TestRequest.class.getMethod("getQueryNull", String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestRequest.class).createRequest(method,
               new Object[] { "1" });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/1");
      assertEquals(httpMethod.getEndpoint().getQuery(), "acl");
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 0);
   }

   @Endpoint(Localhost.class)
   public class PayloadOptions extends BaseHttpRequestOptions {
      @Override
      public String buildStringPayload() {
         return "foo";
      }
   }

   public void testCreateGetOptionsThatProducesPayload() throws SecurityException,
            NoSuchMethodException {
      PayloadOptions options = new PayloadOptions();
      Method method = TestRequest.class.getMethod("putOptions", String.class,
               HttpRequestOptions.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestRequest.class).createRequest(method,
               new Object[] { "1", options });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/1");
      assertEquals(httpMethod.getMethod(), HttpMethod.PUT);
      assertEquals(httpMethod.getHeaders().size(), 3);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.HOST), Collections
               .singletonList("localhost"));
      assertEquals(httpMethod.getPayload().toString(), "foo");
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("application/unknown"));
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList("foo".getBytes().length + ""));
   }

   @DataProvider(name = "strings")
   public Object[][] createData() {
      return new Object[][] { { "apples" }, { "sp ace" }, { "unic₪de" }, { "qu?stion" } };
   }

   @Test(dataProvider = "strings")
   public void testCreateGetRequest(String key) throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method method = TestRequest.class.getMethod("get", String.class, String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestRequest.class).createRequest(method,
               new Object[] { key, "localhost" });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      String expectedPath = "/" + URLEncoder.encode(key, "UTF-8").replaceAll("\\+", "%20");
      assertEquals(httpMethod.getEndpoint().getRawPath(), expectedPath);
      assertEquals(httpMethod.getEndpoint().getPath(), "/" + key);
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 1);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.HOST), Collections
               .singletonList("localhost"));
   }

   public void testCreatePutRequest() throws SecurityException, NoSuchMethodException {
      Method method = TestRequest.class.getMethod("put", String.class, String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestRequest.class).createRequest(method,
               new Object[] { "111", "data" });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/1");
      assertEquals(httpMethod.getMethod(), HttpMethod.PUT);
      assertEquals(httpMethod.getHeaders().size(), 2);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("application/unknown"));
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList("data".getBytes().length + ""));
      assertEquals(httpMethod.getPayload().toString(), "data");
   }

   public void testCreatePutHeader() throws SecurityException, NoSuchMethodException {
      Method method = TestRequest.class.getMethod("putHeader", String.class, String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestRequest.class).createRequest(method,
               new Object[] { "1", "data" });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/1");
      assertEquals(httpMethod.getMethod(), HttpMethod.PUT);
      assertEquals(httpMethod.getHeaders().size(), 3);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("application/unknown"));
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList("data".getBytes().length + ""));
      assertEquals(httpMethod.getHeaders().get("foo"), Collections.singletonList("--1--"));
      assertEquals(httpMethod.getPayload().toString(), "data");
   }

   @Endpoint(Localhost.class)
   public class TestVirtualHostMethod {
      @GET
      @Path("/{id}")
      @VirtualHost
      public ListenableFuture<String> get(@PathParam("id") String id, String foo) {
         return null;
      }
   }

   @Test
   public void testVirtualHostMethod() throws SecurityException, NoSuchMethodException {
      Method method = TestVirtualHostMethod.class.getMethod("get", String.class, String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestVirtualHostMethod.class).createRequest(
               method, new Object[] { "1", "localhost" });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/1");
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 1);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.HOST), Collections
               .singletonList("localhost"));
   }

   @Endpoint(Localhost.class)
   public class TestVirtualHost {
      @GET
      @Path("/{id}")
      @VirtualHost
      public ListenableFuture<String> get(@PathParam("id") String id, String foo) {
         return null;
      }

      @GET
      @Path("/{id}")
      public ListenableFuture<String> getPrefix(@PathParam("id") String id,
               @HostPrefixParam("") String foo) {
         return null;
      }

      @GET
      @Path("/{id}")
      public ListenableFuture<String> getPrefixDot(@PathParam("id") String id,
               @HostPrefixParam String foo) {
         return null;
      }
   }

   @Test
   public void testVirtualHost() throws SecurityException, NoSuchMethodException {
      Method method = TestVirtualHost.class.getMethod("get", String.class, String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestVirtualHost.class).createRequest(method,
               new Object[] { "1", "localhost" });
      assertEquals(httpMethod.getEndpoint().getHost(), "localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/1");
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 1);
      assertEquals(httpMethod.getHeaders().get(HttpHeaders.HOST), Collections
               .singletonList("localhost"));
   }

   @Test
   public void testHostPrefix() throws SecurityException, NoSuchMethodException {
      Method method = TestVirtualHost.class.getMethod("getPrefix", String.class, String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestVirtualHost.class).createRequest(method,
               new Object[] { "1", "holy" });
      assertEquals(httpMethod.getEndpoint().getHost(), "holylocalhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/1");
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 0);
   }

   @Test
   public void testHostPrefixDot() throws SecurityException, NoSuchMethodException {
      Method method = TestVirtualHost.class.getMethod("getPrefixDot", String.class, String.class);
      GeneratedHttpRequest<?> httpMethod = factory(TestVirtualHost.class).createRequest(method,
               new Object[] { "1", "holy" });
      assertEquals(httpMethod.getEndpoint().getHost(), "holy.localhost");
      assertEquals(httpMethod.getEndpoint().getPath(), "/1");
      assertEquals(httpMethod.getMethod(), HttpMethod.GET);
      assertEquals(httpMethod.getHeaders().size(), 0);
   }

   @Test(expectedExceptions = IllegalArgumentException.class)
   public void testHostPrefixDotEmpty() throws SecurityException, NoSuchMethodException {
      Method method = TestVirtualHost.class.getMethod("getPrefixDot", String.class, String.class);
      factory(TestVirtualHost.class).createRequest(method, new Object[] { "1", "" });
   }

   @Test(expectedExceptions = NullPointerException.class)
   public void testHostPrefixDotNull() throws SecurityException, NoSuchMethodException {
      Method method = TestVirtualHost.class.getMethod("getPrefixDot", String.class, String.class);
      factory(TestVirtualHost.class).createRequest(method, new Object[] { "1", null });
   }

   @Endpoint(Localhost.class)
   public class TestHeaders {
      @GET
      public void oneHeader(@HeaderParam("header") String header) {
      }

      @GET
      public void oneIntHeader(@HeaderParam("header") int header) {
      }

      @GET
      public void twoDifferentHeaders(@HeaderParam("header1") String header1,
               @HeaderParam("header2") String header2) {
      }

      @GET
      public void twoSameHeaders(@HeaderParam("header") String header1,
               @HeaderParam("header") String header2) {
      }
   }

   @Test
   public void testOneHeader() throws SecurityException, NoSuchMethodException {
      Method method = TestHeaders.class.getMethod("oneHeader", String.class);
      Multimap<String, String> headers = factory(TestHeaders.class).buildHeaders(
               ImmutableMultimap.<String, String> of().entries(), method, "robot");
      assertEquals(headers.size(), 1);
      assertEquals(headers.get("header"), Collections.singletonList("robot"));
   }

   @Test
   public void testOneIntHeader() throws SecurityException, NoSuchMethodException {
      Method method = TestHeaders.class.getMethod("oneIntHeader", int.class);
      Multimap<String, String> headers = factory(TestHeaders.class).buildHeaders(
               ImmutableMultimap.<String, String> of().entries(), method, 1);
      assertEquals(headers.size(), 1);
      assertEquals(headers.get("header"), Collections.singletonList("1"));
   }

   @Test
   public void testTwoDifferentHeaders() throws SecurityException, NoSuchMethodException {
      Method method = TestHeaders.class
               .getMethod("twoDifferentHeaders", String.class, String.class);
      Multimap<String, String> headers = factory(TestHeaders.class).buildHeaders(
               ImmutableMultimap.<String, String> of().entries(), method, "robot", "egg");
      assertEquals(headers.size(), 2);
      assertEquals(headers.get("header1"), Collections.singletonList("robot"));
      assertEquals(headers.get("header2"), Collections.singletonList("egg"));
   }

   @Test
   public void testTwoSameHeaders() throws SecurityException, NoSuchMethodException {
      Method method = TestHeaders.class.getMethod("twoSameHeaders", String.class, String.class);
      Multimap<String, String> headers = factory(TestHeaders.class).buildHeaders(
               ImmutableMultimap.<String, String> of().entries(), method, "robot", "egg");
      assertEquals(headers.size(), 2);
      Collection<String> values = headers.get("header");
      assert values.contains("robot");
      assert values.contains("egg");
   }

   @Endpoint(Localhost.class)
   public interface TestPayload {
      @PUT
      public void put(@BinderParam(BindToStringPayload.class) String content);

      @PUT
      @Path("{foo}")
      public ListenableFuture<Void> putWithPath(@PathParam("foo") String path,
               @BinderParam(BindToStringPayload.class) String content);

      @PUT
      public void twoEntities(@BinderParam(BindToStringPayload.class) String payload1,
               @BinderParam(BindToStringPayload.class) String payload2);
   }

   @Test
   public void testPut() throws SecurityException, NoSuchMethodException {
      RestAnnotationProcessor<TestPayload> processor = factory(TestPayload.class);
      Method method = TestPayload.class.getMethod("put", String.class);
      GeneratedHttpRequest<TestPayload> request = new GeneratedHttpRequest<TestPayload>("GET", URI
               .create("http://localhost"), processor, TestPayload.class, method, "test");
      processor.decorateRequest(request);
      assertEquals(request.getPayload().toString(), "test");
      assertEquals(request.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("application/unknown"));
      assertEquals(request.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList("test".getBytes().length + ""));
      assertEquals(processor.createResponseParser(method, request).getClass(),
               CloseContentAndReturn.class);
   }

   @Test
   public void putWithPath() throws SecurityException, NoSuchMethodException {

      RestAnnotationProcessor<TestPayload> processor = factory(TestPayload.class);
      Method method = TestPayload.class.getMethod("putWithPath", String.class, String.class);
      GeneratedHttpRequest<TestPayload> request = new GeneratedHttpRequest<TestPayload>("GET", URI
               .create("http://localhost"), processor, TestPayload.class, method, "rabble", "test");
      processor.decorateRequest(request);
      assertEquals(request.getPayload().toString(), "test");
      assertEquals(request.getHeaders().get(HttpHeaders.CONTENT_TYPE), Collections
               .singletonList("application/unknown"));
      assertEquals(request.getHeaders().get(HttpHeaders.CONTENT_LENGTH), Collections
               .singletonList("test".getBytes().length + ""));
   }

   public class TestReplaceFormOptions extends BaseHttpRequestOptions {
      public TestReplaceFormOptions() {
         this.formParameters.put("x-amz-copy-source", "/{bucket}");
      }
   }

   @Endpoint(Localhost.class)
   @SkipEncoding('/')
   public class TestFormReplace {

      @POST
      public void formInOptions(@PathParam("bucket") String path, TestReplaceFormOptions options) {
      }

      @POST
      @FormParams(keys = "x-amz-copy-source", values = "/{bucket}")
      public void oneForm(@PathParam("bucket") String path) {
      }

      @POST
      @FormParams(keys = { "slash", "hyphen" }, values = { "/{bucket}", "-{bucket}" })
      public void twoForm(@PathParam("bucket") String path) {
      }

      @POST
      @FormParams(keys = "x-amz-copy-source", values = "/{bucket}/{key}")
      public void twoForms(@PathParam("bucket") String path, @PathParam("key") String path2) {
      }

      @POST
      @FormParams(keys = "x-amz-copy-source", values = "/{bucket}/{key}")
      public void twoFormsOutOfOrder(@PathParam("key") String path,
               @PathParam("bucket") String path2) {
      }
   }

   @Test
   public void testBuildTwoForm() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneForm = TestFormReplace.class.getMethod("twoForm", String.class);
      String form = factory(TestFormReplace.class).createRequest(oneForm, new Object[] { "robot" })
               .getPayload().toString().toString();
      assertEquals(form, "slash=/robot&hyphen=-robot");
   }

   @FormParams(keys = "x-amz-copy-source", values = "/{bucket}")
   @Endpoint(Localhost.class)
   @SkipEncoding('/')
   public class TestClassForm {
      @POST
      public void oneForm(@PathParam("bucket") String path) {
      }
   }

   @Test
   public void testBuildOneClassForm() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneForm = TestClassForm.class.getMethod("oneForm", String.class);
      String form = factory(TestClassForm.class).createRequest(oneForm, new Object[] { "robot" })
               .getPayload().toString().toString();
      assertEquals(form, "x-amz-copy-source=/robot");
   }

   @Test
   public void testBuildOneForm() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method oneForm = TestFormReplace.class.getMethod("oneForm", String.class);
      String form = factory(TestFormReplace.class).createRequest(oneForm, new Object[] { "robot" })
               .getPayload().toString().toString();
      assertEquals(form, "x-amz-copy-source=/robot");
   }

   @Test
   public void testBuildTwoForms() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method twoForms = TestFormReplace.class.getMethod("twoForms", String.class, String.class);
      String form = factory(TestFormReplace.class).createRequest(twoForms,
               new Object[] { "robot", "eggs" }).getPayload().toString().toString();
      assertEquals(form, "x-amz-copy-source=/robot/eggs");
   }

   @Test
   public void testBuildTwoFormsOutOfOrder() throws SecurityException, NoSuchMethodException,
            UnsupportedEncodingException {
      Method twoFormsOutOfOrder = TestFormReplace.class.getMethod("twoFormsOutOfOrder",
               String.class, String.class);
      String form = factory(TestFormReplace.class).createRequest(twoFormsOutOfOrder,
               new Object[] { "robot", "eggs" }).getPayload().toString().toString();
      assertEquals(form, "x-amz-copy-source=/eggs/robot");
   }

   @SuppressWarnings("unchecked")
   private <T> RestAnnotationProcessor<T> factory(Class<T> clazz) {
      return ((RestAnnotationProcessor<T>) injector.getInstance(Key.get(TypeLiteral.get(Types
               .newParameterizedType(RestAnnotationProcessor.class, clazz)))));
   }

   Injector injector;
   DateService dateService = new SimpleDateFormatDateService();

   @BeforeClass
   void setupFactory() {
      injector = Guice.createInjector(new AbstractModule() {
         @Override
         protected void configure() {
            bindConstant().annotatedWith(Jsr330.named("testaccount")).to("ralphie");
            bind(URI.class).annotatedWith(Localhost.class).toInstance(
                     URI.create("http://localhost:8080"));
            bind(URI.class).annotatedWith(Localhost2.class).toInstance(
                     URI.create("http://localhost:8081"));
            bind(Logger.LoggerFactory.class).toInstance(new LoggerFactory() {
               public Logger getLogger(String category) {
                  return Logger.NULL;
               }
            });
            Jsr330.bindProperties(binder(), new PropertiesBuilder() {

               @Override
               public PropertiesBuilder withCredentials(String account, String key) {
                  return null;
               }

               @Override
               public PropertiesBuilder withEndpoint(URI endpoint) {
                  return null;
               }
            }.build());
         }

      }, new RestModule(), new ExecutorServiceModule(sameThreadExecutor(), sameThreadExecutor()),
               new JavaUrlHttpCommandExecutorServiceModule());

   }

   protected void assertPayloadEquals(GeneratedHttpRequest<?> httpMethod, String toMatch)
            throws IOException {
      if (httpMethod.getPayload() == null) {
         assertNull(toMatch);
      } else {
         String payload = Utils.toStringAndClose(httpMethod.getPayload().getContent());
         assertEquals(payload, toMatch);
      }
   }

   protected void assertHeadersEqual(GeneratedHttpRequest<?> httpMethod, String toMatch) {
      assertEquals(HttpUtils.sortAndConcatHeadersIntoString(httpMethod.getHeaders()), toMatch);
   }

   protected void assertRequestLineEquals(GeneratedHttpRequest<?> httpMethod, String toMatch) {
      assertEquals(httpMethod.getRequestLine(), toMatch);
   }

}