import okio.buffer
import okio.fakefilesystem.FakeFileSystem

class PostPath {
  private val client = OkHttpClient()
  private val fileSystem = FakeFileSystem()
  val path = "test.json".toPath()

  fun run() {
    fileSystem.write(path) {
      writeUtf8("{}")
    }

    val request =
      Request.Builder()
        .url("https://httpbin.org/anything")
        .put(path.asRequestBody(fileSystem, MEDIA_TYPE_JSON))

 */
@RunWith(AndroidJUnit4::class)
class ApacheHttpClientTest {
  private var httpClient = HttpClients.createDefault()

  @After fun tearDown() {
    httpClient.close()
  }

  @Test fun get() {
    val request = HttpGet("https://google.com/robots.txt")

    httpClient.execute(request).use { response ->
      assertEquals(200, response.code)
      // TODO enable ALPN later

      "xn--1ug.example",
      // OkHttp doesn't implement CheckJoiners.
      "\u200D.example",
      // OkHttp doesn't implement CheckBidi.
      "يa",
    )

  @Test
  fun test() {
    val list = WebPlatformToAsciiData.load()
    val failures = mutableListOf<Throwable>()
    for (entry in list) {
      var failure: Throwable? = null
      try {

  /** Records a failure connecting to [failedRoute]. */
  @Synchronized fun failed(failedRoute: Route) {
    _failedRoutes.add(failedRoute)
  }

  /** Records success connecting to [route]. */
  @Synchronized fun connected(route: Route) {
    _failedRoutes.remove(route)
  }

  /** Returns true if [route] has failed recently and should be avoided. */
  @Synchronized fun shouldPostpone(route: Route): Boolean = route in _failedRoutes

        return@firstOrNull true
      } catch (_: Exception) {
        return@firstOrNull false
      }
    }
  }

  override fun equals(other: Any?): Boolean {
    return other === this ||
      (other is BasicTrustRootIndex && other.subjectToCaCerts == subjectToCaCerts)
  }

  override fun hashCode(): Int {
    return subjectToCaCerts.hashCode()
  }

  delegate: SSLSocketFactory,
) : DelegatingSSLSocketFactory(delegate) {
  override fun configureSocket(sslSocket: SSLSocket): SSLSocket = TlsFallbackScsvDisabledSSLSocket(sslSocket)

  private class TlsFallbackScsvDisabledSSLSocket(
    socket: SSLSocket,
  ) : DelegatingSSLSocket(socket) {
    override fun setEnabledCipherSuites(suites: Array<String>) {
      val enabledCipherSuites = mutableListOf<String>()

 * ```
 */
@ExperimentalOkHttpApi
class MockWebServerRule : ExternalResource() {
  val server: MockWebServer = MockWebServer()

  override fun before() {
    try {
      server.start()
    } catch (e: IOException) {
      throw RuntimeException(e)
    }
  }

  override fun after() {
    try {
      server.shutdown()
    } catch (e: IOException) {
      logger.log(Level.WARNING, "MockWebServer shutdown failed", e)

        branch = VersionedSettingsBranch("master"),
        buildScanTags = listOf("Check"),
        subprojects = JsonBasedGradleSubprojectProvider(File("../.teamcity/subprojects.json"))
    )

    @Test
    fun `create correct PerformanceTest build type for Linux`() {
        val performanceTest = PerformanceTest(
            buildModel,
            Stage(
                StageName.PULL_REQUEST_FEEDBACK,

import okio.buffer

/** This is the last interceptor in the chain. It makes a network call to the server. */
class CallServerInterceptor(private val forWebSocket: Boolean) : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    val exchange = realChain.exchange!!
    val request = realChain.request
    val requestBody = request.body

import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test


class SortAcceptedApiChangesTaskIntegrationTest : AbstractAcceptedApiChangesMaintenanceTaskIntegrationTest() {
    @Test
    fun `verify misordered changes can be sorted`() {
        //language=JSON
        firstAcceptedApiChangesFile.writeText(
            """
                {
                    "acceptedApiChanges": [
                        {