/** Don't store the server's response in any cache. */
    fun noStore() = commonNoStore()

    /**
     * Only accept the response if it is in the cache. If the response isn't cached, a `504
     * Unsatisfiable Request` response will be returned.
     */
    fun onlyIfCached() = commonOnlyIfCached()

    /** Don't accept a transformed response. */
    fun noTransform() = commonNoTransform()

            cert_reqs='CERT_NONE',
            ca_certs=ca_certs,
            retries=urllib3.Retry(
                total=5,
                backoff_factor=0.2,
                status_forcelist=[500, 502, 503, 504]
            )
        )

    def load(self):
        """
        Search for credentials with client_grants
        """
        if self.cid is not None:
            fetcher = self._create_credentials_fetcher()

router2_default = APIRouter()
router4_override = APIRouter(
    prefix="/level4",
    tags=["level4a", "level4b"],
    dependencies=[Depends(dep4)],
    responses={
        404: {"description": "Client error level 4"},
        504: {"description": "Server error level 4"},
    },
    default_response_class=ResponseLevel4,
    callbacks=callback_router4.routes,
    deprecated=True,
)
router4_default = APIRouter()


@app.get(

  }

  private fun getCacheOnlyResponse(request: Request): Response? {
    if (client.cache != null) {
      try {
        // Use the cache without hitting the network first
        // 504 code indicates that the Cache is stale
        val onlyIfCached =
          CacheControl.Builder()
            .onlyIfCached()
            .build()

        var cacheUrl = request.url

 *         .onlyIfCached()
 *         .build())
 *     .url("http://publicobject.com/helloworld.txt")
 *     .build();
 * Response forceCacheResponse = client.newCall(request).execute();
 * if (forceCacheResponse.code() != 504) {
 *   // The resource was cached! Show it.
 * } else {
 *   // The resource was not cached.
 * }
 * ```
 *
 * This technique works even better in situations where a stale response is better than no response.

    assertCached(false, 417)
    assertCached(false, 418)
    assertCached(false, 500)
    assertCached(true, 501)
    assertCached(false, 502)
    assertCached(false, 503)
    assertCached(false, 504)
    assertCached(false, 505)
    assertCached(false, 506)
  }

  @Test
  fun responseCachingWith1xxInformationalResponse() {
    assertSubsequentResponseCached(102, 200)

### Canceling a Call ([.kt][CancelCallKotlin], [.java][CancelCallJava])

        Request.Builder()
          .url(server.url("/"))
          .cacheControl(CacheControl.FORCE_CACHE)
          .build(),
      )
    val response = call.execute()
    assertThat(response.code).isEqualTo(504)
    response.close()
    assertThat(listener.recordedEventTypes())
      .containsExactly("CallStart", "SatisfactionFailure", "CallEnd")
  }

  @Test
  fun cacheHit() {
    enableCache()

func stack496()  { var buf [496]byte; use(buf[:]); C.callGoStackCheck() }
func stack500()  { var buf [500]byte; use(buf[:]); C.callGoStackCheck() }
func stack504()  { var buf [504]byte; use(buf[:]); C.callGoStackCheck() }
func stack508()  { var buf [508]byte; use(buf[:]); C.callGoStackCheck() }
func stack512()  { var buf [512]byte; use(buf[:]); C.callGoStackCheck() }

  }

  @Test
  fun onlyIfCachedReturns504WhenNotCached() {
    executeSynchronously("/", "Cache-Control", "only-if-cached")
      .assertCode(504)
      .assertBody("")
      .assertNoNetworkResponse()
      .assertNoCacheResponse()
  }

  @Test
  fun networkDropsOnConditionalGet() {
    client =
      client.newBuilder()