external repository. Publishing configuration, such as a common group name for the libraries as well as the repository coordinates
might be a cross-cutting concern that both libraries need to share. For this example let's also say that we want to enforce that
our libraries expose some documentation with a common structure.

== Organizing build logic

> 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]

     * 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);

    /**

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

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

 */
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++) {

// See the License for the specific language governing permissions and
// limitations under the License.

[[resolution-strategy-safety-nets]]
= Preventing accidental dependency upgrades

In some situations, you might want to be in total control of the dependency graph.
In particular, you may want to make sure that:

- the versions declared in a build script actually correspond to the ones being resolved