"""
        settingsFile << """
            include 'a', 'b'
        """

        expect:
        fails("a:foo", "b:foo", "--parallel")

        // We just need to assert that the build fails with the right error message here, it doesn't matter which task is the first to fail,
        // allowing either failure to pass the test should reduce flakiness on CI.

        def docLinkMessage = getDocLinkMessage()

        builder.setBaseName("Gradle Worker Daemon");
        builder.setLogLevel(loggingManager.getLevel()); // NOTE: might make sense to respect per-compile-task log level
        builder.sharedPackages("org.gradle", "javax.inject");
        if (forkOptions.getClassLoaderStructure() instanceof FlatClassLoaderStructure) {

This allows to build the project without worrying about the credentials.
Try running `./gradlew jar` and it will succeed. Run `./gradlew publish` and it will tell you what is missing right away, without executing the build.
Credentials can and should be kept externally from the project sources and be known only by those having to publish artifacts, perhaps injected by a CI server.

        right.mapRight({ assert it == RIGHT; RIGHT2 }).right.get() == RIGHT2
        right.mapLeft({ assert false }).right.get() == RIGHT
    }

    def "fold() subsumes flatMap()"() {
        expect:
        left.fold({ assert it == LEFT; either(LEFT2) }, { assert false }).left.get() == LEFT2

        right.fold({ assert false }, { assert it == RIGHT; either(RIGHT2) }).right.get() == RIGHT2
    }

Documentation tasks
-------------------
javadoc - Generates Javadoc API documentation for the main source code.

...

Other tasks
-----------
compileJava - Compiles main Java source.

...
----
A task might be responsible for compilation, copying, and moving files around, creating JAR files, generating Javadoc, publishing artifacts to repositories, or many other discrete units of work.

WARNING: For the download URL only secure protocols like `https` are accepted.
This is required to make sure no one can tamper with the download in flight.

The plugins provide the mapping logic via an implementation of link:{javadocPath}/org/gradle/jvm/toolchain/JavaToolchainResolver.html[JavaToolchainResolver]:

.JavaToolchainResolverImplementation.java
[source,java]
----

        where:
        left     | right
        '\u1e9e' | 'ß'
        '\u03a3' | '\u03c2'
        '\u03a3' | '\u03c3'
    }

    def "can compare lower and upper case correctly (#left - #right = #result)"() {
        def char1 = left as char
        def char2 = right as char
        def caseInsensitiveResult = left.toUpperCase() == right.toUpperCase() ? 0 : result

        expect:

In this example, the main class (i.e., the point where the program's execution begins) is `com.example.Main`.

Consult the <<writing_build_scripts.adoc#writing_build_scripts,Writing Build Scripts>> page to learn more.

[.text-right]

            // Most of the time the artifactType registry has the same effect on the variant's attributes, but this isn't guaranteed.
            // It might be better to tighten this up by either requiring a single artifactType registry for the entire build or eliminating this feature
            // entirely.

    t.nestLeft(2).right == "a"
    t.nestRight(2).left == 1
    t.nestRight(2).right == Pair.of(2, "a")

    t.pushLeft(2).left == 2
    t.pushLeft(2).right == t
    t.pushRight(2).left == t
    t.pushRight(2).right == 2

    t.mapLeft { it + 1 }.left == 2
    t.mapLeft { it + 1 }.right == "a"
    t.mapRight { it * 2 }.left == 1
    t.mapRight { it * 2 }.right == "aa"