pax_global_header00006660000000000000000000000064136213231500014506gustar00rootroot0000000000000052 comment=bed7ffa274f5b9e6d0d5c22369e6fe825ded03d2 readable-stream-3.6.0/000077500000000000000000000000001362132315000145445ustar00rootroot00000000000000readable-stream-3.6.0/.airtap.yml000066400000000000000000000005461362132315000166320ustar00rootroot00000000000000sauce_connect: true browsers: - name: chrome version: latest platform: Windows 10 - name: internet explorer version: latest platform: Windows 10 - name: firefox version: latest platform: Windows 10 - name: safari version: latest platform: Mac 10.13 - name: microsoftedge version: latest platform: Windows 10 readable-stream-3.6.0/.babelrc000066400000000000000000000004501362132315000161360ustar00rootroot00000000000000{ "presets": [ ["@babel/preset-env", { "targets": [ "last 2 versions", "not dead", "node 6.0" ], "modules": "commonjs", "exclude": [ "transform-regenerator", "transform-typeof-symbol" ], "debug": true }] ] } readable-stream-3.6.0/.gitignore000066400000000000000000000001311362132315000165270ustar00rootroot00000000000000node_modules/ .zuul.yml .nyc_output coverage package-lock.json *.tap .airtaprc yarn.lock readable-stream-3.6.0/.npmignore000066400000000000000000000001521362132315000165410ustar00rootroot00000000000000build/ test/ examples/ fs.js zlib.js .airtap.yml .airtaprc .babelrc .travis.yml .nyc_output coverage doc/ readable-stream-3.6.0/.travis.yml000066400000000000000000000006061362132315000166570ustar00rootroot00000000000000language: node_js notifications: email: false matrix: fast_finish: true include: - node_js: 6 env: CMD=test - node_js: 8 env: CMD=test - node_js: 9 env: CMD=test - node_js: 10 env: CMD=test - node_js: 12 env: CMD=test - node_js: 12 env: CMD=test-browsers addons: sauce_connect: true hosts: - airtap.local script: npm run $CMD readable-stream-3.6.0/CONTRIBUTING.md000066400000000000000000000026431362132315000170020ustar00rootroot00000000000000# Developer's Certificate of Origin 1.1 By making a contribution to this project, I certify that: * (a) The contribution was created in whole or in part by me and I have the right to submit it under the open source license indicated in the file; or * (b) The contribution is based upon previous work that, to the best of my knowledge, is covered under an appropriate open source license and I have the right under that license to submit that work with modifications, whether created in whole or in part by me, under the same open source license (unless I am permitted to submit under a different license), as indicated in the file; or * (c) The contribution was provided directly to me by some other person who certified (a), (b) or (c) and I have not modified it. * (d) I understand and agree that this project and the contribution are public and that a record of the contribution (including all personal information I submit with it, including my sign-off) is maintained indefinitely and may be redistributed consistent with this project or the open source license(s) involved. ## Moderation Policy The [Node.js Moderation Policy] applies to this WG. ## Code of Conduct The [Node.js Code of Conduct][] applies to this WG. [Node.js Code of Conduct]: https://github.com/nodejs/node/blob/master/CODE_OF_CONDUCT.md [Node.js Moderation Policy]: https://github.com/nodejs/TSC/blob/master/Moderation-Policy.md readable-stream-3.6.0/GOVERNANCE.md000066400000000000000000000126561362132315000165270ustar00rootroot00000000000000### Streams Working Group The Node.js Streams is jointly governed by a Working Group (WG) that is responsible for high-level guidance of the project. The WG has final authority over this project including: * Technical direction * Project governance and process (including this policy) * Contribution policy * GitHub repository hosting * Conduct guidelines * Maintaining the list of additional Collaborators For the current list of WG members, see the project [README.md](./README.md#current-project-team-members). ### Collaborators The readable-stream GitHub repository is maintained by the WG and additional Collaborators who are added by the WG on an ongoing basis. Individuals making significant and valuable contributions are made Collaborators and given commit-access to the project. These individuals are identified by the WG and their addition as Collaborators is discussed during the WG meeting. _Note:_ If you make a significant contribution and are not considered for commit-access log an issue or contact a WG member directly and it will be brought up in the next WG meeting. Modifications of the contents of the readable-stream repository are made on a collaborative basis. Anybody with a GitHub account may propose a modification via pull request and it will be considered by the project Collaborators. All pull requests must be reviewed and accepted by a Collaborator with sufficient expertise who is able to take full responsibility for the change. In the case of pull requests proposed by an existing Collaborator, an additional Collaborator is required for sign-off. Consensus should be sought if additional Collaborators participate and there is disagreement around a particular modification. See _Consensus Seeking Process_ below for further detail on the consensus model used for governance. Collaborators may opt to elevate significant or controversial modifications, or modifications that have not found consensus to the WG for discussion by assigning the ***WG-agenda*** tag to a pull request or issue. The WG should serve as the final arbiter where required. For the current list of Collaborators, see the project [README.md](./README.md#members). ### WG Membership WG seats are not time-limited. There is no fixed size of the WG. However, the expected target is between 6 and 12, to ensure adequate coverage of important areas of expertise, balanced with the ability to make decisions efficiently. There is no specific set of requirements or qualifications for WG membership beyond these rules. The WG may add additional members to the WG by unanimous consensus. A WG member may be removed from the WG by voluntary resignation, or by unanimous consensus of all other WG members. Changes to WG membership should be posted in the agenda, and may be suggested as any other agenda item (see "WG Meetings" below). If an addition or removal is proposed during a meeting, and the full WG is not in attendance to participate, then the addition or removal is added to the agenda for the subsequent meeting. This is to ensure that all members are given the opportunity to participate in all membership decisions. If a WG member is unable to attend a meeting where a planned membership decision is being made, then their consent is assumed. No more than 1/3 of the WG members may be affiliated with the same employer. If removal or resignation of a WG member, or a change of employment by a WG member, creates a situation where more than 1/3 of the WG membership shares an employer, then the situation must be immediately remedied by the resignation or removal of one or more WG members affiliated with the over-represented employer(s). ### WG Meetings The WG meets occasionally on a Google Hangout On Air. A designated moderator approved by the WG runs the meeting. Each meeting should be published to YouTube. Items are added to the WG agenda that are considered contentious or are modifications of governance, contribution policy, WG membership, or release process. The intention of the agenda is not to approve or review all patches; that should happen continuously on GitHub and be handled by the larger group of Collaborators. Any community member or contributor can ask that something be added to the next meeting's agenda by logging a GitHub Issue. Any Collaborator, WG member or the moderator can add the item to the agenda by adding the ***WG-agenda*** tag to the issue. Prior to each WG meeting the moderator will share the Agenda with members of the WG. WG members can add any items they like to the agenda at the beginning of each meeting. The moderator and the WG cannot veto or remove items. The WG may invite persons or representatives from certain projects to participate in a non-voting capacity. The moderator is responsible for summarizing the discussion of each agenda item and sends it as a pull request after the meeting. ### Consensus Seeking Process The WG follows a [Consensus Seeking](http://en.wikipedia.org/wiki/Consensus-seeking_decision-making) decision-making model. When an agenda item has appeared to reach a consensus the moderator will ask "Does anyone object?" as a final call for dissent from the consensus. If an agenda item cannot reach a consensus a WG member can call for either a closing vote or a vote to table the issue to the next meeting. The call for a vote must be seconded by a majority of the WG or else the discussion will continue. Simple majority wins. Note that changes to WG membership require a majority consensus. See "WG Membership" above. readable-stream-3.6.0/LICENSE000066400000000000000000000044411362132315000155540ustar00rootroot00000000000000Node.js is licensed for use as follows: """ Copyright Node.js contributors. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 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. """ This license applies to parts of Node.js originating from the https://github.com/joyent/node repository: """ Copyright Joyent, Inc. and other Node contributors. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 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. """ readable-stream-3.6.0/README.md000066400000000000000000000111461362132315000160260ustar00rootroot00000000000000# readable-stream ***Node.js core streams for userland*** [![Build Status](https://travis-ci.com/nodejs/readable-stream.svg?branch=master)](https://travis-ci.com/nodejs/readable-stream) [![NPM](https://nodei.co/npm/readable-stream.png?downloads=true&downloadRank=true)](https://nodei.co/npm/readable-stream/) [![NPM](https://nodei.co/npm-dl/readable-stream.png?&months=6&height=3)](https://nodei.co/npm/readable-stream/) [![Sauce Test Status](https://saucelabs.com/browser-matrix/readabe-stream.svg)](https://saucelabs.com/u/readabe-stream) ```bash 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). 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). As of version 2.0.0 **readable-stream** uses semantic versioning. ## Version 3.x.x v3.x.x of `readable-stream` is a cut from Node 10. This version supports Node 6, 8, and 10, as well as evergreen browsers, IE 11 and latest Safari. The breaking changes introduced by v3 are composed by the combined breaking changes in [Node v9](https://nodejs.org/en/blog/release/v9.0.0/) and [Node v10](https://nodejs.org/en/blog/release/v10.0.0/), as follows: 1. Error codes: https://github.com/nodejs/node/pull/13310, https://github.com/nodejs/node/pull/13291, https://github.com/nodejs/node/pull/16589, https://github.com/nodejs/node/pull/15042, https://github.com/nodejs/node/pull/15665, https://github.com/nodejs/readable-stream/pull/344 2. 'readable' have precedence over flowing https://github.com/nodejs/node/pull/18994 3. make virtual methods errors consistent https://github.com/nodejs/node/pull/18813 4. updated streams error handling https://github.com/nodejs/node/pull/18438 5. writable.end should return this. https://github.com/nodejs/node/pull/18780 6. readable continues to read when push('') https://github.com/nodejs/node/pull/18211 7. add custom inspect to BufferList https://github.com/nodejs/node/pull/17907 8. always defer 'readable' with nextTick https://github.com/nodejs/node/pull/17979 ## Version 2.x.x v2.x.x of `readable-stream` is a cut of the stream module from Node 8 (there have been no semver-major changes from Node 4 to 8). This version supports all Node.js versions from 0.8, as well as evergreen browsers and IE 10 & 11. ### Big Thanks Cross-browser Testing Platform and Open Source <3 Provided by [Sauce Labs][sauce] # Usage You can swap your `require('stream')` with `require('readable-stream')` without any changes, if you are just using one of the main classes and functions. ```js const { Readable, Writable, Transform, Duplex, pipeline, finished } = require('readable-stream') ```` Note that `require('stream')` will return `Stream`, while `require('readable-stream')` will return `Readable`. We discourage using whatever is exported directly, but rather use one of the properties as shown in the example above. # Streams Working Group `readable-stream` is maintained by the Streams Working Group, which oversees the development and maintenance of the Streams API within Node.js. The responsibilities of the Streams Working Group include: * Addressing stream issues on the Node.js issue tracker. * Authoring and editing stream documentation within the Node.js project. * Reviewing changes to stream subclasses within the Node.js project. * Redirecting changes to streams from the Node.js project to this project. * Assisting in the implementation of stream providers within Node.js. * Recommending versions of `readable-stream` to be included in Node.js. * Messaging about the future of streams to give the community advance notice of changes. ## Team Members * **Calvin Metcalf** ([@calvinmetcalf](https://github.com/calvinmetcalf)) <calvin.metcalf@gmail.com> - Release GPG key: F3EF5F62A87FC27A22E643F714CE4FF5015AA242 * **Mathias Buus** ([@mafintosh](https://github.com/mafintosh)) <mathiasbuus@gmail.com> * **Matteo Collina** ([@mcollina](https://github.com/mcollina)) <matteo.collina@gmail.com> - Release GPG key: 3ABC01543F22DD2239285CDD818674489FBC127E * **Irina Shestak** ([@lrlna](https://github.com/lrlna)) <shestak.irina@gmail.com> * **Yoshua Wyuts** ([@yoshuawuyts](https://github.com/yoshuawuyts)) <yoshuawuyts@gmail.com> [sauce]: https://saucelabs.com readable-stream-3.6.0/build/000077500000000000000000000000001362132315000156435ustar00rootroot00000000000000readable-stream-3.6.0/build/.gitignore000066400000000000000000000000151362132315000176270ustar00rootroot00000000000000node_modules readable-stream-3.6.0/build/build.js000077500000000000000000000140161362132315000173050ustar00rootroot00000000000000#!/usr/bin/env node const hyperquest = require('hyperquest') , bl = require('bl') , fs = require('fs') , path = require('path') , tar = require('tar-fs') , gunzip = require('gunzip-maybe') , babel = require('@babel/core') , glob = require('glob') , pump = require('pump') , rimraf = require('rimraf') , encoding = 'utf8' , urlRegex = /^https?:\/\// , nodeVersion = process.argv[2] , nodeVersionRegexString = '\\d+\\.\\d+\\.\\d+' , usageVersionRegex = RegExp('^' + nodeVersionRegexString + '$') , readmeVersionRegex = RegExp('((?:(?:Node-core )|(?:https\:\/\/nodejs\.org\/dist\/))v)' + nodeVersionRegexString, 'g') , readmePath = path.join(__dirname, '..', 'README.md') , files = require('./files') , testReplace = require('./test-replacements') , downloadurl = `https://nodejs.org/dist/v${nodeVersion}/node-v${nodeVersion}.tar.gz` , src = path.join(__dirname, `node-v${nodeVersion}`) , libsrcurl = path.join(src, 'lib/') , testsrcurl = path.join(src, 'test/parallel/') , libourroot = path.join(__dirname, '../lib/') , testourroot = path.join(__dirname, '../test/parallel/') if (!usageVersionRegex.test(nodeVersion)) { console.error('Usage: build.js xx.yy.zz') return process.exit(1); } // `inputLoc`: URL or local path. function processFile (inputLoc, out, replacements, addAtEnd) { var file = fs.createReadStream(inputLoc, encoding) file.pipe(bl(function (err, data) { if (err) throw err console.log('Processing', inputLoc) data = data.toString() replacements.forEach(function (replacement) { const regexp = replacement[0] var arg2 = replacement[1] if (typeof arg2 === 'function') arg2 = arg2.bind(data) if (arg2 === undefined) { console.error('missing second arg for file', inputLoc, replacement) throw new Error('missing second arg in replacement') } data = data.replace(regexp, arg2) }) if (addAtEnd) { data += addAtEnd } if (inputLoc.slice(-3) === '.js') { try { const transformed = babel.transform(data, { // Required for babel to pick up .babelrc filename: inputLoc }) data = transformed.code } catch (err) { fs.writeFile(out + '.errored.js', data, encoding, function () { console.log('Wrote errored', out) throw err }) return } } fs.writeFile(out, data, encoding, function (err) { if (err) throw err console.log('Wrote', out) }) })) } function deleteOldTests(){ const files = fs.readdirSync(path.join(__dirname, '..', 'test', 'parallel')); for (let file of files) { let name = path.join(__dirname, '..', 'test', 'parallel', file); console.log('Removing', name); fs.unlinkSync(name); } } function processLibFile (file) { var replacements = files[file] , url = libsrcurl + file , out = path.join(libourroot, file) processFile(url, out, replacements) } function processTestFile (file) { var replacements = testReplace.all , url = testsrcurl + file , out = path.join(testourroot, file) if (testReplace[file]) replacements = replacements.concat(testReplace[file]) processFile(url, out, replacements, ';(function () { var t = require(\'tap\'); t.pass(\'sync run\'); })();var _list = process.listeners(\'uncaughtException\'); process.removeAllListeners(\'uncaughtException\'); _list.pop(); _list.forEach((e) => process.on(\'uncaughtException\', e));') } //-------------------------------------------------------------------- // Download the release from nodejs.org console.log(`Downloading ${downloadurl}`) pump( hyperquest(downloadurl), gunzip(), tar.extract(__dirname), function (err) { if (err) { throw err } //-------------------------------------------------------------------- // Grab & process files in ../lib/ Object.keys(files).forEach(processLibFile) //-------------------------------------------------------------------- // Discover, grab and process all test-stream* files on the given release glob(path.join(testsrcurl, 'test-@(stream|readable)*.js'), function (err, list) { if (err) { throw err } list.forEach(function (file) { file = path.basename(file) if (!/-wrap(?:-encoding)?\.js$/.test(file) && file !== 'test-stream2-httpclient-response-end.js' && file !== 'test-stream-base-no-abort.js' && file !== 'test-stream-preprocess.js' && file !== 'test-stream-inheritance.js' && file !== 'test-stream-base-prototype-accessors.js' && file !== 'test-stream-base-prototype-accessors-enumerability.js' && file !== 'test-stream-wrap-drain.js' && file !== 'test-stream-pipeline-http2.js' && file !== 'test-stream-base-typechecking.js') { processTestFile(file) } }) }) //-------------------------------------------------------------------- // Grab the nodejs/node test/common.js glob(path.join(src, 'test/common/*'), function (err, list) { if (err) { throw err } list.forEach(function (file) { file = path.basename(file) processFile( path.join(testsrcurl.replace(/parallel[/\\]$/, 'common/'), file) , path.join(testourroot.replace('parallel', 'common'), file) , testReplace['common.js'] ) }) }) //-------------------------------------------------------------------- // Update Node version in README processFile(readmePath, readmePath, [ [readmeVersionRegex, "$1" + nodeVersion] ]) } ) // delete the current contents of test/parallel so if node removes any tests // they are removed here deleteOldTests(); process.once('beforeExit', function () { rimraf(src, function (err) { if (err) { throw err } console.log('Removed', src) }) }) readable-stream-3.6.0/build/common-replacements.js000066400000000000000000000026121362132315000221520ustar00rootroot00000000000000module.exports.altForEachImplReplacement = [ /$/ , '\nfunction forEach (xs, f) {\n' + ' for (var i = 0, l = xs.length; i < l; i++) {\n' + ' f(xs[i], i);\n' + ' }\n' + '}\n' ] module.exports.altForEachUseReplacement = [ /(\W)([\w\.\(\),\[\] ']+)(\.forEach\()/gm , '$1forEach($2, ' ] module.exports.specialForEachReplacment = [ /(\W)(\[(?:\d\,\s)+\d\])(\.forEach\()/gm , '$1forEach($2, ' ] module.exports.altIndexOfImplReplacement = [ /$/ , '\nfunction indexOf (xs, x) {\n' + ' for (var i = 0, l = xs.length; i < l; i++) {\n' + ' if (xs[i] === x) return i;\n' + ' }\n' + ' return -1;\n' + '}\n' ] module.exports.altIndexOfUseReplacement = [ /(\W)([\w\.\(\),\[\]]+)(\.indexOf\()/gm , '$1indexOf($2, ' ] module.exports.objectKeysDefine = [ /^('use strict';)$/m , '$1\n\n/**/\nvar objectKeys = Object.keys || function (obj) {\n' + ' var keys = [];\n' + ' for (var key in obj) keys.push(key);\n' + ' return keys;\n' + '}\n/**/\n' ] module.exports.objectKeysReplacement = [ /Object\.keys/g , 'objectKeys' ] module.exports.bufferShimFix = [ /^('use strict';)$/m, `/**/ const bufferShim = require('safe-buffer').Buffer; /**/` ] module.exports.bufferStaticMethods = [ /Buffer\.((?:alloc)|(?:allocUnsafe)|(?:from))/g, `bufferShim.$1` ] readable-stream-3.6.0/build/files.js000066400000000000000000000247571362132315000173220ustar00rootroot00000000000000/* This file lists the files to be fetched from the node repo * in the /lib/ directory which will be placed in the ../lib/ * directory after having each of the "replacements" in the * array for that file applied to it. The replacements are * simply the arguments to String#replace, so they can be * strings, regexes, functions. */ const headRegexp = /(^module.exports = \w+;?)/m , requireReplacement = [ /(require\(['"])(_stream_)/g , '$1./$2' ] , instanceofReplacement = [ /instanceof Stream\.(\w+)/g , function (match, streamType) { return 'instanceof ' + streamType } ] // use the string_decoder in node_modules rather than core , stringDecoderReplacement = [ /(require\(['"])(string_decoder)(['"]\))/g , '$1$2/$3' ] // The browser build ends up with a circular dependency, so the require is // done lazily, but cached. , addDuplexDec = [ headRegexp , '$1\n\n/**/\nvar Duplex;\n/**/\n' ] , addDuplexRequire = [ /^(function (?:Writable|Readable)(?:State)?.*{)/gm , '\n$1\n Duplex = Duplex || require(\'./_stream_duplex\');\n' ] , altIndexOfImplReplacement = require('./common-replacements').altIndexOfImplReplacement , altIndexOfUseReplacement = require('./common-replacements').altIndexOfUseReplacement , utilReplacement = [ /^const util = require\('util'\);/m , '' ] , inherits = [ /^util.inherits/m , 'require(\'inherits\')' ] , debugLogReplacement = [ /const debug = util.debuglog\('stream'\);/ , '\n\n/**/\nconst debugUtil = require(\'util\');\n' + 'let debug;\n' + 'if (debugUtil && debugUtil.debuglog) {\n' + ' debug = debugUtil.debuglog(\'stream\');\n' + '} else {\n' + ' debug = function () {};\n' + '}\n/**/\n' ] , deprecateReplacement = [ /util.deprecate/ , 'require(\'util-deprecate\')' ] , objectDefinePropertyReplacement = [ /(Object\.defineProperties)/ , 'if (Object.defineProperties) $1' ] , objectDefinePropertySingReplacement = [ /Object\.defineProperty\(([\w\W]+?)\}\);/ , '(function (){try {\n' + 'Object.defineProperty\($1});\n' + '}catch(_){}}());\n' ] , objectKeysDefine = require('./common-replacements').objectKeysDefine , objectKeysReplacement = require('./common-replacements').objectKeysReplacement , eventEmittterReplacement = [ /^(const EE = require\('events'\));$/m , '/**/\n$1.EventEmitter;\n\n' + 'var EElistenerCount = function(emitter, type) {\n' + ' return emitter.listeners(type).length;\n' + '};\n/**/\n' ] , eventEmittterListenerCountReplacement = [ /(EE\.listenerCount)/g , 'EElistenerCount' ] , bufferIsEncodingReplacement = [ /Buffer.isEncoding\((\w+)\)/ , '([\'hex\', \'utf8\', \'utf-8\', \'ascii\', \'binary\', \'base64\',\n' + '\'ucs2\', \'ucs-2\',\'utf16le\', \'utf-16le\', \'raw\']\n' + '.indexOf(($1 + \'\').toLowerCase()) > -1)' ] , requireStreamReplacement = [ /const Stream = require\('stream'\);/ , '\n\n/**/\n' + 'var Stream = require(\'./internal/streams/stream\')' + '\n/**/\n' ] , isBufferReplacement = [ /(\w+) instanceof Buffer/g , 'Buffer.isBuffer($1)' ] , internalUtilReplacement = [ /^const internalUtil = require\('internal\/util'\);/m , '\n/**/\nconst internalUtil = {\n deprecate: require(\'util-deprecate\')\n};\n' + '/**/\n' ] , internalDirectory = [ /require\('internal\/streams\/([a-zA-z]+)'\)/g, 'require(\'./internal/streams/$1\')' ] , fixInstanceCheck = [ /if \(typeof Symbol === 'function' && Symbol\.hasInstance\) \{/, `if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {` ] , removeOnWriteBind = [ /onwrite\.bind\([^)]+?\)/ , `function(er) { onwrite(stream, er); }` ] , addUintStuff = [ /(?:var|const) (?:{ )Buffer(?: }) = require\('buffer'\)(?:\.Buffer)?;/g , ` const Buffer = require('buffer').Buffer const OurUint8Array = global.Uint8Array || function () {} function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); } function _isUint8Array(obj) { return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; } ` ] , addConstructors = [ headRegexp , `$1 /* */ 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 function CorkedRequest(state) { this.next = null; this.entry = null; this.finish = () => { onCorkedFinish(this, state) }; } /* */ ` ] , useWriteReq = [ /state\.lastBufferedRequest = \{.+?\}/g , `state.lastBufferedRequest = new WriteReq(chunk, encoding, cb)` ] , useCorkedRequest = [ /var corkReq = [\s\S]+?(.+?)\.corkedRequestsFree = corkReq/g , `$1.corkedRequestsFree = new CorkedRequest($1)` ] , fixUintStuff = [ /Stream\.(_isUint8Array|_uint8ArrayToBuffer)\(/g , `$1(` ] , fixBufferCheck = [ /Object\.getPrototypeOf\((chunk)\) !== Buffer\.prototype/g , '!Buffer.isBuffer($1)' ] , errorsOneLevel = [ /internal\/errors/ , '../errors' ] , errorsTwoLevel = [ /internal\/errors/ , '../../../errors' ] , warnings = [ /^const { emitExperimentalWarning } = require\('internal\/util'\);/m, 'const { emitExperimentalWarning } = require(\'../experimentalWarning\');' ] , numberIE11 = [ /Number\.isNaN\(n\)/g , 'n !== n' ] , integerIE11 = [ /Number\.isInteger\(hwm\)/g , '(isFinite(hwm) && Math.floor(hwm) === hwm)' ] , noAsyncIterators1 = [ /Readable\.prototype\[Symbol\.asyncIterator\] = function\(\) \{/g , 'if (typeof Symbol === \'function\' ) {\nReadable.prototype[Symbol.asyncIterator] = function () {' ] , noAsyncIterators2 = [ /return createReadableStreamAsyncIterator\(this\);\n};/m , 'return createReadableStreamAsyncIterator(this);\n};\n}' ] , noAsyncIteratorsFrom1 = [ /Readable\.from = function *\(iterable, opts\) \{/g , 'if (typeof Symbol === \'function\' ) {\nReadable.from = function (iterable, opts) {' ] , noAsyncIteratorsFrom2 = [ /return from\(Readable, iterable, opts\);\n};/m , 'return from(Readable, iterable, opts);\n};\n}' ] , once = [ /const \{ once \} = require\('internal\/util'\);/ , 'function once(callback) { let called = false; return function(...args) { if (called) return; called = true; callback(...args); }; }' ] module.exports['_stream_duplex.js'] = [ requireReplacement , instanceofReplacement , utilReplacement , inherits , stringDecoderReplacement , objectKeysReplacement , objectKeysDefine , errorsOneLevel ] module.exports['_stream_passthrough.js'] = [ requireReplacement , instanceofReplacement , utilReplacement , inherits , stringDecoderReplacement , errorsOneLevel ] module.exports['_stream_readable.js'] = [ addDuplexRequire , addDuplexDec , requireReplacement , instanceofReplacement , altIndexOfImplReplacement , altIndexOfUseReplacement , stringDecoderReplacement , debugLogReplacement , utilReplacement , inherits , stringDecoderReplacement , eventEmittterReplacement , requireStreamReplacement , isBufferReplacement , eventEmittterListenerCountReplacement , internalDirectory , fixUintStuff , addUintStuff , errorsOneLevel , warnings , numberIE11 , noAsyncIterators1 , noAsyncIterators2 , noAsyncIteratorsFrom1 , noAsyncIteratorsFrom2 ] module.exports['_stream_transform.js'] = [ requireReplacement , instanceofReplacement , utilReplacement , inherits , stringDecoderReplacement , errorsOneLevel ] module.exports['_stream_writable.js'] = [ addDuplexRequire , addDuplexDec , requireReplacement , instanceofReplacement , utilReplacement , inherits , stringDecoderReplacement , debugLogReplacement , deprecateReplacement , objectDefinePropertyReplacement , objectDefinePropertySingReplacement , bufferIsEncodingReplacement , [ /^var assert = require\('assert'\);$/m, '' ] , requireStreamReplacement , isBufferReplacement , internalUtilReplacement , fixInstanceCheck , removeOnWriteBind , internalDirectory , fixUintStuff , addUintStuff , fixBufferCheck , useWriteReq , useCorkedRequest , addConstructors , errorsOneLevel ] module.exports['internal/streams/buffer_list.js'] = [ [ /inspect.custom/g, 'custom' ], [ /const \{ inspect \} = require\('util'\);/, ` const { inspect } = require('util') const custom = inspect && inspect.custom || 'inspect' ` ] ] module.exports['internal/streams/destroy.js'] = [ errorsTwoLevel ] module.exports['internal/streams/state.js'] = [ , errorsTwoLevel , integerIE11 ] module.exports['internal/streams/async_iterator.js'] = [ , errorsTwoLevel , [ /internal\/streams\/end-of-stream/, './end-of-stream' ] , [ /const AsyncIteratorPrototype = Object\.getPrototypeOf\(\n.*Object\.getPrototypeOf\(async function\* \(\) \{\}\).prototype\);/m, 'const AsyncIteratorPrototype = Object\.getPrototypeOf(function () {})' ] , [ / return\(\)/, '[Symbol.asyncIterator]() { return this },\n return\(\)' ] ] module.exports['internal/streams/end-of-stream.js'] = [ , errorsTwoLevel , [ /const \{ once \} = require\('internal\/util'\);/, `function once(callback) { let called = false; return function(...args) { if (called) return; called = true; callback.apply(this, args); }; }` ] ] module.exports['internal/streams/pipeline.js'] = [ once , errorsTwoLevel , [ /require\('internal\/streams\/end-of-stream'\)/, 'require(\'.\/end-of-stream\')' ] ] module.exports['internal/streams/from.js'] = [ errorsTwoLevel , [ /if \(iterable && iterable\[Symbol.asyncIterator\]\)/ , `if (iterable && typeof iterable.next === 'function') { iterator = iterable } else if (iterable && iterable[Symbol.asyncIterator])` ] ] readable-stream-3.6.0/build/test-replacements.js000066400000000000000000000300261362132315000216410ustar00rootroot00000000000000const altForEachImplReplacement = require('./common-replacements').altForEachImplReplacement , altForEachUseReplacement = require('./common-replacements').altForEachUseReplacement , altIndexOfImplReplacement = require('./common-replacements').altIndexOfImplReplacement , altIndexOfUseReplacement = require('./common-replacements').altIndexOfUseReplacement , objectKeysDefine = require('./common-replacements').objectKeysDefine , objectKeysReplacement = require('./common-replacements').objectKeysReplacement , bufferShimFix = require('./common-replacements').bufferShimFix , bufferStaticMethods = require('./common-replacements').bufferStaticMethods , specialForEachReplacment = require('./common-replacements').specialForEachReplacment , deepStrictEqual = [ /util\.isDeepStrictEqual/, 'require(\'deep-strict-equal\')' ] , tapOk = [ /console\.log\('ok'\);/g, 'require(\'tap\').pass();' ] , catchES7 = [ /} catch {/, '} catch(_e) {' ] , catchES7OpenClose = [ /} catch {}/, '} catch(_e) {}' ] module.exports.all = [ [ /require\(['"]stream['"]\)/g , 'require(\'../../\')' ] // some tests need stream.Stream but readable.js doesn't offer that // and we've undone it with the previous replacement , [ /stream\.Stream|require\('\.\.\/\.\.\/'\)\.Stream/g , 'require(\'stream\').Stream' ] , [ /require\(['"](_stream_\w+)['"]\)/g , 'require(\'../../lib/$1\')' ] , [ /Stream.(Readable|Writable|Duplex|Transform|PassThrough)/g , 'require(\'../../\').$1' ] , bufferShimFix , bufferStaticMethods , [ /require\(['"]assert['"]\)/g , 'require(\'assert/\')' ] , [ /\/\/ Flags: .*/ , '' ] ] module.exports['test-stream2-basic.js'] = [ altForEachImplReplacement , specialForEachReplacment ] module.exports['test-stream2-objects.js'] = [ altForEachImplReplacement , altForEachUseReplacement ] module.exports['test-stream2-transform.js'] = [ altForEachImplReplacement , altForEachUseReplacement ] module.exports['test-stream2-writable.js'] = [ altForEachImplReplacement , altForEachUseReplacement , [ /'latin1',/g, '\'binary\',' ] ] module.exports['test-stream-big-packet.js'] = [ altIndexOfImplReplacement , altIndexOfUseReplacement ] module.exports['test-stream-end-paused.js'] = [ [ /console.log\('ok'\);/, '' ] ] module.exports['common.js'] = [ objectKeysDefine , objectKeysReplacement , altForEachImplReplacement , altForEachUseReplacement , deepStrictEqual , catchES7 , catchES7OpenClose , [ /require\('module'\)\.builtinModules\.includes\('worker_threads'\)/, 'false' ] , [ /process.argv.length === 2/, 'false' ] , [ /^( for \(var x in global\) \{|function leakedGlobals\(\) \{)$/m , ' /**/\n' + ' if (typeof constructor == \'function\')\n' + ' knownGlobals.push(constructor);\n' + ' if (typeof DTRACE_NET_SOCKET_READ == \'function\')\n' + ' knownGlobals.push(DTRACE_NET_SOCKET_READ);\n' + ' if (typeof DTRACE_NET_SOCKET_WRITE == \'function\')\n' + ' knownGlobals.push(DTRACE_NET_SOCKET_WRITE);\n' + ' if (global.__coverage__)\n' + ' knownGlobals.push(__coverage__);\n' + '\'console,clearImmediate,setImmediate,core,__core-js_shared__,Promise,Map,Set,WeakMap,WeakSet,Reflect,System,queueMicrotask,asap,Observable,regeneratorRuntime,_babelPolyfill\'.split(\',\').filter(function (item) { return typeof global[item] !== undefined}).forEach(function (item) {knownGlobals.push(global[item])})' + ' /**/\n\n$1' ] , [ /(exports.mustCall[\s\S]*)/m , '$1\n' + 'if (!util._errnoException) {\n' + ' var uv;\n' + ' util._errnoException = function(err, syscall) {\n' + ' if (util.isUndefined(uv)) try { uv = process.binding(\'uv\'); } catch (e) {}\n' + ' var errname = uv ? uv.errname(err) : \'\';\n' + ' var e = new Error(syscall + \' \' + errname);\n' + ' e.code = errname;\n' + ' e.errno = errname;\n' + ' e.syscall = syscall;\n' + ' return e;\n' + ' };\n' + '}\n' ] , [ /^if \(global\.ArrayBuffer\) \{([^\}]+)\}$/m , '/**/if (!process.browser) {' + '\nif \(global\.ArrayBuffer\) {$1}\n' + '}/**/\n' ] , [ /^Object\.defineProperty\(([\w\W]+?)\}\)\;/mg , '/**/if (!process.browser) {' + '\nObject\.defineProperty($1});\n' + '}/**/\n' ] , [ /if \(!process\.send\)/ , 'if (!process.send && !process.browser)' ] , [ /^/, `/**/ require('@babel/polyfill'); var util = require('util'); for (var i in util) exports[i] = util[i]; /**/` ], [ /var regexp = `\^\(\\\\w\+\)\\\\s\+\\\\s\$\{port\}\/\$\{protocol\}\\\\s`;/, `var regexp = '^(\\w+)\\s+\\s' + port + '/' + protocol + '\\s';` ], [ /require\(['"]stream['"]\)/g , 'require(\'../../\')' ], [ /^var util = require\('util'\);/m , '\n/**/\nvar util = require(\'core-util-is\');\n' + 'util.inherits = require(\'inherits\');\n/**/\n' ], [ /^const util = require\('util'\);/m , '\n/**/\nvar util = require(\'core-util-is\');\n' + 'util.inherits = require(\'inherits\');\n/**/\n' ] , [ /process\.binding\('timer_wrap'\)\.Timer;/, '{now: function (){}}' ], [ /(exports\.enoughTestCpu[^;]+;)/, '/*$1*/' ], [ /exports\.buildType/, '//exports.buildType' ], [ /require\('async_hooks'\)/, '/*require(\'async_hooks\')' ], [ /\}\).enable\(\);/, '}).enable();*/' ], [ /const async_hooks = require\('async_hooks'\)/, 'var async_hooks = require(\'async_\' + \'hooks\')' ], [ /(?:var|const) async_wrap = process\.binding\('async_wrap'\);\n.*(?:var|const) (?:{ )?kCheck(?: })? = async_wrap\.constants(?:\.kCheck)?;/gm, '// const async_wrap = process.binding(\'async_wrap\');\n' + ' // const kCheck = async_wrap.constants.kCheck;' ], [ /async_wrap\.async_hook_fields\[kCheck\] \+= 1;/, '// async_wrap.async_hook_fields[kCheck] += 1;' ], [ /os\.cpus\(\)/, 'os.cpus().length === 0 ? [{ speed: 1000 }] : os.cpus()' ], [ /const buildType = process.config.target_defaults.default_configuration;/, 'const buildType = \'readable-stream\';' ], [ /const hasCrypto = Boolean\(process.versions.openssl\);/, 'const hasCrypto = true;' ] ] // this test has some trouble with the nextTick depth when run // to stdout, it's also very noisy so we'll quiet it module.exports['test-stream-pipe-multi.js'] = [ altForEachImplReplacement , altForEachUseReplacement , [ /console\.error/g , '//console.error' ] , [ /process\.nextTick/g , 'setImmediate' ] ] // just noisy module.exports['test-stream2-large-read-stall.js'] = [ [ /console\.error/g , ';false && console.error' ] ] module.exports['test-stream-pipe-cleanup.js'] = [ [ /(function Writable\(\) \{)/ , '(function (){\nif (/^v0\\.8\\./.test(process.version))\n return\n\n$1' ] , [ /$/ ,'}())' ] ] module.exports['test-stream2-stderr-sync.js'] = [ altForEachImplReplacement , altForEachUseReplacement , [ // 'tty_wrap' is too different across node versions. // this bypasses it and replicates a console.error() test /(function child0\(\) \{)/ , '$1\n' + ' return console.error(\'child 0\\nfoo\\nbar\\nbaz\');\n' ] ] module.exports['test-stream-unshift-read-race.js'] = [ [ /data\.slice\(pos, pos \+ n\)/g, 'data.slice(pos, Math.min(pos + n, data.length))' ] ] module.exports['test-stream-pipe-without-listenerCount.js'] = [ [ /require\(\'stream\'\)/g, 'stream' ] ] module.exports['test-stream2-unpipe-drain.js'] = [ [ /^/, `(function () {\n` ], [ /$/ ,'}())' ] ] module.exports['test-stream2-decode-partial.js'] = [ [ /readable\.push\(source\.slice\(4, 6\)\)/ ,`readable.push(source.slice(4, source.length));` ] ] module.exports['test-stream3-cork-uncork.js'] = module.exports['test-stream3-cork-end.js'] = [ [ /assert\.ok\(seen\.equals\(expected\)\);/, 'assert.deepEqual(seen, expected);' ] ] module.exports['test-stream2-readable-from-list.js'] = [ [ /require\('internal\/streams\/buffer_list'\)/, 'require(\'../../lib/internal/streams/buffer_list\')' ], [ /assert\.strictEqual\(\n *util.inspect\(\[ list \], \{ compact: false \}\),\n *`\[\n *BufferList \{\n *head: \[Object\],\n *tail: \[Object\],\n *length: 4\n *\}\n *\]`\);/m, 'assert.strictEqual(util.inspect([ list ], { compact: false }).indexOf(\'BufferList\') > 0, true)' ] ] module.exports['test-stream-writev.js'] = [ tapOk, [ /console.log\(`# decode=/, 'require(\'tap\').test(`# decode=' ] ] module.exports['test-stream3-pause-then-read.js'] = [ tapOk ] module.exports['test-stream-unshift-read-race.js'] = [ tapOk ] module.exports['test-stream2-unpipe-leak.js'] = [ tapOk ] module.exports['test-stream2-compatibility.js'] = [ tapOk ] module.exports['test-stream-push-strings.js'] = [ tapOk ] module.exports['test-stream-unshift-empty-chunk.js'] = [ tapOk ] module.exports['test-stream2-pipe-error-once-listener.js'] = [ tapOk ] module.exports['test-stream-push-order.js'] = [ tapOk ] module.exports['test-stream2-push.js'] = [ tapOk ] module.exports['test-stream2-readable-empty-buffer-no-eof.js'] = [ tapOk, [ /case 3:\n(\s+)setImmediate\(r\.read\.bind\(r, 0\)\);/, 'case 3:\n$1setTimeout(r.read.bind(r, 0), 50);' ] ] module.exports['test-stream-buffer-list.js'] = [ [ /require\('internal\/streams\/buffer_list'\);/, 'require(\'../../lib/internal/streams/buffer_list\');' ] ] module.exports['test-stream-transform-constructor-set-methods.js'] = [ [ /Error: _transform\\\(\\\) is n/, 'Error: .*[Nn]' ] ] module.exports['test-stream-unpipe-event.js'] = [ [ /^/, 'if (process.version.indexOf(\'v0.8\') === 0) { process.exit(0) }\n' ] ] module.exports['test-stream-readable-flow-recursion.js'] = [ tapOk, deepStrictEqual ] module.exports['test-stream-readable-with-unimplemented-_read.js'] = [ deepStrictEqual ] module.exports['test-stream-writable-needdrain-state.js'] = [ deepStrictEqual ] module.exports['test-stream-readable-setEncoding-null.js'] = [ deepStrictEqual ] module.exports['test-stream-pipeline.js'] = [ [ /require\('http2'\)/g, '{ createServer() { return { listen() {} } } }' ], [ /assert\.deepStrictEqual\(err, new Error\('kaboom'\)\);/g, 'assert.strictEqual(err.message, \'kaboom\');' ], [ /cb\(new Error\('kaboom'\)\)/g, 'process.nextTick(cb, new Error(\'kaboom\'))' ], [ /const \{ promisify \} = require\('util'\);/g, 'const promisify = require(\'util-promisify\');' ] ] module.exports['test-stream-finished.js'] = [ [ /const \{ promisify \} = require\('util'\);/g, 'const promisify = require(\'util-promisify\');' ] ] module.exports['test-stream-readable-async-iterators.js'] = [ [ /assert.rejects\(/g, '(function(f, e) { let success = false; f().then(function() { success = true; throw new Error(\'should not succeed\') }).catch(function(e2) { if (success) { throw e2; } assert.strictEqual(e.message, e2.message); })})(' ], [ /tests\(\).then\(common\.mustCall\(\)\)/, 'tests().then(common.mustCall(), common.mustNotCall(console.log))' ], [ /const AsyncIteratorPrototype = Object\.getPrototypeOf\(\n.*Object\.getPrototypeOf\(async function\* \(\) \{\}\).prototype\);/m, 'const AsyncIteratorPrototype = Object\.getPrototypeOf(function () {})' ] ] module.exports['test-readable-from.js'] = [ [ /const \{ once \} = require\('events'\);/ , 'const once = require(\'events.once\');' ] ] readable-stream-3.6.0/doc/000077500000000000000000000000001362132315000153115ustar00rootroot00000000000000readable-stream-3.6.0/doc/wg-meetings/000077500000000000000000000000001362132315000175375ustar00rootroot00000000000000readable-stream-3.6.0/doc/wg-meetings/2015-01-30.md000066400000000000000000000043501362132315000211100ustar00rootroot00000000000000# streams WG Meeting 2015-01-30 ## Links * **Google Hangouts Video**: http://www.youtube.com/watch?v=I9nDOSGfwZg * **GitHub Issue**: https://github.com/iojs/readable-stream/issues/106 * **Original Minutes Google Doc**: https://docs.google.com/document/d/17aTgLnjMXIrfjgNaTUnHQO7m3xgzHR2VXBTmi03Qii4/ ## Agenda Extracted from https://github.com/iojs/readable-stream/labels/wg-agenda prior to meeting. * adopt a charter [#105](https://github.com/iojs/readable-stream/issues/105) * release and versioning strategy [#101](https://github.com/iojs/readable-stream/issues/101) * simpler stream creation [#102](https://github.com/iojs/readable-stream/issues/102) * proposal: deprecate implicit flowing of streams [#99](https://github.com/iojs/readable-stream/issues/99) ## Minutes ### adopt a charter * group: +1's all around ### What versioning scheme should be adopted? * group: +1’s 3.0.0 * domenic+group: pulling in patches from other sources where appropriate * mikeal: version independently, suggesting versions for io.js * mikeal+domenic: work with TC to notify in advance of changes simpler stream creation ### streamline creation of streams * sam: streamline creation of streams * domenic: nice simple solution posted but, we lose the opportunity to change the model may not be backwards incompatible (double check keys) **action item:** domenic will check ### remove implicit flowing of streams on(‘data’) * add isFlowing / isPaused * mikeal: worrying that we’re documenting polyfill methods – confuses users * domenic: more reflective API is probably good, with warning labels for users * new section for mad scientists (reflective stream access) * calvin: name the “third state” * mikeal: maybe borrow the name from whatwg? * domenic: we’re missing the “third state” * consensus: kind of difficult to name the third state * mikeal: figure out differences in states / compat * mathias: always flow on data – eliminates third state * explore what it breaks **action items:** * ask isaac for ability to list packages by what public io.js APIs they use (esp. Stream) * ask rod/build for infrastructure * **chris**: explore the “flow on data” approach * add isPaused/isFlowing * add new docs section * move isPaused to that section readable-stream-3.6.0/errors-browser.js000066400000000000000000000101451362132315000201000ustar00rootroot00000000000000'use strict'; function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; } var codes = {}; function createErrorType(code, message, Base) { if (!Base) { Base = Error; } function getMessage(arg1, arg2, arg3) { if (typeof message === 'string') { return message; } else { return message(arg1, arg2, arg3); } } var NodeError = /*#__PURE__*/ function (_Base) { _inheritsLoose(NodeError, _Base); function NodeError(arg1, arg2, arg3) { return _Base.call(this, getMessage(arg1, arg2, arg3)) || this; } return NodeError; }(Base); NodeError.prototype.name = Base.name; NodeError.prototype.code = code; codes[code] = NodeError; } // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js function oneOf(expected, thing) { if (Array.isArray(expected)) { var len = expected.length; expected = expected.map(function (i) { return String(i); }); if (len > 2) { return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1]; } else if (len === 2) { return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]); } else { return "of ".concat(thing, " ").concat(expected[0]); } } else { return "of ".concat(thing, " ").concat(String(expected)); } } // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith function startsWith(str, search, pos) { return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search; } // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith function endsWith(str, search, this_len) { if (this_len === undefined || this_len > str.length) { this_len = str.length; } return str.substring(this_len - search.length, this_len) === search; } // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes function includes(str, search, start) { if (typeof start !== 'number') { start = 0; } if (start + search.length > str.length) { return false; } else { return str.indexOf(search, start) !== -1; } } createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) { return 'The value "' + value + '" is invalid for option "' + name + '"'; }, TypeError); createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) { // determiner: 'must be' or 'must not be' var determiner; if (typeof expected === 'string' && startsWith(expected, 'not ')) { determiner = 'must not be'; expected = expected.replace(/^not /, ''); } else { determiner = 'must be'; } var msg; if (endsWith(name, ' argument')) { // For cases like 'first argument' msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type')); } else { var type = includes(name, '.') ? 'property' : 'argument'; msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type')); } msg += ". Received type ".concat(typeof actual); return msg; }, TypeError); createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF'); createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) { return 'The ' + name + ' method is not implemented'; }); createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close'); createErrorType('ERR_STREAM_DESTROYED', function (name) { return 'Cannot call ' + name + ' after a stream was destroyed'; }); createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times'); createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable'); createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end'); createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError); createErrorType('ERR_UNKNOWN_ENCODING', function (arg) { return 'Unknown encoding: ' + arg; }, TypeError); createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event'); module.exports.codes = codes; readable-stream-3.6.0/errors.js000066400000000000000000000072031362132315000164200ustar00rootroot00000000000000'use strict'; const codes = {}; function createErrorType(code, message, Base) { if (!Base) { Base = Error } function getMessage (arg1, arg2, arg3) { if (typeof message === 'string') { return message } else { return message(arg1, arg2, arg3) } } class NodeError extends Base { constructor (arg1, arg2, arg3) { super(getMessage(arg1, arg2, arg3)); } } NodeError.prototype.name = Base.name; NodeError.prototype.code = code; codes[code] = NodeError; } // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js function oneOf(expected, thing) { if (Array.isArray(expected)) { const len = expected.length; expected = expected.map((i) => String(i)); if (len > 2) { return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` + expected[len - 1]; } else if (len === 2) { return `one of ${thing} ${expected[0]} or ${expected[1]}`; } else { return `of ${thing} ${expected[0]}`; } } else { return `of ${thing} ${String(expected)}`; } } // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith function startsWith(str, search, pos) { return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search; } // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith function endsWith(str, search, this_len) { if (this_len === undefined || this_len > str.length) { this_len = str.length; } return str.substring(this_len - search.length, this_len) === search; } // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes function includes(str, search, start) { if (typeof start !== 'number') { start = 0; } if (start + search.length > str.length) { return false; } else { return str.indexOf(search, start) !== -1; } } createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) { return 'The value "' + value + '" is invalid for option "' + name + '"' }, TypeError); createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) { // determiner: 'must be' or 'must not be' let determiner; if (typeof expected === 'string' && startsWith(expected, 'not ')) { determiner = 'must not be'; expected = expected.replace(/^not /, ''); } else { determiner = 'must be'; } let msg; if (endsWith(name, ' argument')) { // For cases like 'first argument' msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`; } else { const type = includes(name, '.') ? 'property' : 'argument'; msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`; } msg += `. Received type ${typeof actual}`; return msg; }, TypeError); createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF'); createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) { return 'The ' + name + ' method is not implemented' }); createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close'); createErrorType('ERR_STREAM_DESTROYED', function (name) { return 'Cannot call ' + name + ' after a stream was destroyed'; }); createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times'); createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable'); createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end'); createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError); createErrorType('ERR_UNKNOWN_ENCODING', function (arg) { return 'Unknown encoding: ' + arg }, TypeError); createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event'); module.exports.codes = codes; readable-stream-3.6.0/examples/000077500000000000000000000000001362132315000163625ustar00rootroot00000000000000readable-stream-3.6.0/examples/CAPSLOCKTYPER.JS000066400000000000000000000013371362132315000206470ustar00rootroot00000000000000var Transform = require('../transform'); var inherits = require('util').inherits; // subclass function MyStream () { Transform.call(this, { lowWaterMark: 0, encoding: 'utf8' }); } inherits(MyStream, Transform); MyStream.prototype._transform = function (chunk, outputFn, callback) { outputFn(Buffer.from(String(chunk).toUpperCase())); callback(); }; // use it! var s = new MyStream(); process.stdin.resume(); process.stdin.pipe(s).pipe(process.stdout); if (process.stdin.setRawMode) process.stdin.setRawMode(true); process.stdin.on('data', function (c) { c = c.toString(); if (c === '\u0003' || c === '\u0004') { process.stdin.pause(); s.end(); } if (c === '\r') process.stdout.write('\n'); }); readable-stream-3.6.0/examples/typer.js000066400000000000000000000006231362132315000200640ustar00rootroot00000000000000var fs = require('fs'); var fst = fs.createReadStream(__filename); var Readable = require('../readable.js'); var rst = new Readable(); rst.wrap(fst); rst.on('end', function() { process.stdin.pause(); }); process.stdin.setRawMode(true); process.stdin.on('data', function() { var c = rst.read(3); if (!c) return setTimeout(process.exit, 500) process.stdout.write(c); }); process.stdin.resume(); readable-stream-3.6.0/experimentalWarning.js000066400000000000000000000007141362132315000211270ustar00rootroot00000000000000'use strict' var experimentalWarnings = new Set(); function emitExperimentalWarning(feature) { if (experimentalWarnings.has(feature)) return; var msg = feature + ' is an experimental feature. This feature could ' + 'change at any time'; experimentalWarnings.add(feature); process.emitWarning(msg, 'ExperimentalWarning'); } function noop() {} module.exports.emitExperimentalWarning = process.emitWarning ? emitExperimentalWarning : noop; readable-stream-3.6.0/lib/000077500000000000000000000000001362132315000153125ustar00rootroot00000000000000readable-stream-3.6.0/lib/_stream_duplex.js000066400000000000000000000104571362132315000206720ustar00rootroot00000000000000// 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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); } 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 // userland will fail enumerable: false, get: function get() { return this._writableState.highWaterMark; } }); Object.defineProperty(Duplex.prototype, 'writableBuffer', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in // userland will fail enumerable: false, get: function get() { return this._writableState && this._writableState.getBuffer(); } }); Object.defineProperty(Duplex.prototype, 'writableLength', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in // userland will fail enumerable: false, get: function get() { return this._writableState.length; } }); // 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. 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 // userland will fail enumerable: false, get: function get() { if (this._readableState === undefined || this._writableState === undefined) { return false; } return this._readableState.destroyed && this._writableState.destroyed; }, set: function set(value) { // we ignore the value if the stream // has not been initialized yet if (this._readableState === undefined || this._writableState === undefined) { return; } // backward compatibility, the user is explicitly // managing destroyed this._readableState.destroyed = value; this._writableState.destroyed = value; } });readable-stream-3.6.0/lib/_stream_passthrough.js000066400000000000000000000031361362132315000217340ustar00rootroot00000000000000// 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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); };readable-stream-3.6.0/lib/_stream_readable.js000066400000000000000000001062041362132315000211240ustar00rootroot00000000000000// 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 () {}; 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 { debug = function debug() {}; } /**/ var BufferList = require('./internal/streams/buffer_list'); var destroyImpl = require('./internal/streams/destroy'); var _require = require('./internal/streams/state'), 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. 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 // 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 // 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; // 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 // Note: 0 is a valid value, means "don't call _read preemptively ever" this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // 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; this.pipesCount = 0; 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 // 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; // 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.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish') this.autoDestroy = !!options.autoDestroy; // 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'; // 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 var isDuplex = this instanceof Duplex; 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 // userland will fail enumerable: false, get: function get() { if (this._readableState === undefined) { return false; } return this._readableState.destroyed; }, set: function set(value) { // we ignore the value if the stream // has not been initialized yet if (!this._readableState) { return; } // 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. // 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() 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) { errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF()); } else if (state.destroyed) { 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); } else { addChunk(stream, state, chunk, false); } } } else if (!addToFront) { state.reading = false; maybeReadMore(stream, state); } } // 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; stream.emit('data', chunk); } else { // update the buffer info. state.length += state.objectMode ? 1 : chunk.length; 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. 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: 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 var MAX_HWM = 0x40000000; function computeNewHighWaterMark(n) { if (n >= MAX_HWM) { // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE. n = MAX_HWM; } else { // Get the next highest power of 2 to prevent increasing hwm excessively in // tiny amounts n--; n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; n++; } return n; } // 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 (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); 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. 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 // 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); // 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 // *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 // the state of the read buffer, providing enough data when // before there was *not* enough. // // So, the steps are: // 1. Figure out what the state of things will be after we do // a read from the buffer. // // 2. If that resulting state will trigger a _read, then call _read. // Note that this may be asynchronous, or synchronous. Yes, it is // deeply ugly to write APIs this way, but that still doesn't mean // that the Readable class should behave improperly, as streams are // designed to be sync/async agnostic. // Take note if the _read call is sync or async (ie, if the read call // has returned yet), so that we know whether or not it's safe to emit // '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. var doRead = state.needReadable; 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. 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 this._read(state.highWaterMark); 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; } else { 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 (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() // the readable code triggers during a read() call emitReadable(stream); } 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 // 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 // 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, // 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. // // The conditions for reading more data are (one of): // - Not enough data buffered (state.length < state.highWaterMark). The loop // is responsible for filling the buffer with enough data if such data // is available. If highWaterMark is 0 and we are not in the flowing mode // we should _not_ attempt to buffer any extra data. We'll get more data // when the stream consumer calls read() instead. // - No data in the buffer, and the stream is in flowing mode. In this mode // the loop below is responsible for ensuring read() is called. Failing to // call read here would abort the flow and there's no other mechanism for // continuing the flow if the stream consumer has just subscribed to the // 'data' event. // // In addition to the above conditions to keep reading data, the following // conditions prevent the data from being read: // - The stream has ended (state.ended). // - There is already a pending 'read' operation (state.reading). This is a // case where the the stream has called the implementation defined _read() // method, but they are processing the call asynchronously and have _not_ // called push() with new data. In this case we skip performing more // read()s. The execution ends in this method again after the _read() ends // up calling push() with more data. while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) { var len = state.length; debug('maybeReadMore read 0'); stream.read(0); if (len === state.length) // didn't get any data, stop spinning. break; } state.readingMore = false; } // 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; cleanup(); } } } function onend() { debug('onend'); dest.end(); } // 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 dest.removeListener('close', onclose); dest.removeListener('finish', onfinish); dest.removeListener('drain', ondrain); dest.removeListener('error', onerror); dest.removeListener('unpipe', onunpipe); 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 // 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 // also returned false. // => Check whether `dest` is still a piping destination. if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { 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. 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. 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. 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 (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. state.pipes = null; state.pipesCount = 0; state.flowing = false; if (dest) dest.emit('unpipe', this, unpipeInfo); return this; } // slow case. multiple pipe destinations. if (!dest) { // remove all. var dests = state.pipes; var len = state.pipesCount; state.pipes = null; state.pipesCount = 0; state.flowing = false; for (var i = 0; i < len; i++) { dests[i].emit('unpipe', this, { hasUnpiped: false }); } return this; } // try to find the right one. var index = indexOf(state.pipes, dest); if (index === -1) return this; state.pipes.splice(index, 1); state.pipesCount -= 1; 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 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 if (state.flowing !== false) this.resume(); } else if (ev === 'readable') { if (!state.endEmitted && !state.readableListening) { state.readableListening = state.needReadable = true; state.flowing = false; state.emittedReadable = false; debug('on readable', state.length, state.reading); if (state.length) { emitReadable(this); } else if (!state.reading) { process.nextTick(nReadingNextTick, this); } } } 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 // after readable has been emitted but before I/O (nextTick) to // support once('readable', fn) cycles. This means that calling // resume within the same tick will have no // 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 // after readable has been emitted but before I/O (nextTick) to // support once('readable', fn) cycles. This means that calling // resume within the same tick will have no // 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 } 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. Readable.prototype.resume = function () { var state = this._readableState; if (!state.flowing) { 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) { ; } } // 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.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. for (var i in stream) { if (this[i] === undefined && typeof stream[i] === 'function') { this[i] = function methodWrap(method) { return function methodWrapReturnFunction() { return stream[method].apply(stream, arguments); }; }(i); } } // 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. 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 // userland will fail enumerable: false, get: function get() { return this._readableState.highWaterMark; } }); Object.defineProperty(Readable.prototype, 'readableBuffer', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in // userland will fail enumerable: false, get: function get() { return this._readableState && this._readableState.buffer; } }); Object.defineProperty(Readable.prototype, 'readableFlowing', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in // userland will fail enumerable: false, get: function get() { return this._readableState.flowing; }, set: function set(state) { if (this._readableState) { this._readableState.flowing = state; } } }); // exposed for testing purposes only. Readable._fromList = fromList; Object.defineProperty(Readable.prototype, 'readableLength', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in // userland will fail enumerable: false, get: function get() { return this._readableState.length; } }); // 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; var ret; if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { // read it all, truncate the list if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length); state.buffer.clear(); } else { // read part of list ret = state.buffer.consume(n, state.decoder); } 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. 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; }readable-stream-3.6.0/lib/_stream_transform.js000066400000000000000000000174131362132315000214030ustar00rootroot00000000000000// 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 // some bits pass through, and others are simply ignored. (That would // be a valid example of a transform, of course.) // // While the output is causally related to the input, it's not a // necessarily symmetric or synchronous transformation. For example, // a zlib stream might take multiple plain-text writes(), and then // emit a single compressed chunk some time in the future. // // Here's how this works: // // The Transform stream has all the aspects of the readable and writable // stream classes. When you write(chunk), that calls _write(chunk,cb) // internally, and returns false if there's a lot of pending writes // buffered up. When you call read(), that calls _read(n) until // there's enough pending readable data buffered up. // // In a transform stream, the written data is placed in a buffer. When // _read(n) is called, it transforms the queued up data, calling the // buffered _write cb's as it consumes chunks. If consuming a single // written chunk would result in multiple output chunks, then the first // outputted bit calls the readcb, and subsequent chunks just go into // the read buffer, and will cause it to emit 'readable' if necessary. // // This way, back-pressure is actually determined by the reading side, // since _read has to be called to start processing a new chunk. However, // a pathological inflate type of transform can cause excessive buffering // here. For example, imagine a stream where every byte of input is // interpreted as an integer from 0-255, and then results in that many // bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in // 1kb of data being output. In this case, you could write a very small // amount of input, and end up with a very large amount of output. In // such a pathological inflating mechanism, there'd be no way to tell // the system to stop doing the transform. A single 4MB write could // cause the system to run out of memory. // // 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; 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` 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); this._transformState = { afterTransform: afterTransform.bind(this), needTransform: false, transforming: false, writecb: null, writechunk: null, writeencoding: null }; // start out asking for a readable event once data is transformed. this._readableState.needReadable = true; // 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. 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); }); } else { 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! // override this function in implementation classes. // 'chunk' is an input chunk. // // Call `push(newChunk)` to pass along transformed output // to the readable side. You may call 'push' zero or more times. // // 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. // _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 // will get processed, now that we've asked for it. 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 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); }readable-stream-3.6.0/lib/_stream_writable.js000066400000000000000000000524751362132315000212100ustar00rootroot00000000000000// 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 function CorkedRequest(state) { var _this = this; this.next = null; this.entry = null; this.finish = function () { onCorkedFinish(_this, 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 () {}; 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; 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; 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 // 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; // 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 // 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); // if _final has been called this.finalCalled = false; // 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; // has it been destroyed this.destroyed = false; // 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 // encoding is 'binary' so we have to make this configurable. // Everything else in the universe uses 'utf8', though. this.defaultEncoding = options.defaultEncoding || 'utf8'; // 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; // a flag to see when we're in the middle of a write. this.writing = false; // when true all writes will be buffered until .uncork() call this.corked = 0; // 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; // 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; // 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. this.writelen = 0; this.bufferedRequest = null; this.lastBufferedRequest = null; // number of pending user-supplied write callbacks // this must be 0 before 'finish' can be emitted this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs // This is relevant for synchronous Transform streams this.prefinished = false; // True if the error was already emitted and should not be thrown again this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true. this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end') this.autoDestroy = !!options.autoDestroy; // count buffered requests this.bufferedRequestCount = 0; // 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', { get: internalUtil.deprecate(function writableStateBufferGetter() { return this.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. var realHasInstance; if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') { realHasInstance = Function.prototype[Symbol.hasInstance]; Object.defineProperty(Writable, Symbol.hasInstance, { value: function value(object) { if (realHasInstance.call(this, object)) return true; if (this !== Writable) return false; return object && object._writableState instanceof WritableState; } }); } else { realHasInstance = function realHasInstance(object) { return object instanceof this; }; } function Writable(options) { 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.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. 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 errorOrDestroy(stream, er); process.nextTick(cb, er); } // 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)) { state.pendingcb++; ret = writeOrBuffer(this, state, isBuf, 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(); if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(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 // userland will fail enumerable: false, get: function get() { 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 // userland will fail enumerable: false, get: function get() { return this._writableState.highWaterMark; } }); // if we're already writing something, then just put this // in the queue, and wait our turn. Otherwise, call _write // If we return false, then we need a drain event, so set that flag. 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. if (!ret) state.needDrain = true; if (state.writing || state.corked) { var last = state.lastBufferedRequest; state.lastBufferedRequest = { chunk: chunk, encoding: encoding, isBuf: isBuf, 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; state.writing = true; state.sync = true; 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 // after error process.nextTick(finishMaybe, stream, state); stream._writableState.errorEmitted = true; errorOrDestroy(stream, er); } else { // the caller expect this to happen before if // it is async cb(er); stream._writableState.errorEmitted = true; 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; var cb = state.writecb; if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK(); onwriteStateUpdate(state); 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 { afterWrite(stream, state, finished, cb); } } } 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 // 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 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; var buffer = new Array(l); var holder = state.corkedRequestsFree; 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 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 while (entry) { var chunk = entry.chunk; var encoding = entry.encoding; var cb = entry.callback; 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 // 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; encoding = null; } else if (typeof encoding === 'function') { cb = encoding; encoding = null; } if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks if (state.corked) { state.corked = 1; this.uncork(); } // 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 // userland will fail enumerable: false, get: function get() { 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) { state.pendingcb++; state.finalCalled = true; process.nextTick(callFinal, stream, state); } else { state.prefinished = true; stream.emit('prefinish'); } } } 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. state.corkedRequestsFree.next = corkReq; } Object.defineProperty(Writable.prototype, 'destroyed', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in // userland will fail enumerable: false, get: function get() { if (this._writableState === undefined) { return false; } return this._writableState.destroyed; }, set: function set(value) { // we ignore the value if the stream // has not been initialized yet if (!this._writableState) { return; } // 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); };readable-stream-3.6.0/lib/internal/000077500000000000000000000000001362132315000171265ustar00rootroot00000000000000readable-stream-3.6.0/lib/internal/streams/000077500000000000000000000000001362132315000206045ustar00rootroot00000000000000readable-stream-3.6.0/lib/internal/streams/async_iterator.js000066400000000000000000000135051362132315000241740ustar00rootroot00000000000000'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; } var finished = require('./end-of-stream'); var kLastResolve = Symbol('lastResolve'); var kLastReject = Symbol('lastReject'); var kError = Symbol('error'); 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 // we can be expecting either 'end' or // 'error' if (data !== null) { iter[kLastPromise] = null; iter[kLastResolve] = null; iter[kLastReject] = null; resolve(createIterResult(data, false)); } } } 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 () { if (iter[kEnded]) { 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 // we cannot guarantee that there is no error lingering around // waiting to be emitted. return new Promise(function (resolve, reject) { process.nextTick(function () { if (_this[kError]) { reject(_this[kError]); } else { resolve(createIterResult(undefined, true)); } }); }); } // 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; } }, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () { 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 return new Promise(function (resolve, reject) { _this2[kStream].destroy(null, function (err) { if (err) { 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 }), _defineProperty(_Object$create, kLastResolve, { value: null, writable: true }), _defineProperty(_Object$create, kLastReject, { value: null, writable: true }), _defineProperty(_Object$create, kError, { value: null, writable: true }), _defineProperty(_Object$create, kEnded, { value: stream._readableState.endEmitted, writable: true }), _defineProperty(_Object$create, kHandlePromise, { value: function value(resolve, reject) { var data = iterator[kStream].read(); if (data) { iterator[kLastPromise] = null; iterator[kLastResolve] = null; iterator[kLastReject] = null; resolve(createIterResult(data, false)); } else { iterator[kLastResolve] = resolve; iterator[kLastReject] = reject; } }, writable: true }), _Object$create)); 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 // 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;readable-stream-3.6.0/lib/internal/streams/buffer_list.js000066400000000000000000000142771362132315000234610ustar00rootroot00000000000000'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 _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; } var _require = require('buffer'), Buffer = _require.Buffer; var _require2 = require('util'), 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 () { function BufferList() { _classCallCheck(this, BufferList); this.head = null; this.tail = null; this.length = 0; } _createClass(BufferList, [{ key: "push", value: function push(v) { var entry = { data: v, next: null }; if (this.length > 0) this.tail.next = entry;else this.head = entry; this.tail = entry; ++this.length; } }, { key: "unshift", value: function unshift(v) { var entry = { data: v, next: this.head }; if (this.length === 0) this.tail = entry; this.head = entry; ++this.length; } }, { key: "shift", value: function shift() { if (this.length === 0) return; var ret = this.head.data; if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; --this.length; return ret; } }, { key: "clear", value: function clear() { this.head = this.tail = null; this.length = 0; } }, { key: "join", value: function join(s) { if (this.length === 0) return ''; var p = this.head; var ret = '' + p.data; while (p = p.next) { ret += s + p.data; } return ret; } }, { key: "concat", value: function concat(n) { if (this.length === 0) return Buffer.alloc(0); 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. }, { 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); this.head.data = this.head.data.slice(n); } else if (n === this.head.data.length) { // First chunk is a perfect match. ret = this.shift(); } else { // 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. }, { key: "_getString", value: function _getString(n) { var p = this.head; 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; if (p.next) this.head = p.next;else this.head = this.tail = null; } else { 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. }, { key: "_getBuffer", value: function _getBuffer(n) { var ret = Buffer.allocUnsafe(n); var p = this.head; 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; if (p.next) this.head = p.next;else this.head = this.tail = null; } else { 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. }, { key: custom, value: function value(_, options) { return inspect(this, _objectSpread({}, options, { // Only inspect one level. depth: 0, // It should not recurse. customInspect: false })); } }]); return BufferList; }();readable-stream-3.6.0/lib/internal/streams/destroy.js000066400000000000000000000060551362132315000226410ustar00rootroot00000000000000'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); } else if (err) { if (!this._writableState) { process.nextTick(emitErrorNT, this, err); } else if (!this._writableState.errorEmitted) { this._writableState.errorEmitted = true; 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 if (this._readableState) { this._readableState.destroyed = true; } // 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) { process.nextTick(emitErrorAndCloseNT, _this, err); } else if (!_this._writableState.errorEmitted) { _this._writableState.errorEmitted = true; process.nextTick(emitErrorAndCloseNT, _this, err); } else { process.nextTick(emitCloseNT, _this); } } else if (cb) { process.nextTick(emitCloseNT, _this); cb(err); } else { 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; this._readableState.reading = false; this._readableState.ended = false; this._readableState.endEmitted = false; } if (this._writableState) { this._writableState.destroyed = false; this._writableState.ended = false; this._writableState.ending = false; this._writableState.finalCalled = false; this._writableState.prefinished = false; this._writableState.finished = false; 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, errorOrDestroy: errorOrDestroy };readable-stream-3.6.0/lib/internal/streams/end-of-stream.js000066400000000000000000000060361362132315000236100ustar00rootroot00000000000000// 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); if (stream.req) onrequest();else stream.on('request', onrequest); } else if (writable && !stream._writableState) { // legacy streams stream.on('end', onlegacyfinish); stream.on('close', onlegacyfinish); } stream.on('end', onend); stream.on('finish', onfinish); if (opts.error !== false) stream.on('error', onerror); stream.on('close', onclose); return function () { stream.removeListener('complete', onfinish); stream.removeListener('abort', onclose); stream.removeListener('request', onrequest); if (stream.req) stream.req.removeListener('finish', onfinish); stream.removeListener('end', onlegacyfinish); stream.removeListener('close', onlegacyfinish); stream.removeListener('finish', onfinish); stream.removeListener('end', onend); stream.removeListener('error', onerror); stream.removeListener('close', onclose); }; } module.exports = eos;readable-stream-3.6.0/lib/internal/streams/from-browser.js000066400000000000000000000001451362132315000235660ustar00rootroot00000000000000module.exports = function () { throw new Error('Readable.from is not available in the browser') }; readable-stream-3.6.0/lib/internal/streams/from.js000066400000000000000000000061011362132315000221030ustar00rootroot00000000000000'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; } 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 // 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; if (done) { readable.push(null); } else if (readable.push((yield value))) { next(); } else { reading = false; } } catch (err) { readable.destroy(err); } }); return _next2.apply(this, arguments); } return readable; } module.exports = from;readable-stream-3.6.0/lib/internal/streams/pipeline.js000066400000000000000000000045741362132315000227610ustar00rootroot00000000000000// 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 () { if (called) return; called = true; 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; 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; stream.on('close', function () { closed = true; }); if (eos === undefined) eos = require('./end-of-stream'); eos(stream, { readable: reading, writable: writing }, function (err) { if (err) return callback(err); closed = true; callback(); }); var destroyed = false; return function (err) { if (closed) return; if (destroyed) return; 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; var writing = i > 0; return destroyer(stream, reading, writing, function (err) { if (!error) error = err; if (err) destroys.forEach(call); if (reading) return; destroys.forEach(call); callback(error); }); }); return streams.reduce(pipe); } module.exports = pipeline;readable-stream-3.6.0/lib/internal/streams/state.js000066400000000000000000000013551362132315000222660ustar00rootroot00000000000000'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 return state.objectMode ? 16 : 16 * 1024; } module.exports = { getHighWaterMark: getHighWaterMark };readable-stream-3.6.0/lib/internal/streams/stream-browser.js000066400000000000000000000000611362132315000241130ustar00rootroot00000000000000module.exports = require('events').EventEmitter; readable-stream-3.6.0/lib/internal/streams/stream.js000066400000000000000000000000441362132315000224330ustar00rootroot00000000000000module.exports = require('stream'); readable-stream-3.6.0/package.json000066400000000000000000000035361362132315000170410ustar00rootroot00000000000000{ "name": "readable-stream", "version": "3.6.0", "description": "Streams3, a user-land copy of the stream library from Node.js", "main": "readable.js", "engines": { "node": ">= 6" }, "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" }, "devDependencies": { "@babel/cli": "^7.2.0", "@babel/core": "^7.2.0", "@babel/polyfill": "^7.0.0", "@babel/preset-env": "^7.2.0", "airtap": "0.0.9", "assert": "^1.4.0", "bl": "^2.0.0", "deep-strict-equal": "^0.2.0", "events.once": "^2.0.2", "glob": "^7.1.2", "gunzip-maybe": "^1.4.1", "hyperquest": "^2.1.3", "lolex": "^2.6.0", "nyc": "^11.0.0", "pump": "^3.0.0", "rimraf": "^2.6.2", "tap": "^12.0.0", "tape": "^4.9.0", "tar-fs": "^1.16.2", "util-promisify": "^2.1.0" }, "scripts": { "test": "tap -J --no-esm test/parallel/*.js test/ours/*.js", "ci": "TAP=1 tap --no-esm test/parallel/*.js test/ours/*.js | tee test.tap", "test-browsers": "airtap --sauce-connect --loopback airtap.local -- test/browser.js", "test-browser-local": "airtap --open --local -- test/browser.js", "cover": "nyc npm test", "report": "nyc report --reporter=lcov", "update-browser-errors": "babel -o errors-browser.js errors.js" }, "repository": { "type": "git", "url": "git://github.com/nodejs/readable-stream" }, "keywords": [ "readable", "stream", "pipe" ], "browser": { "util": false, "worker_threads": false, "./errors": "./errors-browser.js", "./readable.js": "./readable-browser.js", "./lib/internal/streams/from.js": "./lib/internal/streams/from-browser.js", "./lib/internal/streams/stream.js": "./lib/internal/streams/stream-browser.js" }, "nyc": { "include": [ "lib/**.js" ] }, "license": "MIT" } readable-stream-3.6.0/readable-browser.js000066400000000000000000000007501362132315000203240ustar00rootroot00000000000000exports = module.exports = require('./lib/_stream_readable.js'); exports.Stream = exports; exports.Readable = exports; exports.Writable = require('./lib/_stream_writable.js'); exports.Duplex = require('./lib/_stream_duplex.js'); exports.Transform = require('./lib/_stream_transform.js'); exports.PassThrough = require('./lib/_stream_passthrough.js'); exports.finished = require('./lib/internal/streams/end-of-stream.js'); exports.pipeline = require('./lib/internal/streams/pipeline.js'); readable-stream-3.6.0/readable.js000066400000000000000000000013311362132315000166370ustar00rootroot00000000000000var Stream = require('stream'); if (process.env.READABLE_STREAM === 'disable' && Stream) { module.exports = Stream.Readable; Object.assign(module.exports, Stream); module.exports.Stream = Stream; } else { exports = module.exports = require('./lib/_stream_readable.js'); exports.Stream = Stream || exports; exports.Readable = exports; exports.Writable = require('./lib/_stream_writable.js'); exports.Duplex = require('./lib/_stream_duplex.js'); exports.Transform = require('./lib/_stream_transform.js'); exports.PassThrough = require('./lib/_stream_passthrough.js'); exports.finished = require('./lib/internal/streams/end-of-stream.js'); exports.pipeline = require('./lib/internal/streams/pipeline.js'); } readable-stream-3.6.0/test/000077500000000000000000000000001362132315000155235ustar00rootroot00000000000000readable-stream-3.6.0/test/browser.js000066400000000000000000000062041362132315000175460ustar00rootroot00000000000000if (!global.console) { global.console = {}; } if (!global.console.log) { global.console.log = function () {}; } if (!global.console.error) { global.console.error = global.console.log; } if (!global.console.info) { global.console.info = global.console.log; } var test = require('tape'); var util = require('util'); // TODO: add replacements instead global.process = { env: {}, on: function () {}, cwd: function () { return '/'; }, binding: function () { return { hasTracing: false }; } }; test('streams', function (t) { require('./browser/test-stream-big-packet')(t); require('./browser/test-stream-big-push')(t); require('./browser/test-stream-duplex')(t); require('./browser/test-stream-end-paused')(t); require('./browser/test-stream-ispaused')(t); require('./browser/test-stream-finished')(t); require('./browser/test-stream-pipeline')(t); require('./browser/test-stream-pipe-after-end')(t); require('./browser/test-stream-pipe-cleanup')(t); require('./browser/test-stream-pipe-cleanup-pause')(t); require('./browser/test-stream-pipe-error-handling')(t); require('./browser/test-stream-pipe-event')(t); require('./browser/test-stream-push-order')(t); require('./browser/test-stream-push-strings')(t); require('./browser/test-stream-readable-constructor-set-methods')(t); require('./browser/test-stream-readable-event')(t); require('./browser/test-stream-transform-constructor-set-methods')(t); require('./browser/test-stream-transform-objectmode-falsey-value')(t); require('./browser/test-stream-transform-split-objectmode')(t); require('./browser/test-stream-unshift-empty-chunk')(t); require('./browser/test-stream-unshift-read-race')(t); require('./browser/test-stream-writable-change-default-encoding')(t); require('./browser/test-stream-writable-constructor-set-methods')(t); require('./browser/test-stream-writable-decoded-encoding')(t); require('./browser/test-stream-writev')(t); require('./browser/test-stream-sync-write')(t); require('./browser/test-stream-pipe-without-listenerCount'); }); test('streams 2', function (t) { require('./browser/test-stream2-base64-single-char-read-end')(t); require('./browser/test-stream2-compatibility')(t); require('./browser/test-stream2-large-read-stall')(t); require('./browser/test-stream2-objects')(t); require('./browser/test-stream2-pipe-error-handling')(t); require('./browser/test-stream2-pipe-error-once-listener')(t); require('./browser/test-stream2-push')(t); require('./browser/test-stream2-readable-empty-buffer-no-eof')(t); // require('./browser/test-stream2-readable-from-list')(t); // require('./browser/test-stream2-transform')(t); require('./browser/test-stream2-set-encoding')(t); require('./browser/test-stream2-readable-legacy-drain')(t); require('./browser/test-stream2-readable-wrap-empty')(t); require('./browser/test-stream2-readable-non-empty-end')(t); require('./browser/test-stream2-readable-wrap')(t); require('./browser/test-stream2-unpipe-drain')(t); require('./browser/test-stream2-writable')(t); }); test('streams 3', function (t) { require('./browser/test-stream3-pause-then-read')(t); }); readable-stream-3.6.0/test/browser/000077500000000000000000000000001362132315000172065ustar00rootroot00000000000000readable-stream-3.6.0/test/browser/test-stream-big-packet.js000066400000000000000000000033201362132315000240160ustar00rootroot00000000000000'use strict'; var common = require('../common'); var inherits = require('inherits'); var stream = require('../../'); module.exports = function (t) { t.test('big packet', function (t) { t.plan(3); var passed = false; function PassThrough() { stream.Transform.call(this); }; inherits(PassThrough, stream.Transform); PassThrough.prototype._transform = function(chunk, encoding, done) { this.push(chunk); done(); }; function TestStream() { stream.Transform.call(this); }; inherits(TestStream, stream.Transform); TestStream.prototype._transform = function(chunk, encoding, done) { if (!passed) { // Char 'a' only exists in the last write passed = indexOf(chunk.toString(), 'a') >= 0; } if (passed) { t.ok(passed); } done(); }; var s1 = new PassThrough(); var s2 = new PassThrough(); var s3 = new TestStream(); 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 = Buffer.alloc(s1._writableState.highWaterMark + 1); big.fill('x'); // Since big is larger than highWaterMark, it will be buffered internally. t.ok(!s1.write(big)); // 'tiny' is small enough to pass through internal buffer. t.ok(s2.write('tiny')); // 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'); function indexOf (xs, x) { for (var i = 0, l = xs.length; i < l; i++) { if (xs[i] === x) return i; } return -1; } }); } readable-stream-3.6.0/test/browser/test-stream-big-push.js000066400000000000000000000030131362132315000235250ustar00rootroot00000000000000'use strict'; var common = require('../common'); var stream = require('../../'); module.exports = function (t) { t.test('big push', function (t) { var str = 'asdfasdfasdfasdfasdf'; var r = new stream.Readable({ highWaterMark: 5, encoding: 'utf8' }); var reads = 0; var eofed = false; var ended = false; r._read = function(n) { if (reads === 0) { setTimeout(function() { r.push(str); }); reads++; } else if (reads === 1) { var ret = r.push(str); t.equal(ret, false); reads++; } else { t.notOk(eofed); eofed = true; r.push(null); } }; r.on('end', function() { ended = true; }); // 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 t.notOk(ret); var chunk = r.read(); t.equal(chunk, str); chunk = r.read(); t.equal(chunk, null); r.once('readable', function() { // this time, we'll get *all* the remaining data, because // it's been added synchronously, as the read WOULD take // us below the hwm, and so it triggered a _read() again, // which synchronously added more, which we then return. chunk = r.read(); t.equal(chunk, str + str); chunk = r.read(); t.equal(chunk, null); }); r.on('end', function() { t.ok(eofed); t.ok(ended); t.equal(reads, 2); t.end(); }); }); } readable-stream-3.6.0/test/browser/test-stream-duplex.js000066400000000000000000000012651362132315000233170ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Duplex = require('../../').Transform; var stream = new Duplex({ objectMode: true }); module.exports = function (t) { t.test('duplex', function (t) { t.plan(4); t.ok(stream._readableState.objectMode); t.ok(stream._writableState.objectMode); var written; var read; stream._write = function(obj, _, cb) { written = obj; cb(); }; stream._read = function() {}; stream.on('data', function(obj) { read = obj; }); stream.push({ val: 1 }); stream.end({ val: 2 }); stream.on('end', function() { t.equal(read.val, 1); t.equal(written.val, 2); }); }); } readable-stream-3.6.0/test/browser/test-stream-end-paused.js000066400000000000000000000012431362132315000240370ustar00rootroot00000000000000'use strict'; var common = require('../common'); // Make sure we don't miss the end event for paused 0-length streams var Readable = require('../../').Readable; var stream = new Readable(); module.exports = function (t) { t.test('end pause', function (t) { t.plan(2); var calledRead = false; stream._read = function() { t.notOk(calledRead); calledRead = true; this.push(null); }; stream.on('data', function() { throw new Error('should not ever get data'); }); stream.pause(); setTimeout(function() { stream.on('end', function() { t.ok(calledRead); }); stream.resume(); }); }); } readable-stream-3.6.0/test/browser/test-stream-finished.js000066400000000000000000000024221362132315000236030ustar00rootroot00000000000000"use strict"; var common = require('../common'); var _require = require('../../'), Writable = _require.Writable, Readable = _require.Readable, Transform = _require.Transform, finished = _require.finished; module.exports = function (t) { t.test('readable finished', function (t) { var rs = new Readable({ read: function read() {} }); finished(rs, common.mustCall(function (err) { t.ok(!err, 'no error'); t.end(); })); rs.push(null); rs.resume(); }); t.test('writable finished', function (t) { var ws = new Writable({ write: function write(data, enc, cb) { cb(); } }); finished(ws, common.mustCall(function (err) { t.ok(!err, 'no error'); t.end(); })); ws.end(); }); t.test('transform finished', function (t) { var tr = new Transform({ transform: function transform(data, enc, cb) { cb(); } }); var finish = false; var ended = false; tr.on('end', function () { ended = true; }); tr.on('finish', function () { finish = true; }); finished(tr, common.mustCall(function (err) { t.ok(!err, 'no error'); t.ok(finish); t.ok(ended); t.end(); })); tr.end(); tr.resume(); }); }; readable-stream-3.6.0/test/browser/test-stream-ispaused.js000066400000000000000000000011431362132315000236260ustar00rootroot00000000000000'use strict'; var common = require('../common'); var stream = require('../../'); module.exports = function (t) { t.test('is paused', function (t) { var readable = new stream.Readable(); // _read is a noop, here. readable._read = Function(); // default state of a stream is not "paused" t.notOk(readable.isPaused()); // make the stream start flowing... readable.on('data', Function()); // still not paused. t.notOk(readable.isPaused()); readable.pause(); t.ok(readable.isPaused()); readable.resume(); t.notOk(readable.isPaused()); t.end(); }); } readable-stream-3.6.0/test/browser/test-stream-pipe-after-end.js000066400000000000000000000032721362132315000246160ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Readable = require('../../lib/_stream_readable'); var Writable = require('../../lib/_stream_writable'); var inherits = require('inherits'); module.exports = function (t) { t.test('pipe after end', function (t) { t.plan(4); inherits(TestReadable, Readable); function TestReadable(opt) { if (!(this instanceof TestReadable)) return new TestReadable(opt); Readable.call(this, opt); this._ended = false; } TestReadable.prototype._read = function(n) { if (this._ended) this.emit('error', new Error('_read called twice')); this._ended = true; this.push(null); }; inherits(TestWritable, Writable); function TestWritable(opt) { if (!(this instanceof TestWritable)) return new TestWritable(opt); Writable.call(this, opt); this._written = []; } TestWritable.prototype._write = function(chunk, encoding, cb) { this._written.push(chunk); cb(); }; // this one should not emit 'end' until we read() from it later. var ender = new TestReadable(); var enderEnded = false; // 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(function() { ender.on('end', function() { enderEnded = true; t.ok(true, 'enderEnded'); }); t.notOk(enderEnded); var c = ender.read(); t.equal(c, null); var w = new TestWritable(); w.on('finish', function() { t.ok(true, 'writableFinished'); }); piper.pipe(w); }); }); } readable-stream-3.6.0/test/browser/test-stream-pipe-cleanup-pause.js000066400000000000000000000021471362132315000255130ustar00rootroot00000000000000'use strict'; var common = require('../common'); var stream = require('../../'); module.exports = function (t) { t.test('pipe cleanup pause', function (t) { t.plan(3); 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 // and will cause `.write()` to return false // See: https://github.com/nodejs/node/issues/2323 var buffer = Buffer.alloc(560000); reader._read = function() {}; writer1._write = common.mustCall(function(chunk, encoding, cb) { this.emit('chunk-received'); cb(); }, 1); writer1.once('chunk-received', function() { reader.unpipe(writer1); reader.pipe(writer2); reader.push(buffer); setImmediate(function() { reader.push(buffer); setImmediate(function() { reader.push(buffer); }); }); }); writer2._write = function(chunk, encoding, cb) { t.ok(true); cb(); }; reader.pipe(writer1); reader.push(buffer); }); }; readable-stream-3.6.0/test/browser/test-stream-pipe-cleanup.js000066400000000000000000000055251362132315000244030ustar00rootroot00000000000000'use strict'; // This test asserts that Stream.prototype.pipe does not leave listeners // hanging on the source or dest. var common = require('../common'); var stream = require('../../'); var inherits = require('inherits'); module.exports = function (t) { t.test('pipe cleanup', function (t) { if (/^v0\.8\./.test(process.version)) return t.end(); function Writable() { this.writable = true; this.endCalls = 0; require('stream').Stream.call(this); } inherits(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); } inherits(Readable, require('stream').Stream); function Duplex() { this.readable = true; Writable.call(this); } inherits(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'); } t.equal(0, r.listeners('end').length); t.equal(limit, w.endCalls); w.endCalls = 0; for (i = 0; i < limit; i++) { r = new Readable(); r.pipe(w); r.emit('close'); } t.equal(0, r.listeners('close').length); t.equal(limit, w.endCalls); w.endCalls = 0; r = new Readable(); for (i = 0; i < limit; i++) { w = new Writable(); r.pipe(w); w.emit('close'); } t.equal(0, w.listeners('close').length); r = new Readable(); w = new Writable(); var d = new Duplex(); r.pipe(d); // pipeline A d.pipe(w); // pipeline B t.equal(r.listeners('end').length, 2); // A.onend, A.cleanup t.equal(r.listeners('close').length, 2); // A.onclose, A.cleanup t.equal(d.listeners('end').length, 2); // B.onend, B.cleanup t.equal(d.listeners('close').length, 3); // A.cleanup, B.onclose, B.cleanup t.equal(w.listeners('end').length, 0); t.equal(w.listeners('close').length, 1); // B.cleanup r.emit('end'); t.equal(d.endCalls, 1); t.equal(w.endCalls, 0); t.equal(r.listeners('end').length, 0); t.equal(r.listeners('close').length, 0); t.equal(d.listeners('end').length, 2); // B.onend, B.cleanup t.equal(d.listeners('close').length, 2); // B.onclose, B.cleanup t.equal(w.listeners('end').length, 0); t.equal(w.listeners('close').length, 1); // B.cleanup d.emit('end'); t.equal(d.endCalls, 1); t.equal(w.endCalls, 1); t.equal(r.listeners('end').length, 0); t.equal(r.listeners('close').length, 0); t.equal(d.listeners('end').length, 0); t.equal(d.listeners('close').length, 0); t.equal(w.listeners('end').length, 0); t.equal(w.listeners('close').length, 0); t.end(); }); } readable-stream-3.6.0/test/browser/test-stream-pipe-error-handling.js000066400000000000000000000043041362132315000256610ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Stream = require('stream').Stream; module.exports = function (t) { t.test('Error Listener Catches', function (t) { t.plan(1); var source = new Stream(); var dest = new Stream(); source.pipe(dest); var gotErr = null; source.on('error', function(err) { gotErr = err; }); var err = new Error('This stream turned into bacon.'); source.emit('error', err); t.strictEqual(gotErr, err); }); t.test('Error WithoutListener Throws', function (t) { t.plan(1); 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; } t.strictEqual(gotErr, err); }); t.test('Error With Removed Listener Throws', function (t) { t.plan(2); var EE = require('events').EventEmitter; var R = require('../../').Readable; var W = require('../../').Writable; var r = new R(); var w = new W(); var removed = false; r._read = function() { setTimeout(function() { t.ok(removed); t.throws(function() { w.emit('error', new Error('fail')); }); }); }; w.on('error', myOnError); r.pipe(w); w.removeListener('error', myOnError); removed = true; function myOnError(er) { throw new Error('this should not happen'); } }); t.test('Error With Removed Listener Throws', function (t) { t.plan(2); var EE = require('events').EventEmitter; var R = require('../../').Readable; var W = require('../../').Writable; var r = new R(); var w = new W(); var removed = false; var caught = false; r._read = function() { setTimeout(function() { t.ok(removed); w.emit('error', new Error('fail')); }); }; w.on('error', myOnError); w._write = function() {}; r.pipe(w); // Removing some OTHER random listener should not do anything w.removeListener('error', function() {}); removed = true; function myOnError(er) { t.notOk(caught); caught = true; } }); } readable-stream-3.6.0/test/browser/test-stream-pipe-event.js000066400000000000000000000012701362132315000240660ustar00rootroot00000000000000'use strict'; var common = require('../common'); var stream = require('../../'); var inherits = require('inherits'); module.exports = function (t) { t.test('pipe event', function (t) { t.plan(1); function Writable() { this.writable = true; require('stream').Stream.call(this); } inherits(Writable, require('stream').Stream); function Readable() { this.readable = true; require('stream').Stream.call(this); } inherits(Readable, require('stream').Stream); var passed = false; var w = new Writable(); w.on('pipe', function(src) { passed = true; }); var r = new Readable(); r.pipe(w); t.ok(passed); }); } readable-stream-3.6.0/test/browser/test-stream-pipe-without-listenerCount.js000066400000000000000000000011421362132315000273020ustar00rootroot00000000000000'use strict'; var Stream = require('../../'); module.exports = function (t) { t.tets('pipe without listenerCount', function (t) { t.plan(2); var r = new Stream({ read: function (){}}); r.listenerCount = undefined; var w = new Stream(); w.listenerCount = undefined; w.on('pipe', function() { r.emit('error', new Error('Readable Error')); w.emit('error', new Error('Writable Error')); }); r.on('error', function (e) { t.ok(e, 'readable error'); }); w.on('error', function (e) { t.ok(e, 'writable error'); }); r.pipe(w); }); } readable-stream-3.6.0/test/browser/test-stream-pipeline.js000066400000000000000000000046241362132315000236250ustar00rootroot00000000000000"use strict"; /**/ 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, pipeline = _require.pipeline; module.exports = function (t) { t.test('pipeline', function (t) { var finished = false; var processed = []; var expected = [bufferShim.from('a'), bufferShim.from('b'), bufferShim.from('c')]; var read = new Readable({ read: function read() { } }); var write = new Writable({ write: function write(data, enc, cb) { processed.push(data); cb(); } }); 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) { t.ok(!err, 'no error'); t.ok(finished); t.deepEqual(processed, expected); t.end(); })); }); t.test('pipeline missing args', function (t) { var _read = new Readable({ read: function read() { } }); t.throws(function () { pipeline(_read, function () { }); }); t.throws(function () { pipeline(function () { }); }); t.throws(function () { pipeline(); }); t.end(); }); t.test('pipeline error', function (t) { 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(); }); pipeline(_read2, _write, common.mustCall(function (err) { t.ok(err, 'should have an error'); t.end(); })); }); t.test('pipeline destroy', function () { 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')); }); var dst = pipeline(_read3, _write2, common.mustCall(function (err) { t.equal(err.message, 'kaboom'); t.end(); })); t.equal(dst, _write2); }); }; readable-stream-3.6.0/test/browser/test-stream-push-order.js000066400000000000000000000012531362132315000241030ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Readable = require('../../').Readable; module.exports = function (t) { t.test('push order', function (t) { t.plan(1); 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 { var two = list.shift(); s.push(one); s.push(two); } }; var v = s.read(0); // ACTUALLY [1, 3, 5, 6, 4, 2] setTimeout(function() { t.equals(s._readableState.buffer.join(','), '1,2,3,4,5,6'); }); }); } readable-stream-3.6.0/test/browser/test-stream-push-strings.js000066400000000000000000000023211362132315000244560ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Readable = require('../../').Readable; var inherits = require('inherits'); module.exports = function (t) { t.test('push strings', function (t) { t.plan(2); inherits(MyStream, Readable); function MyStream(options) { Readable.call(this, options); this._chunks = 3; } MyStream.prototype._read = function(n) { switch (this._chunks--) { case 0: return this.push(null); case 1: return setTimeout(function() { this.push('last chunk'); }.bind(this), 100); case 2: return this.push('second to last chunk'); case 3: return process.nextTick(function() { this.push('first chunk'); }.bind(this)); default: throw new Error('?'); } }; var expect = [ 'first chunksecond to last chunk', 'last chunk' ]; var ms = new MyStream(); var results = []; ms.on('readable', function() { var chunk; while (null !== (chunk = ms.read())) results.push(chunk + ''); }); ms.on('end', function() { t.equal(ms._chunks, -1); t.deepEqual(results, expect); }); }); } readable-stream-3.6.0/test/browser/test-stream-readable-constructor-set-methods.js000066400000000000000000000007251362132315000303720ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Readable = require('../../').Readable; module.exports = function (t) { t.test('readable constructor set methods', function (t) { t.plan(2); var _readCalled = false; function _read(n) { _readCalled = true; this.push(null); } var r = new Readable({ read: _read }); r.resume(); setTimeout(function() { t.equal(r._read, _read); t.ok(_readCalled); }); }); } readable-stream-3.6.0/test/browser/test-stream-readable-event.js000066400000000000000000000047111362132315000246730ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Readable = require('../../').Readable; function first(t) { // First test, not reading when the readable is added. // make sure that on('readable', ...) triggers a readable event. var r = new Readable({ highWaterMark: 3 }); var _readCalled = false; r._read = function(n) { _readCalled = true; }; // This triggers a 'readable' event, which is lost. r.push(Buffer.from('blerg')); var caughtReadable = false; setTimeout(function() { // we're testing what we think we are t.notOk(r._readableState.reading); r.on('readable', function() { caughtReadable = true; setTimeout(function() { // we're testing what we think we are t.notOk(_readCalled); t.ok(caughtReadable); t.end(); }); }); }); } function second(t) { // 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 }); var _readCalled = false; r._read = function(n) { _readCalled = true; }; // This triggers a 'readable' event, which is lost. r.push(Buffer.from('bl')); var caughtReadable = false; setTimeout(function() { // assert we're testing what we think we are t.ok(r._readableState.reading); r.on('readable', function() { caughtReadable = true; setTimeout(function() { // we're testing what we think we are t.ok(_readCalled); t.ok(caughtReadable); t.end(); }); }); }); } function third(t) { // Third test, not reading when the stream has not passed // the highWaterMark but *has* reached EOF. var r = new Readable({ highWaterMark: 30 }); var _readCalled = false; r._read = function(n) { _readCalled = true; }; // This triggers a 'readable' event, which is lost. r.push(Buffer.from('blerg')); r.push(null); var caughtReadable = false; setTimeout(function() { // assert we're testing what we think we are t.notOk(r._readableState.reading); r.on('readable', function() { caughtReadable = true; setTimeout(function() { // we're testing what we think we are t.notOk(_readCalled); t.ok(caughtReadable); t.end(); }); }); }); }; module.exports = function (t) { t.test('readable events', function (t) { t.test('first', first); t.test('second', second); t.test('third', third); }); } readable-stream-3.6.0/test/browser/test-stream-sync-write.js000066400000000000000000000017061362132315000241220ustar00rootroot00000000000000require('../common'); var inherits = require('inherits'); var stream = require('../../'); var WritableStream = stream.Writable; module.exports = function(t) { t.test('should bea ble to write sync', function(t) { var InternalStream = function() { WritableStream.call(this); }; inherits(InternalStream, WritableStream); InternalStream.prototype._write = function(chunk, encoding, callback) { callback(); }; var internalStream = new InternalStream(); var ExternalStream = function(writable) { this._writable = writable; WritableStream.call(this); }; inherits(ExternalStream, WritableStream); ExternalStream.prototype._write = function(chunk, encoding, callback) { this._writable.write(chunk, encoding, callback); }; var externalStream = new ExternalStream(internalStream); for (var i = 0; i < 2000; i++) { externalStream.write(i.toString()); } t.end(); }); } readable-stream-3.6.0/test/browser/test-stream-transform-constructor-set-methods.js000066400000000000000000000013421362132315000306420ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Transform = require('../../').Transform; module.exports = function (t) { t.test('transform constructor set methods', function (t) { var _transformCalled = false; function _transform(d, e, n) { _transformCalled = true; n(); } var _flushCalled = false; function _flush(n) { _flushCalled = true; n(); } var tr = new Transform({ transform: _transform, flush: _flush }); tr.end(Buffer.from('blerg')); tr.resume(); tr.on('end', function() { t.equal(tr._transform, _transform); t.equal(tr._flush, _flush); t.ok(_transformCalled); t.ok(_flushCalled); t.end(); }); }); } readable-stream-3.6.0/test/browser/test-stream-transform-objectmode-falsey-value.js000066400000000000000000000015231362132315000305320ustar00rootroot00000000000000'use strict'; var common = require('../common'); var stream = require('../../'); var PassThrough = stream.PassThrough; module.exports = function (t) { t.test('transform objectmode falsey value', function (t) { var src = new PassThrough({ objectMode: true }); var tx = new PassThrough({ objectMode: true }); var dest = new PassThrough({ objectMode: true }); var expect = [ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; var results = []; dest.on('end', function() { t.deepEqual(results, expect); t.end(); }); dest.on('data', function(x) { results.push(x); }); src.pipe(tx).pipe(dest); var i = -1; var int = setInterval(function() { if (i > 10) { src.end(); clearInterval(int); } else { t.ok(true); src.write(i++); } }, 10); }); } readable-stream-3.6.0/test/browser/test-stream-transform-split-objectmode.js000066400000000000000000000031211362132315000272640ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Transform = require('../../').Transform; module.exports = function (t) { t.test('transform split objectmode', function (t) { t.plan(10); var parser = new Transform({ readableObjectMode : true }); t.ok(parser._readableState.objectMode, 'parser 1'); t.notOk(parser._writableState.objectMode, 'parser 2'); t.equals(parser._readableState.highWaterMark, 16, 'parser 3'); t.equals(parser._writableState.highWaterMark, (16 * 1024), 'parser 4'); parser._transform = function(chunk, enc, callback) { callback(null, { val : chunk[0] }); }; var parsed; parser.on('data', function(obj) { parsed = obj; }); parser.end(Buffer.from([42])); parser.on('end', function() { t.equals(parsed.val, 42, 'parser ended'); }); var serializer = new Transform({ writableObjectMode : true }); t.notOk(serializer._readableState.objectMode, 'serializer 1'); t.ok(serializer._writableState.objectMode, 'serializer 2'); t.equals(serializer._readableState.highWaterMark, (16 * 1024), 'serializer 3'); t.equals(serializer._writableState.highWaterMark, 16, 'serializer 4'); serializer._transform = function(obj, _, callback) { callback(null, Buffer.from([obj.val])); }; var serialized; serializer.on('data', function(chunk) { serialized = chunk; }); serializer.write({ val : 42 }); serializer.on('end', function() { t.equals(serialized[0], 42, 'searlizer ended'); }); setImmediate(function () { serializer.end(); }); }); } readable-stream-3.6.0/test/browser/test-stream-unshift-empty-chunk.js000066400000000000000000000030601362132315000257330ustar00rootroot00000000000000'use strict'; var common = require('../common'); // This test verifies that stream.unshift(Buffer(0)) or // stream.unshift('') does not set state.reading=false. var Readable = require('../../').Readable; module.exports = function (t) { t.test('unshift empty chunk', function (t) { t.plan(1); var r = new Readable(); var nChunks = 10; var chunk = Buffer.alloc(10); chunk.fill('x'); r._read = function(n) { setTimeout(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, // 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 = Buffer.alloc(readAll ? 0 : 5); putBack.fill('y'); readAll = !readAll; r.unshift(putBack); } }); var expect = [ 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy', 'xxxxxxxxxx', 'yyyyy' ]; r.on('end', function() { t.deepEqual(seen, expect); }); }); } readable-stream-3.6.0/test/browser/test-stream-unshift-read-race.js000066400000000000000000000060151362132315000253150ustar00rootroot00000000000000'use strict'; var common = require('../common'); // 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('../../'); module.exports = function (t) { t.test('unshift read race', function (tape) { var hwm = 10; var r = stream.Readable({ highWaterMark: hwm }); var chunks = 10; var t = (chunks * 5); var data = Buffer.alloc(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) { tape.notOk(pushedNull, '_read after null push'); // every third chunk is fast push(!(chunks % 3)); function push(fast) { tape.notOk(pushedNull, 'push() after null push'); var c = pos >= data.length ? null : data.slice(pos, Math.min(pos + n, data.length)); pushedNull = c === null; if (fast) { pos += n; r.push(c); if (c === null) pushError(); } else { setTimeout(function() { pos += n; r.push(c); if (c === null) pushError(); }); } } }; function pushError() { tape.throws(function() { r.push(Buffer.alloc(1)); }); } var w = stream.Writable(); var written = []; w._write = function(chunk, encoding, cb) { written.push(chunk.toString()); cb(); }; var ended = false; r.on('end', function() { tape.notOk(ended, 'end emitted more than once'); tape.throws(function() { r.unshift(Buffer.alloc(1)); }); ended = true; w.end(); }); r.on('readable', function() { var chunk; while (null !== (chunk = r.read(10))) { w.write(chunk); if (chunk.length > 4) r.unshift(Buffer.from('1234')); } }); w.on('finish', function() { // each chunk should start with 1234, and then be asfdasdfasdf... // The first got pulled out before the first unshift('1234'), so it's // lacking that piece. tape.equal(written[0], 'asdfasdfas'); var asdf = 'd'; //console.error('0: %s', written[0]); for (var i = 1; i < written.length; i++) { //console.error('%s: %s', i.toString(32), written[i]); tape.equal(written[i].slice(0, 4), '1234'); for (var j = 4; j < written[i].length; j++) { var c = written[i].charAt(j); tape.equal(c, asdf); switch (asdf) { case 'a': asdf = 's'; break; case 's': asdf = 'd'; break; case 'd': asdf = 'f'; break; case 'f': asdf = 'a'; break; } } } tape.equal(written.length, 18); tape.end(); }); }); } readable-stream-3.6.0/test/browser/test-stream-writable-change-default-encoding.js000066400000000000000000000032621362132315000302570ustar00rootroot00000000000000'use strict'; var common = require('../common'); var stream = require('../../'); var inherits = require('inherits'); function MyWritable(fn, options) { stream.Writable.call(this, options); this.fn = fn; }; inherits(MyWritable, stream.Writable); MyWritable.prototype._write = function(chunk, encoding, callback) { this.fn(Buffer.isBuffer(chunk), typeof chunk, encoding); callback(); }; function defaultCondingIsUtf8(t) { t.plan(1); var m = new MyWritable(function(isBuffer, type, enc) { t.equal(enc, 'utf8'); }, { decodeStrings: false }); m.write('foo'); m.end(); } function changeDefaultEncodingToAscii(t) { t.plan(1); var m = new MyWritable(function(isBuffer, type, enc) { t.equal(enc, 'ascii'); }, { decodeStrings: false }); m.setDefaultEncoding('ascii'); m.write('bar'); m.end(); } function changeDefaultEncodingToInvalidValue(t) { t.plan(1); t.throws(function () { var m = new MyWritable(function(isBuffer, type, enc) { }, { decodeStrings: false }); m.setDefaultEncoding({}); m.write('bar'); m.end(); }, TypeError); } function checkVairableCaseEncoding(t) { t.plan(1); var m = new MyWritable(function(isBuffer, type, enc) { t.equal(enc, 'ascii'); }, { decodeStrings: false }); m.setDefaultEncoding('AsCii'); m.write('bar'); m.end(); } module.exports = function (t) { t.test('writable change default encoding', function (t) { t.test('defaultCondingIsUtf8', defaultCondingIsUtf8); t.test('changeDefaultEncodingToAscii', changeDefaultEncodingToAscii); t.test('changeDefaultEncodingToInvalidValue', changeDefaultEncodingToInvalidValue); t.test('checkVairableCaseEncoding', checkVairableCaseEncoding); }); } readable-stream-3.6.0/test/browser/test-stream-writable-constructor-set-methods.js000066400000000000000000000015371362132315000304460ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Writable = require('../../').Writable; module.exports = function (t) { t.test('writable constructor set methods', function (t){ var _writeCalled = false; function _write(d, e, n) { _writeCalled = true; } var w = new Writable({ write: _write }); w.end(Buffer.from('blerg')); var _writevCalled = false; var dLength = 0; function _writev(d, n) { dLength = d.length; _writevCalled = true; } var w2 = new Writable({ writev: _writev }); w2.cork(); w2.write(Buffer.from('blerg')); w2.write(Buffer.from('blerg')); w2.end(); setImmediate(function() { t.equal(w._write, _write); t.ok(_writeCalled); t.equal(w2._writev, _writev); t.equal(dLength, 2); t.ok(_writevCalled); t.end(); }); }); } readable-stream-3.6.0/test/browser/test-stream-writable-decoded-encoding.js000066400000000000000000000022111362132315000267700ustar00rootroot00000000000000'use strict'; var common = require('../common'); var stream = require('../../'); var inherits = require('inherits'); function MyWritable(fn, options) { stream.Writable.call(this, options); this.fn = fn; }; inherits(MyWritable, stream.Writable); MyWritable.prototype._write = function(chunk, encoding, callback) { this.fn(Buffer.isBuffer(chunk), typeof chunk, encoding); callback(); }; function decodeStringsTrue(t) { t.plan(3); var m = new MyWritable(function(isBuffer, type, enc) { t.ok(isBuffer); t.equal(type, 'object'); t.equal(enc, 'buffer'); //console.log('ok - decoded string is decoded'); }, { decodeStrings: true }); m.write('some-text', 'utf8'); m.end(); } function decodeStringsFalse(t) { t.plan(3); var m = new MyWritable(function(isBuffer, type, enc) { t.notOk(isBuffer); t.equal(type, 'string'); t.equal(enc, 'utf8'); //console.log('ok - un-decoded string is not decoded'); }, { decodeStrings: false }); m.write('some-text', 'utf8'); m.end(); } module.exports = function (t) { t.test('decodeStringsTrue', decodeStringsTrue); t.test('decodeStringsFalse', decodeStringsFalse); } readable-stream-3.6.0/test/browser/test-stream-writev.js000066400000000000000000000053071362132315000233370ustar00rootroot00000000000000'use strict'; var common = require('../common'); 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++) { queue.push([!!decode, !!uncork, !!multi]); } } } module.exports = function (t) { t.test('writev', function (t) { queue.forEach(function (tr, i){ t.test('round ' + i, test(tr[0], tr[1], tr[2])); }); }); } function test(decode, uncork, multi) { return function (t) { //console.log('# decode=%j uncork=%j multi=%j', decode, uncork, multi); var counter = 0; var expectCount = 0; function cnt(msg) { expectCount++; var expect = expectCount; var called = false; return function(er) { if (er) throw er; called = true; counter++; t.equal(counter, expect); }; } var w = new stream.Writable({ decodeStrings: decode }); w._write = function(chunk, e, cb) { t.ok(false, 'Should not call _write'); }; var expectChunks = decode ? [ { encoding: 'buffer', chunk: [104, 101, 108, 108, 111, 44, 32] }, { encoding: 'buffer', chunk: [119, 111, 114, 108, 100] }, { encoding: 'buffer', chunk: [33] }, { encoding: 'buffer', chunk: [10, 97, 110, 100, 32, 116, 104, 101, 110, 46, 46, 46] }, { encoding: 'buffer', chunk: [250, 206, 190, 167, 222, 173, 190, 239, 222, 202, 251, 173]} ] : [ { encoding: 'ascii', chunk: 'hello, ' }, { encoding: 'utf8', chunk: 'world' }, { encoding: 'buffer', chunk: [33] }, { encoding: 'binary', chunk: '\nand then...' }, { encoding: 'hex', chunk: 'facebea7deadbeefdecafbad' } ]; var actualChunks; w._writev = function(chunks, cb) { actualChunks = chunks.map(function(chunk) { return { encoding: chunk.encoding, chunk: Buffer.isBuffer(chunk.chunk) ? Array.prototype.slice.call(chunk.chunk) : chunk.chunk }; }); cb(); }; w.cork(); w.write('hello, ', 'ascii', cnt('hello')); w.write('world', 'utf8', cnt('world')); if (multi) w.cork(); w.write(Buffer.from('!'), 'buffer', cnt('!')); w.write('\nand then...', 'binary', cnt('and then')); if (multi) w.uncork(); w.write('facebea7deadbeefdecafbad', 'hex', cnt('hex')); if (uncork) w.uncork(); w.end(cnt('end')); w.on('finish', function() { // make sure finish comes after all the write cb cnt('finish')(); t.deepEqual(expectChunks, actualChunks); t.end(); }); } } readable-stream-3.6.0/test/browser/test-stream2-base64-single-char-read-end.js000066400000000000000000000015361362132315000270340ustar00rootroot00000000000000'use strict'; var common = require('../common'); var R = require('../../lib/_stream_readable'); var W = require('../../lib/_stream_writable'); module.exports = function (t) { t.test('base64 single char read end', function (t) { t.plan(1); var src = new R({encoding: 'base64'}); var dst = new W(); var hasRead = false; var accum = []; var timeout; src._read = function(n) { if(!hasRead) { hasRead = true; process.nextTick(function() { src.push(Buffer.from('1')); src.push(null); }); }; }; dst._write = function(chunk, enc, cb) { accum.push(chunk); cb(); }; src.on('end', function() { t.equal(Buffer.concat(accum) + '', 'MQ=='); clearTimeout(timeout); }); src.pipe(dst); timeout = setTimeout(function() { assert.fail('timed out waiting for _write'); }, 100); }) } readable-stream-3.6.0/test/browser/test-stream2-compatibility.js000066400000000000000000000013131362132315000247430ustar00rootroot00000000000000'use strict'; var R = require('../../lib/_stream_readable'); var inherits = require('inherits'); var EE = require('events').EventEmitter; module.exports = function (t) { t.test('compatibility', function (t) { t.plan(1); var ondataCalled = 0; function TestReader() { R.apply(this); this._buffer = Buffer.alloc(100); this._buffer.fill('x'); this.on('data', function() { ondataCalled++; }); } inherits(TestReader, R); TestReader.prototype._read = function(n) { this.push(this._buffer); this._buffer = Buffer.alloc(0); }; var reader = new TestReader(); setTimeout(function() { t.equal(ondataCalled, 1); }); }); } readable-stream-3.6.0/test/browser/test-stream2-large-read-stall.js000066400000000000000000000030161362132315000252140ustar00rootroot00000000000000'use strict'; var common = require('../common'); module.exports = function (t) { t.test('large object read stall', function (t) { // 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 }); var rs = r._readableState; r._read = push; r.on('readable', function() { ;false && console.error('>> readable'); do { ;false && console.error(' > read(%d)', READSIZE); var ret = r.read(READSIZE); ;false && console.error(' < %j (%d remain)', ret && ret.length, rs.length); } while (ret && ret.length === READSIZE); ;false && console.error('<< after read()', ret && ret.length, rs.needReadable, rs.length); }); var endEmitted = false; r.on('end', function() { t.equal(pushes, PUSHCOUNT + 1); t.end(); ;false && console.error('end'); }); 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 #%d', pushes); if (r.push(Buffer.alloc(PUSHSIZE))) setTimeout(push); } // start the flow var ret = r.read(0); }); } readable-stream-3.6.0/test/browser/test-stream2-objects.js000066400000000000000000000131751362132315000235340ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Readable = require('../../lib/_stream_readable'); var Writable = require('../../lib/_stream_writable'); module.exports = function (t) { function toArray(callback) { var stream = new Writable({ objectMode: true }); var list = []; stream.write = function(chunk) { list.push(chunk); }; stream.end = function() { callback(list); }; return stream; } function fromArray(list) { var r = new Readable({ objectMode: true }); r._read = noop; forEach(list, function(chunk) { r.push(chunk); }); r.push(null); return r; } function noop() {} t.test('can read objects from stream', function(t) { var r = fromArray([{ one: '1'}, { two: '2' }]); var v1 = r.read(); var v2 = r.read(); var v3 = r.read(); t.deepEqual(v1, { one: '1' }); t.deepEqual(v2, { two: '2' }); t.deepEqual(v3, null); t.end(); }); t.test('can pipe objects into stream', function(t) { var r = fromArray([{ one: '1'}, { two: '2' }]); r.pipe(toArray(function(list) { t.deepEqual(list, [ { one: '1' }, { two: '2' } ]); t.end(); })); }); t.test('read(n) is ignored', function(t) { var r = fromArray([{ one: '1'}, { two: '2' }]); var value = r.read(2); t.deepEqual(value, { one: '1' }); t.end(); }); t.test('can read objects from _read (sync)', function(t) { var r = new Readable({ objectMode: true }); var list = [{ one: '1'}, { two: '2' }]; r._read = function(n) { var item = list.shift(); r.push(item || null); }; r.pipe(toArray(function(list) { t.deepEqual(list, [ { one: '1' }, { two: '2' } ]); t.end(); })); }); t.test('can read objects from _read (async)', function(t) { var r = new Readable({ objectMode: true }); var list = [{ one: '1'}, { two: '2' }]; r._read = function(n) { var item = list.shift(); process.nextTick(function() { r.push(item || null); }); }; r.pipe(toArray(function(list) { t.deepEqual(list, [ { one: '1' }, { two: '2' } ]); t.end(); })); }); t.test('can read strings as objects', function(t) { var r = new Readable({ objectMode: true }); r._read = noop; var list = ['one', 'two', 'three']; forEach(list, function(str) { r.push(str); }); r.push(null); r.pipe(toArray(function(array) { t.deepEqual(array, list); t.end(); })); }); t.test('read(0) for object streams', function(t) { var r = new Readable({ objectMode: true }); r._read = noop; r.push('foobar'); r.push(null); var v = r.read(0); r.pipe(toArray(function(array) { t.deepEqual(array, ['foobar']); t.end(); })); }); t.test('falsey values', function(t) { var r = new Readable({ objectMode: true }); r._read = noop; r.push(false); r.push(0); r.push(''); r.push(null); r.pipe(toArray(function(array) { t.deepEqual(array, [false, 0, '']); t.end(); })); }); t.test('high watermark _read', function(t) { var r = new Readable({ highWaterMark: 6, objectMode: true }); var calls = 0; var list = ['1', '2', '3', '4', '5', '6', '7', '8']; r._read = function(n) { calls++; }; forEach(list, function(c) { r.push(c); }); var v = r.read(); t.equal(calls, 0); t.equal(v, '1'); var v2 = r.read(); t.equal(v2, '2'); var v3 = r.read(); t.equal(v3, '3'); t.equal(calls, 1); t.end(); }); t.test('high watermark push', function(t) { var r = new Readable({ highWaterMark: 6, objectMode: true }); r._read = function(n) {}; for (var i = 0; i < 6; i++) { var bool = r.push(i); t.equal(bool, i === 5 ? false : true); } t.end(); }); t.test('can write objects to stream', function(t) { var w = new Writable({ objectMode: true }); w._write = function(chunk, encoding, cb) { t.deepEqual(chunk, { foo: 'bar' }); cb(); }; w.on('finish', function() { t.end(); }); w.write({ foo: 'bar' }); w.end(); }); t.test('can write multiple objects to stream', function(t) { var w = new Writable({ objectMode: true }); var list = []; w._write = function(chunk, encoding, cb) { list.push(chunk); cb(); }; w.on('finish', function() { t.deepEqual(list, [0, 1, 2, 3, 4]); t.end(); }); w.write(0); w.write(1); w.write(2); w.write(3); w.write(4); w.end(); }); t.test('can write strings as objects', function(t) { var w = new Writable({ objectMode: true }); var list = []; w._write = function(chunk, encoding, cb) { list.push(chunk); process.nextTick(cb); }; w.on('finish', function() { t.deepEqual(list, ['0', '1', '2', '3', '4']); t.end(); }); w.write('0'); w.write('1'); w.write('2'); w.write('3'); w.write('4'); w.end(); }); t.test('buffers finish until cb is called', function(t) { var w = new Writable({ objectMode: true }); var called = false; w._write = function(chunk, encoding, cb) { t.equal(chunk, 'foo'); process.nextTick(function() { called = true; cb(); }); }; w.on('finish', function() { t.equal(called, true); t.end(); }); w.write('foo'); w.end(); }); function forEach (xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } } }; readable-stream-3.6.0/test/browser/test-stream2-pipe-error-handling.js000066400000000000000000000037461362132315000257540ustar00rootroot00000000000000'use strict'; var common = require('../common'); var assert = require('assert'); var stream = require('../../'); module.exports = function (t) { t.test('Error Listener Catches', function (t) { var count = 1000; var source = new stream.Readable(); source._read = function(n) { n = Math.min(count, n); count -= n; source.push(Buffer.alloc(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) { gotErr = err; }); var unpipedSource; dest.on('unpipe', function(src) { unpipedSource = src; }); var err = new Error('This stream turned into bacon.'); dest.emit('error', err); t.strictEqual(gotErr, err); t.strictEqual(unpipedSource, source); t.strictEqual(unpipedDest, dest); t.end(); }); t.test('Error Without Listener Throws', function testErrorWithoutListenerThrows(t) { var count = 1000; var source = new stream.Readable(); source._read = function(n) { n = Math.min(count, n); count -= n; source.push(Buffer.alloc(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; } t.strictEqual(gotErr, err); t.strictEqual(unpipedSource, source); t.strictEqual(unpipedDest, dest); t.end(); }); } readable-stream-3.6.0/test/browser/test-stream2-pipe-error-once-listener.js000066400000000000000000000015511362132315000267270ustar00rootroot00000000000000'use strict'; var common = require('../common'); var inherits = require('inherits'); var stream = require('../../'); module.exports = function (t) { t.test('pipe error once listener', function (t){ t.plan(1); var Read = function() { stream.Readable.call(this); }; inherits(Read, stream.Readable); Read.prototype._read = function(size) { this.push('x'); this.push(null); }; var Write = function() { stream.Writable.call(this); }; inherits(Write, stream.Writable); Write.prototype._write = function(buffer, encoding, cb) { this.emit('error', new Error('boom')); this.emit('alldone'); }; var read = new Read(); var write = new Write(); write.once('error', function(err) {}); write.once('alldone', function(err) { t.ok(true); }); read.pipe(write); }); } readable-stream-3.6.0/test/browser/test-stream2-push.js000066400000000000000000000047071362132315000230630ustar00rootroot00000000000000'use strict'; var common = require('../common'); var stream = require('../../'); var Readable = stream.Readable; var Writable = stream.Writable; var inherits = require('inherits'); var EE = require('events').EventEmitter; module.exports = function (t) { // a mock thing a bit like the net.Socket/tcp_wrap.handle interaction t.test('push', function (t) { 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; }); source.on('data', function(chunk) { var ret = stream.push(chunk); //console.error('data', stream._readableState.length); if (!ret) readStop(); }); source.on('end', function() { stream.push(null); }); var reading = false; function readStart() { //console.error('readStart'); reading = true; } function readStop() { //console.error('readStop'); reading = false; process.nextTick(function() { var r = stream.read(); 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 %s', chunk); written.push(chunk); process.nextTick(cb); }; writer.on('finish', finish); // now emit some chunks. var chunk = 'asdfg'; var set = 0; readStart(); data(); function data() { t.ok(reading); source.emit('data', chunk); t.ok(reading); source.emit('data', chunk); t.ok(reading); source.emit('data', chunk); t.ok(reading); source.emit('data', chunk); t.notOk(reading); if (set++ < 5) setTimeout(data, 10); else end(); } function finish() { //console.error('finish'); t.deepEqual(written, expectWritten); t.end(); } function end() { source.emit('end'); t.notOk(reading); writer.end(stream.read()); setTimeout(function() { t.ok(ended); }); } }); }; readable-stream-3.6.0/test/browser/test-stream2-readable-empty-buffer-no-eof.js000066400000000000000000000046621362132315000274270ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Readable = require('../../').Readable; module.exports = function (t) { t.test('readable empty buffer no eof 1', function (t) { t.plan(1); var r = new Readable(); // should not end when we get a Buffer(0) or '' as the _read result // that just means that there is *temporarily* no data, but to go // ahead and try again later. // // note that this is very unusual. it only works for crypto streams // because the other side of the stream will call read(0) to cycle // data through openssl. that's why we set the timeouts to call // r.read(0) again later, otherwise there is no more work being done // and the process just exits. var buf = Buffer.alloc(5); buf.fill('x'); var reads = 5; r._read = function(n) { switch (reads--) { case 0: return r.push(null); // EOF case 1: return r.push(buf); case 2: setTimeout(r.read.bind(r, 0), 50); return r.push(Buffer.alloc(0)); // Not-EOF! case 3: setTimeout(r.read.bind(r, 0), 50); return process.nextTick(function() { return r.push(Buffer.alloc(0)); }); case 4: setTimeout(r.read.bind(r, 0), 50); return setTimeout(function() { return r.push(Buffer.alloc(0)); }); case 5: return setTimeout(function() { return r.push(buf); }); default: throw new Error('unreachable'); } }; var results = []; function flow() { var chunk; while (null !== (chunk = r.read())) results.push(chunk + ''); } r.on('readable', flow); r.on('end', function() { results.push('EOF'); t.deepEqual(results, [ 'xxxxx', 'xxxxx', 'EOF' ]); }); flow(); }); t.test('readable empty buffer no eof 2', function (t) { t.plan(1); var r = new Readable({ encoding: 'base64' }); var reads = 5; r._read = function(n) { if (!reads--) return r.push(null); // EOF else return r.push(Buffer.from('x')); }; var results = []; function flow() { var chunk; while (null !== (chunk = r.read())) results.push(chunk + ''); } r.on('readable', flow); r.on('end', function() { results.push('EOF'); t.deepEqual(results, [ 'eHh4', 'eHg=', 'EOF' ]); }); flow(); }); } readable-stream-3.6.0/test/browser/test-stream2-readable-from-list.js000066400000000000000000000036631362132315000255550ustar00rootroot00000000000000// Flags: --expose_internals /**/ var bufferShim = require('safe-buffer').Buffer; /**/ require('../common'); var fromList = require('../../lib/_stream_readable')._fromList; var BufferList = require('../../lib/internal/streams/BufferList'); function bufferListFromArray(arr) { var bl = new BufferList(); for (var i = 0; i < arr.length; ++i) { bl.push(arr[i]); }return bl; } module.exports = function (t) { t.test('buffers', function (t) { var list = [bufferShim.from('foog'), bufferShim.from('bark'), bufferShim.from('bazy'), bufferShim.from('kuel')]; list = bufferListFromArray(list); // read more than the first element. var ret = fromList(6, { buffer: list, length: 16 }); t.equal(ret.toString(), 'foogba'); // read exactly the first element. ret = fromList(2, { buffer: list, length: 10 }); t.equal(ret.toString(), 'rk'); // read less than the first element. ret = fromList(2, { buffer: list, length: 8 }); t.equal(ret.toString(), 'ba'); // read more than we have. ret = fromList(100, { buffer: list, length: 6 }); t.equal(ret.toString(), 'zykuel'); // all consumed. t.same(list, new BufferList()); t.end(); }); t.test('strings', function (t) { var list = ['foog', 'bark', 'bazy', 'kuel']; list = bufferListFromArray(list); // read more than the first element. var ret = fromList(6, { buffer: list, length: 16, decoder: true }); t.equal(ret, 'foogba'); // read exactly the first element. ret = fromList(2, { buffer: list, length: 10, decoder: true }); t.equal(ret, 'rk'); // read less than the first element. ret = fromList(2, { buffer: list, length: 8, decoder: true }); t.equal(ret, 'ba'); // read more than we have. ret = fromList(100, { buffer: list, length: 6, decoder: true }); t.equal(ret, 'zykuel'); // all consumed. t.same(list, new BufferList()); t.end(); }); } readable-stream-3.6.0/test/browser/test-stream2-readable-legacy-drain.js000066400000000000000000000021761362132315000261760ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Stream = require('../../'); var Readable = require('../../').Readable; module.exports = function (t) { t.test('readable legacy drain', function (t) { var r = new Readable(); var N = 256; var reads = 0; r._read = function(n) { return r.push(++reads === N ? null : Buffer.alloc(1)); }; t.plan(2); r.on('end', function() { t.ok(true, 'rended'); }); var w = new Stream(); w.writable = true; var writes = 0; var buffered = 0; w.write = function(c) { writes += c.length; buffered += c.length; process.nextTick(drain); return false; }; function drain() { if(buffered > 3) { t.ok(false, 'to much buffer'); } buffered = 0; w.emit('drain'); } w.end = function() { t.ok(true, 'wended'); }; // 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); }); } readable-stream-3.6.0/test/browser/test-stream2-readable-non-empty-end.js000066400000000000000000000024541362132315000263300ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Readable = require('../../lib/_stream_readable'); module.exports = function (t) { t.test('non empty end', function (t) { t.plan(4); var len = 0; var chunks = new Array(10); for (var i = 1; i <= 10; i++) { chunks[i - 1] = Buffer.alloc(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); }); }; 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=%d len=%d', bytesread, len); setTimeout(next); } test.read(0); }); test.read(0); function next() { // now let's make 'end' happen test.removeListener('end', thrower); test.on('end', function() { t.ok(true, 'end emitted'); }); // one to get the last byte var r = test.read(); t.ok(r); t.equal(r.length, 1); r = test.read(); t.equal(r, null); } }); } readable-stream-3.6.0/test/browser/test-stream2-readable-wrap-empty.js000066400000000000000000000010411362132315000257320ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Readable = require('../../lib/_stream_readable'); var EE = require('events').EventEmitter; module.exports = function (t) { t.test('wrap empty', function (t) { t.plan(1); var oldStream = new EE(); oldStream.pause = function() {}; oldStream.resume = function() {}; var newStream = new Readable().wrap(oldStream); newStream .on('readable', function() {}) .on('end', function() { t.ok(true, 'ended'); }); oldStream.emit('end'); }) } readable-stream-3.6.0/test/browser/test-stream2-readable-wrap.js000066400000000000000000000043361362132315000246100ustar00rootroot00000000000000'use strict'; var common = require('../common'); var Readable = require('../../lib/_stream_readable'); var Writable = require('../../lib/_stream_writable'); var EE = require('events').EventEmitter; var run = 0; function runTest(t, highWaterMark, objectMode, produce) { t.test('run #' + (++run), function (t) { var old = new EE(); var r = new Readable({ highWaterMark: highWaterMark, objectMode: objectMode }); t.equal(r, r.wrap(old)); var ended = false; r.on('end', function() { ended = true; }); old.pause = function() { //console.error('old.pause()'); old.emit('pause'); flowing = false; }; old.resume = function() { //console.error('old.resume()'); old.emit('resume'); flow(); }; var flowing; var chunks = 10; var oldEnded = false; var expected = []; function flow() { flowing = true; while (flowing && chunks-- > 0) { var item = produce(); expected.push(item); //console.log('old.emit', chunks, flowing); old.emit('data', item); //console.log('after emit', chunks, flowing); } if (chunks <= 0) { oldEnded = true; //console.log('old end', chunks, flowing); old.emit('end'); } } var w = new Writable({ highWaterMark: highWaterMark * 2, objectMode: objectMode }); var written = []; w._write = function(chunk, encoding, cb) { //console.log('_write', chunk); written.push(chunk); setTimeout(cb); }; w.on('finish', function() { performAsserts(); }); r.pipe(w); flow(); function performAsserts() { t.ok(ended); t.ok(oldEnded); t.deepEqual(written, expected); t.end(); } }); } module.exports = function (t) { t.test('readable wrap', function (t) { runTest(t, 100, false, function() { return Buffer.alloc(100); }); runTest(t, 10, false, function() { return Buffer.from('xxxxxxxxxx'); }); runTest(t, 1, true, function() { return { foo: 'bar' }; }); var objectChunks = [ 5, 'a', false, 0, '', 'xyz', { x: 4 }, 7, [], 555 ]; runTest(t, 1, true, function() { return objectChunks.shift(); }); }); } readable-stream-3.6.0/test/browser/test-stream2-set-encoding.js000066400000000000000000000151661362132315000244640ustar00rootroot00000000000000'use strict'; var common = require('../common'); var R = require('../../lib/_stream_readable'); var util = { inherits: require('inherits') }; // tiny node-tap lookalike. module.exports = function (t) { var test = t.test; ///// util.inherits(TestReader, R); function TestReader(n, opts) { R.call(this, opts); this.pos = 0; this.len = n || 100; } TestReader.prototype._read = function(n) { setTimeout(function() { if (this.pos >= this.len) { // double push(null) to test eos handling this.push(null); return this.push(null); } n = Math.min(n, this.len - this.pos); if (n <= 0) { // double push(null) to test eos handling this.push(null); return this.push(null); } this.pos += n; var ret = Buffer.alloc(n); ret.fill('a'); //console.log('this.push(ret)', ret); return this.push(ret); }.bind(this), 1); }; test('setEncoding utf8', function(t) { var tr = new TestReader(100); tr.setEncoding('utf8'); var out = []; 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); }); tr.on('end', function() { t.same(out, expect); t.end(); }); }); test('setEncoding hex', function(t) { 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); }); tr.on('end', function() { t.same(out, expect); t.end(); }); }); test('setEncoding hex with read(13)', function(t) { var tr = new TestReader(100); tr.setEncoding('hex'); var out = []; var expect = [ '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '16161' ]; tr.on('readable', function flow() { //console.log('readable once'); var chunk; while (null !== (chunk = tr.read(13))) out.push(chunk); }); tr.on('end', function() { //console.log('END'); t.same(out, expect); t.end(); }); }); test('setEncoding base64', function(t) { var tr = new TestReader(100); tr.setEncoding('base64'); var out = []; var expect = [ 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYQ==' ]; tr.on('readable', function flow() { var chunk; while (null !== (chunk = tr.read(10))) out.push(chunk); }); tr.on('end', function() { t.same(out, expect); t.end(); }); }); test('encoding: utf8', function(t) { var tr = new TestReader(100, { encoding: 'utf8' }); var out = []; 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); }); tr.on('end', function() { t.same(out, expect); t.end(); }); }); test('encoding: hex', function(t) { var tr = new TestReader(100, { encoding: '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); }); tr.on('end', function() { t.same(out, expect); t.end(); }); }); test('encoding: hex with read(13)', function(t) { var tr = new TestReader(100, { encoding: 'hex' }); var out = []; var expect = [ '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '1616161616161', '6161616161616', '16161' ]; tr.on('readable', function flow() { var chunk; while (null !== (chunk = tr.read(13))) out.push(chunk); }); tr.on('end', function() { t.same(out, expect); t.end(); }); }); test('encoding: base64', function(t) { var tr = new TestReader(100, { encoding: 'base64' }); var out = []; var expect = [ 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYWFhYWFh', 'YWFhYWFhYW', 'FhYQ==' ]; tr.on('readable', function flow() { var chunk; while (null !== (chunk = tr.read(10))) out.push(chunk); }); tr.on('end', function() { t.same(out, expect); t.end(); }); }); test('chainable', function(t) { var tr = new TestReader(100); t.equal(tr.setEncoding('utf8'), tr); t.end(); }); } readable-stream-3.6.0/test/browser/test-stream2-transform.js000066400000000000000000000266041362132315000241170ustar00rootroot00000000000000'use strict'; var common = require('../common'); var PassThrough = require('../../lib/_stream_passthrough'); var Transform = require('../../lib/_stream_transform'); ///// module.exports = function (t) { t.test('writable side consumption', function(t) { 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(Buffer.alloc(i)); } tx.end(); t.equal(tx._readableState.length, 10); t.equal(transformed, 10); t.equal(tx._transformState.writechunk.length, 5); t.same(tx._writableState.getBuffer().map(function(c) { return c.chunk.length; }), [6, 7, 8, 9, 10]); t.end(); }); t.test('passthrough', function(t) { var pt = new PassThrough(); pt.write(Buffer.from('foog')); pt.write(Buffer.from('bark')); pt.write(Buffer.from('bazy')); pt.write(Buffer.from('kuel')); pt.end(); t.equal(pt.read(5).toString(), 'foogb'); t.equal(pt.read(5).toString(), 'arkba'); t.equal(pt.read(5).toString(), 'zykue'); t.equal(pt.read(5).toString(), 'l'); t.end(); }); t.test('object passthrough', function(t) { 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(); t.equal(pt.read(), 1); t.equal(pt.read(), true); t.equal(pt.read(), false); t.equal(pt.read(), 0); t.equal(pt.read(), 'foo'); t.equal(pt.read(), ''); t.same(pt.read(), { a: 'b'}); t.end(); }); t.test('simple transform', function(t) { var pt = new Transform(); pt._transform = function(c, e, cb) { var ret = Buffer.alloc(c.length); ret.fill('x'); pt.push(ret); cb(); }; pt.write(Buffer.from('foog')); pt.write(Buffer.from('bark')); pt.write(Buffer.from('bazy')); pt.write(Buffer.from('kuel')); pt.end(); t.equal(pt.read(5).toString(), 'xxxxx'); t.equal(pt.read(5).toString(), 'xxxxx'); t.equal(pt.read(5).toString(), 'xxxxx'); t.equal(pt.read(5).toString(), 'x'); t.end(); }); t.test('simple object transform', function(t) { var pt = new Transform({ objectMode: true }); pt._transform = function(c, e, cb) { pt.push(JSON.stringify(c)); cb(); }; pt.write(1); pt.write(true); pt.write(false); pt.write(0); pt.write('foo'); pt.write(''); pt.write({ a: 'b'}); pt.end(); t.equal(pt.read(), '1'); t.equal(pt.read(), 'true'); t.equal(pt.read(), 'false'); t.equal(pt.read(), '0'); t.equal(pt.read(), '"foo"'); t.equal(pt.read(), '""'); t.equal(pt.read(), '{"a":"b"}'); t.end(); }); t.test('async passthrough', function(t) { var pt = new Transform(); pt._transform = function(chunk, encoding, cb) { setTimeout(function() { pt.push(chunk); cb(); }, 10); }; pt.write(Buffer.from('foog')); pt.write(Buffer.from('bark')); pt.write(Buffer.from('bazy')); pt.write(Buffer.from('kuel')); pt.end(); pt.on('finish', function() { t.equal(pt.read(5).toString(), 'foogb'); t.equal(pt.read(5).toString(), 'arkba'); t.equal(pt.read(5).toString(), 'zykue'); t.equal(pt.read(5).toString(), 'l'); t.end(); }); }); t.test('assymetric transform (expand)', function(t) { var pt = new Transform(); // emit each chunk 2 times. pt._transform = function(chunk, encoding, cb) { setTimeout(function() { pt.push(chunk); setTimeout(function() { pt.push(chunk); cb(); }, 10); }, 10); }; pt.write(Buffer.from('foog')); pt.write(Buffer.from('bark')); pt.write(Buffer.from('bazy')); pt.write(Buffer.from('kuel')); pt.end(); pt.on('finish', function() { t.equal(pt.read(5).toString(), 'foogf'); t.equal(pt.read(5).toString(), 'oogba'); t.equal(pt.read(5).toString(), 'rkbar'); t.equal(pt.read(5).toString(), 'kbazy'); t.equal(pt.read(5).toString(), 'bazyk'); t.equal(pt.read(5).toString(), 'uelku'); t.equal(pt.read(5).toString(), 'el'); t.end(); }); }); t.test('assymetric transform (compress)', function(t) { var pt = new Transform(); // each output is the first char of 3 consecutive chunks, // or whatever's left. pt.state = ''; pt._transform = function(chunk, encoding, cb) { if (!chunk) chunk = ''; var s = chunk.toString(); setTimeout(function() { this.state += s.charAt(0); if (this.state.length === 3) { pt.push(Buffer.from(this.state)); this.state = ''; } cb(); }.bind(this), 10); }; pt._flush = function(cb) { // just output whatever we have. pt.push(Buffer.from(this.state)); this.state = ''; cb(); }; pt.write(Buffer.from('aaaa')); pt.write(Buffer.from('bbbb')); pt.write(Buffer.from('cccc')); pt.write(Buffer.from('dddd')); pt.write(Buffer.from('eeee')); pt.write(Buffer.from('aaaa')); pt.write(Buffer.from('bbbb')); pt.write(Buffer.from('cccc')); pt.write(Buffer.from('dddd')); pt.write(Buffer.from('eeee')); pt.write(Buffer.from('aaaa')); pt.write(Buffer.from('bbbb')); pt.write(Buffer.from('cccc')); pt.write(Buffer.from('dddd')); pt.end(); // 'abcdeabcdeabcd' pt.on('finish', function() { t.equal(pt.read(5).toString(), 'abcde'); t.equal(pt.read(5).toString(), 'abcde'); t.equal(pt.read(5).toString(), 'abcd'); t.end(); }); }); // this tests for a stall when data is written to a full stream // that has empty transforms. t.test('complex transform', function(t) { var count = 0; var saved = null; var pt = new Transform({highWaterMark:3}); pt._transform = function(c, e, cb) { if (count++ === 1) saved = c; else { if (saved) { pt.push(saved); saved = null; } pt.push(c); } cb(); }; pt.once('readable', function() { process.nextTick(function() { pt.write(Buffer.from('d')); pt.write(Buffer.from('ef'), function() { pt.end(); t.end(); }); t.equal(pt.read().toString(), 'abcdef'); t.equal(pt.read(), null); }); }); pt.write(Buffer.from('abc')); }); t.test('passthrough event emission', function(t) { var pt = new PassThrough(); var emits = 0; pt.on('readable', function() { var state = pt._readableState; //console.error('>>> emit readable %d', emits); emits++; }); var i = 0; pt.write(Buffer.from('foog')); //console.error('need emit 0'); pt.write(Buffer.from('bark')); //console.error('should have emitted readable now 1 === %d', emits); t.equal(emits, 1); t.equal(pt.read(5).toString(), 'foogb'); t.equal(pt.read(5) + '', 'null'); //console.error('need emit 1'); pt.write(Buffer.from('bazy')); //console.error('should have emitted, but not again'); pt.write(Buffer.from('kuel')); //console.error('should have emitted readable now 2 === %d', emits); t.equal(emits, 2); t.equal(pt.read(5).toString(), 'arkba'); t.equal(pt.read(5).toString(), 'zykue'); t.equal(pt.read(5), null); //console.error('need emit 2'); pt.end(); t.equal(emits, 3); t.equal(pt.read(5).toString(), 'l'); t.equal(pt.read(5), null); //console.error('should not have emitted again'); t.equal(emits, 3); t.end(); }); t.test('passthrough event emission reordered', function(t) { var pt = new PassThrough(); var emits = 0; pt.on('readable', function() { //console.error('emit readable', emits); emits++; }); pt.write(Buffer.from('foog')); //console.error('need emit 0'); pt.write(Buffer.from('bark')); //console.error('should have emitted readable now 1 === %d', emits); t.equal(emits, 1); t.equal(pt.read(5).toString(), 'foogb'); t.equal(pt.read(5), null); //console.error('need emit 1'); pt.once('readable', function() { t.equal(pt.read(5).toString(), 'arkba'); t.equal(pt.read(5), null); //console.error('need emit 2'); pt.once('readable', function() { t.equal(pt.read(5).toString(), 'zykue'); t.equal(pt.read(5), null); pt.once('readable', function() { t.equal(pt.read(5).toString(), 'l'); t.equal(pt.read(5), null); t.equal(emits, 4); t.end(); }); pt.end(); }); pt.write(Buffer.from('kuel')); }); pt.write(Buffer.from('bazy')); }); t.test('passthrough facaded', function(t) { //console.error('passthrough facaded'); var pt = new PassThrough(); var datas = []; pt.on('data', function(chunk) { datas.push(chunk.toString()); }); pt.on('end', function() { t.same(datas, ['foog', 'bark', 'bazy', 'kuel']); t.end(); }); pt.write(Buffer.from('foog')); setTimeout(function() { pt.write(Buffer.from('bark')); setTimeout(function() { pt.write(Buffer.from('bazy')); setTimeout(function() { pt.write(Buffer.from('kuel')); setTimeout(function() { pt.end(); }, 10); }, 10); }, 10); }, 10); }); t.test('object transform (json parse)', function(t) { //console.error('json parse stream'); var jp = new Transform({ objectMode: true }); jp._transform = function(data, encoding, cb) { try { jp.push(JSON.parse(data)); cb(); } catch (er) { cb(er); } }; // anything except null/undefined is fine. // those are "magic" in the stream API, because they signal EOF. var objects = [ { foo: 'bar' }, 100, 'string', { nested: { things: [ { foo: 'bar' }, 100, 'string' ] } } ]; var ended = false; jp.on('end', function() { ended = true; }); forEach(objects, function(obj) { jp.write(JSON.stringify(obj)); var res = jp.read(); t.same(res, obj); }); jp.end(); // read one more time to get the 'end' event jp.read(); process.nextTick(function() { t.ok(ended); t.end(); }); }); t.test('object transform (json stringify)', function(t) { //console.error('json parse stream'); var js = new Transform({ objectMode: true }); js._transform = function(data, encoding, cb) { try { js.push(JSON.stringify(data)); cb(); } catch (er) { cb(er); } }; // anything except null/undefined is fine. // those are "magic" in the stream API, because they signal EOF. var objects = [ { foo: 'bar' }, 100, 'string', { nested: { things: [ { foo: 'bar' }, 100, 'string' ] } } ]; var ended = false; js.on('end', function() { ended = true; }); forEach(objects, function(obj) { js.write(obj); var res = js.read(); t.equal(res, JSON.stringify(obj)); }); js.end(); // read one more time to get the 'end' event js.read(); process.nextTick(function() { t.ok(ended); t.end(); }); }); function forEach (xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } } }; readable-stream-3.6.0/test/browser/test-stream2-unpipe-drain.js000066400000000000000000000026141362132315000244720ustar00rootroot00000000000000'use strict'; var common = require('../common'); var stream = require('../../'); var crypto = require('crypto'); var inherits = require('inherits'); module.exports = function (t) { t.test('unpipe drain', function (t) { try { crypto.randomBytes(9); } catch(_) { t.ok(true, 'does not suport random, skipping'); return t.end(); } function TestWriter() { stream.Writable.call(this); } inherits(TestWriter, stream.Writable); TestWriter.prototype._write = function(buffer, encoding, callback) { //console.log('write called'); // super slow write stream (callback never called) }; var dest = new TestWriter(); function TestReader(id) { stream.Readable.call(this); this.reads = 0; } inherits(TestReader, stream.Readable); TestReader.prototype._read = function(size) { this.reads += 1; this.push(crypto.randomBytes(size)); }; var src1 = new TestReader(); var src2 = new TestReader(); src1.pipe(dest); src1.once('readable', function() { process.nextTick(function() { src2.pipe(dest); src2.once('readable', function() { process.nextTick(function() { src1.unpipe(dest); }); }); }); }); dest.on('unpipe', function() { t.equal(src1.reads, 2); t.equal(src2.reads, 1); t.end(); }); }); } readable-stream-3.6.0/test/browser/test-stream2-writable.js000066400000000000000000000202731362132315000237110ustar00rootroot00000000000000'use strict'; var common = require('../common'); var W = require('../../lib/_stream_writable'); var D = require('../../lib/_stream_duplex'); var inherits = require('inherits'); inherits(TestWriter, W); function TestWriter() { W.apply(this, arguments); this.buffer = []; this.written = 0; } TestWriter.prototype._write = function(chunk, encoding, cb) { // simulate a small unpredictable latency setTimeout(function() { this.buffer.push(chunk.toString()); this.written += chunk.length; cb(); }.bind(this), Math.floor(Math.random() * 10)); }; inherits(Processstdout, W); function Processstdout() { W.apply(this, arguments); this.buffer = []; this.written = 0; } Processstdout.prototype._write = function(chunk, encoding, cb) { //console.log(chunk.toString()); cb(); }; var chunks = new Array(50); for (var i = 0; i < chunks.length; i++) { chunks[i] = new Array(i + 1).join('x'); } module.exports = function (t) { var test = t.test; if (!process.stdout) { process.stdout = new Processstdout(); } test('write fast', function(t) { var tw = new TestWriter({ highWaterMark: 100 }); tw.on('finish', function() { t.same(tw.buffer, chunks, 'got chunks in the right order'); t.end(); }); forEach(chunks, function(chunk) { // screw backpressure. Just buffer it all up. tw.write(chunk); }); tw.end(); }); test('write slow', function(t) { var tw = new TestWriter({ highWaterMark: 100 }); tw.on('finish', function() { t.same(tw.buffer, chunks, 'got chunks in the right order'); t.end(); }); var i = 0; (function W() { tw.write(chunks[i++]); if (i < chunks.length) setTimeout(W, 10); else tw.end(); })(); }); test('write backpressure', function(t) { var tw = new TestWriter({ highWaterMark: 50 }); var drains = 0; tw.on('finish', function() { t.same(tw.buffer, chunks, 'got chunks in the right order'); t.equal(drains, 17); t.end(); }); tw.on('drain', function() { drains++; }); var i = 0; (function W() { do { var ret = tw.write(chunks[i++]); } while (ret !== false && i < chunks.length); if (i < chunks.length) { t.ok(tw._writableState.length >= 50); tw.once('drain', W); } else { tw.end(); } })(); }); test('write bufferize', function(t) { var tw = new TestWriter({ highWaterMark: 100 }); var encodings = [ 'hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', undefined ]; tw.on('finish', function() { t.same(tw.buffer, chunks, 'got the expected chunks'); }); forEach(chunks, function(chunk, i) { var enc = encodings[ i % encodings.length ]; chunk = Buffer.from(chunk); tw.write(chunk.toString(enc), enc); }); t.end(); }); test('write no bufferize', function(t) { var tw = new TestWriter({ highWaterMark: 100, decodeStrings: false }); tw._write = function(chunk, encoding, cb) { t.equals(typeof chunk, 'string'); chunk = Buffer.from(chunk, encoding); return TestWriter.prototype._write.call(this, chunk, encoding, cb); }; var encodings = [ 'hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', undefined ]; tw.on('finish', function() { t.same(tw.buffer, chunks, 'got the expected chunks'); }); forEach(chunks, function(chunk, i) { var enc = encodings[ i % encodings.length ]; chunk = Buffer.from(chunk); tw.write(chunk.toString(enc), enc); }); t.end(); }); test('write callbacks', function(t) { var callbacks = chunks.map(function(chunk, i) { return [i, function(er) { callbacks._called[i] = chunk; }]; }).reduce(function(set, x) { set['callback-' + x[0]] = x[1]; return set; }, {}); callbacks._called = []; var tw = new TestWriter({ highWaterMark: 100 }); tw.on('finish', function() { process.nextTick(function() { t.same(tw.buffer, chunks, 'got chunks in the right order'); t.same(callbacks._called, chunks, 'called all callbacks'); t.end(); }); }); forEach(chunks, function(chunk, i) { tw.write(chunk, callbacks['callback-' + i]); }); tw.end(); }); test('end callback', function(t) { var tw = new TestWriter(); tw.end(function() { t.end(); }); }); test('end callback with chunk', function(t) { var tw = new TestWriter(); tw.end(Buffer.from('hello world'), function() { t.end(); }); }); test('end callback with chunk and encoding', function(t) { var tw = new TestWriter(); tw.end('hello world', 'ascii', function() { t.end(); }); }); test('end callback after .write() call', function(t) { var tw = new TestWriter(); tw.write(Buffer.from('hello world')); tw.end(function() { t.end(); }); }); test('end callback called after write callback', function(t) { var tw = new TestWriter(); var writeCalledback = false; tw.write(Buffer.from('hello world'), function() { writeCalledback = true; }); tw.end(function() { t.equal(writeCalledback, true); t.end(); }); }); test('encoding should be ignored for buffers', function(t) { var tw = new W(); var hex = '018b5e9a8f6236ffe30e31baf80d2cf6eb'; tw._write = function(chunk, encoding, cb) { t.equal(chunk.toString('hex'), hex); t.end(); }; var buf = Buffer.from(hex, 'hex'); tw.write(buf, 'binary'); }); test('writables are not pipable', function(t) { var w = new W(); w._write = function() {}; var gotError = false; w.on('error', function(er) { gotError = true; }); w.pipe(process.stdout); t.ok(gotError); t.end(); }); test('duplexes are pipable', function(t) { var d = new D(); d._read = function() {}; d._write = function() {}; var gotError = false; d.on('error', function(er) { gotError = true; }); d.pipe(process.stdout); t.ok(!gotError); t.end(); }); test('end(chunk) two times is an error', function(t) { var w = new W(); w._write = function() {}; var gotError = false; w.on('error', function(er) { gotError = true; t.equal(er.message, 'write after end'); }); w.end('this is the end'); w.end('and so is this'); process.nextTick(function() { t.ok(gotError); t.end(); }); }); test('dont end while writing', function(t) { var w = new W(); var wrote = false; w._write = function(chunk, e, cb) { t.ok(!this.writing); wrote = true; this.writing = true; setTimeout(function() { this.writing = false; cb(); }); }; w.on('finish', function() { t.ok(wrote); t.end(); }); w.write(Buffer(0)); w.end(); }); test('finish does not come before write cb', function(t) { var w = new W(); var writeCb = false; w._write = function(chunk, e, cb) { setTimeout(function() { writeCb = true; cb(); }, 10); }; w.on('finish', function() { t.ok(writeCb); t.end(); }); w.write(Buffer(0)); w.end(); }); test('finish does not come before sync _write cb', function(t) { var w = new W(); var writeCb = false; w._write = function(chunk, e, cb) { cb(); }; w.on('finish', function() { t.ok(writeCb); t.end(); }); w.write(Buffer(0), function(er) { writeCb = true; }); w.end(); }); test('finish is emitted if last chunk is empty', function(t) { var w = new W(); w._write = function(chunk, e, cb) { process.nextTick(cb); }; w.on('finish', function() { t.end(); }); w.write(Buffer(1)); w.end(Buffer(0)); }); function forEach (xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } } } readable-stream-3.6.0/test/browser/test-stream3-pause-then-read.js000066400000000000000000000070661362132315000250700ustar00rootroot00000000000000'use strict'; var common = require('../common'); var stream = require('../../'); var Readable = stream.Readable; var Writable = stream.Writable; module.exports = function (t){ t.test('pause then read', function (t) { var totalChunks = 100; var chunkSize = 99; var expectTotalData = totalChunks * chunkSize; var expectEndingData = expectTotalData; var r = new Readable({ highWaterMark: 1000 }); var chunks = totalChunks; r._read = function(n) { if (!(chunks % 2)) setImmediate(push); else if (!(chunks % 3)) process.nextTick(push); else push(); }; var totalPushed = 0; function push() { var chunk = chunks-- > 0 ? Buffer.alloc(chunkSize) : null; if (chunk) { totalPushed += chunk.length; chunk.fill('x'); } r.push(chunk); } read100(); // first we read 100 bytes function read100() { readn(100, onData); } function readn(n, then) { //console.error('read %d', n); expectEndingData -= n; ;(function read() { var c = r.read(n); if (!c) r.once('readable', read); else { t.equal(c.length, n); t.notOk(r._readableState.flowing); then(); } })(); } // 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 setImmediate(pipeLittle); } }); } // Just pipe 200 bytes, then unshift the extra and unpipe function pipeLittle() { expectEndingData -= 200; //console.error('pipe a little'); var w = new Writable(); var written = 0; w.on('finish', function() { t.equal(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; r.unshift(chunk.slice(chunk.length - diff)); } } else { setImmediate(cb); } }; r.pipe(w); } // 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 r.resume(); r.pause(); r.resume(); r.pause(); r.resume(); r.pause(); r.resume(); r.pause(); r.resume(); 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); t.equal(written, expectEndingData); t.equal(totalPushed, expectTotalData); t.end(); }); r.pipe(w); } }); } readable-stream-3.6.0/test/common/000077500000000000000000000000001362132315000170135ustar00rootroot00000000000000readable-stream-3.6.0/test/common/README.md000066400000000000000000000557771362132315000203170ustar00rootroot00000000000000/**/ require('@babel/polyfill'); var util = require('util'); for (var i in util) exports[i] = util[i]; /**/# Node.js Core Test Common Modules This directory contains modules used to test the Node.js implementation. ## Table of Contents * [Benchmark module](#benchmark-module) * [Common module API](#common-module-api) * [Countdown module](#countdown-module) * [DNS module](#dns-module) * [Duplex pair helper](#duplex-pair-helper) * [Fixtures module](#fixtures-module) * [Heap dump checker module](#heap-dump-checker-module) * [HTTP2 module](#http2-module) * [Internet module](#internet-module) * [tick module](#tick-module) * [tmpdir module](#tmpdir-module) * [WPT module](#wpt-module) ## Benchmark Module The `benchmark` module is used by tests to run benchmarks. ### runBenchmark(name, args, env) * `name` [<string>] Name of benchmark suite to be run. * `args` [<Array>] Array of environment variable key/value pairs (ex: `n=1`) to be applied via `--set`. * `env` [<Object>] Environment variables to be applied during the run. ## Common Module API The `common` module is used by tests for consistency across repeated tasks. ### allowGlobals(...whitelist) * `whitelist` [<Array>] Array of Globals * return [<Array>] Takes `whitelist` and concats that with predefined `knownGlobals`. ### busyLoop(time) * `time` [<number>] Blocks for `time` amount of time. ### canCreateSymLink() * return [<boolean>] Checks whether the current running process can create symlinks. On Windows, this returns `false` if the process running doesn't have privileges to create symlinks ([SeCreateSymbolicLinkPrivilege](https://msdn.microsoft.com/en-us/library/windows/desktop/bb530716(v=vs.85).aspx)). On non-Windows platforms, this always returns `true`. ### createZeroFilledFile(filename) Creates a 10 MB file of all null characters. ### disableCrashOnUnhandledRejection() Removes the `process.on('unhandledRejection')` handler that crashes the process after a tick. The handler is useful for tests that use Promises and need to make sure no unexpected rejections occur, because currently they result in silent failures. However, it is useful in some rare cases to disable it, for example if the `unhandledRejection` hook is directly used by the test. ### enoughTestMem * [<boolean>] Indicates if there is more than 1gb of total memory. ### expectsError([fn, ]settings[, exact]) * `fn` [<Function>] a function that should throw. * `settings` [<Object>] that must contain the `code` property plus any of the other following properties (some properties only apply for `AssertionError`): * `code` [<string>] expected error must have this value for its `code` property. * `type` [<Function>] expected error must be an instance of `type` and must be an Error subclass. * `message` [<string>] or [<RegExp>] if a string is provided for `message`, expected error must have it for its `message` property; if a regular expression is provided for `message`, the regular expression must match the `message` property of the expected error. * `name` [<string>] expected error must have this value for its `name` property. * `info` <Object> expected error must have the same `info` property that is deeply equal to this value. * `generatedMessage` [<string>] (`AssertionError` only) expected error must have this value for its `generatedMessage` property. * `actual` <any> (`AssertionError` only) expected error must have this value for its `actual` property. * `expected` <any> (`AssertionError` only) expected error must have this value for its `expected` property. * `operator` <any> (`AssertionError` only) expected error must have this value for its `operator` property. * `exact` [<number>] default = 1 * return [<Function>] If `fn` is provided, it will be passed to `assert.throws` as first argument and `undefined` will be returned. Otherwise a function suitable as callback or for use as a validation function passed as the second argument to `assert.throws()` will be returned. If the returned function has not been called exactly `exact` number of times when the test is complete, then the test will fail. ### expectWarning(name, expected, code) * `name` [<string>] * `expected` [<string>] | [<Array>] * `code` [<string>] Tests whether `name`, `expected`, and `code` are part of a raised warning. If an expected warning does not have a code then `common.noWarnCode` can be used to indicate this. ### getArrayBufferViews(buf) * `buf` [<Buffer>] * return [<ArrayBufferView[]>] Returns an instance of all possible `ArrayBufferView`s of the provided Buffer. ### getBufferSources(buf) * `buf` [<Buffer>] * return [<BufferSource[]>] Returns an instance of all possible `BufferSource`s of the provided Buffer, consisting of all `ArrayBufferView` and an `ArrayBuffer`. ### getCallSite(func) * `func` [<Function>] * return [<string>] Returns the file name and line number for the provided Function. ### getTTYfd() Attempts to get a valid TTY file descriptor. Returns `-1` if it fails. The TTY file descriptor is assumed to be capable of being writable. ### hasCrypto * [<boolean>] Indicates whether OpenSSL is available. ### hasFipsCrypto * [<boolean>] Indicates `hasCrypto` and `crypto` with fips. ### hasIntl * [<boolean>] Indicates if [internationalization] is supported. ### hasIPv6 * [<boolean>] Indicates whether `IPv6` is supported on this platform. ### hasMultiLocalhost * [<boolean>] Indicates if there are multiple localhosts available. ### inFreeBSDJail * [<boolean>] Checks whether free BSD Jail is true or false. ### isAIX * [<boolean>] Platform check for Advanced Interactive eXecutive (AIX). ### isAlive(pid) * `pid` [<number>] * return [<boolean>] Attempts to 'kill' `pid` ### isFreeBSD * [<boolean>] Platform check for Free BSD. ### isLinux * [<boolean>] Platform check for Linux. ### isLinuxPPCBE * [<boolean>] Platform check for Linux on PowerPC. ### isOSX * [<boolean>] Platform check for macOS. ### isSunOS * [<boolean>] Platform check for SunOS. ### isWindows * [<boolean>] Platform check for Windows. ### localhostIPv4 * [<string>] IP of `localhost`. ### localIPv6Hosts * [<Array>] Array of IPV6 representations for `localhost`. ### mustCall([fn][, exact]) * `fn` [<Function>] default = () => {} * `exact` [<number>] default = 1 * return [<Function>] Returns a function that calls `fn`. If the returned function has not been called exactly `exact` number of times when the test is complete, then the test will fail. If `fn` is not provided, an empty function will be used. ### mustCallAtLeast([fn][, minimum]) * `fn` [<Function>] default = () => {} * `minimum` [<number>] default = 1 * return [<Function>] Returns a function that calls `fn`. If the returned function has not been called at least `minimum` number of times when the test is complete, then the test will fail. If `fn` is not provided, an empty function will be used. ### mustNotCall([msg]) * `msg` [<string>] default = 'function should not have been called' * return [<Function>] Returns a function that triggers an `AssertionError` if it is invoked. `msg` is used as the error message for the `AssertionError`. ### nodeProcessAborted(exitCode, signal) * `exitCode` [<number>] * `signal` [<string>] * return [<boolean>] 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. ### noWarnCode See `common.expectWarning()` for usage. ### opensslCli * [<boolean>] Indicates whether 'opensslCli' is supported. ### platformTimeout(ms) * `ms` [<number>] * return [<number>] Platform normalizes timeout. ### PIPE * [<string>] Path to the test socket. ### PORT * [<number>] A port number for tests to use if one is needed. ### printSkipMessage(msg) * `msg` [<string>] Logs '1..0 # Skipped: ' + `msg` ### pwdCommand * [<array>] First two argument for the `spawn`/`exec` functions. Platform normalized `pwd` command options. Usage example: ```js const common = require('../common'); const { spawn } = require('child_process'); spawn(...common.pwdCommand, { stdio: ['pipe'] }); ``` ### rootDir * [<string>] Path to the 'root' directory. either `/` or `c:\\` (windows) ### runWithInvalidFD(func) * `func` [<Function>] Runs `func` with an invalid file descriptor that is an unsigned integer and can be used to trigger `EBADF` as the first argument. If no such file descriptor could be generated, a skip message will be printed and the `func` will not be run. ### skip(msg) * `msg` [<string>] Logs '1..0 # Skipped: ' + `msg` and exits with exit code `0`. ### skipIfEslintMissing() Skip the rest of the tests in the current file when `ESLint` is not available at `tools/node_modules/eslint` ### skipIfInspectorDisabled() Skip the rest of the tests in the current file when the Inspector was disabled at compile time. ### skipIf32Bits() Skip the rest of the tests in the current file when the Node.js executable was compiled with a pointer size smaller than 64 bits. ### skipIfWorker() Skip the rest of the tests in the current file when not running on a main thread. ## ArrayStream Module The `ArrayStream` module provides a simple `Stream` that pushes elements from a given array. ```js const ArrayStream = require('../common/arraystream'); const stream = new ArrayStream(); stream.run(['a', 'b', 'c']); ``` It can be used within tests as a simple mock stream. ## Countdown Module The `Countdown` module provides a simple countdown mechanism for tests that require a particular action to be taken after a given number of completed tasks (for instance, shutting down an HTTP server after a specific number of requests). The Countdown will fail the test if the remainder did not reach 0. ```js const Countdown = require('../common/countdown'); function doSomething() { console.log('.'); } const countdown = new Countdown(2, doSomething); countdown.dec(); countdown.dec(); ``` ### new Countdown(limit, callback) * `limit` {number} * `callback` {function} Creates a new `Countdown` instance. ### Countdown.prototype.dec() Decrements the `Countdown` counter. ### Countdown.prototype.remaining Specifies the remaining number of times `Countdown.prototype.dec()` must be called before the callback is invoked. ## DNS Module The `DNS` module provides utilities related to the `dns` built-in module. ### errorLookupMock(code, syscall) * `code` [<string>] Defaults to `dns.mockedErrorCode`. * `syscall` [<string>] Defaults to `dns.mockedSysCall`. * return [<Function>] A mock for the `lookup` option of `net.connect()` that would result in an error with the `code` and the `syscall` specified. Returns a function that has the same signature as `dns.lookup()`. ### mockedErrorCode The default `code` of errors generated by `errorLookupMock`. ### mockedSysCall The default `syscall` of errors generated by `errorLookupMock`. ### readDomainFromPacket(buffer, offset) * `buffer` [<Buffer>] * `offset` [<number>] * return [<Object>] Reads the domain string from a packet and returns an object containing the number of bytes read and the domain. ### parseDNSPacket(buffer) * `buffer` [<Buffer>] * return [<Object>] Parses a DNS packet. Returns an object with the values of the various flags of the packet depending on the type of packet. ### writeIPv6(ip) * `ip` [<string>] * return [<Buffer>] Reads an IPv6 String and returns a Buffer containing the parts. ### writeDomainName(domain) * `domain` [<string>] * return [<Buffer>] Reads a Domain String and returns a Buffer containing the domain. ### writeDNSPacket(parsed) * `parsed` [<Object>] * return [<Buffer>] Takes in a parsed Object and writes its fields to a DNS packet as a Buffer object. ## Duplex pair helper The `common/duplexpair` module exports a single function `makeDuplexPair`, which returns an object `{ clientSide, serverSide }` where each side is a `Duplex` stream connected to the other side. There is no difference between client or server side beyond their names. ## Fixtures Module The `common/fixtures` module provides convenience methods for working with files in the `test/fixtures` directory. ### fixtures.fixturesDir * [<string>] The absolute path to the `test/fixtures/` directory. ### fixtures.path(...args) * `...args` [<string>] Returns the result of `path.join(fixtures.fixturesDir, ...args)`. ### fixtures.readSync(args[, enc]) * `args` [<string>] | [<Array>] Returns the result of `fs.readFileSync(path.join(fixtures.fixturesDir, ...args), 'enc')`. ### fixtures.readKey(arg[, enc]) * `arg` [<string>] Returns the result of `fs.readFileSync(path.join(fixtures.fixturesDir, 'keys', arg), 'enc')`. ## Heap dump checker module This provides utilities for checking the validity of heap dumps. This requires the usage of `--expose-internals`. ### heap.recordState() Create a heap dump and an embedder graph copy for inspection. The returned object has a `validateSnapshotNodes` function similar to the one listed below. (`heap.validateSnapshotNodes(...)` is a shortcut for `heap.recordState().validateSnapshotNodes(...)`.) ### heap.validateSnapshotNodes(name, expected, options) * `name` [<string>] Look for this string as the name of heap dump nodes. * `expected` [<Array>] A list of objects, possibly with an `children` property that points to expected other adjacent nodes. * `options` [<Array>] * `loose` [<boolean>] Do not expect an exact listing of occurrences of nodes with name `name` in `expected`. Create a heap dump and an embedder graph copy and validate occurrences. ```js validateSnapshotNodes('TLSWRAP', [ { children: [ { name: 'enc_out' }, { name: 'enc_in' }, { name: 'TLSWrap' } ] } ]); ``` ## hijackstdio Module The `hijackstdio` module provides utility functions for temporarily redirecting `stdout` and `stderr` output. ```js const { hijackStdout, restoreStdout } = require('../common/hijackstdio'); hijackStdout((data) => { /* Do something with data */ restoreStdout(); }); console.log('this is sent to the hijacked listener'); ``` ### hijackStderr(listener) * `listener` [<Function>]: a listener with a single parameter called `data`. Eavesdrop to `process.stderr.write()` calls. Once `process.stderr.write()` is called, `listener` will also be called and the `data` of `write` function will be passed to `listener`. What's more, `process.stderr.writeTimes` is a count of the number of calls. ### hijackStdout(listener) * `listener` [<Function>]: a listener with a single parameter called `data`. Eavesdrop to `process.stdout.write()` calls. Once `process.stdout.write()` is called, `listener` will also be called and the `data` of `write` function will be passed to `listener`. What's more, `process.stdout.writeTimes` is a count of the number of calls. ### restoreStderr() Restore the original `process.stderr.write()`. Used to restore `stderr` to its original state after calling [`hijackstdio.hijackStdErr()`][]. ### restoreStdout() Restore the original `process.stdout.write()`. Used to restore `stdout` to its original state after calling [`hijackstdio.hijackStdOut()`][]. ## HTTP/2 Module The http2.js module provides a handful of utilities for creating mock HTTP/2 frames for testing of HTTP/2 endpoints ```js const http2 = require('../common/http2'); ``` ### Class: Frame The `http2.Frame` is a base class that creates a `Buffer` containing a serialized HTTP/2 frame header. ```js // length is a 24-bit unsigned integer // type is an 8-bit unsigned integer identifying the frame type // flags is an 8-bit unsigned integer containing the flag bits // id is the 32-bit stream identifier, if any. const frame = new http2.Frame(length, type, flags, id); // Write the frame data to a socket socket.write(frame.data); ``` The serialized `Buffer` may be retrieved using the `frame.data` property. ### Class: DataFrame extends Frame The `http2.DataFrame` is a subclass of `http2.Frame` that serializes a `DATA` frame. ```js // id is the 32-bit stream identifier // payload is a Buffer containing the DATA payload // padlen is an 8-bit integer giving the number of padding bytes to include // final is a boolean indicating whether the End-of-stream flag should be set, // defaults to false. const frame = new http2.DataFrame(id, payload, padlen, final); socket.write(frame.data); ``` ### Class: HeadersFrame The `http2.HeadersFrame` is a subclass of `http2.Frame` that serializes a `HEADERS` frame. ```js // id is the 32-bit stream identifier // payload is a Buffer containing the HEADERS payload (see either // http2.kFakeRequestHeaders or http2.kFakeResponseHeaders). // padlen is an 8-bit integer giving the number of padding bytes to include // final is a boolean indicating whether the End-of-stream flag should be set, // defaults to false. const frame = new http2.HeadersFrame(id, payload, padlen, final); socket.write(frame.data); ``` ### Class: SettingsFrame The `http2.SettingsFrame` is a subclass of `http2.Frame` that serializes an empty `SETTINGS` frame. ```js // ack is a boolean indicating whether or not to set the ACK flag. const frame = new http2.SettingsFrame(ack); socket.write(frame.data); ``` ### http2.kFakeRequestHeaders Set to a `Buffer` instance that contains a minimal set of serialized HTTP/2 request headers to be used as the payload of a `http2.HeadersFrame`. ```js const frame = new http2.HeadersFrame(1, http2.kFakeRequestHeaders, 0, true); socket.write(frame.data); ``` ### http2.kFakeResponseHeaders Set to a `Buffer` instance that contains a minimal set of serialized HTTP/2 response headers to be used as the payload a `http2.HeadersFrame`. ```js const frame = new http2.HeadersFrame(1, http2.kFakeResponseHeaders, 0, true); socket.write(frame.data); ``` ### http2.kClientMagic Set to a `Buffer` containing the preamble bytes an HTTP/2 client must send upon initial establishment of a connection. ```js socket.write(http2.kClientMagic); ``` ## Internet Module The `common/internet` module provides utilities for working with internet-related tests. ### internet.addresses * [<Object>] * `INET_HOST` [<string>] A generic host that has registered common DNS records, supports both IPv4 and IPv6, and provides basic HTTP/HTTPS services * `INET4_HOST` [<string>] A host that provides IPv4 services * `INET6_HOST` [<string>] A host that provides IPv6 services * `INET4_IP` [<string>] An accessible IPv4 IP, defaults to the Google Public DNS IPv4 address * `INET6_IP` [<string>] An accessible IPv6 IP, defaults to the Google Public DNS IPv6 address * `INVALID_HOST` [<string>] An invalid host that cannot be resolved * `MX_HOST` [<string>] A host with MX records registered * `SRV_HOST` [<string>] A host with SRV records registered * `PTR_HOST` [<string>] A host with PTR records registered * `NAPTR_HOST` [<string>] A host with NAPTR records registered * `SOA_HOST` [<string>] A host with SOA records registered * `CNAME_HOST` [<string>] A host with CNAME records registered * `NS_HOST` [<string>] A host with NS records registered * `TXT_HOST` [<string>] A host with TXT records registered * `DNS4_SERVER` [<string>] An accessible IPv4 DNS server * `DNS6_SERVER` [<string>] An accessible IPv6 DNS server A set of addresses for internet-related tests. All properties are configurable via `NODE_TEST_*` environment variables. For example, to configure `internet.addresses.INET_HOST`, set the environment variable `NODE_TEST_INET_HOST` to a specified host. ## ongc Module The `ongc` module allows a garbage collection listener to be installed. The module exports a single `onGC()` function. ```js require('../common'); const onGC = require('../common/ongc'); onGC({}, { ongc() { console.log('collected'); } }); ``` ### onGC(target, listener) * `target` [<Object>] * `listener` [<Object>] * `ongc` [<Function>] Installs a GC listener for the collection of `target`. This uses `async_hooks` for GC tracking. This means that it enables `async_hooks` tracking, which may affect the test functionality. It also means that between a `global.gc()` call and the listener being invoked a full `setImmediate()` invocation passes. `listener` is an object to make it easier to use a closure; the target object should not be in scope when `listener.ongc()` is created. ## tick Module The `tick` module provides a helper function that can be used to call a callback after a given number of event loop "ticks". ### tick(x, cb) * `x` [<number>] Number of event loop "ticks". * `cb` [<Function>] A callback function. ## tmpdir Module The `tmpdir` module supports the use of a temporary directory for testing. ### path * [<string>] The realpath of the testing temporary directory. ### refresh() Deletes and recreates the testing temporary directory. ## WPT Module The wpt.js module is a port of parts of [W3C testharness.js](https://github.com/w3c/testharness.js) for testing the Node.js [WHATWG URL API](https://nodejs.org/api/url.html#url_the_whatwg_url_api) implementation with tests from [W3C Web Platform Tests](https://github.com/w3c/web-platform-tests). [<Array>]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array [<ArrayBufferView[]>]: https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView [<Buffer>]: https://nodejs.org/api/buffer.html#buffer_class_buffer [<Function>]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function [<Object>]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object [<RegExp>]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp [<boolean>]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type [<number>]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type [<string>]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type [`hijackstdio.hijackStdErr()`]: #hijackstderrlistener [`hijackstdio.hijackStdOut()`]: #hijackstdoutlistener [internationalization]: https://github.com/nodejs/node/wiki/Intl function forEach (xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } } readable-stream-3.6.0/test/common/arraystream.js000066400000000000000000000021461362132315000217060ustar00rootroot00000000000000"use strict"; /**/ require('@babel/polyfill'); var util = require('util'); 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); } return keys; }; /**/ var _require = require('../../'), 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; ArrayStream.prototype.writable = true; 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); } }readable-stream-3.6.0/test/common/benchmark.js000066400000000000000000000035101362132315000213020ustar00rootroot00000000000000"use strict"; /**/ require('@babel/polyfill'); var util = require('util'); 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); } 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, { env: mergedEnv, stdio: ['inherit', 'pipe', 'inherit', 'ipc'] }); child.stdout.setEncoding('utf8'); var stdout = ''; child.stdout.on('data', function (line) { stdout += line; }); 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 // 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); } }readable-stream-3.6.0/test/common/countdown.js000066400000000000000000000036501362132315000213750ustar00rootroot00000000000000"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; } /**/ require('@babel/polyfill'); var util = require('util'); 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); } return keys; }; /**/ var assert = require('assert'); var kLimit = Symbol('limit'); var kCallback = Symbol('callback'); var common = require('./'); 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() { assert(this[kLimit] > 0, 'Countdown expired'); if (--this[kLimit] === 0) this[kCallback](); return this[kLimit]; } }, { key: "remaining", get: function get() { 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); } }readable-stream-3.6.0/test/common/dns.js000066400000000000000000000323041362132315000201370ustar00rootroot00000000000000"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 _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 */ 'use strict'; /**/ var objectKeys = objectKeys || function (obj) { var keys = []; for (var key in obj) { keys.push(key); } return keys; }; /**/ var assert = require('assert'); var os = require('os'); var types = { A: 1, AAAA: 28, NS: 2, CNAME: 5, SOA: 6, PTR: 12, MX: 15, TXT: 16, ANY: 255 }; var classes = { IN: 1 }; // Naïve DNS parser/serializer. function readDomainFromPacket(buffer, offset) { assert.ok(offset < buffer.length); var length = buffer[offset]; if (length === 0) { return { nread: 1, domain: '' }; } else if ((length & 0xC0) === 0) { offset += 1; 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; 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 var pointeeOffset = buffer.readUInt16BE(offset) & ~0xC000; return { nread: 2, domain: readDomainFromPacket(buffer, pointeeOffset) }; } } function parseDNSPacket(buffer) { assert.ok(buffer.length > 12); var parsed = { id: buffer.readUInt16BE(0), flags: buffer.readUInt16BE(2) }; 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]; parsed[sectionName] = []; for (var _i2 = 0; _i2 < count; ++_i2) { var _readDomainFromPacket2 = readDomainFromPacket(buffer, offset), nread = _readDomainFromPacket2.nread, domain = _readDomainFromPacket2.domain; offset += nread; var type = buffer.readUInt16BE(offset); var rr = { domain: domain, 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; 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; rr.value = _domain2; assert.strictEqual(_nread2, dataLength); break; } case types.SOA: { var mname = readDomainFromPacket(buffer, offset); var rname = readDomainFromPacket(buffer, offset + mname.nread); rr.nsname = mname.domain; rr.hostmaster = rname.domain; var trailerOffset = offset + mname.nread + rname.nread; rr.serial = buffer.readUInt32BE(trailerOffset); rr.refresh = buffer.readUInt32BE(trailerOffset + 4); rr.retry = buffer.readUInt32BE(trailerOffset + 8); rr.expire = buffer.readUInt32BE(trailerOffset + 12); rr.minttl = buffer.readUInt32BE(trailerOffset + 16); 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; try { for (var _iterator = parts[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { var part = _step.value; if (part === '') { offset += 16 - 2 * (parts.length - 1); } else { buf.writeUInt16BE(parseInt(part, 16), offset); offset += 2; } } } catch (err) { _didIteratorError = true; _iteratorError = err; } finally { try { if (!_iteratorNormalCompletion && _iterator.return != null) { _iterator.return(); } } finally { if (_didIteratorError) { throw _iteratorError; } } } 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; try { for (var _iterator2 = parsed.questions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { 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; } finally { try { if (!_iteratorNormalCompletion2 && _iterator2.return != null) { _iterator2.return(); } } finally { if (_didIteratorError2) { throw _iteratorError2; } } } var _iteratorNormalCompletion3 = true; var _didIteratorError3 = false; var _iteratorError3 = undefined; try { for (var _iterator3 = [].concat(parsed.answers, parsed.authorityAnswers, parsed.additionalRecords)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { var rr = _step3.value; if (!rr) continue; assert(types[rr.type]); buffers.push(writeDomainName(rr.domain)); buffers.push(new Uint16Array([types[rr.type], rr.cls === undefined ? classes.IN : rr.cls])); 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. rdLengthBuf[0] = rr.entries.length + total; var _iteratorNormalCompletion4 = true; var _didIteratorError4 = false; var _iteratorError4 = undefined; try { for (var _iterator4 = rr.entries[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) { var txt = _step4.value; buffers.push(new Uint8Array([Buffer.byteLength(txt)])); buffers.push(Buffer.from(txt)); } } catch (err) { _didIteratorError4 = true; _iteratorError4 = err; } finally { try { if (!_iteratorNormalCompletion4 && _iterator4.return != null) { _iterator4.return(); } } finally { if (_didIteratorError4) { throw _iteratorError4; } } } break; case 'MX': rdLengthBuf[0] = 2; buffers.push(new Uint16Array([rr.priority])); // fall through case 'NS': case 'CNAME': case 'PTR': { var domain = writeDomainName(rr.exchange || rr.value); rdLengthBuf[0] += domain.length; buffers.push(domain); break; } case 'SOA': { var mname = writeDomainName(rr.nsname); var rname = writeDomainName(rr.hostmaster); rdLengthBuf[0] = mname.length + rname.length + 20; buffers.push(mname, rname); 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; } finally { try { if (!_iteratorNormalCompletion3 && _iterator3.return != null) { _iterator3.return(); } } finally { if (_didIteratorError3) { throw _iteratorError3; } } } 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; return function lookupWithError(hostname, dnsopts, cb) { var err = new Error("".concat(syscall, " ").concat(code, " ").concat(hostname)); err.code = code; err.errno = code; err.syscall = syscall; err.hostname = hostname; cb(err); }; } module.exports = { types: types, classes: classes, writeDNSPacket: writeDNSPacket, parseDNSPacket: parseDNSPacket, errorLookupMock: errorLookupMock, mockedErrorCode: mockedErrorCode, mockedSysCall: mockedSysCall }; function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } }readable-stream-3.6.0/test/common/duplexpair.js000066400000000000000000000073131362132315000215320ustar00rootroot00000000000000"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 _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); } /**/ require('@babel/polyfill'); var util = require('util'); 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); } return keys; }; /**/ var _require = require('../../'), Duplex = _require.Duplex; var assert = require('assert'); var kCallback = Symbol('Callback'); var kOtherSide = Symbol('Other'); var DuplexSocket = /*#__PURE__*/ function (_Duplex) { _inherits(DuplexSocket, _Duplex); function DuplexSocket() { var _this; _classCallCheck(this, DuplexSocket); _this = _possibleConstructorReturn(this, _getPrototypeOf(DuplexSocket).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(); } } }, { key: "_write", value: function _write(chunk, encoding, callback) { assert.notStrictEqual(this[kOtherSide], null); assert.strictEqual(this[kOtherSide][kCallback], null); this[kOtherSide][kCallback] = callback; this[kOtherSide].push(chunk); } }, { key: "_final", value: function _final(callback) { this[kOtherSide].on('end', callback); this[kOtherSide].push(null); } }]); return DuplexSocket; }(Duplex); function makeDuplexPair() { var clientSide = new DuplexSocket(); var serverSide = new DuplexSocket(); clientSide[kOtherSide] = serverSide; serverSide[kOtherSide] = clientSide; return { clientSide: clientSide, serverSide: serverSide }; } module.exports = makeDuplexPair; function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } }readable-stream-3.6.0/test/common/fixtures.js000066400000000000000000000034261362132315000212270ustar00rootroot00000000000000"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; } } /**/ require('@babel/polyfill'); var util = require('util'); 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); } 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); } }readable-stream-3.6.0/test/common/heap.js000066400000000000000000000230531362132315000202710ustar00rootroot00000000000000"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; } /**/ require('@babel/polyfill'); var util = require('util'); 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); } 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; function inspectNode(snapshot) { return util.inspect(snapshot, { depth: 4 }); } function isEdge(edge, _ref) { var node_name = _ref.node_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. // if (edge.name !== edge_name) { // return false; // } // From our internal embedded graph if (edge.to.value) { if (edge.to.value.constructor.name !== node_name) { return false; } } else if (edge.to.name !== node_name) { return false; } return true; } var State = /*#__PURE__*/ function () { function State() { _classCallCheck(this, State); this.snapshot = createJSHeapDump(); this.embedderGraph = buildEmbedderGraph(); } // 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; 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; try { for (var _iterator = expected[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { var expectation = _step.value; if (expectation.children) { var _iteratorNormalCompletion2 = true; var _didIteratorError2 = false; var _iteratorError2 = undefined; try { var _loop = function _loop() { var expectedEdge = _step2.value; var check = typeof expectedEdge === 'function' ? expectedEdge : function (edge) { return isEdge(edge, expectedEdge); }; var hasChild = rootNodes.some(function (node) { return node.outgoingEdges.some(check); }); // 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) { _loop(); } } catch (err) { _didIteratorError2 = true; _iteratorError2 = err; } finally { try { if (!_iteratorNormalCompletion2 && _iterator2.return != null) { _iterator2.return(); } } finally { if (_didIteratorError2) { throw _iteratorError2; } } } } } } catch (err) { _didIteratorError = true; _iteratorError = err; } finally { try { if (!_iteratorNormalCompletion && _iterator.return != null) { _iterator.return(); } } finally { if (_didIteratorError) { throw _iteratorError; } } } } // 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; 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; try { for (var _iterator3 = expected[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { var expectation = _step3.value; if (expectation.children) { var _iteratorNormalCompletion4 = true; var _didIteratorError4 = false; var _iteratorError4 = undefined; 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 // 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) { _loop2(); } } catch (err) { _didIteratorError4 = true; _iteratorError4 = err; } finally { try { if (!_iteratorNormalCompletion4 && _iterator4.return != null) { _iterator4.return(); } } finally { if (_didIteratorError4) { throw _iteratorError4; } } } } } } catch (err) { _didIteratorError3 = true; _iteratorError3 = err; } finally { try { if (!_iteratorNormalCompletion3 && _iterator3.return != null) { _iterator3.return(); } } finally { if (_didIteratorError3) { throw _iteratorError3; } } } } }, { 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; this.validateSnapshot(rootName, expected, { loose: loose }); this.validateGraph(rootName, expected, { loose: loose }); } }]); 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); } }readable-stream-3.6.0/test/common/hijackstdio.js000066400000000000000000000024061362132315000216470ustar00rootroot00000000000000"use strict"; /**/ require('@babel/polyfill'); var util = require('util'); 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); } return keys; }; /**/ // 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); } catch (e) { process.nextTick(function () { 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); } }readable-stream-3.6.0/test/common/http2.js000066400000000000000000000171331362132315000204170ustar00rootroot00000000000000"use strict"; function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } 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 _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; } /**/ require('@babel/polyfill'); var util = require('util'); 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); } 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; var FLAG_EOH = 0x4; var FLAG_PADDED = 0x8; 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; array[pos++] = val >> 16 & 0xff; 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 () { 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) { _inherits(SettingsFrame, _Frame); 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 SettingsFrame; }(Frame); var DataFrame = /*#__PURE__*/ function (_Frame2) { _inherits(DataFrame, _Frame2); 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)); buffers.unshift(_this[kFrameData]); _this[kFrameData] = Buffer.concat(buffers); return _this; } return DataFrame; }(Frame); var HeadersFrame = /*#__PURE__*/ function (_Frame3) { _inherits(HeadersFrame, _Frame3); 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)); buffers.unshift(_this2[kFrameData]); _this2[kFrameData] = Buffer.concat(buffers); return _this2; } return HeadersFrame; }(Frame); var PingFrame = /*#__PURE__*/ function (_Frame4) { _inherits(PingFrame, _Frame4); 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)); buffers.unshift(_this3[kFrameData]); _this3[kFrameData] = Buffer.concat(buffers); return _this3; } return PingFrame; }(Frame); var AltSvcFrame = /*#__PURE__*/ function (_Frame5) { _inherits(AltSvcFrame, _Frame5); function AltSvcFrame(size) { var _this4; _classCallCheck(this, AltSvcFrame); var buffers = [Buffer.alloc(size)]; _this4 = _possibleConstructorReturn(this, _getPrototypeOf(AltSvcFrame).call(this, size, 10, 0, 0)); buffers.unshift(_this4[kFrameData]); _this4[kFrameData] = Buffer.concat(buffers); return _this4; } return AltSvcFrame; }(Frame); module.exports = { Frame: Frame, AltSvcFrame: AltSvcFrame, DataFrame: DataFrame, HeadersFrame: HeadersFrame, SettingsFrame: SettingsFrame, PingFrame: PingFrame, kFakeRequestHeaders: kFakeRequestHeaders, kFakeResponseHeaders: kFakeResponseHeaders, kClientMagic: kClientMagic }; function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } }readable-stream-3.6.0/test/common/index.js000066400000000000000000000723311362132315000204660ustar00rootroot00000000000000"use strict"; 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; } } /**/ require('@babel/polyfill'); var util = require('util'); 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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. /* 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); } 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; /**/ 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; 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. return true; }(); // 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; var buffer = Buffer.allocUnsafe(bytesToRead); var fd = fs.openSync(module.parent.filename, 'r'); var bytesRead = fs.readSync(fd, buffer, 0, bytesToRead); 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. 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; try { for (var _iterator = flags[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { var flag = _step.value; 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 // 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; } finally { try { if (!_iteratorNormalCompletion && _iterator.return != null) { _iterator.return(); } } finally { if (_didIteratorError) { throw _iteratorError; } } } } } var isWindows = process.platform === 'win32'; var isAIX = process.platform === 'aix'; var isLinuxPPCBE = process.platform === 'linux' && process.arch === 'ppc64' && os.endianness() === 'BE'; var isSunOS = process.platform === 'sunos'; 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 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. if (process.env.NODE_TEST_WITH_ASYNC_HOOKS) { var destroydIdsList = {}; var destroyListList = {}; var initHandles = {}; 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]); } }); 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]) { process._rawDebug( `Is same resource: ${r === initHandles[id].resource}`); process._rawDebug(`Previous stack:\n${initHandles[id].stack}\n`); throw new Error(`init called twice for same id (${id})`); } initHandles[id] = { resource: r, stack: new Error().stack.substr(6) }; }, before() { }, after() { }, destroy(id) { if (destroydIdsList[id] !== undefined) { process._rawDebug(destroydIdsList[id]); process._rawDebug(); throw new Error(`destroy called for same id (${id})`); } 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 '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/; return objectKeys(iFaces).some(function (name) { return re.test(name) && iFaces[name].some(function (_ref) { var family = _ref.family; return family === 'IPv6'; }); }); }(); /* * 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); child.on('exit', function onExit(exitCode, signal) { var errMsg = 'Test should have aborted ' + "but instead exited with exit code ".concat(exitCode) + " and signal ".concat(signal); 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; if (isAIX) return 2 * ms; // default localhost speed is slower on AIX if (process.arch !== 'arm') return ms; var armv = process.config.variables.arm_version; if (armv === '6') return 7 * ms; // ARMv6 if (armv === '7') return 2 * ms; // ARMv7 return ms; // ARMv8+ } 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); knownGlobals.push(DTRACE_HTTP_CLIENT_RESPONSE); knownGlobals.push(DTRACE_HTTP_CLIENT_REQUEST); 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); knownGlobals.push(COUNTER_HTTP_SERVER_REQUEST); knownGlobals.push(COUNTER_HTTP_SERVER_RESPONSE); 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); if (global.__coverage__) knownGlobals.push(__coverage__); 'console,clearImmediate,setImmediate,core,__core-js_shared__,Promise,Map,Set,WeakMap,WeakSet,Reflect,System,queueMicrotask,asap,Observable,regeneratorRuntime,_babelPolyfill'.split(',').filter(function (item) { 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); }); } else { 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) { if ('minimum' in context) { context.messageSegment = "at least ".concat(context.minimum); return context.actual < context.minimum; } else { context.messageSegment = "exactly ".concat(context.exact); return context.actual !== context.exact; } }); forEach(failed, function (context) { console.log('Mismatched %s function calls. Expected %s, actual %d.', context.name, context.messageSegment, context.actual); console.log(context.stack.split('\n').slice(2).join('\n')); }); 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 if (mustCallChecks.length === 0) process.on('exit', runCallChecks); mustCallChecks.push(context); return function () { context.actual++; return fn.apply(this, arguments); }; } function hasMultiLocalhost() { var _process$binding2 = process.binding('tcp_wrap'), 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. // On other platforms, creating symlinks shouldn't need admin privileges if (isWindows) { // whoami.exe needs to be the one from System32 // 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 }); return output.includes('SeCreateSymbolicLinkPrivilege'); } catch (_e) { return false; } } // 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 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" // 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), // 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']; // 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]; // 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'); return true; } catch (_unused) { 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 // 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 // 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); } else { expectWarningByMap(nameOrMap); } } var Comparison = function Comparison(obj, keys) { _classCallCheck(this, Comparison); var _iteratorNormalCompletion2 = true; var _didIteratorError2 = false; var _iteratorError2 = undefined; try { for (var _iterator2 = keys[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { var key = _step2.value; if (key in obj) this[key] = obj[key]; } } catch (err) { _didIteratorError2 = true; _iteratorError2 = err; } finally { try { if (!_iteratorNormalCompletion2 && _iterator2.return != null) { _iterator2.return(); } } finally { if (_didIteratorError2) { throw _iteratorError2; } } } }; // 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 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. 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.message = error.message; } // Check all error properties. var keys = objectKeys(settings); var _iteratorNormalCompletion3 = true; var _didIteratorError3 = false; var _iteratorError3 = undefined; try { for (var _iterator3 = keys[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { 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); var b = new Comparison(innerSettings, keys); var tmpLimit = Error.stackTraceLimit; Error.stackTraceLimit = 0; var err = new assert.AssertionError({ actual: a, expected: b, operator: 'strictEqual', stackStartFn: assert.throws }); Error.stackTraceLimit = tmpLimit; throw new assert.AssertionError({ actual: error, expected: settings, operator: 'common.expectsError', message: err.message }); } } } catch (err) { _didIteratorError3 = true; _iteratorError3 = err; } finally { try { if (!_iteratorNormalCompletion3 && _iterator3.return != null) { _iterator3.return(); } } finally { if (_didIteratorError3) { throw _iteratorError3; } } } 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; 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; 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. 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. // Ref: ef2861961c3d9e9ed6972e1e84d969683b25cf95 var ttyFd = [1, 2, 4, 5].find(tty.isatty); if (ttyFd === undefined) { try { return fs.openSync('/dev/tty'); } catch (_unused2) { // There aren't any tty fd's available to use. return -1; } } return ttyFd; } function runWithInvalidFD(func) { 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) { ; } } catch (_unused3) { return func(fd); } printSkipMessage('Could not generate an invalid fd'); } module.exports = { allowGlobals: allowGlobals, buildType: buildType, busyLoop: busyLoop, canCreateSymLink: canCreateSymLink, childShouldThrowAndAbort: childShouldThrowAndAbort, createZeroFilledFile: createZeroFilledFile, disableCrashOnUnhandledRejection: disableCrashOnUnhandledRejection, enoughTestCpu: enoughTestCpu, enoughTestMem: enoughTestMem, expectsError: expectsError, expectWarning: expectWarning, getArrayBufferViews: getArrayBufferViews, getBufferSources: getBufferSources, getCallSite: getCallSite, getTTYfd: getTTYfd, hasIntl: hasIntl, hasCrypto: hasCrypto, hasIPv6: hasIPv6, hasMultiLocalhost: hasMultiLocalhost, isAIX: isAIX, isAlive: isAlive, isFreeBSD: isFreeBSD, isLinux: isLinux, isLinuxPPCBE: isLinuxPPCBE, isMainThread: isMainThread, isOpenBSD: isOpenBSD, isOSX: isOSX, isSunOS: isSunOS, isWindows: isWindows, localIPv6Hosts: localIPv6Hosts, mustCall: mustCall, mustCallAtLeast: mustCallAtLeast, mustNotCall: mustNotCall, nodeProcessAborted: nodeProcessAborted, noWarnCode: undefined, PIPE: PIPE, platformTimeout: platformTimeout, printSkipMessage: printSkipMessage, pwdCommand: pwdCommand, rootDir: rootDir, runWithInvalidFD: runWithInvalidFD, skip: skip, skipIf32Bits: skipIf32Bits, 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 // user will provide this instead. if (process.env.LOCALHOST) { localhostIPv4 = process.env.LOCALHOST; } else { 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'; } else { // 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); } }readable-stream-3.6.0/test/common/index.mjs000066400000000000000000000034641362132315000206440ustar00rootroot00000000000000/**/ require('@babel/polyfill'); var util = require('util'); for (var i in util) exports[i] = util[i]; /**/// Flags: --experimental-modules /* eslint-disable node-core/required-modules */ import common from './index.js'; const { isMainThread, isWindows, isAIX, isLinuxPPCBE, isSunOS, isFreeBSD, isOpenBSD, isLinux, isOSX, enoughTestMem, enoughTestCpu, rootDir, buildType, localIPv6Hosts, opensslCli, PIPE, hasIPv6, childShouldThrowAndAbort, createZeroFilledFile, platformTimeout, allowGlobals, mustCall, mustCallAtLeast, hasMultiLocalhost, skipIfEslintMissing, canCreateSymLink, getCallSite, mustNotCall, printSkipMessage, skip, ArrayStream, nodeProcessAborted, busyLoop, isAlive, noWarnCode, expectWarning, expectsError, skipIfInspectorDisabled, skipIf32Bits, getArrayBufferViews, getBufferSources, disableCrashOnUnhandledRejection, getTTYfd, runWithInvalidFD } = common; export { isMainThread, isWindows, isAIX, isLinuxPPCBE, isSunOS, isFreeBSD, isOpenBSD, isLinux, isOSX, enoughTestMem, enoughTestCpu, rootDir, buildType, localIPv6Hosts, opensslCli, PIPE, hasIPv6, childShouldThrowAndAbort, createZeroFilledFile, platformTimeout, allowGlobals, mustCall, mustCallAtLeast, hasMultiLocalhost, skipIfEslintMissing, canCreateSymLink, getCallSite, mustNotCall, printSkipMessage, skip, ArrayStream, nodeProcessAborted, busyLoop, isAlive, noWarnCode, expectWarning, expectsError, skipIfInspectorDisabled, skipIf32Bits, getArrayBufferViews, getBufferSources, disableCrashOnUnhandledRejection, getTTYfd, runWithInvalidFD }; function forEach (xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } } readable-stream-3.6.0/test/common/inspector-helper.js000066400000000000000000000574701362132315000226510ustar00rootroot00000000000000"use strict"; function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } 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 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; } /**/ require('@babel/polyfill'); var util = require('util'); 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); } 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; var _require2 = require('url'), parseURL = _require2.parse; var _require3 = require('internal/url'), pathToFileURL = _require3.pathToFileURL; var _require4 = require('events'), 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); process.on('uncaughtException', handler); common.disableCrashOnUnhandledRejection(); process.on('unhandledRejection', handler); process.on('SIGINT', handler); return child; } function makeBufferingDataCallback(dataCallback) { var buffer = Buffer.alloc(0); return function (data) { var newData = Buffer.concat([buffer, data]); 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; try { for (var _iterator = lines[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { var line = _step.value; dataCallback(line); } } catch (err) { _didIteratorError = true; _iteratorError = err; } finally { try { if (!_iteratorNormalCompletion && _iterator.return != null) { _iterator.return(); } } finally { if (_didIteratorError) { throw _iteratorError; } } } }; } 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; if (buffer.length < 2) return { length: 0, message: message }; if (buffer[0] === 0x88 && buffer[1] === 0x00) { return { length: 2, message: message, 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; } else if (dataLen === 127) { assert(buffer[2] === 0 && buffer[3] === 0, 'Inspector message too big'); 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); wsHeaderBuf.writeUInt8(0x81, 0); var byte2 = 0x80; var bodyLen = messageBuf.length; var maskOffset = 2; if (bodyLen < 126) { byte2 = 0x80 + bodyLen; } else if (bodyLen < 65536) { byte2 = 0xFE; wsHeaderBuf.writeUInt16BE(bodyLen, 2); maskOffset = 4; } else { byte2 = 0xFF; wsHeaderBuf.writeUInt32BE(bodyLen, 2); 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; } return Buffer.concat([wsHeaderBuf.slice(0, maskOffset + 4), messageBuf]); } var InspectorSession = /*#__PURE__*/ function () { function InspectorSession(socket, instance) { var _this = this; _classCallCheck(this, InspectorSession); this._instance = instance; this._socket = socket; this._nextId = 1; this._commandResponsePromises = new Map(); this._unprocessedNotifications = []; this._notificationCallback = null; this._scriptsIdsByUrl = new Map(); 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; if (!length) break; if (closed) { socket.write(Buffer.from([0x88, 0x00])); // WS close frame } buffer = buffer.slice(length); if (message) _this._onMessage(message); } while (true); }); this._terminationPromise = new Promise(function (resolve) { socket.once('close', resolve); }); } _createClass(InspectorSession, [{ key: "waitForServerDisconnect", value: function waitForServerDisconnect() { return this._terminationPromise; } }, { key: "disconnect", value: function () { var _disconnect = _asyncToGenerator(function* () { this._socket.destroy(); return this.waitForServerDisconnect(); }); function disconnect() { return _disconnect.apply(this, arguments); } return disconnect; }() }, { key: "_onMessage", value: function _onMessage(message) { if (message.id) { var _this$_commandRespons = this._commandResponsePromises.get(message.id), 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; 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; this._notificationCallback = null; callback(message); } else { this._unprocessedNotifications.push(message); } } } }, { 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) { _this2._commandResponsePromises.set(msg.id, { resolve: resolve, reject: reject }); }); return new Promise(function (resolve) { return _this2._socket.write(formatWSFrame(msg), resolve); }).then(function () { return responsePromise; }); } }, { 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. return Promise.all(commands.map(function (command) { return _this3._sendMessage(command); })).then(function () {}); } else { return this._sendMessage(commands); } } }, { key: "waitForNotification", value: function waitForNotification(methodOrPredicate, description) { var desc = description || methodOrPredicate; var message = "Timed out waiting for matching notification (".concat(desc, "))"); return fires(this._asyncWaitForNotification(methodOrPredicate), message, TIMEOUT); } }, { key: "_asyncWaitForNotification", 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(); } else { notification = yield new Promise(function (resolve) { return _this4._notificationCallback = resolve; }); } } while (!predicate(notification)); return notification; }); function _asyncWaitForNotification(_x) { return _asyncWaitForNotification2.apply(this, arguments); } return _asyncWaitForNotification; }() }, { key: "_isBreakOnLineNotification", value: function _isBreakOnLineNotification(message, line, expectedScriptPath) { 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; } } }, { 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)); } }, { 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; try { for (var _iterator2 = params.args[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { var value = _step2.value; if (value.value !== values[_i2++]) return false; } } catch (err) { _didIteratorError2 = true; _iteratorError2 = err; } finally { try { if (!_iteratorNormalCompletion2 && _iterator2.return != null) { _iterator2.return(); } } finally { if (_didIteratorError2) { throw _iteratorError2; } } } return _i2 === values.length; } } } }, { 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); }, desc); } }, { key: "runToCompletion", value: function () { var _runToCompletion = _asyncToGenerator(function* () { console.log('[test]', 'Verify node waits for the frontend to disconnect'); yield this.send({ 'method': 'Debugger.resume' }); 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...') { ; } yield this.disconnect(); }); function runToCompletion() { return _runToCompletion.apply(this, arguments); } return runToCompletion; }() }, { key: "scriptPath", value: function scriptPath() { return this._instance.scriptPath(); } }, { key: "script", value: function script() { return this._instance.script(); } }, { key: "scriptURL", value: function scriptURL() { return pathToFileURL(this.scriptPath()); } }]); return InspectorSession; }(); var NodeInstance = /*#__PURE__*/ function (_EventEmitter) { _inherits(NodeInstance, _EventEmitter); 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._scriptPath = scriptFile; _this7._script = scriptFile ? null : scriptContents; _this7._portCallback = null; _this7.portPromise = new Promise(function (resolve) { return _this7._portCallback = resolve; }); _this7._process = spawnChildProcess(inspectorFlags, scriptContents, scriptFile); _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({ exitCode: exitCode, signal: signal }); _this7._running = false; }); }); 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); } } }, { key: "httpGet", value: function httpGet(host, path, hostHeaderValue) { console.log('[test]', "Testing ".concat(path)); var headers = hostHeaderValue ? { 'Host': hostHeaderValue } : null; return this.portPromise.then(function (port) { return new Promise(function (resolve, reject) { var req = http.get({ host: host, port: port, path: path, headers: headers }, function (res) { var response = ''; res.setEncoding('utf8'); res.on('data', function (data) { return response += data.toString(); }).on('end', function () { resolve(response); }); }); req.on('error', reject); }); }).then(function (response) { try { return JSON.parse(response); } catch (e) { e.body = response; throw e; } }); } }, { key: "sendUpgradeRequest", value: function () { var _sendUpgradeRequest = _asyncToGenerator(function* () { var response = yield this.httpGet(null, '/json/list'); var devtoolsUrl = response[0].webSocketDebuggerUrl; var port = yield this.portPromise; return http.get({ port: port, path: parseURL(devtoolsUrl).path, headers: { 'Connection': 'Upgrade', 'Upgrade': 'websocket', 'Sec-WebSocket-Version': 13, 'Sec-WebSocket-Key': 'key==' } }); }); function sendUpgradeRequest() { return _sendUpgradeRequest.apply(this, arguments); } return sendUpgradeRequest; }() }, { key: "connectInspectorSession", 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) { upgradeRequest.on('upgrade', function (message, socket) { return resolve(new InspectorSession(socket, _this8)); }).on('response', common.mustNotCall('Upgrade was not received')); }); }); function connectInspectorSession() { return _connectInspectorSession.apply(this, arguments); } return connectInspectorSession; }() }, { key: "expectConnectionDeclined", value: function () { var _expectConnectionDeclined = _asyncToGenerator(function* () { console.log('[test]', 'Checking upgrade is not possible'); var upgradeRequest = yield this.sendUpgradeRequest(); return new Promise(function (resolve) { upgradeRequest.on('upgrade', common.mustNotCall('Upgrade was received')).on('response', function (response) { return response.on('data', function () {}).on('end', function () { return resolve(response.statusCode); }); }); }); }); function expectConnectionDeclined() { return _expectConnectionDeclined.apply(this, arguments); } return expectConnectionDeclined; }() }, { key: "expectShutdown", value: function expectShutdown() { return this._shutdownPromise; } }, { 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; }); } }, { key: "write", value: function write(message) { this._process.stdin.write(message); } }, { key: "kill", value: function kill() { this._process.kill(); return this.expectShutdown(); } }, { key: "scriptPath", value: function scriptPath() { return this._scriptPath; } }, { key: "script", value: function script() { if (this._script === null) this._script = fs.readFileSync(this.scriptPath(), 'utf8'); return this._script; } }], [{ key: "startViaSignal", value: function () { 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(); return result; }, function (error) { callback(); throw error; }); } function timeoutPromise(error, timeoutMs) { var clearCallback = null; var done = false; var promise = onResolvedOrRejected(new Promise(function (resolve, reject) { var timeout = setTimeout(function () { return reject(error); }, timeoutMs); clearCallback = function clearCallback() { if (done) return; clearTimeout(timeout); resolve(); }; }), function () { return done = true; }); promise.clear = clearCallback; return promise; } // Returns a new promise that will propagate `promise` resolution or rejection // if that happens within the `timeoutMs` timespan, or rejects with `error` as // a reason otherwise. function fires(promise, error, timeoutMs) { var timeout = timeoutPromise(error, timeoutMs); return Promise.race([onResolvedOrRejected(promise, function () { return timeout.clear(); }), timeout]); } module.exports = { NodeInstance: NodeInstance }; function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } }readable-stream-3.6.0/test/common/internet.js000066400000000000000000000051411362132315000212020ustar00rootroot00000000000000"use strict"; /**/ require('@babel/polyfill'); var util = require('util'); 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); } return keys; }; /**/ // Utilities for internet-related tests var addresses = { // A generic host that has registered common DNS records, // supports both IPv4 and IPv6, and provides basic HTTP/HTTPS services INET_HOST: 'nodejs.org', // A host that provides IPv4 services INET4_HOST: 'nodejs.org', // A host that provides IPv6 services INET6_HOST: 'nodejs.org', // An accessible IPv4 IP, // defaults to the Google Public DNS IPv4 address INET4_IP: '8.8.8.8', // An accessible IPv6 IP, // defaults to the Google Public DNS IPv6 address INET6_IP: '2001:4860:4860::8888', // An invalid host that cannot be resolved // See https://tools.ietf.org/html/rfc2606#section-2 INVALID_HOST: 'something.invalid', // A host with MX records registered MX_HOST: 'nodejs.org', // A host with SRV records registered SRV_HOST: '_jabber._tcp.google.com', // A host with PTR records registered PTR_HOST: '8.8.8.8.in-addr.arpa', // A host with NAPTR records registered NAPTR_HOST: 'sip2sip.info', // A host with SOA records registered SOA_HOST: 'nodejs.org', // A host with CNAME records registered CNAME_HOST: 'blog.nodejs.org', // A host with NS records registered NS_HOST: 'nodejs.org', // A host with TXT records registered TXT_HOST: 'nodejs.org', // An accessible IPv4 DNS server DNS4_SERVER: '8.8.8.8', // An accessible IPv4 DNS server DNS6_SERVER: '2001:4860:4860::8888' }; var _iteratorNormalCompletion = true; var _didIteratorError = false; var _iteratorError = undefined; try { for (var _iterator = objectKeys(addresses)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { 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; } finally { try { if (!_iteratorNormalCompletion && _iterator.return != null) { _iterator.return(); } } finally { if (_didIteratorError) { throw _iteratorError; } } } module.exports = { addresses: addresses }; function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } }readable-stream-3.6.0/test/common/ongc.js000066400000000000000000000022771362132315000203070ustar00rootroot00000000000000"use strict"; /**/ require('@babel/polyfill'); var util = require('util'); 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); } 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'); const onGcAsyncHook = async_hooks.createHook({ init: common.mustCallAtLeast(function(id, type) { if (this.trackedId === undefined) { assert.strictEqual(type, gcTrackerTag); this.trackedId = id; } }), destroy(id) { assert.notStrictEqual(this.trackedId, -1); if (id === this.trackedId) { this.gcListener.ongc(); onGcAsyncHook.disable(); } } }).enable();*/ onGcAsyncHook.gcListener = 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); } }readable-stream-3.6.0/test/common/shared-lib-util.js000066400000000000000000000036051362132315000223420ustar00rootroot00000000000000"use strict"; /**/ require('@babel/polyfill'); var util = require('util'); 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); } 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. 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.PATH = (env.PATH ? env.PATH + path.delimiter : '') + kExecPath; } // Get the full path of shared lib. function getSharedLibPath() { if (common.isWindows) { return path.join(kExecPath, 'node.dll'); } else if (common.isOSX) { return path.join(kExecPath, "libnode.".concat(kShlibSuffix)); } else { return path.join(kExecPath, 'lib.target', "libnode.".concat(kShlibSuffix)); } } // 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); } }readable-stream-3.6.0/test/common/tick.js000066400000000000000000000012401362132315000203000ustar00rootroot00000000000000"use strict"; /**/ require('@babel/polyfill'); var util = require('util'); 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); } return keys; }; /**/ require('../common'); module.exports = function tick(x, cb) { function ontick() { if (--x === 0) { if (typeof cb === 'function') cb(); } else { setImmediate(ontick); } } setImmediate(ontick); }; function forEach(xs, f) { for (var i = 0, l = xs.length; i < l; i++) { f(xs[i], i); } }readable-stream-3.6.0/test/common/tls.js000066400000000000000000000203171362132315000201560ustar00rootroot00000000000000"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 _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); } /**/ 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 */ 'use strict'; /**/ var objectKeys = objectKeys || function (obj) { var keys = []; 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) { _inherits(TestTLSSocket, _net$Socket); function TestTLSSocket(server_cert) { var _this; _classCallCheck(this, TestTLSSocket); _this = _possibleConstructorReturn(this, _getPrototypeOf(TestTLSSocket).call(this)); _this.server_cert = server_cert; _this.version = Buffer.from('0303', 'hex'); _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); } }, { key: "createClientKeyExchange", value: function createClientKeyExchange() { var encrypted_pre_master_secret = crypto.publicEncrypt({ key: this.server_cert, padding: crypto.constants.RSA_PKCS1_PADDING }, this.pre_master_secret); var length = Buffer.alloc(2); length.writeUIntBE(encrypted_pre_master_secret.length, 0, 2); var msg = addHandshakeHeader(0x10, Buffer.concat([length, encrypted_pre_master_secret])); this.emit('handshake', msg); return addRecordHeader(0x16, msg); } }, { key: "createFinished", value: function createFinished() { var shasum = crypto.createHash('sha256'); shasum.update(Buffer.concat(this.handshake_list)); var message_hash = shasum.digest(); var r = PRF12('sha256', this.master_secret, 'client finished', message_hash, 12); var msg = addHandshakeHeader(0x14, r); this.emit('handshake', msg); return addRecordHeader(0x16, msg); } }, { key: "createIllegalHandshake", value: function createIllegalHandshake() { var illegal_handshake = Buffer.alloc(5); return addRecordHeader(0x16, illegal_handshake); } }, { key: "parseTLSFrame", value: function parseTLSFrame(buf) { var offset = 0; var record = buf.slice(offset, 5); var type = record[0]; 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); } }, { key: "parseTLSHandshake", 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; var handshake = buf.slice(0, offset + length); this.emit('handshake', handshake); offset += length; var remaining = buf.slice(offset); return remaining; } }, { key: "encrypt", value: function encrypt(plain) { var type = plain.slice(0, 1); var version = plain.slice(1, 3); var nonce = crypto.randomBytes(8); var iv = Buffer.concat([this.client_writeIV.slice(0, 4), nonce]); var bob = crypto.createCipheriv('aes-128-gcm', this.client_writeKey, iv); var write_seq = Buffer.alloc(8); write_seq.writeUInt32BE(this.write_seq++, 4); var aad = Buffer.concat([write_seq, plain.slice(0, 5)]); bob.setAAD(aad); var encrypted1 = bob.update(plain.slice(5)); var encrypted = Buffer.concat([encrypted1, bob.final()]); var tag = bob.getAuthTag(); var length = Buffer.alloc(2); length.writeUInt16BE(nonce.length + encrypted.length + tag.length, 0); 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); } }readable-stream-3.6.0/test/common/tmpdir.js000066400000000000000000000040451362132315000206530ustar00rootroot00000000000000"use strict"; /**/ require('@babel/polyfill'); var util = require('util'); 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); } 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) { if (e.code === 'ENOENT') return; if (e.code === 'EPERM') return rmdirSync(p, e); if (e.code !== 'EISDIR') throw e; 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) { if (f instanceof Buffer) { var buf = Buffer.concat([Buffer.from(p), Buffer.from(path.sep), f]); rimrafSync(buf); } else { rimrafSync(path.join(p, f)); } }); fs.rmdirSync(p); } } } 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, // 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); } }readable-stream-3.6.0/test/common/wpt.js000066400000000000000000000025761362132315000201750ustar00rootroot00000000000000"use strict"; /**/ require('@babel/polyfill'); var util = require('util'); 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); } return keys; }; /**/ var assert = require('assert'); // https://github.com/w3c/testharness.js/blob/master/testharness.js module.exports = { test: function test(fn, desc) { try { fn(); } catch (err) { console.error("In ".concat(desc, ":")); throw err; } }, assert_equals: assert.strictEqual, assert_true: function assert_true(value, message) { return assert.strictEqual(value, true, message); }, assert_false: function assert_false(value, message) { return assert.strictEqual(value, false, message); }, assert_throws: function assert_throws(code, func, desc) { assert.throws(func, function (err) { return typeof err === 'object' && 'name' in err && err.name.startsWith(code.name); }, desc); }, assert_array_equals: assert.deepStrictEqual, assert_unreached: function assert_unreached(desc) { 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); } }readable-stream-3.6.0/test/fixtures/000077500000000000000000000000001362132315000173745ustar00rootroot00000000000000readable-stream-3.6.0/test/fixtures/x1024.txt000066400000000000000000000020001362132315000207030ustar00rootroot00000000000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxreadable-stream-3.6.0/test/ours/000077500000000000000000000000001362132315000165135ustar00rootroot00000000000000readable-stream-3.6.0/test/ours/errors.js000066400000000000000000000057631362132315000204000ustar00rootroot00000000000000var tap = require('tap'); var assert = require('assert'); var errors = require('../../errors').codes; function expect (err, Base, name, code, message) { assert(err instanceof Base); assert.strictEqual(err.name, name); assert.strictEqual(err.code, code); assert.strictEqual(err.message, message); } expect( new errors.ERR_INVALID_OPT_VALUE('name', 0), TypeError, 'TypeError', 'ERR_INVALID_OPT_VALUE', 'The value "0" is invalid for option "name"' ); expect( new errors.ERR_INVALID_OPT_VALUE('name', undefined), TypeError, 'TypeError', 'ERR_INVALID_OPT_VALUE', 'The value "undefined" is invalid for option "name"' ); expect( new errors.ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], 0), TypeError, 'TypeError', 'ERR_INVALID_ARG_TYPE', 'The "chunk" argument must be one of type string, Buffer, or Uint8Array. Received type number' ); expect( new errors.ERR_INVALID_ARG_TYPE('first argument', 'not string', 'foo'), TypeError, 'TypeError', 'ERR_INVALID_ARG_TYPE', 'The first argument must not be of type string. Received type string' ); expect( new errors.ERR_INVALID_ARG_TYPE('obj.prop', 'string', undefined), TypeError, 'TypeError', 'ERR_INVALID_ARG_TYPE', 'The "obj.prop" property must be of type string. Received type undefined' ); expect( new errors.ERR_STREAM_PUSH_AFTER_EOF(), Error, 'Error', 'ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF' ); expect( new errors.ERR_METHOD_NOT_IMPLEMENTED('_read()'), Error, 'Error', 'ERR_METHOD_NOT_IMPLEMENTED', 'The _read() method is not implemented' ); expect( new errors.ERR_METHOD_NOT_IMPLEMENTED('_write()'), Error, 'Error', 'ERR_METHOD_NOT_IMPLEMENTED', 'The _write() method is not implemented' ); expect( new errors.ERR_STREAM_PREMATURE_CLOSE(), Error, 'Error', 'ERR_STREAM_PREMATURE_CLOSE', 'Premature close' ); expect( new errors.ERR_STREAM_DESTROYED('pipe'), Error, 'Error', 'ERR_STREAM_DESTROYED', 'Cannot call pipe after a stream was destroyed' ); expect( new errors.ERR_STREAM_DESTROYED('write'), Error, 'Error', 'ERR_STREAM_DESTROYED', 'Cannot call write after a stream was destroyed' ); expect( new errors.ERR_MULTIPLE_CALLBACK(), Error, 'Error', 'ERR_MULTIPLE_CALLBACK', 'Callback called multiple times' ); expect( new errors.ERR_STREAM_CANNOT_PIPE(), Error, 'Error', 'ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable' ); expect( new errors.ERR_STREAM_WRITE_AFTER_END(), Error, 'Error', 'ERR_STREAM_WRITE_AFTER_END', 'write after end' ); expect( new errors.ERR_STREAM_NULL_VALUES(), TypeError, 'TypeError', 'ERR_STREAM_NULL_VALUES', 'May not write null values to stream' ); expect( new errors.ERR_UNKNOWN_ENCODING('foo'), TypeError, 'TypeError', 'ERR_UNKNOWN_ENCODING', 'Unknown encoding: foo' ); expect( new errors.ERR_STREAM_UNSHIFT_AFTER_END_EVENT(), Error, 'Error', 'ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event' ); require('tap').pass('sync done'); readable-stream-3.6.0/test/ours/lolex-fake-timers.js000066400000000000000000000015461362132315000224070ustar00rootroot00000000000000require('../common'); var tap = require('tap'); var util = require('util'); var assert = require('assert'); var lolex = require('lolex'); var stream = require('../../'); var Transform = stream.Transform; function MyTransform() { Transform.call(this); } util.inherits(MyTransform, Transform); var clock = lolex.install({toFake: [ 'setImmediate', 'nextTick' ]}); var stream2DataCalled = false; var stream = new MyTransform(); stream.on('data', function() { stream.on('end', function() { var stream2 = new MyTransform(); stream2.on('data', function() { stream2.on('end', function() { stream2DataCalled = true }); setImmediate(function() { stream2.end() }); }); stream2.emit('data') }); stream.end(); }); stream.emit('data'); clock.runAll() clock.uninstall(); assert(stream2DataCalled); tap.pass('ok'); readable-stream-3.6.0/test/ours/test-stream-sync-write.js000066400000000000000000000014761362132315000234330ustar00rootroot00000000000000require('../common'); var util = require('util'); var stream = require('../../'); var WritableStream = stream.Writable; var InternalStream = function() { WritableStream.call(this); }; util.inherits(InternalStream, WritableStream); InternalStream.prototype._write = function(chunk, encoding, callback) { callback(); }; var internalStream = new InternalStream(); var ExternalStream = function(writable) { this._writable = writable; WritableStream.call(this); }; util.inherits(ExternalStream, WritableStream); ExternalStream.prototype._write = function(chunk, encoding, callback) { this._writable.write(chunk, encoding, callback); }; var externalStream = new ExternalStream(internalStream); for (var i = 0; i < 2000; i++) { externalStream.write(i.toString()); } require('tap').pass('sync done'); readable-stream-3.6.0/test/parallel/000077500000000000000000000000001362132315000173175ustar00rootroot00000000000000readable-stream-3.6.0/test/parallel/test-readable-from.js000066400000000000000000000322631362132315000233400ustar00rootroot00000000000000"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 _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"); } /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var _require = require('../common'), mustCall = _require.mustCall; var once = require('events.once'); var _require2 = require('../../'), Readable = _require2.Readable; var _require3 = require('assert/'), 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'; yield 'b'; yield 'c'; }); return _generate.apply(this, arguments); } var stream = Readable.from(generate()); var expected = ['a', 'b', 'c']; var _iteratorNormalCompletion = true; 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()); } } catch (err) { _didIteratorError = true; _iteratorError = err; } finally { try { if (!_iteratorNormalCompletion && _iterator.return != null) { yield _iterator.return(); } } finally { if (_didIteratorError) { throw _iteratorError; } } } }); return _toReadableBasicSupport.apply(this, arguments); } function toReadableSyncIterator() { return _toReadableSyncIterator.apply(this, arguments); } function _toReadableSyncIterator() { _toReadableSyncIterator = _asyncToGenerator(function* () { function* generate() { yield 'a'; yield 'b'; yield 'c'; } var stream = Readable.from(generate()); var expected = ['a', 'b', 'c']; var _iteratorNormalCompletion2 = true; 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()); } } catch (err) { _didIteratorError2 = true; _iteratorError2 = err; } finally { try { if (!_iteratorNormalCompletion2 && _iterator2.return != null) { yield _iterator2.return(); } } finally { if (_didIteratorError2) { throw _iteratorError2; } } } }); 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 _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()); } } catch (err) { _didIteratorError3 = true; _iteratorError3 = err; } finally { try { if (!_iteratorNormalCompletion3 && _iterator3.return != null) { yield _iterator3.return(); } } finally { if (_didIteratorError3) { throw _iteratorError3; } } } }); 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 _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()); } } catch (err) { _didIteratorError4 = true; _iteratorError4 = err; } finally { try { if (!_iteratorNormalCompletion4 && _iterator4.return != null) { yield _iterator4.return(); } } finally { if (_didIteratorError4) { throw _iteratorError4; } } } }); 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'; yield 'b'; yield 'c'; }); return _generate2.apply(this, arguments); } var stream = Readable.from(generate()); var iterations = 0; var expected = ['a', 'b', 'c']; stream.on('data', function (chunk) { iterations++; strictEqual(chunk, expected.shift()); }); yield once(stream, 'end'); strictEqual(iterations, 3); }); 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'; yield 'b'; yield 'c'; }); return _generate3.apply(this, arguments); } var stream = Readable.from(generate(), { objectMode: false }); var iterations = 0; var expected = ['a', 'b', 'c']; stream.on('data', function (chunk) { iterations++; strictEqual(chunk instanceof Buffer, true); strictEqual(chunk.toString(), expected.shift()); }); yield once(stream, 'end'); strictEqual(iterations, 3); }); 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) { strictEqual(err.message, 'kaboom'); strictEqual(stream.destroyed, true); } }); 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 _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(); } } catch (err) { _didIteratorError6 = true; _iteratorError6 = err; } finally { try { if (!_iteratorNormalCompletion6 && _iterator6.return != null) { yield _awaitAsyncGenerator(_iterator6.return()); } } finally { if (_didIteratorError6) { throw _iteratorError6; } } } }); return _generate5.apply(this, arguments); } var source = new Readable({ objectMode: true, read: function read() { this.push('a'); this.push('b'); this.push('c'); this.push(null); } }); var stream = Readable.from(generate(source)); var expected = ['A', 'B', 'C']; var _iteratorNormalCompletion5 = true; 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()); } } catch (err) { _didIteratorError5 = true; _iteratorError5 = err; } finally { try { if (!_iteratorNormalCompletion5 && _iterator5.return != null) { yield _iterator5.return(); } } finally { if (_didIteratorError5) { throw _iteratorError5; } } } }); 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); });readable-stream-3.6.0/test/parallel/test-readable-large-hwm.js000066400000000000000000000016641362132315000242610ustar00rootroot00000000000000"use strict"; /**/ 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. 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); } } }); r.on('readable', function () { while (true) { var ret = r.read(bufferSize); if (ret === null) break; } }); 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); });readable-stream-3.6.0/test/parallel/test-readable-single-end.js000066400000000000000000000013631362132315000244170ustar00rootroot00000000000000"use strict"; /**/ 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) var r = new Readable({ read: function read() {} }); 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); });readable-stream-3.6.0/test/parallel/test-stream-auto-destroy.js000066400000000000000000000035641362132315000245720ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var stream = require('../../'); var assert = require('assert/'); { var r = new stream.Readable({ autoDestroy: true, read: function read() { this.push('hello'); this.push('world'); this.push(null); }, destroy: common.mustCall(function (err, cb) { return cb(); }) }); var ended = false; r.resume(); r.on('end', common.mustCall(function () { ended = true; })); r.on('close', common.mustCall(function () { assert(ended); })); } { var w = new stream.Writable({ autoDestroy: true, write: function write(data, enc, cb) { cb(null); }, destroy: common.mustCall(function (err, cb) { return cb(); }) }); var finished = false; w.write('hello'); w.write('world'); w.end(); w.on('finish', common.mustCall(function () { finished = true; })); w.on('close', common.mustCall(function () { assert(finished); })); } { var t = new stream.Transform({ autoDestroy: true, transform: function transform(data, enc, cb) { cb(null, data); }, destroy: common.mustCall(function (err, cb) { return cb(); }) }); var _ended = false; var _finished = false; t.write('hello'); t.write('world'); t.end(); t.resume(); t.on('end', common.mustCall(function () { _ended = true; })); t.on('finish', common.mustCall(function () { _finished = true; })); t.on('close', common.mustCall(function () { assert(_ended); assert(_finished); })); } ; (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); });readable-stream-3.6.0/test/parallel/test-stream-backpressure.js000066400000000000000000000023211362132315000246120ustar00rootroot00000000000000"use strict"; /**/ 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({ read: common.mustCall(function () { if (pushes++ === 10) { this.push(null); return; } var length = this._readableState.length; // 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. }, 11) }); var ws = stream.Writable({ write: common.mustCall(function (data, enc, cb) { setImmediate(cb); }, 41 * 10) }); 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); });readable-stream-3.6.0/test/parallel/test-stream-big-packet.js000066400000000000000000000115731362132315000241400ustar00rootroot00000000000000"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 _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); } // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 stream = require('../../'); var passed = false; var TestStream = /*#__PURE__*/ function (_stream$Transform) { _inherits(TestStream, _stream$Transform); function TestStream() { _classCallCheck(this, TestStream); return _possibleConstructorReturn(this, _getPrototypeOf(TestStream).apply(this, arguments)); } _createClass(TestStream, [{ key: "_transform", value: function _transform(chunk, encoding, done) { if (!passed) { // 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 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. assert(!s1.write(big)); // 'tiny' is small enough to pass through internal buffer. assert(s2.write('tiny')); // 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'); // 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); });readable-stream-3.6.0/test/parallel/test-stream-big-push.js000066400000000000000000000052121362132315000236410ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ 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 () { r.push(str); }, 1); 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 assert(!ret); var chunk = r.read(); assert.strictEqual(chunk, str); chunk = r.read(); assert.strictEqual(chunk, null); r.once('readable', function () { // this time, we'll get *all* the remaining data, because // it's been added synchronously, as the read WOULD take // us below the hwm, and so it triggered a _read() again, // which synchronously added more, which we then return. chunk = r.read(); assert.strictEqual(chunk, str + str); chunk = r.read(); 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); });readable-stream-3.6.0/test/parallel/test-stream-buffer-list.js000066400000000000000000000021241362132315000243440ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ require('../common'); var assert = require('assert/'); var BufferList = require('../../lib/internal/streams/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 list = new BufferList(); list.push(buf); var copy = list.concat(3); assert.notStrictEqual(copy, buf); assert.deepStrictEqual(copy, buf); assert.strictEqual(list.join(','), 'foo'); 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); });readable-stream-3.6.0/test/parallel/test-stream-decoder-objectmode.js000066400000000000000000000016011362132315000256370ustar00rootroot00000000000000"use strict"; /**/ 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', objectMode: true }); 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. 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); });readable-stream-3.6.0/test/parallel/test-stream-destroy-event-order.js000066400000000000000000000014561362132315000260520ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var assert = require('assert/'); var _require = require('../../'), Readable = _require.Readable; var rs = new Readable({ read: function read() {} }); var closed = false; var errored = false; rs.on('close', common.mustCall(function () { closed = true; assert(errored); })); rs.on('error', common.mustCall(function (err) { errored = true; assert(!closed); })); 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); });readable-stream-3.6.0/test/parallel/test-stream-duplex-destroy.js000066400000000000000000000120431362132315000251130ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('../../'), Duplex = _require.Duplex; var assert = require('assert/'); { var duplex = new Duplex({ write: function write(chunk, enc, cb) { cb(); }, read: function read() {} }); duplex.resume(); duplex.on('end', common.mustNotCall()); duplex.on('finish', common.mustNotCall()); duplex.on('close', common.mustCall()); duplex.destroy(); assert.strictEqual(duplex.destroyed, true); } { var _duplex = new Duplex({ write: function write(chunk, enc, cb) { cb(); }, 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); } { var _duplex2 = new Duplex({ write: function write(chunk, enc, cb) { cb(); }, 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(); }, read: function read() {}, destroy: common.mustCall(function (err, cb) { assert.strictEqual(err, _expected2); cb(); }) }); _duplex3.resume(); _duplex3.on('end', common.mustNotCall('no end event')); _duplex3.on('finish', common.mustNotCall('no finish event')); // 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); } { var _duplex4 = new Duplex({ write: function write(chunk, enc, cb) { cb(); }, read: function read() {} }); _duplex4._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, null); cb(); }); _duplex4.destroy(); assert.strictEqual(_duplex4.destroyed, true); } { var _duplex5 = new Duplex({ write: function write(chunk, enc, cb) { cb(); }, 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); } { var _duplex6 = new Duplex({ write: function write(chunk, enc, cb) { cb(); }, 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); } { var _duplex7 = new Duplex({ write: function write(chunk, enc, cb) { cb(); }, read: function read() {}, allowHalfOpen: true }); _duplex7.resume(); _duplex7.on('finish', common.mustNotCall()); _duplex7.on('end', common.mustNotCall()); _duplex7.destroy(); assert.strictEqual(_duplex7.destroyed, true); } { var _duplex8 = new Duplex({ write: function write(chunk, enc, cb) { cb(); }, read: function read() {} }); _duplex8.destroyed = true; 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() { 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); });readable-stream-3.6.0/test/parallel/test-stream-duplex-end.js000066400000000000000000000025271362132315000241760ustar00rootroot00000000000000"use strict"; /**/ 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() {} }); assert.strictEqual(stream.allowHalfOpen, true); stream.on('finish', common.mustNotCall()); assert.strictEqual(stream.listenerCount('end'), 0); stream.resume(); stream.push(null); } { var _stream = new 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); } { var _stream2 = new 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); });readable-stream-3.6.0/test/parallel/test-stream-duplex.js000066400000000000000000000042211362132315000234230ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 }); assert(Duplex() instanceof Duplex); assert(stream._readableState.objectMode); assert(stream._writableState.objectMode); 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; }); stream.push({ val: 1 }); stream.end({ val: 2 }); process.on('exit', function () { assert.strictEqual(read.val, 1); 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); });readable-stream-3.6.0/test/parallel/test-stream-end-paused.js000066400000000000000000000040671362132315000241570ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ var common = require('../common'); var assert = require('assert/'); // 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'); }); stream.pause(); setTimeout(common.mustCall(function () { stream.on('end', common.mustCall()); stream.resume(); }), 1); 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); });readable-stream-3.6.0/test/parallel/test-stream-events-prepend.js000066400000000000000000000062401362132315000250640ustar00rootroot00000000000000"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 _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); } /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var stream = require('../../'); var Writable = /*#__PURE__*/ function (_stream$Writable) { _inherits(Writable, _stream$Writable); function Writable() { var _this; _classCallCheck(this, Writable); _this = _possibleConstructorReturn(this, _getPrototypeOf(Writable).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) { _inherits(Readable, _stream$Readable); function Readable() { _classCallCheck(this, Readable); return _possibleConstructorReturn(this, _getPrototypeOf(Readable).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); });readable-stream-3.6.0/test/parallel/test-stream-finished.js000066400000000000000000000072531362132315000237230ustar00rootroot00000000000000"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; var assert = require('assert/'); var fs = require('fs'); var promisify = require('util-promisify'); { var rs = new Readable({ read: function read() {} }); finished(rs, common.mustCall(function (err) { assert(!err, 'no error'); })); rs.push(null); rs.resume(); } { var ws = new Writable({ write: function write(data, enc, cb) { cb(); } }); finished(ws, common.mustCall(function (err) { assert(!err, 'no error'); })); ws.end(); } { var tr = new Transform({ transform: function transform(data, enc, cb) { cb(); } }); var finish = false; var ended = false; tr.on('end', function () { ended = true; }); tr.on('finish', function () { finish = true; }); finished(tr, common.mustCall(function (err) { assert(!err, 'no error'); assert(finish); assert(ended); })); tr.end(); tr.resume(); } { 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 rs = fs.createReadStream(__filename); var done = common.mustCall(); var ended = false; rs.resume(); rs.on('end', function () { ended = true; }); yield finishedPromise(rs); assert(ended); done(); }); return _run.apply(this, arguments); } 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 { 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); });readable-stream-3.6.0/test/parallel/test-stream-ispaused.js000066400000000000000000000037121362132315000237430ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 stream = require('../../'); var readable = new stream.Readable(); // _read is a noop, here. readable._read = Function(); // default state of a stream is not "paused" assert.ok(!readable.isPaused()); // 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); });readable-stream-3.6.0/test/parallel/test-stream-objectmode-undefined.js000066400000000000000000000024531362132315000262010ustar00rootroot00000000000000"use strict"; /**/ 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; { var stream = new Readable({ objectMode: true, read: common.mustCall(function () { stream.push(undefined); stream.push(null); }) }); stream.on('data', common.mustCall(function (chunk) { assert.strictEqual(chunk, undefined); })); } { var _stream = new Writable({ objectMode: true, write: common.mustCall(function (chunk) { assert.strictEqual(chunk, undefined); }) }); _stream.write(undefined); } { var _stream2 = new Transform({ objectMode: true, transform: common.mustCall(function (chunk) { _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); });readable-stream-3.6.0/test/parallel/test-stream-once-readable-pipe.js000066400000000000000000000032021362132315000255340ustar00rootroot00000000000000"use strict"; /**/ 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. { 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.once('readable', common.mustCall()); r.pipe(w); r.push(data[0]); r.push(data[1]); r.push(data[2]); r.push(null); w.on('finish', common.mustCall(function () { assert.strictEqual(receivedData, data.join('')); })); } { 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-after-end.js000066400000000000000000000117451362132315000247330ustar00rootroot00000000000000"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 _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); } // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ 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) { _inherits(TestReadable, _Readable); function TestReadable(opt) { var _this; _classCallCheck(this, TestReadable); _this = _possibleConstructorReturn(this, _getPrototypeOf(TestReadable).call(this, opt)); _this._ended = false; return _this; } _createClass(TestReadable, [{ key: "_read", value: function _read() { if (this._ended) this.emit('error', new Error('_read called twice')); this._ended = true; this.push(null); } }]); return TestReadable; }(Readable); var TestWritable = /*#__PURE__*/ function (_Writable) { _inherits(TestWritable, _Writable); function TestWritable(opt) { var _this2; _classCallCheck(this, TestWritable); _this2 = _possibleConstructorReturn(this, _getPrototypeOf(TestWritable).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(); // 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()); var c = ender.read(); assert.strictEqual(c, null); var w = new TestWritable(); w.on('finish', common.mustCall()); 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-await-drain-manual-resume.js000066400000000000000000000062121362132315000300300ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var stream = require('../../'); var assert = require('assert/'); // 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 // return false, because chunks are still being buffered, so it will increase // the awaitDrain counter again. process.nextTick(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 // 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; } } } })); })); 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. })); ; (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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-await-drain-push-while-write.js000066400000000000000000000025001362132315000304660ustar00rootroot00000000000000"use strict"; /**/ 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. var bufs = [bufferShim.alloc(32 * 1024), bufferShim.alloc(33 * 1024)]; // above hwm var readable = new stream.Readable({ read: function read() { while (bufs.length > 0) { this.push(bufs.shift()); } } }); 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-await-drain.js000066400000000000000000000043121362132315000252560ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var stream = require('../../'); var assert = require('assert/'); // 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 // 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(); }, 1); writer1.once('chunk-received', function () { assert.strictEqual(reader._readableState.awaitDrain, 0, 'awaitDrain initial value should be 0, actual is ' + reader._readableState.awaitDrain); setImmediate(function () { // This one should *not* get through to writer1 because writer2 is not // "done" processing. reader.push(buffer); }); }); // 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. // 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. // This should be called exactly once, since the first .write() call // will return false. }, 1); reader.pipe(writer1); 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-cleanup-pause.js000066400000000000000000000024071362132315000256230ustar00rootroot00000000000000"use strict"; /**/ 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 // 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(); }, 1); writer1.once('chunk-received', function () { reader.unpipe(writer1); reader.pipe(writer2); reader.push(buffer); setImmediate(function () { reader.push(buffer); setImmediate(function () { reader.push(buffer); }); }); }); writer2._write = common.mustCall(function (chunk, encoding, cb) { cb(); }, 3); 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-cleanup.js000066400000000000000000000111331362132315000245040ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ // 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 r.emit('end'); assert.strictEqual(d.endCalls, 1); assert.strictEqual(w.endCalls, 0); 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 d.emit('end'); assert.strictEqual(d.endCalls, 1); assert.strictEqual(w.endCalls, 1); assert.strictEqual(r.listeners('end').length, 0); assert.strictEqual(r.listeners('close').length, 0); assert.strictEqual(d.listeners('end').length, 0); assert.strictEqual(d.listeners('close').length, 0); 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-error-handling.js000066400000000000000000000063161362132315000257770ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ var common = require('../common'); var assert = require('assert/'); var Stream = require('stream').Stream; { var source = new Stream(); var dest = new Stream(); source.pipe(dest); var gotErr = null; source.on('error', function (err) { gotErr = err; }); var err = new Error('This stream turned into bacon.'); source.emit('error', err); assert.strictEqual(gotErr, err); } { 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 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); assert.throws(function () { w.emit('error', new Error('fail')); }, /^Error: fail$/); }), 1); }); w.on('error', myOnError); 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 _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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-event.js000066400000000000000000000042261362132315000242030ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 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; var w = new Writable(); w.on('pipe', function (src) { passed = true; }); 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-flow-after-unpipe.js000066400000000000000000000022751362132315000264300ustar00rootroot00000000000000"use strict"; /**/ 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(). var rs = new Readable({ highWaterMark: 1, // That this gets called at least 20 times is the real test here. read: common.mustCallAtLeast(function () { return rs.push('foo'); }, 20) }); var ws = new Writable({ highWaterMark: 1, write: common.mustCall(function () { // Ignore the callback, this write() simply never finishes. setImmediate(function () { return rs.unpipe(ws); }); }) }); var chunks = 0; 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-flow.js000066400000000000000000000035371362132315000240350ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('../../'), Readable = _require.Readable, Writable = _require.Writable, PassThrough = _require.PassThrough; { var ticks = 17; var rs = new Readable({ objectMode: true, read: function read() { if (ticks-- > 0) return process.nextTick(function () { return rs.push({}); }); rs.push({}); rs.push(null); } }); var ws = new Writable({ highWaterMark: 0, objectMode: true, write: function write(data, end, cb) { return setImmediate(cb); } }); rs.on('end', common.mustCall()); ws.on('finish', common.mustCall()); rs.pipe(ws); } { 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 })).pipe(new PassThrough({ objectMode: true, highWaterMark: 2 })); pt.on('end', function () { wrapper.push(null); }); var wrapper = new Readable({ objectMode: true, read: function read() { process.nextTick(function () { var data = pt.read(); if (data === null) { pt.once('readable', function () { data = pt.read(); if (data !== null) wrapper.push(data); }); } else { wrapper.push(data); } }); } }); wrapper.resume(); 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-manual-resume.js000066400000000000000000000022611362132315000256320ustar00rootroot00000000000000"use strict"; /**/ 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({ objectMode: true, read: common.mustCallAtLeast(function () { if (--counter >= 0) rs.push({ counter: counter });else rs.push(null); }, n) }); var ws = stream.Writable({ objectMode: true, write: common.mustCall(function (data, enc, cb) { setImmediate(cb); }, n) }); setImmediate(function () { return throwCodeInbetween(rs, ws); }); rs.pipe(ws); } test(function (rs) { return rs.read(); }); test(function (rs) { return rs.resume(); }); 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-multiple-pipes.js000066400000000000000000000054201362132315000260300ustar00rootroot00000000000000"use strict"; /**/ 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 target = new stream.Writable({ write: common.mustCall(function (chunk, encoding, callback) { target.output.push(chunk); callback(); }, 1) }); target.output = []; target.on('pipe', common.mustCall()); readable.pipe(target); writables.push(target); }; for (var i = 0; i < 5; i++) { _loop(i); } 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. 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; } } } 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; } } } })); ; (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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-same-destination-twice.js000066400000000000000000000053421362132315000274370ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); // 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; { var passThrough = new PassThrough(); var dest = new Writable({ write: common.mustCall(function (chunk, encoding, cb) { assert.strictEqual("".concat(chunk), 'foobar'); cb(); }) }); 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.unpipe(dest); assert.strictEqual(passThrough._events.data.length, 1); assert.strictEqual(passThrough._readableState.pipesCount, 1); assert.strictEqual(passThrough._readableState.pipes, dest); passThrough.write('foobar'); passThrough.pipe(dest); } { 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-unpipe-streams.js000066400000000000000000000056401362132315000260370ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var assert = require('assert/'); var _require = require('../../'), Readable = _require.Readable, Writable = _require.Writable; var source = Readable({ read: function read() {} }); var dest1 = Writable({ write: function write() {} }); var dest2 = Writable({ write: function write() {} }); source.pipe(dest1); source.pipe(dest2); 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. source.unpipe(dest2); assert.strictEqual(source._readableState.pipes, dest1); assert.notStrictEqual(source._readableState.pipes, dest2); dest2.on('unpipe', common.mustNotCall()); source.unpipe(dest2); source.unpipe(dest1); assert.strictEqual(source._readableState.pipes, null); { // 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']; var checkSrcCleanup = common.mustCall(function () { assert.strictEqual(_source._readableState.pipes, null); assert.strictEqual(_source._readableState.pipesCount, 0); assert.strictEqual(_source._readableState.flowing, false); srcCheckEventNames.forEach(function (eventName) { 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); });readable-stream-3.6.0/test/parallel/test-stream-pipe-without-listenerCount.js000066400000000000000000000013711362132315000274170ustar00rootroot00000000000000"use strict"; /**/ 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(); w.listenerCount = undefined; w.on('pipe', function () { r.emit('error', new Error('Readable Error')); w.emit('error', new Error('Writable Error')); }); 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); });readable-stream-3.6.0/test/parallel/test-stream-pipeline-queued-end-in-destroy.js000066400000000000000000000031021362132315000300510ustar00rootroot00000000000000"use strict"; /**/ 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() // 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. }, read: function read() {}, destroy: function destroy(err, cb) { // Call end() from inside the destroy() method, like HTTP/2 streams // do at the time of writing. this.end(); cb(err); } }); 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. 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); });readable-stream-3.6.0/test/parallel/test-stream-pipeline.js000066400000000000000000000252331362132315000237350ustar00rootroot00000000000000"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; var assert = require('assert/'); var http = require('http'); var promisify = require('util-promisify'); { var finished = false; var processed = []; var expected = [bufferShim.from('a'), bufferShim.from('b'), bufferShim.from('c')]; var read = new Readable({ read: function read() {} }); var write = new Writable({ write: function write(data, enc, cb) { processed.push(data); cb(); } }); 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'); assert.ok(finished); assert.deepStrictEqual(processed, expected); })); } { var _read = new Readable({ read: function read() {} }); assert.throws(function () { pipeline(_read, function () {}); }, /ERR_MISSING_ARGS/); assert.throws(function () { pipeline(function () {}); }, /ERR_MISSING_ARGS/); assert.throws(function () { pipeline(); }, /ERR_MISSING_ARGS/); } { 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(); }); pipeline(_read2, _write, common.mustCall(function (err) { assert.ok(err, 'should have an error'); })); } { 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')); }); var dst = pipeline(_read3, _write2, common.mustCall(function (err) { assert.strictEqual(err.message, 'kaboom'); })); assert.strictEqual(dst, _write2); } { 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'); } { var server = http.createServer(function (req, res) { var rs = new Readable({ read: function read() { rs.push('hello'); rs.push(null); } }); pipeline(rs, res, function () {}); }); server.listen(0, function () { var req = http.request({ port: server.address().port }); req.end(); req.on('response', function (res) { var buf = []; res.on('data', function (data) { return buf.push(data); }); res.on('end', common.mustCall(function () { assert.deepStrictEqual(Buffer.concat(buf), bufferShim.from('hello')); server.close(); })); }); }); } { var _server = http.createServer(function (req, res) { var sent = false; var rs = new Readable({ read: function read() { if (sent) { return; } sent = true; rs.push('hello'); }, destroy: common.mustCall(function (err, cb) { // prevents fd leaks by destroying http pipelines cb(); }) }); pipeline(rs, res, function () {}); }); _server.listen(0, function () { var req = http.request({ port: _server.address().port }); req.end(); req.on('response', function (res) { setImmediate(function () { res.destroy(); _server.close(); }); }); }); } { var _server2 = http.createServer(function (req, res) { var sent = 0; var rs = new Readable({ read: function read() { if (sent++ > 10) { return; } rs.push('hello'); }, destroy: common.mustCall(function (err, cb) { cb(); }) }); pipeline(rs, res, function () {}); }); var cnt = 10; var badSink = new Writable({ write: function write(data, enc, cb) { cnt--; if (cnt === 0) process.nextTick(cb, new Error('kaboom'));else cb(); } }); _server2.listen(0, function () { var req = http.request({ port: _server2.address().port }); req.end(); req.on('response', function (res) { pipeline(res, badSink, common.mustCall(function (err) { assert.strictEqual(err.message, 'kaboom'); _server2.close(); })); }); }); } { var _server3 = http.createServer(function (req, res) { pipeline(req, res, common.mustCall()); }); _server3.listen(0, function () { var req = http.request({ port: _server3.address().port }); var sent = 0; var rs = new Readable({ read: function read() { if (sent++ > 10) { return; } rs.push('hello'); } }); pipeline(rs, req, common.mustCall(function () { _server3.close(); })); req.on('response', function (res) { var cnt = 10; res.on('data', function () { cnt--; if (cnt === 0) rs.destroy(); }); }); }); } { var makeTransform = function makeTransform() { var tr = new Transform({ transform: function transform(data, enc, cb) { cb(null, data); } }); tr.on('close', common.mustCall()); return tr; }; var rs = new Readable({ read: function read() { rs.push('hello'); } }); var _cnt = 10; var ws = new Writable({ write: function write(data, enc, cb) { _cnt--; if (_cnt === 0) return process.nextTick(cb, new Error('kaboom')); cb(); } }); rs.on('close', common.mustCall()); ws.on('close', common.mustCall()); pipeline(rs, makeTransform(), makeTransform(), makeTransform(), makeTransform(), makeTransform(), makeTransform(), ws, common.mustCall(function (err) { assert.strictEqual(err.message, 'kaboom'); })); } { 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'); })); } { 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 read = new Readable({ read: function read() {} }); var write = new Writable({ write: function write(data, enc, cb) { cb(); } }); read.push('data'); read.push(null); var finished = false; write.on('finish', function () { finished = true; }); yield pipelinePromise(read, write); assert(finished); }); return _run.apply(this, arguments); } 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); });readable-stream-3.6.0/test/parallel/test-stream-push-order.js000066400000000000000000000040111362132315000242070ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 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 { var two = list.shift(); s.push(one); s.push(two); } }; s.read(0); // 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); });readable-stream-3.6.0/test/parallel/test-stream-push-strings.js000066400000000000000000000111241362132315000245700ustar00rootroot00000000000000"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 _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); } // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 Readable = require('../../').Readable; var MyStream = /*#__PURE__*/ function (_Readable) { _inherits(MyStream, _Readable); function MyStream(options) { var _this; _classCallCheck(this, MyStream); _this = _possibleConstructorReturn(this, _getPrototypeOf(MyStream).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)); } }); 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-async-iterators.js000066400000000000000000000530031362132315000270100ustar00rootroot00000000000000"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"); } /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('../../'), 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* () { { var AsyncIteratorPrototype = Object.getPrototypeOf(function () {}); var rs = new Readable({}); assert.strictEqual(Object.getPrototypeOf(Object.getPrototypeOf(rs[Symbol.asyncIterator]())), AsyncIteratorPrototype); } { var readable = new Readable({ objectMode: true, read: function read() {} }); readable.push(0); readable.push(1); readable.push(null); var iter = readable[Symbol.asyncIterator](); assert.strictEqual((yield iter.next()).value, 0); var _iteratorNormalCompletion = true; 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); } } catch (err) { _didIteratorError = true; _iteratorError = err; } finally { try { if (!_iteratorNormalCompletion && _iterator.return != null) { yield _iterator.return(); } } finally { if (_didIteratorError) { throw _iteratorError; } } } } { 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); }, _max)); errors.forEach(function (promise) { promise.catch(common.mustCall(function (err) { 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 () { success = true; throw new Error('should not succeed'); }).catch(function (e2) { if (success) { throw e2; } assert.strictEqual(e.message, e2.message); }); }(iterator.next.bind(iterator), err); } { console.log('read object mode'); 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 _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'); } } catch (err) { _didIteratorError2 = true; _iteratorError2 = err; } finally { try { if (!_iteratorNormalCompletion2 && _iterator2.return != null) { yield _iterator2.return(); } } finally { if (_didIteratorError2) { throw _iteratorError2; } } } 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 _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; } } catch (err) { _didIteratorError3 = true; _iteratorError3 = err; } finally { try { if (!_iteratorNormalCompletion3 && _iterator3.return != null) { yield _iterator3.return(); } } finally { if (_didIteratorError3) { throw _iteratorError3; } } } } 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; setImmediate(function () { _this.destroy(new Error('kaboom')); }); } } }); var _received = 0; var _err2 = null; try { // eslint-disable-next-line no-unused-vars var _iteratorNormalCompletion4 = true; 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++; } } catch (err) { _didIteratorError4 = true; _iteratorError4 = err; } finally { try { if (!_iteratorNormalCompletion4 && _iterator4.return != null) { yield _iterator4.return(); } } finally { if (_didIteratorError4) { throw _iteratorError4; } } } } 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 _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'); } } catch (err) { _didIteratorError5 = true; _iteratorError5 = err; } finally { try { if (!_iteratorNormalCompletion5 && _iterator5.return != null) { yield _iterator5.return(); } } finally { if (_didIteratorError5) { throw _iteratorError5; } } } } 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() { this.push('hello'); this.destroy(new Error('kaboom')); } }); var _received2 = 0; var _err4 = null; try { var _iteratorNormalCompletion6 = true; 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++; } } catch (err) { _didIteratorError6 = true; _iteratorError6 = err; } finally { try { if (!_iteratorNormalCompletion6 && _iterator6.return != null) { yield _iterator6.return(); } } finally { if (_didIteratorError6) { throw _iteratorError6; } } } } catch (e) { _err4 = e; } assert.strictEqual(_err4.message, 'kaboom'); assert.strictEqual(_received2, 1); } { console.log('push async'); 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 _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'); } } catch (err) { _didIteratorError7 = true; _iteratorError7 = err; } finally { try { if (!_iteratorNormalCompletion7 && _iterator7.return != null) { yield _iterator7.return(); } } finally { if (_didIteratorError7) { throw _iteratorError7; } } } 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 _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; } } catch (err) { _didIteratorError8 = true; _iteratorError8 = err; } finally { try { if (!_iteratorNormalCompletion8 && _iterator8.return != null) { yield _iterator8.return(); } } finally { if (_didIteratorError8) { throw _iteratorError8; } } } assert.strictEqual(data, expected); } { console.log('.next() on destroyed stream'); var _readable12 = new Readable({ read: function read() {// no-op } }); _readable12.destroy(); var _ref = yield _readable12[Symbol.asyncIterator]().next(), done = _ref.done; assert.strictEqual(done, true); } { console.log('.next() on pipelined stream'); var _readable13 = new Readable({ 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) { assert.strictEqual(e, _err5); } } { console.log('iterating on an ended stream completes'); var r = new Readable({ objectMode: true, read: function read() { this.push('asdf'); this.push('hehe'); this.push(null); } }); // eslint-disable-next-line no-unused-vars var _iteratorNormalCompletion9 = true; 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 } catch (err) { _didIteratorError9 = true; _iteratorError9 = err; } finally { try { if (!_iteratorNormalCompletion9 && _iterator9.return != null) { yield _iterator9.return(); } } finally { if (_didIteratorError9) { throw _iteratorError9; } } } var _iteratorNormalCompletion10 = true; 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; } } catch (err) { _didIteratorError10 = true; _iteratorError10 = err; } finally { try { if (!_iteratorNormalCompletion10 && _iterator10.return != null) { yield _iterator10.return(); } } finally { if (_didIteratorError10) { throw _iteratorError10; } } } } { 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; 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); } } catch (err) { _didIteratorError11 = true; _iteratorError11 = err; } finally { try { if (!_iteratorNormalCompletion11 && _iterator11.return != null) { yield _iterator11.return(); } } finally { if (_didIteratorError11) { throw _iteratorError11; } } } } { 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), { done: true, value: undefined }); 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), { done: true, value: undefined }); 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-constructor-set-methods.js000066400000000000000000000010771362132315000305040ustar00rootroot00000000000000"use strict"; /**/ 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-destroy.js000066400000000000000000000104461362132315000253560ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('../../'), Readable = _require.Readable; var assert = require('assert/'); { var read = new Readable({ read: function read() {} }); read.resume(); read.on('close', common.mustCall()); read.destroy(); assert.strictEqual(read.destroyed, true); } { 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); } { var _read3 = new Readable({ read: function read() {}, destroy: common.mustCall(function (err, cb) { assert.strictEqual(err, _expected2); cb(); }) }); var _expected2 = new Error('kaboom'); _read3.on('end', common.mustNotCall('no end event')); // 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 _read7.on('end', common.mustNotCall()); _read7.destroy(); } { 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(); } { // destroy and destroy callback 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); })); } { 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-emittedReadable.js000066400000000000000000000050021362132315000267300ustar00rootroot00000000000000"use strict"; /**/ 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. 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.strictEqual(readable._readableState.emittedReadable, false); }, 3)); // 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 setImmediate(common.mustCall(function () { readable.push('quo'); process.nextTick(common.mustCall(function () { readable.push(null); })); })); var noRead = new Readable({ read: function read() {} }); 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) assert.strictEqual(noRead._readableState.emittedReadable, true); })); noRead.push('foo'); noRead.push(null); var flowing = new Readable({ read: function read() {} }); flowing.on('data', common.mustCall(function () { // When in flowing mode, emittedReadable is always false. assert.strictEqual(flowing._readableState.emittedReadable, false); flowing.read(); assert.strictEqual(flowing._readableState.emittedReadable, false); }, 3)); flowing.push('foooo'); flowing.push('bar'); flowing.push('quo'); 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-event.js000066400000000000000000000075771362132315000250210ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ 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.push(bufferShim.from('blerg')); setTimeout(function () { // we're testing what we think we are assert(!r._readableState.reading); r.on('readable', common.mustCall()); }, 1); } { // 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(); // 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); } { // Third test, not reading when the stream has not passed // the highWaterMark but *has* reached EOF. var _r2 = new Readable({ highWaterMark: 30 }); _r2._read = common.mustNotCall(); // 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); } { // pushing a empty string in non-objectMode should // trigger next `read()`. var underlyingData = ['', 'x', 'y', '', 'z']; var expected = underlyingData.filter(function (data) { 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); } else { _this.push(underlyingData.shift()); } }); }; _r3.on('readable', function () { var data = _r3.read(); if (data !== null) result.push(data); }); _r3.on('end', common.mustCall(function () { assert.deepStrictEqual(result, expected); })); } { // #20923 var _r4 = new Readable(); _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); });readable-stream-3.6.0/test/parallel/test-stream-readable-flow-recursion.js000066400000000000000000000054731362132315000266470ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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/'); // 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; // 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); if (!chunk) stream.once('readable', flow.bind(null, stream, size, callback));else callback(chunk); 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(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); });readable-stream-3.6.0/test/parallel/test-stream-readable-hwm-0-async.js000066400000000000000000000017621362132315000257310ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); // 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; var count = 5; var r = new Readable({ // Called 6 times: First 5 return data, last one signals end of stream. read: common.mustCall(function () { process.nextTick(common.mustCall(function () { if (count--) r.push('a');else r.push(null); })); }, 6), highWaterMark: 0 }); 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-hwm-0-no-flow-data.js000066400000000000000000000075361362132315000271110ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); // 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. var calls = []; var r = new Readable({ read: common.mustCall(function () { calls.push('_read:' + streamData[0]); process.nextTick(function () { calls.push('push:' + streamData[0]); r.push(streamData.shift()); }); }, streamData.length), highWaterMark: 0, // Object mode is used here just for testing convenience. It really // shouldn't affect the order of events. Just the data and its format. objectMode: true }); assert.strictEqual(r.readableFlowing, null); r.on('readable', common.mustCall(function () { calls.push('readable'); }, 2)); assert.strictEqual(r.readableFlowing, false); r.on('data', common.mustCall(function (data) { calls.push('data:' + data); }, 1)); 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 // 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.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 // data and the _read implementation above does the push() asynchronously. // // Note: This 'null' signals "no data available". It isn't the end-of-stream // null value as the stream doesn't know yet that it is about to reach the // end. // // 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. // The 'end' event will be emitted only after a 'read()'. // // This is somewhat special for the case where the '_read' implementation // 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 // 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']); }); }); }); ; (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); });readable-stream-3.6.0/test/parallel/test-stream-readable-hwm-0.js000066400000000000000000000023051362132315000246100ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); // 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; 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) // because the we haven't pushed any data r.on('readable', common.mustCall(function () { assert.strictEqual(r.read(), null); assert.strictEqual(pushedNull, true); })); r.on('end', common.mustCall()); process.nextTick(function () { assert.strictEqual(r.read(), null); pushedNull = true; 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-infinite-read.js000066400000000000000000000020661362132315000264020ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var assert = require('assert/'); var _require = require('../../'), Readable = _require.Readable; var buf = bufferShim.alloc(8192); var readable = new Readable({ read: common.mustCall(function () { this.push(buf); }, 31) }); var i = 0; readable.on('readable', common.mustCall(function () { if (i++ === 10) { // We will just terminate now. process.removeAllListeners('readable'); return; } 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 { assert.strictEqual(data.length, 8192 * 3); } }, 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-invalid-chunk.js000066400000000000000000000014331362132315000264150ustar00rootroot00000000000000"use strict"; /**/ 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([]); }); checkError(function () { return readable.push({}); }); 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-needReadable.js000066400000000000000000000062241362132315000262170ustar00rootroot00000000000000"use strict"; /**/ 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. 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. assert.strictEqual(readable._readableState.needReadable, true); readable.push('foo'); readable.push(null); readable.on('end', common.mustCall(function () { // No need to emit readable anymore when the stream ends. assert.strictEqual(readable._readableState.needReadable, false); })); var asyncReadable = new Readable({ read: function read() {} }); asyncReadable.on('readable', common.mustCall(function () { if (asyncReadable.read() !== null) { // After each read(), the buffer is empty. // If the stream doesn't end now, // then we need to notify the reader on future changes. assert.strictEqual(asyncReadable._readableState.needReadable, true); } }, 2)); process.nextTick(common.mustCall(function () { asyncReadable.push('foooo'); })); process.nextTick(common.mustCall(function () { asyncReadable.push('bar'); })); setImmediate(common.mustCall(function () { asyncReadable.push(null); assert.strictEqual(asyncReadable._readableState.needReadable, false); })); var flowing = new Readable({ read: function read() {} }); // 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. flowing.on('data', common.mustCall(function (data) { assert.strictEqual(flowing._readableState.needReadable, false); }, 3)); var slowProducer = new Readable({ read: function read() {} }); slowProducer.on('readable', common.mustCall(function () { if (slowProducer.read(8) === null) { // The buffer doesn't have enough data, and the stream is not need, // we need to notify the reader when data arrives. assert.strictEqual(slowProducer._readableState.needReadable, true); } else { assert.strictEqual(slowProducer._readableState.needReadable, false); } }, 4)); process.nextTick(common.mustCall(function () { slowProducer.push('foo'); process.nextTick(common.mustCall(function () { slowProducer.push('foo'); process.nextTick(common.mustCall(function () { slowProducer.push('foo'); process.nextTick(common.mustCall(function () { slowProducer.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); });readable-stream-3.6.0/test/parallel/test-stream-readable-no-unneeded-readable.js000066400000000000000000000031041362132315000276140ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('../../'), 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 }); } }); r.once('end', function () { wrapper.push(null); }); wrapper.resume(); wrapper.once('end', common.mustCall()); } { var source = new Readable({ read: function read() {} }); source.push('foo'); source.push('bar'); source.push(null); var pt = source.pipe(new PassThrough()); test(pt); } { // This is the underlying cause of the above test case. var pushChunks = ['foo', 'bar']; var r = new Readable({ read: function read() { var chunk = pushChunks.shift(); if (chunk) { // synchronous call r.push(chunk); } else { // asynchronous call process.nextTick(function () { return r.push(null); }); } } }); 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-object-multi-push-async.js000066400000000000000000000104441362132315000303510ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var assert = require('assert/'); var _require = require('../../'), Readable = _require.Readable; var MAX = 42; var BATCH = 10; { 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); }); }); }, 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); } }); readable.on('end', common.mustCall(function () { assert.strictEqual(i, (Math.floor(MAX / BATCH) + 1) * BATCH); })); } { var _readable = new Readable({ objectMode: true, read: common.mustCall(function () { var _this2 = this; console.log('>> READ'); 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); }); }); }, 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 _readable2 = new Readable({ objectMode: true, read: common.mustCall(function () { var _this3 = this; console.log('>> READ'); fetchData(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); })); } { var _readable3 = new Readable({ 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); })); } { var _readable4 = new Readable({ 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-pause-and-resume.js000066400000000000000000000023201362132315000270300ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var _require = require('../../'), Readable = _require.Readable; var common = require('../common'); var ticks = 18; var expectedData = 19; var rs = new Readable({ objectMode: true, read: function read() { if (ticks-- > 0) return process.nextTick(function () { return rs.push({}); }); rs.push({}); rs.push(null); } }); 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. var ondata = common.mustCall(function (data) { rs.pause(); expectedData--; if (expectedData <= 0) return; setImmediate(function () { rs.removeListener('data', ondata); readAndPause(); rs.resume(); }); }, 1); // only call ondata once 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-readable-then-resume.js000066400000000000000000000017521362132315000276560ustar00rootroot00000000000000"use strict"; /**/ 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 check(new Readable({ objectMode: true, highWaterMark: 1, read: function read() { if (!this.first) { this.push('hello'); this.first = true; return; } this.push(null); } })); function check(s) { var readableListener = common.mustNotCall(); s.on('readable', readableListener); s.on('end', common.mustCall()); 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-reading-readingMore.js000066400000000000000000000113351362132315000275260ustar00rootroot00000000000000"use strict"; /**/ 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(size) {} }); 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 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.ended, !state.reading); var data = readable.read(); 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 assert.strictEqual(state.reading, true); assert.strictEqual(state.readingMore, true); // add chunk to front readable.unshift('unshifted'); // end readable.push(null); } { var _readable = new Readable({ read: function read(size) {} }); 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 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 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); } _readable.on('end', common.mustCall(onStreamEnd)); _readable.push('pushed'); // stop emitting 'data' events assert.strictEqual(_state.flowing, true); _readable.pause(); // 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 _readable.push(null); } { var _readable2 = new Readable({ read: function read(size) {} }); var _state2 = _readable2._readableState; // 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); 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 process.nextTick(function () { _readable2.resume(); // stop emitting 'data' events assert.strictEqual(_state2.flowing, true); _readable2.pause(); // paused assert.strictEqual(_state2.flowing, false); _readable2.resume(); assert.strictEqual(_state2.flowing, true); // 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-resume-hwm.js000066400000000000000000000020731362132315000257530ustar00rootroot00000000000000"use strict"; /**/ 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. var readable = new Readable({ read: common.mustNotCall(), highWaterMark: 100 }); // Fill up the internal buffer so that we definitely exceed the HWM: for (var i = 0; i < 10; i++) { readable.push('a'.repeat(200)); } // 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-resumeScheduled.js000066400000000000000000000043751362132315000270120ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); // Testing Readable Stream resumeScheduled state var assert = require('assert/'); var _require = require('../../'), Readable = _require.Readable, Writable = _require.Writable; { // pipe() test case var r = new Readable({ read: function read() {} }); var w = new Writable(); // 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 () { assert.strictEqual(r._readableState.resumeScheduled, false); })); } { // 'data' listener test case var _r = new Readable({ read: function read() {} }); // resumeScheduled should start = `false`. assert.strictEqual(_r._readableState.resumeScheduled, false); _r.push(bufferShim.from([1, 2, 3])); // 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); })); } { // 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. _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); });readable-stream-3.6.0/test/parallel/test-stream-readable-setEncoding-existing-buffers.js000066400000000000000000000036361362132315000314140ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ require('../common'); var _require = require('../../'), Readable = _require.Readable; var assert = require('assert/'); { // Call .setEncoding() while there are bytes already in the buffer. var r = new Readable({ read: function read() {} }); r.push(bufferShim.from('a')); r.push(bufferShim.from('b')); r.setEncoding('utf8'); var chunks = []; r.on('data', function (chunk) { return chunks.push(chunk); }); process.nextTick(function () { assert.deepStrictEqual(chunks, ['ab']); }); } { // Call .setEncoding() while the buffer contains a complete, // but chunked character. 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, ['🎉']); }); } { // Call .setEncoding() while the buffer contains an incomplete character, // and finish the character later. 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-setEncoding-null.js000066400000000000000000000013131362132315000270700ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ require('../common'); var assert = require('assert/'); var _require = require('../../'), Readable = _require.Readable; { var readable = new Readable({ encoding: 'hex' }); assert.strictEqual(readable._readableState.encoding, 'hex'); readable.setEncoding(null); 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); });readable-stream-3.6.0/test/parallel/test-stream-readable-with-unimplemented-_read.js000066400000000000000000000012431362132315000305470ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('../../'), Readable = _require.Readable; var readable = new Readable(); readable.on('error', common.expectsError({ code: 'ERR_METHOD_NOT_IMPLEMENTED', type: Error, message: 'The _read() method is not implemented' })); 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); });readable-stream-3.6.0/test/parallel/test-stream-readableListening-state.js000066400000000000000000000024641362132315000266630ustar00rootroot00000000000000"use strict"; /**/ 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`. assert.strictEqual(r._readableState.readableListening, false); r.on('readable', common.mustCall(function () { // Inside the readable event this state should be true. assert.strictEqual(r._readableState.readableListening, true); })); r.push(bufferShim.from('Testing readableListening state')); var r2 = new stream.Readable({ read: function read() {} }); // 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 // a `readable` listener assert.strictEqual(r2._readableState.readableListening, false); })); 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); });readable-stream-3.6.0/test/parallel/test-stream-transform-callback-twice.js000066400000000000000000000013471362132315000270060ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('../../'), Transform = _require.Transform; var stream = new Transform({ transform: function transform(chunk, enc, cb) { cb(); cb(); } }); stream.on('error', common.expectsError({ type: Error, message: 'Callback called multiple times', code: 'ERR_MULTIPLE_CALLBACK' })); 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); });readable-stream-3.6.0/test/parallel/test-stream-transform-constructor-set-methods.js000066400000000000000000000022621362132315000307550ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('assert/'), strictEqual = _require.strictEqual; var _require2 = require('../../'), Transform = _require2.Transform; var t = new Transform(); t.on('error', common.expectsError({ type: Error, code: 'ERR_METHOD_NOT_IMPLEMENTED', 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, final: _final }); strictEqual(t2._transform, _transform); strictEqual(t2._flush, _flush); 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); });readable-stream-3.6.0/test/parallel/test-stream-transform-destroy.js000066400000000000000000000074761362132315000256430ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('../../'), Transform = _require.Transform; var assert = require('assert/'); { var transform = new Transform({ transform: function transform(chunk, enc, cb) {} }); transform.resume(); transform.on('end', common.mustNotCall()); transform.on('close', common.mustCall()); transform.on('finish', common.mustNotCall()); transform.destroy(); } { 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) { assert.strictEqual(err, _expected2); 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')); // 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); });readable-stream-3.6.0/test/parallel/test-stream-transform-final-sync.js000066400000000000000000000052461362132315000262060ustar00rootroot00000000000000"use strict"; /**/ 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({ transform: function transformCallback(chunk, _, next) { // part 1 this.push(chunk); //part 2 next(); }, final: function endCallback(done) { // part 1 process.nextTick(function () { // part 2 done(); }); }, flush: function flushCallback(done) { // part 1 process.nextTick(function () { // part 2 done(); }); } }); t.on('data', dataListener); t.on('end', endListener); t.on('finish', finishListener); t.write(1); t.write(4); t.end(7, endMethodCallback); The order things are called 1. transformCallback part 1 2. dataListener 3. transformCallback part 2 4. transformCallback part 1 5. dataListener 6. transformCallback part 2 7. transformCallback part 1 8. dataListener 9. transformCallback part 2 10. finalCallback part 1 11. finalCallback part 2 12. flushCallback part 1 13. finishListener 14. endMethodCallback 15. flushCallback part 2 16. endListener */ var t = new stream.Transform({ objectMode: true, transform: common.mustCall(function (chunk, _, next) { // transformCallback part 1 assert.strictEqual(++state, chunk); this.push(state); // transformCallback part 2 assert.strictEqual(++state, chunk + 2); process.nextTick(next); }, 3), final: common.mustCall(function (done) { state++; // finalCallback part 1 assert.strictEqual(state, 10); state++; // finalCallback part 2 assert.strictEqual(state, 11); done(); }, 1), flush: common.mustCall(function (done) { state++; // fluchCallback part 1 assert.strictEqual(state, 12); process.nextTick(function () { state++; // fluchCallback part 2 assert.strictEqual(state, 15); done(); }); }, 1) }); t.on('finish', common.mustCall(function () { state++; // finishListener assert.strictEqual(state, 13); }, 1)); t.on('end', common.mustCall(function () { state++; // endEvent assert.strictEqual(state, 16); }, 1)); t.on('data', common.mustCall(function (d) { // dataListener assert.strictEqual(++state, d + 1); }, 3)); t.write(1); t.write(4); t.end(7, common.mustCall(function () { 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); });readable-stream-3.6.0/test/parallel/test-stream-transform-final.js000066400000000000000000000053271362132315000252340ustar00rootroot00000000000000"use strict"; /**/ 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({ transform: function transformCallback(chunk, _, next) { // part 1 this.push(chunk); //part 2 next(); }, final: function endCallback(done) { // part 1 process.nextTick(function () { // part 2 done(); }); }, flush: function flushCallback(done) { // part 1 process.nextTick(function () { // part 2 done(); }); } }); t.on('data', dataListener); t.on('end', endListener); t.on('finish', finishListener); t.write(1); t.write(4); t.end(7, endMethodCallback); The order things are called 1. transformCallback part 1 2. dataListener 3. transformCallback part 2 4. transformCallback part 1 5. dataListener 6. transformCallback part 2 7. transformCallback part 1 8. dataListener 9. transformCallback part 2 10. finalCallback part 1 11. finalCallback part 2 12. flushCallback part 1 13. finishListener 14. endMethodCallback 15. flushCallback part 2 16. endListener */ var t = new stream.Transform({ objectMode: true, transform: common.mustCall(function (chunk, _, next) { // transformCallback part 1 assert.strictEqual(++state, chunk); this.push(state); // transformCallback part 2 assert.strictEqual(++state, chunk + 2); process.nextTick(next); }, 3), final: common.mustCall(function (done) { state++; // finalCallback part 1 assert.strictEqual(state, 10); setTimeout(function () { state++; // finalCallback part 2 assert.strictEqual(state, 11); done(); }, 100); }, 1), flush: common.mustCall(function (done) { state++; // flushCallback part 1 assert.strictEqual(state, 12); process.nextTick(function () { state++; // flushCallback part 2 assert.strictEqual(state, 15); done(); }); }, 1) }); t.on('finish', common.mustCall(function () { state++; // finishListener assert.strictEqual(state, 13); }, 1)); t.on('end', common.mustCall(function () { state++; // end event assert.strictEqual(state, 16); }, 1)); t.on('data', common.mustCall(function (d) { // dataListener assert.strictEqual(++state, d + 1); }, 3)); t.write(1); t.write(4); t.end(7, common.mustCall(function () { 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); });readable-stream-3.6.0/test/parallel/test-stream-transform-flush-data.js000066400000000000000000000014011362132315000261600ustar00rootroot00000000000000"use strict"; /**/ 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 }); t.end(bufferShim.from('blerg')); 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); });readable-stream-3.6.0/test/parallel/test-stream-transform-objectmode-falsey-value.js000066400000000000000000000042701362132315000306450ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ var common = require('../common'); var assert = require('assert/'); var stream = require('../../'); var PassThrough = stream.PassThrough; var src = new PassThrough({ objectMode: true }); var tx = new PassThrough({ objectMode: true }); var dest = new PassThrough({ objectMode: true }); var expect = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; var results = []; dest.on('data', common.mustCall(function (x) { results.push(x); }, expect.length)); src.pipe(tx).pipe(dest); var i = -1; var int = setInterval(common.mustCall(function () { if (results.length === expect.length) { src.end(); clearInterval(int); assert.deepStrictEqual(results, expect); } else { src.write(i++); } }, 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); });readable-stream-3.6.0/test/parallel/test-stream-transform-split-highwatermark.js000066400000000000000000000057671362132315000301410ustar00rootroot00000000000000"use strict"; /**/ 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; 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 testTransform(666, DEFAULT, { readableHighWaterMark: 666 }); testTransform(DEFAULT, 777, { writableHighWaterMark: 777 }); testTransform(666, 777, { readableHighWaterMark: 666, writableHighWaterMark: 777 }); // test 0 overriding defaultHwm testTransform(0, DEFAULT, { readableHighWaterMark: 0 }); testTransform(DEFAULT, 0, { writableHighWaterMark: 0 }); // test highWaterMark overriding testTransform(555, 555, { highWaterMark: 555, readableHighWaterMark: 666 }); testTransform(555, 555, { highWaterMark: 555, writableHighWaterMark: 777 }); testTransform(555, 555, { highWaterMark: 555, readableHighWaterMark: 666, writableHighWaterMark: 777 }); // test highWaterMark = 0 overriding testTransform(0, 0, { highWaterMark: 0, readableHighWaterMark: 666 }); testTransform(0, 0, { highWaterMark: 0, writableHighWaterMark: 777 }); testTransform(0, 0, { highWaterMark: 0, readableHighWaterMark: 666, writableHighWaterMark: 777 }); // test undefined, null [undefined, null].forEach(function (v) { testTransform(DEFAULT, DEFAULT, { readableHighWaterMark: v }); testTransform(DEFAULT, DEFAULT, { writableHighWaterMark: v }); testTransform(666, DEFAULT, { highWaterMark: v, readableHighWaterMark: 666 }); testTransform(DEFAULT, 777, { highWaterMark: v, writableHighWaterMark: 777 }); }); // test NaN { common.expectsError(function () { new Transform({ readableHighWaterMark: NaN }); }, { type: TypeError, code: 'ERR_INVALID_OPT_VALUE', message: 'The value "NaN" is invalid for option "readableHighWaterMark"' }); common.expectsError(function () { new Transform({ writableHighWaterMark: NaN }); }, { type: TypeError, code: 'ERR_INVALID_OPT_VALUE', message: 'The value "NaN" is invalid for option "writableHighWaterMark"' }); } // test non Duplex streams ignore the options { var r = new Readable({ readableHighWaterMark: 666 }); assert.strictEqual(r._readableState.highWaterMark, DEFAULT); var w = new Writable({ writableHighWaterMark: 777 }); 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); });readable-stream-3.6.0/test/parallel/test-stream-transform-split-objectmode.js000066400000000000000000000060011362132315000273750ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 Transform = require('../../').Transform; var parser = new Transform({ readableObjectMode: true }); assert(parser._readableState.objectMode); assert(!parser._writableState.objectMode); 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; }); parser.end(bufferShim.from([42])); process.on('exit', function () { assert.strictEqual(parsed.val, 42); }); var serializer = new Transform({ writableObjectMode: true }); assert(!serializer._readableState.objectMode); assert(serializer._writableState.objectMode); 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; }); serializer.write({ val: 42 }); 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); });readable-stream-3.6.0/test/parallel/test-stream-uint8array.js000066400000000000000000000063711362132315000242400ustar00rootroot00000000000000"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; } } /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var assert = require('assert/'); var _require = require('../../'), 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) }); writable.write(ABC); writable.end(DEF); } { // Writable test, pass in Uint8Array in object mode. var _writable = new Writable({ objectMode: true, write: common.mustCall(function (chunk, encoding, cb) { assert(!(chunk instanceof Buffer)); assert(chunk instanceof Uint8Array); assert.strictEqual(chunk, ABC); assert.strictEqual(encoding, 'utf8'); 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); assert.strictEqual(encoding, 'buffer'); assert.strictEqual(String(chunk), 'ABC'); callback = cb; }), writev: common.mustCall(function (chunks, cb) { assert.strictEqual(chunks.length, 2); assert.strictEqual(chunks[0].encoding, 'buffer'); assert.strictEqual(chunks[1].encoding, 'buffer'); assert.strictEqual(chunks[0].chunk + chunks[1].chunk, 'DEFGHI'); }) }); _writable2.write(ABC); _writable2.write(DEF); _writable2.end(GHI); callback(); } { // Simple Readable test. var readable = new Readable({ read: function read() {} }); readable.push(DEF); readable.unshift(ABC); var buf = readable.read(); assert(buf instanceof Buffer); assert.deepStrictEqual(_toConsumableArray(buf), [].concat(_toConsumableArray(ABC), _toConsumableArray(DEF))); } { // Readable test, setEncoding. 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); });readable-stream-3.6.0/test/parallel/test-stream-unpipe-event.js000066400000000000000000000127521362132315000245510ustar00rootroot00000000000000"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 _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); } 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) { _inherits(NullWriteable, _Writable); function NullWriteable() { _classCallCheck(this, NullWriteable); return _possibleConstructorReturn(this, _getPrototypeOf(NullWriteable).apply(this, arguments)); } _createClass(NullWriteable, [{ key: "_write", value: function _write(chunk, encoding, callback) { return callback(); } }]); return NullWriteable; }(Writable); var QuickEndReadable = /*#__PURE__*/ function (_Readable) { _inherits(QuickEndReadable, _Readable); function QuickEndReadable() { _classCallCheck(this, QuickEndReadable); return _possibleConstructorReturn(this, _getPrototypeOf(QuickEndReadable).apply(this, arguments)); } _createClass(QuickEndReadable, [{ key: "_read", value: function _read() { this.push(null); } }]); return QuickEndReadable; }(Readable); var NeverEndReadable = /*#__PURE__*/ function (_Readable2) { _inherits(NeverEndReadable, _Readable2); function NeverEndReadable() { _classCallCheck(this, NeverEndReadable); return _possibleConstructorReturn(this, _getPrototypeOf(NeverEndReadable).apply(this, arguments)); } _createClass(NeverEndReadable, [{ key: "_read", value: function _read() {} }]); return NeverEndReadable; }(Readable); { var dest = new NullWriteable(); var src = new QuickEndReadable(); dest.on('pipe', common.mustCall()); dest.on('unpipe', common.mustCall()); src.pipe(dest); setImmediate(function () { assert.strictEqual(src._readableState.pipesCount, 0); }); } { 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); });readable-stream-3.6.0/test/parallel/test-stream-unshift-empty-chunk.js000066400000000000000000000053061362132315000260510ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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/'); // 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, // 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); } }); 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); });readable-stream-3.6.0/test/parallel/test-stream-unshift-read-race.js000066400000000000000000000107111362132315000254240ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ var common = require('../common'); var assert = require('assert/'); // 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 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); if (c === null) pushError(); } else { setTimeout(function () { pos += n; r.push(c); if (c === null) pushError(); }, 1); } } }; function pushError() { common.expectsError(function () { r.push(bufferShim.allocUnsafe(1)); }, { code: 'ERR_STREAM_PUSH_AFTER_EOF', type: Error, 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)); }, { code: 'ERR_STREAM_UNSHIFT_AFTER_END_EVENT', type: Error, message: 'stream.unshift() after end event' }); w.end(); })); r.on('readable', function () { var chunk; while (null !== (chunk = r.read(10))) { w.write(chunk); if (chunk.length > 4) r.unshift(bufferShim.from('1234')); } }); w.on('finish', common.mustCall(function () { // each chunk should start with 1234, and then be asfdasdfasdf... // The first got pulled out before the first unshift('1234'), so it's // lacking that piece. 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; } } } })); 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); });readable-stream-3.6.0/test/parallel/test-stream-writable-change-default-encoding.js000066400000000000000000000116161362132315000303720ustar00rootroot00000000000000"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 _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); } // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ var common = require('../common'); var assert = require('assert/'); var stream = require('../../'); var MyWritable = /*#__PURE__*/ function (_stream$Writable) { _inherits(MyWritable, _stream$Writable); function MyWritable(fn, options) { var _this; _classCallCheck(this, MyWritable); _this = _possibleConstructorReturn(this, _getPrototypeOf(MyWritable).call(this, options)); _this.fn = fn; return _this; } _createClass(MyWritable, [{ key: "_write", value: function _write(chunk, encoding, callback) { this.fn(Buffer.isBuffer(chunk), typeof chunk, encoding); callback(); } }]); return MyWritable; }(stream.Writable); (function defaultCondingIsUtf8() { var m = new MyWritable(function (isBuffer, type, enc) { assert.strictEqual(enc, 'utf8'); }, { decodeStrings: false }); m.write('foo'); m.end(); })(); (function changeDefaultEncodingToAscii() { var m = new MyWritable(function (isBuffer, type, enc) { assert.strictEqual(enc, 'ascii'); }, { decodeStrings: false }); m.setDefaultEncoding('ascii'); m.write('bar'); m.end(); })(); common.expectsError(function changeDefaultEncodingToInvalidValue() { var m = new MyWritable(function (isBuffer, type, enc) {}, { decodeStrings: false }); m.setDefaultEncoding({}); m.write('bar'); m.end(); }, { type: TypeError, code: 'ERR_UNKNOWN_ENCODING', message: 'Unknown encoding: [object Object]' }); (function checkVairableCaseEncoding() { var m = new MyWritable(function (isBuffer, type, enc) { assert.strictEqual(enc, 'ascii'); }, { decodeStrings: false }); m.setDefaultEncoding('AsCii'); 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); });readable-stream-3.6.0/test/parallel/test-stream-writable-constructor-set-methods.js000066400000000000000000000022471362132315000305560ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('assert/'), strictEqual = _require.strictEqual; var _require2 = require('../../'), Writable = _require2.Writable; var w = new Writable(); w.on('error', common.expectsError({ type: Error, code: 'ERR_METHOD_NOT_IMPLEMENTED', 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 }); strictEqual(w2._write, _write); strictEqual(w2._writev, _writev); w2.write(bufferShim.from('blerg')); w2.cork(); 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); });readable-stream-3.6.0/test/parallel/test-stream-writable-decoded-encoding.js000066400000000000000000000105601362132315000271070ustar00rootroot00000000000000"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 _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); } // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 stream = require('../../'); var MyWritable = /*#__PURE__*/ function (_stream$Writable) { _inherits(MyWritable, _stream$Writable); function MyWritable(fn, options) { var _this; _classCallCheck(this, MyWritable); _this = _possibleConstructorReturn(this, _getPrototypeOf(MyWritable).call(this, options)); _this.fn = fn; return _this; } _createClass(MyWritable, [{ key: "_write", value: function _write(chunk, encoding, callback) { this.fn(Buffer.isBuffer(chunk), typeof chunk, encoding); callback(); } }]); return MyWritable; }(stream.Writable); { var m = new MyWritable(function (isBuffer, type, enc) { assert(isBuffer); assert.strictEqual(type, 'object'); assert.strictEqual(enc, 'buffer'); }, { decodeStrings: true }); m.write('some-text', 'utf8'); m.end(); } { var _m = new MyWritable(function (isBuffer, type, enc) { assert(!isBuffer); assert.strictEqual(type, 'string'); assert.strictEqual(enc, 'utf8'); }, { 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); });readable-stream-3.6.0/test/parallel/test-stream-writable-destroy.js000066400000000000000000000135641362132315000254340ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('../../'), Writable = _require.Writable; var assert = require('assert/'); { var write = new Writable({ write: function write(chunk, enc, cb) { cb(); } }); write.on('finish', common.mustNotCall()); write.on('close', common.mustCall()); write.destroy(); assert.strictEqual(write.destroyed, true); } { var _write = new Writable({ write: function write(chunk, enc, cb) { 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); } { var _write2 = new Writable({ write: function write(chunk, enc, cb) { 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); } { var _write3 = new Writable({ write: function write(chunk, enc, cb) { cb(); }, destroy: common.mustCall(function (err, cb) { assert.strictEqual(err, _expected2); cb(); }) }); var _expected2 = new Error('kaboom'); _write3.on('finish', common.mustNotCall('no finish event')); _write3.on('close', common.mustCall()); // error is swallowed by the custom _destroy _write3.on('error', common.mustNotCall('no error event')); _write3.destroy(_expected2); assert.strictEqual(_write3.destroyed, true); } { var _write4 = new Writable({ write: function write(chunk, enc, cb) { cb(); } }); _write4._destroy = common.mustCall(function (err, cb) { assert.strictEqual(err, null); cb(); }); _write4.destroy(); assert.strictEqual(_write4.destroyed, true); } { var _write5 = new Writable({ write: function write(chunk, enc, cb) { 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); } { var _write6 = new Writable({ write: function write(chunk, enc, cb) { 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); } { // double error case var _write7 = new Writable({ write: function write(chunk, enc, cb) { 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); } { var writable = new Writable({ destroy: common.mustCall(function (err, cb) { process.nextTick(cb, new Error('kaboom 1')); }), write: function write(chunk, enc, cb) { cb(); } }); writable.on('close', common.mustCall()); writable.on('error', common.expectsError({ type: Error, message: 'kaboom 2' })); 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. writable.destroy(new Error('kaboom 2')); assert.strictEqual(writable._writableState.errorEmitted, true); } { var _write8 = new Writable({ write: function write(chunk, enc, cb) { cb(); } }); _write8.destroyed = true; assert.strictEqual(_write8.destroyed, true); // the internal destroy() mechanism should not be triggered _write8.on('close', common.mustNotCall()); _write8.destroy(); } { 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(); } { // destroy and destroy callback var _write9 = new Writable({ write: function write(chunk, enc, cb) { cb(); } }); _write9.destroy(); var _expected4 = new Error('kaboom'); _write9.destroy(_expected4, common.mustCall(function (err) { assert.strictEqual(err, _expected4); })); } { // Checks that `._undestroy()` restores the state so that `final` will be // called again. var _write10 = new Writable({ write: common.mustNotCall(), final: common.mustCall(function (cb) { 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); });readable-stream-3.6.0/test/parallel/test-stream-writable-ended-state.js000066400000000000000000000015601362132315000261310ustar00rootroot00000000000000"use strict"; /**/ 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); });readable-stream-3.6.0/test/parallel/test-stream-writable-finished-state.js000066400000000000000000000016541362132315000266470ustar00rootroot00000000000000"use strict"; /**/ 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); })); 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); });readable-stream-3.6.0/test/parallel/test-stream-writable-needdrain-state.js000066400000000000000000000016421362132315000270040ustar00rootroot00000000000000"use strict"; /**/ 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); });readable-stream-3.6.0/test/parallel/test-stream-writable-null.js000066400000000000000000000073071362132315000247130ustar00rootroot00000000000000"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 _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); } /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var assert = require('assert/'); var stream = require('../../'); var MyWritable = /*#__PURE__*/ function (_stream$Writable) { _inherits(MyWritable, _stream$Writable); function MyWritable() { _classCallCheck(this, MyWritable); return _possibleConstructorReturn(this, _getPrototypeOf(MyWritable).apply(this, arguments)); } _createClass(MyWritable, [{ key: "_write", value: function _write(chunk, encoding, callback) { assert.notStrictEqual(chunk, null); callback(); } }]); return MyWritable; }(stream.Writable); common.expectsError(function () { var m = new MyWritable({ objectMode: true }); m.write(null, function (err) { return assert.ok(err); }); }, { code: 'ERR_STREAM_NULL_VALUES', type: TypeError, message: 'May not write null values to stream' }); { // Should not throw. var m = new MyWritable({ objectMode: true }).on('error', assert); m.write(null, assert); } common.expectsError(function () { var m = new MyWritable(); m.write(false, function (err) { return assert.ok(err); }); }, { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }); { // Should not throw. var _m = new MyWritable().on('error', assert); _m.write(false, assert); } { // Should not throw. var _m2 = new MyWritable({ objectMode: true }); _m2.write(false, assert.ifError); } { // Should not throw. var _m3 = new MyWritable({ objectMode: true }).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); });readable-stream-3.6.0/test/parallel/test-stream-writable-write-cb-twice.js000066400000000000000000000025441362132315000265640ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var _require = require('../../'), Writable = _require.Writable; { // Sync + Sync var writable = new Writable({ write: common.mustCall(function (buf, enc, cb) { cb(); common.expectsError(cb, { code: 'ERR_MULTIPLE_CALLBACK', type: Error }); }) }); writable.write('hi'); } { // Sync + Async var _writable = new Writable({ write: common.mustCall(function (buf, enc, cb) { cb(); process.nextTick(function () { common.expectsError(cb, { code: 'ERR_MULTIPLE_CALLBACK', type: Error }); }); }) }); _writable.write('hi'); } { // Async + Async var _writable2 = new Writable({ write: common.mustCall(function (buf, enc, cb) { process.nextTick(cb); process.nextTick(function () { common.expectsError(cb, { code: 'ERR_MULTIPLE_CALLBACK', type: Error }); }); }) }); _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); });readable-stream-3.6.0/test/parallel/test-stream-writable-write-writev-finish.js000066400000000000000000000103651362132315000276650ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ var common = require('../common'); var assert = require('assert/'); var stream = require('../../'); // 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); })); 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 _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 // 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 () { assert.strictEqual(_firstError4, true); })); 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"); }); w.end(); } { 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); });readable-stream-3.6.0/test/parallel/test-stream-writableState-ending.js000066400000000000000000000024021362132315000261750ustar00rootroot00000000000000"use strict"; /**/ 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); }); 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. 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); });readable-stream-3.6.0/test/parallel/test-stream-writableState-uncorked-bufferedRequestCount.js000066400000000000000000000037101362132315000327100ustar00rootroot00000000000000"use strict"; /**/ 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); cb(); }, 1); writable._write = common.mustCall(function (chunk, encoding, cb) { cb(); }, 1); // first cork writable.cork(); assert.strictEqual(writable._writableState.corked, 1); assert.strictEqual(writable._writableState.bufferedRequestCount, 0); // cork again writable.cork(); 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 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 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 writable.cork(); writable.write('third chunk'); 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); });readable-stream-3.6.0/test/parallel/test-stream-write-destroy.js000066400000000000000000000047401362132315000247510ustar00rootroot00000000000000"use strict"; /**/ 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. 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 = []; var w = new Writable({ write: function write(data, enc, cb) { callbacks.push(cb); }, // Effectively disable the HWM to observe 'drain' events more easily. highWaterMark: 1 }); var chunksWritten = 0; var drains = 0; var finished = false; w.on('drain', function () { return drains++; }); w.on('finish', function () { return finished = true; }); w.write('abc', function () { return chunksWritten++; }); assert.strictEqual(chunksWritten, 0); assert.strictEqual(drains, 0); 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.) w.write('def', function () { return chunksWritten++; }); } if (useEnd) { // Again, test 2 cases: Either we indicate that we want to end the // writable or not. w.end('ghi', function () { return chunksWritten++; }); } else { w.write('ghi', function () { 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(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); });readable-stream-3.6.0/test/parallel/test-stream-write-final.js000066400000000000000000000016001362132315000243410ustar00rootroot00000000000000"use strict"; /**/ 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) { assert.strictEqual(this, w); setTimeout(function () { shutdown = true; cb(); }, 100); }), write: function write(chunk, e, cb) { process.nextTick(cb); } }); w.on('finish', common.mustCall(function () { assert(shutdown); })); 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); });readable-stream-3.6.0/test/parallel/test-stream-writev.js000066400000000000000000000076131362132315000234520ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ 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++) { queue.push([!!decode, !!uncork, !!multi]); } } } 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; return function (er) { assert.ifError(er); counter++; assert.strictEqual(counter, expect); }; } var w = new stream.Writable({ decodeStrings: decode }); w._write = common.mustNotCall('Should not call _write'); var expectChunks = decode ? [{ encoding: 'buffer', chunk: [104, 101, 108, 108, 111, 44, 32] }, { encoding: 'buffer', chunk: [119, 111, 114, 108, 100] }, { encoding: 'buffer', chunk: [33] }, { encoding: 'buffer', chunk: [10, 97, 110, 100, 32, 116, 104, 101, 110, 46, 46, 46] }, { encoding: 'buffer', chunk: [250, 206, 190, 167, 222, 173, 190, 239, 222, 202, 251, 173] }] : [{ encoding: 'ascii', chunk: 'hello, ' }, { encoding: 'utf8', chunk: 'world' }, { encoding: 'buffer', chunk: [33] }, { encoding: 'latin1', chunk: '\nand then...' }, { encoding: 'hex', chunk: 'facebea7deadbeefdecafbad' }]; var actualChunks; w._writev = function (chunks, cb) { actualChunks = chunks.map(function (chunk) { return { encoding: chunk.encoding, chunk: Buffer.isBuffer(chunk.chunk) ? Array.prototype.slice.call(chunk.chunk) : chunk.chunk }; }); cb(); }; w.cork(); w.write('hello, ', 'ascii', cnt('hello')); w.write('world', 'utf8', cnt('world')); if (multi) w.cork(); w.write(bufferShim.from('!'), 'buffer', cnt('!')); w.write('\nand then...', 'latin1', cnt('and then')); if (multi) w.uncork(); w.write('facebea7deadbeefdecafbad', 'hex', cnt('hex')); if (uncork) w.uncork(); w.end(cnt('end')); w.on('finish', function () { // make sure finish comes after all the write cb cnt('finish')(); assert.deepStrictEqual(actualChunks, expectChunks); 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); });readable-stream-3.6.0/test/parallel/test-stream2-base64-single-char-read-end.js000066400000000000000000000042721362132315000271450ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 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; process.nextTick(function () { src.push(bufferShim.from('1')); src.push(null); }); } }; dst._write = function (chunk, enc, cb) { accum.push(chunk); cb(); }; src.on('end', function () { assert.strictEqual(String(Buffer.concat(accum)), 'MQ=='); clearTimeout(timeout); }); src.pipe(dst); 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); });readable-stream-3.6.0/test/parallel/test-stream2-basic.js000066400000000000000000000271651362132315000233010ustar00rootroot00000000000000"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 _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); } // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ var common = require('../common'); var R = require('../../lib/_stream_readable'); var assert = require('assert/'); var EE = require('events').EventEmitter; var TestReader = /*#__PURE__*/ function (_R) { _inherits(TestReader, _R); function TestReader(n) { var _this; _classCallCheck(this, TestReader); _this = _possibleConstructorReturn(this, _getPrototypeOf(TestReader).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); } else { // now we have more. // kinda cheating by calling _read, but whatever, // it's just fake anyway. _this2._read(n); } }, 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) { _inherits(TestWriter, _EE); function TestWriter() { var _this3; _classCallCheck(this, TestWriter); _this3 = _possibleConstructorReturn(this, _getPrototypeOf(TestWriter).call(this)); _this3.received = []; _this3.flush = false; return _this3; } _createClass(TestWriter, [{ key: "write", value: function write(c) { this.received.push(c.toString()); this.emit('write', c); return true; } }, { key: "end", value: function end(c) { if (c) this.write(c); this.emit('end', this.received); } }]); return TestWriter; }(EE); { // Test basic functionality var r = new TestReader(20); var reads = []; var expect = ['x', 'xx', 'xxx', 'xxxx', 'xxxxx', 'xxxxxxxxx', 'xxxxxxxxxx', 'xxxxxxxxxxxx', 'xxxxxxxxxxxxx', 'xxxxxxxxxxxxxxx', 'xxxxxxxxxxxxxxxxx', 'xxxxxxxxxxxxxxxxxxx', 'xxxxxxxxxxxxxxxxxxxxx', 'xxxxxxxxxxxxxxxxxxxxxxx', 'xxxxxxxxxxxxxxxxxxxxxxxxx', 'xxxxxxxxxxxxxxxxxxxxx']; r.on('end', common.mustCall(function () { 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 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()]; var writes = SPLIT; w[0].on('write', function () { if (--writes === 0) { r.unpipe(); assert.strictEqual(r._readableState.pipes, null); w[0].end(); r.pipe(w[1]); assert.strictEqual(r._readableState.pipes, w[1]); } }); var ended = 0; w[0].on('end', common.mustCall(function (results) { ended++; assert.strictEqual(ended, 1); assert.deepStrictEqual(results, expect[0]); })); w[1].on('end', common.mustCall(function (results) { ended++; assert.strictEqual(ended, 2); assert.deepStrictEqual(results, expect[1]); })); r.pipe(w[0]); }); { // 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 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()]; var writes = SPLIT; w[0].on('write', function () { if (--writes === 0) { r.unpipe(); w[0].end(); r.pipe(w[1]); } }); var ended = 0; w[0].on('end', common.mustCall(function (results) { ended++; assert.strictEqual(ended, 1); assert.deepStrictEqual(results, expect[0]); })); w[1].on('end', common.mustCall(function (results) { ended++; assert.strictEqual(ended, 2); assert.deepStrictEqual(results, expect[1]); })); r.pipe(w[0]); r.pipe(w[2]); }); { // Verify that back pressure is respected 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); }); } { // 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); }); } { // Verify that adding readable listeners trigger data flow 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); })); } { // 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); });readable-stream-3.6.0/test/parallel/test-stream2-compatibility.js000066400000000000000000000113741362132315000250640ustar00rootroot00000000000000"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 _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); } // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 R = require('../../lib/_stream_readable'); var W = require('../../lib/_stream_writable'); var assert = require('assert/'); var ondataCalled = 0; var TestReader = /*#__PURE__*/ function (_R) { _inherits(TestReader, _R); function TestReader() { var _this; _classCallCheck(this, TestReader); _this = _possibleConstructorReturn(this, _getPrototypeOf(TestReader).call(this)); _this._buffer = bufferShim.alloc(100, 'x'); _this.on('data', function () { ondataCalled++; }); return _this; } _createClass(TestReader, [{ key: "_read", value: function _read(n) { this.push(this._buffer); 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) { _inherits(TestWriter, _W); function TestWriter() { var _this2; _classCallCheck(this, TestWriter); _this2 = _possibleConstructorReturn(this, _getPrototypeOf(TestWriter).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); });readable-stream-3.6.0/test/parallel/test-stream2-decode-partial.js000066400000000000000000000016631362132315000250700ustar00rootroot00000000000000"use strict"; /**/ 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]); var source = Buffer.concat([euro, cent]); var readable = Readable({ encoding: 'utf8' }); readable.push(source.slice(0, 2)); readable.push(source.slice(2, 4)); readable.push(source.slice(4, source.length)); ; readable.push(null); readable.on('data', function (data) { buf += data; }); 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); });readable-stream-3.6.0/test/parallel/test-stream2-finish-pipe.js000066400000000000000000000036511362132315000244250ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 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); // 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); });readable-stream-3.6.0/test/parallel/test-stream2-large-read-stall.js000066400000000000000000000053031362132315000253260ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ var common = require('../common'); var assert = require('assert/'); // 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 }); var rs = r._readableState; r._read = push; r.on('readable', function () { ; false && console.error('>> readable'); var ret; do { ; false && console.error(" > read(".concat(READSIZE, ")")); ret = r.read(READSIZE); ; 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); }); 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); });readable-stream-3.6.0/test/parallel/test-stream2-objects.js000066400000000000000000000162201362132315000236370ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ 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 }); r._read = common.mustNotCall(); forEach(list, function (chunk) { r.push(chunk); }); r.push(null); return r; } { // Verify that objects can be read from the stream var r = fromArray([{ one: '1' }, { two: '2' }]); var v1 = r.read(); var v2 = r.read(); var v3 = r.read(); assert.deepStrictEqual(v1, { one: '1' }); assert.deepStrictEqual(v2, { two: '2' }); assert.deepStrictEqual(v3, null); } { // Verify that objects can be piped into the stream var _r = fromArray([{ one: '1' }, { two: '2' }]); _r.pipe(toArray(common.mustCall(function (list) { assert.deepStrictEqual(list, [{ one: '1' }, { two: '2' }]); }))); } { // Verify that read(n) is ignored var _r2 = fromArray([{ one: '1' }, { two: '2' }]); var value = _r2.read(2); assert.deepStrictEqual(value, { one: '1' }); } { // Verify that objects can be synchronously read 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' }, { two: '2' }]); }))); } { // Verify that objects can be asynchronously read 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' }, { two: '2' }]); }))); } { // Verify that strings can be read as objects 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); }))); } { // Verify read(0) behavior for object streams 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']); }))); } { // Verify the behavior of pushing falsey values 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, '']); }))); } { // Verify high watermark _read() behavior var _r8 = new Readable({ 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); } { // Verify high watermark push behavior var _r9 = new Readable({ 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); } } { // Verify that objects can be written to stream 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' }); w.end(); } { // Verify that multiple objects can be written to stream 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(); } { // Verify that strings can be written as objects 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(); } { // Verify that stream buffers finish until callback is called var _w3 = new Writable({ objectMode: true }); var called = false; _w3._write = function (chunk, encoding, cb) { assert.strictEqual(chunk, 'foo'); process.nextTick(function () { called = true; 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); });readable-stream-3.6.0/test/parallel/test-stream2-pipe-error-handling.js000066400000000000000000000063071362132315000260610ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 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) { gotErr = err; }); var unpipedSource; dest.on('unpipe', function (src) { unpipedSource = src; }); var err = new Error('This stream turned into bacon.'); dest.emit('error', err); assert.strictEqual(gotErr, err); assert.strictEqual(unpipedSource, source); assert.strictEqual(unpipedDest, dest); } { 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); });readable-stream-3.6.0/test/parallel/test-stream2-pipe-error-once-listener.js000066400000000000000000000106301362132315000270360ustar00rootroot00000000000000"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 _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); } // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 stream = require('../../'); var Read = /*#__PURE__*/ function (_stream$Readable) { _inherits(Read, _stream$Readable); function Read() { _classCallCheck(this, Read); return _possibleConstructorReturn(this, _getPrototypeOf(Read).apply(this, arguments)); } _createClass(Read, [{ key: "_read", value: function _read(size) { this.push('x'); this.push(null); } }]); return Read; }(stream.Readable); var Write = /*#__PURE__*/ function (_stream$Writable) { _inherits(Write, _stream$Writable); function Write() { _classCallCheck(this, Write); return _possibleConstructorReturn(this, _getPrototypeOf(Write).apply(this, arguments)); } _createClass(Write, [{ key: "_write", value: function _write(buffer, encoding, cb) { this.emit('error', new Error('boom')); this.emit('alldone'); } }]); return Write; }(stream.Writable); var read = new Read(); var write = new Write(); write.once('error', function () {}); write.once('alldone', function (err) { require('tap').pass(); }); process.on('exit', function (c) { console.error('error thrown even with listener'); }); 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); });readable-stream-3.6.0/test/parallel/test-stream2-push.js000066400000000000000000000067331362132315000231750ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 _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 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; }); source.on('data', function (chunk) { var ret = stream.push(chunk); console.error('data', stream.readableLength); if (!ret) readStop(); }); source.on('end', function () { stream.push(null); }); var reading = false; function readStart() { console.error('readStart'); reading = true; } function readStop() { console.error('readStop'); reading = false; process.nextTick(function () { var r = stream.read(); 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); // now emit some chunks. var chunk = 'asdfg'; var set = 0; readStart(); data(); function data() { assert(reading); source.emit('data', chunk); assert(reading); source.emit('data', chunk); assert(reading); source.emit('data', chunk); assert(reading); source.emit('data', chunk); 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); writer.end(stream.read()); setImmediate(function () { 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); });readable-stream-3.6.0/test/parallel/test-stream2-read-sync-stack.js000066400000000000000000000040221362132315000251730ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ var common = require('../common'); var Readable = require('../../').Readable; // 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); }); 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); });readable-stream-3.6.0/test/parallel/test-stream2-readable-empty-buffer-no-eof.js000066400000000000000000000075451362132315000275430ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 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 // result that just means that there is *temporarily* no data, but to // go ahead and try again later. // // note that this is very unusual. it only works for crypto streams // because the other side of the stream will call read(0) to cycle // data through openssl. that's why setImmediate() is used to call // r.read(0) again later, otherwise there is no more work being done // and the process just exits. 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)); } } r.on('readable', flow); r.on('end', function () { results.push('EOF'); }); 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)); } } r.on('readable', flow); r.on('end', function () { results.push('EOF'); }); 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); });readable-stream-3.6.0/test/parallel/test-stream2-readable-from-list.js000066400000000000000000000070461362132315000256650ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 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]); } 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. var ret = fromList(6, { buffer: list, length: 16 }); 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. ret = fromList(2, { buffer: list, length: 8 }); 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.deepStrictEqual(list, new BufferList()); } { // Verify behavior with strings var _list2 = ['foog', 'bark', 'bazy', 'kuel']; _list2 = bufferListFromArray(_list2); // read more than the first element. var _ret = fromList(6, { buffer: _list2, length: 16, decoder: true }); assert.strictEqual(_ret, 'foogba'); // read exactly the first element. _ret = fromList(2, { buffer: _list2, length: 10, decoder: true }); 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. _ret = fromList(100, { buffer: _list2, length: 6, decoder: true }); 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); });readable-stream-3.6.0/test/parallel/test-stream2-readable-legacy-drain.js000066400000000000000000000044301362132315000263020ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ 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(); // 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); });readable-stream-3.6.0/test/parallel/test-stream2-readable-non-empty-end.js000066400000000000000000000050621362132315000264370ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ 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 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); });readable-stream-3.6.0/test/parallel/test-stream2-readable-wrap-empty.js000066400000000000000000000035251362132315000260540ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ 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); });readable-stream-3.6.0/test/parallel/test-stream2-set-encoding.js000066400000000000000000000220531362132315000245660ustar00rootroot00000000000000"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 _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); } // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ var common = require('../common'); var assert = require('assert/'); var R = require('../../lib/_stream_readable'); var TestReader = /*#__PURE__*/ function (_R) { _inherits(TestReader, _R); function TestReader(n, opts) { var _this; _classCallCheck(this, TestReader); _this = _possibleConstructorReturn(this, _getPrototypeOf(TestReader).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); tr.setEncoding('utf8'); var out = []; 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); } }); tr.on('end', common.mustCall(function () { assert.deepStrictEqual(out, expect); })); } { // 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); } }); _tr.on('end', common.mustCall(function () { assert.deepStrictEqual(_out, _expect); })); } { // 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); } }); _tr2.on('end', common.mustCall(function () { assert.deepStrictEqual(_out2, _expect2); })); } { // 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); } }); _tr3.on('end', common.mustCall(function () { assert.deepStrictEqual(_out3, _expect3); })); } { // Verify utf8 encoding 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); } }); _tr4.on('end', common.mustCall(function () { assert.deepStrictEqual(_out4, _expect4); })); } { // Verify hex encoding 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); } }); _tr5.on('end', common.mustCall(function () { assert.deepStrictEqual(_out5, _expect5); })); } { // Verify hex encoding with read(13) 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); } }); _tr6.on('end', common.mustCall(function () { assert.deepStrictEqual(_out6, _expect6); })); } { // Verify base64 encoding 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); } }); _tr7.on('end', common.mustCall(function () { assert.deepStrictEqual(_out7, _expect7); })); } { // 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); });readable-stream-3.6.0/test/parallel/test-stream2-transform.js000066400000000000000000000315001362132315000242170ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ 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); assert.strictEqual(tx._transformState.writechunk.length, 5); assert.deepStrictEqual(tx.writableBuffer.map(function (c) { return c.chunk.length; }), [6, 7, 8, 9, 10]); } { // Verify passthrough behavior var pt = new PassThrough(); pt.write(bufferShim.from('foog')); pt.write(bufferShim.from('bark')); pt.write(bufferShim.from('bazy')); pt.write(bufferShim.from('kuel')); pt.end(); assert.strictEqual(pt.read(5).toString(), 'foogb'); assert.strictEqual(pt.read(5).toString(), 'arkba'); assert.strictEqual(pt.read(5).toString(), 'zykue'); assert.strictEqual(pt.read(5).toString(), 'l'); } { // Verify object passthrough behavior 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); assert.strictEqual(_pt.read(), 0); assert.strictEqual(_pt.read(), 'foo'); assert.strictEqual(_pt.read(), ''); assert.deepStrictEqual(_pt.read(), { a: 'b' }); } { // 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'); assert.strictEqual(_pt4.read(5).toString(), 'x'); } { // Verify simple object 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'); assert.strictEqual(_pt5.read(), '0'); assert.strictEqual(_pt5.read(), '"foo"'); assert.strictEqual(_pt5.read(), '""'); assert.strictEqual(_pt5.read(), '{"a":"b"}'); } { // 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'); assert.strictEqual(_pt6.read(5).toString(), 'zykue'); assert.strictEqual(_pt6.read(5).toString(), 'l'); })); } { // Verify asymmetric transform (expand) 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'); assert.strictEqual(_pt7.read(5).toString(), 'rkbar'); assert.strictEqual(_pt7.read(5).toString(), 'kbazy'); assert.strictEqual(_pt7.read(5).toString(), 'bazyk'); assert.strictEqual(_pt7.read(5).toString(), 'uelku'); assert.strictEqual(_pt7.read(5).toString(), 'el'); })); } { // Verify asymmetric transform (compress) 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(); // '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. { // 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); assert.strictEqual(emits, 1); } { // 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); }, 10); }, 10); }, 10); } { // Verify object transform (JSON parse) var jp = new Transform({ objectMode: true }); jp._transform = function (data, encoding, cb) { try { jp.push(JSON.parse(data)); cb(); } catch (er) { cb(er); } }; // anything except null/undefined is fine. // those are "magic" in the stream API, because they signal EOF. var objects = [{ foo: 'bar' }, 100, 'string', { nested: { things: [{ foo: 'bar' }, 100, 'string'] } }]; var ended = false; jp.on('end', function () { ended = true; }); forEach(objects, function (obj) { jp.write(JSON.stringify(obj)); var res = jp.read(); assert.deepStrictEqual(res, obj); }); jp.end(); // read one more time to get the 'end' event jp.read(); process.nextTick(common.mustCall(function () { assert.strictEqual(ended, true); })); } { // Verify object transform (JSON stringify) var js = new Transform({ objectMode: true }); js._transform = function (data, encoding, cb) { try { js.push(JSON.stringify(data)); cb(); } catch (er) { cb(er); } }; // anything except null/undefined is fine. // those are "magic" in the stream API, because they signal EOF. var _objects = [{ foo: 'bar' }, 100, 'string', { nested: { things: [{ foo: 'bar' }, 100, 'string'] } }]; var _ended = false; js.on('end', function () { _ended = true; }); forEach(_objects, function (obj) { js.write(obj); var res = js.read(); assert.strictEqual(res, JSON.stringify(obj)); }); 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); });readable-stream-3.6.0/test/parallel/test-stream2-unpipe-drain.js000066400000000000000000000116751362132315000246120ustar00rootroot00000000000000"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 _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 () { // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 stream = require('../../'); var TestWriter = /*#__PURE__*/ function (_stream$Writable) { _inherits(TestWriter, _stream$Writable); function TestWriter() { _classCallCheck(this, TestWriter); return _possibleConstructorReturn(this, _getPrototypeOf(TestWriter).apply(this, arguments)); } _createClass(TestWriter, [{ key: "_write", value: function _write(buffer, encoding, callback) { 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) { _inherits(TestReader, _stream$Readable); function TestReader() { var _this; _classCallCheck(this, TestReader); _this = _possibleConstructorReturn(this, _getPrototypeOf(TestReader).call(this)); _this.reads = 0; return _this; } _createClass(TestReader, [{ key: "_read", value: function _read(size) { this.reads += 1; this.push(bufferShim.alloc(size)); } }]); return TestReader; }(stream.Readable); var src1 = new TestReader(); var src2 = new TestReader(); src1.pipe(dest); src1.once('readable', function () { process.nextTick(function () { src2.pipe(dest); src2.once('readable', function () { process.nextTick(function () { src1.unpipe(dest); }); }); }); }); process.on('exit', function () { assert.strictEqual(src1.reads, 2); 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); });readable-stream-3.6.0/test/parallel/test-stream2-unpipe-leak.js000066400000000000000000000121251362132315000244200ustar00rootroot00000000000000"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 _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); } // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 stream = require('../../'); var chunk = bufferShim.from('hallo'); var TestWriter = /*#__PURE__*/ function (_stream$Writable) { _inherits(TestWriter, _stream$Writable); function TestWriter() { _classCallCheck(this, TestWriter); return _possibleConstructorReturn(this, _getPrototypeOf(TestWriter).apply(this, arguments)); } _createClass(TestWriter, [{ key: "_write", value: function _write(buffer, encoding, callback) { callback(null); } }]); return TestWriter; }(stream.Writable); var dest = new TestWriter(); // 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) { _inherits(TestReader, _stream$Readable); function TestReader() { _classCallCheck(this, TestReader); return _possibleConstructorReturn(this, _getPrototypeOf(TestReader).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); assert.strictEqual(dest.listeners('drain').length, 0); assert.strictEqual(dest.listeners('error').length, 0); assert.strictEqual(dest.listeners('close').length, 0); assert.strictEqual(dest.listeners('finish').length, 0); console.error(src._readableState); 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); });readable-stream-3.6.0/test/parallel/test-stream2-writable.js000066400000000000000000000272271362132315000240300ustar00rootroot00000000000000"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 _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); } // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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; /**/ 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) { _inherits(TestWriter, _W); function TestWriter(opts) { var _this; _classCallCheck(this, TestWriter); _this = _possibleConstructorReturn(this, _getPrototypeOf(TestWriter).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({ highWaterMark: 100 }); tw.on('finish', common.mustCall(function () { // got chunks in the right order assert.deepStrictEqual(tw.buffer, chunks); })); forEach(chunks, function (chunk) { // Ignore backpressure. Just buffer it all up. tw.write(chunk); }); tw.end(); } { // Verify slow writing 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(); })(); } { // Verify write backpressure 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(); } })(); } { // Verify write buffersize 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); }); } { // Verify write with no buffersize var _tw4 = new TestWriter({ 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); }); } { // Verify write callbacks var callbacks = chunks.map(function (chunk, i) { return [i, function () { callbacks._called[i] = chunk; }]; }).reduce(function (set, x) { set["callback-".concat(x[0])] = x[1]; 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(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); })); } { // 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'); } { // Verify writables cannot be piped var w = new W(); w._write = common.mustNotCall(); var gotError = false; w.on('error', function () { gotError = true; }); w.pipe(process.stdout); assert.strictEqual(gotError, true); } { // Verify that duplex streams cannot be piped var d = new D(); d._read = common.mustCall(); d._write = common.mustNotCall(); var _gotError = false; d.on('error', function () { _gotError = true; }); d.pipe(process.stdout); assert.strictEqual(_gotError, false); } { // 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); })); } { // 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; this.writing = true; setTimeout(function () { this.writing = false; 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); setTimeout(function () { shutdown = true; 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); });readable-stream-3.6.0/test/parallel/test-stream3-cork-end.js000066400000000000000000000047641362132315000237230ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ require('../common'); var assert = require('assert/'); var stream = require('../../'); var Writable = stream.Writable; // 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. // // node version target: 0.12 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 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.strictEqual(encoding, 'buffer'); seenChunks.push(chunk); cb(); }; // 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 assert.ok(writeState); writeChunks(remainingChunks, callback); }); } else { callback(); } } // do an initial write w.write('stuff'); // the write was immediate assert.strictEqual(seenChunks.length, 1); // reset the seen chunks seenChunks = []; // 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 w.end(); // stream should not ended in current tick assert.ok(!seenEnd); // 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 assert.ok(seen); 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); });readable-stream-3.6.0/test/parallel/test-stream3-cork-uncork.js000066400000000000000000000045331362132315000244500ustar00rootroot00000000000000"use strict"; /**/ var bufferShim = require('safe-buffer').Buffer; /**/ require('../common'); var assert = require('assert/'); var stream = require('../../'); var Writable = stream.Writable; // Test the buffering behavior of Writable streams. // // The call to cork() triggers storing chunks which are flushed // on calling uncork() in the same tick. // // node version target: 0.12 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 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 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 assert.ok(writeState); writeChunks(remainingChunks, callback); }); } else { callback(); } } // do an initial write w.write('stuff'); // the write was immediate assert.strictEqual(seenChunks.length, 1); // reset the chunks seen so far seenChunks = []; // 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 w.uncork(); // 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 assert.ok(seen); 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); });readable-stream-3.6.0/test/parallel/test-stream3-pause-then-read.js000066400000000000000000000111051362132315000251660ustar00rootroot00000000000000"use strict"; // 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 // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // 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 stream = require('../../'); var Readable = stream.Readable; var Writable = stream.Writable; var totalChunks = 100; var chunkSize = 99; var expectTotalData = totalChunks * chunkSize; var expectEndingData = expectTotalData; 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(); // 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); if (!c) r.once('readable', read);else { assert.strictEqual(c.length, n); assert(!r.readableFlowing); then(); } })(); } // 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 setImmediate(pipeLittle); } }); } // Just pipe 200 bytes, then unshift the extra and unpipe function pipeLittle() { expectEndingData -= 200; console.error('pipe a little'); var w = new Writable(); var written = 0; w.on('finish', function () { 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; r.unshift(chunk.slice(chunk.length - diff)); } } else { setImmediate(cb); } }; r.pipe(w); } // 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 r.resume(); r.pause(); r.resume(); r.pause(); r.resume(); r.pause(); r.resume(); r.pause(); r.resume(); 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); });readable-stream-3.6.0/test/parallel/test-streams-highwatermark.js000066400000000000000000000045001362132315000251420ustar00rootroot00000000000000"use strict"; /**/ 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; var readable = stream.Readable({ highWaterMark: ovfl }); assert.strictEqual(readable._readableState.highWaterMark, ovfl); var writable = stream.Writable({ 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 () { type({ highWaterMark: invalidHwm }); }, { type: TypeError, code: 'ERR_INVALID_OPT_VALUE', 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(); } } { // 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); } } { // 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); });