}

    def "parse symlinked Jar"(String symlinkName, String fileName, String version, String dependencyNotation) {
        def actualFile = tmpDir.file(fileName).touch()
        def symlinkFile = tmpDir.file(symlinkName).createLink(actualFile)

        def jar = GroovyJarFile.parse(symlinkFile)

        expect:
        jar != null
        jar.file == actualFile

	}

	if statusCode == 0 {
		statusCode = http.StatusOK
	}

	// Copy headers to rw's headers, after we've decided not to
	// go into handleInternalRedirect, which won't want its rw
	// headers to have been touched.
	for k, vv := range headers {
		for _, v := range vv {
			rw.Header().Add(k, v)
		}
	}

	rw.WriteHeader(statusCode)

	_, err = io.Copy(rw, linebody)
	if err != nil {

		})
		sds := a.Check(t, security.WorkloadKeyCertResourceName, security.RootCertReqResourceName)

		// Ensure we output the certs
		checkCertsWritten(t, dir)

		// The provisioning certificates should not be touched
		go sds[security.WorkloadKeyCertResourceName].DrainResponses()
		expectFileChanged(t, filepath.Join(dir, "cert-chain.pem"), filepath.Join(dir, "key.pem"))
	})

                        GFileUtils.mkdirs(workingDir);
                        // Update timestamp so that working directory is not garbage collected
                        GFileUtils.touch(baseDir);
                        delegate.populate(workingDir, ref, spec);
                        return workingDir;
                    } catch (Exception e) {

            lastCleanupTime = Instant.ofEpochMilli(gcFile.lastModified());
        }

        return cleanupFrequency.requiresCleanup(lastCleanupTime);
    }

    private void markCleanedUp() {
        GFileUtils.touch(getGcFile());
    }

    private File getGcFile() {
        File currentVersionCacheDir = versionSpecificCacheDirectoryScanner.getDirectory(GradleVersion.current());

    }

    @ToBeFixedForConfigurationCache
    def "includes build identifier in dependency resolution results with #display"() {
        repoC.file("a/.gitkeepdir").touch()
        repoC.file("settings.gradle") << """
            ${settings}
            include 'a'
        """
        repoC.file("build.gradle") << """
            allprojects { apply plugin: 'java-library' }

    }

    @ToBeFixedForConfigurationCache
    def "includes build identifier in dependency resolution results with #display"() {
        repo.file("a/.gitkeepdir").touch()
        repo.file("settings.gradle") << """
            ${settings}
            include 'a'
        """
        repo.file("build.gradle") << """
            allprojects { apply plugin: 'java-library' }

	group           singleflight.Group
	liveTTL         time.Duration
	// updatedQuotas holds a cache of quotas that we've updated.  This is used to pull the "really latest" during back to
	// back quota evaluations that touch the same quota doc.  This only works because we can compare etcd resourceVersions
	// for the same resource as integers.  Before this change: 22 updates with 12 conflicts.  after this change: 15 updates with 0 conflicts

        try {
            cache.open()
            dir.file("some-file").touch()
        } finally {
            cache.close()
        }

        return dir
    }

	if err := os.Chdir(d); err != nil {
		t.Fatalf("chtmpdir: %v", err)
	}
	return func() {
		if err := os.Chdir(oldwd); err != nil {
			t.Fatalf("chtmpdir: %v", err)
		}
		os.RemoveAll(d)
	}
}

func touch(t *testing.T, name string) {
	f, err := os.Create(name)
	if err != nil {
		t.Fatal(err)
	}
	if err := f.Close(); err != nil {
		t.Fatal(err)
	}
}

const (
	_AT_SYMLINK_NOFOLLOW = 0x100