diff --git a/fs/walk_test.ts b/fs/walk_test.ts
index b0ff06a09f16..21690a06e240 100644
--- a/fs/walk_test.ts
+++ b/fs/walk_test.ts
@@ -6,16 +6,18 @@ import {
   assertRejects,
   assertThrows,
 } from "@std/assert";
+import { copy, copySync } from "./copy.ts";
 import { fromFileUrl, resolve } from "@std/path";
 
 const testdataDir = resolve(fromFileUrl(import.meta.url), "../testdata/walk");
 
 async function assertWalkPaths(
+  parentDir: string,
   rootPath: string,
   expectedPaths: string[],
   options?: WalkOptions,
 ) {
-  const root = resolve(testdataDir, rootPath);
+  const root = resolve(parentDir, rootPath);
   const entries = await Array.fromAsync(walk(root, options));
 
   const expected = expectedPaths.map((path) => resolve(root, path));
@@ -24,11 +26,12 @@ async function assertWalkPaths(
 }
 
 function assertWalkSyncPaths(
+  parentDir: string,
   rootPath: string,
   expectedPaths: string[],
   options?: WalkOptions,
 ) {
-  const root = resolve(testdataDir, rootPath);
+  const root = resolve(parentDir, rootPath);
   const entriesSync = Array.from(walkSync(root, options));
 
   const expected = expectedPaths.map((path) => resolve(root, path));
@@ -37,126 +40,196 @@ function assertWalkSyncPaths(
 }
 
 Deno.test("walk() returns current dir for empty dir", async () => {
-  const emptyDir = resolve(testdataDir, "empty_dir");
+  const tempDirPath = await Deno.makeTempDir({
+    prefix: "deno_std_walk_",
+  });
+  const emptyDir = resolve(tempDirPath, "empty_dir");
   await Deno.mkdir(emptyDir);
-  await assertWalkPaths("empty_dir", ["."]);
-  await Deno.remove(emptyDir);
+  await assertWalkPaths(tempDirPath, "empty_dir", ["."]);
+  await Deno.remove(tempDirPath, { recursive: true });
 });
 
-Deno.test("walkSync() returns current dir for empty dir", async () => {
-  const emptyDir = resolve(testdataDir, "empty_dir");
-  await Deno.mkdir(emptyDir);
-  assertWalkSyncPaths("empty_dir", ["."]);
-  await Deno.remove(emptyDir);
+Deno.test("walkSync() returns current dir for empty dir", () => {
+  const tempDirPath = Deno.makeTempDirSync({
+    prefix: "deno_std_walk_sync_",
+  });
+  const emptyDir = resolve(tempDirPath, "empty_dir");
+  Deno.mkdirSync(emptyDir);
+  assertWalkSyncPaths(tempDirPath, "empty_dir", ["."]);
+  Deno.removeSync(tempDirPath, { recursive: true });
 });
 
 Deno.test("walk() returns current dir and single file", async () =>
-  await assertWalkPaths("single_file", [".", "x"]));
+  await assertWalkPaths(testdataDir, "single_file", [".", "x"]));
 
 Deno.test("walkSync() returns current dir and single file", () =>
-  assertWalkSyncPaths("single_file", [".", "x"]));
+  assertWalkSyncPaths(testdataDir, "single_file", [".", "x"]));
 
 Deno.test("walk() returns current dir, subdir, and nested file", async () =>
-  await assertWalkPaths("nested_single_file", [".", "a", "a/x"]));
+  await assertWalkPaths(testdataDir, "nested_single_file", [".", "a", "a/x"]));
 
 Deno.test("walkSync() returns current dir, subdir, and nested file", () =>
-  assertWalkSyncPaths("nested_single_file", [".", "a", "a/x"]));
+  assertWalkSyncPaths(testdataDir, "nested_single_file", [".", "a", "a/x"]));
 
 Deno.test("walk() accepts maxDepth option", async () =>
-  await assertWalkPaths("depth", [".", "a", "a/b", "a/b/c"], { maxDepth: 3 }));
+  await assertWalkPaths(testdataDir, "depth", [".", "a", "a/b", "a/b/c"], {
+    maxDepth: 3,
+  }));
 
 Deno.test("walkSync() accepts maxDepth option", () =>
-  assertWalkSyncPaths("depth", [".", "a", "a/b", "a/b/c"], { maxDepth: 3 }));
+  assertWalkSyncPaths(testdataDir, "depth", [".", "a", "a/b", "a/b/c"], {
+    maxDepth: 3,
+  }));
 
 Deno.test("walk() accepts includeDirs option set to false", async () =>
-  await assertWalkPaths("depth", ["a/b/c/d/x"], { includeDirs: false }));
+  await assertWalkPaths(testdataDir, "depth", ["a/b/c/d/x"], {
+    includeDirs: false,
+  }));
 
 Deno.test("walkSync() accepts includeDirs option set to false", () =>
-  assertWalkSyncPaths("depth", ["a/b/c/d/x"], { includeDirs: false }));
+  assertWalkSyncPaths(testdataDir, "depth", ["a/b/c/d/x"], {
+    includeDirs: false,
+  }));
 
 Deno.test("walk() accepts includeFiles option set to false", async () =>
-  await assertWalkPaths("depth", [".", "a", "a/b", "a/b/c", "a/b/c/d"], {
+  await assertWalkPaths(testdataDir, "depth", [
+    ".",
+    "a",
+    "a/b",
+    "a/b/c",
+    "a/b/c/d",
+  ], {
     includeFiles: false,
   }));
 
 Deno.test("walkSync() accepts includeFiles option set to false", () =>
-  assertWalkSyncPaths("depth", [".", "a", "a/b", "a/b/c", "a/b/c/d"], {
+  assertWalkSyncPaths(testdataDir, "depth", [
+    ".",
+    "a",
+    "a/b",
+    "a/b/c",
+    "a/b/c/d",
+  ], {
     includeFiles: false,
   }));
 
 Deno.test("walk() accepts ext option as strings", async () =>
-  await assertWalkPaths("ext", ["y.rs", "x.ts"], {
+  await assertWalkPaths(testdataDir, "ext", ["y.rs", "x.ts"], {
     exts: [".rs", ".ts"],
   }));
 
 Deno.test("walk() accepts ext option as strings (excluding period prefix)", async () =>
-  await assertWalkPaths("ext", ["y.rs", "x.ts"], {
+  await assertWalkPaths(testdataDir, "ext", ["y.rs", "x.ts"], {
     exts: ["rs", "ts"],
   }));
 
 Deno.test("walkSync() accepts ext option as strings", () =>
-  assertWalkSyncPaths("ext", ["y.rs", "x.ts"], {
+  assertWalkSyncPaths(testdataDir, "ext", ["y.rs", "x.ts"], {
     exts: [".rs", ".ts"],
   }));
 
 Deno.test("walkSync() accepts ext option as strings (excluding period prefix)", () =>
-  assertWalkSyncPaths("ext", ["y.rs", "x.ts"], {
+  assertWalkSyncPaths(testdataDir, "ext", ["y.rs", "x.ts"], {
     exts: [".rs", ".ts"],
   }));
 
 Deno.test("walk() accepts ext option as regExps", async () =>
-  await assertWalkPaths("match", ["x", "y"], {
+  await assertWalkPaths(testdataDir, "match", ["x", "y"], {
     match: [/x/, /y/],
   }));
 
 Deno.test("walkSync() accepts ext option as regExps", () =>
-  assertWalkSyncPaths("match", ["x", "y"], {
+  assertWalkSyncPaths(testdataDir, "match", ["x", "y"], {
     match: [/x/, /y/],
   }));
 
 Deno.test("walk() accepts skip option as regExps", async () =>
-  await assertWalkPaths("match", [".", "z"], {
+  await assertWalkPaths(testdataDir, "match", [".", "z"], {
     skip: [/x/, /y/],
   }));
 
 Deno.test("walkSync() accepts skip option as regExps", () =>
-  assertWalkSyncPaths("match", [".", "z"], {
+  assertWalkSyncPaths(testdataDir, "match", [".", "z"], {
     skip: [/x/, /y/],
   }));
 
 // https://github.com/denoland/deno_std/issues/1358
 Deno.test("walk() accepts followSymlinks option set to true", async () =>
-  await assertWalkPaths("symlink", [".", "a", "a/z", "a", "a/z", "x", "x"], {
+  await assertWalkPaths(testdataDir, "symlink", [
+    ".",
+    "a",
+    "a/z",
+    "a",
+    "a/z",
+    "x",
+    "x",
+  ], {
     followSymlinks: true,
   }));
 
 Deno.test("walkSync() accepts followSymlinks option set to true", () =>
-  assertWalkSyncPaths("symlink", [".", "a", "a/z", "a", "a/z", "x", "x"], {
+  assertWalkSyncPaths(testdataDir, "symlink", [
+    ".",
+    "a",
+    "a/z",
+    "a",
+    "a/z",
+    "x",
+    "x",
+  ], {
     followSymlinks: true,
   }));
 
 Deno.test("walk() accepts followSymlinks option set to true with canonicalize option set to false", async () =>
-  await assertWalkPaths("symlink", [".", "a", "a/z", "b", "b/z", "x", "y"], {
+  await assertWalkPaths(testdataDir, "symlink", [
+    ".",
+    "a",
+    "a/z",
+    "b",
+    "b/z",
+    "x",
+    "y",
+  ], {
     followSymlinks: true,
     canonicalize: false,
   }));
 
 Deno.test("walkSync() accepts followSymlinks option set to true with canonicalize option set to false", () =>
-  assertWalkSyncPaths("symlink", [".", "a", "a/z", "b", "b/z", "x", "y"], {
+  assertWalkSyncPaths(testdataDir, "symlink", [
+    ".",
+    "a",
+    "a/z",
+    "b",
+    "b/z",
+    "x",
+    "y",
+  ], {
     followSymlinks: true,
     canonicalize: false,
   }));
 
 Deno.test("walk() accepts followSymlinks option set to false", async () => {
-  await assertWalkPaths("symlink", [".", "a", "a/z", "b", "x", "y"], {
+  await assertWalkPaths(testdataDir, "symlink", [
+    ".",
+    "a",
+    "a/z",
+    "b",
+    "x",
+    "y",
+  ], {
     followSymlinks: false,
   });
 });
 
 Deno.test("walkSync() accepts followSymlinks option set to false", () => {
-  assertWalkSyncPaths("symlink", [".", "a", "a/z", "b", "x", "y"], {
-    followSymlinks: false,
-  });
+  assertWalkSyncPaths(
+    testdataDir,
+    "symlink",
+    [".", "a", "a/z", "b", "x", "y"],
+    {
+      followSymlinks: false,
+    },
+  );
 });
 
 Deno.test("walk() rejects Deno.errors.NotFound for non-existent root", async () => {
@@ -177,14 +250,23 @@ Deno.test({
   name: "walk() walks unix socket",
   ignore: Deno.build.os === "windows",
   async fn() {
-    const path = resolve(testdataDir, "socket", "a.sock");
+    const tempDirPath = await Deno.makeTempDir({
+      prefix: "deno_std_walk_",
+    });
+    // Copy contents from "walk/socket" into temporary directory.
+    await copy(resolve(testdataDir, "socket"), resolve(tempDirPath, "socket"));
+    const path = resolve(tempDirPath, "socket", "a.sock");
     try {
       using _listener = Deno.listen({ path, transport: "unix" });
-      await assertWalkPaths("socket", [".", "a.sock", ".gitignore"], {
+      await assertWalkPaths(tempDirPath, "socket", [
+        ".",
+        "a.sock",
+        ".gitignore",
+      ], {
         followSymlinks: true,
       });
     } finally {
-      await Deno.remove(path);
+      await Deno.remove(tempDirPath, { recursive: true });
     }
   },
 });
@@ -193,15 +275,25 @@ Deno.test({
 Deno.test({
   name: "walkSync() walks unix socket",
   ignore: Deno.build.os === "windows",
-  async fn() {
-    const path = resolve(testdataDir, "socket", "a.sock");
+  fn() {
+    const tempDirPath = Deno.makeTempDirSync({
+      prefix: "deno_std_walk_sync_",
+    });
+    // Copy contents from "walk/socket" into temporary directory.
+    copySync(resolve(testdataDir, "socket"), resolve(tempDirPath, "socket"));
+    const path = resolve(tempDirPath, "socket", "a.sock");
     try {
       using _listener = Deno.listen({ path, transport: "unix" });
-      assertWalkSyncPaths("socket", [".", "a.sock", ".gitignore"], {
-        followSymlinks: true,
-      });
+      assertWalkSyncPaths(
+        tempDirPath,
+        "socket",
+        [".", "a.sock", ".gitignore"],
+        {
+          followSymlinks: true,
+        },
+      );
     } finally {
-      await Deno.remove(path);
+      Deno.removeSync(tempDirPath, { recursive: true });
     }
   },
 });
@@ -210,32 +302,47 @@ Deno.test({
   name: "walk() walks fifo files on unix",
   ignore: Deno.build.os === "windows",
   async fn() {
+    const tempDirPath = await Deno.makeTempDir({
+      prefix: "deno_std_walk_",
+    });
+    // Copy contents from "walk/fifo" into temporary directory.
+    await copy(resolve(testdataDir, "fifo"), resolve(tempDirPath, "fifo"));
     const command = new Deno.Command("mkfifo", {
-      args: [resolve(testdataDir, "fifo", "fifo")],
+      args: [resolve(tempDirPath, "fifo", "fifo")],
     });
     await command.output();
-    await assertWalkPaths("fifo", [".", "fifo", ".gitignore"], {
+    await assertWalkPaths(tempDirPath, "fifo", [".", "fifo", ".gitignore"], {
       followSymlinks: true,
     });
+    await Deno.remove(tempDirPath, { recursive: true });
   },
 });
 
 Deno.test({
   name: "walkSync() walks fifo files on unix",
   ignore: Deno.build.os === "windows",
-  async fn() {
+  fn() {
+    const tempDirPath = Deno.makeTempDirSync({
+      prefix: "deno_std_walk_sync_",
+    });
+    // Copy contents from "walk/fifo" into temporary directory.
+    copySync(resolve(testdataDir, "fifo"), resolve(tempDirPath, "fifo"));
     const command = new Deno.Command("mkfifo", {
-      args: [resolve(testdataDir, "fifo", "fifo")],
+      args: [resolve(tempDirPath, "fifo", "fifo")],
     });
-    await command.output();
-    assertWalkSyncPaths("fifo", [".", "fifo", ".gitignore"], {
+    command.outputSync();
+    assertWalkSyncPaths(tempDirPath, "fifo", [".", "fifo", ".gitignore"], {
       followSymlinks: true,
     });
+    Deno.removeSync(tempDirPath, { recursive: true });
   },
 });
 
 Deno.test("walk() rejects with `Deno.errors.NotFound` when root is removed during execution", async () => {
-  const root = resolve(testdataDir, "error");
+  const tempDirPath = await Deno.makeTempDir({
+    prefix: "deno_std_walk_",
+  });
+  const root = resolve(tempDirPath, "error");
   await Deno.mkdir(root);
   try {
     await assertRejects(
@@ -250,5 +357,7 @@ Deno.test("walk() rejects with `Deno.errors.NotFound` when root is removed durin
   } catch (err) {
     await Deno.remove(root, { recursive: true });
     throw err;
+  } finally {
+    await Deno.remove(tempDirPath, { recursive: true });
   }
 });