.isEqualTo("INFO: Callback failure for call to " + server.url("/") + "...")
  }

  @Test
  fun connectionPooling() {
    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))
    server.enqueue(MockResponse(body = "ghi"))
    executeSynchronously("/a").assertBody("abc")
    executeSynchronously("/b").assertBody("def")
    executeSynchronously("/c").assertBody("ghi")

  }

  private fun testServerPrematureDisconnect(transferKind: TransferKind) {
    val mockResponse = MockResponse.Builder()
    transferKind.setBody(mockResponse, "ABCDE\nFGHIJKLMNOPQRSTUVWXYZ", 16)
    server.enqueue(truncateViolently(mockResponse, 16).build())
    server.enqueue(
      MockResponse
        .Builder()
        .body("Request #2")
        .build(),
    )

        testableFilter.doFilter(mockRequest, mockResponse, mockFilterChain);

        assertFalse(mockFilterChain.wasDoFilterCalled());
        assertEquals(429, mockResponse.getStatus());
        assertEquals("application/json;charset=UTF-8", mockResponse.getContentType());
        assertEquals("60", mockResponse.getHeaderValue("Retry-After"));
        assertTrue(mockResponse.getWriterOutput().contains("\"status\":9"));

  }

  @Test
  fun receiveAndSendMultipleCookies() {
    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("Set-Cookie", "a=android")
        .addHeader("Set-Cookie", "b=banana")
        .build(),
    )
    server.enqueue(MockResponse())
    val cookieManager = CookieManager(null, CookiePolicy.ACCEPT_ORIGINAL_SERVER)
    client =
      client

    }
    response.append("</body></html>");

    return new MockResponse()
        .setStatus("HTTP/1.1 200")
        .addHeader("content-type: text/html; charset=utf-8")
        .setBody(response.toString());
  }

  private MockResponse fileToResponse(String path, File file) throws IOException {
    return new MockResponse()
        .setStatus("HTTP/1.1 200")
        .setBody(fileToBytes(file))

 */
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
import org.junit.jupiter.api.Assumptions.assumeTrue

    mockResponse = mockResponse.addHeader("", "")
    mockResponse = mockResponse.addHeaderLenient("", Any())
    mockResponse = mockResponse.setHeader("", Any())
    mockResponse.headers = headersOf()
    mockResponse.trailers = headersOf()
    mockResponse = mockResponse.removeHeader("")
    var body: Buffer? = mockResponse.getBody()
    mockResponse = mockResponse.setBody(Buffer())

        mockRequest = new TestHttpServletRequest();
        mockResponse = new TestHttpServletResponse();
        mockFilterChain = new TestFilterChain();
    }

    // Test with no Origin header
    @Test
    public void test_doFilter_noOriginHeader() throws IOException, ServletException {
        mockRequest.setHeader("Origin", null);

        corsFilter.doFilter(mockRequest, mockResponse, mockFilterChain);

import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import javax.net.ssl.X509TrustManager
import kotlin.time.Duration.Companion.minutes
import kotlin.time.Duration.Companion.nanoseconds
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import okhttp3.CertificatePinner.Companion.pin
import okhttp3.Headers.Companion.headersOf
import okhttp3.internal.connection.ConnectionListener

                        return this;
                    }

                    @Override
                    public CurlResponse execute() {
                        if (mockResponse != null) {
                            return mockResponse;
                        }
                        return createMockResponse(200, "{}");
                    }
                };
            }
        };