.isSameAs(forJavaName("TestCipherSuite"))
    assertThat(forJavaName(CipherSuite.TLS_KRB5_WITH_DES_CBC_MD5.javaName))
      .isSameAs(CipherSuite.TLS_KRB5_WITH_DES_CBC_MD5)
  }

  /**
   * Tests that interned CipherSuite instances remain the case across garbage collections, even if
   * the String used to construct them is no longer strongly referenced outside of the CipherSuite.
   */
  @Test

    assertThat(call.isCanceled()).isFalse()
  }

  private fun sleepingRequestBody(sleepMillis: Int): RequestBody {
    return object : RequestBody() {
      override fun contentType(): MediaType? {
        return "text/plain".toMediaTypeOrNull()
      }

      @Throws(IOException::class)
      override fun writeTo(sink: BufferedSink) {
        try {
          sink.writeUtf8("abc")
          sink.flush()

    val call =
      client.newCall(
        Request(
          url = server.url("/foo"),
          body =
            object : RequestBody() {
              override fun contentType(): MediaType = "text/plain; charset=utf-8".toMediaType()

              override fun writeTo(sink: BufferedSink) {
                sink.write(postBytes)
              }
            },
        ),
      )

@Tag("Slow")
class RealWebSocketTest {
  // NOTE: Fields are named 'client' and 'server' for cognitive simplicity. This differentiation has
  // zero effect on the behavior of the WebSocket API which is why tests are only written once
  // from the perspective of a single peer.
  private val random = Random(0)
  private val client2Server = Pipe(8192L)
  private val server2client = Pipe(8192L)
  private val taskFaker = TaskFaker()

    val e = RuntimeException()
    clientListener.setNextEventDelegate(
      object : WebSocketListener() {
        override fun onMessage(
          webSocket: WebSocket,
          text: String,
        ) {
          throw e
        }
      },
    )
    server.send("Hello, WebSockets!")
    clientListener.assertFailure(e)
    serverListener.assertFailure(EOFException::class.java)

        // If you throw an exception here then native image building fails half way through
        // silently without rewriting the binary. So we report noisily, but keep going and prefer
        // running most tests still.
        e.printStackTrace()
      }
    }
  }

  private fun registerTest(
    access: Feature.BeforeAnalysisAccess,
    java: Class<*>,
  ) {
    access.registerAsUsed(java)

    }

    listener.onClosing(this, code, reason)
  }

  // Writer methods to enqueue frames. They'll be sent asynchronously by the writer thread.

  override fun send(text: String): Boolean {
    return send(text.encodeUtf8(), OPCODE_TEXT)
  }

  override fun send(bytes: ByteString): Boolean {
    return send(bytes, OPCODE_BINARY)
  }

  @Synchronized private fun send(
    data: ByteString,

    // Hanging.
    "okhttp3.WholeOperationTimeoutTest",
  )

/**
 * Run periodically to refresh the known set of working tests.
 *
 * TODO use filtering to allow skipping acceptable problem tests
 */
fun main() {
  val knownTestFile = File("native-image-tests/src/main/resources/testlist.txt")
  val testSelector = DiscoverySelectors.selectPackage("okhttp3")
  val testClasses =
    findTests(listOf(testSelector))

        with:
          distribution: 'zulu'
          java-version: 17

      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v3

      - name: Run Container Tests

class CommonRequestBodyTest {
  @Test
  fun correctContentType() {
    val body = "Body"
    val requestBody = body.toRequestBody(MediaType("text/plain", "text", "plain", arrayOf()))

    val contentType = requestBody.contentType()!!

    assertThat(contentType.mediaType).isEqualTo("text/plain; charset=utf-8")
    assertThat(contentType.parameter("charset")).isEqualTo("utf-8")
  }