file_path
stringlengths 3
280
| file_language
stringclasses 66
values | content
stringlengths 1
1.04M
| repo_name
stringlengths 5
92
| repo_stars
int64 0
154k
| repo_description
stringlengths 0
402
| repo_primary_language
stringclasses 108
values | developer_username
stringlengths 1
25
| developer_name
stringlengths 0
30
| developer_company
stringlengths 0
82
|
|---|---|---|---|---|---|---|---|---|---|
tests/unit-pure/es.string.trim-right.js
|
JavaScript
|
import { STRICT, WHITESPACES } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import trimRight from 'core-js-pure/es/string/trim-right';
QUnit.test('String#trimRight', assert => {
assert.isFunction(trimRight);
assert.same(trimRight(' \n q w e \n '), ' \n q w e', 'removes whitespaces at right side of string');
assert.same(trimRight(WHITESPACES), '', 'removes all whitespaces');
assert.same(trimRight('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
assert.throws(() => trimRight(Symbol('trimRight test')), 'throws on symbol context');
if (STRICT) {
assert.throws(() => trimRight(null, 0), TypeError);
assert.throws(() => trimRight(undefined, 0), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.string.trim-start.js
|
JavaScript
|
import { STRICT, WHITESPACES } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import trimStart from 'core-js-pure/es/string/trim-start';
QUnit.test('String#trimStart', assert => {
assert.isFunction(trimStart);
assert.same(trimStart(' \n q w e \n '), 'q w e \n ', 'removes whitespaces at left side of string');
assert.same(trimStart(WHITESPACES), '', 'removes all whitespaces');
assert.same(trimStart('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
assert.throws(() => trimStart(Symbol('trimStart test')), 'throws on symbol context');
if (STRICT) {
assert.throws(() => trimStart(null, 0), TypeError);
assert.throws(() => trimStart(undefined, 0), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.string.trim.js
|
JavaScript
|
import { STRICT, WHITESPACES } from '../helpers/constants.js';
import trim from 'core-js-pure/es/string/trim';
QUnit.test('String#trim', assert => {
assert.isFunction(trim);
assert.same(trim(' \n q w e \n '), 'q w e', 'removes whitespaces at left & right side of string');
assert.same(trim(WHITESPACES), '', 'removes all whitespaces');
assert.same(trim('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => trim(Symbol('trim test')), 'throws on symbol context');
}
if (STRICT) {
assert.throws(() => trim(null, 0), TypeError);
assert.throws(() => trim(undefined, 0), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.suppressed-error.constructor.js
|
JavaScript
|
/* eslint-disable unicorn/throw-new-error, sonarjs/inconsistent-function-call -- testing */
import SuppressedError from 'core-js-pure/es/suppressed-error';
import Symbol from 'core-js-pure/es/symbol';
import toString from 'core-js-pure/es/object/to-string';
QUnit.test('SuppressedError', assert => {
assert.isFunction(SuppressedError);
assert.arity(SuppressedError, 3);
assert.name(SuppressedError, 'SuppressedError');
assert.true(new SuppressedError() instanceof SuppressedError);
assert.true(new SuppressedError() instanceof Error);
assert.true(SuppressedError() instanceof SuppressedError);
assert.true(SuppressedError() instanceof Error);
assert.same(SuppressedError().error, undefined);
assert.same(SuppressedError().suppressed, undefined);
assert.same(SuppressedError().message, '');
assert.same(SuppressedError().cause, undefined);
assert.same(SuppressedError().name, 'SuppressedError');
assert.same(new SuppressedError().error, undefined);
assert.same(new SuppressedError().suppressed, undefined);
assert.same(new SuppressedError().message, '');
assert.same(new SuppressedError().cause, undefined);
assert.same(new SuppressedError().name, 'SuppressedError');
const error1 = SuppressedError(1, 2, 3, { cause: 4 });
assert.same(error1.error, 1);
assert.same(error1.suppressed, 2);
assert.same(error1.message, '3');
assert.same(error1.cause, undefined);
assert.same(error1.name, 'SuppressedError');
const error2 = new SuppressedError(1, 2, 3, { cause: 4 });
assert.same(error2.error, 1);
assert.same(error2.suppressed, 2);
assert.same(error2.message, '3');
assert.same(error2.cause, undefined);
assert.same(error2.name, 'SuppressedError');
assert.throws(() => SuppressedError(1, 2, Symbol('SuppressedError constructor test')), 'throws on symbol as a message');
assert.same(toString(SuppressedError()), '[object Error]', 'Object#toString');
// eslint-disable-next-line no-prototype-builtins -- safe
assert.false(SuppressedError.prototype.hasOwnProperty('cause'), 'prototype has not cause');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.symbol.async-dispose.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol.asyncDispose', assert => {
assert.true('asyncDispose' in Symbol, 'Symbol.asyncDispose available');
assert.true(Object(Symbol.asyncDispose) instanceof Symbol, 'Symbol.asyncDispose is symbol');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.symbol.async-iterator.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol.asyncIterator', assert => {
assert.true('asyncIterator' in Symbol, 'Symbol.asyncIterator available');
assert.true(Object(Symbol.asyncIterator) instanceof Symbol, 'Symbol.asyncIterator is symbol');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.symbol.constructor.js
|
JavaScript
|
import { DESCRIPTORS, GLOBAL } from '../helpers/constants.js';
import create from 'core-js-pure/es/object/create';
import defineProperty from 'core-js-pure/es/object/define-property';
import defineProperties from 'core-js-pure/es/object/define-properties';
import getOwnPropertyDescriptor from 'core-js-pure/es/object/get-own-property-descriptor';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import keys from 'core-js-pure/es/object/keys';
import ownKeys from 'core-js-pure/es/reflect/own-keys';
import Map from 'core-js-pure/es/map';
import Set from 'core-js-pure/es/set';
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol', assert => {
assert.isFunction(Symbol);
const symbol1 = Symbol('symbol');
const symbol2 = Symbol('symbol');
assert.notSame(symbol1, symbol2, 'Symbol("symbol") !== Symbol("symbol")');
const object = {};
object[symbol1] = 42;
assert.same(object[symbol1], 42, 'Symbol() work as key');
assert.notSame(object[symbol2], 42, 'Various symbols from one description are various keys');
// assert.throws(() => Symbol(Symbol('foo')), 'throws on symbol argument');
if (DESCRIPTORS) {
let count = 0;
// eslint-disable-next-line no-unused-vars -- required for testing
for (const key in object) count++;
assert.same(count, 0, 'object[Symbol()] is not enumerable');
}
});
QUnit.test('Symbol as global key', assert => {
const TEXT = 'test global symbol key';
const symbol = Symbol(TEXT);
GLOBAL[symbol] = TEXT;
assert.same(GLOBAL[symbol], TEXT, TEXT);
});
QUnit.test('Well-known Symbols', assert => {
const wks = [
'hasInstance',
'isConcatSpreadable',
'iterator',
'match',
'matchAll',
'replace',
'search',
'species',
'split',
'toPrimitive',
'toStringTag',
'unscopables',
];
for (const name of wks) {
assert.true(name in Symbol, `Symbol.${ name } available`);
assert.true(Object(Symbol[name]) instanceof Symbol, `Symbol.${ name } is symbol`);
}
});
QUnit.test('Symbol#@@toPrimitive', assert => {
const symbol = Symbol('Symbol#@@toPrimitive test');
assert.isFunction(Symbol.prototype[Symbol.toPrimitive]);
assert.same(symbol, symbol[Symbol.toPrimitive](), 'works');
});
QUnit.test('Symbol#@@toStringTag', assert => {
assert.same(Symbol.prototype[Symbol.toStringTag], 'Symbol', 'Symbol::@@toStringTag is `Symbol`');
});
if (DESCRIPTORS) {
QUnit.test('Symbols & descriptors', assert => {
const d = Symbol('d');
const e = Symbol('e');
const f = Symbol('f');
const i = Symbol('i');
const j = Symbol('j');
const prototype = { g: 'g' };
prototype[i] = 'i';
defineProperty(prototype, 'h', {
value: 'h',
});
defineProperty(prototype, 'j', {
value: 'j',
});
const object = create(prototype);
object.a = 'a';
object[d] = 'd';
defineProperty(object, 'b', {
value: 'b',
});
defineProperty(object, 'c', {
value: 'c',
enumerable: true,
});
defineProperty(object, e, {
configurable: true,
writable: true,
value: 'e',
});
const descriptor = {
value: 'f',
enumerable: true,
};
defineProperty(object, f, descriptor);
assert.true(descriptor.enumerable, 'defineProperty not changes descriptor object');
assert.deepEqual(getOwnPropertyDescriptor(object, 'a'), {
configurable: true,
writable: true,
enumerable: true,
value: 'a',
}, 'getOwnPropertyDescriptor a');
assert.deepEqual(getOwnPropertyDescriptor(object, 'b'), {
configurable: false,
writable: false,
enumerable: false,
value: 'b',
}, 'getOwnPropertyDescriptor b');
assert.deepEqual(getOwnPropertyDescriptor(object, 'c'), {
configurable: false,
writable: false,
enumerable: true,
value: 'c',
}, 'getOwnPropertyDescriptor c');
assert.deepEqual(getOwnPropertyDescriptor(object, d), {
configurable: true,
writable: true,
enumerable: true,
value: 'd',
}, 'getOwnPropertyDescriptor d');
assert.deepEqual(getOwnPropertyDescriptor(object, e), {
configurable: true,
writable: true,
enumerable: false,
value: 'e',
}, 'getOwnPropertyDescriptor e');
assert.deepEqual(getOwnPropertyDescriptor(object, f), {
configurable: false,
writable: false,
enumerable: true,
value: 'f',
}, 'getOwnPropertyDescriptor f');
assert.same(getOwnPropertyDescriptor(object, 'g'), undefined, 'getOwnPropertyDescriptor g');
assert.same(getOwnPropertyDescriptor(object, 'h'), undefined, 'getOwnPropertyDescriptor h');
assert.same(getOwnPropertyDescriptor(object, i), undefined, 'getOwnPropertyDescriptor i');
assert.same(getOwnPropertyDescriptor(object, j), undefined, 'getOwnPropertyDescriptor j');
assert.same(getOwnPropertyDescriptor(object, 'k'), undefined, 'getOwnPropertyDescriptor k');
assert.false(getOwnPropertyDescriptor(Object.prototype, 'toString').enumerable, 'getOwnPropertyDescriptor on Object.prototype');
assert.same(getOwnPropertyDescriptor(Object.prototype, d), undefined, 'getOwnPropertyDescriptor on Object.prototype missed symbol');
assert.same(keys(object).length, 2, 'Object.keys');
assert.same(getOwnPropertyNames(object).length, 3, 'Object.getOwnPropertyNames');
assert.same(getOwnPropertySymbols(object).length, 3, 'Object.getOwnPropertySymbols');
assert.same(ownKeys(object).length, 6, 'Reflect.ownKeys');
delete object[e];
object[e] = 'e';
assert.deepEqual(getOwnPropertyDescriptor(object, e), {
configurable: true,
writable: true,
enumerable: true,
value: 'e',
}, 'redefined non-enum key');
const g = Symbol('g');
defineProperty(object, g, { configurable: true, enumerable: true, writable: true, value: 1 });
defineProperty(object, g, { value: 2 });
assert.deepEqual(getOwnPropertyDescriptor(object, g), {
configurable: true,
writable: true,
enumerable: true,
value: 2,
}, 'redefine with partial descriptor preserves enumerable');
});
QUnit.test('Symbols & Object.defineProperties', assert => {
const c = Symbol('c');
const d = Symbol('d');
const descriptors = {
a: {
value: 'a',
},
};
descriptors[c] = {
value: 'c',
};
defineProperty(descriptors, 'b', {
value: {
value: 'b',
},
});
defineProperty(descriptors, d, {
value: {
value: 'd',
},
});
const object = defineProperties({}, descriptors);
assert.same(object.a, 'a', 'a');
assert.same(object.b, undefined, 'b');
assert.same(object[c], 'c', 'c');
assert.same(object[d], undefined, 'd');
});
QUnit.test('Symbols & Object.create', assert => {
const c = Symbol('c');
const d = Symbol('d');
const descriptors = {
a: {
value: 'a',
},
};
descriptors[c] = {
value: 'c',
};
defineProperty(descriptors, 'b', {
value: {
value: 'b',
},
});
defineProperty(descriptors, d, {
value: {
value: 'd',
},
});
const object = create(null, descriptors);
assert.same(object.a, 'a', 'a');
assert.same(object.b, undefined, 'b');
assert.same(object[c], 'c', 'c');
assert.same(object[d], undefined, 'd');
});
const constructors = { Map, Set, Promise };
for (const name in constructors) {
QUnit.test(`${ name }@@species`, assert => {
assert.same(constructors[name][Symbol.species], constructors[name], `${ name }@@species === ${ name }`);
const Subclass = create(constructors[name]);
assert.same(Subclass[Symbol.species], Subclass, `${ name } subclass`);
});
}
QUnit.test('Array@@species', assert => {
assert.same(Array[Symbol.species], Array, 'Array@@species === Array');
const Subclass = create(Array);
assert.same(Subclass[Symbol.species], Subclass, 'Array subclass');
});
QUnit.test('Symbol.sham flag', assert => {
assert.same(Symbol.sham, typeof Symbol('Symbol.sham flag test') == 'symbol' ? undefined : true);
});
}
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.symbol.dispose.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol.dispose', assert => {
assert.true('dispose' in Symbol, 'Symbol.dispose available');
assert.true(Object(Symbol.dispose) instanceof Symbol, 'Symbol.dispose is symbol');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.symbol.for.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol.for', assert => {
assert.isFunction(Symbol.for, 'Symbol.for is function');
const symbol = Symbol.for('foo');
assert.strictEqual(Symbol.for('foo'), symbol, 'registry');
assert.true(Object(symbol) instanceof Symbol, 'returns symbol');
assert.throws(() => Symbol.for(Symbol('foo')), 'throws on symbol argument');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.symbol.key-for.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol.keyFor', assert => {
assert.isFunction(Symbol.keyFor, 'Symbol.keyFor is function');
assert.strictEqual(Symbol.keyFor(Symbol.for('foo')), 'foo');
assert.strictEqual(Symbol.keyFor(Symbol('foo')), undefined);
assert.throws(() => Symbol.keyFor('foo'), 'throws on non-symbol');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.unescape.js
|
JavaScript
|
import unescape from 'core-js-pure/es/unescape';
QUnit.test('unescape', assert => {
assert.isFunction(unescape);
assert.arity(unescape, 1);
assert.same(unescape('%21q2%u0444'), '!q2ф');
assert.same(unescape('%u044q2%21'), '%u044q2!');
assert.same(unescape(null), 'null');
assert.same(unescape(undefined), 'undefined');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => unescape(Symbol('unescape test')), 'throws on symbol argument');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.weak-map.get-or-insert-computed.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import WeakMap from 'core-js-pure/es/weak-map';
QUnit.test('WeakMap#getOrInsertComputed', assert => {
const { getOrInsertComputed } = WeakMap.prototype;
assert.isFunction(getOrInsertComputed);
assert.arity(getOrInsertComputed, 2);
assert.name(getOrInsertComputed, 'getOrInsertComputed');
assert.nonEnumerable(WeakMap.prototype, 'getOrInsertComputed');
const a = {};
const b = {};
let map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsertComputed(a, () => 3), 2, 'result#1');
assert.same(map.get(a), 2, 'map#1');
map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsertComputed(b, () => 3), 3, 'result#2');
assert.same(map.get(a), 2, 'map#2-1');
assert.same(map.get(b), 3, 'map#2-2');
map = new WeakMap([[a, 2]]);
map.getOrInsertComputed(a, () => assert.avoid());
map = new WeakMap([[a, 2]]);
map.getOrInsertComputed(b, function (key) {
if (STRICT) assert.same(this, undefined, 'correct handler in callback');
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(key, b, 'correct key in callback');
});
map = new WeakMap([[a, 2]]);
assert.throws(() => {
map.getOrInsertComputed(1, () => assert.avoid());
}, TypeError, 'key validation before call of callback');
assert.throws(() => new WeakMap().getOrInsertComputed(1, () => 3), TypeError, 'invalid key#1');
assert.throws(() => new WeakMap().getOrInsertComputed(null, () => 3), TypeError, 'invalid key#2');
assert.throws(() => new WeakMap().getOrInsertComputed(undefined, () => 3), TypeError, 'invalid key#3');
assert.throws(() => new WeakMap().getOrInsertComputed(a, {}), TypeError, 'non-callable#1');
assert.throws(() => new WeakMap().getOrInsertComputed(a, 1), TypeError, 'non-callable#2');
assert.throws(() => new WeakMap().getOrInsertComputed(a, null), TypeError, 'non-callable#3');
assert.throws(() => new WeakMap().getOrInsertComputed(a, undefined), TypeError, 'non-callable#4');
assert.throws(() => new WeakMap().getOrInsertComputed(a), TypeError, 'non-callable#5');
assert.throws(() => getOrInsertComputed.call({}, a, () => 3), TypeError, 'non-generic#1');
assert.throws(() => getOrInsertComputed.call([], a, () => 3), TypeError, 'non-generic#2');
assert.throws(() => getOrInsertComputed.call(undefined, a, () => 3), TypeError, 'non-generic#3');
assert.throws(() => getOrInsertComputed.call(null, a, () => 3), TypeError, 'non-generic#4');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.weak-map.get-or-insert.js
|
JavaScript
|
import WeakMap from 'core-js-pure/es/weak-map';
QUnit.test('WeakMap#getOrInsert', assert => {
const { getOrInsert } = WeakMap.prototype;
assert.isFunction(getOrInsert);
assert.arity(getOrInsert, 2);
assert.name(getOrInsert, 'getOrInsert');
assert.nonEnumerable(WeakMap.prototype, 'getOrInsert');
const a = {};
const b = {};
let map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsert(a, 3), 2, 'result#1');
assert.same(map.get(a), 2, 'map#1');
map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsert(b, 3), 3, 'result#2');
assert.same(map.get(a), 2, 'map#2-1');
assert.same(map.get(b), 3, 'map#2-2');
assert.throws(() => new WeakMap().getOrInsert(1, 1), TypeError, 'invalid key#1');
assert.throws(() => new WeakMap().getOrInsert(null, 1), TypeError, 'invalid key#2');
assert.throws(() => new WeakMap().getOrInsert(undefined, 1), TypeError, 'invalid key#3');
assert.throws(() => new WeakMap().getOrInsert(), TypeError, 'invalid key#4');
assert.throws(() => getOrInsert.call({}, a, 1), TypeError, 'non-generic#1');
assert.throws(() => getOrInsert.call([], a, 1), TypeError, 'non-generic#2');
assert.throws(() => getOrInsert.call(undefined, a, 1), TypeError, 'non-generic#3');
assert.throws(() => getOrInsert.call(null, a, 1), TypeError, 'non-generic#4');
assert.throws(() => getOrInsert.call({
has() { return false; },
get() { /* empty */ },
set() { /* empty */ },
}, a, 1), TypeError, 'non-generic, missing delete');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.weak-map.js
|
JavaScript
|
import { createIterable, nativeSubclass } from '../helpers/helpers.js';
import { DESCRIPTORS, FREEZING } from '../helpers/constants.js';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import freeze from 'core-js-pure/es/object/freeze';
import isFrozen from 'core-js-pure/es/object/is-frozen';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import keys from 'core-js-pure/es/object/keys';
import ownKeys from 'core-js-pure/es/reflect/own-keys';
import Symbol from 'core-js-pure/es/symbol';
import WeakMap from 'core-js-pure/es/weak-map';
QUnit.test('WeakMap', assert => {
assert.isFunction(WeakMap);
assert.true('delete' in WeakMap.prototype, 'delete in WeakMap.prototype');
assert.true('get' in WeakMap.prototype, 'get in WeakMap.prototype');
assert.true('has' in WeakMap.prototype, 'has in WeakMap.prototype');
assert.true('set' in WeakMap.prototype, 'set in WeakMap.prototype');
assert.true(new WeakMap() instanceof WeakMap, 'new WeakMap instanceof WeakMap');
let object = {};
assert.same(new WeakMap(createIterable([[object, 42]])).get(object), 42, 'Init from iterable');
let weakmap = new WeakMap();
const frozen = freeze({});
weakmap.set(frozen, 42);
assert.same(weakmap.get(frozen), 42, 'Support frozen objects');
weakmap = new WeakMap();
weakmap.set(frozen, 42);
assert.true(weakmap.has(frozen), 'works with frozen objects, #1');
assert.same(weakmap.get(frozen), 42, 'works with frozen objects, #2');
weakmap.delete(frozen);
assert.false(weakmap.has(frozen), 'works with frozen objects, #3');
assert.same(weakmap.get(frozen), undefined, 'works with frozen objects, #4');
let done = false;
try {
new WeakMap(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.true(done, '.return #throw');
assert.false('clear' in WeakMap.prototype, 'should not contains `.clear` method');
const array = [];
done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new WeakMap(array);
assert.true(done);
object = {};
new WeakMap().set(object, 1);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakMap);
assert.true(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.true(new Subclass() instanceof WeakMap, 'correct subclassing with native classes #2');
object = {};
assert.same(new Subclass().set(object, 2).get(object), 2, 'correct subclassing with native classes #3');
}
if (typeof ArrayBuffer == 'function') {
const buffer = new ArrayBuffer(8);
const map = new WeakMap([[buffer, 8]]);
assert.true(map.has(buffer), 'works with ArrayBuffer keys');
}
});
QUnit.test('WeakMap#delete', assert => {
assert.isFunction(WeakMap.prototype.delete);
const a = {};
const b = {};
const weakmap = new WeakMap();
weakmap.set(a, 42);
weakmap.set(b, 21);
assert.true(weakmap.has(a), 'WeakMap has values before .delete() #1');
assert.true(weakmap.has(b), 'WeakMap has values before .delete() #2');
weakmap.delete(a);
assert.false(weakmap.has(a), 'WeakMap has not value after .delete() #1');
assert.true(weakmap.has(b), 'WeakMap has not value after .delete() #2');
assert.notThrows(() => !weakmap.delete(1), 'return false on primitive');
const object = {};
weakmap.set(object, 42);
freeze(object);
assert.true(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.false(weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#get', assert => {
assert.isFunction(WeakMap.prototype.get);
const weakmap = new WeakMap();
assert.same(weakmap.get({}), undefined, 'WeakMap .get() before .set() return undefined');
let object = {};
weakmap.set(object, 42);
assert.same(weakmap.get(object), 42, 'WeakMap .get() return value');
weakmap.delete(object);
assert.same(weakmap.get(object), undefined, 'WeakMap .get() after .delete() return undefined');
assert.notThrows(() => weakmap.get(1) === undefined, 'return undefined on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.same(weakmap.get(object), 42, 'works with frozen objects #1');
weakmap.delete(object);
assert.same(weakmap.get(object), undefined, 'works with frozen objects #2');
});
QUnit.test('WeakMap#has', assert => {
assert.isFunction(WeakMap.prototype.has);
const weakmap = new WeakMap();
assert.false(weakmap.has({}), 'WeakMap .has() before .set() return false');
let object = {};
weakmap.set(object, 42);
assert.true(weakmap.has(object), 'WeakMap .has() return true');
weakmap.delete(object);
assert.false(weakmap.has(object), 'WeakMap .has() after .delete() return false');
assert.notThrows(() => !weakmap.has(1), 'return false on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.true(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.false(weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#set', assert => {
assert.isFunction(WeakMap.prototype.set);
const weakmap = new WeakMap();
const object = {};
weakmap.set(object, 33);
assert.same(weakmap.get(object), 33, 'works with object as keys');
assert.same(weakmap.set({}, 42), weakmap, 'chaining');
assert.throws(() => new WeakMap().set(42, 42), 'throws with primitive keys');
const object1 = freeze({});
const object2 = {};
weakmap.set(object1, 42);
weakmap.set(object2, 42);
freeze(object);
assert.same(weakmap.get(object1), 42, 'works with frozen objects #1');
assert.same(weakmap.get(object2), 42, 'works with frozen objects #2');
weakmap.delete(object1);
weakmap.delete(object2);
assert.same(weakmap.get(object1), undefined, 'works with frozen objects #3');
assert.same(weakmap.get(object2), undefined, 'works with frozen objects #4');
const array = freeze([]);
weakmap.set(array, 42);
assert.same(weakmap.get(array), 42, 'works with frozen arrays #1');
if (FREEZING) assert.true(isFrozen(array), 'works with frozen arrays #2');
});
QUnit.test('WeakMap#@@toStringTag', assert => {
assert.same(WeakMap.prototype[Symbol.toStringTag], 'WeakMap', 'WeakMap::@@toStringTag is `WeakMap`');
assert.same(String(new WeakMap()), '[object WeakMap]', 'correct stringification');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.weak-set.js
|
JavaScript
|
import { createIterable, nativeSubclass } from '../helpers/helpers.js';
import { DESCRIPTORS } from '../helpers/constants.js';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import freeze from 'core-js-pure/es/object/freeze';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import keys from 'core-js-pure/es/object/keys';
import ownKeys from 'core-js-pure/es/reflect/own-keys';
import Symbol from 'core-js-pure/es/symbol';
import WeakSet from 'core-js-pure/es/weak-set';
QUnit.test('WeakSet', assert => {
assert.isFunction(WeakSet);
assert.true('add' in WeakSet.prototype, 'add in WeakSet.prototype');
assert.true('delete' in WeakSet.prototype, 'delete in WeakSet.prototype');
assert.true('has' in WeakSet.prototype, 'has in WeakSet.prototype');
assert.true(new WeakSet() instanceof WeakSet, 'new WeakSet instanceof WeakSet');
let object = {};
assert.true(new WeakSet(createIterable([object])).has(object), 'Init from iterable');
const weakset = new WeakSet();
const frozen = freeze({});
weakset.add(frozen);
assert.true(weakset.has(frozen), 'works with frozen objects, #1');
weakset.delete(frozen);
assert.false(weakset.has(frozen), 'works with frozen objects, #2');
let done = false;
try {
new WeakSet(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.true(done, '.return #throw');
assert.false('clear' in WeakSet.prototype, 'should not contains `.clear` method');
const array = [];
done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new WeakSet(array);
assert.true(done);
object = {};
new WeakSet().add(object);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakSet);
assert.true(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.true(new Subclass() instanceof WeakSet, 'correct subclassing with native classes #2');
object = {};
assert.true(new Subclass().add(object).has(object), 'correct subclassing with native classes #3');
}
if (typeof ArrayBuffer == 'function') {
const buffer = new ArrayBuffer(8);
const set = new WeakSet([buffer]);
assert.true(set.has(buffer), 'works with ArrayBuffer keys');
}
});
QUnit.test('WeakSet#add', assert => {
assert.isFunction(WeakSet.prototype.add);
const weakset = new WeakSet();
assert.same(weakset.add({}), weakset, 'chaining');
assert.throws(() => new WeakSet().add(42), 'throws with primitive keys');
});
QUnit.test('WeakSet#delete', assert => {
assert.isFunction(WeakSet.prototype.delete);
const a = {};
const b = {};
const weakset = new WeakSet().add(a).add(b);
assert.true(weakset.has(a), 'WeakSet has values before .delete() #1');
assert.true(weakset.has(b), 'WeakSet has values before .delete() #2');
weakset.delete(a);
assert.false(weakset.has(a), 'WeakSet has not value after .delete() #1');
assert.true(weakset.has(b), 'WeakSet has not value after .delete() #2');
assert.notThrows(() => !weakset.delete(1), 'return false on primitive');
});
QUnit.test('WeakSet#has', assert => {
assert.isFunction(WeakSet.prototype.has);
const weakset = new WeakSet();
assert.false(weakset.has({}), 'WeakSet has`nt value');
const object = {};
weakset.add(object);
assert.true(weakset.has(object), 'WeakSet has value after .add()');
weakset.delete(object);
assert.false(weakset.has(object), 'WeakSet has not value after .delete()');
assert.notThrows(() => !weakset.has(1), 'return false on primitive');
});
QUnit.test('WeakSet::@@toStringTag', assert => {
assert.same(WeakSet.prototype[Symbol.toStringTag], 'WeakSet', 'WeakSet::@@toStringTag is `WeakSet`');
assert.same(String(new WeakSet()), '[object WeakSet]', 'correct stringification');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.array.filter-out.js
|
JavaScript
|
// TODO: Remove from `core-js@4`
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import filterOut from 'core-js-pure/full/array/filter-out';
QUnit.test('Array#filterOut', assert => {
assert.isFunction(filterOut);
let array = [1];
const context = {};
filterOut(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.deepEqual([1, 2, 3, 4, 5], filterOut([1, 2, 3, 'q', {}, 4, true, 5], it => typeof it != 'number'));
if (STRICT) {
assert.throws(() => filterOut(null, () => { /* empty */ }), TypeError);
assert.throws(() => filterOut(undefined, () => { /* empty */ }), TypeError);
}
array = [];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(filterOut(array, Boolean).foo, 1, '@@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.array.filter-reject.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import filterReject from 'core-js-pure/full/array/filter-reject';
QUnit.test('Array#filterReject', assert => {
assert.isFunction(filterReject);
let array = [1];
const context = {};
filterReject(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.deepEqual([1, 2, 3, 4, 5], filterReject([1, 2, 3, 'q', {}, 4, true, 5], it => typeof it != 'number'));
if (STRICT) {
assert.throws(() => filterReject(null, () => { /* empty */ }), TypeError);
assert.throws(() => filterReject(undefined, () => { /* empty */ }), TypeError);
}
array = [];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(filterReject(array, Boolean).foo, 1, '@@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.array.group-by-to-map.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Map from 'core-js-pure/es/map';
import Symbol from 'core-js-pure/es/symbol';
import from from 'core-js-pure/es/array/from';
import groupByToMap from 'core-js-pure/actual/array/group-by-to-map';
QUnit.test('Array#groupByToMap', assert => {
assert.isFunction(groupByToMap);
let array = [1];
const context = {};
groupByToMap(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(groupByToMap([], it => it) instanceof Map, 'returns Map');
assert.deepEqual(from(groupByToMap([1, 2, 3], it => it % 2)), [[1, [1, 3]], [0, [2]]], '#1');
assert.deepEqual(
from(groupByToMap([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], it => `i${ it % 5 }`)),
[['i1', [1, 6, 11]], ['i2', [2, 7, 12]], ['i3', [3, 8]], ['i4', [4, 9]], ['i0', [5, 10]]],
'#2',
);
assert.deepEqual(from(groupByToMap(Array(3), it => it)), [[undefined, [undefined, undefined, undefined]]], '#3');
if (STRICT) {
assert.throws(() => groupByToMap(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => groupByToMap(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(groupByToMap(array, Boolean).get(true).foo, undefined, 'no @@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.array.group-by.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
import groupBy from 'core-js-pure/actual/array/group-by';
QUnit.test('Array#groupBy', assert => {
assert.isFunction(groupBy);
let array = [1];
const context = {};
groupBy(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(getPrototypeOf(groupBy([], it => it)), null, 'null proto');
assert.deepEqual(groupBy([1, 2, 3], it => it % 2), { 1: [1, 3], 0: [2] }, '#1');
assert.deepEqual(
groupBy([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], it => `i${ it % 5 }`),
{ i1: [1, 6, 11], i2: [2, 7, 12], i3: [3, 8], i4: [4, 9], i0: [5, 10] },
'#2',
);
assert.deepEqual(groupBy(Array(3), it => it), { undefined: [undefined, undefined, undefined] }, '#3');
if (STRICT) {
assert.throws(() => groupBy(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => groupBy(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(groupBy(array, Boolean).true.foo, undefined, 'no @@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.array.group-to-map.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Map from 'core-js-pure/es/map';
import Symbol from 'core-js-pure/es/symbol';
import from from 'core-js-pure/es/array/from';
import groupToMap from 'core-js-pure/actual/array/group-to-map';
QUnit.test('Array#groupToMap', assert => {
assert.isFunction(groupToMap);
let array = [1];
const context = {};
groupToMap(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(groupToMap([], it => it) instanceof Map, 'returns Map');
assert.deepEqual(from(groupToMap([1, 2, 3], it => it % 2)), [[1, [1, 3]], [0, [2]]], '#1');
assert.deepEqual(
from(groupToMap([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], it => `i${ it % 5 }`)),
[['i1', [1, 6, 11]], ['i2', [2, 7, 12]], ['i3', [3, 8]], ['i4', [4, 9]], ['i0', [5, 10]]],
'#2',
);
assert.deepEqual(from(groupToMap(Array(3), it => it)), [[undefined, [undefined, undefined, undefined]]], '#3');
if (STRICT) {
assert.throws(() => groupToMap(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => groupToMap(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(groupToMap(array, Boolean).get(true).foo, undefined, 'no @@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.array.group.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
import group from 'core-js-pure/actual/array/group';
QUnit.test('Array#group', assert => {
assert.isFunction(group);
let array = [1];
const context = {};
group(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(getPrototypeOf(group([], it => it)), null, 'null proto');
assert.deepEqual(group([1, 2, 3], it => it % 2), { 1: [1, 3], 0: [2] }, '#1');
assert.deepEqual(
group([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], it => `i${ it % 5 }`),
{ i1: [1, 6, 11], i2: [2, 7, 12], i3: [3, 8], i4: [4, 9], i0: [5, 10] },
'#2',
);
assert.deepEqual(group(Array(3), it => it), { undefined: [undefined, undefined, undefined] }, '#3');
if (STRICT) {
assert.throws(() => group(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => group(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(group(array, Boolean).true.foo, undefined, 'no @@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.array.is-template-object.js
|
JavaScript
|
import freeze from 'core-js-pure/es/object/freeze';
import isTemplateObject from 'core-js-pure/full/array/is-template-object';
QUnit.test('Array.isTemplateObject', assert => {
assert.isFunction(isTemplateObject);
assert.arity(isTemplateObject, 1);
assert.name(isTemplateObject, 'isTemplateObject');
assert.false(isTemplateObject(undefined));
assert.false(isTemplateObject(null));
assert.false(isTemplateObject({}));
assert.false(isTemplateObject(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()));
assert.false(isTemplateObject([]));
assert.false(isTemplateObject(freeze([])));
const template = (() => {
try {
// eslint-disable-next-line no-template-curly-in-string -- ignore
return Function('return (it => it)`qwe${ 123 }asd`')();
} catch { /* empty */ }
})();
if (template) assert.true(isTemplateObject(template));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.array.unique-by.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import uniqueBy from 'core-js-pure/full/array/unique-by';
QUnit.test('Array#uniqueBy', assert => {
assert.isFunction(uniqueBy);
let array = [1, 2, 3, 2, 1];
assert.notSame(uniqueBy(array), array);
assert.deepEqual(uniqueBy(array), [1, 2, 3]);
array = [
{
id: 1,
uid: 10000,
},
{
id: 2,
uid: 10000,
},
{
id: 3,
uid: 10001,
},
];
assert.deepEqual(uniqueBy(array, it => it.uid), [
{
id: 1,
uid: 10000,
},
{
id: 3,
uid: 10001,
},
]);
assert.deepEqual(uniqueBy(array, ({ id, uid }) => `${ id }-${ uid }`), array);
assert.deepEqual(uniqueBy([1, undefined, 2, undefined, null, 1]), [1, undefined, 2, null]);
assert.deepEqual(uniqueBy([0, -0]), [0]);
assert.deepEqual(uniqueBy([NaN, NaN]), [NaN]);
assert.deepEqual(uniqueBy({ length: 1, 0: 1 }), [1]);
if (STRICT) {
assert.throws(() => uniqueBy(null), TypeError);
assert.throws(() => uniqueBy(undefined), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.as-indexed-pairs.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import AsyncIterator from 'core-js-pure/full/async-iterator';
QUnit.test('AsyncIterator#asIndexedPairs', assert => {
const { asIndexedPairs } = AsyncIterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
assert.nonEnumerable(AsyncIterator.prototype, 'asIndexedPairs');
if (STRICT) {
assert.throws(() => asIndexedPairs.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => asIndexedPairs.call(null, () => { /* empty */ }), TypeError);
}
return asIndexedPairs.call(createIterator(['a', 'b', 'c'])).toArray().then(it => {
assert.same(it.toString(), '0,a,1,b,2,c', 'basic functionality');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.constructor.js
|
JavaScript
|
import { nativeSubclass } from '../helpers/helpers.js';
import Symbol from 'core-js-pure/es/symbol';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator', assert => {
assert.isFunction(AsyncIterator);
assert.arity(AsyncIterator, 0);
assert.true(AsyncIterator.from([1, 2, 3]) instanceof AsyncIterator, 'Async From Proxy');
assert.true(AsyncIterator.from([1, 2, 3]).drop(1) instanceof AsyncIterator, 'Async Drop Proxy');
if (nativeSubclass) {
const Sub = nativeSubclass(AsyncIterator);
assert.true(new Sub() instanceof AsyncIterator, 'abstract constructor');
}
assert.throws(() => new AsyncIterator(), 'direct constructor throws');
// eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
assert.throws(() => AsyncIterator(), 'throws w/o `new`');
});
QUnit.test('AsyncIterator#constructor', assert => {
assert.same(AsyncIterator.prototype.constructor, AsyncIterator, 'AsyncIterator#constructor is AsyncIterator');
});
QUnit.test('AsyncIterator#@@toStringTag', assert => {
assert.same(AsyncIterator.prototype[Symbol.toStringTag], 'AsyncIterator', 'AsyncIterator::@@toStringTag is `AsyncIterator`');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.drop.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#drop', assert => {
const { drop } = AsyncIterator.prototype;
assert.isFunction(drop);
assert.arity(drop, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'drop');
if (STRICT) {
assert.throws(() => drop.call(undefined, 1), TypeError);
assert.throws(() => drop.call(null, 1), TypeError);
}
assert.throws(() => drop.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
assert.throws(() => drop.call(createIterator([1, 2, 3]), NaN), RangeError, 'NaN');
return drop.call(createIterator([1, 2, 3]), 1).toArray().then(it => {
assert.arrayEqual(it, [2, 3], 'basic functionality');
return drop.call(createIterator([1, 2, 3]), 1.5).toArray();
}).then(it => {
assert.arrayEqual(it, [2, 3], 'float');
return drop.call(createIterator([1, 2, 3]), 4).toArray();
}).then(it => {
assert.arrayEqual(it, [], 'big');
return drop.call(createIterator([1, 2, 3]), 0).toArray();
}).then(it => {
assert.arrayEqual(it, [1, 2, 3], 'zero');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.every.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#every', assert => {
const { every } = AsyncIterator.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'every');
if (STRICT) {
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => every.call(createIterator([1]), undefined), TypeError);
assert.throws(() => every.call(createIterator([1]), null), TypeError);
assert.throws(() => every.call(createIterator([1]), {}), TypeError);
const counters = [];
return every.call(createIterator([1, 2, 3]), it => typeof it == 'number').then(result => {
assert.true(result, 'basic functionality, +');
return every.call(createIterator([1, 2, 3]), it => it === 2);
}).then(result => {
assert.false(result, 'basic functionality, -');
return every.call(createIterator([1, 2, 3]), (value, counter) => {
counters.push(counter);
return true;
});
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return every.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
}).then(() => {
return every.call(createIterator([1]), () => { throw 42; });
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => {
return every.call(
createIterator([1], { return() { throw 43; } }),
() => { throw 42; },
);
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error even if return() throws');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.filter.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#filter', assert => {
const { filter } = AsyncIterator.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'filter');
if (STRICT) {
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => filter.call(createIterator([1]), undefined), TypeError);
assert.throws(() => filter.call(createIterator([1]), null), TypeError);
assert.throws(() => filter.call(createIterator([1]), {}), TypeError);
const counters = [];
return filter.call(createIterator([1, 2, 3]), it => it % 2).toArray().then(it => {
assert.arrayEqual(it, [1, 3], 'basic functionality');
return filter.call(createIterator([1, 2, 3]), (value, counter) => {
counters.push(counter);
return value;
}).toArray();
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return filter.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
}).toArray();
}).then(() => {
return filter.call(createIterator([1]), () => { throw 42; }).toArray();
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.find.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#find', assert => {
const { find } = AsyncIterator.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'find');
if (STRICT) {
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => find.call(createIterator([1]), undefined), TypeError);
assert.throws(() => find.call(createIterator([1]), null), TypeError);
assert.throws(() => find.call(createIterator([1]), {}), TypeError);
const counters = [];
return find.call(createIterator([2, 3, 4]), it => it % 2).then(result => {
assert.same(result, 3, 'basic functionality, +');
return find.call(createIterator([1, 2, 3]), it => it === 4);
}).then(result => {
assert.same(result, undefined, 'basic functionality, -');
return find.call(createIterator([1, 2, 3]), (value, counter) => {
counters.push(counter);
return false;
});
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return find.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
}).then(() => {
return find.call(createIterator([1]), () => { throw 42; });
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => {
return find.call(
createIterator([1], { return() { throw 43; } }),
() => { throw 42; },
);
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error even if return() throws');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.flat-map.js
|
JavaScript
|
import { createIterator, createIterable } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('AsyncIterator#flatMap', assert => {
const { flatMap } = AsyncIterator.prototype;
assert.isFunction(flatMap);
assert.arity(flatMap, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'flatMap');
if (STRICT) {
assert.throws(() => flatMap.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => flatMap.call(createIterator([1]), undefined), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), null), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), {}), TypeError);
return flatMap.call(createIterator([1, [], 2, createIterable([3, 4]), [5, 6]]), it => typeof it == 'number' ? [-it] : it).toArray().then(it => {
assert.arrayEqual(it, [-1, -2, 3, 4, 5, 6], 'basic functionality');
return flatMap.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
return [arg];
}).toArray();
}).then(() => {
return flatMap.call(createIterator([1]), () => { throw 42; }).toArray();
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
});
});
QUnit.test('AsyncIterator#flatMap, inner iterator async close on return', assert => {
assert.expect(3);
const async = assert.async();
let innerReturnAwaited = false;
const outer = AsyncIterator.from({
next() {
return Promise.resolve({ value: [1, 2, 3], done: false });
},
return() {
assert.true(innerReturnAwaited, 'inner return() fully awaited before outer return()');
return Promise.resolve({ value: undefined, done: true });
},
[Symbol.asyncIterator]() { return this; },
});
const helper = outer.flatMap(arr => {
let i = 0;
return {
next() {
return Promise.resolve(i < arr.length
? { value: arr[i++], done: false }
: { value: undefined, done: true });
},
return() {
assert.required('inner return() called');
return new Promise(resolve => {
setTimeout(() => {
innerReturnAwaited = true;
resolve({ value: undefined, done: true });
}, 50);
});
},
[Symbol.asyncIterator]() { return this; },
};
});
helper.next().then(first => {
assert.same(first.value, 1, 'got first value');
return helper.return();
}).then(() => {
async();
}, () => {
assert.avoid();
async();
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.for-each.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#forEach', assert => {
const { forEach } = AsyncIterator.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'forEach');
if (STRICT) {
assert.throws(() => forEach.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => forEach.call(createIterator([1]), undefined), TypeError);
assert.throws(() => forEach.call(createIterator([1]), null), TypeError);
assert.throws(() => forEach.call(createIterator([1]), {}), TypeError);
const array = [];
const counters = [];
return forEach.call(createIterator([1, 2, 3]), it => array.push(it)).then(() => {
assert.arrayEqual(array, [1, 2, 3], 'basic functionality');
return forEach.call(createIterator([1, 2, 3]), (value, counter) => counters.push(counter));
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return forEach.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
}).then(() => {
return forEach.call(createIterator([1]), () => { throw 42; });
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => {
return forEach.call(
createIterator([1], { return() { throw 43; } }),
() => { throw 42; },
);
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error even if return() throws');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.from.js
|
JavaScript
|
import Promise from 'core-js-pure/es/promise';
import assign from 'core-js-pure/es/object/assign';
import create from 'core-js-pure/es/object/create';
import values from 'core-js-pure/es/array/values';
import ITERATOR from 'core-js-pure/es/symbol/iterator';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
import Iterator from 'core-js-pure/actual/iterator';
QUnit.test('AsyncIterator.from', assert => {
const { from } = AsyncIterator;
assert.isFunction(from);
assert.arity(from, 1);
assert.true(AsyncIterator.from(values([])) instanceof AsyncIterator, 'proxy, iterator');
assert.true(AsyncIterator.from([]) instanceof AsyncIterator, 'proxy, iterable');
const asyncIterator = assign(create(AsyncIterator.prototype), {
next: () => { /* empty */ },
});
assert.same(AsyncIterator.from(asyncIterator), asyncIterator, 'does not wrap AsyncIterator instances');
assert.throws(() => from(undefined), TypeError);
assert.throws(() => from(null), TypeError);
const closableIterator = {
closed: false,
[ITERATOR]() { return this; },
next() {
return { value: Promise.reject(42), done: false };
},
return() {
this.closed = true;
return { value: undefined, done: true };
},
};
return AsyncIterator.from([1, Promise.resolve(2), 3]).toArray().then(result => {
assert.arrayEqual(result, [1, 2, 3], 'unwrap promises');
}).then(() => {
return from(Iterator.from(closableIterator)).toArray();
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
assert.true(closableIterator.closed, 'doesn\'t close sync iterator on promise rejection');
});
});
QUnit.test('AsyncIterator.from, sync iterator value forwarding', assert => {
assert.expect(5);
const async = assert.async();
function * gen() {
const x = yield 1;
yield x;
}
const asyncIter = AsyncIterator.from(gen());
asyncIter.next().then(r1 => {
assert.same(r1.value, 1, 'first yield value');
assert.false(r1.done, 'not done after first yield');
return asyncIter.next(42);
}).then(r2 => {
assert.same(r2.value, 42, 'next(value) forwarded to sync generator');
assert.false(r2.done, 'not done after second yield');
return asyncIter.next();
}).then(r3 => {
assert.true(r3.done, 'done after generator completes');
async();
}).catch(() => {
assert.avoid();
async();
});
});
QUnit.test('AsyncIterator.from, sync iterator throw forwarding', assert => {
assert.expect(2);
const async = assert.async();
function * gen() {
try {
yield 1;
} catch (error) {
yield `caught: ${ error }`;
}
}
const asyncIter = AsyncIterator.from(gen());
asyncIter.next().then(() => {
return asyncIter.throw('boom');
}).then(result => {
assert.same(result.value, 'caught: boom', 'throw(value) forwarded to sync generator');
assert.false(result.done, 'not done after catch yield');
async();
}).catch(() => {
assert.avoid();
async();
});
});
QUnit.test('AsyncIterator.from, throw closes iterator without throw method', assert => {
assert.expect(2);
const async = assert.async();
let closeCalled = false;
const iter = AsyncIterator.from({
next() { return { value: 1, done: false }; },
return() { closeCalled = true; return { value: undefined, done: true }; },
[ITERATOR]() { return this; },
});
iter.next().then(() => {
return iter.throw('error');
}).then(() => {
assert.avoid();
async();
}, error => {
assert.same(error, 'error', 'rejects with thrown value');
assert.true(closeCalled, 'closes iterator when no throw method');
async();
});
});
QUnit.test('AsyncIterator.from, return(value) without iterator return method', assert => {
assert.expect(2);
const async = assert.async();
const iter = AsyncIterator.from({
next() { return { value: 1, done: false }; },
[ITERATOR]() { return this; },
});
iter.return(42).then(result => {
assert.same(result.value, 42, 'return(value) forwards value when no return method');
assert.true(result.done, 'done is true');
async();
}).catch(() => {
assert.avoid();
async();
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.indexed.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import AsyncIterator from 'core-js-pure/full/async-iterator';
QUnit.test('AsyncIterator#indexed', assert => {
const { indexed } = AsyncIterator.prototype;
assert.isFunction(indexed);
assert.arity(indexed, 0);
assert.nonEnumerable(AsyncIterator.prototype, 'indexed');
if (STRICT) {
assert.throws(() => indexed.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => indexed.call(null, () => { /* empty */ }), TypeError);
}
return indexed.call(createIterator(['a', 'b', 'c'])).toArray().then(it => {
assert.same(it.toString(), '0,a,1,b,2,c', 'basic functionality');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.map.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#map', assert => {
const { map } = AsyncIterator.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'map');
if (STRICT) {
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => map.call(createIterator([1]), undefined), TypeError);
assert.throws(() => map.call(createIterator([1]), null), TypeError);
assert.throws(() => map.call(createIterator([1]), {}), TypeError);
const counters = [];
return map.call(createIterator([1, 2, 3]), it => it ** 2).toArray().then(it => {
assert.arrayEqual(it, [1, 4, 9], 'basic functionality');
return map.call(createIterator([1, 2, 3]), (value, counter) => {
counters.push(counter);
return value;
}).toArray();
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return map.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
}).toArray();
}).then(() => {
return map.call(createIterator([1]), () => { throw 42; }).toArray();
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.reduce.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#reduce', assert => {
const { reduce } = AsyncIterator.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'reduce');
if (STRICT) {
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
}
assert.throws(() => reduce.call(createIterator([1]), undefined, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), null, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), {}, 1), TypeError);
return reduce.call(createIterator([1, 2, 3]), (a, b) => a + b, 1).then(it => {
assert.same(it, 7, 'basic functionality, initial');
return reduce.call(createIterator([2]), function (a, b, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 3, 'arguments length');
assert.same(a, 1, 'argument 1');
assert.same(b, 2, 'argument 2');
assert.same(counter, 0, 'counter');
}, 1);
}).then(() => {
return reduce.call(createIterator([1, 2, 3]), (a, b) => a + b);
}).then(it => {
assert.same(it, 6, 'basic functionality, no initial');
// counter increments unconditionally, so first reducer call gets counter=1
const countersNoInit = [];
return reduce.call(createIterator([10, 20, 30]), (a, b, counter) => {
countersNoInit.push(counter);
return a + b;
}).then(() => {
assert.deepEqual(countersNoInit, [1, 2], 'counter without initial value');
});
}).then(() => {
return reduce.call(createIterator([]), (a, b) => a + b);
}).catch(() => {
assert.true(true, 'reduce an empty iterable with no initial');
return reduce.call(createIterator([1]), () => { throw 42; }, 1);
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.some.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#some', assert => {
const { some } = AsyncIterator.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'some');
if (STRICT) {
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => some.call(createIterator([1]), undefined), TypeError);
assert.throws(() => some.call(createIterator([1]), null), TypeError);
assert.throws(() => some.call(createIterator([1]), {}), TypeError);
const counters = [];
return some.call(createIterator([1, 2, 3]), it => it === 2).then(result => {
assert.true(result, 'basic functionality, +');
return some.call(createIterator([1, 2, 3]), it => it === 4);
}).then(result => {
assert.false(result, 'basic functionality, -');
return some.call(createIterator([1, 2, 3]), (value, counter) => {
counters.push(counter);
return false;
});
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return some.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
}).then(() => {
return some.call(createIterator([1]), () => { throw 42; });
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => {
return some.call(
createIterator([1], { return() { throw 43; } }),
() => { throw 42; },
);
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error even if return() throws');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.take.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#take', assert => {
const { take } = AsyncIterator.prototype;
assert.isFunction(take);
assert.arity(take, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'take');
if (STRICT) {
assert.throws(() => take.call(undefined, 1), TypeError);
assert.throws(() => take.call(null, 1), TypeError);
}
assert.throws(() => take.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
assert.throws(() => take.call(createIterator([1, 2, 3]), NaN), RangeError, 'NaN');
return take.call(createIterator([1, 2, 3]), 2).toArray().then(it => {
assert.arrayEqual(it, [1, 2], 'basic functionality');
return take.call(createIterator([1, 2, 3]), 1.5).toArray();
}).then(it => {
assert.arrayEqual(it, [1], 'float');
return take.call(createIterator([1, 2, 3]), 4).toArray();
}).then(it => {
assert.arrayEqual(it, [1, 2, 3], 'big');
return take.call(createIterator([1, 2, 3]), 0).toArray();
}).then(it => {
assert.arrayEqual(it, [], 'zero');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.async-iterator.to-array.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#toArray', assert => {
const { toArray } = AsyncIterator.prototype;
assert.isFunction(toArray);
assert.arity(toArray, 0);
assert.nonEnumerable(AsyncIterator.prototype, 'toArray');
if (STRICT) {
assert.throws(() => toArray.call(undefined), TypeError);
assert.throws(() => toArray.call(null), TypeError);
}
return toArray.call(createIterator([1, 2, 3])).then(it => {
assert.arrayEqual(it, [1, 2, 3]);
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.bigint.range.js
|
JavaScript
|
/* eslint-disable es/no-bigint -- safe */
import from from 'core-js-pure/es/array/from';
import range from 'core-js-pure/full/bigint/range';
if (typeof BigInt == 'function') QUnit.test('BigInt.range', assert => {
assert.isFunction(range);
assert.name(range, 'range');
assert.arity(range, 3);
let iterator = range(BigInt(1), BigInt(2));
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: BigInt(1),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.deepEqual(from(range(BigInt(-1), BigInt(5))), [BigInt(-1), BigInt(0), BigInt(1), BigInt(2), BigInt(3), BigInt(4)]);
assert.deepEqual(from(range(BigInt(-5), BigInt(1))), [BigInt(-5), BigInt(-4), BigInt(-3), BigInt(-2), BigInt(-1), BigInt(0)]);
assert.deepEqual(
from(range(BigInt('9007199254740991'), BigInt('9007199254740992'), { inclusive: true })),
[BigInt('9007199254740991'), BigInt('9007199254740992')],
);
assert.deepEqual(from(range(BigInt(0), BigInt(0))), []);
assert.deepEqual(from(range(BigInt(0), BigInt(-5), BigInt(1))), []);
iterator = range(BigInt(1), BigInt(3));
assert.deepEqual(iterator.start, BigInt(1));
assert.deepEqual(iterator.end, BigInt(3));
assert.deepEqual(iterator.step, BigInt(1));
assert.false(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { inclusive: true });
assert.deepEqual(iterator.start, BigInt(-1));
assert.deepEqual(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(-1));
assert.true(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { step: BigInt(4), inclusive() { /* empty */ } });
assert.same(iterator.start, BigInt(-1));
assert.same(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(4));
assert.true(iterator.inclusive);
iterator = range(BigInt(0), BigInt(5));
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
assert.throws(() => Object.getOwnPropertyDescriptor(iterator, 'start').get.call({}), TypeError);
assert.throws(() => range(Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(-Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), Infinity), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), { step: Infinity }), TypeError);
assert.throws(() => range({}, BigInt(1)), TypeError);
assert.throws(() => range(BigInt(1), {}), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.composite-key.js
|
JavaScript
|
import { FREEZING } from '../helpers/constants.js';
import { getPrototypeOf, isFrozen } from 'core-js-pure/es/object';
import compositeKey from 'core-js-pure/full/composite-key';
QUnit.test('compositeKey', assert => {
assert.isFunction(compositeKey);
if (compositeKey.name) assert.name(compositeKey, 'compositeKey');
const key = compositeKey({});
assert.same(typeof key, 'object');
assert.same({}.toString.call(key), '[object Object]');
assert.same(getPrototypeOf(key), null);
if (FREEZING) assert.true(isFrozen(key));
const a = ['a'];
const b = ['b'];
const c = ['c'];
assert.same(compositeKey(a), compositeKey(a));
assert.notSame(compositeKey(a), compositeKey(['a']));
assert.notSame(compositeKey(a), compositeKey(a, 1));
assert.notSame(compositeKey(a), compositeKey(a, b));
assert.same(compositeKey(a, 1), compositeKey(a, 1));
assert.same(compositeKey(a, b), compositeKey(a, b));
assert.notSame(compositeKey(a, b), compositeKey(b, a));
assert.same(compositeKey(a, b, c), compositeKey(a, b, c));
assert.notSame(compositeKey(a, b, c), compositeKey(c, b, a));
assert.notSame(compositeKey(a, b, c), compositeKey(a, c, b));
assert.notSame(compositeKey(a, b, c, 1), compositeKey(a, b, c));
assert.same(compositeKey(a, b, c, 1), compositeKey(a, b, c, 1));
assert.same(compositeKey(1, a), compositeKey(1, a));
assert.notSame(compositeKey(1, a), compositeKey(a, 1));
assert.same(compositeKey(1, a, 2, b), compositeKey(1, a, 2, b));
assert.notSame(compositeKey(1, a, 2, b), compositeKey(1, a, b, 2));
assert.same(compositeKey(1, 2, a, b), compositeKey(1, 2, a, b));
assert.notSame(compositeKey(1, 2, a, b), compositeKey(1, a, b, 2));
assert.same(compositeKey(a, a), compositeKey(a, a));
assert.notSame(compositeKey(a, a), compositeKey(a, ['a']));
assert.notSame(compositeKey(a, a), compositeKey(a, b));
assert.throws(() => compositeKey(), TypeError);
assert.throws(() => compositeKey(1, 2), TypeError);
assert.throws(() => compositeKey('foo', null, true), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.composite-symbol.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
import compositeSymbol from 'core-js-pure/full/composite-symbol';
QUnit.test('compositeSymbol', assert => {
assert.isFunction(compositeSymbol);
if (compositeSymbol.name) assert.name(compositeSymbol, 'compositeSymbol');
assert.true(Object(compositeSymbol({})) instanceof Symbol);
const a = ['a'];
const b = ['b'];
const c = ['c'];
assert.same(compositeSymbol(a), compositeSymbol(a));
assert.notSame(compositeSymbol(a), compositeSymbol(['a']));
assert.notSame(compositeSymbol(a), compositeSymbol(a, 1));
assert.notSame(compositeSymbol(a), compositeSymbol(a, b));
assert.same(compositeSymbol(a, 1), compositeSymbol(a, 1));
assert.same(compositeSymbol(a, b), compositeSymbol(a, b));
assert.notSame(compositeSymbol(a, b), compositeSymbol(b, a));
assert.same(compositeSymbol(a, b, c), compositeSymbol(a, b, c));
assert.notSame(compositeSymbol(a, b, c), compositeSymbol(c, b, a));
assert.notSame(compositeSymbol(a, b, c), compositeSymbol(a, c, b));
assert.notSame(compositeSymbol(a, b, c, 1), compositeSymbol(a, b, c));
assert.same(compositeSymbol(a, b, c, 1), compositeSymbol(a, b, c, 1));
assert.same(compositeSymbol(1, a), compositeSymbol(1, a));
assert.notSame(compositeSymbol(1, a), compositeSymbol(a, 1));
assert.same(compositeSymbol(1, a, 2, b), compositeSymbol(1, a, 2, b));
assert.notSame(compositeSymbol(1, a, 2, b), compositeSymbol(1, a, b, 2));
assert.same(compositeSymbol(1, 2, a, b), compositeSymbol(1, 2, a, b));
assert.notSame(compositeSymbol(1, 2, a, b), compositeSymbol(1, a, b, 2));
assert.same(compositeSymbol(a, a), compositeSymbol(a, a));
assert.notSame(compositeSymbol(a, a), compositeSymbol(a, ['a']));
assert.notSame(compositeSymbol(a, a), compositeSymbol(a, b));
assert.same(compositeSymbol(), compositeSymbol());
assert.same(compositeSymbol(1, 2), compositeSymbol(1, 2));
assert.notSame(compositeSymbol(1, 2), compositeSymbol(2, 1));
assert.same(compositeSymbol('foo', null, true), compositeSymbol('foo', null, true));
assert.same(compositeSymbol('string'), Symbol.for('string'));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.function.demethodize.js
|
JavaScript
|
import demethodize from 'core-js-pure/full/function/demethodize';
QUnit.test('Function#demethodize', assert => {
assert.isFunction(demethodize);
// eslint-disable-next-line prefer-arrow-callback -- required for testing
assert.same(demethodize(function () { return 42; })(), 42);
assert.deepEqual(demethodize(Array.prototype.slice)([1, 2, 3], 1), [2, 3]);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.function.is-callable.js
|
JavaScript
|
import isCallable from 'core-js-pure/full/function/is-callable';
import { fromSource } from '../helpers/helpers.js';
QUnit.test('Function.isCallable', assert => {
assert.isFunction(isCallable);
assert.arity(isCallable, 1);
assert.name(isCallable, 'isCallable');
assert.false(isCallable({}), 'object');
assert.false(isCallable(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()), 'arguments');
assert.false(isCallable([]), 'array');
assert.false(isCallable(/./), 'regex');
assert.false(isCallable(1), 'number');
assert.false(isCallable(true), 'boolean');
assert.false(isCallable('1'), 'string');
assert.false(isCallable(null), 'null');
assert.false(isCallable(), 'undefined');
assert.true(isCallable(Function.call), 'native function');
// eslint-disable-next-line prefer-arrow-callback -- required
assert.true(isCallable(function () { /* empty */ }), 'function');
const arrow = fromSource('it => it');
if (arrow) assert.true(isCallable(arrow), 'arrow');
const klass = fromSource('class {}');
// Safari 9 and Edge 13- bugs
if (klass && !/constructor|function/.test(klass)) assert.false(isCallable(klass), 'class');
const gen = fromSource('function * () {}');
if (gen) assert.true(isCallable(gen), 'gen');
const asyncFunc = fromSource('async function () {}');
if (asyncFunc) assert.true(isCallable(asyncFunc), 'asyncFunc');
const asyncGen = fromSource('async * function () {}');
if (asyncGen) assert.true(isCallable(asyncGen), 'asyncGen');
const method = fromSource('({f(){}}).f');
// Safari 9 bug
if (method && !/function/.test(method)) assert.true(isCallable(method), 'method');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.function.is-constructor.js
|
JavaScript
|
import isConstructor from 'core-js-pure/full/function/is-constructor';
import { fromSource } from '../helpers/helpers.js';
QUnit.test('Function.isConstructor', assert => {
assert.isFunction(isConstructor);
assert.arity(isConstructor, 1);
assert.name(isConstructor, 'isConstructor');
assert.false(isConstructor({}), 'object');
assert.false(isConstructor(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()), 'arguments');
assert.false(isConstructor([]), 'array');
assert.false(isConstructor(/./), 'regex');
assert.false(isConstructor(1), 'number');
assert.false(isConstructor(true), 'boolean');
assert.false(isConstructor('1'), 'string');
assert.false(isConstructor(null), 'null');
assert.false(isConstructor(), 'undefined');
// assert.false(isConstructor(Function.call), 'native function'); // fails in some old engines
// eslint-disable-next-line prefer-arrow-callback -- required
assert.true(isConstructor(function () { /* empty */ }), 'function');
const arrow = fromSource('it => it');
if (arrow) assert.false(isConstructor(arrow), 'arrow');
const klass = fromSource('class {}');
// Safari 9 and Edge 13- bugs
if (klass && !/constructor|function/.test(klass)) assert.true(isConstructor(klass), 'class');
const Gen = fromSource('function * () {}');
// V8 ~ Chrome 49- bug
if (Gen) try {
new Gen();
} catch {
assert.false(isConstructor(Gen), 'gen');
}
const asyncFunc = fromSource('async function () {}');
if (asyncFunc) assert.false(isConstructor(asyncFunc), 'asyncFunc');
const asyncGen = fromSource('async * function () {}');
if (asyncGen) assert.false(isConstructor(asyncGen), 'asyncGen');
const method = fromSource('({f(){}}).f');
// Safari 9 bug
if (method && !/function/.test(method)) assert.false(isConstructor(method), 'method');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.function.metadata.js
|
JavaScript
|
import Symbol from 'core-js-pure/actual/symbol';
QUnit.test('Function#@@metadata', assert => {
assert.true(Symbol.metadata in Function.prototype);
assert.same(Function.prototype[Symbol.metadata], null, 'is null');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.function.un-this.js
|
JavaScript
|
import unThis from 'core-js-pure/full/function/un-this';
QUnit.test('Function#unThis', assert => {
assert.isFunction(unThis);
// eslint-disable-next-line prefer-arrow-callback -- required for testing
assert.same(unThis(function () { return 42; })(), 42);
assert.deepEqual(unThis(Array.prototype.slice)([1, 2, 3], 1), [2, 3]);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.iterator.as-indexed-pairs.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/full/iterator';
QUnit.test('Iterator#asIndexedPairs', assert => {
const { asIndexedPairs } = Iterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
assert.nonEnumerable(Iterator.prototype, 'asIndexedPairs');
assert.arrayEqual(asIndexedPairs.call(createIterator(['a', 'b', 'c'])).toArray().toString(), '0,a,1,b,2,c', 'basic functionality');
if (STRICT) {
assert.throws(() => asIndexedPairs.call(undefined), TypeError);
assert.throws(() => asIndexedPairs.call(null), TypeError);
}
assert.throws(() => asIndexedPairs.call({}).next(), TypeError);
assert.throws(() => asIndexedPairs.call([]).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.iterator.chunks.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/full/iterator/index';
import from from 'core-js-pure/es/array/from';
QUnit.test('Iterator#chunks', assert => {
const { chunks } = Iterator.prototype;
assert.isFunction(chunks);
assert.arity(chunks, 1);
assert.name(chunks, 'chunks');
assert.nonEnumerable(Iterator.prototype, 'chunks');
assert.arrayEqual(from(chunks.call(createIterator([1, 2, 3]), 2)), [[1, 2], [3]], 'basic functionality #1');
assert.arrayEqual(from(chunks.call(createIterator([1, 2, 3, 4]), 2)), [[1, 2], [3, 4]], 'basic functionality #2');
assert.arrayEqual(from(chunks.call(createIterator([]), 2)), [], 'basic functionality on empty iterable');
const it = createIterator([1, 2, 3]);
const result = chunks.call(it, 3);
assert.isIterable(result, 'returns iterable');
assert.isIterator(result, 'returns iterator');
assert.true(result instanceof Iterator, 'returns iterator');
assert.deepEqual(result.next(), { done: false, value: [1, 2, 3] }, '.next with active inner iterator result');
assert.deepEqual(result.return(), { done: true, value: undefined }, '.return with active inner iterator result');
assert.deepEqual(result.next(), { done: true, value: undefined }, '.return with active inner iterator result on closed iterator');
if (STRICT) {
assert.throws(() => chunks.call('', 1), TypeError, 'iterable non-object this');
assert.throws(() => chunks.call(undefined, 1), TypeError, 'non-iterable-object this #1');
assert.throws(() => chunks.call(null, 1), TypeError, 'non-iterable-object this #2');
assert.throws(() => chunks.call(5, 1), TypeError, 'non-iterable-object this #3');
}
assert.throws(() => chunks.call(it), RangeError, 'throws on empty argument');
assert.throws(() => chunks.call(it, -1), RangeError, 'throws on negative argument');
const observableReturn = {
return() {
this.called = true;
return { done: true, value: undefined };
},
};
const itObservable = createIterator([1, 2, 3], observableReturn);
assert.throws(() => chunks.call(itObservable, 0x100000000), RangeError, 'throws on argument more then 2^32 - 1');
assert.true(itObservable.called, 'iterator closed on argument validation error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.iterator.indexed.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/full/iterator';
QUnit.test('Iterator#indexed', assert => {
const { indexed } = Iterator.prototype;
assert.isFunction(indexed);
assert.arity(indexed, 0);
assert.nonEnumerable(Iterator.prototype, 'indexed');
assert.arrayEqual(indexed.call(createIterator(['a', 'b', 'c'])).toArray().toString(), '0,a,1,b,2,c', 'basic functionality');
if (STRICT) {
assert.throws(() => indexed.call(undefined), TypeError);
assert.throws(() => indexed.call(null), TypeError);
}
assert.throws(() => indexed.call({}).next(), TypeError);
assert.throws(() => indexed.call([]).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.iterator.range.js
|
JavaScript
|
/* eslint-disable es/no-bigint -- safe */
import { MAX_SAFE_INTEGER } from '../helpers/constants.js';
import from from 'core-js-pure/es/array/from';
import range from 'core-js-pure/full/iterator/range';
QUnit.test('Iterator.range', assert => {
assert.isFunction(range);
assert.name(range, 'range');
assert.arity(range, 3);
let iterator = range(1, 2);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.deepEqual(from(range(-1, 5)), [-1, 0, 1, 2, 3, 4]);
assert.deepEqual(from(range(-5, 1)), [-5, -4, -3, -2, -1, 0]);
assert.deepEqual(
from(range(0, 1, 0.1)),
[0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9],
);
assert.deepEqual(
from(range(MAX_SAFE_INTEGER, MAX_SAFE_INTEGER + 1, { inclusive: true })),
[MAX_SAFE_INTEGER, MAX_SAFE_INTEGER + 1],
);
assert.deepEqual(from(range(0, 0)), []);
assert.deepEqual(from(range(0, -5, 1)), []);
assert.throws(() => range(NaN, 0), RangeError, 'NaN as start');
assert.throws(() => range(0, NaN), RangeError, 'NaN as end');
assert.throws(() => range(NaN, NaN), RangeError, 'NaN as start and end');
assert.throws(() => range(0, 0, { step: NaN }), RangeError, 'NaN as step option');
assert.throws(() => range(0, 5, NaN), RangeError, 'NaN as step argument');
iterator = range(1, 3);
assert.deepEqual(iterator.start, 1);
assert.deepEqual(iterator.end, 3);
assert.deepEqual(iterator.step, 1);
assert.false(iterator.inclusive);
iterator = range(-1, -3, { inclusive: true });
assert.deepEqual(iterator.start, -1);
assert.deepEqual(iterator.end, -3);
assert.same(iterator.step, -1);
assert.true(iterator.inclusive);
iterator = range(0, 5, null);
assert.same(iterator.start, 0, 'null option: start');
assert.same(iterator.end, 5, 'null option: end');
assert.same(iterator.step, 1, 'null option: step defaults to 1');
assert.false(iterator.inclusive, 'null option: inclusive defaults to false');
iterator = range(-1, -3, { step: 4, inclusive() { /* empty */ } });
assert.same(iterator.start, -1);
assert.same(iterator.end, -3);
assert.same(iterator.step, 4);
assert.true(iterator.inclusive);
iterator = range(0, 5);
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
assert.throws(() => Object.getOwnPropertyDescriptor(iterator, 'start').get.call({}), TypeError);
assert.throws(() => range(Infinity, 10, 0), RangeError);
assert.throws(() => range(-Infinity, 10, 0), RangeError);
assert.throws(() => range(0, 10, Infinity), RangeError);
assert.throws(() => range(0, 10, { step: Infinity }), RangeError);
assert.throws(() => range({}, 1), TypeError);
assert.throws(() => range(1, {}), TypeError);
assert.throws(() => range('1', 2), TypeError);
assert.throws(() => range({ valueOf() { return 1; } }, 2), TypeError);
if (typeof BigInt == 'function') {
iterator = range(BigInt(1), BigInt(2));
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: BigInt(1),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.deepEqual(from(range(BigInt(-1), BigInt(5))), [BigInt(-1), BigInt(0), BigInt(1), BigInt(2), BigInt(3), BigInt(4)]);
assert.deepEqual(from(range(BigInt(-5), BigInt(1))), [BigInt(-5), BigInt(-4), BigInt(-3), BigInt(-2), BigInt(-1), BigInt(0)]);
assert.deepEqual(
from(range(BigInt('9007199254740991'), BigInt('9007199254740992'), { inclusive: true })),
[BigInt('9007199254740991'), BigInt('9007199254740992')],
);
assert.deepEqual(from(range(BigInt(0), BigInt(0))), []);
assert.deepEqual(from(range(BigInt(0), BigInt(-5), BigInt(1))), []);
iterator = range(BigInt(1), BigInt(3));
assert.deepEqual(iterator.start, BigInt(1));
assert.deepEqual(iterator.end, BigInt(3));
assert.deepEqual(iterator.step, BigInt(1));
assert.false(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { inclusive: true });
assert.deepEqual(iterator.start, BigInt(-1));
assert.deepEqual(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(-1));
assert.true(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { step: BigInt(4), inclusive() { /* empty */ } });
assert.same(iterator.start, BigInt(-1));
assert.same(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(4));
assert.true(iterator.inclusive);
iterator = range(BigInt(0), BigInt(5));
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
assert.throws(() => Object.getOwnPropertyDescriptor(iterator, 'start').get.call({}), TypeError);
assert.throws(() => range(Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(-Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), Infinity), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), { step: Infinity }), TypeError);
assert.throws(() => range({}, BigInt(1)), TypeError);
assert.throws(() => range(BigInt(1), {}), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.iterator.sliding.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/full/iterator/index';
import from from 'core-js-pure/es/array/from';
QUnit.test('Iterator#sliding', assert => {
const { sliding } = Iterator.prototype;
assert.isFunction(sliding);
assert.arity(sliding, 1);
assert.name(sliding, 'sliding');
assert.nonEnumerable(Iterator.prototype, 'sliding');
assert.arrayEqual(from(sliding.call(createIterator([1, 2, 3]), 2)), [[1, 2], [2, 3]], 'basic functionality #1');
assert.arrayEqual(from(sliding.call(createIterator([1, 2, 3, 4]), 2)), [[1, 2], [2, 3], [3, 4]], 'basic functionality #2');
assert.arrayEqual(from(sliding.call(createIterator([1, 2]), 3)), [[1, 2]], 'basic functionality #3');
assert.arrayEqual(from(sliding.call(createIterator([]), 2)), [], 'basic functionality on empty iterable');
const it = createIterator([1, 2, 3]);
const result = sliding.call(it, 3);
assert.isIterable(result, 'returns iterable');
assert.isIterator(result, 'returns iterator');
assert.true(result instanceof Iterator, 'returns iterator');
assert.deepEqual(result.next(), { done: false, value: [1, 2, 3] }, '.next with active inner iterator result');
assert.deepEqual(result.return(), { done: true, value: undefined }, '.return with active inner iterator result');
assert.deepEqual(result.next(), { done: true, value: undefined }, '.return with active inner iterator result on closed iterator');
if (STRICT) {
assert.throws(() => sliding.call('', 1), TypeError, 'iterable non-object this');
assert.throws(() => sliding.call(undefined, 1), TypeError, 'non-iterable-object this #1');
assert.throws(() => sliding.call(null, 1), TypeError, 'non-iterable-object this #2');
assert.throws(() => sliding.call(5, 1), TypeError, 'non-iterable-object this #3');
}
assert.throws(() => sliding.call(it), RangeError, 'throws on empty argument');
assert.throws(() => sliding.call(it, -1), RangeError, 'throws on negative argument');
const observableReturn = {
return() {
this.called = true;
return { done: true, value: undefined };
},
};
const itObservable = createIterator([1, 2, 3], observableReturn);
assert.throws(() => sliding.call(itObservable, 0x100000000), RangeError, 'throws on argument more then 2^32 - 1');
assert.true(itObservable.called, 'iterator closed on argument validation error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.iterator.to-async.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Promise from 'core-js-pure/es/promise';
import Set from 'core-js-pure/es/set';
import ITERATOR from 'core-js-pure/es/symbol/iterator';
import Iterator from 'core-js-pure/actual/iterator';
import 'core-js-pure/actual/async-iterator';
QUnit.test('Iterator#toAsync', assert => {
const { toAsync } = Iterator.prototype;
assert.isFunction(toAsync);
assert.arity(toAsync, 0);
if (STRICT) {
assert.throws(() => toAsync.call(undefined), TypeError);
assert.throws(() => toAsync.call(null), TypeError);
}
const closableIterator = {
closed: false,
[ITERATOR]() { return this; },
next() {
return { value: Promise.reject(42), done: false };
},
return() {
this.closed = true;
return { value: undefined, done: true };
},
};
return Iterator.from([1, 2, 3]).toAsync().map(it => Promise.resolve(it)).toArray().then(it => {
assert.arrayEqual(it, [1, 2, 3]);
return Iterator.from(new Set([1, 2, 3])).toAsync().map(el => Promise.resolve(el)).toArray();
}).then(it => {
assert.arrayEqual(it, [1, 2, 3]);
}).then(() => {
return Iterator.from(closableIterator).toAsync().toArray();
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
assert.true(closableIterator.closed, 'doesn\'t close sync iterator on promise rejection');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.iterator.windows.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/full/iterator/index';
import from from 'core-js-pure/es/array/from';
QUnit.test('Iterator#windows', assert => {
const { windows } = Iterator.prototype;
assert.isFunction(windows);
assert.arity(windows, 1);
assert.name(windows, 'windows');
assert.nonEnumerable(Iterator.prototype, 'windows');
assert.arrayEqual(from(windows.call(createIterator([1, 2, 3]), 2)), [[1, 2], [2, 3]], 'basic functionality #1');
assert.arrayEqual(from(windows.call(createIterator([1, 2, 3, 4]), 2)), [[1, 2], [2, 3], [3, 4]], 'basic functionality #2');
assert.arrayEqual(from(windows.call(createIterator([1, 2]), 3)), [], 'basic functionality #3');
assert.arrayEqual(from(windows.call(createIterator([]), 2)), [], 'basic functionality on empty iterable');
assert.arrayEqual(from(windows.call(createIterator([1, 2]), 3, 'only-full')), [], 'undersized #1');
assert.arrayEqual(from(windows.call(createIterator([1, 2]), 3, 'allow-partial')), [[1, 2]], 'undersized #2');
const it = createIterator([1, 2, 3]);
const result = windows.call(it, 3);
assert.isIterable(result, 'returns iterable');
assert.isIterator(result, 'returns iterator');
assert.true(result instanceof Iterator, 'returns iterator');
assert.deepEqual(result.next(), { done: false, value: [1, 2, 3] }, '.next with active inner iterator result');
assert.deepEqual(result.return(), { done: true, value: undefined }, '.return with active inner iterator result');
assert.deepEqual(result.next(), { done: true, value: undefined }, '.return with active inner iterator result on closed iterator');
if (STRICT) {
assert.throws(() => windows.call('', 1), TypeError, 'iterable non-object this');
assert.throws(() => windows.call(undefined, 1), TypeError, 'non-iterable-object this #1');
assert.throws(() => windows.call(null, 1), TypeError, 'non-iterable-object this #2');
assert.throws(() => windows.call(5, 1), TypeError, 'non-iterable-object this #3');
}
assert.throws(() => windows.call(it), RangeError, 'throws on empty argument');
assert.throws(() => windows.call(it, -1), RangeError, 'throws on negative argument');
const observableReturn = {
return() {
this.called = true;
return { done: true, value: undefined };
},
};
const itObservable = createIterator([1, 2, 3], observableReturn);
assert.throws(() => windows.call(itObservable, 0x100000000), RangeError, 'throws on argument more then 2^32 - 1');
assert.true(itObservable.called, 'iterator closed on argument validation error');
assert.throws(() => windows.call(createIterator([1]), 2, null), TypeError, 'incorrect `undersized` argument #1');
assert.throws(() => windows.call(createIterator([1]), 2, 'allowpartial'), TypeError, 'incorrect `undersized` argument #2');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.iterator.zip-keyed.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { DESCRIPTORS } from '../helpers/constants.js';
import defineProperty from 'core-js-pure/actual/object/define-property';
import from from 'core-js-pure/es/array/from';
import assign from 'core-js-pure/es/object/assign';
import create from 'core-js-pure/es/object/create';
import Symbol from 'core-js-pure/es/symbol';
import Iterator from 'core-js-pure/es/iterator';
import zipKeyed from 'core-js-pure/actual/iterator/zip-keyed';
function nullProto(obj) {
return assign(create(null), obj);
}
QUnit.test('Iterator.zipKeyed', assert => {
assert.isFunction(zipKeyed);
assert.arity(zipKeyed, 1);
assert.name(zipKeyed, 'zipKeyed');
let result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5], c: [7, 8, 9] });
assert.true(result instanceof Iterator, 'Iterator instance');
assert.deepEqual(from(result), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }]);
result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5, 6], c: [7, 8, 9] });
assert.deepEqual(from(result), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }]);
result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5, 6], c: [7, 8, 9] }, { mode: 'longest', padding: { c: 10 } });
assert.deepEqual(from(result), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }, { a: undefined, b: 6, c: 10 }]);
result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5, 6], c: [7, 8, 9] }, { mode: 'strict' });
assert.throws(() => from(result), TypeError);
if (DESCRIPTORS) {
let obj = {};
defineProperty(obj, 'a', { get: () => [0, 1, 2], enumerable: true });
defineProperty(obj, 'b', { get: () => [3, 4, 5], enumerable: true });
defineProperty(obj, 'c', { get: () => [7, 8, 9], enumerable: true });
defineProperty(obj, Symbol('d'), { get: () => [10, 11, 12] });
assert.deepEqual(from(zipKeyed(obj)), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }]);
const it = createIterator([1, 2], {
return() {
this.called = true;
return { done: true, value: undefined };
},
});
obj = { a: it };
defineProperty(obj, 'b', { get: () => { throw new Error(); }, enumerable: true });
assert.throws(() => from(zipKeyed(obj)), Error);
assert.true(it.called, 'iterator return called');
const foo = Symbol('foo');
const bar = Symbol('bar');
const zipped = zipKeyed({ [foo]: [1, 2, 3], [bar]: [4, 5, 6], baz: [7, 8, 9] });
result = from(zipped);
assert.same(result[0][foo], 1);
assert.same(result[0][bar], 4);
assert.same(result[0].baz, 7);
assert.same(result[1][foo], 2);
assert.same(result[1][bar], 5);
assert.same(result[1].baz, 8);
assert.same(result[2][foo], 3);
assert.same(result[2][bar], 6);
assert.same(result[2].baz, 9);
}
{
const $result = zipKeyed({
a: [0, 1, 2],
b: [3, 4, 5, 6, 7],
c: [8, 9],
}, {
mode: 'longest',
});
assert.deepEqual(from($result), [
nullProto({ a: 0, b: 3, c: 8 }),
nullProto({ a: 1, b: 4, c: 9 }),
nullProto({ a: 2, b: 5, c: undefined }),
nullProto({ a: undefined, b: 6, c: undefined }),
nullProto({ a: undefined, b: 7, c: undefined }),
]);
}
{
const $result = zipKeyed({
a: [0, 1, 2],
b: [3, 4, 5, 6, 7],
c: [8, 9],
}, {
mode: 'longest',
padding: { a: 'A', b: 'B', c: 'C' },
});
assert.deepEqual(from($result), [
nullProto({ a: 0, b: 3, c: 8 }),
nullProto({ a: 1, b: 4, c: 9 }),
nullProto({ a: 2, b: 5, c: 'C' }),
nullProto({ a: 'A', b: 6, c: 'C' }),
nullProto({ a: 'A', b: 7, c: 'C' }),
]);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.iterator.zip.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import from from 'core-js-pure/es/array/from';
import Iterator from 'core-js-pure/es/iterator';
import Symbol from 'core-js-pure/es/symbol';
import zip from 'core-js-pure/actual/iterator/zip';
QUnit.test('Iterator.zip', assert => {
assert.isFunction(zip);
assert.arity(zip, 1);
assert.name(zip, 'zip');
let result = zip([[1, 2, 3], [4, 5, 6]]);
assert.true(result instanceof Iterator, 'Iterator instance');
assert.deepEqual(from(result), [[1, 4], [2, 5], [3, 6]]);
result = zip([[1, 2, 3], [4, 5, 6, 7]]);
assert.deepEqual(from(result), [[1, 4], [2, 5], [3, 6]]);
result = zip([[1, 2, 3], [4, 5, 6, 7]], { mode: 'longest', padding: [9] });
assert.deepEqual(from(result), [[1, 4], [2, 5], [3, 6], [9, 7]]);
result = zip([[1, 2, 3, 4], [5, 6, 7]], { mode: 'longest', padding: [1, 9] });
assert.deepEqual(from(result), [[1, 5], [2, 6], [3, 7], [4, 9]]);
result = zip([[1, 2, 3], [4, 5, 6], [7, 8, 9]], { mode: 'strict' });
assert.deepEqual(from(result), [[1, 4, 7], [2, 5, 8], [3, 6, 9]]);
result = zip([[1, 2, 3], [4, 5, 6, 7]], { mode: 'strict' });
assert.throws(() => from(result), TypeError);
const observableReturn = {
return() {
this.called = true;
return { done: true, value: undefined };
},
};
{
const it1 = createIterator([1, 2], observableReturn);
const it2 = createIterator([3, 4], observableReturn);
result = zip([it1, it2]);
assert.deepEqual(result.next().value, [1, 3]);
assert.deepEqual(result.return(), { done: true, value: undefined });
assert.deepEqual(result.next(), { done: true, value: undefined });
assert.true(it1.called, 'first iterator return called');
assert.true(it2.called, 'second iterator return called');
}
{
const it = createIterator([1, 2, 3], observableReturn);
result = zip([it, [4, 5]], { mode: 'strict' });
assert.throws(() => from(result), TypeError);
assert.true(it.called, 'iterator return called #1');
}
{
const it = createIterator([3, 4, 5], observableReturn);
result = zip([[1, 2], it], { mode: 'strict' });
assert.throws(() => from(result), TypeError);
assert.true(it.called, 'iterator return called #2');
}
{
const it1 = createIterator([1, 2], { next() { throw new Error(); } });
const it2 = createIterator([3, 4], observableReturn);
result = zip([it1, it2]);
assert.throws(() => from(result), Error);
assert.true(it2.called, 'iterator return called #4');
}
{
const expectedError = new TypeError('strict next error');
let it2calls = 0;
const it2 = createIterator([2], {
next() {
if (it2calls++) throw expectedError;
return { value: 2, done: false };
},
});
result = zip([createIterator([1]), it2], { mode: 'strict' });
result.next();
let caught;
try {
result.next();
} catch (error) {
caught = error;
}
assert.same(caught, expectedError, 'strict mode propagates error from .next() during exhaustion check');
}
{
const $result = zip([
[0, 1, 2],
[3, 4, 5, 6, 7],
[8, 9],
], {
mode: 'longest',
});
assert.deepEqual(from($result), [
[0, 3, 8],
[1, 4, 9],
[2, 5, undefined],
[undefined, 6, undefined],
[undefined, 7, undefined],
]);
}
{
const $result = zip([
[0, 1, 2],
[3, 4, 5, 6, 7],
[8, 9],
], {
mode: 'longest',
padding: ['A', 'B', 'C'],
});
assert.deepEqual(from($result), [
[0, 3, 8],
[1, 4, 9],
[2, 5, 'C'],
['A', 6, 'C'],
['A', 7, 'C'],
]);
}
{
const expectedError = new TypeError('not iterable');
const badIterable = { [Symbol.iterator]() { throw expectedError; } };
const it1 = createIterator([1, 2], observableReturn);
let caught;
try {
zip([it1, badIterable]);
} catch (error) {
caught = error;
}
assert.same(caught, expectedError, 'original error is preserved');
assert.true(it1.called, 'first iterator return called on non-iterable second element');
}
{
const expectedError = new TypeError('inner return error');
const throwingReturn = {
return() {
throw expectedError;
},
};
const it1 = createIterator([1, 2], throwingReturn);
const it2 = createIterator([3, 4], observableReturn);
result = zip([it1, it2]);
result.next();
let caught;
try {
result.return();
} catch (error) {
caught = error;
}
assert.same(caught, expectedError, 'propagates the original error from inner return()');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.delete-all.js
|
JavaScript
|
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map#deleteAll', assert => {
const { deleteAll } = Map.prototype;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.nonEnumerable(Map.prototype, 'deleteAll');
let set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.true(set.deleteAll(1, 2));
assert.deepEqual(from(set), [[3, 4]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.false(set.deleteAll(3, 4));
assert.deepEqual(from(set), [[1, 2], [2, 3]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.false(set.deleteAll(4, 5));
assert.deepEqual(from(set), [[1, 2], [2, 3], [3, 4]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.true(set.deleteAll());
assert.deepEqual(from(set), [[1, 2], [2, 3], [3, 4]]);
assert.throws(() => deleteAll.call({ delete() { /* empty */ } }, 1, 2, 3));
assert.throws(() => deleteAll.call({}, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(undefined, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(null, 1, 2, 3), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.emplace.js
|
JavaScript
|
import Map from 'core-js-pure/full/map';
QUnit.test('Map#emplace', assert => {
const { emplace } = Map.prototype;
assert.isFunction(emplace);
assert.arity(emplace, 2);
assert.name(emplace, 'emplace');
assert.nonEnumerable(Map.prototype, 'emplace');
const map = new Map([['a', 2]]);
let handler = {
update(value, key, that) {
assert.same(this, handler, 'correct handler in callback');
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 'a', 'correct key in callback');
assert.same(that, map, 'correct map in callback');
return value ** 2;
},
insert() {
assert.avoid();
},
};
assert.same(map.emplace('a', handler), 4, 'returns a correct value');
handler = {
update() {
assert.avoid();
},
insert(key, that) {
assert.same(this, handler, 'correct handler in callback');
assert.same(arguments.length, 2, 'correct number of callback arguments');
assert.same(key, 'b', 'correct key in callback');
assert.same(that, map, 'correct map in callback');
return 3;
},
};
assert.same(map.emplace('b', handler), 3, 'returns a correct value');
assert.same(map.size, 2, 'correct size');
assert.same(map.get('a'), 4, 'correct result #1');
assert.same(map.get('b'), 3, 'correct result #2');
assert.same(new Map([['a', 2]]).emplace('b', { insert: () => 3 }), 3);
assert.same(new Map([['a', 2]]).emplace('a', { update: value => value ** 2 }), 4);
handler = { update() { /* empty */ }, insert() { /* empty */ } };
assert.throws(() => new Map().emplace('a'), TypeError);
assert.throws(() => emplace.call({}, 'a', handler), TypeError);
assert.throws(() => emplace.call([], 'a', handler), TypeError);
assert.throws(() => emplace.call(undefined, 'a', handler), TypeError);
assert.throws(() => emplace.call(null, 'a', handler), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.every.js
|
JavaScript
|
import Map from 'core-js-pure/full/map';
QUnit.test('Map#every', assert => {
const { every } = Map.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.nonEnumerable(Map.prototype, 'every');
let map = new Map([[9, 1]]);
const context = {};
map.every(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 9, 'correct index in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
map = new Map([[0, 1], [1, 2], [2, 3]]);
assert.true(map.every(it => typeof it == 'number'));
assert.true(map.every(it => it < 4));
assert.false(map.every(it => it < 3));
assert.false(map.every(it => typeof it == 'string'));
assert.true(map.every(function () {
return +this === 1;
}, 1));
let result = '';
map.every((value, key) => result += key);
assert.same(result, '012');
assert.true(map.every((value, key, that) => that === map));
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.filter.js
|
JavaScript
|
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map#filter', assert => {
const { filter } = Map.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.nonEnumerable(Map.prototype, 'filter');
const map = new Map([[1, 2]]);
const context = {};
map.filter(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).filter(it => typeof it == 'number')), [
['a', 1],
[1, 2],
['b', 3],
[3, 4],
[4, 5],
]);
assert.true(new Map().filter(it => it) instanceof Map);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.find-key.js
|
JavaScript
|
import Map from 'core-js-pure/full/map';
QUnit.test('Map#findKey', assert => {
const { findKey } = Map.prototype;
assert.isFunction(findKey);
assert.arity(findKey, 1);
assert.nonEnumerable(Map.prototype, 'findKey');
const set = new Map([[1, 2]]);
const context = {};
set.findKey(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Map([[1, 2], [2, 3], [3, 4]]).findKey(it => it % 2), 2);
assert.same(new Map().findKey(it => it === 42), undefined);
assert.throws(() => findKey.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.find.js
|
JavaScript
|
import Map from 'core-js-pure/full/map';
QUnit.test('Map#find', assert => {
const { find } = Map.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.nonEnumerable(Map.prototype, 'find');
const set = new Map([[1, 2]]);
const context = {};
set.find(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Map([[1, 2], [2, 3], [3, 4]]).find(it => it % 2), 3);
assert.same(new Map().find(it => it === 42), undefined);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.from.js
|
JavaScript
|
import { createIterable } from '../helpers/helpers.js';
import toArray from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map.from', assert => {
const { from } = Map;
assert.isFunction(from);
assert.arity(from, 1);
assert.true(from([]) instanceof Map);
assert.deepEqual(toArray(from([])), []);
assert.deepEqual(toArray(from([[1, 2]])), [[1, 2]]);
assert.deepEqual(toArray(from([[1, 2], [2, 3], [1, 4]])), [[1, 4], [2, 3]]);
assert.deepEqual(toArray(from(createIterable([[1, 2], [2, 3], [1, 4]]))), [[1, 4], [2, 3]]);
const pair = [1, 2];
const context = {};
from([pair], function (element, index) {
assert.same(element, pair);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.includes.js
|
JavaScript
|
import Map from 'core-js-pure/full/map';
QUnit.test('Map#includes', assert => {
const { includes } = Map.prototype;
assert.isFunction(includes);
assert.name(includes, 'includes');
assert.arity(includes, 1);
assert.nonEnumerable(Map.prototype, 'includes');
const object = {};
const map = new Map([[1, 1], [2, 2], [3, 3], [4, -0], [5, object], [6, NaN]]);
assert.true(map.includes(1));
assert.true(map.includes(-0));
assert.true(map.includes(0));
assert.true(map.includes(object));
assert.false(map.includes(4));
assert.false(map.includes(-0.5));
assert.false(map.includes({}));
assert.true(map.includes(NaN));
assert.throws(() => includes.call({}, 1), TypeError);
assert.throws(() => includes.call(undefined, 1), TypeError);
assert.throws(() => includes.call(null, 1), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.key-by.js
|
JavaScript
|
import { createIterable } from '../helpers/helpers.js';
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map.keyBy', assert => {
const { keyBy } = Map;
assert.isFunction(keyBy);
assert.arity(keyBy, 2);
assert.name(keyBy, 'keyBy');
assert.true(Map.keyBy([], it => it) instanceof Map);
assert.deepEqual(from(Map.keyBy([], it => it)), []);
assert.deepEqual(from(Map.keyBy([1, 2], it => it ** 2)), [[1, 1], [4, 2]]);
assert.deepEqual(from(Map.keyBy([1, 2, 1], it => it ** 2)), [[1, 1], [4, 2]]);
assert.deepEqual(from(Map.keyBy(createIterable([1, 2]), it => it ** 2)), [[1, 1], [4, 2]]);
const element = {};
Map.keyBy([element], it => assert.same(it, element));
// assert.throws(() => keyBy([1, 2], it => it));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.key-of.js
|
JavaScript
|
import Map from 'core-js-pure/full/map';
QUnit.test('Map#keyOf', assert => {
const { keyOf } = Map.prototype;
assert.isFunction(keyOf);
assert.arity(keyOf, 1);
assert.nonEnumerable(Map.prototype, 'keyOf');
const object = {};
const map = new Map([[1, 1], [2, 2], [3, 3], [4, -0], [5, object], [6, NaN]]);
assert.same(map.keyOf(1), 1);
assert.same(map.keyOf(-0), 4);
assert.same(map.keyOf(0), 4);
assert.same(map.keyOf(object), 5);
assert.same(map.keyOf(4), undefined);
assert.same(map.keyOf(-0.5), undefined);
assert.same(map.keyOf({}), undefined);
assert.same(map.keyOf(NaN), undefined);
assert.throws(() => keyOf.call({}, 1), TypeError);
assert.throws(() => keyOf.call(undefined, 1), TypeError);
assert.throws(() => keyOf.call(null, 1), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.map-keys.js
|
JavaScript
|
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map#mapKeys', assert => {
const { mapKeys } = Map.prototype;
assert.isFunction(mapKeys);
assert.arity(mapKeys, 1);
assert.name(mapKeys, 'mapKeys');
assert.nonEnumerable(Map.prototype, 'mapKeys');
const map = new Map([[1, 2]]);
const context = {};
map.mapKeys(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(new Map().mapKeys(it => it) instanceof Map);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).mapKeys((value, key) => `${ key }${ value }`)), [
['a1', 1],
['12', 2],
['b3', 3],
['2q', 'q'],
['c[object Object]', {}],
['34', 4],
['dtrue', true],
['45', 5],
]);
assert.throws(() => mapKeys.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => mapKeys.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => mapKeys.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.map-values.js
|
JavaScript
|
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map#mapValues', assert => {
const { mapValues } = Map.prototype;
assert.isFunction(mapValues);
assert.arity(mapValues, 1);
assert.name(mapValues, 'mapValues');
assert.nonEnumerable(Map.prototype, 'mapValues');
const map = new Map([[1, 2]]);
const context = {};
map.mapValues(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(new Map().mapValues(it => it) instanceof Map);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).mapValues((value, key) => `${ key }${ value }`)), [
['a', 'a1'],
[1, '12'],
['b', 'b3'],
[2, '2q'],
['c', 'c[object Object]'],
[3, '34'],
['d', 'dtrue'],
[4, '45'],
]);
assert.throws(() => mapValues.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => mapValues.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => mapValues.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.merge.js
|
JavaScript
|
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map#merge', assert => {
const { merge } = Map.prototype;
assert.isFunction(merge);
assert.arity(merge, 1);
assert.name(merge, 'merge');
assert.nonEnumerable(Map.prototype, 'merge');
const map = new Map([[1, 2]]);
const result = map.merge([[3, 4]]);
assert.same(result, map);
assert.true(result instanceof Map);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[5, 6]])), [[1, 2], [3, 4], [5, 6]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[3, 5], [5, 6]])), [[1, 2], [3, 5], [5, 6]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([])), [[1, 2], [3, 4]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[3, 5]], [[5, 6]])), [[1, 2], [3, 5], [5, 6]]);
assert.throws(() => merge.call({}, [[1, 2]]), TypeError);
assert.throws(() => merge.call(undefined, [[1, 2]]), TypeError);
assert.throws(() => merge.call(null, [[1, 2]]), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.of.js
|
JavaScript
|
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map.of', assert => {
const { of } = Map;
assert.isFunction(of);
assert.arity(of, 0);
assert.true(of() instanceof Map);
assert.deepEqual(from(of([1, 2])), [[1, 2]]);
assert.deepEqual(from(of([1, 2], [2, 3], [1, 4])), [[1, 4], [2, 3]]);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.reduce.js
|
JavaScript
|
import Map from 'core-js-pure/full/map';
QUnit.test('Map#reduce', assert => {
const { reduce } = Map.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.nonEnumerable(Map.prototype, 'reduce');
const set = new Map([['a', 1]]);
const accumulator = {};
set.reduce(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 'a', 'correct index in callback');
assert.same(that, set, 'correct link to set in callback');
}, accumulator);
assert.same(new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce((a, b) => a + b, 1), 7, 'works with initial accumulator');
new Map([
['a', 1],
['b', 2],
]).reduce((memo, value, key) => {
assert.same(memo, 1, 'correct default accumulator');
assert.same(value, 2, 'correct start value without initial accumulator');
assert.same(key, 'b', 'correct start index without initial accumulator');
});
assert.same(new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce((memo, value, key, s) => {
s.delete('b');
values += value;
keys += key;
}, 0);
assert.same(values, '13', 'correct order #1');
assert.same(keys, 'ac', 'correct order #2');
assert.throws(() => reduce.call({}, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.some.js
|
JavaScript
|
import Map from 'core-js-pure/full/map';
QUnit.test('Map#some', assert => {
const { some } = Map.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.nonEnumerable(Map.prototype, 'some');
let map = new Map([[9, 1]]);
const context = {};
map.some(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 9, 'correct index in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
map = new Map([[0, 1], [1, '2'], [2, 3]]);
assert.true(map.some(it => typeof it == 'number'));
assert.true(map.some(it => it < 3));
assert.false(map.some(it => it < 0));
assert.true(map.some(it => typeof it == 'string'));
assert.false(map.some(function () {
return +this !== 1;
}, 1));
let result = '';
map.some((value, key) => {
result += key;
return false;
});
assert.same(result, '012');
assert.true(map.some((value, key, that) => that === map));
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.update-or-insert.js
|
JavaScript
|
import Map from 'core-js-pure/full/map';
QUnit.test('Map#updateOrInsert', assert => {
const { updateOrInsert } = Map.prototype;
assert.isFunction(updateOrInsert);
assert.arity(updateOrInsert, 2);
assert.nonEnumerable(Map.prototype, 'updateOrInsert');
const map = new Map([['a', 2]]);
assert.same(map.updateOrInsert('a', function (value) {
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
return value ** 2;
}, () => {
assert.avoid();
return 3;
}), 4, 'returns a correct value');
assert.same(map.updateOrInsert('b', value => {
assert.avoid();
return value ** 2;
}, function () {
assert.same(arguments.length, 0, 'correct number of callback arguments');
return 3;
}), 3, 'returns a correct value');
assert.same(map.size, 2, 'correct size');
assert.same(map.get('a'), 4, 'correct result #1');
assert.same(map.get('b'), 3, 'correct result #2');
assert.same(new Map([['a', 2]]).updateOrInsert('b', null, () => 3), 3);
assert.same(new Map([['a', 2]]).updateOrInsert('a', value => value ** 2), 4);
assert.throws(() => new Map().updateOrInsert('a'), TypeError);
assert.throws(() => updateOrInsert.call({}, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call([], 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call(undefined, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call(null, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.update.js
|
JavaScript
|
import Map from 'core-js-pure/full/map';
QUnit.test('Map#update', assert => {
const { update } = Map.prototype;
assert.isFunction(update);
assert.arity(update, 2);
assert.name(update, 'update');
assert.nonEnumerable(Map.prototype, 'update');
let map = new Map([[9, 2]]);
assert.same(map.update(9, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 9, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
return value * 2;
}), map, 'returns this');
assert.same(map.size, 1, 'correct size');
assert.same(map.get(9), 4, 'correct result');
map = new Map([[4, 5]]);
map.update(9, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 9, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
return value * 2;
}, function (key, that) {
assert.same(arguments.length, 2, 'correct number of thunk arguments');
assert.same(key, 9, 'correct key in thunk');
assert.same(that, map, 'correct link to map in thunk');
return 2;
});
assert.same(map.size, 2, 'correct size');
assert.same(map.get(4), 5, 'correct result #1');
assert.same(map.get(9), 4, 'correct result #2');
assert.throws(() => new Map([[9, 2]]).update(9), TypeError);
assert.throws(() => new Map().update(9, () => { /* empty */ }), TypeError);
assert.throws(() => update.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => update.call([], () => { /* empty */ }), TypeError);
assert.throws(() => update.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => update.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.map.upsert.js
|
JavaScript
|
import Map from 'core-js-pure/full/map';
QUnit.test('Map#upsert', assert => {
const { upsert } = Map.prototype;
assert.isFunction(upsert);
assert.arity(upsert, 2);
assert.nonEnumerable(Map.prototype, 'upsert');
const map = new Map([['a', 2]]);
assert.same(map.upsert('a', function (value) {
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
return value ** 2;
}, () => {
assert.avoid();
return 3;
}), 4, 'returns a correct value');
assert.same(map.upsert('b', value => {
assert.avoid();
return value ** 2;
}, function () {
assert.same(arguments.length, 0, 'correct number of callback arguments');
return 3;
}), 3, 'returns a correct value');
assert.same(map.size, 2, 'correct size');
assert.same(map.get('a'), 4, 'correct result #1');
assert.same(map.get('b'), 3, 'correct result #2');
assert.same(new Map([['a', 2]]).upsert('b', null, () => 3), 3);
assert.same(new Map([['a', 2]]).upsert('a', value => value ** 2), 4);
assert.throws(() => new Map().upsert('a'), TypeError);
assert.throws(() => upsert.call({}, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call([], 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(undefined, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(null, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.clamp.js
|
JavaScript
|
import clamp from 'core-js-pure/full/math/clamp';
QUnit.test('Math.clamp', assert => {
assert.isFunction(clamp);
assert.arity(clamp, 3);
assert.same(clamp(2, 4, 6), 4);
assert.same(clamp(4, 2, 6), 4);
assert.same(clamp(6, 2, 4), 4);
assert.same(clamp(-0, 0, 1), 0, 'If value is -0𝔽 and min is +0𝔽, return +0𝔽.');
assert.same(clamp(0, -0, 1), 0, 'If value is +0𝔽 and min is -0𝔽, return +0𝔽.');
assert.same(clamp(-0, -1, 0), -0, 'If value is -0𝔽 and max is +0𝔽, return -0𝔽.');
assert.same(clamp(0, -1, -0), -0, 'If value is +0𝔽 and max is -0𝔽, return -0𝔽.');
assert.same(clamp(0, -0, -0), -0, 'If min = max return min.');
assert.same(clamp(2, 0, -0), -0, 'min is +0𝔽 and max is -0𝔽');
assert.same(clamp(2, 3, 1), 1, 'min > max');
assert.same(clamp(NaN, 3, 1), NaN, 'If value is NaN, return NaN.');
assert.same(clamp(2, NaN, 1), NaN, 'If min is NaN, return NaN.');
assert.same(clamp(2, 3, NaN), NaN, 'If max is NaN, return NaN.');
assert.throws(() => clamp({ valueOf: () => 2 }, 1, 3), TypeError, 'If value is not a Number, throw a TypeError exception');
assert.throws(() => clamp(2, Object(1), 3), TypeError, 'If min is not a Number, throw a TypeError exception.');
assert.throws(() => clamp(2, 1, Object(3)), TypeError, 'If max is not a Number, throw a TypeError exception.');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.deg-per-rad.js
|
JavaScript
|
import DEG_PER_RAD from 'core-js-pure/full/math/deg-per-rad';
QUnit.test('Math.DEG_PER_RAD', assert => {
assert.same(DEG_PER_RAD, Math.PI / 180, 'Is Math.PI / 180');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.degrees.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import degrees from 'core-js-pure/full/math/degrees';
QUnit.test('Math.degrees', assert => {
assert.isFunction(degrees);
assert.arity(degrees, 1);
assert.same(degrees(0), 0);
assert.same(degrees(Math.PI / 2), 90);
assert.same(degrees(Math.PI), 180);
assert.same(degrees(3 * Math.PI / 2), 270);
const checker = createConversionChecker(3 * Math.PI / 2);
assert.same(degrees(checker), 270, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.fscale.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import fscale from 'core-js-pure/full/math/fscale';
QUnit.test('Math.fscale', assert => {
assert.isFunction(fscale);
assert.arity(fscale, 5);
assert.same(fscale(3, 1, 2, 1, 2), 3);
assert.same(fscale(0, 3, 5, 8, 10), 5);
assert.same(fscale(1, 1, 1, 1, 1), NaN);
assert.same(fscale(-1, -1, -1, -1, -1), NaN);
const checker1 = createConversionChecker(3);
const checker2 = createConversionChecker(1);
const checker3 = createConversionChecker(2);
const checker4 = createConversionChecker(1);
const checker5 = createConversionChecker(2);
assert.same(fscale(checker1, checker2, checker3, checker4, checker5), 3, 'object wrapper');
assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
assert.same(checker1.$toString, 0, 'checker1 toString calls');
assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
assert.same(checker2.$toString, 0, 'checker2 toString calls');
assert.same(checker3.$valueOf, 1, 'checker3 valueOf calls');
assert.same(checker3.$toString, 0, 'checker3 toString calls');
assert.same(checker4.$valueOf, 1, 'checker4 valueOf calls');
assert.same(checker4.$toString, 0, 'checker4 toString calls');
assert.same(checker5.$valueOf, 1, 'checker5 valueOf calls');
assert.same(checker5.$toString, 0, 'checker5 toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.iaddh.js
|
JavaScript
|
import iaddh from 'core-js-pure/full/math/iaddh';
QUnit.test('Math.iaddh', assert => {
assert.isFunction(iaddh);
assert.arity(iaddh, 4);
assert.same(iaddh(0, 2, 1, 0), 2);
assert.same(iaddh(0, 4, 1, 1), 5);
assert.same(iaddh(2, 4, 1, 1), 5);
assert.same(iaddh(0xFFFFFFFF, 4, 1, 1), 6);
assert.same(iaddh(1, 4, 0xFFFFFFFF, 1), 6);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.imulh.js
|
JavaScript
|
import imulh from 'core-js-pure/full/math/imulh';
QUnit.test('Math.imulh', assert => {
assert.isFunction(imulh);
assert.arity(imulh, 2);
assert.same(imulh(0xFFFFFFFF, 7), -1);
assert.same(imulh(0xFFFFFFF, 77), 4);
assert.same(imulh(1, 7), 0);
assert.same(imulh(-1, 7), -1);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.isubh.js
|
JavaScript
|
import isubh from 'core-js-pure/full/math/isubh';
QUnit.test('Math.isubh', assert => {
assert.isFunction(isubh);
assert.arity(isubh, 4);
assert.same(isubh(0, 2, 1, 0), 1);
assert.same(isubh(0, 4, 1, 1), 2);
assert.same(isubh(2, 4, 1, 1), 3);
assert.same(isubh(0xFFFFFFFF, 4, 1, 1), 3);
assert.same(isubh(1, 4, 0xFFFFFFFF, 1), 2);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.rad-per-deg.js
|
JavaScript
|
import RAD_PER_DEG from 'core-js-pure/full/math/rad-per-deg';
QUnit.test('Math.RAD_PER_DEG', assert => {
assert.same(RAD_PER_DEG, 180 / Math.PI, 'Is 180 / Math.PI');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.radians.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import radians from 'core-js-pure/full/math/radians';
QUnit.test('Math.radians', assert => {
assert.isFunction(radians);
assert.arity(radians, 1);
assert.same(radians(0), 0);
assert.same(radians(90), Math.PI / 2);
assert.same(radians(180), Math.PI);
assert.same(radians(270), 3 * Math.PI / 2);
const checker = createConversionChecker(270);
assert.same(radians(checker), 3 * Math.PI / 2, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.scale.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import scale from 'core-js-pure/full/math/scale';
QUnit.test('Math.scale', assert => {
assert.isFunction(scale);
assert.arity(scale, 5);
assert.same(scale(3, 1, 2, 1, 2), 3);
assert.same(scale(0, 3, 5, 8, 10), 5);
assert.same(scale(1, 1, 1, 1, 1), NaN);
assert.same(scale(-1, -1, -1, -1, -1), NaN);
const checker1 = createConversionChecker(3);
const checker2 = createConversionChecker(1);
const checker3 = createConversionChecker(2);
const checker4 = createConversionChecker(1);
const checker5 = createConversionChecker(2);
assert.same(scale(checker1, checker2, checker3, checker4, checker5), 3, 'object wrapper');
assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
assert.same(checker1.$toString, 0, 'checker1 toString calls');
assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
assert.same(checker2.$toString, 0, 'checker2 toString calls');
assert.same(checker3.$valueOf, 1, 'checker3 valueOf calls');
assert.same(checker3.$toString, 0, 'checker3 toString calls');
assert.same(checker4.$valueOf, 1, 'checker4 valueOf calls');
assert.same(checker4.$toString, 0, 'checker4 toString calls');
assert.same(checker5.$valueOf, 1, 'checker5 valueOf calls');
assert.same(checker5.$toString, 0, 'checker5 toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.seeded-prng.js
|
JavaScript
|
import seededPRNG from 'core-js-pure/full/math/seeded-prng';
QUnit.test('Math.seededPRNG', assert => {
assert.isFunction(seededPRNG);
assert.arity(seededPRNG, 1);
for (const gen of [seededPRNG({ seed: 42 }), seededPRNG({ seed: 42 })]) {
assert.deepEqual(gen.next(), { value: 0.16461519912315087, done: false });
assert.deepEqual(gen.next(), { value: 0.2203933906000046, done: false });
assert.deepEqual(gen.next(), { value: 0.8249682894209105, done: false });
assert.deepEqual(gen.next(), { value: 0.10750079537509083, done: false });
assert.deepEqual(gen.next(), { value: 0.004673248161257476, done: false });
}
for (const gen of [seededPRNG({ seed: 43 }), seededPRNG({ seed: 43 })]) {
assert.deepEqual(gen.next(), { value: 0.1923438591811283, done: false });
assert.deepEqual(gen.next(), { value: 0.7896811578326683, done: false });
assert.deepEqual(gen.next(), { value: 0.9518230761883996, done: false });
assert.deepEqual(gen.next(), { value: 0.1414634102410296, done: false });
assert.deepEqual(gen.next(), { value: 0.7379838030207752, done: false });
}
assert.throws(() => seededPRNG(), TypeError);
assert.throws(() => seededPRNG(5), TypeError);
assert.throws(() => seededPRNG({ seed: null }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.signbit.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import signbit from 'core-js-pure/full/math/signbit';
QUnit.test('Math.signbit', assert => {
assert.isFunction(signbit);
assert.false(signbit(NaN));
assert.false(signbit());
assert.true(signbit(-0));
assert.false(signbit(0));
assert.false(signbit(Infinity));
assert.true(signbit(-Infinity));
assert.false(signbit(13510798882111488));
assert.true(signbit(-13510798882111488));
assert.false(signbit(42.5));
assert.true(signbit(-42.5));
const checker = createConversionChecker(-13510798882111488);
assert.true(signbit(checker), 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.math.umulh.js
|
JavaScript
|
import umulh from 'core-js-pure/full/math/umulh';
QUnit.test('Math.umulh', assert => {
assert.isFunction(umulh);
assert.arity(umulh, 2);
assert.same(umulh(0xFFFFFFFF, 7), 6);
assert.same(umulh(0xFFFFFFF, 77), 4);
assert.same(umulh(1, 7), 0);
assert.same(umulh(-1, 7), 6);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.number.clamp.js
|
JavaScript
|
import clamp from 'core-js-pure/full/number/clamp';
QUnit.test('Number#clamp', assert => {
assert.isFunction(clamp);
assert.same(clamp(2, 4, 6), 4);
assert.same(clamp(4, 2, 6), 4);
assert.same(clamp(6, 2, 4), 4);
assert.same(clamp(-0, 0, 1), 0, 'If value is -0𝔽 and min is +0𝔽, return +0𝔽.');
assert.same(clamp(0, -0, 1), 0, 'If value is +0𝔽 and min is -0𝔽, return +0𝔽.');
assert.same(clamp(-0, -1, 0), -0, 'If value is -0𝔽 and max is +0𝔽, return -0𝔽.');
assert.same(clamp(0, -1, -0), -0, 'If value is +0𝔽 and max is -0𝔽, return -0𝔽.');
assert.same(clamp(0, -0, -0), -0, 'If min = max return min.');
assert.same(clamp(2, 0, -0), -0, 'min is +0𝔽 and max is -0𝔽');
assert.same(clamp(2, 3, 1), 1, 'min > max');
assert.same(clamp(NaN, 3, 1), NaN, 'If value is NaN, return NaN.');
assert.same(clamp(2, NaN, 1), NaN, 'If min is NaN, return NaN.');
assert.same(clamp(2, 3, NaN), NaN, 'If max is NaN, return NaN.');
assert.throws(() => clamp({ valueOf: () => 2 }, 1, 3), TypeError, 'If value is not a Number, throw a TypeError exception');
assert.throws(() => clamp(2, Object(1), 3), TypeError, 'If min is not a Number, throw a TypeError exception.');
assert.throws(() => clamp(2, 1, Object(3)), TypeError, 'If max is not a Number, throw a TypeError exception.');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.number.from-string.js
|
JavaScript
|
import fromString from 'core-js-pure/full/number/from-string';
QUnit.test('Number.fromString', assert => {
assert.isFunction(fromString);
assert.name(fromString, 'fromString');
assert.arity(fromString, 2);
assert.throws(() => fromString(undefined), TypeError, 'The first argument should be a string #1');
assert.throws(() => fromString(Object('10')), TypeError, 'The first argument should be a string #1');
assert.throws(() => fromString(''), SyntaxError, 'Empty string');
assert.same(fromString('-10', 2), -2, 'Works with negative numbers');
assert.throws(() => fromString('-'), SyntaxError, '-');
assert.same(fromString('10'), 10, 'Default radix is 10 #1');
assert.same(fromString('10', undefined), 10, 'Default radix is 10 #2');
for (let radix = 2; radix <= 36; ++radix) {
assert.same(fromString('10', radix), radix, `Radix ${ radix }`);
}
assert.throws(() => fromString('10', -4294967294), RangeError, 'Radix uses ToInteger #1');
assert.same(fromString('10', 2.5), 2, 'Radix uses ToInteger #2');
assert.same(fromString('42'), 42);
assert.same(fromString('42', 10), 42);
assert.same(fromString('3.14159', 10), 3.14159);
assert.same(fromString('-100.11', 2), -4.75);
assert.same(fromString('202.1', 3), 20.333333333333332);
assert.same(fromString('0'), 0);
assert.same(fromString('0', 2), 0);
assert.same(fromString('-0'), -0);
assert.same(fromString('-0', 2), -0);
assert.throws(() => fromString('0xc0ffee'), SyntaxError);
assert.throws(() => fromString('0o755'), SyntaxError);
assert.throws(() => fromString('0b00101010'), SyntaxError);
assert.throws(() => fromString('C0FFEE', 16), SyntaxError);
assert.same(fromString('c0ffee', 16), 12648430);
assert.same(fromString('755', 8), 493);
assert.throws(() => fromString(''), SyntaxError);
assert.throws(() => fromString(' '), SyntaxError);
assert.throws(() => fromString(' 1'), SyntaxError);
assert.throws(() => fromString(' \n '), SyntaxError);
assert.throws(() => fromString('x'), SyntaxError);
assert.throws(() => fromString('1234', 0), RangeError);
assert.throws(() => fromString('1234', 1), RangeError);
assert.throws(() => fromString('1234', 37), RangeError);
assert.throws(() => fromString('010'), SyntaxError);
assert.throws(() => fromString('1_000_000_000'), SyntaxError);
assert.throws(() => fromString('19', 8), SyntaxError, 'Invalid digit for radix #1');
assert.throws(() => fromString('1g', 16), SyntaxError, 'Invalid digit for radix #2');
assert.throws(() => fromString('fg', 16), SyntaxError, 'Invalid digit for radix #3');
assert.throws(() => fromString('89', 8), SyntaxError, 'Invalid digit for radix #4');
assert.throws(() => fromString('1.2.3', 16), SyntaxError, 'Multiple dots #1');
assert.throws(() => fromString('1.2.3', 10), SyntaxError, 'Multiple dots #2');
assert.throws(() => fromString('.5', 16), SyntaxError, 'Leading dot #1');
assert.throws(() => fromString('5.', 16), SyntaxError, 'Trailing dot #1');
assert.throws(() => fromString('.5', 10), SyntaxError, 'Leading dot #2');
assert.throws(() => fromString('5.', 10), SyntaxError, 'Trailing dot #2');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.number.range.js
|
JavaScript
|
import { MAX_SAFE_INTEGER } from '../helpers/constants.js';
import from from 'core-js-pure/es/array/from';
import range from 'core-js-pure/full/number/range';
QUnit.test('range', assert => {
assert.isFunction(range);
assert.name(range, 'range');
assert.arity(range, 3);
let iterator = range(1, 2);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.deepEqual(from(range(-1, 5)), [-1, 0, 1, 2, 3, 4]);
assert.deepEqual(from(range(-5, 1)), [-5, -4, -3, -2, -1, 0]);
assert.deepEqual(
from(range(0, 1, 0.1)),
[0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9],
);
assert.deepEqual(
from(range(MAX_SAFE_INTEGER, MAX_SAFE_INTEGER + 1, { inclusive: true })),
[MAX_SAFE_INTEGER, MAX_SAFE_INTEGER + 1],
);
assert.deepEqual(from(range(0, 0)), []);
assert.deepEqual(from(range(0, -5, 1)), []);
assert.throws(() => range(NaN, 0), RangeError, 'NaN as start');
assert.throws(() => range(0, NaN), RangeError, 'NaN as end');
assert.throws(() => range(NaN, NaN), RangeError, 'NaN as start and end');
assert.throws(() => range(0, 0, { step: NaN }), RangeError, 'NaN as step option');
assert.throws(() => range(0, 5, NaN), RangeError, 'NaN as step argument');
iterator = range(1, 3);
assert.deepEqual(iterator.start, 1);
assert.deepEqual(iterator.end, 3);
assert.deepEqual(iterator.step, 1);
assert.false(iterator.inclusive);
iterator = range(-1, -3, { inclusive: true });
assert.deepEqual(iterator.start, -1);
assert.deepEqual(iterator.end, -3);
assert.same(iterator.step, -1);
assert.true(iterator.inclusive);
iterator = range(-1, -3, { step: 4, inclusive() { /* empty */ } });
assert.same(iterator.start, -1);
assert.same(iterator.end, -3);
assert.same(iterator.step, 4);
assert.true(iterator.inclusive);
iterator = range(0, 5);
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
assert.throws(() => Object.getOwnPropertyDescriptor(iterator, 'start').get.call({}), TypeError);
assert.throws(() => range(Infinity, 10, 0), RangeError);
assert.throws(() => range(-Infinity, 10, 0), RangeError);
assert.throws(() => range(0, 10, Infinity), RangeError);
assert.throws(() => range(0, 10, { step: Infinity }), RangeError);
assert.throws(() => range({}, 1), TypeError);
assert.throws(() => range(1, {}), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.object.iterate-entries.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
import iterateEntries from 'core-js-pure/full/object/iterate-entries';
QUnit.test('Object.iterateEntries', assert => {
assert.isFunction(iterateEntries);
assert.name(iterateEntries, 'iterateEntries');
assert.arity(iterateEntries, 1);
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateEntries(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: ['q', 1],
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: ['e', 3],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.object.iterate-keys.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
import iterateKeys from 'core-js-pure/full/object/iterate-keys';
QUnit.test('Object.iterateKeys', assert => {
assert.isFunction(iterateKeys);
assert.name(iterateKeys, 'iterateKeys');
assert.arity(iterateKeys, 1);
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateKeys(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.object.iterate-values.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
import iterateValues from 'core-js-pure/full/object/iterate-values';
QUnit.test('Object.iterateValues', assert => {
assert.isFunction(iterateValues);
assert.name(iterateValues, 'iterateValues');
assert.arity(iterateValues, 1);
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateValues(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: 3,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.observable.constructor.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/full/symbol';
import Observable from 'core-js-pure/full/observable';
QUnit.test('Observable', assert => {
assert.isFunction(Observable);
assert.arity(Observable, 1);
const observable = new Observable(function (subscriptionObserver) {
assert.same(typeof subscriptionObserver, 'object', 'Subscription observer is object');
assert.same(subscriptionObserver.constructor, Object);
const { next, error, complete } = subscriptionObserver;
assert.isFunction(next);
assert.isFunction(error);
assert.isFunction(complete);
assert.arity(next, 1);
assert.arity(error, 1);
assert.arity(complete, 0);
if (STRICT) {
assert.same(this, undefined, 'correct executor context');
}
});
observable.subscribe({});
assert.true(observable instanceof Observable);
// eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
assert.throws(() => Observable(() => { /* empty */ }), 'throws w/o `new`');
});
QUnit.test('Observable#subscribe', assert => {
assert.isFunction(Observable.prototype.subscribe);
assert.arity(Observable.prototype.subscribe, 1);
const subscription = new Observable(() => { /* empty */ }).subscribe({});
assert.same(typeof subscription, 'object', 'Subscription is object');
assert.same(subscription.constructor, Object);
assert.isFunction(subscription.unsubscribe);
assert.arity(subscription.unsubscribe, 0);
});
QUnit.test('Observable#constructor', assert => {
assert.same(Observable.prototype.constructor, Observable);
});
QUnit.test('Observable#@@observable', assert => {
assert.isFunction(Observable.prototype[Symbol.observable]);
const observable = new Observable(() => { /* empty*/ });
assert.same(observable[Symbol.observable](), observable);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.observable.from.js
|
JavaScript
|
import Observable from 'core-js-pure/full/observable';
QUnit.test('Observable.from', assert => {
assert.isFunction(Observable.from);
assert.arity(Observable.from, 1);
const results1 = [];
Observable.from([1, 2, 3]).subscribe({ next: v => results1.push(v) });
assert.deepEqual(results1, [1, 2, 3], 'first subscription receives all values');
const obs = Observable.from([4, 5, 6]);
const sub1 = [];
const sub2 = [];
obs.subscribe({ next: v => sub1.push(v) });
obs.subscribe({ next: v => sub2.push(v) });
assert.deepEqual(sub1, [4, 5, 6], 'multi-subscribe: first subscription');
assert.deepEqual(sub2, [4, 5, 6], 'multi-subscribe: second subscription gets fresh iterator');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.observable.of.js
|
JavaScript
|
import Observable from 'core-js-pure/full/observable';
QUnit.test('Observable.of', assert => {
assert.isFunction(Observable.of);
assert.arity(Observable.of, 0);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.reflect.define-metadata.js
|
JavaScript
|
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
QUnit.test('Reflect.defineMetadata', assert => {
assert.isFunction(defineMetadata);
assert.arity(defineMetadata, 3);
assert.throws(() => defineMetadata('key', 'value', undefined, undefined), TypeError);
assert.same(defineMetadata('key', 'value', {}, undefined), undefined);
assert.same(defineMetadata('key', 'value', {}, 'name'), undefined);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.reflect.delete-metadata.js
|
JavaScript
|
import create from 'core-js-pure/full/object/create';
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
import hasOwnMetadata from 'core-js-pure/full/reflect/has-own-metadata';
import deleteMetadata from 'core-js-pure/full/reflect/delete-metadata';
QUnit.test('Reflect.deleteMetadata', assert => {
assert.isFunction(deleteMetadata);
assert.arity(deleteMetadata, 2);
assert.throws(() => deleteMetadata('key', undefined, undefined), TypeError);
assert.false(deleteMetadata('key', {}, undefined));
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.true(deleteMetadata('key', object, undefined));
const prototype = {};
defineMetadata('key', 'value', prototype, undefined);
assert.false(deleteMetadata('key', create(prototype), undefined));
object = {};
defineMetadata('key', 'value', object, undefined);
deleteMetadata('key', object, undefined);
assert.false(hasOwnMetadata('key', object, undefined));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.reflect.get-metadata-keys.js
|
JavaScript
|
import create from 'core-js-pure/full/object/create';
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
import getMetadataKeys from 'core-js-pure/full/reflect/get-metadata-keys';
QUnit.test('Reflect.getMetadataKeys', assert => {
assert.isFunction(getMetadataKeys);
assert.arity(getMetadataKeys, 1);
assert.throws(() => getMetadataKeys(undefined, undefined), TypeError);
assert.deepEqual(getMetadataKeys({}, undefined), []);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key']);
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key']);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1']);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
defineMetadata('key0', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, undefined);
object = create(prototype);
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1', 'key2']);
assert.deepEqual(getMetadataKeys({}, 'name'), []);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key']);
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key']);
object = {};
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
defineMetadata('key0', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, 'name');
object = create(prototype);
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key0', 'key1', 'key2']);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/esnext.reflect.get-metadata.js
|
JavaScript
|
import create from 'core-js-pure/full/object/create';
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
import getMetadata from 'core-js-pure/full/reflect/get-metadata';
QUnit.test('Reflect.getMetadata', assert => {
assert.isFunction(getMetadata);
assert.arity(getMetadata, 2);
assert.throws(() => getMetadata('key', undefined, undefined), TypeError);
assert.same(getMetadata('key', {}, undefined), undefined);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(getMetadata('key', object, undefined), 'value');
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.same(getMetadata('key', object, undefined), 'value');
assert.same(getMetadata('key', {}, 'name'), undefined);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.same(getMetadata('key', object, 'name'), 'value');
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.same(getMetadata('key', object, 'name'), 'value');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.