def taskOutput = getTaskOutput(result)
        taskOutput.contains('Starting test: MyTest > testExpectation')
        taskOutput.contains('Finishing test: MyTest > testExpectation')
    }

    def "can use setOf() in Kotlin DSL to configure logging no events"() {
        given:
        buildKotlinFile << testLoggingStandardStreamWithEmptyEventSet()

        file(JAVA_TEST_FILE_PATH) << javaTestClass {
            """

shadedJar {
    shadedConfiguration.exclude(mapOf("group" to "org.slf4j", "module" to "slf4j-api"))
    keepPackages = listOf("org.gradle.tooling")
    unshadedPackages = listOf("org.gradle", "org.slf4j", "sun.misc")
    ignoredPackages = setOf("org.gradle.tooling.provider.model")
}

errorprone {
    disabledChecks.addAll(
        "EqualsUnsafeCast", // 1 occurrences
        "FutureReturnValueIgnored", // 1 occurrences

    }

    fun renderAnnotationsWithMeta(analysisSession: KaSession, annotations: KaAnnotationList) = buildString {
        renderAnnotationsRecursive(analysisSession, annotations, currentMetaAnnotations = setOf(), indent = 0)
    }

    private fun StringBuilder.renderAnnotationsRecursive(
        analysisSession: KaSession,
        annotations: KaAnnotationList,
        currentMetaAnnotations: Set<ClassId>?,

    softwareTypeRegistry: SoftwareTypeRegistry
): InterpretationSequence =
    DefaultInterpretationSequence(
        listOf(
            SimpleInterpretationSequenceStepWithConversion("settingsPluginManagement", features = setOf(SettingsBlocksCheck.feature)) { pluginManagementEvaluationSchema() },
            PluginsInterpretationSequenceStep("settingsPlugins", targetScope, scriptSource) { settings.services },

import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.unwrapFakeOverridesOrDelegated

private val allowedFakeElementKinds = setOf(
    KtFakeSourceElementKind.FromUseSiteTarget,
    KtFakeSourceElementKind.PropertyFromParameter,
    KtFakeSourceElementKind.ItLambdaParameter,
    KtFakeSourceElementKind.EnumGeneratedDeclaration,

        private val operatorWithAssignmentVariant = setOf(
            OperatorNameConventions.PLUS,
            OperatorNameConventions.MINUS,
            OperatorNameConventions.TIMES,
            OperatorNameConventions.DIV,
            OperatorNameConventions.REM,
            OperatorNameConventions.MOD,
        )

        private val callArgErrors = setOf(
            Errors.ARGUMENT_PASSED_TWICE,

    targetSdk = 34
  }

  kotlinOptions {
    jvmTarget = JavaVersion.VERSION_11.toString()
  }

  // issue merging due to conflict with httpclient and something else
  packagingOptions.resources.excludes += setOf(
    "META-INF/DEPENDENCIES",
    "META-INF/LICENSE.md",
    "META-INF/LICENSE-notice.md",
    "README.txt",
    "org/bouncycastle/LICENSE"
  )
}

dependencies {
  implementation(libs.kotlin.reflect)

            gradleDslGeneralSchema()
        }

    override fun getTopLevelReceiverFromTarget(target: Any) = PluginsTopLevelReceiver()

    override val features: Set<InterpretationStepFeature>
        get() = setOf(SettingsBlocksCheck.feature)

    override fun whenEvaluated(resultReceiver: PluginsTopLevelReceiver) {
        val pluginRequests = resultReceiver.plugins.specs.map {

import kotlin.test.Test
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull

/** Runs the web platform ToAscii tests. */
class WebPlatformToAsciiTest {
  @Suppress("ktlint:standard:max-line-length")
  val knownFailures =
    setOf(
      // OkHttp rejects empty labels.
      "x..xn--zca",
      "x..ß",
      // OkHttp rejects labels longer than 63 code points, the web platform tests don't.

    outputs.file(outputFile)
    val values = embeddedKotlinBaseDependencies
    inputs.files(values)
    val skippedModules = setOf(project.name, "distributions-dependencies")
    // https://github.com/gradle/configuration-cache/issues/183
    val modules = provider {
        embeddedKotlinBaseDependencies.incoming.resolutionResult.allComponents