* 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;

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>

    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 }

  }

  // Fails on JS, ClassCastException: Illegal cast
  @Test fun ofMapThrowsOnNull() {
    assertFailsWith<NullPointerException> {
      (mapOf("User-Agent" to null) as Map<String, String>).toHeaders()
    }
  }

  @Test fun toMultimapGroupsHeaders() {
    val headers =
      Headers.headersOf(
        "cache-control",
        "no-cache",
        "cache-control",

      }
    }
  }
  return null
}

/**
 * Inputs must have applied [withoutSectionSpans].
 */
internal fun sections(mappings: List<Mapping>): Map<Int, List<MappedRange>> {
  val result = mutableMapOf<Int, MutableList<MappedRange>>()

  for (mapping in mappings) {
    require(!mapping.spansSections)

    val section = mapping.section

          .toDouble(),
      )
        .isCloseTo(elapsedMs.toDouble(), 100.0)
    }

    return result
  }

  fun recordedEventTypes() = eventSequence.map { it.name }

  fun clearAllEvents() {
    while (eventSequence.isNotEmpty()) {
      takeEvent()
    }
  }

  private fun logEvent(e: CallEvent) {
    for (lock in forbiddenLocks) {

 *  New: ConnectionSpec can now be configured to use the SSL socket's default
    cipher suites. To use, set the cipher suites to `null`.
 *  New: Support `DELETE` with a request body.
 *  New: `Headers.of(Map)` creates headers from a Map.


## Version 2.2.0

_2014-12-30_

 *  **`RequestBody.contentLength()` now throws `IOException`.**
    This is a source-incompatible change. If you have code that calls

  }

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

  @Test

  }

  @Test fun regularMappings() {
    assertThat("hello".map()).isEqualTo("hello")
    assertThat("hello-world".map()).isEqualTo("hello-world")
    assertThat("HELLO".map()).isEqualTo("hello")
    assertThat("Hello".map()).isEqualTo("hello")

    // These compound characters map their its components.
    assertThat("¼".map()).isEqualTo("1⁄4")
    assertThat("™".map()).isEqualTo("tm")
  }

  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? {