test(child_process): add JS integration tests for exec and execFile

Add integration tests following the existing spawn test patterns:
- exec: 5 tests (stdout, options, stderr, nonexistent, maxBuffer)
- execFile: 7 tests (stdout, no args, options, nonexistent, exit code, maxBuffer, shell)

All tests use cross-platform commands (IS_WINDOWS checks) to ensure
compatibility with Windows CI.

Author: chessbyte

tests/unit/child_process.test.ts

@@ -9,7 +9,7 @@ it("node:child_process should be the same as child_process", () => {
   expect(defaultImport).toStrictEqual(legacyImport);
 });
 
-const { spawn } = defaultImport;
+const { spawn, exec, execFile } = defaultImport;
 
 describe("spawn", () => {
   it("should spawn a child process", (done) => {
@@ -227,3 +227,205 @@ describe("spawn", () => {
     });
   });
 });
+
+describe("exec", () => {
+  it("should execute a shell command and return stdout", (done) => {
+    exec("echo Hello", (error, stdout, stderr) => {
+      try {
+        expect(error).toBeNull();
+        expect(stdout.trim()).toEqual("Hello");
+        expect(stderr).toEqual("");
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+
+  it("should execute a command with options", (done) => {
+    const cwd = IS_WINDOWS ? process.cwd() : "/tmp";
+    const pwdCmd = IS_WINDOWS ? "cd" : "pwd";
+    exec(pwdCmd, { cwd }, (error, stdout, stderr) => {
+      try {
+        expect(error).toBeNull();
+        if (IS_WINDOWS) {
+          expect(stdout.trim().toLowerCase()).toContain(
+            process.cwd().toLowerCase()
+          );
+        } else {
+          expect(stdout.trim()).toContain("/tmp");
+        }
+        expect(stderr).toEqual("");
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+
+  it("should capture stderr on command failure", (done) => {
+    if (process.env._VIRTUAL_ENV) {
+      // QEMU may handle errors differently
+      return done();
+    }
+    // Use a command that writes to stderr and exits with error
+    const cmd = IS_WINDOWS
+      ? "cmd /c exit 1"
+      : "sh -c 'echo error >&2 && exit 1'";
+    exec(cmd, (error, stdout, stderr) => {
+      try {
+        expect(error).not.toBeNull();
+        expect(error!.code).toEqual(1);
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+
+  it("should handle nonexistent commands", (done) => {
+    if (process.env._VIRTUAL_ENV) {
+      // QEMU may handle errors differently
+      return done();
+    }
+    exec("nonexistent_command_12345", (error, stdout, stderr) => {
+      try {
+        expect(error).not.toBeNull();
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+
+  it("should respect maxBuffer option", (done) => {
+    // Generate output larger than maxBuffer
+    const cmd = IS_WINDOWS
+      ? 'cmd /c "echo AAAAAAAAAA"'
+      : "echo AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+    exec(cmd, { maxBuffer: 10 }, (error, stdout, stderr) => {
+      try {
+        expect(error).not.toBeNull();
+        expect(error!.message).toContain("maxBuffer");
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+});
+
+describe("execFile", () => {
+  it("should execute a file and return stdout", (done) => {
+    execFile("echo", ["Hello", "World"], (error, stdout, stderr) => {
+      try {
+        expect(error).toBeNull();
+        expect(stdout.trim()).toEqual("Hello World");
+        expect(stderr).toEqual("");
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+
+  it("should execute a file without arguments", (done) => {
+    const cmd = IS_WINDOWS ? "cmd" : "pwd";
+    const args = IS_WINDOWS ? ["/c", "cd"] : [];
+    execFile(cmd, args, (error, stdout, stderr) => {
+      try {
+        expect(error).toBeNull();
+        expect(stdout.length).toBeGreaterThan(0);
+        expect(stderr).toEqual("");
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+
+  it("should execute with options", (done) => {
+    const cwd = IS_WINDOWS ? process.cwd() : "/tmp";
+    const cmd = IS_WINDOWS ? "cmd" : "pwd";
+    const args = IS_WINDOWS ? ["/c", "cd"] : [];
+    execFile(cmd, args, { cwd }, (error, stdout, stderr) => {
+      try {
+        expect(error).toBeNull();
+        if (IS_WINDOWS) {
+          expect(stdout.trim().toLowerCase()).toContain(
+            process.cwd().toLowerCase()
+          );
+        } else {
+          expect(stdout.trim()).toContain("/tmp");
+        }
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+
+  it("should handle nonexistent executable", (done) => {
+    if (process.env._VIRTUAL_ENV) {
+      // QEMU may handle errors differently
+      return done();
+    }
+    execFile("nonexistent_command_12345", [], (error, stdout, stderr) => {
+      try {
+        expect(error).not.toBeNull();
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+
+  it("should handle executable failure with exit code", (done) => {
+    if (process.env._VIRTUAL_ENV) {
+      // QEMU may handle errors differently
+      return done();
+    }
+    const cmd = IS_WINDOWS ? "cmd" : "sh";
+    const args = IS_WINDOWS ? ["/c", "exit 42"] : ["-c", "exit 42"];
+    execFile(cmd, args, (error, stdout, stderr) => {
+      try {
+        expect(error).not.toBeNull();
+        expect(error!.code).toEqual(42);
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+
+  it("should respect maxBuffer option", (done) => {
+    execFile(
+      "echo",
+      ["AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"],
+      { maxBuffer: 10 },
+      (error, stdout, stderr) => {
+        try {
+          expect(error).not.toBeNull();
+          expect(error!.message).toContain("maxBuffer");
+          done();
+        } catch (err) {
+          done(err);
+        }
+      }
+    );
+  });
+
+  it("should execute with shell option", (done) => {
+    // When shell is true, execFile should use shell to execute
+    const cmd = IS_WINDOWS ? "echo %PATH%" : "echo $PATH";
+    execFile(cmd, [], { shell: true }, (error, stdout, stderr) => {
+      try {
+        expect(error).toBeNull();
+        expect(stdout.length).toBeGreaterThan(0);
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+});