*/
        val testPathToBinaryResultsDirs: MapProperty<String, File>
    }

    private
    val projectPathToFailedTaskPaths: MutableMap<String, MutableList<String>> = mutableMapOf()

    private
    val projectPathToExecutedTaskPaths: MutableMap<String, MutableList<String>> = mutableMapOf()

    private
    val taskPathReports: Map<String, List<File>>
        get() = parameters.taskPathToReports.get()

    private

    object : CookieHandler() {
      override fun put(
        uri: URI?,
        responseHeaders: MutableMap<String, MutableList<String>>?,
      ) = TODO()

      override fun get(
        uri: URI?,
        requestHeaders: MutableMap<String, MutableList<String>>?,
      ): MutableMap<String, MutableList<String>> = TODO()
    }

  private fun newInterceptorChain(): Interceptor.Chain =

  class Builder() {
    internal var dispatcher: Dispatcher = Dispatcher()
    internal var connectionPool: ConnectionPool? = null
    internal val interceptors: MutableList<Interceptor> = mutableListOf()
    internal val networkInterceptors: MutableList<Interceptor> = mutableListOf()
    internal var eventListenerFactory: EventListener.Factory = EventListener.NONE.asFactory()
    internal var retryOnConnectionFailure = true

    server.enqueue(MockResponse(body = "DEF"))
    // Enqueue an additional response that show if we burnt a good prior response.
    server.enqueue(
      MockResponse(body = "XXX"),
    )
    val connections: MutableList<RealConnection?> = ArrayList()
    val localClient =
      client
        .newBuilder()
        .eventListener(
          object : EventListener() {
            override fun connectionAcquired(

          .build(),
      )
    assertThat(conditionalRequest.headers["If-Modified-Since"])
      .isEqualTo(lastModifiedDate)
  }

  @Test
  fun testPublicPathConstructor() {
    val events: MutableList<String> = ArrayList()
    fileSystem.createDirectories(cache.directoryPath)
    fileSystem.createDirectories(cache.directoryPath)
    val loggingFileSystem: FileSystem =
      object : ForwardingFileSystem(fileSystem) {

        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .inTunnel()
        .build(),
    )
    server.enqueue(MockResponse())
    val challengeSchemes: MutableList<String?> = ArrayList()
    val credential = basic("jesse", "password1")
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),