ikan Uploader :
Directory : /home/ubuntu/node-v16.18.1/test/parallel/
Upload File : |
| Current File : //home/ubuntu/node-v16.18.1/test/parallel/test-stream-iterator-helpers-test262-tests.mjs |
import { mustCall } from '../common/index.mjs';
import { Readable } from 'stream';
import assert from 'assert';
// These tests are manually ported from the draft PR for the test262 test suite
// Authored by Rick Waldron in https://github.com/tc39/test262/pull/2818/files
// test262 license:
// The << Software identified by reference to the Ecma Standard* ("Software)">>
// is protected by copyright and is being made available under the
// "BSD License", included below. This Software may be subject to third party
// rights (rights from parties other than Ecma International), including patent
// rights, and no licenses under such third party rights are granted under this
// license even if the third party concerned is a member of Ecma International.
// SEE THE ECMA CODE OF CONDUCT IN PATENT MATTERS AVAILABLE AT
// http://www.ecma-international.org/memento/codeofconduct.htm FOR INFORMATION
// REGARDING THE LICENSING OF PATENT CLAIMS THAT ARE REQUIRED TO IMPLEMENT ECMA
// INTERNATIONAL STANDARDS*
// Copyright (C) 2012-2013 Ecma International
// All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. Neither the name of the authors nor Ecma International may be used to
// endorse or promote products derived from this software without specific
// prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE ECMA INTERNATIONAL "AS IS" AND ANY EXPRESS
// OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
// NO EVENT SHALL ECMA INTERNATIONAL BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// * Ecma International Standards hereafter means Ecma International Standards
// as well as Ecma Technical Reports
// Note all the tests that check AsyncIterator's prototype itself and things
// that happen before stream conversion were not ported.
{
// asIndexedPairs/is-function
assert.strictEqual(typeof Readable.prototype.asIndexedPairs, 'function');
// asIndexedPairs/indexed-pairs.js
const iterator = Readable.from([0, 1]);
const indexedPairs = iterator.asIndexedPairs();
for await (const [i, v] of indexedPairs) {
assert.strictEqual(i, v);
}
// asIndexedPairs/length.js
assert.strictEqual(Readable.prototype.asIndexedPairs.length, 0);
// asIndexedPairs/name.js
assert.strictEqual(Readable.prototype.asIndexedPairs.name, 'asIndexedPairs');
const descriptor = Object.getOwnPropertyDescriptor(
Readable.prototype,
'asIndexedPairs'
);
assert.strictEqual(descriptor.enumerable, false);
assert.strictEqual(descriptor.configurable, true);
assert.strictEqual(descriptor.writable, true);
}
{
// drop/length
assert.strictEqual(Readable.prototype.drop.length, 1);
const descriptor = Object.getOwnPropertyDescriptor(
Readable.prototype,
'drop'
);
assert.strictEqual(descriptor.enumerable, false);
assert.strictEqual(descriptor.configurable, true);
assert.strictEqual(descriptor.writable, true);
// drop/limit-equals-total
const iterator = Readable.from([1, 2]).drop(2);
const result = await iterator[Symbol.asyncIterator]().next();
assert.deepStrictEqual(result, { done: true, value: undefined });
// drop/limit-greater-than-total.js
const iterator2 = Readable.from([1, 2]).drop(3);
const result2 = await iterator2[Symbol.asyncIterator]().next();
assert.deepStrictEqual(result2, { done: true, value: undefined });
// drop/limit-less-than-total.js
const iterator3 = Readable.from([1, 2]).drop(1);
const result3 = await iterator3[Symbol.asyncIterator]().next();
assert.deepStrictEqual(result3, { done: false, value: 2 });
// drop/limit-rangeerror
assert.throws(() => Readable.from([1]).drop(-1), RangeError);
assert.throws(() => {
Readable.from([1]).drop({
valueOf() {
throw new Error('boom');
}
});
}, /boom/);
// drop/limit-tointeger
const two = await Readable.from([1, 2]).drop({ valueOf: () => 1 }).toArray();
assert.deepStrictEqual(two, [2]);
// drop/name
assert.strictEqual(Readable.prototype.drop.name, 'drop');
// drop/non-constructible
assert.throws(() => new Readable.prototype.drop(1), TypeError);
// drop/proto
const proto = Object.getPrototypeOf(Readable.prototype.drop);
assert.strictEqual(proto, Function.prototype);
}
{
// every/abrupt-iterator-close
const stream = Readable.from([1, 2, 3]);
const e = new Error();
await assert.rejects(stream.every(mustCall(() => {
throw e;
}, 1)), e);
}
{
// every/callable-fn
await assert.rejects(Readable.from([1, 2]).every({}), TypeError);
}
{
// every/callable
Readable.prototype.every.call(Readable.from([]), () => {});
// eslint-disable-next-line array-callback-return
Readable.from([]).every(() => {});
assert.throws(() => {
const r = Readable.from([]);
new r.every(() => {});
}, TypeError);
}
{
// every/false
const iterator = Readable.from([1, 2, 3]);
const result = await iterator.every((v) => v === 1);
assert.strictEqual(result, false);
}
{
// every/every
const iterator = Readable.from([1, 2, 3]);
const result = await iterator.every((v) => true);
assert.strictEqual(result, true);
}
{
// every/is-function
assert.strictEqual(typeof Readable.prototype.every, 'function');
}
{
// every/length
assert.strictEqual(Readable.prototype.every.length, 1);
// every/name
assert.strictEqual(Readable.prototype.every.name, 'every');
// every/propdesc
const descriptor = Object.getOwnPropertyDescriptor(
Readable.prototype,
'every'
);
assert.strictEqual(descriptor.enumerable, false);
assert.strictEqual(descriptor.configurable, true);
assert.strictEqual(descriptor.writable, true);
}
Kontol Shell Bypass