The effect of this configuration would be that changes to `build-info.properties` would be ignored for both up-to-date checks and task output caching.

            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

.Setting Swift compiler options for all variants
====
include::sample[dir="snippets/swift/basic/kotlin",files="build.gradle.kts[tags=swift-compiler-options-all-variants]"]
include::sample[dir="snippets/swift/basic/groovy",files="build.gradle[tags=swift-compiler-options-all-variants]"]
====

    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.

        !file("build/generated/sources/annotationProcessor/java/main/AHelperResource.txt").exists()

        and:
        outputs.deletedFiles("AHelper")
    }

    def "all files are recompiled when processor changes"() {
        given:
        java "@Helper class A {}"
        outputs.snapshot { run "compileJava" }

        when:
        helperProcessor.suffix = "world"

                    }
                }
                buildTypes {
                    debug
                    release
                }
                components {
                    all {
                        targetPlatform "win32"
                        targetPlatform "x64"
                    }
                }
            }
        """
    }

    /**
     * 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

        hello(NativeLibrarySpec) {
            targetPlatform "x86"
        }
    }
    testSuites {
        helloTest(CUnitTestSuiteSpec) {
            testing \$.components.hello
            binaries.all {
                lib library: "cunit", linkage: "static"
            }
        }
    }
}
"""

        when:
        run "check"

        then:

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" }