builder.networkInterceptors().addAll(listOf(null) as List<Interceptor>)
    assertFailsWith<IllegalStateException> {
      builder.build()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Null network interceptor: [null]")
    }
  }

  @Test fun testH2PriorKnowledgeOkHttpClientConstructionFallback() {
    assertFailsWith<IllegalArgumentException> {
      OkHttpClient
        .Builder()

      assertThat(source.readUtf8(halfResponseBody.length.toLong())).isEqualTo(halfResponseBody)
      source.close()
      assertFailsWith<IllegalStateException> {
        source.readUtf8()
      }
      assertFailsWith<IOException> {
        response.peekTrailers()
      }
      assertFailsWith<IOException> {
        response.trailers()
      }
    }
  }

  private fun MockResponse.Builder.body(

    val builder = Request.Builder()
    assertFailsWith<IllegalArgumentException> {
      builder.header(s, "Value")
    }
    assertFailsWith<IllegalArgumentException> {
      builder.addHeader(s, "Value")
    }
    assertFailsWith<IllegalArgumentException> {
      builder.header("Name", s)
    }
    assertFailsWith<IllegalArgumentException> {
      builder.addHeader("Name", s)
    }
  }

 * limitations under the License.
 */
package okhttp3

import app.cash.burst.Burst
import app.cash.burst.burstValues
import java.io.IOException
import java.util.Random
import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import okhttp3.testing.PlatformRule
import okio.ByteString.Companion.toByteString

  private fun Editor.assertInoperable() {
    assertFailsWith<IllegalStateException> {
      setString(0, "A")
    }
    assertFailsWith<IllegalStateException> {
      newSource(0)
    }
    assertFailsWith<IllegalStateException> {
      newSink(0)
    }
    assertFailsWith<IllegalStateException> {
      commit()
    }
    assertFailsWith<IllegalStateException> {
      abort()
    }

    val builder = Request.Builder()
    assertFailsWith<IllegalArgumentException> {
      builder.header(s, "Value")
    }
    assertFailsWith<IllegalArgumentException> {
      builder.addHeader(s, "Value")
    }
    assertFailsWith<IllegalArgumentException> {
      builder.header("Name", s)
    }
    assertFailsWith<IllegalArgumentException> {
      builder.addHeader("Name", s)
    }
  }

import java.net.Proxy
import java.net.UnknownHostException
import java.time.Duration
import java.util.Arrays
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit
import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketEffect.CloseSocket
import mockwebserver3.junit5.StartStop
import okhttp3.CallEvent.CacheConditionalHit

  }

  @Test
  fun requestHeaderValidationIsStrict() {
    assertFailsWith<IllegalArgumentException> {
      Request
        .Builder()
        .addHeader("a\tb", "Value")
    }
    assertFailsWith<IllegalArgumentException> {
      Request
        .Builder()
        .addHeader("Name", "c\u007fd")
    }
    assertFailsWith<IllegalArgumentException> {
      Request
        .Builder()

      )

    call.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("abc")
      val requestBodyOut = requestBody.takeSink()
      assertFailsWith<IOException> {
        SlowRequestBody.writeTo(requestBodyOut)
      }
      assertFailsWith<IOException> {
        requestBodyOut.close()
      }
    }

    // Confirm that the connection pool was not corrupted by making another call.

import javax.net.ssl.SSLHandshakeException
import javax.net.ssl.SSLPeerUnverifiedException
import javax.net.ssl.SSLSocketFactory
import javax.net.ssl.TrustManager
import javax.security.auth.x500.X500Principal
import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import okhttp3.CallEvent.CallFailed
import okhttp3.CallEvent.CallStart