nodejs · XadillaX · Jun 3, 2017 · Jun 4, 2017 · Jun 4, 2017 · Jun 4, 2017
diff --git a/test/common/README.md b/test/common/README.md
@@ -116,6 +116,26 @@ Checks whether `IPv6` is supported on this platform.
 
 Checks if there are multiple localhosts available.
 
+### hijackStderr(listener)
+* `listener`
+[&lt;Function>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Normal_objects_and_functions):
+a listener with a single parameter called `data`.
+
+Hijack `process.stderr` to listen `write` action. Once `process.stderr.write` is
+called, `listener` will also be called and the `data` of `write` function will
+be passed to `listener`. What's more, `process.stderr.writeTimes` will plus one
+then.
+
+### hijackStdout(listener)
+* `listener`
+[&lt;Function>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Normal_objects_and_functions):
+a listener with a single parameter called `data`.
+
+Hijack `process.stdout` to listen `write` action. Once `process.stdout.write` is
+called, `listener` will also be called and the `data` of `write` function will
+be passed to `listener`. What's more, `process.stdout.writeTimes` will plus one
+then.
+
 ### inFreeBSDJail
 * return [&lt;Boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type)
 
@@ -250,6 +270,14 @@ Port tests are running on.
 
 Deletes the 'tmp' dir and recreates it
 
+### restoreStderr
+
+Restore the original `process.stderr.write`.
+
+### restoreStdout
+
+Restore the original `process.stdout.write`.
+
 ### rootDir
 * return [&lt;String>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type)
 

diff --git a/test/common/index.js b/test/common/index.js
@@ -759,3 +759,27 @@ exports.getTTYfd = function getTTYfd() {
   }
   return tty_fd;
 };
+
+// Hijack stdout and stderr
+const stdWrite = {};
+function hijackStdWritable(name, listener) {
+  const stream = process[name];
+  const _write = stdWrite[name] = stream.write.bind(stream);
+
+  stream.writeTimes = 0;
+  stream.write = function(data, callback) {
+    listener(data);
+    _write(data, callback);
+    stream.writeTimes++;
+  };
+}
+
+function restoreWritable(name) {
+  process[name].write = stdWrite[name];
+  delete process[name].writeTimes;
+}
+
+exports.hijackStdout = hijackStdWritable.bind(null, 'stdout');
+exports.hijackStderr = hijackStdWritable.bind(null, 'stderr');
+exports.restoreStdout = restoreWritable.bind(null, 'stdout');
+exports.restoreStderr = restoreWritable.bind(null, 'stderr');
diff --git a/test/fixtures/echo-close-check.js b/test/fixtures/echo-close-check.js
@@ -26,9 +26,15 @@ const fs = require('fs');
 
 process.stdout.write('hello world\r\n');
 
-var stdin = process.openStdin();
+const stdin = process.openStdin();
+
+let current;
+common.hijackStdout(common.mustCall(function(data) {
+  assert.strictEqual(data, current);
+}));
 
 stdin.on('data', function(data) {
+  current = data.toString();
   process.stdout.write(data.toString());
 });
 

diff --git a/test/fixtures/echo.js b/test/fixtures/echo.js
@@ -26,6 +26,12 @@ process.stdout.write('hello world\r\n');
 
 var stdin = process.openStdin();
 
+let current;
 stdin.on('data', function(data) {
+  current = data;
   process.stdout.write(data.toString());
 });
+
+common.hijackStdout(function(data) {
+  assert.equal(data, current);
+});
diff --git a/test/parallel/test-console.js b/test/parallel/test-console.js
@@ -45,16 +45,14 @@ assert.doesNotThrow(function() {
 // an Object with a custom .inspect() function
 const custom_inspect = { foo: 'bar', inspect: () => 'inspect' };
 
-const stdout_write = global.process.stdout.write;
-const stderr_write = global.process.stderr.write;
 const strings = [];
 const errStrings = [];
-global.process.stdout.write = function(string) {
-  strings.push(string);
-};
-global.process.stderr.write = function(string) {
-  errStrings.push(string);
-};
+common.hijackStdout(function(data) {
+  strings.push(data);
+});
+common.hijackStderr(function(data) {
+  errStrings.push(data);
+});
 
 // test console.log() goes to stdout
 console.log('foo');
@@ -105,8 +103,10 @@ console.timeEnd('constructor');
 console.time('hasOwnProperty');
 console.timeEnd('hasOwnProperty');
 
-global.process.stdout.write = stdout_write;
-global.process.stderr.write = stderr_write;
+assert.strictEqual(strings.length, process.stdout.writeTimes);
+assert.strictEqual(errStrings.length, process.stderr.writeTimes);
+common.restoreStdout();
+common.restoreStderr();
 
 // verify that console.timeEnd() doesn't leave dead links
 const timesMapSize = console._times.size;
@@ -146,9 +146,6 @@ assert.ok(/^hasOwnProperty: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 assert.strictEqual('Trace: This is a {"formatted":"trace"} 10 foo',
                    errStrings.shift().split('\n').shift());
 
-assert.strictEqual(strings.length, 0);
-assert.strictEqual(errStrings.length, 0);
-
 assert.throws(() => {
   console.assert(false, 'should throw');
 }, common.expectsError({
@@ -159,3 +156,14 @@ assert.throws(() => {
 assert.doesNotThrow(() => {
   console.assert(true, 'this should not throw');
 });
+
+// hijack stderr to catch `process.emitWarning` which is using
+// `process.nextTick`
+common.hijackStderr(common.mustCall(function(data) {
+  common.restoreStderr();
+
+  // stderr.write will catch sync error, so use `process.nextTick` here
+  process.nextTick(function() {
+    assert(/no such label/.test(data));
+  });
+}));
diff --git a/test/parallel/test-global-console-exists.js b/test/parallel/test-global-console-exists.js
@@ -7,37 +7,30 @@
 const common = require('../common');
 const assert = require('assert');
 const EventEmitter = require('events');
-const leak_warning = /EventEmitter memory leak detected\. 2 hello listeners/;
+const leakWarning = /EventEmitter memory leak detected\. 2 hello listeners/;
 
-let write_calls = 0;
+common.hijackStderr(common.mustCall(function(data) {
+  if (process.stderr.writeTimes === 0) {
+    assert.ok(data.match(leakWarning));
+  } else {
+    assert.fail('stderr.write should be called only once');
+  }
+}));
 
-process.on('warning', (warning) => {
+process.on('warning', function(warning) {
   // This will be called after the default internal
   // process warning handler is called. The default
   // process warning writes to the console, which will
   // invoke the monkeypatched process.stderr.write
   // below.
-  assert.strictEqual(write_calls, 1);
-  EventEmitter.defaultMaxListeners = old_default;
+  assert.strictEqual(process.stderr.writeTimes, 1);
+  EventEmitter.defaultMaxListeners = oldDefault;
   // when we get here, we should be done
 });
 
-process.stderr.write = (data) => {
-  if (write_calls === 0)
-    assert.ok(data.match(leak_warning));
-  else
-    assert.fail('stderr.write should be called only once');
-
-  write_calls++;
-};
-
-const old_default = EventEmitter.defaultMaxListeners;
+const oldDefault = EventEmitter.defaultMaxListeners;
 EventEmitter.defaultMaxListeners = 1;
 
 const e = new EventEmitter();
 e.on('hello', common.noop);
 e.on('hello', common.noop);
-
-// TODO: Figure out how to validate console. Currently,
-// there is no obvious way of validating that console
-// exists here exactly when it should.
diff --git a/test/parallel/test-process-raw-debug.js b/test/parallel/test-process-raw-debug.js
@@ -20,7 +20,7 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const os = require('os');
 
@@ -63,10 +63,7 @@ function child() {
     throw new Error('No ticking!');
   };
 
-  const stderr = process.stderr;
-  stderr.write = function() {
-    throw new Error('No writing to stderr!');
-  };
+  common.hijackStderr(common.mustNotCall('stderr.write must not be called.'));
 
   process._rawDebug('I can still %s!', 'debug');
 }
diff --git a/test/parallel/test-util-log.js b/test/parallel/test-util-log.js
@@ -20,19 +20,18 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const util = require('util');
 
 assert.ok(process.stdout.writable);
 assert.ok(process.stderr.writable);
 
-const stdout_write = global.process.stdout.write;
 const strings = [];
-global.process.stdout.write = function(string) {
-  strings.push(string);
-};
-console._stderr = process.stdout;
+common.hijackStdout(function(data) {
+  strings.push(data);
+});
+common.hijackStderr(common.mustNotCall('stderr.write must not be called'));
 
 const tests = [
   {input: 'foo', output: 'foo'},
@@ -56,4 +55,6 @@ tests.forEach(function(test) {
   assert.strictEqual(match[1], test.output);
 });
 
-global.process.stdout.write = stdout_write;
+assert.strictEqual(process.stdout.writeTimes, tests.length);
+
+common.restoreStdout();