gsd-pi 2.8.3 → 2.10.0

package/packages/native/src/__tests__/grep.test.mjs

@@ -0,0 +1,162 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as fs from "node:fs";
+import * as os from "node:os";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+// Load the native addon directly
+const addonDir = path.resolve(__dirname, "..", "..", "..", "..", "native", "addon");
+const platformTag = `${process.platform}-${process.arch}`;
+const candidates = [
+  path.join(addonDir, `gsd_engine.${platformTag}.node`),
+  path.join(addonDir, "gsd_engine.dev.node"),
+];
+
+let native;
+for (const candidate of candidates) {
+  try {
+    native = require(candidate);
+    break;
+  } catch {
+    // try next
+  }
+}
+
+if (!native) {
+  console.error("Native addon not found. Run `npm run build:native -w @gsd/native` first.");
+  process.exit(1);
+}
+
+describe("native grep: search()", () => {
+  test("finds matches in buffer content", () => {
+    const content = Buffer.from("hello world\nfoo bar\nhello rust\n");
+    const result = native.search(content, { pattern: "hello" });
+
+    assert.equal(result.matchCount, 2);
+    assert.equal(result.matches.length, 2);
+    assert.equal(result.matches[0].line, "hello world");
+    assert.equal(result.matches[0].lineNumber, 1);
+    assert.equal(result.matches[1].line, "hello rust");
+    assert.equal(result.matches[1].lineNumber, 3);
+    assert.equal(result.limitReached, false);
+  });
+
+  test("supports case-insensitive search", () => {
+    const content = Buffer.from("Hello World\nhello world\nHELLO\n");
+    const result = native.search(content, {
+      pattern: "hello",
+      ignoreCase: true,
+    });
+
+    assert.equal(result.matchCount, 3);
+  });
+
+  test("respects maxCount limit", () => {
+    const content = Buffer.from("aaa\naaa\naaa\naaa\n");
+    const result = native.search(content, {
+      pattern: "aaa",
+      maxCount: 2,
+    });
+
+    assert.equal(result.matches.length, 2);
+    assert.equal(result.limitReached, true);
+  });
+
+  test("returns context lines", () => {
+    const content = Buffer.from("line1\nline2\nmatch_here\nline4\nline5\n");
+    const result = native.search(content, {
+      pattern: "match_here",
+      contextBefore: 1,
+      contextAfter: 1,
+    });
+
+    assert.equal(result.matches.length, 1);
+    assert.equal(result.matches[0].contextBefore.length, 1);
+    assert.equal(result.matches[0].contextBefore[0].line, "line2");
+    assert.equal(result.matches[0].contextAfter.length, 1);
+    assert.equal(result.matches[0].contextAfter[0].line, "line4");
+  });
+
+  test("throws on invalid regex", () => {
+    const content = Buffer.from("hello");
+    assert.throws(() => {
+      native.search(content, { pattern: "[invalid" });
+    });
+  });
+});
+
+describe("native grep: grep()", () => {
+  let tmpDir;
+
+  test("searches files on disk", (t) => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-grep-test-"));
+    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+    fs.writeFileSync(path.join(tmpDir, "file1.txt"), "hello world\nfoo bar\n");
+    fs.writeFileSync(path.join(tmpDir, "file2.txt"), "hello rust\nbaz qux\n");
+    fs.writeFileSync(path.join(tmpDir, "file3.log"), "no match here\n");
+
+    const result = native.grep({
+      pattern: "hello",
+      path: tmpDir,
+    });
+
+    assert.equal(result.totalMatches, 2);
+    assert.equal(result.filesWithMatches, 2);
+    assert.equal(result.matches.length, 2);
+
+    // Matches should be sorted by file path
+    const paths = result.matches.map((m) => m.path);
+    assert.deepEqual(paths, [...paths].sort());
+  });
+
+  test("respects glob filter", (t) => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-grep-test-"));
+    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+    fs.writeFileSync(path.join(tmpDir, "code.ts"), "hello typescript\n");
+    fs.writeFileSync(path.join(tmpDir, "code.js"), "hello javascript\n");
+    fs.writeFileSync(path.join(tmpDir, "readme.md"), "hello markdown\n");
+
+    const result = native.grep({
+      pattern: "hello",
+      path: tmpDir,
+      glob: "*.ts",
+    });
+
+    assert.equal(result.totalMatches, 1);
+    assert.equal(result.matches[0].line, "hello typescript");
+  });
+
+  test("respects maxCount", (t) => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-grep-test-"));
+    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+    for (let i = 0; i < 10; i++) {
+      fs.writeFileSync(path.join(tmpDir, `file${i}.txt`), "match_me\n");
+    }
+
+    const result = native.grep({
+      pattern: "match_me",
+      path: tmpDir,
+      maxCount: 3,
+    });
+
+    assert.ok(result.matches.length <= 3);
+    assert.equal(result.limitReached, true);
+  });
+
+  test("errors on non-existent path", () => {
+    assert.throws(() => {
+      native.grep({
+        pattern: "test",
+        path: "/nonexistent/path/that/does/not/exist",
+      });
+    });
+  });
+});

package/packages/native/src/__tests__/highlight.test.mjs

@@ -0,0 +1,156 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+// Load the native addon directly
+const addonDir = path.resolve(__dirname, "..", "..", "..", "..", "native", "addon");
+const platformTag = `${process.platform}-${process.arch}`;
+const candidates = [
+  path.join(addonDir, `gsd_engine.${platformTag}.node`),
+  path.join(addonDir, "gsd_engine.dev.node"),
+];
+
+let native;
+for (const candidate of candidates) {
+  try {
+    native = require(candidate);
+    break;
+  } catch {
+    // try next
+  }
+}
+
+if (!native) {
+  console.error("Native addon not found. Run `npm run build:native -w @gsd/native` first.");
+  process.exit(1);
+}
+
+const testColors = {
+  comment: "\x1b[38;2;106;153;85m",
+  keyword: "\x1b[38;2;197;134;192m",
+  function: "\x1b[38;2;220;220;170m",
+  variable: "\x1b[38;2;156;220;254m",
+  string: "\x1b[38;2;206;145;120m",
+  number: "\x1b[38;2;181;206;168m",
+  type: "\x1b[38;2;78;201;176m",
+  operator: "\x1b[38;2;212;212;212m",
+  punctuation: "\x1b[38;2;212;212;212m",
+};
+
+describe("native highlight: highlightCode()", () => {
+  test("highlights JavaScript code with ANSI colors", () => {
+    const code = 'const x = 42;\n';
+    const result = native.highlightCode(code, "javascript", testColors);
+
+    // Result should contain ANSI escape sequences
+    assert.ok(result.includes("\x1b["), "should contain ANSI escape codes");
+    // Result should contain the original tokens
+    assert.ok(result.includes("const"), "should contain 'const'");
+    assert.ok(result.includes("42"), "should contain '42'");
+    // Reset codes should be present
+    assert.ok(result.includes("\x1b[39m"), "should contain ANSI reset codes");
+  });
+
+  test("returns unhighlighted code for unknown language", () => {
+    const code = "some random text\n";
+    const result = native.highlightCode(code, "nonexistent_lang_xyz", testColors);
+
+    // Plain text syntax should pass through without color codes on plain content
+    assert.ok(typeof result === "string");
+    assert.ok(result.includes("some random text"));
+  });
+
+  test("handles null language gracefully", () => {
+    const code = "hello world\n";
+    const result = native.highlightCode(code, null, testColors);
+
+    assert.ok(typeof result === "string");
+    assert.ok(result.includes("hello world"));
+  });
+
+  test("handles empty code", () => {
+    const result = native.highlightCode("", "javascript", testColors);
+    assert.equal(result, "");
+  });
+
+  test("handles multiline code", () => {
+    const code = 'function foo() {\n  return "bar";\n}\n';
+    const result = native.highlightCode(code, "javascript", testColors);
+
+    assert.ok(result.includes("function"));
+    assert.ok(result.includes("foo"));
+    assert.ok(result.includes("return"));
+    assert.ok(result.includes("bar"));
+  });
+
+  test("supports optional inserted/deleted colors", () => {
+    const colorsWithDiff = {
+      ...testColors,
+      inserted: "\x1b[38;2;0;255;0m",
+      deleted: "\x1b[38;2;255;0;0m",
+    };
+    const code = "+added line\n-removed line\n";
+    const result = native.highlightCode(code, "diff", colorsWithDiff);
+
+    assert.ok(typeof result === "string");
+    assert.ok(result.length > 0);
+  });
+});
+
+describe("native highlight: supportsLanguage()", () => {
+  test("returns true for known aliases", () => {
+    assert.ok(native.supportsLanguage("javascript"));
+    assert.ok(native.supportsLanguage("typescript"));
+    assert.ok(native.supportsLanguage("python"));
+    assert.ok(native.supportsLanguage("rust"));
+    assert.ok(native.supportsLanguage("go"));
+    assert.ok(native.supportsLanguage("bash"));
+  });
+
+  test("returns true case-insensitively", () => {
+    assert.ok(native.supportsLanguage("JavaScript"));
+    assert.ok(native.supportsLanguage("PYTHON"));
+    assert.ok(native.supportsLanguage("Rust"));
+  });
+
+  test("returns true for short aliases", () => {
+    assert.ok(native.supportsLanguage("ts"));
+    assert.ok(native.supportsLanguage("py"));
+    assert.ok(native.supportsLanguage("rs"));
+    assert.ok(native.supportsLanguage("rb"));
+    assert.ok(native.supportsLanguage("sh"));
+  });
+
+  test("returns false for completely unknown languages", () => {
+    assert.equal(native.supportsLanguage("nonexistent_lang_xyz"), false);
+  });
+});
+
+describe("native highlight: getSupportedLanguages()", () => {
+  test("returns an array of language names", () => {
+    const langs = native.getSupportedLanguages();
+    assert.ok(Array.isArray(langs));
+    assert.ok(langs.length > 0, "should have at least one language");
+  });
+
+  test("includes common languages", () => {
+    const langs = native.getSupportedLanguages();
+    // These are syntect default syntax names
+    assert.ok(langs.includes("JavaScript"), "should include JavaScript");
+    assert.ok(langs.includes("Python"), "should include Python");
+    assert.ok(langs.includes("Rust"), "should include Rust");
+    assert.ok(langs.includes("C"), "should include C");
+  });
+
+  test("returns strings", () => {
+    const langs = native.getSupportedLanguages();
+    for (const lang of langs) {
+      assert.equal(typeof lang, "string");
+    }
+  });
+});

package/packages/native/src/__tests__/html.test.mjs

@@ -0,0 +1,98 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+const addonDir = path.resolve(__dirname, "..", "..", "..", "..", "native", "addon");
+const platformTag = `${process.platform}-${process.arch}`;
+const candidates = [
+  path.join(addonDir, `gsd_engine.${platformTag}.node`),
+  path.join(addonDir, "gsd_engine.dev.node"),
+];
+
+let native;
+for (const candidate of candidates) {
+  try {
+    native = require(candidate);
+    break;
+  } catch {
+    // try next
+  }
+}
+
+if (!native) {
+  console.error("Native addon not found. Run `npm run build:native -w @gsd/native` first.");
+  process.exit(1);
+}
+
+describe("native html: htmlToMarkdown()", () => {
+  test("converts basic HTML to markdown", () => {
+    const html = "<h1>Hello</h1><p>World</p>";
+    const result = native.htmlToMarkdown(html);
+    assert.ok(result.includes("Hello"), "Should contain heading text");
+    assert.ok(result.includes("World"), "Should contain paragraph text");
+  });
+
+  test("converts links to markdown links", () => {
+    const html = '<p>Visit <a href="https://example.com">Example</a></p>';
+    const result = native.htmlToMarkdown(html);
+    assert.ok(result.includes("[Example]"), "Should contain markdown link text");
+    assert.ok(result.includes("(https://example.com)"), "Should contain markdown link URL");
+  });
+
+  test("converts lists to markdown", () => {
+    const html = "<ul><li>First</li><li>Second</li><li>Third</li></ul>";
+    const result = native.htmlToMarkdown(html);
+    assert.ok(result.includes("First"), "Should contain first item");
+    assert.ok(result.includes("Second"), "Should contain second item");
+    assert.ok(result.includes("Third"), "Should contain third item");
+  });
+
+  test("converts bold and italic", () => {
+    const html = "<p><strong>bold</strong> and <em>italic</em></p>";
+    const result = native.htmlToMarkdown(html);
+    assert.ok(result.includes("**bold**") || result.includes("__bold__"), "Should contain bold");
+    assert.ok(result.includes("*italic*") || result.includes("_italic_"), "Should contain italic");
+  });
+
+  test("handles empty HTML", () => {
+    const result = native.htmlToMarkdown("");
+    assert.equal(typeof result, "string");
+  });
+
+  test("handles plain text", () => {
+    const result = native.htmlToMarkdown("Just plain text");
+    assert.ok(result.includes("Just plain text"), "Should preserve plain text");
+  });
+
+  test("accepts skipImages option", () => {
+    const html = '<h1>Title</h1><p>Content with <img src="photo.jpg" alt="photo"> image</p>';
+    const result = native.htmlToMarkdown(html, { skipImages: true });
+    assert.ok(result.includes("Title"), "Should contain heading");
+    assert.ok(result.includes("Content"), "Should contain paragraph text");
+  });
+
+  test("accepts cleanContent option", () => {
+    const html = '<nav><a href="/home">Home</a></nav><main><h1>Article</h1><p>Body text.</p></main><footer>Copyright</footer>';
+    const result = native.htmlToMarkdown(html, { cleanContent: true });
+    assert.ok(result.includes("Article") || result.includes("Body text"), "Should contain main content");
+  });
+
+  test("converts code blocks", () => {
+    const html = "<pre><code>const x = 1;</code></pre>";
+    const result = native.htmlToMarkdown(html);
+    assert.ok(result.includes("const x = 1;"), "Should contain code content");
+  });
+
+  test("converts complex nested HTML", () => {
+    const html = '<div><h2>Section</h2><p>Text with <a href="https://example.com"><strong>bold link</strong></a>.</p><ul><li>Item one</li><li>Item two</li></ul></div>';
+    const result = native.htmlToMarkdown(html);
+    assert.ok(result.includes("Section"), "Should contain heading");
+    assert.ok(result.includes("example.com"), "Should contain link");
+    assert.ok(result.includes("one"), "Should contain list items");
+  });
+});

package/packages/native/src/__tests__/image.test.mjs

@@ -0,0 +1,137 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { deflateSync } from "node:zlib";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+const addonDir = path.resolve(__dirname, "..", "..", "..", "..", "native", "addon");
+const platformTag = `${process.platform}-${process.arch}`;
+const candidates = [
+  path.join(addonDir, `gsd_engine.${platformTag}.node`),
+  path.join(addonDir, "gsd_engine.dev.node"),
+];
+
+let native;
+for (const candidate of candidates) {
+  try {
+    native = require(candidate);
+    break;
+  } catch {
+    // try next
+  }
+}
+
+if (!native) {
+  console.error("Native addon not found. Run 'npm run build:native -w @gsd/native' first.");
+  process.exit(1);
+}
+
+function crc32(buf) {
+  let crc = 0xffffffff;
+  const table = [];
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    table[n] = c;
+  }
+  for (let i = 0; i < buf.length; i++) crc = table[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function createTestPng() {
+  const signature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+  const ihdrData = Buffer.alloc(13);
+  ihdrData.writeUInt32BE(2, 0);
+  ihdrData.writeUInt32BE(2, 4);
+  ihdrData[8] = 8;
+  ihdrData[9] = 2;
+  const ihdrType = Buffer.from("IHDR");
+  const ihdrCrc = Buffer.alloc(4);
+  ihdrCrc.writeUInt32BE(crc32(Buffer.concat([ihdrType, ihdrData])));
+  const ihdr = Buffer.concat([Buffer.from([0, 0, 0, 13]), ihdrType, ihdrData, ihdrCrc]);
+
+  const raw = Buffer.from([
+    0, 255, 0, 0, 255, 0, 0,
+    0, 255, 0, 0, 255, 0, 0,
+  ]);
+  const compressed = deflateSync(raw);
+  const idatType = Buffer.from("IDAT");
+  const idatLen = Buffer.alloc(4);
+  idatLen.writeUInt32BE(compressed.length);
+  const idatCrc = Buffer.alloc(4);
+  idatCrc.writeUInt32BE(crc32(Buffer.concat([idatType, compressed])));
+  const idat = Buffer.concat([idatLen, idatType, compressed, idatCrc]);
+
+  const iendType = Buffer.from("IEND");
+  const iendCrc = Buffer.alloc(4);
+  iendCrc.writeUInt32BE(crc32(iendType));
+  const iend = Buffer.concat([Buffer.from([0, 0, 0, 0]), iendType, iendCrc]);
+
+  return Buffer.concat([signature, ihdr, idat, iend]);
+}
+
+const NativeImage = native.NativeImage;
+
+describe("native image: NativeImage", () => {
+  test("NativeImage class exists with parse method", () => {
+    assert.ok(NativeImage, "NativeImage should be exported");
+    assert.equal(typeof NativeImage.parse, "function");
+  });
+
+  test("parse decodes PNG with correct dimensions", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    assert.equal(img.width, 2);
+    assert.equal(img.height, 2);
+  });
+
+  test("encode to PNG produces valid PNG", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    const encoded = await img.encode(0, 100);
+    assert.ok(encoded.length > 0);
+    assert.equal(encoded[0], 0x89);
+    assert.equal(encoded[1], 0x50);
+    assert.equal(encoded[2], 0x4e);
+    assert.equal(encoded[3], 0x47);
+  });
+
+  test("encode to JPEG produces valid JPEG", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    const encoded = await img.encode(1, 80);
+    assert.ok(encoded.length > 0);
+    assert.equal(encoded[0], 0xff);
+    assert.equal(encoded[1], 0xd8);
+  });
+
+  test("resize returns correct dimensions", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    const resized = await img.resize(10, 20, 5);
+    assert.equal(resized.width, 10);
+    assert.equal(resized.height, 20);
+  });
+
+  test("resize + encode round-trip", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    const resized = await img.resize(4, 4, 1);
+    const encoded = await resized.encode(0, 100);
+    assert.ok(encoded.length > 0);
+    const reparsed = await NativeImage.parse(new Uint8Array(encoded));
+    assert.equal(reparsed.width, 4);
+    assert.equal(reparsed.height, 4);
+  });
+
+  test("rejects invalid image data", async () => {
+    await assert.rejects(
+      () => NativeImage.parse(new Uint8Array([0, 1, 2, 3, 4, 5])),
+      /Failed to (detect|decode) image/,
+    );
+  });
+
+  test("rejects invalid format number", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    await assert.rejects(() => img.encode(99, 100), /Invalid image format/);
+  });
+});

package/packages/native/src/__tests__/ps.test.mjs

@@ -0,0 +1,109 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+// Load the native addon directly
+const addonDir = path.resolve(__dirname, "..", "..", "..", "..", "native", "addon");
+const platformTag = `${process.platform}-${process.arch}`;
+const candidates = [
+  path.join(addonDir, `gsd_engine.${platformTag}.node`),
+  path.join(addonDir, "gsd_engine.dev.node"),
+];
+
+let native;
+for (const candidate of candidates) {
+  try {
+    native = require(candidate);
+    break;
+  } catch {
+    // try next
+  }
+}
+
+if (!native) {
+  console.error("Native addon not found. Run `npm run build:native -w @gsd/native` first.");
+  process.exit(1);
+}
+
+describe("native ps: listDescendants()", () => {
+  test("returns an array for the current process", () => {
+    const descendants = native.listDescendants(process.pid);
+    assert.ok(Array.isArray(descendants));
+  });
+
+  test("returns empty array for non-existent PID", () => {
+    // PID 2147483647 is extremely unlikely to exist
+    const descendants = native.listDescendants(2147483647);
+    assert.ok(Array.isArray(descendants));
+    assert.equal(descendants.length, 0);
+  });
+
+  test("finds child processes", { skip: "proc_listchildpids unreliable on macOS — needs sysctl KERN_PROC implementation" }, async () => {
+    const child = spawn("sh", ["-c", "sleep 30 & sleep 30 & wait"], {
+      stdio: "ignore",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    try {
+      const descendants = native.listDescendants(child.pid);
+      assert.ok(descendants.length > 0, `expected descendants of sh (pid ${child.pid}), got: ${JSON.stringify(descendants)}`);
+    } finally {
+      native.killTree(child.pid, 9);
+    }
+  });
+});
+
+describe("native ps: killTree()", () => {
+  test("kills a process and its children", async () => {
+    // Spawn a shell that spawns a sleep subprocess
+    const child = spawn("sh", ["-c", "sleep 60"], { stdio: "ignore" });
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    const killed = native.killTree(child.pid, 9);
+    assert.ok(killed >= 1, `should kill at least 1 process, killed: ${killed}`);
+
+    // Verify the child is actually dead
+    await new Promise((resolve) => {
+      child.on("exit", resolve);
+      // Timeout safety — if already exited, resolve immediately
+      setTimeout(resolve, 500);
+    });
+  });
+
+  test("returns 0 for non-existent PID", () => {
+    const killed = native.killTree(2147483647, 9);
+    assert.equal(killed, 0);
+  });
+});
+
+describe("native ps: processGroupId()", () => {
+  test("returns a number for the current process", () => {
+    const pgid = native.processGroupId(process.pid);
+    if (process.platform === "win32") {
+      assert.equal(pgid, null);
+    } else {
+      assert.equal(typeof pgid, "number");
+      assert.ok(pgid > 0);
+    }
+  });
+
+  test("returns null for non-existent PID", () => {
+    const pgid = native.processGroupId(2147483647);
+    assert.equal(pgid, null);
+  });
+});
+
+describe("native ps: killProcessGroup()", () => {
+  test("returns false for non-existent process group", () => {
+    const result = native.killProcessGroup(2147483647, 15);
+    assert.equal(result, false);
+  });
+});