).isTrue()
    }

  fun assertFailure(vararg messages: String) =
    apply {
      assertThat(failure, "No failure found").isNotNull()
      assertThat(messages).contains(failure!!.message)
    }

  fun assertFailureMatches(vararg patterns: String) =
    apply {
      val message = failure!!.message!!
      assertThat(

  private val responseCookies: Deque<List<Cookie>> = ArrayDeque()

  fun enqueueRequestCookies(vararg cookies: Cookie) {
    requestCookies.add(cookies.toList())
  }

  fun takeResponseCookies(): List<Cookie> {
    return responseCookies.removeFirst()
  }

  fun assertResponseCookies(vararg cookies: String?) {
    assertThat(takeResponseCookies().map(Cookie::toString)).containsExactly(*cookies)
  }

fun Project.execAndGetStdout(workingDir: File, ignoreExitValue: Boolean, vararg args: String): String {
    val out = ByteArrayOutputStream()
    exec {
        isIgnoreExitValue = ignoreExitValue
        commandLine(*args)
        standardOutput = out
        this.workingDir = workingDir
    }
    return out.toString().trim()
}


fun Project.execAndGetStdoutIgnoringError(vararg args: String) = execAndGetStdout(File("."), true, *args)

   * strict than the others.
   */
  fun escapeForUri(vararg codePoints: Int) =
    apply {
      uriEscapedCodePoints.append(String(*codePoints))
    }

  /**
   * Configure code points to be stripped in conversion to `java.net.URI`. That class is more
   * strict than the others.
   */
  fun stripForUri(vararg codePoints: Int) =
    apply {
      uriStrippedCodePoints.append(String(*codePoints))

        fun assertHasInformation(vararg information: String) {
            assertThat("Has information", richReport.information.map { it.message }, CoreMatchers.equalTo(information.toList()))
        }

        fun assertHasAccepted(vararg accepted: String) {
            assertThat("Has accepted", richReport.accepted.map { it.message }, CoreMatchers.equalTo(accepted.toList()))
        }

  }

  private fun createSocketWithEnabledProtocols(vararg tlsVersions: TlsVersion): SSLSocket {
    return (handshakeCertificates.sslSocketFactory().createSocket() as SSLSocket).apply {
      enabledProtocols = javaNames(*tlsVersions)
    }
  }

  private fun assertEnabledProtocols(
    socket: SSLSocket,
    vararg required: TlsVersion,
  ) {

  override fun lookup(hostname: String): List<InetAddress> {
    requestedHosts.add(hostname)
    return hostAddresses[hostname] ?: throw UnknownHostException()
  }

  fun assertRequests(vararg expectedHosts: String?) {
    assertThat(requestedHosts).containsExactly(*expectedHosts)
    requestedHosts.clear()
  }

  /** Allocates and returns `count` fake IPv4 addresses like [255.0.0.100, 255.0.0.101].  */

import java.security.cert.X509Certificate
import javax.security.auth.x500.X500Principal

/** A simple index that of trusted root certificates that have been loaded into memory. */
class BasicTrustRootIndex(vararg caCerts: X509Certificate) : TrustRootIndex {
  private val subjectToCaCerts: Map<X500Principal, Set<X509Certificate>>

  init {
    val map = mutableMapOf<X500Principal, MutableSet<X509Certificate>>()

  try {
    for (url in urls) {
      sendRequest(client, url)
    }
  } finally {
    client.dispatcher.executorService.shutdownNow()
    client.connectionPool.evictAll()
  }
}

private fun buildClient(vararg specs: ConnectionSpec): OkHttpClient {
  return OkHttpClient.Builder()
    .connectionSpecs(listOf(*specs))
    .build()
}

private fun sendRequest(
  client: OkHttpClient,
  url: String,
) {

import org.gradle.api.tasks.bundling.Jar
import org.gradle.kotlin.dsl.dependencies
import org.gradle.kotlin.dsl.findByType
import org.gradle.kotlin.dsl.get
import org.gradle.kotlin.dsl.getByName

fun Project.applyOsgi(vararg bndProperties: String) {
  plugins.withId("org.jetbrains.kotlin.jvm") {
    applyOsgi("jar", "osgiApi", bndProperties)
  }
}

private fun Project.applyOsgi(
  jarTaskName: String,