}
    configurations.classpath {
        resolutionStrategy.activateDependencyLocking()
    }
}
"""

        when:
        fails 'buildEnvironment'

        then:
        failureHasCause("Locking strict mode:")
    }

    def 'locks build script classpath combined with plugins (initial unique: #unique)'() {
        given:
        addPlugin()

            }
        '''
        file('src/main/java/Square.java') << 'public class Square extends Rectangle {}'

        when:
        fails 'compileJava'

        then:
        failureHasCause("Cannot specify -sourcepath or --source-path via `CompileOptions.compilerArgs`. Use the `CompileOptions.sourcepath` property instead.")
    }

    def "fails when processorpath is set on compilerArgs"() {

            configurations {
                $first("foo")
                $second("foo")
            }
        """

        when:
        fails "help"

        then:
        failureHasCause("Cannot add a configuration with name 'foo' as a configuration with that name already exists.")

        where:
        first             | second
        "consumable"      | "resolvable"

        settingsFile << """
            throw new RuntimeException("Boom")
        """

        when:
        withWatchFs().fails("help")
        then:
        failureHasCause("Boom")
    }

    def "detects when a task removes the build directory #buildDir"() {
        buildFile << """
            apply plugin: 'base'

            project.buildDir = file("${buildDir}")

        } else {
            failureHasCause("Failed to calculate the value of task ':failingTask' property 'stringInput'.")
        }
        failureHasCause("BOOM")
    }

    @ToBeFixedForConfigurationCache
    def "input and output properties are not evaluated too often"() {
        buildFile << """

        assertHasResult()
        tasks.each {
            result.assertTaskExecuted(it)
        }
    }

    protected void failureHasCause(String cause) {
        failure.assertHasCause(cause)
    }

    protected void failureHasCause(Pattern pattern) {
        failure.assertThatCause(matchesRegexp(pattern))
    }

    protected void failureDescriptionStartsWith(String description) {

                    }
                }
            }

            apply type: ComponentSpecContainerRules
        """

        when:
        fails "tasks"
        then:
        failureHasCause "Attempt to modify a read only view of model element 'components' of type '$projectionType' given to rule ComponentSpecContainerRules#addComponentTasks(TaskContainer, $projectionType)"

        where:

                        binaries {}
                    }
                }
            }
        """

        expect:
        fails "model"
        failureHasCause "Could not find method binaries()"
    }

    def "can define subtype of `ApplicationBinarySpec`"() {
        buildFile << """
@Managed
interface TheApp extends ApplicationSpec {}
@Managed

            "Use a Copy task with Task.doNotTrackState() instead. " +
            documentationRegistry.getDocumentationRecommendationFor("information", "incremental_build", "sec:disable-state-tracking"))
        failureHasCause("Failed to create MD5 hash for file '${unreadableOutput}' as it does not exist.")

        cleanup:
        unreadableOutput.makeReadable()
    }

    @Issue("https://github.com/gradle/gradle/issues/9586")

            }
        """

        when:
        executer.withStackTraceChecksDisabled()
        runAndFail "copy"
        then:
        expectUnreadableCopyDestinationFailure()
        failureHasCause(expectedError(unreadableOutput))

        cleanup:
        unreadableOutput.makeReadable()

        where:
        type        | create              | expectedError