*
   * @return true if the range of [string] from [pos] to [limit] was valid and decoded successfully.
   *     Otherwise, the decode failed.
   */
  private fun decodeLabel(
    string: String,
    pos: Int,
    limit: Int,
    result: Buffer,
  ): Boolean {
    if (!string.regionMatches(pos, PREFIX_STRING, 0, 4, ignoreCase = true)) {
      result.writeUtf8(string, pos, limit)

        return emptyList()
      }

    var cookies: MutableList<Cookie>? = null
    for ((key, value) in cookieHeaders) {
      if (("Cookie".equals(key, ignoreCase = true) || "Cookie2".equals(key, ignoreCase = true)) &&
        value.isNotEmpty()
      ) {
        for (header in value) {
          if (cookies == null) cookies = mutableListOf()
          cookies.addAll(decodeHeaderAsJavaNetCookies(url, header))

    writeTimeoutMillis: Int = 10_000,
    socketConnectTimeoutMillis: Int = 10_000,
    socketReadTimeoutMillis: Int = 10_000,
    pingIntervalMillis: Int = 10_000,
    retryOnConnectionFailure: Boolean = true,
    fastFallback: Boolean = true,
    routeDatabase: RouteDatabase = RouteDatabase(),
  ) : this(
    RealConnectionPool(
      taskRunner = taskRunner,
      maxIdleConnections = maxIdleConnections,

    bytesOut.read(fullBuffer, bytesOut.size)

    // Copy back all but what we're truncating.
    fullBuffer.read(bytesOut, lastFrame.start + length)
    outFrames.add(OutFrame(lastFrame.sequence, lastFrame.start, true))
    return writer
  }

  fun takeFrame(): InFrame = inFrames.take()

  fun play() {
    check(serverSocket == null)
    serverSocket = ServerSocket()
    serverSocket!!.reuseAddress = false

    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"

    buildFeatures {
      buildConfig = false
    }

    testOptions {
      unitTests {
        isIncludeAndroidResources = true
      }

      targetSdk = 34
    }
  }

  compileOptions {
    targetCompatibility(JavaVersion.VERSION_11)
    sourceCompatibility(JavaVersion.VERSION_11)
  }

  kotlinOptions {

        }
        "private".equals(directive, ignoreCase = true) -> {
          isPrivate = true
        }
        "public".equals(directive, ignoreCase = true) -> {
          isPublic = true
        }
        "must-revalidate".equals(directive, ignoreCase = true) -> {
          mustRevalidate = true
        }
        "max-stale".equals(directive, ignoreCase = true) -> {

    }
  }

  /** Returns true if [certificate] matches [ipAddress]. */
  private fun verifyIpAddress(
    ipAddress: String,
    certificate: X509Certificate,
  ): Boolean {
    val canonicalIpAddress = ipAddress.toCanonicalHost()

    return getSubjectAltNames(certificate, ALT_IPA_NAME).any {
      canonicalIpAddress == it.toCanonicalHost()
    }
  }

  /** Returns true if [certificate] matches [hostname]. */

            rawSocket,
            rawSocket.inetAddress.hostAddress,
            rawSocket.port,
            true,
          ) as SSLSocket
        sslSocket.use {
          sslSocket.useClientMode = false
          sslSocket.wantClientAuth = true
          sslSocket.startHandshake()
          return@submit sslSocket.session.handshake()
        }
      }
    }
  }

  val cacheDir =
    context.cacheDir.resolve("httpEngine").also {
      it.mkdirs()
    }
  val engine =
    HttpEngine.Builder(context)
      .setEnableBrotli(true)
      .setStoragePath(cacheDir.path)
      .setEnableHttpCache(HttpEngine.Builder.HTTP_CACHE_DISK, 10_000_000)
      .setConnectionMigrationOptions(
        ConnectionMigrationOptions.Builder()

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.survey.ssllabs

import com.squareup.moshi.JsonClass

@JsonClass(generateAdapter = true)
class UserAgentCapabilities(
  val abortsOnUnrecognizedName: Boolean,
  val alpnProtocols: List<String>,
  val ellipticCurves: List<Int>,
  val handshakeFormat: String,
  val hexHandshakeBytes: String,