TEST(TestEnv, TestDirHandling) {
  TF_StringStream* tempdirs = TF_GetLocalTempDirectories();
  const char* tempdir;
  bool found = false;
  while (TF_StringStreamNext(tempdirs, &tempdir)) {
    found = true;

    TF_Status* s = TF_NewStatus();

    ::tensorflow::string dirpath =
        ::tensorflow::io::JoinPath(tempdir, "somedir");
    TF_CreateDir(dirpath.c_str(), s);

        HttpStatus.SC_HTTP_VERSION_NOT_SUPPORTED,
        511 // network authentication required
    ]

    @Rule
    HttpServer server = new HttpServer()
    @Rule
    TestNameTestDirectoryProvider tempDir = new TestNameTestDirectoryProvider(getClass())

    BuildCacheServiceFactory.Describer buildCacheDescriber
    HttpClientHelper.Factory httpClientHelperFactory = HttpClientHelper.Factory.createFactory(new DocumentationRegistry())

import (
	"io"
	"os"
	"path/filepath"
	"testing"

	"istio.io/istio/pkg/test/util/assert"
)

func copyTest(t *testing.T, copyFn func(srcFilepath, targetDir, targetFilename string) error) {
	t.Helper()
	d := t.TempDir()
	if err := os.WriteFile(filepath.Join(d, "in"), []byte("hello world"), 0o750); err != nil {
		t.Fatal(err)
	}
	if err := copyFn(filepath.Join(d, "in"), d, "out"); err != nil {
		t.Fatal(err)
	}

func main() {
	println(runtime.MemProfileRate)
}
`,
			"524288",
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			tempDir := t.TempDir()
			src := filepath.Join(tempDir, "x.go")
			if err := os.WriteFile(src, []byte(tt.prog), 0644); err != nil {
				t.Fatal(err)
			}
			cmd := testenv.Command(t, testenv.GoToolPath(t), "run", src)

		t.Errorf("TempDir error = %#v; want PathError for path %q satisfying IsNotExist", err, badDir)
	}
}

func TestMkdirTempBadPattern(t *testing.T) {
	t.Parallel()

	tmpDir, err := MkdirTemp("", t.Name())
	if err != nil {
		t.Fatal(err)
	}
	defer RemoveAll(tmpDir)

	const sep = string(PathSeparator)
	tests := []struct {
		pattern string

    createTemporaryDirectory("gradle-kotlin-dsl-", null).let { tempDir ->
        try {
            val tempFile = canonicalScriptFileFor(tempDir, scriptPath, scriptText)
            try {
                action(tempFile)
            } finally {
                tempFile.delete()
            }
        } finally {
            tempDir.delete()
        }
    }


private

import (
	"fmt"
	"os"
	"path/filepath"
	"testing"
	"time"
)

func TestLocalStorage(t *testing.T) {
	var localStorageStateFileName = "graceful_node_shutdown_state"
	tempdir := os.TempDir()
	path := filepath.Join(tempdir, localStorageStateFileName)
	l := localStorage{
		Path: path,
	}
	now := time.Now()
	want := state{
		StartTime: now,
		EndTime:   now,
	}
	err := l.Store(want)
	if err != nil {

 */

package org.gradle.api.internal.changedetection.state

import spock.lang.Specification
import spock.lang.TempDir

import org.gradle.api.internal.changedetection.state.LineEndingContentFixture as content

class LineEndingNormalizingInputStreamHasherTest extends Specification {
    @TempDir
    File tempDir

    def hasher = new LineEndingNormalizingInputStreamHasher()

}

func TestCache_GetFileFor_Empty(t *testing.T) {
	g := NewWithT(t)
	d := t.TempDir()
	t.Logf("Test Dir: %q", d)

	c := NewCache(d)

	f := c.GetFileFor(CacheKey{})
	g.Expect(f).To(BeEmpty())
}

func TestCache_Delete(t *testing.T) {
	g := NewWithT(t)
	d := t.TempDir()
	t.Logf("Test Dir: %q", d)

	c := NewCache(d)

	_, err := c.Apply(gateway)

	}
	outPath := filepath.Join(outDir, "bug-report.tar.gz")

	if !config.DryRun {
		common.LogAndPrintf("Creating an archive at %s.\n", outPath)
		archiveDir := archive.DirToArchive(tempDir)
		if tempDir != "" {
			archiveDir = tempDir
		}
		curTime = time.Now()
		err := archive.Create(archiveDir, outPath)
		fmt.Printf("Time used for creating the tar file is %v.\n", time.Since(curTime))
		if err != nil {
			return err