}

    @Requires(UnitTestPreconditions.NotWindows)
    def "build fails if keystore cannot be created"() {
        given:
        def fs = NativeServicesTestFixture.instance.get(FileSystem)
        assert keyStoreDir.mkdir()
        fs.chmod(keyStoreDir, 0444)

        when:
        fails(*(["help", "--configuration-cache"] + encryptionOptions))

        then:

        when: 'task fails'
        buildFile '''
            tasks.register('fail') {
                doLast { assert false }
            }
        '''
        configurationCacheFails 'fail'

        then: 'flow action reacts to build failure'
        outputContains '(red)'
        configCache.assertStateStored()

        when: 'task from cache fails'
        configurationCacheFails 'fail'

        }

        where:
        exceptionHandlerDescritpion | exceptionHandlerImpl | expectedFailuresCount
        "rethrown"                  | "throw ex"           | 2  // The original exception propagates and fails the build, and configuration cache problem is reported too.
        "ignored"                   | "// ignored"         | 1  // Only the configuration cache problem is reported
    }

        assertThatDeclaredValuesAreSetProperly()

        when:
        file("build.gradle.dcl") << """
            testSoftwareType {
                nonPublic = "foo"
            }
        """
        fails(":printTestSoftwareTypeExtensionImplConfiguration")

        then:
        failure.assertThatCause(Matchers.containsString("Failed to interpret the declarative DSL file"))

        """

        when:
        isolatedProjectsRun("assemble")

        then:
        fixture.assertStateStored {
            projectsConfigured(":", ":a", ":b")
        }
    }

    def "fails on invoke method of unconfigured project"() {
        given:
        settingsFile << """
            include(':a')
            include(':b')
        """

        file("a/build.gradle") << """

     */
    private
    fun <C : Closeable, T : Closeable> safeWrap(innerSupplier: () -> C, unsafeWrapper: (C) -> T): T {
        // fine if we fail here
        val innerCloseable = innerSupplier()
        val outerCloseable = try {
            // but if we fail here, we need to ensure we close
            // the inner closeable, or else it will leak
            unsafeWrapper(innerCloseable)
        } catch (e: Throwable) {

            println(richReport.toText())
            block()
        }
    }

    /**
     * Runs the binary compatibility check against two source trees, but fails without generating a rich report.
     *
     * The fixture build supports both Java and Kotlin sources.
     *
     * @param v1 sources producer for V1, receiver is the `src/main` directory

        }
    """

    def 'reports #kind errors in project file'() {
        given:
        file("build.gradle.dcl") << bodyCode

        when:
        def failure = fails(":help")

        then:
        failure.assertHasErrorOutput(expectedMessage)

        where:
        kind               | bodyCode              | expectedMessage

 *
 * Our performance tests don't work with PTS, yet.
 * Smoke and soak tests are hard to grasp for PTS, that is why we run them without.
 * When running on Windows with PTS, SimplifiedKotlinScriptEvaluatorTest fails. See https://github.com/gradle/gradle-private/issues/3615.
 */
fun Project.supportsPredictiveTestSelection() = !isPerformanceProject() && !setOf("smoke-test", "soak", "kotlin-dsl", "smoke-ide-test").contains(name)

/**

        file("settings.gradle.dcl") << getDeclarativeSettingsScriptThatSetsConventions(convention)

        file("build.gradle.dcl") << getDeclarativeScriptThatConfiguresOnlyTestSoftwareType("")

        when:
        fails(":printTestSoftwareTypeExtensionConfiguration")

        then:
        result.assertHasErrorOutput("Value reassigned")

        where:
        testCase                                    | convention