if (publications.isEmpty()) {
            return VariantCoordinateResolver.fixed(getImplicitCoordinates(coordsType, project));
        }

        // For all published components, find those that are not children of other components.
        // These are the top-level publications.
        Set<ProjectComponentPublication> topLevel = new LinkedHashSet<>();

            lock.unlock();
        }

        // At this point:
        // If in daemon mode, the process has started successfully and all streams to the process have been closed
        // If in fork mode, the process has completed and all cleanup has been done
        // In both cases, all asynchronous work for the process has completed and we're done

        return result();
    }

    @Override

    a. If the attribute has a known precedence, Gradle will stop as soon as there is a single candidate remaining.
    b. After all extra attributes with precedence are considered, the remaining candidates can be chosen if they are compatible with all of the non-ordered disambiguation rules.

    /**
     * This method collects all source paths that will be passed to a compiler. While collecting paths it additionally also
     * collects all classes that are inside these sources, but were not detected as a dependency of changed classes.
     * This is important so all .class files that will be re-created are removed before compilation, otherwise

Such modules, that only have a name as module description, are called _automatic module_ that export **all** their packages and can read **all** modules on the module path.

A third case are traditional libraries that provide no module information at all -- for example `commons-cli:commons-cli:1.4`.
Gradle puts such libraries on the classpath instead of the module path.

            testing {
                suites {
                    test {
                        useTestNG('$version')
                        targets {
                            all {
                                testTask.configure {
                                    reports.junitXml.outputPerTestCase = true
                                    onOutput { test, event -> print "\$test -> \$event.message" }

    }

    @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

        """

        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:

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