Example usage for org.apache.http.client.utils HttpClientUtils closeQuietly

List of usage examples for org.apache.http.client.utils HttpClientUtils closeQuietly

  1. HOME
  2. Java
  3. org.apache.http
  4. org.apache.http.client.utils.*
  5. HttpClientUtils
  6. closeQuietly

Introduction

In this page you can find the example usage for org.apache.http.client.utils HttpClientUtils closeQuietly.

Prototype

public static void closeQuietly(final HttpClient httpClient)

Source Link

Document

Unconditionally close a httpClient.

Usage

From source file:org.jboss.as.test.clustering.cluster.web.authentication.FormAuthenticationWebFailoverTestCase.java

@Test
public void test(@ArquillianResource(SecureServlet.class) @OperateOnDeployment(DEPLOYMENT_1) URL baseURL1,
        @ArquillianResource(SecureServlet.class) @OperateOnDeployment(DEPLOYMENT_2) URL baseURL2)
        throws IOException, URISyntaxException {

    URI uri1 = SecureServlet.createURI(baseURL1);
    URI uri2 = SecureServlet.createURI(baseURL2);

    try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) {
        HttpResponse response = client.execute(new HttpGet(uri1));
        try {/*  w w w  .  ja  va2s.co m*/
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertNull(response.getFirstHeader(SecureServlet.SESSION_ID_HEADER));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        HttpPost login = new HttpPost(baseURL1.toURI().resolve("j_security_check"));

        List<NameValuePair> pairs = new ArrayList<>(2);
        pairs.add(new BasicNameValuePair("j_username", "allowed"));
        pairs.add(new BasicNameValuePair("j_password", "password"));

        login.setEntity(new UrlEncodedFormEntity(pairs, "UTF-8"));
        response = client.execute(login);
        try {
            Assert.assertEquals(HttpServletResponse.SC_FOUND, response.getStatusLine().getStatusCode());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        String sessionId = null;
        response = client.execute(new HttpGet(uri1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertNotNull(response.getFirstHeader(SecureServlet.SESSION_ID_HEADER));
            sessionId = response.getFirstHeader(SecureServlet.SESSION_ID_HEADER).getValue();
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        undeploy(DEPLOYMENT_1);

        response = client.execute(new HttpGet(uri2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(sessionId, response.getFirstHeader(SecureServlet.SESSION_ID_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        deploy(DEPLOYMENT_1);

        response = client.execute(new HttpGet(uri1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(sessionId, response.getFirstHeader(SecureServlet.SESSION_ID_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    }
}

From source file:org.jboss.as.test.clustering.cluster.web.expiration.SessionExpirationTestCase.java

@Test
public void test(
        @ArquillianResource(SessionOperationServlet.class) @OperateOnDeployment(DEPLOYMENT_1) URL baseURL1,
        @ArquillianResource(SessionOperationServlet.class) @OperateOnDeployment(DEPLOYMENT_2) URL baseURL2)
        throws IOException, URISyntaxException, InterruptedException {
    DefaultHttpClient client = org.jboss.as.test.http.util.HttpClientUtils.relaxedCookieHttpClient();
    try {/*from  w  ww . j  a v a 2 s .c  o  m*/
        // This should trigger session creation event, but not added attribute event
        HttpResponse response = client
                .execute(new HttpGet(SessionOperationServlet.createSetURI(baseURL1, "a")));
        try {
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
            Assert.assertEquals(response.getFirstHeader(SessionOperationServlet.SESSION_ID).getValue(),
                    response.getFirstHeader(SessionOperationServlet.CREATED_SESSIONS).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // This should trigger attribute added event and bound binding event
        response = client.execute(new HttpGet(SessionOperationServlet.createSetURI(baseURL1, "a", "1")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.SESSION_ID));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
            Assert.assertEquals("a",
                    response.getFirstHeader(SessionOperationServlet.ADDED_ATTRIBUTES).getValue());
            Assert.assertEquals("1",
                    response.getFirstHeader(SessionOperationServlet.BOUND_ATTRIBUTES).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // No events should have been triggered on remote node
        response = client.execute(new HttpGet(SessionOperationServlet.createGetURI(baseURL2, "a")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.RESULT));
            Assert.assertEquals("1", response.getFirstHeader(SessionOperationServlet.RESULT).getValue());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // Make sure remove attribute event is not fired since attribute does not exist
        response = client.execute(new HttpGet(SessionOperationServlet.createRemoveURI(baseURL2, "b")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.RESULT));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // This should trigger attribute replaced event, as well as valueBound/valueUnbound binding events
        response = client.execute(new HttpGet(SessionOperationServlet.createSetURI(baseURL1, "a", "2")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
            Assert.assertEquals("a",
                    response.getFirstHeader(SessionOperationServlet.REPLACED_ATTRIBUTES).getValue());
            Assert.assertEquals("2",
                    response.getFirstHeader(SessionOperationServlet.BOUND_ATTRIBUTES).getValue());
            Assert.assertEquals("1",
                    response.getFirstHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // No events should have been triggered on remote node
        response = client.execute(new HttpGet(SessionOperationServlet.createGetURI(baseURL2, "a")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.RESULT));
            Assert.assertEquals("2", response.getFirstHeader(SessionOperationServlet.RESULT).getValue());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // This should trigger attribute removed event and valueUnbound binding event
        response = client.execute(new HttpGet(SessionOperationServlet.createSetURI(baseURL1, "a")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
            Assert.assertEquals("a",
                    response.getFirstHeader(SessionOperationServlet.REMOVED_ATTRIBUTES).getValue());
            Assert.assertEquals("2",
                    response.getFirstHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // No events should have been triggered on remote node
        response = client.execute(new HttpGet(SessionOperationServlet.createGetURI(baseURL2, "a")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.RESULT));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // This should trigger attribute added event and valueBound binding event
        response = client.execute(new HttpGet(SessionOperationServlet.createSetURI(baseURL1, "a", "3", "4")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
            Assert.assertEquals("a",
                    response.getFirstHeader(SessionOperationServlet.ADDED_ATTRIBUTES).getValue());
            Assert.assertEquals("3",
                    response.getFirstHeader(SessionOperationServlet.BOUND_ATTRIBUTES).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // No events should have been triggered on remote node
        response = client.execute(new HttpGet(SessionOperationServlet.createGetURI(baseURL2, "a")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.RESULT));
            Assert.assertEquals("4", response.getFirstHeader(SessionOperationServlet.RESULT).getValue());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // This should trigger attribute removed event and valueUnbound binding event
        response = client.execute(new HttpGet(SessionOperationServlet.createRemoveURI(baseURL1, "a")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
            Assert.assertEquals("a",
                    response.getFirstHeader(SessionOperationServlet.REMOVED_ATTRIBUTES).getValue());
            Assert.assertEquals("4",
                    response.getFirstHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // No events should have been triggered on remote node
        response = client.execute(new HttpGet(SessionOperationServlet.createGetURI(baseURL2, "a")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.RESULT));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // This should trigger attribute added event and valueBound binding event
        response = client.execute(new HttpGet(SessionOperationServlet.createSetURI(baseURL2, "a", "5")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.SESSION_ID));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
            Assert.assertEquals("a",
                    response.getFirstHeader(SessionOperationServlet.ADDED_ATTRIBUTES).getValue());
            Assert.assertEquals("5",
                    response.getFirstHeader(SessionOperationServlet.BOUND_ATTRIBUTES).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // This should trigger session destroyed event and valueUnbound binding event
        response = client.execute(new HttpGet(SessionOperationServlet.createInvalidateURI(baseURL1)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.SESSION_ID));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
            Assert.assertEquals(response.getFirstHeader(SessionOperationServlet.SESSION_ID).getValue(),
                    response.getFirstHeader(SessionOperationServlet.DESTROYED_SESSIONS).getValue());
            Assert.assertEquals("a",
                    response.getFirstHeader(SessionOperationServlet.REMOVED_ATTRIBUTES).getValue());
            Assert.assertEquals("5",
                    response.getFirstHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // This should trigger attribute added event and valueBound binding event
        response = client.execute(new HttpGet(SessionOperationServlet.createSetURI(baseURL2, "a", "6")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.SESSION_ID));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
            Assert.assertEquals(response.getFirstHeader(SessionOperationServlet.SESSION_ID).getValue(),
                    response.getFirstHeader(SessionOperationServlet.CREATED_SESSIONS).getValue());
            Assert.assertEquals("a",
                    response.getFirstHeader(SessionOperationServlet.ADDED_ATTRIBUTES).getValue());
            Assert.assertEquals("6",
                    response.getFirstHeader(SessionOperationServlet.BOUND_ATTRIBUTES).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // This should not trigger any events
        response = client.execute(new HttpGet(SessionOperationServlet.createGetURI(baseURL2, "a", "7")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.RESULT));
            Assert.assertEquals("6", response.getFirstHeader(SessionOperationServlet.RESULT).getValue());
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.SESSION_ID));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // This should not trigger any events
        response = client.execute(new HttpGet(SessionOperationServlet.createGetURI(baseURL2, "a")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.RESULT));
            Assert.assertEquals("7", response.getFirstHeader(SessionOperationServlet.RESULT).getValue());
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.SESSION_ID));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // Trigger session timeout in 1 second
        response = client.execute(new HttpGet(SessionOperationServlet.createTimeoutURI(baseURL1, 1)));
        String sessionId = null;
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.RESULT));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.SESSION_ID));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
            sessionId = response.getFirstHeader(SessionOperationServlet.SESSION_ID).getValue();
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // Trigger timeout of sessionId
        Thread.sleep(2000);

        // Timeout should trigger session destroyed event and valueUnbound binding event
        response = client.execute(new HttpGet(SessionOperationServlet.createGetURI(baseURL1, "a")));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.RESULT));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.SESSION_ID));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.CREATED_SESSIONS));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.DESTROYED_SESSIONS));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.ADDED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REPLACED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.REMOVED_ATTRIBUTES));
            Assert.assertFalse(response.containsHeader(SessionOperationServlet.BOUND_ATTRIBUTES));
            Assert.assertTrue(response.containsHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES));
            Assert.assertEquals(sessionId,
                    response.getFirstHeader(SessionOperationServlet.DESTROYED_SESSIONS).getValue());
            Assert.assertEquals(response.getFirstHeader(SessionOperationServlet.SESSION_ID).getValue(),
                    response.getFirstHeader(SessionOperationServlet.CREATED_SESSIONS).getValue());
            Assert.assertEquals("7",
                    response.getFirstHeader(SessionOperationServlet.UNBOUND_ATTRIBUTES).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    } finally {
        HttpClientUtils.closeQuietly(client);
    }
}

From source file:org.jboss.as.test.clustering.cluster.singleton.SingletonTestCase.java

@Test
public void testSingletonService(@ArquillianResource() @OperateOnDeployment(DEPLOYMENT_1) URL baseURL1,
        @ArquillianResource() @OperateOnDeployment(DEPLOYMENT_2) URL baseURL2)
        throws IOException, URISyntaxException {

    // Needed to be able to inject ArquillianResource
    stop(CONTAINER_2);//from   ww w.  j  av a 2  s. c  o  m

    DefaultHttpClient client = org.jboss.as.test.http.util.HttpClientUtils.relaxedCookieHttpClient();

    // URLs look like "http://IP:PORT/singleton/service"
    URI defaultURI1 = MyServiceServlet.createURI(baseURL1, MyService.DEFAULT_SERVICE_NAME);
    URI defaultURI2 = MyServiceServlet.createURI(baseURL2, MyService.DEFAULT_SERVICE_NAME);

    log.info("URLs are: " + defaultURI1 + ", " + defaultURI2);

    URI quorumURI1 = MyServiceServlet.createURI(baseURL1, MyService.QUORUM_SERVICE_NAME);
    URI quorumURI2 = MyServiceServlet.createURI(baseURL2, MyService.QUORUM_SERVICE_NAME);

    try {
        HttpResponse response = client.execute(new HttpGet(defaultURI1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(NODE_1, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(quorumURI1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertNull(response.getFirstHeader("node"));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        start(CONTAINER_2);

        response = client.execute(new HttpGet(defaultURI1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(quorumURI1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(defaultURI2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(quorumURI2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        stop(CONTAINER_2);

        response = client.execute(new HttpGet(defaultURI1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(NODE_1, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(quorumURI1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertNull(response.getFirstHeader("node"));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        start(CONTAINER_2);

        response = client.execute(new HttpGet(defaultURI1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(quorumURI1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(defaultURI2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(quorumURI2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        stop(CONTAINER_1);

        response = client.execute(new HttpGet(defaultURI2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(NODE_2, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(quorumURI2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertNull(response.getFirstHeader("node"));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        start(CONTAINER_1);

        response = client.execute(new HttpGet(defaultURI1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(quorumURI1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(defaultURI2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(quorumURI2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(MyServiceActivator.PREFERRED_NODE, response.getFirstHeader("node").getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    } finally {
        HttpClientUtils.closeQuietly(client);
    }
}

From source file:org.jboss.as.test.clustering.cluster.singleton.SingletonBackupServiceTestCase.java

@Test
public void testSingletonService(
        @ArquillianResource(ValueServiceServlet.class) @OperateOnDeployment(DEPLOYMENT_1) URL baseURL1,
        @ArquillianResource(ValueServiceServlet.class) @OperateOnDeployment(DEPLOYMENT_2) URL baseURL2)
        throws IOException, URISyntaxException {

    // Needed to be able to inject ArquillianResource
    stop(CONTAINER_2);//from  w ww  . j av a2  s  . c om

    try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) {
        HttpResponse response = client.execute(
                new HttpGet(ValueServiceServlet.createURI(baseURL1, ValueServiceActivator.SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals("true", response.getFirstHeader(ValueServiceServlet.PRIMARY_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        start(CONTAINER_2);

        response = client.execute(
                new HttpGet(ValueServiceServlet.createURI(baseURL1, ValueServiceActivator.SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals("true", response.getFirstHeader(ValueServiceServlet.PRIMARY_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(
                new HttpGet(ValueServiceServlet.createURI(baseURL2, ValueServiceActivator.SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals("false",
                    response.getFirstHeader(ValueServiceServlet.PRIMARY_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        stop(CONTAINER_2);

        response = client.execute(
                new HttpGet(ValueServiceServlet.createURI(baseURL1, ValueServiceActivator.SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals("true", response.getFirstHeader(ValueServiceServlet.PRIMARY_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        start(CONTAINER_2);

        response = client.execute(
                new HttpGet(ValueServiceServlet.createURI(baseURL1, ValueServiceActivator.SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals("true", response.getFirstHeader(ValueServiceServlet.PRIMARY_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(
                new HttpGet(ValueServiceServlet.createURI(baseURL2, ValueServiceActivator.SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals("false",
                    response.getFirstHeader(ValueServiceServlet.PRIMARY_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        stop(CONTAINER_1);

        response = client.execute(
                new HttpGet(ValueServiceServlet.createURI(baseURL2, ValueServiceActivator.SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals("true", response.getFirstHeader(ValueServiceServlet.PRIMARY_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        start(CONTAINER_1);

        response = client.execute(
                new HttpGet(ValueServiceServlet.createURI(baseURL1, ValueServiceActivator.SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals("false",
                    response.getFirstHeader(ValueServiceServlet.PRIMARY_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(
                new HttpGet(ValueServiceServlet.createURI(baseURL2, ValueServiceActivator.SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals("true", response.getFirstHeader(ValueServiceServlet.PRIMARY_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    }
}

From source file:com.seyren.core.service.notification.HipChatNotificationService.java

private void sendMessage(String message, MessageColor color, String[] roomIds, String from, String authToken,
        boolean notify) {
    for (String roomId : roomIds) {
        LOGGER.info("Posting: {} to {}: {} {}", from, roomId, message, color);
        HttpClient client = HttpClientBuilder.create().useSystemProperties().build();
        String url = baseUrl + "/v2/room/" + roomId + "/notification?auth_token=" + authToken;
        HttpPost post = new HttpPost(url);

        try {/*from   www.  j  a v  a2 s .  co m*/
            List<BasicNameValuePair> parameters = new ArrayList<BasicNameValuePair>();
            parameters.add(new BasicNameValuePair("message", message));
            parameters.add(new BasicNameValuePair("color", color.name().toLowerCase()));
            parameters.add(new BasicNameValuePair("message_format", "html"));
            if (notify) {
                parameters.add(new BasicNameValuePair("notify", "true"));
            }
            post.setEntity(new UrlEncodedFormEntity(parameters));
            client.execute(post);
        } catch (Exception e) {
            LOGGER.warn("Error posting to HipChat", e);
        } finally {
            post.releaseConnection();
            HttpClientUtils.closeQuietly(client);
        }
    }
}

From source file:com.flipkart.flux.client.runtime.FluxRuntimeConnectorHttpImpl.java

@Override
public void submitEvent(EventData eventData, Long stateMachineId) {
    CloseableHttpResponse httpResponse = null;
    try {/*from  w w  w  .  ja  va2 s  .  c  o m*/
        httpResponse = postOverHttp(eventData, "/" + stateMachineId + "/context/events");
    } finally {
        HttpClientUtils.closeQuietly(httpResponse);
    }
}

From source file:com.jive.myco.seyren.core.service.notification.HipChatNotificationService.java

private void sendMessage(String message, MessageColor color, String[] roomIds, String from, String authToken,
        boolean notify) {
    for (String roomId : roomIds) {
        LOGGER.info("Posting: {} to {}: {} {}", from, roomId, message, color);
        HttpClient client = HttpClientBuilder.create().build();
        String url = baseUrl + "/v1/rooms/message";
        HttpPost post = new HttpPost(url);

        try {/*from  ww w .  j a v a 2 s. co m*/
            List<BasicNameValuePair> parameters = new ArrayList<BasicNameValuePair>();
            parameters.add(new BasicNameValuePair("auth_token", authToken));
            parameters.add(new BasicNameValuePair("from", from));
            parameters.add(new BasicNameValuePair("room_id", roomId));
            parameters.add(new BasicNameValuePair("message", message));
            parameters.add(new BasicNameValuePair("color", color.name().toLowerCase()));
            if (notify) {
                parameters.add(new BasicNameValuePair("notify", "1"));
            }
            post.setEntity(new UrlEncodedFormEntity(parameters));
            client.execute(post);
        } catch (Exception e) {
            LOGGER.warn("Error posting to HipChat", e);
        } finally {
            post.releaseConnection();
            HttpClientUtils.closeQuietly(client);
        }
    }
}

From source file:org.apache.vxquery.rest.AbstractRestServerTest.java

/**
 * Submit a {@link QueryRequest} and fetth the resulting
 * {@link AsyncQueryResponse}//  ww w.j a v a2  s . c  o  m
 *
 * @param uri
 *            uri of the GET request
 * @param accepts
 *            application/json | application/xml
 * @param method
 *            Http Method to be used to send the request
 * @return Response received for the query request
 * @throws Exception
 */
protected static <T> T getQuerySuccessResponse(URI uri, String accepts, Class<T> type, String method)
        throws Exception {
    CloseableHttpClient httpClient = HttpClients.custom().setConnectionTimeToLive(20, TimeUnit.SECONDS).build();

    try {
        HttpUriRequest request = getRequest(uri, method);

        if (accepts != null) {
            request.setHeader(HttpHeaders.ACCEPT, accepts);
        }

        try (CloseableHttpResponse httpResponse = httpClient.execute(request)) {
            Assert.assertEquals(HttpResponseStatus.OK.code(), httpResponse.getStatusLine().getStatusCode());
            if (accepts != null) {
                Assert.assertEquals(accepts, httpResponse.getFirstHeader(HttpHeaders.CONTENT_TYPE).getValue());
            }

            HttpEntity entity = httpResponse.getEntity();
            Assert.assertNotNull(entity);

            String response = RestUtils.readEntity(entity);
            return RestUtils.mapEntity(response, type, accepts);
        }
    } finally {
        HttpClientUtils.closeQuietly(httpClient);
    }
}

From source file:org.jboss.as.test.clustering.cluster.web.shared.SharedSessionFailoverTestCase.java

@Test
public void test(@ArquillianResource(SimpleServlet.class) @OperateOnDeployment(DEPLOYMENT_1) URL baseURL1,
        @ArquillianResource(SimpleServlet.class) @OperateOnDeployment(DEPLOYMENT_2) URL baseURL2)
        throws URISyntaxException, IOException {

    URI uri11 = SimpleServlet.createURI(baseURL1.toURI().resolve(MODULE_1).toURL());
    URI uri12 = SimpleServlet.createURI(baseURL1.toURI().resolve(MODULE_2).toURL());
    URI uri21 = SimpleServlet.createURI(baseURL2.toURI().resolve(MODULE_1).toURL());
    URI uri22 = SimpleServlet.createURI(baseURL2.toURI().resolve(MODULE_2).toURL());

    try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) {
        HttpResponse response = client.execute(new HttpGet(uri11));
        try {//  w w w .  j a va2s  .  c  o  m
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(1,
                    Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(uri12));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(2,
                    Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(uri21));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(3,
                    Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(uri22));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(4,
                    Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    }
}