*
   * Note that transport-layer success (receiving a HTTP response code, headers and body) does not
   * necessarily indicate application-layer success: `response` may still indicate an unhappy HTTP
   * response code like 404 or 500.
   */
  @Throws(IOException::class)
  fun onResponse(
    call: Call,
    response: Response,
  )

                return new MockResponse().setResponseCode(200).setBody("{\\\"info\\\":{\\\"name\":\"Lucas Albuquerque\",\"age\":\"21\",\"gender\":\"male\"}}");
        }
        return new MockResponse().setResponseCode(404);
    }
};
server.setDispatcher(dispatcher);
```


### Download

```kotlin
testImplementation("com.squareup.okhttp3:mockwebserver:4.12.0")
```

### License

      assertThat(ioe.cause!!).isInstanceOf<EOFException>()
    }
  }

  // TODO GET preferred order - with tests to confirm this
  // 1. successful fresh cached GET response
  // 2. unsuccessful (404, 500) fresh cached GET response
  // 3. successful network response
  // 4. successful stale cached GET response
  // 5. unsuccessful response
  @Test
  fun usesCache() {

   *
   * Note that transport-layer success (receiving a HTTP response code, headers and body) does not
   * necessarily indicate application-layer success: `response` may still indicate an unhappy HTTP
   * response code like 404 or 500.
   *
   * @throws IOException if the request could not be executed due to cancellation, a connectivity
   *     problem or timeout. Because networks can fail during an exchange, it is possible that the

    val request =
      Request.Builder()
        .url("https://valid-isrgrootx1.letsencrypt.org/robots.txt")
        .build()
    client.newCall(request).execute().use { response ->
      assertThat(response.code).isEqualTo(404)
      assertThat(response.protocol).isEqualTo(Protocol.HTTP_2)
    }
  }

      MockResponse.Builder()
        .status("HTTP/1.1 404 Not Found")
        .build(),
    )
    newWebSocket()
    clientListener.assertFailure(
      404,
      null,
      ProtocolException::class.java,
      "Expected HTTP 101 response but was '404 Not Found'",
    )
  }

  @Test
  fun clientTimeoutClosesBody() {
    webServer.enqueue(
      MockResponse.Builder()
        .code(408)

    }
  }

  private fun send404(
    stream: Http2Stream,
    path: String,
  ) {
    val responseHeaders =
      listOf(
        Header(":status", "404"),
        Header(":version", "HTTP/1.1"),
        Header("content-type", "text/plain"),
      )
    stream.writeHeaders(
      responseHeaders = responseHeaders,
      outFinished = false,

    assertCached(true, 307)
    assertCached(true, 308)
    assertCached(false, 400)
    assertCached(false, 401)
    assertCached(false, 402)
    assertCached(false, 403)
    assertCached(true, 404)
    assertCached(true, 405)
    assertCached(false, 406)
    assertCached(false, 408)
    assertCached(false, 409)
    // the HTTP spec permits caching 410s, but the RI doesn't.
    assertCached(true, 410)

      Header(RESPONSE_STATUS, "200"),
      Header(RESPONSE_STATUS, "204"),
      Header(RESPONSE_STATUS, "206"),
      Header(RESPONSE_STATUS, "304"),
      Header(RESPONSE_STATUS, "400"),
      Header(RESPONSE_STATUS, "404"),
      Header(RESPONSE_STATUS, "500"),
      Header("accept-charset", ""),
      Header("accept-encoding", "gzip, deflate"),
      Header("accept-language", ""),
      Header("accept-ranges", ""),