test: remove the Windows skips that are not needed

test/bundler/bun-build-api.test.ts

@@ -1061,14 +1061,12 @@ describe("Bun.build", () => {
   // descriptor in the resolver. A second in-process Bun.build() used to reuse a
   // descriptor the first build had already closed, failing with EBADF. The test
   // host must also import the package so its fd is cached before the builds run.
-  test.concurrent.skipIf(isWindows)(
-    "repeated in-process builds of a symlinked package do not reuse a closed fd",
-    async () => {
-      using dir = tempDir("build-symlink-fd-cache", {
-        "vendor/pkg/package.json": `{"name":"pkg","version":"1.0.0","type":"module","exports":"./index.js"}`,
-        "vendor/pkg/index.js": `export const value = 1;\n`,
-        "entry.ts": `import { value } from "pkg";\nconsole.log(value);\n`,
-        "repro.test.ts": `
+  test.concurrent("repeated in-process builds of a symlinked package do not reuse a closed fd", async () => {
+    using dir = tempDir("build-symlink-fd-cache", {
+      "vendor/pkg/package.json": `{"name":"pkg","version":"1.0.0","type":"module","exports":"./index.js"}`,
+      "vendor/pkg/index.js": `export const value = 1;\n`,
+      "entry.ts": `import { value } from "pkg";\nconsole.log(value);\n`,
+      "repro.test.ts": `
         import { it } from "bun:test";
         import { value } from "pkg";
         void value;
@@ -1082,22 +1080,21 @@ describe("Bun.build", () => {
           console.log("ALL_BUILDS_OK");
         });
       `,
-      });
-      mkdirSync(join(String(dir), "node_modules"), { recursive: true });
-      symlinkSync("../vendor/pkg", join(String(dir), "node_modules", "pkg"));
+    });
+    mkdirSync(join(String(dir), "node_modules"), { recursive: true });
+    symlinkSync("../vendor/pkg", join(String(dir), "node_modules", "pkg"));
 
-      await using proc = Bun.spawn({
-        cmd: [bunExe(), "test", "repro.test.ts"],
-        env: bunEnv,
-        cwd: String(dir),
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
-      expect(stdout + stderr).toContain("ALL_BUILDS_OK");
-      expect(exitCode).toBe(0);
-    },
-  );
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test", "repro.test.ts"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stdout + stderr).toContain("ALL_BUILDS_OK");
+    expect(exitCode).toBe(0);
+  });
 
   test.concurrent("errors are returned as an array", async () => {
     const x = await buildNoThrow({

test/cli/bake/bake.test.ts

@@ -464,8 +464,7 @@ test.concurrent.each([
   expect(response).toBe("200 1");
 });
 
-// Creating a symlink on Windows needs a privilege that CI does not have.
-test.concurrent.skipIf(isWindows)("bun bake serves pages that are symlinks or in a symlinked folder", async () => {
+test.concurrent("bun bake serves pages that are symlinks or in a symlinked folder", async () => {
   using dir = tempDir("bake-command-symlink", {
     "shared/page.html": `<!doctype html><html><body><h1>Shared</h1></body></html>`,
     "shared/docs/intro.html": `<!doctype html><html><body><h1>Intro</h1></body></html>`,
@@ -792,9 +791,8 @@ test.concurrent("bun bake runs the SIGTERM handlers before it starts again for b
   await output.waitFor(/SIGTERM before restart/);
 });
 
-// On a terminal, `bun bake` adds its own SIGTERM listener, which exits. Bun.spawn's `terminal` is
-// POSIX only.
-test.concurrent.skipIf(isWindows)(
+// On a terminal, `bun bake` adds its own SIGTERM listener, which exits.
+test.concurrent(
   "on a terminal, bun bake runs every SIGTERM listener before it starts again for bake.config.ts",
   async () => {
     const server = (version: string) => `

test/cli/check/check.test.ts

@@ -2911,7 +2911,7 @@ export const a: number[] = [file, one, two];
     });
 
     // Opening such a pipe blocks until a writer opens it. package.json is opened to look for a "check" script.
-    test.skipIf(isWindows)("doesn't hang when package.json is a symlink to a named pipe with no writer", async () => {
+    test("doesn't hang when package.json is a symlink to a named pipe with no writer", async () => {
       using dir = project({ "a.ts": `export {};\n` });
       expect(Bun.spawnSync(["mkfifo", join(String(dir), "pipe")]).exitCode).toBe(0);
       symlinkSync("pipe", join(String(dir), "package.json"));
@@ -3035,7 +3035,7 @@ export const a: number[] = [file, one, two];
       expect(exitCode).toBe(1);
     });
 
-    test.skipIf(process.platform === "win32")("ignores a named pipe in the project directory", async () => {
+    test("ignores a named pipe in the project directory", async () => {
       using dir = project({ "a.ts": `export const a: string = 1;\n` });
       // Reading a pipe without a writer blocks forever.
       expect(Bun.spawnSync(["mkfifo", join(String(dir), "pipe.ts")]).exitCode).toBe(0);
@@ -24276,28 +24276,25 @@ describe.concurrent("--check", () => {
   });
 
   // The path is compared as `bun run` spells it.
-  test.skipIf(isWindows)(
-    "`bun check` type checks in a `check` script started by a Bun that sets only BUN_INTERNAL_CHECK_SCRIPTS",
-    async () => {
-      using dir = project({
-        "package.json": JSON.stringify({ scripts: { check: "echo the script ran" } }),
-        "tsconfig.json": tsconfig,
-        "a.ts": `export const a: number = "1";\n`,
-      });
-      const cwd = String(dir);
-      const results = await Promise.all([
-        run(cwd, ["check", "--pretty", "false"], { BUN_INTERNAL_CHECK_SCRIPTS: `${Buffer.byteLength(cwd)}:${cwd}` }),
-        // Another package's path.
-        run(cwd, ["check", "--pretty", "false"], { BUN_INTERNAL_CHECK_SCRIPTS: `2:/x` }),
-      ]);
-      expect(
-        results.map(it => [it.stdout.includes("TS2322"), it.stdout.includes("the script ran"), it.exitCode]),
-      ).toEqual([
-        [true, false, 1],
-        [false, true, 0],
-      ]);
-    },
-  );
+  test("`bun check` type checks in a `check` script started by a Bun that sets only BUN_INTERNAL_CHECK_SCRIPTS", async () => {
+    using dir = project({
+      "package.json": JSON.stringify({ scripts: { check: "echo the script ran" } }),
+      "tsconfig.json": tsconfig,
+      "a.ts": `export const a: number = "1";\n`,
+    });
+    const cwd = String(dir);
+    const results = await Promise.all([
+      run(cwd, ["check", "--pretty", "false"], { BUN_INTERNAL_CHECK_SCRIPTS: `${Buffer.byteLength(cwd)}:${cwd}` }),
+      // Another package's path.
+      run(cwd, ["check", "--pretty", "false"], { BUN_INTERNAL_CHECK_SCRIPTS: `2:/x` }),
+    ]);
+    expect(
+      results.map(it => [it.stdout.includes("TS2322"), it.stdout.includes("the script ran"), it.exitCode]),
+    ).toEqual([
+      [true, false, 1],
+      [false, true, 0],
+    ]);
+  });
 
   test("--check with --filter, --parallel or --sequential checks the project before the scripts", async () => {
     using dir = project({

test/cli/create/create-jsx.test.ts

@@ -126,7 +126,7 @@ for (const development of [true, false]) {
         });
       });
 
-      test.todoIf(isCI || isWindows)("dev server", async () => {
+      test.todoIf(isCI)("dev server", async () => {
         console.log({ dir });
         await using process = Bun.spawn([bunExe(), "create", "./index.jsx"], {
           cwd: dir,
@@ -193,7 +193,7 @@ for (const development of [true, false]) {
         });
       });
 
-      test.todoIf(isCI || isWindows)("dev server", async () => {
+      test.todoIf(isCI)("dev server", async () => {
         const process = Bun.spawn([bunExe(), "create", "./index.tsx"], {
           cwd: dir,
           env: env,
@@ -259,7 +259,7 @@ for (const development of [true, false]) {
         });
       });
 
-      test.todoIf(isCI || isWindows)("dev server", async () => {
+      test.todoIf(isCI)("dev server", async () => {
         const process = Bun.spawn([bunExe(), "create", "./index.tsx"], {
           cwd: dir,
           env: env,

test/cli/format/format.test.ts

@@ -521,20 +521,17 @@ describe.concurrent("bun fmt", () => {
       expect(result.exitCode).toBe(0);
     });
 
-    // A file name can have at most 255 bytes. On Windows the path would also be too long.
-    test.skipIf(isWindows)(
-      "can have the longest possible name, and is still replaced rather than written in place",
-      async () => {
-        const name = `${Buffer.alloc(252, "a")}.ts`;
-        using dir = tempDir("bun-format", { [name]: ugly });
-        const before = statSync(join(String(dir), name)).ino;
-        const { exitCode } = await write(String(dir), []);
-        expect(read(String(dir), name)).toBe(formatted);
-        expect(statSync(join(String(dir), name)).ino).not.toBe(before);
-        expect(readdirSync(String(dir))).toEqual([name]);
-        expect(exitCode).toBe(0);
-      },
-    );
+    // A file name can have at most 255 bytes.
+    test("can have the longest possible name, and is still replaced rather than written in place", async () => {
+      const name = `${Buffer.alloc(252, "a")}.ts`;
+      using dir = tempDir("bun-format", { [name]: ugly });
+      const before = statSync(join(String(dir), name)).ino;
+      const { exitCode } = await write(String(dir), []);
+      expect(read(String(dir), name)).toBe(formatted);
+      expect(statSync(join(String(dir), name)).ino).not.toBe(before);
+      expect(readdirSync(String(dir))).toEqual([name]);
+      expect(exitCode).toBe(0);
+    });
 
     // For example in a container with a user's project mounted into it.
     test.skipIf(!isRoot)("keeps its owner if root formats it", async () => {
@@ -552,7 +549,7 @@ describe.concurrent("bun fmt", () => {
     });
 
     // Prettier doesn't need write access to the directory.
-    test.skipIf(isWindows || isRoot)("can be in a read-only directory", async () => {
+    test.skipIf(isRoot)("can be in a read-only directory", async () => {
       using dir = tempDir("bun-format", { "src/a.js": ugly });
       chmodSync(join(String(dir), "src"), 0o555);
       try {
@@ -5731,15 +5728,12 @@ exports.format = async text => "by Prettier";
     expect(result.exitCode).toBe(2);
   });
 
-  test.skipIf(isWindows)(
-    "/dev/null works as an ignore file without patterns and as a configuration without options",
-    async () => {
-      const files = { ".prettierignore": "a.js\n", ".prettierrc": `{ "semi": false }\n`, "a.js": formatted };
-      expect(await different(files, ["."])).toEqual([]);
-      expect(await different(files, ["--ignore-path", "/dev/null", "."])).toEqual(["a.js"]);
-      expect(await different(files, ["--ignore-path", "/dev/null", "--config", "/dev/null", "."])).toEqual([]);
-    },
-  );
+  test("/dev/null works as an ignore file without patterns and as a configuration without options", async () => {
+    const files = { ".prettierignore": "a.js\n", ".prettierrc": `{ "semi": false }\n`, "a.js": formatted };
+    expect(await different(files, ["."])).toEqual([]);
+    expect(await different(files, ["--ignore-path", "/dev/null", "."])).toEqual(["a.js"]);
+    expect(await different(files, ["--ignore-path", "/dev/null", "--config", "/dev/null", "."])).toEqual([]);
+  });
 
   // This means "never break a line". Prettier accepts every integer from 0 up, and Infinity.
   test.each([
@@ -6162,7 +6156,7 @@ exports.format = async text => "by Prettier";
     expect(result.exitCode).toBe(0);
   });
 
-  test.skipIf(isWindows)("a named pipe whose name ends in .js is skipped, like in Prettier", async () => {
+  test("a named pipe whose name ends in .js is skipped, like in Prettier", async () => {
     const before = (dir: string) => expect(Bun.spawnSync(["mkfifo", join(dir, "pipe.js")]).exitCode).toBe(0);
     expect(await different({ "a.js": ugly }, [], { before })).toEqual(["a.js"]);
   });
@@ -6634,7 +6628,7 @@ exports.format = async text => "by Prettier";
     // A case's guard used to be printed without a stack check, so the stack overflowed at depths between the printer's
     // limit and the parser's. The threads that format files have stack to spare, so this uses the main thread with half
     // of its usual stack.
-    test.skipIf(isWindows || isDebug || isASAN).concurrent.each([4_500, 4_612, 4_728, 4_846, 4_967, 5_091])(
+    test.skipIf(isDebug || isASAN).concurrent.each([4_500, 4_612, 4_728, 4_846, 4_967, 5_091])(
       "Flow's match with %d nested guards, on a 4 MB stack",
       async depth => {
         using dir = tempDir("bun-format-small-stack", {});

test/cli/format/oxfmt-cli/oxfmt-cli.test.ts

@@ -3,7 +3,7 @@
 // `--list-different` list.
 // `cases.json` is written by `test/cli/lint/oracle/driver/oxfmt-fixtures.mjs --record`.
 import { afterAll, describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, isWindows, tempDir } from "harness";
+import { bunEnv, bunExe, tempDir } from "harness";
 import { readFileSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { endChildren, spawn } from "../../children";
@@ -21,7 +21,7 @@ describe.concurrent("bun fmt behaves like oxfmt", () => {
   for (const it of cases) {
     const files = { ...(fixtures as Record<string, Files>)[it.name], ...it.gitignore } as Files;
     const links = Object.entries(files).filter(([, file]) => typeof file !== "string") as [string, { link: string }][];
-    test.skipIf(isWindows && links.length > 0)(`${it.name}/${it.index}: ${it.args.join(" ")}`, async () => {
+    test(`${it.name}/${it.index}: ${it.args.join(" ")}`, async () => {
       const texts = Object.entries(files).filter(([, file]) => typeof file === "string") as [string, string][];
       // Without a configuration file, `bun fmt` behaves like Prettier. An empty one above the fixtures makes it behave
       // like oxfmt.

test/cli/format/prettier-cli/prettier-cli.test.ts

@@ -4,7 +4,7 @@
 // input. `bun fmt` writes unless told otherwise, so Prettier was given `--write` where the command line only prints.
 // `cases.json` is written by `test/cli/lint/oracle/driver/prettier-fixtures.mjs --record`.
 import { afterAll, describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, isWindows, tempDir } from "harness";
+import { bunEnv, bunExe, tempDir } from "harness";
 import { readFileSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { endChildren, spawn } from "../../children";
@@ -25,7 +25,7 @@ describe.concurrent("bun fmt behaves like Prettier", () => {
     const links = Object.entries(files).filter(([, file]) => typeof file !== "string") as [string, { link: string }][];
     // Links, or a name that Windows doesn't allow.
     const needsPosix = links.length > 0 || Object.keys(files).some(name => /[<>:"|?*\\]/.test(name));
-    test.skipIf(isWindows && needsPosix)(`${it.test}: ${it.directory} $ ${it.args.join(" ")}`, async () => {
+    test(`${it.test}: ${it.directory} $ ${it.args.join(" ")}`, async () => {
       const texts = Object.entries(files).filter(([, file]) => typeof file === "string") as [string, string][];
       using dir = tempDir("prettier-cli", Object.fromEntries(texts.map(([name, text]) => [`${top}/${name}`, text])));
       for (const [name, { link }] of links) symlinkSync(link, join(String(dir), top, name));

test/cli/format/tailwind/tailwind.test.ts

@@ -5,7 +5,7 @@
 //
 // The order comes from the project's `tailwindcss` package. Here that's a stub that knows the classes in order.json.
 import { afterAll, describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, isLinux, isWindows, tempDir } from "harness";
+import { bunEnv, bunExe, isLinux, tempDir } from "harness";
 import { chmodSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { endChildren, spawn } from "../../children";
@@ -163,7 +163,7 @@ if (now.join() !== before.join()) throw new Error("There is " + now.filter(it =>
   });
 
   // As with Nix, an image layer owned by root, or a sandbox. Skipped as root, which can write anywhere.
-  test.skipIf(isWindows || process.getuid?.() === 0)("works with read-only packages", async () => {
+  test.skipIf(process.getuid?.() === 0)("works with read-only packages", async () => {
     using dir = tempDir("bun-format-tailwind", {
       ...version4,
       ".oxfmtrc.json": '{ "sortTailwindcss": {} }\n',

test/cli/hot/watch.test.ts

@@ -1,10 +1,10 @@
 import { spawn } from "bun";
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, forEachLine, isBroken, isWindows, tempDir } from "harness";
+import { bunEnv, bunExe, forEachLine, tempDir } from "harness";
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
-describe.todoIf(isBroken && isWindows)("--watch works", async () => {
+describe("--watch works", async () => {
   for (const watchedFile of ["entry.js", "tmp.js"]) {
     test(`with ${watchedFile}`, async () => {
       await using tmpdir_ = tempDir("watch-fixture", {

test/cli/inspect/BunFrontendDevServer.test.ts

@@ -3,7 +3,7 @@ import { decodeSerializedError } from "bake/error-serialization.ts";
 import { Subprocess, spawn } from "bun";
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import fs from "fs";
-import { bunExe, bunEnv as env, isPosix, tempDir, tmpdirSync } from "harness";
+import { bunExe, bunEnv as env, tempDir, tmpdirSync } from "harness";
 import path, { join } from "node:path";
 import { InspectorSession, connect } from "./junit-reporter";
 import { SocketFramer } from "./socket-framer";
@@ -72,7 +72,7 @@ class BunFrontendDevServerSession extends InspectorSession {
   }
 }
 
-describe.if(isPosix)("BunFrontendDevServer inspector protocol", () => {
+describe("BunFrontendDevServer inspector protocol", () => {
   let devServerProcess: Subprocess<"ignore", "pipe", "pipe">;
   let serverUrl: URL;
   let session: BunFrontendDevServerSession;

test/cli/inspect/test-reporter.test.ts

@@ -1,6 +1,6 @@
 import { Subprocess, spawn, write } from "bun";
 import { afterEach, describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, isPosix, tempDir } from "harness";
+import { bunEnv, bunExe, tempDir } from "harness";
 import { join } from "node:path";
 import { InspectorSession, connect } from "./junit-reporter";
 import { SocketFramer } from "./socket-framer";
@@ -165,7 +165,7 @@ class TestReporterSession extends InspectorSession {
   }
 }
 
-describe.if(isPosix)("TestReporter inspector protocol", () => {
+describe("TestReporter inspector protocol", () => {
   let proc: Subprocess<"ignore", "pipe", "pipe"> | undefined;
   let socket: ReturnType<typeof connect> extends Promise<infer T> ? T : never;
 

test/cli/install/bun-add-filter.test.ts

@@ -2408,7 +2408,7 @@ test.concurrent("remove --filter --dry-run touches nothing", async () => {
   expect(await exists(join(dir, "node_modules", "no-deps", "package.json"))).toBeTrue();
 });
 
-test.concurrent.skipIf(isWindows || isRoot)(
+test.concurrent.skipIf(isRoot)(
   "an unwritable target is reported by name, the rest is still written, exit code 1",
   async () => {
     const dir = await makeMonorepo();