* on what responses can be stored, and which requests can be satisfied by those stored responses.
 *
 * See [RFC 7234, 5.2](https://tools.ietf.org/html/rfc7234#section-5.2).
 */
class CacheControl internal constructor(
  /**
   * In a response, this field's name "no-cache" is misleading. It doesn't prevent us from caching
   * the response; it only means we have to validate the response with the origin server before

  fun emptyBuilderIsEmpty() {
    val cacheControl = CacheControl.Builder().build()
    assertThat(cacheControl.toString()).isEqualTo("")
    assertThat(cacheControl.noCache).isFalse()
    assertThat(cacheControl.noStore).isFalse()
    assertThat(cacheControl.maxAgeSeconds).isEqualTo(-1)
    assertThat(cacheControl.sMaxAgeSeconds).isEqualTo(-1)
    assertThat(cacheControl.isPrivate).isFalse()

    assertThat(cacheControl.isPublic).isFalse()
    assertThat(cacheControl.mustRevalidate).isFalse()
    assertThat(cacheControl.maxStaleSeconds).isEqualTo(-1)
    assertThat(cacheControl.minFreshSeconds).isEqualTo(-1)
    assertThat(cacheControl.onlyIfCached).isFalse()
    assertThat(cacheControl.noTransform).isFalse()
    assertThat(cacheControl.immutable).isFalse()
    assertThat(cacheControl.toString()).isEqualTo(header)
  }

          // s-maxage is not checked because OkHttp is a private cache that should ignore s-maxage.
          if (response.header("Expires") == null &&
            response.cacheControl.maxAgeSeconds == -1 &&
            !response.cacheControl.isPublic &&
            !response.cacheControl.isPrivate
          ) {
            return false
          }
        }

        else -> {
          // All other codes cannot be cached.

    val minFreshSeconds: Int = cacheControl.minFreshSeconds
    val onlyIfCached: Boolean = cacheControl.onlyIfCached
    val noTransform: Boolean = cacheControl.noTransform
    val immutable: Boolean = cacheControl.immutable
    val forceCache: CacheControl = CacheControl.FORCE_CACHE
    val forceNetwork: CacheControl = CacheControl.FORCE_NETWORK
    val parse: CacheControl = CacheControl.parse(headersOf())
  }

  @Test

    else -> toInt()
  }
}

internal fun CacheControl.Companion.commonForceNetwork() =
  CacheControl.Builder()
    .noCache()
    .build()

internal fun CacheControl.Companion.commonForceCache() =
  CacheControl.Builder()
    .onlyIfCached()
    .maxStale(Int.MAX_VALUE.seconds)
    .build()

internal fun CacheControl.Builder.commonBuild(): CacheControl {
  return CacheControl(
    noCache = noCache,
    noStore = noStore,

		case "StatusCode":
			z.StatusCode, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "StatusCode")
				return
			}
		case "CacheControl":
			z.CacheControl, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "CacheControl")
				return
			}
		case "Expires":
			z.Expires, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Expires")
				return

  }

fun Request.Builder.commonHeaders(headers: Headers) =
  apply {
    this.headers = headers.newBuilder()
  }

fun Request.Builder.commonCacheControl(cacheControl: CacheControl): Request.Builder {
  val value = cacheControl.toString()
  return when {
    value.isEmpty() -> removeHeader("Cache-Control")
    else -> header("Cache-Control", value)
  }
}

      else -> false
    }

val Response.commonCacheControl: CacheControl
  get() {
    var result = lazyCacheControl
    if (result == null) {
      result = CacheControl.parse(headers)
      lazyCacheControl = result
    }
    return result
  }

fun Response.commonClose() {
  body.close()
}

	}

	if oi.ETag != "" {
		w.Header()[xhttp.ETag] = []string{"\"" + oi.ETag + "\""}
	}

	if oi.Expires != "" {
		w.Header().Set(xhttp.Expires, oi.Expires)
	}

	if oi.CacheControl != "" {
		w.Header().Set(xhttp.CacheControl, oi.CacheControl)
	}

	statusCode()
}

// CondCheck represents the conditional request made to the remote cache
// for validation during GET/HEAD object requests.
type CondCheck struct {