diff --git a/.babelrc b/.babelrc index 465861f3d1..e61393e664 100644 --- a/.babelrc +++ b/.babelrc @@ -2,9 +2,7 @@ "presets": [ ["@babel/preset-env", { "targets": [ - "last 2 versions", - "not dead", - "node 6.0" + "node 0.10" ], "modules": "commonjs", "exclude": [ diff --git a/README.md b/README.md index 6f035ab16f..19117c1a05 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ npm install --save readable-stream This package is a mirror of the streams implementations in Node.js. -Full documentation may be found on the [Node.js website](https://nodejs.org/dist/v10.19.0/docs/api/stream.html). +Full documentation may be found on the [Node.js website](https://nodejs.org/dist/v10.18.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). diff --git a/build/files.js b/build/files.js index 96d5210947..1494a2a480 100644 --- a/build/files.js +++ b/build/files.js @@ -133,7 +133,7 @@ const headRegexp = /(^module.exports = \w+;?)/m /(?:var|const) (?:{ )Buffer(?: }) = require\('buffer'\)(?:\.Buffer)?;/g , ` const Buffer = require('buffer').Buffer - const OurUint8Array = global.Uint8Array || function () {} + const OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {} function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); } diff --git a/lib/_stream_duplex.js b/lib/_stream_duplex.js index 6752519225..19abfa604d 100644 --- a/lib/_stream_duplex.js +++ b/lib/_stream_duplex.js @@ -18,60 +18,48 @@ // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. + // a duplex stream is just a stream that is both readable and writable. // Since JS doesn't have multiple prototypal inheritance, this class // prototypally inherits from Readable, and then parasitically from // Writable. + 'use strict'; -/**/ +/**/ var objectKeys = Object.keys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - module.exports = Duplex; - var Readable = require('./_stream_readable'); - var Writable = require('./_stream_writable'); - require('inherits')(Duplex, Readable); - { // Allow the keys array to be GC'ed. 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) { if (!(this instanceof Duplex)) return new Duplex(options); Readable.call(this, options); Writable.call(this, options); this.allowHalfOpen = true; - if (options) { if (options.readable === false) this.readable = false; if (options.writable === false) this.writable = false; - if (options.allowHalfOpen === false) { this.allowHalfOpen = false; this.once('end', onend); } } } - Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in @@ -98,20 +86,20 @@ Object.defineProperty(Duplex.prototype, 'writableLength', { get: function get() { return this._writableState.length; } -}); // the no-half-open enforcer +}); +// the no-half-open enforcer function onend() { // If the writable side ended, then we're ok. - if (this._writableState.ended) return; // no more data can be written. - // But allow more writes to happen in this tick. + if (this._writableState.ended) return; + // no more data can be written. + // But allow more writes to happen in this tick. process.nextTick(onEndNT, this); } - function onEndNT(self) { self.end(); } - Object.defineProperty(Duplex.prototype, 'destroyed', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in @@ -121,7 +109,6 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { if (this._readableState === undefined || this._writableState === undefined) { return false; } - return this._readableState.destroyed && this._writableState.destroyed; }, set: function set(value) { @@ -129,10 +116,10 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { // has not been initialized yet if (this._readableState === undefined || this._writableState === undefined) { return; - } // backward compatibility, the user is explicitly - // managing destroyed - + } + // backward compatibility, the user is explicitly + // managing destroyed this._readableState.destroyed = value; this._writableState.destroyed = value; } diff --git a/lib/_stream_passthrough.js b/lib/_stream_passthrough.js index 32e7414c5a..24a6bdde29 100644 --- a/lib/_stream_passthrough.js +++ b/lib/_stream_passthrough.js @@ -18,22 +18,20 @@ // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. + // a passthrough stream. // basically just the most minimal sort of Transform stream. // Every written chunk gets output as-is. + 'use strict'; module.exports = PassThrough; - var Transform = require('./_stream_transform'); - require('inherits')(PassThrough, Transform); - function PassThrough(options) { if (!(this instanceof PassThrough)) return new PassThrough(options); Transform.call(this, options); } - PassThrough.prototype._transform = function (chunk, encoding, cb) { cb(null, chunk); }; \ No newline at end of file diff --git a/lib/_stream_readable.js b/lib/_stream_readable.js index 192d451488..df1f608d53 100644 --- a/lib/_stream_readable.js +++ b/lib/_stream_readable.js @@ -18,49 +18,40 @@ // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. + 'use strict'; module.exports = Readable; -/**/ +/**/ var Duplex; /**/ Readable.ReadableState = ReadableState; -/**/ +/**/ var EE = require('events').EventEmitter; - var EElistenerCount = function EElistenerCount(emitter, type) { return emitter.listeners(type).length; }; /**/ /**/ - - var Stream = require('./internal/streams/stream'); /**/ - var Buffer = require('buffer').Buffer; - -var OurUint8Array = global.Uint8Array || function () {}; - +var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); } - function _isUint8Array(obj) { return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; } -/**/ - +/**/ var debugUtil = require('util'); - var debug; - if (debugUtil && debugUtil.debuglog) { debug = debugUtil.debuglog('stream'); } else { @@ -68,60 +59,57 @@ if (debugUtil && debugUtil.debuglog) { } /**/ - var BufferList = require('./internal/streams/buffer_list'); - var destroyImpl = require('./internal/streams/destroy'); - var _require = require('./internal/streams/state'), - getHighWaterMark = _require.getHighWaterMark; - + getHighWaterMark = _require.getHighWaterMark; var _require$codes = require('../errors').codes, - ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, - ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF, - ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, - ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance. - + ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, + ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF, + ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, + ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; +// Lazy loaded to improve the startup performance. var StringDecoder; var createReadableStreamAsyncIterator; var from; - require('inherits')(Readable, Stream); - var errorOrDestroy = destroyImpl.errorOrDestroy; var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; - function prependListener(emitter, event, fn) { // Sadly this is not cacheable as some libraries bundle their own // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any + if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); + + // This is a hack to make sure that our error handler is attached before any // userland ones. NEVER DO THIS. This is here only because this code needs // to continue to work with older versions of Node.js that do not include // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]]; } - function ReadableState(options, stream, isDuplex) { Duplex = Duplex || require('./_stream_duplex'); - options = options || {}; // Duplex streams are both readable and writable, but share + options = options || {}; + + // Duplex streams are both readable and writable, but share // the same options object. // However, some cases require setting options to different // values for the readable and the writable sides of the duplex stream. // These options can be provided separately as readableXXX and writableXXX. + if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; - if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to + // object stream flag. Used to make read(n) ignore n and to // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer + if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; + + // the point at which it stops calling _read() to fill the buffer // Note: 0 is a valid value, means "don't call _read preemptively ever" + this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); - this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the + // A linked list is used to store data chunks instead of an array because the // linked list can remove elements from the beginning faster than // array.shift() - this.buffer = new BufferList(); this.length = 0; this.pipes = null; @@ -129,61 +117,66 @@ function ReadableState(options, stream, isDuplex) { this.flowing = null; this.ended = false; this.endEmitted = false; - this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted + this.reading = false; + + // a flag to be able to tell if the event 'readable'/'data' is emitted // immediately, or on a later tick. We set this to true at first, because // any actions that shouldn't happen until "later" should generally also // not happen before the first read call. + this.sync = true; - this.sync = true; // whenever we return null, then we set a flag to say + // whenever we return null, then we set a flag to say // that we're awaiting a 'readable' event emission. - this.needReadable = false; this.emittedReadable = false; this.readableListening = false; this.resumeScheduled = false; - this.paused = true; // Should close be emitted on destroy. Defaults to true. + this.paused = true; - this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish') + // Should close be emitted on destroy. Defaults to true. + this.emitClose = options.emitClose !== false; - this.autoDestroy = !!options.autoDestroy; // has it been destroyed + // Should .destroy() be called after 'end' (and potentially 'finish') + this.autoDestroy = !!options.autoDestroy; - this.destroyed = false; // Crypto is kind of old and crusty. Historically, its default string + // has it been destroyed + this.destroyed = false; + + // Crypto is kind of old and crusty. Historically, its default string // encoding is 'binary' so we have to make this configurable. // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; - this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s - - this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled + // the number of writers that are awaiting a drain event in .pipe()s + this.awaitDrain = 0; + // if true, a maybeReadMore has been scheduled this.readingMore = false; this.decoder = null; this.encoding = null; - if (options.encoding) { if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; this.decoder = new StringDecoder(options.encoding); this.encoding = options.encoding; } } - function Readable(options) { Duplex = Duplex || require('./_stream_duplex'); - if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside - // the ReadableState constructor, at least with V8 6.5 + if (!(this instanceof Readable)) return new Readable(options); + // Checking for a Stream.Duplex instance is faster here instead of inside + // the ReadableState constructor, at least with V8 6.5 var isDuplex = this instanceof Duplex; - this._readableState = new ReadableState(options, this, isDuplex); // legacy + this._readableState = new ReadableState(options, this, isDuplex); + // legacy this.readable = true; - if (options) { if (typeof options.read === 'function') this._read = options.read; if (typeof options.destroy === 'function') this._destroy = options.destroy; } - Stream.call(this); } - Object.defineProperty(Readable.prototype, 'destroyed', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in @@ -193,7 +186,6 @@ Object.defineProperty(Readable.prototype, 'destroyed', { if (this._readableState === undefined) { return false; } - return this._readableState.destroyed; }, set: function set(value) { @@ -201,69 +193,60 @@ Object.defineProperty(Readable.prototype, 'destroyed', { // has not been initialized yet if (!this._readableState) { return; - } // backward compatibility, the user is explicitly - // managing destroyed - + } + // backward compatibility, the user is explicitly + // managing destroyed this._readableState.destroyed = value; } }); Readable.prototype.destroy = destroyImpl.destroy; Readable.prototype._undestroy = destroyImpl.undestroy; - Readable.prototype._destroy = function (err, cb) { cb(err); -}; // Manually shove something into the read() buffer. +}; + +// Manually shove something into the read() buffer. // This returns true if the highWaterMark has not been hit yet, // similar to how Writable.write() returns true if you should // write() some more. - - Readable.prototype.push = function (chunk, encoding) { var state = this._readableState; var skipChunkCheck; - if (!state.objectMode) { if (typeof chunk === 'string') { encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { chunk = Buffer.from(chunk, encoding); encoding = ''; } - skipChunkCheck = true; } } else { skipChunkCheck = true; } - return readableAddChunk(this, chunk, encoding, false, skipChunkCheck); -}; // Unshift should *always* be something directly out of read() - +}; +// Unshift should *always* be something directly out of read() Readable.prototype.unshift = function (chunk) { return readableAddChunk(this, chunk, null, true, false); }; - function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { debug('readableAddChunk', chunk); var state = stream._readableState; - if (chunk === null) { state.reading = false; onEofChunk(stream, state); } else { var er; if (!skipChunkCheck) er = chunkInvalid(state, chunk); - if (er) { errorOrDestroy(stream, er); } else if (state.objectMode || chunk && chunk.length > 0) { if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) { chunk = _uint8ArrayToBuffer(chunk); } - if (addToFront) { if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true); } else if (state.ended) { @@ -272,7 +255,6 @@ function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { return false; } else { state.reading = false; - if (state.decoder && !encoding) { chunk = state.decoder.write(chunk); if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state); @@ -284,14 +266,13 @@ function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { state.reading = false; maybeReadMore(stream, state); } - } // We can push more data if we are below the highWaterMark. + } + + // We can push more data if we are below the highWaterMark. // Also, if we have no data yet, we can stand some more bytes. // This is to work around cases where hwm=0, such as the repl. - - return !state.ended && (state.length < state.highWaterMark || state.length === 0); } - function addChunk(stream, state, chunk, addToFront) { if (state.flowing && state.length === 0 && !state.sync) { state.awaitDrain = 0; @@ -302,50 +283,42 @@ function addChunk(stream, state, chunk, addToFront) { if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); if (state.needReadable) emitReadable(stream); } - maybeReadMore(stream, state); } - function chunkInvalid(state, chunk) { var er; - if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk); } - return er; } - Readable.prototype.isPaused = function () { return this._readableState.flowing === false; -}; // backwards compatibility. - +}; +// backwards compatibility. Readable.prototype.setEncoding = function (enc) { if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; var decoder = new StringDecoder(enc); - this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8 - - this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers: + this._readableState.decoder = decoder; + // If setEncoding(null), decoder.encoding equals utf8 + this._readableState.encoding = this._readableState.decoder.encoding; + // Iterate over current buffer to convert already stored Buffers: var p = this._readableState.buffer.head; var content = ''; - while (p !== null) { content += decoder.write(p.data); p = p.next; } - this._readableState.buffer.clear(); - if (content !== '') this._readableState.buffer.push(content); this._readableState.length = content.length; return this; -}; // Don't raise the hwm > 1GB - +}; +// Don't raise the hwm > 1GB var MAX_HWM = 0x40000000; - function computeNewHighWaterMark(n) { if (n >= MAX_HWM) { // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE. @@ -361,55 +334,54 @@ function computeNewHighWaterMark(n) { n |= n >>> 16; n++; } - return n; -} // This function is designed to be inlinable, so please take care when making -// changes to the function body. - +} +// This function is designed to be inlinable, so please take care when making +// changes to the function body. function howMuchToRead(n, state) { if (n <= 0 || state.length === 0 && state.ended) return 0; if (state.objectMode) return 1; - if (n !== n) { // Only flow one buffer at a time if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } // If we're asking for more than the current hwm, then raise the hwm. - - + } + // If we're asking for more than the current hwm, then raise the hwm. if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; // Don't have enough - + if (n <= state.length) return n; + // Don't have enough if (!state.ended) { state.needReadable = true; return 0; } - return state.length; -} // you can override either this method, or the async _read(n) below. - +} +// you can override either this method, or the async _read(n) below. Readable.prototype.read = function (n) { debug('read', n); n = parseInt(n, 10); var state = this._readableState; var nOrig = n; - if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we + if (n !== 0) state.emittedReadable = false; + + // if we're doing read(0) to trigger a readable event, but we // already have a bunch of data in the buffer, then just trigger // the 'readable' event and move on. - if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) { debug('read: emitReadable', state.length, state.ended); if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); return null; } + n = howMuchToRead(n, state); - n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up. - + // if we've ended, and we're now clear, then finish it up. if (n === 0 && state.ended) { if (state.length === 0) endReadable(this); return null; - } // All the actual chunk generation logic needs to be + } + + // All the actual chunk generation logic needs to be // *below* the call to _read. The reason is that in certain // synthetic stream cases, such as passthrough streams, _read // may be a completely synchronous operation which may change @@ -430,40 +402,37 @@ Readable.prototype.read = function (n) { // 'readable' etc. // // 3. Actually pull the requested chunks out of the buffer and return. - // if we need a readable event, then we need to do some reading. - + // if we need a readable event, then we need to do some reading. var doRead = state.needReadable; - debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some + debug('need readable', doRead); + // if we currently have less than the highWaterMark, then also read some if (state.length === 0 || state.length - n < state.highWaterMark) { doRead = true; debug('length less than watermark', doRead); - } // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - + } + // however, if we've ended, then there's no point, and if we're already + // reading, then it's unnecessary. if (state.ended || state.reading) { doRead = false; debug('reading or ended', doRead); } else if (doRead) { debug('do read'); state.reading = true; - state.sync = true; // if the length is currently zero, then we *need* a readable event. - - if (state.length === 0) state.needReadable = true; // call internal read method - + state.sync = true; + // if the length is currently zero, then we *need* a readable event. + if (state.length === 0) state.needReadable = true; + // call internal read method this._read(state.highWaterMark); - - state.sync = false; // If _read pushed data synchronously, then `reading` will be false, + state.sync = false; + // If _read pushed data synchronously, then `reading` will be false, // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); } - var ret; if (n > 0) ret = fromList(n, state);else ret = null; - if (ret === null) { state.needReadable = state.length <= state.highWaterMark; n = 0; @@ -471,34 +440,28 @@ Readable.prototype.read = function (n) { state.length -= n; state.awaitDrain = 0; } - if (state.length === 0) { // If we have nothing in the buffer, then we want to know // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick. + if (!state.ended) state.needReadable = true; + // If we tried to read() past the EOF, then emit end on the next tick. if (nOrig !== n && state.ended) endReadable(this); } - if (ret !== null) this.emit('data', ret); return ret; }; - function onEofChunk(stream, state) { debug('onEofChunk'); if (state.ended) return; - if (state.decoder) { var chunk = state.decoder.end(); - if (chunk && chunk.length) { state.buffer.push(chunk); state.length += state.objectMode ? 1 : chunk.length; } } - state.ended = true; - if (state.sync) { // if we are sync, wait until next tick to emit the data. // Otherwise we risk emitting data in the flow() @@ -507,61 +470,56 @@ function onEofChunk(stream, state) { } else { // emit 'readable' now to make sure it gets picked up. state.needReadable = false; - if (!state.emittedReadable) { state.emittedReadable = true; emitReadable_(stream); } } -} // Don't emit readable right away in sync mode, because this can trigger +} + +// Don't emit readable right away in sync mode, because this can trigger // another read() call => stack overflow. This way, it might trigger // a nextTick recursion warning, but that's not so bad. - - function emitReadable(stream) { var state = stream._readableState; debug('emitReadable', state.needReadable, state.emittedReadable); state.needReadable = false; - if (!state.emittedReadable) { debug('emitReadable', state.flowing); state.emittedReadable = true; process.nextTick(emitReadable_, stream); } } - function emitReadable_(stream) { var state = stream._readableState; debug('emitReadable_', state.destroyed, state.length, state.ended); - if (!state.destroyed && (state.length || state.ended)) { stream.emit('readable'); state.emittedReadable = false; - } // The stream needs another readable event if + } + + // The stream needs another readable event if // 1. It is not flowing, as the flow mechanism will take // care of it. // 2. It is not ended. // 3. It is below the highWaterMark, so we can schedule // another readable later. - - state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark; flow(stream); -} // at this point, the user has presumably seen the 'readable' event, +} + +// at this point, the user has presumably seen the 'readable' event, // and called read() to consume some data. that may have triggered // in turn another _read(n) call, in which case reading = true if // it's in progress. // However, if we're not ended, or reading, and the length < hwm, // then go ahead and try to read some more preemptively. - - function maybeReadMore(stream, state) { if (!state.readingMore) { state.readingMore = true; process.nextTick(maybeReadMore_, stream, state); } } - function maybeReadMore_(stream, state) { // Attempt to read more data if we should. // @@ -590,49 +548,42 @@ function maybeReadMore_(stream, state) { var len = state.length; debug('maybeReadMore read 0'); stream.read(0); - if (len === state.length) // didn't get any data, stop spinning. + if (len === state.length) + // didn't get any data, stop spinning. break; } - state.readingMore = false; -} // abstract method. to be overridden in specific implementation classes. +} + +// abstract method. to be overridden in specific implementation classes. // call cb(er, data) where data is <= n in length. // for virtual (non-string, non-buffer) streams, "length" is somewhat // arbitrary, and perhaps not very meaningful. - - Readable.prototype._read = function (n) { errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()')); }; - Readable.prototype.pipe = function (dest, pipeOpts) { var src = this; var state = this._readableState; - switch (state.pipesCount) { case 0: state.pipes = dest; break; - case 1: state.pipes = [state.pipes, dest]; break; - default: state.pipes.push(dest); break; } - state.pipesCount += 1; debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr; var endFn = doEnd ? onend : unpipe; if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn); dest.on('unpipe', onunpipe); - function onunpipe(readable, unpipeInfo) { debug('onunpipe'); - if (readable === src) { if (unpipeInfo && unpipeInfo.hasUnpiped === false) { unpipeInfo.hasUnpiped = true; @@ -640,23 +591,21 @@ Readable.prototype.pipe = function (dest, pipeOpts) { } } } - function onend() { debug('onend'); dest.end(); - } // when the dest drains, it reduces the awaitDrain counter + } + + // when the dest drains, it reduces the awaitDrain counter // on the source. This would be more elegant with a .once() // handler in flow(), but adding and removing repeatedly is // too slow. - - var ondrain = pipeOnDrain(src); dest.on('drain', ondrain); var cleanedUp = false; - function cleanup() { - debug('cleanup'); // cleanup event handlers once the pipe is broken - + debug('cleanup'); + // cleanup event handlers once the pipe is broken dest.removeListener('close', onclose); dest.removeListener('finish', onfinish); dest.removeListener('drain', ondrain); @@ -665,22 +614,20 @@ Readable.prototype.pipe = function (dest, pipeOpts) { src.removeListener('end', onend); src.removeListener('end', unpipe); src.removeListener('data', ondata); - cleanedUp = true; // if the reader is waiting for a drain event from this + cleanedUp = true; + + // if the reader is waiting for a drain event from this // specific writer, then it would cause it to never start // flowing again. // So, if this is awaiting a drain, then we just call it now. // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); } - src.on('data', ondata); - function ondata(chunk) { debug('ondata'); var ret = dest.write(chunk); debug('dest.write', ret); - if (ret === false) { // If the user unpiped during `dest.write()`, it is possible // to get stuck in a permanently paused state if that write @@ -690,87 +637,84 @@ Readable.prototype.pipe = function (dest, pipeOpts) { debug('false write response, pause', state.awaitDrain); state.awaitDrain++; } - src.pause(); } - } // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - + } + // if the dest has an error, then stop piping into it. + // however, don't suppress the throwing behavior for this. function onerror(er) { debug('onerror', er); unpipe(); dest.removeListener('error', onerror); if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er); - } // Make sure our error handler is attached before userland ones. - + } - prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once. + // Make sure our error handler is attached before userland ones. + prependListener(dest, 'error', onerror); + // Both close and finish should trigger unpipe, but only once. function onclose() { dest.removeListener('finish', onfinish); unpipe(); } - dest.once('close', onclose); - function onfinish() { debug('onfinish'); dest.removeListener('close', onclose); unpipe(); } - dest.once('finish', onfinish); - function unpipe() { debug('unpipe'); src.unpipe(dest); - } // tell the dest that it's being piped to - + } - dest.emit('pipe', src); // start the flow if it hasn't been started already. + // tell the dest that it's being piped to + dest.emit('pipe', src); + // start the flow if it hasn't been started already. if (!state.flowing) { debug('pipe resume'); src.resume(); } - return dest; }; - function pipeOnDrain(src) { return function pipeOnDrainFunctionResult() { var state = src._readableState; debug('pipeOnDrain', state.awaitDrain); if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) { state.flowing = true; flow(src); } }; } - Readable.prototype.unpipe = function (dest) { var state = this._readableState; var unpipeInfo = { hasUnpiped: false - }; // if we're not piping anywhere, then do nothing. + }; - if (state.pipesCount === 0) return this; // just one destination. most common case. + // if we're not piping anywhere, then do nothing. + if (state.pipesCount === 0) return this; + // just one destination. most common case. if (state.pipesCount === 1) { // passed in one, but it's not the right one. if (dest && dest !== state.pipes) return this; - if (!dest) dest = state.pipes; // got a match. + if (!dest) dest = state.pipes; + // got a match. state.pipes = null; state.pipesCount = 0; state.flowing = false; if (dest) dest.emit('unpipe', this, unpipeInfo); return this; - } // slow case. multiple pipe destinations. + } + // slow case. multiple pipe destinations. if (!dest) { // remove all. @@ -779,17 +723,13 @@ Readable.prototype.unpipe = function (dest) { state.pipes = null; state.pipesCount = 0; state.flowing = false; - - for (var i = 0; i < len; i++) { - dests[i].emit('unpipe', this, { - hasUnpiped: false - }); - } - + for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, { + hasUnpiped: false + }); return this; - } // try to find the right one. - + } + // try to find the right one. var index = indexOf(state.pipes, dest); if (index === -1) return this; state.pipes.splice(index, 1); @@ -797,19 +737,19 @@ Readable.prototype.unpipe = function (dest) { if (state.pipesCount === 1) state.pipes = state.pipes[0]; dest.emit('unpipe', this, unpipeInfo); return this; -}; // set up data events if they are asked for -// Ensure readable listeners eventually get something - +}; +// set up data events if they are asked for +// Ensure readable listeners eventually get something Readable.prototype.on = function (ev, fn) { var res = Stream.prototype.on.call(this, ev, fn); var state = this._readableState; - if (ev === 'data') { // update readableListening so that resume() may be a no-op // a few lines down. This is needed to support once('readable'). - state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused + state.readableListening = this.listenerCount('readable') > 0; + // Try start flowing on next tick if stream isn't explicitly paused if (state.flowing !== false) this.resume(); } else if (ev === 'readable') { if (!state.endEmitted && !state.readableListening) { @@ -817,7 +757,6 @@ Readable.prototype.on = function (ev, fn) { state.flowing = false; state.emittedReadable = false; debug('on readable', state.length, state.reading); - if (state.length) { emitReadable(this); } else if (!state.reading) { @@ -825,15 +764,11 @@ Readable.prototype.on = function (ev, fn) { } } } - return res; }; - Readable.prototype.addListener = Readable.prototype.on; - Readable.prototype.removeListener = function (ev, fn) { var res = Stream.prototype.removeListener.call(this, ev, fn); - if (ev === 'readable') { // We need to check if there is someone still listening to // readable and reset the state. However this needs to happen @@ -843,13 +778,10 @@ Readable.prototype.removeListener = function (ev, fn) { // effect. process.nextTick(updateReadableListening, this); } - return res; }; - Readable.prototype.removeAllListeners = function (ev) { var res = Stream.prototype.removeAllListeners.apply(this, arguments); - if (ev === 'readable' || ev === undefined) { // We need to check if there is someone still listening to // readable and reset the state. However this needs to happen @@ -859,121 +791,103 @@ Readable.prototype.removeAllListeners = function (ev) { // effect. process.nextTick(updateReadableListening, this); } - return res; }; - function updateReadableListening(self) { var state = self._readableState; state.readableListening = self.listenerCount('readable') > 0; - if (state.resumeScheduled && !state.paused) { // flowing needs to be set to true now, otherwise // the upcoming resume will not flow. - state.flowing = true; // crude way to check if we should resume + state.flowing = true; + + // crude way to check if we should resume } else if (self.listenerCount('data') > 0) { self.resume(); } } - function nReadingNextTick(self) { debug('readable nexttick read 0'); self.read(0); -} // pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. - +} +// pause() and resume() are remnants of the legacy readable stream API +// If the user uses them, then switch into old mode. Readable.prototype.resume = function () { var state = this._readableState; - if (!state.flowing) { - debug('resume'); // we flow only if there is no one listening + debug('resume'); + // we flow only if there is no one listening // for readable, but we still have to call // resume() - state.flowing = !state.readableListening; resume(this, state); } - state.paused = false; return this; }; - function resume(stream, state) { if (!state.resumeScheduled) { state.resumeScheduled = true; process.nextTick(resume_, stream, state); } } - function resume_(stream, state) { debug('resume', state.reading); - if (!state.reading) { stream.read(0); } - state.resumeScheduled = false; stream.emit('resume'); flow(stream); if (state.flowing && !state.reading) stream.read(0); } - Readable.prototype.pause = function () { debug('call pause flowing=%j', this._readableState.flowing); - if (this._readableState.flowing !== false) { debug('pause'); this._readableState.flowing = false; this.emit('pause'); } - this._readableState.paused = true; return this; }; - function flow(stream) { var state = stream._readableState; debug('flow', state.flowing); + while (state.flowing && stream.read() !== null); +} - while (state.flowing && stream.read() !== null) { - ; - } -} // wrap an old-style stream as the async data source. +// wrap an old-style stream as the async data source. // This is *not* part of the readable stream interface. // It is an ugly unfortunate mess of history. - - Readable.prototype.wrap = function (stream) { var _this = this; - var state = this._readableState; var paused = false; stream.on('end', function () { debug('wrapped end'); - if (state.decoder && !state.ended) { var chunk = state.decoder.end(); if (chunk && chunk.length) _this.push(chunk); } - _this.push(null); }); stream.on('data', function (chunk) { debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode + if (state.decoder) chunk = state.decoder.write(chunk); + // don't skip over falsy values in objectMode if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - var ret = _this.push(chunk); - if (!ret) { paused = true; stream.pause(); } - }); // proxy all the other methods. - // important when wrapping filters and duplexes. + }); + // proxy all the other methods. + // important when wrapping filters and duplexes. for (var i in stream) { if (this[i] === undefined && typeof stream[i] === 'function') { this[i] = function methodWrap(method) { @@ -982,37 +896,32 @@ Readable.prototype.wrap = function (stream) { }; }(i); } - } // proxy certain important events. - + } + // proxy certain important events. for (var n = 0; n < kProxyEvents.length; n++) { stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n])); - } // when we try to consume some more bytes, simply unpause the - // underlying stream. - + } + // when we try to consume some more bytes, simply unpause the + // underlying stream. this._read = function (n) { debug('wrapped _read', n); - if (paused) { paused = false; stream.resume(); } }; - return this; }; - if (typeof Symbol === 'function') { Readable.prototype[Symbol.asyncIterator] = function () { if (createReadableStreamAsyncIterator === undefined) { createReadableStreamAsyncIterator = require('./internal/streams/async_iterator'); } - return createReadableStreamAsyncIterator(this); }; } - Object.defineProperty(Readable.prototype, 'readableHighWaterMark', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in @@ -1044,8 +953,9 @@ Object.defineProperty(Readable.prototype, 'readableFlowing', { this._readableState.flowing = state; } } -}); // exposed for testing purposes only. +}); +// exposed for testing purposes only. Readable._fromList = fromList; Object.defineProperty(Readable.prototype, 'readableLength', { // making it explicit this property is not enumerable @@ -1055,11 +965,12 @@ Object.defineProperty(Readable.prototype, 'readableLength', { get: function get() { return this._readableState.length; } -}); // Pluck off n bytes from an array of buffers. +}); + +// Pluck off n bytes from an array of buffers. // Length is the combined lengths of all the buffers in the list. // This function is designed to be inlinable, so please take care when making // changes to the function body. - function fromList(n, state) { // nothing buffered if (state.length === 0) return null; @@ -1074,51 +985,43 @@ function fromList(n, state) { } return ret; } - function endReadable(stream) { var state = stream._readableState; debug('endReadable', state.endEmitted); - if (!state.endEmitted) { state.ended = true; process.nextTick(endReadableNT, state, stream); } } - function endReadableNT(state, stream) { - debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift. + debug('endReadableNT', state.endEmitted, state.length); + // Check that we didn't get one last unshift. if (!state.endEmitted && state.length === 0) { state.endEmitted = true; stream.readable = false; stream.emit('end'); - if (state.autoDestroy) { // In case of duplex streams we need a way to detect // if the writable side is ready for autoDestroy as well var wState = stream._writableState; - if (!wState || wState.autoDestroy && wState.finished) { stream.destroy(); } } } } - if (typeof Symbol === 'function') { Readable.from = function (iterable, opts) { if (from === undefined) { from = require('./internal/streams/from'); } - return from(Readable, iterable, opts); }; } - function indexOf(xs, x) { for (var i = 0, l = xs.length; i < l; i++) { if (xs[i] === x) return i; } - return -1; } \ No newline at end of file diff --git a/lib/_stream_transform.js b/lib/_stream_transform.js index 41a738c4e9..1ccb7157be 100644 --- a/lib/_stream_transform.js +++ b/lib/_stream_transform.js @@ -18,6 +18,7 @@ // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. + // a transform stream is a readable/writable stream where you do // something with the data. Sometimes it's called a "filter", // but that's not a great name for it, since that implies a thing where @@ -59,42 +60,36 @@ // However, even in such a pathological case, only a single written chunk // would be consumed, and then the rest would wait (un-transformed) until // the results of the previous transformed chunk were consumed. + 'use strict'; module.exports = Transform; - var _require$codes = require('../errors').codes, - ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, - ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, - ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING, - ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0; - + ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, + ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, + ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING, + ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0; var Duplex = require('./_stream_duplex'); - require('inherits')(Transform, Duplex); - function afterTransform(er, data) { var ts = this._transformState; ts.transforming = false; var cb = ts.writecb; - if (cb === null) { return this.emit('error', new ERR_MULTIPLE_CALLBACK()); } - ts.writechunk = null; ts.writecb = null; - if (data != null) // single equals check for both `null` and `undefined` + if (data != null) + // single equals check for both `null` and `undefined` this.push(data); cb(er); var rs = this._readableState; rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { this._read(rs.highWaterMark); } } - function Transform(options) { if (!(this instanceof Transform)) return new Transform(options); Duplex.call(this, options); @@ -105,26 +100,25 @@ function Transform(options) { writecb: null, writechunk: null, writeencoding: null - }; // start out asking for a readable event once data is transformed. + }; + + // start out asking for a readable event once data is transformed. + this._readableState.needReadable = true; - this._readableState.needReadable = true; // we have implemented the _read method, and done the other things + // we have implemented the _read method, and done the other things // that Readable wants before the first _read call, so unset the // sync guard flag. - this._readableState.sync = false; - if (options) { if (typeof options.transform === 'function') this._transform = options.transform; if (typeof options.flush === 'function') this._flush = options.flush; - } // When the writable side finishes, then flush out anything remaining. - + } + // When the writable side finishes, then flush out anything remaining. this.on('prefinish', prefinish); } - function prefinish() { var _this = this; - if (typeof this._flush === 'function' && !this._readableState.destroyed) { this._flush(function (er, data) { done(_this, er, data); @@ -133,11 +127,12 @@ function prefinish() { done(this, null, null); } } - Transform.prototype.push = function (chunk, encoding) { this._transformState.needTransform = false; return Duplex.prototype.push.call(this, chunk, encoding); -}; // This is the part where you do stuff! +}; + +// This is the part where you do stuff! // override this function in implementation classes. // 'chunk' is an input chunk. // @@ -147,33 +142,27 @@ Transform.prototype.push = function (chunk, encoding) { // Call `cb(err)` when you are done with this chunk. If you pass // an error, then that'll put the hurt on the whole operation. If you // never call cb(), then you'll never get another chunk. - - Transform.prototype._transform = function (chunk, encoding, cb) { cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()')); }; - Transform.prototype._write = function (chunk, encoding, cb) { var ts = this._transformState; ts.writecb = cb; ts.writechunk = chunk; ts.writeencoding = encoding; - if (!ts.transforming) { var rs = this._readableState; if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); } -}; // Doesn't matter what the args are here. +}; + +// Doesn't matter what the args are here. // _transform does all the work. // That we got here means that the readable side wants more data. - - Transform.prototype._read = function (n) { var ts = this._transformState; - if (ts.writechunk !== null && !ts.transforming) { ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); } else { // mark that we need a transform, so that any data that comes in @@ -181,20 +170,20 @@ Transform.prototype._read = function (n) { ts.needTransform = true; } }; - Transform.prototype._destroy = function (err, cb) { Duplex.prototype._destroy.call(this, err, function (err2) { cb(err2); }); }; - function done(stream, er, data) { if (er) return stream.emit('error', er); - if (data != null) // single equals check for both `null` and `undefined` - stream.push(data); // TODO(BridgeAR): Write a test for these two error cases + if (data != null) + // single equals check for both `null` and `undefined` + stream.push(data); + + // TODO(BridgeAR): Write a test for these two error cases // if there's nothing in the write buffer, then that means // that nothing more will ever be provided - if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0(); if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING(); return stream.push(null); diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js index a2634d7c24..292415e23a 100644 --- a/lib/_stream_writable.js +++ b/lib/_stream_writable.js @@ -18,29 +18,29 @@ // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. + // A bit simpler than readable streams. // Implement an async ._write(chunk, encoding, cb), and it'll handle all // the drain event emission and buffering. + 'use strict'; module.exports = Writable; -/* */ +/* */ function WriteReq(chunk, encoding, cb) { this.chunk = chunk; this.encoding = encoding; this.callback = cb; this.next = null; -} // It seems a linked list but it is not -// there will be only 2 of these for each stream - +} +// It seems a linked list but it is not +// there will be only 2 of these for each stream function CorkedRequest(state) { var _this = this; - this.next = null; this.entry = null; - this.finish = function () { onCorkedFinish(_this, state); }; @@ -48,155 +48,159 @@ function CorkedRequest(state) { /* */ /**/ - - var Duplex; /**/ Writable.WritableState = WritableState; -/**/ +/**/ var internalUtil = { deprecate: require('util-deprecate') }; /**/ /**/ - var Stream = require('./internal/streams/stream'); /**/ - var Buffer = require('buffer').Buffer; - -var OurUint8Array = global.Uint8Array || function () {}; - +var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); } - function _isUint8Array(obj) { return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; } - var destroyImpl = require('./internal/streams/destroy'); - var _require = require('./internal/streams/state'), - getHighWaterMark = _require.getHighWaterMark; - + getHighWaterMark = _require.getHighWaterMark; var _require$codes = require('../errors').codes, - ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, - ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, - ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, - ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE, - ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED, - ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES, - ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END, - ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING; - + ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, + ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, + ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, + ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE, + ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED, + ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES, + ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END, + ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING; var errorOrDestroy = destroyImpl.errorOrDestroy; - require('inherits')(Writable, Stream); - function nop() {} - function WritableState(options, stream, isDuplex) { Duplex = Duplex || require('./_stream_duplex'); - options = options || {}; // Duplex streams are both readable and writable, but share + options = options || {}; + + // Duplex streams are both readable and writable, but share // the same options object. // However, some cases require setting options to different // values for the readable and the writable sides of the duplex stream, // e.g. options.readableObjectMode vs. options.writableObjectMode, etc. + if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; - if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream + // object stream flag to indicate whether or not this stream // contains buffers or objects. - this.objectMode = !!options.objectMode; - if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false + if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; + + // the point at which write() starts returning false // Note: 0 is a valid value, means that we always return false if // the entire buffer is not flushed immediately on write() + this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); - this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called + // if _final has been called + this.finalCalled = false; - this.finalCalled = false; // drain event flag. + // drain event flag. + this.needDrain = false; + // at the start of calling end() + this.ending = false; + // when end() has been called, and returned + this.ended = false; + // when 'finish' is emitted + this.finished = false; - this.needDrain = false; // at the start of calling end() + // has it been destroyed + this.destroyed = false; - this.ending = false; // when end() has been called, and returned - - this.ended = false; // when 'finish' is emitted - - this.finished = false; // has it been destroyed - - this.destroyed = false; // should we decode strings into buffers before passing to _write? + // should we decode strings into buffers before passing to _write? // this is here so that some node-core streams can optimize string // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; // Crypto is kind of old and crusty. Historically, its default string + this.decodeStrings = !noDecode; + + // Crypto is kind of old and crusty. Historically, its default string // encoding is 'binary' so we have to make this configurable. // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; - this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement + // not an actual buffer we keep track of, but a measurement // of how much we're waiting to get pushed to some underlying // socket or file. + this.length = 0; - this.length = 0; // a flag to see when we're in the middle of a write. + // a flag to see when we're in the middle of a write. + this.writing = false; - this.writing = false; // when true all writes will be buffered until .uncork() call + // when true all writes will be buffered until .uncork() call + this.corked = 0; - this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately, + // a flag to be able to tell if the onwrite cb is called immediately, // or on a later tick. We set this to true at first, because any // actions that shouldn't happen until "later" should generally also // not happen before the first write call. + this.sync = true; - this.sync = true; // a flag to know if we're processing previously buffered items, which + // a flag to know if we're processing previously buffered items, which // may call the _write() callback in the same tick, so that we don't // end up in an overlapped onwrite situation. + this.bufferProcessing = false; - this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb) - + // the callback that's passed to _write(chunk,cb) this.onwrite = function (er) { onwrite(stream, er); - }; // the callback that the user supplies to write(chunk,encoding,cb) - + }; - this.writecb = null; // the amount that is being written when _write is called. + // the callback that the user supplies to write(chunk,encoding,cb) + this.writecb = null; + // the amount that is being written when _write is called. this.writelen = 0; this.bufferedRequest = null; - this.lastBufferedRequest = null; // number of pending user-supplied write callbacks + this.lastBufferedRequest = null; + + // number of pending user-supplied write callbacks // this must be 0 before 'finish' can be emitted + this.pendingcb = 0; - this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs + // emit prefinish if the only thing we're waiting for is _write cbs // This is relevant for synchronous Transform streams + this.prefinished = false; - this.prefinished = false; // True if the error was already emitted and should not be thrown again + // True if the error was already emitted and should not be thrown again + this.errorEmitted = false; - this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true. + // Should close be emitted on destroy. Defaults to true. + this.emitClose = options.emitClose !== false; - this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end') + // Should .destroy() be called after 'finish' (and potentially 'end') + this.autoDestroy = !!options.autoDestroy; - this.autoDestroy = !!options.autoDestroy; // count buffered requests + // count buffered requests + this.bufferedRequestCount = 0; - this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always + // allocate the first CorkedRequest, there is always // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); } - WritableState.prototype.getBuffer = function getBuffer() { var current = this.bufferedRequest; var out = []; - while (current) { out.push(current); current = current.next; } - return out; }; - (function () { try { Object.defineProperty(WritableState.prototype, 'buffer', { @@ -205,12 +209,11 @@ WritableState.prototype.getBuffer = function getBuffer() { }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003') }); } catch (_) {} -})(); // Test _writableState for inheritance to account for Duplex streams, -// whose prototype chain only points to Readable. - +})(); +// Test _writableState for inheritance to account for Duplex streams, +// whose prototype chain only points to Readable. var realHasInstance; - if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') { realHasInstance = Function.prototype[Symbol.hasInstance]; Object.defineProperty(Writable, Symbol.hasInstance, { @@ -225,81 +228,73 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot return object instanceof this; }; } - function Writable(options) { - Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too. + Duplex = Duplex || require('./_stream_duplex'); + + // Writable ctor is applied to Duplexes, too. // `realHasInstance` is necessary because using plain `instanceof` // would return false, as no `_writableState` property is attached. + // Trying to use the custom `instanceof` for Writable here will also break the // Node.js LazyTransform implementation, which has a non-trivial getter for // `_writableState` that would lead to infinite recursion. + // Checking for a Stream.Duplex instance is faster here instead of inside // the WritableState constructor, at least with V8 6.5 - var isDuplex = this instanceof Duplex; if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options); - this._writableState = new WritableState(options, this, isDuplex); // legacy. + this._writableState = new WritableState(options, this, isDuplex); + // legacy. this.writable = true; - if (options) { if (typeof options.write === 'function') this._write = options.write; if (typeof options.writev === 'function') this._writev = options.writev; if (typeof options.destroy === 'function') this._destroy = options.destroy; if (typeof options.final === 'function') this._final = options.final; } - Stream.call(this); -} // Otherwise people can pipe Writable streams, which is just wrong. - +} +// Otherwise people can pipe Writable streams, which is just wrong. Writable.prototype.pipe = function () { errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE()); }; - function writeAfterEnd(stream, cb) { - var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb - + var er = new ERR_STREAM_WRITE_AFTER_END(); + // TODO: defer error events consistently everywhere, not just the cb errorOrDestroy(stream, er); process.nextTick(cb, er); -} // Checks that a user-supplied chunk is valid, especially for the particular +} + +// Checks that a user-supplied chunk is valid, especially for the particular // mode the stream is in. Currently this means that `null` is never accepted // and undefined/non-string values are only allowed in object mode. - - function validChunk(stream, state, chunk, cb) { var er; - if (chunk === null) { er = new ERR_STREAM_NULL_VALUES(); } else if (typeof chunk !== 'string' && !state.objectMode) { er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk); } - if (er) { errorOrDestroy(stream, er); process.nextTick(cb, er); return false; } - return true; } - Writable.prototype.write = function (chunk, encoding, cb) { var state = this._writableState; var ret = false; - var isBuf = !state.objectMode && _isUint8Array(chunk); - if (isBuf && !Buffer.isBuffer(chunk)) { chunk = _uint8ArrayToBuffer(chunk); } - if (typeof encoding === 'function') { cb = encoding; encoding = null; } - if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; if (typeof cb !== 'function') cb = nop; if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) { @@ -308,20 +303,16 @@ Writable.prototype.write = function (chunk, encoding, cb) { } return ret; }; - Writable.prototype.cork = function () { this._writableState.corked++; }; - Writable.prototype.uncork = function () { var state = this._writableState; - if (state.corked) { state.corked--; if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); } }; - Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { // node::ParseEncoding() requires lower case. if (typeof encoding === 'string') encoding = encoding.toLowerCase(); @@ -329,7 +320,6 @@ Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { this._writableState.defaultEncoding = encoding; return this; }; - Object.defineProperty(Writable.prototype, 'writableBuffer', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in @@ -339,15 +329,12 @@ Object.defineProperty(Writable.prototype, 'writableBuffer', { return this._writableState && this._writableState.getBuffer(); } }); - function decodeChunk(state, chunk, encoding) { if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { chunk = Buffer.from(chunk, encoding); } - return chunk; } - Object.defineProperty(Writable.prototype, 'writableHighWaterMark', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in @@ -356,27 +343,25 @@ Object.defineProperty(Writable.prototype, 'writableHighWaterMark', { get: function get() { return this._writableState.highWaterMark; } -}); // if we're already writing something, then just put this +}); + +// 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. - function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { if (!isBuf) { var newChunk = decodeChunk(state, chunk, encoding); - if (chunk !== newChunk) { isBuf = true; encoding = 'buffer'; chunk = newChunk; } } - var len = state.objectMode ? 1 : chunk.length; state.length += len; - var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false. - + var ret = state.length < state.highWaterMark; + // we must ensure that previous needDrain will not be reset to false. if (!ret) state.needDrain = true; - if (state.writing || state.corked) { var last = state.lastBufferedRequest; state.lastBufferedRequest = { @@ -386,21 +371,17 @@ function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { callback: cb, next: null }; - if (last) { last.next = state.lastBufferedRequest; } else { state.bufferedRequest = state.lastBufferedRequest; } - state.bufferedRequestCount += 1; } else { doWrite(stream, state, false, len, chunk, encoding, cb); } - return ret; } - function doWrite(stream, state, writev, len, chunk, encoding, cb) { state.writelen = len; state.writecb = cb; @@ -409,16 +390,14 @@ function doWrite(stream, state, writev, len, chunk, encoding, cb) { if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); state.sync = false; } - function onwriteError(stream, state, sync, er, cb) { --state.pendingcb; - if (sync) { // defer the callback if we are being called synchronously // to avoid piling up things on the stack - process.nextTick(cb, er); // this can emit finish, and it will always happen + process.nextTick(cb, er); + // this can emit finish, and it will always happen // after error - process.nextTick(finishMaybe, stream, state); stream._writableState.errorEmitted = true; errorOrDestroy(stream, er); @@ -427,20 +406,18 @@ function onwriteError(stream, state, sync, er, cb) { // it is async cb(er); stream._writableState.errorEmitted = true; - errorOrDestroy(stream, er); // this can emit finish, but finish must + errorOrDestroy(stream, er); + // this can emit finish, but finish must // always follow error - finishMaybe(stream, state); } } - function onwriteStateUpdate(state) { state.writing = false; state.writecb = null; state.length -= state.writelen; state.writelen = 0; } - function onwrite(stream, er) { var state = stream._writableState; var sync = state.sync; @@ -450,11 +427,9 @@ function onwrite(stream, er) { if (er) onwriteError(stream, state, sync, er, cb);else { // Check if we're actually ready to finish, but don't emit yet var finished = needFinish(state) || stream.destroyed; - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { clearBuffer(stream, state); } - if (sync) { process.nextTick(afterWrite, stream, state, finished, cb); } else { @@ -462,29 +437,27 @@ function onwrite(stream, er) { } } } - function afterWrite(stream, state, finished, cb) { if (!finished) onwriteDrain(stream, state); state.pendingcb--; cb(); finishMaybe(stream, state); -} // Must force callback to be called on nextTick, so that we don't +} + +// Must force callback to be called on nextTick, so that we don't // emit 'drain' before the write() consumer gets the 'false' return // value, and has a chance to attach a 'drain' listener. - - function onwriteDrain(stream, state) { if (state.length === 0 && state.needDrain) { state.needDrain = false; stream.emit('drain'); } -} // if there's something in the buffer waiting, then process it - +} +// if there's something in the buffer waiting, then process it function clearBuffer(stream, state) { state.bufferProcessing = true; var entry = state.bufferedRequest; - if (stream._writev && entry && entry.next) { // Fast case, write everything using _writev() var l = state.bufferedRequestCount; @@ -493,28 +466,25 @@ function clearBuffer(stream, state) { holder.entry = entry; var count = 0; var allBuffers = true; - while (entry) { buffer[count] = entry; if (!entry.isBuf) allBuffers = false; entry = entry.next; count += 1; } - buffer.allBuffers = allBuffers; - doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite + doWrite(stream, state, true, state.length, buffer, '', holder.finish); + // doWrite is almost always async, defer these to save a bit of time + // as the hot path ends with doWrite state.pendingcb++; state.lastBufferedRequest = null; - if (holder.next) { state.corkedRequestsFree = holder.next; holder.next = null; } else { state.corkedRequestsFree = new CorkedRequest(state); } - state.bufferedRequestCount = 0; } else { // Slow case, write chunks one-by-one @@ -525,32 +495,26 @@ function clearBuffer(stream, state) { var len = state.objectMode ? 1 : chunk.length; doWrite(stream, state, false, len, chunk, encoding, cb); entry = entry.next; - state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then + state.bufferedRequestCount--; + // if we didn't call the onwrite immediately, then // it means that we need to wait until it does. // also, that means that the chunk and cb are currently // being processed, so move the buffer counter past them. - if (state.writing) { break; } } - if (entry === null) state.lastBufferedRequest = null; } - state.bufferedRequest = entry; state.bufferProcessing = false; } - Writable.prototype._write = function (chunk, encoding, cb) { cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()')); }; - Writable.prototype._writev = null; - Writable.prototype.end = function (chunk, encoding, cb) { var state = this._writableState; - if (typeof chunk === 'function') { cb = chunk; chunk = null; @@ -559,19 +523,18 @@ Writable.prototype.end = function (chunk, encoding, cb) { cb = encoding; encoding = null; } + if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks - + // .end() fully uncorks if (state.corked) { state.corked = 1; this.uncork(); - } // ignore unnecessary end() calls. - + } + // ignore unnecessary end() calls. if (!state.ending) endWritable(this, state, cb); return this; }; - Object.defineProperty(Writable.prototype, 'writableLength', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in @@ -581,25 +544,20 @@ Object.defineProperty(Writable.prototype, 'writableLength', { return this._writableState.length; } }); - function needFinish(state) { return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; } - function callFinal(stream, state) { stream._final(function (err) { state.pendingcb--; - if (err) { errorOrDestroy(stream, err); } - state.prefinished = true; stream.emit('prefinish'); finishMaybe(stream, state); }); } - function prefinish(stream, state) { if (!state.prefinished && !state.finalCalled) { if (typeof stream._final === 'function' && !state.destroyed) { @@ -612,59 +570,47 @@ function prefinish(stream, state) { } } } - function finishMaybe(stream, state) { var need = needFinish(state); - if (need) { prefinish(stream, state); - if (state.pendingcb === 0) { state.finished = true; stream.emit('finish'); - if (state.autoDestroy) { // In case of duplex streams we need a way to detect // if the readable side is ready for autoDestroy as well var rState = stream._readableState; - if (!rState || rState.autoDestroy && rState.endEmitted) { stream.destroy(); } } } } - return need; } - function endWritable(stream, state, cb) { state.ending = true; finishMaybe(stream, state); - if (cb) { if (state.finished) process.nextTick(cb);else stream.once('finish', cb); } - state.ended = true; stream.writable = false; } - function onCorkedFinish(corkReq, state, err) { var entry = corkReq.entry; corkReq.entry = null; - while (entry) { var cb = entry.callback; state.pendingcb--; cb(err); entry = entry.next; - } // reuse the free corkReq. - + } + // reuse the free corkReq. state.corkedRequestsFree.next = corkReq; } - Object.defineProperty(Writable.prototype, 'destroyed', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in @@ -674,7 +620,6 @@ Object.defineProperty(Writable.prototype, 'destroyed', { if (this._writableState === undefined) { return false; } - return this._writableState.destroyed; }, set: function set(value) { @@ -682,16 +627,15 @@ Object.defineProperty(Writable.prototype, 'destroyed', { // has not been initialized yet if (!this._writableState) { return; - } // backward compatibility, the user is explicitly - // managing destroyed - + } + // backward compatibility, the user is explicitly + // managing destroyed this._writableState.destroyed = value; } }); Writable.prototype.destroy = destroyImpl.destroy; Writable.prototype._undestroy = destroyImpl.undestroy; - Writable.prototype._destroy = function (err, cb) { cb(err); }; \ No newline at end of file diff --git a/lib/internal/streams/async_iterator.js b/lib/internal/streams/async_iterator.js index 9fb615a2f3..742c5a4674 100644 --- a/lib/internal/streams/async_iterator.js +++ b/lib/internal/streams/async_iterator.js @@ -1,11 +1,10 @@ 'use strict'; var _Object$setPrototypeO; - -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } var finished = require('./end-of-stream'); - var kLastResolve = Symbol('lastResolve'); var kLastReject = Symbol('lastReject'); var kError = Symbol('error'); @@ -13,22 +12,19 @@ var kEnded = Symbol('ended'); var kLastPromise = Symbol('lastPromise'); var kHandlePromise = Symbol('handlePromise'); var kStream = Symbol('stream'); - function createIterResult(value, done) { return { value: value, done: done }; } - function readAndResolve(iter) { var resolve = iter[kLastResolve]; - if (resolve !== null) { - var data = iter[kStream].read(); // we defer if data is null + var data = iter[kStream].read(); + // we defer if data is null // we can be expecting either 'end' or // 'error' - if (data !== null) { iter[kLastPromise] = null; iter[kLastResolve] = null; @@ -37,13 +33,11 @@ function readAndResolve(iter) { } } } - function onReadable(iter) { // we wait for the next tick, because it might // emit an error with process.nextTick process.nextTick(readAndResolve, iter); } - function wrapForNext(lastPromise, iter) { return function (resolve, reject) { lastPromise.then(function () { @@ -51,33 +45,26 @@ function wrapForNext(lastPromise, iter) { resolve(createIterResult(undefined, true)); return; } - iter[kHandlePromise](resolve, reject); }, reject); }; } - var AsyncIteratorPrototype = Object.getPrototypeOf(function () {}); var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = { get stream() { return this[kStream]; }, - next: function next() { var _this = this; - // if we have detected an error in the meanwhile // reject straight away var error = this[kError]; - if (error !== null) { return Promise.reject(error); } - if (this[kEnded]) { return Promise.resolve(createIterResult(undefined, true)); } - if (this[kStream].destroyed) { // We need to defer via nextTick because if .destroy(err) is // called, the error will be emitted via nextTick, and @@ -92,29 +79,25 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro } }); }); - } // if we have multiple next() calls + } + + // if we have multiple next() calls // we will wait for the previous Promise to finish // this logic is optimized to support for await loops, // where next() is only called once at a time - - var lastPromise = this[kLastPromise]; var promise; - if (lastPromise) { promise = new Promise(wrapForNext(lastPromise, this)); } else { // fast path needed to support multiple this.push() // without triggering the next() queue var data = this[kStream].read(); - if (data !== null) { return Promise.resolve(createIterResult(data, false)); } - promise = new Promise(this[kHandlePromise]); } - this[kLastPromise] = promise; return promise; } @@ -122,7 +105,6 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro return this; }), _defineProperty(_Object$setPrototypeO, "return", function _return() { var _this2 = this; - // destroy(err, cb) is a private API // we can guarantee we have that here, because we control the // Readable class this is attached to @@ -132,15 +114,12 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro reject(err); return; } - resolve(createIterResult(undefined, true)); }); }); }), _Object$setPrototypeO), AsyncIteratorPrototype); - var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) { var _Object$create; - var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, { value: stream, writable: true @@ -159,7 +138,6 @@ var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterat }), _defineProperty(_Object$create, kHandlePromise, { value: function value(resolve, reject) { var data = iterator[kStream].read(); - if (data) { iterator[kLastPromise] = null; iterator[kLastResolve] = null; @@ -175,33 +153,28 @@ var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterat iterator[kLastPromise] = null; finished(stream, function (err) { if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') { - var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise + var reject = iterator[kLastReject]; + // reject if we are waiting for data in the Promise // returned by next() and store the error - if (reject !== null) { iterator[kLastPromise] = null; iterator[kLastResolve] = null; iterator[kLastReject] = null; reject(err); } - iterator[kError] = err; return; } - var resolve = iterator[kLastResolve]; - if (resolve !== null) { iterator[kLastPromise] = null; iterator[kLastResolve] = null; iterator[kLastReject] = null; resolve(createIterResult(undefined, true)); } - iterator[kEnded] = true; }); stream.on('readable', onReadable.bind(null, iterator)); return iterator; }; - module.exports = createReadableStreamAsyncIterator; \ No newline at end of file diff --git a/lib/internal/streams/buffer_list.js b/lib/internal/streams/buffer_list.js index cdea425f19..69bda497d3 100644 --- a/lib/internal/streams/buffer_list.js +++ b/lib/internal/streams/buffer_list.js @@ -1,40 +1,28 @@ 'use strict'; -function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } - -function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } - -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } var _require = require('buffer'), - Buffer = _require.Buffer; - + Buffer = _require.Buffer; var _require2 = require('util'), - inspect = _require2.inspect; - + inspect = _require2.inspect; var custom = inspect && inspect.custom || 'inspect'; - function copyBuffer(src, target, offset) { Buffer.prototype.copy.call(src, target, offset); } - -module.exports = -/*#__PURE__*/ -function () { +module.exports = /*#__PURE__*/function () { function BufferList() { _classCallCheck(this, BufferList); - this.head = null; this.tail = null; this.length = 0; } - _createClass(BufferList, [{ key: "push", value: function push(v) { @@ -78,11 +66,7 @@ function () { if (this.length === 0) return ''; var p = this.head; var ret = '' + p.data; - - while (p = p.next) { - ret += s + p.data; - } - + while (p = p.next) ret += s + p.data; return ret; } }, { @@ -92,21 +76,19 @@ function () { var ret = Buffer.allocUnsafe(n >>> 0); var p = this.head; var i = 0; - while (p) { copyBuffer(p.data, ret, i); i += p.data.length; p = p.next; } - return ret; - } // Consumes a specified amount of bytes or characters from the buffered data. + } + // Consumes a specified amount of bytes or characters from the buffered data. }, { key: "consume", value: function consume(n, hasStrings) { var ret; - if (n < this.head.data.length) { // `slice` is the same for buffers and strings. ret = this.head.data.slice(0, n); @@ -118,15 +100,15 @@ function () { // Result spans more than one buffer. ret = hasStrings ? this._getString(n) : this._getBuffer(n); } - return ret; } }, { key: "first", value: function first() { return this.head.data; - } // Consumes a specified amount of characters from the buffered data. + } + // Consumes a specified amount of characters from the buffered data. }, { key: "_getString", value: function _getString(n) { @@ -134,13 +116,11 @@ function () { var c = 1; var ret = p.data; n -= ret.length; - while (p = p.next) { var str = p.data; var nb = n > str.length ? str.length : n; if (nb === str.length) ret += str;else ret += str.slice(0, n); n -= nb; - if (n === 0) { if (nb === str.length) { ++c; @@ -149,17 +129,15 @@ function () { this.head = p; p.data = str.slice(nb); } - break; } - ++c; } - this.length -= c; return ret; - } // Consumes a specified amount of bytes from the buffered data. + } + // Consumes a specified amount of bytes from the buffered data. }, { key: "_getBuffer", value: function _getBuffer(n) { @@ -168,13 +146,11 @@ function () { var c = 1; p.data.copy(ret); n -= p.data.length; - while (p = p.next) { var buf = p.data; var nb = n > buf.length ? buf.length : n; buf.copy(ret, ret.length - n, 0, nb); n -= nb; - if (n === 0) { if (nb === buf.length) { ++c; @@ -183,21 +159,19 @@ function () { this.head = p; p.data = buf.slice(nb); } - break; } - ++c; } - this.length -= c; return ret; - } // Make sure the linked list only shows the minimal necessary information. + } + // Make sure the linked list only shows the minimal necessary information. }, { key: custom, value: function value(_, options) { - return inspect(this, _objectSpread({}, options, { + return inspect(this, _objectSpread(_objectSpread({}, options), {}, { // Only inspect one level. depth: 0, // It should not recurse. @@ -205,6 +179,5 @@ function () { })); } }]); - return BufferList; }(); \ No newline at end of file diff --git a/lib/internal/streams/destroy.js b/lib/internal/streams/destroy.js index 3268a16f3b..31a17c4dc4 100644 --- a/lib/internal/streams/destroy.js +++ b/lib/internal/streams/destroy.js @@ -1,11 +1,10 @@ -'use strict'; // undocumented cb() API, needed for core, not for public API +'use strict'; +// undocumented cb() API, needed for core, not for public API function destroy(err, cb) { var _this = this; - var readableDestroyed = this._readableState && this._readableState.destroyed; var writableDestroyed = this._writableState && this._writableState.destroyed; - if (readableDestroyed || writableDestroyed) { if (cb) { cb(err); @@ -17,21 +16,20 @@ function destroy(err, cb) { process.nextTick(emitErrorNT, this, err); } } - return this; - } // we set destroyed to true before firing error callbacks in order - // to make it re-entrance safe in case destroy() is called within callbacks + } + // we set destroyed to true before firing error callbacks in order + // to make it re-entrance safe in case destroy() is called within callbacks if (this._readableState) { this._readableState.destroyed = true; - } // if this is a duplex stream mark the writable part as destroyed as well - + } + // if this is a duplex stream mark the writable part as destroyed as well if (this._writableState) { this._writableState.destroyed = true; } - this._destroy(err || null, function (err) { if (!cb && err) { if (!_this._writableState) { @@ -49,21 +47,17 @@ function destroy(err, cb) { process.nextTick(emitCloseNT, _this); } }); - return this; } - function emitErrorAndCloseNT(self, err) { emitErrorNT(self, err); emitCloseNT(self); } - function emitCloseNT(self) { if (self._writableState && !self._writableState.emitClose) return; if (self._readableState && !self._readableState.emitClose) return; self.emit('close'); } - function undestroy() { if (this._readableState) { this._readableState.destroyed = false; @@ -71,7 +65,6 @@ function undestroy() { this._readableState.ended = false; this._readableState.endEmitted = false; } - if (this._writableState) { this._writableState.destroyed = false; this._writableState.ended = false; @@ -82,22 +75,20 @@ function undestroy() { this._writableState.errorEmitted = false; } } - function emitErrorNT(self, err) { self.emit('error', err); } - function errorOrDestroy(stream, err) { // We have tests that rely on errors being emitted // in the same tick, so changing this is semver major. // For now when you opt-in to autoDestroy we allow // the error to be emitted nextTick. In a future // semver major update we should change the default to this. + var rState = stream._readableState; var wState = stream._writableState; if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err); } - module.exports = { destroy: destroy, undestroy: undestroy, diff --git a/lib/internal/streams/end-of-stream.js b/lib/internal/streams/end-of-stream.js index 831f286d98..59c671b5af 100644 --- a/lib/internal/streams/end-of-stream.js +++ b/lib/internal/streams/end-of-stream.js @@ -1,78 +1,62 @@ // Ported from https://github.com/mafintosh/end-of-stream with // permission from the author, Mathias Buus (@mafintosh). + 'use strict'; var ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE; - function once(callback) { var called = false; return function () { if (called) return; called = true; - for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { args[_key] = arguments[_key]; } - callback.apply(this, args); }; } - function noop() {} - function isRequest(stream) { return stream.setHeader && typeof stream.abort === 'function'; } - function eos(stream, opts, callback) { if (typeof opts === 'function') return eos(stream, null, opts); if (!opts) opts = {}; callback = once(callback || noop); var readable = opts.readable || opts.readable !== false && stream.readable; var writable = opts.writable || opts.writable !== false && stream.writable; - var onlegacyfinish = function onlegacyfinish() { if (!stream.writable) onfinish(); }; - var writableEnded = stream._writableState && stream._writableState.finished; - var onfinish = function onfinish() { writable = false; writableEnded = true; if (!readable) callback.call(stream); }; - var readableEnded = stream._readableState && stream._readableState.endEmitted; - var onend = function onend() { readable = false; readableEnded = true; if (!writable) callback.call(stream); }; - var onerror = function onerror(err) { callback.call(stream, err); }; - var onclose = function onclose() { var err; - if (readable && !readableEnded) { if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE(); return callback.call(stream, err); } - if (writable && !writableEnded) { if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE(); return callback.call(stream, err); } }; - var onrequest = function onrequest() { stream.req.on('finish', onfinish); }; - if (isRequest(stream)) { stream.on('complete', onfinish); stream.on('abort', onclose); @@ -82,7 +66,6 @@ function eos(stream, opts, callback) { stream.on('end', onlegacyfinish); stream.on('close', onlegacyfinish); } - stream.on('end', onend); stream.on('finish', onfinish); if (opts.error !== false) stream.on('error', onerror); @@ -100,5 +83,4 @@ function eos(stream, opts, callback) { stream.removeListener('close', onclose); }; } - module.exports = eos; \ No newline at end of file diff --git a/lib/internal/streams/from.js b/lib/internal/streams/from.js index 6c41284416..0a34ee92e3 100644 --- a/lib/internal/streams/from.js +++ b/lib/internal/streams/from.js @@ -1,52 +1,42 @@ 'use strict'; function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } - function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } - -function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } - -function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } - -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } var ERR_INVALID_ARG_TYPE = require('../../../errors').codes.ERR_INVALID_ARG_TYPE; - function from(Readable, iterable, opts) { var iterator; - if (iterable && typeof iterable.next === 'function') { iterator = iterable; } else if (iterable && iterable[Symbol.asyncIterator]) iterator = iterable[Symbol.asyncIterator]();else if (iterable && iterable[Symbol.iterator]) iterator = iterable[Symbol.iterator]();else throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable); - var readable = new Readable(_objectSpread({ objectMode: true - }, opts)); // Reading boolean to protect against _read + }, opts)); + // Reading boolean to protect against _read // being called before last iteration completion. - var reading = false; - readable._read = function () { if (!reading) { reading = true; next(); } }; - function next() { return _next2.apply(this, arguments); } - function _next2() { _next2 = _asyncToGenerator(function* () { try { - var _ref = yield iterator.next(), - value = _ref.value, - done = _ref.done; - + var _yield$iterator$next = yield iterator.next(), + value = _yield$iterator$next.value, + done = _yield$iterator$next.done; if (done) { readable.push(null); - } else if (readable.push((yield value))) { + } else if (readable.push(yield value)) { next(); } else { reading = false; @@ -57,8 +47,6 @@ function from(Readable, iterable, opts) { }); return _next2.apply(this, arguments); } - return readable; } - -module.exports = from; \ No newline at end of file +module.exports = from; diff --git a/lib/internal/streams/pipeline.js b/lib/internal/streams/pipeline.js index 6589909889..e6f39241f9 100644 --- a/lib/internal/streams/pipeline.js +++ b/lib/internal/streams/pipeline.js @@ -1,9 +1,9 @@ // Ported from https://github.com/mafintosh/pump with // permission from the author, Mathias Buus (@mafintosh). + 'use strict'; var eos; - function once(callback) { var called = false; return function () { @@ -12,20 +12,16 @@ function once(callback) { callback.apply(void 0, arguments); }; } - var _require$codes = require('../../../errors').codes, - ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, - ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED; - + ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, + ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED; function noop(err) { // Rethrow the error if it exists to avoid swallowing it if (err) throw err; } - function isRequest(stream) { return stream.setHeader && typeof stream.abort === 'function'; } - function destroyer(stream, reading, writing, callback) { callback = once(callback); var closed = false; @@ -45,40 +41,34 @@ function destroyer(stream, reading, writing, callback) { return function (err) { if (closed) return; if (destroyed) return; - destroyed = true; // request.destroy just do .end - .abort is what we want + destroyed = true; + // request.destroy just do .end - .abort is what we want if (isRequest(stream)) return stream.abort(); if (typeof stream.destroy === 'function') return stream.destroy(); callback(err || new ERR_STREAM_DESTROYED('pipe')); }; } - function call(fn) { fn(); } - function pipe(from, to) { return from.pipe(to); } - function popCallback(streams) { if (!streams.length) return noop; if (typeof streams[streams.length - 1] !== 'function') return noop; return streams.pop(); } - function pipeline() { for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) { streams[_key] = arguments[_key]; } - var callback = popCallback(streams); if (Array.isArray(streams[0])) streams = streams[0]; - if (streams.length < 2) { throw new ERR_MISSING_ARGS('streams'); } - var error; var destroys = streams.map(function (stream, i) { var reading = i < streams.length - 1; @@ -93,5 +83,4 @@ function pipeline() { }); return streams.reduce(pipe); } - module.exports = pipeline; \ No newline at end of file diff --git a/lib/internal/streams/state.js b/lib/internal/streams/state.js index 19887eb8a9..3fbf8927e0 100644 --- a/lib/internal/streams/state.js +++ b/lib/internal/streams/state.js @@ -1,27 +1,22 @@ 'use strict'; var ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE; - function highWaterMarkFrom(options, isDuplex, duplexKey) { return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null; } - function getHighWaterMark(state, options, duplexKey, isDuplex) { var hwm = highWaterMarkFrom(options, isDuplex, duplexKey); - if (hwm != null) { if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) { var name = isDuplex ? duplexKey : 'highWaterMark'; throw new ERR_INVALID_OPT_VALUE(name, hwm); } - return Math.floor(hwm); - } // Default value - + } + // Default value return state.objectMode ? 16 : 16 * 1024; } - module.exports = { getHighWaterMark: getHighWaterMark }; \ No newline at end of file diff --git a/package.json b/package.json index 0b0c4bd207..ade59e71aa 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "readable-stream", - "version": "3.6.0", + "version": "3.6.2", "description": "Streams3, a user-land copy of the stream library from Node.js", "main": "readable.js", "engines": { diff --git a/test/common/arraystream.js b/test/common/arraystream.js index 167f927dff..3734c17203 100644 --- a/test/common/arraystream.js +++ b/test/common/arraystream.js @@ -2,49 +2,32 @@ /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var _require = require('../../'), - Stream = _require.Stream; - -function noop() {} // A stream to push an array into a REPL - + Stream = _require.Stream; +function noop() {} +// A stream to push an array into a REPL function ArrayStream() { this.run = function (data) { var _this = this; - forEach(data, function (line) { _this.emit('data', "".concat(line, "\n")); }); }; } - Object.setPrototypeOf(ArrayStream.prototype, Stream.prototype); Object.setPrototypeOf(ArrayStream, Stream); ArrayStream.prototype.readable = true; @@ -53,7 +36,6 @@ ArrayStream.prototype.pause = noop; ArrayStream.prototype.resume = noop; ArrayStream.prototype.write = noop; module.exports = ArrayStream; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/benchmark.js b/test/common/benchmark.js index 1b368bac58..2ab30d9527 100644 --- a/test/common/benchmark.js +++ b/test/common/benchmark.js @@ -2,49 +2,30 @@ /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var assert = require('assert'); - var fork = require('child_process').fork; - var path = require('path'); - var runjs = path.join(__dirname, '..', '..', 'benchmark', 'run.js'); - function runBenchmark(name, args, env) { var argv = []; - for (var _i = 0; _i < args.length; _i++) { argv.push('--set'); argv.push(args[_i]); } - argv.push(name); var mergedEnv = Object.assign({}, process.env, env); var child = fork(runjs, argv, { @@ -58,19 +39,17 @@ function runBenchmark(name, args, env) { }); child.on('exit', function (code, signal) { assert.strictEqual(code, 0); - assert.strictEqual(signal, null); // This bit makes sure that each benchmark file is being sent settings such + assert.strictEqual(signal, null); + // This bit makes sure that each benchmark file is being sent settings such // that the benchmark file runs just one set of options. This helps keep the // benchmark tests from taking a long time to run. Therefore, each benchmark // file should result in three lines of output: a blank line, a line with // the name of the benchmark file, and a line with the only results that we // get from testing the benchmark file. - assert.ok(/^(?:\n.+?\n.+?\n)+$/.test(stdout), "benchmark file not running exactly one configuration in test: ".concat(stdout)); }); } - module.exports = runBenchmark; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/countdown.js b/test/common/countdown.js index 39193672b5..dd1d92fb9c 100644 --- a/test/common/countdown.js +++ b/test/common/countdown.js @@ -1,59 +1,38 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var assert = require('assert'); - var kLimit = Symbol('limit'); var kCallback = Symbol('callback'); - var common = require('./'); - -var Countdown = -/*#__PURE__*/ -function () { +var Countdown = /*#__PURE__*/function () { function Countdown(limit, cb) { _classCallCheck(this, Countdown); - assert.strictEqual(typeof limit, 'number'); assert.strictEqual(typeof cb, 'function'); this[kLimit] = limit; this[kCallback] = common.mustCall(cb); } - _createClass(Countdown, [{ key: "dec", value: function dec() { @@ -67,12 +46,9 @@ function () { return this[kLimit]; } }]); - return Countdown; }(); - module.exports = Countdown; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/dns.js b/test/common/dns.js index f63b686fd2..581b7a1bb0 100644 --- a/test/common/dns.js +++ b/test/common/dns.js @@ -1,46 +1,29 @@ "use strict"; -function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); } - -function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } - -function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } - +function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; } +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } +function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } } function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } - /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var assert = require('assert'); - var os = require('os'); - var types = { A: 1, AAAA: 28, @@ -54,12 +37,13 @@ var types = { }; var classes = { IN: 1 -}; // Naïve DNS parser/serializer. +}; + +// Naïve DNS parser/serializer. function readDomainFromPacket(buffer, offset) { assert.ok(offset < buffer.length); var length = buffer[offset]; - if (length === 0) { return { nread: 1, @@ -67,20 +51,19 @@ function readDomainFromPacket(buffer, offset) { }; } else if ((length & 0xC0) === 0) { offset += 1; - var chunk = buffer.toString('ascii', offset, offset + length); // Read the rest of the domain. - + var chunk = buffer.toString('ascii', offset, offset + length); + // Read the rest of the domain. var _readDomainFromPacket = readDomainFromPacket(buffer, offset + length), - nread = _readDomainFromPacket.nread, - domain = _readDomainFromPacket.domain; - + nread = _readDomainFromPacket.nread, + domain = _readDomainFromPacket.domain; return { nread: 1 + length + nread, domain: domain ? "".concat(chunk, ".").concat(domain) : chunk }; } else { // Pointer to another part of the packet. - assert.strictEqual(length & 0xC0, 0xC0); // eslint-disable-next-line space-infix-ops, space-unary-ops - + assert.strictEqual(length & 0xC0, 0xC0); + // eslint-disable-next-line space-infix-ops, space-unary-ops var pointeeOffset = buffer.readUInt16BE(offset) & ~0xC000; return { nread: 2, @@ -88,7 +71,6 @@ function readDomainFromPacket(buffer, offset) { }; } } - function parseDNSPacket(buffer) { assert.ok(buffer.length > 12); var parsed = { @@ -97,19 +79,15 @@ function parseDNSPacket(buffer) { }; var counts = [['questions', buffer.readUInt16BE(4)], ['answers', buffer.readUInt16BE(6)], ['authorityAnswers', buffer.readUInt16BE(8)], ['additionalRecords', buffer.readUInt16BE(10)]]; var offset = 12; - for (var _i = 0, _counts = counts; _i < _counts.length; _i++) { var _counts$_i = _slicedToArray(_counts[_i], 2), - sectionName = _counts$_i[0], - count = _counts$_i[1]; - + sectionName = _counts$_i[0], + count = _counts$_i[1]; parsed[sectionName] = []; - for (var _i2 = 0; _i2 < count; ++_i2) { var _readDomainFromPacket2 = readDomainFromPacket(buffer, offset), - nread = _readDomainFromPacket2.nread, - domain = _readDomainFromPacket2.domain; - + nread = _readDomainFromPacket2.nread, + domain = _readDomainFromPacket2.domain; offset += nread; var type = buffer.readUInt16BE(offset); var rr = { @@ -117,69 +95,56 @@ function parseDNSPacket(buffer) { cls: buffer.readUInt16BE(offset + 2) }; offset += 4; - for (var name in types) { if (types[name] === type) rr.type = name; } - if (sectionName !== 'questions') { rr.ttl = buffer.readInt32BE(offset); var dataLength = buffer.readUInt16BE(offset); offset += 6; - switch (type) { case types.A: assert.strictEqual(dataLength, 4); rr.address = "".concat(buffer[offset + 0], ".").concat(buffer[offset + 1], ".") + "".concat(buffer[offset + 2], ".").concat(buffer[offset + 3]); break; - case types.AAAA: assert.strictEqual(dataLength, 16); rr.address = buffer.toString('hex', offset, offset + 16).replace(/(.{4}(?!$))/g, '$1:'); break; - case types.TXT: { var position = offset; rr.entries = []; - while (position < offset + dataLength) { var txtLength = buffer[offset]; rr.entries.push(buffer.toString('utf8', position + 1, position + 1 + txtLength)); position += 1 + txtLength; } - assert.strictEqual(position, offset + dataLength); break; } - case types.MX: { rr.priority = buffer.readInt16BE(buffer, offset); offset += 2; - var _readDomainFromPacket3 = readDomainFromPacket(buffer, offset), - _nread = _readDomainFromPacket3.nread, - _domain = _readDomainFromPacket3.domain; - + _nread = _readDomainFromPacket3.nread, + _domain = _readDomainFromPacket3.domain; rr.exchange = _domain; assert.strictEqual(_nread, dataLength); break; } - case types.NS: case types.CNAME: case types.PTR: { var _readDomainFromPacket4 = readDomainFromPacket(buffer, offset), - _nread2 = _readDomainFromPacket4.nread, - _domain2 = _readDomainFromPacket4.domain; - + _nread2 = _readDomainFromPacket4.nread, + _domain2 = _readDomainFromPacket4.domain; rr.value = _domain2; assert.strictEqual(_nread2, dataLength); break; } - case types.SOA: { var mname = readDomainFromPacket(buffer, offset); @@ -195,35 +160,27 @@ function parseDNSPacket(buffer) { assert.strictEqual(trailerOffset + 20, dataLength); break; } - default: throw new Error("Unknown RR type ".concat(rr.type)); } - offset += dataLength; } - parsed[sectionName].push(rr); assert.ok(offset <= buffer.length); } } - assert.strictEqual(offset, buffer.length); return parsed; } - function writeIPv6(ip) { var parts = ip.replace(/^:|:$/g, '').split(':'); var buf = Buffer.alloc(16); var offset = 0; - var _iteratorNormalCompletion = true; - var _didIteratorError = false; - var _iteratorError = undefined; - + var _iterator = _createForOfIteratorHelper(parts), + _step; try { - for (var _iterator = parts[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + for (_iterator.s(); !(_step = _iterator.n()).done;) { var part = _step.value; - if (part === '') { offset += 16 - 2 * (parts.length - 1); } else { @@ -232,66 +189,40 @@ function writeIPv6(ip) { } } } catch (err) { - _didIteratorError = true; - _iteratorError = err; + _iterator.e(err); } finally { - try { - if (!_iteratorNormalCompletion && _iterator.return != null) { - _iterator.return(); - } - } finally { - if (_didIteratorError) { - throw _iteratorError; - } - } + _iterator.f(); } - return buf; } - function writeDomainName(domain) { return Buffer.concat(domain.split('.').map(function (label) { assert(label.length < 64); return Buffer.concat([Buffer.from([label.length]), Buffer.from(label, 'ascii')]); }).concat([Buffer.alloc(1)])); } - function writeDNSPacket(parsed) { var buffers = []; var kStandardResponseFlags = 0x8180; buffers.push(new Uint16Array([parsed.id, parsed.flags === undefined ? kStandardResponseFlags : parsed.flags, parsed.questions && parsed.questions.length, parsed.answers && parsed.answers.length, parsed.authorityAnswers && parsed.authorityAnswers.length, parsed.additionalRecords && parsed.additionalRecords.length])); - var _iteratorNormalCompletion2 = true; - var _didIteratorError2 = false; - var _iteratorError2 = undefined; - + var _iterator2 = _createForOfIteratorHelper(parsed.questions), + _step2; try { - for (var _iterator2 = parsed.questions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { var q = _step2.value; assert(types[q.type]); buffers.push(writeDomainName(q.domain)); buffers.push(new Uint16Array([types[q.type], q.cls === undefined ? classes.IN : q.cls])); } } catch (err) { - _didIteratorError2 = true; - _iteratorError2 = err; + _iterator2.e(err); } finally { - try { - if (!_iteratorNormalCompletion2 && _iterator2.return != null) { - _iterator2.return(); - } - } finally { - if (_didIteratorError2) { - throw _iteratorError2; - } - } + _iterator2.f(); } - - var _iteratorNormalCompletion3 = true; - var _didIteratorError3 = false; - var _iteratorError3 = undefined; - + var _iterator3 = _createForOfIteratorHelper([].concat(parsed.answers, parsed.authorityAnswers, parsed.additionalRecords)), + _step3; try { - for (var _iterator3 = [].concat(parsed.answers, parsed.authorityAnswers, parsed.additionalRecords)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { var rr = _step3.value; if (!rr) continue; assert(types[rr.type]); @@ -300,58 +231,41 @@ function writeDNSPacket(parsed) { buffers.push(new Int32Array([rr.ttl])); var rdLengthBuf = new Uint16Array(1); buffers.push(rdLengthBuf); - switch (rr.type) { case 'A': rdLengthBuf[0] = 4; buffers.push(new Uint8Array(rr.address.split('.'))); break; - case 'AAAA': rdLengthBuf[0] = 16; buffers.push(writeIPv6(rr.address)); break; - case 'TXT': var total = rr.entries.map(function (s) { return s.length; }).reduce(function (a, b) { return a + b; - }); // Total length of all strings + 1 byte each for their lengths. - + }); + // Total length of all strings + 1 byte each for their lengths. rdLengthBuf[0] = rr.entries.length + total; - var _iteratorNormalCompletion4 = true; - var _didIteratorError4 = false; - var _iteratorError4 = undefined; - + var _iterator4 = _createForOfIteratorHelper(rr.entries), + _step4; try { - for (var _iterator4 = rr.entries[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) { + for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) { var txt = _step4.value; buffers.push(new Uint8Array([Buffer.byteLength(txt)])); buffers.push(Buffer.from(txt)); } } catch (err) { - _didIteratorError4 = true; - _iteratorError4 = err; + _iterator4.e(err); } finally { - try { - if (!_iteratorNormalCompletion4 && _iterator4.return != null) { - _iterator4.return(); - } - } finally { - if (_didIteratorError4) { - throw _iteratorError4; - } - } + _iterator4.f(); } - break; - case 'MX': rdLengthBuf[0] = 2; buffers.push(new Uint16Array([rr.priority])); // fall through - case 'NS': case 'CNAME': case 'PTR': @@ -361,7 +275,6 @@ function writeDNSPacket(parsed) { buffers.push(domain); break; } - case 'SOA': { var mname = writeDomainName(rr.nsname); @@ -371,41 +284,26 @@ function writeDNSPacket(parsed) { buffers.push(new Uint32Array([rr.serial, rr.refresh, rr.retry, rr.expire, rr.minttl])); break; } - default: throw new Error("Unknown RR type ".concat(rr.type)); } } } catch (err) { - _didIteratorError3 = true; - _iteratorError3 = err; + _iterator3.e(err); } finally { - try { - if (!_iteratorNormalCompletion3 && _iterator3.return != null) { - _iterator3.return(); - } - } finally { - if (_didIteratorError3) { - throw _iteratorError3; - } - } + _iterator3.f(); } - return Buffer.concat(buffers.map(function (typedArray) { var buf = Buffer.from(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength); - if (os.endianness() === 'LE') { if (typedArray.BYTES_PER_ELEMENT === 2) buf.swap16(); if (typedArray.BYTES_PER_ELEMENT === 4) buf.swap32(); } - return buf; })); } - var mockedErrorCode = 'ENOTFOUND'; var mockedSysCall = 'getaddrinfo'; - function errorLookupMock() { var code = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : mockedErrorCode; var syscall = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : mockedSysCall; @@ -418,7 +316,6 @@ function errorLookupMock() { cb(err); }; } - module.exports = { types: types, classes: classes, @@ -428,7 +325,6 @@ module.exports = { mockedErrorCode: mockedErrorCode, mockedSysCall: mockedSysCall }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/duplexpair.js b/test/common/duplexpair.js index d4277740aa..0fe421c588 100644 --- a/test/common/duplexpair.js +++ b/test/common/duplexpair.js @@ -1,79 +1,52 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var _require = require('../../'), - Duplex = _require.Duplex; - + Duplex = _require.Duplex; var assert = require('assert'); - var kCallback = Symbol('Callback'); var kOtherSide = Symbol('Other'); - -var DuplexSocket = -/*#__PURE__*/ -function (_Duplex) { +var DuplexSocket = /*#__PURE__*/function (_Duplex) { _inherits(DuplexSocket, _Duplex); - + var _super = _createSuper(DuplexSocket); function DuplexSocket() { var _this; - _classCallCheck(this, DuplexSocket); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(DuplexSocket).call(this)); + _this = _super.call(this); _this[kCallback] = null; _this[kOtherSide] = null; return _this; } - _createClass(DuplexSocket, [{ key: "_read", value: function _read() { var callback = this[kCallback]; - if (callback) { this[kCallback] = null; callback(); @@ -94,10 +67,8 @@ function (_Duplex) { this[kOtherSide].push(null); } }]); - return DuplexSocket; }(Duplex); - function makeDuplexPair() { var clientSide = new DuplexSocket(); var serverSide = new DuplexSocket(); @@ -108,9 +79,7 @@ function makeDuplexPair() { serverSide: serverSide }; } - module.exports = makeDuplexPair; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/fixtures.js b/test/common/fixtures.js index 1ddc225e71..57cd3075d0 100644 --- a/test/common/fixtures.js +++ b/test/common/fixtures.js @@ -1,72 +1,48 @@ "use strict"; -function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); } - -function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); } - -function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); } - -function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } } - +function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } +function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } +function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } +function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var path = require('path'); - var fs = require('fs'); - var fixturesDir = path.join(__dirname, '..', 'fixtures'); - function fixturesPath() { for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { args[_key] = arguments[_key]; } - return path.join.apply(path, [fixturesDir].concat(args)); } - function readFixtureSync(args, enc) { if (Array.isArray(args)) return fs.readFileSync(fixturesPath.apply(void 0, _toConsumableArray(args)), enc); return fs.readFileSync(fixturesPath(args), enc); } - function readFixtureKey(name, enc) { return fs.readFileSync(fixturesPath('keys', name), enc); } - module.exports = { fixturesDir: fixturesDir, path: fixturesPath, readSync: readFixtureSync, readKey: readFixtureKey }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/heap.js b/test/common/heap.js index 0675fdf453..8d1c2dfb16 100644 --- a/test/common/heap.js +++ b/test/common/heap.js @@ -1,72 +1,53 @@ "use strict"; +function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; } +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var assert = require('assert'); -/**/ - +/**/ var util = require('core-util-is'); - util.inherits = require('inherits'); /**/ var internalTestHeap; - try { internalTestHeap = require('internal/test/heap'); } catch (e) { console.log('using `test/common/heap.js` requires `--expose-internals`'); throw e; } - var _internalTestHeap = internalTestHeap, - createJSHeapDump = _internalTestHeap.createJSHeapDump, - buildEmbedderGraph = _internalTestHeap.buildEmbedderGraph; - + createJSHeapDump = _internalTestHeap.createJSHeapDump, + buildEmbedderGraph = _internalTestHeap.buildEmbedderGraph; function inspectNode(snapshot) { return util.inspect(snapshot, { depth: 4 }); } - function isEdge(edge, _ref) { var node_name = _ref.node_name, - edge_name = _ref.edge_name; - + edge_name = _ref.edge_name; // For ABI compatibility, we did not backport the virtual function // AddEdge() with a name as last argument back to v10.x, so edge_name. // is ignored. @@ -81,51 +62,38 @@ function isEdge(edge, _ref) { } else if (edge.to.name !== node_name) { return false; } - return true; } - -var State = -/*#__PURE__*/ -function () { +var State = /*#__PURE__*/function () { function State() { _classCallCheck(this, State); - this.snapshot = createJSHeapDump(); this.embedderGraph = buildEmbedderGraph(); - } // Validate the v8 heap snapshot - + } + // Validate the v8 heap snapshot _createClass(State, [{ key: "validateSnapshot", value: function validateSnapshot(rootName, expected) { var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}, - _ref2$loose = _ref2.loose, - loose = _ref2$loose === void 0 ? false : _ref2$loose; - + _ref2$loose = _ref2.loose, + loose = _ref2$loose === void 0 ? false : _ref2$loose; var rootNodes = this.snapshot.filter(function (node) { return node.name === rootName && node.type !== 'string'; }); - if (loose) { assert(rootNodes.length >= expected.length, "Expect to find at least ".concat(expected.length, " '").concat(rootName, "', ") + "found ".concat(rootNodes.length)); } else { assert.strictEqual(rootNodes.length, expected.length, "Expect to find ".concat(expected.length, " '").concat(rootName, "', ") + "found ".concat(rootNodes.length)); } - - var _iteratorNormalCompletion = true; - var _didIteratorError = false; - var _iteratorError = undefined; - + var _iterator = _createForOfIteratorHelper(expected), + _step; try { - for (var _iterator = expected[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + for (_iterator.s(); !(_step = _iterator.n()).done;) { var expectation = _step.value; - if (expectation.children) { - var _iteratorNormalCompletion2 = true; - var _didIteratorError2 = false; - var _iteratorError2 = undefined; - + var _iterator2 = _createForOfIteratorHelper(expectation.children), + _step2; try { var _loop = function _loop() { var expectedEdge = _step2.value; @@ -134,139 +102,92 @@ function () { }; var hasChild = rootNodes.some(function (node) { return node.outgoingEdges.some(check); - }); // Don't use assert with a custom message here. Otherwise the + }); + // Don't use assert with a custom message here. Otherwise the // inspection in the message is done eagerly and wastes a lot of CPU // time. - if (!hasChild) { throw new Error('expected to find child ' + "".concat(util.inspect(expectedEdge), " in ").concat(inspectNode(rootNodes))); } }; - - for (var _iterator2 = expectation.children[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { _loop(); } } catch (err) { - _didIteratorError2 = true; - _iteratorError2 = err; + _iterator2.e(err); } finally { - try { - if (!_iteratorNormalCompletion2 && _iterator2.return != null) { - _iterator2.return(); - } - } finally { - if (_didIteratorError2) { - throw _iteratorError2; - } - } + _iterator2.f(); } } } } catch (err) { - _didIteratorError = true; - _iteratorError = err; + _iterator.e(err); } finally { - try { - if (!_iteratorNormalCompletion && _iterator.return != null) { - _iterator.return(); - } - } finally { - if (_didIteratorError) { - throw _iteratorError; - } - } + _iterator.f(); } - } // Validate our internal embedded graph representation + } + // Validate our internal embedded graph representation }, { key: "validateGraph", value: function validateGraph(rootName, expected) { var _ref3 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}, - _ref3$loose = _ref3.loose, - loose = _ref3$loose === void 0 ? false : _ref3$loose; - + _ref3$loose = _ref3.loose, + loose = _ref3$loose === void 0 ? false : _ref3$loose; var rootNodes = this.embedderGraph.filter(function (node) { return node.name === rootName; }); - if (loose) { assert(rootNodes.length >= expected.length, "Expect to find at least ".concat(expected.length, " '").concat(rootName, "', ") + "found ".concat(rootNodes.length)); } else { assert.strictEqual(rootNodes.length, expected.length, "Expect to find ".concat(expected.length, " '").concat(rootName, "', ") + "found ".concat(rootNodes.length)); } - - var _iteratorNormalCompletion3 = true; - var _didIteratorError3 = false; - var _iteratorError3 = undefined; - + var _iterator3 = _createForOfIteratorHelper(expected), + _step3; try { - for (var _iterator3 = expected[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { var expectation = _step3.value; - if (expectation.children) { - var _iteratorNormalCompletion4 = true; - var _didIteratorError4 = false; - var _iteratorError4 = undefined; - + var _iterator4 = _createForOfIteratorHelper(expectation.children), + _step4; try { var _loop2 = function _loop2() { var expectedEdge = _step4.value; var check = typeof expectedEdge === 'function' ? expectedEdge : function (edge) { return isEdge(edge, expectedEdge); - }; // Don't use assert with a custom message here. Otherwise the + }; + // Don't use assert with a custom message here. Otherwise the // inspection in the message is done eagerly and wastes a lot of CPU // time. - var hasChild = rootNodes.some(function (node) { return node.edges.some(check); }); - if (!hasChild) { throw new Error('expected to find child ' + "".concat(util.inspect(expectedEdge), " in ").concat(inspectNode(rootNodes))); } }; - - for (var _iterator4 = expectation.children[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) { + for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) { _loop2(); } } catch (err) { - _didIteratorError4 = true; - _iteratorError4 = err; + _iterator4.e(err); } finally { - try { - if (!_iteratorNormalCompletion4 && _iterator4.return != null) { - _iterator4.return(); - } - } finally { - if (_didIteratorError4) { - throw _iteratorError4; - } - } + _iterator4.f(); } } } } catch (err) { - _didIteratorError3 = true; - _iteratorError3 = err; + _iterator3.e(err); } finally { - try { - if (!_iteratorNormalCompletion3 && _iterator3.return != null) { - _iterator3.return(); - } - } finally { - if (_didIteratorError3) { - throw _iteratorError3; - } - } + _iterator3.f(); } } }, { key: "validateSnapshotNodes", value: function validateSnapshotNodes(rootName, expected) { var _ref4 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}, - _ref4$loose = _ref4.loose, - loose = _ref4$loose === void 0 ? false : _ref4$loose; - + _ref4$loose = _ref4.loose, + loose = _ref4$loose === void 0 ? false : _ref4$loose; this.validateSnapshot(rootName, expected, { loose: loose }); @@ -275,25 +196,19 @@ function () { }); } }]); - return State; }(); - function recordState() { return new State(); } - function validateSnapshotNodes() { var _recordState; - return (_recordState = recordState()).validateSnapshotNodes.apply(_recordState, arguments); } - module.exports = { recordState: recordState, validateSnapshotNodes: validateSnapshotNodes }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/hijackstdio.js b/test/common/hijackstdio.js index b3003f468a..9288841d64 100644 --- a/test/common/hijackstdio.js +++ b/test/common/hijackstdio.js @@ -2,43 +2,25 @@ /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ -// Hijack stdout and stderr - +// Hijack stdout and stderr var stdWrite = {}; - function hijackStdWritable(name, listener) { var stream = process[name]; - var _write = stdWrite[name] = stream.write; - stream.writeTimes = 0; - stream.write = function (data, callback) { try { listener(data); @@ -47,25 +29,20 @@ function hijackStdWritable(name, listener) { throw e; }); } - _write.call(stream, data, callback); - stream.writeTimes++; }; } - function restoreWritable(name) { process[name].write = stdWrite[name]; delete process[name].writeTimes; } - module.exports = { hijackStdout: hijackStdWritable.bind(null, 'stdout'), hijackStderr: hijackStdWritable.bind(null, 'stderr'), restoreStdout: restoreWritable.bind(null, 'stdout'), restoreStderr: restoreWritable.bind(null, 'stderr') }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/http2.js b/test/common/http2.js index 73ea152027..25c6e748bb 100644 --- a/test/common/http2.js +++ b/test/common/http2.js @@ -1,52 +1,35 @@ "use strict"; -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ + // An HTTP/2 testing tool used to create mock frames for direct testing // of HTTP/2 endpoints. - var kFrameData = Symbol('frame-data'); var FLAG_EOS = 0x1; var FLAG_ACK = 0x1; @@ -56,19 +39,15 @@ var PADDING = Buffer.alloc(255); var kClientMagic = Buffer.from('505249202a20485454502f322' + 'e300d0a0d0a534d0d0a0d0a', 'hex'); var kFakeRequestHeaders = Buffer.from('828684410f7777772e65' + '78616d706c652e636f6d', 'hex'); var kFakeResponseHeaders = Buffer.from('4803333032580770726976617465611d' + '4d6f6e2c203231204f63742032303133' + '2032303a31333a323120474d546e1768' + '747470733a2f2f7777772e6578616d70' + '6c652e636f6d', 'hex'); - function isUint32(val) { return val >>> 0 === val; } - function isUint24(val) { return val >>> 0 === val && val <= 0xFFFFFF; } - function isUint8(val) { return val >>> 0 === val && val <= 0xFF; } - function write32BE(array, pos, val) { if (!isUint32(val)) throw new RangeError('val is not a 32-bit number'); array[pos++] = val >> 24 & 0xff; @@ -76,170 +55,124 @@ function write32BE(array, pos, val) { array[pos++] = val >> 8 & 0xff; array[pos++] = val & 0xff; } - function write24BE(array, pos, val) { if (!isUint24(val)) throw new RangeError('val is not a 24-bit number'); array[pos++] = val >> 16 & 0xff; array[pos++] = val >> 8 & 0xff; array[pos++] = val & 0xff; } - function write8(array, pos, val) { if (!isUint8(val)) throw new RangeError('val is not an 8-bit number'); array[pos] = val; } - -var Frame = -/*#__PURE__*/ -function () { +var Frame = /*#__PURE__*/function () { function Frame(length, type, flags, id) { _classCallCheck(this, Frame); - this[kFrameData] = Buffer.alloc(9); write24BE(this[kFrameData], 0, length); write8(this[kFrameData], 3, type); write8(this[kFrameData], 4, flags); write32BE(this[kFrameData], 5, id); } - _createClass(Frame, [{ key: "data", get: function get() { return this[kFrameData]; } }]); - return Frame; }(); - -var SettingsFrame = -/*#__PURE__*/ -function (_Frame) { +var SettingsFrame = /*#__PURE__*/function (_Frame) { _inherits(SettingsFrame, _Frame); - + var _super = _createSuper(SettingsFrame); function SettingsFrame() { var ack = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - _classCallCheck(this, SettingsFrame); - var flags = 0; if (ack) flags |= FLAG_ACK; - return _possibleConstructorReturn(this, _getPrototypeOf(SettingsFrame).call(this, 0, 4, flags, 0)); + return _super.call(this, 0, 4, flags, 0); } - - return SettingsFrame; + return _createClass(SettingsFrame); }(Frame); - -var DataFrame = -/*#__PURE__*/ -function (_Frame2) { +var DataFrame = /*#__PURE__*/function (_Frame2) { _inherits(DataFrame, _Frame2); - + var _super2 = _createSuper(DataFrame); function DataFrame(id, payload) { var _this; - var padlen = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; var final = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; - _classCallCheck(this, DataFrame); - var len = payload.length; var flags = 0; if (final) flags |= FLAG_EOS; var buffers = [payload]; - if (padlen > 0) { buffers.unshift(Buffer.from([padlen])); buffers.push(PADDING.slice(0, padlen)); len += padlen + 1; flags |= FLAG_PADDED; } - - _this = _possibleConstructorReturn(this, _getPrototypeOf(DataFrame).call(this, len, 0, flags, id)); + _this = _super2.call(this, len, 0, flags, id); buffers.unshift(_this[kFrameData]); _this[kFrameData] = Buffer.concat(buffers); return _this; } - - return DataFrame; + return _createClass(DataFrame); }(Frame); - -var HeadersFrame = -/*#__PURE__*/ -function (_Frame3) { +var HeadersFrame = /*#__PURE__*/function (_Frame3) { _inherits(HeadersFrame, _Frame3); - + var _super3 = _createSuper(HeadersFrame); function HeadersFrame(id, payload) { var _this2; - var padlen = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; var final = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; - _classCallCheck(this, HeadersFrame); - var len = payload.length; var flags = FLAG_EOH; if (final) flags |= FLAG_EOS; var buffers = [payload]; - if (padlen > 0) { buffers.unshift(Buffer.from([padlen])); buffers.push(PADDING.slice(0, padlen)); len += padlen + 1; flags |= FLAG_PADDED; } - - _this2 = _possibleConstructorReturn(this, _getPrototypeOf(HeadersFrame).call(this, len, 1, flags, id)); + _this2 = _super3.call(this, len, 1, flags, id); buffers.unshift(_this2[kFrameData]); _this2[kFrameData] = Buffer.concat(buffers); return _this2; } - - return HeadersFrame; + return _createClass(HeadersFrame); }(Frame); - -var PingFrame = -/*#__PURE__*/ -function (_Frame4) { +var PingFrame = /*#__PURE__*/function (_Frame4) { _inherits(PingFrame, _Frame4); - + var _super4 = _createSuper(PingFrame); function PingFrame() { var _this3; - var ack = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - _classCallCheck(this, PingFrame); - var buffers = [Buffer.alloc(8)]; - _this3 = _possibleConstructorReturn(this, _getPrototypeOf(PingFrame).call(this, 8, 6, ack ? 1 : 0, 0)); + _this3 = _super4.call(this, 8, 6, ack ? 1 : 0, 0); buffers.unshift(_this3[kFrameData]); _this3[kFrameData] = Buffer.concat(buffers); return _this3; } - - return PingFrame; + return _createClass(PingFrame); }(Frame); - -var AltSvcFrame = -/*#__PURE__*/ -function (_Frame5) { +var AltSvcFrame = /*#__PURE__*/function (_Frame5) { _inherits(AltSvcFrame, _Frame5); - + var _super5 = _createSuper(AltSvcFrame); function AltSvcFrame(size) { var _this4; - _classCallCheck(this, AltSvcFrame); - var buffers = [Buffer.alloc(size)]; - _this4 = _possibleConstructorReturn(this, _getPrototypeOf(AltSvcFrame).call(this, size, 10, 0, 0)); + _this4 = _super5.call(this, size, 10, 0, 0); buffers.unshift(_this4[kFrameData]); _this4[kFrameData] = Buffer.concat(buffers); return _this4; } - - return AltSvcFrame; + return _createClass(AltSvcFrame); }(Frame); - module.exports = { Frame: Frame, AltSvcFrame: AltSvcFrame, @@ -251,7 +184,6 @@ module.exports = { kFakeResponseHeaders: kFakeResponseHeaders, kClientMagic: kClientMagic }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/index.js b/test/common/index.js index 8c7f9d030a..a9edce03ef 100644 --- a/test/common/index.js +++ b/test/common/index.js @@ -1,27 +1,23 @@ "use strict"; +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - -function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); } - -function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); } - -function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); } - -function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } } - +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } +function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } +function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } +function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } +function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; } +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ -// Copyright Joyent, Inc. and other Node contributors. +for (var i in util) exports[i] = util[i]; +/**/ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the @@ -43,71 +39,50 @@ for (var i in util) { // USE OR OTHER DEALINGS IN THE SOFTWARE. /* eslint-disable node-core/required-modules, node-core/crypto-check */ - - 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var process = global.process; // Some tests tamper with the process global. - var path = require('path'); - var fs = require('fs'); - var assert = require('assert'); - var os = require('os'); - var _require = require('child_process'), - exec = _require.exec, - execSync = _require.execSync, - spawnSync = _require.spawnSync; -/**/ - + exec = _require.exec, + execSync = _require.execSync, + spawnSync = _require.spawnSync; +/**/ var util = require('core-util-is'); - util.inherits = require('inherits'); /**/ var Timer = { now: function now() {} }; - var tmpdir = require('./tmpdir'); - var _process$binding = process.binding('config'), - bits = _process$binding.bits, - hasIntl = _process$binding.hasIntl; - + bits = _process$binding.bits, + hasIntl = _process$binding.hasIntl; var noop = function noop() {}; - var hasCrypto = true; - var isMainThread = function () { if (false) { return require('worker_threads').isMainThread; - } // Worker module not enabled → only a single main thread exists. - - + } + // Worker module not enabled → only a single main thread exists. return true; -}(); // Check for flags. Skip this for workers (both, the `cluster` module and -// `worker_threads`) and child processes. - +}(); +// Check for flags. Skip this for workers (both, the `cluster` module and +// `worker_threads`) and child processes. if (false && isMainThread && module.parent && require('cluster').isMaster) { // The copyright notice is relatively big and the flags could come afterwards. var bytesToRead = 1500; @@ -117,51 +92,38 @@ if (false && isMainThread && module.parent && require('cluster').isMaster) { fs.closeSync(fd); var source = buffer.toString('utf8', 0, bytesRead); var flagStart = source.indexOf('// Flags: --') + 10; - if (flagStart !== 9) { - var flagEnd = source.indexOf('\n', flagStart); // Normalize different EOL. - + var flagEnd = source.indexOf('\n', flagStart); + // Normalize different EOL. if (source[flagEnd - 1] === '\r') { flagEnd--; } - var flags = source.substring(flagStart, flagEnd).replace(/_/g, '-').split(' '); var args = process.execArgv.map(function (arg) { return arg.replace(/_/g, '-'); }); - var _iteratorNormalCompletion = true; - var _didIteratorError = false; - var _iteratorError = undefined; - + var _iterator = _createForOfIteratorHelper(flags), + _step; try { - for (var _iterator = flags[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + for (_iterator.s(); !(_step = _iterator.n()).done;) { var flag = _step.value; - - if (!args.includes(flag) && // If the binary was built without-ssl then the crypto flags are + if (!args.includes(flag) && + // If the binary was built without-ssl then the crypto flags are // invalid (bad option). The test itself should handle this case. - hasCrypto && ( // If the binary is build without `intl` the inspect option is + hasCrypto && ( + // If the binary is build without `intl` the inspect option is // invalid. The test itself should handle this case. process.config.variables.v8_enable_inspector !== 0 || !flag.startsWith('--inspect'))) { throw new Error("Test has to be started with the flag: '".concat(flag, "'")); } } } catch (err) { - _didIteratorError = true; - _iteratorError = err; + _iterator.e(err); } finally { - try { - if (!_iteratorNormalCompletion && _iterator.return != null) { - _iterator.return(); - } - } finally { - if (_didIteratorError) { - throw _iteratorError; - } - } + _iterator.f(); } } } - var isWindows = process.platform === 'win32'; var isAIX = process.platform === 'aix'; var isLinuxPPCBE = process.platform === 'linux' && process.arch === 'ppc64' && os.endianness() === 'BE'; @@ -170,16 +132,15 @@ var isFreeBSD = process.platform === 'freebsd'; var isOpenBSD = process.platform === 'openbsd'; var isLinux = process.platform === 'linux'; var isOSX = process.platform === 'darwin'; -var enoughTestMem = os.totalmem() > 0x70000000; -/* 1.75 Gb */ - +var enoughTestMem = os.totalmem() > 0x70000000; /* 1.75 Gb */ var cpus = os.cpus().length === 0 ? [{ speed: 1000 }] : os.cpus(); var enoughTestCpu = Array.isArray(cpus) && (cpus.length > 1 || cpus[0].speed > 999); var rootDir = isWindows ? 'c:\\' : '/'; -var buildType = 'readable-stream'; // If env var is set then enable async_hook hooks for all tests. +var buildType = 'readable-stream'; +// If env var is set then enable async_hook hooks for all tests. if (process.env.NODE_TEST_WITH_ASYNC_HOOKS) { var destroydIdsList = {}; var destroyListList = {}; @@ -187,25 +148,19 @@ if (process.env.NODE_TEST_WITH_ASYNC_HOOKS) { var async_wrap = process.binding('async_wrap'); process.on('exit', function () { // iterate through handles to make sure nothing crashes - for (var k in initHandles) { - util.inspect(initHandles[k]); - } + for (var k in initHandles) util.inspect(initHandles[k]); }); var _queueDestroyAsyncId = async_wrap.queueDestroyAsyncId; - async_wrap.queueDestroyAsyncId = function queueDestroyAsyncId(id) { if (destroyListList[id] !== undefined) { process._rawDebug(destroyListList[id]); - process._rawDebug(); - throw new Error("same id added to destroy list twice (".concat(id, ")")); } - destroyListList[id] = new Error().stack; - _queueDestroyAsyncId(id); }; + /*require('async_hooks').createHook({ init(id, ty, tr, r) { if (initHandles[id]) { @@ -227,24 +182,24 @@ if (process.env.NODE_TEST_WITH_ASYNC_HOOKS) { destroydIdsList[id] = new Error().stack; }, }).enable();*/ - } var opensslCli = null; var inFreeBSDJail = null; var localhostIPv4 = null; -var localIPv6Hosts = isLinux ? [// Debian/Ubuntu -'ip6-localhost', 'ip6-loopback', // SUSE -'ipv6-localhost', 'ipv6-loopback', // Typically universal +var localIPv6Hosts = isLinux ? [ +// Debian/Ubuntu +'ip6-localhost', 'ip6-loopback', +// SUSE +'ipv6-localhost', 'ipv6-loopback', +// Typically universal 'localhost'] : ['localhost']; - var PIPE = function () { var localRelative = path.relative(process.cwd(), "".concat(tmpdir.path, "/")); var pipePrefix = isWindows ? '\\\\.\\pipe\\' : localRelative; var pipeName = "node-test.".concat(process.pid, ".sock"); return path.join(pipePrefix, pipeName); }(); - var hasIPv6 = function () { var iFaces = os.networkInterfaces(); var re = isWindows ? /Loopback Pseudo-Interface/ : /lo/; @@ -255,22 +210,19 @@ var hasIPv6 = function () { }); }); }(); + /* * Check that when running a test with * `$node --abort-on-uncaught-exception $file child` * the process aborts. */ - - function childShouldThrowAndAbort() { var testCmd = ''; - if (!isWindows) { // Do not create core files, as it can take a lot of disk space on // continuous testing and developers' machines testCmd += 'ulimit -c 0 && '; } - testCmd += "\"".concat(process.argv[0], "\" --abort-on-uncaught-exception "); testCmd += "\"".concat(process.argv[1], "\" child"); var child = exec(testCmd); @@ -279,15 +231,12 @@ function childShouldThrowAndAbort() { assert(nodeProcessAborted(exitCode, signal), errMsg); }); } - function createZeroFilledFile(filename) { var fd = fs.openSync(filename, 'w'); fs.ftruncateSync(fd, 10 * 1024 * 1024); fs.closeSync(fd); } - var pwdCommand = isWindows ? ['cmd.exe', ['/d', '/c', 'cd']] : ['pwd', []]; - function platformTimeout(ms) { if (process.features.debug) ms = 2 * ms; if (global.__coverage__) ms = 4 * ms; @@ -303,11 +252,9 @@ function platformTimeout(ms) { } var knownGlobals = [Buffer, clearImmediate, clearInterval, clearTimeout, global, process, setImmediate, setInterval, setTimeout]; - if (global.gc) { knownGlobals.push(global.gc); } - if (global.DTRACE_HTTP_SERVER_RESPONSE) { knownGlobals.push(DTRACE_HTTP_SERVER_RESPONSE); knownGlobals.push(DTRACE_HTTP_SERVER_REQUEST); @@ -316,7 +263,6 @@ if (global.DTRACE_HTTP_SERVER_RESPONSE) { knownGlobals.push(DTRACE_NET_STREAM_END); knownGlobals.push(DTRACE_NET_SERVER_CONNECTION); } - if (global.COUNTER_NET_SERVER_CONNECTION) { knownGlobals.push(COUNTER_NET_SERVER_CONNECTION); knownGlobals.push(COUNTER_NET_SERVER_CONNECTION_CLOSE); @@ -325,22 +271,18 @@ if (global.COUNTER_NET_SERVER_CONNECTION) { knownGlobals.push(COUNTER_HTTP_CLIENT_REQUEST); knownGlobals.push(COUNTER_HTTP_CLIENT_RESPONSE); } - if (process.env.NODE_TEST_KNOWN_GLOBALS) { var knownFromEnv = process.env.NODE_TEST_KNOWN_GLOBALS.split(','); allowGlobals.apply(void 0, _toConsumableArray(knownFromEnv)); } - function allowGlobals() { for (var _len = arguments.length, whitelist = new Array(_len), _key = 0; _key < _len; _key++) { whitelist[_key] = arguments[_key]; } - knownGlobals = knownGlobals.concat(whitelist); } -/**/ - +/**/ if (typeof constructor == 'function') knownGlobals.push(constructor); if (typeof DTRACE_NET_SOCKET_READ == 'function') knownGlobals.push(DTRACE_NET_SOCKET_READ); if (typeof DTRACE_NET_SOCKET_WRITE == 'function') knownGlobals.push(DTRACE_NET_SOCKET_WRITE); @@ -349,18 +291,15 @@ if (global.__coverage__) knownGlobals.push(__coverage__); return typeof global[item] !== undefined; }).forEach(function (item) { knownGlobals.push(global[item]); -}); -/**/ +}); /**/ function leakedGlobals() { var leaked = []; - for (var val in global) { if (!knownGlobals.includes(global[val])) { leaked.push(val); } } - if (global.__coverage__) { return leaked.filter(function (varname) { return !/^(?:cov_|__cov)/.test(varname); @@ -369,16 +308,13 @@ function leakedGlobals() { return leaked; } } - process.on('exit', function () { var leaked = leakedGlobals(); - if (leaked.length > 0) { assert.fail("Unexpected global(s) found: ".concat(leaked.join(', '))); } }); var mustCallChecks = []; - function runCallChecks(exitCode) { if (exitCode !== 0) return; var failed = mustCallChecks.filter(function (context) { @@ -396,32 +332,27 @@ function runCallChecks(exitCode) { }); if (failed.length) process.exit(1); } - function mustCall(fn, exact) { return _mustCallInner(fn, exact, 'exact'); } - function mustCallAtLeast(fn, minimum) { return _mustCallInner(fn, minimum, 'minimum'); } - function _mustCallInner(fn) { var _context; - var criteria = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; var field = arguments.length > 2 ? arguments[2] : undefined; if (process._exiting) throw new Error('Cannot use common.mustCall*() in process exit handler'); - if (typeof fn === 'number') { criteria = fn; fn = noop; } else if (fn === undefined) { fn = noop; } - if (typeof criteria !== 'number') throw new TypeError("Invalid ".concat(field, " value: ").concat(criteria)); - var context = (_context = {}, _defineProperty(_context, field, criteria), _defineProperty(_context, "actual", 0), _defineProperty(_context, "stack", new Error().stack), _defineProperty(_context, "name", fn.name || ''), _context); // add the exit listener only once to avoid listener leak warnings + var context = (_context = {}, _defineProperty(_context, field, criteria), _defineProperty(_context, "actual", 0), _defineProperty(_context, "stack", new Error().stack), _defineProperty(_context, "name", fn.name || ''), _context); + // add the exit listener only once to avoid listener leak warnings if (mustCallChecks.length === 0) process.on('exit', runCallChecks); mustCallChecks.push(context); return function () { @@ -429,24 +360,20 @@ function _mustCallInner(fn) { return fn.apply(this, arguments); }; } - function hasMultiLocalhost() { var _process$binding2 = process.binding('tcp_wrap'), - TCP = _process$binding2.TCP, - TCPConstants = _process$binding2.constants; - + TCP = _process$binding2.TCP, + TCPConstants = _process$binding2.constants; var t = new TCP(TCPConstants.SOCKET); var ret = t.bind('127.0.0.2', 0); t.close(); return ret === 0; } - function skipIfEslintMissing() { if (!fs.existsSync(path.join(__dirname, '..', '..', 'tools', 'node_modules', 'eslint'))) { skip('missing ESLint'); } } - function canCreateSymLink() { // On Windows, creating symlinks requires admin privileges. // We'll only try to run symlink test if we have enough privileges. @@ -456,7 +383,6 @@ function canCreateSymLink() { // If unix tools are in the path, they can shadow the one we want, // so use the full path while executing whoami var whoamiPath = path.join(process.env.SystemRoot, 'System32', 'whoami.exe'); - try { var output = execSync("".concat(whoamiPath, " /priv"), { timout: 1000 @@ -465,83 +391,76 @@ function canCreateSymLink() { } catch (_e) { return false; } - } // On non-Windows platforms, this always returns `true` - - + } + // On non-Windows platforms, this always returns `true` return true; } - function getCallSite(top) { var originalStackFormatter = Error.prepareStackTrace; - Error.prepareStackTrace = function (err, stack) { return "".concat(stack[0].getFileName(), ":").concat(stack[0].getLineNumber()); }; - var err = new Error(); - Error.captureStackTrace(err, top); // with the V8 Error API, the stack is not formatted until it is accessed - + Error.captureStackTrace(err, top); + // with the V8 Error API, the stack is not formatted until it is accessed err.stack; Error.prepareStackTrace = originalStackFormatter; return err.stack; } - function mustNotCall(msg) { var callSite = getCallSite(mustNotCall); return function mustNotCall() { assert.fail("".concat(msg || 'function should not have been called', " at ").concat(callSite)); }; } - function printSkipMessage(msg) { console.log("1..0 # Skipped: ".concat(msg)); } - function skip(msg) { printSkipMessage(msg); process.exit(0); -} // Returns true if the exit code "exitCode" and/or signal name "signal" +} + +// Returns true if the exit code "exitCode" and/or signal name "signal" // represent the exit code and/or signal name of a node process that aborted, // false otherwise. - - function nodeProcessAborted(exitCode, signal) { // Depending on the compiler used, node will exit with either // exit code 132 (SIGILL), 133 (SIGTRAP) or 134 (SIGABRT). - var expectedExitCodes = [132, 133, 134]; // On platforms using KSH as the default shell (like SmartOS), + var expectedExitCodes = [132, 133, 134]; + + // On platforms using KSH as the default shell (like SmartOS), // when a process aborts, KSH exits with an exit code that is // greater than 256, and thus the exit code emitted with the 'exit' // event is null and the signal is set to either SIGILL, SIGTRAP, // or SIGABRT (depending on the compiler). + var expectedSignals = ['SIGILL', 'SIGTRAP', 'SIGABRT']; - var expectedSignals = ['SIGILL', 'SIGTRAP', 'SIGABRT']; // On Windows, 'aborts' are of 2 types, depending on the context: + // On Windows, 'aborts' are of 2 types, depending on the context: // (i) Forced access violation, if --abort-on-uncaught-exception is on // which corresponds to exit code 3221225477 (0xC0000005) // (ii) Otherwise, _exit(134) which is called in place of abort() due to // raising SIGABRT exiting with ambiguous exit code '3' by default + if (isWindows) expectedExitCodes = [0xC0000005, 134]; - if (isWindows) expectedExitCodes = [0xC0000005, 134]; // When using --abort-on-uncaught-exception, V8 will use + // When using --abort-on-uncaught-exception, V8 will use // base::OS::Abort to terminate the process. // Depending on the compiler used, the shell or other aspects of // the platform used to build the node binary, this will actually // make V8 exit by aborting or by raising a signal. In any case, // one of them (exit code or signal) needs to be set to one of // the expected exit codes or signals. - if (signal !== null) { return expectedSignals.includes(signal); } else { return expectedExitCodes.includes(exitCode); } } - function busyLoop(time) { var startTime = Timer.now(); var stopTime = startTime + time; - while (Timer.now() < stopTime) {} } - function isAlive(pid) { try { process.kill(pid, 'SIGCONT'); @@ -550,55 +469,47 @@ function isAlive(pid) { return false; } } - function _expectWarning(name, expected) { var map = new Map(expected); return mustCall(function (warning) { assert.strictEqual(warning.name, name); assert.ok(map.has(warning.message), "unexpected error message: \"".concat(warning.message, "\"")); var code = map.get(warning.message); - assert.strictEqual(warning.code, code); // Remove a warning message after it is seen so that we guarantee that we + assert.strictEqual(warning.code, code); + // Remove a warning message after it is seen so that we guarantee that we // get each message only once. - map.delete(expected); }, expected.length); } - function expectWarningByName(name, expected, code) { if (typeof expected === 'string') { expected = [[expected, code]]; } - process.on('warning', _expectWarning(name, expected)); } - function expectWarningByMap(warningMap) { var catchWarning = {}; forEach(objectKeys(warningMap), function (name) { var expected = warningMap[name]; - if (!Array.isArray(expected)) { throw new Error('warningMap entries must be arrays consisting of two ' + 'entries: [message, warningCode]'); } - if (!Array.isArray(expected[0])) { if (expected.length === 0) { return; } - expected = [[expected[0], expected[1]]]; } - catchWarning[name] = _expectWarning(name, expected); }); process.on('warning', function (warning) { return catchWarning[warning.name](warning); }); -} // accepts a warning name and description or array of descriptions or a map +} + +// accepts a warning name and description or array of descriptions or a map // of warning names to description(s) // ensures a warning is generated for each name/description pair - - function expectWarning(nameOrMap, expected, code) { if (typeof nameOrMap === 'string') { expectWarningByName(nameOrMap, expected, code); @@ -606,89 +517,63 @@ function expectWarning(nameOrMap, expected, code) { expectWarningByMap(nameOrMap); } } - -var Comparison = function Comparison(obj, keys) { +var Comparison = /*#__PURE__*/_createClass(function Comparison(obj, keys) { _classCallCheck(this, Comparison); - - var _iteratorNormalCompletion2 = true; - var _didIteratorError2 = false; - var _iteratorError2 = undefined; - + var _iterator2 = _createForOfIteratorHelper(keys), + _step2; try { - for (var _iterator2 = keys[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { var key = _step2.value; if (key in obj) this[key] = obj[key]; } } catch (err) { - _didIteratorError2 = true; - _iteratorError2 = err; + _iterator2.e(err); } finally { - try { - if (!_iteratorNormalCompletion2 && _iterator2.return != null) { - _iterator2.return(); - } - } finally { - if (_didIteratorError2) { - throw _iteratorError2; - } - } + _iterator2.f(); } -}; // Useful for testing expected internal/error objects - - +}); // Useful for testing expected internal/error objects function expectsError(fn, settings, exact) { if (typeof fn !== 'function') { exact = settings; settings = fn; fn = undefined; } - function innerFn(error) { if (arguments.length !== 1) { // Do not use `assert.strictEqual()` to prevent `util.inspect` from // always being called. assert.fail("Expected one argument, got ".concat(util.inspect(arguments))); } - - var descriptor = Object.getOwnPropertyDescriptor(error, 'message'); // The error message should be non-enumerable - + var descriptor = Object.getOwnPropertyDescriptor(error, 'message'); + // The error message should be non-enumerable assert.strictEqual(descriptor.enumerable, false); var innerSettings = settings; - if ('type' in settings) { var type = settings.type; - if (type !== Error && !Error.isPrototypeOf(type)) { throw new TypeError('`settings.type` must inherit from `Error`'); } - var _constructor = error.constructor; - if (_constructor.name === 'NodeError' && type.name !== 'NodeError') { _constructor = Object.getPrototypeOf(error.constructor); - } // Add the `type` to the error to properly compare and visualize it. - - + } + // Add the `type` to the error to properly compare and visualize it. if (!('type' in error)) error.type = _constructor; } - if ('message' in settings && typeof settings.message === 'object' && settings.message.test(error.message)) { // Make a copy so we are able to modify the settings. - innerSettings = Object.create(settings, Object.getOwnPropertyDescriptors(settings)); // Visualize the message as identical in case of other errors. - + innerSettings = Object.create(settings, Object.getOwnPropertyDescriptors(settings)); + // Visualize the message as identical in case of other errors. innerSettings.message = error.message; - } // Check all error properties. - + } + // Check all error properties. var keys = objectKeys(settings); - var _iteratorNormalCompletion3 = true; - var _didIteratorError3 = false; - var _iteratorError3 = undefined; - + var _iterator3 = _createForOfIteratorHelper(keys), + _step3; try { - for (var _iterator3 = keys[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { var key = _step3.value; - if (!require('deep-strict-equal')(error[key], innerSettings[key])) { // Create placeholder objects to create a nice output. var a = new Comparison(error, keys); @@ -711,92 +596,67 @@ function expectsError(fn, settings, exact) { } } } catch (err) { - _didIteratorError3 = true; - _iteratorError3 = err; + _iterator3.e(err); } finally { - try { - if (!_iteratorNormalCompletion3 && _iterator3.return != null) { - _iterator3.return(); - } - } finally { - if (_didIteratorError3) { - throw _iteratorError3; - } - } + _iterator3.f(); } - return true; } - if (fn) { assert.throws(fn, innerFn); return; } - return mustCall(innerFn, exact); } - function skipIfInspectorDisabled() { if (process.config.variables.v8_enable_inspector === 0) { skip('V8 inspector is disabled'); } } - function skipIf32Bits() { if (bits < 64) { skip('The tested feature is not available in 32bit builds'); } } - function skipIfWorker() { if (!isMainThread) { skip('This test only works on a main thread'); } } - function getArrayBufferViews(buf) { var buffer = buf.buffer, - byteOffset = buf.byteOffset, - byteLength = buf.byteLength; + byteOffset = buf.byteOffset, + byteLength = buf.byteLength; var out = []; var arrayBufferViews = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, DataView]; - for (var _i = 0, _arrayBufferViews = arrayBufferViews; _i < _arrayBufferViews.length; _i++) { var type = _arrayBufferViews[_i]; var _type$BYTES_PER_ELEME = type.BYTES_PER_ELEMENT, - BYTES_PER_ELEMENT = _type$BYTES_PER_ELEME === void 0 ? 1 : _type$BYTES_PER_ELEME; - + BYTES_PER_ELEMENT = _type$BYTES_PER_ELEME === void 0 ? 1 : _type$BYTES_PER_ELEME; if (byteLength % BYTES_PER_ELEMENT === 0) { out.push(new type(buffer, byteOffset, byteLength / BYTES_PER_ELEMENT)); } } - return out; } - function getBufferSources(buf) { return [].concat(_toConsumableArray(getArrayBufferViews(buf)), [new Uint8Array(buf).buffer]); -} // Crash the process on unhandled rejections. - +} +// Crash the process on unhandled rejections. var crashOnUnhandledRejection = function crashOnUnhandledRejection(err) { throw err; }; - process.on('unhandledRejection', crashOnUnhandledRejection); - function disableCrashOnUnhandledRejection() { process.removeListener('unhandledRejection', crashOnUnhandledRejection); } - function getTTYfd() { // Do our best to grab a tty fd. - var tty = require('tty'); // Don't attempt fd 0 as it is not writable on Windows. + var tty = require('tty'); + // Don't attempt fd 0 as it is not writable on Windows. // Ref: ef2861961c3d9e9ed6972e1e84d969683b25cf95 - - var ttyFd = [1, 2, 4, 5].find(tty.isatty); - if (ttyFd === undefined) { try { return fs.openSync('/dev/tty'); @@ -805,25 +665,19 @@ function getTTYfd() { return -1; } } - return ttyFd; } - function runWithInvalidFD(func) { - var fd = 1 << 30; // Get first known bad file descriptor. 1 << 30 is usually unlikely to + var fd = 1 << 30; + // Get first known bad file descriptor. 1 << 30 is usually unlikely to // be an valid one. - try { - while (fs.fstatSync(fd--) && fd > 0) { - ; - } + while (fs.fstatSync(fd--) && fd > 0); } catch (_unused3) { return func(fd); } - printSkipMessage('Could not generate an invalid fd'); } - module.exports = { allowGlobals: allowGlobals, buildType: buildType, @@ -871,30 +725,23 @@ module.exports = { skipIfEslintMissing: skipIfEslintMissing, skipIfInspectorDisabled: skipIfInspectorDisabled, skipIfWorker: skipIfWorker, - get localhostIPv6() { return '::1'; }, - get hasFipsCrypto() { return hasCrypto && require('crypto').fips; }, - get inFreeBSDJail() { if (inFreeBSDJail !== null) return inFreeBSDJail; - if (exports.isFreeBSD && execSync('sysctl -n security.jail.jailed').toString() === '1\n') { inFreeBSDJail = true; } else { inFreeBSDJail = false; } - return inFreeBSDJail; }, - get localhostIPv4() { if (localhostIPv4 !== null) return localhostIPv4; - if (this.inFreeBSDJail) { // Jailed network interfaces are a bit special - since we need to jump // through loops, as well as this being an exception case, assume the @@ -905,15 +752,12 @@ module.exports = { console.error('Looks like we\'re in a FreeBSD Jail. ' + 'Please provide your default interface address ' + 'as LOCALHOST or expect some tests to fail.'); } } - if (localhostIPv4 === null) localhostIPv4 = '127.0.0.1'; return localhostIPv4; }, - // opensslCli defined lazily to reduce overhead of spawnSync get opensslCli() { if (opensslCli !== null) return opensslCli; - if (process.config.variables.node_shared_openssl) { // use external command opensslCli = 'openssl'; @@ -921,28 +765,21 @@ module.exports = { // use command built from sources included in Node.js repository opensslCli = path.join(path.dirname(process.execPath), 'openssl-cli'); } - if (exports.isWindows) opensslCli += '.exe'; var opensslCmd = spawnSync(opensslCli, ['version']); - if (opensslCmd.status !== 0 || opensslCmd.error !== undefined) { // openssl command cannot be executed opensslCli = false; } - return opensslCli; }, - get PORT() { if (+process.env.TEST_PARALLEL) { throw new Error('common.PORT cannot be used in a parallelized test'); } - return +process.env.NODE_COMMON_PORT || 12346; } - }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/inspector-helper.js b/test/common/inspector-helper.js index f90d43220b..bbca6d3e7f 100644 --- a/test/common/inspector-helper.js +++ b/test/common/inspector-helper.js @@ -1,88 +1,60 @@ "use strict"; -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } - function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; } +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} +for (var i in util) exports[i] = util[i]; /**/ - - 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var common = require('../common'); - var assert = require('assert'); - var fs = require('fs'); - var http = require('http'); - var fixtures = require('../common/fixtures'); - var _require = require('child_process'), - spawn = _require.spawn; - + spawn = _require.spawn; var _require2 = require('url'), - parseURL = _require2.parse; - + parseURL = _require2.parse; var _require3 = require('internal/url'), - pathToFileURL = _require3.pathToFileURL; - + pathToFileURL = _require3.pathToFileURL; var _require4 = require('events'), - EventEmitter = _require4.EventEmitter; - + EventEmitter = _require4.EventEmitter; var _MAINSCRIPT = fixtures.path('loop.js'); - var DEBUG = false; var TIMEOUT = common.platformTimeout(15 * 1000); - function spawnChildProcess(inspectorFlags, scriptContents, scriptFile) { var args = [].concat(inspectorFlags); - if (scriptContents) { args.push('-e', scriptContents); } else { args.push(scriptFile); } - var child = spawn(process.execPath, args); var handler = tearDown.bind(null, child); process.on('exit', handler); @@ -92,7 +64,6 @@ function spawnChildProcess(inspectorFlags, scriptContents, scriptFile) { process.on('SIGINT', handler); return child; } - function makeBufferingDataCallback(dataCallback) { var buffer = Buffer.alloc(0); return function (data) { @@ -100,41 +71,27 @@ function makeBufferingDataCallback(dataCallback) { var str = newData.toString('utf8'); var lines = str.replace(/\r/g, '').split('\n'); if (str.endsWith('\n')) buffer = Buffer.alloc(0);else buffer = Buffer.from(lines.pop(), 'utf8'); - var _iteratorNormalCompletion = true; - var _didIteratorError = false; - var _iteratorError = undefined; - + var _iterator = _createForOfIteratorHelper(lines), + _step; try { - for (var _iterator = lines[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + for (_iterator.s(); !(_step = _iterator.n()).done;) { var line = _step.value; dataCallback(line); } } catch (err) { - _didIteratorError = true; - _iteratorError = err; + _iterator.e(err); } finally { - try { - if (!_iteratorNormalCompletion && _iterator.return != null) { - _iterator.return(); - } - } finally { - if (_didIteratorError) { - throw _iteratorError; - } - } + _iterator.f(); } }; } - function tearDown(child, err) { child.kill(); - if (err) { console.error(err); process.exit(1); } } - function parseWSFrame(buffer) { // Protocol described in https://tools.ietf.org/html/rfc6455#section-5 var message = null; @@ -142,7 +99,6 @@ function parseWSFrame(buffer) { length: 0, message: message }; - if (buffer[0] === 0x88 && buffer[1] === 0x00) { return { length: 2, @@ -150,12 +106,10 @@ function parseWSFrame(buffer) { closed: true }; } - assert.strictEqual(buffer[0], 0x81); var dataLen = 0x7F & buffer[1]; var bodyOffset = 2; if (buffer.length < bodyOffset + dataLen) return 0; - if (dataLen === 126) { dataLen = buffer.readUInt16BE(2); bodyOffset = 4; @@ -164,27 +118,23 @@ function parseWSFrame(buffer) { dataLen = buffer.readUIntBE(4, 6); bodyOffset = 10; } - if (buffer.length < bodyOffset + dataLen) return { length: 0, message: message }; var jsonPayload = buffer.slice(bodyOffset, bodyOffset + dataLen).toString('utf8'); - try { message = JSON.parse(jsonPayload); } catch (e) { console.error("JSON.parse() failed for: ".concat(jsonPayload)); throw e; } - if (DEBUG) console.log('[received]', JSON.stringify(message)); return { length: bodyOffset + dataLen, message: message }; } - function formatWSFrame(message) { var messageBuf = Buffer.from(JSON.stringify(message)); var wsHeaderBuf = Buffer.allocUnsafe(16); @@ -192,7 +142,6 @@ function formatWSFrame(message) { var byte2 = 0x80; var bodyLen = messageBuf.length; var maskOffset = 2; - if (bodyLen < 126) { byte2 = 0x80 + bodyLen; } else if (bodyLen < 65536) { @@ -205,25 +154,15 @@ function formatWSFrame(message) { wsHeaderBuf.writeUInt32BE(0, 6); maskOffset = 10; } - wsHeaderBuf.writeUInt8(byte2, 1); wsHeaderBuf.writeUInt32BE(0x01020408, maskOffset); - - for (var _i = 0; _i < messageBuf.length; _i++) { - messageBuf[_i] = messageBuf[_i] ^ 1 << _i % 4; - } - + for (var _i = 0; _i < messageBuf.length; _i++) messageBuf[_i] = messageBuf[_i] ^ 1 << _i % 4; return Buffer.concat([wsHeaderBuf.slice(0, maskOffset + 4), messageBuf]); } - -var InspectorSession = -/*#__PURE__*/ -function () { +var InspectorSession = /*#__PURE__*/function () { function InspectorSession(socket, instance) { var _this = this; - _classCallCheck(this, InspectorSession); - this._instance = instance; this._socket = socket; this._nextId = 1; @@ -234,15 +173,12 @@ function () { var buffer = Buffer.alloc(0); socket.on('data', function (data) { buffer = Buffer.concat([buffer, data]); - do { var _parseWSFrame = parseWSFrame(buffer), - length = _parseWSFrame.length, - message = _parseWSFrame.message, - closed = _parseWSFrame.closed; - + length = _parseWSFrame.length, + message = _parseWSFrame.message, + closed = _parseWSFrame.closed; if (!length) break; - if (closed) { socket.write(Buffer.from([0x88, 0x00])); // WS close frame } @@ -255,7 +191,6 @@ function () { socket.once('close', resolve); }); } - _createClass(InspectorSession, [{ key: "waitForServerDisconnect", value: function waitForServerDisconnect() { @@ -266,14 +201,11 @@ function () { value: function () { var _disconnect = _asyncToGenerator(function* () { this._socket.destroy(); - return this.waitForServerDisconnect(); }); - function disconnect() { return _disconnect.apply(this, arguments); } - return disconnect; }() }, { @@ -281,27 +213,21 @@ function () { value: function _onMessage(message) { if (message.id) { var _this$_commandRespons = this._commandResponsePromises.get(message.id), - resolve = _this$_commandRespons.resolve, - reject = _this$_commandRespons.reject; - + resolve = _this$_commandRespons.resolve, + reject = _this$_commandRespons.reject; this._commandResponsePromises.delete(message.id); - if (message.result) resolve(message.result);else reject(message.error); } else { if (message.method === 'Debugger.scriptParsed') { var _message$params = message.params, - scriptId = _message$params.scriptId, - url = _message$params.url; - + scriptId = _message$params.scriptId, + url = _message$params.url; this._scriptsIdsByUrl.set(scriptId, url); - var fileUrl = url.startsWith('file:') ? url : pathToFileURL(url).toString(); - if (fileUrl === this.scriptURL().toString()) { this.mainScriptId = scriptId; } } - if (this._notificationCallback) { // In case callback needs to install another var callback = this._notificationCallback; @@ -316,9 +242,7 @@ function () { key: "_sendMessage", value: function _sendMessage(message) { var _this2 = this; - var msg = JSON.parse(JSON.stringify(message)); // Clone! - msg.id = this._nextId++; if (DEBUG) console.log('[sent]', JSON.stringify(msg)); var responsePromise = new Promise(function (resolve, reject) { @@ -337,7 +261,6 @@ function () { key: "send", value: function send(commands) { var _this3 = this; - if (Array.isArray(commands)) { // Multiple commands means the response does not matter. There might even // never be a response. @@ -360,14 +283,11 @@ function () { value: function () { var _asyncWaitForNotification2 = _asyncToGenerator(function* (methodOrPredicate) { var _this4 = this; - function matchMethod(notification) { return notification.method === methodOrPredicate; } - var predicate = typeof methodOrPredicate === 'string' ? matchMethod : methodOrPredicate; var notification = null; - do { if (this._unprocessedNotifications.length) { notification = this._unprocessedNotifications.shift(); @@ -377,14 +297,11 @@ function () { }); } } while (!predicate(notification)); - return notification; }); - function _asyncWaitForNotification(_x) { return _asyncWaitForNotification2.apply(this, arguments); } - return _asyncWaitForNotification; }() }, { @@ -393,9 +310,7 @@ function () { if (message.method === 'Debugger.paused') { var callFrame = message.params.callFrames[0]; var location = callFrame.location; - var scriptPath = this._scriptsIdsByUrl.get(location.scriptId); - assert.strictEqual(scriptPath.toString(), expectedScriptPath.toString(), "".concat(scriptPath, " !== ").concat(expectedScriptPath)); assert.strictEqual(location.lineNumber, line); return true; @@ -405,7 +320,6 @@ function () { key: "waitForBreakOnLine", value: function waitForBreakOnLine(line, url) { var _this5 = this; - return this.waitForNotification(function (notification) { return _this5._isBreakOnLineNotification(notification, line, url); }, "break on ".concat(url, ":").concat(line)); @@ -414,36 +328,22 @@ function () { key: "_matchesConsoleOutputNotification", value: function _matchesConsoleOutputNotification(notification, type, values) { if (!Array.isArray(values)) values = [values]; - if (notification.method === 'Runtime.consoleAPICalled') { var params = notification.params; - if (params.type === type) { var _i2 = 0; - var _iteratorNormalCompletion2 = true; - var _didIteratorError2 = false; - var _iteratorError2 = undefined; - + var _iterator2 = _createForOfIteratorHelper(params.args), + _step2; try { - for (var _iterator2 = params.args[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { var value = _step2.value; if (value.value !== values[_i2++]) return false; } } catch (err) { - _didIteratorError2 = true; - _iteratorError2 = err; + _iterator2.e(err); } finally { - try { - if (!_iteratorNormalCompletion2 && _iterator2.return != null) { - _iterator2.return(); - } - } finally { - if (_didIteratorError2) { - throw _iteratorError2; - } - } + _iterator2.f(); } - return _i2 === values.length; } } @@ -452,7 +352,6 @@ function () { key: "waitForConsoleOutput", value: function waitForConsoleOutput(type, values) { var _this6 = this; - var desc = "Console output matching ".concat(JSON.stringify(values)); return this.waitForNotification(function (notification) { return _this6._matchesConsoleOutputNotification(notification, type, values); @@ -469,18 +368,12 @@ function () { yield this.waitForNotification(function (notification) { return notification.method === 'Runtime.executionContextDestroyed' && notification.params.executionContextId === 1; }); - - while ((yield this._instance.nextStderrString()) !== 'Waiting for the debugger to disconnect...') { - ; - } - + while ((yield this._instance.nextStderrString()) !== 'Waiting for the debugger to disconnect...'); yield this.disconnect(); }); - function runToCompletion() { return _runToCompletion.apply(this, arguments); } - return runToCompletion; }() }, { @@ -499,25 +392,18 @@ function () { return pathToFileURL(this.scriptPath()); } }]); - return InspectorSession; }(); - -var NodeInstance = -/*#__PURE__*/ -function (_EventEmitter) { +var NodeInstance = /*#__PURE__*/function (_EventEmitter) { _inherits(NodeInstance, _EventEmitter); - + var _super = _createSuper(NodeInstance); function NodeInstance() { var _this7; - var inspectorFlags = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['--inspect-brk=0']; var scriptContents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; var scriptFile = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _MAINSCRIPT; - _classCallCheck(this, NodeInstance); - - _this7 = _possibleConstructorReturn(this, _getPrototypeOf(NodeInstance).call(this)); + _this7 = _super.call(this); _this7._scriptPath = scriptFile; _this7._script = scriptFile ? null : scriptContents; _this7._portCallback = null; @@ -528,17 +414,13 @@ function (_EventEmitter) { _this7._running = true; _this7._stderrLineCallback = null; _this7._unprocessedStderrLines = []; - _this7._process.stdout.on('data', makeBufferingDataCallback(function (line) { _this7.emit('stdout', line); - console.log('[out]', line); })); - _this7._process.stderr.on('data', makeBufferingDataCallback(function (message) { return _this7.onStderrLine(message); })); - _this7._shutdownPromise = new Promise(function (resolve) { _this7._process.once('exit', function (exitCode, signal) { resolve({ @@ -550,25 +432,19 @@ function (_EventEmitter) { }); return _this7; } - _createClass(NodeInstance, [{ key: "onStderrLine", value: function onStderrLine(line) { console.log('[err]', line); - if (this._portCallback) { var matches = line.match(/Debugger listening on ws:\/\/.+:(\d+)\/.+/); - if (matches) { this._portCallback(matches[1]); - this._portCallback = null; } } - if (this._stderrLineCallback) { this._stderrLineCallback(line); - this._stderrLineCallback = null; } else { this._unprocessedStderrLines.push(line); @@ -626,11 +502,9 @@ function (_EventEmitter) { } }); }); - function sendUpgradeRequest() { return _sendUpgradeRequest.apply(this, arguments); } - return sendUpgradeRequest; }() }, { @@ -638,7 +512,6 @@ function (_EventEmitter) { value: function () { var _connectInspectorSession = _asyncToGenerator(function* () { var _this8 = this; - console.log('[test]', 'Connecting to a child Node process'); var upgradeRequest = yield this.sendUpgradeRequest(); return new Promise(function (resolve) { @@ -647,11 +520,9 @@ function (_EventEmitter) { }).on('response', common.mustNotCall('Upgrade was not received')); }); }); - function connectInspectorSession() { return _connectInspectorSession.apply(this, arguments); } - return connectInspectorSession; }() }, { @@ -668,11 +539,9 @@ function (_EventEmitter) { }); }); }); - function expectConnectionDeclined() { return _expectConnectionDeclined.apply(this, arguments); } - return expectConnectionDeclined; }() }, { @@ -684,7 +553,6 @@ function (_EventEmitter) { key: "nextStderrString", value: function nextStderrString() { var _this9 = this; - if (this._unprocessedStderrLines.length) return Promise.resolve(this._unprocessedStderrLines.shift()); return new Promise(function (resolve) { return _this9._stderrLineCallback = resolve; @@ -699,7 +567,6 @@ function (_EventEmitter) { key: "kill", value: function kill() { this._process.kill(); - return this.expectShutdown(); } }, { @@ -719,25 +586,18 @@ function (_EventEmitter) { var _startViaSignal = _asyncToGenerator(function* (scriptContents) { var instance = new NodeInstance([], "".concat(scriptContents, "\nprocess._rawDebug('started');"), undefined); var msg = 'Timed out waiting for process to start'; - while ((yield fires(instance.nextStderrString(), msg, TIMEOUT)) !== 'started') {} - process._debugProcess(instance._process.pid); - return instance; }); - function startViaSignal(_x2) { return _startViaSignal.apply(this, arguments); } - return startViaSignal; }() }]); - return NodeInstance; }(EventEmitter); - function onResolvedOrRejected(promise, callback) { return promise.then(function (result) { callback(); @@ -747,7 +607,6 @@ function onResolvedOrRejected(promise, callback) { throw error; }); } - function timeoutPromise(error, timeoutMs) { var clearCallback = null; var done = false; @@ -755,7 +614,6 @@ function timeoutPromise(error, timeoutMs) { var timeout = setTimeout(function () { return reject(error); }, timeoutMs); - clearCallback = function clearCallback() { if (done) return; clearTimeout(timeout); @@ -766,22 +624,20 @@ function timeoutPromise(error, timeoutMs) { }); promise.clear = clearCallback; return promise; -} // Returns a new promise that will propagate `promise` resolution or rejection +} + +// 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 = { NodeInstance: NodeInstance }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/internet.js b/test/common/internet.js index e34dabbe21..99c132e27f 100644 --- a/test/common/internet.js +++ b/test/common/internet.js @@ -1,34 +1,24 @@ "use strict"; +function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; } +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ -// Utilities for internet-related tests +// Utilities for internet-related tests var addresses = { // A generic host that has registered common DNS records, @@ -68,38 +58,24 @@ var addresses = { // An accessible IPv4 DNS server DNS6_SERVER: '2001:4860:4860::8888' }; -var _iteratorNormalCompletion = true; -var _didIteratorError = false; -var _iteratorError = undefined; - +var _iterator = _createForOfIteratorHelper(objectKeys(addresses)), + _step; try { - for (var _iterator = objectKeys(addresses)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + for (_iterator.s(); !(_step = _iterator.n()).done;) { var key = _step.value; var envName = "NODE_TEST_".concat(key); - if (process.env[envName]) { addresses[key] = process.env[envName]; } } } catch (err) { - _didIteratorError = true; - _iteratorError = err; + _iterator.e(err); } finally { - try { - if (!_iteratorNormalCompletion && _iterator.return != null) { - _iterator.return(); - } - } finally { - if (_didIteratorError) { - throw _iteratorError; - } - } + _iterator.f(); } - module.exports = { addresses: addresses }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/ongc.js b/test/common/ongc.js index c8ec0f07bc..3b2cd2a46d 100644 --- a/test/common/ongc.js +++ b/test/common/ongc.js @@ -2,38 +2,23 @@ /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} +for (var i in util) exports[i] = util[i]; /**/ - - 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var common = require('../common'); - var assert = require('assert'); - var gcTrackerMap = new WeakMap(); var gcTrackerTag = 'NODE_TEST_COMMON_GC_TRACKER'; - function onGC(obj, gcListener) { var async_hooks = /*require('async_hooks'); @@ -56,9 +41,7 @@ function onGC(obj, gcListener) { gcTrackerMap.set(obj, new async_hooks.AsyncResource(gcTrackerTag)); obj = null; } - module.exports = onGC; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/shared-lib-util.js b/test/common/shared-lib-util.js index fc96fc647a..353da267a2 100644 --- a/test/common/shared-lib-util.js +++ b/test/common/shared-lib-util.js @@ -2,56 +2,42 @@ /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} +for (var i in util) exports[i] = util[i]; /**/ - - 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var common = require('../common'); - var path = require('path'); - var kNodeShared = Boolean(process.config.variables.node_shared); var kShlibSuffix = process.config.variables.shlib_suffix; -var kExecPath = path.dirname(process.execPath); // If node executable is linked to shared lib, need to take care about the -// shared lib path. +var kExecPath = path.dirname(process.execPath); +// If node executable is linked to shared lib, need to take care about the +// shared lib path. function addLibraryPath(env) { if (!kNodeShared) { return; } - env = env || process.env; - env.LD_LIBRARY_PATH = (env.LD_LIBRARY_PATH ? env.LD_LIBRARY_PATH + path.delimiter : '') + path.join(kExecPath, 'lib.target'); // For AIX. - - env.LIBPATH = (env.LIBPATH ? env.LIBPATH + path.delimiter : '') + path.join(kExecPath, 'lib.target'); // For Mac OSX. - - env.DYLD_LIBRARY_PATH = (env.DYLD_LIBRARY_PATH ? env.DYLD_LIBRARY_PATH + path.delimiter : '') + kExecPath; // For Windows. - + env.LD_LIBRARY_PATH = (env.LD_LIBRARY_PATH ? env.LD_LIBRARY_PATH + path.delimiter : '') + path.join(kExecPath, 'lib.target'); + // For AIX. + env.LIBPATH = (env.LIBPATH ? env.LIBPATH + path.delimiter : '') + path.join(kExecPath, 'lib.target'); + // For Mac OSX. + env.DYLD_LIBRARY_PATH = (env.DYLD_LIBRARY_PATH ? env.DYLD_LIBRARY_PATH + path.delimiter : '') + kExecPath; + // For Windows. env.PATH = (env.PATH ? env.PATH + path.delimiter : '') + kExecPath; -} // Get the full path of shared lib. - +} +// Get the full path of shared lib. function getSharedLibPath() { if (common.isWindows) { return path.join(kExecPath, 'node.dll'); @@ -60,19 +46,17 @@ function getSharedLibPath() { } else { return path.join(kExecPath, 'lib.target', "libnode.".concat(kShlibSuffix)); } -} // Get the binary path of stack frames. - +} +// Get the binary path of stack frames. function getBinaryPath() { return kNodeShared ? getSharedLibPath() : process.execPath; } - module.exports = { addLibraryPath: addLibraryPath, getBinaryPath: getBinaryPath, getSharedLibPath: getSharedLibPath }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/tick.js b/test/common/tick.js index f4f5fb772d..84ab4305b7 100644 --- a/test/common/tick.js +++ b/test/common/tick.js @@ -2,33 +2,20 @@ /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} +for (var i in util) exports[i] = util[i]; /**/ - - 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - require('../common'); - module.exports = function tick(x, cb) { function ontick() { if (--x === 0) { @@ -37,10 +24,8 @@ module.exports = function tick(x, cb) { setImmediate(ontick); } } - setImmediate(ontick); }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/tls.js b/test/common/tls.js index 98b00d0e09..8f87816dbc 100644 --- a/test/common/tls.js +++ b/test/common/tls.js @@ -1,96 +1,67 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules, node-core/crypto-check */ - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules, node-core/crypto-check */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var crypto = require('crypto'); - var net = require('net'); - exports.ccs = Buffer.from('140303000101', 'hex'); - -var TestTLSSocket = -/*#__PURE__*/ -function (_net$Socket) { +var TestTLSSocket = /*#__PURE__*/function (_net$Socket) { _inherits(TestTLSSocket, _net$Socket); - + var _super = _createSuper(TestTLSSocket); function TestTLSSocket(server_cert) { var _this; - _classCallCheck(this, TestTLSSocket); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(TestTLSSocket).call(this)); + _this = _super.call(this); _this.server_cert = server_cert; _this.version = Buffer.from('0303', 'hex'); - _this.handshake_list = []; // AES128-GCM-SHA256 - + _this.handshake_list = []; + // AES128-GCM-SHA256 _this.ciphers = Buffer.from('000002009c0', 'hex'); _this.pre_master_secret = Buffer.concat([_this.version, crypto.randomBytes(46)]); _this.master_secret = null; _this.write_seq = 0; _this.client_random = crypto.randomBytes(32); - _this.on('handshake', function (msg) { _this.handshake_list.push(msg); }); - _this.on('server_random', function (server_random) { _this.master_secret = PRF12('sha256', _this.pre_master_secret, 'master secret', Buffer.concat([_this.client_random, server_random]), 48); var key_block = PRF12('sha256', _this.master_secret, 'key expansion', Buffer.concat([server_random, _this.client_random]), 40); _this.client_writeKey = key_block.slice(0, 16); _this.client_writeIV = key_block.slice(32, 36); }); - return _this; } - _createClass(TestTLSSocket, [{ key: "createClientHello", value: function createClientHello() { var compressions = Buffer.from('0100', 'hex'); // null - var msg = addHandshakeHeader(0x01, Buffer.concat([this.version, this.client_random, this.ciphers, compressions])); this.emit('handshake', msg); return addRecordHeader(0x16, msg); @@ -134,13 +105,11 @@ function (_net$Socket) { var length = record.slice(3, 5).readUInt16BE(0); offset += 5; var remaining = buf.slice(offset, offset + length); - if (type === 0x16) { do { remaining = this.parseTLSHandshake(remaining); } while (remaining.length > 0); } - offset += length; return buf.slice(offset); } @@ -149,12 +118,10 @@ function (_net$Socket) { value: function parseTLSHandshake(buf) { var offset = 0; var handshake_type = buf[offset]; - if (handshake_type === 0x02) { var server_random = buf.slice(6, 6 + 32); this.emit('server_random', server_random); } - offset += 1; var length = buf.readUIntBE(offset, 3); offset += 3; @@ -184,59 +151,48 @@ function (_net$Socket) { return Buffer.concat([type, version, length, nonce, encrypted, tag]); } }]); - return TestTLSSocket; }(net.Socket); - function addRecordHeader(type, frame) { var record_layer = Buffer.from('0003030000', 'hex'); record_layer[0] = type; record_layer.writeUInt16BE(frame.length, 3); return Buffer.concat([record_layer, frame]); } - function addHandshakeHeader(type, msg) { var handshake_header = Buffer.alloc(4); handshake_header[0] = type; handshake_header.writeUIntBE(msg.length, 1, 3); return Buffer.concat([handshake_header, msg]); } - function PRF12(algo, secret, label, seed, size) { var newSeed = Buffer.concat([Buffer.from(label, 'utf8'), seed]); return P_hash(algo, secret, newSeed, size); } - function P_hash(algo, secret, seed, size) { var result = Buffer.alloc(size); var hmac = crypto.createHmac(algo, secret); hmac.update(seed); var a = hmac.digest(); var j = 0; - while (j < size) { hmac = crypto.createHmac(algo, secret); hmac.update(a); hmac.update(seed); var b = hmac.digest(); var todo = b.length; - if (j + todo > size) { todo = size - j; } - b.copy(result, j, 0, todo); j += todo; hmac = crypto.createHmac(algo, secret); hmac.update(a); a = hmac.digest(); } - return result; } - exports.TestTLSSocket = TestTLSSocket; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/tmpdir.js b/test/common/tmpdir.js index 4f3091de7c..200d624dbd 100644 --- a/test/common/tmpdir.js +++ b/test/common/tmpdir.js @@ -2,46 +2,28 @@ /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - var fs = require('fs'); - var path = require('path'); - function rimrafSync(p) { var st; - try { st = fs.lstatSync(p); } catch (e) { if (e.code === 'ENOENT') return; } - try { if (st && st.isDirectory()) rmdirSync(p, null);else fs.unlinkSync(p); } catch (e) { @@ -51,13 +33,11 @@ function rimrafSync(p) { rmdirSync(p, e); } } - function rmdirSync(p, originalEr) { try { fs.rmdirSync(p); } catch (e) { if (e.code === 'ENOTDIR') throw originalEr; - if (e.code === 'ENOTEMPTY' || e.code === 'EEXIST' || e.code === 'EPERM') { var enc = process.platform === 'linux' ? 'buffer' : 'utf8'; forEach(fs.readdirSync(p, enc), function (f) { @@ -72,28 +52,23 @@ function rmdirSync(p, originalEr) { } } } +var testRoot = process.env.NODE_TEST_DIR ? fs.realpathSync(process.env.NODE_TEST_DIR) : path.resolve(__dirname, '..'); -var testRoot = process.env.NODE_TEST_DIR ? fs.realpathSync(process.env.NODE_TEST_DIR) : path.resolve(__dirname, '..'); // Using a `.` prefixed name, which is the convention for "hidden" on POSIX, +// Using a `.` prefixed name, which is the convention for "hidden" on POSIX, // gets tools to ignore it by default or by simple rules, especially eslint. - var tmpdirName = '.tmp'; - if (process.env.TEST_THREAD_ID) { tmpdirName += ".".concat(process.env.TEST_THREAD_ID); } - var tmpPath = path.join(testRoot, tmpdirName); - function refresh() { rimrafSync(this.path); fs.mkdirSync(this.path); } - module.exports = { path: tmpPath, refresh: refresh }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/common/wpt.js b/test/common/wpt.js index 0d1b9c8008..e71e5fdf5c 100644 --- a/test/common/wpt.js +++ b/test/common/wpt.js @@ -2,36 +2,22 @@ /**/ require('@babel/polyfill'); - var util = require('util'); - -for (var i in util) { - exports[i] = util[i]; -} -/**/ - -/* eslint-disable node-core/required-modules */ - - +for (var i in util) exports[i] = util[i]; +/**/ /* eslint-disable node-core/required-modules */ 'use strict'; -/**/ - +/**/ var objectKeys = objectKeys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ +var assert = require('assert'); -var assert = require('assert'); // https://github.com/w3c/testharness.js/blob/master/testharness.js - - +// https://github.com/w3c/testharness.js/blob/master/testharness.js module.exports = { test: function test(fn, desc) { try { @@ -58,7 +44,6 @@ module.exports = { assert.fail("Reached unreachable code: ".concat(desc)); } }; - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); diff --git a/test/parallel/test-readable-from.js b/test/parallel/test-readable-from.js index 83e91f1615..7cc50059bd 100644 --- a/test/parallel/test-readable-from.js +++ b/test/parallel/test-readable-from.js @@ -1,53 +1,33 @@ "use strict"; function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } - function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } - -function _awaitAsyncGenerator(value) { return new _AwaitValue(value); } - +function _awaitAsyncGenerator(value) { return new _OverloadYield(value, 0); } function _wrapAsyncGenerator(fn) { return function () { return new _AsyncGenerator(fn.apply(this, arguments)); }; } - -function _AsyncGenerator(gen) { var front, back; function send(key, arg) { return new Promise(function (resolve, reject) { var request = { key: key, arg: arg, resolve: resolve, reject: reject, next: null }; if (back) { back = back.next = request; } else { front = back = request; resume(key, arg); } }); } function resume(key, arg) { try { var result = gen[key](arg); var value = result.value; var wrappedAwait = value instanceof _AwaitValue; Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { if (wrappedAwait) { resume(key === "return" ? "return" : "next", arg); return; } settle(result.done ? "return" : "normal", arg); }, function (err) { resume("throw", err); }); } catch (err) { settle("throw", err); } } function settle(type, value) { switch (type) { case "return": front.resolve({ value: value, done: true }); break; case "throw": front.reject(value); break; default: front.resolve({ value: value, done: false }); break; } front = front.next; if (front) { resume(front.key, front.arg); } else { back = null; } } this._invoke = send; if (typeof gen.return !== "function") { this.return = undefined; } } - -if (typeof Symbol === "function" && Symbol.asyncIterator) { _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { return this; }; } - -_AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); }; - -_AsyncGenerator.prototype.throw = function (arg) { return this._invoke("throw", arg); }; - -_AsyncGenerator.prototype.return = function (arg) { return this._invoke("return", arg); }; - -function _AwaitValue(value) { this.wrapped = value; } - -function _asyncIterator(iterable) { var method; if (typeof Symbol !== "undefined") { if (Symbol.asyncIterator) { method = iterable[Symbol.asyncIterator]; if (method != null) return method.call(iterable); } if (Symbol.iterator) { method = iterable[Symbol.iterator]; if (method != null) return method.call(iterable); } } throw new TypeError("Object is not async iterable"); } - +function _AsyncGenerator(gen) { var front, back; function resume(key, arg) { try { var result = gen[key](arg), value = result.value, overloaded = value instanceof _OverloadYield; Promise.resolve(overloaded ? value.v : value).then(function (arg) { if (overloaded) { var nextKey = "return" === key ? "return" : "next"; if (!value.k || arg.done) return resume(nextKey, arg); arg = gen[nextKey](arg).value; } settle(result.done ? "return" : "normal", arg); }, function (err) { resume("throw", err); }); } catch (err) { settle("throw", err); } } function settle(type, value) { switch (type) { case "return": front.resolve({ value: value, done: !0 }); break; case "throw": front.reject(value); break; default: front.resolve({ value: value, done: !1 }); } (front = front.next) ? resume(front.key, front.arg) : back = null; } this._invoke = function (key, arg) { return new Promise(function (resolve, reject) { var request = { key: key, arg: arg, resolve: resolve, reject: reject, next: null }; back ? back = back.next = request : (front = back = request, resume(key, arg)); }); }, "function" != typeof gen.return && (this.return = void 0); } +_AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function () { return this; }, _AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); }, _AsyncGenerator.prototype.throw = function (arg) { return this._invoke("throw", arg); }, _AsyncGenerator.prototype.return = function (arg) { return this._invoke("return", arg); }; +function _OverloadYield(value, kind) { this.v = value, this.k = kind; } +function _asyncIterator(iterable) { var method, async, sync, retry = 2; for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) { if (async && null != (method = iterable[async])) return method.call(iterable); if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable)); async = "@@asyncIterator", sync = "@@iterator"; } throw new TypeError("Object is not async iterable"); } +function AsyncFromSyncIterator(s) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var done = r.done; return Promise.resolve(r.value).then(function (value) { return { value: value, done: done }; }); } return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) { this.s = s, this.n = s.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, return: function _return(value) { var ret = this.s.return; return void 0 === ret ? Promise.resolve({ value: value, done: !0 }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments)); }, throw: function _throw(value) { var thr = this.s.return; return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(s); } /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - var _require = require('../common'), - mustCall = _require.mustCall; - + mustCall = _require.mustCall; var once = require('events.once'); - var _require2 = require('../../'), - Readable = _require2.Readable; - + Readable = _require2.Readable; var _require3 = require('assert/'), - strictEqual = _require3.strictEqual; - + strictEqual = _require3.strictEqual; function toReadableBasicSupport() { return _toReadableBasicSupport.apply(this, arguments); } - function _toReadableBasicSupport() { _toReadableBasicSupport = _asyncToGenerator(function* () { function generate() { return _generate.apply(this, arguments); } - function _generate() { _generate = _wrapAsyncGenerator(function* () { yield 'a'; @@ -56,25 +36,24 @@ function _toReadableBasicSupport() { }); return _generate.apply(this, arguments); } - var stream = Readable.from(generate()); var expected = ['a', 'b', 'c']; - var _iteratorNormalCompletion = true; + var _iteratorAbruptCompletion = false; var _didIteratorError = false; - var _iteratorError; - try { - for (var _iterator = _asyncIterator(stream), _step, _value; _step = yield _iterator.next(), _iteratorNormalCompletion = _step.done, _value = yield _step.value, !_iteratorNormalCompletion; _iteratorNormalCompletion = true) { - var chunk = _value; - strictEqual(chunk, expected.shift()); + for (var _iterator = _asyncIterator(stream), _step; _iteratorAbruptCompletion = !(_step = yield _iterator.next()).done; _iteratorAbruptCompletion = false) { + var chunk = _step.value; + { + strictEqual(chunk, expected.shift()); + } } } catch (err) { _didIteratorError = true; _iteratorError = err; } finally { try { - if (!_iteratorNormalCompletion && _iterator.return != null) { + if (_iteratorAbruptCompletion && _iterator.return != null) { yield _iterator.return(); } } finally { @@ -86,11 +65,9 @@ function _toReadableBasicSupport() { }); return _toReadableBasicSupport.apply(this, arguments); } - function toReadableSyncIterator() { return _toReadableSyncIterator.apply(this, arguments); } - function _toReadableSyncIterator() { _toReadableSyncIterator = _asyncToGenerator(function* () { function* generate() { @@ -98,25 +75,24 @@ function _toReadableSyncIterator() { yield 'b'; yield 'c'; } - var stream = Readable.from(generate()); var expected = ['a', 'b', 'c']; - var _iteratorNormalCompletion2 = true; + var _iteratorAbruptCompletion2 = false; var _didIteratorError2 = false; - var _iteratorError2; - try { - for (var _iterator2 = _asyncIterator(stream), _step2, _value2; _step2 = yield _iterator2.next(), _iteratorNormalCompletion2 = _step2.done, _value2 = yield _step2.value, !_iteratorNormalCompletion2; _iteratorNormalCompletion2 = true) { - var chunk = _value2; - strictEqual(chunk, expected.shift()); + for (var _iterator2 = _asyncIterator(stream), _step2; _iteratorAbruptCompletion2 = !(_step2 = yield _iterator2.next()).done; _iteratorAbruptCompletion2 = false) { + var chunk = _step2.value; + { + strictEqual(chunk, expected.shift()); + } } } catch (err) { _didIteratorError2 = true; _iteratorError2 = err; } finally { try { - if (!_iteratorNormalCompletion2 && _iterator2.return != null) { + if (_iteratorAbruptCompletion2 && _iterator2.return != null) { yield _iterator2.return(); } } finally { @@ -128,32 +104,30 @@ function _toReadableSyncIterator() { }); return _toReadableSyncIterator.apply(this, arguments); } - function toReadablePromises() { return _toReadablePromises.apply(this, arguments); } - function _toReadablePromises() { _toReadablePromises = _asyncToGenerator(function* () { var promises = [Promise.resolve('a'), Promise.resolve('b'), Promise.resolve('c')]; var stream = Readable.from(promises); var expected = ['a', 'b', 'c']; - var _iteratorNormalCompletion3 = true; + var _iteratorAbruptCompletion3 = false; var _didIteratorError3 = false; - var _iteratorError3; - try { - for (var _iterator3 = _asyncIterator(stream), _step3, _value3; _step3 = yield _iterator3.next(), _iteratorNormalCompletion3 = _step3.done, _value3 = yield _step3.value, !_iteratorNormalCompletion3; _iteratorNormalCompletion3 = true) { - var chunk = _value3; - strictEqual(chunk, expected.shift()); + for (var _iterator3 = _asyncIterator(stream), _step3; _iteratorAbruptCompletion3 = !(_step3 = yield _iterator3.next()).done; _iteratorAbruptCompletion3 = false) { + var chunk = _step3.value; + { + strictEqual(chunk, expected.shift()); + } } } catch (err) { _didIteratorError3 = true; _iteratorError3 = err; } finally { try { - if (!_iteratorNormalCompletion3 && _iterator3.return != null) { + if (_iteratorAbruptCompletion3 && _iterator3.return != null) { yield _iterator3.return(); } } finally { @@ -165,31 +139,29 @@ function _toReadablePromises() { }); return _toReadablePromises.apply(this, arguments); } - function toReadableString() { return _toReadableString.apply(this, arguments); } - function _toReadableString() { _toReadableString = _asyncToGenerator(function* () { var stream = Readable.from('abc'); var expected = ['a', 'b', 'c']; - var _iteratorNormalCompletion4 = true; + var _iteratorAbruptCompletion4 = false; var _didIteratorError4 = false; - var _iteratorError4; - try { - for (var _iterator4 = _asyncIterator(stream), _step4, _value4; _step4 = yield _iterator4.next(), _iteratorNormalCompletion4 = _step4.done, _value4 = yield _step4.value, !_iteratorNormalCompletion4; _iteratorNormalCompletion4 = true) { - var chunk = _value4; - strictEqual(chunk, expected.shift()); + for (var _iterator4 = _asyncIterator(stream), _step4; _iteratorAbruptCompletion4 = !(_step4 = yield _iterator4.next()).done; _iteratorAbruptCompletion4 = false) { + var chunk = _step4.value; + { + strictEqual(chunk, expected.shift()); + } } } catch (err) { _didIteratorError4 = true; _iteratorError4 = err; } finally { try { - if (!_iteratorNormalCompletion4 && _iterator4.return != null) { + if (_iteratorAbruptCompletion4 && _iterator4.return != null) { yield _iterator4.return(); } } finally { @@ -201,17 +173,14 @@ function _toReadableString() { }); return _toReadableString.apply(this, arguments); } - function toReadableOnData() { return _toReadableOnData.apply(this, arguments); } - function _toReadableOnData() { _toReadableOnData = _asyncToGenerator(function* () { function generate() { return _generate2.apply(this, arguments); } - function _generate2() { _generate2 = _wrapAsyncGenerator(function* () { yield 'a'; @@ -220,7 +189,6 @@ function _toReadableOnData() { }); return _generate2.apply(this, arguments); } - var stream = Readable.from(generate()); var iterations = 0; var expected = ['a', 'b', 'c']; @@ -233,17 +201,14 @@ function _toReadableOnData() { }); return _toReadableOnData.apply(this, arguments); } - function toReadableOnDataNonObject() { return _toReadableOnDataNonObject.apply(this, arguments); } - function _toReadableOnDataNonObject() { _toReadableOnDataNonObject = _asyncToGenerator(function* () { function generate() { return _generate3.apply(this, arguments); } - function _generate3() { _generate3 = _wrapAsyncGenerator(function* () { yield 'a'; @@ -252,7 +217,6 @@ function _toReadableOnDataNonObject() { }); return _generate3.apply(this, arguments); } - var stream = Readable.from(generate(), { objectMode: false }); @@ -268,27 +232,22 @@ function _toReadableOnDataNonObject() { }); return _toReadableOnDataNonObject.apply(this, arguments); } - function destroysTheStreamWhenThrowing() { return _destroysTheStreamWhenThrowing.apply(this, arguments); } - function _destroysTheStreamWhenThrowing() { _destroysTheStreamWhenThrowing = _asyncToGenerator(function* () { function generate() { return _generate4.apply(this, arguments); } - function _generate4() { _generate4 = _wrapAsyncGenerator(function* () { throw new Error('kaboom'); }); return _generate4.apply(this, arguments); } - var stream = Readable.from(generate()); stream.read(); - try { yield once(stream, 'error'); } catch (err) { @@ -298,35 +257,32 @@ function _destroysTheStreamWhenThrowing() { }); return _destroysTheStreamWhenThrowing.apply(this, arguments); } - function asTransformStream() { return _asTransformStream.apply(this, arguments); } - function _asTransformStream() { _asTransformStream = _asyncToGenerator(function* () { function generate(_x) { return _generate5.apply(this, arguments); } - function _generate5() { _generate5 = _wrapAsyncGenerator(function* (stream) { - var _iteratorNormalCompletion6 = true; + var _iteratorAbruptCompletion6 = false; var _didIteratorError6 = false; - var _iteratorError6; - try { - for (var _iterator6 = _asyncIterator(stream), _step6, _value6; _step6 = yield _awaitAsyncGenerator(_iterator6.next()), _iteratorNormalCompletion6 = _step6.done, _value6 = yield _awaitAsyncGenerator(_step6.value), !_iteratorNormalCompletion6; _iteratorNormalCompletion6 = true) { - var chunk = _value6; - yield chunk.toUpperCase(); + for (var _iterator6 = _asyncIterator(stream), _step6; _iteratorAbruptCompletion6 = !(_step6 = yield _awaitAsyncGenerator(_iterator6.next())).done; _iteratorAbruptCompletion6 = false) { + var chunk = _step6.value; + { + yield chunk.toUpperCase(); + } } } catch (err) { _didIteratorError6 = true; _iteratorError6 = err; } finally { try { - if (!_iteratorNormalCompletion6 && _iterator6.return != null) { + if (_iteratorAbruptCompletion6 && _iterator6.return != null) { yield _awaitAsyncGenerator(_iterator6.return()); } } finally { @@ -338,7 +294,6 @@ function _asTransformStream() { }); return _generate5.apply(this, arguments); } - var source = new Readable({ objectMode: true, read: function read() { @@ -350,22 +305,22 @@ function _asTransformStream() { }); var stream = Readable.from(generate(source)); var expected = ['A', 'B', 'C']; - var _iteratorNormalCompletion5 = true; + var _iteratorAbruptCompletion5 = false; var _didIteratorError5 = false; - var _iteratorError5; - try { - for (var _iterator5 = _asyncIterator(stream), _step5, _value5; _step5 = yield _iterator5.next(), _iteratorNormalCompletion5 = _step5.done, _value5 = yield _step5.value, !_iteratorNormalCompletion5; _iteratorNormalCompletion5 = true) { - var chunk = _value5; - strictEqual(chunk, expected.shift()); + for (var _iterator5 = _asyncIterator(stream), _step5; _iteratorAbruptCompletion5 = !(_step5 = yield _iterator5.next()).done; _iteratorAbruptCompletion5 = false) { + var chunk = _step5.value; + { + strictEqual(chunk, expected.shift()); + } } } catch (err) { _didIteratorError5 = true; _iteratorError5 = err; } finally { try { - if (!_iteratorNormalCompletion5 && _iterator5.return != null) { + if (_iteratorAbruptCompletion5 && _iterator5.return != null) { yield _iterator5.return(); } } finally { @@ -377,22 +332,15 @@ function _asTransformStream() { }); return _asTransformStream.apply(this, arguments); } - Promise.all([toReadableBasicSupport(), toReadableSyncIterator(), toReadablePromises(), toReadableString(), toReadableOnData(), toReadableOnDataNonObject(), destroysTheStreamWhenThrowing(), asTransformStream()]).then(mustCall()); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-readable-large-hwm.js b/test/parallel/test-readable-large-hwm.js index 9e47f0f487..6ef9b502b9 100644 --- a/test/parallel/test-readable-large-hwm.js +++ b/test/parallel/test-readable-large-hwm.js @@ -3,22 +3,18 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var _require = require('../../'), - Readable = _require.Readable; // Make sure that readable completes -// even when reading larger buffer. - + Readable = _require.Readable; +// Make sure that readable completes +// even when reading larger buffer. var bufferSize = 10 * 1024 * 1024; var n = 0; var r = new Readable({ read: function read() { // Try to fill readable buffer piece by piece. r.push(bufferShim.alloc(bufferSize / 10)); - if (n++ > 10) { r.push(null); } @@ -32,19 +28,13 @@ r.on('readable', function () { }); r.on('end', common.mustCall()); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-readable-single-end.js b/test/parallel/test-readable-single-end.js index b50c36fffa..e73bb6a9a9 100644 --- a/test/parallel/test-readable-single-end.js +++ b/test/parallel/test-readable-single-end.js @@ -4,13 +4,12 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var _require = require('../../'), - Readable = _require.Readable; // This test ensures that there will not be an additional empty 'readable' -// event when stream has ended (only 1 event signalling about end) + Readable = _require.Readable; +// This test ensures that there will not be an additional empty 'readable' +// event when stream has ended (only 1 event signalling about end) var r = new Readable({ read: function read() {} @@ -19,19 +18,13 @@ r.push(null); r.on('readable', common.mustCall()); r.on('end', common.mustCall()); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-auto-destroy.js b/test/parallel/test-stream-auto-destroy.js index 93338b4c20..0203663040 100644 --- a/test/parallel/test-stream-auto-destroy.js +++ b/test/parallel/test-stream-auto-destroy.js @@ -3,14 +3,9 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var stream = require('../../'); - var assert = require('assert/'); - { var r = new stream.Readable({ autoDestroy: true, @@ -81,19 +76,13 @@ var assert = require('assert/'); })); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-backpressure.js b/test/parallel/test-stream-backpressure.js index 35da341a75..8caaeaed1d 100644 --- a/test/parallel/test-stream-backpressure.js +++ b/test/parallel/test-stream-backpressure.js @@ -4,13 +4,9 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var pushes = 0; var total = 65500 + 40 * 1024; var rs = new stream.Readable({ @@ -19,19 +15,19 @@ var rs = new stream.Readable({ this.push(null); return; } + var length = this._readableState.length; - var length = this._readableState.length; // We are at most doing two full runs of _reads + // We are at most doing two full runs of _reads // before stopping, because Readable is greedy // to keep its buffer full - assert(length <= total); this.push(bufferShim.alloc(65500)); - for (var i = 0; i < 40; i++) { this.push(bufferShim.alloc(1024)); - } // We will be over highWaterMark at this point - // but a new call to _read is scheduled anyway. + } + // We will be over highWaterMark at this point + // but a new call to _read is scheduled anyway. }, 11) }); var ws = stream.Writable({ @@ -41,19 +37,13 @@ var ws = stream.Writable({ }); rs.pipe(ws); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-big-packet.js b/test/parallel/test-stream-big-packet.js index 063dee3e1e..56962d9c58 100644 --- a/test/parallel/test-stream-big-packet.js +++ b/test/parallel/test-stream-big-packet.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -40,27 +36,17 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var passed = false; - -var TestStream = -/*#__PURE__*/ -function (_stream$Transform) { +var TestStream = /*#__PURE__*/function (_stream$Transform) { _inherits(TestStream, _stream$Transform); - + var _super = _createSuper(TestStream); function TestStream() { _classCallCheck(this, TestStream); - - return _possibleConstructorReturn(this, _getPrototypeOf(TestStream).apply(this, arguments)); + return _super.apply(this, arguments); } - _createClass(TestStream, [{ key: "_transform", value: function _transform(chunk, encoding, done) { @@ -68,58 +54,50 @@ function (_stream$Transform) { // Char 'a' only exists in the last write passed = chunk.toString().includes('a'); } - done(); } }]); - return TestStream; }(stream.Transform); - var s1 = new stream.PassThrough(); var s2 = new stream.PassThrough(); var s3 = new TestStream(); -s1.pipe(s3); // Don't let s2 auto close which may close s3 - +s1.pipe(s3); +// Don't let s2 auto close which may close s3 s2.pipe(s3, { end: false -}); // We must write a buffer larger than highWaterMark +}); -var big = bufferShim.alloc(s1.writableHighWaterMark + 1, 'x'); // Since big is larger than highWaterMark, it will be buffered internally. +// We must write a buffer larger than highWaterMark +var big = bufferShim.alloc(s1.writableHighWaterMark + 1, 'x'); -assert(!s1.write(big)); // 'tiny' is small enough to pass through internal buffer. +// Since big is larger than highWaterMark, it will be buffered internally. +assert(!s1.write(big)); +// 'tiny' is small enough to pass through internal buffer. +assert(s2.write('tiny')); -assert(s2.write('tiny')); // Write some small data in next IO loop, which will never be written to s3 +// Write some small data in next IO loop, which will never be written to s3 // Because 'drain' event is not emitted from s1 and s1 is still paused +setImmediate(s1.write.bind(s1), 'later'); -setImmediate(s1.write.bind(s1), 'later'); // Assert after two IO loops when all operations have been done. - +// Assert after two IO loops when all operations have been done. process.on('exit', function () { assert(passed, 'Large buffer is not handled properly by Writable Stream'); }); - function indexOf(xs, x) { for (var i = 0, l = xs.length; i < l; i++) { if (xs[i] === x) return i; } - return -1; } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-big-push.js b/test/parallel/test-stream-big-push.js index 54ef1ca0ad..4f9c6875dc 100644 --- a/test/parallel/test-stream-big-push.js +++ b/test/parallel/test-stream-big-push.js @@ -24,21 +24,15 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var str = 'asdfasdfasdfasdfasdf'; var r = new stream.Readable({ highWaterMark: 5, encoding: 'utf8' }); var reads = 0; - function _read() { if (reads === 0) { setTimeout(function () { @@ -47,20 +41,19 @@ function _read() { reads++; } else if (reads === 1) { var _ret = r.push(str); - assert.strictEqual(_ret, false); reads++; } else { r.push(null); } } - r._read = common.mustCall(_read, 3); -r.on('end', common.mustCall()); // push some data in to start. -// we've never gotten any read event at this point. - -var ret = r.push(str); // should be false. > hwm +r.on('end', common.mustCall()); +// push some data in to start. +// we've never gotten any read event at this point. +var ret = r.push(str); +// should be false. > hwm assert(!ret); var chunk = r.read(); assert.strictEqual(chunk, str); @@ -77,19 +70,13 @@ r.once('readable', function () { assert.strictEqual(chunk, null); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-buffer-list.js b/test/parallel/test-stream-buffer-list.js index 85d1aea460..c331392e7d 100644 --- a/test/parallel/test-stream-buffer-list.js +++ b/test/parallel/test-stream-buffer-list.js @@ -3,22 +3,19 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); +var BufferList = require('../../lib/internal/streams/buffer_list'); -var BufferList = require('../../lib/internal/streams/buffer_list'); // Test empty buffer list. - - +// Test empty buffer list. var emptyList = new BufferList(); emptyList.shift(); assert.deepStrictEqual(emptyList, new BufferList()); assert.strictEqual(emptyList.join(','), ''); assert.deepStrictEqual(emptyList.concat(0), bufferShim.alloc(0)); -var buf = bufferShim.from('foo'); // Test buffer list with one element. +var buf = bufferShim.from('foo'); +// Test buffer list with one element. var list = new BufferList(); list.push(buf); var copy = list.concat(3); @@ -29,19 +26,13 @@ var shifted = list.shift(); assert.strictEqual(shifted, buf); assert.deepStrictEqual(list, new BufferList()); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-decoder-objectmode.js b/test/parallel/test-stream-decoder-objectmode.js index fe5a356734..790a7628a5 100644 --- a/test/parallel/test-stream-decoder-objectmode.js +++ b/test/parallel/test-stream-decoder-objectmode.js @@ -4,13 +4,9 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - require('../common'); - var stream = require('../../'); - var assert = require('assert/'); - var readable = new stream.Readable({ read: function read() {}, encoding: 'utf16le', @@ -18,25 +14,20 @@ var readable = new stream.Readable({ }); readable.push(bufferShim.from('abc', 'utf16le')); readable.push(bufferShim.from('def', 'utf16le')); -readable.push(null); // Without object mode, these would be concatenated into a single chunk. +readable.push(null); +// Without object mode, these would be concatenated into a single chunk. assert.strictEqual(readable.read(), 'abc'); assert.strictEqual(readable.read(), 'def'); assert.strictEqual(readable.read(), null); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-destroy-event-order.js b/test/parallel/test-stream-destroy-event-order.js index 12db9e626a..bc5dfcc63d 100644 --- a/test/parallel/test-stream-destroy-event-order.js +++ b/test/parallel/test-stream-destroy-event-order.js @@ -4,14 +4,10 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable; - + Readable = _require.Readable; var rs = new Readable({ read: function read() {} }); @@ -27,19 +23,13 @@ rs.on('error', common.mustCall(function (err) { })); rs.destroy(new Error('kaboom')); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-duplex-destroy.js b/test/parallel/test-stream-duplex-destroy.js index d163430858..5a625fd257 100644 --- a/test/parallel/test-stream-duplex-destroy.js +++ b/test/parallel/test-stream-duplex-destroy.js @@ -4,14 +4,10 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var _require = require('../../'), - Duplex = _require.Duplex; - + Duplex = _require.Duplex; var assert = require('assert/'); - { var duplex = new Duplex({ write: function write(chunk, enc, cb) { @@ -33,21 +29,14 @@ var assert = require('assert/'); }, read: function read() {} }); - _duplex.resume(); - var expected = new Error('kaboom'); - _duplex.on('end', common.mustNotCall()); - _duplex.on('finish', common.mustNotCall()); - _duplex.on('error', common.mustCall(function (err) { assert.strictEqual(err, expected); })); - _duplex.destroy(expected); - assert.strictEqual(_duplex.destroyed, true); } { @@ -57,27 +46,20 @@ var assert = require('assert/'); }, read: function read() {} }); - _duplex2._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, _expected); cb(err); }); - var _expected = new Error('kaboom'); - _duplex2.on('finish', common.mustNotCall('no finish event')); - _duplex2.on('error', common.mustCall(function (err) { assert.strictEqual(err, _expected); })); - _duplex2.destroy(_expected); - assert.strictEqual(_duplex2.destroyed, true); } { var _expected2 = new Error('kaboom'); - var _duplex3 = new Duplex({ write: function write(chunk, enc, cb) { cb(); @@ -88,20 +70,14 @@ var assert = require('assert/'); cb(); }) }); - _duplex3.resume(); - _duplex3.on('end', common.mustNotCall('no end event')); + _duplex3.on('finish', common.mustNotCall('no finish event')); - _duplex3.on('finish', common.mustNotCall('no finish event')); // error is swallowed by the custom _destroy - - + // error is swallowed by the custom _destroy _duplex3.on('error', common.mustNotCall('no error event')); - _duplex3.on('close', common.mustCall()); - _duplex3.destroy(_expected2); - assert.strictEqual(_duplex3.destroyed, true); } { @@ -111,14 +87,11 @@ var assert = require('assert/'); }, read: function read() {} }); - _duplex4._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, null); cb(); }); - _duplex4.destroy(); - assert.strictEqual(_duplex4.destroyed, true); } { @@ -128,37 +101,24 @@ var assert = require('assert/'); }, read: function read() {} }); - _duplex5.resume(); - _duplex5._destroy = common.mustCall(function (err, cb) { var _this = this; - assert.strictEqual(err, null); process.nextTick(function () { _this.push(null); - _this.end(); - cb(); }); }); var fail = common.mustNotCall('no finish or end event'); - _duplex5.on('finish', fail); - _duplex5.on('end', fail); - _duplex5.destroy(); - _duplex5.removeListener('end', fail); - _duplex5.removeListener('finish', fail); - _duplex5.on('end', common.mustCall()); - _duplex5.on('finish', common.mustCall()); - assert.strictEqual(_duplex5.destroyed, true); } { @@ -168,24 +128,17 @@ var assert = require('assert/'); }, read: function read() {} }); - var _expected3 = new Error('kaboom'); - _duplex6._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, null); cb(_expected3); }); - _duplex6.on('finish', common.mustNotCall('no finish event')); - _duplex6.on('end', common.mustNotCall('no end event')); - _duplex6.on('error', common.mustCall(function (err) { assert.strictEqual(err, _expected3); })); - _duplex6.destroy(); - assert.strictEqual(_duplex6.destroyed, true); } { @@ -196,15 +149,10 @@ var assert = require('assert/'); read: function read() {}, allowHalfOpen: true }); - _duplex7.resume(); - _duplex7.on('finish', common.mustNotCall()); - _duplex7.on('end', common.mustNotCall()); - _duplex7.destroy(); - assert.strictEqual(_duplex7.destroyed, true); } { @@ -214,41 +162,32 @@ var assert = require('assert/'); }, read: function read() {} }); - _duplex8.destroyed = true; - assert.strictEqual(_duplex8.destroyed, true); // the internal destroy() mechanism should not be triggered + assert.strictEqual(_duplex8.destroyed, true); + // the internal destroy() mechanism should not be triggered _duplex8.on('finish', common.mustNotCall()); - _duplex8.on('end', common.mustNotCall()); - _duplex8.destroy(); } { - function MyDuplex() { + var MyDuplex = function MyDuplex() { assert.strictEqual(this.destroyed, false); this.destroyed = false; Duplex.call(this); - } - + }; Object.setPrototypeOf(MyDuplex.prototype, Duplex.prototype); Object.setPrototypeOf(MyDuplex, Duplex); new MyDuplex(); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-duplex-end.js b/test/parallel/test-stream-duplex-end.js index 194648950a..df8f630027 100644 --- a/test/parallel/test-stream-duplex-end.js +++ b/test/parallel/test-stream-duplex-end.js @@ -4,13 +4,9 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var assert = require('assert/'); - var Duplex = require('../../').Duplex; - { var stream = new Duplex({ read: function read() {} @@ -26,15 +22,10 @@ var Duplex = require('../../').Duplex; read: function read() {}, allowHalfOpen: false }); - assert.strictEqual(_stream.allowHalfOpen, false); - _stream.on('finish', common.mustCall()); - assert.strictEqual(_stream.listenerCount('end'), 1); - _stream.resume(); - _stream.push(null); } { @@ -42,32 +33,21 @@ var Duplex = require('../../').Duplex; read: function read() {}, allowHalfOpen: false }); - assert.strictEqual(_stream2.allowHalfOpen, false); _stream2._writableState.ended = true; - _stream2.on('finish', common.mustNotCall()); - assert.strictEqual(_stream2.listenerCount('end'), 1); - _stream2.resume(); - _stream2.push(null); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-duplex.js b/test/parallel/test-stream-duplex.js index c32c7553d0..1e7e600b37 100644 --- a/test/parallel/test-stream-duplex.js +++ b/test/parallel/test-stream-duplex.js @@ -20,18 +20,13 @@ // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. - /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - require('../common'); - var assert = require('assert/'); - var Duplex = require('../../').Duplex; - var stream = new Duplex({ objectMode: true }); @@ -42,14 +37,11 @@ assert(stream.allowHalfOpen); assert.strictEqual(stream.listenerCount('end'), 0); var written; var read; - stream._write = function (obj, _, cb) { written = obj; cb(); }; - stream._read = function () {}; - stream.on('data', function (obj) { read = obj; }); @@ -64,19 +56,13 @@ process.on('exit', function () { assert.strictEqual(written.val, 2); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-end-paused.js b/test/parallel/test-stream-end-paused.js index 71e4460b0b..bf10f8f17f 100644 --- a/test/parallel/test-stream-end-paused.js +++ b/test/parallel/test-stream-end-paused.js @@ -24,24 +24,19 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); +var assert = require('assert/'); -var assert = require('assert/'); // Make sure we don't miss the end event for paused 0-length streams - +// Make sure we don't miss the end event for paused 0-length streams var Readable = require('../../').Readable; - var stream = new Readable(); var calledRead = false; - stream._read = function () { assert(!calledRead); calledRead = true; this.push(null); }; - stream.on('data', function () { throw new Error('should not ever get data'); }); @@ -54,19 +49,13 @@ process.on('exit', function () { assert(calledRead); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-events-prepend.js b/test/parallel/test-stream-events-prepend.js index adfe99df5c..eec8fbe45e 100644 --- a/test/parallel/test-stream-events-prepend.js +++ b/test/parallel/test-stream-events-prepend.js @@ -1,94 +1,67 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var stream = require('../../'); - -var Writable = -/*#__PURE__*/ -function (_stream$Writable) { +var Writable = /*#__PURE__*/function (_stream$Writable) { _inherits(Writable, _stream$Writable); - + var _super = _createSuper(Writable); function Writable() { var _this; - _classCallCheck(this, Writable); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(Writable).call(this)); + _this = _super.call(this); _this.prependListener = undefined; return _this; } - _createClass(Writable, [{ key: "_write", value: function _write(chunk, end, cb) { cb(); } }]); - return Writable; }(stream.Writable); - -var Readable = -/*#__PURE__*/ -function (_stream$Readable) { +var Readable = /*#__PURE__*/function (_stream$Readable) { _inherits(Readable, _stream$Readable); - + var _super2 = _createSuper(Readable); function Readable() { _classCallCheck(this, Readable); - - return _possibleConstructorReturn(this, _getPrototypeOf(Readable).apply(this, arguments)); + return _super2.apply(this, arguments); } - _createClass(Readable, [{ key: "_read", value: function _read() { this.push(null); } }]); - return Readable; }(stream.Readable); - var w = new Writable(); w.on('pipe', common.mustCall()); var r = new Readable(); r.pipe(w); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-finished.js b/test/parallel/test-stream-finished.js index 086962c8b1..cb558fd168 100644 --- a/test/parallel/test-stream-finished.js +++ b/test/parallel/test-stream-finished.js @@ -1,28 +1,20 @@ "use strict"; function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } - function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } - /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var _require = require('../../'), - Writable = _require.Writable, - Readable = _require.Readable, - Transform = _require.Transform, - finished = _require.finished; - + Writable = _require.Writable, + Readable = _require.Readable, + Transform = _require.Transform, + finished = _require.finished; var assert = require('assert/'); - var fs = require('fs'); - var promisify = require('util-promisify'); - { var rs = new Readable({ read: function read() {} @@ -68,20 +60,12 @@ var promisify = require('util-promisify'); } { var _rs = fs.createReadStream(__filename); - _rs.resume(); - finished(_rs, common.mustCall()); } { - var finishedPromise = promisify(finished); - - function run() { - return _run.apply(this, arguments); - } - - function _run() { - _run = _asyncToGenerator(function* () { + var run = /*#__PURE__*/function () { + var _ref = _asyncToGenerator(function* () { var rs = fs.createReadStream(__filename); var done = common.mustCall(); var ended = false; @@ -93,85 +77,65 @@ var promisify = require('util-promisify'); assert(ended); done(); }); - return _run.apply(this, arguments); - } - + return function run() { + return _ref.apply(this, arguments); + }; + }(); + var finishedPromise = promisify(finished); run(); } { var _rs2 = fs.createReadStream('file-does-not-exist'); - finished(_rs2, common.mustCall(function (err) { assert.strictEqual(err.code, 'ENOENT'); })); } { var _rs3 = new Readable(); - finished(_rs3, common.mustCall(function (err) { assert(!err, 'no error'); })); - _rs3.push(null); - _rs3.emit('close'); // should not trigger an error - - _rs3.resume(); } { var _rs4 = new Readable(); - finished(_rs4, common.mustCall(function (err) { assert(err, 'premature close error'); })); - _rs4.emit('close'); // should trigger error - - _rs4.push(null); - _rs4.resume(); -} // Test that calling returned function removes listeners +} +// Test that calling returned function removes listeners { var _ws = new Writable({ write: function write(data, env, cb) { cb(); } }); - var removeListener = finished(_ws, common.mustNotCall()); removeListener(); - _ws.end(); } { var _rs5 = new Readable(); - var removeListeners = finished(_rs5, common.mustNotCall()); removeListeners(); - _rs5.emit('close'); - _rs5.push(null); - _rs5.resume(); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-ispaused.js b/test/parallel/test-stream-ispaused.js index 278f19b636..58592d544b 100644 --- a/test/parallel/test-stream-ispaused.js +++ b/test/parallel/test-stream-ispaused.js @@ -24,41 +24,34 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var stream = require('../../'); +var readable = new stream.Readable(); -var readable = new stream.Readable(); // _read is a noop, here. - -readable._read = Function(); // default state of a stream is not "paused" +// _read is a noop, here. +readable._read = Function(); -assert.ok(!readable.isPaused()); // make the stream start flowing... +// default state of a stream is not "paused" +assert.ok(!readable.isPaused()); -readable.on('data', Function()); // still not paused. +// make the stream start flowing... +readable.on('data', Function()); +// still not paused. assert.ok(!readable.isPaused()); readable.pause(); assert.ok(readable.isPaused()); readable.resume(); assert.ok(!readable.isPaused()); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-objectmode-undefined.js b/test/parallel/test-stream-objectmode-undefined.js index 0a13eb1e98..b31051cce6 100644 --- a/test/parallel/test-stream-objectmode-undefined.js +++ b/test/parallel/test-stream-objectmode-undefined.js @@ -3,17 +3,12 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable, - Writable = _require.Writable, - Transform = _require.Transform; - + Readable = _require.Readable, + Writable = _require.Writable, + Transform = _require.Transform; { var stream = new Readable({ objectMode: true, @@ -33,7 +28,6 @@ var _require = require('../../'), assert.strictEqual(chunk, undefined); }) }); - _stream.write(undefined); } { @@ -43,27 +37,19 @@ var _require = require('../../'), _stream2.push(chunk); }) }); - _stream2.on('data', common.mustCall(function (chunk) { assert.strictEqual(chunk, undefined); })); - _stream2.write(undefined); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-once-readable-pipe.js b/test/parallel/test-stream-once-readable-pipe.js index 1cdea29f0a..4d73ee596c 100644 --- a/test/parallel/test-stream-once-readable-pipe.js +++ b/test/parallel/test-stream-once-readable-pipe.js @@ -4,16 +4,14 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable, - Writable = _require.Writable; // This test ensures that if have 'readable' listener -// on Readable instance it will not disrupt the pipe. + Readable = _require.Readable, + Writable = _require.Writable; +// This test ensures that if have 'readable' listener +// on Readable instance it will not disrupt the pipe. { var receivedData = ''; @@ -39,50 +37,34 @@ var _require = require('../../'), } { var _receivedData = ''; - var _w = new Writable({ write: function write(chunk, env, callback) { _receivedData += chunk; callback(); } }); - var _data = ['foo', 'bar', 'baz']; - var _r = new Readable({ read: function read() {} }); - _r.pipe(_w); - _r.push(_data[0]); - _r.push(_data[1]); - _r.push(_data[2]); - _r.push(null); - _r.once('readable', common.mustCall()); - _w.on('finish', common.mustCall(function () { assert.strictEqual(_receivedData, _data.join('')); })); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-after-end.js b/test/parallel/test-stream-pipe-after-end.js index 5e39fce11d..7043e0a8dd 100644 --- a/test/parallel/test-stream-pipe-after-end.js +++ b/test/parallel/test-stream-pipe-after-end.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -40,31 +36,20 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var Readable = require('../../lib/_stream_readable'); - var Writable = require('../../lib/_stream_writable'); - -var TestReadable = -/*#__PURE__*/ -function (_Readable) { +var TestReadable = /*#__PURE__*/function (_Readable) { _inherits(TestReadable, _Readable); - + var _super = _createSuper(TestReadable); function TestReadable(opt) { var _this; - _classCallCheck(this, TestReadable); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(TestReadable).call(this, opt)); + _this = _super.call(this, opt); _this._ended = false; return _this; } - _createClass(TestReadable, [{ key: "_read", value: function _read() { @@ -73,42 +58,32 @@ function (_Readable) { this.push(null); } }]); - return TestReadable; }(Readable); - -var TestWritable = -/*#__PURE__*/ -function (_Writable) { +var TestWritable = /*#__PURE__*/function (_Writable) { _inherits(TestWritable, _Writable); - + var _super2 = _createSuper(TestWritable); function TestWritable(opt) { var _this2; - _classCallCheck(this, TestWritable); - - _this2 = _possibleConstructorReturn(this, _getPrototypeOf(TestWritable).call(this, opt)); + _this2 = _super2.call(this, opt); _this2._written = []; return _this2; } - _createClass(TestWritable, [{ key: "_write", value: function _write(chunk, encoding, cb) { this._written.push(chunk); - cb(); } }]); - return TestWritable; }(Writable); // this one should not emit 'end' until we read() from it later. +var ender = new TestReadable(); - -var ender = new TestReadable(); // what happens when you pipe() a Readable that's already ended? - -var piper = new TestReadable(); // pushes EOF null, and length=0, so this will trigger 'end' - +// what happens when you pipe() a Readable that's already ended? +var piper = new TestReadable(); +// pushes EOF null, and length=0, so this will trigger 'end' piper.read(); setTimeout(common.mustCall(function () { ender.on('end', common.mustCall()); @@ -119,19 +94,13 @@ setTimeout(common.mustCall(function () { piper.pipe(w); }), 1); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-await-drain-manual-resume.js b/test/parallel/test-stream-pipe-await-drain-manual-resume.js index aacd62cdf7..a5beec5125 100644 --- a/test/parallel/test-stream-pipe-await-drain-manual-resume.js +++ b/test/parallel/test-stream-pipe-await-drain-manual-resume.js @@ -3,36 +3,31 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var stream = require('../../'); +var assert = require('assert/'); -var assert = require('assert/'); // A consumer stream with a very low highWaterMark, which starts in a state +// A consumer stream with a very low highWaterMark, which starts in a state // where it buffers the chunk it receives rather than indicating that they // have been consumed. - - var writable = new stream.Writable({ highWaterMark: 5 }); var isCurrentlyBufferingWrites = true; var queue = []; - writable._write = function (chunk, encoding, cb) { if (isCurrentlyBufferingWrites) queue.push({ chunk: chunk, cb: cb });else cb(); }; - var readable = new stream.Readable({ read: function read() {} }); readable.pipe(writable); readable.once('pause', common.mustCall(function () { - assert.strictEqual(readable._readableState.awaitDrain, 1, 'Expected awaitDrain to equal 1 but instead got ' + "".concat(readable._readableState.awaitDrain)); // First pause, resume manually. The next write() to writable will still + assert.strictEqual(readable._readableState.awaitDrain, 1, 'Expected awaitDrain to equal 1 but instead got ' + "".concat(readable._readableState.awaitDrain)); + // First pause, resume manually. The next write() to writable will still // return false, because chunks are still being buffered, so it will increase // the awaitDrain counter again. @@ -40,61 +35,35 @@ readable.once('pause', common.mustCall(function () { readable.resume(); })); readable.once('pause', common.mustCall(function () { - assert.strictEqual(readable._readableState.awaitDrain, 1, '.resume() should not reset the counter but instead got ' + "".concat(readable._readableState.awaitDrain)); // Second pause, handle all chunks from now on. Once all callbacks that + assert.strictEqual(readable._readableState.awaitDrain, 1, '.resume() should not reset the counter but instead got ' + "".concat(readable._readableState.awaitDrain)); + // Second pause, handle all chunks from now on. Once all callbacks that // are currently queued up are handled, the awaitDrain drain counter should // fall back to 0 and all chunks that are pending on the readable side // should be flushed. - isCurrentlyBufferingWrites = false; - var _iteratorNormalCompletion = true; - var _didIteratorError = false; - var _iteratorError = undefined; - - try { - for (var _iterator = queue[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { - var queued = _step.value; - queued.cb(); - } - } catch (err) { - _didIteratorError = true; - _iteratorError = err; - } finally { - try { - if (!_iteratorNormalCompletion && _iterator.return != null) { - _iterator.return(); - } - } finally { - if (_didIteratorError) { - throw _iteratorError; - } - } + for (var _i = 0, _queue = queue; _i < _queue.length; _i++) { + var queued = _queue[_i]; + queued.cb(); } })); })); readable.push(bufferShim.alloc(100)); // Fill the writable HWM, first 'pause'. - readable.push(bufferShim.alloc(100)); // Second 'pause'. - readable.push(bufferShim.alloc(100)); // Should get through to the writable. - readable.push(null); writable.on('finish', common.mustCall(function () { - assert.strictEqual(readable._readableState.awaitDrain, 0, 'awaitDrain should equal 0 after all chunks are written but instead got' + "".concat(readable._readableState.awaitDrain)); // Everything okay, all chunks were written. + assert.strictEqual(readable._readableState.awaitDrain, 0, 'awaitDrain should equal 0 after all chunks are written but instead got' + "".concat(readable._readableState.awaitDrain)); + // Everything okay, all chunks were written. })); -; +; (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-await-drain-push-while-write.js b/test/parallel/test-stream-pipe-await-drain-push-while-write.js index 9ee200a899..4d845bad3f 100644 --- a/test/parallel/test-stream-pipe-await-drain-push-while-write.js +++ b/test/parallel/test-stream-pipe-await-drain-push-while-write.js @@ -3,35 +3,27 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var stream = require('../../'); - var assert = require('assert/'); - var writable = new stream.Writable({ write: common.mustCall(function (chunk, encoding, cb) { assert.strictEqual(readable._readableState.awaitDrain, 0); - if (chunk.length === 32 * 1024) { // first chunk readable.push(bufferShim.alloc(34 * 1024)); // above hwm // We should check if awaitDrain counter is increased in the next // tick, because awaitDrain is incremented after this method finished - process.nextTick(function () { assert.strictEqual(readable._readableState.awaitDrain, 1); }); } - cb(); }, 3) -}); // A readable stream which produces two buffers. +}); +// A readable stream which produces two buffers. var bufs = [bufferShim.alloc(32 * 1024), bufferShim.alloc(33 * 1024)]; // above hwm - var readable = new stream.Readable({ read: function read() { while (bufs.length > 0) { @@ -41,19 +33,13 @@ var readable = new stream.Readable({ }); readable.pipe(writable); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-await-drain.js b/test/parallel/test-stream-pipe-await-drain.js index f63ae4eeec..ab825cfe3e 100644 --- a/test/parallel/test-stream-pipe-await-drain.js +++ b/test/parallel/test-stream-pipe-await-drain.js @@ -3,26 +3,22 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var stream = require('../../'); +var assert = require('assert/'); -var assert = require('assert/'); // This is very similar to test-stream-pipe-cleanup-pause.js. - +// This is very similar to test-stream-pipe-cleanup-pause.js. var reader = new stream.Readable(); var writer1 = new stream.Writable(); var writer2 = new stream.Writable(); -var writer3 = new stream.Writable(); // 560000 is chosen here because it is larger than the (default) highWaterMark +var writer3 = new stream.Writable(); + +// 560000 is chosen here because it is larger than the (default) highWaterMark // and will cause `.write()` to return false // See: https://github.com/nodejs/node/issues/5820 - var buffer = bufferShim.allocUnsafe(560000); - reader._read = function () {}; - writer1._write = common.mustCall(function (chunk, encoding, cb) { this.emit('chunk-received'); cb(); @@ -34,15 +30,18 @@ writer1.once('chunk-received', function () { // "done" processing. reader.push(buffer); }); -}); // A "slow" consumer: +}); +// A "slow" consumer: writer2._write = common.mustCall(function (chunk, encoding, cb) { - assert.strictEqual(reader._readableState.awaitDrain, 1, 'awaitDrain should be 1 after first push, actual is ' + reader._readableState.awaitDrain); // Not calling cb here to "simulate" slow stream. + assert.strictEqual(reader._readableState.awaitDrain, 1, 'awaitDrain should be 1 after first push, actual is ' + reader._readableState.awaitDrain); + // Not calling cb here to "simulate" slow stream. // This should be called exactly once, since the first .write() call // will return false. }, 1); writer3._write = common.mustCall(function (chunk, encoding, cb) { - assert.strictEqual(reader._readableState.awaitDrain, 2, 'awaitDrain should be 2 after second push, actual is ' + reader._readableState.awaitDrain); // Not calling cb here to "simulate" slow stream. + assert.strictEqual(reader._readableState.awaitDrain, 2, 'awaitDrain should be 2 after second push, actual is ' + reader._readableState.awaitDrain); + // Not calling cb here to "simulate" slow stream. // This should be called exactly once, since the first .write() call // will return false. }, 1); @@ -51,19 +50,13 @@ reader.pipe(writer2); reader.pipe(writer3); reader.push(buffer); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-cleanup-pause.js b/test/parallel/test-stream-pipe-cleanup-pause.js index 8f1e11df82..fb29c536ab 100644 --- a/test/parallel/test-stream-pipe-cleanup-pause.js +++ b/test/parallel/test-stream-pipe-cleanup-pause.js @@ -3,22 +3,17 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var stream = require('../../'); - var reader = new stream.Readable(); var writer1 = new stream.Writable(); -var writer2 = new stream.Writable(); // 560000 is chosen here because it is larger than the (default) highWaterMark +var writer2 = new stream.Writable(); + +// 560000 is chosen here because it is larger than the (default) highWaterMark // and will cause `.write()` to return false // See: https://github.com/nodejs/node/issues/2323 - var buffer = bufferShim.allocUnsafe(560000); - reader._read = function () {}; - writer1._write = common.mustCall(function (chunk, encoding, cb) { this.emit('chunk-received'); cb(); @@ -40,19 +35,13 @@ writer2._write = common.mustCall(function (chunk, encoding, cb) { reader.pipe(writer1); reader.push(buffer); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-cleanup.js b/test/parallel/test-stream-pipe-cleanup.js index a761f38c2e..3f9b2f92cc 100644 --- a/test/parallel/test-stream-pipe-cleanup.js +++ b/test/parallel/test-stream-pipe-cleanup.js @@ -26,98 +26,72 @@ var bufferShim = require('safe-buffer').Buffer; /**/ // This test asserts that Stream.prototype.pipe does not leave listeners // hanging on the source or dest. - - require('../common'); - var stream = require('../../'); - var assert = require('assert/'); - (function () { if (/^v0\.8\./.test(process.version)) return; - function Writable() { this.writable = true; this.endCalls = 0; - require('stream').Stream.call(this); } - Object.setPrototypeOf(Writable.prototype, require('stream').Stream.prototype); Object.setPrototypeOf(Writable, require('stream').Stream); - Writable.prototype.end = function () { this.endCalls++; }; - Writable.prototype.destroy = function () { this.endCalls++; }; - function Readable() { this.readable = true; - require('stream').Stream.call(this); } - Object.setPrototypeOf(Readable.prototype, require('stream').Stream.prototype); Object.setPrototypeOf(Readable, require('stream').Stream); - function Duplex() { this.readable = true; Writable.call(this); } - Object.setPrototypeOf(Duplex.prototype, Writable.prototype); Object.setPrototypeOf(Duplex, Writable); var i = 0; var limit = 100; var w = new Writable(); var r; - for (i = 0; i < limit; i++) { r = new Readable(); r.pipe(w); r.emit('end'); } - assert.strictEqual(r.listeners('end').length, 0); assert.strictEqual(w.endCalls, limit); w.endCalls = 0; - for (i = 0; i < limit; i++) { r = new Readable(); r.pipe(w); r.emit('close'); } - assert.strictEqual(r.listeners('close').length, 0); assert.strictEqual(w.endCalls, limit); w.endCalls = 0; r = new Readable(); - for (i = 0; i < limit; i++) { w = new Writable(); r.pipe(w); w.emit('close'); } - assert.strictEqual(w.listeners('close').length, 0); r = new Readable(); w = new Writable(); var d = new Duplex(); r.pipe(d); // pipeline A - d.pipe(w); // pipeline B - assert.strictEqual(r.listeners('end').length, 2); // A.onend, A.cleanup - assert.strictEqual(r.listeners('close').length, 2); // A.onclose, A.cleanup - assert.strictEqual(d.listeners('end').length, 2); // B.onend, B.cleanup // A.cleanup, B.onclose, B.cleanup - assert.strictEqual(d.listeners('close').length, 3); assert.strictEqual(w.listeners('end').length, 0); assert.strictEqual(w.listeners('close').length, 1); // B.cleanup @@ -128,9 +102,7 @@ var assert = require('assert/'); assert.strictEqual(r.listeners('end').length, 0); assert.strictEqual(r.listeners('close').length, 0); assert.strictEqual(d.listeners('end').length, 2); // B.onend, B.cleanup - assert.strictEqual(d.listeners('close').length, 2); // B.onclose, B.cleanup - assert.strictEqual(w.listeners('end').length, 0); assert.strictEqual(w.listeners('close').length, 1); // B.cleanup @@ -144,19 +116,13 @@ var assert = require('assert/'); assert.strictEqual(w.listeners('end').length, 0); assert.strictEqual(w.listeners('close').length, 0); })(); - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-error-handling.js b/test/parallel/test-stream-pipe-error-handling.js index b86a4d01fb..91275e86ef 100644 --- a/test/parallel/test-stream-pipe-error-handling.js +++ b/test/parallel/test-stream-pipe-error-handling.js @@ -24,14 +24,9 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var Stream = require('stream').Stream; - { var source = new Stream(); var dest = new Stream(); @@ -46,28 +41,23 @@ var Stream = require('stream').Stream; } { var _source = new Stream(); - var _dest = new Stream(); - _source.pipe(_dest); - var _err = new Error('This stream turned into bacon.'); - var _gotErr = null; - try { _source.emit('error', _err); } catch (e) { _gotErr = e; } - assert.strictEqual(_gotErr, _err); } { + var myOnError = function myOnError() { + throw new Error('this should not happen'); + }; var R = require('../../').Readable; - var W = require('../../').Writable; - var r = new R(); var w = new W(); var removed = false; @@ -83,54 +73,34 @@ var Stream = require('stream').Stream; r.pipe(w); w.removeListener('error', myOnError); removed = true; - - function myOnError() { - throw new Error('this should not happen'); - } } { var _R = require('../../').Readable; - var _W = require('../../').Writable; - var _r = new _R(); - var _w = new _W(); - var _removed = false; _r._read = common.mustCall(function () { setTimeout(common.mustCall(function () { assert(_removed); - _w.emit('error', new Error('fail')); }), 1); }); - _w.on('error', common.mustCall()); - _w._write = function () {}; - - _r.pipe(_w); // Removing some OTHER random listener should not do anything - - + _r.pipe(_w); + // Removing some OTHER random listener should not do anything _w.removeListener('error', function () {}); - _removed = true; } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-event.js b/test/parallel/test-stream-pipe-event.js index 43d0ab0971..f1ecf00e3b 100644 --- a/test/parallel/test-stream-pipe-event.js +++ b/test/parallel/test-stream-pipe-event.js @@ -24,29 +24,19 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var stream = require('../../'); - var assert = require('assert/'); - function Writable() { this.writable = true; - require('stream').Stream.call(this); } - Object.setPrototypeOf(Writable.prototype, require('stream').Stream.prototype); Object.setPrototypeOf(Writable, require('stream').Stream); - function Readable() { this.readable = true; - require('stream').Stream.call(this); } - Object.setPrototypeOf(Readable.prototype, require('stream').Stream.prototype); Object.setPrototypeOf(Readable, require('stream').Stream); var passed = false; @@ -58,19 +48,13 @@ var r = new Readable(); r.pipe(w); assert.ok(passed); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-flow-after-unpipe.js b/test/parallel/test-stream-pipe-flow-after-unpipe.js index a87cc937a7..b5bcbf90cd 100644 --- a/test/parallel/test-stream-pipe-flow-after-unpipe.js +++ b/test/parallel/test-stream-pipe-flow-after-unpipe.js @@ -3,15 +3,13 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var _require = require('../../'), - Readable = _require.Readable, - Writable = _require.Writable; // Tests that calling .unpipe() un-blocks a stream that is paused because -// it is waiting on the writable side to finish a write(). + Readable = _require.Readable, + Writable = _require.Writable; +// Tests that calling .unpipe() un-blocks a stream that is paused because +// it is waiting on the writable side to finish a write(). var rs = new Readable({ highWaterMark: 1, @@ -34,21 +32,16 @@ rs.on('data', common.mustCallAtLeast(function () { chunks++; if (chunks >= 20) rs.pause(); // Finish this test. })); + rs.pipe(ws); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-flow.js b/test/parallel/test-stream-pipe-flow.js index f1ba58e46d..87990a0c29 100644 --- a/test/parallel/test-stream-pipe-flow.js +++ b/test/parallel/test-stream-pipe-flow.js @@ -3,15 +3,11 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var _require = require('../../'), - Readable = _require.Readable, - Writable = _require.Writable, - PassThrough = _require.PassThrough; - + Readable = _require.Readable, + Writable = _require.Writable, + PassThrough = _require.PassThrough; { var ticks = 17; var rs = new Readable({ @@ -37,14 +33,12 @@ var _require = require('../../'), } { var missing = 8; - var _rs = new Readable({ objectMode: true, read: function read() { if (missing--) _rs.push({});else _rs.push(null); } }); - var pt = _rs.pipe(new PassThrough({ objectMode: true, highWaterMark: 2 @@ -52,7 +46,6 @@ var _require = require('../../'), objectMode: true, highWaterMark: 2 })); - pt.on('end', function () { wrapper.push(null); }); @@ -61,7 +54,6 @@ var _require = require('../../'), read: function read() { process.nextTick(function () { var data = pt.read(); - if (data === null) { pt.once('readable', function () { data = pt.read(); @@ -77,19 +69,13 @@ var _require = require('../../'), wrapper.on('end', common.mustCall()); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-manual-resume.js b/test/parallel/test-stream-pipe-manual-resume.js index 1ac02b0780..acf9fe5187 100644 --- a/test/parallel/test-stream-pipe-manual-resume.js +++ b/test/parallel/test-stream-pipe-manual-resume.js @@ -3,15 +3,12 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var stream = require('../../'); - function test(throwCodeInbetween) { // Check that a pipe does not stall if .read() is called unexpectedly // (i.e. the stream is not resumed by the pipe). + var n = 1000; var counter = n; var rs = stream.Readable({ @@ -33,7 +30,6 @@ function test(throwCodeInbetween) { }); rs.pipe(ws); } - test(function (rs) { return rs.read(); }); @@ -44,19 +40,13 @@ test(function () { return 0; }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-multiple-pipes.js b/test/parallel/test-stream-pipe-multiple-pipes.js index 011923a043..0e2b42559a 100644 --- a/test/parallel/test-stream-pipe-multiple-pipes.js +++ b/test/parallel/test-stream-pipe-multiple-pipes.js @@ -3,20 +3,14 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var stream = require('../../'); - var assert = require('assert/'); - var readable = new stream.Readable({ read: function read() {} }); var writables = []; - -var _loop = function _loop(i) { +var _loop = function _loop() { var target = new stream.Writable({ write: common.mustCall(function (chunk, encoding, callback) { target.output.push(chunk); @@ -28,86 +22,40 @@ var _loop = function _loop(i) { readable.pipe(target); writables.push(target); }; - for (var i = 0; i < 5; i++) { - _loop(i); + _loop(); } - var input = bufferShim.from([1, 2, 3, 4, 5]); -readable.push(input); // The pipe() calls will postpone emission of the 'resume' event using nextTick, -// so no data will be available to the writable streams until then. +readable.push(input); +// The pipe() calls will postpone emission of the 'resume' event using nextTick, +// so no data will be available to the writable streams until then. process.nextTick(common.mustCall(function () { - var _iteratorNormalCompletion = true; - var _didIteratorError = false; - var _iteratorError = undefined; - - try { - for (var _iterator = writables[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { - var target = _step.value; - assert.deepStrictEqual(target.output, [input]); - target.on('unpipe', common.mustCall()); - readable.unpipe(target); - } - } catch (err) { - _didIteratorError = true; - _iteratorError = err; - } finally { - try { - if (!_iteratorNormalCompletion && _iterator.return != null) { - _iterator.return(); - } - } finally { - if (_didIteratorError) { - throw _iteratorError; - } - } + for (var _i = 0, _writables = writables; _i < _writables.length; _i++) { + var target = _writables[_i]; + assert.deepStrictEqual(target.output, [input]); + target.on('unpipe', common.mustCall()); + readable.unpipe(target); } - readable.push('something else'); // This does not get through. - readable.push(null); readable.resume(); // Make sure the 'end' event gets emitted. })); -readable.on('end', common.mustCall(function () { - var _iteratorNormalCompletion2 = true; - var _didIteratorError2 = false; - var _iteratorError2 = undefined; - try { - for (var _iterator2 = writables[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { - var target = _step2.value; - assert.deepStrictEqual(target.output, [input]); - } - } catch (err) { - _didIteratorError2 = true; - _iteratorError2 = err; - } finally { - try { - if (!_iteratorNormalCompletion2 && _iterator2.return != null) { - _iterator2.return(); - } - } finally { - if (_didIteratorError2) { - throw _iteratorError2; - } - } +readable.on('end', common.mustCall(function () { + for (var _i2 = 0, _writables2 = writables; _i2 < _writables2.length; _i2++) { + var target = _writables2[_i2]; + assert.deepStrictEqual(target.output, [input]); } })); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-same-destination-twice.js b/test/parallel/test-stream-pipe-same-destination-twice.js index cbe6f66ad3..e3b10d3f06 100644 --- a/test/parallel/test-stream-pipe-same-destination-twice.js +++ b/test/parallel/test-stream-pipe-same-destination-twice.js @@ -3,19 +3,15 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ +var common = require('../common'); - -var common = require('../common'); // Regression test for https://github.com/nodejs/node/issues/12718. +// Regression test for https://github.com/nodejs/node/issues/12718. // Tests that piping a source stream twice to the same destination stream // works, and that a subsequent unpipe() call only removes the pipe *once*. - - var assert = require('assert/'); - var _require = require('../../'), - PassThrough = _require.PassThrough, - Writable = _require.Writable; - + PassThrough = _require.PassThrough, + Writable = _require.Writable; { var passThrough = new PassThrough(); var dest = new Writable({ @@ -39,64 +35,45 @@ var _require = require('../../'), } { var _passThrough = new PassThrough(); - var _dest = new Writable({ write: common.mustCall(function (chunk, encoding, cb) { assert.strictEqual("".concat(chunk), 'foobar'); cb(); }, 2) }); - _passThrough.pipe(_dest); - _passThrough.pipe(_dest); - assert.strictEqual(_passThrough._events.data.length, 2); assert.strictEqual(_passThrough._readableState.pipesCount, 2); assert.strictEqual(_passThrough._readableState.pipes[0], _dest); assert.strictEqual(_passThrough._readableState.pipes[1], _dest); - _passThrough.write('foobar'); } { var _passThrough2 = new PassThrough(); - var _dest2 = new Writable({ write: common.mustNotCall() }); - _passThrough2.pipe(_dest2); - _passThrough2.pipe(_dest2); - assert.strictEqual(_passThrough2._events.data.length, 2); assert.strictEqual(_passThrough2._readableState.pipesCount, 2); assert.strictEqual(_passThrough2._readableState.pipes[0], _dest2); assert.strictEqual(_passThrough2._readableState.pipes[1], _dest2); - _passThrough2.unpipe(_dest2); - _passThrough2.unpipe(_dest2); - assert.strictEqual(_passThrough2._events.data, undefined); assert.strictEqual(_passThrough2._readableState.pipesCount, 0); - _passThrough2.write('foobar'); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-unpipe-streams.js b/test/parallel/test-stream-pipe-unpipe-streams.js index 163212c93f..d4175cdc96 100644 --- a/test/parallel/test-stream-pipe-unpipe-streams.js +++ b/test/parallel/test-stream-pipe-unpipe-streams.js @@ -3,16 +3,11 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable, - Writable = _require.Writable; - + Readable = _require.Readable, + Writable = _require.Writable; var source = Readable({ read: function read() {} }); @@ -28,7 +23,9 @@ dest1.on('unpipe', common.mustCall()); dest2.on('unpipe', common.mustCall()); assert.strictEqual(source._readableState.pipes[0], dest1); assert.strictEqual(source._readableState.pipes[1], dest2); -assert.strictEqual(source._readableState.pipes.length, 2); // Should be able to unpipe them in the reverse order that they were piped. +assert.strictEqual(source._readableState.pipes.length, 2); + +// Should be able to unpipe them in the reverse order that they were piped. source.unpipe(dest2); assert.strictEqual(source._readableState.pipes, dest1); @@ -38,19 +35,29 @@ source.unpipe(dest2); source.unpipe(dest1); assert.strictEqual(source._readableState.pipes, null); { + var checkDestCleanup = function checkDestCleanup(dest) { + var currentDestId = ++destCount; + _source.pipe(dest); + var unpipeChecker = common.mustCall(function () { + assert.deepStrictEqual(dest.listeners('unpipe'), [unpipeChecker], "destination{".concat(currentDestId, "} should have a 'unpipe' event ") + 'listener which is `unpipeChecker`'); + dest.removeListener('unpipe', unpipeChecker); + destCheckEventNames.forEach(function (eventName) { + assert.strictEqual(dest.listenerCount(eventName), 0, "destination{".concat(currentDestId, "}'s '").concat(eventName, "' event ") + 'listeners not removed'); + }); + if (--destCount === 0) checkSrcCleanup(); + }); + dest.on('unpipe', unpipeChecker); + }; // test `cleanup()` if we unpipe all streams. var _source = Readable({ read: function read() {} }); - var _dest = Writable({ write: function write() {} }); - var _dest2 = Writable({ write: function write() {} }); - var destCount = 0; var srcCheckEventNames = ['end', 'data']; var destCheckEventNames = ['close', 'finish', 'drain', 'error', 'unpipe']; @@ -62,42 +69,18 @@ assert.strictEqual(source._readableState.pipes, null); assert.strictEqual(_source.listenerCount(eventName), 0, "source's '".concat(eventName, "' event listeners not removed")); }); }); - - function checkDestCleanup(dest) { - var currentDestId = ++destCount; - - _source.pipe(dest); - - var unpipeChecker = common.mustCall(function () { - assert.deepStrictEqual(dest.listeners('unpipe'), [unpipeChecker], "destination{".concat(currentDestId, "} should have a 'unpipe' event ") + 'listener which is `unpipeChecker`'); - dest.removeListener('unpipe', unpipeChecker); - destCheckEventNames.forEach(function (eventName) { - assert.strictEqual(dest.listenerCount(eventName), 0, "destination{".concat(currentDestId, "}'s '").concat(eventName, "' event ") + 'listeners not removed'); - }); - if (--destCount === 0) checkSrcCleanup(); - }); - dest.on('unpipe', unpipeChecker); - } - checkDestCleanup(_dest); checkDestCleanup(_dest2); - _source.unpipe(); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipe-without-listenerCount.js b/test/parallel/test-stream-pipe-without-listenerCount.js index 041218adb7..f06d68e765 100644 --- a/test/parallel/test-stream-pipe-without-listenerCount.js +++ b/test/parallel/test-stream-pipe-without-listenerCount.js @@ -3,12 +3,8 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var stream = require('../../'); - var r = new stream.Stream(); r.listenerCount = undefined; var w = new stream.Stream(); @@ -21,19 +17,13 @@ r.on('error', common.mustCall()); w.on('error', common.mustCall()); r.pipe(w); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipeline-queued-end-in-destroy.js b/test/parallel/test-stream-pipeline-queued-end-in-destroy.js index ea252acd07..2e87bbdb77 100644 --- a/test/parallel/test-stream-pipeline-queued-end-in-destroy.js +++ b/test/parallel/test-stream-pipeline-queued-end-in-destroy.js @@ -3,26 +3,24 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable, - Duplex = _require.Duplex, - pipeline = _require.pipeline; // Test that the callback for pipeline() is called even when the ._destroy() + Readable = _require.Readable, + Duplex = _require.Duplex, + pipeline = _require.pipeline; + +// Test that the callback for pipeline() is called even when the ._destroy() // method of the stream places an .end() request to itself that does not // get processed before the destruction of the stream (i.e. the 'close' event). // Refs: https://github.com/nodejs/node/issues/24456 - var readable = new Readable({ read: common.mustCall(function () {}) }); var duplex = new Duplex({ - write: function write(chunk, enc, cb) {// Simulate messages queueing up. + write: function write(chunk, enc, cb) { + // Simulate messages queueing up. }, read: function read() {}, destroy: function destroy(err, cb) { @@ -35,27 +33,22 @@ var duplex = new Duplex({ duplex.on('finished', common.mustNotCall()); pipeline(readable, duplex, common.mustCall(function (err) { assert.strictEqual(err.code, 'ERR_STREAM_PREMATURE_CLOSE'); -})); // Write one chunk of data, and destroy the stream later. -// That should trigger the pipeline destruction. +})); +// Write one chunk of data, and destroy the stream later. +// That should trigger the pipeline destruction. readable.push('foo'); setImmediate(function () { readable.destroy(); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-pipeline.js b/test/parallel/test-stream-pipeline.js index 686f57027f..85558843c6 100644 --- a/test/parallel/test-stream-pipeline.js +++ b/test/parallel/test-stream-pipeline.js @@ -1,29 +1,21 @@ "use strict"; function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } - function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } - /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var _require = require('../../'), - Stream = _require.Stream, - Writable = _require.Writable, - Readable = _require.Readable, - Transform = _require.Transform, - pipeline = _require.pipeline; - + Stream = _require.Stream, + Writable = _require.Writable, + Readable = _require.Readable, + Transform = _require.Transform, + pipeline = _require.pipeline; var assert = require('assert/'); - var http = require('http'); - var promisify = require('util-promisify'); - { var finished = false; var processed = []; @@ -40,11 +32,9 @@ var promisify = require('util-promisify'); write.on('finish', function () { finished = true; }); - for (var i = 0; i < expected.length; i++) { read.push(expected[i]); } - read.push(null); pipeline(read, write, common.mustCall(function (err) { assert.ok(!err, 'no error'); @@ -56,7 +46,6 @@ var promisify = require('util-promisify'); var _read = new Readable({ read: function read() {} }); - assert.throws(function () { pipeline(_read, function () {}); }, /ERR_MISSING_ARGS/); @@ -71,15 +60,12 @@ var promisify = require('util-promisify'); var _read2 = new Readable({ read: function read() {} }); - var _write = new Writable({ write: function write(data, enc, cb) { cb(); } }); - _read2.push('data'); - setImmediate(function () { return _read2.destroy(); }); @@ -91,15 +77,12 @@ var promisify = require('util-promisify'); var _read3 = new Readable({ read: function read() {} }); - var _write2 = new Writable({ write: function write(data, enc, cb) { cb(); } }); - _read3.push('data'); - setImmediate(function () { return _read3.destroy(new Error('kaboom')); }); @@ -112,31 +95,23 @@ var promisify = require('util-promisify'); var _read4 = new Readable({ read: function read() {} }); - var transform = new Transform({ transform: function transform(data, enc, cb) { process.nextTick(cb, new Error('kaboom')); } }); - var _write3 = new Writable({ write: function write(data, enc, cb) { cb(); } }); - _read4.on('close', common.mustCall()); - transform.on('close', common.mustCall()); - _write3.on('close', common.mustCall()); - var _dst = pipeline(_read4, transform, _write3, common.mustCall(function (err) { assert.strictEqual(err.message, 'kaboom'); })); - assert.strictEqual(_dst, _write3); - _read4.push('hello'); } { @@ -174,7 +149,6 @@ var promisify = require('util-promisify'); if (sent) { return; } - sent = true; rs.push('hello'); }, @@ -185,7 +159,6 @@ var promisify = require('util-promisify'); }); pipeline(rs, res, function () {}); }); - _server.listen(0, function () { var req = http.request({ port: _server.address().port @@ -194,7 +167,6 @@ var promisify = require('util-promisify'); req.on('response', function (res) { setImmediate(function () { res.destroy(); - _server.close(); }); }); @@ -208,7 +180,6 @@ var promisify = require('util-promisify'); if (sent++ > 10) { return; } - rs.push('hello'); }, destroy: common.mustCall(function (err, cb) { @@ -217,7 +188,6 @@ var promisify = require('util-promisify'); }); pipeline(rs, res, function () {}); }); - var cnt = 10; var badSink = new Writable({ write: function write(data, enc, cb) { @@ -225,7 +195,6 @@ var promisify = require('util-promisify'); if (cnt === 0) process.nextTick(cb, new Error('kaboom'));else cb(); } }); - _server2.listen(0, function () { var req = http.request({ port: _server2.address().port @@ -234,7 +203,6 @@ var promisify = require('util-promisify'); req.on('response', function (res) { pipeline(res, badSink, common.mustCall(function (err) { assert.strictEqual(err.message, 'kaboom'); - _server2.close(); })); }); @@ -244,7 +212,6 @@ var promisify = require('util-promisify'); var _server3 = http.createServer(function (req, res) { pipeline(req, res, common.mustCall()); }); - _server3.listen(0, function () { var req = http.request({ port: _server3.address().port @@ -255,7 +222,6 @@ var promisify = require('util-promisify'); if (sent++ > 10) { return; } - rs.push('hello'); } }); @@ -281,7 +247,6 @@ var promisify = require('util-promisify'); tr.on('close', common.mustCall()); return tr; }; - var rs = new Readable({ read: function read() { rs.push('hello'); @@ -303,43 +268,33 @@ var promisify = require('util-promisify'); } { var oldStream = new Stream(); - oldStream.pause = oldStream.resume = function () {}; - oldStream.write = function (data) { oldStream.emit('data', data); return true; }; - oldStream.end = function () { oldStream.emit('end'); }; - var _expected = [bufferShim.from('hello'), bufferShim.from('world')]; - var _rs = new Readable({ read: function read() { for (var _i = 0; _i < _expected.length; _i++) { _rs.push(_expected[_i]); } - _rs.push(null); } }); - var _ws = new Writable({ write: function write(data, enc, cb) { assert.deepStrictEqual(data, _expected.shift()); cb(); } }); - var _finished = false; - _ws.on('finish', function () { _finished = true; }); - pipeline(_rs, oldStream, _ws, common.mustCall(function (err) { assert(!err, 'no error'); assert(_finished, 'last stream finished'); @@ -347,68 +302,48 @@ var promisify = require('util-promisify'); } { var _oldStream = new Stream(); - _oldStream.pause = _oldStream.resume = function () {}; - _oldStream.write = function (data) { _oldStream.emit('data', data); - return true; }; - _oldStream.end = function () { _oldStream.emit('end'); }; - var destroyableOldStream = new Stream(); - destroyableOldStream.pause = destroyableOldStream.resume = function () {}; - destroyableOldStream.destroy = common.mustCall(function () { destroyableOldStream.emit('close'); }); - destroyableOldStream.write = function (data) { destroyableOldStream.emit('data', data); return true; }; - destroyableOldStream.end = function () { destroyableOldStream.emit('end'); }; - var _rs2 = new Readable({ read: function read() { _rs2.destroy(new Error('stop')); } }); - var _ws2 = new Writable({ write: function write(data, enc, cb) { cb(); } }); - var _finished2 = false; - _ws2.on('finish', function () { _finished2 = true; }); - pipeline(_rs2, _oldStream, destroyableOldStream, _ws2, common.mustCall(function (err) { assert.deepStrictEqual(err, new Error('stop')); assert(!_finished2, 'should not finish'); })); } { - var pipelinePromise = promisify(pipeline); - - function run() { - return _run.apply(this, arguments); - } - - function _run() { - _run = _asyncToGenerator(function* () { + var run = /*#__PURE__*/function () { + var _ref = _asyncToGenerator(function* () { var read = new Readable({ read: function read() {} }); @@ -426,58 +361,45 @@ var promisify = require('util-promisify'); yield pipelinePromise(read, write); assert(finished); }); - return _run.apply(this, arguments); - } - + return function run() { + return _ref.apply(this, arguments); + }; + }(); + var pipelinePromise = promisify(pipeline); run(); } { var _read5 = new Readable({ read: function read() {} }); - var _transform = new Transform({ transform: function transform(data, enc, cb) { process.nextTick(cb, new Error('kaboom')); } }); - var _write4 = new Writable({ write: function write(data, enc, cb) { cb(); } }); - _read5.on('close', common.mustCall()); - _transform.on('close', common.mustCall()); - _write4.on('close', common.mustCall()); - process.on('uncaughtException', common.mustCall(function (err) { assert.strictEqual(err.message, 'kaboom'); })); - var _dst2 = pipeline(_read5, _transform, _write4); - assert.strictEqual(_dst2, _write4); - _read5.push('hello'); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-push-order.js b/test/parallel/test-stream-push-order.js index 4dd13be724..76766cba67 100644 --- a/test/parallel/test-stream-push-order.js +++ b/test/parallel/test-stream-push-order.js @@ -24,23 +24,16 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var Readable = require('../../').Readable; - var assert = require('assert/'); - var s = new Readable({ highWaterMark: 20, encoding: 'ascii' }); var list = ['1', '2', '3', '4', '5', '6']; - s._read = function (n) { var one = list.shift(); - if (!one) { s.push(null); } else { @@ -49,28 +42,22 @@ s._read = function (n) { s.push(two); } }; +s.read(0); -s.read(0); // ACTUALLY [1, 3, 5, 6, 4, 2] +// ACTUALLY [1, 3, 5, 6, 4, 2] process.on('exit', function () { assert.deepStrictEqual(s.readableBuffer.join(','), '1,2,3,4,5,6'); - require('tap').pass(); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-push-strings.js b/test/parallel/test-stream-push-strings.js index f2555d6241..a98b06ed44 100644 --- a/test/parallel/test-stream-push-strings.js +++ b/test/parallel/test-stream-push-strings.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -40,90 +36,63 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var Readable = require('../../').Readable; - -var MyStream = -/*#__PURE__*/ -function (_Readable) { +var MyStream = /*#__PURE__*/function (_Readable) { _inherits(MyStream, _Readable); - + var _super = _createSuper(MyStream); function MyStream(options) { var _this; - _classCallCheck(this, MyStream); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(MyStream).call(this, options)); + _this = _super.call(this, options); _this._chunks = 3; return _this; } - _createClass(MyStream, [{ key: "_read", value: function _read(n) { var _this2 = this; - switch (this._chunks--) { case 0: return this.push(null); - case 1: return setTimeout(function () { _this2.push('last chunk'); }, 100); - case 2: return this.push('second to last chunk'); - case 3: return process.nextTick(function () { _this2.push('first chunk'); }); - default: throw new Error('?'); } } }]); - return MyStream; }(Readable); - var ms = new MyStream(); var results = []; ms.on('readable', function () { var chunk; - - while (null !== (chunk = ms.read())) { - results.push(String(chunk)); - } + while (null !== (chunk = ms.read())) results.push(String(chunk)); }); var expect = ['first chunksecond to last chunk', 'last chunk']; process.on('exit', function () { assert.strictEqual(ms._chunks, -1); assert.deepStrictEqual(results, expect); - require('tap').pass(); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-async-iterators.js b/test/parallel/test-stream-readable-async-iterators.js index d97cb866bc..1394f71854 100644 --- a/test/parallel/test-stream-readable-async-iterators.js +++ b/test/parallel/test-stream-readable-async-iterators.js @@ -1,30 +1,22 @@ "use strict"; function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } - function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } - -function _asyncIterator(iterable) { var method; if (typeof Symbol !== "undefined") { if (Symbol.asyncIterator) { method = iterable[Symbol.asyncIterator]; if (method != null) return method.call(iterable); } if (Symbol.iterator) { method = iterable[Symbol.iterator]; if (method != null) return method.call(iterable); } } throw new TypeError("Object is not async iterable"); } - +function _asyncIterator(iterable) { var method, async, sync, retry = 2; for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) { if (async && null != (method = iterable[async])) return method.call(iterable); if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable)); async = "@@asyncIterator", sync = "@@iterator"; } throw new TypeError("Object is not async iterable"); } +function AsyncFromSyncIterator(s) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var done = r.done; return Promise.resolve(r.value).then(function (value) { return { value: value, done: done }; }); } return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) { this.s = s, this.n = s.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, return: function _return(value) { var ret = this.s.return; return void 0 === ret ? Promise.resolve({ value: value, done: !0 }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments)); }, throw: function _throw(value) { var thr = this.s.return; return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(s); } /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var _require = require('../../'), - Readable = _require.Readable, - PassThrough = _require.PassThrough, - pipeline = _require.pipeline; - + Readable = _require.Readable, + PassThrough = _require.PassThrough, + pipeline = _require.pipeline; var assert = require('assert/'); - function tests() { return _tests.apply(this, arguments); } // to avoid missing some tests if a promise does not resolve - - function _tests() { _tests = _asyncToGenerator(function* () { { @@ -42,22 +34,22 @@ function _tests() { readable.push(null); var iter = readable[Symbol.asyncIterator](); assert.strictEqual((yield iter.next()).value, 0); - var _iteratorNormalCompletion = true; + var _iteratorAbruptCompletion = false; var _didIteratorError = false; - var _iteratorError; - try { - for (var _iterator = _asyncIterator(iter), _step, _value; _step = yield _iterator.next(), _iteratorNormalCompletion = _step.done, _value = yield _step.value, !_iteratorNormalCompletion; _iteratorNormalCompletion = true) { - var d = _value; - assert.strictEqual(d, 1); + for (var _iterator = _asyncIterator(iter), _step; _iteratorAbruptCompletion = !(_step = yield _iterator.next()).done; _iteratorAbruptCompletion = false) { + var d = _step.value; + { + assert.strictEqual(d, 1); + } } } catch (err) { _didIteratorError = true; _iteratorError = err; } finally { try { - if (!_iteratorNormalCompletion && _iterator.return != null) { + if (_iteratorAbruptCompletion && _iterator.return != null) { yield _iterator.return(); } } finally { @@ -70,122 +62,85 @@ function _tests() { { console.log('read without for..await'); var max = 5; - var _readable = new Readable({ objectMode: true, read: function read() {} }); - var _iter = _readable[Symbol.asyncIterator](); - assert.strictEqual(_iter.stream, _readable); var values = []; - for (var i = 0; i < max; i++) { values.push(_iter.next()); } - Promise.all(values).then(common.mustCall(function (values) { values.forEach(common.mustCall(function (item, i) { return assert.strictEqual(item.value, 'hello-' + i); }, 5)); })); - _readable.push('hello-0'); - _readable.push('hello-1'); - _readable.push('hello-2'); - _readable.push('hello-3'); - _readable.push('hello-4'); - _readable.push(null); - var last = yield _iter.next(); assert.strictEqual(last.done, true); } { console.log('read without for..await deferred'); - var _readable2 = new Readable({ objectMode: true, read: function read() {} }); - var _iter2 = _readable2[Symbol.asyncIterator](); - assert.strictEqual(_iter2.stream, _readable2); var _values = []; - for (var _i = 0; _i < 3; _i++) { _values.push(_iter2.next()); } - _readable2.push('hello-0'); - _readable2.push('hello-1'); - _readable2.push('hello-2'); - var k = 0; var results1 = yield Promise.all(_values); results1.forEach(common.mustCall(function (item) { return assert.strictEqual(item.value, 'hello-' + k++); }, 3)); _values = []; - for (var _i2 = 0; _i2 < 2; _i2++) { _values.push(_iter2.next()); } - _readable2.push('hello-3'); - _readable2.push('hello-4'); - _readable2.push(null); - var results2 = yield Promise.all(_values); results2.forEach(common.mustCall(function (item) { return assert.strictEqual(item.value, 'hello-' + k++); }, 2)); - var _last = yield _iter2.next(); - assert.strictEqual(_last.done, true); } { console.log('read without for..await with errors'); var _max = 3; - var _readable3 = new Readable({ objectMode: true, read: function read() {} }); - var _iter3 = _readable3[Symbol.asyncIterator](); - assert.strictEqual(_iter3.stream, _readable3); var _values2 = []; var errors = []; - var _i3; - for (_i3 = 0; _i3 < _max; _i3++) { _values2.push(_iter3.next()); } - for (_i3 = 0; _i3 < 2; _i3++) { errors.push(_iter3.next()); } - _readable3.push('hello-0'); - _readable3.push('hello-1'); - _readable3.push('hello-2'); - var resolved = yield Promise.all(_values2); resolved.forEach(common.mustCall(function (item, i) { return assert.strictEqual(item.value, 'hello-' + i); @@ -195,22 +150,16 @@ function _tests() { assert.strictEqual(err.message, 'kaboom'); })); }); - _readable3.destroy(new Error('kaboom')); } { console.log('call next() after error'); - var _readable4 = new Readable({ read: function read() {} }); - var iterator = _readable4[Symbol.asyncIterator](); - var err = new Error('kaboom'); - _readable4.destroy(new Error('kaboom')); - yield function (f, e) { var success = false; f().then(function () { @@ -220,7 +169,6 @@ function _tests() { if (success) { throw e2; } - assert.strictEqual(e.message, e2.message); }); }(iterator.next.bind(iterator), err); @@ -230,35 +178,32 @@ function _tests() { var _max2 = 42; var readed = 0; var received = 0; - var _readable5 = new Readable({ objectMode: true, read: function read() { this.push('hello'); - if (++readed === _max2) { this.push(null); } } }); - - var _iteratorNormalCompletion2 = true; + var _iteratorAbruptCompletion2 = false; var _didIteratorError2 = false; - var _iteratorError2; - try { - for (var _iterator2 = _asyncIterator(_readable5), _step2, _value2; _step2 = yield _iterator2.next(), _iteratorNormalCompletion2 = _step2.done, _value2 = yield _step2.value, !_iteratorNormalCompletion2; _iteratorNormalCompletion2 = true) { - var _k = _value2; - received++; - assert.strictEqual(_k, 'hello'); + for (var _iterator2 = _asyncIterator(_readable5), _step2; _iteratorAbruptCompletion2 = !(_step2 = yield _iterator2.next()).done; _iteratorAbruptCompletion2 = false) { + var _k = _step2.value; + { + received++; + assert.strictEqual(_k, 'hello'); + } } } catch (err) { _didIteratorError2 = true; _iteratorError2 = err; } finally { try { - if (!_iteratorNormalCompletion2 && _iterator2.return != null) { + if (_iteratorAbruptCompletion2 && _iterator2.return != null) { yield _iterator2.return(); } } finally { @@ -267,38 +212,32 @@ function _tests() { } } } - assert.strictEqual(readed, received); } { console.log('destroy sync'); - var _readable6 = new Readable({ objectMode: true, read: function read() { this.destroy(new Error('kaboom from read')); } }); - var _err; - try { // eslint-disable-next-line no-unused-vars - var _iteratorNormalCompletion3 = true; + var _iteratorAbruptCompletion3 = false; var _didIteratorError3 = false; - var _iteratorError3; - try { - for (var _iterator3 = _asyncIterator(_readable6), _step3, _value3; _step3 = yield _iterator3.next(), _iteratorNormalCompletion3 = _step3.done, _value3 = yield _step3.value, !_iteratorNormalCompletion3; _iteratorNormalCompletion3 = true) { - var _k2 = _value3; + for (var _iterator3 = _asyncIterator(_readable6), _step3; _iteratorAbruptCompletion3 = !(_step3 = yield _iterator3.next()).done; _iteratorAbruptCompletion3 = false) { + var _k2 = _step3.value; } } catch (err) { _didIteratorError3 = true; _iteratorError3 = err; } finally { try { - if (!_iteratorNormalCompletion3 && _iterator3.return != null) { + if (_iteratorAbruptCompletion3 && _iterator3.return != null) { yield _iterator3.return(); } } finally { @@ -310,17 +249,14 @@ function _tests() { } catch (e) { _err = e; } - assert.strictEqual(_err.message, 'kaboom from read'); } { console.log('destroy async'); - var _readable7 = new Readable({ objectMode: true, read: function read() { var _this = this; - if (!this.pushed) { this.push('hello'); this.pushed = true; @@ -330,28 +266,26 @@ function _tests() { } } }); - var _received = 0; var _err2 = null; - try { // eslint-disable-next-line no-unused-vars - var _iteratorNormalCompletion4 = true; + var _iteratorAbruptCompletion4 = false; var _didIteratorError4 = false; - var _iteratorError4; - try { - for (var _iterator4 = _asyncIterator(_readable7), _step4, _value4; _step4 = yield _iterator4.next(), _iteratorNormalCompletion4 = _step4.done, _value4 = yield _step4.value, !_iteratorNormalCompletion4; _iteratorNormalCompletion4 = true) { - var _k3 = _value4; - _received++; + for (var _iterator4 = _asyncIterator(_readable7), _step4; _iteratorAbruptCompletion4 = !(_step4 = yield _iterator4.next()).done; _iteratorAbruptCompletion4 = false) { + var _k3 = _step4.value; + { + _received++; + } } } catch (err) { _didIteratorError4 = true; _iteratorError4 = err; } finally { try { - if (!_iteratorNormalCompletion4 && _iterator4.return != null) { + if (_iteratorAbruptCompletion4 && _iterator4.return != null) { yield _iterator4.return(); } } finally { @@ -363,40 +297,36 @@ function _tests() { } catch (e) { _err2 = e; } - assert.strictEqual(_err2.message, 'kaboom'); assert.strictEqual(_received, 1); } { console.log('destroyed by throw'); - var _readable8 = new Readable({ objectMode: true, read: function read() { this.push('hello'); } }); - var _err3 = null; - try { - var _iteratorNormalCompletion5 = true; + var _iteratorAbruptCompletion5 = false; var _didIteratorError5 = false; - var _iteratorError5; - try { - for (var _iterator5 = _asyncIterator(_readable8), _step5, _value5; _step5 = yield _iterator5.next(), _iteratorNormalCompletion5 = _step5.done, _value5 = yield _step5.value, !_iteratorNormalCompletion5; _iteratorNormalCompletion5 = true) { - var _k4 = _value5; - assert.strictEqual(_k4, 'hello'); - throw new Error('kaboom'); + for (var _iterator5 = _asyncIterator(_readable8), _step5; _iteratorAbruptCompletion5 = !(_step5 = yield _iterator5.next()).done; _iteratorAbruptCompletion5 = false) { + var _k4 = _step5.value; + { + assert.strictEqual(_k4, 'hello'); + throw new Error('kaboom'); + } } } catch (err) { _didIteratorError5 = true; _iteratorError5 = err; } finally { try { - if (!_iteratorNormalCompletion5 && _iterator5.return != null) { + if (_iteratorAbruptCompletion5 && _iterator5.return != null) { yield _iterator5.return(); } } finally { @@ -408,13 +338,11 @@ function _tests() { } catch (e) { _err3 = e; } - assert.strictEqual(_err3.message, 'kaboom'); assert.strictEqual(_readable8.destroyed, true); } { console.log('destroyed sync after push'); - var _readable9 = new Readable({ objectMode: true, read: function read() { @@ -422,28 +350,26 @@ function _tests() { this.destroy(new Error('kaboom')); } }); - var _received2 = 0; var _err4 = null; - try { - var _iteratorNormalCompletion6 = true; + var _iteratorAbruptCompletion6 = false; var _didIteratorError6 = false; - var _iteratorError6; - try { - for (var _iterator6 = _asyncIterator(_readable9), _step6, _value6; _step6 = yield _iterator6.next(), _iteratorNormalCompletion6 = _step6.done, _value6 = yield _step6.value, !_iteratorNormalCompletion6; _iteratorNormalCompletion6 = true) { - var _k5 = _value6; - assert.strictEqual(_k5, 'hello'); - _received2++; + for (var _iterator6 = _asyncIterator(_readable9), _step6; _iteratorAbruptCompletion6 = !(_step6 = yield _iterator6.next()).done; _iteratorAbruptCompletion6 = false) { + var _k5 = _step6.value; + { + assert.strictEqual(_k5, 'hello'); + _received2++; + } } } catch (err) { _didIteratorError6 = true; _iteratorError6 = err; } finally { try { - if (!_iteratorNormalCompletion6 && _iterator6.return != null) { + if (_iteratorAbruptCompletion6 && _iterator6.return != null) { yield _iterator6.return(); } } finally { @@ -455,7 +381,6 @@ function _tests() { } catch (e) { _err4 = e; } - assert.strictEqual(_err4.message, 'kaboom'); assert.strictEqual(_received2, 1); } @@ -464,39 +389,35 @@ function _tests() { var _max3 = 42; var _readed = 0; var _received3 = 0; - var _readable10 = new Readable({ objectMode: true, read: function read() { var _this2 = this; - setImmediate(function () { _this2.push('hello'); - if (++_readed === _max3) { _this2.push(null); } }); } }); - - var _iteratorNormalCompletion7 = true; + var _iteratorAbruptCompletion7 = false; var _didIteratorError7 = false; - var _iteratorError7; - try { - for (var _iterator7 = _asyncIterator(_readable10), _step7, _value7; _step7 = yield _iterator7.next(), _iteratorNormalCompletion7 = _step7.done, _value7 = yield _step7.value, !_iteratorNormalCompletion7; _iteratorNormalCompletion7 = true) { - var _k6 = _value7; - _received3++; - assert.strictEqual(_k6, 'hello'); + for (var _iterator7 = _asyncIterator(_readable10), _step7; _iteratorAbruptCompletion7 = !(_step7 = yield _iterator7.next()).done; _iteratorAbruptCompletion7 = false) { + var _k6 = _step7.value; + { + _received3++; + assert.strictEqual(_k6, 'hello'); + } } } catch (err) { _didIteratorError7 = true; _iteratorError7 = err; } finally { try { - if (!_iteratorNormalCompletion7 && _iterator7.return != null) { + if (_iteratorAbruptCompletion7 && _iterator7.return != null) { yield _iterator7.return(); } } finally { @@ -505,55 +426,46 @@ function _tests() { } } } - assert.strictEqual(_readed, _received3); } { console.log('push binary async'); var _max4 = 42; var _readed2 = 0; - var _readable11 = new Readable({ read: function read() { var _this3 = this; - setImmediate(function () { _this3.push('hello'); - if (++_readed2 === _max4) { _this3.push(null); } }); } }); - var expected = ''; - _readable11.setEncoding('utf8'); - _readable11.pause(); - _readable11.on('data', function (chunk) { expected += chunk; }); - var data = ''; - var _iteratorNormalCompletion8 = true; + var _iteratorAbruptCompletion8 = false; var _didIteratorError8 = false; - var _iteratorError8; - try { - for (var _iterator8 = _asyncIterator(_readable11), _step8, _value8; _step8 = yield _iterator8.next(), _iteratorNormalCompletion8 = _step8.done, _value8 = yield _step8.value, !_iteratorNormalCompletion8; _iteratorNormalCompletion8 = true) { - var _k7 = _value8; - data += _k7; + for (var _iterator8 = _asyncIterator(_readable11), _step8; _iteratorAbruptCompletion8 = !(_step8 = yield _iterator8.next()).done; _iteratorAbruptCompletion8 = false) { + var _k7 = _step8.value; + { + data += _k7; + } } } catch (err) { _didIteratorError8 = true; _iteratorError8 = err; } finally { try { - if (!_iteratorNormalCompletion8 && _iterator8.return != null) { + if (_iteratorAbruptCompletion8 && _iterator8.return != null) { yield _iterator8.return(); } } finally { @@ -562,42 +474,33 @@ function _tests() { } } } - assert.strictEqual(data, expected); } { console.log('.next() on destroyed stream'); - var _readable12 = new Readable({ - read: function read() {// no-op + read: function read() { + // no-op } }); - _readable12.destroy(); - - var _ref = yield _readable12[Symbol.asyncIterator]().next(), - done = _ref.done; - + var _yield$_readable12$Sy = yield _readable12[Symbol.asyncIterator]().next(), + done = _yield$_readable12$Sy.done; assert.strictEqual(done, true); } { console.log('.next() on pipelined stream'); - var _readable13 = new Readable({ - read: function read() {// no-op + read: function read() { + // no-op } }); - var passthrough = new PassThrough(); - var _err5 = new Error('kaboom'); - pipeline(_readable13, passthrough, common.mustCall(function (e) { assert.strictEqual(e, _err5); })); - _readable13.destroy(_err5); - try { yield _readable13[Symbol.asyncIterator]().next(); } catch (e) { @@ -613,24 +516,22 @@ function _tests() { this.push('hehe'); this.push(null); } - }); // eslint-disable-next-line no-unused-vars - - var _iteratorNormalCompletion9 = true; + }); + // eslint-disable-next-line no-unused-vars + var _iteratorAbruptCompletion9 = false; var _didIteratorError9 = false; - var _iteratorError9; - try { - for (var _iterator9 = _asyncIterator(r), _step9, _value9; _step9 = yield _iterator9.next(), _iteratorNormalCompletion9 = _step9.done, _value9 = yield _step9.value, !_iteratorNormalCompletion9; _iteratorNormalCompletion9 = true) { - var a = _value9; - } // eslint-disable-next-line no-unused-vars - + for (var _iterator9 = _asyncIterator(r), _step9; _iteratorAbruptCompletion9 = !(_step9 = yield _iterator9.next()).done; _iteratorAbruptCompletion9 = false) { + var a = _step9.value; + } + // eslint-disable-next-line no-unused-vars } catch (err) { _didIteratorError9 = true; _iteratorError9 = err; } finally { try { - if (!_iteratorNormalCompletion9 && _iterator9.return != null) { + if (_iteratorAbruptCompletion9 && _iterator9.return != null) { yield _iterator9.return(); } } finally { @@ -639,22 +540,19 @@ function _tests() { } } } - - var _iteratorNormalCompletion10 = true; + var _iteratorAbruptCompletion10 = false; var _didIteratorError10 = false; - var _iteratorError10; - try { - for (var _iterator10 = _asyncIterator(r), _step10, _value10; _step10 = yield _iterator10.next(), _iteratorNormalCompletion10 = _step10.done, _value10 = yield _step10.value, !_iteratorNormalCompletion10; _iteratorNormalCompletion10 = true) { - var b = _value10; + for (var _iterator10 = _asyncIterator(r), _step10; _iteratorAbruptCompletion10 = !(_step10 = yield _iterator10.next()).done; _iteratorAbruptCompletion10 = false) { + var b = _step10.value; } } catch (err) { _didIteratorError10 = true; _iteratorError10 = err; } finally { try { - if (!_iteratorNormalCompletion10 && _iterator10.return != null) { + if (_iteratorAbruptCompletion10 && _iterator10.return != null) { yield _iterator10.return(); } } finally { @@ -666,33 +564,31 @@ function _tests() { } { console.log('destroy mid-stream does not error'); - var _r = new Readable({ objectMode: true, read: function read() { this.push('asdf'); this.push('hehe'); } - }); // eslint-disable-next-line no-unused-vars - + }); - var _iteratorNormalCompletion11 = true; + // eslint-disable-next-line no-unused-vars + var _iteratorAbruptCompletion11 = false; var _didIteratorError11 = false; - var _iteratorError11; - try { - for (var _iterator11 = _asyncIterator(_r), _step11, _value11; _step11 = yield _iterator11.next(), _iteratorNormalCompletion11 = _step11.done, _value11 = yield _step11.value, !_iteratorNormalCompletion11; _iteratorNormalCompletion11 = true) { - var _a = _value11; - - _r.destroy(null); + for (var _iterator11 = _asyncIterator(_r), _step11; _iteratorAbruptCompletion11 = !(_step11 = yield _iterator11.next()).done; _iteratorAbruptCompletion11 = false) { + var _a = _step11.value; + { + _r.destroy(null); + } } } catch (err) { _didIteratorError11 = true; _iteratorError11 = err; } finally { try { - if (!_iteratorNormalCompletion11 && _iterator11.return != null) { + if (_iteratorAbruptCompletion11 && _iterator11.return != null) { yield _iterator11.return(); } } finally { @@ -704,113 +600,83 @@ function _tests() { } { console.log('all next promises must be resolved on end'); - var _r2 = new Readable({ objectMode: true, read: function read() {} }); - var _b = _r2[Symbol.asyncIterator](); - var c = _b.next(); - var _d = _b.next(); - _r2.push(null); - - assert.deepStrictEqual((yield c), { + assert.deepStrictEqual(yield c, { done: true, value: undefined }); - assert.deepStrictEqual((yield _d), { + assert.deepStrictEqual(yield _d, { done: true, value: undefined }); } { console.log('all next promises must be resolved on destroy'); - var _r3 = new Readable({ objectMode: true, read: function read() {} }); - var _b2 = _r3[Symbol.asyncIterator](); - var _c = _b2.next(); - var _d2 = _b2.next(); - _r3.destroy(); - - assert.deepStrictEqual((yield _c), { + assert.deepStrictEqual(yield _c, { done: true, value: undefined }); - assert.deepStrictEqual((yield _d2), { + assert.deepStrictEqual(yield _d2, { done: true, value: undefined }); } { console.log('all next promises must be resolved on destroy with error'); - var _r4 = new Readable({ objectMode: true, read: function read() {} }); - var _b3 = _r4[Symbol.asyncIterator](); - var _c2 = _b3.next(); - var _d3 = _b3.next(); - var _err6 = new Error('kaboom'); - _r4.destroy(_err6); - yield Promise.all([_asyncToGenerator(function* () { var e; - try { yield _c2; } catch (_e) { e = _e; } - assert.strictEqual(e, _err6); })(), _asyncToGenerator(function* () { var e; - try { yield _d3; } catch (_e) { e = _e; } - assert.strictEqual(e, _err6); })()]); } }); return _tests.apply(this, arguments); } - tests().then(common.mustCall(), common.mustNotCall(console.log)); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-constructor-set-methods.js b/test/parallel/test-stream-readable-constructor-set-methods.js index d8f683dd2f..6f7ea6f245 100644 --- a/test/parallel/test-stream-readable-constructor-set-methods.js +++ b/test/parallel/test-stream-readable-constructor-set-methods.js @@ -3,34 +3,23 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var Readable = require('../../').Readable; - var _read = common.mustCall(function _read(n) { this.push(null); }); - var r = new Readable({ read: _read }); r.resume(); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-destroy.js b/test/parallel/test-stream-readable-destroy.js index 439476ab33..79192adfb6 100644 --- a/test/parallel/test-stream-readable-destroy.js +++ b/test/parallel/test-stream-readable-destroy.js @@ -4,14 +4,10 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var _require = require('../../'), - Readable = _require.Readable; - + Readable = _require.Readable; var assert = require('assert/'); - { var read = new Readable({ read: function read() {} @@ -25,45 +21,31 @@ var assert = require('assert/'); var _read = new Readable({ read: function read() {} }); - _read.resume(); - var expected = new Error('kaboom'); - _read.on('end', common.mustNotCall('no end event')); - _read.on('close', common.mustCall()); - _read.on('error', common.mustCall(function (err) { assert.strictEqual(err, expected); })); - _read.destroy(expected); - assert.strictEqual(_read.destroyed, true); } { var _read2 = new Readable({ read: function read() {} }); - _read2._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, _expected); cb(err); }); - var _expected = new Error('kaboom'); - _read2.on('end', common.mustNotCall('no end event')); - _read2.on('close', common.mustCall()); - _read2.on('error', common.mustCall(function (err) { assert.strictEqual(err, _expected); })); - _read2.destroy(_expected); - assert.strictEqual(_read2.destroyed, true); } { @@ -74,108 +56,81 @@ var assert = require('assert/'); cb(); }) }); - var _expected2 = new Error('kaboom'); + _read3.on('end', common.mustNotCall('no end event')); - _read3.on('end', common.mustNotCall('no end event')); // error is swallowed by the custom _destroy - - + // error is swallowed by the custom _destroy _read3.on('error', common.mustNotCall('no error event')); - _read3.on('close', common.mustCall()); - _read3.destroy(_expected2); - assert.strictEqual(_read3.destroyed, true); } { var _read4 = new Readable({ read: function read() {} }); - _read4._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, null); cb(); }); - _read4.destroy(); - assert.strictEqual(_read4.destroyed, true); } { var _read5 = new Readable({ read: function read() {} }); - _read5.resume(); - _read5._destroy = common.mustCall(function (err, cb) { var _this = this; - assert.strictEqual(err, null); process.nextTick(function () { _this.push(null); - cb(); }); }); var fail = common.mustNotCall('no end event'); - _read5.on('end', fail); - _read5.on('close', common.mustCall()); - _read5.destroy(); - _read5.removeListener('end', fail); - _read5.on('end', common.mustCall()); - assert.strictEqual(_read5.destroyed, true); } { var _read6 = new Readable({ read: function read() {} }); - var _expected3 = new Error('kaboom'); - _read6._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, null); cb(_expected3); }); - _read6.on('end', common.mustNotCall('no end event')); - _read6.on('error', common.mustCall(function (err) { assert.strictEqual(err, _expected3); })); - _read6.destroy(); - assert.strictEqual(_read6.destroyed, true); } { var _read7 = new Readable({ read: function read() {} }); - _read7.resume(); - _read7.destroyed = true; - assert.strictEqual(_read7.destroyed, true); // the internal destroy() mechanism should not be triggered + assert.strictEqual(_read7.destroyed, true); + // the internal destroy() mechanism should not be triggered _read7.on('end', common.mustNotCall()); - _read7.destroy(); } { - function MyReadable() { + var MyReadable = function MyReadable() { assert.strictEqual(this.destroyed, false); this.destroyed = false; Readable.call(this); - } - + }; Object.setPrototypeOf(MyReadable.prototype, Readable.prototype); Object.setPrototypeOf(MyReadable, Readable); new MyReadable(); @@ -185,13 +140,9 @@ var assert = require('assert/'); var _read8 = new Readable({ read: function read() {} }); - _read8.resume(); - var _expected4 = new Error('kaboom'); - _read8.on('close', common.mustCall()); - _read8.destroy(_expected4, common.mustCall(function (err) { assert.strictEqual(err, _expected4); })); @@ -200,27 +151,18 @@ var assert = require('assert/'); var _read9 = new Readable({ read: function read() {} }); - _read9.destroy(); - _read9.push('hi'); - _read9.on('data', common.mustNotCall()); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-emittedReadable.js b/test/parallel/test-stream-readable-emittedReadable.js index d08ffce14b..2feda840bb 100644 --- a/test/parallel/test-stream-readable-emittedReadable.js +++ b/test/parallel/test-stream-readable-emittedReadable.js @@ -3,38 +3,37 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var Readable = require('../../').Readable; - var readable = new Readable({ read: function read() {} -}); // Initialized to false. +}); +// Initialized to false. assert.strictEqual(readable._readableState.emittedReadable, false); var expected = [bufferShim.from('foobar'), bufferShim.from('quo'), null]; readable.on('readable', common.mustCall(function () { // emittedReadable should be true when the readable event is emitted assert.strictEqual(readable._readableState.emittedReadable, true); - assert.deepStrictEqual(readable.read(), expected.shift()); // emittedReadable is reset to false during read() - + assert.deepStrictEqual(readable.read(), expected.shift()); + // emittedReadable is reset to false during read() assert.strictEqual(readable._readableState.emittedReadable, false); -}, 3)); // When the first readable listener is just attached, -// emittedReadable should be false +}, 3)); -assert.strictEqual(readable._readableState.emittedReadable, false); // These trigger a single 'readable', as things are batched up +// When the first readable listener is just attached, +// emittedReadable should be false +assert.strictEqual(readable._readableState.emittedReadable, false); +// These trigger a single 'readable', as things are batched up process.nextTick(common.mustCall(function () { readable.push('foo'); })); process.nextTick(common.mustCall(function () { readable.push('bar'); -})); // these triggers two readable events +})); +// these triggers two readable events setImmediate(common.mustCall(function () { readable.push('quo'); process.nextTick(common.mustCall(function () { @@ -47,8 +46,8 @@ var noRead = new Readable({ noRead.on('readable', common.mustCall(function () { // emittedReadable should be true when the readable event is emitted assert.strictEqual(noRead._readableState.emittedReadable, true); - noRead.read(0); // emittedReadable is not reset during read(0) - + noRead.read(0); + // emittedReadable is not reset during read(0) assert.strictEqual(noRead._readableState.emittedReadable, true); })); noRead.push('foo'); @@ -69,19 +68,13 @@ process.nextTick(common.mustCall(function () { flowing.push(null); })); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-event.js b/test/parallel/test-stream-readable-event.js index 1b33347760..8f45349bd0 100644 --- a/test/parallel/test-stream-readable-event.js +++ b/test/parallel/test-stream-readable-event.js @@ -24,22 +24,18 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var Readable = require('../../').Readable; - { // First test, not reading when the readable is added. // make sure that on('readable', ...) triggers a readable event. var r = new Readable({ highWaterMark: 3 }); - r._read = common.mustNotCall(); // This triggers a 'readable' event, which is lost. + r._read = common.mustNotCall(); + // This triggers a 'readable' event, which is lost. r.push(bufferShim.from('blerg')); setTimeout(function () { // we're testing what we think we are @@ -50,18 +46,17 @@ var Readable = require('../../').Readable; { // second test, make sure that readable is re-emitted if there's // already a length, while it IS reading. + var _r = new Readable({ highWaterMark: 3 }); + _r._read = common.mustCall(); - _r._read = common.mustCall(); // This triggers a 'readable' event, which is lost. - + // This triggers a 'readable' event, which is lost. _r.push(bufferShim.from('bl')); - setTimeout(function () { // assert we're testing what we think we are assert(_r._readableState.reading); - _r.on('readable', common.mustCall()); }, 1); } @@ -71,17 +66,14 @@ var Readable = require('../../').Readable; var _r2 = new Readable({ highWaterMark: 30 }); + _r2._read = common.mustNotCall(); - _r2._read = common.mustNotCall(); // This triggers a 'readable' event, which is lost. - + // This triggers a 'readable' event, which is lost. _r2.push(bufferShim.from('blerg')); - _r2.push(null); - setTimeout(function () { // assert we're testing what we think we are assert(!_r2._readableState.reading); - _r2.on('readable', common.mustCall()); }, 1); } @@ -93,14 +85,11 @@ var Readable = require('../../').Readable; return data; }); var result = []; - var _r3 = new Readable({ encoding: 'utf8' }); - _r3._read = function () { var _this = this; - process.nextTick(function () { if (!underlyingData.length) { _this.push(null); @@ -109,13 +98,10 @@ var Readable = require('../../').Readable; } }); }; - _r3.on('readable', function () { var data = _r3.read(); - if (data !== null) result.push(data); }); - _r3.on('end', common.mustCall(function () { assert.deepStrictEqual(result, expected); })); @@ -123,30 +109,21 @@ var Readable = require('../../').Readable; { // #20923 var _r4 = new Readable(); - - _r4._read = function () {// actually doing thing here + _r4._read = function () { + // actually doing thing here }; - _r4.on('data', function () {}); - _r4.removeAllListeners(); - assert.strictEqual(_r4.eventNames().length, 0); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-flow-recursion.js b/test/parallel/test-stream-readable-flow-recursion.js index ed98bd3244..f781e5ab3c 100644 --- a/test/parallel/test-stream-readable-flow-recursion.js +++ b/test/parallel/test-stream-readable-flow-recursion.js @@ -24,35 +24,30 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); +var assert = require('assert/'); -var assert = require('assert/'); // this test verifies that passing a huge number to read(size) +// this test verifies that passing a huge number to read(size) // will push up the highWaterMark, and cause the stream to read // more data continuously, but without triggering a nextTick // warning or RangeError. +var Readable = require('../../').Readable; -var Readable = require('../../').Readable; // throw an error if we trigger a nextTick warning. - - +// throw an error if we trigger a nextTick warning. process.throwDeprecation = true; var stream = new Readable({ highWaterMark: 2 }); var reads = 0; var total = 5000; - stream._read = function (size) { reads++; size = Math.min(size, total); total -= size; if (size === 0) stream.push(null);else stream.push(bufferShim.allocUnsafe(size)); }; - var depth = 0; - function flow(stream, size, callback) { depth += 1; var chunk = stream.read(size); @@ -60,35 +55,27 @@ function flow(stream, size, callback) { depth -= 1; console.log("flow(".concat(depth, "): exit")); } - flow(stream, 5000, function () { console.log("complete (".concat(depth, ")")); }); process.on('exit', function (code) { - assert.strictEqual(reads, 2); // we pushed up the high water mark - - assert.strictEqual(stream.readableHighWaterMark, 8192); // length is 0 right now, because we pulled it all out. - + assert.strictEqual(reads, 2); + // we pushed up the high water mark + assert.strictEqual(stream.readableHighWaterMark, 8192); + // length is 0 right now, because we pulled it all out. assert.strictEqual(stream.readableLength, 0); assert(!code); assert.strictEqual(depth, 0); - require('tap').pass(); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-hwm-0-async.js b/test/parallel/test-stream-readable-hwm-0-async.js index 5b4d102f52..225dd4fd81 100644 --- a/test/parallel/test-stream-readable-hwm-0-async.js +++ b/test/parallel/test-stream-readable-hwm-0-async.js @@ -4,15 +4,14 @@ var bufferShim = require('safe-buffer').Buffer; /**/ +var common = require('../common'); -var common = require('../common'); // This test ensures that Readable stream will continue to call _read +// This test ensures that Readable stream will continue to call _read // for streams with highWaterMark === 0 once the stream returns data // by calling push() asynchronously. - var _require = require('../../'), - Readable = _require.Readable; - + Readable = _require.Readable; var count = 5; var r = new Readable({ // Called 6 times: First 5 return data, last one signals end of stream. @@ -26,19 +25,13 @@ var r = new Readable({ r.on('end', common.mustCall()); r.on('data', common.mustCall(5)); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-hwm-0-no-flow-data.js b/test/parallel/test-stream-readable-hwm-0-no-flow-data.js index 13f7ec3e49..f275f574d6 100644 --- a/test/parallel/test-stream-readable-hwm-0-no-flow-data.js +++ b/test/parallel/test-stream-readable-hwm-0-no-flow-data.js @@ -4,21 +4,20 @@ var bufferShim = require('safe-buffer').Buffer; /**/ +var common = require('../common'); -var common = require('../common'); // Ensure that subscribing the 'data' event will not make the stream flow. +// Ensure that subscribing the 'data' event will not make the stream flow. // The 'data' event will require calling read() by hand. // // The test is written for the (somewhat rare) highWaterMark: 0 streams to // specifically catch any regressions that might occur with these streams. - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable; - -var streamData = ['a', null]; // Track the calls so we can assert their order later. + Readable = _require.Readable; +var streamData = ['a', null]; +// Track the calls so we can assert their order later. var calls = []; var r = new Readable({ read: common.mustCall(function () { @@ -44,20 +43,24 @@ r.on('data', common.mustCall(function (data) { r.on('end', common.mustCall(function () { calls.push('end'); })); -assert.strictEqual(r.readableFlowing, false); // The stream emits the events asynchronously but that's not guaranteed to +assert.strictEqual(r.readableFlowing, false); + +// The stream emits the events asynchronously but that's not guaranteed to // happen on the next tick (especially since the _read implementation above // uses process.nextTick). // // We use setImmediate here to give the stream enough time to emit all the // events it's about to emit. - setImmediate(function () { // Only the _read, push, readable calls have happened. No data must be // emitted yet. - assert.deepStrictEqual(calls, ['_read:a', 'push:a', 'readable']); // Calling 'r.read()' should trigger the data event. + assert.deepStrictEqual(calls, ['_read:a', 'push:a', 'readable']); + // Calling 'r.read()' should trigger the data event. assert.strictEqual(r.read(), 'a'); - assert.deepStrictEqual(calls, ['_read:a', 'push:a', 'readable', 'data:a']); // The next 'read()' will return null because hwm: 0 does not buffer any + assert.deepStrictEqual(calls, ['_read:a', 'push:a', 'readable', 'data:a']); + + // The next 'read()' will return null because hwm: 0 does not buffer any // data and the _read implementation above does the push() asynchronously. // // Note: This 'null' signals "no data available". It isn't the end-of-stream @@ -66,7 +69,6 @@ setImmediate(function () { // // Using setImmediate again to give the stream enough time to emit all the // events it wants to emit. - assert.strictEqual(r.read(), null); setImmediate(function () { // There's a new 'readable' event after the data has been pushed. @@ -76,11 +78,12 @@ setImmediate(function () { // calls 'push' asynchronously. If 'push' was synchronous, the 'end' event // would be emitted here _before_ we call read(). assert.deepStrictEqual(calls, ['_read:a', 'push:a', 'readable', 'data:a', '_read:null', 'push:null', 'readable']); - assert.strictEqual(r.read(), null); // While it isn't really specified whether the 'end' event should happen + assert.strictEqual(r.read(), null); + + // While it isn't really specified whether the 'end' event should happen // synchronously with read() or not, we'll assert the current behavior // ('end' event happening on the next tick after read()) so any changes // to it are noted and acknowledged in the future. - assert.deepStrictEqual(calls, ['_read:a', 'push:a', 'readable', 'data:a', '_read:null', 'push:null', 'readable']); process.nextTick(function () { assert.deepStrictEqual(calls, ['_read:a', 'push:a', 'readable', 'data:a', '_read:null', 'push:null', 'readable', 'end']); @@ -88,19 +91,13 @@ setImmediate(function () { }); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-hwm-0.js b/test/parallel/test-stream-readable-hwm-0.js index c2752273d8..24bc3d4e3f 100644 --- a/test/parallel/test-stream-readable-hwm-0.js +++ b/test/parallel/test-stream-readable-hwm-0.js @@ -4,25 +4,23 @@ var bufferShim = require('safe-buffer').Buffer; /**/ +var common = require('../common'); -var common = require('../common'); // This test ensures that Readable stream will call _read() for streams +// This test ensures that Readable stream will call _read() for streams // with highWaterMark === 0 upon .read(0) instead of just trying to // emit 'readable' event. - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable; - + Readable = _require.Readable; var r = new Readable({ // must be called only once upon setting 'readable' listener read: common.mustCall(), highWaterMark: 0 }); -var pushedNull = false; // this will trigger read(0) but must only be called after push(null) +var pushedNull = false; +// this will trigger read(0) but must only be called after push(null) // because the we haven't pushed any data - r.on('readable', common.mustCall(function () { assert.strictEqual(r.read(), null); assert.strictEqual(pushedNull, true); @@ -34,19 +32,13 @@ process.nextTick(function () { r.push(null); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-infinite-read.js b/test/parallel/test-stream-readable-infinite-read.js index f51c0d218c..ada2b70c29 100644 --- a/test/parallel/test-stream-readable-infinite-read.js +++ b/test/parallel/test-stream-readable-infinite-read.js @@ -4,14 +4,10 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable; - + Readable = _require.Readable; var buf = bufferShim.alloc(8192); var readable = new Readable({ read: common.mustCall(function () { @@ -25,10 +21,9 @@ readable.on('readable', common.mustCall(function () { process.removeAllListeners('readable'); return; } - - var data = readable.read(); // TODO(mcollina): there is something odd in the highWaterMark logic + var data = readable.read(); + // TODO(mcollina): there is something odd in the highWaterMark logic // investigate. - if (i === 1) { assert.strictEqual(data.length, 8192 * 2); } else { @@ -36,19 +31,13 @@ readable.on('readable', common.mustCall(function () { } }, 11)); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-invalid-chunk.js b/test/parallel/test-stream-readable-invalid-chunk.js index 0512890b50..bc90e3df6f 100644 --- a/test/parallel/test-stream-readable-invalid-chunk.js +++ b/test/parallel/test-stream-readable-invalid-chunk.js @@ -4,22 +4,17 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var stream = require('../../'); - var readable = new stream.Readable({ read: function read() {} }); - function checkError(fn) { common.expectsError(fn, { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }); } - checkError(function () { return readable.push([]); }); @@ -30,19 +25,13 @@ checkError(function () { return readable.push(0); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-needReadable.js b/test/parallel/test-stream-readable-needReadable.js index df882d2b4b..f505402d5e 100644 --- a/test/parallel/test-stream-readable-needReadable.js +++ b/test/parallel/test-stream-readable-needReadable.js @@ -3,25 +3,22 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var Readable = require('../../').Readable; - var readable = new Readable({ read: function read() {} -}); // Initialized to false. +}); +// Initialized to false. assert.strictEqual(readable._readableState.needReadable, false); readable.on('readable', common.mustCall(function () { // When the readable event fires, needReadable is reset. assert.strictEqual(readable._readableState.needReadable, false); readable.read(); -})); // If a readable listener is attached, then a readable event is needed. +})); +// If a readable listener is attached, then a readable event is needed. assert.strictEqual(readable._readableState.needReadable, true); readable.push('foo'); readable.push(null); @@ -52,16 +49,18 @@ setImmediate(common.mustCall(function () { })); var flowing = new Readable({ read: function read() {} -}); // Notice this must be above the on('data') call. +}); +// Notice this must be above the on('data') call. flowing.push('foooo'); flowing.push('bar'); flowing.push('quo'); process.nextTick(common.mustCall(function () { flowing.push(null); -})); // When the buffer already has enough data, and the stream is -// in flowing mode, there is no need for the readable event. +})); +// When the buffer already has enough data, and the stream is +// in flowing mode, there is no need for the readable event. flowing.on('data', common.mustCall(function (data) { assert.strictEqual(flowing._readableState.needReadable, false); }, 3)); @@ -90,19 +89,13 @@ process.nextTick(common.mustCall(function () { })); })); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-no-unneeded-readable.js b/test/parallel/test-stream-readable-no-unneeded-readable.js index 2da85fb9c9..db1b14abc3 100644 --- a/test/parallel/test-stream-readable-no-unneeded-readable.js +++ b/test/parallel/test-stream-readable-no-unneeded-readable.js @@ -3,41 +3,34 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var _require = require('../../'), - Readable = _require.Readable, - PassThrough = _require.PassThrough; - + Readable = _require.Readable, + PassThrough = _require.PassThrough; function test(r) { var wrapper = new Readable({ read: function read() { var data = r.read(); - if (data) { wrapper.push(data); return; } - r.once('readable', function () { data = r.read(); - if (data) { wrapper.push(data); - } // else the end event should fire - + } + // else the end event should fire }); } }); + r.once('end', function () { wrapper.push(null); }); wrapper.resume(); wrapper.once('end', common.mustCall()); } - { var source = new Readable({ read: function read() {} @@ -54,7 +47,6 @@ function test(r) { var r = new Readable({ read: function read() { var chunk = pushChunks.shift(); - if (chunk) { // synchronous call r.push(chunk); @@ -69,19 +61,13 @@ function test(r) { test(r); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-object-multi-push-async.js b/test/parallel/test-stream-readable-object-multi-push-async.js index 8aecbf1546..8508672547 100644 --- a/test/parallel/test-stream-readable-object-multi-push-async.js +++ b/test/parallel/test-stream-readable-object-multi-push-async.js @@ -4,38 +4,40 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable; - + Readable = _require.Readable; var MAX = 42; var BATCH = 10; { + var fetchData = function fetchData(cb) { + if (i > MAX) { + setTimeout(cb, 10, null, []); + } else { + var array = []; + var max = i + BATCH; + for (; i < max; i++) { + array.push(i); + } + setTimeout(cb, 10, null, array); + } + }; var readable = new Readable({ objectMode: true, read: common.mustCall(function () { var _this = this; - console.log('>> READ'); fetchData(function (err, data) { if (err) { _this.destroy(err); - return; } - if (data.length === 0) { console.log('pushing null'); - _this.push(null); - return; } - console.log('pushing'); data.forEach(function (d) { return _this.push(d); @@ -44,26 +46,9 @@ var BATCH = 10; }, Math.floor(MAX / BATCH) + 2) }); var i = 0; - - function fetchData(cb) { - if (i > MAX) { - setTimeout(cb, 10, null, []); - } else { - var array = []; - var max = i + BATCH; - - for (; i < max; i++) { - array.push(i); - } - - setTimeout(cb, 10, null, array); - } - } - readable.on('readable', function () { var data; console.log('readable emitted'); - while (data = readable.read()) { console.log(data); } @@ -73,27 +58,33 @@ var BATCH = 10; })); } { + var _fetchData = function _fetchData(cb) { + if (_i > MAX) { + setTimeout(cb, 10, null, []); + } else { + var array = []; + var max = _i + BATCH; + for (; _i < max; _i++) { + array.push(_i); + } + setTimeout(cb, 10, null, array); + } + }; var _readable = new Readable({ objectMode: true, read: common.mustCall(function () { var _this2 = this; - console.log('>> READ'); - fetchData(function (err, data) { + _fetchData(function (err, data) { if (err) { _this2.destroy(err); - return; } - if (data.length === 0) { console.log('pushing null'); - _this2.push(null); - return; } - console.log('pushing'); data.forEach(function (d) { return _this2.push(d); @@ -101,77 +92,48 @@ var BATCH = 10; }); }, Math.floor(MAX / BATCH) + 2) }); - var _i = 0; - - function fetchData(cb) { - if (_i > MAX) { - setTimeout(cb, 10, null, []); - } else { - var array = []; - var max = _i + BATCH; - - for (; _i < max; _i++) { - array.push(_i); - } - - setTimeout(cb, 10, null, array); - } - } - _readable.on('data', function (data) { console.log('data emitted', data); }); - _readable.on('end', common.mustCall(function () { assert.strictEqual(_i, (Math.floor(MAX / BATCH) + 1) * BATCH); })); } { + var _fetchData2 = function _fetchData2(cb) { + var array = []; + var max = _i2 + BATCH; + for (; _i2 < max; _i2++) { + array.push(_i2); + } + setTimeout(cb, 10, null, array); + }; var _readable2 = new Readable({ objectMode: true, read: common.mustCall(function () { var _this3 = this; - console.log('>> READ'); - fetchData(function (err, data) { + _fetchData2(function (err, data) { if (err) { _this3.destroy(err); - return; } - console.log('pushing'); data.forEach(function (d) { return _this3.push(d); }); - if (data[BATCH - 1] >= MAX) { console.log('pushing null'); - _this3.push(null); } }); }, Math.floor(MAX / BATCH) + 1) }); - var _i2 = 0; - - function fetchData(cb) { - var array = []; - var max = _i2 + BATCH; - - for (; _i2 < max; _i2++) { - array.push(_i2); - } - - setTimeout(cb, 10, null, array); - } - _readable2.on('data', function (data) { console.log('data emitted', data); }); - _readable2.on('end', common.mustCall(function () { assert.strictEqual(_i2, (Math.floor(MAX / BATCH) + 1) * BATCH); })); @@ -181,16 +143,12 @@ var BATCH = 10; objectMode: true, read: common.mustNotCall() }); - _readable3.on('data', common.mustNotCall()); - _readable3.push(null); - var nextTickPassed = false; process.nextTick(function () { nextTickPassed = true; }); - _readable3.on('end', common.mustCall(function () { assert.strictEqual(nextTickPassed, true); })); @@ -200,33 +158,23 @@ var BATCH = 10; objectMode: true, read: common.mustCall() }); - _readable4.on('data', function (data) { console.log('data emitted', data); }); - _readable4.on('end', common.mustCall()); - setImmediate(function () { _readable4.push('aaa'); - _readable4.push(null); }); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-pause-and-resume.js b/test/parallel/test-stream-readable-pause-and-resume.js index fe852cf426..a0a10ca23a 100644 --- a/test/parallel/test-stream-readable-pause-and-resume.js +++ b/test/parallel/test-stream-readable-pause-and-resume.js @@ -4,12 +4,9 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var _require = require('../../'), - Readable = _require.Readable; - + Readable = _require.Readable; var common = require('../common'); - var ticks = 18; var expectedData = 19; var rs = new Readable({ @@ -24,7 +21,6 @@ var rs = new Readable({ }); rs.on('end', common.mustCall()); readAndPause(); - function readAndPause() { // Does a on(data) -> pause -> wait -> resume -> on(data) ... loop. // Expects on(data) to never fire if the stream is paused. @@ -41,21 +37,14 @@ function readAndPause() { rs.on('data', ondata); } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-readable-then-resume.js b/test/parallel/test-stream-readable-readable-then-resume.js index 5764ab8ddd..ff55369838 100644 --- a/test/parallel/test-stream-readable-readable-then-resume.js +++ b/test/parallel/test-stream-readable-readable-then-resume.js @@ -4,13 +4,12 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var _require = require('../../'), - Readable = _require.Readable; // This test verifies that a stream could be resumed after -// removing the readable event in the same tick + Readable = _require.Readable; +// This test verifies that a stream could be resumed after +// removing the readable event in the same tick check(new Readable({ objectMode: true, @@ -21,11 +20,9 @@ check(new Readable({ this.first = true; return; } - this.push(null); } })); - function check(s) { var readableListener = common.mustNotCall(); s.on('readable', readableListener); @@ -33,21 +30,14 @@ function check(s) { s.removeListener('readable', readableListener); s.resume(); } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-reading-readingMore.js b/test/parallel/test-stream-readable-reading-readingMore.js index a17b4c6cdf..066386c89e 100644 --- a/test/parallel/test-stream-readable-reading-readingMore.js +++ b/test/parallel/test-stream-readable-reading-readingMore.js @@ -3,176 +3,158 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var Readable = require('../../').Readable; - { + var onStreamEnd = function onStreamEnd() { + // End of stream; state.reading is false + // And so should be readingMore. + assert.strictEqual(state.readingMore, false); + assert.strictEqual(state.reading, false); + }; var readable = new Readable({ read: function read(size) {} }); - var state = readable._readableState; // Starting off with false initially. + var state = readable._readableState; + // Starting off with false initially. assert.strictEqual(state.reading, false); assert.strictEqual(state.readingMore, false); readable.on('data', common.mustCall(function (data) { // while in a flowing state with a 'readable' listener // we should not be reading more - if (readable.readableFlowing) assert.strictEqual(state.readingMore, true); // reading as long as we've not ended + if (readable.readableFlowing) assert.strictEqual(state.readingMore, true); + // reading as long as we've not ended assert.strictEqual(state.reading, !state.ended); }, 2)); - - function onStreamEnd() { - // End of stream; state.reading is false - // And so should be readingMore. - assert.strictEqual(state.readingMore, false); - assert.strictEqual(state.reading, false); - } - var expectedReadingMore = [true, false]; readable.on('readable', common.mustCall(function () { // there is only one readingMore scheduled from on('data'), // after which everything is governed by the .read() call - assert.strictEqual(state.readingMore, expectedReadingMore.shift()); // if the stream has ended, we shouldn't be reading + assert.strictEqual(state.readingMore, expectedReadingMore.shift()); + // if the stream has ended, we shouldn't be reading assert.strictEqual(state.ended, !state.reading); var data = readable.read(); - if (data === null) // reached end of stream + if (data === null) + // reached end of stream process.nextTick(common.mustCall(onStreamEnd, 1)); }, 2)); readable.on('end', common.mustCall(onStreamEnd)); readable.push('pushed'); - readable.read(6); // reading + readable.read(6); + // reading assert.strictEqual(state.reading, true); - assert.strictEqual(state.readingMore, true); // add chunk to front + assert.strictEqual(state.readingMore, true); - readable.unshift('unshifted'); // end + // add chunk to front + readable.unshift('unshifted'); + // end readable.push(null); } { + var _onStreamEnd = function _onStreamEnd() { + // End of stream; state.reading is false + // And so should be readingMore. + assert.strictEqual(_state.readingMore, false); + assert.strictEqual(_state.reading, false); + }; var _readable = new Readable({ read: function read(size) {} }); + var _state = _readable._readableState; - var _state = _readable._readableState; // Starting off with false initially. - + // Starting off with false initially. assert.strictEqual(_state.reading, false); assert.strictEqual(_state.readingMore, false); - _readable.on('data', common.mustCall(function (data) { // while in a flowing state without a 'readable' listener // we should be reading more - if (_readable.readableFlowing) assert.strictEqual(_state.readingMore, true); // reading as long as we've not ended + if (_readable.readableFlowing) assert.strictEqual(_state.readingMore, true); + // reading as long as we've not ended assert.strictEqual(_state.reading, !_state.ended); }, 2)); + _readable.on('end', common.mustCall(_onStreamEnd)); + _readable.push('pushed'); - function onStreamEnd() { - // End of stream; state.reading is false - // And so should be readingMore. - assert.strictEqual(_state.readingMore, false); - assert.strictEqual(_state.reading, false); - } - - _readable.on('end', common.mustCall(onStreamEnd)); - - _readable.push('pushed'); // stop emitting 'data' events - - + // stop emitting 'data' events assert.strictEqual(_state.flowing, true); + _readable.pause(); - _readable.pause(); // paused - - + // paused assert.strictEqual(_state.reading, false); assert.strictEqual(_state.flowing, false); - _readable.resume(); - assert.strictEqual(_state.reading, false); - assert.strictEqual(_state.flowing, true); // add chunk to front - - _readable.unshift('unshifted'); // end + assert.strictEqual(_state.flowing, true); + // add chunk to front + _readable.unshift('unshifted'); + // end _readable.push(null); } { + var _onStreamEnd2 = function _onStreamEnd2() { + // End of stream; state.reading is false + // And so should be readingMore. + assert.strictEqual(_state2.readingMore, false); + assert.strictEqual(_state2.reading, false); + }; var _readable2 = new Readable({ read: function read(size) {} }); + var _state2 = _readable2._readableState; - var _state2 = _readable2._readableState; // Starting off with false initially. - + // Starting off with false initially. assert.strictEqual(_state2.reading, false); assert.strictEqual(_state2.readingMore, false); var onReadable = common.mustNotCall; - _readable2.on('readable', onReadable); - _readable2.on('data', common.mustCall(function (data) { // reading as long as we've not ended assert.strictEqual(_state2.reading, !_state2.ended); }, 2)); - _readable2.removeListener('readable', onReadable); + _readable2.on('end', common.mustCall(_onStreamEnd2)); + _readable2.push('pushed'); - function onStreamEnd() { - // End of stream; state.reading is false - // And so should be readingMore. - assert.strictEqual(_state2.readingMore, false); - assert.strictEqual(_state2.reading, false); - } - - _readable2.on('end', common.mustCall(onStreamEnd)); - - _readable2.push('pushed'); // we are still not flowing, we will be resuming in the next tick - - - assert.strictEqual(_state2.flowing, false); // wait for nextTick, so the readableListener flag resets + // we are still not flowing, we will be resuming in the next tick + assert.strictEqual(_state2.flowing, false); + // wait for nextTick, so the readableListener flag resets process.nextTick(function () { - _readable2.resume(); // stop emitting 'data' events - + _readable2.resume(); + // stop emitting 'data' events assert.strictEqual(_state2.flowing, true); + _readable2.pause(); - _readable2.pause(); // paused - - + // paused assert.strictEqual(_state2.flowing, false); - _readable2.resume(); + assert.strictEqual(_state2.flowing, true); - assert.strictEqual(_state2.flowing, true); // add chunk to front - - _readable2.unshift('unshifted'); // end - + // add chunk to front + _readable2.unshift('unshifted'); + // end _readable2.push(null); }); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-resume-hwm.js b/test/parallel/test-stream-readable-resume-hwm.js index 93a4a54226..b97283f9a1 100644 --- a/test/parallel/test-stream-readable-resume-hwm.js +++ b/test/parallel/test-stream-readable-resume-hwm.js @@ -3,45 +3,36 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var _require = require('../../'), - Readable = _require.Readable; // readable.resume() should not lead to a ._read() call being scheduled -// when we exceed the high water mark already. + Readable = _require.Readable; +// readable.resume() should not lead to a ._read() call being scheduled +// when we exceed the high water mark already. var readable = new Readable({ read: common.mustNotCall(), highWaterMark: 100 -}); // Fill up the internal buffer so that we definitely exceed the HWM: +}); + +// Fill up the internal buffer so that we definitely exceed the HWM: +for (var i = 0; i < 10; i++) readable.push('a'.repeat(200)); -for (var i = 0; i < 10; i++) { - readable.push('a'.repeat(200)); -} // Call resume, and pause after one chunk. +// Call resume, and pause after one chunk. // The .pause() is just so that we don’t empty the buffer fully, which would // be a valid reason to call ._read(). - - readable.resume(); readable.once('data', common.mustCall(function () { return readable.pause(); })); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-resumeScheduled.js b/test/parallel/test-stream-readable-resumeScheduled.js index 8aba21c386..7944bdbfdd 100644 --- a/test/parallel/test-stream-readable-resumeScheduled.js +++ b/test/parallel/test-stream-readable-resumeScheduled.js @@ -3,26 +3,25 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ +var common = require('../common'); - -var common = require('../common'); // Testing Readable Stream resumeScheduled state - +// Testing Readable Stream resumeScheduled state var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable, - Writable = _require.Writable; - + Readable = _require.Readable, + Writable = _require.Writable; { // pipe() test case var r = new Readable({ read: function read() {} }); - var w = new Writable(); // resumeScheduled should start = `false`. + var w = new Writable(); - assert.strictEqual(r._readableState.resumeScheduled, false); // calling pipe() should change the state value = true. + // resumeScheduled should start = `false`. + assert.strictEqual(r._readableState.resumeScheduled, false); + // calling pipe() should change the state value = true. r.pipe(w); assert.strictEqual(r._readableState.resumeScheduled, true); process.nextTick(common.mustCall(function () { @@ -33,18 +32,16 @@ var _require = require('../../'), // 'data' listener test case var _r = new Readable({ read: function read() {} - }); // resumeScheduled should start = `false`. - + }); + // resumeScheduled should start = `false`. assert.strictEqual(_r._readableState.resumeScheduled, false); + _r.push(bufferShim.from([1, 2, 3])); - _r.push(bufferShim.from([1, 2, 3])); // adding 'data' listener should change the state value - - + // adding 'data' listener should change the state value _r.on('data', common.mustCall(function () { assert.strictEqual(_r._readableState.resumeScheduled, false); })); - assert.strictEqual(_r._readableState.resumeScheduled, true); process.nextTick(common.mustCall(function () { assert.strictEqual(_r._readableState.resumeScheduled, false); @@ -54,38 +51,30 @@ var _require = require('../../'), // resume() test case var _r2 = new Readable({ read: function read() {} - }); // resumeScheduled should start = `false`. - + }); - assert.strictEqual(_r2._readableState.resumeScheduled, false); // Calling resume() should change the state value. + // resumeScheduled should start = `false`. + assert.strictEqual(_r2._readableState.resumeScheduled, false); + // Calling resume() should change the state value. _r2.resume(); - assert.strictEqual(_r2._readableState.resumeScheduled, true); - _r2.on('resume', common.mustCall(function () { // The state value should be `false` again assert.strictEqual(_r2._readableState.resumeScheduled, false); })); - process.nextTick(common.mustCall(function () { assert.strictEqual(_r2._readableState.resumeScheduled, false); })); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-setEncoding-existing-buffers.js b/test/parallel/test-stream-readable-setEncoding-existing-buffers.js index 31bd3263ce..5701b8baf9 100644 --- a/test/parallel/test-stream-readable-setEncoding-existing-buffers.js +++ b/test/parallel/test-stream-readable-setEncoding-existing-buffers.js @@ -3,15 +3,10 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var _require = require('../../'), - Readable = _require.Readable; - + Readable = _require.Readable; var assert = require('assert/'); - { // Call .setEncoding() while there are bytes already in the buffer. var r = new Readable({ @@ -34,23 +29,15 @@ var assert = require('assert/'); var _r = new Readable({ read: function read() {} }); - _r.push(bufferShim.from([0xf0])); - _r.push(bufferShim.from([0x9f])); - _r.push(bufferShim.from([0x8e])); - _r.push(bufferShim.from([0x89])); - _r.setEncoding('utf8'); - var _chunks = []; - _r.on('data', function (chunk) { return _chunks.push(chunk); }); - process.nextTick(function () { assert.deepStrictEqual(_chunks, ['🎉']); }); @@ -61,41 +48,27 @@ var assert = require('assert/'); var _r2 = new Readable({ read: function read() {} }); - _r2.push(bufferShim.from([0xf0])); - _r2.push(bufferShim.from([0x9f])); - _r2.setEncoding('utf8'); - _r2.push(bufferShim.from([0x8e])); - _r2.push(bufferShim.from([0x89])); - var _chunks2 = []; - _r2.on('data', function (chunk) { return _chunks2.push(chunk); }); - process.nextTick(function () { assert.deepStrictEqual(_chunks2, ['🎉']); }); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-setEncoding-null.js b/test/parallel/test-stream-readable-setEncoding-null.js index c4276b4fbb..91da12a273 100644 --- a/test/parallel/test-stream-readable-setEncoding-null.js +++ b/test/parallel/test-stream-readable-setEncoding-null.js @@ -4,14 +4,10 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable; - + Readable = _require.Readable; { var readable = new Readable({ encoding: 'hex' @@ -21,19 +17,13 @@ var _require = require('../../'), assert.strictEqual(readable._readableState.encoding, 'utf8'); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readable-with-unimplemented-_read.js b/test/parallel/test-stream-readable-with-unimplemented-_read.js index 42b8c26134..ff678e0614 100644 --- a/test/parallel/test-stream-readable-with-unimplemented-_read.js +++ b/test/parallel/test-stream-readable-with-unimplemented-_read.js @@ -3,13 +3,9 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var _require = require('../../'), - Readable = _require.Readable; - + Readable = _require.Readable; var readable = new Readable(); readable.on('error', common.expectsError({ code: 'ERR_METHOD_NOT_IMPLEMENTED', @@ -18,19 +14,13 @@ readable.on('error', common.expectsError({ })); readable.read(); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-readableListening-state.js b/test/parallel/test-stream-readableListening-state.js index cf6c46b759..e0379d6a00 100644 --- a/test/parallel/test-stream-readableListening-state.js +++ b/test/parallel/test-stream-readableListening-state.js @@ -4,17 +4,14 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var r = new stream.Readable({ read: function read() {} -}); // readableListening state should start in `false`. +}); +// readableListening state should start in `false`. assert.strictEqual(r._readableState.readableListening, false); r.on('readable', common.mustCall(function () { // Inside the readable event this state should be true. @@ -23,8 +20,9 @@ r.on('readable', common.mustCall(function () { r.push(bufferShim.from('Testing readableListening state')); var r2 = new stream.Readable({ read: function read() {} -}); // readableListening state should start in `false`. +}); +// readableListening state should start in `false`. assert.strictEqual(r2._readableState.readableListening, false); r2.on('data', common.mustCall(function (chunk) { // readableListening should be false because we don't have @@ -33,19 +31,13 @@ r2.on('data', common.mustCall(function (chunk) { })); r2.push(bufferShim.from('Testing readableListening state')); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-transform-callback-twice.js b/test/parallel/test-stream-transform-callback-twice.js index 005d5bf679..7b1ac28266 100644 --- a/test/parallel/test-stream-transform-callback-twice.js +++ b/test/parallel/test-stream-transform-callback-twice.js @@ -3,13 +3,9 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var _require = require('../../'), - Transform = _require.Transform; - + Transform = _require.Transform; var stream = new Transform({ transform: function transform(chunk, enc, cb) { cb(); @@ -23,19 +19,13 @@ stream.on('error', common.expectsError({ })); stream.write('foo'); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-transform-constructor-set-methods.js b/test/parallel/test-stream-transform-constructor-set-methods.js index 2b57d43b4f..65bd2f67a7 100644 --- a/test/parallel/test-stream-transform-constructor-set-methods.js +++ b/test/parallel/test-stream-transform-constructor-set-methods.js @@ -3,16 +3,11 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var _require = require('assert/'), - strictEqual = _require.strictEqual; - + strictEqual = _require.strictEqual; var _require2 = require('../../'), - Transform = _require2.Transform; - + Transform = _require2.Transform; var t = new Transform(); t.on('error', common.expectsError({ type: Error, @@ -20,19 +15,15 @@ t.on('error', common.expectsError({ message: 'The _transform() method is not implemented' })); t.end(bufferShim.from('blerg')); - var _transform = common.mustCall(function (chunk, _, next) { next(); }); - var _final = common.mustCall(function (next) { next(); }); - var _flush = common.mustCall(function (next) { next(); }); - var t2 = new Transform({ transform: _transform, flush: _flush, @@ -44,19 +35,13 @@ strictEqual(t2._final, _final); t2.end(bufferShim.from('blerg')); t2.resume(); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-transform-destroy.js b/test/parallel/test-stream-transform-destroy.js index 3a6f1dda9f..5bf3e8fa66 100644 --- a/test/parallel/test-stream-transform-destroy.js +++ b/test/parallel/test-stream-transform-destroy.js @@ -4,14 +4,10 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var _require = require('../../'), - Transform = _require.Transform; - + Transform = _require.Transform; var assert = require('assert/'); - { var transform = new Transform({ transform: function transform(chunk, enc, cb) {} @@ -26,48 +22,34 @@ var assert = require('assert/'); var _transform = new Transform({ transform: function transform(chunk, enc, cb) {} }); - _transform.resume(); - var expected = new Error('kaboom'); - _transform.on('end', common.mustNotCall()); - _transform.on('finish', common.mustNotCall()); - _transform.on('close', common.mustCall()); - _transform.on('error', common.mustCall(function (err) { assert.strictEqual(err, expected); })); - _transform.destroy(expected); } { var _transform2 = new Transform({ transform: function transform(chunk, enc, cb) {} }); - _transform2._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, _expected); cb(err); }, 1); - var _expected = new Error('kaboom'); - _transform2.on('finish', common.mustNotCall('no finish event')); - _transform2.on('close', common.mustCall()); - _transform2.on('error', common.mustCall(function (err) { assert.strictEqual(err, _expected); })); - _transform2.destroy(_expected); } { var _expected2 = new Error('kaboom'); - var _transform3 = new Transform({ transform: function transform(chunk, enc, cb) {}, destroy: common.mustCall(function (err, cb) { @@ -75,107 +57,74 @@ var assert = require('assert/'); cb(); }, 1) }); - _transform3.resume(); - _transform3.on('end', common.mustNotCall('no end event')); - _transform3.on('close', common.mustCall()); + _transform3.on('finish', common.mustNotCall('no finish event')); - _transform3.on('finish', common.mustNotCall('no finish event')); // error is swallowed by the custom _destroy - - + // error is swallowed by the custom _destroy _transform3.on('error', common.mustNotCall('no error event')); - _transform3.destroy(_expected2); } { var _transform4 = new Transform({ transform: function transform(chunk, enc, cb) {} }); - _transform4._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, null); cb(); }, 1); - _transform4.destroy(); } { var _transform5 = new Transform({ transform: function transform(chunk, enc, cb) {} }); - _transform5.resume(); - _transform5._destroy = common.mustCall(function (err, cb) { var _this = this; - assert.strictEqual(err, null); process.nextTick(function () { _this.push(null); - _this.end(); - cb(); }); }, 1); var fail = common.mustNotCall('no event'); - _transform5.on('finish', fail); - _transform5.on('end', fail); - _transform5.on('close', common.mustCall()); - _transform5.destroy(); - _transform5.removeListener('end', fail); - _transform5.removeListener('finish', fail); - _transform5.on('end', common.mustCall()); - _transform5.on('finish', common.mustCall()); } { var _transform6 = new Transform({ transform: function transform(chunk, enc, cb) {} }); - var _expected3 = new Error('kaboom'); - _transform6._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, null); cb(_expected3); }, 1); - _transform6.on('close', common.mustCall()); - _transform6.on('finish', common.mustNotCall('no finish event')); - _transform6.on('end', common.mustNotCall('no end event')); - _transform6.on('error', common.mustCall(function (err) { assert.strictEqual(err, _expected3); })); - _transform6.destroy(); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-transform-final-sync.js b/test/parallel/test-stream-transform-final-sync.js index 39c0b46a98..c8061ccbf0 100644 --- a/test/parallel/test-stream-transform-final-sync.js +++ b/test/parallel/test-stream-transform-final-sync.js @@ -3,15 +3,11 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var state = 0; + /* What you do var stream = new stream.Transform({ @@ -68,40 +64,40 @@ var t = new stream.Transform({ transform: common.mustCall(function (chunk, _, next) { // transformCallback part 1 assert.strictEqual(++state, chunk); - this.push(state); // transformCallback part 2 - + this.push(state); + // transformCallback part 2 assert.strictEqual(++state, chunk + 2); process.nextTick(next); }, 3), final: common.mustCall(function (done) { - state++; // finalCallback part 1 - + state++; + // finalCallback part 1 assert.strictEqual(state, 10); - state++; // finalCallback part 2 - + state++; + // finalCallback part 2 assert.strictEqual(state, 11); done(); }, 1), flush: common.mustCall(function (done) { - state++; // fluchCallback part 1 - + state++; + // fluchCallback part 1 assert.strictEqual(state, 12); process.nextTick(function () { - state++; // fluchCallback part 2 - + state++; + // fluchCallback part 2 assert.strictEqual(state, 15); done(); }); }, 1) }); t.on('finish', common.mustCall(function () { - state++; // finishListener - + state++; + // finishListener assert.strictEqual(state, 13); }, 1)); t.on('end', common.mustCall(function () { - state++; // endEvent - + state++; + // endEvent assert.strictEqual(state, 16); }, 1)); t.on('data', common.mustCall(function (d) { @@ -111,24 +107,18 @@ t.on('data', common.mustCall(function (d) { t.write(1); t.write(4); t.end(7, common.mustCall(function () { - state++; // endMethodCallback - + state++; + // endMethodCallback assert.strictEqual(state, 14); }, 1)); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-transform-final.js b/test/parallel/test-stream-transform-final.js index 37b270ca8f..1c90e9adff 100644 --- a/test/parallel/test-stream-transform-final.js +++ b/test/parallel/test-stream-transform-final.js @@ -3,15 +3,11 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var state = 0; + /* What you do var stream = new stream.Transform({ @@ -68,42 +64,42 @@ var t = new stream.Transform({ transform: common.mustCall(function (chunk, _, next) { // transformCallback part 1 assert.strictEqual(++state, chunk); - this.push(state); // transformCallback part 2 - + this.push(state); + // transformCallback part 2 assert.strictEqual(++state, chunk + 2); process.nextTick(next); }, 3), final: common.mustCall(function (done) { - state++; // finalCallback part 1 - + state++; + // finalCallback part 1 assert.strictEqual(state, 10); setTimeout(function () { - state++; // finalCallback part 2 - + state++; + // finalCallback part 2 assert.strictEqual(state, 11); done(); }, 100); }, 1), flush: common.mustCall(function (done) { - state++; // flushCallback part 1 - + state++; + // flushCallback part 1 assert.strictEqual(state, 12); process.nextTick(function () { - state++; // flushCallback part 2 - + state++; + // flushCallback part 2 assert.strictEqual(state, 15); done(); }); }, 1) }); t.on('finish', common.mustCall(function () { - state++; // finishListener - + state++; + // finishListener assert.strictEqual(state, 13); }, 1)); t.on('end', common.mustCall(function () { - state++; // end event - + state++; + // end event assert.strictEqual(state, 16); }, 1)); t.on('data', common.mustCall(function (d) { @@ -113,24 +109,18 @@ t.on('data', common.mustCall(function (d) { t.write(1); t.write(4); t.end(7, common.mustCall(function () { - state++; // endMethodCallback - + state++; + // endMethodCallback assert.strictEqual(state, 14); }, 1)); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-transform-flush-data.js b/test/parallel/test-stream-transform-flush-data.js index a6f9810315..8630a5df03 100644 --- a/test/parallel/test-stream-transform-flush-data.js +++ b/test/parallel/test-stream-transform-flush-data.js @@ -4,23 +4,16 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - require('../common'); - var assert = require('assert/'); - var Transform = require('../../').Transform; - var expected = 'asdf'; - function _transform(d, e, n) { n(); } - function _flush(n) { n(null, expected); } - var t = new Transform({ transform: _transform, flush: _flush @@ -30,19 +23,13 @@ t.on('data', function (data) { assert.strictEqual(data.toString(), expected); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-transform-objectmode-falsey-value.js b/test/parallel/test-stream-transform-objectmode-falsey-value.js index 39ec6c3c8f..d3ebb07b4f 100644 --- a/test/parallel/test-stream-transform-objectmode-falsey-value.js +++ b/test/parallel/test-stream-transform-objectmode-falsey-value.js @@ -24,14 +24,9 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var PassThrough = stream.PassThrough; var src = new PassThrough({ objectMode: true @@ -59,19 +54,13 @@ var int = setInterval(common.mustCall(function () { } }, expect.length + 1), 1); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-transform-split-highwatermark.js b/test/parallel/test-stream-transform-split-highwatermark.js index 5de64157aa..5501f0cc1f 100644 --- a/test/parallel/test-stream-transform-split-highwatermark.js +++ b/test/parallel/test-stream-transform-split-highwatermark.js @@ -3,26 +3,20 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Transform = _require.Transform, - Readable = _require.Readable, - Writable = _require.Writable; - + Transform = _require.Transform, + Readable = _require.Readable, + Writable = _require.Writable; var DEFAULT = 16 * 1024; - function testTransform(expectedReadableHwm, expectedWritableHwm, options) { var t = new Transform(options); assert.strictEqual(t._readableState.highWaterMark, expectedReadableHwm); assert.strictEqual(t._writableState.highWaterMark, expectedWritableHwm); -} // test overriding defaultHwm - +} +// test overriding defaultHwm testTransform(666, DEFAULT, { readableHighWaterMark: 666 }); @@ -32,15 +26,17 @@ testTransform(DEFAULT, 777, { testTransform(666, 777, { readableHighWaterMark: 666, writableHighWaterMark: 777 -}); // test 0 overriding defaultHwm +}); +// test 0 overriding defaultHwm testTransform(0, DEFAULT, { readableHighWaterMark: 0 }); testTransform(DEFAULT, 0, { writableHighWaterMark: 0 -}); // test highWaterMark overriding +}); +// test highWaterMark overriding testTransform(555, 555, { highWaterMark: 555, readableHighWaterMark: 666 @@ -53,8 +49,9 @@ testTransform(555, 555, { highWaterMark: 555, readableHighWaterMark: 666, writableHighWaterMark: 777 -}); // test highWaterMark = 0 overriding +}); +// test highWaterMark = 0 overriding testTransform(0, 0, { highWaterMark: 0, readableHighWaterMark: 666 @@ -67,8 +64,9 @@ testTransform(0, 0, { highWaterMark: 0, readableHighWaterMark: 666, writableHighWaterMark: 777 -}); // test undefined, null +}); +// test undefined, null [undefined, null].forEach(function (v) { testTransform(DEFAULT, DEFAULT, { readableHighWaterMark: v @@ -84,8 +82,9 @@ testTransform(0, 0, { highWaterMark: v, writableHighWaterMark: 777 }); -}); // test NaN +}); +// test NaN { common.expectsError(function () { new Transform({ @@ -105,8 +104,9 @@ testTransform(0, 0, { code: 'ERR_INVALID_OPT_VALUE', message: 'The value "NaN" is invalid for option "writableHighWaterMark"' }); -} // test non Duplex streams ignore the options +} +// test non Duplex streams ignore the options { var r = new Readable({ readableHighWaterMark: 666 @@ -118,19 +118,13 @@ testTransform(0, 0, { assert.strictEqual(w._writableState.highWaterMark, DEFAULT); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-transform-split-objectmode.js b/test/parallel/test-stream-transform-split-objectmode.js index e2349c1862..4236630bef 100644 --- a/test/parallel/test-stream-transform-split-objectmode.js +++ b/test/parallel/test-stream-transform-split-objectmode.js @@ -24,14 +24,9 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var Transform = require('../../').Transform; - var parser = new Transform({ readableObjectMode: true }); @@ -41,13 +36,11 @@ 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] }); }; - var parsed; parser.on('data', function (obj) { parsed = obj; @@ -65,11 +58,9 @@ 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])); }; - var serialized; serializer.on('data', function (chunk) { serialized = chunk; @@ -81,19 +72,13 @@ process.on('exit', function () { assert.strictEqual(serialized[0], 42); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-uint8array.js b/test/parallel/test-stream-uint8array.js index b5b767270c..df7cf8d744 100644 --- a/test/parallel/test-stream-uint8array.js +++ b/test/parallel/test-stream-uint8array.js @@ -1,42 +1,34 @@ "use strict"; -function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); } - -function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); } - -function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); } - -function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } } - +function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } +function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } +function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } +function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable, - Writable = _require.Writable; - + Readable = _require.Readable, + Writable = _require.Writable; var ABC = new Uint8Array([0x41, 0x42, 0x43]); var DEF = new Uint8Array([0x44, 0x45, 0x46]); var GHI = new Uint8Array([0x47, 0x48, 0x49]); { // Simple Writable test. + var n = 0; var writable = new Writable({ write: common.mustCall(function (chunk, encoding, cb) { assert(chunk instanceof Buffer); - if (n++ === 0) { assert.strictEqual(String(chunk), 'ABC'); } else { assert.strictEqual(String(chunk), 'DEF'); } - cb(); }, 2) }); @@ -45,6 +37,7 @@ var GHI = new Uint8Array([0x47, 0x48, 0x49]); } { // Writable test, pass in Uint8Array in object mode. + var _writable = new Writable({ objectMode: true, write: common.mustCall(function (chunk, encoding, cb) { @@ -55,13 +48,11 @@ var GHI = new Uint8Array([0x47, 0x48, 0x49]); cb(); }) }); - _writable.end(ABC); } { // Writable test, multiple writes carried out via writev. var callback; - var _writable2 = new Writable({ write: common.mustCall(function (chunk, encoding, cb) { assert(chunk instanceof Buffer); @@ -76,13 +67,9 @@ var GHI = new Uint8Array([0x47, 0x48, 0x49]); assert.strictEqual(chunks[0].chunk + chunks[1].chunk, 'DEFGHI'); }) }); - _writable2.write(ABC); - _writable2.write(DEF); - _writable2.end(GHI); - callback(); } { @@ -101,31 +88,20 @@ var GHI = new Uint8Array([0x47, 0x48, 0x49]); var _readable = new Readable({ read: function read() {} }); - _readable.setEncoding('utf8'); - _readable.push(DEF); - _readable.unshift(ABC); - var out = _readable.read(); - assert.strictEqual(out, 'ABCDEF'); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-unpipe-event.js b/test/parallel/test-stream-unpipe-event.js index 797e03182d..ebd402e288 100644 --- a/test/parallel/test-stream-unpipe-event.js +++ b/test/parallel/test-stream-unpipe-event.js @@ -1,100 +1,71 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } if (process.version.indexOf('v0.8') === 0) { process.exit(0); } /**/ - - var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Writable = _require.Writable, - Readable = _require.Readable; - -var NullWriteable = -/*#__PURE__*/ -function (_Writable) { + Writable = _require.Writable, + Readable = _require.Readable; +var NullWriteable = /*#__PURE__*/function (_Writable) { _inherits(NullWriteable, _Writable); - + var _super = _createSuper(NullWriteable); function NullWriteable() { _classCallCheck(this, NullWriteable); - - return _possibleConstructorReturn(this, _getPrototypeOf(NullWriteable).apply(this, arguments)); + return _super.apply(this, arguments); } - _createClass(NullWriteable, [{ key: "_write", value: function _write(chunk, encoding, callback) { return callback(); } }]); - return NullWriteable; }(Writable); - -var QuickEndReadable = -/*#__PURE__*/ -function (_Readable) { +var QuickEndReadable = /*#__PURE__*/function (_Readable) { _inherits(QuickEndReadable, _Readable); - + var _super2 = _createSuper(QuickEndReadable); function QuickEndReadable() { _classCallCheck(this, QuickEndReadable); - - return _possibleConstructorReturn(this, _getPrototypeOf(QuickEndReadable).apply(this, arguments)); + return _super2.apply(this, arguments); } - _createClass(QuickEndReadable, [{ key: "_read", value: function _read() { this.push(null); } }]); - return QuickEndReadable; }(Readable); - -var NeverEndReadable = -/*#__PURE__*/ -function (_Readable2) { +var NeverEndReadable = /*#__PURE__*/function (_Readable2) { _inherits(NeverEndReadable, _Readable2); - + var _super3 = _createSuper(NeverEndReadable); function NeverEndReadable() { _classCallCheck(this, NeverEndReadable); - - return _possibleConstructorReturn(this, _getPrototypeOf(NeverEndReadable).apply(this, arguments)); + return _super3.apply(this, arguments); } - _createClass(NeverEndReadable, [{ key: "_read", value: function _read() {} }]); - return NeverEndReadable; }(Readable); - { var dest = new NullWriteable(); var src = new QuickEndReadable(); @@ -107,103 +78,70 @@ function (_Readable2) { } { var _dest = new NullWriteable(); - var _src = new NeverEndReadable(); - _dest.on('pipe', common.mustCall()); - _dest.on('unpipe', common.mustNotCall('unpipe should not have been emitted')); - _src.pipe(_dest); - setImmediate(function () { assert.strictEqual(_src._readableState.pipesCount, 1); }); } { var _dest2 = new NullWriteable(); - var _src2 = new NeverEndReadable(); - _dest2.on('pipe', common.mustCall()); - _dest2.on('unpipe', common.mustCall()); - _src2.pipe(_dest2); - _src2.unpipe(_dest2); - setImmediate(function () { assert.strictEqual(_src2._readableState.pipesCount, 0); }); } { var _dest3 = new NullWriteable(); - var _src3 = new QuickEndReadable(); - _dest3.on('pipe', common.mustCall()); - _dest3.on('unpipe', common.mustCall()); - _src3.pipe(_dest3, { end: false }); - setImmediate(function () { assert.strictEqual(_src3._readableState.pipesCount, 0); }); } { var _dest4 = new NullWriteable(); - var _src4 = new NeverEndReadable(); - _dest4.on('pipe', common.mustCall()); - _dest4.on('unpipe', common.mustNotCall('unpipe should not have been emitted')); - _src4.pipe(_dest4, { end: false }); - setImmediate(function () { assert.strictEqual(_src4._readableState.pipesCount, 1); }); } { var _dest5 = new NullWriteable(); - var _src5 = new NeverEndReadable(); - _dest5.on('pipe', common.mustCall()); - _dest5.on('unpipe', common.mustCall()); - _src5.pipe(_dest5, { end: false }); - _src5.unpipe(_dest5); - setImmediate(function () { assert.strictEqual(_src5._readableState.pipesCount, 0); }); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-unshift-empty-chunk.js b/test/parallel/test-stream-unshift-empty-chunk.js index 2157dff99f..b36124f143 100644 --- a/test/parallel/test-stream-unshift-empty-chunk.js +++ b/test/parallel/test-stream-unshift-empty-chunk.js @@ -24,38 +24,31 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); +var assert = require('assert/'); -var assert = require('assert/'); // This test verifies that stream.unshift(bufferShim.alloc(0)) or +// This test verifies that stream.unshift(bufferShim.alloc(0)) or // stream.unshift('') does not set state.reading=false. - - var Readable = require('../../').Readable; - var r = new Readable(); var nChunks = 10; var chunk = bufferShim.alloc(10, 'x'); - r._read = function (n) { setImmediate(function () { r.push(--nChunks === 0 ? null : chunk); }); }; - var readAll = false; var seen = []; r.on('readable', function () { var chunk; - while (chunk = r.read()) { - seen.push(chunk.toString()); // simulate only reading a certain amount of the data, + seen.push(chunk.toString()); + // simulate only reading a certain amount of the data, // and then putting the rest of the chunk back into the // stream, like a parser might do. We just fill it with // 'y' so that it's easy to see which bits were touched, // and which were not. - var putBack = bufferShim.alloc(readAll ? 0 : 5, 'y'); readAll = !readAll; r.unshift(putBack); @@ -64,23 +57,16 @@ r.on('readable', function () { var expect = ['xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy']; r.on('end', function () { assert.deepStrictEqual(seen, expect); - require('tap').pass(); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-unshift-read-race.js b/test/parallel/test-stream-unshift-read-race.js index fc0c64df48..375b9b321b 100644 --- a/test/parallel/test-stream-unshift-read-race.js +++ b/test/parallel/test-stream-unshift-read-race.js @@ -24,45 +24,38 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); +var assert = require('assert/'); -var assert = require('assert/'); // This test verifies that: +// This test verifies that: // 1. unshift() does not cause colliding _read() calls. // 2. unshift() after the 'end' event is an error, but after the EOF // signalling null, it is ok, and just creates a new readable chunk. // 3. push() after the EOF signaling null is an error. // 4. _read() is not called after pushing the EOF null chunk. - var stream = require('../../'); - var hwm = 10; var r = stream.Readable({ highWaterMark: hwm }); var chunks = 10; var data = bufferShim.allocUnsafe(chunks * hwm + Math.ceil(hwm / 2)); - for (var i = 0; i < data.length; i++) { var c = 'asdf'.charCodeAt(i % 4); data[i] = c; } - var pos = 0; var pushedNull = false; - r._read = function (n) { - assert(!pushedNull, '_read after null push'); // every third chunk is fast + assert(!pushedNull, '_read after null push'); + // every third chunk is fast push(!(chunks % 3)); - function push(fast) { assert(!pushedNull, 'push() after null push'); var c = pos >= data.length ? null : data.slice(pos, pos + n); pushedNull = c === null; - if (fast) { pos += n; r.push(c); @@ -76,7 +69,6 @@ r._read = function (n) { } } }; - function pushError() { common.expectsError(function () { r.push(bufferShim.allocUnsafe(1)); @@ -86,15 +78,12 @@ function pushError() { message: 'stream.push() after EOF' }); } - var w = stream.Writable(); var written = []; - w._write = function (chunk, encoding, cb) { written.push(chunk.toString()); cb(); }; - r.on('end', common.mustCall(function () { common.expectsError(function () { r.unshift(bufferShim.allocUnsafe(1)); @@ -107,7 +96,6 @@ r.on('end', common.mustCall(function () { })); r.on('readable', function () { var chunk; - while (null !== (chunk = r.read(10))) { w.write(chunk); if (chunk.length > 4) r.unshift(bufferShim.from('1234')); @@ -120,29 +108,22 @@ w.on('finish', common.mustCall(function () { assert.strictEqual(written[0], 'asdfasdfas'); var asdf = 'd'; console.error("0: ".concat(written[0])); - for (var _i = 1; _i < written.length; _i++) { console.error("".concat(_i.toString(32), ": ").concat(written[_i])); assert.strictEqual(written[_i].slice(0, 4), '1234'); - for (var j = 4; j < written[_i].length; j++) { var _c = written[_i].charAt(j); - assert.strictEqual(_c, asdf); - switch (asdf) { case 'a': asdf = 's'; break; - case 's': asdf = 'd'; break; - case 'd': asdf = 'f'; break; - case 'f': asdf = 'a'; break; @@ -152,23 +133,16 @@ w.on('finish', common.mustCall(function () { })); process.on('exit', function () { assert.strictEqual(written.length, 18); - require('tap').pass(); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writable-change-default-encoding.js b/test/parallel/test-stream-writable-change-default-encoding.js index 441dc637e5..102426957a 100644 --- a/test/parallel/test-stream-writable-change-default-encoding.js +++ b/test/parallel/test-stream-writable-change-default-encoding.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -40,29 +36,19 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - -var MyWritable = -/*#__PURE__*/ -function (_stream$Writable) { +var MyWritable = /*#__PURE__*/function (_stream$Writable) { _inherits(MyWritable, _stream$Writable); - + var _super = _createSuper(MyWritable); function MyWritable(fn, options) { var _this; - _classCallCheck(this, MyWritable); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(MyWritable).call(this, options)); + _this = _super.call(this, options); _this.fn = fn; return _this; } - _createClass(MyWritable, [{ key: "_write", value: function _write(chunk, encoding, callback) { @@ -70,10 +56,8 @@ function (_stream$Writable) { callback(); } }]); - return MyWritable; }(stream.Writable); - (function defaultCondingIsUtf8() { var m = new MyWritable(function (isBuffer, type, enc) { assert.strictEqual(enc, 'utf8'); @@ -83,7 +67,6 @@ function (_stream$Writable) { m.write('foo'); m.end(); })(); - (function changeDefaultEncodingToAscii() { var m = new MyWritable(function (isBuffer, type, enc) { assert.strictEqual(enc, 'ascii'); @@ -94,7 +77,6 @@ function (_stream$Writable) { m.write('bar'); m.end(); })(); - common.expectsError(function changeDefaultEncodingToInvalidValue() { var m = new MyWritable(function (isBuffer, type, enc) {}, { decodeStrings: false @@ -107,7 +89,6 @@ common.expectsError(function changeDefaultEncodingToInvalidValue() { code: 'ERR_UNKNOWN_ENCODING', message: 'Unknown encoding: [object Object]' }); - (function checkVairableCaseEncoding() { var m = new MyWritable(function (isBuffer, type, enc) { assert.strictEqual(enc, 'ascii'); @@ -118,21 +99,14 @@ common.expectsError(function changeDefaultEncodingToInvalidValue() { m.write('bar'); m.end(); })(); - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writable-constructor-set-methods.js b/test/parallel/test-stream-writable-constructor-set-methods.js index 8d4938822b..090f8b9220 100644 --- a/test/parallel/test-stream-writable-constructor-set-methods.js +++ b/test/parallel/test-stream-writable-constructor-set-methods.js @@ -3,16 +3,11 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var _require = require('assert/'), - strictEqual = _require.strictEqual; - + strictEqual = _require.strictEqual; var _require2 = require('../../'), - Writable = _require2.Writable; - + Writable = _require2.Writable; var w = new Writable(); w.on('error', common.expectsError({ type: Error, @@ -20,16 +15,13 @@ w.on('error', common.expectsError({ message: 'The _write() method is not implemented' })); w.end(bufferShim.from('blerg')); - var _write = common.mustCall(function (chunk, _, next) { next(); }); - var _writev = common.mustCall(function (chunks, next) { strictEqual(chunks.length, 2); next(); }); - var w2 = new Writable({ write: _write, writev: _writev @@ -42,19 +34,13 @@ w2.write(bufferShim.from('blerg')); w2.write(bufferShim.from('blerg')); w2.end(); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writable-decoded-encoding.js b/test/parallel/test-stream-writable-decoded-encoding.js index 1bf9ed6ea3..5a23b8cd11 100644 --- a/test/parallel/test-stream-writable-decoded-encoding.js +++ b/test/parallel/test-stream-writable-decoded-encoding.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -40,29 +36,19 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - -var MyWritable = -/*#__PURE__*/ -function (_stream$Writable) { +var MyWritable = /*#__PURE__*/function (_stream$Writable) { _inherits(MyWritable, _stream$Writable); - + var _super = _createSuper(MyWritable); function MyWritable(fn, options) { var _this; - _classCallCheck(this, MyWritable); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(MyWritable).call(this, options)); + _this = _super.call(this, options); _this.fn = fn; return _this; } - _createClass(MyWritable, [{ key: "_write", value: function _write(chunk, encoding, callback) { @@ -70,10 +56,8 @@ function (_stream$Writable) { callback(); } }]); - return MyWritable; }(stream.Writable); - { var m = new MyWritable(function (isBuffer, type, enc) { assert(isBuffer); @@ -93,25 +77,17 @@ function (_stream$Writable) { }, { decodeStrings: false }); - _m.write('some-text', 'utf8'); - _m.end(); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writable-destroy.js b/test/parallel/test-stream-writable-destroy.js index dfc88f8166..a6e2f83d27 100644 --- a/test/parallel/test-stream-writable-destroy.js +++ b/test/parallel/test-stream-writable-destroy.js @@ -4,14 +4,10 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var _require = require('../../'), - Writable = _require.Writable; - + Writable = _require.Writable; var assert = require('assert/'); - { var write = new Writable({ write: function write(chunk, enc, cb) { @@ -29,19 +25,13 @@ var assert = require('assert/'); cb(); } }); - var expected = new Error('kaboom'); - _write.on('finish', common.mustNotCall()); - _write.on('close', common.mustCall()); - _write.on('error', common.mustCall(function (err) { assert.strictEqual(err, expected); })); - _write.destroy(expected); - assert.strictEqual(_write.destroyed, true); } { @@ -50,24 +40,17 @@ var assert = require('assert/'); cb(); } }); - _write2._destroy = function (err, cb) { assert.strictEqual(err, _expected); cb(err); }; - var _expected = new Error('kaboom'); - _write2.on('finish', common.mustNotCall('no finish event')); - _write2.on('close', common.mustCall()); - _write2.on('error', common.mustCall(function (err) { assert.strictEqual(err, _expected); })); - _write2.destroy(_expected); - assert.strictEqual(_write2.destroyed, true); } { @@ -80,18 +63,13 @@ var assert = require('assert/'); cb(); }) }); - var _expected2 = new Error('kaboom'); - _write3.on('finish', common.mustNotCall('no finish event')); + _write3.on('close', common.mustCall()); - _write3.on('close', common.mustCall()); // error is swallowed by the custom _destroy - - + // error is swallowed by the custom _destroy _write3.on('error', common.mustNotCall('no error event')); - _write3.destroy(_expected2); - assert.strictEqual(_write3.destroyed, true); } { @@ -100,14 +78,11 @@ var assert = require('assert/'); cb(); } }); - _write4._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, null); cb(); }); - _write4.destroy(); - assert.strictEqual(_write4.destroyed, true); } { @@ -116,29 +91,20 @@ var assert = require('assert/'); cb(); } }); - _write5._destroy = common.mustCall(function (err, cb) { var _this = this; - assert.strictEqual(err, null); process.nextTick(function () { _this.end(); - cb(); }); }); var fail = common.mustNotCall('no finish event'); - _write5.on('finish', fail); - _write5.on('close', common.mustCall()); - _write5.destroy(); - _write5.removeListener('finish', fail); - _write5.on('finish', common.mustCall()); - assert.strictEqual(_write5.destroyed, true); } { @@ -147,24 +113,17 @@ var assert = require('assert/'); cb(); } }); - var _expected3 = new Error('kaboom'); - _write6._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, null); cb(_expected3); }); - _write6.on('close', common.mustCall()); - _write6.on('finish', common.mustNotCall('no finish event')); - _write6.on('error', common.mustCall(function (err) { assert.strictEqual(err, _expected3); })); - _write6.destroy(); - assert.strictEqual(_write6.destroyed, true); } { @@ -174,15 +133,10 @@ var assert = require('assert/'); cb(); } }); - _write7.on('close', common.mustCall()); - _write7.on('error', common.mustCall()); - _write7.destroy(new Error('kaboom 1')); - _write7.destroy(new Error('kaboom 2')); - assert.strictEqual(_write7._writableState.errorEmitted, true); assert.strictEqual(_write7.destroyed, true); } @@ -202,9 +156,10 @@ var assert = require('assert/'); })); writable.destroy(); assert.strictEqual(writable.destroyed, true); - assert.strictEqual(writable._writableState.errorEmitted, false); // Test case where `writable.destroy()` is called again with an error before - // the `_destroy()` callback is called. + assert.strictEqual(writable._writableState.errorEmitted, false); + // Test case where `writable.destroy()` is called again with an error before + // the `_destroy()` callback is called. writable.destroy(new Error('kaboom 2')); assert.strictEqual(writable._writableState.errorEmitted, true); } @@ -214,21 +169,19 @@ var assert = require('assert/'); cb(); } }); - _write8.destroyed = true; - assert.strictEqual(_write8.destroyed, true); // the internal destroy() mechanism should not be triggered + assert.strictEqual(_write8.destroyed, true); + // the internal destroy() mechanism should not be triggered _write8.on('close', common.mustNotCall()); - _write8.destroy(); } { - function MyWritable() { + var MyWritable = function MyWritable() { assert.strictEqual(this.destroyed, false); this.destroyed = false; Writable.call(this); - } - + }; Object.setPrototypeOf(MyWritable.prototype, Writable.prototype); Object.setPrototypeOf(MyWritable, Writable); new MyWritable(); @@ -240,11 +193,8 @@ var assert = require('assert/'); cb(); } }); - _write9.destroy(); - var _expected4 = new Error('kaboom'); - _write9.destroy(_expected4, common.mustCall(function (err) { assert.strictEqual(err, _expected4); })); @@ -258,29 +208,19 @@ var assert = require('assert/'); return cb(); }, 2) }); - _write10.end(); - _write10.destroy(); - _write10._undestroy(); - _write10.end(); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writable-ended-state.js b/test/parallel/test-stream-writable-ended-state.js index ac8c6f44b4..3d24d20bbe 100644 --- a/test/parallel/test-stream-writable-ended-state.js +++ b/test/parallel/test-stream-writable-ended-state.js @@ -4,39 +4,27 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var writable = new stream.Writable(); - writable._write = function (chunk, encoding, cb) { assert.strictEqual(writable._writableState.ended, false); cb(); }; - assert.strictEqual(writable._writableState.ended, false); writable.end('testing ended state', common.mustCall(function () { assert.strictEqual(writable._writableState.ended, true); })); assert.strictEqual(writable._writableState.ended, true); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writable-finished-state.js b/test/parallel/test-stream-writable-finished-state.js index 641602a093..ce2bf9ef25 100644 --- a/test/parallel/test-stream-writable-finished-state.js +++ b/test/parallel/test-stream-writable-finished-state.js @@ -4,21 +4,15 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var writable = new stream.Writable(); - writable._write = function (chunk, encoding, cb) { // The state finished should start in false. assert.strictEqual(writable._writableState.finished, false); cb(); }; - writable.on('finish', common.mustCall(function () { assert.strictEqual(writable._writableState.finished, true); })); @@ -26,19 +20,13 @@ writable.end('testing finished state', common.mustCall(function () { assert.strictEqual(writable._writableState.finished, true); })); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writable-needdrain-state.js b/test/parallel/test-stream-writable-needdrain-state.js index 0dc2b1152b..f8076e147d 100644 --- a/test/parallel/test-stream-writable-needdrain-state.js +++ b/test/parallel/test-stream-writable-needdrain-state.js @@ -4,42 +4,30 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var stream = require('../../'); - var assert = require('assert/'); - var transform = new stream.Transform({ transform: _transform, highWaterMark: 1 }); - function _transform(chunk, encoding, cb) { assert.strictEqual(transform._writableState.needDrain, true); cb(); } - assert.strictEqual(transform._writableState.needDrain, false); transform.write('asdasd', common.mustCall(function () { assert.strictEqual(transform._writableState.needDrain, false); })); assert.strictEqual(transform._writableState.needDrain, true); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writable-null.js b/test/parallel/test-stream-writable-null.js index a6e8794a33..88fc5b4230 100644 --- a/test/parallel/test-stream-writable-null.js +++ b/test/parallel/test-stream-writable-null.js @@ -1,43 +1,30 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - -var MyWritable = -/*#__PURE__*/ -function (_stream$Writable) { +var MyWritable = /*#__PURE__*/function (_stream$Writable) { _inherits(MyWritable, _stream$Writable); - + var _super = _createSuper(MyWritable); function MyWritable() { _classCallCheck(this, MyWritable); - - return _possibleConstructorReturn(this, _getPrototypeOf(MyWritable).apply(this, arguments)); + return _super.apply(this, arguments); } - _createClass(MyWritable, [{ key: "_write", value: function _write(chunk, encoding, callback) { @@ -45,10 +32,8 @@ function (_stream$Writable) { callback(); } }]); - return MyWritable; }(stream.Writable); - common.expectsError(function () { var m = new MyWritable({ objectMode: true @@ -80,7 +65,6 @@ common.expectsError(function () { { // Should not throw. var _m = new MyWritable().on('error', assert); - _m.write(false, assert); } { @@ -88,7 +72,6 @@ common.expectsError(function () { var _m2 = new MyWritable({ objectMode: true }); - _m2.write(false, assert.ifError); } { @@ -98,23 +81,16 @@ common.expectsError(function () { }).on('error', function (e) { assert.ifError(e || new Error('should not get here')); }); - _m3.write(false, assert.ifError); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writable-write-cb-twice.js b/test/parallel/test-stream-writable-write-cb-twice.js index 9f3fbc3ebc..60146b904d 100644 --- a/test/parallel/test-stream-writable-write-cb-twice.js +++ b/test/parallel/test-stream-writable-write-cb-twice.js @@ -3,13 +3,9 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var _require = require('../../'), - Writable = _require.Writable; - + Writable = _require.Writable; { // Sync + Sync var writable = new Writable({ @@ -36,7 +32,6 @@ var _require = require('../../'), }); }) }); - _writable.write('hi'); } { @@ -52,23 +47,16 @@ var _require = require('../../'), }); }) }); - _writable2.write('hi'); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writable-write-writev-finish.js b/test/parallel/test-stream-writable-write-writev-finish.js index 135230fe10..8f83069ad1 100644 --- a/test/parallel/test-stream-writable-write-writev-finish.js +++ b/test/parallel/test-stream-writable-write-writev-finish.js @@ -4,22 +4,18 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var assert = require('assert/'); +var stream = require('../../'); -var stream = require('../../'); // ensure consistency between the finish event when using cork() +// ensure consistency between the finish event when using cork() // and writev and when not using them - { var writable = new stream.Writable(); - writable._write = function (chunks, encoding, cb) { cb(new Error('write test error')); }; - var firstError = false; writable.on('finish', common.mustCall(function () { assert.strictEqual(firstError, true); @@ -33,99 +29,75 @@ var stream = require('../../'); // ensure consistency between the finish event w } { var _writable = new stream.Writable(); - _writable._write = function (chunks, encoding, cb) { setImmediate(cb, new Error('write test error')); }; - var _firstError = false; - _writable.on('finish', common.mustCall(function () { assert.strictEqual(_firstError, true); })); - _writable.on('prefinish', common.mustCall()); - _writable.on('error', common.mustCall(function (er) { assert.strictEqual(er.message, 'write test error'); _firstError = true; })); - _writable.end('test'); } { var _writable2 = new stream.Writable(); - _writable2._write = function (chunks, encoding, cb) { cb(new Error('write test error')); }; - _writable2._writev = function (chunks, cb) { cb(new Error('writev test error')); }; - var _firstError2 = false; - _writable2.on('finish', common.mustCall(function () { assert.strictEqual(_firstError2, true); })); - _writable2.on('prefinish', common.mustCall()); - _writable2.on('error', common.mustCall(function (er) { assert.strictEqual(er.message, 'writev test error'); _firstError2 = true; })); - _writable2.cork(); - _writable2.write('test'); - setImmediate(function () { _writable2.end('test'); }); } { var _writable3 = new stream.Writable(); - _writable3._write = function (chunks, encoding, cb) { setImmediate(cb, new Error('write test error')); }; - _writable3._writev = function (chunks, cb) { setImmediate(cb, new Error('writev test error')); }; - var _firstError3 = false; - _writable3.on('finish', common.mustCall(function () { assert.strictEqual(_firstError3, true); })); - _writable3.on('prefinish', common.mustCall()); - _writable3.on('error', common.mustCall(function (er) { assert.strictEqual(er.message, 'writev test error'); _firstError3 = true; })); - _writable3.cork(); - _writable3.write('test'); - setImmediate(function () { _writable3.end('test'); }); -} // Regression test for +} + +// Regression test for // https://github.com/nodejs/node/issues/13812 { var rs = new stream.Readable(); rs.push('ok'); rs.push(null); - rs._read = function () {}; - var ws = new stream.Writable(); var _firstError4 = false; ws.on('finish', common.mustCall(function () { @@ -134,41 +106,29 @@ var stream = require('../../'); // ensure consistency between the finish event w ws.on('error', common.mustCall(function () { _firstError4 = true; })); - ws._write = function (chunk, encoding, done) { setImmediate(done, new Error()); }; - rs.pipe(ws); } { var _rs = new stream.Readable(); - _rs.push('ok'); - _rs.push(null); - _rs._read = function () {}; - var _ws = new stream.Writable(); - _ws.on('finish', common.mustNotCall()); - _ws.on('error', common.mustCall()); - _ws._write = function (chunk, encoding, done) { done(new Error()); }; - _rs.pipe(_ws); } { var w = new stream.Writable(); - w._write = function (chunk, encoding, cb) { process.nextTick(cb); }; - w.on('error', common.mustCall()); w.on('prefinish', function () { w.write("shouldn't write in prefinish listener"); @@ -177,33 +137,23 @@ var stream = require('../../'); // ensure consistency between the finish event w } { var _w = new stream.Writable(); - _w._write = function (chunk, encoding, cb) { process.nextTick(cb); }; - _w.on('error', common.mustCall()); - _w.on('finish', function () { _w.write("shouldn't write in finish listener"); }); - _w.end(); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writableState-ending.js b/test/parallel/test-stream-writableState-ending.js index 49754b4385..9be0e94d07 100644 --- a/test/parallel/test-stream-writableState-ending.js +++ b/test/parallel/test-stream-writableState-ending.js @@ -4,27 +4,20 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var writable = new stream.Writable(); - function testStates(ending, finished, ended) { assert.strictEqual(writable._writableState.ending, ending); assert.strictEqual(writable._writableState.finished, finished); assert.strictEqual(writable._writableState.ended, ended); } - writable._write = function (chunk, encoding, cb) { // ending, finished, ended start in false. testStates(false, false, false); cb(); }; - writable.on('finish', function () { // ending, finished, ended = true. testStates(true, true, true); @@ -32,26 +25,22 @@ writable.on('finish', function () { var result = writable.end('testing function end()', function () { // ending, finished, ended = true. testStates(true, true, true); -}); // end returns the writable instance +}); -assert.strictEqual(result, writable); // ending, ended = true. -// finished = false. +// end returns the writable instance +assert.strictEqual(result, writable); +// ending, ended = true. +// finished = false. testStates(true, false, true); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writableState-uncorked-bufferedRequestCount.js b/test/parallel/test-stream-writableState-uncorked-bufferedRequestCount.js index d3efeb7ab8..331c51e10b 100644 --- a/test/parallel/test-stream-writableState-uncorked-bufferedRequestCount.js +++ b/test/parallel/test-stream-writableState-uncorked-bufferedRequestCount.js @@ -4,13 +4,9 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var writable = new stream.Writable(); writable._writev = common.mustCall(function (chunks, cb) { assert.strictEqual(chunks.length, 2); @@ -18,55 +14,54 @@ writable._writev = common.mustCall(function (chunks, cb) { }, 1); writable._write = common.mustCall(function (chunk, encoding, cb) { cb(); -}, 1); // first cork +}, 1); +// first cork writable.cork(); assert.strictEqual(writable._writableState.corked, 1); -assert.strictEqual(writable._writableState.bufferedRequestCount, 0); // cork again +assert.strictEqual(writable._writableState.bufferedRequestCount, 0); +// cork again writable.cork(); -assert.strictEqual(writable._writableState.corked, 2); // the first chunk is buffered +assert.strictEqual(writable._writableState.corked, 2); +// the first chunk is buffered writable.write('first chunk'); -assert.strictEqual(writable._writableState.bufferedRequestCount, 1); // first uncork does nothing +assert.strictEqual(writable._writableState.bufferedRequestCount, 1); +// first uncork does nothing writable.uncork(); assert.strictEqual(writable._writableState.corked, 1); assert.strictEqual(writable._writableState.bufferedRequestCount, 1); -process.nextTick(uncork); // the second chunk is buffered, because we uncork at the end of tick +process.nextTick(uncork); +// the second chunk is buffered, because we uncork at the end of tick writable.write('second chunk'); assert.strictEqual(writable._writableState.corked, 1); assert.strictEqual(writable._writableState.bufferedRequestCount, 2); - function uncork() { // second uncork flushes the buffer writable.uncork(); assert.strictEqual(writable._writableState.corked, 0); - assert.strictEqual(writable._writableState.bufferedRequestCount, 0); // verify that end() uncorks correctly + assert.strictEqual(writable._writableState.bufferedRequestCount, 0); + // verify that end() uncorks correctly writable.cork(); writable.write('third chunk'); - writable.end(); // end causes an uncork() as well + writable.end(); + // end causes an uncork() as well assert.strictEqual(writable._writableState.corked, 0); assert.strictEqual(writable._writableState.bufferedRequestCount, 0); } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-write-destroy.js b/test/parallel/test-stream-write-destroy.js index 6528b2bacd..e321fa33d9 100644 --- a/test/parallel/test-stream-write-destroy.js +++ b/test/parallel/test-stream-write-destroy.js @@ -3,20 +3,16 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Writable = _require.Writable; // Test interaction between calling .destroy() on a writable and pending -// writes. + Writable = _require.Writable; +// Test interaction between calling .destroy() on a writable and pending +// writes. for (var _i = 0, _arr = [false, true]; _i < _arr.length; _i++) { var withPendingData = _arr[_i]; - var _loop = function _loop() { var useEnd = _arr2[_i2]; var callbacks = []; @@ -44,7 +40,6 @@ for (var _i = 0, _arr = [false, true]; _i < _arr.length; _i++) { callbacks.shift()(); assert.strictEqual(chunksWritten, 1); assert.strictEqual(drains, 1); - if (withPendingData) { // Test 2 cases: There either is or is not data still in the write queue. // (The second write will never actually get executed either way.) @@ -52,7 +47,6 @@ for (var _i = 0, _arr = [false, true]; _i < _arr.length; _i++) { return chunksWritten++; }); } - if (useEnd) { // Again, test 2 cases: Either we indicate that we want to end the // writable or not. @@ -64,38 +58,30 @@ for (var _i = 0, _arr = [false, true]; _i < _arr.length; _i++) { return chunksWritten++; }); } - assert.strictEqual(chunksWritten, 1); w.destroy(); assert.strictEqual(chunksWritten, 1); callbacks.shift()(); assert.strictEqual(chunksWritten, 2); assert.strictEqual(callbacks.length, 0); - assert.strictEqual(drains, 1); // When we used `.end()`, we see the 'finished' event if and only if - // we actually finished processing the write queue. + assert.strictEqual(drains, 1); + // When we used `.end()`, we see the 'finished' event if and only if + // we actually finished processing the write queue. assert.strictEqual(finished, !withPendingData && useEnd); }; - for (var _i2 = 0, _arr2 = [false, true]; _i2 < _arr2.length; _i2++) { _loop(); } } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-write-final.js b/test/parallel/test-stream-write-final.js index 3f7ba25754..0a0d1a16a7 100644 --- a/test/parallel/test-stream-write-final.js +++ b/test/parallel/test-stream-write-final.js @@ -3,14 +3,9 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var shutdown = false; var w = new stream.Writable({ final: common.mustCall(function (cb) { @@ -30,19 +25,13 @@ w.on('finish', common.mustCall(function () { w.write(bufferShim.allocUnsafe(1)); w.end(bufferShim.allocUnsafe(0)); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream-writev.js b/test/parallel/test-stream-writev.js index ea0fcc8afa..c7d2152af8 100644 --- a/test/parallel/test-stream-writev.js +++ b/test/parallel/test-stream-writev.js @@ -24,16 +24,10 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var queue = []; - for (var decode = 0; decode < 2; decode++) { for (var uncork = 0; uncork < 2; uncork++) { for (var multi = 0; multi < 2; multi++) { @@ -41,20 +35,15 @@ for (var decode = 0; decode < 2; decode++) { } } } - run(); - function run() { var t = queue.pop(); if (t) test(t[0], t[1], t[2], run);else require('tap').pass(); } - function test(decode, uncork, multi, next) { require('tap').test("# decode=".concat(decode, " uncork=").concat(uncork, " multi=").concat(multi)); - var counter = 0; var expectCount = 0; - function cnt(msg) { expectCount++; var expect = expectCount; @@ -64,7 +53,6 @@ function test(decode, uncork, multi, next) { assert.strictEqual(counter, expect); }; } - var w = new stream.Writable({ decodeStrings: decode }); @@ -101,7 +89,6 @@ function test(decode, uncork, multi, next) { chunk: 'facebea7deadbeefdecafbad' }]; var actualChunks; - w._writev = function (chunks, cb) { actualChunks = chunks.map(function (chunk) { return { @@ -111,7 +98,6 @@ function test(decode, uncork, multi, next) { }); cb(); }; - w.cork(); w.write('hello, ', 'ascii', cnt('hello')); w.write('world', 'utf8', cnt('world')); @@ -129,21 +115,14 @@ function test(decode, uncork, multi, next) { next(); }); } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-base64-single-char-read-end.js b/test/parallel/test-stream2-base64-single-char-read-end.js index 5ee7b9d52e..64e7929a77 100644 --- a/test/parallel/test-stream2-base64-single-char-read-end.js +++ b/test/parallel/test-stream2-base64-single-char-read-end.js @@ -24,23 +24,16 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var R = require('../../lib/_stream_readable'); - var W = require('../../lib/_stream_writable'); - var assert = require('assert/'); - var src = new R({ encoding: 'base64' }); var dst = new W(); var hasRead = false; var accum = []; - src._read = function (n) { if (!hasRead) { hasRead = true; @@ -50,12 +43,10 @@ src._read = function (n) { }); } }; - dst._write = function (chunk, enc, cb) { accum.push(chunk); cb(); }; - src.on('end', function () { assert.strictEqual(String(Buffer.concat(accum)), 'MQ=='); clearTimeout(timeout); @@ -65,19 +56,13 @@ var timeout = setTimeout(function () { assert.fail('timed out waiting for _write'); }, 100); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-basic.js b/test/parallel/test-stream2-basic.js index 7a16dc3fbf..d0094c439e 100644 --- a/test/parallel/test-stream2-basic.js +++ b/test/parallel/test-stream2-basic.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -41,48 +37,35 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var R = require('../../lib/_stream_readable'); - var assert = require('assert/'); - var EE = require('events').EventEmitter; - -var TestReader = -/*#__PURE__*/ -function (_R) { +var TestReader = /*#__PURE__*/function (_R) { _inherits(TestReader, _R); - + var _super = _createSuper(TestReader); function TestReader(n) { var _this; - _classCallCheck(this, TestReader); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(TestReader).call(this)); + _this = _super.call(this); _this._buffer = bufferShim.alloc(n || 100, 'x'); _this._pos = 0; _this._bufs = 10; return _this; } - _createClass(TestReader, [{ key: "_read", value: function _read(n) { var _this2 = this; - var max = this._buffer.length - this._pos; n = Math.max(n, 0); var toRead = Math.min(n, max); - if (toRead === 0) { // simulate the read buffer filling up with some more bytes some time // in the future. setTimeout(function () { _this2._pos = 0; _this2._bufs -= 1; - if (_this2._bufs <= 0) { // read them all! if (!_this2.ended) _this2.push(null); @@ -95,33 +78,24 @@ function (_R) { }, 10); return; } - var ret = this._buffer.slice(this._pos, this._pos + toRead); - this._pos += toRead; this.push(ret); } }]); - return TestReader; }(R); - -var TestWriter = -/*#__PURE__*/ -function (_EE) { +var TestWriter = /*#__PURE__*/function (_EE) { _inherits(TestWriter, _EE); - + var _super2 = _createSuper(TestWriter); function TestWriter() { var _this3; - _classCallCheck(this, TestWriter); - - _this3 = _possibleConstructorReturn(this, _getPrototypeOf(TestWriter).call(this)); + _this3 = _super2.call(this); _this3.received = []; _this3.flush = false; return _this3; } - _createClass(TestWriter, [{ key: "write", value: function write(c) { @@ -136,11 +110,16 @@ function (_EE) { this.emit('end', this.received); } }]); - return TestWriter; }(EE); - { + var flow = function flow() { + var res; + while (null !== (res = r.read(readSize++))) { + reads.push(res.toString()); + } + r.once('readable', flow); + }; // Test basic functionality var r = new TestReader(20); var reads = []; @@ -149,35 +128,23 @@ function (_EE) { assert.deepStrictEqual(reads, expect); })); var readSize = 1; - - function flow() { - var res; - - while (null !== (res = r.read(readSize++))) { - reads.push(res.toString()); - } - - r.once('readable', flow); - } - flow(); } { // Verify pipe var _r = new TestReader(5); - var _expect = ['xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx']; var w = new TestWriter(); w.on('end', common.mustCall(function (received) { assert.deepStrictEqual(received, _expect); })); - _r.pipe(w); } forEach([1, 2, 3, 4, 5, 6, 7, 8, 9], function (SPLIT) { // Verify unpipe - var r = new TestReader(5); // unpipe after 3 writes, then write to another stream instead. + var r = new TestReader(5); + // unpipe after 3 writes, then write to another stream instead. var expect = ['xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx']; expect = [expect.slice(0, SPLIT), expect.slice(SPLIT)]; var w = [new TestWriter(), new TestWriter()]; @@ -207,26 +174,22 @@ forEach([1, 2, 3, 4, 5, 6, 7, 8, 9], function (SPLIT) { { // Verify both writers get the same data when piping to destinations var _r2 = new TestReader(5); - var _w = [new TestWriter(), new TestWriter()]; var _expect2 = ['xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx']; - _w[0].on('end', common.mustCall(function (received) { assert.deepStrictEqual(received, _expect2); })); - _w[1].on('end', common.mustCall(function (received) { assert.deepStrictEqual(received, _expect2); })); - _r2.pipe(_w[0]); - _r2.pipe(_w[1]); } forEach([1, 2, 3, 4, 5, 6, 7, 8, 9], function (SPLIT) { // Verify multi-unpipe - var r = new TestReader(5); // unpipe after 3 writes, then write to another stream instead. + var r = new TestReader(5); + // unpipe after 3 writes, then write to another stream instead. var expect = ['xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx', 'xxxxx']; expect = [expect.slice(0, SPLIT), expect.slice(SPLIT)]; var w = [new TestWriter(), new TestWriter(), new TestWriter()]; @@ -257,74 +220,54 @@ forEach([1, 2, 3, 4, 5, 6, 7, 8, 9], function (SPLIT) { var _r3 = new R({ objectMode: true }); - _r3._read = common.mustNotCall(); var counter = 0; - _r3.push(['one']); - _r3.push(['two']); - _r3.push(['three']); - _r3.push(['four']); - _r3.push(null); - var w1 = new R(); - w1.write = function (chunk) { assert.strictEqual(chunk[0], 'one'); w1.emit('close'); process.nextTick(function () { _r3.pipe(w2); - _r3.pipe(w3); }); }; - w1.end = common.mustNotCall(); - _r3.pipe(w1); - var expected = ['two', 'two', 'three', 'three', 'four', 'four']; var w2 = new R(); - w2.write = function (chunk) { assert.strictEqual(chunk[0], expected.shift()); assert.strictEqual(counter, 0); counter++; - if (chunk[0] === 'four') { return true; } - setTimeout(function () { counter--; w2.emit('drain'); }, 10); return false; }; - w2.end = common.mustCall(); var w3 = new R(); - w3.write = function (chunk) { assert.strictEqual(chunk[0], expected.shift()); assert.strictEqual(counter, 1); counter++; - if (chunk[0] === 'four') { return true; } - setTimeout(function () { counter--; w3.emit('drain'); }, 50); return false; }; - w3.end = common.mustCall(function () { assert.strictEqual(counter, 2); assert.strictEqual(expected.length, 0); @@ -333,51 +276,37 @@ forEach([1, 2, 3, 4, 5, 6, 7, 8, 9], function (SPLIT) { { // Verify read(0) behavior for ended streams var _r4 = new R(); - var written = false; var ended = false; _r4._read = common.mustNotCall(); - _r4.push(bufferShim.from('foo')); - _r4.push(null); - var v = _r4.read(0); - assert.strictEqual(v, null); - var _w2 = new R(); - _w2.write = function (buffer) { written = true; assert.strictEqual(ended, false); assert.strictEqual(buffer.toString(), 'foo'); }; - _w2.end = common.mustCall(function () { ended = true; assert.strictEqual(written, true); }); - _r4.pipe(_w2); } { // Verify synchronous _read ending var _r5 = new R(); - var called = false; - _r5._read = function (n) { _r5.push(null); }; - _r5.once('end', function () { // Verify that this is called before the next tick called = true; }); - _r5.read(); - process.nextTick(function () { assert.strictEqual(called, true); }); @@ -387,20 +316,15 @@ forEach([1, 2, 3, 4, 5, 6, 7, 8, 9], function (SPLIT) { var _r6 = new R({ highWaterMark: 5 }); - var onReadable = false; var readCalled = 0; - _r6._read = function (n) { if (readCalled++ === 2) _r6.push(null);else _r6.push(bufferShim.from('asdf')); }; - _r6.on('readable', function () { onReadable = true; - _r6.read(); }); - _r6.on('end', common.mustCall(function () { assert.strictEqual(readCalled, 3); assert.ok(onReadable); @@ -409,34 +333,23 @@ forEach([1, 2, 3, 4, 5, 6, 7, 8, 9], function (SPLIT) { { // Verify that streams are chainable var _r7 = new R(); - _r7._read = common.mustCall(); - var r2 = _r7.setEncoding('utf8').pause().resume().pause(); - assert.strictEqual(_r7, r2); } - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-compatibility.js b/test/parallel/test-stream2-compatibility.js index 04ab8eeced..e773d67278 100644 --- a/test/parallel/test-stream2-compatibility.js +++ b/test/parallel/test-stream2-compatibility.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -40,38 +36,24 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var R = require('../../lib/_stream_readable'); - var W = require('../../lib/_stream_writable'); - var assert = require('assert/'); - var ondataCalled = 0; - -var TestReader = -/*#__PURE__*/ -function (_R) { +var TestReader = /*#__PURE__*/function (_R) { _inherits(TestReader, _R); - + var _super = _createSuper(TestReader); function TestReader() { var _this; - _classCallCheck(this, TestReader); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(TestReader).call(this)); + _this = _super.call(this); _this._buffer = bufferShim.alloc(100, 'x'); - _this.on('data', function () { ondataCalled++; }); - return _this; } - _createClass(TestReader, [{ key: "_read", value: function _read(n) { @@ -79,69 +61,47 @@ function (_R) { this._buffer = bufferShim.alloc(0); } }]); - return TestReader; }(R); - var reader = new TestReader(); setImmediate(function () { assert.strictEqual(ondataCalled, 1); - require('tap').pass(); - reader.push(null); }); - -var TestWriter = -/*#__PURE__*/ -function (_W) { +var TestWriter = /*#__PURE__*/function (_W) { _inherits(TestWriter, _W); - + var _super2 = _createSuper(TestWriter); function TestWriter() { var _this2; - _classCallCheck(this, TestWriter); - - _this2 = _possibleConstructorReturn(this, _getPrototypeOf(TestWriter).call(this)); - + _this2 = _super2.call(this); _this2.write('foo'); - _this2.end(); - return _this2; } - _createClass(TestWriter, [{ key: "_write", value: function _write(chunk, enc, cb) { cb(); } }]); - return TestWriter; }(W); - var writer = new TestWriter(); process.on('exit', function () { assert.strictEqual(reader.readable, false); assert.strictEqual(writer.writable, false); - require('tap').pass(); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-decode-partial.js b/test/parallel/test-stream2-decode-partial.js index 600e0c6583..776650c209 100644 --- a/test/parallel/test-stream2-decode-partial.js +++ b/test/parallel/test-stream2-decode-partial.js @@ -3,14 +3,9 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var Readable = require('../../lib/_stream_readable'); - var assert = require('assert/'); - var buf = ''; var euro = bufferShim.from([0xE2, 0x82, 0xAC]); var cent = bufferShim.from([0xC2, 0xA2]); @@ -30,19 +25,13 @@ process.on('exit', function () { assert.strictEqual(buf, '€¢'); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-finish-pipe.js b/test/parallel/test-stream2-finish-pipe.js index f20cdb0d24..6165242a91 100644 --- a/test/parallel/test-stream2-finish-pipe.js +++ b/test/parallel/test-stream2-finish-pipe.js @@ -24,43 +24,30 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var stream = require('../../'); - var r = new stream.Readable(); - r._read = function (size) { r.push(bufferShim.allocUnsafe(size)); }; - var w = new stream.Writable(); - w._write = function (data, encoding, cb) { cb(null); }; +r.pipe(w); -r.pipe(w); // This might sound unrealistic, but it happens in net.js. When +// This might sound unrealistic, but it happens in net.js. When // `socket.allowHalfOpen === false`, EOF will cause `.destroySoon()` call which // ends the writable side of net.Socket. - w.end(); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-large-read-stall.js b/test/parallel/test-stream2-large-read-stall.js index fe628142fa..fbc0777a90 100644 --- a/test/parallel/test-stream2-large-read-stall.js +++ b/test/parallel/test-stream2-large-read-stall.js @@ -24,21 +24,17 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); +var assert = require('assert/'); -var assert = require('assert/'); // If everything aligns so that you do a read(n) of exactly the +// If everything aligns so that you do a read(n) of exactly the // remaining buffer, then make sure that 'end' still emits. - var READSIZE = 100; var PUSHSIZE = 20; var PUSHCOUNT = 1000; var HWM = 50; - var Readable = require('../../').Readable; - var r = new Readable({ highWaterMark: HWM }); @@ -48,7 +44,6 @@ r.on('readable', function () { ; false && console.error('>> readable'); var ret; - do { ; false && console.error(" > read(".concat(READSIZE, ")")); @@ -56,7 +51,6 @@ r.on('readable', function () { ; false && console.error(" < ".concat(ret && ret.length, " (").concat(rs.length, " remain)")); } while (ret && ret.length === READSIZE); - ; false && console.error('<< after read()', ret && ret.length, rs.needReadable, rs.length); }); @@ -64,35 +58,25 @@ r.on('end', common.mustCall(function () { assert.strictEqual(pushes, PUSHCOUNT + 1); })); var pushes = 0; - function push() { if (pushes > PUSHCOUNT) return; - if (pushes++ === PUSHCOUNT) { ; false && console.error(' push(EOF)'); return r.push(null); } - ; false && console.error(" push #".concat(pushes)); if (r.push(bufferShim.allocUnsafe(PUSHSIZE))) setTimeout(push, 1); } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-objects.js b/test/parallel/test-stream2-objects.js index ec0c17d491..c79d858090 100644 --- a/test/parallel/test-stream2-objects.js +++ b/test/parallel/test-stream2-objects.js @@ -25,31 +25,23 @@ var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var Readable = require('../../lib/_stream_readable'); - var Writable = require('../../lib/_stream_writable'); - var assert = require('assert/'); - function toArray(callback) { var stream = new Writable({ objectMode: true }); var list = []; - stream.write = function (chunk) { list.push(chunk); }; - stream.end = common.mustCall(function () { callback(list); }); return stream; } - function fromArray(list) { var r = new Readable({ objectMode: true @@ -61,7 +53,6 @@ function fromArray(list) { r.push(null); return r; } - { // Verify that objects can be read from the stream var r = fromArray([{ @@ -87,7 +78,6 @@ function fromArray(list) { }, { two: '2' }]); - _r.pipe(toArray(common.mustCall(function (list) { assert.deepStrictEqual(list, [{ one: '1' @@ -103,9 +93,7 @@ function fromArray(list) { }, { two: '2' }]); - var value = _r2.read(2); - assert.deepStrictEqual(value, { one: '1' }); @@ -115,19 +103,15 @@ function fromArray(list) { var _r3 = new Readable({ objectMode: true }); - var list = [{ one: '1' }, { two: '2' }]; - _r3._read = function (n) { var item = list.shift(); - _r3.push(item || null); }; - _r3.pipe(toArray(common.mustCall(function (list) { assert.deepStrictEqual(list, [{ one: '1' @@ -141,21 +125,17 @@ function fromArray(list) { var _r4 = new Readable({ objectMode: true }); - var _list2 = [{ one: '1' }, { two: '2' }]; - _r4._read = function (n) { var item = _list2.shift(); - process.nextTick(function () { _r4.push(item || null); }); }; - _r4.pipe(toArray(common.mustCall(function (list) { assert.deepStrictEqual(list, [{ one: '1' @@ -169,15 +149,12 @@ function fromArray(list) { var _r5 = new Readable({ objectMode: true }); - _r5._read = common.mustNotCall(); var _list3 = ['one', 'two', 'three']; forEach(_list3, function (str) { _r5.push(str); }); - _r5.push(null); - _r5.pipe(toArray(common.mustCall(function (array) { assert.deepStrictEqual(array, _list3); }))); @@ -187,13 +164,9 @@ function fromArray(list) { var _r6 = new Readable({ objectMode: true }); - _r6._read = common.mustNotCall(); - _r6.push('foobar'); - _r6.push(null); - _r6.pipe(toArray(common.mustCall(function (array) { assert.deepStrictEqual(array, ['foobar']); }))); @@ -203,17 +176,11 @@ function fromArray(list) { var _r7 = new Readable({ objectMode: true }); - _r7._read = common.mustNotCall(); - _r7.push(false); - _r7.push(0); - _r7.push(''); - _r7.push(null); - _r7.pipe(toArray(common.mustCall(function (array) { assert.deepStrictEqual(array, [false, 0, '']); }))); @@ -224,29 +191,20 @@ function fromArray(list) { highWaterMark: 6, objectMode: true }); - var calls = 0; var _list4 = ['1', '2', '3', '4', '5', '6', '7', '8']; - _r8._read = function (n) { calls++; }; - forEach(_list4, function (c) { _r8.push(c); }); - var v = _r8.read(); - assert.strictEqual(calls, 0); assert.strictEqual(v, '1'); - var _v = _r8.read(); - assert.strictEqual(_v, '2'); - var _v2 = _r8.read(); - assert.strictEqual(_v2, '3'); assert.strictEqual(calls, 1); } @@ -256,12 +214,9 @@ function fromArray(list) { highWaterMark: 6, objectMode: true }); - _r9._read = common.mustNotCall(); - for (var i = 0; i < 6; i++) { var bool = _r9.push(i); - assert.strictEqual(bool, i !== 5); } } @@ -270,14 +225,12 @@ function fromArray(list) { var w = new Writable({ objectMode: true }); - w._write = function (chunk, encoding, cb) { assert.deepStrictEqual(chunk, { foo: 'bar' }); cb(); }; - w.on('finish', common.mustCall()); w.write({ foo: 'bar' @@ -289,29 +242,19 @@ function fromArray(list) { var _w = new Writable({ objectMode: true }); - var _list5 = []; - _w._write = function (chunk, encoding, cb) { _list5.push(chunk); - cb(); }; - _w.on('finish', common.mustCall(function () { assert.deepStrictEqual(_list5, [0, 1, 2, 3, 4]); })); - _w.write(0); - _w.write(1); - _w.write(2); - _w.write(3); - _w.write(4); - _w.end(); } { @@ -319,29 +262,19 @@ function fromArray(list) { var _w2 = new Writable({ objectMode: true }); - var _list6 = []; - _w2._write = function (chunk, encoding, cb) { _list6.push(chunk); - process.nextTick(cb); }; - _w2.on('finish', common.mustCall(function () { assert.deepStrictEqual(_list6, ['0', '1', '2', '3', '4']); })); - _w2.write('0'); - _w2.write('1'); - _w2.write('2'); - _w2.write('3'); - _w2.write('4'); - _w2.end(); } { @@ -349,9 +282,7 @@ function fromArray(list) { var _w3 = new Writable({ objectMode: true }); - var called = false; - _w3._write = function (chunk, encoding, cb) { assert.strictEqual(chunk, 'foo'); process.nextTick(function () { @@ -359,36 +290,25 @@ function fromArray(list) { cb(); }); }; - _w3.on('finish', common.mustCall(function () { assert.strictEqual(called, true); })); - _w3.write('foo'); - _w3.end(); } - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-pipe-error-handling.js b/test/parallel/test-stream2-pipe-error-handling.js index e621d48dc6..f6db5cec00 100644 --- a/test/parallel/test-stream2-pipe-error-handling.js +++ b/test/parallel/test-stream2-pipe-error-handling.js @@ -24,37 +24,26 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - { var count = 1000; var source = new stream.Readable(); - source._read = function (n) { n = Math.min(count, n); count -= n; source.push(bufferShim.allocUnsafe(n)); }; - var unpipedDest; - source.unpipe = function (dest) { unpipedDest = dest; stream.Readable.prototype.unpipe.call(this, dest); }; - var dest = new stream.Writable(); - dest._write = function (chunk, encoding, cb) { cb(); }; - source.pipe(dest); var gotErr = null; dest.on('error', function (err) { @@ -72,65 +61,45 @@ var stream = require('../../'); } { var _count = 1000; - var _source = new stream.Readable(); - _source._read = function (n) { n = Math.min(_count, n); _count -= n; - _source.push(bufferShim.allocUnsafe(n)); }; - var _unpipedDest; - _source.unpipe = function (dest) { _unpipedDest = dest; stream.Readable.prototype.unpipe.call(this, dest); }; - var _dest = new stream.Writable(); - _dest._write = function (chunk, encoding, cb) { cb(); }; - _source.pipe(_dest); - var _unpipedSource; - _dest.on('unpipe', function (src) { _unpipedSource = src; }); - var _err = new Error('This stream turned into bacon.'); - var _gotErr = null; - try { _dest.emit('error', _err); } catch (e) { _gotErr = e; } - assert.strictEqual(_gotErr, _err); assert.strictEqual(_unpipedSource, _source); assert.strictEqual(_unpipedDest, _dest); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-pipe-error-once-listener.js b/test/parallel/test-stream2-pipe-error-once-listener.js index ad613095d1..c4abbf6379 100644 --- a/test/parallel/test-stream2-pipe-error-once-listener.js +++ b/test/parallel/test-stream2-pipe-error-once-listener.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -41,22 +37,15 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func var bufferShim = require('safe-buffer').Buffer; /**/ - require('../common'); - var stream = require('../../'); - -var Read = -/*#__PURE__*/ -function (_stream$Readable) { +var Read = /*#__PURE__*/function (_stream$Readable) { _inherits(Read, _stream$Readable); - + var _super = _createSuper(Read); function Read() { _classCallCheck(this, Read); - - return _possibleConstructorReturn(this, _getPrototypeOf(Read).apply(this, arguments)); + return _super.apply(this, arguments); } - _createClass(Read, [{ key: "_read", value: function _read(size) { @@ -64,21 +53,15 @@ function (_stream$Readable) { this.push(null); } }]); - return Read; }(stream.Readable); - -var Write = -/*#__PURE__*/ -function (_stream$Writable) { +var Write = /*#__PURE__*/function (_stream$Writable) { _inherits(Write, _stream$Writable); - + var _super2 = _createSuper(Write); function Write() { _classCallCheck(this, Write); - - return _possibleConstructorReturn(this, _getPrototypeOf(Write).apply(this, arguments)); + return _super2.apply(this, arguments); } - _createClass(Write, [{ key: "_write", value: function _write(buffer, encoding, cb) { @@ -86,10 +69,8 @@ function (_stream$Writable) { this.emit('alldone'); } }]); - return Write; }(stream.Writable); - var read = new Read(); var write = new Write(); write.once('error', function () {}); @@ -101,19 +82,13 @@ process.on('exit', function (c) { }); read.pipe(write); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-push.js b/test/parallel/test-stream2-push.js index b7b9083f0e..9fe85f75a3 100644 --- a/test/parallel/test-stream2-push.js +++ b/test/parallel/test-stream2-push.js @@ -24,30 +24,24 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var _require = require('../../'), - Readable = _require.Readable, - Writable = _require.Writable; - -var EE = require('events').EventEmitter; // a mock thing a bit like the net.Socket/tcp_wrap.handle interaction + Readable = _require.Readable, + Writable = _require.Writable; +var EE = require('events').EventEmitter; +// a mock thing a bit like the net.Socket/tcp_wrap.handle interaction var stream = new Readable({ highWaterMark: 16, encoding: 'utf8' }); var source = new EE(); - stream._read = function () { console.error('stream._read'); readStart(); }; - var ended = false; stream.on('end', function () { ended = true; @@ -61,12 +55,10 @@ source.on('end', function () { stream.push(null); }); var reading = false; - function readStart() { console.error('readStart'); reading = true; } - function readStop() { console.error('readStop'); reading = false; @@ -75,26 +67,24 @@ function readStop() { if (r !== null) writer.write(r); }); } - var writer = new Writable({ decodeStrings: false }); var written = []; var expectWritten = ['asdfgasdfgasdfgasdfg', 'asdfgasdfgasdfgasdfg', 'asdfgasdfgasdfgasdfg', 'asdfgasdfgasdfgasdfg', 'asdfgasdfgasdfgasdfg', 'asdfgasdfgasdfgasdfg']; - writer._write = function (chunk, encoding, cb) { console.error("WRITE ".concat(chunk)); written.push(chunk); process.nextTick(cb); }; +writer.on('finish', finish); -writer.on('finish', finish); // now emit some chunks. +// now emit some chunks. var chunk = 'asdfg'; var set = 0; readStart(); data(); - function data() { assert(reading); source.emit('data', chunk); @@ -107,14 +97,11 @@ function data() { assert(!reading); if (set++ < 5) setTimeout(data, 10);else end(); } - function finish() { console.error('finish'); assert.deepStrictEqual(written, expectWritten); - require('tap').pass(); } - function end() { source.emit('end'); assert(!reading); @@ -123,21 +110,14 @@ function end() { assert(ended); }); } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-read-sync-stack.js b/test/parallel/test-stream2-read-sync-stack.js index 7b94553928..f16f9394f3 100644 --- a/test/parallel/test-stream2-read-sync-stack.js +++ b/test/parallel/test-stream2-read-sync-stack.js @@ -24,23 +24,19 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); +var Readable = require('../../').Readable; -var Readable = require('../../').Readable; // This tests synchronous read callbacks and verifies that even if they nest +// This tests synchronous read callbacks and verifies that even if they nest // heavily the process handles it without an error - var r = new Readable(); var N = 256 * 1024; var reads = 0; - r._read = function (n) { var chunk = reads++ === N ? null : bufferShim.allocUnsafe(1); r.push(chunk); }; - r.on('readable', function onReadable() { if (!(r.readableLength % 256)) console.error('readable', r.readableLength); r.read(N * 2); @@ -48,19 +44,13 @@ r.on('readable', function onReadable() { r.on('end', common.mustCall()); r.read(0); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-readable-empty-buffer-no-eof.js b/test/parallel/test-stream2-readable-empty-buffer-no-eof.js index d62979a07f..5d5c4e6211 100644 --- a/test/parallel/test-stream2-readable-empty-buffer-no-eof.js +++ b/test/parallel/test-stream2-readable-empty-buffer-no-eof.js @@ -24,19 +24,15 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var Readable = require('../../').Readable; - test1(); test2(); - function test1() { - var r = new Readable(); // should not end when we get a bufferShim.alloc(0) or '' as the _read + var r = new Readable(); + + // should not end when we get a bufferShim.alloc(0) or '' as the _read // result that just means that there is *temporarily* no data, but to // go ahead and try again later. // @@ -48,53 +44,40 @@ function test1() { var buf = bufferShim.alloc(5, 'x'); var reads = 5; - r._read = function (n) { switch (reads--) { case 5: return setImmediate(function () { return r.push(buf); }); - case 4: setImmediate(function () { return r.push(bufferShim.alloc(0)); }); return setImmediate(r.read.bind(r, 0)); - case 3: setTimeout(r.read.bind(r, 0), 50); return process.nextTick(function () { return r.push(bufferShim.alloc(0)); }); - case 2: setImmediate(r.read.bind(r, 0)); return r.push(bufferShim.alloc(0)); // Not-EOF! - case 1: return r.push(buf); - case 0: return r.push(null); // EOF - default: throw new Error('unreachable'); } }; - var results = []; - function flow() { var chunk; - - while (null !== (chunk = r.read())) { - results.push(String(chunk)); - } + while (null !== (chunk = r.read())) results.push(String(chunk)); } - r.on('readable', flow); r.on('end', function () { results.push('EOF'); @@ -102,32 +85,23 @@ function test1() { flow(); process.on('exit', function () { assert.deepStrictEqual(results, ['xxxxx', 'xxxxx', 'EOF']); - require('tap').pass(); }); } - function test2() { var r = new Readable({ encoding: 'base64' }); var reads = 5; - r._read = function (n) { if (!reads--) return r.push(null); // EOF else return r.push(bufferShim.from('x')); }; - var results = []; - function flow() { var chunk; - - while (null !== (chunk = r.read())) { - results.push(String(chunk)); - } + while (null !== (chunk = r.read())) results.push(String(chunk)); } - r.on('readable', flow); r.on('end', function () { results.push('EOF'); @@ -135,25 +109,17 @@ function test2() { flow(); process.on('exit', function () { assert.deepStrictEqual(results, ['eHh4', 'eHg=', 'EOF']); - require('tap').pass(); }); } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-readable-from-list.js b/test/parallel/test-stream2-readable-from-list.js index 90376973d9..f44511af43 100644 --- a/test/parallel/test-stream2-readable-from-list.js +++ b/test/parallel/test-stream2-readable-from-list.js @@ -24,112 +24,103 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var fromList = require('../../lib/_stream_readable')._fromList; - var BufferList = require('../../lib/internal/streams/buffer_list'); - var util = require('util'); - function bufferListFromArray(arr) { var bl = new BufferList(); - - for (var i = 0; i < arr.length; ++i) { - bl.push(arr[i]); - } - + for (var i = 0; i < arr.length; ++i) bl.push(arr[i]); return bl; } - { // Verify behavior with buffers var list = [bufferShim.from('foog'), bufferShim.from('bark'), bufferShim.from('bazy'), bufferShim.from('kuel')]; list = bufferListFromArray(list); assert.strictEqual(util.inspect([list], { compact: false - }).indexOf('BufferList') > 0, true); // read more than the first element. + }).indexOf('BufferList') > 0, true); + // read more than the first element. var ret = fromList(6, { buffer: list, length: 16 }); - assert.strictEqual(ret.toString(), 'foogba'); // read exactly the first element. + assert.strictEqual(ret.toString(), 'foogba'); + // read exactly the first element. ret = fromList(2, { buffer: list, length: 10 }); - assert.strictEqual(ret.toString(), 'rk'); // read less than the first element. + assert.strictEqual(ret.toString(), 'rk'); + // read less than the first element. ret = fromList(2, { buffer: list, length: 8 }); - assert.strictEqual(ret.toString(), 'ba'); // read more than we have. + assert.strictEqual(ret.toString(), 'ba'); + // read more than we have. ret = fromList(100, { buffer: list, length: 6 }); - assert.strictEqual(ret.toString(), 'zykuel'); // all consumed. + assert.strictEqual(ret.toString(), 'zykuel'); + // all consumed. assert.deepStrictEqual(list, new BufferList()); } { // Verify behavior with strings var _list2 = ['foog', 'bark', 'bazy', 'kuel']; - _list2 = bufferListFromArray(_list2); // read more than the first element. + _list2 = bufferListFromArray(_list2); + // read more than the first element. var _ret = fromList(6, { buffer: _list2, length: 16, decoder: true }); + assert.strictEqual(_ret, 'foogba'); - assert.strictEqual(_ret, 'foogba'); // read exactly the first element. - + // read exactly the first element. _ret = fromList(2, { buffer: _list2, length: 10, decoder: true }); - assert.strictEqual(_ret, 'rk'); // read less than the first element. + assert.strictEqual(_ret, 'rk'); + // read less than the first element. _ret = fromList(2, { buffer: _list2, length: 8, decoder: true }); - assert.strictEqual(_ret, 'ba'); // read more than we have. + assert.strictEqual(_ret, 'ba'); + // read more than we have. _ret = fromList(100, { buffer: _list2, length: 6, decoder: true }); - assert.strictEqual(_ret, 'zykuel'); // all consumed. + assert.strictEqual(_ret, 'zykuel'); + // all consumed. assert.deepStrictEqual(_list2, new BufferList()); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-readable-legacy-drain.js b/test/parallel/test-stream2-readable-legacy-drain.js index 08cd9a57d8..53eac68eaa 100644 --- a/test/parallel/test-stream2-readable-legacy-drain.js +++ b/test/parallel/test-stream2-readable-legacy-drain.js @@ -24,63 +24,47 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var Stream = require('../../'); - var Readable = require('../../').Readable; - var r = new Readable(); var N = 256; var reads = 0; - r._read = function (n) { return r.push(++reads === N ? null : bufferShim.allocUnsafe(1)); }; - r.on('end', common.mustCall()); var w = new Stream(); w.writable = true; var buffered = 0; - w.write = function (c) { buffered += c.length; process.nextTick(drain); return false; }; - function drain() { assert(buffered <= 3); buffered = 0; w.emit('drain'); } +w.end = common.mustCall(); -w.end = common.mustCall(); // Just for kicks, let's mess with the drain count. +// Just for kicks, let's mess with the drain count. // This verifies that even if it gets negative in the // pipe() cleanup function, we'll still function properly. - r.on('readable', function () { w.emit('drain'); }); r.pipe(w); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-readable-non-empty-end.js b/test/parallel/test-stream2-readable-non-empty-end.js index 5b129fd4f6..d0e753d0b7 100644 --- a/test/parallel/test-stream2-readable-non-empty-end.js +++ b/test/parallel/test-stream2-readable-non-empty-end.js @@ -24,79 +24,59 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var Readable = require('../../lib/_stream_readable'); - var len = 0; var chunks = new Array(10); - for (var i = 1; i <= 10; i++) { chunks[i - 1] = bufferShim.allocUnsafe(i); len += i; } - var test = new Readable(); var n = 0; - test._read = function (size) { var chunk = chunks[n++]; setTimeout(function () { test.push(chunk === undefined ? null : chunk); }, 1); }; - test.on('end', thrower); - function thrower() { throw new Error('this should not happen!'); } - var bytesread = 0; test.on('readable', function () { var b = len - bytesread - 1; var res = test.read(b); - if (res) { bytesread += res.length; console.error("br=".concat(bytesread, " len=").concat(len)); setTimeout(next, 1); } - test.read(0); }); test.read(0); - function next() { // now let's make 'end' happen test.removeListener('end', thrower); - test.on('end', common.mustCall()); // one to get the last byte + test.on('end', common.mustCall()); + // one to get the last byte var r = test.read(); assert(r); assert.strictEqual(r.length, 1); r = test.read(); assert.strictEqual(r, null); } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-readable-wrap-empty.js b/test/parallel/test-stream2-readable-wrap-empty.js index 99c4f4e1f9..ee59ad7284 100644 --- a/test/parallel/test-stream2-readable-wrap-empty.js +++ b/test/parallel/test-stream2-readable-wrap-empty.js @@ -24,37 +24,23 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var Readable = require('../../lib/_stream_readable'); - var EE = require('events').EventEmitter; - var oldStream = new EE(); - oldStream.pause = function () {}; - oldStream.resume = function () {}; - var newStream = new Readable().wrap(oldStream); newStream.on('readable', function () {}).on('end', common.mustCall()); oldStream.emit('end'); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-set-encoding.js b/test/parallel/test-stream2-set-encoding.js index d1c7c8f693..1970f8a3da 100644 --- a/test/parallel/test-stream2-set-encoding.js +++ b/test/parallel/test-stream2-set-encoding.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -40,62 +36,44 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var R = require('../../lib/_stream_readable'); - -var TestReader = -/*#__PURE__*/ -function (_R) { +var TestReader = /*#__PURE__*/function (_R) { _inherits(TestReader, _R); - + var _super = _createSuper(TestReader); function TestReader(n, opts) { var _this; - _classCallCheck(this, TestReader); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(TestReader).call(this, opts)); + _this = _super.call(this, opts); _this.pos = 0; _this.len = n || 100; return _this; } - _createClass(TestReader, [{ key: "_read", value: function _read(n) { var _this2 = this; - setTimeout(function () { if (_this2.pos >= _this2.len) { // double push(null) to test eos handling _this2.push(null); - return _this2.push(null); } - n = Math.min(n, _this2.len - _this2.pos); - if (n <= 0) { // double push(null) to test eos handling _this2.push(null); - return _this2.push(null); } - _this2.pos += n; var ret = bufferShim.alloc(n, 'a'); return _this2.push(ret); }, 1); } }]); - return TestReader; }(R); - { // Verify utf8 encoding var tr = new TestReader(100); @@ -104,10 +82,7 @@ function (_R) { var expect = ['aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa']; tr.on('readable', function flow() { var chunk; - - while (null !== (chunk = tr.read(10))) { - out.push(chunk); - } + while (null !== (chunk = tr.read(10))) out.push(chunk); }); tr.on('end', common.mustCall(function () { assert.deepStrictEqual(out, expect); @@ -116,20 +91,13 @@ function (_R) { { // Verify hex encoding var _tr = new TestReader(100); - _tr.setEncoding('hex'); - var _out = []; var _expect = ['6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161']; - _tr.on('readable', function flow() { var chunk; - - while (null !== (chunk = _tr.read(10))) { - _out.push(chunk); - } + while (null !== (chunk = _tr.read(10))) _out.push(chunk); }); - _tr.on('end', common.mustCall(function () { assert.deepStrictEqual(_out, _expect); })); @@ -137,20 +105,13 @@ function (_R) { { // Verify hex encoding with read(13) var _tr2 = new TestReader(100); - _tr2.setEncoding('hex'); - var _out2 = []; var _expect2 = ['6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '16161']; - _tr2.on('readable', function flow() { var chunk; - - while (null !== (chunk = _tr2.read(13))) { - _out2.push(chunk); - } + while (null !== (chunk = _tr2.read(13))) _out2.push(chunk); }); - _tr2.on('end', common.mustCall(function () { assert.deepStrictEqual(_out2, _expect2); })); @@ -158,20 +119,13 @@ function (_R) { { // Verify base64 encoding var _tr3 = new TestReader(100); - _tr3.setEncoding('base64'); - var _out3 = []; var _expect3 = ['YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYQ==']; - _tr3.on('readable', function flow() { var chunk; - - while (null !== (chunk = _tr3.read(10))) { - _out3.push(chunk); - } + while (null !== (chunk = _tr3.read(10))) _out3.push(chunk); }); - _tr3.on('end', common.mustCall(function () { assert.deepStrictEqual(_out3, _expect3); })); @@ -181,18 +135,12 @@ function (_R) { var _tr4 = new TestReader(100, { encoding: 'utf8' }); - var _out4 = []; var _expect4 = ['aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa', 'aaaaaaaaaa']; - _tr4.on('readable', function flow() { var chunk; - - while (null !== (chunk = _tr4.read(10))) { - _out4.push(chunk); - } + while (null !== (chunk = _tr4.read(10))) _out4.push(chunk); }); - _tr4.on('end', common.mustCall(function () { assert.deepStrictEqual(_out4, _expect4); })); @@ -202,18 +150,12 @@ function (_R) { var _tr5 = new TestReader(100, { encoding: 'hex' }); - var _out5 = []; var _expect5 = ['6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161', '6161616161']; - _tr5.on('readable', function flow() { var chunk; - - while (null !== (chunk = _tr5.read(10))) { - _out5.push(chunk); - } + while (null !== (chunk = _tr5.read(10))) _out5.push(chunk); }); - _tr5.on('end', common.mustCall(function () { assert.deepStrictEqual(_out5, _expect5); })); @@ -223,18 +165,12 @@ function (_R) { var _tr6 = new TestReader(100, { encoding: 'hex' }); - var _out6 = []; var _expect6 = ['6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '16161']; - _tr6.on('readable', function flow() { var chunk; - - while (null !== (chunk = _tr6.read(13))) { - _out6.push(chunk); - } + while (null !== (chunk = _tr6.read(13))) _out6.push(chunk); }); - _tr6.on('end', common.mustCall(function () { assert.deepStrictEqual(_out6, _expect6); })); @@ -244,18 +180,12 @@ function (_R) { var _tr7 = new TestReader(100, { encoding: 'base64' }); - var _out7 = []; var _expect7 = ['YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYQ==']; - _tr7.on('readable', function flow() { var chunk; - - while (null !== (chunk = _tr7.read(10))) { - _out7.push(chunk); - } + while (null !== (chunk = _tr7.read(10))) _out7.push(chunk); }); - _tr7.on('end', common.mustCall(function () { assert.deepStrictEqual(_out7, _expect7); })); @@ -263,23 +193,16 @@ function (_R) { { // Verify chaining behavior var _tr8 = new TestReader(100); - assert.deepStrictEqual(_tr8.setEncoding('utf8'), _tr8); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-transform.js b/test/parallel/test-stream2-transform.js index 9bf6158c49..d0c85f84df 100644 --- a/test/parallel/test-stream2-transform.js +++ b/test/parallel/test-stream2-transform.js @@ -24,33 +24,24 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var PassThrough = require('../../lib/_stream_passthrough'); - var Transform = require('../../lib/_stream_transform'); - { // Verify writable side consumption var tx = new Transform({ highWaterMark: 10 }); var transformed = 0; - tx._transform = function (chunk, encoding, cb) { transformed += chunk.length; tx.push(chunk); cb(); }; - for (var i = 1; i <= 10; i++) { tx.write(bufferShim.allocUnsafe(i)); } - tx.end(); assert.strictEqual(tx.readableLength, 10); assert.strictEqual(transformed, 10); @@ -77,25 +68,16 @@ var Transform = require('../../lib/_stream_transform'); var _pt = new PassThrough({ objectMode: true }); - _pt.write(1); - _pt.write(true); - _pt.write(false); - _pt.write(0); - _pt.write('foo'); - _pt.write(''); - _pt.write({ a: 'b' }); - _pt.end(); - assert.strictEqual(_pt.read(), 1); assert.strictEqual(_pt.read(), true); assert.strictEqual(_pt.read(), false); @@ -109,37 +91,26 @@ var Transform = require('../../lib/_stream_transform'); { // Verify passthrough constructor behavior var _pt2 = PassThrough(); - assert(_pt2 instanceof PassThrough); } { // Verify transform constructor behavior var _pt3 = Transform(); - assert(_pt3 instanceof Transform); } { // Perform a simple transform var _pt4 = new Transform(); - _pt4._transform = function (c, e, cb) { var ret = bufferShim.alloc(c.length, 'x'); - _pt4.push(ret); - cb(); }; - _pt4.write(bufferShim.from('foog')); - _pt4.write(bufferShim.from('bark')); - _pt4.write(bufferShim.from('bazy')); - _pt4.write(bufferShim.from('kuel')); - _pt4.end(); - assert.strictEqual(_pt4.read(5).toString(), 'xxxxx'); assert.strictEqual(_pt4.read(5).toString(), 'xxxxx'); assert.strictEqual(_pt4.read(5).toString(), 'xxxxx'); @@ -150,31 +121,20 @@ var Transform = require('../../lib/_stream_transform'); var _pt5 = new Transform({ objectMode: true }); - _pt5._transform = function (c, e, cb) { _pt5.push(JSON.stringify(c)); - cb(); }; - _pt5.write(1); - _pt5.write(true); - _pt5.write(false); - _pt5.write(0); - _pt5.write('foo'); - _pt5.write(''); - _pt5.write({ a: 'b' }); - _pt5.end(); - assert.strictEqual(_pt5.read(), '1'); assert.strictEqual(_pt5.read(), 'true'); assert.strictEqual(_pt5.read(), 'false'); @@ -186,25 +146,17 @@ var Transform = require('../../lib/_stream_transform'); { // Verify async passthrough var _pt6 = new Transform(); - _pt6._transform = function (chunk, encoding, cb) { setTimeout(function () { _pt6.push(chunk); - cb(); }, 10); }; - _pt6.write(bufferShim.from('foog')); - _pt6.write(bufferShim.from('bark')); - _pt6.write(bufferShim.from('bazy')); - _pt6.write(bufferShim.from('kuel')); - _pt6.end(); - _pt6.on('finish', common.mustCall(function () { assert.strictEqual(_pt6.read(5).toString(), 'foogb'); assert.strictEqual(_pt6.read(5).toString(), 'arkba'); @@ -214,31 +166,23 @@ var Transform = require('../../lib/_stream_transform'); } { // Verify asymmetric transform (expand) - var _pt7 = new Transform(); // emit each chunk 2 times. - + var _pt7 = new Transform(); + // emit each chunk 2 times. _pt7._transform = function (chunk, encoding, cb) { setTimeout(function () { _pt7.push(chunk); - setTimeout(function () { _pt7.push(chunk); - cb(); }, 10); }, 10); }; - _pt7.write(bufferShim.from('foog')); - _pt7.write(bufferShim.from('bark')); - _pt7.write(bufferShim.from('bazy')); - _pt7.write(bufferShim.from('kuel')); - _pt7.end(); - _pt7.on('finish', common.mustCall(function () { assert.strictEqual(_pt7.read(5).toString(), 'foogf'); assert.strictEqual(_pt7.read(5).toString(), 'oogba'); @@ -251,144 +195,105 @@ var Transform = require('../../lib/_stream_transform'); } { // Verify asymmetric transform (compress) - var _pt8 = new Transform(); // each output is the first char of 3 consecutive chunks, - // or whatever's left. - + var _pt8 = new Transform(); + // each output is the first char of 3 consecutive chunks, + // or whatever's left. _pt8.state = ''; - _pt8._transform = function (chunk, encoding, cb) { var _this = this; - if (!chunk) chunk = ''; var s = chunk.toString(); setTimeout(function () { _this.state += s.charAt(0); - if (_this.state.length === 3) { _pt8.push(bufferShim.from(_this.state)); - _this.state = ''; } - cb(); }, 10); }; - _pt8._flush = function (cb) { // just output whatever we have. _pt8.push(bufferShim.from(this.state)); - this.state = ''; cb(); }; - _pt8.write(bufferShim.from('aaaa')); - _pt8.write(bufferShim.from('bbbb')); - _pt8.write(bufferShim.from('cccc')); - _pt8.write(bufferShim.from('dddd')); - _pt8.write(bufferShim.from('eeee')); - _pt8.write(bufferShim.from('aaaa')); - _pt8.write(bufferShim.from('bbbb')); - _pt8.write(bufferShim.from('cccc')); - _pt8.write(bufferShim.from('dddd')); - _pt8.write(bufferShim.from('eeee')); - _pt8.write(bufferShim.from('aaaa')); - _pt8.write(bufferShim.from('bbbb')); - _pt8.write(bufferShim.from('cccc')); - _pt8.write(bufferShim.from('dddd')); + _pt8.end(); - _pt8.end(); // 'abcdeabcdeabcd' - - + // 'abcdeabcdeabcd' _pt8.on('finish', common.mustCall(function () { assert.strictEqual(_pt8.read(5).toString(), 'abcde'); assert.strictEqual(_pt8.read(5).toString(), 'abcde'); assert.strictEqual(_pt8.read(5).toString(), 'abcd'); })); -} // this tests for a stall when data is written to a full stream -// that has empty transforms. +} +// this tests for a stall when data is written to a full stream +// that has empty transforms. { // Verify complex transform behavior var count = 0; var saved = null; - var _pt9 = new Transform({ highWaterMark: 3 }); - _pt9._transform = function (c, e, cb) { if (count++ === 1) saved = c;else { if (saved) { _pt9.push(saved); - saved = null; } - _pt9.push(c); } cb(); }; - _pt9.once('readable', function () { process.nextTick(function () { _pt9.write(bufferShim.from('d')); - _pt9.write(bufferShim.from('ef'), common.mustCall(function () { _pt9.end(); })); - assert.strictEqual(_pt9.read().toString(), 'abcdef'); assert.strictEqual(_pt9.read(), null); }); }); - _pt9.write(bufferShim.from('abc')); } { // Verify passthrough event emission var _pt10 = new PassThrough(); - var emits = 0; - _pt10.on('readable', function () { emits++; }); - _pt10.write(bufferShim.from('foog')); - _pt10.write(bufferShim.from('bark')); - assert.strictEqual(emits, 0); assert.strictEqual(_pt10.read(5).toString(), 'foogb'); assert.strictEqual(String(_pt10.read(5)), 'null'); assert.strictEqual(emits, 0); - _pt10.write(bufferShim.from('bazy')); - _pt10.write(bufferShim.from('kuel')); - assert.strictEqual(emits, 0); assert.strictEqual(_pt10.read(5).toString(), 'arkba'); assert.strictEqual(_pt10.read(5).toString(), 'zykue'); assert.strictEqual(_pt10.read(5), null); - _pt10.end(); - assert.strictEqual(emits, 1); assert.strictEqual(_pt10.read(5).toString(), 'l'); assert.strictEqual(_pt10.read(5), null); @@ -397,68 +302,49 @@ var Transform = require('../../lib/_stream_transform'); { // Verify passthrough event emission reordering var _pt11 = new PassThrough(); - var _emits = 0; - _pt11.on('readable', function () { _emits++; }); - _pt11.write(bufferShim.from('foog')); - _pt11.write(bufferShim.from('bark')); - assert.strictEqual(_emits, 0); assert.strictEqual(_pt11.read(5).toString(), 'foogb'); assert.strictEqual(_pt11.read(5), null); - _pt11.once('readable', common.mustCall(function () { assert.strictEqual(_pt11.read(5).toString(), 'arkba'); assert.strictEqual(_pt11.read(5), null); - _pt11.once('readable', common.mustCall(function () { assert.strictEqual(_pt11.read(5).toString(), 'zykue'); assert.strictEqual(_pt11.read(5), null); - _pt11.once('readable', common.mustCall(function () { assert.strictEqual(_pt11.read(5).toString(), 'l'); assert.strictEqual(_pt11.read(5), null); assert.strictEqual(_emits, 3); })); - _pt11.end(); })); - _pt11.write(bufferShim.from('kuel')); })); - _pt11.write(bufferShim.from('bazy')); } { // Verify passthrough facade var _pt12 = new PassThrough(); - var datas = []; - _pt12.on('data', function (chunk) { datas.push(chunk.toString()); }); - _pt12.on('end', common.mustCall(function () { assert.deepStrictEqual(datas, ['foog', 'bark', 'bazy', 'kuel']); })); - _pt12.write(bufferShim.from('foog')); - setTimeout(function () { _pt12.write(bufferShim.from('bark')); - setTimeout(function () { _pt12.write(bufferShim.from('bazy')); - setTimeout(function () { _pt12.write(bufferShim.from('kuel')); - setTimeout(function () { _pt12.end(); }, 10); @@ -471,7 +357,6 @@ var Transform = require('../../lib/_stream_transform'); var jp = new Transform({ objectMode: true }); - jp._transform = function (data, encoding, cb) { try { jp.push(JSON.parse(data)); @@ -479,10 +364,10 @@ var Transform = require('../../lib/_stream_transform'); } catch (er) { cb(er); } - }; // anything except null/undefined is fine. - // those are "magic" in the stream API, because they signal EOF. - + }; + // anything except null/undefined is fine. + // those are "magic" in the stream API, because they signal EOF. var objects = [{ foo: 'bar' }, 100, 'string', { @@ -501,8 +386,8 @@ var Transform = require('../../lib/_stream_transform'); var res = jp.read(); assert.deepStrictEqual(res, obj); }); - jp.end(); // read one more time to get the 'end' event - + jp.end(); + // read one more time to get the 'end' event jp.read(); process.nextTick(common.mustCall(function () { assert.strictEqual(ended, true); @@ -513,7 +398,6 @@ var Transform = require('../../lib/_stream_transform'); var js = new Transform({ objectMode: true }); - js._transform = function (data, encoding, cb) { try { js.push(JSON.stringify(data)); @@ -521,10 +405,10 @@ var Transform = require('../../lib/_stream_transform'); } catch (er) { cb(er); } - }; // anything except null/undefined is fine. - // those are "magic" in the stream API, because they signal EOF. - + }; + // anything except null/undefined is fine. + // those are "magic" in the stream API, because they signal EOF. var _objects = [{ foo: 'bar' }, 100, 'string', { @@ -543,34 +427,26 @@ var Transform = require('../../lib/_stream_transform'); var res = js.read(); assert.strictEqual(res, JSON.stringify(obj)); }); - js.end(); // read one more time to get the 'end' event - + js.end(); + // read one more time to get the 'end' event js.read(); process.nextTick(common.mustCall(function () { assert.strictEqual(_ended, true); })); } - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-unpipe-drain.js b/test/parallel/test-stream2-unpipe-drain.js index a2e8166cf6..3253b35525 100644 --- a/test/parallel/test-stream2-unpipe-drain.js +++ b/test/parallel/test-stream2-unpipe-drain.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } (function () { // Copyright Joyent, Inc. and other Node contributors. // @@ -41,52 +37,36 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - - var TestWriter = - /*#__PURE__*/ - function (_stream$Writable) { + var TestWriter = /*#__PURE__*/function (_stream$Writable) { _inherits(TestWriter, _stream$Writable); - + var _super = _createSuper(TestWriter); function TestWriter() { _classCallCheck(this, TestWriter); - - return _possibleConstructorReturn(this, _getPrototypeOf(TestWriter).apply(this, arguments)); + return _super.apply(this, arguments); } - _createClass(TestWriter, [{ key: "_write", value: function _write(buffer, encoding, callback) { - console.log('write called'); // super slow write stream (callback never called) + console.log('write called'); + // super slow write stream (callback never called) } }]); - return TestWriter; }(stream.Writable); - var dest = new TestWriter(); - - var TestReader = - /*#__PURE__*/ - function (_stream$Readable) { + var TestReader = /*#__PURE__*/function (_stream$Readable) { _inherits(TestReader, _stream$Readable); - + var _super2 = _createSuper(TestReader); function TestReader() { var _this; - _classCallCheck(this, TestReader); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(TestReader).call(this)); + _this = _super2.call(this); _this.reads = 0; return _this; } - _createClass(TestReader, [{ key: "_read", value: function _read(size) { @@ -94,10 +74,8 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func this.push(bufferShim.alloc(size)); } }]); - return TestReader; }(stream.Readable); - var src1 = new TestReader(); var src2 = new TestReader(); src1.pipe(dest); @@ -116,19 +94,13 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func assert.strictEqual(src2.reads, 2); }); })(); - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-unpipe-leak.js b/test/parallel/test-stream2-unpipe-leak.js index 93e26015d9..26005d7b67 100644 --- a/test/parallel/test-stream2-unpipe-leak.js +++ b/test/parallel/test-stream2-unpipe-leak.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -40,70 +36,51 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var chunk = bufferShim.from('hallo'); - -var TestWriter = -/*#__PURE__*/ -function (_stream$Writable) { +var TestWriter = /*#__PURE__*/function (_stream$Writable) { _inherits(TestWriter, _stream$Writable); - + var _super = _createSuper(TestWriter); function TestWriter() { _classCallCheck(this, TestWriter); - - return _possibleConstructorReturn(this, _getPrototypeOf(TestWriter).apply(this, arguments)); + return _super.apply(this, arguments); } - _createClass(TestWriter, [{ key: "_write", value: function _write(buffer, encoding, callback) { callback(null); } }]); - return TestWriter; }(stream.Writable); +var dest = new TestWriter(); -var dest = new TestWriter(); // Set this high so that we'd trigger a nextTick warning +// Set this high so that we'd trigger a nextTick warning // and/or RangeError if we do maybeReadMore wrong. - -var TestReader = -/*#__PURE__*/ -function (_stream$Readable) { +var TestReader = /*#__PURE__*/function (_stream$Readable) { _inherits(TestReader, _stream$Readable); - + var _super2 = _createSuper(TestReader); function TestReader() { _classCallCheck(this, TestReader); - - return _possibleConstructorReturn(this, _getPrototypeOf(TestReader).call(this, { + return _super2.call(this, { highWaterMark: 0x10000 - })); + }); } - _createClass(TestReader, [{ key: "_read", value: function _read(size) { this.push(chunk); } }]); - return TestReader; }(stream.Readable); - var src = new TestReader(); - for (var i = 0; i < 10; i++) { src.pipe(dest); src.unpipe(dest); } - assert.strictEqual(src.listeners('end').length, 0); assert.strictEqual(src.listeners('readable').length, 0); assert.strictEqual(dest.listeners('unpipe').length, 0); @@ -116,23 +93,16 @@ process.on('exit', function () { src.readableBuffer.length = 0; console.error(src._readableState); assert(src.readableLength >= src.readableHighWaterMark); - require('tap').pass(); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream2-writable.js b/test/parallel/test-stream2-writable.js index 4d38254e8d..8ae96f781b 100644 --- a/test/parallel/test-stream2-writable.js +++ b/test/parallel/test-stream2-writable.js @@ -1,21 +1,17 @@ "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -41,55 +37,39 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func var bufferShim = require('safe-buffer').Buffer; /**/ - var common = require('../common'); - var W = require('../../lib/_stream_writable'); - var D = require('../../lib/_stream_duplex'); - var assert = require('assert/'); - -var TestWriter = -/*#__PURE__*/ -function (_W) { +var TestWriter = /*#__PURE__*/function (_W) { _inherits(TestWriter, _W); - + var _super = _createSuper(TestWriter); function TestWriter(opts) { var _this; - _classCallCheck(this, TestWriter); - - _this = _possibleConstructorReturn(this, _getPrototypeOf(TestWriter).call(this, opts)); + _this = _super.call(this, opts); _this.buffer = []; _this.written = 0; return _this; } - _createClass(TestWriter, [{ key: "_write", value: function _write(chunk, encoding, cb) { var _this2 = this; - // simulate a small unpredictable latency setTimeout(function () { _this2.buffer.push(chunk.toString()); - _this2.written += chunk.length; cb(); }, Math.floor(Math.random() * 10)); } }]); - return TestWriter; }(W); - var chunks = new Array(50); - for (var i = 0; i < chunks.length; i++) { chunks[i] = 'x'.repeat(i); } - { // Verify fast writing var tw = new TestWriter({ @@ -110,17 +90,13 @@ for (var i = 0; i < chunks.length; i++) { var _tw = new TestWriter({ highWaterMark: 100 }); - _tw.on('finish', common.mustCall(function () { // got chunks in the right order assert.deepStrictEqual(_tw.buffer, chunks); })); - var _i = 0; - (function W() { _tw.write(chunks[_i++]); - if (_i < chunks.length) setTimeout(W, 10);else _tw.end(); })(); } @@ -129,31 +105,23 @@ for (var i = 0; i < chunks.length; i++) { var _tw2 = new TestWriter({ highWaterMark: 50 }); - var drains = 0; - _tw2.on('finish', common.mustCall(function () { // got chunks in the right order assert.deepStrictEqual(_tw2.buffer, chunks); assert.strictEqual(drains, 17); })); - _tw2.on('drain', function () { drains++; }); - var _i2 = 0; - (function W() { var ret; - do { ret = _tw2.write(chunks[_i2++]); } while (ret !== false && _i2 < chunks.length); - if (_i2 < chunks.length) { assert(_tw2.writableLength >= 50); - _tw2.once('drain', W); } else { _tw2.end(); @@ -165,18 +133,14 @@ for (var i = 0; i < chunks.length; i++) { var _tw3 = new TestWriter({ highWaterMark: 100 }); - var encodings = ['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', undefined]; - _tw3.on('finish', function () { // got the expected chunks assert.deepStrictEqual(_tw3.buffer, chunks); }); - forEach(chunks, function (chunk, i) { var enc = encodings[i % encodings.length]; chunk = bufferShim.from(chunk); - _tw3.write(chunk.toString(enc), enc); }); } @@ -186,24 +150,19 @@ for (var i = 0; i < chunks.length; i++) { highWaterMark: 100, decodeStrings: false }); - _tw4._write = function (chunk, encoding, cb) { assert.strictEqual(typeof chunk, 'string'); chunk = bufferShim.from(chunk, encoding); return TestWriter.prototype._write.call(this, chunk, encoding, cb); }; - var _encodings = ['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', undefined]; - _tw4.on('finish', function () { // got the expected chunks assert.deepStrictEqual(_tw4.buffer, chunks); }); - forEach(chunks, function (chunk, i) { var enc = _encodings[i % _encodings.length]; chunk = bufferShim.from(chunk); - _tw4.write(chunk.toString(enc), enc); }); } @@ -218,62 +177,50 @@ for (var i = 0; i < chunks.length; i++) { return set; }, {}); callbacks._called = []; - var _tw5 = new TestWriter({ highWaterMark: 100 }); - _tw5.on('finish', common.mustCall(function () { process.nextTick(common.mustCall(function () { // got chunks in the right order - assert.deepStrictEqual(_tw5.buffer, chunks); // called all callbacks - + assert.deepStrictEqual(_tw5.buffer, chunks); + // called all callbacks assert.deepStrictEqual(callbacks._called, chunks); })); })); - forEach(chunks, function (chunk, i) { _tw5.write(chunk, callbacks["callback-".concat(i)]); }); - _tw5.end(); } { // Verify end() callback var _tw6 = new TestWriter(); - _tw6.end(common.mustCall()); } { // Verify end() callback with chunk var _tw7 = new TestWriter(); - _tw7.end(bufferShim.from('hello world'), common.mustCall()); } { // Verify end() callback with chunk and encoding var _tw8 = new TestWriter(); - _tw8.end('hello world', 'ascii', common.mustCall()); } { // Verify end() callback after write() call var _tw9 = new TestWriter(); - _tw9.write(bufferShim.from('hello world')); - _tw9.end(common.mustCall()); } { // Verify end() callback after write() callback var _tw10 = new TestWriter(); - var writeCalledback = false; - _tw10.write(bufferShim.from('hello world'), function () { writeCalledback = true; }); - _tw10.end(common.mustCall(function () { assert.strictEqual(writeCalledback, true); })); @@ -281,13 +228,11 @@ for (var i = 0; i < chunks.length; i++) { { // Verify encoding is ignored for buffers var _tw11 = new W(); - var hex = '018b5e9a8f6236ffe30e31baf80d2cf6eb'; _tw11._write = common.mustCall(function (chunk) { assert.strictEqual(chunk.toString('hex'), hex); }); var buf = bufferShim.from(hex, 'hex'); - _tw11.write(buf, 'latin1'); } { @@ -316,21 +261,16 @@ for (var i = 0; i < chunks.length; i++) { { // Verify that end(chunk) twice is an error var _w = new W(); - _w._write = common.mustCall(function (msg) { assert.strictEqual(msg.toString(), 'this is the end'); }); var _gotError2 = false; - _w.on('error', function (er) { _gotError2 = true; assert.strictEqual(er.message, 'write after end'); }); - _w.end('this is the end'); - _w.end('and so is this'); - process.nextTick(common.mustCall(function () { assert.strictEqual(_gotError2, true); })); @@ -338,9 +278,7 @@ for (var i = 0; i < chunks.length; i++) { { // Verify stream doesn't end while writing var _w2 = new W(); - var wrote = false; - _w2._write = function (chunk, e, cb) { assert.strictEqual(this.writing, undefined); wrote = true; @@ -350,74 +288,56 @@ for (var i = 0; i < chunks.length; i++) { cb(); }, 1); }; - _w2.on('finish', common.mustCall(function () { assert.strictEqual(wrote, true); })); - _w2.write(bufferShim.alloc(0)); - _w2.end(); } { // Verify finish does not come before write() callback var _w3 = new W(); - var writeCb = false; - _w3._write = function (chunk, e, cb) { setTimeout(function () { writeCb = true; cb(); }, 10); }; - _w3.on('finish', common.mustCall(function () { assert.strictEqual(writeCb, true); })); - _w3.write(bufferShim.alloc(0)); - _w3.end(); } { // Verify finish does not come before synchronous _write() callback var _w4 = new W(); - var _writeCb = false; - _w4._write = function (chunk, e, cb) { cb(); }; - _w4.on('finish', common.mustCall(function () { assert.strictEqual(_writeCb, true); })); - _w4.write(bufferShim.alloc(0), function () { _writeCb = true; }); - _w4.end(); } { // Verify finish is emitted if the last chunk is empty var _w5 = new W(); - _w5._write = function (chunk, e, cb) { process.nextTick(cb); }; - _w5.on('finish', common.mustCall()); - _w5.write(bufferShim.allocUnsafe(1)); - _w5.end(bufferShim.alloc(0)); } { // Verify that finish is emitted after shutdown var _w6 = new W(); - var shutdown = false; _w6._final = common.mustCall(function (cb) { assert.strictEqual(this, _w6); @@ -426,40 +346,28 @@ for (var i = 0; i < chunks.length; i++) { cb(); }, 100); }); - _w6._write = function (chunk, e, cb) { process.nextTick(cb); }; - _w6.on('finish', common.mustCall(function () { assert.strictEqual(shutdown, true); })); - _w6.write(bufferShim.allocUnsafe(1)); - _w6.end(bufferShim.allocUnsafe(0)); } - function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream3-cork-end.js b/test/parallel/test-stream3-cork-end.js index 78a3fd8cd2..1e18e32364 100644 --- a/test/parallel/test-stream3-cork-end.js +++ b/test/parallel/test-stream3-cork-end.js @@ -3,15 +3,12 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var stream = require('../../'); +var Writable = stream.Writable; -var Writable = stream.Writable; // Test the buffering behavior of Writable streams. +// Test the buffering behavior of Writable streams. // // The call to cork() triggers storing chunks which are flushed // on calling end() and the stream subsequently ended. @@ -22,85 +19,81 @@ var expectedChunks = ['please', 'buffer', 'me', 'kindly']; var inputChunks = expectedChunks.slice(0); var seenChunks = []; var seenEnd = false; -var w = new Writable(); // lets arrange to store the chunks - +var w = new Writable(); +// lets arrange to store the chunks w._write = function (chunk, encoding, cb) { // stream end event is not seen before the last write - assert.ok(!seenEnd); // default encoding given none was specified - + assert.ok(!seenEnd); + // default encoding given none was specified assert.strictEqual(encoding, 'buffer'); seenChunks.push(chunk); cb(); -}; // lets record the stream end event - - +}; +// lets record the stream end event w.on('finish', function () { seenEnd = true; }); - function writeChunks(remainingChunks, callback) { var writeChunk = remainingChunks.shift(); var writeState; - if (writeChunk) { setImmediate(function () { - writeState = w.write(writeChunk); // we were not told to stop writing - + writeState = w.write(writeChunk); + // we were not told to stop writing assert.ok(writeState); writeChunks(remainingChunks, callback); }); } else { callback(); } -} // do an initial write - +} -w.write('stuff'); // the write was immediate +// do an initial write +w.write('stuff'); +// the write was immediate +assert.strictEqual(seenChunks.length, 1); +// reset the seen chunks +seenChunks = []; -assert.strictEqual(seenChunks.length, 1); // reset the seen chunks - -seenChunks = []; // trigger stream buffering - -w.cork(); // write the bufferedChunks +// trigger stream buffering +w.cork(); +// write the bufferedChunks writeChunks(inputChunks, function () { // should not have seen anything yet - assert.strictEqual(seenChunks.length, 0); // trigger flush and ending the stream + assert.strictEqual(seenChunks.length, 0); - w.end(); // stream should not ended in current tick + // trigger flush and ending the stream + w.end(); - assert.ok(!seenEnd); // buffered bytes should be seen in current tick + // stream should not ended in current tick + assert.ok(!seenEnd); - assert.strictEqual(seenChunks.length, 4); // did the chunks match + // buffered bytes should be seen in current tick + assert.strictEqual(seenChunks.length, 4); + // did the chunks match for (var i = 0, l = expectedChunks.length; i < l; i++) { - var seen = seenChunks[i]; // there was a chunk - + var seen = seenChunks[i]; + // there was a chunk assert.ok(seen); - var expected = bufferShim.from(expectedChunks[i]); // it was what we expected - + var expected = bufferShim.from(expectedChunks[i]); + // it was what we expected assert.deepEqual(seen, expected); } - setImmediate(function () { // stream should have ended in next tick assert.ok(seenEnd); }); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream3-cork-uncork.js b/test/parallel/test-stream3-cork-uncork.js index 48875fff2e..7f4c36a4d3 100644 --- a/test/parallel/test-stream3-cork-uncork.js +++ b/test/parallel/test-stream3-cork-uncork.js @@ -3,15 +3,12 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var stream = require('../../'); +var Writable = stream.Writable; -var Writable = stream.Writable; // Test the buffering behavior of Writable streams. +// Test the buffering behavior of Writable streams. // // The call to cork() triggers storing chunks which are flushed // on calling uncork() in the same tick. @@ -22,81 +19,76 @@ var expectedChunks = ['please', 'buffer', 'me', 'kindly']; var inputChunks = expectedChunks.slice(0); var seenChunks = []; var seenEnd = false; -var w = new Writable(); // lets arrange to store the chunks - +var w = new Writable(); +// lets arrange to store the chunks w._write = function (chunk, encoding, cb) { // default encoding given none was specified assert.strictEqual(encoding, 'buffer'); seenChunks.push(chunk); cb(); -}; // lets record the stream end event - - +}; +// lets record the stream end event w.on('finish', function () { seenEnd = true; }); - function writeChunks(remainingChunks, callback) { var writeChunk = remainingChunks.shift(); var writeState; - if (writeChunk) { setImmediate(function () { - writeState = w.write(writeChunk); // we were not told to stop writing - + writeState = w.write(writeChunk); + // we were not told to stop writing assert.ok(writeState); writeChunks(remainingChunks, callback); }); } else { callback(); } -} // do an initial write - +} -w.write('stuff'); // the write was immediate +// do an initial write +w.write('stuff'); +// the write was immediate +assert.strictEqual(seenChunks.length, 1); +// reset the chunks seen so far +seenChunks = []; -assert.strictEqual(seenChunks.length, 1); // reset the chunks seen so far - -seenChunks = []; // trigger stream buffering - -w.cork(); // write the bufferedChunks +// trigger stream buffering +w.cork(); +// write the bufferedChunks writeChunks(inputChunks, function () { // should not have seen anything yet - assert.strictEqual(seenChunks.length, 0); // trigger writing out the buffer + assert.strictEqual(seenChunks.length, 0); - w.uncork(); // buffered bytes should be seen in current tick + // trigger writing out the buffer + w.uncork(); - assert.strictEqual(seenChunks.length, 4); // did the chunks match + // buffered bytes should be seen in current tick + assert.strictEqual(seenChunks.length, 4); + // did the chunks match for (var i = 0, l = expectedChunks.length; i < l; i++) { - var seen = seenChunks[i]; // there was a chunk - + var seen = seenChunks[i]; + // there was a chunk assert.ok(seen); - var expected = bufferShim.from(expectedChunks[i]); // it was what we expected - + var expected = bufferShim.from(expectedChunks[i]); + // it was what we expected assert.deepEqual(seen, expected); } - setImmediate(function () { // the stream should not have been ended assert.ok(!seenEnd); }); }); ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-stream3-pause-then-read.js b/test/parallel/test-stream3-pause-then-read.js index 66a48c91df..9a548f91b5 100644 --- a/test/parallel/test-stream3-pause-then-read.js +++ b/test/parallel/test-stream3-pause-then-read.js @@ -24,14 +24,9 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - var Readable = stream.Readable; var Writable = stream.Writable; var totalChunks = 100; @@ -42,35 +37,28 @@ var r = new Readable({ highWaterMark: 1000 }); var chunks = totalChunks; - r._read = function (n) { console.log('_read called', chunks); if (!(chunks % 2)) setImmediate(push);else if (!(chunks % 3)) process.nextTick(push);else push(); }; - var totalPushed = 0; - function push() { var chunk = chunks-- > 0 ? bufferShim.alloc(chunkSize, 'x') : null; - if (chunk) { totalPushed += chunk.length; } - console.log('chunks', chunks); r.push(chunk); } +read100(); -read100(); // first we read 100 bytes - +// first we read 100 bytes function read100() { readn(100, onData); } - function readn(n, then) { console.error("read ".concat(n)); expectEndingData -= n; - (function read() { var c = r.read(n); console.error('c', c); @@ -80,36 +68,34 @@ function readn(n, then) { then(); } })(); -} // then we listen to some data events - +} +// then we listen to some data events function onData() { expectEndingData -= 100; console.error('onData'); var seen = 0; r.on('data', function od(c) { seen += c.length; - if (seen >= 100) { // seen enough r.removeListener('data', od); r.pause(); - if (seen > 100) { // oh no, seen too much! // put the extra back. var diff = seen - 100; r.unshift(c.slice(c.length - diff)); console.error('seen too much', seen, diff); - } // Nothing should be lost in between - + } + // Nothing should be lost in between setImmediate(pipeLittle); } }); -} // Just pipe 200 bytes, then unshift the extra and unpipe - +} +// Just pipe 200 bytes, then unshift the extra and unpipe function pipeLittle() { expectEndingData -= 200; console.error('pipe a little'); @@ -119,15 +105,12 @@ function pipeLittle() { assert.strictEqual(written, 200); setImmediate(read1234); }); - w._write = function (chunk, encoding, cb) { written += chunk.length; - if (written >= 200) { r.unpipe(w); w.end(); cb(); - if (written > 200) { var diff = written - 200; written -= diff; @@ -137,18 +120,16 @@ function pipeLittle() { setImmediate(cb); } }; - r.pipe(w); -} // now read 1234 more bytes - +} +// now read 1234 more bytes function read1234() { readn(1234, resumePause); } - function resumePause() { - console.error('resumePause'); // don't read anything, just resume and re-pause a whole bunch - + console.error('resumePause'); + // don't read anything, just resume and re-pause a whole bunch r.resume(); r.pause(); r.resume(); @@ -161,41 +142,30 @@ function resumePause() { r.pause(); setImmediate(pipe); } - function pipe() { console.error('pipe the rest'); var w = new Writable(); var written = 0; - w._write = function (chunk, encoding, cb) { written += chunk.length; cb(); }; - w.on('finish', function () { console.error('written', written, totalPushed); assert.strictEqual(written, expectEndingData); assert.strictEqual(totalPushed, expectTotalData); - require('tap').pass(); }); r.pipe(w); } - ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file diff --git a/test/parallel/test-streams-highwatermark.js b/test/parallel/test-streams-highwatermark.js index b6231c5ba7..63349c0b7e 100644 --- a/test/parallel/test-streams-highwatermark.js +++ b/test/parallel/test-streams-highwatermark.js @@ -3,18 +3,14 @@ /**/ var bufferShim = require('safe-buffer').Buffer; /**/ - - var common = require('../common'); - var assert = require('assert/'); - var stream = require('../../'); - { // This test ensures that the stream implementation correctly handles values // for highWaterMark which exceed the range of signed 32 bit integers and // rejects invalid values. + // This number exceeds the range of 32 bit integer arithmetic but should still // be handled correctly. var ovfl = Number.MAX_SAFE_INTEGER; @@ -26,10 +22,8 @@ var stream = require('../../'); highWaterMark: ovfl }); assert.strictEqual(writable._writableState.highWaterMark, ovfl); - var _loop = function _loop() { var invalidHwm = _arr[_i]; - var _loop2 = function _loop2() { var type = _arr2[_i2]; common.expectsError(function () { @@ -42,12 +36,10 @@ var stream = require('../../'); message: "The value \"".concat(invalidHwm, "\" is invalid for option \"highWaterMark\"") }); }; - for (var _i2 = 0, _arr2 = [stream.Readable, stream.Writable]; _i2 < _arr2.length; _i2++) { _loop2(); } }; - for (var _i = 0, _arr = [true, false, '5', {}, -5, NaN]; _i < _arr.length; _i++) { _loop(); } @@ -56,13 +48,12 @@ var stream = require('../../'); // This test ensures that the push method's implementation // correctly handles the edge case where the highWaterMark and // the state.length are both zero + var _readable = stream.Readable({ highWaterMark: 0 }); - for (var i = 0; i < 3; i++) { var needMoreData = _readable.push(); - assert.strictEqual(needMoreData, true); } } @@ -70,28 +61,21 @@ var stream = require('../../'); // This test ensures that the read(n) method's implementation // correctly handles the edge case where the highWaterMark, state.length // and n are all zero + var _readable2 = stream.Readable({ highWaterMark: 0 }); - _readable2._read = common.mustCall(); - _readable2.read(0); } ; - (function () { var t = require('tap'); - t.pass('sync run'); })(); - var _list = process.listeners('uncaughtException'); - process.removeAllListeners('uncaughtException'); - _list.pop(); - _list.forEach(function (e) { return process.on('uncaughtException', e); }); \ No newline at end of file