stdout 'Go Gopher'

env GOPROXY=direct

! go mod download
stderr '^go: github\.com/golang/notexist/subdir@v0.1.0: reading github\.com/golang/notexist/subdir/go\.mod at revision subdir/v0\.1\.0: '

-- go.mod --
module test

go 1.18

require github.com/golang/notexist/subdir v0.1.0

-- $WORK/home/gopher/.gitconfig --
[user]
	name = Go Gopher
	email = ******@****.***
[url "******@****.***:"]

        def rootFile2 = root.createFile("rootFile2")
        def subdir = dir1.createDir("subdir")
        def subdirFile1 = subdir.createFile("subdirFile1")

        def unfiltered = fileSystemAccess.read(root.getAbsolutePath(), snapshottingFilter(new PatternSet())).get()

        expect:
        filteredPaths(unfiltered, include("**/*2")) == [root, dir1, dirFile2, subdir, rootFile2] as Set

chmod 0777 run.sh

! go list all
! stdout 'RAN SCRIPT'

cd subdir
! go list all
! stdout 'RAN SCRIPT'

-- go.mod --
module exploit

go 1.21
toolchain go1.999999-/run.sh
-- go1.999999-/run.sh --
#!/bin/sh
printf 'RAN SCRIPT\n'
exit 1
-- run.sh --
#!/bin/sh
printf 'RAN SCRIPT\n'
exit 1
-- subdir/go.mod --
module exploit

go 1.21
toolchain go1.999999-/../../run.sh

        def subDir = outputDir.createDir("subDir")
        outputFiles << subDir.file("in-subdir.txt")

        def outputFile = temporaryFolder.createFile("output.txt")
        outputFiles << outputFile

        outputFiles.each {
            it << "output ${it.name}"
        }

        def overlappingFile = subDir.file("overlap")
        overlappingFile << "overlapping file"

        expect:
        succeeds("test")
    }

    def writeJavaTestSource(String srcDir, String clazzName = "JavaClazz") {
        file(srcDir, "org/test/${clazzName}.java") << """
            package org.test;
            public class ${clazzName} { }
            """
    }

    def writeGroovyTestSource(String srcDir) {
        file(srcDir, 'org/test/SecurityTest.groovy') << """
            package org.test

                "bin",
                kotlinFilesIn(srcDir),
                loggerFor<ProjectAccessorsClassPathTest>(),
                classPath.asFiles
            )
        )
    }

    private
    fun kotlinFilesIn(srcDir: File) =
        srcDir.walkTopDown().filter { it.isFile && it.extension == "kt" }.toList()

    private

        destDir = project.file("destDir")
        depCacheDir = project.file("depCache")
        srcDir = project.file("src")
        srcDir.mkdirs()

        scalaCompile = createTask(ScalaCompile)
        scalaCompile.setCompiler(scalaCompiler)

        FileUtils.touch(new File(srcDir, "incl/file.scala"))
        FileUtils.touch(new File(srcDir, "incl/file.java"))
    }

    def "default values"() {
        given:

                    source.srcDir "src/main/comp-a"
                }
                compB(LibrarySourceSet) {
                    source.srcDir "src/main/comp-b"
                }
            }
            binaries {
                bin(SampleBinary) {
                    sources {
                        binaryA(LibrarySourceSet) {
                            source.srcDir "src/main/binary-a"
                        }

// tag::c-sources[]
            sources {
                c {
                    source {
                        srcDir "src/source"
                        include "**/*.c"
                    }
                    exportedHeaders {
                        srcDir "src/include"
                    }
                }
            }
// end::c-sources[]
        }
        main(NativeExecutableSpec) {

		// Don't require the source files to be present.
		if abs, err := filepath.Abs(srcDir); err == nil { // see issue 14282
			srcDir = abs
		}
		var bp *build.Package
		bp, err = build.Import(path, srcDir, build.FindOnly|build.AllowBinary)
		if bp.PkgObj == "" {
			if bp.Goroot && bp.Dir != "" {
				filename, err = lookupGorootExport(bp.Dir)
				if err == nil {
					_, err = os.Stat(filename)
				}