) = apply {
    actions += { stream ->
      stream.sink.writeUtf8(s)
      stream.sink.flush()
      responseSent.countDown()
    }
  }

  fun exhaustResponse() =
    apply {
      actions += { stream -> stream.sink.close() }
    }

  fun sleep(
    duration: Long,
    unit: TimeUnit,
  ) = apply {
    actions += { Thread.sleep(unit.toMillis(duration)) }
  }

            final DefaultQueryBuilderFunction builder) {
        final DefaultQueryBuilder defaultQuery = createDefaultQueryBuilder();
        defaultQuery.add(builder.apply(fessConfig.getIndexFieldTitle(), fessConfig.getQueryBoostTitleAsDecimal().floatValue()));
        defaultQuery.add(builder.apply(fessConfig.getIndexFieldContent(), fessConfig.getQueryBoostContentAsDecimal().floatValue()));

    }

    open fun request(request: Request) =
      apply {
        this.request = request
      }

    open fun protocol(protocol: Protocol) =
      apply {
        this.protocol = protocol
      }

    open fun code(code: Int) =
      apply {
        this.code = code
      }

    open fun message(message: String) =
      apply {
        this.message = message
      }

  @StartStop val serverA =
    MockWebServer().apply {
      dispatcher = dispatcherA
    }

  private val dispatcherB = ClosableDispatcher()

  @StartStop val serverB =
    MockWebServer().apply {
      dispatcher = dispatcherB
    }

  /** This one won't start because it isn't annotated. */
  private val dispatcherC = ClosableDispatcher()
  val serverC =
    MockWebServer().apply {
      dispatcher = dispatcherC
    }

     */
    fun cookieJar(cookieJar: CookieJar) =
      apply {
        this.cookieJar = cookieJar
      }

    /** Sets the response cache to be used to read and write cached responses. */
    fun cache(cache: Cache?) =
      apply {
        this.cache = cache
      }

    internal fun taskRunner(taskRunner: TaskRunner) =
      apply {
        this.taskRunner = taskRunner
      }

    /**

      this.g = checkNotNull(g);
      this.f = checkNotNull(f);
    }

    @Override
    @ParametricNullness
    public C apply(@ParametricNullness A a) {
      return g.apply(f.apply(a));
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof FunctionComposition) {

            Element dependencies = plugin.child("dependencies").orElse(null);
            Element dependency = dependencies.child("dependency").orElse(null);

            // Apply dependency inference
            UpgradeContext context = createMockContext();
            strategy.apply(context, pomMap);

            // Verify version and groupId were removed from plugin dependency
            assertNull(dependency.child("version").orElse(null));

    }
}

class AndroidStudioProvisioningPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            val androidStudioProvisioningExtension = extensions
                .create("androidStudioProvisioning", AndroidStudioProvisioningExtension::class)
                .apply {
                    androidStudioVersion.convention(DEFAULT_ANDROID_STUDIO_VERSION)
                }

    }

    fun client(client: OkHttpClient) =
      apply {
        this.client = client
      }

    fun url(url: HttpUrl) =
      apply {
        this.url = url
      }

    fun includeIPv6(includeIPv6: Boolean) =
      apply {
        this.includeIPv6 = includeIPv6
      }

    fun post(post: Boolean) =
      apply {
        this.post = post
      }

        private
        fun newSimpleDateFormatUTC(pattern: String) = SimpleDateFormat(pattern).apply {
            timeZone = TimeZone.getTimeZone("UTC")
        }

        fun readBuildReceiptFromString(buildReceipt: String) =
            Properties().apply { load(buildReceipt.reader()) }

        const val buildReceiptFileName = "build-receipt.properties"