// It has path "go" or "toolchain". The "go" repo reports versions like "1.2".
// The "toolchain" repo reports versions like "go1.2".
//
// Note that the repo ONLY reports versions. It does not actually support
// downloading of the actual toolchains. Instead, that is done using
// the regular repo code with "golang.org/toolchain".
// The naming conflict is unfortunate: "golang.org/toolchain"
// should perhaps have been "go.dev/dl", but it's too late.

		} else {
			defer os.RemoveAll(tmpDir)
		}
		cfg.BuildContext.GOPATH = tmpDir
	}

	cfg.GOPROXY = "direct"
	cfg.GOSUMDB = "off"
	modload.Init()

	// Shard tests by downloading only every nth module when shard flags are set.
	// This makes it easier to test small groups of modules quickly. We avoid
	// testing similarly named modules together (the list is sorted by module
	// path and version).

        """

        when:
        repositoryInteractions {
            'org:foo:1.0' {
                // HEAD requests happen in parallel when Gradle downloads metadata.
                // In this cases "downloading metadata" means testing for the artifact.
                // Each declaration is treated separately with it's own "consumer provided" metadata

                                && artifact.getDependencyTrail().size() == 1) {
                            logger.warn(
                                    "While downloading {}:{}:{}{}",
                                    pomArtifact.getGroupId(),
                                    pomArtifact.getArtifactId(),
                                    pomArtifact.getVersion(),

        // File resources are handled slightly differently at present.
        // file:// repos are treated differently
        // 1) we don't cache their files
        // 2) we don't do progress logging for "downloading"
        if (schemes.equals(Collections.singleton("file"))) {
            return createFileTransport(name);
        }

This is a key feature to create builds that are reliable and reproducible in any environment.

[[sub:cache_artifact_reuse]]
=== Artifact reuse

Before downloading an artifact, Gradle tries to determine the checksum of the required artifact by downloading the sha file associated with that artifact.
If the checksum can be retrieved, an artifact is not downloaded if an artifact already exists with the same id and checksum.

        configureB.parent == resolveCompileA
        resolveCompileA.children == [configureB]
    }

    @TargetGradleVersion(">=3.5 <4.0")
    def "generates events for downloading artifacts"() {
        given:
        def modules = setupBuildWithArtifactDownloadDuringConfiguration()

        def projectB = modules.projectB
        def projectC = modules.projectC

The following sections explain those categories.

=== Startup

This reflects Gradle’s initialization time, which consists mostly of:

- JVM initialization and class loading
- Downloading the Gradle distribution if you’re using the wrapper
- Starting the daemon if a suitable one isn’t already running
- Executing Gradle initialization scripts

echo "done"

if [ ! -f ./mc ]; then
	echo -n "Downloading MinIO client ..."
	wget -O mc https://dl.min.io/client/mc/release/linux-amd64/mc &&
		chmod +x mc
	echo "done"
fi

export MC_HOST_minio1=https://minio:minio123@localhost:9001

# go install m@v should use local toolchain if not upgrading
! go install rsc.io/fortune/nonexist@v1
! stderr go1.22.9
! stderr switching
stderr '^go: downloading rsc.io/fortune v1.0.0$'
stderr '^go: rsc.io/fortune/nonexist@v1: module rsc.io/fortune@v1 found \(v1.0.0\), but does not contain package rsc.io/fortune/nonexist'

# go run m@v should use local toolchain if not upgrading