test,tools: enable running tests under workers

Enable running tests inside workers by passing `--worker`
to `tools/test.py`. A number of tests are marked as skipped,
or have been slightly altered to fit the different environment.

PR-URL: https://github.com/nodejs/node/pull/20876
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Shingo Inoue <leko.noor@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: John-David Dalton <john.david.dalton@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>

test/async-hooks/init-hooks.js

@@ -1,7 +1,7 @@
 'use strict';
 // Flags: --expose-gc
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const async_hooks = require('async_hooks');
 const util = require('util');
@@ -162,6 +162,10 @@ class ActivityCollector {
         const stub = { uid, type: 'Unknown', handleIsObject: true };
         this._activities.set(uid, stub);
         return stub;
+      } else if (!common.isMainThread) {
+        // Worker threads start main script execution inside of an AsyncWrap
+        // callback, so we don't yield errors for these.
+        return null;
       } else {
         const err = new Error(`Found a handle whose ${hook}` +
                               ' hook was invoked but not its init hook');

test/async-hooks/test-crypto-pbkdf2.js

@@ -3,6 +3,8 @@
 const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
 
 const assert = require('assert');
 const tick = require('./tick');

test/async-hooks/test-crypto-randomBytes.js

@@ -3,6 +3,8 @@
 const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
 
 const assert = require('assert');
 const tick = require('./tick');

test/async-hooks/test-emit-before-after.js

@@ -7,6 +7,9 @@ const spawnSync = require('child_process').spawnSync;
 const async_hooks = require('internal/async_hooks');
 const initHooks = require('./init-hooks');
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 switch (process.argv[2]) {
   case 'test_invalid_async_id':
     async_hooks.emitBefore(-2, 1);

test/async-hooks/test-enable-disable.js

@@ -88,6 +88,10 @@ const assert = require('assert');
 const tick = require('./tick');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
+
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different timing');
+
 // Include "Unknown"s because hook2 will not be able to identify
 // the type of the first Immediate  since it will miss its `init` invocation.
 const types = [ 'Immediate', 'Unknown' ];

test/async-hooks/test-fseventwrap.js

@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 
 const assert = require('assert');
 const initHooks = require('./init-hooks');
@@ -7,6 +7,9 @@ const tick = require('./tick');
 const { checkInvocations } = require('./hook-checks');
 const fs = require('fs');
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 const hooks = initHooks();
 
 hooks.enable();

test/async-hooks/test-fsreqwrap-readFile.js

@@ -7,6 +7,9 @@ const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const fs = require('fs');
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 const hooks = initHooks();
 
 hooks.enable();

test/async-hooks/test-getaddrinforeqwrap.js

@@ -7,6 +7,9 @@ const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const dns = require('dns');
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 const hooks = initHooks();
 
 hooks.enable();

test/async-hooks/test-getnameinforeqwrap.js

@@ -7,6 +7,9 @@ const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const dns = require('dns');
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 const hooks = initHooks();
 
 hooks.enable();

test/async-hooks/test-graph.signal.js

@@ -1,9 +1,10 @@
 'use strict';
 
 const common = require('../common');
-if (common.isWindows) {
+if (common.isWindows)
   common.skip('no signals on Windows');
-}
+if (!common.isMainThread)
+  common.skip('No signal handling available in Workers');
 
 const initHooks = require('./init-hooks');
 const verifyGraph = require('./verify-graph');

test/async-hooks/test-no-assert-when-disabled.js

@@ -1,6 +1,9 @@
 'use strict';
 // Flags: --no-force-async-hooks-checks --expose-internals
-require('../common');
+const common = require('../common');
+
+if (!common.isMainThread)
+  common.skip('Workers don\'t inherit per-env state like the check flag');
 
 const async_hooks = require('internal/async_hooks');
 

test/async-hooks/test-pipewrap.js

@@ -10,6 +10,9 @@ const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const spawn = require('child_process').spawn;
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 const hooks = initHooks();
 
 hooks.enable();

test/async-hooks/test-promise.chain-promise-before-init-hooks.js

@@ -4,6 +4,10 @@ const common = require('../common');
 const assert = require('assert');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
+
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 common.crashOnUnhandledRejection();
 
 const p = new Promise(common.mustCall(function executor(resolve, reject) {

test/async-hooks/test-promise.js

@@ -6,6 +6,9 @@ const assert = require('assert');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 common.crashOnUnhandledRejection();
 
 const hooks = initHooks();

test/async-hooks/test-signalwrap.js

@@ -3,6 +3,8 @@ const common = require('../common');
 
 if (common.isWindows)
   common.skip('no signals in Windows');
+if (!common.isMainThread)
+  common.skip('No signal handling available in Workers');
 
 const assert = require('assert');
 const initHooks = require('./init-hooks');

test/async-hooks/test-statwatcher.js

@@ -1,12 +1,15 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const commonPath = require.resolve('../common');
 const assert = require('assert');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const fs = require('fs');
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 const hooks = initHooks();
 hooks.enable();
 

test/common/index.js

@@ -46,6 +46,14 @@ Object.defineProperty(exports, 'PORT', {
   enumerable: true
 });
 
+exports.isMainThread = (() => {
+  try {
+    return require('worker').isMainThread;
+  } catch {
+    // Worker module not enabled → only a single main thread exists.
+    return true;
+  }
+})();
 
 exports.isWindows = process.platform === 'win32';
 exports.isWOW64 = exports.isWindows &&
@@ -746,6 +754,10 @@ exports.skipIfInspectorDisabled = function skipIfInspectorDisabled() {
   if (process.config.variables.v8_enable_inspector === 0) {
     exports.skip('V8 inspector is disabled');
   }
+  if (!exports.isMainThread) {
+    // TODO(addaleax): Fix me.
+    exports.skip('V8 inspector is not available in Workers');
+  }
 };
 
 exports.skipIf32Bits = function skipIf32Bits() {

test/known_issues/test-stdin-is-always-net.socket.js

@@ -19,5 +19,5 @@ const proc = spawn(
 // To double-check this test, set stdio to 'pipe' and uncomment the line below.
 // proc.stderr.pipe(process.stderr);
 proc.on('exit', common.mustCall(function(exitCode) {
-  process.exitCode = exitCode;
+  assert.strictEqual(exitCode, 0);
 }));

test/parallel/test-async-hooks-disable-during-promise.js

@@ -3,6 +3,9 @@ const common = require('../common');
 const async_hooks = require('async_hooks');
 common.crashOnUnhandledRejection();
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different AsyncWraps');
+
 const hook = async_hooks.createHook({
   init: common.mustCall(2),
   before: common.mustCall(1),

test/parallel/test-async-hooks-disable-gc-tracking.js

@@ -8,7 +8,7 @@ const common = require('../common');
 const async_hooks = require('async_hooks');
 
 const hook = async_hooks.createHook({
-  destroy: common.mustCall(1) // only 1 immediate is destroyed
+  destroy: common.mustCallAtLeast(1) // only 1 immediate is destroyed
 }).enable();
 
 new async_hooks.AsyncResource('foobar', { requireManualDestroy: true });

test/parallel/test-async-hooks-enable-during-promise.js

@@ -7,8 +7,8 @@ common.crashOnUnhandledRejection();
 Promise.resolve(1).then(common.mustCall(() => {
   async_hooks.createHook({
     init: common.mustCall(),
-    before: common.mustCall(),
+    before: common.mustCallAtLeast(),
-    after: common.mustCall(2)
+    after: common.mustCallAtLeast(2)
   }).enable();
 
   process.nextTick(common.mustCall());

test/parallel/test-async-hooks-prevent-double-destroy.js

@@ -8,7 +8,7 @@ const common = require('../common');
 const async_hooks = require('async_hooks');
 
 const hook = async_hooks.createHook({
-  destroy: common.mustCall(2) // 1 immediate + manual destroy
+  destroy: common.mustCallAtLeast(2) // 1 immediate + manual destroy
 }).enable();
 
 {

test/parallel/test-async-hooks-promise-triggerid.js

@@ -3,6 +3,9 @@ const common = require('../common');
 const assert = require('assert');
 const async_hooks = require('async_hooks');
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 common.crashOnUnhandledRejection();
 
 const promiseAsyncIds = [];

test/parallel/test-async-hooks-promise.js

@@ -3,6 +3,9 @@ const common = require('../common');
 const assert = require('assert');
 const async_hooks = require('async_hooks');
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 const initCalls = [];
 const resolveCalls = [];
 

test/parallel/test-async-hooks-top-level-clearimmediate.js

@@ -6,6 +6,9 @@ const common = require('../common');
 const assert = require('assert');
 const async_hooks = require('async_hooks');
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different async IDs');
+
 let seenId, seenResource;
 
 async_hooks.createHook({

test/parallel/test-async-wrap-promise-after-enabled.js

@@ -5,6 +5,9 @@
 const common = require('../common');
 const assert = require('assert');
 
+if (!common.isMainThread)
+  common.skip('Worker bootstrapping works differently -> different timing');
+
 const async_hooks = require('async_hooks');
 
 const seenEvents = [];

test/parallel/test-child-process-custom-fds.js

@@ -5,6 +5,9 @@ const assert = require('assert');
 const internalCp = require('internal/child_process');
 const oldSpawnSync = internalCp.spawnSync;
 
+if (!common.isMainThread)
+  common.skip('stdio is not associated with file descriptors in Workers');
+
 // Verify that customFds is used if stdio is not provided.
 {
   const msg = 'child_process: options.customFds option is deprecated. ' +

test/parallel/test-child-process-http-socket-leak.js

@@ -6,7 +6,6 @@ const common = require('../common');
 const assert = require('assert');
 const { fork } = require('child_process');
 const http = require('http');
-const { kTimeout } = require('internal/timers');
 
 if (process.argv[2] === 'child') {
   process.once('message', (req, socket) => {
@@ -19,6 +18,8 @@ if (process.argv[2] === 'child') {
   return;
 }
 
+const { kTimeout } = require('internal/timers');
+
 let child;
 let socket;
 

test/parallel/test-child-process-validate-stdio.js

@@ -30,7 +30,8 @@ common.expectsError(() => _validateStdio(stdio2, true),
                     { code: 'ERR_IPC_SYNC_FORK', type: Error }
 );
 
-{
+
+if (common.isMainThread) {
   const stdio3 = [process.stdin, process.stdout, process.stderr];
   const result = _validateStdio(stdio3, false);
   assert.deepStrictEqual(result, {
@@ -42,4 +43,7 @@ common.expectsError(() => _validateStdio(stdio2, true),
     ipc: undefined,
     ipcFd: undefined
   });
+} else {
+  common.printSkipMessage(
+    'stdio is not associated with file descriptors in Workers');
 }

test/parallel/test-cli-eval.js

@@ -34,6 +34,9 @@ const path = require('path');
 const fixtures = require('../common/fixtures');
 const nodejs = `"${process.execPath}"`;
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 if (process.argv.length > 2) {
   console.log(process.argv.slice(2).join(' '));
   process.exit(0);

test/parallel/test-cli-node-options-disallowed.js

@@ -2,6 +2,8 @@
 const common = require('../common');
 if (process.config.variables.node_without_node_options)
   common.skip('missing NODE_OPTIONS support');
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
 
 // Test options specified by env variable.
 

test/parallel/test-cli-node-options.js

@@ -2,6 +2,8 @@
 const common = require('../common');
 if (process.config.variables.node_without_node_options)
   common.skip('missing NODE_OPTIONS support');
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
 
 // Test options specified by env variable.
 

test/parallel/test-cluster-net-listen-relative-path.js

@@ -11,6 +11,8 @@ const tmpdir = require('../common/tmpdir');
 if (common.isWindows)
   common.skip('On Windows named pipes live in their own ' +
               'filesystem and don\'t have a ~100 byte limit');
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
 
 // Choose a socket name such that the absolute path would exceed 100 bytes.
 const socketDir = './unix-socket-dir';

test/parallel/test-console.js

@@ -27,9 +27,10 @@ const util = require('util');
 assert.ok(process.stdout.writable);
 assert.ok(process.stderr.writable);
 // Support legacy API
-assert.strictEqual(typeof process.stdout.fd, 'number');
+if (common.isMainThread) {
-assert.strictEqual(typeof process.stderr.fd, 'number');
+  assert.strictEqual(typeof process.stdout.fd, 'number');
-
+  assert.strictEqual(typeof process.stderr.fd, 'number');
+}
 process.once('warning', common.mustCall((warning) => {
   assert(/no such label/.test(warning.message));
 }));

test/parallel/test-cwd-enoent-preload.js

@@ -3,6 +3,8 @@ const common = require('../common');
 // Fails with EINVAL on SmartOS, EBUSY on Windows, EBUSY on AIX.
 if (common.isSunOS || common.isWindows || common.isAIX)
   common.skip('cannot rmdir current working directory');
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
 
 const assert = require('assert');
 const fs = require('fs');

test/parallel/test-cwd-enoent-repl.js

@@ -3,6 +3,8 @@ const common = require('../common');
 // Fails with EINVAL on SmartOS, EBUSY on Windows, EBUSY on AIX.
 if (common.isSunOS || common.isWindows || common.isAIX)
   common.skip('cannot rmdir current working directory');
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
 
 const assert = require('assert');
 const fs = require('fs');

test/parallel/test-cwd-enoent.js

@@ -3,6 +3,8 @@ const common = require('../common');
 // Fails with EINVAL on SmartOS, EBUSY on Windows, EBUSY on AIX.
 if (common.isSunOS || common.isWindows || common.isAIX)
   common.skip('cannot rmdir current working directory');
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
 
 const assert = require('assert');
 const fs = require('fs');

test/parallel/test-debug-args.js

@@ -1,7 +1,10 @@
 'use strict';
 // Flags: --debug-code
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
+if (!common.isMainThread)
+  common.skip('execArgv does not affect Workers');
+
 assert(process.execArgv.includes('--debug-code'));

test/parallel/test-fs-realpath.js

@@ -24,6 +24,9 @@ const common = require('../common');
 const fixtures = require('../common/fixtures');
 const tmpdir = require('../common/tmpdir');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const assert = require('assert');
 const fs = require('fs');
 const path = require('path');

test/parallel/test-fs-write-file-sync.js

@@ -28,6 +28,9 @@ let openCount = 0;
 let mode;
 let content;
 
+if (!common.isMainThread)
+  common.skip('process.umask is not available in Workers');
+
 // Need to hijack fs.open/close to make sure that things
 // get closed once they're opened.
 fs._openSync = fs.openSync;

test/parallel/test-module-cjs-helpers.js

@@ -1,5 +1,5 @@
 'use strict';
-// Flags: --expose-internals
+// Flags: --expose-internals --experimental-worker
 
 require('../common');
 const assert = require('assert');
@@ -7,5 +7,5 @@ const { builtinLibs } = require('internal/modules/cjs/helpers');
 
 const hasInspector = process.config.variables.v8_enable_inspector === 1;
 
-const expectedLibs = hasInspector ? 33 : 32;
+const expectedLibs = hasInspector ? 34 : 33;
 assert.strictEqual(builtinLibs.length, expectedLibs);

test/parallel/test-preload.js

@@ -5,6 +5,8 @@ const fixtures = require('../common/fixtures');
 // Refs: https://github.com/nodejs/node/pull/2253
 if (common.isSunOS)
   common.skip('unreliable on SunOS');
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
 
 const assert = require('assert');
 const childProcess = require('child_process');

test/parallel/test-process-chdir-errormessage.js

@@ -1,8 +1,10 @@
 'use strict';
 
-const { expectsError } = require('../common');
+const common = require('../common');
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
 
-expectsError(
+common.expectsError(
   () => {
     process.chdir('does-not-exist');
   },

test/parallel/test-process-chdir.js

@@ -5,6 +5,9 @@ const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const tmpdir = require('../common/tmpdir');
 
 process.chdir('..');

test/parallel/test-process-euid-egid.js

@@ -3,9 +3,11 @@
 const common = require('../common');
 const assert = require('assert');
 
-if (common.isWindows) {
+if (common.isWindows || !common.isMainThread) {
+  if (common.isMainThread) {
     assert.strictEqual(process.geteuid, undefined);
     assert.strictEqual(process.getegid, undefined);
+  }
   assert.strictEqual(process.seteuid, undefined);
   assert.strictEqual(process.setegid, undefined);
   return;

test/parallel/test-process-exit-handler.js

@@ -1,11 +1,14 @@
 'use strict';
-require('../common');
+const common = require('../common');
+
+if (!common.isMainThread)
+  common.skip('execArgv does not affect Workers');
 
 // This test ensures that no asynchronous operations are performed in the 'exit'
 // handler.
 // https://github.com/nodejs/node/issues/12322
 
 process.on('exit', () => {
-  setTimeout(process.abort, 0); // Should not run.
+  setTimeout(() => process.abort(), 0); // Should not run.
   for (const start = Date.now(); Date.now() - start < 10;);
 });

test/parallel/test-process-fatal-exception-tick.js

@@ -3,6 +3,9 @@
 const common = require('../common');
 const assert = require('assert');
 
+if (!common.isMainThread)
+  common.skip('Error handling timing is different in Workers');
+
 // If a process encounters an uncaughtException, it should schedule
 // processing of nextTicks on the next Immediates cycle but not
 // before all Immediates are handled

test/parallel/test-process-uid-gid.js

@@ -24,11 +24,13 @@ const common = require('../common');
 
 const assert = require('assert');
 
-if (common.isWindows) {
+if (common.isWindows || !common.isMainThread) {
-  // uid/gid functions are POSIX only
+  // uid/gid functions are POSIX only, setters are main-thread only.
+  if (common.isMainThread) {
     assert.strictEqual(process.getuid, undefined);
-  assert.strictEqual(process.setuid, undefined);
     assert.strictEqual(process.getgid, undefined);
+  }
+  assert.strictEqual(process.setuid, undefined);
   assert.strictEqual(process.setgid, undefined);
   return;
 }

test/parallel/test-process-umask-mask.js

@@ -6,6 +6,9 @@
 const common = require('../common');
 const assert = require('assert');
 
+if (!common.isMainThread)
+  common.skip('process.umask is not available in Workers');
+
 let mask;
 
 if (common.isWindows) {

test/parallel/test-process-umask.js

@@ -22,6 +22,8 @@
 'use strict';
 const common = require('../common');
 const assert = require('assert');
+if (!common.isMainThread)
+  common.skip('process.umask is not available in Workers');
 
 // Note in Windows one can only set the "user" bits.
 let mask;

test/parallel/test-repl-require.js

@@ -5,6 +5,9 @@ const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const net = require('net');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 process.chdir(fixtures.fixturesDir);
 const repl = require('repl');
 

test/parallel/test-repl-sigint-nested-eval.js

@@ -4,6 +4,8 @@ if (common.isWindows) {
   // No way to send CTRL_C_EVENT to processes from JS right now.
   common.skip('platform not supported');
 }
+if (!common.isMainThread)
+  common.skip('No signal handling available in Workers');
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;

test/parallel/test-repl-sigint.js

@@ -4,6 +4,8 @@ if (common.isWindows) {
   // No way to send CTRL_C_EVENT to processes from JS right now.
   common.skip('platform not supported');
 }
+if (!common.isMainThread)
+  common.skip('No signal handling available in Workers');
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;

test/parallel/test-repl-tab-complete.js

@@ -26,6 +26,9 @@ const assert = require('assert');
 const fixtures = require('../common/fixtures');
 const hasInspector = process.config.variables.v8_enable_inspector === 1;
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 // We have to change the directory to ../fixtures before requiring repl
 // in order to make the tests for completion of node_modules work properly
 // since repl modifies module.paths.

test/parallel/test-require-symlink.js

@@ -4,6 +4,8 @@ const common = require('../common');
 
 if (!common.canCreateSymLink())
   common.skip('insufficient privileges');
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
 
 const assert = require('assert');
 const { spawn } = require('child_process');

test/parallel/test-setproctitle.js

@@ -5,6 +5,8 @@ const common = require('../common');
 // FIXME add sunos support
 if (common.isSunOS)
   common.skip(`Unsupported platform [${process.platform}]`);
+if (!common.isMainThread)
+  common.skip('Setting the process title from Workers is not supported');
 
 const assert = require('assert');
 const exec = require('child_process').exec;

test/parallel/test-signal-args.js

@@ -3,9 +3,10 @@
 const common = require('../common');
 const assert = require('assert');
 
-if (common.isWindows) {
+if (common.isWindows)
   common.skip('Sending signals with process.kill is not supported on Windows');
-}
+if (!common.isMainThread)
+  common.skip('No signal handling available in Workers');
 
 process.once('SIGINT', common.mustCall((signal) => {
   assert.strictEqual(signal, 'SIGINT');

test/parallel/test-signal-handler.js

@@ -25,6 +25,8 @@ const common = require('../common');
 
 if (common.isWindows)
   common.skip('SIGUSR1 and SIGHUP signals are not supported');
+if (!common.isMainThread)
+  common.skip('Signal handling in Workers is not supported');
 
 console.log(`process.pid: ${process.pid}`);
 

test/parallel/test-stdio-pipe-access.js

@@ -1,5 +1,7 @@
 'use strict';
-require('../common');
+const common = require('../common');
+if (!common.isMainThread)
+  common.skip('Workers don’t have process-like stdio');
 
 // Test if Node handles acessing process.stdin if it is a redirected
 // pipe without deadlocking

test/parallel/test-stdio-pipe-redirect.js

@@ -1,5 +1,7 @@
 'use strict';
-require('../common');
+const common = require('../common');
+if (!common.isMainThread)
+  common.skip('Workers don’t have process-like stdio');
 
 // Test if Node handles redirecting one child process stdout to another
 // process stdin without crashing.

test/parallel/test-timers-immediate-unref-nested-once.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const common = require('../common');
+
+// This immediate should not execute as it was unrefed
+// and nothing else is keeping the event loop alive
+setImmediate(() => {
+  setImmediate(common.mustNotCall()).unref();
+});

test/parallel/test-timers-immediate-unref-simple.js

@@ -2,6 +2,11 @@
 
 const common = require('../common');
 
+if (!common.isMainThread) {
+  // Note that test-timers-immediate-unref-nested-once works instead.
+  common.skip('Worker bootstrapping works differently -> different timing');
+}
+
 // This immediate should not execute as it was unrefed
 // and nothing else is keeping the event loop alive
 setImmediate(common.mustNotCall()).unref();

test/parallel/test-trace-events-all.js

@@ -4,6 +4,9 @@ const assert = require('assert');
 const cp = require('child_process');
 const fs = require('fs');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const CODE =
   'setTimeout(() => { for (var i = 0; i < 100000; i++) { "test" + i } }, 1)';
 const FILE_NAME = 'node_trace.1.log';

test/parallel/test-trace-events-api.js

@@ -5,6 +5,8 @@ const common = require('../common');
 
 if (!common.hasTracing)
   common.skip('missing trace events');
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
 
 const assert = require('assert');
 const cp = require('child_process');

test/parallel/test-trace-events-async-hooks.js

@@ -5,6 +5,9 @@ const cp = require('child_process');
 const fs = require('fs');
 const util = require('util');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const CODE =
   'setTimeout(() => { for (var i = 0; i < 100000; i++) { "test" + i } }, 1)';
 const FILE_NAME = 'node_trace.1.log';

test/parallel/test-trace-events-binding.js

@@ -4,6 +4,9 @@ const assert = require('assert');
 const cp = require('child_process');
 const fs = require('fs');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const CODE = `
   process.binding("trace_events").emit(
     'b'.charCodeAt(0), 'custom',

test/parallel/test-trace-events-bootstrap.js

@@ -6,6 +6,9 @@ const path = require('path');
 const fs = require('fs');
 const tmpdir = require('../common/tmpdir');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const names = [
   'environment',
   'nodeStart',

test/parallel/test-trace-events-category-used.js

@@ -3,6 +3,9 @@ const common = require('../common');
 const assert = require('assert');
 const cp = require('child_process');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const CODE = `console.log(
   process.binding("trace_events").categoryGroupEnabled("custom")
 );`;

test/parallel/test-trace-events-file-pattern.js

@@ -5,6 +5,9 @@ const assert = require('assert');
 const cp = require('child_process');
 const fs = require('fs');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 tmpdir.refresh();
 process.chdir(tmpdir.path);
 

test/parallel/test-trace-events-fs-sync.js

@@ -4,6 +4,9 @@ const assert = require('assert');
 const cp = require('child_process');
 const fs = require('fs');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const tests = new Array();
 const traceFile = 'node_trace.1.log';
 

test/parallel/test-trace-events-metadata.js

@@ -4,6 +4,9 @@ const assert = require('assert');
 const cp = require('child_process');
 const fs = require('fs');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const CODE =
   'setTimeout(() => { for (var i = 0; i < 100000; i++) { "test" + i } }, 1)';
 const FILE_NAME = 'node_trace.1.log';

test/parallel/test-trace-events-none.js

@@ -4,6 +4,9 @@ const assert = require('assert');
 const cp = require('child_process');
 const fs = require('fs');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const CODE =
   'setTimeout(() => { for (var i = 0; i < 100000; i++) { "test" + i } }, 1)';
 const FILE_NAME = 'node_trace.1.log';

test/parallel/test-trace-events-perf.js

@@ -6,6 +6,9 @@ const path = require('path');
 const fs = require('fs');
 const tmpdir = require('../common/tmpdir');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 if (process.argv[2] === 'child') {
   const { performance } = require('perf_hooks');
 

test/parallel/test-trace-events-process-exit.js

@@ -4,6 +4,9 @@ const assert = require('assert');
 const cp = require('child_process');
 const fs = require('fs');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const tmpdir = require('../common/tmpdir');
 
 const FILE_NAME = 'node_trace.1.log';

test/parallel/test-trace-events-v8.js

@@ -4,6 +4,9 @@ const assert = require('assert');
 const cp = require('child_process');
 const fs = require('fs');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const CODE =
   'setTimeout(() => { for (var i = 0; i < 100000; i++) { "test" + i } }, 1)';
 const FILE_NAME = 'node_trace.1.log';

test/parallel/test-trace-events-vm.js

@@ -6,6 +6,9 @@ const path = require('path');
 const fs = require('fs');
 const tmpdir = require('../common/tmpdir');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const names = [
   'ContextifyScript::New',
   'RunInThisContext',

test/sequential/test-async-wrap-getasyncid.js

@@ -39,6 +39,8 @@ common.crashOnUnhandledRejection();
     delete providers.STREAMPIPE;
     delete providers.MESSAGEPORT;
     delete providers.WORKER;
+    if (!common.isMainThread)
+      delete providers.INSPECTORJSBINDING;
 
     const objKeys = Object.keys(providers);
     if (objKeys.length > 0)
@@ -281,7 +283,8 @@ if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
   testInitialized(req, 'SendWrap');
 }
 
-if (process.config.variables.v8_enable_inspector !== 0) {
+if (process.config.variables.v8_enable_inspector !== 0 &&
+    common.isMainThread) {
   const binding = process.binding('inspector');
   const handle = new binding.Connection(() => {});
   testInitialized(handle, 'Connection');

test/sequential/test-buffer-creation-regression.js

@@ -30,7 +30,6 @@ try {
 } catch (e) {
   if (e instanceof RangeError && acceptableOOMErrors.includes(e.message))
     common.skip(`Unable to allocate ${size} bytes for ArrayBuffer`);
-
   throw e;
 }
 

test/sequential/test-fs-watch.js

@@ -28,6 +28,9 @@ const path = require('path');
 
 const tmpdir = require('../common/tmpdir');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 const expectFilePath = common.isWindows ||
                        common.isLinux ||
                        common.isOSX ||

test/sequential/test-init.js

@@ -25,6 +25,9 @@ const assert = require('assert');
 const child = require('child_process');
 const fixtures = require('../common/fixtures');
 
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
 if (process.env.TEST_INIT) {
   return process.stdout.write('Loaded successfully!');
 }

test/sequential/test-inspector-overwrite-config.js

@@ -13,6 +13,10 @@
 
 const common = require('../common');
 const assert = require('assert');
+
+if (!common.isMainThread)
+  common.skip('--require does not work with Workers');
+
 const inspector = require('inspector');
 const msg = 'Test inspector logging';
 let asserted = false;

test/sequential/test-performance.js

@@ -4,6 +4,9 @@ const common = require('../common');
 const assert = require('assert');
 const { performance } = require('perf_hooks');
 
+if (!common.isMainThread)
+  common.skip('bootstrapping workers works differently');
+
 assert(performance);
 assert(performance.nodeTiming);
 assert.strictEqual(typeof performance.timeOrigin, 'number');

tools/run-worker.js

@@ -0,0 +1,11 @@
+'use strict';
+if (typeof require === 'undefined') {
+  console.log('1..0 # Skipped: Not being run as CommonJS');
+  process.exit(0);
+}
+
+const path = require('path');
+const { Worker } = require('worker');
+
+new Worker(path.resolve(process.cwd(), process.argv[2]))
+  .on('exit', (code) => process.exitCode = code);

tools/test.py

@@ -1375,6 +1375,8 @@ def BuildOptions():
       help="Expect test cases to fail", default=False, action="store_true")
   result.add_option("--valgrind", help="Run tests through valgrind",
       default=False, action="store_true")
+  result.add_option("--worker", help="Run parallel tests inside a worker context",
+      default=False, action="store_true")
   result.add_option("--check-deopts", help="Check tests for permanent deoptimizations",
       default=False, action="store_true")
   result.add_option("--cat", help="Print the source of the tests",
@@ -1617,6 +1619,11 @@ def Main():
     options.node_args.append("--always-opt")
     options.progress = "deopts"
 
+  if options.worker:
+    run_worker = join(workspace, "tools", "run-worker.js")
+    options.node_args.append('--experimental-worker')
+    options.node_args.append(run_worker)
+
   shell = abspath(options.shell)
   buildspace = dirname(shell)