> Configure project :app
BUILD SCRIPT: This is executed during the configuration phase

BUILD SUCCESSFUL in 1s
13 actionable tasks: 6 executed, 7 up-to-date
----

[.text-right]

    private final AbstractFileCollection left;
    private final FileCollection right;

    public SubtractingFileCollection(AbstractFileCollection left, FileCollection right) {
        super(left.taskDependencyFactory, left.patternSetFactory);
        this.left = left;
        this.right = right;
    }

    public AbstractFileCollection getLeft() {
        return left;
    }

#   set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any
# character that might be a shell metacharacter, then use eval to reverse
# that process (while maintaining the separation between arguments), and wrap
# the whole thing up as a single "set" statement.
#

* Providing user-specific information (e.g., authentication credentials)
* Defining machine-specific details (e.g., JDK locations)
* Registering build listeners (e.g., external tools that wish to listen to Gradle events might find this helpful)
* Registering loggers (e.g., customize how Gradle logs the events that it generates)

        because("Smoke test preconditions are coming from here")
    }

    // This is a special dependency, as some of the preconditions might need a distribution.
    // E.g. see "IntegTestPreconditions.groovy"
    testImplementation(project(":distributions-core")) {
        because("Some preconditions might need a distribution to run against")
    }

    // ========================================================================

     * in either order: that is, if {@code left instanceof L && right instanceof R} or {@code left instanceof R && right instanceof L}.
     *
     * @param left an exclude spec
     * @param right another exclude spec
     * @return {@code true} if this intersection applies to the given exclude specs (in any order); {@code false} otherwise
     */
    boolean applies(ExcludeSpec left, ExcludeSpec right);

    /**

 */
private
fun sameType(left: DataType, right: DataType) = when (left) {
    is DataClass -> right is DataClass && left.name.qualifiedName == right.name.qualifiedName
    is DataType.BooleanDataType -> right is DataType.BooleanDataType
    is DataType.IntDataType -> right is DataType.IntDataType
    is DataType.LongDataType -> right is DataType.LongDataType
    is DataType.StringDataType -> right is DataType.StringDataType

        def hash = hasher.hash()
        hash != Hashing.hashString("abc")
    }

    def 'hash collision for bytes'() {
        def left = [[1, 2, 3], [4, 5]]
        def right = [[1, 2], [3, 4, 5]]
        expect:
        hashKey(left) != hashKey(right)
    }

    def 'hash collision for strings'() {
        expect:
        hashStrings(["abc", "de"]) != hashStrings(["ab", "cde"])
    }

import static org.gradle.internal.snapshot.PathUtil.getPathComparator

class CaseSensitiveVfsRelativePathTest extends AbstractCaseVfsRelativePathTest {

    def "finds right entry in sorted list with only case differences"() {
        def children = ["bAd", "BaD", "Bad"]
        children.sort(getPathComparator(CASE_SENSITIVE))
        expect:
        for (int i = 0; i < children.size(); i++) {

The Gradle team uses ADRs to record architectural decisions that the team has made.

See [Architecture decisions records](standards) for the list of ADRs.
Be aware these are very technical descriptions of the decisions, and you might find the documentation below more useful as an introduction to the internals of Gradle.

## Platform architecture

Gradle is arranged into several coarse-grained components called "platforms".