.isEqualTo(
        list(certificate, intermediateCa, trusted),
      )
  }

  @Test
  fun chainMaxLength() {
    val heldCertificates = chainOfLength(10)
    val certificates: MutableList<Certificate> = ArrayList()
    for (heldCertificate in heldCertificates) {
      certificates.add(heldCertificate.certificate)
    }
    val root = heldCertificates[heldCertificates.size - 1].certificate

    return results.ifEmpty {
      throwBestFailure(hostname, failures)
    }
  }

  private fun executeRequests(
    hostname: String,
    networkRequests: List<Call>,
    responses: MutableList<InetAddress>,
    failures: MutableList<Exception>,
  ) {
    val latch = CountDownLatch(networkRequests.size)

    for (call in networkRequests) {
      call.enqueue(
        object : Callback {
          override fun onFailure(

            )
        }

        var prevStage: Stage? = null
        val previousPerformanceTestPasses: MutableList<PerformanceTestsPass> = mutableListOf()
        val previousCrossVersionTests: MutableList<BaseGradleBuildType> = mutableListOf()
        model.stages.forEach { stage ->
            if (isSecurityFork() && stage.stageName > StageName.READY_FOR_RELEASE) {

   */
  override fun toString(): String = commonToString()

  fun toMultimap(): Map<String, List<String>> {
    val result = TreeMap<String, MutableList<String>>(String.CASE_INSENSITIVE_ORDER)
    for (i in 0 until size) {
      val name = name(i).lowercase(Locale.US)
      var values: MutableList<String>? = result[name]
      if (values == null) {
        values = ArrayList(2)
        result[name] = values
      }

    List<String> mutableList = Lists.newArrayList("789", "123");
    Iterable<Long> convertedValues = STR_TO_LONG.convertAll(mutableList);
    assertEquals(ImmutableList.of(789L, 123L), ImmutableList.copyOf(convertedValues));

    Iterator<Long> iterator = convertedValues.iterator();
    iterator.next();
    iterator.remove();
    assertEquals(ImmutableList.of("123"), mutableList);
  }

  public void testReverse() {

 * Modifies [ranges] to combine any adjacent [MappedRange.InlineDelta] of same size to single entry.
 * @returns same instance of [ranges] for convenience
 */
internal fun mergeAdjacentDeltaMappedRanges(ranges: MutableList<MappedRange>): MutableList<MappedRange> {
  var i = 0
  while (i < ranges.size) {
    val curr = ranges[i]
    if (curr is MappedRange.InlineDelta) {
      val j = i + 1
      mergeAdjacent@ while (j < ranges.size) {

    applyConnectionSpec(tlsSpec, socket, isFallback = true)
    assertThat(socket.enabledProtocols).containsExactly(
      TlsVersion.TLS_1_2.javaName,
    )
    val expectedCipherSuites: MutableList<String> = ArrayList()
    expectedCipherSuites.add(CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.javaName)
    expectedCipherSuites.add(CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA.javaName)

  override fun setHandshakeApplicationProtocolSelector(selector: BiFunction<SSLSocket, MutableList<String>, String>?) {
    delegate!!.handshakeApplicationProtocolSelector = selector
  }

  override fun getHandshakeApplicationProtocolSelector(): BiFunction<SSLSocket, MutableList<String>, String> =
    delegate!!.handshakeApplicationProtocolSelector

 * limitations under the License.
 */
package okhttp3

import javax.net.ssl.HostnameVerifier
import javax.net.ssl.SSLSession

class RecordingHostnameVerifier : HostnameVerifier {
  @JvmField
  val calls: MutableList<String> = mutableListOf()

  @Synchronized override fun verify(
    hostname: String,
    session: SSLSession,
  ): Boolean {
    calls.add("verify $hostname")
    return true
  }

    Collection<String> c = MinimalCollection.of("a", "b", "a");
    List<String> list = ImmutableList.copyOf(c);
    assertEquals(asList("a", "b", "a"), list);
    List<String> mutableList = asList("a", "b");
    list = ImmutableList.copyOf(mutableList);
    mutableList.set(0, "c");
    assertEquals(asList("a", "b"), list);
  }

  public void testCopyOf_collectionContainingNull() {