// Collect non-test files.
	dirFiles := make(map[string][]string)
	root := filepath.Join(testenv.GOROOT(t), "src")
	walkPkgDirs(root, func(dir string, filenames []string) {
		dirFiles[dir] = filenames
	}, t.Error)

	c := &stdlibChecker{
		dirFiles: dirFiles,
		pkgs:     make(map[string]*futurePackage),
	}

	start := time.Now()

	// Though we read files while parsing, type-checking is otherwise CPU bound.

	// CACertAndKeyBaseName defines certificate authority base name
	CACertAndKeyBaseName = "ca"
	// CACertName defines certificate name
	CACertName = "ca.crt"
	// CAKeyName defines certificate name
	CAKeyName = "ca.key"

	// APIServerCertAndKeyBaseName defines API's server certificate and key base name
	APIServerCertAndKeyBaseName = "apiserver"
	// APIServerCertName defines API's server certificate name
	APIServerCertName = "apiserver.crt"

)

const (
	// DefaultServiceDNSDomain defines default cluster-internal domain name for Services and Pods
	DefaultServiceDNSDomain = "cluster.local"
	// DefaultServicesSubnet defines default service subnet range
	DefaultServicesSubnet = "10.96.0.0/12"
	// DefaultClusterDNSIP defines default DNS IP
	DefaultClusterDNSIP = "10.96.0.10"
	// DefaultKubernetesVersion defines default kubernetes version
	DefaultKubernetesVersion = "stable-1"

        then:
        cachedClasspath.asFiles == [cachedFile]
        cachedFile.assertIsFile()

        and:
        1 * fileAccessTimeJournal.setLastAccessTime(cachedFile.parentFile, _)
        0 * fileAccessTimeJournal._

        when:
        def cachedClasspath2 = transformer.transform(classpath, BuildLogic)

        then:
        cachedClasspath2.asFiles == [cachedFile]

        and:

    }
}


internal
fun Encoder.writeDefaultClassPath(classPath: ClassPath) {
    writeCollection(classPath.asFiles) {
        writeFile(it)
    }
}


internal
fun Encoder.writeTransformedClassPath(classPath: TransformedClassPath) {
    writeCollection(classPath.asFiles.zip(classPath.asTransformedFiles)) {
        writeFile(it.first)
        writeFile(it.second)
    }
}


internal

        then:
        project.sourceDirectories.find {it.path == 'src/main/java' }.classpathAttributes.isEmpty()
    }

    @TargetGradleVersion(">=3.0 <4.4")
    def "Source folder defines one classpath attribute"() {
        settingsFile << 'rootProject.name = "root"'
        buildFile <<
            """apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {

		}
	}
}

func TestPackageDir(t *testing.T) {
	cases := []struct {
		input  *packages.Package
		expect string
	}{{
		input: &packages.Package{
			PkgPath:      "example.com/foo/bar/qux",
			GoFiles:      []string{"/src/prj/file.go"},
			IgnoredFiles: []string{"/otherdir/file.go"},
		},
		expect: filepath.Clean("/src/prj"),
	}, {
		input: &packages.Package{
			PkgPath:      "example.com/foo/bar/qux",

    def "uses modules to determine gradle API classpath"() {
        when:
        def classpath = provider.findClassPath("GRADLE_API")

        then:
        classpath.asFiles.collect{it.name} == [
            "gradle-worker-main-runtime",
            "gradle-launcher-runtime",
            "gradle-cli-runtime",
            "gradle-workers-runtime",

	}
	sort.Strings(p.AllTags)

	if len(p.CgoFiles) > 0 {
		p.SFiles = append(p.SFiles, Sfiles...)
		sort.Strings(p.SFiles)
	} else {
		p.IgnoredOtherFiles = append(p.IgnoredOtherFiles, Sfiles...)
		sort.Strings(p.IgnoredOtherFiles)
	}

	if badGoError != nil {
		return p, badGoError
	}
	if len(p.GoFiles)+len(p.CgoFiles)+len(p.TestGoFiles)+len(p.XTestGoFiles) == 0 {

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Base plugin for the maven and ivy publish plugins. Defines the publishing extension."

errorprone {
    disabledChecks.addAll(
        "InlineMeSuggester", // 7 occurrences
        "MixedMutabilityReturnType", // 5 occurrences
        "StringCaseLocaleUsage", // 1 occurrences
    )
}

dependencies {
    api(projects.serviceProvider)