}

    @Override
    public void enableUserStandardOutputListeners() {
        // Create all of the pipeline eagerly as soon as this is enabled, to track the state of build operations.
        // All of the pipelines do this, so should instead have a single stage that tracks this for all pipelines and that can replay the current state to new pipelines
        // Then, a pipeline can be added for each listener as required

        lateIncludedBuildTaskPosition < rootBuildFinishedPosition
    }

    @ToBeFixedForConfigurationCache(because = "build listener")
    def "fires build finished events for all builds when settings script for child build cannot be compiled"() {
        given:
        buildA.settingsFile << """
            gradle.buildFinished {
                println "build A finished"

        list.add(2, 'c')

        then:
        list == ['a', 'b', 'c']
    }

    def "fires events when element is added at index"() {
        Action<String> action = Mock()

        given:
        list.all(action)

        when:
        list.add(0, 'a')
        list.add(0, 'b')

        then:
        1 * action.execute('a')
        1 * action.execute('b')
        0 * action._
    }

        """

        m1.ivy.expectGet()
        m2.ivy.expectGet()
        m1.getArtifact(name: 'some-jar', type: 'jar').expectGet()

        expect:
        succeeds "resolve"
        // Currently builds all file dependencies
        executed ":lib:jar", ":lib:utilClasses", ":lib:utilDir", ":lib:utilJar", ":ui:jar", ":app:resolve"
    }

    @ToBeFixedForConfigurationCache

Use '--warning-mode all' to show the individual deprecation warnings.
See https://docs.gradle.org/6.0/userguide/command_line_interface.html#sec:command_line_warnings
```

The deprecation warnings show up in https://scans.gradle.com/s/txrptciitl2ha/deprecations[build scans] for every build, regardless of the command-line switches used.

When the build is executed with `--warning-mode all`, the individual warnings will be shown:

            """
            compilationDetails.outputFile = "\${project.name}-${name}-1.0.jar"

            spec.delegate = compilationDetails
            spec.call(compilationDetails)
            compilations[name] = compilationDetails
        }
    }

    def publishes(String component) {
        settingsFile << """
            include 'other'
        """

        return buildOperationRunner.call(new CallableBuildOperation<BuildCacheController>() {
            @Override
            public BuildCacheController call(BuildOperationContext context) {
                if (buildCacheState == BuildCacheMode.DISABLED) {
                    context.setResult(ResultImpl.disabled());

        build/tmp/teŝt files/** => $hiddenArtifactDestination/teŝt-files
        build/errorLogs/** => $hiddenArtifactDestination/errorLogs
        subprojects/internal-build-reports/build/reports/incubation/all-incubating.html => incubation-reports
        build/reports/dependency-verification/** => dependency-verification-reports
    """.trimIndent()

    paramsForBuildToolBuild(buildJvm, os, arch)
    params {

     */
    public void sign(Configuration... configurations) {
        for (Configuration configuration : configurations) {
            configuration.getAllArtifacts().all(artifact -> {
                if (artifact instanceof Signature || hasSignatureFor(artifact)) {
                    return;
                }
                signArtifact(artifact);
            });

        print(output.value)

        then:
        output.value == """
{failure}FAILURE: {normal}{failure}Build failed with an exception.{normal}

* What went wrong:
Could not resolve all task dependencies for org:example:1.0.
{info}> {normal}first failure
   {info}> {normal}ultimate cause
{info}> {normal}There is 1 more failure with an identical cause.

* Try:
$STACKTRACE
$INFO_OR_DEBUG