}

  @Test
  fun incompleteUrlComposition() {
    val noHost =
      assertFailsWith<IllegalStateException> {
        HttpUrl.Builder().scheme("http").build()
      }
    assertThat(noHost.message).isEqualTo("host == null")
    val noScheme =
      assertFailsWith<IllegalStateException> {
        HttpUrl.Builder().host("host").build()
      }

      PublicSuffixDatabase(
        path = "/xxx.gz".toPath(),
      )
    lateinit var firstFailure: Exception
    assertFailsWith<Exception> {
      badPublicSuffixDatabase.getEffectiveTldPlusOne("squareup.com")
    }.also { e ->
      firstFailure = e
    }
    assertFailsWith<Exception> {
      badPublicSuffixDatabase.getEffectiveTldPlusOne("squareup.com")
    }.also { e ->

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

import assertk.assertThat
import assertk.assertions.startsWith
import kotlin.test.assertFailsWith
import kotlin.test.fail
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.internal.idn.Punycode
import okio.Buffer
import okio.ByteString
import okio.ByteString.Companion.encodeUtf8

/**

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import java.io.IOException
import java.util.Arrays
import kotlin.test.assertFailsWith
import okhttp3.TestUtil.headerEntries
import okio.Buffer
import okio.ByteString
import okio.ByteString.Companion.decodeHex
import okio.ByteString.Companion.encodeUtf8
import org.junit.jupiter.api.BeforeEach

  @Test
  fun noTlsVersions() {
    assertFailsWith<IllegalArgumentException> {
      ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
        .tlsVersions(*arrayOf<String>())
        .build()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("At least one TLS version is required")
    }
  }

  @Test
  fun noCipherSuites() {
    assertFailsWith<IllegalArgumentException> {

    dispatcher.maxRequestsPerHost = 10
    listener.forbidLock(dispatcher)
  }

  @Test
  fun maxRequestsZero() {
    assertFailsWith<IllegalArgumentException> {
      dispatcher.maxRequests = 0
    }
  }

  @Test
  fun maxPerHostZero() {
    assertFailsWith<IllegalArgumentException> {
      dispatcher.maxRequestsPerHost = 0
    }
  }

  @Test
  fun enqueuedJobsRunImmediately() {

    assertThat(cookie.persistent).isTrue()
    assertThat(cookie.hostOnly).isFalse()
  }

  @Test fun builderNameValidation() {
    assertFailsWith<IllegalArgumentException> {
      Cookie.Builder().name(" a ")
    }
  }

  @Test fun builderValueValidation() {
    assertFailsWith<IllegalArgumentException> {
      Cookie.Builder().value(" b ")
    }
  }

  @Test fun builderClampsMaxDate() {
    val cookie =

 */
package okhttp3

import assertk.assertThat
import assertk.assertions.isEqualTo
import java.io.IOException
import java.util.concurrent.TimeUnit
import javax.net.ssl.SSLException
import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketPolicy.DisconnectAfterRequest
import mockwebserver3.SocketPolicy.DisconnectAtEnd

import java.nio.charset.StandardCharsets
import java.util.Arrays
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicBoolean
import javax.net.ssl.HttpsURLConnection
import kotlin.test.assertFailsWith
import okhttp3.Headers
import okhttp3.Protocol
import okhttp3.RecordingHostnameVerifier
import okhttp3.TestUtil.assumeNotWindows
import okhttp3.testing.PlatformRule
import okhttp3.tls.HandshakeCertificates

import assertk.assertions.isTrue
import java.io.EOFException
import java.io.IOException
import java.net.ProtocolException
import java.net.SocketTimeoutException
import java.util.Random
import kotlin.test.assertFailsWith
import okhttp3.FailingCall
import okhttp3.Headers
import okhttp3.Headers.Companion.headersOf
import okhttp3.Protocol
import okhttp3.Request
import okhttp3.Response
import okhttp3.TestUtil.repeat