issuer = (it[3] as Pair<*, *>).second as List<List<AttributeTypeAndValue>>,
          validity = it[4] as Validity,
          subject = (it[5] as Pair<*, *>).second as List<List<AttributeTypeAndValue>>,
          subjectPublicKeyInfo = it[6] as SubjectPublicKeyInfo,
          issuerUniqueID = it[7] as BitString?,
          subjectUniqueID = it[8] as BitString?,
          extensions = it[9] as List<Extension>,
        )
      },
    )

    // Make sure we have enough connection options to permit retries.
    dnsResults =
      listOf(
        localhostIpv4,
        localhostIpv6,
        TestUtil.UNREACHABLE_ADDRESS_IPV4.address,
      )
    serverIpv4.protocols = listOf(Protocol.H2_PRIOR_KNOWLEDGE)
    serverIpv6.protocols = listOf(Protocol.H2_PRIOR_KNOWLEDGE)

    // Yield the first IP address so the second IP address completes first.

            object : CookieManager() {
              override fun get(
                uri: URI,
                requestHeaders: Map<String, List<String>>,
              ) = mapOf(
                "COOKIE" to listOf("Bar=bar"),
                "cooKIE2" to listOf("Baz=baz"),
              )
            },
          ),
        ).build()
    server.enqueue(MockResponse())
    get(server.url("/"))

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
)

var port int

func init() {
	flag.IntVar(&port, "port", 8080, "Port to listen on")
}

func mainHandler(w http.ResponseWriter, r *http.Request) {
	body, err := io.ReadAll(r.Body)
	defer r.Body.Close()
	if err != nil {
		log.Printf("Error reading request body: %v", err)

	"fmt"
	"io"
	"net"
	"sync"
	"testing"
	"time"
)

// Test deadlineconn handles read timeout properly by reading two messages beyond deadline.
func TestBuffConnReadTimeout(t *testing.T) {
	l, err := net.Listen("tcp", "localhost:0")
	if err != nil {
		t.Fatalf("unable to create listener. %v", err)
	}
	defer l.Close()
	serverAddr := l.Addr().String()

	tcpListener, ok := l.(*net.TCPListener)
	if !ok {

  fun recordedRequest() {
    var recordedRequest: RecordedRequest =
      RecordedRequest(
        "",
        headersOf(),
        listOf(),
        0L,
        Buffer(),
        0,
        Socket(),
      )
    recordedRequest = RecordedRequest("", headersOf(), listOf(), 0L, Buffer(), 0, Socket())
    var requestUrl: HttpUrl? = recordedRequest.requestUrl
    var requestLine: String = recordedRequest.requestLine

        socket,
        socket.inetAddress.hostAddress,
        socket.port,
        true,
      ) as SSLSocket
    sslSocket.useClientMode = false
    Platform.get().configureTlsExtensions(sslSocket, null, listOf(Protocol.HTTP_2))
    sslSocket.startHandshake()
    return sslSocket
  }

  override fun onStream(stream: Http2Stream) {
    try {
      val requestHeaders = stream.takeHeaders()
      var path: String? = null

    assertThat(listOf(clientCertificate.certificate, clientIntermediate.certificate))
      .isEqualTo(serverHandshake.peerCertificates)
    assertThat(listOf(serverCertificate.certificate, serverIntermediate.certificate))
      .isEqualTo(serverHandshake.localCertificates)
    val clientHandshake = clientHandshakeFuture.get()
    assertThat(listOf(serverCertificate.certificate, serverIntermediate.certificate))

    
    public List<SmbFile> batchExists(List<String> paths) {
        // Group paths by parent directory
        Map<String, List<String>> pathsByParent = paths.stream()
            .collect(Collectors.groupingBy(this::getParentPath));
        
        List<SmbFile> results = new ArrayList<>();
        
        for (Map.Entry<String, List<String>> entry : pathsByParent.entrySet()) {

 * limitations under the License.
 */
package okhttp3.survey.types

data class Client(
  val userAgent: String,
  val version: String,
  val platform: String? = null,
  val enabled: List<SuiteId> = listOf(),
  val supported: List<SuiteId> = listOf(),
) {
  val nameAndVersion: String
    get() = "$userAgent/$version"