import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public AsyncHandler.State onStatusReceived(final HttpResponseStatus status) throws Exception {
    responseBuilder.accumulate(status);
    if (status.getStatusCode() == 200 || status.getStatusCode() == 206) {
        url = status.getUri().toUrl();
    } else {
        return AsyncHandler.State.ABORT;
    }

    if (decoratedAsyncHandler != null) {
        return decoratedAsyncHandler.onStatusReceived(status);
    }

    return AsyncHandler.State.CONTINUE;
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
@Test
public void testOnStatusReceivedOkStatusWithDecoratedAsyncHandler() throws Exception {
    HttpResponseStatus mockResponseStatus = mock(HttpResponseStatus.class);
    when(mockResponseStatus.getStatusCode()).thenReturn(200);
    when(mockResponseStatus.getUri()).thenReturn(mock(Uri.class));

    @SuppressWarnings("unchecked")
    AsyncHandler<Response> decoratedAsyncHandler = mock(AsyncHandler.class);
    State mockState = mock(State.class);
    when(decoratedAsyncHandler.onStatusReceived(mockResponseStatus)).thenReturn(mockState);

    ResumableAsyncHandler handler = new ResumableAsyncHandler(decoratedAsyncHandler);

    State state = handler.onStatusReceived(mockResponseStatus);
    verify(decoratedAsyncHandler).onStatusReceived(mockResponseStatus);
    assertEquals(state, mockState, "State returned should be equal to the one returned from decoratedAsyncHandler");
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
@Test
public void testOnBodyPartReceivedWithDecoratedAsyncHandler() throws Exception {
    HttpResponseBodyPart bodyPart = PowerMockito.mock(HttpResponseBodyPart.class);
    when(bodyPart.getBodyPartBytes()).thenReturn(new byte[0]);
    ByteBuffer buffer = ByteBuffer.allocate(0);
    when(bodyPart.getBodyByteBuffer()).thenReturn(buffer);

    @SuppressWarnings("unchecked")
    AsyncHandler<Response> decoratedAsyncHandler = mock(AsyncHandler.class);
    State mockState = mock(State.class);
    when(decoratedAsyncHandler.onBodyPartReceived(bodyPart)).thenReturn(mockState);

    // following is needed to set the url variable
    HttpResponseStatus mockResponseStatus = mock(HttpResponseStatus.class);
    when(mockResponseStatus.getStatusCode()).thenReturn(200);
    Uri mockUri = mock(Uri.class);
    when(mockUri.toUrl()).thenReturn("http://non.null");
    when(mockResponseStatus.getUri()).thenReturn(mockUri);

    ResumableAsyncHandler handler = new ResumableAsyncHandler(decoratedAsyncHandler);
    handler.onStatusReceived(mockResponseStatus);

    State state = handler.onBodyPartReceived(bodyPart);
    assertEquals(state, mockState, "State should be equal to the state returned from decoratedAsyncHandler");

}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
public UpgradeCallback(NettyResponseFuture<?> future, Channel channel, HttpResponse response, WebSocketUpgradeHandler handler, HttpResponseStatus status,
        HttpResponseHeaders responseHeaders) {
    super(future);
    this.channel = channel;
    this.response = response;
    this.handler = handler;
    this.status = status;
    this.responseHeaders = responseHeaders;
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
public boolean exitAfterIntercept(//
        Channel channel,//
        NettyResponseFuture<?> future,//
        AsyncHandler<?> handler,//
        HttpResponse response,//
        HttpResponseStatus status,//
        HttpResponseHeaders responseHeaders) throws Exception {

    HttpRequest httpRequest = future.getNettyRequest().getHttpRequest();
    ProxyServer proxyServer = future.getProxyServer();
    int statusCode = response.getStatus().code();
    Request request = future.getCurrentRequest();
    Realm realm = request.getRealm() != null ? request.getRealm() : config.getRealm();

    if (hasResponseFilters && responseFiltersInterceptor.exitAfterProcessingFilters(channel, future, handler, status, responseHeaders)) {
        return true;
    }

    if (statusCode == UNAUTHORIZED_401) {
        return unauthorized401Interceptor.exitAfterHandling401(channel, future, response, request, statusCode, realm, proxyServer, httpRequest);

    } else if (statusCode == PROXY_AUTHENTICATION_REQUIRED_407) {
        return proxyUnauthorized407Interceptor.exitAfterHandling407(channel, future, response, request, statusCode, proxyServer, httpRequest);

    } else if (statusCode == CONTINUE_100) {
        return continue100Interceptor.exitAfterHandling100(channel, future, statusCode);

    } else if (Redirect30xInterceptor.REDIRECT_STATUSES.contains(statusCode)) {
        return redirect30xInterceptor.exitAfterHandlingRedirect(channel, future, response, request, statusCode, realm);

    } else if (httpRequest.getMethod() == HttpMethod.CONNECT && statusCode == OK_200) {
        return connectSuccessInterceptor.exitAfterHandlingConnect(channel, future, request, proxyServer, statusCode, httpRequest);

    }
    return false;
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
public boolean exitAfterProcessingFilters(//
        Channel channel,//
        NettyResponseFuture<?> future,//
        AsyncHandler<?> handler, //
        HttpResponseStatus status,//
        HttpResponseHeaders responseHeaders) {

    FilterContext fc = new FilterContext.FilterContextBuilder().asyncHandler(handler).request(future.getCurrentRequest()).responseStatus(status)
            .responseHeaders(responseHeaders).build();

    for (ResponseFilter asyncFilter : config.getResponseFilters()) {
        try {
            fc = asyncFilter.filter(fc);
            // FIXME Is it worth protecting against this?
            assertNotNull("fc", "filterContext");
        } catch (FilterException efe) {
            requestSender.abort(channel, future, efe);
        }
    }

    // The handler may have been wrapped.
    future.setAsyncHandler(fc.getAsyncHandler());

    // The request has changed
    if (fc.replayRequest()) {
        requestSender.replayRequest(future, fc, channel);
        return true;
    }
    return false;
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
public NettyResponse(HttpResponseStatus status,//
        HttpResponseHeaders headers,//
        List<HttpResponseBodyPart> bodyParts) {
    this.bodyParts = bodyParts;
    this.headers = headers;
    this.status = status;
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
@Test(groups = "standalone")
public void zeroCopyFileTest() throws IOException, ExecutionException, TimeoutException, InterruptedException, URISyntaxException {
    File tmp = new File(System.getProperty("java.io.tmpdir") + File.separator + "zeroCopy.txt");
    tmp.deleteOnExit();
    try (AsyncHttpClient client = asyncHttpClient()) {
        try (FileOutputStream stream = new FileOutputStream(tmp)) {
            Response resp = client.preparePost("http://localhost:" + port1 + "/").setBody(SIMPLE_TEXT_FILE).execute(new AsyncHandler<Response>() {
                public void onThrowable(Throwable t) {
                }

                public State onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {
                    stream.write(bodyPart.getBodyPartBytes());
                    return State.CONTINUE;
                }

                public State onStatusReceived(HttpResponseStatus responseStatus) throws Exception {
                    return State.CONTINUE;
                }

                public State onHeadersReceived(HttpResponseHeaders headers) throws Exception {
                    return State.CONTINUE;
                }

                public Response onCompleted() throws Exception {
                    return null;
                }
            }).get();
            assertNull(resp);
            assertEquals(SIMPLE_TEXT_FILE.length(), tmp.length());
        }
    }
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
@Test(groups = "standalone")
public void zeroCopyFileWithBodyManipulationTest() throws IOException, ExecutionException, TimeoutException, InterruptedException, URISyntaxException {
    File tmp = new File(System.getProperty("java.io.tmpdir") + File.separator + "zeroCopy.txt");
    tmp.deleteOnExit();
    try (AsyncHttpClient client = asyncHttpClient()) {
        try (FileOutputStream stream = new FileOutputStream(tmp)) {
            Response resp = client.preparePost("http://localhost:" + port1 + "/").setBody(SIMPLE_TEXT_FILE).execute(new AsyncHandler<Response>() {
                public void onThrowable(Throwable t) {
                }

                public State onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {
                    stream.write(bodyPart.getBodyPartBytes());

                    if (bodyPart.getBodyPartBytes().length == 0) {
                        return State.ABORT;
                    }

                    return State.CONTINUE;
                }

                public State onStatusReceived(HttpResponseStatus responseStatus) throws Exception {
                    return State.CONTINUE;
                }

                public State onHeadersReceived(HttpResponseHeaders headers) throws Exception {
                    return State.CONTINUE;
                }

                public Response onCompleted() throws Exception {
                    return null;
                }
            }).get();
            assertNull(resp);
            assertEquals(SIMPLE_TEXT_FILE.length(), tmp.length());
        }
    }
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
@Test
public void testOnStatusReceivedOkStatus() throws Exception {
    MapResumableProcessor processor = new MapResumableProcessor();
    ResumableAsyncHandler handler = new ResumableAsyncHandler(processor);
    HttpResponseStatus responseStatus200 = mock(HttpResponseStatus.class);
    when(responseStatus200.getStatusCode()).thenReturn(200);
    when(responseStatus200.getUri()).thenReturn(mock(Uri.class));
    State state = handler.onStatusReceived(responseStatus200);
    assertEquals(state, AsyncHandler.State.CONTINUE, "Status should be CONTINUE for a OK response");
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
@Test
public void testOnStatusReceived206Status() throws Exception {
    MapResumableProcessor processor = new MapResumableProcessor();
    ResumableAsyncHandler handler = new ResumableAsyncHandler(processor);
    HttpResponseStatus responseStatus206 = mock(HttpResponseStatus.class);
    when(responseStatus206.getStatusCode()).thenReturn(206);
    when(responseStatus206.getUri()).thenReturn(mock(Uri.class));
    State state = handler.onStatusReceived(responseStatus206);
    assertEquals(state, AsyncHandler.State.CONTINUE, "Status should be CONTINUE for a 'Partial Content' response");
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
@Test
public void testOnStatusReceived500Status() throws Exception{
    MapResumableProcessor processor = new MapResumableProcessor();
    ResumableAsyncHandler handler = new ResumableAsyncHandler(processor);
    HttpResponseStatus mockResponseStatus = mock(HttpResponseStatus.class);
    when(mockResponseStatus.getStatusCode()).thenReturn(500);
    when(mockResponseStatus.getUri()).thenReturn(mock(Uri.class));
    State state = handler.onStatusReceived(mockResponseStatus);
    assertEquals(state, AsyncHandler.State.ABORT, "State should be ABORT for Internal Server Error status");
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
@Override
public void transactionMarker() throws Exception {
    AsyncHttpClient asyncHttpClient = new DefaultAsyncHttpClient();
    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicInteger statusCode = new AtomicInteger();
    asyncHttpClient.prepareGet("http://localhost:" + getPort() + "/hello3/")
            .execute(new AsyncHandler<Response>() {
                @Override
                public State onBodyPartReceived(HttpResponseBodyPart part) {
                    return null;
                }
                @Override
                public Response onCompleted() throws Exception {
                    latch.countDown();
                    return null;
                }
                @Override
                public State onHeadersReceived(HttpResponseHeaders headers) {
                    return null;
                }
                @Override
                public State onStatusReceived(HttpResponseStatus status) {
                    statusCode.set(status.getStatusCode());
                    return null;
                }
                @Override
                public void onThrowable(Throwable t) {}
            });
    latch.await();
    asyncHttpClient.close();
    if (statusCode.get() != 200) {
        throw new IllegalStateException("Unexpected status code: " + statusCode);
    }
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
@Override
public State onStatusReceived(HttpResponseStatus status) throws Exception {
    monitorService.sendStatus(String.valueOf(status.getStatusCode()), start);
    return State.CONTINUE;
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
@Override
public State onStatusReceived(HttpResponseStatus responseStatus)
        throws Exception {
    statusCode = responseStatus.getStatusCode();
    return asyncHandler.onStatusReceived(responseStatus);
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public final State onStatusReceived(HttpResponseStatus responseStatus) throws Exception {
    status = responseStatus.getStatusCode();
    return status == SWITCHING_PROTOCOLS ? State.UPGRADE : State.ABORT;
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
public State onStatusReceived(HttpResponseStatus responseStatus) throws Exception {
    responseBuilder.reset();
    responseBuilder.accumulate(responseStatus);
    return State.CONTINUE;
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public final State onStatusReceived(final HttpResponseStatus status) throws Exception {
    this.status = status;
    return State.CONTINUE;
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
public HttpStatusWrapper(HttpResponseStatus wrapper, String statusText, int statusCode) {
    super(wrapper.getUri(), null);
    this.wrapped = wrapper;
    this.statusText = statusText;
    this.statusCode = statusCode;
}
 

import org.asynchttpclient.HttpResponseStatus; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public State onStatusReceived(HttpResponseStatus responseStatus) throws Exception {
    return asyncHandler.onStatusReceived(responseStatus);
}