implementation(project(":b"))
              implementation(project(":c"))
              implementation(project(":d"))
            }
        """

        expect:
        executer.noDeprecationChecks()
        succeeds(":a:classes", "--parallel")
        true
    }

    @Issue("https://github.com/gradle/gradle/issues/6735")
    def "can depend on the source set of another Java project"() {

            configurations.custom {
                preventUsageMutation()
                canBeResolved = !canBeResolved
            }
        """
        executer.noDeprecationChecks()

        expect:
        fails 'help'

        and:
        assertUsageLockedFailure('custom', displayName)

        where:

    }

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

    def "cannot annotate type 'java.net.URL' with @Input"() {

        executer.beforeExecute {
            executer.noDeprecationChecks()
            executer.withArgument("-Dorg.gradle.internal.max.validation.errors=20")
        }

        given:
        buildFile << """
            interface NestedBean {
                @Input

            configurations.$role('custom')
            configurations.custom.$methodCall
        """

        when:
        executer.noDeprecationChecks() // These will be checked elsewhere, this test is about ensuring failures
        fails('help')

        then:
        failureCauseContains(message)

        where:

            }
        """

        settingsFile << """
            rootProject.name = 'example-of-project-reference-in-test-suites'

            include("app")
        """
        executer.noDeprecationChecks()

        expect: "should be able to reference the project without failing"
        succeeds ':app:assemble', ':app:integrationTest'

        def files = findFiles(cacheDir, "files-*/**/*")
        files.size() == 2
        journal.assertExists()

        when:
        executer.noDeprecationChecks()
        run '--stop' // ensure daemon does not cache file access times in memory
        forceCleanup(gcFile)

        and:

    @Requires(IntegTestPreconditions.IsEmbeddedExecutor)
    def "cacheability for task with disabled optimizations is VALIDATION_FAILURE"() {
        when:
        executer.noDeprecationChecks()
        buildFile """
            import org.gradle.integtests.fixtures.validation.ValidationProblem
            import org.gradle.api.problems.Severity

            @CacheableTask

            .startLauncherInDebugger(opts -> debugLauncher.copyTo(opts))
            .withProfiler(profiler)
            .withForceInteractive(interactive);

        if (!checkDeprecations) {
            executer.noDeprecationChecks();
        }

        if (durationMeasurement != null) {
            executer.withDurationMeasurement(durationMeasurement);
        }

        if (consoleType != null) {

    }

    def "reports build listener registration on #registrationPoint"() {

        given:
        buildFile << code

        when:
        executer.noDeprecationChecks()
        configurationCacheFails 'help'

        then:
        outputContains("Configuration cache entry discarded with 1 problem.")
        problems.assertFailureHasProblems(failure) {

        withOriginalSourceIn("composite-lib")
    }

    def "can not use ResolvedArtifactResult as task input annotated with #annotation"() {

        executer.beforeExecute {
            executer.noDeprecationChecks() // Cannot convert the provided notation to a File or URI
            executer.withArgument("-Dorg.gradle.internal.max.validation.errors=20")
        }

        given:
        buildFile << """