Updated to Node 8.11.1 (#332)

Author: mcollina

README.md

@@ -1,6 +1,6 @@
 # readable-stream
 
-***Node-core v8.9.4 streams for userland*** [![Build Status](https://travis-ci.org/nodejs/readable-stream.svg?branch=master)](https://travis-ci.org/nodejs/readable-stream)
+***Node-core v8.11.1 streams for userland*** [![Build Status](https://travis-ci.org/nodejs/readable-stream.svg?branch=master)](https://travis-ci.org/nodejs/readable-stream)
 
 
 [![NPM](https://nodei.co/npm/readable-stream.png?downloads=true&downloadRank=true)](https://nodei.co/npm/readable-stream/)
@@ -18,7 +18,7 @@ npm install --save readable-stream
 This package is a mirror of the Streams2 and Streams3 implementations in
 Node-core.
 
-Full documentation may be found on the [Node.js website](https://nodejs.org/dist/v8.9.4/docs/api/stream.html).
+Full documentation may be found on the [Node.js website](https://nodejs.org/dist/v8.11.1/docs/api/stream.html).
 
 If you want to guarantee a stable streams base, regardless of what version of
 Node you, or the users of your libraries are using, use **readable-stream** *only* and avoid the *"stream"* module in Node-core, for background see [this blogpost](http://r.va.gg/2014/06/why-i-dont-use-nodes-core-stream-module.html).

lib/_stream_duplex.js

@@ -52,10 +52,13 @@ var Writable = require('./_stream_writable');
 
 util.inherits(Duplex, Readable);
 
-var keys = objectKeys(Writable.prototype);
-for (var v = 0; v < keys.length; v++) {
-  var method = keys[v];
-  if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+{
+  // avoid scope creep, the keys array can then be collected
+  var keys = objectKeys(Writable.prototype);
+  for (var v = 0; v < keys.length; v++) {
+    var method = keys[v];
+    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+  }
 }
 
 function Duplex(options) {
@@ -74,6 +77,16 @@ function Duplex(options) {
   this.once('end', onend);
 }
 
+Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function () {
+    return this._writableState.highWaterMark;
+  }
+});
+
 // the no-half-open enforcer
 function onend() {
   // if we allow half-open state, or if the writable side ended,

lib/_stream_readable.js

@@ -876,6 +876,16 @@ Readable.prototype.wrap = function (stream) {
   return this;
 };
 
+Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function () {
+    return this._readableState.highWaterMark;
+  }
+});
+
 // exposed for testing purposes only.
 Readable._fromList = fromList;
 

lib/_stream_writable.js

@@ -368,6 +368,16 @@ function decodeChunk(state, chunk, encoding) {
   return chunk;
 }
 
+Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function () {
+    return this._writableState.highWaterMark;
+  }
+});
+
 // if we're already writing something, then just put this
 // in the queue, and wait our turn.  Otherwise, call _write
 // If we return false, then we need a drain event, so set that flag.

test/common/README.md

@@ -133,15 +133,6 @@ Tests whether `name` and `expected` are part of a raised warning.
 
 Checks if `pathname` exists
 
-### fires(promise, [error], [timeoutMs])
-* promise [<Promise]
-* error [<String] default = 'timeout'
-* timeoutMs [<Number] default = 100
-
-Returns a new promise that will propagate `promise` resolution or rejection if
-that happens within the `timeoutMs` timespan, or rejects with `error` as
-a reason otherwise.
-
 ### getArrayBufferViews(buf)
 * `buf` [<Buffer>]
 * return [<ArrayBufferView[]>]
@@ -367,6 +358,11 @@ Path to the project directory.
 
 Logs '1..0 # Skipped: ' + `msg` and exits with exit code `0`.
 
+### skipIfEslintMissing()
+
+Skip the rest of the tests in the current file when `ESLint` is not available
+at `tools/node_modules/eslint`
+
 ### skipIfInspectorDisabled()
 
 Skip the rest of the tests in the current file when the Inspector

test/common/index.js

@@ -562,8 +562,11 @@ function _mustCallInner(fn) {
 }
 
 exports.hasMultiLocalhost = function hasMultiLocalhost() {
-  var TCP = process.binding('tcp_wrap').TCP;
-  var t = new TCP();
+  var _process$binding = process.binding('tcp_wrap'),
+      TCP = _process$binding.TCP,
+      TCPConstants = _process$binding.constants;
+
+  var t = new TCP(TCPConstants.SOCKET);
   var ret = t.bind('127.0.0.2', 0);
   t.close();
   return ret === 0;
@@ -578,6 +581,12 @@ exports.fileExists = function (pathname) {
   }
 };
 
+exports.skipIfEslintMissing = function () {
+  if (!exports.fileExists(path.join('..', '..', 'tools', 'node_modules', 'eslint'))) {
+    exports.skip('missing ESLint');
+  }
+};
+
 exports.canCreateSymLink = function () {
   // On Windows, creating symlinks requires admin privileges.
   // We'll only try to run symlink test if we have enough privileges.
@@ -769,7 +778,7 @@ exports.expectsError = function expectsError(fn, settings, exact) {
     settings = fn;
     fn = undefined;
   }
-  var innerFn = exports.mustCall(function (error) {
+  function innerFn(error) {
     assert.strictEqual(error.code, settings.code);
     if ('type' in settings) {
       var type = settings.type;
@@ -799,12 +808,12 @@ exports.expectsError = function expectsError(fn, settings, exact) {
       });
     }
     return true;
-  }, exact);
+  }
   if (fn) {
     assert.throws(fn, innerFn);
     return;
   }
-  return innerFn;
+  return exports.mustCall(innerFn, exact);
 };
 
 exports.skipIfInspectorDisabled = function skipIfInspectorDisabled() {
@@ -819,15 +828,16 @@ exports.skipIf32Bits = function skipIf32Bits() {
   }
 };
 
-var arrayBufferViews = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, DataView];
-
 exports.getArrayBufferViews = function getArrayBufferViews(buf) {
   var buffer = buf.buffer,
       byteOffset = buf.byteOffset,
       byteLength = buf.byteLength;
 
 
   var out = [];
+
+  var arrayBufferViews = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, DataView];
+
   var _iteratorNormalCompletion = true;
   var _didIteratorError = false;
   var _iteratorError = undefined;
@@ -909,35 +919,6 @@ function restoreWritable(name) {
   delete process[name].writeTimes;
 }
 
-function onResolvedOrRejected(promise, callback) {
-  return promise.then(function (result) {
-    callback();
-    return result;
-  }, function (error) {
-    callback();
-    throw error;
-  });
-}
-
-function timeoutPromise(error, timeoutMs) {
-  var clearCallback = null;
-  var done = false;
-  var promise = onResolvedOrRejected(new Promise(function (resolve, reject) {
-    var timeout = setTimeout(function () {
-      return reject(error);
-    }, timeoutMs);
-    clearCallback = function () {
-      if (done) return;
-      clearTimeout(timeout);
-      resolve();
-    };
-  }), function () {
-    return done = true;
-  });
-  promise.clear = clearCallback;
-  return promise;
-}
-
 exports.hijackStdout = hijackStdWritable.bind(null, 'stdout');
 exports.hijackStderr = hijackStdWritable.bind(null, 'stderr');
 exports.restoreStdout = restoreWritable.bind(null, 'stdout');
@@ -952,19 +933,6 @@ exports.firstInvalidFD = function firstInvalidFD() {
   return fd;
 };
 
-exports.fires = function fires(promise, error, timeoutMs) {
-  if (!timeoutMs && util.isNumber(error)) {
-    timeoutMs = error;
-    error = null;
-  }
-  if (!error) error = 'timeout';
-  if (!timeoutMs) timeoutMs = 100;
-  var timeout = timeoutPromise(error, timeoutMs);
-  return Promise.race([onResolvedOrRejected(promise, function () {
-    return timeout.clear();
-  }), timeout]);
-};
-
 function forEach(xs, f) {
   for (var i = 0, l = xs.length; i < l; i++) {
     f(xs[i], i);

test/common/inspector-helper.js

@@ -271,7 +271,7 @@ var InspectorSession = function () {
   InspectorSession.prototype.waitForNotification = function waitForNotification(methodOrPredicate, description) {
     var desc = description || methodOrPredicate;
     var message = 'Timed out waiting for matching notification (' + desc + '))';
-    return common.fires(this._asyncWaitForNotification(methodOrPredicate), message, TIMEOUT);
+    return fires(this._asyncWaitForNotification(methodOrPredicate), message, TIMEOUT);
   };
 
   InspectorSession.prototype._asyncWaitForNotification = async function _asyncWaitForNotification(methodOrPredicate) {
@@ -409,7 +409,7 @@ var NodeInstance = function () {
   NodeInstance.startViaSignal = async function startViaSignal(scriptContents) {
     var instance = new NodeInstance([], scriptContents + '\nprocess._rawDebug(\'started\');', undefined);
     var msg = 'Timed out waiting for process to start';
-    while ((await common.fires(instance.nextStderrString(), msg, TIMEOUT)) !== 'started') {}
+    while ((await fires(instance.nextStderrString(), msg, TIMEOUT)) !== 'started') {}
     process._debugProcess(instance._process.pid);
     return instance;
   };
@@ -508,6 +508,45 @@ function readMainScriptSource() {
   return fs.readFileSync(_MAINSCRIPT, 'utf8');
 }
 
+function onResolvedOrRejected(promise, callback) {
+  return promise.then(function (result) {
+    callback();
+    return result;
+  }, function (error) {
+    callback();
+    throw error;
+  });
+}
+
+function timeoutPromise(error, timeoutMs) {
+  var clearCallback = null;
+  var done = false;
+  var promise = onResolvedOrRejected(new Promise(function (resolve, reject) {
+    var timeout = setTimeout(function () {
+      return reject(error);
+    }, timeoutMs);
+    clearCallback = function () {
+      if (done) return;
+      clearTimeout(timeout);
+      resolve();
+    };
+  }), function () {
+    return done = true;
+  });
+  promise.clear = clearCallback;
+  return promise;
+}
+
+// Returns a new promise that will propagate `promise` resolution or rejection
+// if that happens within the `timeoutMs` timespan, or rejects with `error` as
+// a reason otherwise.
+function fires(promise, error, timeoutMs) {
+  var timeout = timeoutPromise(error, timeoutMs);
+  return Promise.race([onResolvedOrRejected(promise, function () {
+    return timeout.clear();
+  }), timeout]);
+}
+
 module.exports = {
   mainScriptPath: _MAINSCRIPT,
   readMainScriptSource: readMainScriptSource,

test/parallel/test-stream-big-packet.js

@@ -62,7 +62,7 @@ s1.pipe(s3);
 s2.pipe(s3, { end: false });
 
 // We must write a buffer larger than highWaterMark
-var big = bufferShim.alloc(s1._writableState.highWaterMark + 1, 'x');
+var big = bufferShim.alloc(s1.writableHighWaterMark + 1, 'x');
 
 // Since big is larger than highWaterMark, it will be buffered internally.
 assert(!s1.write(big));

test/parallel/test-stream-readable-flow-recursion.js

@@ -64,7 +64,7 @@ flow(stream, 5000, function () {
 process.on('exit', function (code) {
   assert.strictEqual(reads, 2);
   // we pushed up the high water mark
-  assert.strictEqual(stream._readableState.highWaterMark, 8192);
+  assert.strictEqual(stream.readableHighWaterMark, 8192);
   // length is 0 right now, because we pulled it all out.
   assert.strictEqual(stream._readableState.length, 0);
   assert(!code);

test/parallel/test-stream-transform-split-objectmode.js

@@ -31,8 +31,10 @@ var parser = new Transform({ readableObjectMode: true });
 
 assert(parser._readableState.objectMode);
 assert(!parser._writableState.objectMode);
-assert.strictEqual(parser._readableState.highWaterMark, 16);
-assert.strictEqual(parser._writableState.highWaterMark, 16 * 1024);
+assert.strictEqual(parser.readableHighWaterMark, 16);
+assert.strictEqual(parser.writableHighWaterMark, 16 * 1024);
+assert.strictEqual(parser.readableHighWaterMark, parser._readableState.highWaterMark);
+assert.strictEqual(parser.writableHighWaterMark, parser._writableState.highWaterMark);
 
 parser._transform = function (chunk, enc, callback) {
   callback(null, { val: chunk[0] });
@@ -54,8 +56,10 @@ var serializer = new Transform({ writableObjectMode: true });
 
 assert(!serializer._readableState.objectMode);
 assert(serializer._writableState.objectMode);
-assert.strictEqual(serializer._readableState.highWaterMark, 16 * 1024);
-assert.strictEqual(serializer._writableState.highWaterMark, 16);
+assert.strictEqual(serializer.readableHighWaterMark, 16 * 1024);
+assert.strictEqual(serializer.writableHighWaterMark, 16);
+assert.strictEqual(parser.readableHighWaterMark, parser._readableState.highWaterMark);
+assert.strictEqual(parser.writableHighWaterMark, parser._writableState.highWaterMark);
 
 serializer._transform = function (obj, _, callback) {
   callback(null, bufferShim.from([obj.val]));