import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Suppress
public void testExtremelyLarge() throws Exception {
    // NOTE: suppressed since this takes several minutes to run
    final long length = 3 * GB_IN_BYTES;
    final InputStream body = new FakeInputStream(length);

    enqueueResponse(new MockResponse().setResponseCode(HTTP_OK).setBody(body, length)
            .setHeader("Content-type", "text/plain")
            .setSocketPolicy(SocketPolicy.DISCONNECT_AT_END));

    final Download download = enqueueRequest(getRequest()
            .setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, "extreme.bin"));
    download.runUntilStatus(DownloadManager.STATUS_SUCCESSFUL, 10 * DateUtils.MINUTE_IN_MILLIS);

    assertEquals(length, download.getLongField(DownloadManager.COLUMN_TOTAL_SIZE_BYTES));
    assertEquals(length, download.getLongField(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR));
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void responsesAreCached() throws IOException {
  client.setResponseCache(cache);

  server.enqueue(new MockResponse().addHeader("cache-control: max-age=60").setBody("A"));
  server.play();

  assertContent("A", client.open(server.getUrl("/")), Integer.MAX_VALUE);
  assertEquals(1, cache.getRequestCount());
  assertEquals(1, cache.getNetworkCount());
  assertEquals(0, cache.getHitCount());
  assertContent("A", client.open(server.getUrl("/")), Integer.MAX_VALUE);
  assertContent("A", client.open(server.getUrl("/")), Integer.MAX_VALUE);
  assertEquals(3, cache.getRequestCount());
  assertEquals(1, cache.getNetworkCount());
  assertEquals(2, cache.getHitCount());
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void redirectedFromHttpsToHttpFollowingProtocolRedirects() throws Exception {
  server2 = new MockWebServer();
  server2.enqueue(new MockResponse().setBody("This is insecure HTTP!"));
  server2.play();

  server.useHttps(sslContext.getSocketFactory(), false);
  server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
      .addHeader("Location: " + server2.getUrl("/"))
      .setBody("This page has moved!"));
  server.play();

  client.setSslSocketFactory(sslContext.getSocketFactory());
  client.setHostnameVerifier(new RecordingHostnameVerifier());
  client.setFollowProtocolRedirects(true);
  HttpsURLConnection connection = (HttpsURLConnection) client.open(server.getUrl("/"));
  assertContent("This is insecure HTTP!", connection);
  assertNull(connection.getCipherSuite());
  assertNull(connection.getLocalCertificates());
  assertNull(connection.getServerCertificates());
  assertNull(connection.getPeerPrincipal());
  assertNull(connection.getLocalPrincipal());
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void connectionCloseInRequest() throws IOException, InterruptedException {
  server.enqueue(new MockResponse()); // server doesn't honor the connection: close header!
  server.enqueue(new MockResponse());
  server.play();

  HttpURLConnection a = client.open(server.getUrl("/"));
  a.setRequestProperty("Connection", "close");
  assertEquals(200, a.getResponseCode());

  HttpURLConnection b = client.open(server.getUrl("/"));
  assertEquals(200, b.getResponseCode());

  assertEquals(0, server.takeRequest().getSequenceNumber());
  assertEquals("When connection: close is used, each request should get its own connection", 0,
      server.takeRequest().getSequenceNumber());
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void getHeadersRetainsCached200LevelWarnings() throws Exception {
  server.enqueue(new MockResponse().addHeader("Warning: 299 test danger")
      .addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
      .addHeader("Cache-Control: max-age=0")
      .setBody("A"));
  server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
  server.play();

  URLConnection connection1 = openConnection(server.getUrl("/"));
  assertEquals("A", readAscii(connection1));
  assertEquals("299 test danger", connection1.getHeaderField("Warning"));

  URLConnection connection2 = openConnection(server.getUrl("/"));
  assertEquals("A", readAscii(connection2));
  assertEquals("299 test danger", connection2.getHeaderField("Warning"));
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test
public void testImagePush() throws IOException, InterruptedException {
    final String json = Resources.toString(getResource("image/image-push.json"), Charsets.UTF_8);
    final Auth auth = new Auth("hannibal", "xxxx", "[email protected]");
    MockWebServer server = new MockWebServer();
    server.enqueue(new MockResponse().setBody(json));
    server.play();
    Docker docker = createDockerForMock(server);
    Progress response = docker.imagePush("base", "reg", auth);
    assertNotNull(response);
    assertEquals(response.getError(), "Invalid...");
    RecordedRequest recordedRequest = server.takeRequest();
    String body = new String(recordedRequest.getBody());
    Auth requestAuth = new Gson().fromJson(body, Auth.class);
    assertEquals(auth.getEmail(), requestAuth.getEmail());
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
/**
 * Obnoxiously test that the chunk sizes transmitted exactly equal the
 * requested data+chunk header size. Although setChunkedStreamingMode()
 * isn't specific about whether the size applies to the data or the
 * complete chunk, the RI interprets it as a complete chunk.
 */
@Test public void setChunkedStreamingMode() throws IOException, InterruptedException {
  server.enqueue(new MockResponse());
  server.play();

  HttpURLConnection urlConnection = client.open(server.getUrl("/"));
  urlConnection.setChunkedStreamingMode(8);
  urlConnection.setDoOutput(true);
  OutputStream outputStream = urlConnection.getOutputStream();
  outputStream.write("ABCDEFGHIJKLMNOPQ".getBytes("US-ASCII"));
  assertEquals(200, urlConnection.getResponseCode());

  RecordedRequest request = server.takeRequest();
  assertEquals("ABCDEFGHIJKLMNOPQ", new String(request.getBody(), "US-ASCII"));
  assertEquals(Arrays.asList(3, 3, 3, 3, 3, 2), request.getChunkSizes());
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test
public void testGetDataString() throws InterruptedException {
	// Define WFS mock responses
	mockServer.enqueue(new MockResponse().clearHeaders().setBody(
			createStubGetCapabilitiesResponse()));
	mockServer.enqueue(new MockResponse().clearHeaders().setBody(
			createStubGetFeatureResponse()));

	classUnderTest.init(createStubContext(), createStubProperties());
	Iterator<Map<String, Object>> result = classUnderTest
			.getData("bestuurlijkegrenzen:provincies_2012");

	assertThat("Result should not be NULL.", result, notNullValue());

	Map<String, Object> transformedFeature = result.next();
	assertThat("Result should contain at least 1 feature.",
			transformedFeature, notNullValue());
	assertThat("Feature should contain 3 properties", transformedFeature
			.entrySet().size(), is(3));
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void authenticate() throws Exception {
  server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_UNAUTHORIZED)
      .addHeader("www-authenticate: Basic realm=\"protected area\"")
      .setBody("Please authenticate."));
  server.enqueue(new MockResponse().setBody("Successful auth!"));
  server.play();

  Authenticator.setDefault(new RecordingAuthenticator());
  HttpURLConnection connection = client.open(server.getUrl("/"));
  assertEquals("Successful auth!", readAscii(connection.getInputStream(), Integer.MAX_VALUE));

  RecordedRequest denied = server.takeRequest();
  assertContainsNoneMatching(denied.getHeaders(), "authorization: Basic .*");
  RecordedRequest accepted = server.takeRequest();
  assertEquals("GET / HTTP/1.1", accepted.getRequestLine());
  assertContains(accepted.getHeaders(),
      "authorization: Basic " + RecordingAuthenticator.BASE_64_CREDENTIALS);
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void clientConfiguredGzipContentEncoding() throws Exception {
  byte[] bodyBytes = gzip("ABCDEFGHIJKLMNOPQRSTUVWXYZ".getBytes("UTF-8"));
  server.enqueue(new MockResponse()
      .setBody(bodyBytes)
      .addHeader("Content-Encoding: gzip"));
  server.play();

  URLConnection connection = client.open(server.getUrl("/"));
  connection.addRequestProperty("Accept-Encoding", "gzip");
  InputStream gunzippedIn = new GZIPInputStream(connection.getInputStream());
  assertEquals("ABCDEFGHIJKLMNOPQRSTUVWXYZ", readAscii(gunzippedIn, Integer.MAX_VALUE));
  assertEquals(bodyBytes.length, connection.getContentLength());

  RecordedRequest request = server.takeRequest();
  assertContains(request.getHeaders(), "Accept-Encoding: gzip");
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void redirectToCachedResult() throws Exception {
  server.enqueue(new MockResponse().addHeader("Cache-Control: max-age=60").setBody("ABC"));
  server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_MOVED_PERM)
      .addHeader("Location: /foo"));
  server.enqueue(new MockResponse().setBody("DEF"));
  server.play();

  assertEquals("ABC", readAscii(openConnection(server.getUrl("/foo"))));
  RecordedRequest request1 = server.takeRequest();
  assertEquals("GET /foo HTTP/1.1", request1.getRequestLine());
  assertEquals(0, request1.getSequenceNumber());

  assertEquals("ABC", readAscii(openConnection(server.getUrl("/bar"))));
  RecordedRequest request2 = server.takeRequest();
  assertEquals("GET /bar HTTP/1.1", request2.getRequestLine());
  assertEquals(1, request2.getSequenceNumber());

  // an unrelated request should reuse the pooled connection
  assertEquals("DEF", readAscii(openConnection(server.getUrl("/baz"))));
  RecordedRequest request3 = server.takeRequest();
  assertEquals("GET /baz HTTP/1.1", request3.getRequestLine());
  assertEquals(2, request3.getSequenceNumber());
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
private void testServerPrematureDisconnect(TransferKind transferKind) throws IOException {
  MockResponse response = new MockResponse();
  transferKind.setBody(response, "ABCDE\nFGHIJKLMNOPQRSTUVWXYZ", 16);
  server.enqueue(truncateViolently(response, 16));
  server.enqueue(new MockResponse().setBody("Request #2"));
  server.play();

  BufferedReader reader = new BufferedReader(
      new InputStreamReader(openConnection(server.getUrl("/")).getInputStream()));
  assertEquals("ABCDE", reader.readLine());
  try {
    reader.readLine();
    fail("This implementation silently ignored a truncated HTTP body.");
  } catch (IOException expected) {
  } finally {
    reader.close();
  }

  assertEquals(1, cache.getWriteAbortCount());
  assertEquals(0, cache.getWriteSuccessCount());
  URLConnection connection = openConnection(server.getUrl("/"));
  assertEquals("Request #2", readAscii(connection));
  assertEquals(1, cache.getWriteAbortCount());
  assertEquals(1, cache.getWriteSuccessCount());
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
private void testEarlyDisconnectDoesntHarmPooling(TransferKind transferKind) throws Exception {
  MockResponse response1 = new MockResponse();
  transferKind.setBody(response1, "ABCDEFGHIJK", 1024);
  server.enqueue(response1);

  MockResponse response2 = new MockResponse();
  transferKind.setBody(response2, "LMNOPQRSTUV", 1024);
  server.enqueue(response2);

  server.play();

  URLConnection connection1 = client.open(server.getUrl("/"));
  InputStream in1 = connection1.getInputStream();
  assertEquals("ABCDE", readAscii(in1, 5));
  in1.close();

  HttpURLConnection connection2 = client.open(server.getUrl("/"));
  InputStream in2 = connection2.getInputStream();
  assertEquals("LMNOP", readAscii(in2, 5));
  in2.close();

  assertEquals(0, server.takeRequest().getSequenceNumber());
  assertEquals(1, server.takeRequest().getSequenceNumber()); // Connection is pooled!
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
private void testServerClosesOutput(SocketPolicy socketPolicy) throws Exception {
  server.enqueue(new MockResponse().setBody("This connection won't pool properly")
      .setSocketPolicy(socketPolicy));
  MockResponse responseAfter = new MockResponse().setBody("This comes after a busted connection");
  server.enqueue(responseAfter);
  server.enqueue(responseAfter); // Enqueue 2x because the broken connection may be reused.
  server.play();

  HttpURLConnection connection1 = client.open(server.getUrl("/a"));
  connection1.setReadTimeout(100);
  assertContent("This connection won't pool properly", connection1);
  assertEquals(0, server.takeRequest().getSequenceNumber());
  HttpURLConnection connection2 = client.open(server.getUrl("/b"));
  connection2.setReadTimeout(100);
  assertContent("This comes after a busted connection", connection2);

  // Check that a fresh connection was created, either immediately or after attempting reuse.
  RecordedRequest requestAfter = server.takeRequest();
  if (server.getRequestCount() == 3) {
    requestAfter = server.takeRequest(); // The failure consumed a response.
  }
  // sequence number 0 means the HTTP socket connection was not reused
  assertEquals(0, requestAfter.getSequenceNumber());
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void post() throws Exception {
  server.enqueue(new MockResponse().setBody("abc"));
  server.play();

  Request request = new Request.Builder(server.getUrl("/"))
      .post(Request.Body.create(MediaType.parse("text/plain"), "def"))
      .build();
  client.enqueue(request, receiver);

  receiver.await(request)
      .assertCode(200)
      .assertBody("abc");

  RecordedRequest recordedRequest = server.takeRequest();
  assertEquals("def", recordedRequest.getUtf8Body());
  assertEquals("3", recordedRequest.getHeader("Content-Length"));
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void getKeepAlive() throws Exception {
  MockWebServer server = new MockWebServer();
  server.enqueue(new MockResponse().setBody("ABC"));
  server.play();

  // The request should work once and then fail
  URLConnection connection1 = client.open(server.getUrl(""));
  connection1.setReadTimeout(100);
  InputStream input = connection1.getInputStream();
  assertEquals("ABC", readAscii(input, Integer.MAX_VALUE));
  input.close();
  server.shutdown();
  try {
    HttpURLConnection connection2 = client.open(server.getUrl(""));
    connection2.setReadTimeout(100);
    connection2.getInputStream();
    fail();
  } catch (ConnectException expected) {
  }
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
private void testMethodInvalidates(String requestMethod) throws Exception {
  // 1. seed the cache
  // 2. invalidate it
  // 3. expect a cache miss
  server.enqueue(
      new MockResponse().setBody("A").addHeader("Expires: " + formatDate(1, TimeUnit.HOURS)));
  server.enqueue(new MockResponse().setBody("B"));
  server.enqueue(new MockResponse().setBody("C"));
  server.play();

  URL url = server.getUrl("/");

  assertEquals("A", readAscii(openConnection(url)));

  HttpURLConnection invalidate = openConnection(url);
  invalidate.setRequestMethod(requestMethod);
  addRequestBodyIfNecessary(requestMethod, invalidate);
  assertEquals("B", readAscii(invalidate));

  assertEquals("C", readAscii(openConnection(url)));
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void customAuthenticator() throws Exception {
  MockResponse pleaseAuthenticate = new MockResponse().setResponseCode(401)
      .addHeader("WWW-Authenticate: Basic realm=\"protected area\"")
      .setBody("Please authenticate.");
  server.enqueue(pleaseAuthenticate);
  server.enqueue(new MockResponse().setBody("A"));
  server.play();

  Credential credential = Credential.basic("jesse", "peanutbutter");
  RecordingOkAuthenticator authenticator = new RecordingOkAuthenticator(credential);
  client.setAuthenticator(authenticator);
  assertContent("A", client.open(server.getUrl("/private")));

  assertContainsNoneMatching(server.takeRequest().getHeaders(), "Authorization: .*");
  assertContains(server.takeRequest().getHeaders(),
      "Authorization: " + credential.getHeaderValue());

  assertEquals(1, authenticator.calls.size());
  String call = authenticator.calls.get(0);
  assertTrue(call, call.contains("proxy=DIRECT"));
  assertTrue(call, call.contains("url=" + server.getUrl("/private")));
  assertTrue(call, call.contains("challenges=[Basic realm=\"protected area\"]"));
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void connectViaHttpsReusingConnections() throws IOException, InterruptedException {
  server.useHttps(sslContext.getSocketFactory(), false);
  server.enqueue(new MockResponse().setBody("this response comes via HTTPS"));
  server.enqueue(new MockResponse().setBody("another response via HTTPS"));
  server.play();

  // The pool will only reuse sockets if the SSL socket factories are the same.
  SSLSocketFactory clientSocketFactory = sslContext.getSocketFactory();
  RecordingHostnameVerifier hostnameVerifier = new RecordingHostnameVerifier();

  client.setSslSocketFactory(clientSocketFactory);
  client.setHostnameVerifier(hostnameVerifier);
  HttpURLConnection connection = client.open(server.getUrl("/"));
  assertContent("this response comes via HTTPS", connection);

  connection = client.open(server.getUrl("/"));
  assertContent("another response via HTTPS", connection);

  assertEquals(0, server.takeRequest().getSequenceNumber());
  assertEquals(1, server.takeRequest().getSequenceNumber());
}
 

import com.google.mockwebserver.MockResponse; //导入依赖的package包/类
@Test public void varyAndHttps() throws Exception {
  server.useHttps(sslContext.getSocketFactory(), false);
  server.enqueue(new MockResponse().addHeader("Cache-Control: max-age=60")
      .addHeader("Vary: Accept-Language")
      .setBody("A"));
  server.enqueue(new MockResponse().setBody("B"));
  server.play();

  URL url = server.getUrl("/");
  HttpsURLConnection connection1 = (HttpsURLConnection) client.open(url);
  connection1.setSSLSocketFactory(sslContext.getSocketFactory());
  connection1.setHostnameVerifier(NULL_HOSTNAME_VERIFIER);
  connection1.addRequestProperty("Accept-Language", "en-US");
  assertEquals("A", readAscii(connection1));

  HttpsURLConnection connection2 = (HttpsURLConnection) client.open(url);
  connection2.setSSLSocketFactory(sslContext.getSocketFactory());
  connection2.setHostnameVerifier(NULL_HOSTNAME_VERIFIER);
  connection2.addRequestProperty("Accept-Language", "en-US");
  assertEquals("A", readAscii(connection2));
}