* Fallback to {@literal javax.xml.bind.DatatypeConverter} from JAXB which is available starting with Java 6 but is not anymore in Java 9.
     * Fortunately, both of these two Base64 encoders implement the right Base64 flavor, the one that does not split the output in multiple lines.
     *
     * @param userInfo user info
     * @return Base64 encoded user info

     * since Maven doesn't have a "status" but infers it from the version instead, we can show
     * that we can provide a status to Maven dependencies and still use attribute matching
     * to use the right version.
     */
    def "can select the latest.#status version having release status"() {
        given:
        def versions = [
            '1': 'release',
            '2': 'milestone',

[[common-problems]]
= Solving common problems

Small problems in a build, like forgetting to declare a configuration file as an input to your task, can be easily overlooked.
The configuration file might change infrequently, or only change when some other (correctly tracked) input changes as well.
The worst that could happen is that your task doesn't execute when it should.

[[customizing_wrapper]]
== Customizing the Gradle Wrapper

Most users of Gradle are happy with the default runtime behavior of the Wrapper.
However, organizational policies, security constraints or personal preferences might require you to dive deeper into customizing the Wrapper.

Thankfully, the built-in `wrapper` task exposes numerous options to bend the runtime behavior to your needs.

        if (common) {
            common.each { inCommon ->
                diff.common.find { it.left == inCommon && it.right == inCommon }
            }
        }
        diff.rightOnly == rightOnlySet

        where:
        left      | right     | leftOnly  | rightOnly | common
        [1, 2, 3] | [2, 3, 4] | [1]       | [4]       | [2, 3]
        []        | []        | []        | []        | []

    def cleanup() {
        mostRecentReleaseExecuter.cleanup()
    }

    def setup() {
        buildFile << "apply plugin: 'base'\n"
        // When adding support for a new JDK version, the previous release might not work with it yet.
        Assume.assumeTrue(releasedVersionDistributions.mostRecentRelease.worksWith(Jvm.current()))
    }

    GradleVersion getMostRecentReleaseVersion() {

Resolving a configuration can have side effects on Gradle's project model.
As a result, Gradle must manage access to each project's configurations.
There are a number of ways a configuration might be resolved unsafely.
For example:

* A task from one project directly resolves a configuration in another project in the task's action.
* A task specifies a configuration from another project as an input file collection.

            if (includedBuildPrefix != null) {
                Path includedBuildPath = includedBuildPrefix.left;
                BuildState includedBuild = includedBuildPrefix.right;
                Path projectPath = path.removeFirstSegments(includedBuildPath.segmentCount());
                return findProjectOf(includedBuild, projectPath);
            }

    }

    private getTomlPath(String name) {
        def tomlResource = getClass().getResource("/org/gradle/api/internal/catalog/parser/${name}.toml").toURI()
        // Paths might be unusual, but we need it because of 1.8
        Paths.get(tomlResource)
    }

    @CompileStatic
    private static class DependencySpec {
        private final DependencyModel model

        list.index.asMap().size() == 2
        list.index.pendingAsMap.size() == 2

        filtered.index.asMap().size() == 1
        filtered.index.pendingAsMap.size() == 1

        expect: "list contains the right elements when iterated"
        filtered.asList() == ["realized2", "unrealized2"]

        and: "unrealized element get realized"
        container.index.asMap().size() == 4