}

            is FirSpreadArgumentExpression -> {
                expression.convertConstantExpression(builder)
            }

            is FirVarargArgumentsExpression -> {
                // Vararg arguments may have multiple independent expressions associated.
                // Choose one to be the representative PSI value for the entire assembled argument.

    allTasks.filter(unsupportedTasksPredicate).forEach { task ->
        task.notCompatibleWithConfigurationCache("Task is not compatible with the configuration cache")
    }
}


fun String.startsWithAnyOf(vararg prefixes: String): Boolean =
    prefixes.any { prefix -> startsWith(prefix) }

val Task.typeSimpleName: String

    companion object {
        fun of(container: ConfigurationContainer) =
            ConfigurationContainerScope(container)
    }

    override fun detachedConfiguration(vararg dependencies: Dependency): Configuration =
        delegate.detachedConfiguration(*dependencies)

    override fun resolvable(name: String): NamedDomainObjectProvider<ResolvableConfiguration> =
        delegate.resolvable(name)

# MinIO Deployment Quickstart Guide [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/)

  }

  @Test
  @Throws(Exception::class)
  fun completeBuilder() {
    val cacheControl =
      CacheControl.Builder()
        .noCache()
        .noStore()
        .maxAge(1.seconds)
        .maxStale(2.seconds)
        .minFresh(3.seconds)
        .onlyIfCached()
        .noTransform()
        .immutable()
        .build()
    assertThat(cacheControl.toString()).isEqualTo(

 *
 * @param T the plugin type.
 * @param targets the plugin target objects or collections of objects
 * @see [PluginAware.apply]
 */
inline fun <reified T : Plugin<*>> PluginAware.applyTo(vararg targets: Any) {
    apply {
        plugin(T::class.java)
        to(*targets)
    }

                CoreMatchers.equalTo("<command-line><init><init.d><settings>")
            )
        }
    }

    private
    fun buildWithGradleUserHome(gradleUserHomeDir: File, vararg arguments: String) =
        gradleExecuterFor(arguments)
            .withGradleUserHomeDir(gradleUserHomeDir)
            .withOwnUserHomeServices()
            .run()

    runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/typeParameters.kt");
  }

  @Test
  @TestMetadata("vararg.kt")
  public void testVararg() {
    runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/vararg.kt");
  }

  @Test
  @TestMetadata("where.kt")
  public void testWhere() {

        delegate.create(name)

    override fun <T : Task> create(name: String, type: Class<T>): T =
        delegate.create(name, type)

    override fun <T : Task> create(name: String, type: Class<T>, vararg constructorArgs: Any?): T =
        delegate.create(name, type, *constructorArgs)

    override fun <T : Task> create(name: String, type: Class<T>, configuration: Action<in T>): T =

   *
   * TODO: for sets, sort by tag when encoding.
   * TODO: for set ofs, sort by encoded value when encoding.
   */
  fun <T> sequence(
    name: String,
    vararg members: DerAdapter<*>,
    decompose: (T) -> List<*>,
    construct: (List<*>) -> T,
  ): BasicDerAdapter<T> {
    val codec =
      object : BasicDerAdapter.Codec<T> {