}
            val combinations = buildList { combinations(typesToCheckOn, persistentListOf(), typeParameters.size) }
            check(combinations.size == typesToCheckOn.size.toDouble().pow(typeParameters.size).toInt())
            val allSubstitutors = buildList {
                combinations.forEach { typesPermutation ->

                                     "System.clearProperty(*['some.property'])",
                                     "clearProperty('some.property')",
                                 ], [false, true]].combinations()
        indyStatus = enableIndy ? "with indy" : "without indy"
    }

    def "#setProperties is instrumented in dynamic Groovy #indyStatus"() {
        def configurationCache = newConfigurationCacheFixture()

                processBuilder().java
            ],
            [
                "resolveCollection",
                "resolveProviders"
            ]
        ].combinations()
    }

    def "using #snippetsFactory.summary in transform action with #task of buildSrc build is not a problem"(SnippetsFactory snippetsFactory, String task) {
        given:
        createDir("buildSrc") {

        outputDoesNotContain '*foo.fail*'

        and:
        configurationCache.assertStateLoaded()

        where:
        [pattern, fileTree] << [fileTreeOperators(), fileTrees()].combinations()
        isZip = fileTree.toString().startsWith('zip')
    }

    private List<String> fileTrees() {
        [
            "fileTree(dir: 'src', include: '**/*.*')",
            "zipTree('src.zip')",
        ]

    def indyModes() {
        return [true, false]
    }

    final def testCasesWithIndyModes() {
        // Combine each test case with enableIndy=true and/or enableIndy=false
        return [testCases(), indyModes()].combinations().collect { it.flatten() }
    }

    def "#title is intercepted in groovy build script #indyStatus"(VarInitializer varInitializer) {
        given:
        def cwd = testDirectory.file(expectedPwdSuffix)

class ScriptChangeFixture {

    static List<Spec> specs() {
        [
            ScriptDiscovery.values(),
            ScriptLanguage.values(),
            ScriptType.values()
        ].combinations().collect { ScriptDiscovery d, ScriptLanguage l, ScriptType t ->
            new Spec(d, l, t)
        }
    }

    @Immutable
    static class Spec {
        ScriptDiscovery scriptDiscovery

                [new RootBuildLocation(), new IncludedBuildLocation()],
                [new RootBuildLocation(), new BuildSrcLocation(), new IncludedBuildLocation()],
            ]
        ].combinations().collect { language, locations ->
            new Spec(locations, language)
        }
    }

    static class Spec {

        final String copyTask = "copyTask"

import org.gradle.integtests.fixtures.KotlinDslTestUtil
import org.gradle.test.fixtures.file.TestFile

class BuildLogicChangeFixture {

    static List<Spec> specs() {
        [Kind.values(), Language.values()].combinations().collect { Kind kind, Language language ->
            new Spec(language, kind)
        }
    }

    @Immutable
    static class Spec {
        Language language
        Kind kind

        @Override

 *  <p>Codecs may be implemented:
 *  <ul>
 *  <li>as a custom class that implements both encoding and decoding protocols in the same class
 *  <li>based on the combination of arbitrary encoder and decoder functions, as done via {@link org.gradle.internal.serialize.graph.CombinatorsKt#codec(kotlin.jvm.functions.Function3, kotlin.jvm.functions.Function2) codec(...)}

        'validation:property-validation:conflicting-annotations' : 'Type has conflicting annotation',
        'validation:property-validation:ignored-property-must-not-be-annotated' : 'Has wrong combination of annotations',
        'validation:property-validation:implicit-dependency' : 'Property has implicit dependency',
        'validation:property-validation:incompatible-annotations' : 'Incompatible annotations',