val name = namesAndValues[i]
    val value = namesAndValues[i + 1]
    headersCheckName(name)
    headersCheckValue(value, name)
  }

  return Headers(namesAndValues)
}

internal fun Map<String, String>.commonToHeaders(): Headers {
  // Make a defensive copy and clean it up.
  val namesAndValues = arrayOfNulls<String>(size * 2)
  var i = 0
  for ((k, v) in this) {
    val name = k.trim()

                maxIntermediateCas = maxIntermediateCas.toLong(),
              ),
          )
      }

      if (altNames.isNotEmpty()) {
        val extensionValue =
          altNames.map {
            when {
              it.canParseAsIpAddress() -> {
                generalNameIpAddress to InetAddress.getByName(it).address.toByteString()
              }
              else -> {

  private val subjectToCaCerts: Map<X500Principal, Set<X509Certificate>>

  init {
    val map = mutableMapOf<X500Principal, MutableSet<X509Certificate>>()
    for (caCert in caCerts) {
      map.getOrPut(caCert.subjectX500Principal) { mutableSetOf() }.add(caCert)
    }
    this.subjectToCaCerts = map
  }

  override fun findByIssuerAndSignature(cert: X509Certificate): X509Certificate? {

      "$prefix/samples/guide/src/main/java/okhttp3/recipes/kt",
    ).map { File(it) }

  return directories.flatMap {
    it.listFiles().orEmpty().filter { f -> f.isFile }.toList()
  }
}

internal class MainTestProvider : SimpleProvider() {
  override fun arguments(): List<Any> {
    val mainFiles = mainFiles()
    return mainFiles.map {
      val suffix = it.path.replace("${prefix}samples/guide/src/main/java/", "")

 * limitations under the License.
 */
package okhttp3.slack;

import java.io.Closeable;
import java.io.IOException;
import java.security.SecureRandom;
import java.util.LinkedHashMap;
import java.util.Map;
import okhttp3.HttpUrl;
import okhttp3.mockwebserver.Dispatcher;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import okio.ByteString;

      .build();
  private final Moshi moshi = new Moshi.Builder().build();
  private final JsonAdapter<Map<String, String>> mapJsonAdapter = moshi.adapter(
      Types.newParameterizedType(Map.class, String.class, String.class));

  public void run() throws Exception {
    Map<String, String> requestBody = new LinkedHashMap<>();
    requestBody.put("longUrl", "https://publicobject.com/2014/12/04/html-formatting-javadocs/");

import org.junit.jupiter.params.provider.Arguments
import org.junit.jupiter.params.provider.ArgumentsProvider

abstract class SimpleProvider : ArgumentsProvider {
  override fun provideArguments(context: ExtensionContext) = arguments().map { Arguments.of(it) }.stream()

  @Throws(Exception::class)
  abstract fun arguments(): List<Any>

  for ((name, value) in this) {
    builder.addLenient(name.utf8(), value.utf8())
  }
  return builder.build()
}

internal fun Headers.toHeaderList(): List<Header> =
  (0 until size).map {
    Header(name(it), value(it))
  }

/** Returns true if an HTTP request for this URL and [other] can reuse a connection. */
internal fun HttpUrl.canReuseConnectionFor(other: HttpUrl): Boolean =

  }

  @Test @Disabled
  fun challenge() {
    val challenge = Challenge("", mapOf("" to ""))
    val scheme: String = challenge.scheme()
    val authParams: Map<String?, String> = challenge.authParams()
    val realm: String? = challenge.realm()
    val charset: Charset = challenge.charset()
  }

  @Test @Disabled
  fun cipherSuite() {

    this.withLock {
      return Collections.unmodifiableList(readyAsyncCalls.map { it.call })
    }

  /** Returns a snapshot of the calls currently being executed. */
  fun runningCalls(): List<Call> =
    this.withLock {
      return Collections.unmodifiableList(runningSyncCalls + runningAsyncCalls.map { it.call })
    }

  fun queuedCallsCount(): Int = this.withLock { readyAsyncCalls.size }