delegate: SSLSocketFactory,
) : DelegatingSSLSocketFactory(delegate) {
  override fun configureSocket(sslSocket: SSLSocket): SSLSocket = TlsFallbackScsvDisabledSSLSocket(sslSocket)

  private class TlsFallbackScsvDisabledSSLSocket(
    socket: SSLSocket,
  ) : DelegatingSSLSocket(socket) {
    override fun setEnabledCipherSuites(suites: Array<String>) {
      val enabledCipherSuites = mutableListOf<String>()

   * timeout. Because networks can fail during an exchange, it is possible that the remote server
   * accepted the request before the failure.
   */
  fun onFailure(
    call: Call,
    e: IOException,
  )

  /**
   * Called when the HTTP response was successfully returned by the remote server. The callback may

/**
 * Most websites serve cookies in the blessed format. Eagerly create the parser to ensure such
 * cookies are on the fast path.
 */
private val STANDARD_DATE_FORMAT =
  object : ThreadLocal<DateFormat>() {
    override fun initialValue(): DateFormat {
      // Date format specified by RFC 7231 section 7.1.1.1.
      return SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss 'GMT'", Locale.US).apply {
        isLenient = false
        timeZone = UTC

            buildScanTags = listOf("Check"),
            subprojects = JsonBasedGradleSubprojectProvider(File("../.teamcity/subprojects.json")),
        )

    @Test
    fun `create correct PerformanceTest build type for Linux`() {
        val performanceTest =
            PerformanceTest(
                buildModel,
                Stage(
                    StageName.PULL_REQUEST_FEEDBACK,

    private val nullableAnnotationName = "org.jspecify.annotations.Nullable"
    private val nullUnmarkedAnnotationName = "org.jspecify.annotations.NullUnmarked"

    @Test
    fun `from non-null returning to null-unmarked returning is breaking`() {

        checkNotBinaryCompatibleJava(
            v1 = """
                public class Source {
                    public String foo() { return "bar"; }

    )
    publishing.publications.configureEach {
        if (signArtifacts) {
            signing.sign(this)
        }
    }
}

fun configureJavadocVariant() {
    java {
        withJavadocJar()
    }
}

fun MavenPublication.configureGradleModulePublication() {
    from(components["java"])
    artifactId = gradleModule.identity.baseName.get()
    versionMapping {

   */
  @Throws(IOException::class)
  fun authenticate(
    route: Route?,
    response: Response,
  ): Request?

  companion object {
    /** An authenticator that knows no credentials and makes no attempt to authenticate. */
    @JvmField
    val NONE: Authenticator = AuthenticatorNone()

    private class AuthenticatorNone : Authenticator {
      override fun authenticate(
        route: Route?,

   */
  private fun includeAuthorityInRequestLine(
    request: Request,
    proxyType: Proxy.Type,
  ): Boolean = !request.isHttps && proxyType == Proxy.Type.HTTP

  /**
   * Returns the path to request, like the '/' in 'GET / HTTP/1.1'. Never empty, even if the request
   * URL is. Includes the query component if it exists.
   */
  fun requestPath(url: HttpUrl): String {

import okhttp3.internal.http2.Http2ExchangeCodec.Companion.http2HeadersList
import okhttp3.internal.http2.Http2ExchangeCodec.Companion.readHttp2HeadersList
import org.junit.jupiter.api.Test

class HeadersRequestTest {
  @Test fun readNameValueBlockDropsForbiddenHeadersHttp2() {
    val headerBlock =
      headersOf(
        ":status",
        "200 OK",
        ":version",
        "HTTP/1.1",
        "connection",
        "close",
      )

import java.util.concurrent.TimeUnit
import okhttp3.OkHttpClient
import okhttp3.Request

class CancelCall {
  private val executor = Executors.newScheduledThreadPool(1)
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request
        .Builder()
        .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
        .build()

    val startNanos = System.nanoTime()