*/
class RealInterceptorChain(
  internal val call: RealCall,
  private val interceptors: List<Interceptor>,
  private val index: Int,
  internal val exchange: Exchange?,
  internal val request: Request,
  internal val connectTimeoutMillis: Int,
  internal val readTimeoutMillis: Int,
  internal val writeTimeoutMillis: Int,
) : Interceptor.Chain {
  private var calls: Int = 0

    ```kotlin
      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()
        val call = client.newCall(request)

    // @JvmField val TLS_NULL_WITH_NULL_NULL = init("TLS_NULL_WITH_NULL_NULL", 0x0000)
    @JvmField val TLS_RSA_WITH_NULL_MD5 = init("SSL_RSA_WITH_NULL_MD5", 0x0001)

    @JvmField val TLS_RSA_WITH_NULL_SHA = init("SSL_RSA_WITH_NULL_SHA", 0x0002)

    @JvmField val TLS_RSA_EXPORT_WITH_RC4_40_MD5 = init("SSL_RSA_EXPORT_WITH_RC4_40_MD5", 0x0003)

		t.Fatalf("unexpected error: %v", err)
	}
	val := maskString("hello")
	ps.Publish(val)

	msg1 := <-ch1
	msg2 := <-ch2
	if msg1 != val && msg2 != val {
		t.Fatalf("expected both subscribers to have%s , found %s and  %s", val, msg1, msg2)
	}
}

func TestMultiPubSubMask(t *testing.T) {
	ps := New[Maskable, Maskable](3)

        init = {
            id("${performanceTestProject.spec.asConfigurationId(model)}_Trigger")
            val performanceTestSpec = performanceTestProject.spec
            name = performanceTestProject.name + " (Trigger)"

            val os = Os.LINUX
            val type = performanceTestSpec.type

            applyDefaultSettings(os)
            params {
                text(

    val delegate: BlockingQueue<T>,
  ) : AbstractQueue<T>(),
    BlockingQueue<T> {
    override val size: Int = delegate.size

    private var editCount = 0

    override fun poll(): T = delegate.poll()

    override fun poll(
      timeout: Long,
      unit: TimeUnit,
    ): T? {
      return taskRunner.withLock {
        val waitUntil = nanoTime + unit.toNanos(timeout)

import java.util.Date

/**
 * A received response or failure recorded by the response recorder.
 */
class RecordedResponse(
  @JvmField val request: Request,
  val response: Response?,
  val webSocket: WebSocket?,
  val body: String?,
  val failure: IOException?,
) {
  fun assertRequestUrl(url: HttpUrl) =
    apply {
      assertThat(request.url).isEqualTo(url)
    }

@Suppress("ktlint:standard:property-naming")
class InetAddressOrderTest {
  val ipv4_10_0_0_6 = Inet4Address.getByName("10.0.0.6")
  val ipv4_10_0_0_1 = Inet4Address.getByName("10.0.0.1")
  val ipv4_10_0_0_4 = Inet4Address.getByName("10.0.0.4")
  val ipv6_ab = Inet6Address.getByName("::ac")
  val ipv6_fc = Inet6Address.getByName("::fc")

  @Test fun prioritiseIpv6Example() {
    val result =
      reorderForHappyEyeballs(
        listOf(

      headersOf("", "OkHttp")
    }
  }

  @Test fun ofAcceptsEmptyValue() {
    val headers = headersOf("User-Agent", "")
    assertThat(headers.value(0)).isEqualTo("")
  }

  @Test fun ofMakesDefensiveCopy() {
    val namesAndValues =
      arrayOf(
        "User-Agent",
        "OkHttp",
      )
    val headers = headersOf(*namesAndValues)
    namesAndValues[1] = "Chrome"

                    license.setName(val);
                }
                // Url
                org = license.getUrl();
                val = interpolate(org);
                if (org != val) {
                    license.setUrl(val);
                }
                // Distribution
                org = license.getDistribution();
                val = interpolate(org);
                if (org != val) {