class CompressionInterceptorTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  val source =
    Buffer().apply {
      write("Hello World".encodeUtf8())
    } as Source

  @Test
  fun emptyDoesntChangeRequestOrResponse() {
    val empty = CompressionInterceptor()
    val client =
      clientTestRule
        .newClientBuilder()
        .addInterceptor(empty)

    val trustManagers =
      TrustManagerFactory
        .getInstance(TrustManagerFactory.getDefaultAlgorithm())
        .apply {
          init(null as KeyStore?)
        }.trustManagers!!
    check(trustManagers.size == 1 && trustManagers[0] is X509TrustManager) {
      "Unexpected default trust managers: ${trustManagers.contentToString()}"
    }

        else -> localhost()
      }

    val isAndroid: Boolean
      get() = Platform.Companion.isAndroid

    companion object {
      const val PROPERTY_NAME = "okhttp.platform"
      const val CONSCRYPT_PROPERTY = "conscrypt"
      const val CORRETTO_PROPERTY = "corretto"
      const val JDK9_PROPERTY = "jdk9"
      const val JDK8_ALPN_PROPERTY = "jdk8alpn"
      const val JDK8_PROPERTY = "jdk8"

}

internal fun idnToAscii(host: String): String? {
  val bufferA = Buffer().writeUtf8(host)
  val bufferB = Buffer()

  // 1. Map, from bufferA to bufferB.
  while (!bufferA.exhausted()) {
    val codePoint = bufferA.readUtf8CodePoint()
    if (!IDNA_MAPPING_TABLE.map(codePoint, bufferB)) return null
  }

  // 2. Normalize, from bufferB to bufferA.
  val normalized = normalizeNfc(bufferB.readUtf8())

        System.setProperty("var1", "value1");
        System.setProperty("var2", "value2");

        String value = "${var1}-${var2}";
        assertEquals("value1-value2", ResourceUtil.resolve(value));

        // Test nested-like patterns (but not actual nesting)
        value = "${var1${var2}}"; // The ${var2} part gets replaced first
        assertEquals("${var1value2}", ResourceUtil.resolve(value));

        "com.squareup.okhttp3.urlconnection",
      )

    /** Equinox must also be on the testing classpath.  */
    private const val RESOLVE_OSGI_FRAMEWORK = "org.eclipse.osgi"
    private const val RESOLVE_JAVA_VERSION = "JavaSE-1.8"
    private const val REPO_NAME = "OsgiTest"
  }

		[]string{"api"},
	)
	observations := []struct {
		val   float64
		label string
	}{
		{
			val:   0.02,
			label: labels[0],
		},
		{
			val:   0.07,
			label: labels[1],
		},
		{
			val:   0.11,
			label: labels[1],
		},
		{
			val:   0.19,
			label: labels[1],
		},
		{
			val:   0.31,
			label: labels[1],
		},
		{
			val:   0.61,
			label: labels[3],
		},
		{

 * connects successfully. This kicks off new attempts every 250 ms until a connect succeeds.
 */
internal class FastFallbackExchangeFinder(
  override val routePlanner: RoutePlanner,
  private val taskRunner: TaskRunner,
) : ExchangeFinder {
  private val connectDelayNanos = TimeUnit.MILLISECONDS.toNanos(250L)
  private var nextTcpConnectAtNanos = Long.MIN_VALUE

  /**

 */
public open class QueueDispatcher : Dispatcher() {
  protected val responseQueue: BlockingQueue<MockResponse> = LinkedBlockingQueue()
  private var failFastResponse: MockResponse? = null

  @Throws(InterruptedException::class)
  override fun dispatch(request: RecordedRequest): MockResponse {
    // To permit interactive/browser testing, ignore requests for favicons.
    val requestLine = request.requestLine

@Tag("Slowish")
class EventSourcesHttpTest {
  @RegisterExtension
  val platform = PlatformRule()

  @StartStop
  private val server = MockWebServer()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private val listener = EventSourceRecorder()
  private val client = clientTestRule.newClient()

  @AfterEach
  fun after() {
    listener.assertExhausted()
  }