func HasAuto() bool {
	env := cfg.Getenv("GOTOOLCHAIN")
	return env == "auto" || strings.HasSuffix(env, "+auto")
}

// HasPath reports whether the GOTOOLCHAIN setting allows "path" upgrades.
func HasPath() bool {
	env := cfg.Getenv("GOTOOLCHAIN")
	return env == "path" || strings.HasSuffix(env, "+path")

            getRelativePath() >> RelativePath.parse(false, path)
            isDirectory() >> isDir
            isIncludeEmptyDirs() >> includeEmptyDirs
        }
    }

    private Matcher<FileCopyDetailsInternal> hasPath(final String path) {
        return new BaseMatcher<FileCopyDetailsInternal>() {
            void describeTo(Description description) {
                description.appendText("has path ").appendValue(path)
            }

class FileResolutionIntegrationTest extends AbstractIntegrationSpec {
    def "file conversion works with java.nio.file.Path"() {
        buildFile """
java.nio.file.Path fAsPath = buildDir.toPath().resolve('testdir').toAbsolutePath()
def f = file(fAsPath)
assert f == fAsPath.toFile()
"""

        expect:
        succeeds()
    }

    def "file conversion works with Provider of supported types"() {
        buildFile << """

        new HierarchicalAttributeContainer(attributesFactory, hasBoth, hasNone).hashCode() != new HierarchicalAttributeContainer(attributesFactory, hasBoth, hasOne).hashCode()

                def testFile = file("${'$'}buildDir/${'$'}name")
                executable = Jvm.current().getJavaExecutable()
                args '-cp', sourceSets.main.runtimeClasspath.asPath, 'org.gradle.TestMain', projectDir, testFile
                doLast {
                    assert testFile.exists()
                }
                assert delegate instanceof ExtensionAware
            }

    }

    default boolean hasData(MeasuredOperationList measuredOperations) {
        return !measuredOperations.getTotalTime().isEmpty();
    }

    default ExecutionGraph toExecutionGraph(PerformanceTestExecution execution, int index) {
        Line baseline = new Line(execution.getScenarios().stream().filter(this::hasData).findFirst().orElse(new MeasuredOperationList()));

		}
	}

	// Write out the length of the data.
	if spec.HasData {
		w.buf = binary.AppendUvarint(w.buf, uint64(len(e.Data)))
	}

	// Write out varint events.
	_, err := w.w.Write(w.buf)
	w.buf = w.buf[:0]
	if err != nil {
		return err
	}

	// Write out data.
	if spec.HasData {
		_, err := w.w.Write(e.Data)
		return err
	}
	return nil

// tag::use-classpath[]
tasks.register('check') {
    doLast {
        ant.taskdef(name: 'pmd',
                    classname: 'net.sourceforge.pmd.ant.PMDTask',
                    classpath: configurations.pmd.asPath)
        ant.pmd(shortFilenames: 'true',
                failonruleviolation: 'true',
                rulesetfiles: file('pmd-rules.xml').toURI().toString()) {
            formatter(type: 'text', toConsole: 'true')

    int getCount(String sessionId);

    void delete(String sessionId);

    void deleteAll();

    RESULT getAccessResult(String sessionId, String url);

    List<RESULT> getAccessResultList(String url, boolean hasData);

    void iterate(String sessionId, final AccessResultCallback<RESULT> accessResultCallback);

    @Override
    String getBuildFile(VariantContext variantContext) {
        return staticLibraryName("build/lib/main/${variantContext.asPath}${rootProjectName}")
    }

    @Override
    void makeSingleProject() {
        buildFile << """
            apply plugin: "cpp-library"
            library.linkage = [Linkage.STATIC]
        """
    }