incubator-wink-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ngalla...@apache.org
Subject svn commit: r787553 [10/34] - in /incubator/wink/contrib/ibm-jaxrs/tests: ./ fvt/ fvt/demo/ fvt/demo/jaxrs/ fvt/demo/jaxrs/cache/ fvt/demo/jaxrs/cache/server/ fvt/demo/jaxrs/cache/test/ fvt/demo/jaxrs/datasource/ fvt/demo/jaxrs/datasource/server/ fvt/d...
Date Tue, 23 Jun 2009 05:38:19 GMT
Added: incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/request/test/RequestMethodsTest.java
URL: http://svn.apache.org/viewvc/incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/request/test/RequestMethodsTest.java?rev=787553&view=auto
==============================================================================
--- incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/request/test/RequestMethodsTest.java (added)
+++ incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/request/test/RequestMethodsTest.java Tue Jun 23 05:37:57 2009
@@ -0,0 +1,2130 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 jaxrs.tests.context.request.test;
+
+import java.io.IOException;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+
+import javax.ws.rs.core.Request;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.ResponseBuilder;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.ws.http.HTTPException;
+
+import jaxrs.tests.context.request.server.Variant;
+
+import org.apache.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.HttpException;
+import org.apache.commons.httpclient.methods.GetMethod;
+import org.apache.commons.httpclient.methods.PostMethod;
+import org.apache.commons.httpclient.methods.PutMethod;
+import org.apache.commons.httpclient.methods.StringRequestEntity;
+
+import framework.defaults.test.FVTTestCase;
+
+/**
+ * Tests the {@link Request} implementation.
+ */
+public class RequestMethodsTest extends FVTTestCase {
+
+    final private static SimpleDateFormat rfc1123Format = new SimpleDateFormat(
+            "EEE, dd MMM yyyy HH:mm:ss zzz", Locale.ENGLISH);
+
+    final private static SimpleDateFormat rfc850Format = new SimpleDateFormat(
+            "EEEE, dd-MMM-yy HH:mm:ss zzz", Locale.ENGLISH);
+
+    final private static SimpleDateFormat asctimeDateFormat = new SimpleDateFormat(
+            "EEE MMM dd HH:mm:ss yyyy", Locale.ENGLISH);
+
+    final private static SimpleDateFormat asctimeDateFormatWithOneDigit = new SimpleDateFormat(
+            "EEE MMM  d HH:mm:ss yyyy", Locale.ENGLISH);
+
+    {
+        /*
+         * the implementation allows you to set a different time zone on the
+         * requests for If-Modified-Since headers and it will do the
+         * "right thing" (this is more leniant).
+         *
+         * However, asctime does not have a time zone specified so it is assumed
+         * that all datetimes are in GMT/UTC so the tests have to assume that
+         * the GMT time zone is used.
+         */
+        asctimeDateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
+        asctimeDateFormatWithOneDigit.setTimeZone(TimeZone.getTimeZone("GMT"));
+    }
+
+    public static junit.framework.Test suite() {
+        return FVTTestCase.getTestSuite(RequestMethodsTest.class,
+                "jaxrs.tests.context.request.server.Application");
+    }
+
+    /**
+     * Tests the {@link Request#evaluatePreconditions(Date)} that uses the
+     * <code>If-Modified-Since</code> header and the RFC 1123 date format.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void testEvaluateDateIfModifiedSinceUsingRFC1123Format()
+            throws HttpException, IOException {
+        checkIfModifiedSinceUsingSuppliedDateFormat(rfc1123Format);
+    }
+
+    /**
+     * Tests the {@link Request#evaluatePreconditions(Date)} that uses the
+     * <code>If-Modified-Since</code> header and the RFC 850 date format.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void testEvaluateDateIfModifiedSinceUsingRFC850Format()
+            throws HttpException, IOException {
+        checkIfModifiedSinceUsingSuppliedDateFormat(rfc850Format);
+    }
+
+    /**
+     * Tests the {@link Request#evaluatePreconditions(Date)} that uses the
+     * <code>If-Modified-Since</code> header and the Asctime date format.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void testEvaluateDateIfModifiedSinceUsingAscTimeFormat()
+            throws HttpException, IOException {
+        SimpleDateFormat formatter = (Calendar.getInstance().get(
+                Calendar.DAY_OF_MONTH) < 10) ? asctimeDateFormatWithOneDigit
+                : asctimeDateFormat;
+        checkIfModifiedSinceUsingSuppliedDateFormat(formatter);
+    }
+
+    private void checkIfModifiedSinceUsingSuppliedDateFormat(SimpleDateFormat formatter)
+            throws IOException, HTTPException {
+        HttpClient client = new HttpClient();
+
+        PutMethod putMethod = new PutMethod(getBaseURI()
+                + "/context/request/date");
+        Date d2 = new Date(System.currentTimeMillis() - 120000);
+        Date d = new Date(System.currentTimeMillis() - 60000);
+        String date = DateFormat.getDateTimeInstance().format(d);
+        putMethod.setRequestEntity(new StringRequestEntity(date, "text/string",
+                "UTF-8"));
+        try {
+            /*
+             * sets a last modified date
+             */
+            client.executeMethod(putMethod);
+            assertEquals(204, putMethod.getStatusCode());
+        } finally {
+            putMethod.releaseConnection();
+        }
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/date");
+        getMethod.setRequestHeader("If-Modified-Since", formatter.format(d));
+        try {
+            /*
+             * verifies that if the exact date is sent in and used in
+             * If-Modified-Since header, then the server will be ok and that it
+             * will return 304
+             */
+            client.executeMethod(getMethod);
+            assertEquals(304, getMethod.getStatusCode());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/date");
+        try {
+            /*
+             * verifies that if no If-Modified-Since header is sent, then the
+             * server will be ok and the Request instance won't build a
+             * response.
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the date: " + rfc1123Format.format(d), getMethod
+                    .getResponseBodyAsString());
+
+            rfc1123Format.setTimeZone(TimeZone.getTimeZone("GMT"));
+            assertEquals(rfc1123Format.format(d), getMethod.getResponseHeader(
+                    "Last-Modified").getValue());
+            rfc1123Format.setTimeZone(TimeZone.getDefault());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        String lastModified = getMethod.getResponseHeader("Last-Modified")
+                .getValue();
+        getMethod = new GetMethod(getBaseURI() + "/context/request/date");
+        getMethod.setRequestHeader("If-Modified-Since", lastModified);
+        try {
+            /*
+             * verifies that using Last-Modified response header sent by server
+             * as If-Modified-Since request header, then the server will return
+             * a 304
+             */
+            client.executeMethod(getMethod);
+            assertEquals(304, getMethod.getStatusCode());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/date");
+        getMethod.setRequestHeader("If-Modified-Since", formatter.format(d2));
+        try {
+            /*
+             * verifies that using a If-Modified-Since earlier than the
+             * Last-Modified response header sent by server then the server will
+             * return a 200 with entity
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the date: " + rfc1123Format.format(d), getMethod
+                    .getResponseBodyAsString());
+
+            rfc1123Format.setTimeZone(TimeZone.getTimeZone("GMT"));
+            assertEquals(rfc1123Format.format(d), getMethod.getResponseHeader(
+                    "Last-Modified").getValue());
+            rfc1123Format.setTimeZone(TimeZone.getDefault());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/date");
+        getMethod.setRequestHeader("If-Modified-Since", formatter
+                .format(new Date()));
+        try {
+            /*
+             * verifies that using a If-Modified-Since later than the
+             * Last-Modified response header sent by server, then the server
+             * will return a 304
+             */
+            client.executeMethod(getMethod);
+            assertEquals(304, getMethod.getStatusCode());
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#evaluatePreconditions(Date)} that uses the
+     * <code>If-Unmodified-Since</code> header using RFC 1123.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void testEvaluateDateIfUnmodifiedSinceUsingRFC1123()
+            throws HttpException, IOException {
+        checkIfUnmodifiedSinceUsingSuppliedDateFormat(rfc1123Format);
+    }
+
+    /**
+     * Tests the {@link Request#evaluatePreconditions(Date)} that uses the
+     * <code>If-Unmodified-Since</code> header using RFC 850.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void testEvaluateDateIfUnmodifiedSinceUsingRFC850()
+            throws HttpException, IOException {
+        checkIfUnmodifiedSinceUsingSuppliedDateFormat(rfc850Format);
+    }
+
+    /**
+     * Tests the {@link Request#evaluatePreconditions(Date)} that uses the
+     * <code>If-Unmodified-Since</code> header using Asctime.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void testEvaluateDateIfUnmodifiedSinceUsingAscTime()
+            throws HttpException, IOException {
+        SimpleDateFormat dateFormat = (Calendar.getInstance().get(
+                Calendar.DAY_OF_MONTH) < 10) ? asctimeDateFormatWithOneDigit
+                : asctimeDateFormat;
+        checkIfUnmodifiedSinceUsingSuppliedDateFormat(dateFormat);
+    }
+
+    private void checkIfUnmodifiedSinceUsingSuppliedDateFormat(SimpleDateFormat formatter)
+            throws IOException, HTTPException {
+        HttpClient client = new HttpClient();
+
+        PutMethod putMethod = new PutMethod(getBaseURI()
+                + "/context/request/date");
+        Date d2 = new Date(System.currentTimeMillis() - 120000);
+        Date d = new Date(System.currentTimeMillis() - 60000);
+        String date = DateFormat.getDateTimeInstance().format(d);
+        putMethod.setRequestEntity(new StringRequestEntity(date, "text/string",
+                "UTF-8"));
+        try {
+            /*
+             * sets a last modified date
+             */
+            client.executeMethod(putMethod);
+            assertEquals(204, putMethod.getStatusCode());
+        } finally {
+            putMethod.releaseConnection();
+        }
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/date");
+        getMethod.setRequestHeader("If-Unmodified-Since", formatter.format(d));
+        try {
+            /*
+             * verifies that if the exact date is sent in and used in
+             * If-Unmodified-Since header, then the server will be ok and that
+             * it will return 200
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the date: " + rfc1123Format.format(d), getMethod
+                    .getResponseBodyAsString());
+
+            rfc1123Format.setTimeZone(TimeZone.getTimeZone("GMT"));
+            assertEquals(rfc1123Format.format(d), getMethod.getResponseHeader(
+                    "Last-Modified").getValue());
+            rfc1123Format.setTimeZone(TimeZone.getDefault());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/date");
+        try {
+            /*
+             * verifies that if no If-Unmodified-Since header is sent, then the
+             * server will be ok and the Request instance won't build a
+             * response.
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the date: " + rfc1123Format.format(d), getMethod
+                    .getResponseBodyAsString());
+
+            rfc1123Format.setTimeZone(TimeZone.getTimeZone("GMT"));
+            assertEquals(rfc1123Format.format(d), getMethod.getResponseHeader(
+                    "Last-Modified").getValue());
+            rfc1123Format.setTimeZone(TimeZone.getDefault());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        String lastModified = getMethod.getResponseHeader("Last-Modified")
+                .getValue();
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/date");
+        getMethod.setRequestHeader("If-Unmodified-Since", lastModified);
+        try {
+            /*
+             * verifies that using Last-Modified response header sent by server
+             * as If-Unmodified-Since request header, then the server will
+             * return the entity
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the date: " + rfc1123Format.format(d), getMethod
+                    .getResponseBodyAsString());
+
+            rfc1123Format.setTimeZone(TimeZone.getTimeZone("GMT"));
+            assertEquals(rfc1123Format.format(d), getMethod.getResponseHeader(
+                    "Last-Modified").getValue());
+            rfc1123Format.setTimeZone(TimeZone.getDefault());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/date");
+        getMethod.setRequestHeader("If-Unmodified-Since", formatter.format(d2));
+        try {
+            /*
+             * verifies that using a If-Unmodified-Since earlier than the
+             * Last-Modified response header sent by server then the server will
+             * return a 412
+             */
+            client.executeMethod(getMethod);
+            assertEquals(412, getMethod.getStatusCode());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/date");
+        getMethod.setRequestHeader("If-Unmodified-Since", formatter
+                .format(new Date()));
+        try {
+            /*
+             * verifies that using a If-Unmodified-Since later than the
+             * Last-Modified response header sent by server, then the server
+             * will return 200 and the entity
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the date: " + rfc1123Format.format(d), getMethod
+                    .getResponseBodyAsString());
+
+            rfc1123Format.setTimeZone(TimeZone.getTimeZone("GMT"));
+            assertEquals(rfc1123Format.format(d), getMethod.getResponseHeader(
+                    "Last-Modified").getValue());
+            rfc1123Format.setTimeZone(TimeZone.getDefault());
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the
+     * {@link Request#evaluatePreconditions(javax.ws.rs.core.EntityTag)} that
+     * uses the <code>If-Match</code> header and a strong ETag.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void testEvaluateEtagIfMatchStrong() throws HttpException,
+            IOException {
+        checkETagIfMatch("\"myentitytagABCXYZ\"", false);
+    }
+
+    /**
+     * Tests the
+     * {@link Request#evaluatePreconditions(javax.ws.rs.core.EntityTag)} that
+     * uses the <code>If-Match</code> header and a weak ETag.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void testEvaluateEtagIfMatchWeak() throws HttpException, IOException {
+        checkETagIfMatch("\"myentitytagABCXYZ\"", true);
+    }
+
+    /**
+     * Tests the
+     * {@link Request#evaluatePreconditions(javax.ws.rs.core.EntityTag)} that
+     * uses the <code>If-Match</code> header.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void checkETagIfMatch(String etag, boolean isEntityTagWeak)
+            throws HttpException, IOException {
+        HttpClient client = new HttpClient();
+
+        final String justTheTag = etag;
+        final String setETag = isEntityTagWeak ? "W/" + justTheTag : justTheTag;
+        String isWeak = isEntityTagWeak ? "true" : "false";
+
+        PutMethod putMethod = new PutMethod(getBaseURI()
+                + "/context/request/etag");
+        putMethod.setRequestEntity(new StringRequestEntity(setETag,
+                "text/string", "UTF-8"));
+        try {
+            /*
+             * sets an entity tag
+             */
+            client.executeMethod(putMethod);
+            assertEquals(204, putMethod.getStatusCode());
+        } finally {
+            putMethod.releaseConnection();
+        }
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/etag");
+        getMethod.setRequestHeader("If-Match", setETag);
+        try {
+            /*
+             * verifies that if the exact etag is sent in, then the request is
+             * allowed to proceed
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        try {
+            /*
+             * verifies that a request without an If-Match header will still
+             * proceed
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.setRequestHeader("If-Match", setETag.substring(1, setETag
+                .length() - 1));
+        try {
+            /*
+             * verifies that an unquoted entity tag is not a valid entity tag
+             */
+            client.executeMethod(getMethod);
+            assertEquals(412, getMethod.getStatusCode());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.setRequestHeader("If-Match", setETag.substring(0, setETag
+                .length() - 1));
+        try {
+            /*
+             * verifies that a misquoted entity tag is not a valid entity tag
+             */
+            client.executeMethod(getMethod);
+            assertEquals(412, getMethod.getStatusCode());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.setRequestHeader("If-Match", setETag.substring(1, setETag
+                .length()));
+        try {
+            /*
+             * verifies that a misquoted entity tag is not a valid entity tag
+             */
+            client.executeMethod(getMethod);
+            assertEquals(412, getMethod.getStatusCode());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.setRequestHeader("If-Match", "\"someothervalue\"");
+        try {
+            /*
+             * verifies that if an etag is sent that does not match the server
+             * etag, that a 412 is returned
+             */
+            client.executeMethod(getMethod);
+            assertEquals(412, getMethod.getStatusCode());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.setRequestHeader("If-Match", "\"austin\", \"powers\"");
+        try {
+            /*
+             * verifies that if multiple etags are sent that do not match the
+             * server etag, that a 412 is returned
+             */
+            client.executeMethod(getMethod);
+            assertEquals(412, getMethod.getStatusCode());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.addRequestHeader("If-Match", "\"austin\"");
+        getMethod.addRequestHeader("If-Match", "\"powers\"");
+        try {
+            /*
+             * verifies that if multiple etags are sent that do not match the
+             * server etag, that a 412 is returned
+             */
+            client.executeMethod(getMethod);
+            assertEquals(412, getMethod.getStatusCode());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.addRequestHeader("If-Match", "\"austin\"");
+        getMethod.addRequestHeader("If-Match", setETag);
+        getMethod.addRequestHeader("If-Match", "\"powers\"");
+        try {
+            /*
+             * verifies that if multiple etags are sent that do match the server
+             * etag, that a 200 and entity body is returned
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.addRequestHeader("If-Match", "\"austin\", , \"powers\"");
+        try {
+            /*
+             * verifies that if multiple etags are sent that do not match the
+             * server etag, that a 412 is returned
+             */
+            client.executeMethod(getMethod);
+            assertEquals(412, getMethod.getStatusCode());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.addRequestHeader("If-Match", "\"austin\", " + setETag
+                + " , \"powers\"");
+        try {
+            /*
+             * verifies that if multiple etags are sent that do match the server
+             * etag, that a 200 and entity body is returned
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the
+     * {@link Request#evaluatePreconditions(javax.ws.rs.core.EntityTag)} that
+     * uses the <code>If-None-Match</code> header with strong entity tag.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void testEvaluateEtagIfNoneMatchStrong() throws HttpException,
+            IOException {
+        checkETagIfNoneMatch("\"myentitytagABCXYZ\"", false);
+    }
+
+    /**
+     * Tests the
+     * {@link Request#evaluatePreconditions(javax.ws.rs.core.EntityTag)} that
+     * uses the <code>If-None-Match</code> header with weak entity tag.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void testEvaluateEtagIfNoneMatchWeak() throws HttpException,
+            IOException {
+        checkETagIfNoneMatch("\"myentitytagABCXYZ\"", true);
+    }
+
+    /**
+     * Tests the
+     * {@link Request#evaluatePreconditions(javax.ws.rs.core.EntityTag)} that
+     * uses the <code>If-None-Match</code> header.
+     *
+     * @throws HttpException
+     * @throws IOException
+     */
+    public void checkETagIfNoneMatch(String etag, boolean isEntityTagWeak)
+            throws HttpException, IOException {
+        HttpClient client = new HttpClient();
+        final String justTheTag = etag;
+        final String setETag = isEntityTagWeak ? "W/" + justTheTag : justTheTag;
+        String isWeak = isEntityTagWeak ? "true" : "false";
+
+        PutMethod putMethod = new PutMethod(getBaseURI()
+                + "/context/request/etag");
+        putMethod.setRequestEntity(new StringRequestEntity(setETag,
+                "text/string", "UTF-8"));
+        try {
+            /*
+             * sets an entity tag
+             */
+            client.executeMethod(putMethod);
+            assertEquals(204, putMethod.getStatusCode());
+        } finally {
+            putMethod.releaseConnection();
+        }
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/etag");
+        getMethod.setRequestHeader("If-None-Match", setETag);
+        try {
+            /*
+             * verifies that if the exact etag is sent in, then the response is
+             * a 304
+             */
+            client.executeMethod(getMethod);
+            assertEquals(304, getMethod.getStatusCode());
+            assertEquals(setETag, getMethod.getResponseHeader("ETag")
+                    .getValue());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.setRequestHeader("If-None-Match", "*");
+        try {
+            /*
+             * verifies that if a "*" etag is sent in, then the response returns
+             * a 304
+             */
+            client.executeMethod(getMethod);
+            assertEquals(304, getMethod.getStatusCode());
+            assertEquals(setETag, getMethod.getResponseHeader("ETag")
+                    .getValue());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        PostMethod postMethod = new PostMethod(getBaseURI()
+                + "/context/request/etag");
+        postMethod.setRequestHeader("If-None-Match", setETag);
+        try {
+            /*
+             * verifies that if a matching etag is sent in, then the response
+             * returns a 412
+             */
+            client.executeMethod(postMethod);
+            assertEquals(412, postMethod.getStatusCode());
+            assertEquals(setETag, postMethod.getResponseHeader("ETag")
+                    .getValue());
+        } finally {
+            postMethod.releaseConnection();
+        }
+
+        postMethod = new PostMethod(getBaseURI() + "/context/request/etag");
+        postMethod.setRequestHeader("If-None-Match", "*");
+        try {
+            /*
+             * verifies that if a "*" etag is sent in, then the response returns
+             * a 412
+             */
+            client.executeMethod(postMethod);
+            assertEquals(412, postMethod.getStatusCode());
+            assertEquals(setETag, postMethod.getResponseHeader("ETag")
+                    .getValue());
+        } finally {
+            postMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        try {
+            /*
+             * verifies that a request without an If-None-Match header will
+             * still proceed
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        postMethod = new PostMethod(getBaseURI() + "/context/request/etag");
+        try {
+            /*
+             * verifies that a request without an If-None-Match header will
+             * still proceed
+             */
+            client.executeMethod(postMethod);
+            assertEquals(200, postMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, postMethod
+                    .getResponseBodyAsString());
+        } finally {
+            postMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.setRequestHeader("If-None-Match", setETag.substring(1,
+                setETag.length() - 1));
+        try {
+            /*
+             * verifies that an unquoted entity tag is not a valid entity tag so
+             * the request is allowed to proceed
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.setRequestHeader("If-None-Match", setETag.substring(0,
+                setETag.length() - 1));
+        try {
+            /*
+             * verifies that a misquoted entity tag is not a valid entity tag so
+             * the request is allowed to proceed
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.setRequestHeader("If-None-Match", setETag.substring(1,
+                setETag.length()));
+        try {
+            /*
+             * verifies that a misquoted entity tag is not a valid entity tag so
+             * the request is allowed to proceed
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.setRequestHeader("If-None-Match", "\"someothervalue\"");
+        try {
+            /*
+             * verifies that if an etag is sent that does not match the server
+             * etag, that request is allowed to proceed
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.setRequestHeader("If-None-Match", "\"austin\", \"powers\"");
+        try {
+            /*
+             * verifies that if multiple etags are sent that do not match the
+             * server etag, that the request is allowed to proceed
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.addRequestHeader("If-None-Match", "\"austin\"");
+        getMethod.addRequestHeader("If-None-Match", "\"powers\"");
+        try {
+            /*
+             * verifies that if multiple etags are sent that do not match the
+             * server etag, that the request is allowed to proceed
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.addRequestHeader("If-None-Match", "\"austin\"");
+        getMethod.addRequestHeader("If-None-Match", setETag);
+        getMethod.addRequestHeader("If-None-Match", "\"powers\"");
+        try {
+            /*
+             * verifies that if multiple etags are sent that do match the server
+             * etag, that a 304 is returned with the etag
+             */
+            client.executeMethod(getMethod);
+            assertEquals(304, getMethod.getStatusCode());
+            assertEquals(setETag, getMethod.getResponseHeader("ETag")
+                    .getValue());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.addRequestHeader("If-None-Match", "\"austin\", , \"powers\"");
+        try {
+            /*
+             * verifies that if multiple etags are sent that do not match the
+             * server etag, then a 200 and the request entity is returned
+             */
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, getMethod
+                    .getResponseBodyAsString());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        postMethod = new PostMethod(getBaseURI() + "/context/request/etag");
+        postMethod
+                .addRequestHeader("If-None-Match", "\"austin\", , \"powers\"");
+        try {
+            /*
+             * verifies that a request without an If-None-Match header will
+             * still proceed
+             */
+            client.executeMethod(postMethod);
+            assertEquals(200, postMethod.getStatusCode());
+            assertEquals("the etag: " + justTheTag + isWeak, postMethod
+                    .getResponseBodyAsString());
+        } finally {
+            postMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI() + "/context/request/etag");
+        getMethod.addRequestHeader("If-None-Match", "\"austin\", " + setETag
+                + " , \"powers\"");
+        try {
+            /*
+             * verifies that if multiple etags are sent that do match the server
+             * etag, that a 304 is returned
+             */
+            client.executeMethod(getMethod);
+            assertEquals(304, getMethod.getStatusCode());
+            assertEquals(setETag, getMethod.getResponseHeader("ETag")
+                    .getValue());
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        postMethod = new PostMethod(getBaseURI() + "/context/request/etag");
+        postMethod.addRequestHeader("If-None-Match", "\"austin\", " + setETag
+                + " , \"powers\"");
+        try {
+            /*
+             * verifies that a request without an If-None-Match header will
+             * still proceed
+             */
+            client.executeMethod(postMethod);
+            assertEquals(412, postMethod.getStatusCode());
+            assertEquals(setETag, getMethod.getResponseHeader("ETag")
+                    .getValue());
+        } finally {
+            postMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with no request
+     * headers sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantNoHeaders() throws HttpException, IOException,
+            JAXBException {
+        HttpClient client = new HttpClient();
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly/");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+            assertNull(getMethod.getResponseHeader("Vary"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with Accept:
+     * text/xml request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptOnlyXMLHeaders() throws HttpException,
+            IOException, JAXBException {
+        HttpClient client = new HttpClient();
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept", "text/xml");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            Unmarshaller unmarshaller = JAXBContext.newInstance(
+                    "jaxrs.tests.context.request.server").createUnmarshaller();
+            Variant v = (Variant) unmarshaller.unmarshal(getMethod
+                    .getResponseBodyAsStream());
+            assertNotNull(v);
+            assertEquals("text/xml", v.getMediatype());
+            assertEquals("text/xml", getMethod
+                    .getResponseHeader("Content-Type").getValue());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with Accept:
+     * application/json request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptOnlyJSONHeaders() throws HttpException,
+            IOException, JAXBException {
+        HttpClient client = new HttpClient();
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept", "application/json");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertEquals("application/json", getMethod
+                    .getResponseBodyAsString());
+            assertEquals("application/json", getMethod.getResponseHeader(
+                    "Content-Type").getValue());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * application/json;q=0.2,text/xml;q=0.8" request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptPreferXMLOverJSONHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept",
+                "application/json;q=0.2 , text/xml;q=0.8");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            Unmarshaller unmarshaller = JAXBContext.newInstance(
+                    "jaxrs.tests.context.request.server").createUnmarshaller();
+            Variant v = (Variant) unmarshaller.unmarshal(getMethod
+                    .getResponseBodyAsStream());
+            assertNotNull(v);
+            assertEquals("text/xml", v.getMediatype());
+            assertEquals("text/xml", getMethod
+                    .getResponseHeader("Content-Type").getValue());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * application/json;q=0.8,text/xml;q=0.2" request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptPreferJSONOverXMLHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept",
+                "application/json;q=0.8 , text/xml;q=0.2");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertEquals("application/json", getMethod
+                    .getResponseBodyAsString());
+            assertEquals("application/json", getMethod.getResponseHeader(
+                    "Content-Type").getValue());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * application/json;q=0.8,text/xml;q=0.2" request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptPreferJSONImplicitlyOverXMLHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept",
+                "application/json , text/xml;q=0.2");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertEquals("application/json", getMethod
+                    .getResponseBodyAsString());
+            assertEquals("application/json", getMethod.getResponseHeader(
+                    "Content-Type").getValue());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * text/wildcard , text/xml;q=0.2" request header sent. This is not a real
+     * world condition but just to make sure that text/wildcard does not cause
+     * problems.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptPreferTextWildcardOverTextXMLHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+
+        getMethod.setRequestHeader("Accept", "text/* , text/xml;q=0.2");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+            assertTrue(getMethod.getResponseBodyAsString().contains("text"));
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * text/*;q=0.2,text/xml;q=0.8" request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptPreferTextXMLOverTextWildcardHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept", "text/*;q=0.2,text/xml;q=0.8");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            Unmarshaller unmarshaller = JAXBContext.newInstance(
+                    "jaxrs.tests.context.request.server").createUnmarshaller();
+            Variant v = (Variant) unmarshaller.unmarshal(getMethod
+                    .getResponseBodyAsStream());
+            assertNotNull(v);
+            assertEquals("text/xml", v.getMediatype());
+            assertEquals("text/xml", getMethod
+                    .getResponseHeader("Content-Type").getValue());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * text/*;q=0.2,text/xml;q=0.8,text/html;q=0.9" request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptPreferTextHTMLOverMultipleTextSubtypesHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept",
+                "text/*;q=0.2,text/xml;q=0.8,text/html;q=0.9");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertEquals("text/html", getMethod.getResponseBodyAsString());
+            assertEquals("text/html", getMethod.getResponseHeader(
+                    "Content-Type").getValue());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * text/*;q=0.2,text/plain; q=.95, text/xml;q=0.8,text/html;q=0.9" request
+     * header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptPreferTextPlainOverMultipleTextSubtypesHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod
+                .setRequestHeader("Accept",
+                        "text/*;q=0.2,text/plain; q=.95, text/xml;q=0.8,text/html;q=0.9");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertEquals("text/*", getMethod.getResponseBodyAsString());
+            assertEquals("text/plain", getMethod.getResponseHeader(
+                    "Content-Type").getValue());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * application/* , text/xml;q=0.2" request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptPreferApplicationWildcardOverTextXMLHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept", "application/* , text/xml;q=0.2");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertEquals("application/json", getMethod
+                    .getResponseBodyAsString());
+            /*
+             * This is fine as an octet-stream
+             */
+            assertEquals("application/octet-stream", getMethod
+                    .getResponseHeader("Content-Type").getValue());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * application/*;q=0.2 , text/xml;q=0.2" request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptEqualApplicationWildcardWithTextXMLHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept",
+                "application/*;q=0.2, text/xml;q=0.2");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            if ("application/octet-stream".equals(getMethod.getResponseHeader(
+                    "Content-Type").getValue())) {
+                assertEquals("application/json", getMethod
+                        .getResponseBodyAsString());
+                assertEquals("application/octet-stream", getMethod
+                        .getResponseHeader("Content-Type").getValue());
+            } else {
+                Unmarshaller unmarshaller = JAXBContext.newInstance(
+                        "jaxrs.tests.context.request.server")
+                        .createUnmarshaller();
+                Variant v = (Variant) unmarshaller.unmarshal(getMethod
+                        .getResponseBodyAsStream());
+                assertNotNull(v);
+                assertEquals("text/xml", v.getMediatype());
+                assertEquals("text/xml", getMethod.getResponseHeader(
+                        "Content-Type").getValue());
+
+                String value = getMethod.getResponseHeader("Vary").getValue();
+                assertNotNull(value);
+                assertEquals("Accept", value);
+            }
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * application/*;q=0.2 , abcd/efgh;q=0.2" request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptApplicationWildcardWithWeirdTypeHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept",
+                "application/*;q=0.2 , abcd/efgh;q=0.2");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertEquals("application/json", getMethod
+                    .getResponseBodyAsString());
+            /*
+             * this is correct because the Request does not know about abcd/efgh
+             */
+            assertEquals("abcd/efgh", getMethod.getResponseHeader(
+                    "Content-Type").getValue());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * application/*;q=0.2 , abcd/efgh;q=0.9" request header sent. This should
+     * result in application/json being returned because the variant list does
+     * not have abcd/efgh and only application/json matches
+     * application/wildcard.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptPreferWeirdTypeOverApplicationWildcardHeaders()
+            throws HttpException, IOException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept",
+                "application/*;q=0.2 , abcd/efgh;q=0.9");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertEquals("application/json", getMethod
+                    .getResponseBodyAsString());
+            assertEquals("abcd/efgh", getMethod.getResponseHeader(
+                    "Content-Type").getValue());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with "Accept:
+     * abcd/efgh;q=0.9" request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptWeirdUnsupportedTypeHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptonly");
+        getMethod.setRequestHeader("Accept", "abcd/efgh;q=0.9");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+            /*
+             * a "random" content-type is expected back
+             */
+            assertNotNull(getMethod.getResponseHeader("Content-Type")
+                    .getValue());
+            assertNull(getMethod.getResponseHeader("Vary"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with no request
+     * headers sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptLanguageNoHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptlanguageonly");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertNull(getMethod.getResponseHeader("Vary"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Language: en" request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptLanguagePreferEnglishHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptlanguageonly");
+        getMethod.setRequestHeader("Accept-Language", "en");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("en", getMethod.getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept-Language", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Language: en-US" request header sent. This should result in a
+     * random variant returned since there is no exact match.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptLanguageNotExpectedLanguageHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptlanguageonly");
+        getMethod.setRequestHeader("Accept-Language", "en-US");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertNull(getMethod.getResponseHeader("Vary"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Language: *" request header sent. This should result in a random
+     * variant being returned.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptLanguageWildcardHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptlanguageonly");
+        getMethod.setRequestHeader("Accept-Language", "*");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept-Language", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Language: de" request header sent. This should result in de being
+     * returned.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptLanguagePreferGermanHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptlanguageonly");
+        getMethod.setRequestHeader("Accept-Language", "de");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("de", getMethod.getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept-Language", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Language: de;q=0.8,en;q=0.2" request header sent. This should
+     * result in German language being returned.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptLanguagePreferGermanOverEnglishHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptlanguageonly");
+        getMethod.setRequestHeader("Accept-Language", "de;q=0.8,en;q=0.2");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("de", getMethod.getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept-Language", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Language: de;q=0.2,en;q=0.8" request header sent. This should
+     * result in English language being returned.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptLanguagePreferEnglishOverGermanHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptlanguageonly");
+        getMethod.setRequestHeader("Accept-Language", "de;q=0.2,en;q=0.8");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("en", getMethod.getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept-Language", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with no request
+     * headers sent. This should result in a random variation returned.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptTypeAcceptLanguageNoHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptmultiple");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertNull(getMethod.getResponseHeader("Vary"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)}. This should
+     * result in English language being returned with application/json.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptTypeAcceptLanguageEnglishJSONHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptmultiple");
+        getMethod.setRequestHeader("Accept", "application/json");
+        getMethod.setRequestHeader("Accept-Language", "en");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("application/json-en-compress", getMethod
+                    .getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertTrue(value.contains("Accept"));
+            assertTrue(value.contains("Accept-Language"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)}. This should
+     * result in English language being returned with application/json in gzip
+     * encoding.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptTypeAcceptLanguageEnglishJSONGzipHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptmultiple");
+        getMethod.setRequestHeader("Accept", "application/json");
+        getMethod.setRequestHeader("Accept-Language", "en");
+        getMethod.setRequestHeader("Accept-Encoding", "gzip");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+
+            assertEquals("application/json-en-gzip", getMethod
+                    .getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertTrue(value.contains("Accept"));
+            assertTrue(value.contains("Accept-Language"));
+            assertTrue(value.contains("Accept-Encoding"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)}. This should
+     * result in English language being returned with text/html.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptTypeAcceptLanguageEnglishWeirdTypeHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptmultiple");
+        getMethod.setRequestHeader("Accept", "efgh/abcd");
+        getMethod.setRequestHeader("Accept-Language", "en");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            String content = getMethod.getResponseBodyAsString();
+            // assertTrue(content, content.contains("efgh/abcd"));
+            assertTrue(content, content.contains("en"));
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertTrue(value.contains("Accept"));
+            assertTrue(value.contains("Accept-Language"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)}. This should
+     * result in English language being returned with text/html with compress
+     * encoding.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptTypeAcceptLanguageEnglishAcceptEncodingCompressWeirdTypeHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptmultiple");
+        getMethod.setRequestHeader("Accept", "efgh/abcd");
+        getMethod.setRequestHeader("Accept-Language", "en");
+        getMethod.setRequestHeader("Accept-Encoding", "compress");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            String content = getMethod.getResponseBodyAsString();
+            // assertTrue(content, content.contains("efgh/abcd"));
+            assertTrue(content, content.contains("en"));
+            assertTrue(content, content.contains("compress"));
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertTrue(value.contains("Accept"));
+            assertTrue(value.contains("Accept-Language"));
+            assertTrue(value.contains("Accept-Encoding"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)}. This should
+     * result in German language being returned with application/json with gzip
+     * encoding.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantMultipleAcceptTypeAcceptEncodingAcceptLanguageTypeHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptmultiple");
+        getMethod.setRequestHeader("Accept",
+                "text/xml;q=0.5, application/json;q=0.8, */*;q=0.2");
+        getMethod.setRequestHeader("Accept-Language", "en;q=0.2,de;q=0.8");
+        getMethod.setRequestHeader("Accept-Encoding", "compress;q=0.8,gzip");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+
+            assertEquals("application/json-de-gzip", getMethod
+                    .getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertTrue(value.contains("Accept"));
+            assertTrue(value.contains("Accept-Language"));
+            assertTrue(value.contains("Accept-Encoding"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with no request
+     * headers sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptEncodingNoHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptencodingonly");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertNull(getMethod.getResponseHeader("Vary"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Encoding: compress" request header sent.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptEncodingPreferCompressHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptencodingonly");
+        getMethod.setRequestHeader("Accept-Encoding", "compress");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("compress", getMethod.getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept-Encoding", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Encoding: abcdefg" request header sent. This should result in a
+     * random variant returned since there is no exact match.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptEncodingNotExpectedEncodingHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptencodingonly");
+        getMethod.setRequestHeader("Accept-Encoding", "abcdefg");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            assertNull(getMethod.getResponseHeader("Vary"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Language: *" request header sent. This should result in German
+     * being returned.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptEncodingWildcardHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptlanguageonly");
+        getMethod.setRequestHeader("Accept-Encoding", "*");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertNotNull(getMethod.getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept-Encoding", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Encoding: gzip" request header sent. This should result in a gzip
+     * encoding returned.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptEncodingPreferGzip()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptencodingonly");
+        getMethod.setRequestHeader("Accept-Encoding", "gzip");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("gzip", getMethod.getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept-Encoding", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Encoding: compress;q=0.2,gzip;q=0.8" request header sent. This
+     * should result in gzip being returned.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptEncodingPreferGzipOverCompressHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptencodingonly");
+        getMethod.setRequestHeader("Accept-Encoding",
+                "compress;q=0.2,gzip;q=0.8");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("gzip", getMethod.getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept-Encoding", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Request#selectVariant(java.util.List)} with
+     * "Accept-Encoding: compress;q=0.8,gzip;q=0.2" request header sent. This
+     * should result in compress being returned.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testSelectVariantAcceptEncodingPreferCompressOverGzipHeaders()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/acceptencodingonly");
+        getMethod.setRequestHeader("Accept-Encoding",
+                "compress;q=0.8,gzip;q=0.2");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            assertEquals("compress", getMethod.getResponseBodyAsString());
+
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertEquals("Accept-Encoding", value);
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link ResponseBuilder#variants(java.util.List)} would override
+     * the Vary header set by{@link Request#selectVariant(java.util.List)}.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testResponseBuilderVariantsOverrideSelectVariants()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/responsebuilder");
+        getMethod.setRequestHeader("Accept", "text/plain");
+        getMethod.setRequestHeader("Accept-Language", "en");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertTrue(value, value.contains("Accept"));
+            assertTrue(value, value.contains("Accept-Language"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/responsebuilder?type=variants");
+        getMethod.setRequestHeader("Accept", "text/xml");
+        getMethod.setRequestHeader("Accept-Language", "en");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertTrue(value, value.contains("Accept-Language"));
+            assertTrue(value, value.contains("Accept-Encoding"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    /**
+     * Tests the {@link Response#notAcceptable(java.util.List)} would override
+     * the Vary header set by{@link Request#selectVariant(java.util.List)}.
+     *
+     * @throws HttpException
+     * @throws IOException
+     * @throws JAXBException
+     */
+    public void testResponseBuilderNotAcceptableVariantsOverrideSelectVariants()
+            throws HttpException, IOException, JAXBException {
+        HttpClient client = new HttpClient();
+
+        GetMethod getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/responsebuilder");
+        getMethod.setRequestHeader("Accept", "text/plain");
+        getMethod.setRequestHeader("Accept-Language", "en");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(200, getMethod.getStatusCode());
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertTrue(value, value.contains("Accept"));
+            assertTrue(value, value.contains("Accept-Language"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+
+        getMethod = new GetMethod(getBaseURI()
+                + "/context/request/variant/responsebuilder?type=notacceptable");
+        getMethod.setRequestHeader("Accept", "text/xml");
+        getMethod.setRequestHeader("Accept-Language", "en");
+        try {
+            client.executeMethod(getMethod);
+            assertEquals(406, getMethod.getStatusCode());
+            String value = getMethod.getResponseHeader("Vary").getValue();
+            assertNotNull(value);
+            assertTrue(value, value.contains("Accept"));
+            assertTrue(value, value.contains("Accept-Encoding"));
+        } finally {
+            getMethod.releaseConnection();
+        }
+    }
+
+    //
+    // public void testSelectVariantThenDoAnotherEvaluatePrecondition() {
+    // fail();
+    // /*
+    // * should check about Vary header
+    // */
+    // }
+}

Added: incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/securitycontext/buildTest.xml
URL: http://svn.apache.org/viewvc/incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/securitycontext/buildTest.xml?rev=787553&view=auto
==============================================================================
--- incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/securitycontext/buildTest.xml (added)
+++ incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/securitycontext/buildTest.xml Tue Jun 23 05:37:57 2009
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements. See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership. The ASF licenses this file
+  ~ to you 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.
+  -->
+
+<project name="jaxrs.tests.context.securitycontext" default="all">
+	<import file="../../../../buildCommon.xml" />
+</project>

Added: incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/securitycontext/server/Application.java
URL: http://svn.apache.org/viewvc/incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/securitycontext/server/Application.java?rev=787553&view=auto
==============================================================================
--- incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/securitycontext/server/Application.java (added)
+++ incubator/wink/contrib/ibm-jaxrs/tests/fvt/jaxrs/tests/context/securitycontext/server/Application.java Tue Jun 23 05:37:57 2009
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 jaxrs.tests.context.securitycontext.server;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Application extends javax.ws.rs.core.Application {
+
+    @Override
+    public Set<Class<?>> getClasses() {
+        Set<Class<?>> clazzes = new HashSet<Class<?>>();
+        clazzes.add(SecurityContextBeanResource.class);
+        clazzes.add(SecurityContextConstructorResource.class);
+        clazzes.add(SecurityContextFieldResource.class);
+        clazzes.add(SecurityContextNotBeanMethodResource.class);
+        clazzes.add(SecurityContextParamResource.class);
+        return clazzes;
+    }
+
+}



Mime
View raw message