public interface FlatDirectoryArtifactRepository extends ArtifactRepository {
    /**
     * Returns the directories where this repository will look for artifacts.
     *
     * @return The directories. Never null.
     */
    Set<File> getDirs();

    /**
     * Adds a directory where this repository will look for artifacts.
     *
     * <p>The provided value are evaluated as per {@link org.gradle.api.Project#file(Object)}.
     *

            mkdir()
            File(this, "gradle").writeText("stub")
            File(this, "gradle.exe").writeText("stub")
        }

        assertFails("Install directory $target does not look like a Gradle installation. Cannot delete it to install.")
        assertTargetIsPreserved()
    }

    @Test
    fun `does not install to non-empty dir with empty lib`() {
        target.resolve("bin").apply {

NOTE: Dependencies on other projects isn't covered in this guide.
To learn more about this subject, have a look at the https://github.com/gradle/native-samples/tree/master/cpp/transitive-dependencies[transitive dependency sample] for a demonstration.

NOTE: Publishing libraries to Maven repositories is outside the scope of this guide.

To learn more, have a look at their respective linked documentation to configure those IDE integration in your project.

== Run the application

Look inside the `build` folder and you will notice the appearance of an `exe` folder.
By convention, Gradle will place all applications in subfolders named according to the component name.

[short] skip
[compiler:gccgo] skip

# Test line numbers in cover errors.

# Get errors from a go test into stderr.txt
! go test coverbad
stderr 'p\.go:4:2' # look for error at coverbad/p.go:4
[cgo] stderr 'p1\.go:6:2' # look for error at coverbad/p.go:6
! stderr $WORK # make sure temporary directory isn't in error

cp stderr $WORK/stderr.txt

# Get errors from coverage into stderr2.txt
! go test -cover coverbad
cp stderr $WORK/stderr2.txt

# When all versions are replaced, we should not look up a deprecation message.
# We will still look up a deprecation message for the replacement.
cp go.mod.allreplaced go.mod
go list -m -u -f '{{.Path}}@{{.Version}} <{{.Deprecated}}>{{with .Replace}} => {{.Path}}@{{.Version}} <{{.Deprecated}}>{{end}}' all
stdout '^example.com/deprecated/a@v1.0.0 <> => example.com/deprecated/b@v1.0.0 <in example.com/deprecated/b@v1.9.0>$'

}

// shortcircuitBlock checks for a CFG in which an If block
// has as its control value a Phi that has a ConstBool arg.
// In some such cases, we can rewrite the CFG into a flatter form.
//
// (1) Look for a CFG of the form
//
//	p   other pred(s)
//	 \ /
//	  b
//	 / \
//	t   other succ
//
// in which b is an If block containing a single phi value with a single use (b's Control),

stderr 'preprofile.*default\.pgo'

# ... building a different package should not run preprofile again, instead
# using a profile from cache.
#
# Note we can't directly look for $GOCACHE in the regex below because the
# Windows slashes would need to be escaped. Instead just look for the "gocache"
# component (specified above) as an approximation.
go build -x -pgo=default.pgo lib2.go
! stderr 'preprofile.*default\.pgo'

====

A project can have multiple repositories. Gradle will look for a dependency in each repository in the order they are specified, stopping at the first repository that contains the requested module.

To find out more about defining repositories, have a look at <<declaring_repositories.adoc#declaring-repositories,Declaring Repositories>>.

[[sec:publishing_artifacts_java_tutorial]]

	// and then check that they don't appear in that
	// order in the deterministic seeded result.
	var out []int64
	for i := 0; i < 10; i++ {
		out = append(out, Int64())
	}

	// Look for out in seeded output.
	// Strictly speaking, we should look for them in order,
	// but this is good enough and not significantly more
	// likely to have a false positive.
	r := New(NewPCG(1, 0))
	found := 0
	for i := 0; i < 1000; i++ {