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.aggregate-error.js
|
JavaScript
|
/* eslint-disable unicorn/throw-new-error, sonarjs/inconsistent-function-call -- required for testing */
import AggregateError from 'core-js-pure/es/aggregate-error';
import Symbol from 'core-js-pure/es/symbol';
import toString from 'core-js-pure/es/object/to-string';
import create from 'core-js-pure/es/object/create';
QUnit.test('AggregateError', assert => {
assert.isFunction(AggregateError);
assert.arity(AggregateError, 2);
assert.name(AggregateError, 'AggregateError');
assert.true(new AggregateError([1]) instanceof AggregateError);
assert.true(new AggregateError([1]) instanceof Error);
assert.true(AggregateError([1]) instanceof AggregateError);
assert.true(AggregateError([1]) instanceof Error);
assert.same(AggregateError([1], 'foo').message, 'foo');
assert.same(AggregateError([1], 123).message, '123');
assert.same(AggregateError([1]).message, '');
assert.deepEqual(AggregateError([1, 2, 3]).errors, [1, 2, 3]);
assert.throws(() => AggregateError([1], Symbol()), 'throws on symbol as a message');
assert.same(toString(AggregateError([1])), '[object Error]', 'Object#toString');
assert.true(AggregateError([1], 1) instanceof AggregateError, 'no cause, without new');
assert.true(new AggregateError([1], 1) instanceof AggregateError, 'no cause, with new');
assert.true(AggregateError([1], 1, {}) instanceof AggregateError, 'with options, without new');
assert.true(new AggregateError([1], 1, {}) instanceof AggregateError, 'with options, with new');
assert.true(AggregateError([1], 1, 'foo') instanceof AggregateError, 'non-object options, without new');
assert.true(new AggregateError([1], 1, 'foo') instanceof AggregateError, 'non-object options, with new');
assert.same(AggregateError([1], 1, { cause: 7 }).cause, 7, 'cause, without new');
assert.same(new AggregateError([1], 1, { cause: 7 }).cause, 7, 'cause, with new');
assert.same(AggregateError([1], 1, create({ cause: 7 })).cause, 7, 'prototype cause, without new');
assert.same(new AggregateError([1], 1, create({ cause: 7 })).cause, 7, 'prototype cause, with new');
let error = AggregateError([1], 1, { cause: 7 });
assert.deepEqual(error.errors, [1]);
assert.same(error.name, 'AggregateError', 'instance name');
assert.same(error.message, '1', 'instance message');
assert.same(error.cause, 7, 'instance cause');
// eslint-disable-next-line no-prototype-builtins -- safe
assert.true(error.hasOwnProperty('cause'), 'cause is own');
error = AggregateError([1]);
assert.deepEqual(error.errors, [1]);
assert.same(error.message, '', 'default instance message');
assert.same(error.cause, undefined, 'default instance cause undefined');
// eslint-disable-next-line no-prototype-builtins -- safe
assert.false(error.hasOwnProperty('cause'), 'default instance cause missed');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.at.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import at from 'core-js-pure/es/array/at';
QUnit.test('Array#at', assert => {
assert.isFunction(at);
assert.same(1, at([1, 2, 3], 0));
assert.same(2, at([1, 2, 3], 1));
assert.same(3, at([1, 2, 3], 2));
assert.same(undefined, at([1, 2, 3], 3));
assert.same(3, at([1, 2, 3], -1));
assert.same(2, at([1, 2, 3], -2));
assert.same(1, at([1, 2, 3], -3));
assert.same(undefined, at([1, 2, 3], -4));
assert.same(1, at([1, 2, 3], 0.4));
assert.same(1, at([1, 2, 3], 0.5));
assert.same(1, at([1, 2, 3], 0.6));
assert.same(1, at([1], NaN));
assert.same(1, at([1]));
assert.same(1, at([1, 2, 3], -0));
assert.same(undefined, at(Array(1), 0));
assert.same(1, at({ 0: 1, length: 1 }, 0));
if (STRICT) {
assert.throws(() => at(null, 0), TypeError);
assert.throws(() => at(undefined, 0), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.concat.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
import concat from 'core-js-pure/es/array/concat';
/* eslint-disable no-sparse-arrays -- required for testing */
QUnit.test('Array#concat', assert => {
assert.isFunction(concat);
let array = [1, 2];
const sparseArray = [1, , 2];
const nonSpreadableArray = [1, 2];
nonSpreadableArray[Symbol.isConcatSpreadable] = false;
const arrayLike = { 0: 1, 1: 2, length: 2 };
const spreadableArrayLike = { 0: 1, 1: 2, length: 2, [Symbol.isConcatSpreadable]: true };
assert.deepEqual(concat(array), [1, 2], '#1');
assert.deepEqual(concat(sparseArray), [1, , 2], '#2');
assert.deepEqual(concat(nonSpreadableArray), [[1, 2]], '#3');
assert.deepEqual(concat(arrayLike), [{ 0: 1, 1: 2, length: 2 }], '#4');
assert.deepEqual(concat(spreadableArrayLike), [1, 2], '#5');
assert.deepEqual(concat([], array), [1, 2], '#6');
assert.deepEqual(concat([], sparseArray), [1, , 2], '#7');
assert.deepEqual(concat([], nonSpreadableArray), [[1, 2]], '#8');
assert.deepEqual(concat([], arrayLike), [{ 0: 1, 1: 2, length: 2 }], '#9');
assert.deepEqual(concat([], spreadableArrayLike), [1, 2], '#10');
assert.deepEqual(concat(array, sparseArray, nonSpreadableArray, arrayLike, spreadableArrayLike), [
1, 2, 1, , 2, [1, 2], { 0: 1, 1: 2, length: 2 }, 1, 2,
], '#11');
array = [];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
// https://bugs.webkit.org/show_bug.cgi?id=281061
assert.same(concat(array).foo, 1, '@@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.copy-within.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import copyWithin from 'core-js-pure/es/array/copy-within';
QUnit.test('Array#copyWithin', assert => {
assert.isFunction(copyWithin);
const array = [1];
assert.same(copyWithin(array, 0), array);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 0, 3), [4, 5, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 1, 3), [1, 4, 5, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 1, 2), [1, 3, 4, 5, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 2, 2), [1, 2, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 0, 3, 4), [4, 2, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 1, 3, 4), [1, 4, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 1, 2, 4), [1, 3, 4, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 0, -2), [4, 5, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 0, -2, -1), [4, 2, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], -4, -3, -2), [1, 3, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], -4, -3, -1), [1, 3, 4, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], -4, -3), [1, 3, 4, 5, 5]);
if (STRICT) {
assert.throws(() => copyWithin(null, 0), TypeError);
assert.throws(() => copyWithin(undefined, 0), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.every.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import every from 'core-js-pure/es/array/every';
QUnit.test('Array#every', assert => {
assert.isFunction(every);
const array = [1];
const context = {};
every(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(every([1, 2, 3], it => typeof it == 'number'));
assert.true(every([1, 2, 3], it => it < 4));
assert.false(every([1, 2, 3], it => it < 3));
assert.false(every([1, 2, 3], it => typeof it == 'string'));
assert.true(every([1, 2, 3], function () {
return +this === 1;
}, 1));
let rez = '';
every([1, 2, 3], (value, key) => rez += key);
assert.same(rez, '012');
const arr = [1, 2, 3];
assert.true(every(arr, (value, key, that) => that === arr));
if (STRICT) {
assert.throws(() => every(null, () => { /* empty */ }), TypeError);
assert.throws(() => every(undefined, () => { /* empty */ }), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.fill.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import fill from 'core-js-pure/es/array/fill';
QUnit.test('Array#fill', assert => {
assert.isFunction(fill);
const array = fill(Array(5), 5);
assert.same(array, array);
assert.deepEqual(fill(Array(5), 5), [5, 5, 5, 5, 5]);
assert.deepEqual(fill(Array(5), 5, 1), [undefined, 5, 5, 5, 5]);
assert.deepEqual(fill(Array(5), 5, 1, 4), [undefined, 5, 5, 5, undefined]);
assert.deepEqual(fill(Array(5), 5, 6, 1), [undefined, undefined, undefined, undefined, undefined]);
assert.deepEqual(fill(Array(5), 5, -3, 4), [undefined, undefined, 5, 5, undefined]);
assert.arrayEqual(fill({ length: 5 }, 5), [5, 5, 5, 5, 5]);
if (STRICT) {
assert.throws(() => fill(null, 0), TypeError);
assert.throws(() => fill(undefined, 0), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.filter.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import filter from 'core-js-pure/es/array/filter';
QUnit.test('Array#filter', assert => {
assert.isFunction(filter);
let array = [1];
const context = {};
filter(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], filter([1, 2, 3, 'q', {}, 4, true, 5], it => typeof it == 'number'));
if (STRICT) {
assert.throws(() => filter(null, () => { /* empty */ }), TypeError);
assert.throws(() => filter(undefined, () => { /* empty */ }), TypeError);
}
array = [];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(filter(array, Boolean).foo, 1, '@@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.find-index.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import findIndex from 'core-js-pure/es/array/find-index';
QUnit.test('Array#findIndex', assert => {
assert.isFunction(findIndex);
const array = [1];
const context = {};
findIndex(array, function (value, key, that) {
assert.same(this, context);
assert.same(value, 1);
assert.same(key, 0);
assert.same(that, array);
}, context);
assert.same(findIndex([1, 3, NaN, 42, {}], it => it === 42), 3);
if (STRICT) {
assert.throws(() => findIndex(null, 0), TypeError);
assert.throws(() => findIndex(undefined, 0), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.find-last-index.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import findLastIndex from 'core-js-pure/es/array/find-last-index';
QUnit.test('Array#findLastIndex', assert => {
assert.isFunction(findLastIndex);
const array = [1];
const context = {};
findLastIndex(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(findLastIndex([{}, 2, NaN, 42, 1], it => !(it % 2)), 3);
assert.same(findLastIndex([{}, 2, NaN, 42, 1], it => it === 43), -1);
let values = '';
let keys = '';
findLastIndex([1, 2, 3], (value, key) => {
values += value;
keys += key;
});
assert.same(values, '321');
assert.same(keys, '210');
if (STRICT) {
assert.throws(() => findLastIndex(null, 0), TypeError);
assert.throws(() => findLastIndex(undefined, 0), TypeError);
}
assert.notThrows(() => findLastIndex({
length: -1,
0: 1,
}, () => {
throw new Error();
}) === -1, 'uses ToLength');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.find-last.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import findLast from 'core-js-pure/es/array/find-last';
QUnit.test('Array#findLast', assert => {
assert.isFunction(findLast);
const array = [1];
const context = {};
findLast(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(findLast([{}, 2, NaN, 42, 1], it => !(it % 2)), 42);
assert.same(findLast([{}, 2, NaN, 42, 1], it => it === 43), undefined);
let values = '';
let keys = '';
findLast([1, 2, 3], (value, key) => {
values += value;
keys += key;
});
assert.same(values, '321');
assert.same(keys, '210');
if (STRICT) {
assert.throws(() => findLast(null, 0), TypeError);
assert.throws(() => findLast(undefined, 0), TypeError);
}
assert.notThrows(() => findLast({
length: -1,
0: 1,
}, () => {
throw new Error();
}) === undefined, 'uses ToLength');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.find.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import find from 'core-js-pure/es/array/find';
QUnit.test('Array#find', assert => {
assert.isFunction(find);
const array = [1];
const context = {};
find(array, function (value, key, that) {
assert.same(this, context);
assert.same(value, 1);
assert.same(key, 0);
assert.same(that, array);
}, context);
assert.same(find([1, 3, NaN, 42, {}], it => it === 42), 42);
assert.same(find([1, 3, NaN, 42, {}], it => it === 43), undefined);
if (STRICT) {
assert.throws(() => find(null, 0), TypeError);
assert.throws(() => find(undefined, 0), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.flat-map.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import flatMap from 'core-js-pure/es/array/flat-map';
QUnit.test('Array#flatMap', assert => {
assert.isFunction(flatMap);
assert.deepEqual(flatMap([], it => it), []);
assert.deepEqual(flatMap([1, 2, 3], it => it), [1, 2, 3]);
assert.deepEqual(flatMap([1, 2, 3], it => [it, it]), [1, 1, 2, 2, 3, 3]);
assert.deepEqual(flatMap([1, 2, 3], it => [[it], [it]]), [[1], [1], [2], [2], [3], [3]]);
assert.deepEqual(flatMap([1, [2, 3]], () => 1), [1, 1]);
const array = [1];
const context = {};
flatMap(array, function (value, index, that) {
assert.same(value, 1);
assert.same(index, 0);
assert.same(that, array);
assert.same(this, context);
}, context);
if (STRICT) {
assert.throws(() => flatMap(null, it => it), TypeError);
assert.throws(() => flatMap(undefined, it => it), TypeError);
}
assert.notThrows(() => flatMap({ length: -1 }, () => {
throw new Error();
}).length === 0, 'uses ToLength');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.flat.js
|
JavaScript
|
import { DESCRIPTORS, STRICT } from '../helpers/constants.js';
import flat from 'core-js-pure/es/array/flat';
import defineProperty from 'core-js-pure/es/object/define-property';
QUnit.test('Array#flat', assert => {
assert.isFunction(flat);
assert.deepEqual(flat([]), []);
const array = [1, [2, 3], [4, [5, 6]]];
assert.deepEqual(flat(array, 0), array);
assert.deepEqual(flat(array, 1), [1, 2, 3, 4, [5, 6]]);
assert.deepEqual(flat(array), [1, 2, 3, 4, [5, 6]]);
assert.deepEqual(flat(array, 2), [1, 2, 3, 4, 5, 6]);
assert.deepEqual(flat(array, 3), [1, 2, 3, 4, 5, 6]);
assert.deepEqual(flat(array, -1), array);
assert.deepEqual(flat(array, Infinity), [1, 2, 3, 4, 5, 6]);
if (STRICT) {
assert.throws(() => flat(null), TypeError);
assert.throws(() => flat(undefined), TypeError);
}
if (DESCRIPTORS) {
assert.notThrows(() => flat(defineProperty({ length: -1 }, 0, {
get() {
throw new Error();
},
})).length === 0, 'uses ToLength');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.for-each.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import forEach from 'core-js-pure/es/array/for-each';
QUnit.test('Array#forEach', assert => {
assert.isFunction(forEach);
let array = [1];
const context = {};
forEach(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);
let result = '';
forEach([1, 2, 3], it => {
result += it;
});
assert.same(result, '123');
result = '';
forEach([1, 2, 3], (value, key) => {
result += key;
});
assert.same(result, '012');
result = '';
forEach([1, 2, 3], (value, key, that) => {
result += that;
});
assert.same(result, '1,2,31,2,31,2,3');
result = '';
forEach([1, 2, 3], function () {
result += this;
}, 1);
assert.same(result, '111');
result = '';
array = [];
array[5] = '';
forEach(array, (value, key) => {
result += key;
});
assert.same(result, '5');
if (STRICT) {
assert.throws(() => forEach(null, () => { /* empty */ }), TypeError);
assert.throws(() => forEach(undefined, () => { /* empty */ }), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.from-async.js
|
JavaScript
|
import { createAsyncIterable, createIterable/* , createIterator */ } from '../helpers/helpers.js';
import { STRICT_THIS } from '../helpers/constants.js';
import Promise from 'core-js-pure/es/promise';
import fromAsync from 'core-js-pure/es/array/from-async';
// import Iterator from 'core-js-pure/actual/iterator';
QUnit.test('Array.fromAsync', assert => {
assert.isFunction(fromAsync);
assert.arity(fromAsync, 1);
assert.name(fromAsync, 'fromAsync');
let counter = 0;
// eslint-disable-next-line prefer-arrow-callback -- constructor
fromAsync.call(function () {
counter++;
return [];
}, { length: 0 });
assert.same(counter, 1, 'proper number of constructor calling');
function C() { /* empty */ }
// const closableIterator = createIterator([1], {
// return() { this.closed = true; return { value: undefined, done: true }; },
// });
return fromAsync(createAsyncIterable([1, 2, 3]), it => it ** 2).then(it => {
assert.arrayEqual(it, [1, 4, 9], 'async iterable and mapfn');
return fromAsync(createAsyncIterable([1]), function (arg, index) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(index, 0, 'index');
});
}).then(() => {
return fromAsync(createAsyncIterable([1, 2, 3]));
}).then(it => {
assert.arrayEqual(it, [1, 2, 3], 'async iterable without mapfn');
return fromAsync(createIterable([1, 2, 3]), arg => arg ** 2);
}).then(it => {
assert.arrayEqual(it, [1, 4, 9], 'iterable and mapfn');
return fromAsync(createIterable([1, 2, 3]), arg => Promise.resolve(arg ** 2));
}).then(it => {
assert.arrayEqual(it, [1, 4, 9], 'iterable and async mapfn');
return fromAsync(createIterable([1]), function (arg, index) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(index, 0, 'index');
});
}).then(() => {
return fromAsync(createIterable([1, 2, 3]));
}).then(it => {
assert.arrayEqual(it, [1, 2, 3], 'iterable and without mapfn');
return fromAsync([1, Promise.resolve(2), 3]);
}).then(it => {
assert.arrayEqual(it, [1, 2, 3], 'array');
return fromAsync('123');
}).then(it => {
assert.arrayEqual(it, ['1', '2', '3'], 'string');
return fromAsync.call(C, [1]);
}).then(it => {
assert.true(it instanceof C, 'subclassable');
return fromAsync({ length: 1, 0: 1 });
}).then(it => {
assert.arrayEqual(it, [1], 'non-iterable');
return fromAsync(createIterable([1]), () => { throw 42; });
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
return fromAsync(undefined, () => { /* empty */ });
}).then(() => {
assert.avoid();
}, error => {
assert.true(error instanceof TypeError);
return fromAsync(null, () => { /* empty */ });
}).then(() => {
assert.avoid();
}, error => {
assert.true(error instanceof TypeError);
return fromAsync([1], null);
}).then(() => {
assert.avoid();
}, error => {
assert.true(error instanceof TypeError);
return fromAsync([1], {});
}).then(() => {
assert.avoid();
}, error => {
assert.true(error instanceof TypeError);
// sync iterable: return() should be called through AsyncFromSyncIterator on early termination
const closable = createIterable([1, 2, 3], {
return() {
closable.closed = true;
return { value: undefined, done: true };
},
});
return fromAsync(closable, item => {
if (item === 2) throw 42;
return item;
}).then(() => {
assert.avoid();
}, err => {
assert.same(err, 42, 'sync iterable: rejection on callback error');
assert.true(closable.closed, 'sync iterable: return() called on early termination');
});
});
/* Tests are temporarily disabled due to the lack of proper async feature detection in native implementations.
.then(() => {
return fromAsync(Iterator.from(closableIterator), () => { throw 42; });
}).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/es.array.from.js
|
JavaScript
|
/* eslint-disable prefer-rest-params -- required for testing */
import { DESCRIPTORS } from '../helpers/constants.js';
import { createIterable } from '../helpers/helpers.js';
import Symbol from 'core-js-pure/es/symbol';
import defineProperty from 'core-js-pure/es/object/define-property';
import freeze from 'core-js-pure/es/object/freeze';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import from from 'core-js-pure/es/array/from';
QUnit.test('Array.from', assert => {
assert.isFunction(from);
assert.arity(from, 1);
let types = {
'array-like': {
length: '3',
0: '1',
1: '2',
2: '3',
},
arguments: function () {
return arguments;
}('1', '2', '3'),
array: ['1', '2', '3'],
iterable: createIterable(['1', '2', '3']),
string: '123',
};
for (const type in types) {
const data = types[type];
assert.arrayEqual(from(data), ['1', '2', '3'], `Works with ${ type }`);
assert.arrayEqual(from(data, it => it ** 2), [1, 4, 9], `Works with ${ type } + mapFn`);
}
types = {
'array-like': {
length: 1,
0: 1,
},
arguments: function () {
return arguments;
}(1),
array: [1],
iterable: createIterable([1]),
string: '1',
};
for (const type in types) {
const data = types[type];
const context = {};
assert.arrayEqual(from(data, function (value, key) {
assert.same(this, context, `Works with ${ type }, correct callback context`);
assert.same(value, type === 'string' ? '1' : 1, `Works with ${ type }, correct callback value`);
assert.same(key, 0, `Works with ${ type }, correct callback key`);
assert.same(arguments.length, 2, `Works with ${ type }, correct callback arguments number`);
return 42;
}, context), [42], `Works with ${ type }, correct result`);
}
const primitives = [false, true, 0];
for (const primitive of primitives) {
assert.arrayEqual(from(primitive), [], `Works with ${ primitive }`);
}
assert.throws(() => from(null), TypeError, 'Throws on null');
assert.throws(() => from(undefined), TypeError, 'Throws on undefined');
assert.arrayEqual(from('𠮷𠮷𠮷'), ['𠮷', '𠮷', '𠮷'], 'Uses correct string iterator');
let done = true;
from(createIterable([1, 2, 3], {
return() {
return done = false;
},
}), () => false);
assert.true(done, '.return #default');
done = false;
try {
from(createIterable([1, 2, 3], {
return() {
return done = true;
},
}), () => {
throw new Error();
});
} catch { /* empty */ }
assert.true(done, '.return #throw');
class C { /* empty */ }
let instance = from.call(C, createIterable([1, 2]));
assert.true(instance instanceof C, 'generic, iterable case, instanceof');
assert.arrayEqual(instance, [1, 2], 'generic, iterable case, elements');
instance = from.call(C, {
0: 1,
1: 2,
length: 2,
});
assert.true(instance instanceof C, 'generic, array-like case, instanceof');
assert.arrayEqual(instance, [1, 2], 'generic, array-like case, elements');
let array = [1, 2, 3];
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);
};
assert.arrayEqual(from(array), [1, 2, 3], 'Array with custom iterator, elements');
assert.true(done, 'call @@iterator in Array with custom iterator');
array = [1, 2, 3];
delete array[1];
assert.arrayEqual(from(array, String), ['1', 'undefined', '3'], 'Ignores holes');
assert.notThrows(() => from({
length: -1,
0: 1,
}, () => {
throw new Error();
}), 'Uses ToLength');
assert.arrayEqual(from([], undefined), [], 'Works with undefined as second argument');
assert.throws(() => from([], null), TypeError, 'Throws with null as second argument');
assert.throws(() => from([], 0), TypeError, 'Throws with 0 as second argument');
assert.throws(() => from([], ''), TypeError, 'Throws with "" as second argument');
assert.throws(() => from([], false), TypeError, 'Throws with false as second argument');
assert.throws(() => from([], {}), TypeError, 'Throws with {} as second argument');
if (DESCRIPTORS) {
let called = false;
defineProperty(C.prototype, 0, {
set() {
called = true;
},
});
from.call(C, [1, 2, 3]);
assert.false(called, 'Should not call prototype accessors');
}
// iterator should be closed when createProperty fails
if (DESCRIPTORS) {
let returnCalled = false;
const iterable = {
[Symbol.iterator]() {
return {
next() { return { value: 1, done: false }; },
return() { returnCalled = true; return { done: true }; },
};
},
};
const Frozen = function () { return freeze([]); };
assert.throws(() => from.call(Frozen, iterable), TypeError, 'throws when createProperty fails');
assert.true(returnCalled, 'iterator is closed when createProperty throws');
}
// mapfn callable check should happen before ToObject(items)
assert.throws(() => from(null, 42), TypeError, 'non-callable mapfn with null items throws for mapfn');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.includes.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import includes from 'core-js-pure/es/array/includes';
QUnit.test('Array#includes', assert => {
assert.isFunction(includes);
const object = {};
const array = [1, 2, 3, -0, object];
assert.true(includes(array, 1));
assert.true(includes(array, -0));
assert.true(includes(array, 0));
assert.true(includes(array, object));
assert.false(includes(array, 4));
assert.false(includes(array, -0.5));
assert.false(includes(array, {}));
assert.true(includes(Array(1), undefined));
assert.true(includes([NaN], NaN));
if (STRICT) {
assert.throws(() => includes(null, 0), TypeError);
assert.throws(() => includes(undefined, 0), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.index-of.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import indexOf from 'core-js-pure/es/array/index-of';
QUnit.test('Array#indexOf', assert => {
assert.isFunction(indexOf);
assert.same(0, indexOf([1, 1, 1], 1));
assert.same(-1, indexOf([1, 2, 3], 1, 1));
assert.same(1, indexOf([1, 2, 3], 2, 1));
assert.same(-1, indexOf([1, 2, 3], 2, -1));
assert.same(1, indexOf([1, 2, 3], 2, -2));
assert.same(-1, indexOf([NaN], NaN));
assert.same(3, indexOf(Array(2).concat([1, 2, 3]), 2));
assert.same(-1, indexOf(Array(1), undefined));
assert.same(0, indexOf([1], 1, -0), "shouldn't return negative zero");
if (STRICT) {
assert.throws(() => indexOf(null, 0), TypeError);
assert.throws(() => indexOf(undefined, 0), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.is-array.js
|
JavaScript
|
import isArray from 'core-js-pure/es/array/is-array';
QUnit.test('Array.isArray', assert => {
assert.isFunction(isArray);
assert.false(isArray({}));
assert.false(isArray(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()));
assert.true(isArray([]));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.iterator.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
import getIterator from 'core-js-pure/es/get-iterator';
import { keys, values, entries } from 'core-js-pure/es/array';
QUnit.test('Array#@@iterator', assert => {
assert.isFunction(values);
const iterator = getIterator(['q', 'w', 'e']);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Array Iterator');
assert.same(String(iterator), '[object Array Iterator]');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Array#keys', assert => {
assert.isFunction(keys);
const iterator = keys(['q', 'w', 'e']);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 0,
done: false,
});
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
assert.deepEqual(iterator.next(), {
value: 2,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Array#values', assert => {
assert.isFunction(values);
const iterator = values(['q', 'w', 'e']);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Array#entries', assert => {
assert.isFunction(entries);
const iterator = entries(['q', 'w', 'e']);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: [0, 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: [1, 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: [2, '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/es.array.join.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import join from 'core-js-pure/es/array/join';
QUnit.test('Array#join', assert => {
assert.isFunction(join);
assert.same(join([1, 2, 3], undefined), '1,2,3');
assert.same(join('123'), '1,2,3');
assert.same(join('123', '|'), '1|2|3');
if (STRICT) {
assert.throws(() => join(null), TypeError);
assert.throws(() => join(undefined), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.last-index-of.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import lastIndexOf from 'core-js-pure/es/array/last-index-of';
QUnit.test('Array#lastIndexOf', assert => {
assert.isFunction(lastIndexOf);
assert.same(2, lastIndexOf([1, 1, 1], 1));
assert.same(-1, lastIndexOf([1, 2, 3], 3, 1));
assert.same(1, lastIndexOf([1, 2, 3], 2, 1));
assert.same(-1, lastIndexOf([1, 2, 3], 2, -3));
assert.same(-1, lastIndexOf([1, 2, 3], 1, -4));
assert.same(1, lastIndexOf([1, 2, 3], 2, -2));
assert.same(-1, lastIndexOf([NaN], NaN));
assert.same(1, lastIndexOf([1, 2, 3].concat(Array(2)), 2));
assert.same(0, lastIndexOf([1], 1, -0), "shouldn't return negative zero");
if (STRICT) {
assert.throws(() => lastIndexOf(null, 0), TypeError);
assert.throws(() => lastIndexOf(undefined, 0), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.map.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import map from 'core-js-pure/es/array/map';
QUnit.test('Array#map', assert => {
assert.isFunction(map);
let array = [1];
const context = {};
map(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([2, 3, 4], map([1, 2, 3], it => it + 1));
assert.deepEqual([1, 3, 5], map([1, 2, 3], (value, key) => value + key));
assert.deepEqual([2, 2, 2], map([1, 2, 3], function () {
return +this;
}, 2));
if (STRICT) {
assert.throws(() => map(null, () => { /* empty */ }), TypeError);
assert.throws(() => map(undefined, () => { /* empty */ }), TypeError);
}
array = [];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(map(array, Boolean).foo, 1, '@@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.of.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
import defineProperty from 'core-js-pure/es/object/define-property';
import of from 'core-js-pure/es/array/of';
QUnit.test('Array.of', assert => {
assert.isFunction(of);
assert.arity(of, 0);
assert.deepEqual(of(1), [1]);
assert.deepEqual(of(1, 2, 3), [1, 2, 3]);
class C { /* empty */ }
const instance = of.call(C, 1, 2);
assert.true(instance instanceof C);
assert.same(instance[0], 1);
assert.same(instance[1], 2);
assert.same(instance.length, 2);
if (DESCRIPTORS) {
let called = false;
defineProperty(C.prototype, 0, {
set() {
called = true;
},
});
of.call(C, 1, 2, 3);
assert.false(called, 'Should not call prototype accessors');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.push.js
|
JavaScript
|
import { REDEFINABLE_ARRAY_LENGTH_DESCRIPTOR, STRICT } from '../helpers/constants.js';
import push from 'core-js-pure/es/array/virtual/push';
import defineProperty from 'core-js-pure/es/object/define-property';
QUnit.test('Array#push', assert => {
assert.isFunction(push);
const object = { length: 0x100000000 };
assert.same(push.call(object, 1), 0x100000001, 'proper ToLength #1');
assert.same(object[0x100000000], 1, 'proper ToLength #2');
if (STRICT) {
if (REDEFINABLE_ARRAY_LENGTH_DESCRIPTOR) {
assert.throws(() => push.call(defineProperty([], 'length', { writable: false }), 1), TypeError, 'non-writable length, with arg');
assert.throws(() => push.call(defineProperty([], 'length', { writable: false })), TypeError, 'non-writable length, without arg');
}
assert.throws(() => push.call(null), TypeError);
assert.throws(() => push.call(undefined), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.reduce-right.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import reduceRight from 'core-js-pure/es/array/reduce-right';
QUnit.test('Array#reduceRight', assert => {
assert.isFunction(reduceRight);
const array = [1];
const accumulator = {};
reduceRight(array, 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, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
}, accumulator);
assert.same(reduceRight([1, 2, 3], (a, b) => a + b, 1), 7, 'works with initial accumulator');
reduceRight([1, 2], (memo, value, key) => {
assert.same(memo, 2, 'correct default accumulator');
assert.same(value, 1, 'correct start value without initial accumulator');
assert.same(key, 0, 'correct start index without initial accumulator');
});
assert.same(reduceRight([1, 2, 3], (a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
reduceRight([1, 2, 3], (memo, value, key) => {
values += value;
keys += key;
}, 0);
assert.same(values, '321', 'correct order #1');
assert.same(keys, '210', 'correct order #2');
assert.same(reduceRight({
0: 1,
1: 2,
length: 2,
}, (a, b) => a + b), 3, 'generic');
assert.throws(() => reduceRight([], () => { /* empty */ }), TypeError);
assert.throws(() => reduceRight(Array(5), () => { /* empty */ }), TypeError);
if (STRICT) {
assert.throws(() => reduceRight(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduceRight(undefined, () => { /* empty */ }, 1), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.reduce.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import reduce from 'core-js-pure/es/array/reduce';
QUnit.test('Array#reduce', assert => {
assert.isFunction(reduce);
const array = [1];
const accumulator = {};
reduce(array, 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, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
}, accumulator);
assert.same(reduce([1, 2, 3], (a, b) => a + b, 1), 7, 'works with initial accumulator');
reduce([1, 2], (memo, value, key) => {
assert.same(memo, 1, 'correct default accumulator');
assert.same(value, 2, 'correct start value without initial accumulator');
assert.same(key, 1, 'correct start index without initial accumulator');
});
assert.same(reduce([1, 2, 3], (a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
reduce([1, 2, 3], (memo, value, key) => {
values += value;
keys += key;
}, 0);
assert.same(values, '123', 'correct order #1');
assert.same(keys, '012', 'correct order #2');
assert.same(reduce({
0: 1,
1: 2,
length: 2,
}, (a, b) => a + b), 3, 'generic');
assert.throws(() => reduce([], () => { /* empty */ }), TypeError);
assert.throws(() => reduce(Array(5), () => { /* empty */ }), TypeError);
if (STRICT) {
assert.throws(() => reduce(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce(undefined, () => { /* empty */ }, 1), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.reverse.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import reverse from 'core-js-pure/es/array/reverse';
QUnit.test('Array#reverse', assert => {
assert.isFunction(reverse);
const a = [1, 2.2, 3.3];
function fn() {
+a;
reverse(a);
}
fn();
assert.arrayEqual(a, [3.3, 2.2, 1]);
if (STRICT) {
assert.throws(() => reverse(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reverse(undefined, () => { /* empty */ }, 1), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.slice.js
|
JavaScript
|
import { GLOBAL } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import isArray from 'core-js-pure/es/array/is-array';
import slice from 'core-js-pure/es/array/slice';
QUnit.test('Array#slice', assert => {
assert.isFunction(slice);
let array = ['1', '2', '3', '4', '5'];
assert.deepEqual(slice(array), array);
assert.deepEqual(slice(array, 1, 3), ['2', '3']);
assert.deepEqual(slice(array, 1, undefined), ['2', '3', '4', '5']);
assert.deepEqual(slice(array, 1, -1), ['2', '3', '4']);
assert.deepEqual(slice(array, -2, -1), ['4']);
assert.deepEqual(slice(array, -2, -3), []);
const string = '12345';
assert.deepEqual(slice(string), array);
assert.deepEqual(slice(string, 1, 3), ['2', '3']);
assert.deepEqual(slice(string, 1, undefined), ['2', '3', '4', '5']);
assert.deepEqual(slice(string, 1, -1), ['2', '3', '4']);
assert.deepEqual(slice(string, -2, -1), ['4']);
assert.deepEqual(slice(string, -2, -3), []);
const list = GLOBAL.document && document.body && document.body.childNodes;
if (list) {
assert.notThrows(() => isArray(slice(list)), 'works with NodeList');
}
array = [];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(slice(array).foo, 1, '@@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.some.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import some from 'core-js-pure/es/array/some';
QUnit.test('Array#some', assert => {
assert.isFunction(some);
let array = [1];
const context = {};
some(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(some([1, '2', 3], it => typeof it == 'number'));
assert.true(some([1, 2, 3], it => it < 3));
assert.false(some([1, 2, 3], it => it < 0));
assert.false(some([1, 2, 3], it => typeof it == 'string'));
assert.false(some([1, 2, 3], function () {
return +this !== 1;
}, 1));
let result = '';
some([1, 2, 3], (value, key) => {
result += key;
return false;
});
assert.same(result, '012');
array = [1, 2, 3];
assert.false(some(array, (value, key, that) => that !== array));
if (STRICT) {
assert.throws(() => some(null, () => { /* empty */ }), TypeError);
assert.throws(() => some(undefined, () => { /* empty */ }), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.sort.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import sort from 'core-js-pure/es/array/sort';
QUnit.test('Array#sort', assert => {
assert.isFunction(sort);
assert.notThrows(() => sort([1, 2, 3], undefined), 'works with undefined');
assert.throws(() => sort([1, 2, 3], null), 'throws on null');
assert.throws(() => sort([1, 2, 3], {}), 'throws on {}');
assert.deepEqual(sort([1, 3, 2]), [1, 2, 3], '#1');
assert.deepEqual(sort([1, 3, 2, 11]), [1, 11, 2, 3], '#2');
assert.deepEqual(sort([1, -1, 3, NaN, 2, 0, 11, -0]), [-1, 0, -0, 1, 11, 2, 3, NaN], '#3');
let array = Array(5);
array[0] = 1;
array[2] = 3;
array[4] = 2;
let expected = Array(5);
expected[0] = 1;
expected[1] = 2;
expected[2] = 3;
assert.deepEqual(sort(array), expected, 'holes');
array = 'zyxwvutsrqponMLKJIHGFEDCBA'.split('');
expected = 'ABCDEFGHIJKLMnopqrstuvwxyz'.split('');
assert.deepEqual(sort(array), expected, 'alpha #1');
array = 'ёяюэьыъщшчцхфутсрПОНМЛКЙИЗЖЕДГВБА'.split('');
expected = 'АБВГДЕЖЗИЙКЛМНОПрстуфхцчшщъыьэюяё'.split('');
assert.deepEqual(sort(array), expected, 'alpha #2');
array = [undefined, 1];
assert.notThrows(() => sort(array, () => { throw 1; }), 'undefined #1');
assert.deepEqual(array, [1, undefined], 'undefined #2');
/* Safari TP ~ 17.6 issue
const object = {
valueOf: () => 1,
toString: () => -1,
};
array = {
0: undefined,
1: 2,
2: 1,
3: 'X',
4: -1,
5: 'a',
6: true,
7: object,
8: NaN,
10: Infinity,
length: 11,
};
expected = {
0: -1,
1: object,
2: 1,
3: 2,
4: Infinity,
5: NaN,
6: 'X',
7: 'a',
8: true,
9: undefined,
length: 11,
};
assert.deepEqual(sort(array), expected, 'custom generic');
*/
let index, mod, code, chr, value;
expected = Array(516);
array = Array(516);
for (index = 0; index < 516; index++) {
mod = index % 4;
array[index] = 515 - index;
expected[index] = index - 2 * mod + 3;
}
sort(array, (a, b) => (a / 4 | 0) - (b / 4 | 0));
assert.true(1 / sort([0, -0])[0] > 0, '-0');
assert.arrayEqual(array, expected, 'stable #1');
let result = '';
array = [];
// generate an array with more 512 elements (Chakra and old V8 fails only in this case)
for (code = 65; code < 76; code++) {
chr = String.fromCharCode(code);
switch (code) {
case 66: case 69: case 70: case 72: value = 3; break;
case 68: case 71: value = 4; break;
default: value = 2;
}
for (index = 0; index < 47; index++) {
array.push({ k: chr + index, v: value });
}
}
sort(array, (a, b) => b.v - a.v);
for (index = 0; index < array.length; index++) {
chr = array[index].k.charAt(0);
if (result.charAt(result.length - 1) !== chr) result += chr;
}
assert.same(result, 'DGBEFHACIJK', 'stable #2');
// default comparator returns 0 for equal string representations
const obj1 = { toString() { return 'a'; } };
const obj2 = { toString() { return 'a'; } };
assert.same(sort([obj1, obj2])[0], obj1, 'stable sort for equal string representations');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => sort([Symbol(1), Symbol(2)]), 'w/o cmp throws on symbols');
}
if (STRICT) {
assert.throws(() => sort(null), TypeError, 'ToObject(this)');
assert.throws(() => sort(undefined), TypeError, 'ToObject(this)');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.splice.js
|
JavaScript
|
import { REDEFINABLE_ARRAY_LENGTH_DESCRIPTOR, STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import splice from 'core-js-pure/es/array/splice';
import defineProperty from 'core-js-pure/es/object/define-property';
QUnit.test('Array#splice', assert => {
assert.isFunction(splice);
let array = [1, 2, 3, 4, 5];
assert.deepEqual(splice(array, 2), [3, 4, 5]);
assert.deepEqual(array, [1, 2]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(splice(array, -2), [4, 5]);
assert.deepEqual(array, [1, 2, 3]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(splice(array, 2, 2), [3, 4]);
assert.deepEqual(array, [1, 2, 5]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(splice(array, 2, -2), []);
assert.deepEqual(array, [1, 2, 3, 4, 5]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(splice(array, 2, 2, 6, 7), [3, 4]);
assert.deepEqual(array, [1, 2, 6, 7, 5]);
// ES6 semantics
array = [0, 1, 2];
assert.deepEqual(splice(array, 0), [0, 1, 2]);
array = [0, 1, 2];
assert.deepEqual(splice(array, 1), [1, 2]);
array = [0, 1, 2];
assert.deepEqual(splice(array, 2), [2]);
if (STRICT) {
if (REDEFINABLE_ARRAY_LENGTH_DESCRIPTOR) {
assert.throws(() => splice(defineProperty([1, 2, 3], 'length', { writable: false }), 1, 1), TypeError, 'non-writable length');
}
assert.throws(() => splice(null), TypeError);
assert.throws(() => splice(undefined), TypeError);
}
array = [];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(splice(array).foo, 1, '@@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.to-reversed.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import toReversed from 'core-js-pure/es/array/to-reversed';
QUnit.test('Array#toReversed', assert => {
assert.isFunction(toReversed);
let array = [1, 2];
assert.notSame(toReversed(array), array, 'immutable');
assert.deepEqual(toReversed([1, 2.2, 3.3]), [3.3, 2.2, 1], 'basic');
const object = {};
array = {
0: undefined,
1: 2,
2: 1,
3: 'X',
4: -1,
5: 'a',
6: true,
7: object,
8: NaN,
10: Infinity,
length: 11,
};
const expected = [
Infinity,
undefined,
NaN,
object,
true,
'a',
-1,
'X',
1,
2,
undefined,
];
assert.deepEqual(toReversed(array), expected, 'non-array target');
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.true(toReversed(array) instanceof Array, 'non-generic');
if (STRICT) {
assert.throws(() => toReversed(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => toReversed(undefined, () => { /* empty */ }, 1), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.to-sorted.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import toSorted from 'core-js-pure/es/array/to-sorted';
QUnit.test('Array#toSorted', assert => {
assert.isFunction(toSorted);
let array = [1];
assert.notSame(toSorted(array), array, 'immutable');
assert.deepEqual(toSorted([1, 3, 2]), [1, 2, 3], '#1');
assert.deepEqual(toSorted([1, 3, 2, 11]), [1, 11, 2, 3], '#2');
assert.deepEqual(toSorted([1, -1, 3, NaN, 2, 0, 11, -0]), [-1, 0, -0, 1, 11, 2, 3, NaN], '#1');
array = Array(5);
array[0] = 1;
array[2] = 3;
array[4] = 2;
let expected = Array(5);
expected[0] = 1;
expected[1] = 2;
expected[2] = 3;
assert.deepEqual(toSorted(array), expected, 'holes');
array = 'zyxwvutsrqponMLKJIHGFEDCBA'.split('');
expected = 'ABCDEFGHIJKLMnopqrstuvwxyz'.split('');
assert.deepEqual(toSorted(array), expected, 'alpha #1');
array = 'ёяюэьыъщшчцхфутсрПОНМЛКЙИЗЖЕДГВБА'.split('');
expected = 'АБВГДЕЖЗИЙКЛМНОПрстуфхцчшщъыьэюяё'.split('');
assert.deepEqual(toSorted(array), expected, 'alpha #2');
array = [undefined, 1];
assert.notThrows(() => array = toSorted(array, () => { throw 1; }), 'undefined #1');
assert.deepEqual(array, [1, undefined], 'undefined #2');
/* Safari TP ~ 17.6 issue
const object = {
valueOf: () => 1,
toString: () => -1,
};
array = {
0: undefined,
1: 2,
2: 1,
3: 'X',
4: -1,
5: 'a',
6: true,
7: object,
8: NaN,
10: Infinity,
length: 11,
};
expected = [
-1,
object,
1,
2,
Infinity,
NaN,
'X',
'a',
true,
undefined,
undefined,
];
assert.deepEqual(toSorted(array), expected, 'non-array target');
*/
let index, mod, code, chr, value;
expected = Array(516);
array = Array(516);
for (index = 0; index < 516; index++) {
mod = index % 4;
array[index] = 515 - index;
expected[index] = index - 2 * mod + 3;
}
assert.arrayEqual(toSorted(array, (a, b) => (a / 4 | 0) - (b / 4 | 0)), expected, 'stable #1');
assert.true(1 / toSorted([0, -0])[0] > 0, '-0');
let result = '';
array = [];
// generate an array with more 512 elements (Chakra and old V8 fails only in this case)
for (code = 65; code < 76; code++) {
chr = String.fromCharCode(code);
switch (code) {
case 66: case 69: case 70: case 72: value = 3; break;
case 68: case 71: value = 4; break;
default: value = 2;
}
for (index = 0; index < 47; index++) {
array.push({ k: chr + index, v: value });
}
}
array = toSorted(array, (a, b) => b.v - a.v);
for (index = 0; index < array.length; index++) {
chr = array[index].k.charAt(0);
if (result.charAt(result.length - 1) !== chr) result += chr;
}
assert.same(result, 'DGBEFHACIJK', 'stable #2');
assert.notThrows(() => toSorted([1, 2, 3], undefined).length === 3, 'works with undefined');
assert.throws(() => toSorted([1, 2, 3], null), 'throws on null');
assert.throws(() => toSorted([1, 2, 3], {}), 'throws on {}');
if (typeof Symbol == 'function' && !Symbol.sham) {
assert.throws(() => toSorted([Symbol(1), Symbol(2)]), 'w/o cmp throws on symbols');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.true(toSorted(array) instanceof Array, 'non-generic');
if (STRICT) {
assert.throws(() => toSorted(null), TypeError, 'ToObject(this)');
assert.throws(() => toSorted(undefined), TypeError, 'ToObject(this)');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.to-spliced.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import toSpliced from 'core-js-pure/es/array/to-spliced';
QUnit.test('Array#toSpliced', assert => {
assert.isFunction(toSpliced);
let array = [1, 2, 3, 4, 5];
assert.notSame(toSpliced(array, 2), array);
assert.deepEqual(toSpliced([1, 2, 3, 4, 5], 2), [1, 2]);
assert.deepEqual(toSpliced([1, 2, 3, 4, 5], -2), [1, 2, 3]);
assert.deepEqual(toSpliced([1, 2, 3, 4, 5], 2, 2), [1, 2, 5]);
assert.deepEqual(toSpliced([1, 2, 3, 4, 5], 2, -2), [1, 2, 3, 4, 5]);
assert.deepEqual(toSpliced([1, 2, 3, 4, 5], 2, 2, 6, 7), [1, 2, 6, 7, 5]);
if (STRICT) {
assert.throws(() => toSpliced(null), TypeError);
assert.throws(() => toSpliced(undefined), TypeError);
}
array = [];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.true(toSpliced(array) instanceof Array, 'non-generic');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.unshift.js
|
JavaScript
|
import { REDEFINABLE_ARRAY_LENGTH_DESCRIPTOR, STRICT } from '../helpers/constants.js';
import unshift from 'core-js-pure/es/array/virtual/unshift';
import defineProperty from 'core-js-pure/es/object/define-property';
QUnit.test('Array#unshift', assert => {
assert.isFunction(unshift);
assert.same(unshift.call([1], 0), 2, 'proper result');
if (STRICT) {
if (REDEFINABLE_ARRAY_LENGTH_DESCRIPTOR) {
assert.throws(() => unshift.call(defineProperty([], 'length', { writable: false }), 1), TypeError, 'non-writable length, with arg');
assert.throws(() => unshift.call(defineProperty([], 'length', { writable: false })), TypeError, 'non-writable length, without arg');
}
assert.throws(() => unshift.call(null), TypeError);
assert.throws(() => unshift.call(undefined), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.array.with.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import withAt from 'core-js-pure/es/array/with';
QUnit.test('Array#with', assert => {
assert.isFunction(withAt);
let array = [1, 2, 3, 4, 5];
assert.notSame(withAt(array, 2, 1), array);
assert.deepEqual(withAt([1, 2, 3, 4, 5], 2, 6), [1, 2, 6, 4, 5]);
assert.deepEqual(withAt([1, 2, 3, 4, 5], -2, 6), [1, 2, 3, 6, 5]);
assert.deepEqual(withAt([1, 2, 3, 4, 5], '1', 6), [1, 6, 3, 4, 5]);
assert.throws(() => withAt([1, 2, 3, 4, 5], 5, 6), RangeError);
assert.throws(() => withAt([1, 2, 3, 4, 5], -6, 6), RangeError);
if (STRICT) {
assert.throws(() => withAt(null, 1, 2), TypeError);
assert.throws(() => withAt(undefined, 1, 2), TypeError);
}
array = [1, 2];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.true(withAt(array, 1, 2) instanceof Array, 'non-generic');
// Incorrect exception thrown when index coercion fails in Firefox
function CustomError() { /* empty */ }
const index = { valueOf() { throw new CustomError(); } };
assert.throws(() => withAt([], index, null), CustomError, 'incorrect error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.async-disposable-stack.constructor.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
import AsyncDisposableStack from 'core-js-pure/es/async-disposable-stack';
import SuppressedError from 'core-js-pure/es/suppressed-error';
QUnit.test('AsyncDisposableStack constructor', assert => {
assert.isFunction(AsyncDisposableStack);
assert.arity(AsyncDisposableStack, 0);
assert.name(AsyncDisposableStack, 'AsyncDisposableStack');
assert.true(new AsyncDisposableStack() instanceof AsyncDisposableStack);
assert.same(AsyncDisposableStack.prototype.constructor, AsyncDisposableStack);
// eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
assert.throws(() => AsyncDisposableStack(), 'throws w/o `new`');
});
QUnit.test('AsyncDisposableStack#disposeAsync', assert => {
assert.isFunction(AsyncDisposableStack.prototype.disposeAsync);
assert.arity(AsyncDisposableStack.prototype.disposeAsync, 0);
assert.name(AsyncDisposableStack.prototype.disposeAsync, 'disposeAsync');
assert.nonEnumerable(AsyncDisposableStack.prototype, 'disposeAsync');
});
QUnit.test('AsyncDisposableStack#use', assert => {
assert.isFunction(AsyncDisposableStack.prototype.use);
assert.arity(AsyncDisposableStack.prototype.use, 1);
assert.name(AsyncDisposableStack.prototype.use, 'use');
assert.nonEnumerable(AsyncDisposableStack.prototype, 'use');
let result = '';
const stack = new AsyncDisposableStack();
const resource = {
[Symbol.asyncDispose]() {
result += '1';
assert.same(this, resource);
assert.same(arguments.length, 0);
},
};
assert.same(stack.use(resource), resource);
return stack.disposeAsync().then(it => {
assert.same(it, undefined);
assert.same(result, '1');
});
});
QUnit.test('AsyncDisposableStack#adopt', assert => {
assert.isFunction(AsyncDisposableStack.prototype.adopt);
assert.arity(AsyncDisposableStack.prototype.adopt, 2);
assert.name(AsyncDisposableStack.prototype.adopt, 'adopt');
assert.nonEnumerable(AsyncDisposableStack.prototype, 'adopt');
let result = '';
const stack = new AsyncDisposableStack();
const resource = {};
assert.same(stack.adopt(resource, function (arg) {
result += '1';
if (STRICT) assert.same(this, undefined);
assert.same(arguments.length, 1);
assert.same(arg, resource);
}), resource);
return stack.disposeAsync().then(it => {
assert.same(it, undefined);
assert.same(result, '1');
});
});
QUnit.test('AsyncDisposableStack#defer', assert => {
assert.isFunction(AsyncDisposableStack.prototype.defer);
assert.arity(AsyncDisposableStack.prototype.defer, 1);
assert.name(AsyncDisposableStack.prototype.defer, 'defer');
assert.nonEnumerable(AsyncDisposableStack.prototype, 'defer');
let result = '';
const stack = new AsyncDisposableStack();
assert.same(stack.defer(function () {
result += '1';
if (STRICT) assert.same(this, undefined);
assert.same(arguments.length, 0);
}), undefined);
return stack.disposeAsync().then(it => {
assert.same(it, undefined);
assert.same(result, '1');
});
});
QUnit.test('AsyncDisposableStack#move', assert => {
assert.isFunction(AsyncDisposableStack.prototype.move);
assert.arity(AsyncDisposableStack.prototype.move, 0);
assert.name(AsyncDisposableStack.prototype.move, 'move');
assert.nonEnumerable(AsyncDisposableStack.prototype, 'move');
let result = '';
const stack1 = new AsyncDisposableStack();
stack1.defer(() => result += '2');
stack1.defer(() => result += '1');
const stack2 = stack1.move();
assert.true(stack1.disposed);
return stack2.disposeAsync().then(() => {
assert.same(result, '12');
});
});
QUnit.test('AsyncDisposableStack#@@asyncDispose', assert => {
assert.same(AsyncDisposableStack.prototype[Symbol.asyncDispose], AsyncDisposableStack.prototype.disposeAsync);
});
QUnit.test('AsyncDisposableStack#@@toStringTag', assert => {
assert.same(AsyncDisposableStack.prototype[Symbol.toStringTag], 'AsyncDisposableStack', '@@toStringTag');
});
QUnit.test('AsyncDisposableStack#1', assert => {
let result = '';
const stack = new AsyncDisposableStack();
stack.use({ [Symbol.asyncDispose]: () => result += '6' });
stack.adopt({}, () => result += '5');
stack.defer(() => result += '4');
stack.use({ [Symbol.asyncDispose]: () => Promise.resolve(result += '3') });
stack.adopt({}, () => Promise.resolve(result += '2'));
stack.defer(() => Promise.resolve(result += '1'));
assert.false(stack.disposed);
return stack.disposeAsync().then(it => {
assert.same(it, undefined);
assert.same(result, '123456');
assert.true(stack.disposed);
return stack.disposeAsync();
}).then(it => {
assert.same(it, undefined);
});
});
QUnit.test('AsyncDisposableStack#2', assert => {
let result = '';
const stack = new AsyncDisposableStack();
stack.use({ [Symbol.asyncDispose]: () => result += '6' });
stack.adopt({}, () => { throw new Error(5); });
stack.defer(() => result += '4');
stack.use({ [Symbol.asyncDispose]: () => Promise.resolve(result += '3') });
stack.adopt({}, () => Promise.resolve(result += '2'));
stack.defer(() => Promise.resolve(result += '1'));
return stack.disposeAsync().then(() => {
assert.avoid();
}, error => {
assert.same(result, '12346');
assert.true(error instanceof Error);
assert.same(error.message, '5');
});
});
QUnit.test('AsyncDisposableStack#3', assert => {
let result = '';
const stack = new AsyncDisposableStack();
stack.use({ [Symbol.asyncDispose]: () => result += '6' });
stack.adopt({}, () => { throw new Error(5); });
stack.defer(() => result += '4');
stack.use({ [Symbol.asyncDispose]: () => Promise.reject(new Error(3)) });
stack.adopt({}, () => Promise.resolve(result += '2'));
stack.defer(() => Promise.resolve(result += '1'));
return stack.disposeAsync().then(() => {
assert.avoid();
}, error => {
assert.same(result, '1246');
assert.true(error instanceof SuppressedError);
assert.same(error.error.message, '5');
assert.same(error.suppressed.message, '3');
});
});
// https://github.com/tc39/proposal-explicit-resource-management/issues/256
QUnit.test('AsyncDisposableStack#256', assert => {
const resume = assert.async();
assert.expect(1);
let called = false;
const stack = new AsyncDisposableStack();
const neverResolves = new Promise(() => { /* empty */ });
stack.use({ [Symbol.dispose]() { return neverResolves; } });
stack.disposeAsync().then(() => {
called = true;
assert.required('It should be called');
resume();
});
setTimeout(() => called || resume(), 3e3);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.async-iterator.async-dispose.js
|
JavaScript
|
import AsyncIterator from 'core-js-pure/full/async-iterator';
import Symbol from 'core-js-pure/es/symbol';
import create from 'core-js-pure/es/object/create';
QUnit.test('AsyncIterator#@@asyncDispose', assert => {
const asyncDispose = AsyncIterator.prototype[Symbol.asyncDispose];
assert.isFunction(asyncDispose);
assert.arity(asyncDispose, 0);
return create(AsyncIterator.prototype)[Symbol.asyncDispose]().then(result => {
assert.same(result, undefined);
}).then(() => {
let called = false;
const iterator2 = create(AsyncIterator.prototype);
iterator2.return = function () {
called = true;
assert.same(this, iterator2);
return 7;
};
return iterator2[Symbol.asyncDispose]().then(result => {
assert.same(result, undefined);
assert.true(called);
});
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.date.get-year.js
|
JavaScript
|
import getYear from 'core-js-pure/es/date/get-year';
QUnit.test('Date#getYear', assert => {
assert.isFunction(getYear);
const date = new Date();
assert.same(getYear(date), date.getFullYear() - 1900);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.date.now.js
|
JavaScript
|
import now from 'core-js-pure/es/date/now';
QUnit.test('Date.now', assert => {
assert.isFunction(now);
assert.same(typeof now(), 'number', 'typeof');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.date.set-year.js
|
JavaScript
|
import setYear from 'core-js-pure/es/date/set-year';
QUnit.test('Date#setYear', assert => {
assert.isFunction(setYear);
const date = new Date();
setYear(date, 1);
assert.same(date.getFullYear(), 1901);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.date.to-gmt-string.js
|
JavaScript
|
import toGMTString from 'core-js-pure/es/date/to-gmt-string';
QUnit.test('Date#toGMTString', assert => {
assert.isFunction(toGMTString);
const date = new Date();
assert.same(toGMTString(date), date.toUTCString());
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.date.to-iso-string.js
|
JavaScript
|
import toISOString from 'core-js-pure/es/date/to-iso-string';
QUnit.test('Date#toISOString', assert => {
assert.isFunction(toISOString);
assert.same(toISOString(new Date(0)), '1970-01-01T00:00:00.000Z');
assert.same(toISOString(new Date(1e12 + 1)), '2001-09-09T01:46:40.001Z');
assert.same(toISOString(new Date(-5e13 - 1)), '0385-07-25T07:06:39.999Z');
const future = toISOString(new Date(1e15 + 1));
const properFuture = future === '+033658-09-27T01:46:40.001Z' || future === '33658-09-27T01:46:40.001Z';
assert.true(properFuture);
const prehistoric = toISOString(new Date(-1e15 + 1));
const properPrehistoric = prehistoric === '-029719-04-05T22:13:20.001Z' || prehistoric === '-29719-04-05T22:13:20.001Z';
assert.true(properPrehistoric);
assert.throws(() => toISOString(new Date(NaN)), RangeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.date.to-json.js
|
JavaScript
|
import toISOString from 'core-js-pure/es/date/to-iso-string';
import toJSON from 'core-js-pure/es/date/to-json';
QUnit.test('Date#toJSON', assert => {
assert.isFunction(toJSON);
if (Date.prototype.toISOString) {
const date = new Date();
assert.same(toJSON(date), toISOString(date), 'base');
}
assert.same(toJSON(new Date(NaN)), null, 'not finite');
assert.same(toJSON({
toISOString() {
return 42;
},
}), 42, 'generic');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.disposable-stack.constructor.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import DisposableStack from 'core-js-pure/es/disposable-stack';
import SuppressedError from 'core-js-pure/es/suppressed-error';
QUnit.test('DisposableStack constructor', assert => {
assert.isFunction(DisposableStack);
assert.arity(DisposableStack, 0);
assert.name(DisposableStack, 'DisposableStack');
assert.true(new DisposableStack() instanceof DisposableStack);
assert.same(DisposableStack.prototype.constructor, DisposableStack);
// eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
assert.throws(() => DisposableStack(), 'throws w/o `new`');
});
QUnit.test('DisposableStack#dispose', assert => {
assert.isFunction(DisposableStack.prototype.dispose);
assert.arity(DisposableStack.prototype.dispose, 0);
assert.name(DisposableStack.prototype.dispose, 'dispose');
assert.nonEnumerable(DisposableStack.prototype, 'dispose');
});
QUnit.test('DisposableStack#use', assert => {
assert.isFunction(DisposableStack.prototype.use);
assert.arity(DisposableStack.prototype.use, 1);
assert.name(DisposableStack.prototype.use, 'use');
assert.nonEnumerable(DisposableStack.prototype, 'use');
let result = '';
const stack = new DisposableStack();
const resource = {
[Symbol.dispose]() {
result += '1';
assert.same(this, resource);
assert.same(arguments.length, 0);
},
};
assert.same(stack.use(resource), resource);
assert.same(stack.dispose(), undefined);
assert.same(result, '1');
});
QUnit.test('DisposableStack#adopt', assert => {
assert.isFunction(DisposableStack.prototype.adopt);
assert.arity(DisposableStack.prototype.adopt, 2);
assert.name(DisposableStack.prototype.adopt, 'adopt');
assert.nonEnumerable(DisposableStack.prototype, 'adopt');
let result = '';
const stack = new DisposableStack();
const resource = {};
assert.same(stack.adopt(resource, function (arg) {
result += '1';
if (STRICT) assert.same(this, undefined);
assert.same(arguments.length, 1);
assert.same(arg, resource);
}), resource);
assert.same(stack.dispose(), undefined);
assert.same(result, '1');
});
QUnit.test('DisposableStack#defer', assert => {
assert.isFunction(DisposableStack.prototype.defer);
assert.arity(DisposableStack.prototype.defer, 1);
assert.name(DisposableStack.prototype.defer, 'defer');
assert.nonEnumerable(DisposableStack.prototype, 'defer');
let result = '';
const stack = new DisposableStack();
assert.same(stack.defer(function () {
result += '1';
if (STRICT) assert.same(this, undefined);
assert.same(arguments.length, 0);
}), undefined);
assert.same(stack.dispose(), undefined);
assert.same(result, '1');
});
QUnit.test('DisposableStack#move', assert => {
assert.isFunction(DisposableStack.prototype.move);
assert.arity(DisposableStack.prototype.move, 0);
assert.name(DisposableStack.prototype.move, 'move');
assert.nonEnumerable(DisposableStack.prototype, 'move');
let result = '';
const stack1 = new DisposableStack();
stack1.defer(() => result += '2');
stack1.defer(() => result += '1');
const stack2 = stack1.move();
assert.true(stack1.disposed);
stack2.dispose();
assert.same(result, '12');
});
QUnit.test('DisposableStack#@@dispose', assert => {
assert.same(DisposableStack.prototype[Symbol.dispose], DisposableStack.prototype.dispose);
});
QUnit.test('DisposableStack#@@toStringTag', assert => {
assert.same(DisposableStack.prototype[Symbol.toStringTag], 'DisposableStack', '@@toStringTag');
});
QUnit.test('DisposableStack', assert => {
let result1 = '';
const stack1 = new DisposableStack();
stack1.use({ [Symbol.dispose]: () => result1 += '6' });
stack1.adopt({}, () => result1 += '5');
stack1.defer(() => result1 += '4');
stack1.use({ [Symbol.dispose]: () => result1 += '3' });
stack1.adopt({}, () => result1 += '2');
stack1.defer(() => result1 += '1');
assert.false(stack1.disposed);
assert.same(stack1.dispose(), undefined);
assert.same(result1, '123456');
assert.true(stack1.disposed);
assert.same(stack1.dispose(), undefined);
let result2 = '';
const stack2 = new DisposableStack();
let error2;
stack2.use({ [Symbol.dispose]: () => result2 += '6' });
stack2.adopt({}, () => { throw new Error(5); });
stack2.defer(() => result2 += '4');
stack2.use({ [Symbol.dispose]: () => result2 += '3' });
stack2.adopt({}, () => result2 += '2');
stack2.defer(() => result2 += '1');
try {
stack2.dispose();
} catch (error2$) {
error2 = error2$;
}
assert.same(result2, '12346');
assert.true(error2 instanceof Error);
assert.same(error2.message, '5');
let result3 = '';
const stack3 = new DisposableStack();
let error3;
stack3.use({ [Symbol.dispose]: () => result3 += '6' });
stack3.adopt({}, () => { throw new Error(5); });
stack3.defer(() => result3 += '4');
stack3.use({ [Symbol.dispose]: () => { throw new Error(3); } });
stack3.adopt({}, () => result3 += '2');
stack3.defer(() => result3 += '1');
try {
stack3.dispose();
} catch (error3$) {
error3 = error3$;
}
assert.same(result3, '1246');
assert.true(error3 instanceof SuppressedError);
assert.same(error3.error.message, '5');
assert.same(error3.suppressed.message, '3');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.error.cause.js
|
JavaScript
|
/* eslint-disable sonarjs/inconsistent-function-call -- required for testing */
import { PROTO } from '../helpers/constants.js';
import path from 'core-js-pure/es/error';
import create from 'core-js-pure/es/object/create';
function runErrorTestCase($Error, ERROR_NAME, WEB_ASSEMBLY) {
QUnit.test(`${ ERROR_NAME } constructor with 'cause' param`, assert => {
assert.isFunction($Error);
assert.arity($Error, 1);
assert.name($Error, ERROR_NAME);
if (PROTO && $Error !== path.Error) {
// eslint-disable-next-line no-prototype-builtins -- safe
assert.true(path.Error.isPrototypeOf($Error), 'constructor has `Error` in the prototype chain');
}
assert.true($Error(1) instanceof $Error, 'no cause, without new');
assert.true(new $Error(1) instanceof $Error, 'no cause, with new');
assert.true($Error(1, {}) instanceof $Error, 'with options, without new');
assert.true(new $Error(1, {}) instanceof $Error, 'with options, with new');
assert.true($Error(1, 'foo') instanceof $Error, 'non-object options, without new');
assert.true(new $Error(1, 'foo') instanceof $Error, 'non-object options, with new');
assert.same($Error(1, { cause: 7 }).cause, 7, 'cause, without new');
assert.same(new $Error(1, { cause: 7 }).cause, 7, 'cause, with new');
assert.same($Error(1, create({ cause: 7 })).cause, 7, 'prototype cause, without new');
assert.same(new $Error(1, create({ cause: 7 })).cause, 7, 'prototype cause, with new');
let error = $Error(1, { cause: 7 });
if (!WEB_ASSEMBLY) assert.same(error.name, ERROR_NAME, 'instance name');
assert.same(error.message, '1', 'instance message');
assert.same(error.cause, 7, 'instance cause');
// eslint-disable-next-line no-prototype-builtins -- safe
assert.true(error.hasOwnProperty('cause'), 'cause is own');
error = $Error();
assert.same(error.message, '', 'default instance message');
assert.same(error.cause, undefined, 'default instance cause undefined');
// eslint-disable-next-line no-prototype-builtins -- safe
assert.false(error.hasOwnProperty('cause'), 'default instance cause missed');
});
}
for (const ERROR_NAME of ['Error', 'EvalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError']) {
runErrorTestCase(path[ERROR_NAME], ERROR_NAME);
}
if (path.WebAssembly) for (const ERROR_NAME of ['CompileError', 'LinkError', 'RuntimeError']) {
if (path.WebAssembly[ERROR_NAME]) runErrorTestCase(path.WebAssembly[ERROR_NAME], ERROR_NAME, true);
}
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.error.is-error.js
|
JavaScript
|
import isError from 'core-js-pure/es/error/is-error';
import create from 'core-js-pure/es/object/create';
import AggregateError from 'core-js-pure/es/aggregate-error';
import SuppressedError from 'core-js-pure/actual/suppressed-error';
import DOMException from 'core-js-pure/stable/dom-exception';
QUnit.test('Error.isError', assert => {
assert.isFunction(isError);
assert.arity(isError, 1);
assert.name(isError, 'isError');
assert.true(isError(new Error('error')));
assert.true(isError(new TypeError('error')));
assert.true(isError(new AggregateError([1, 2, 3], 'error')));
assert.true(isError(new SuppressedError(1, 2, 'error')));
assert.true(isError(new DOMException('error')));
assert.false(isError(null));
assert.false(isError({}));
assert.false(isError(create(Error.prototype)));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.escape.js
|
JavaScript
|
import escape from 'core-js-pure/es/escape';
QUnit.test('escape', assert => {
assert.isFunction(escape);
assert.arity(escape, 1);
assert.same(escape('!q2ф'), '%21q2%u0444');
assert.same(escape(null), 'null');
assert.same(escape(undefined), 'undefined');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => escape(Symbol('escape test')), 'throws on symbol argument');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.function.bind.js
|
JavaScript
|
import bind from 'core-js-pure/es/function/bind';
QUnit.test('Function#bind', assert => {
assert.isFunction(bind);
const object = { a: 42 };
assert.same(bind(function () {
return this.a;
}, object)(), 42);
assert.same(new (bind(() => { /* empty */ }, object))().a, undefined);
function C(a, b) {
this.a = a;
this.b = b;
}
const instance = new (bind(C, null, 1))(2);
assert.true(instance instanceof C);
assert.same(instance.a, 1);
assert.same(instance.b, 2);
assert.same(bind(it => it, null, 42)(), 42);
const regExpTest = bind(RegExp.prototype.test, /a/);
assert.true(regExpTest('a'));
const Date2017 = bind(Date, null, 2017);
const date = new Date2017(11);
assert.true(date instanceof Date);
assert.same(date.getFullYear(), 2017);
assert.same(date.getMonth(), 11);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.function.has-instance.js
|
JavaScript
|
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Function#@@hasInstance', assert => {
assert.true(Symbol.hasInstance in Function.prototype);
assert.true(Function[Symbol.hasInstance](() => { /* empty */ }));
assert.false(Function[Symbol.hasInstance]({}));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.global-this.js
|
JavaScript
|
import globalThis from 'core-js-pure/es/global-this';
QUnit.test('globalThis', assert => {
assert.same(globalThis, Object(globalThis), 'is object');
assert.same(globalThis.Math, Math, 'contains globals');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.concat.js
|
JavaScript
|
import { createIterable, createIterator } from '../helpers/helpers.js';
import concat from 'core-js-pure/es/iterator/concat';
import Iterator from 'core-js-pure/es/iterator';
import Symbol from 'core-js-pure/es/symbol';
import from from 'core-js-pure/es/array/from';
QUnit.test('Iterator.concat', assert => {
assert.isFunction(concat);
assert.arity(concat, 0);
assert.name(concat, 'concat');
let iterator = concat();
assert.isIterable(iterator, 'iterable, no args');
assert.isIterator(iterator, 'iterator, no args');
assert.true(iterator instanceof Iterator, 'iterator instance, no args');
assert.arrayEqual(from(iterator), [], 'proper values, no args');
iterator = concat([1, 2, 3]);
assert.isIterable(iterator, 'iterable, array');
assert.isIterator(iterator, 'iterator, array');
assert.true(iterator instanceof Iterator, 'iterator instance, array');
assert.arrayEqual(from(iterator), [1, 2, 3], 'proper values, array');
iterator = concat([]);
assert.isIterable(iterator, 'iterable, empty array');
assert.isIterator(iterator, 'iterator, empty array');
assert.true(iterator instanceof Iterator, 'iterator instance, empty array');
assert.arrayEqual(from(iterator), [], 'proper values, empty array');
iterator = concat(createIterable([1, 2, 3]));
assert.isIterable(iterator, 'iterable, custom iterable');
assert.isIterator(iterator, 'iterator, custom iterable');
assert.true(iterator instanceof Iterator, 'iterator instance, custom iterable');
assert.arrayEqual(from(iterator), [1, 2, 3], 'proper values, custom iterable');
iterator = concat([1, 2, 3], [], createIterable([4, 5, 6]), createIterable([]));
assert.isIterable(iterator, 'iterable, mixed');
assert.isIterator(iterator, 'iterator, mixed');
assert.true(iterator instanceof Iterator, 'iterator instance, mixed');
assert.arrayEqual(from(iterator), [1, 2, 3, 4, 5, 6], 'proper values, mixed');
iterator = concat(createIterable([1, 2, 3]));
iterator.next();
assert.deepEqual(iterator.return(), { done: true, value: undefined }, '.return with no active inner iterator result');
assert.deepEqual(iterator.next(), { done: true, value: undefined }, '.return with no active inner iterator result on closed iterator');
iterator = concat(createIterable([1, 2, 3]));
assert.deepEqual(iterator.next(), { done: false, value: 1 }, '.next with active inner iterator result');
assert.deepEqual(iterator.return(), { done: true, value: undefined }, '.return with active inner iterator result');
assert.deepEqual(iterator.next(), { done: true, value: undefined }, '.return with active inner iterator result on closed iterator');
let called = false;
iterator = concat(createIterable([1, 2, 3], {
return() {
called = true;
return {};
},
}));
iterator.next();
assert.deepEqual(iterator.return(), { done: true, value: undefined }, '.return with active inner iterator with return result');
assert.true(called, 'inner .return called');
// https://github.com/tc39/proposal-iterator-sequencing/issues/17
const oldIterResult = {
done: false,
value: 123,
};
const testIterator = {
next() {
return oldIterResult;
},
};
const iterable = {
[Symbol.iterator]() {
return testIterator;
},
};
iterator = concat(iterable);
const iterResult = iterator.next();
assert.same(iterResult.done, false);
assert.same(iterResult.value, 123);
// https://github.com/tc39/proposal-iterator-sequencing/pull/26
assert.notSame(iterResult, oldIterResult);
assert.throws(() => concat(createIterator([1, 2, 3])), TypeError, 'non-iterable iterator #1');
assert.throws(() => concat([], createIterator([1, 2, 3])), TypeError, 'non-iterable iterator #2');
assert.throws(() => concat(''), TypeError, 'iterable non-object argument #1');
assert.throws(() => concat([], ''), TypeError, 'iterable non-object argument #2');
assert.throws(() => concat(undefined), TypeError, 'non-iterable-object argument #1');
assert.throws(() => concat(null), TypeError, 'non-iterable-object argument #2');
assert.throws(() => concat(1), TypeError, 'non-iterable-object argument #3');
assert.throws(() => concat({}), TypeError, 'non-iterable-object argument #4');
assert.throws(() => concat([], undefined), TypeError, 'non-iterable-object argument #5');
assert.throws(() => concat([], null), TypeError, 'non-iterable-object argument #6');
assert.throws(() => concat([], 1), TypeError, 'non-iterable-object argument #7');
assert.throws(() => concat([], {}), TypeError, 'non-iterable-object argument #8');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.constructor.js
|
JavaScript
|
import { createIterator, nativeSubclass } from '../helpers/helpers.js';
import Symbol from 'core-js-pure/es/symbol';
import Iterator from 'core-js-pure/es/iterator';
QUnit.test('Iterator', assert => {
assert.isFunction(Iterator);
assert.arity(Iterator, 0);
assert.true(Iterator.from(createIterator([1, 2, 3])) instanceof Iterator, 'From Proxy');
if (nativeSubclass) {
const Sub = nativeSubclass(Iterator);
assert.true(new Sub() instanceof Iterator, 'abstract constructor');
}
assert.throws(() => new Iterator(), 'direct constructor throws');
// eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
assert.throws(() => Iterator(), 'throws w/o `new`');
});
QUnit.test('Iterator#constructor', assert => {
assert.same(Iterator.prototype.constructor, Iterator, 'Iterator#constructor is Iterator');
});
QUnit.test('Iterator#@@toStringTag', assert => {
assert.same(Iterator.prototype[Symbol.toStringTag], 'Iterator', 'Iterator::@@toStringTag is `Iterator`');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.dispose.js
|
JavaScript
|
import Iterator from 'core-js-pure/es/iterator';
import Symbol from 'core-js-pure/es/symbol';
import create from 'core-js-pure/es/object/create';
QUnit.test('Iterator#@@dispose', assert => {
const dispose = Iterator.prototype[Symbol.dispose];
assert.isFunction(dispose);
assert.arity(dispose, 0);
assert.same(create(Iterator.prototype)[Symbol.dispose](), undefined);
let called = false;
const iterator2 = create(Iterator.prototype);
iterator2.return = function () {
called = true;
assert.same(this, iterator2);
return 7;
};
assert.same(iterator2[Symbol.dispose](), undefined);
assert.true(called);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.drop.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/es/iterator';
QUnit.test('Iterator#drop', assert => {
const { drop } = Iterator.prototype;
assert.isFunction(drop);
assert.arity(drop, 1);
assert.nonEnumerable(Iterator.prototype, 'drop');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 1).toArray(), [2, 3], 'basic functionality');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 1.5).toArray(), [2, 3], 'float');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 4).toArray(), [], 'big');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 0).toArray(), [1, 2, 3], 'zero');
if (STRICT) {
assert.throws(() => drop.call(undefined, 1), TypeError);
assert.throws(() => drop.call(null, 1), TypeError);
}
assert.throws(() => drop.call({}, 1).next(), TypeError);
assert.throws(() => drop.call([], 1).next(), TypeError);
assert.throws(() => drop.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => drop.call(it, NaN), RangeError, 'NaN');
assert.true(it.closed, 'drop closes iterator on validation error');
// https://issues.chromium.org/issues/336839115
assert.throws(() => drop.call({ next: null }, 0).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.every.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import Iterator from 'core-js-pure/es/iterator';
QUnit.test('Iterator#every', assert => {
const { every } = Iterator.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.nonEnumerable(Iterator.prototype, 'every');
assert.true(every.call(createIterator([1, 2, 3]), it => typeof it == 'number'), 'basic functionality #1');
assert.false(every.call(createIterator([1, 2, 3]), it => it % 2), 'basic functionality #2');
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');
});
if (STRICT) {
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call([], () => { /* empty */ }), TypeError);
assert.throws(() => every.call(createIterator([1]), undefined), TypeError);
assert.throws(() => every.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => every.call(it, {}), TypeError);
assert.true(it.closed, 'every closes iterator on validation error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.filter.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import Iterator from 'core-js-pure/es/iterator';
QUnit.test('Iterator#filter', assert => {
const { filter } = Iterator.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.nonEnumerable(Iterator.prototype, 'filter');
assert.arrayEqual(filter.call(createIterator([1, 2, 3]), it => it % 2).toArray(), [1, 3], 'basic functionality');
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();
if (STRICT) {
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => filter.call({}, () => { /* empty */ }).next(), TypeError);
assert.throws(() => filter.call([], () => { /* empty */ }).next(), TypeError);
assert.throws(() => filter.call(createIterator([1]), undefined), TypeError);
assert.throws(() => filter.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => filter.call(it, {}), TypeError);
assert.true(it.closed, 'filter closes iterator on validation error');
// https://issues.chromium.org/issues/336839115
assert.throws(() => filter.call({ next: null }, () => { /* empty */ }).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.find.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import Iterator from 'core-js-pure/es/iterator';
QUnit.test('Iterator#find', assert => {
const { find } = Iterator.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.nonEnumerable(Iterator.prototype, 'find');
assert.same(find.call(createIterator([1, 2, 3]), it => !(it % 2)), 2, 'basic functionality');
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');
});
if (STRICT) {
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call([], () => { /* empty */ }), TypeError);
assert.throws(() => find.call(createIterator([1]), undefined), TypeError);
assert.throws(() => find.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => find.call(it, {}), TypeError);
assert.true(it.closed, 'find closes iterator on validation error');
let returnCount = 0;
const it2 = createIterator([1, 2, 3], {
return() {
returnCount++;
throw new Error('close error');
},
});
assert.throws(() => find.call(it2, () => true), Error, 'iterator.return() throwing on stop');
assert.same(returnCount, 1, 'iterator.return() called exactly once when it throws');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.flat-map.js
|
JavaScript
|
import { createIterator, createIterable } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import Iterator from 'core-js-pure/es/iterator';
import Map from 'core-js-pure/es/map';
QUnit.test('Iterator#flatMap', assert => {
const { flatMap } = Iterator.prototype;
assert.isFunction(flatMap);
assert.arity(flatMap, 1);
assert.nonEnumerable(Iterator.prototype, 'flatMap');
assert.arrayEqual(
flatMap.call(createIterator([1, [], 2, createIterable([3, 4]), [5, 6]]), it => typeof it == 'number' ? [-it] : it).toArray(),
[-1, -2, 3, 4, 5, 6],
'basic functionality',
);
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();
// Should not throw an error for an iterator without `return` method. Fixed in Safari 26.2
// https://bugs.webkit.org/show_bug.cgi?id=297532
assert.notThrows(() => {
const iter = flatMap.call(new Map([[4, 5]]).entries(), v => v);
iter.next();
iter.return();
}, 'iterator without `return` method');
if (STRICT) {
assert.throws(() => flatMap.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => flatMap.call(createIterator([1]), it => it).next(), TypeError);
assert.throws(() => flatMap.call({}, () => { /* empty */ }).next(), TypeError);
assert.throws(() => flatMap.call([], () => { /* empty */ }).next(), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), undefined), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => flatMap.call(it, {}), TypeError);
assert.true(it.closed, 'flatMap closes iterator on validation error');
// https://issues.chromium.org/issues/336839115
assert.throws(() => flatMap.call({ next: null }, () => { /* empty */ }).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.for-each.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import Iterator from 'core-js-pure/es/iterator';
QUnit.test('Iterator#forEach', assert => {
const { forEach } = Iterator.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.nonEnumerable(Iterator.prototype, 'forEach');
const array = [];
forEach.call(createIterator([1, 2, 3]), it => array.push(it));
assert.arrayEqual(array, [1, 2, 3], 'basic functionality');
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');
});
if (STRICT) {
assert.throws(() => forEach.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => forEach.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call([], () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(createIterator([1]), undefined), TypeError);
assert.throws(() => forEach.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => forEach.call(it, {}), TypeError);
assert.true(it.closed, 'forEach closes iterator on validation error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.from.js
|
JavaScript
|
import { createIterable, createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/es/iterator';
import assign from 'core-js-pure/es/object/assign';
QUnit.test('Iterator.from', assert => {
const { from } = Iterator;
assert.isFunction(from);
assert.arity(from, 1);
assert.true(Iterator.from(createIterator([1, 2, 3])) instanceof Iterator, 'proxy, iterator');
assert.true(Iterator.from(createIterable([1, 2, 3])) instanceof Iterator, 'proxy, iterable');
assert.arrayEqual(Iterator.from(createIterable([1, 2, 3])).toArray(), [1, 2, 3], 'just a proxy');
assert.throws(() => from(undefined), TypeError);
assert.throws(() => from(null), TypeError);
assert.throws(() => from({}).next(), TypeError);
assert.throws(() => from(assign(new Iterator(), { next: 42 })).next(), TypeError);
// Should not throw when an underlying iterator's `return` method is null
// https://bugs.webkit.org/show_bug.cgi?id=288714
const iterator = createIterator([], { return: null });
const result = from(iterator).return('ignored');
assert.true(result.done, 'iterator with null next #1');
assert.strictEqual(result.value, undefined, 'iterator with null next #2');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.map.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import Iterator from 'core-js-pure/es/iterator';
QUnit.test('Iterator#map', assert => {
const { map } = Iterator.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.nonEnumerable(Iterator.prototype, 'map');
assert.arrayEqual(map.call(createIterator([1, 2, 3]), it => it ** 2).toArray(), [1, 4, 9], 'basic functionality');
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();
if (STRICT) {
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => map.call({}, () => { /* empty */ }).next(), TypeError);
assert.throws(() => map.call([], () => { /* empty */ }).next(), TypeError);
assert.throws(() => map.call(createIterator([1]), undefined), TypeError);
assert.throws(() => map.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => map.call(it, {}), TypeError);
assert.true(it.closed, 'map closes iterator on validation error');
// https://issues.chromium.org/issues/336839115
assert.throws(() => map.call({ next: null }, () => { /* empty */ }).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.reduce.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import Iterator from 'core-js-pure/es/iterator';
QUnit.test('Iterator#reduce', assert => {
const { reduce } = Iterator.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.nonEnumerable(Iterator.prototype, 'reduce');
assert.same(reduce.call(createIterator([1, 2, 3]), (a, b) => a + b, 1), 7, 'basic functionality');
assert.same(reduce.call(createIterator([1, 2, 3]), (a, b) => a + b), 6, 'basic functionality, no init');
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);
if (STRICT) {
assert.throws(() => reduce.call(undefined, (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call(null, (a, b) => a + b, 0), TypeError);
}
assert.throws(() => reduce.call({}, (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call([], (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call(createIterator([1]), undefined, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), null, 1), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => reduce.call(it, {}, 1), TypeError);
assert.true(it.closed, 'reduce closes iterator on validation error');
assert.notThrows(() => reduce.call(createIterator([]), () => false, undefined), 'fails on undefined initial parameter');
assert.same(reduce.call(createIterator([]), () => false, undefined), undefined, 'incorrect result on undefined initial parameter');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.some.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import Iterator from 'core-js-pure/es/iterator';
QUnit.test('Iterator#some', assert => {
const { some } = Iterator.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.nonEnumerable(Iterator.prototype, 'some');
assert.true(some.call(createIterator([1, 2, 3]), it => it % 2), 'basic functionality #1');
assert.false(some.call(createIterator([1, 2, 3]), it => typeof it == 'string'), 'basic functionality #2');
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');
});
if (STRICT) {
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call([], () => { /* empty */ }), TypeError);
assert.throws(() => some.call(createIterator([1]), undefined), TypeError);
assert.throws(() => some.call(createIterator([1]), null), TypeError);
assert.throws(() => some.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => some.call(it, {}), TypeError);
assert.true(it.closed, 'some closes iterator on validation error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.take.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/es/iterator';
QUnit.test('Iterator#take', assert => {
const { take } = Iterator.prototype;
assert.isFunction(take);
assert.arity(take, 1);
assert.nonEnumerable(Iterator.prototype, 'take');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 2).toArray(), [1, 2], 'basic functionality');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 1.5).toArray(), [1], 'float');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 4).toArray(), [1, 2, 3], 'big');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 0).toArray(), [], 'zero');
if (STRICT) {
assert.throws(() => take.call(undefined, 1), TypeError);
assert.throws(() => take.call(null, 1), TypeError);
}
assert.throws(() => take.call({}, 1).next(), TypeError);
assert.throws(() => take.call([], 1).next(), TypeError);
assert.throws(() => take.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => take.call(it, NaN), RangeError, 'NaN');
assert.true(it.closed, 'take closes iterator on validation error');
// https://issues.chromium.org/issues/336839115
assert.throws(() => take.call({ next: null }, 1).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.iterator.to-array.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterable, createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/es/iterator';
QUnit.test('Iterator#toArray', assert => {
const { toArray } = Iterator.prototype;
assert.isFunction(toArray);
assert.arity(toArray, 0);
assert.nonEnumerable(Iterator.prototype, 'toArray');
assert.arrayEqual(Iterator.from('123').toArray(), ['1', '2', '3']);
assert.arrayEqual(Iterator.from(createIterable([1, 2, 3])).toArray(), [1, 2, 3]);
assert.arrayEqual(toArray.call(createIterator([1, 2, 3])), [1, 2, 3]);
if (STRICT) {
assert.throws(() => toArray.call(undefined), TypeError);
assert.throws(() => toArray.call(null), TypeError);
}
assert.throws(() => toArray.call({}), TypeError);
assert.throws(() => toArray.call([]), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.json.is-raw-json.js
|
JavaScript
|
import isRawJSON from 'core-js-pure/es/json/is-raw-json';
import rawJSON from 'core-js-pure/es/json/raw-json';
import freeze from 'core-js-pure/es/object/freeze';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('JSON.rawJSON', assert => {
assert.isFunction(isRawJSON);
assert.arity(isRawJSON, 1);
assert.name(isRawJSON, 'isRawJSON');
assert.true(isRawJSON(rawJSON(1)), 'raw1');
assert.true(isRawJSON(rawJSON(null)), 'raw2');
assert.false(isRawJSON(freeze({ rawJSON: '123' })), 'fake');
assert.false(isRawJSON(undefined), 'undefined');
assert.false(isRawJSON(null), 'null');
assert.false(isRawJSON(1), 'number');
assert.false(isRawJSON('qwe'), 'string');
assert.false(isRawJSON(true), 'bool');
assert.false(isRawJSON(Symbol('JSON.isRawJSON test')), 'sym');
assert.false(isRawJSON({}), 'object');
assert.false(isRawJSON([]), 'array');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.json.parse.js
|
JavaScript
|
// Some tests adopted from Test262 project and governed by the BSD license.
// Copyright (c) 2012 Ecma International. All rights reserved.
/* eslint-disable unicorn/escape-case -- testing */
import { DESCRIPTORS, REDEFINABLE_PROTO } from '../helpers/constants.js';
import parse from 'core-js-pure/es/json/parse';
import defineProperty from 'core-js-pure/es/object/define-property';
import hasOwn from 'core-js-pure/es/object/has-own';
import keys from 'core-js-pure/es/object/keys';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('JSON.parse', assert => {
assert.isFunction(parse);
assert.arity(parse, 2);
assert.name(parse, 'parse');
for (const [reviver, note] of [[undefined, 'without reviver'], [(key, value) => value, 'with reviver']]) {
assert.throws(() => parse('12\t\r\n 34', reviver), SyntaxError, `15.12.1.1-0-1 ${ note }`); // should produce a syntax error as whitespace results in two tokens
assert.throws(() => parse('\u000b1234', reviver), SyntaxError, `15.12.1.1-0-2 ${ note }`); // should produce a syntax error
assert.throws(() => parse('\u000c1234', reviver), SyntaxError, `15.12.1.1-0-3 ${ note }`); // should produce a syntax error
assert.throws(() => parse('\u00a01234', reviver), SyntaxError, `15.12.1.1-0-4 ${ note }`); // should produce a syntax error
assert.throws(() => parse('\u200b1234', reviver), SyntaxError, `15.12.1.1-0-5 ${ note }`); // should produce a syntax error
assert.throws(() => parse('\ufeff1234', reviver), SyntaxError, `15.12.1.1-0-6 ${ note }`); // should produce a syntax error
assert.throws(() => parse('\u2028\u20291234', reviver), SyntaxError, `15.12.1.1-0-8 ${ note }`); // should produce a syntax error
assert.notThrows(() => parse('\t\r \n{\t\r \n"property"\t\r \n:\t\r \n{\t\r \n}\t\r \n,\t\r \n"prop2"\t\r \n:\t\r \n' +
'[\t\r \ntrue\t\r \n,\t\r \nnull\t\r \n,123.456\t\r \n]\t\r \n}\t\r \n', reviver), SyntaxError, `15.12.1.1-0-9 ${ note }`); // should JSON parse without error
assert.same(parse('\t1234', reviver), 1234, `15.12.1.1-g1-1-1 ${ note }`); // '<TAB> should be ignored'
assert.throws(() => parse('12\t34', reviver), SyntaxError, `15.12.1.1-g1-1-2 ${ note }`); // <TAB> should produce a syntax error as whitespace results in two tokens
assert.same(parse('\r1234', reviver), 1234, `15.12.1.1-g1-2-1 ${ note }`); // '<CR> should be ignored'
assert.throws(() => parse('12\r34', reviver), SyntaxError, `15.12.1.1-g1-2-2 ${ note }`); // <CR> should produce a syntax error as whitespace results in two tokens
assert.same(parse('\n1234', reviver), 1234, `15.12.1.1-g1-3-1 ${ note }`); // '<LF> should be ignored'
assert.throws(() => parse('12\n34', reviver), SyntaxError, `15.12.1.1-g1-3-2 ${ note }`); // <LF> should produce a syntax error as whitespace results in two tokens
assert.same(parse(' 1234', reviver), 1234, `15.12.1.1-g1-4-1 ${ note }`); // '<SP> should be ignored'
assert.throws(() => parse('12 34', reviver), SyntaxError, `15.12.1.1-g1-4-2 ${ note }`); // <SP> should produce a syntax error as whitespace results in two tokens
assert.same(parse('"abc"', reviver), 'abc', `15.12.1.1-g2-1 ${ note }`);
assert.throws(() => parse("'abc'", reviver), SyntaxError, `15.12.1.1-g2-2 ${ note }`);
assert.throws(() => parse('\\u0022abc\\u0022', reviver), SyntaxError, `15.12.1.1-g2-3 ${ note }`);
assert.throws(() => parse('"abc\'', reviver), SyntaxError, `15.12.1.1-g2-4 ${ note }`);
assert.same(parse('""', reviver), '', `15.12.1.1-g2-5 ${ note }`);
// invalid string characters should produce a syntax error
assert.throws(() => parse('"\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007"', reviver), SyntaxError, `15.12.1.1-g4-1 ${ note }`);
assert.throws(() => parse('"\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f"', reviver), SyntaxError, `15.12.1.1-g4-2 ${ note }`);
assert.throws(() => parse('"\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017"', reviver), SyntaxError, `15.12.1.1-g4-3 ${ note }`);
assert.throws(() => parse('"\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f"', reviver), SyntaxError, `15.12.1.1-g4-4 ${ note }`);
assert.same(parse('"\\u0058"', reviver), 'X', `15.12.1.1-g5-1 ${ note }`);
assert.throws(() => parse('"\\u005"', reviver), SyntaxError, `15.12.1.1-g5-2 ${ note }`);
assert.throws(() => parse('"\\u0X50"', reviver), SyntaxError, `15.12.1.1-g5-3 ${ note }`);
assert.same(parse('"\\/"', reviver), '/', `15.12.1.1-g6-1 ${ note }`);
assert.same(parse('"\\\\"', reviver), '\\', `15.12.1.1-g6-2 ${ note }`);
assert.same(parse('"\\b"', reviver), '\b', `15.12.1.1-g6-3 ${ note }`);
assert.same(parse('"\\f"', reviver), '\f', `15.12.1.1-g6-4 ${ note }`);
assert.same(parse('"\\n"', reviver), '\n', `15.12.1.1-g6-5 ${ note }`);
assert.same(parse('"\\r"', reviver), '\r', `15.12.1.1-g6-6 ${ note }`);
assert.same(parse('"\\t"', reviver), '\t', `15.12.1.1-g6-7 ${ note }`);
const nullChars = [
'"\u0000"',
'"\u0001"',
'"\u0002"',
'"\u0003"',
'"\u0004"',
'"\u0005"',
'"\u0006"',
'"\u0007"',
'"\u0008"',
'"\u0009"',
'"\u000A"',
'"\u000B"',
'"\u000C"',
'"\u000D"',
'"\u000E"',
'"\u000F"',
'"\u0010"',
'"\u0011"',
'"\u0012"',
'"\u0013"',
'"\u0014"',
'"\u0015"',
'"\u0016"',
'"\u0017"',
'"\u0018"',
'"\u0019"',
'"\u001A"',
'"\u001B"',
'"\u001C"',
'"\u001D"',
'"\u001E"',
'"\u001F"',
];
for (let i = 0; i < nullChars.length; i++) {
assert.throws(() => parse(`{${ nullChars[i] } : "John" }`, reviver), SyntaxError, `15.12.2-2-1-${ i } ${ note }`);
assert.throws(() => parse(`{${ nullChars[i] }name : "John" }`, reviver), SyntaxError, `15.12.2-2-2-${ i } ${ note }`);
assert.throws(() => parse(`{name${ nullChars[i] } : "John" }`, reviver), SyntaxError, `15.12.2-2-3-${ i } ${ note }`);
assert.throws(() => parse(`{${ nullChars[i] }name${ nullChars[i] } : "John" }`, reviver), SyntaxError, `15.12.2-2-4-${ i } ${ note }`);
assert.throws(() => parse(`{na${ nullChars[i] }me : "John" }`, reviver), SyntaxError, `15.12.2-2-5-${ i } ${ note }`);
assert.throws(() => parse(`{ "name" : ${ nullChars[i] } }`, reviver), SyntaxError, `15.12.2-2-6-${ i } ${ note }`);
assert.throws(() => parse(`{ "name" : ${ nullChars[i] }John }`, reviver), SyntaxError, `15.12.2-2-7-${ i } ${ note }`);
assert.throws(() => parse(`{ "name" : John${ nullChars[i] } }`, reviver), SyntaxError, `15.12.2-2-8-${ i } ${ note }`);
assert.throws(() => parse(`{ "name" : ${ nullChars[i] }John${ nullChars[i] } }`, reviver), SyntaxError, `15.12.2-2-9-${ i } ${ note }`);
assert.throws(() => parse(`{ "name" : Jo${ nullChars[i] }hn }`, reviver), SyntaxError, `15.12.2-2-10-${ i } ${ note }`);
}
if (REDEFINABLE_PROTO) {
// eslint-disable-next-line no-proto -- testing
assert.same(parse('{ "__proto__": 1, "__proto__": 2 }', reviver).__proto__, 2, `duplicate proto ${ note }`);
}
assert.throws(() => parse('\u16801', reviver), SyntaxError, `15.12.1.1-0-7-1 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u180e1', reviver), SyntaxError, `15.12.1.1-0-7-2 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20001', reviver), SyntaxError, `15.12.1.1-0-7-3 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20011', reviver), SyntaxError, `15.12.1.1-0-7-4 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20021', reviver), SyntaxError, `15.12.1.1-0-7-5 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20031', reviver), SyntaxError, `15.12.1.1-0-7-6 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20041', reviver), SyntaxError, `15.12.1.1-0-7-7 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20051', reviver), SyntaxError, `15.12.1.1-0-7-8 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20061', reviver), SyntaxError, `15.12.1.1-0-7-9 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20071', reviver), SyntaxError, `15.12.1.1-0-7-10 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20081', reviver), SyntaxError, `15.12.1.1-0-7-11 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20091', reviver), SyntaxError, `15.12.1.1-0-7-12 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u200a1', reviver), SyntaxError, `15.12.1.1-0-7-13 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u202f1', reviver), SyntaxError, `15.12.1.1-0-7-14 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u205f1', reviver), SyntaxError, `15.12.1.1-0-7-15 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u30001', reviver), SyntaxError, `15.12.1.1-0-7-16 ${ note }`); // invalid whitespace
assert.same(parse('-0', reviver), -0, `negative-zero-1 ${ note }`);
assert.same(parse(' \n-0', reviver), -0, `negative-zero-2 ${ note }`);
assert.same(parse('-0 \t', reviver), -0, `negative-zero-3 ${ note }`);
assert.same(parse('\n\t -0\n ', reviver), -0, `negative-zero-4 ${ note }`);
assert.same(parse(-0, reviver), 0, `negative-zero-5 ${ note }`);
assert.throws(() => parse('1.', reviver), SyntaxError, `number-fraction-no-digits-1 ${ note }`);
assert.throws(() => parse('-0.', reviver), SyntaxError, `number-fraction-no-digits-2 ${ note }`);
assert.throws(() => parse('1.e5', reviver), SyntaxError, `number-fraction-no-digits-3 ${ note }`);
assert.throws(() => parse('[1.,2]', reviver), SyntaxError, `number-fraction-no-digits-4 ${ note }`);
assert.throws(() => parse('{', reviver), SyntaxError, `unterminated-object-1 ${ note }`);
assert.throws(() => parse('{"a":1,', reviver), SyntaxError, `unterminated-object-2 ${ note }`);
assert.throws(() => parse('[', reviver), SyntaxError, `unterminated-array-1 ${ note }`);
assert.throws(() => parse('[1,', reviver), SyntaxError, `unterminated-array-2 ${ note }`);
assert.throws(() => parse(undefined, reviver), SyntaxError, `undefined ${ note }`);
assert.throws(() => parse(Symbol('JSON.parse test'), reviver), TypeError, `symbol ${ note }`);
assert.same(parse(null, reviver), null, `null ${ note }`);
assert.same(parse(false, reviver), false, `false ${ note }`);
assert.same(parse(true, reviver), true, `true ${ note }`);
assert.same(parse(0, reviver), 0, `0 ${ note }`);
assert.same(parse(3.14, reviver), 3.14, `3.14 ${ note }`);
assert.same(parse({
toString() {
return '"string"';
},
valueOf() {
return '"default_or_number"';
},
}, reviver), 'string', `text-object ${ note }`);
assert.throws(() => parse({
toString: null,
valueOf() {
throw new EvalError('t262');
},
}, reviver), EvalError, `text-object-abrupt-1 ${ note }`);
assert.throws(() => parse({
toString() {
throw new EvalError('t262');
},
}, reviver), EvalError, `text-object-abrupt-2 ${ note }`);
}
// eslint-disable-next-line no-extend-native -- testing
Array.prototype[1] = 3;
const arr1 = parse('[1, 2]', function (key, value) {
if (key === '0') delete this[1];
return value;
});
delete Array.prototype[1];
assert.same(arr1[0], 1, 'reviver-array-get-prop-from-prototype-1');
assert.true(hasOwn(arr1, '1'), 'reviver-array-get-prop-from-prototype-2');
assert.same(arr1[1], 3, 'reviver-array-get-prop-from-prototype-3');
// eslint-disable-next-line no-extend-native -- testing
Object.prototype.b = 3;
const obj1 = parse('{"a": 1, "b": 2}', function (key, value) {
if (key === 'a') delete this.b;
return value;
});
delete Object.prototype.b;
assert.same(obj1.a, 1, 'reviver-object-get-prop-from-prototype-1');
assert.true(hasOwn(obj1, 'b'), 'reviver-object-get-prop-from-prototype-2');
assert.same(obj1.b, 3, 'reviver-object-get-prop-from-prototype-3');
if (DESCRIPTORS) {
const arr2 = parse('[1, 2]', function (key, value) {
if (key === '0') defineProperty(this, '1', { configurable: false });
if (key === '1') return 22;
return value;
});
assert.same(arr2[0], 1, 'reviver-array-non-configurable-prop-create-1');
assert.same(arr2[1], 2, 'reviver-array-non-configurable-prop-create-2');
const arr3 = parse('[1, 2]', function (key, value) {
if (key === '0') defineProperty(this, '1', { configurable: false });
if (key === '1') return;
return value;
});
assert.same(arr3[0], 1, 'reviver-array-non-configurable-prop-delete-1');
assert.true(hasOwn(arr3, '1'), 'reviver-array-non-configurable-prop-delete-2');
assert.same(arr3[1], 2, 'reviver-array-non-configurable-prop-delete-3');
const obj2 = parse('{"a": 1, "b": 2}', function (key, value) {
if (key === 'a') defineProperty(this, 'b', { configurable: false });
if (key === 'b') return 22;
return value;
});
assert.same(obj2.a, 1, 'reviver-object-non-configurable-prop-create-1');
assert.same(obj2.b, 2, 'reviver-object-non-configurable-prop-create-2');
const obj3 = parse('{"a": 1, "b": 2}', function (key, value) {
if (key === 'a') defineProperty(this, 'b', { configurable: false });
if (key === 'b') return;
return value;
});
assert.same(obj3.a, 1, 'reviver-object-non-configurable-prop-delete-1');
assert.true(hasOwn(obj3, 'b'), 'reviver-object-non-configurable-prop-delete-2');
assert.same(obj3.b, 2, 'reviver-object-non-configurable-prop-delete-3');
assert.throws(() => parse('[0,0]', function () {
defineProperty(this, '1', { get: () => { throw new EvalError('t262'); } });
}), EvalError, 'reviver-get-name-err');
}
assert.throws(() => parse('0', () => { throw new EvalError('t262'); }), EvalError, 'reviver-call-err');
// FF20- enumeration order issue
if (keys({ k: 1, 2: 3 })[0] === '2') {
const calls = [];
parse('{"p1":0,"p2":0,"p1":0,"2":0,"1":0}', (name, val) => {
calls.push(name);
return val;
});
// The empty string is the _rootName_ in JSON.parse
assert.arrayEqual(calls, ['1', '2', 'p1', 'p2', ''], 'reviver-call-order');
}
assert.throws(() => parse(), SyntaxError, 'no args');
});
QUnit.test('JSON.parse source access', assert => {
const spy = (k, v, { source: $source }) => source = $source;
let source;
parse('1234', spy);
assert.same(source, '1234', '1234');
parse('"1234"', spy);
assert.same(source, '"1234"', '"1234"');
parse('null', spy);
assert.same(source, 'null', 'null');
parse('true', spy);
assert.same(source, 'true', 'true');
parse('false', spy);
assert.same(source, 'false', 'false');
parse('{}', spy);
assert.same(source, undefined, '{}');
parse('[]', spy);
assert.same(source, undefined, '[]');
parse('9007199254740993', spy);
assert.same(source, '9007199254740993', '9007199254740993');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.json.raw-json.js
|
JavaScript
|
import { FREEZING } from '../helpers/constants.js';
import rawJSON from 'core-js-pure/es/json/raw-json';
import stringify from 'core-js-pure/es/json/stringify';
import isFrozen from 'core-js-pure/es/object/is-frozen';
import hasOwn from 'core-js-pure/es/object/has-own';
QUnit.test('JSON.rawJSON', assert => {
assert.isFunction(rawJSON);
assert.arity(rawJSON, 1);
assert.name(rawJSON, 'rawJSON');
const raw = rawJSON(1);
assert.true(hasOwn(raw, 'rawJSON'), 'own rawJSON');
assert.same(raw.rawJSON, '1', 'is string 1');
if (FREEZING) assert.true(isFrozen(raw), 'frozen');
assert.same(stringify(rawJSON('"qwe"')), '"qwe"');
assert.same(stringify(rawJSON('null')), 'null');
assert.same(stringify(rawJSON('true')), 'true');
assert.same(stringify(rawJSON('9007199254740993')), '9007199254740993');
assert.same(stringify({ key: rawJSON('9007199254740993') }), '{"key":9007199254740993}');
assert.same(stringify([rawJSON('9007199254740993')]), '[9007199254740993]');
assert.throws(() => rawJSON('"qwe'), SyntaxError, 'invalid 1');
assert.throws(() => rawJSON({}), SyntaxError, 'invalid 2');
assert.throws(() => rawJSON(''), SyntaxError, 'invalid 3');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.json.stringify.js
|
JavaScript
|
// Some tests adopted from Test262 project and governed by the BSD license.
// Copyright (c) 2012 Ecma International. All rights reserved.
/* eslint-disable es/no-bigint,unicorn/no-hex-escape -- testing */
import { DESCRIPTORS, GLOBAL } from '../helpers/constants.js';
import stringify from 'core-js-pure/es/json/stringify';
import Symbol from 'core-js-pure/es/symbol';
import defineProperty from 'core-js-pure/es/object/define-property';
import keys from 'core-js-pure/es/object/keys';
import values from 'core-js-pure/es/object/values';
if (GLOBAL.JSON?.stringify) {
QUnit.test('JSON.stringify', assert => {
assert.isFunction(stringify);
assert.arity(stringify, 3);
assert.name(stringify, 'stringify');
assert.same(stringify({ a: 1, b: 2 }, []), '{}', 'replacer-array-empty-1');
assert.same(stringify({ a: 1, b: { c: 2 } }, []), '{}', 'replacer-array-empty-2');
assert.same(stringify([1, { a: 2 }], []), '[1,{}]', 'replacer-array-empty-3');
const num1 = new Number(10);
num1.toString = () => 'toString';
num1.valueOf = () => { throw new EvalError('should not be called'); };
assert.same(stringify({
10: 1,
toString: 2,
valueOf: 3,
}, [num1]), '{"toString":2}', 'replacer-array-number-object');
const obj1 = {
0: 0,
1: 1,
'-4': 2,
0.3: 3,
'-Infinity': 4,
NaN: 5,
};
assert.same(stringify(obj1, [
-0,
1,
-4,
0.3,
-Infinity,
NaN,
]), stringify(obj1), 'replacer-array-number');
const str1 = new String('str');
str1.toString = () => 'toString';
str1.valueOf = () => { throw new EvalError('should not be called'); };
assert.same(stringify({
str: 1,
toString: 2,
valueOf: 3,
}, [str1]), '{"toString":2}', 'replacer-array-string-object');
assert.same(stringify({ undefined: 1 }, [undefined]), '{}', 'replacer-array-undefined-1');
// eslint-disable-next-line no-sparse-arrays -- testing
assert.same(stringify({ key: 1, undefined: 2 }, [,,,]), '{}', 'replacer-array-undefined-2');
const sparse = Array(3);
sparse[1] = 'key';
assert.same(stringify({ undefined: 1, key: 2 }, sparse), '{"key":2}', 'replacer-array-undefined-3');
assert.throws(() => stringify({}, () => { throw new EvalError('should not be called'); }), EvalError, 'replacer-function-abrupt');
const calls = [];
const b1 = [1, 2];
const b2 = { c1: true, c2: false };
const a1 = {
b1,
b2: {
toJSON() { return b2; },
},
};
const obj2 = { a1, a2: 'a2' };
assert.same(stringify(obj2, function (key, value) {
if (key !== '') calls.push([this, key, value]);
return value;
}), stringify(obj2), 'replacer-function-arguments-1');
assert.arrayEqual(calls[0], [obj2, 'a1', a1], 'replacer-function-arguments-2');
assert.arrayEqual(calls[1], [a1, 'b1', b1], 'replacer-function-arguments-3');
assert.arrayEqual(calls[2], [b1, '0', 1], 'replacer-function-arguments-4');
assert.arrayEqual(calls[3], [b1, '1', 2], 'replacer-function-arguments-5');
assert.arrayEqual(calls[4], [a1, 'b2', b2], 'replacer-function-arguments-6');
assert.arrayEqual(calls[5], [b2, 'c1', true], 'replacer-function-arguments-7');
assert.arrayEqual(calls[6], [b2, 'c2', false], 'replacer-function-arguments-8');
assert.arrayEqual(calls[7], [obj2, 'a2', 'a2'], 'replacer-function-arguments-9');
const circular1 = [{}];
assert.throws(() => stringify(circular1, () => circular1), TypeError, 'replacer-function-array-circular');
const direct1 = { prop: {} };
assert.throws(() => stringify(direct1, () => direct1), TypeError, 'replacer-function-object-circular-1');
const indirect1 = { p1: { p2: {} } };
assert.throws(() => stringify(indirect1, (key, value) => key === 'p2' ? indirect1 : value), TypeError, 'replacer-function-object-circular-2');
assert.same(stringify(1, () => { /* empty */ }), undefined, 'replacer-function-result-undefined-1');
assert.same(stringify([1], () => { /* empty */ }), undefined, 'replacer-function-result-undefined-2');
assert.same(stringify({ prop: 1 }, () => { /* empty */ }), undefined, 'replacer-function-result-undefined-3');
assert.same(stringify([1], (key, value) => value === 1 ? undefined : value), '[null]', 'replacer-function-result-undefined-4');
assert.same(stringify({ prop: 1 }, (key, value) => value === 1 ? undefined : value), '{}', 'replacer-function-result-undefined-5');
assert.same(stringify({ a: { b: [1] } }, (key, value) => value === 1 ? undefined : value), '{"a":{"b":[null]}}', 'replacer-function-result-undefined-6');
assert.same(stringify(null, (key, value) => {
assert.same(value, null);
switch (key) {
case '': return { a1: null, a2: null };
case 'a1': return { b1: null, b2: null };
case 'a2': return 'a2';
case 'b1': return [null, null];
case 'b2': return { c1: null, c2: null };
case '0': return 1;
case '1': return 2;
case 'c1': return true;
case 'c2': return false;
} throw new EvalError('unreachable');
}), stringify({
a1: {
b1: [1, 2],
b2: {
c1: true,
c2: false,
},
},
a2: 'a2',
}), 'replacer-function-result');
assert.same(stringify({
toJSON() { return 'toJSON'; },
}, (_key, value) => `${ value }|replacer`), '"toJSON|replacer"', 'replacer-function-tojson-1');
assert.same(stringify({
toJSON() { return { calls: 'toJSON' }; },
}, (_key, value) => {
if (value && value.calls) value.calls += '|replacer';
return value;
}), '{"calls":"toJSON|replacer"}', 'replacer-function-tojson-2');
const obj4 = { key: [1] };
const json1 = '{"key":[1]}';
assert.same(stringify(obj4, {}), json1, 'replacer-wrong-type-1');
assert.same(stringify(obj4, new String('str')), json1, 'replacer-wrong-type-2');
assert.same(stringify(obj4, new Number(6.1)), json1, 'replacer-wrong-type-3');
assert.same(stringify(obj4, null), json1, 'replacer-wrong-type-4');
assert.same(stringify(obj4, ''), json1, 'replacer-wrong-type-5');
assert.same(stringify(obj4, 0), json1, 'replacer-wrong-type-6');
assert.same(stringify(obj4, Symbol('stringify replacer test')), json1, 'replacer-wrong-type-7');
assert.same(stringify(obj4, true), json1, 'replacer-wrong-type-8');
const obj5 = {
a1: {
b1: [1, 2, 3, 4],
b2: {
c1: 1,
c2: 2,
},
},
a2: 'a2',
};
assert.same(stringify(obj5, null, -1.99999), stringify(obj5, null, -1), 'space-number-float-1');
assert.same(stringify(obj5, null, new Number(5.11111)), stringify(obj5, null, 5), 'space-number-float-2');
assert.same(stringify(obj5, null, 6.99999), stringify(obj5, null, 6), 'space-number-float-3');
assert.same(stringify(obj5, null, new Number(1)), stringify(obj5, null, 1), 'space-number-object-1');
const num2 = new Number(1);
num2.toString = () => { throw new EvalError('should not be called'); };
num2.valueOf = () => 3;
assert.same(stringify(obj5, null, num2), stringify(obj5, null, 3), 'space-number-object-2');
const abrupt1 = new Number(4);
abrupt1.toString = () => { throw new EvalError('t262'); };
abrupt1.valueOf = () => { throw new EvalError('t262'); };
assert.throws(() => stringify(obj5, null, abrupt1), EvalError, 'space-number-object-3');
assert.same(stringify(obj5, null, new Number(-5)), stringify(obj5, null, 0), 'space-number-range-1');
assert.same(stringify(obj5, null, 10), stringify(obj5, null, 100), 'space-number-range-2');
assert.same(stringify(obj5, null, 0), stringify(obj5, null, ''), 'space-number-1');
assert.same(stringify(obj5, null, 4), stringify(obj5, null, ' '), 'space-number-2');
assert.same(stringify(obj5, null, new String('xxx')), stringify(obj5, null, 'xxx'), 'space-string-object-1');
const str2 = new String('xxx');
str2.toString = () => '---';
str2.valueOf = () => { throw new EvalError('should not be called'); };
assert.same(stringify(obj5, null, str2), stringify(obj5, null, '---'), 'space-string-object-2');
const abrupt2 = new String('xxx');
abrupt2.toString = () => { throw new EvalError('t262'); };
abrupt2.valueOf = () => { throw new EvalError('t262'); };
assert.throws(() => stringify(obj5, null, abrupt2), EvalError, 'space-string-object-3');
assert.same(stringify(obj5, null, '0123456789xxxxxxxxx'), stringify(obj5, null, '0123456789'), 'space-string-range');
assert.same(stringify(obj5, null, ''), stringify(obj5), 'space-string-1');
assert.same(stringify(obj5, null, ' '), `{
"a1": {
"b1": [
1,
2,
3,
4
],
"b2": {
"c1": 1,
"c2": 2
}
},
"a2": "a2"
}`, 'space-string-2');
assert.same(stringify(obj5), stringify(obj5, null, null), 'space-wrong-type-1');
assert.same(stringify(obj5), stringify(obj5, null, true), 'space-wrong-type-2');
assert.same(stringify(obj5), stringify(obj5, null, new Boolean(false)), 'space-wrong-type-3');
assert.same(stringify(obj5), stringify(obj5, null, Symbol('stringify space test')), 'space-wrong-type-4');
assert.same(stringify(obj5), stringify(obj5, null, {}), 'space-wrong-type-5');
const direct2 = [];
direct2.push(direct2);
assert.throws(() => stringify(direct2), TypeError, 'value-array-circular-1');
const indirect2 = [];
indirect2.push([[indirect2]]);
assert.throws(() => stringify(indirect2), TypeError, 'value-array-circular-2');
if (typeof BigInt == 'function') {
assert.same(stringify(BigInt(0), (k, v) => typeof v === 'bigint' ? 'bigint' : v), '"bigint"', 'value-bigint-replacer-1');
assert.same(stringify({ x: BigInt(0) }, (k, v) => typeof v === 'bigint' ? 'bigint' : v), '{"x":"bigint"}', 'value-bigint-replacer-2');
assert.throws(() => stringify(BigInt(0)), TypeError, 'value-bigint-1');
assert.throws(() => stringify(Object(BigInt(0))), TypeError, 'value-bigint-2');
assert.throws(() => stringify({ x: BigInt(0) }), TypeError, 'value-bigint-3');
}
assert.same(stringify(new Boolean(true)), 'true', 'value-boolean-object-1');
assert.same(stringify({
toJSON() {
return { key: new Boolean(false) };
},
}), '{"key":false}', 'value-boolean-object-2');
assert.same(stringify([1], (k, v) => v === 1 ? new Boolean(true) : v), '[true]', 'value-boolean-object-3');
assert.same(stringify(() => { /* empty */ }), undefined, 'value-function-1');
assert.same(stringify([() => { /* empty */ }]), '[null]', 'value-function-2');
assert.same(stringify({ key() { /* empty */ } }), '{}', 'value-function-3');
assert.same(stringify(-0), '0', 'value-number-negative-zero-1');
assert.same(stringify(['-0', 0, -0]), '["-0",0,0]', 'value-number-negative-zero-2');
assert.same(stringify({ key: -0 }), '{"key":0}', 'value-number-negative-zero-3');
assert.same(stringify(Infinity), 'null', 'value-number-non-finite-1');
assert.same(stringify({ key: -Infinity }), '{"key":null}', 'value-number-non-finite-2');
assert.same(stringify([NaN]), '[null]', 'value-number-non-finite-3');
assert.same(stringify(new Number(8.5)), '8.5', 'value-number-object-1');
assert.same(stringify(['str'], (key, value) => {
if (value === 'str') {
const num = new Number(42);
num.toString = () => { throw new EvalError('should not be called'); };
num.valueOf = () => 2;
return num;
} return value;
}), '[2]', 'value-number-object-2');
assert.throws(() => stringify({
key: {
toJSON() {
const num = new Number(3.14);
num.toString = () => { throw new EvalError('t262'); };
num.valueOf = () => { throw new EvalError('t262'); };
return num;
},
},
}), EvalError, 'value-number-object-3');
const direct3 = { prop: null };
direct3.prop = direct3;
assert.throws(() => stringify(direct3), TypeError, 'value-object-circular-1');
const indirect3 = { p1: { p2: {} } };
indirect3.p1.p2.p3 = indirect3;
assert.throws(() => stringify(indirect3), TypeError, 'value-object-circular-2');
assert.same(stringify(null), 'null', 'null');
assert.same(stringify(true), 'true', 'true');
assert.same(stringify(false), 'false', 'false');
assert.same(stringify('str'), '"str"', '"str"');
assert.same(stringify(123), '123', '123');
assert.same(stringify(undefined), undefined, 'undefined');
const charToJson = {
'"': '\\"',
'\\': '\\\\',
'\x00': '\\u0000',
'\x01': '\\u0001',
'\x02': '\\u0002',
'\x03': '\\u0003',
'\x04': '\\u0004',
'\x05': '\\u0005',
'\x06': '\\u0006',
'\x07': '\\u0007',
'\x08': '\\b',
'\x09': '\\t',
'\x0A': '\\n',
'\x0B': '\\u000b',
'\x0C': '\\f',
'\x0D': '\\r',
'\x0E': '\\u000e',
'\x0F': '\\u000f',
'\x10': '\\u0010',
'\x11': '\\u0011',
'\x12': '\\u0012',
'\x13': '\\u0013',
'\x14': '\\u0014',
'\x15': '\\u0015',
'\x16': '\\u0016',
'\x17': '\\u0017',
'\x18': '\\u0018',
'\x19': '\\u0019',
'\x1A': '\\u001a',
'\x1B': '\\u001b',
'\x1C': '\\u001c',
'\x1D': '\\u001d',
'\x1E': '\\u001e',
'\x1F': '\\u001f',
};
const chars = keys(charToJson).join('');
const charsReversed = keys(charToJson).reverse().join('');
const jsonChars = values(charToJson).join('');
const jsonCharsReversed = values(charToJson).reverse().join('');
const json = stringify({ [`name${ chars }${ charsReversed }`]: `${ charsReversed }${ chars }value` });
for (const chr in charToJson) {
const count = json.split(charToJson[chr]).length - 1;
assert.same(count, 4, `Every ASCII 0x${ chr.charCodeAt(0).toString(16) } serializes to ${ charToJson[chr] }`);
}
assert.same(
json,
`{"name${ jsonChars }${ jsonCharsReversed }":"${ jsonCharsReversed }${ jsonChars }value"}`,
'JSON.stringify(objectUsingControlCharacters)',
);
assert.same(stringify('\uD834'), '"\\ud834"', 'JSON.stringify("\\uD834")');
assert.same(stringify('\uDF06'), '"\\udf06"', 'JSON.stringify("\\uDF06")');
assert.same(stringify('\uD834\uDF06'), '"𝌆"', 'JSON.stringify("\\uD834\\uDF06")');
assert.same(stringify('\uD834\uD834\uDF06\uD834'), '"\\ud834𝌆\\ud834"', 'JSON.stringify("\\uD834\\uD834\\uDF06\\uD834")');
assert.same(stringify('\uD834\uD834\uDF06\uDF06'), '"\\ud834𝌆\\udf06"', 'JSON.stringify("\\uD834\\uD834\\uDF06\\uDF06")');
assert.same(stringify('\uDF06\uD834\uDF06\uD834'), '"\\udf06𝌆\\ud834"', 'JSON.stringify("\\uDF06\\uD834\\uDF06\\uD834")');
assert.same(stringify('\uDF06\uD834\uDF06\uDF06'), '"\\udf06𝌆\\udf06"', 'JSON.stringify("\\uDF06\\uD834\\uDF06\\uDF06")');
assert.same(stringify('\uDF06\uD834'), '"\\udf06\\ud834"', 'JSON.stringify("\\uDF06\\uD834")');
assert.same(stringify('\uD834\uDF06\uD834\uD834'), '"𝌆\\ud834\\ud834"', 'JSON.stringify("\\uD834\\uDF06\\uD834\\uD834")');
assert.same(stringify('\uD834\uDF06\uD834\uDF06'), '"𝌆𝌆"', 'JSON.stringify("\\uD834\\uDF06\\uD834\\uDF06")');
assert.same(stringify('\uDF06\uDF06\uD834\uD834'), '"\\udf06\\udf06\\ud834\\ud834"', 'JSON.stringify("\\uDF06\\uDF06\\uD834\\uD834")');
assert.same(stringify('\uDF06\uDF06\uD834\uDF06'), '"\\udf06\\udf06𝌆"', 'JSON.stringify("\\uDF06\\uDF06\\uD834\\uDF06")');
assert.same(stringify(new String('str')), '"str"', 'value-string-object-1');
assert.same(stringify({
key: {
toJSON() {
const str = new String('str');
str.toString = () => 'toString';
str.valueOf = () => { throw new EvalError('should not be called'); };
return str;
},
},
}), '{"key":"toString"}', 'value-string-object-2');
assert.throws(() => stringify([true], (key, value) => {
if (value === true) {
const str = new String('str');
str.toString = () => { throw new EvalError('t262'); };
str.valueOf = () => { throw new EvalError('t262'); };
return str;
} return value;
}), 'value-string-object-3');
assert.throws(() => stringify({
toJSON() { throw new EvalError('t262'); },
}), EvalError, 'value-tojson-abrupt-1');
let callCount = 0;
let $this, $key;
const obj6 = {
toJSON(key) {
callCount += 1;
$this = this;
$key = key;
},
};
assert.same(stringify(obj6), undefined, 'value-tojson-arguments-1');
assert.same(callCount, 1, 'value-tojson-arguments-2');
assert.same($this, obj6, 'value-tojson-arguments-3');
assert.same($key, '', 'value-tojson-arguments-4');
assert.same(stringify([1, obj6, 3]), '[1,null,3]', 'value-tojson-arguments-5');
assert.same(callCount, 2, 'value-tojson-arguments-6');
assert.same($this, obj6, 'value-tojson-arguments-7');
// some old implementations (like WebKit) could pass numbers as keys
// assert.same($key, '1', 'value-tojson-arguments-8');
assert.same(stringify({ key: obj6 }), '{}', 'value-tojson-arguments-9');
assert.same(callCount, 3, 'value-tojson-arguments-10');
assert.same($this, obj6, 'value-tojson-arguments-11');
assert.same($key, 'key', 'value-tojson-arguments-12');
const arr1 = [];
const circular2 = [arr1];
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- testing
arr1.toJSON = () => circular2;
assert.throws(() => stringify(circular2), TypeError, 'value-tojson-array-circular');
assert.same(stringify({ toJSON: null }), '{"toJSON":null}', 'value-tojson-not-function-1');
assert.same(stringify({ toJSON: false }), '{"toJSON":false}', 'value-tojson-not-function-2');
assert.same(stringify({ toJSON: [] }), '{"toJSON":[]}', 'value-tojson-not-function-3');
assert.same(stringify({ toJSON: /re/ }), '{"toJSON":{}}', 'value-tojson-not-function-4');
const obj7 = {};
const circular3 = { prop: obj7 };
obj7.toJSON = () => circular3;
assert.throws(() => stringify(circular3), TypeError, 'value-tojson-object-circular');
assert.same(stringify({ toJSON() { return [false]; } }), '[false]', 'value-tojson-result-1');
const arr2 = [true];
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- testing
arr2.toJSON = () => { /* empty */ };
assert.same(stringify(arr2), undefined, 'value-tojson-result-2');
const str3 = new String('str');
// eslint-disable-next-line es/no-nonstandard-string-prototype-properties -- testing
str3.toJSON = () => null;
assert.same(stringify({ key: str3 }), '{"key":null}', 'value-tojson-result-3');
const num3 = new Number(14);
// eslint-disable-next-line es/no-nonstandard-number-prototype-properties -- testing
num3.toJSON = () => ({ key: 7 });
assert.same(stringify([num3]), '[{"key":7}]', 'value-tojson-result-4');
if (DESCRIPTORS) {
// This getter will be triggered during enumeration, but the property it adds should not be enumerated.
/* IE issue
const o = defineProperty({
p1: 'p1',
p2: 'p2',
p3: 'p3',
}, 'add', {
enumerable: true,
get() {
o.extra = 'extra';
return 'add';
},
});
o.p4 = 'p4';
o[2] = '2';
o[0] = '0';
o[1] = '1';
delete o.p1;
delete o.p3;
o.p1 = 'p1';
assert.same(stringify(o), '{"0":"0","1":"1","2":"2","p2":"p2","add":"add","p4":"p4","p1":"p1"}', 'property-order');
*/
let getCalls = 0;
assert.same(stringify(defineProperty({}, 'key', {
enumerable: true,
get() {
getCalls += 1;
return true;
},
}), ['key', 'key']), '{"key":true}', 'replacer-array-duplicates-1');
assert.same(getCalls, 1, 'replacer-array-duplicates-2');
/* old WebKit bug - however, fixing of this is not in priority
const obj3 = defineProperty({}, 'a', {
enumerable: true,
get() {
delete this.b;
return 1;
},
});
obj3.b = 2;
assert.same(stringify(obj3, (key, value) => {
if (key === 'b') {
assert.same(value, undefined, 'replacer-function-object-deleted-property-1');
return '<replaced>';
} return value;
}), '{"a":1,"b":"<replaced>"}', 'replacer-function-object-deleted-property-2');
*/
assert.throws(() => stringify({ key: defineProperty(Array(1), '0', {
get() { throw new EvalError('t262'); },
}) }), EvalError, 'value-array-abrupt');
assert.throws(() => stringify(defineProperty({}, 'key', {
enumerable: true,
get() { throw new EvalError('t262'); },
})), EvalError, 'value-object-abrupt');
assert.throws(() => stringify(defineProperty({}, 'toJSON', {
get() { throw new EvalError('t262'); },
})), EvalError, 'value-tojson-abrupt-2');
}
});
QUnit.test('Symbols & JSON.stringify', assert => {
const symbol1 = Symbol('symbol & stringify test 1');
const symbol2 = Symbol('symbol & stringify test 2');
assert.same(stringify([
1,
symbol1,
false,
symbol2,
{},
]), '[1,null,false,null,{}]', 'array value');
assert.same(stringify({
symbol: symbol1,
}), '{}', 'object value');
if (DESCRIPTORS) {
const object = { bar: 2 };
object[symbol1] = 1;
assert.same(stringify(object), '{"bar":2}', 'object key');
}
assert.same(stringify(symbol1), undefined, 'symbol value');
if (typeof symbol1 == 'symbol') {
assert.same(stringify(Object(symbol1)), '{}', 'boxed symbol');
}
assert.same(stringify(undefined, () => 42), '42', 'replacer works with top-level undefined');
});
QUnit.test('Well‑formed JSON.stringify', assert => {
assert.same(stringify({ foo: 'bar' }), '{"foo":"bar"}', 'basic');
assert.same(stringify('\uDEAD'), '"\\udead"', 'r1');
assert.same(stringify('\uDF06\uD834'), '"\\udf06\\ud834"', 'r2');
assert.same(stringify('\uDF06ab\uD834'), '"\\udf06ab\\ud834"', 'r3');
assert.same(stringify('𠮷'), '"𠮷"', 'r4');
assert.same(stringify('\uD834\uDF06'), '"𝌆"', 'r5');
assert.same(stringify('\uD834\uD834\uDF06'), '"\\ud834𝌆"', 'r6');
assert.same(stringify('\uD834\uDF06\uDF06'), '"𝌆\\udf06"', 'r7');
assert.same(stringify({ '𠮷': ['\uDF06\uD834'] }), '{"𠮷":["\\udf06\\ud834"]}', 'r8');
});
}
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.map.get-or-insert-computed.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import Map from 'core-js-pure/es/map';
import from from 'core-js-pure/es/array/from';
QUnit.test('Map#getOrInsertComputed', assert => {
const { getOrInsertComputed } = Map.prototype;
assert.isFunction(getOrInsertComputed);
assert.arity(getOrInsertComputed, 2);
assert.name(getOrInsertComputed, 'getOrInsertComputed');
assert.nonEnumerable(Map.prototype, 'getOrInsertComputed');
let map = new Map([['a', 2]]);
assert.same(map.getOrInsertComputed('a', () => 3), 2, 'result#1');
assert.deepEqual(from(map), [['a', 2]], 'map#1');
map = new Map([['a', 2]]);
assert.same(map.getOrInsertComputed('b', () => 3), 3, 'result#2');
assert.deepEqual(from(map), [['a', 2], ['b', 3]], 'map#2');
map = new Map([['a', 2]]);
map.getOrInsertComputed('a', () => assert.avoid());
map = new Map([['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 Map([['a', 2]]);
map.getOrInsertComputed(-0, key => assert.same(key, 0, 'CanonicalizeKeyedCollectionKey'));
assert.throws(() => new Map().getOrInsertComputed('a', {}), TypeError, 'non-callable#1');
assert.throws(() => new Map().getOrInsertComputed('a', 1), TypeError, 'non-callable#2');
assert.throws(() => new Map().getOrInsertComputed('a', null), TypeError, 'non-callable#3');
assert.throws(() => new Map().getOrInsertComputed('a', undefined), TypeError, 'non-callable#4');
assert.throws(() => new Map().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.map.get-or-insert.js
|
JavaScript
|
import Map from 'core-js-pure/es/map';
import from from 'core-js-pure/es/array/from';
QUnit.test('Map#getOrInsert', assert => {
const { getOrInsert } = Map.prototype;
assert.isFunction(getOrInsert);
assert.arity(getOrInsert, 2);
assert.name(getOrInsert, 'getOrInsert');
assert.nonEnumerable(Map.prototype, 'getOrInsert');
let map = new Map([['a', 2]]);
assert.same(map.getOrInsert('a', 3), 2, 'result#1');
assert.deepEqual(from(map), [['a', 2]], 'map#1');
map = new Map([['a', 2]]);
assert.same(map.getOrInsert('b', 3), 3, 'result#2');
assert.deepEqual(from(map), [['a', 2], ['b', 3]], 'map#2');
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');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.map.group-by.js
|
JavaScript
|
import { createIterable } from '../helpers/helpers.js';
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/es/map';
QUnit.test('Map.groupBy', assert => {
const { groupBy } = Map;
assert.isFunction(groupBy);
assert.arity(groupBy, 2);
assert.name(groupBy, 'groupBy');
assert.true(groupBy([], it => it) instanceof Map);
assert.deepEqual(from(groupBy([], it => it)), []);
assert.deepEqual(from(groupBy([1, 2], it => it ** 2)), [[1, [1]], [4, [2]]]);
assert.deepEqual(from(groupBy([1, 2, 1], it => it ** 2)), [[1, [1, 1]], [4, [2]]]);
assert.deepEqual(from(groupBy(createIterable([1, 2]), it => it ** 2)), [[1, [1]], [4, [2]]]);
assert.deepEqual(from(groupBy('qwe', it => it)), [['q', ['q']], ['w', ['w']], ['e', ['e']]], 'iterable string');
const element = {};
groupBy([element], function (it, i) {
assert.same(arguments.length, 2);
assert.same(it, element);
assert.same(i, 0);
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.map.js
|
JavaScript
|
/* eslint-disable sonarjs/no-element-overwrite -- required for testing */
import { createIterable, is, nativeSubclass } from '../helpers/helpers.js';
import { DESCRIPTORS } from '../helpers/constants.js';
import getIterator from 'core-js-pure/es/get-iterator';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import freeze from 'core-js-pure/es/object/freeze';
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 Symbol from 'core-js-pure/es/symbol';
import Set from 'core-js-pure/es/set';
import Map from 'core-js-pure/es/map';
QUnit.test('Map', assert => {
assert.isFunction(Map);
assert.true('clear' in Map.prototype, 'clear in Map.prototype');
assert.true('delete' in Map.prototype, 'delete in Map.prototype');
assert.true('forEach' in Map.prototype, 'forEach in Map.prototype');
assert.true('get' in Map.prototype, 'get in Map.prototype');
assert.true('has' in Map.prototype, 'has in Map.prototype');
assert.true('set' in Map.prototype, 'set in Map.prototype');
assert.true(new Map() instanceof Map, 'new Map instanceof Map');
assert.same(new Map(createIterable([[1, 1], [2, 2], [3, 3]])).size, 3, 'Init from iterable');
assert.same(new Map([[freeze({}), 1], [2, 3]]).size, 2, 'Support frozen objects');
let done = false;
try {
new Map(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.true(done, '.return #throw');
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 Map(array);
assert.true(done);
const object = {};
new Map().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(Map);
assert.true(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.true(new Subclass() instanceof Map, 'correct subclassing with native classes #2');
assert.same(new Subclass().set(1, 2).get(1), 2, 'correct subclassing with native classes #3');
}
if (typeof ArrayBuffer == 'function') {
const buffer = new ArrayBuffer(8);
const map = new Map([[buffer, 8]]);
assert.true(map.has(buffer), 'works with ArrayBuffer keys');
}
});
QUnit.test('Map#clear', assert => {
assert.isFunction(Map.prototype.clear);
let map = new Map();
map.clear();
assert.same(map.size, 0);
map = new Map().set(1, 2).set(2, 3).set(1, 4);
map.clear();
assert.same(map.size, 0);
assert.false(map.has(1));
assert.false(map.has(2));
const frozen = freeze({});
map = new Map().set(1, 2).set(frozen, 3);
map.clear();
assert.same(map.size, 0, 'Support frozen objects');
assert.false(map.has(1));
assert.false(map.has(frozen));
});
QUnit.test('Map#delete', assert => {
assert.isFunction(Map.prototype.delete);
const object = {};
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 7);
map.set(2, 5);
map.set(1, 4);
map.set(object, 9);
assert.same(map.size, 5);
assert.true(map.delete(NaN));
assert.same(map.size, 4);
assert.false(map.delete(4));
assert.same(map.size, 4);
map.delete([]);
assert.same(map.size, 4);
map.delete(object);
assert.same(map.size, 3);
const frozen = freeze({});
map.set(frozen, 42);
assert.same(map.size, 4);
map.delete(frozen);
assert.same(map.size, 3);
});
QUnit.test('Map#forEach', assert => {
assert.isFunction(Map.prototype.forEach);
let result = {};
let count = 0;
const object = {};
let map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 7);
map.set(2, 5);
map.set(1, 4);
map.set(object, 9);
map.forEach((value, key) => {
count++;
result[value] = key;
});
assert.same(count, 5);
assert.deepEqual(result, {
1: NaN,
7: 3,
5: 2,
4: 1,
9: object,
});
map = new Map();
map.set('0', 9);
map.set('1', 9);
map.set('2', 9);
map.set('3', 9);
result = '';
map.forEach((value, key) => {
result += key;
if (key === '2') {
map.delete('2');
map.delete('3');
map.delete('1');
map.set('4', 9);
}
});
assert.same(result, '0124');
map = new Map([['0', 1]]);
result = '';
map.forEach(it => {
map.delete('0');
if (result !== '') throw new Error();
result += it;
});
assert.same(result, '1');
assert.throws(() => Map.prototype.forEach.call(new Set(), () => { /* empty */ }), 'non-generic');
});
QUnit.test('Map#get', assert => {
assert.isFunction(Map.prototype.get);
const object = {};
const frozen = freeze({});
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(frozen, 42);
map.set(object, object);
assert.same(map.get(NaN), 1);
assert.same(map.get(4), undefined);
assert.same(map.get({}), undefined);
assert.same(map.get(object), object);
assert.same(map.get(frozen), 42);
assert.same(map.get(2), 5);
});
QUnit.test('Map#has', assert => {
assert.isFunction(Map.prototype.has);
const object = {};
const frozen = freeze({});
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(frozen, 42);
map.set(object, object);
assert.true(map.has(NaN));
assert.true(map.has(object));
assert.true(map.has(2));
assert.true(map.has(frozen));
assert.false(map.has(4));
assert.false(map.has({}));
});
QUnit.test('Map#set', assert => {
assert.isFunction(Map.prototype.set);
const object = {};
let map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(object, object);
assert.same(map.size, 5);
const chain = map.set(7, 2);
assert.same(chain, map);
map.set(7, 2);
assert.same(map.size, 6);
assert.same(map.get(7), 2);
assert.same(map.get(NaN), 1);
map.set(NaN, 42);
assert.same(map.size, 6);
assert.same(map.get(NaN), 42);
map.set({}, 11);
assert.same(map.size, 7);
assert.same(map.get(object), object);
map.set(object, 27);
assert.same(map.size, 7);
assert.same(map.get(object), 27);
map = new Map();
map.set(NaN, 2);
map.set(NaN, 3);
map.set(NaN, 4);
assert.same(map.size, 1);
const frozen = freeze({});
map = new Map().set(frozen, 42);
assert.same(map.get(frozen), 42);
});
QUnit.test('Map#size', assert => {
const map = new Map();
map.set(2, 1);
const { size } = map;
assert.same(typeof size, 'number', 'size is number');
assert.same(size, 1, 'size is correct');
if (DESCRIPTORS) {
const sizeDescriptor = getOwnPropertyDescriptor(Map.prototype, 'size');
const getter = sizeDescriptor && sizeDescriptor.get;
const setter = sizeDescriptor && sizeDescriptor.set;
assert.same(typeof getter, 'function', 'size is getter');
assert.same(typeof setter, 'undefined', 'size is not setter');
assert.throws(() => Map.prototype.size, TypeError);
}
});
QUnit.test('Map & -0', assert => {
let map = new Map();
map.set(-0, 1);
assert.same(map.size, 1);
assert.true(map.has(0));
assert.true(map.has(-0));
assert.same(map.get(0), 1);
assert.same(map.get(-0), 1);
map.forEach((val, key) => {
assert.false(is(key, -0));
});
map.delete(-0);
assert.same(map.size, 0);
map = new Map([[-0, 1]]);
map.forEach((val, key) => {
assert.false(is(key, -0));
});
map = new Map();
map.set(4, 4);
map.set(3, 3);
map.set(2, 2);
map.set(1, 1);
map.set(0, 0);
assert.true(map.has(-0));
});
QUnit.test('Map#@@toStringTag', assert => {
assert.same(Map.prototype[Symbol.toStringTag], 'Map', 'Map::@@toStringTag is `Map`');
assert.same(String(new Map()), '[object Map]', 'correct stringification');
});
QUnit.test('Map Iterator', assert => {
const map = new Map();
map.set('a', 1);
map.set('b', 2);
map.set('c', 3);
map.set('d', 4);
const results = [];
const iterator = map.keys();
results.push(iterator.next().value);
assert.true(map.delete('a'));
assert.true(map.delete('b'));
assert.true(map.delete('c'));
map.set('e');
results.push(iterator.next().value, iterator.next().value);
assert.true(iterator.next().done);
map.set('f');
assert.true(iterator.next().done);
assert.deepEqual(results, ['a', 'd', 'e']);
});
QUnit.test('Map#keys', assert => {
assert.isFunction(Map.prototype.keys);
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.keys();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: 'a',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 's',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'd',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#values', assert => {
assert.isFunction(Map.prototype.values);
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.values();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#entries', assert => {
assert.isFunction(Map.prototype.entries);
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.entries();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: ['a', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['s', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['d', 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#@@iterator', assert => {
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = getIterator(map);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Map Iterator');
assert.same(String(iterator), '[object Map Iterator]');
assert.deepEqual(iterator.next(), {
value: ['a', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['s', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['d', '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/es.math.acosh.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import acosh from 'core-js-pure/es/math/acosh';
import EPSILON from 'core-js-pure/es/number/epsilon';
QUnit.test('Math.acosh', assert => {
assert.isFunction(acosh);
assert.same(acosh(NaN), NaN);
assert.same(acosh(0.5), NaN);
assert.same(acosh(-1), NaN);
assert.same(acosh(-1e300), NaN);
assert.same(acosh(1), 0);
assert.same(acosh(Infinity), Infinity);
assert.closeTo(acosh(1234), 7.811163220849231, 1e-11);
assert.closeTo(acosh(8.88), 2.8737631531629235, 1e-11);
assert.closeTo(acosh(1e+160), 369.10676205960726, 1e-11);
assert.closeTo(acosh(Number.MAX_VALUE), 710.475860073944, 1e-11);
assert.closeTo(acosh(1 + EPSILON), 2.1073424255447017e-8, 1e-11);
const checker = createConversionChecker(1234);
assert.closeTo(acosh(checker), 7.811163220849231, 1e-11);
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/es.math.asinh.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import asinh from 'core-js-pure/es/math/asinh';
QUnit.test('Math.asinh', assert => {
assert.isFunction(asinh);
assert.same(asinh(NaN), NaN);
assert.same(asinh(0), 0);
assert.same(asinh(-0), -0);
assert.same(asinh(Infinity), Infinity);
assert.same(asinh(-Infinity), -Infinity);
assert.closeTo(asinh(1234), 7.811163549201245, 1e-11);
assert.closeTo(asinh(9.99), 2.997227420191335, 1e-11);
assert.closeTo(asinh(1e150), 346.0809111296668, 1e-11);
assert.closeTo(asinh(1e7), 16.811242831518268, 1e-11);
assert.closeTo(asinh(-1e7), -16.811242831518268, 1e-11);
const checker = createConversionChecker(1234);
assert.closeTo(asinh(checker), 7.811163549201245, 1e-11);
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/es.math.atanh.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import atanh from 'core-js-pure/es/math/atanh';
QUnit.test('Math.atanh', assert => {
assert.isFunction(atanh);
assert.same(atanh(NaN), NaN);
assert.same(atanh(-2), NaN);
assert.same(atanh(-1.5), NaN);
assert.same(atanh(2), NaN);
assert.same(atanh(1.5), NaN);
assert.same(atanh(-1), -Infinity);
assert.same(atanh(1), Infinity);
assert.same(atanh(0), 0);
assert.same(atanh(-0), -0);
assert.same(atanh(-1e300), NaN);
assert.same(atanh(1e300), NaN);
assert.closeTo(atanh(0.5), 0.5493061443340549, 1e-11);
assert.closeTo(atanh(-0.5), -0.5493061443340549, 1e-11);
assert.closeTo(atanh(0.444), 0.47720201260109457, 1e-11);
assert.closeTo(atanh(1e-10), 1e-10, 1e-25, 'small value 1e-10');
assert.closeTo(atanh(1e-17), 1e-17, 1e-32, 'small value 1e-17');
assert.notSame(atanh(1e-20), 0, 'atanh(1e-20) should not be 0');
const checker = createConversionChecker(0.5);
assert.closeTo(atanh(checker), 0.5493061443340549, 1e-11);
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/es.math.cbrt.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import cbrt from 'core-js-pure/es/math/cbrt';
QUnit.test('Math.cbrt', assert => {
assert.isFunction(cbrt);
assert.same(cbrt(NaN), NaN);
assert.same(cbrt(0), 0);
assert.same(cbrt(-0), -0);
assert.same(cbrt(Infinity), Infinity);
assert.same(cbrt(-Infinity), -Infinity);
assert.same(cbrt(-8), -2);
assert.same(cbrt(8), 2);
assert.closeTo(cbrt(-1000), -10, 1e-11);
assert.closeTo(cbrt(1000), 10, 1e-11);
const checker = createConversionChecker(1000);
assert.closeTo(cbrt(checker), 10, 1e-11);
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/es.math.clz32.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import clz32 from 'core-js-pure/es/math/clz32';
QUnit.test('Math.clz32', assert => {
assert.isFunction(clz32);
assert.same(clz32(0), 32);
assert.same(clz32(1), 31);
assert.same(clz32(-1), 0);
assert.same(clz32(0.6), 32);
assert.same(clz32(2 ** 32 - 1), 0);
assert.same(clz32(2 ** 32), 32);
const checker = createConversionChecker(1);
assert.same(clz32(checker), 31, '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/es.math.cosh.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import cosh from 'core-js-pure/es/math/cosh';
QUnit.test('Math.cosh', assert => {
assert.isFunction(cosh);
assert.same(cosh(NaN), NaN);
assert.same(cosh(0), 1);
assert.same(cosh(-0), 1);
assert.same(cosh(Infinity), Infinity);
assert.same(cosh(-Infinity), Infinity);
assert.closeTo(cosh(12), 81377.395712574, 1e-9);
assert.closeTo(cosh(22), 1792456423.065796, 1e-5);
assert.closeTo(cosh(-10), 11013.232920103323, 1e-11);
assert.closeTo(cosh(-23), 4872401723.124452, 1e-5);
assert.closeTo(cosh(710), 1.1169973830808557e+308, 1e+295);
const checker = createConversionChecker(12);
assert.closeTo(cosh(checker), 81377.395712574, 1e-9, '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/es.math.expm1.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import expm1 from 'core-js-pure/es/math/expm1';
QUnit.test('Math.expm1', assert => {
assert.isFunction(expm1);
assert.same(expm1(NaN), NaN);
assert.same(expm1(0), 0);
assert.same(expm1(-0), -0);
assert.same(expm1(Infinity), Infinity);
assert.same(expm1(-Infinity), -1);
assert.closeTo(expm1(10), 22025.465794806718, 1e-11);
assert.closeTo(expm1(-10), -0.9999546000702375, 1e-11);
const checker = createConversionChecker(10);
assert.closeTo(expm1(checker), 22025.465794806718, 1e-11);
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/es.math.f16round.js
|
JavaScript
|
// some asserts based on https://github.com/petamoriken/float16/blob/master/test/f16round.js
import { createConversionChecker } from '../helpers/helpers.js';
import f16round from 'core-js-pure/es/math/f16round';
const { MAX_VALUE, MIN_VALUE } = Number;
QUnit.test('Math.f16round', assert => {
assert.isFunction(f16round);
assert.name(f16round, 'f16round');
assert.arity(f16round, 1);
assert.same(f16round(), NaN);
assert.same(f16round(undefined), NaN);
assert.same(f16round(NaN), NaN);
assert.same(f16round(null), 0);
assert.same(f16round(0), 0);
assert.same(f16round(-0), -0);
assert.same(f16round(MIN_VALUE), 0);
assert.same(f16round(-MIN_VALUE), -0);
assert.same(f16round(Infinity), Infinity);
assert.same(f16round(-Infinity), -Infinity);
assert.same(f16round(MAX_VALUE), Infinity);
assert.same(f16round(-MAX_VALUE), -Infinity);
const MAX_FLOAT16 = 65504;
const MIN_FLOAT16 = 2 ** -24;
assert.same(f16round(MAX_FLOAT16), MAX_FLOAT16);
assert.same(f16round(-MAX_FLOAT16), -MAX_FLOAT16);
assert.same(f16round(MIN_FLOAT16), MIN_FLOAT16);
assert.same(f16round(-MIN_FLOAT16), -MIN_FLOAT16);
assert.same(f16round(MIN_FLOAT16 / 2), 0);
assert.same(f16round(-MIN_FLOAT16 / 2), -0);
assert.same(f16round(2.980232238769531911744490042422139897126953655970282852649688720703125e-8), MIN_FLOAT16);
assert.same(f16round(-2.980232238769531911744490042422139897126953655970282852649688720703125e-8), -MIN_FLOAT16);
assert.same(f16round(1.337), 1.3369140625);
assert.same(f16round(0.499994), 0.5);
assert.same(f16round(7.9999999), 8);
const checker = createConversionChecker(1.1);
assert.same(f16round(checker), 1.099609375, '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/es.math.fround.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import fround from 'core-js-pure/es/math/fround';
const { MAX_VALUE, MIN_VALUE } = Number;
QUnit.test('Math.fround', assert => {
assert.isFunction(fround);
assert.same(fround(), NaN);
assert.same(fround(undefined), NaN);
assert.same(fround(NaN), NaN);
assert.same(fround(null), 0);
assert.same(fround(0), 0);
assert.same(fround(-0), -0);
assert.same(fround(MIN_VALUE), 0);
assert.same(fround(-MIN_VALUE), -0);
assert.same(fround(Infinity), Infinity);
assert.same(fround(-Infinity), -Infinity);
assert.same(fround(MAX_VALUE), Infinity);
assert.same(fround(-MAX_VALUE), -Infinity);
assert.same(fround(3.4028235677973366e+38), Infinity);
assert.same(fround(3), 3);
assert.same(fround(-3), -3);
const maxFloat32 = 3.4028234663852886e+38;
const minFloat32 = 1.401298464324817e-45;
assert.same(fround(maxFloat32), maxFloat32);
assert.same(fround(-maxFloat32), -maxFloat32);
assert.same(fround(maxFloat32 + 2 ** 102), maxFloat32);
assert.same(fround(minFloat32), minFloat32);
assert.same(fround(-minFloat32), -minFloat32);
assert.same(fround(minFloat32 / 2), 0);
assert.same(fround(-minFloat32 / 2), -0);
assert.same(fround(minFloat32 / 2 + 2 ** -202), minFloat32);
assert.same(fround(-minFloat32 / 2 - 2 ** -202), -minFloat32);
const maxSubnormal32 = 1.1754942106924411e-38;
const minNormal32 = 1.1754943508222875e-38;
assert.same(fround(1.1754942807573642e-38), maxSubnormal32, 'fround(1.1754942807573642e-38)');
assert.same(fround(1.1754942807573643e-38), minNormal32, 'fround(1.1754942807573643e-38)');
assert.same(fround(1.1754942807573644e-38), minNormal32, 'fround(1.1754942807573644e-38)');
assert.same(fround(-1.1754942807573642e-38), -maxSubnormal32, 'fround(-1.1754942807573642e-38)');
assert.same(fround(-1.1754942807573643e-38), -minNormal32, 'fround(-1.1754942807573643e-38)');
assert.same(fround(-1.1754942807573644e-38), -minNormal32, 'fround(-1.1754942807573644e-38)');
const checker = createConversionChecker(1.1754942807573642e-38);
assert.same(fround(checker), maxSubnormal32, '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/es.math.hypot.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import hypot from 'core-js-pure/es/math/hypot';
QUnit.test('Math.hypot', assert => {
const { sqrt } = Math;
assert.isFunction(hypot);
assert.same(hypot(), 0);
assert.same(hypot(1), 1);
assert.same(hypot('', 0), 0);
assert.same(hypot(0, ''), 0);
assert.same(hypot(Infinity, 0), Infinity, 'Infinity, 0');
assert.same(hypot(-Infinity, 0), Infinity, '-Infinity, 0');
assert.same(hypot(0, Infinity), Infinity, '0, Infinity');
assert.same(hypot(0, -Infinity), Infinity, '0, -Infinity');
assert.same(hypot(Infinity, NaN), Infinity, 'Infinity, NaN');
assert.same(hypot(NaN, -Infinity), Infinity, 'NaN, -Infinity');
assert.same(hypot(NaN, 0), NaN, 'NaN, 0');
assert.same(hypot(0, NaN), NaN, '0, NaN');
assert.same(hypot(0, -0), 0);
assert.same(hypot(0, 0), 0);
assert.same(hypot(-0, -0), 0);
assert.same(hypot(-0, 0), 0);
assert.same(hypot(0, 1), 1);
assert.same(hypot(0, -1), 1);
assert.same(hypot(-0, 1), 1);
assert.same(hypot(-0, -1), 1);
assert.same(hypot(0), 0);
assert.same(hypot(1), 1);
assert.same(hypot(2), 2);
assert.same(hypot(0, 0, 1), 1);
assert.same(hypot(0, 1, 0), 1);
assert.same(hypot(1, 0, 0), 1);
assert.same(hypot(2, 3, 4), sqrt(2 ** 2 + 3 ** 2 + 4 ** 2));
assert.same(hypot(2, 3, 4, 5), sqrt(2 ** 2 + 3 ** 2 + 4 ** 2 + 5 ** 2));
assert.closeTo(hypot(66, 66), 93.33809511662427, 1e-11);
assert.closeTo(hypot(0.1, 100), 100.0000499999875, 1e-11);
assert.same(hypot(1e+300, 1e+300), 1.4142135623730952e+300);
assert.same(Math.floor(hypot(1e-300, 1e-300) * 1e308), 141421356);
assert.same(hypot(1e+300, 1e+300, 2, 3), 1.4142135623730952e+300);
assert.same(hypot(-3, 4), 5);
assert.same(hypot(3, -4), 5);
const checker1 = createConversionChecker(2);
const checker2 = createConversionChecker(3);
const checker3 = createConversionChecker(4);
const checker4 = createConversionChecker(5);
assert.same(hypot(checker1, checker2, checker3, checker4), sqrt(2 ** 2 + 3 ** 2 + 4 ** 2 + 5 ** 2), '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');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.math.imul.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import imul from 'core-js-pure/es/math/imul';
QUnit.test('Math.imul', assert => {
assert.isFunction(imul);
assert.same(imul(0, 0), 0);
assert.same(imul(123, 456), 56088);
assert.same(imul(-123, 456), -56088);
assert.same(imul(123, -456), -56088);
assert.same(imul(19088743, 4275878552), 602016552);
assert.same(imul(false, 7), 0);
assert.same(imul(7, false), 0);
assert.same(imul(false, false), 0);
assert.same(imul(true, 7), 7);
assert.same(imul(7, true), 7);
assert.same(imul(true, true), 1);
assert.same(imul(undefined, 7), 0);
assert.same(imul(7, undefined), 0);
assert.same(imul(undefined, undefined), 0);
assert.same(imul('str', 7), 0);
assert.same(imul(7, 'str'), 0);
assert.same(imul({}, 7), 0);
assert.same(imul(7, {}), 0);
assert.same(imul([], 7), 0);
assert.same(imul(7, []), 0);
assert.same(imul(0xFFFFFFFF, 5), -5);
assert.same(imul(0xFFFFFFFE, 5), -10);
assert.same(imul(2, 4), 8);
assert.same(imul(-1, 8), -8);
assert.same(imul(-2, -2), 4);
assert.same(imul(-0, 7), 0);
assert.same(imul(7, -0), 0);
assert.same(imul(0.1, 7), 0);
assert.same(imul(7, 0.1), 0);
assert.same(imul(0.9, 7), 0);
assert.same(imul(7, 0.9), 0);
assert.same(imul(1.1, 7), 7);
assert.same(imul(7, 1.1), 7);
assert.same(imul(1.9, 7), 7);
assert.same(imul(7, 1.9), 7);
const checker1 = createConversionChecker(-123);
const checker2 = createConversionChecker(456);
assert.same(imul(checker1, checker2), -56088, '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');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.math.log10.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import log10 from 'core-js-pure/es/math/log10';
QUnit.test('Math.log10', assert => {
assert.isFunction(log10);
assert.same(log10(''), log10(0));
assert.same(log10(NaN), NaN);
assert.same(log10(-1), NaN);
assert.same(log10(0), -Infinity);
assert.same(log10(-0), -Infinity);
assert.same(log10(1), 0);
assert.same(log10(Infinity), Infinity);
assert.closeTo(log10(0.1), -1, 1e-11);
assert.closeTo(log10(0.5), -0.3010299956639812, 1e-11);
assert.closeTo(log10(1.5), 0.17609125905568124, 1e-11);
assert.closeTo(log10(5), 0.6989700043360189, 1e-11);
assert.closeTo(log10(50), 1.6989700043360187, 1e-11);
assert.closeTo(log10(1000), 3, 1e-11);
const checker = createConversionChecker(0.5);
assert.closeTo(log10(checker), -0.3010299956639812, 1e-11);
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/es.math.log1p.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import log1p from 'core-js-pure/es/math/log1p';
QUnit.test('Math.log1p', assert => {
assert.isFunction(log1p);
assert.same(log1p(''), log1p(0));
assert.same(log1p(NaN), NaN);
assert.same(log1p(-2), NaN);
assert.same(log1p(-1), -Infinity);
assert.same(log1p(0), 0);
assert.same(log1p(-0), -0);
assert.same(log1p(Infinity), Infinity);
assert.closeTo(log1p(5), 1.791759469228055, 1e-11);
assert.closeTo(log1p(50), 3.9318256327243257, 1e-11);
const checker = createConversionChecker(5);
assert.closeTo(log1p(checker), 1.791759469228055, 1e-11);
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/es.math.log2.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import log2 from 'core-js-pure/es/math/log2';
QUnit.test('Math.log2', assert => {
assert.isFunction(log2);
assert.same(log2(''), log2(0));
assert.same(log2(NaN), NaN);
assert.same(log2(-1), NaN);
assert.same(log2(0), -Infinity);
assert.same(log2(-0), -Infinity);
assert.same(log2(1), 0);
assert.same(log2(Infinity), Infinity);
assert.same(log2(0.5), -1);
assert.same(log2(32), 5);
assert.closeTo(log2(5), 2.321928094887362, 1e-11);
const checker = createConversionChecker(5);
assert.closeTo(log2(checker), 2.321928094887362, 1e-11);
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/es.math.sign.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import sign from 'core-js-pure/es/math/sign';
QUnit.test('Math.sign', assert => {
assert.isFunction(sign);
assert.same(sign(NaN), NaN);
assert.same(sign(), NaN);
assert.same(sign(-0), -0);
assert.same(sign(0), 0);
assert.same(sign(Infinity), 1);
assert.same(sign(-Infinity), -1);
assert.same(sign(13510798882111488), 1);
assert.same(sign(-13510798882111488), -1);
assert.same(sign(42.5), 1);
assert.same(sign(-42.5), -1);
const checker = createConversionChecker(-42.5);
assert.same(sign(checker), -1, '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/es.math.sinh.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import sinh from 'core-js-pure/es/math/sinh';
QUnit.test('Math.sinh', assert => {
assert.isFunction(sinh);
assert.same(sinh(NaN), NaN);
assert.same(sinh(0), 0);
assert.same(sinh(-0), -0);
assert.same(sinh(Infinity), Infinity);
assert.same(sinh(-Infinity), -Infinity);
assert.closeTo(sinh(-5), -74.20321057778875, 1e-11);
assert.closeTo(sinh(2), 3.6268604078470186, 1e-11);
assert.same(sinh(-2e-17), -2e-17);
const checker = createConversionChecker(-5);
assert.closeTo(sinh(checker), -74.20321057778875, 1e-11);
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/es.math.sum-precise.js
|
JavaScript
|
/* eslint-disable @stylistic/max-len -- ok */
import sumPrecise from 'core-js-pure/es/math/sum-precise';
import { createIterable } from '../helpers/helpers.js';
QUnit.test('Math.sumPrecise', assert => {
assert.isFunction(sumPrecise);
assert.name(sumPrecise, 'sumPrecise');
assert.arity(sumPrecise, 1);
assert.same(sumPrecise([1, 2, 3]), 6, 'basic');
assert.same(sumPrecise(createIterable([1, 2, 3])), 6, 'custom iterable');
assert.throws(() => sumPrecise(undefined), TypeError, 'undefined');
assert.throws(() => sumPrecise(null), TypeError, 'null');
assert.throws(() => sumPrecise({ 0: 1 }), TypeError, 'non-iterable');
assert.throws(() => sumPrecise(1, 2), TypeError, 'non-iterable #2');
assert.throws(() => sumPrecise([1, '2']), TypeError, 'non-number elements');
// Adapted from https://github.com/tc39/test262
// Copyright (C) 2024 Kevin Gibbons. All rights reserved.
// This code is governed by the BSD license
assert.same(sumPrecise([NaN]), NaN, '[NaN]');
assert.same(sumPrecise([Infinity, -Infinity]), NaN, '[Infinity, -Infinity]');
assert.same(sumPrecise([-Infinity, Infinity]), NaN, '[-Infinity, Infinity]');
assert.same(sumPrecise([Infinity]), Infinity, '[Infinity]');
assert.same(sumPrecise([Infinity, Infinity]), Infinity, '[Infinity, Infinity]');
assert.same(sumPrecise([-Infinity]), -Infinity, '[-Infinity]');
assert.same(sumPrecise([-Infinity, -Infinity]), -Infinity, '[-Infinity, -Infinity]');
assert.same(sumPrecise([]), -0, '[]');
assert.same(sumPrecise([-0]), -0, '[-0]');
assert.same(sumPrecise([-0, -0]), -0, '[-0, -0]');
assert.same(sumPrecise([-0, 0]), 0, '[-0, 0]');
assert.same(sumPrecise([1e308]), 1e308, '[1e308]');
assert.same(sumPrecise([1e308, -1e308]), 0, '[1e308, -1e308]');
assert.same(sumPrecise([0.1]), 0.1, '[0.1]');
assert.same(sumPrecise([0.1, 0.1]), 0.2, '[0.1, 0.1]');
assert.same(sumPrecise([0.1, -0.1]), 0, '[0.1, -0.1]');
assert.same(sumPrecise([1e308, 1e308, 0.1, 0.1, 1e30, 0.1, -1e30, -1e308, -1e308]), 0.30000000000000004, '[1e308, 1e308, 0.1, 0.1, 1e30, 0.1, -1e30, -1e308, -1e308]');
assert.same(sumPrecise([1e30, 0.1, -1e30]), 0.1, '[1e30, 0.1, -1e30]');
assert.same(sumPrecise([8.98846567431158e+307, 8.988465674311579e+307, -Number.MAX_VALUE]), 9.9792015476736e+291, '[8.98846567431158e+307, 8.988465674311579e+307, -Number.MAX_VALUE]');
assert.same(sumPrecise([-5.630637621603525e+255, 9.565271205476345e+307, 2.9937604643020797e+292]), 9.565271205476347e+307, '[-5.630637621603525e+255, 9.565271205476345e+307, 2.9937604643020797e+292]');
assert.same(sumPrecise([6.739986666787661e+66, 2, -1.2689709186578243e-116, 1.7046015739467354e+308, -9.979201547673601e+291, 6.160926733208294e+307, -3.179557053031852e+234, -7.027282978772846e+307, -0.7500000000000001]), 1.61796594939028e+308, '[6.739986666787661e+66, 2, -1.2689709186578243e-116, 1.7046015739467354e+308, -9.979201547673601e+291, 6.160926733208294e+307, -3.179557053031852e+234, -7.027282978772846e+307, -0.7500000000000001]');
assert.same(sumPrecise([0.31150493246968836, -8.988465674311582e+307, 1.8315037361673755e-270, -15.999999999999996, 2.9999999999999996, 7.345200721499384e+164, -2.033582473639399, -8.98846567431158e+307, -3.5737295155405993e+292, 4.13894772383715e-124, -3.6111186457260667e-35, 2.387234887098013e+180, 7.645295562778372e-298, 3.395189016861822e-103, -2.6331611115768973e-149]), -Infinity, '[0.31150493246968836, -8.988465674311582e+307, 1.8315037361673755e-270, -15.999999999999996, 2.9999999999999996, 7.345200721499384e+164, -2.033582473639399, -8.98846567431158e+307, -3.5737295155405993e+292, 4.13894772383715e-124, -3.6111186457260667e-35, 2.387234887098013e+180, 7.645295562778372e-298, 3.395189016861822e-103, -2.6331611115768973e-149]');
assert.same(sumPrecise([-1.1442589134409902e+308, 9.593842098384855e+138, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]), -1.5936821971565685e+308, '[-1.1442589134409902e+308, 9.593842098384855e+138, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]');
assert.same(sumPrecise([-1.1442589134409902e+308, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]), -1.5936821971565687e+308, '[-1.1442589134409902e+308, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]');
assert.same(sumPrecise([9.593842098384855e+138, -6.948356297254111e+307, -1.3482698511467367e+308, 4.494232837155792e+307]), -1.5936821971565685e+308, '[9.593842098384855e+138, -6.948356297254111e+307, -1.3482698511467367e+308, 4.494232837155792e+307]');
assert.same(sumPrecise([-2.534858246857893e+115, 8.988465674311579e+307, 8.98846567431158e+307]), Number.MAX_VALUE, '[-2.534858246857893e+115, 8.988465674311579e+307, 8.98846567431158e+307]');
assert.same(sumPrecise([1.3588124894186193e+308, 1.4803986201152006e+223, 6.741349255733684e+307]), Infinity, '[1.3588124894186193e+308, 1.4803986201152006e+223, 6.741349255733684e+307]');
assert.same(sumPrecise([6.741349255733684e+307, 1.7976931348623155e+308, -7.388327292663961e+41]), Infinity, '[6.741349255733684e+307, 1.7976931348623155e+308, -7.388327292663961e+41]');
assert.same(sumPrecise([-1.9807040628566093e+28, Number.MAX_VALUE, 9.9792015476736e+291]), Number.MAX_VALUE, '[-1.9807040628566093e+28, Number.MAX_VALUE, 9.9792015476736e+291]');
assert.same(sumPrecise([-1.0214557991173964e+61, Number.MAX_VALUE, 8.98846567431158e+307, -8.988465674311579e+307]), Number.MAX_VALUE, '[-1.0214557991173964e+61, Number.MAX_VALUE, 8.98846567431158e+307, -8.988465674311579e+307]');
assert.same(sumPrecise([Number.MAX_VALUE, 7.999999999999999, -1.908963895403937e-230, 1.6445950082320264e+292, 2.0734856707605806e+205]), Infinity, '[Number.MAX_VALUE, 7.999999999999999, -1.908963895403937e-230, 1.6445950082320264e+292, 2.0734856707605806e+205]');
assert.same(sumPrecise([6.197409167220438e-223, -9.979201547673601e+291, -Number.MAX_VALUE]), -Infinity, '[6.197409167220438e-223, -9.979201547673601e+291, -Number.MAX_VALUE]');
assert.same(sumPrecise([4.49423283715579e+307, 8.944251746776101e+307, -0.0002441406250000001, 1.1752060710043817e+308, 4.940846717201632e+292, -1.6836699406454528e+308]), 8.353845887521184e+307, '[4.49423283715579e+307, 8.944251746776101e+307, -0.0002441406250000001, 1.1752060710043817e+308, 4.940846717201632e+292, -1.6836699406454528e+308]');
assert.same(sumPrecise([8.988465674311579e+307, 7.999999999999998, 7.029158107234023e-308, -2.2303483759420562e-172, -Number.MAX_VALUE, -8.98846567431158e+307]), -Number.MAX_VALUE, '8.988465674311579e+307, 7.999999999999998, 7.029158107234023e-308, -2.2303483759420562e-172, -Number.MAX_VALUE, -8.98846567431158e+307]');
assert.same(sumPrecise([8.98846567431158e+307, 8.98846567431158e+307]), Infinity, '[8.98846567431158e+307, 8.98846567431158e+307]');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.math.tanh.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import tanh from 'core-js-pure/es/math/tanh';
QUnit.test('Math.tanh', assert => {
assert.isFunction(tanh);
assert.same(tanh(NaN), NaN);
assert.same(tanh(0), 0);
assert.same(tanh(-0), -0);
assert.same(tanh(Infinity), 1);
assert.same(tanh(90), 1);
assert.closeTo(tanh(10), 0.9999999958776927, 1e-11);
const checker = createConversionChecker(10);
assert.closeTo(tanh(checker), 0.9999999958776927, 1e-11);
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/es.math.trunc.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import trunc from 'core-js-pure/es/math/trunc';
QUnit.test('Math.trunc', assert => {
assert.isFunction(trunc);
assert.same(trunc(NaN), NaN, 'NaN -> NaN');
assert.same(trunc(-0), -0, '-0 -> -0');
assert.same(trunc(0), 0, '0 -> 0');
assert.same(trunc(Infinity), Infinity, 'Infinity -> Infinity');
assert.same(trunc(-Infinity), -Infinity, '-Infinity -> -Infinity');
assert.same(trunc(null), 0, 'null -> 0');
assert.same(trunc({}), NaN, '{} -> NaN');
assert.same(trunc([]), 0, '[] -> 0');
assert.same(trunc(1.01), 1, '1.01 -> 0');
assert.same(trunc(1.99), 1, '1.99 -> 0');
assert.same(trunc(-1), -1, '-1 -> -1');
assert.same(trunc(-1.99), -1, '-1.99 -> -1');
assert.same(trunc(-555.555), -555, '-555.555 -> -555');
assert.same(trunc(9007199254740992), 9007199254740992, '9007199254740992 -> 9007199254740992');
assert.same(trunc(-9007199254740992), -9007199254740992, '-9007199254740992 -> -9007199254740992');
const checker = createConversionChecker(-1.99);
assert.same(trunc(checker), -1, '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/es.number.constructor.js
|
JavaScript
|
/* eslint-disable sonarjs/inconsistent-function-call -- required for testing */
import globalThis from 'core-js-pure/es/global-this';
import create from 'core-js-pure/es/object/create';
import Number from 'core-js-pure/es/number';
import Symbol from 'core-js-pure/es/symbol';
const NativeNumber = globalThis.Number;
const whitespaces = ' \t\u000B\f\u00A0\uFEFF\n\r\u2028\u2029\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000';
function getCheck(assert) {
return function (a, b) {
assert.same(Number(a), b, `Number ${ typeof a } ${ a } -> ${ b }`);
const x = new Number(a);
assert.same(x, Object(x), `new Number ${ typeof a } ${ a } is object`);
assert.same({}.toString.call(x).slice(8, -1), 'Number', `classof new Number ${ typeof a } ${ a } is Number`);
assert.same(x.valueOf(), b, `new Number(${ typeof a } ${ a }).valueOf() -> ${ b }`);
};
}
QUnit.test('Number constructor: regression', assert => {
const check = getCheck(assert);
assert.isFunction(Number);
assert.same(Number.prototype.constructor, NativeNumber);
assert.same(1.0.constructor, NativeNumber);
const constants = ['MAX_VALUE', 'MIN_VALUE', 'NaN', 'NEGATIVE_INFINITY', 'POSITIVE_INFINITY'];
for (const constant of constants) {
assert.true(constant in Number, `Number.${ constant }`);
assert.nonEnumerable(Number, constant);
}
assert.same(Number(), 0);
assert.same(new Number().valueOf(), 0);
check(42, 42);
check(42.42, 42.42);
check(new Number(42), 42);
check(new Number(42.42), 42.42);
check('42', 42);
check('42.42', 42.42);
check('0x42', 66);
check('0X42', 66);
check('0xzzz', NaN);
check('0x1g', NaN);
check('+0x1', NaN);
check('-0x1', NaN);
check('+0X1', NaN);
check('-0X1', NaN);
check(new String('42'), 42);
check(new String('42.42'), 42.42);
check(new String('0x42'), 66);
check(null, 0);
check(undefined, NaN);
check(false, 0);
check(true, 1);
check(new Boolean(false), 0);
check(new Boolean(true), 1);
check({}, NaN);
check({
valueOf: '1.1',
}, NaN);
check({
valueOf: '1.1',
toString() {
return '2.2';
},
}, 2.2);
check({
valueOf() {
return '1.1';
},
}, 1.1);
check({
valueOf() {
return '1.1';
},
toString() {
return '2.2';
},
}, 1.1);
check({
valueOf() {
return '-0x1a2b3c';
},
}, NaN);
check({
toString() {
return '-0x1a2b3c';
},
}, NaN);
check({
valueOf() {
return 42;
},
}, 42);
check({
valueOf() {
return '42';
},
}, 42);
check({
valueOf() {
return null;
},
}, 0);
check({
toString() {
return 42;
},
}, 42);
check({
toString() {
return '42';
},
}, 42);
check({
valueOf() {
return 1;
},
toString() {
return 2;
},
}, 1);
check({
valueOf: 1,
toString() {
return 2;
},
}, 2);
let number = 1;
assert.same(Number({
valueOf() {
return ++number;
},
}), 2, 'Number call valueOf only once #1');
assert.same(number, 2, 'Number call valueOf only once #2');
number = 1;
assert.same(Number({
toString() {
return ++number;
},
}), 2, 'Number call toString only once #1');
assert.same(number, 2, 'Number call toString only once #2');
number = 1;
assert.same(new Number({
valueOf() {
return ++number;
},
}).valueOf(), 2, 'new Number call valueOf only once #1');
assert.same(number, 2, 'new Number call valueOf only once #2');
number = 1;
assert.same(new Number({
toString() {
return ++number;
},
}).valueOf(), 2, 'new Number call toString only once #1');
assert.same(number, 2, 'new Number call toString only once #2');
assert.throws(() => Number(create(null)), TypeError, 'Number assert.throws on object w/o valueOf and toString');
assert.throws(() => Number({
valueOf: 1,
toString: 2,
}), TypeError, 'Number assert.throws on object then valueOf and toString are not functions');
assert.throws(() => new Number(create(null)), TypeError, 'new Number assert.throws on object w/o valueOf and toString');
assert.throws(() => new Number({
valueOf: 1,
toString: 2,
}), TypeError, 'new Number assert.throws on object then valueOf and toString are not functions');
if (typeof Symbol == 'function' && !Symbol.sham) {
const symbol = Symbol('Number constructor test');
assert.throws(() => Number(symbol), 'throws on symbol argument');
assert.throws(() => new Number(symbol), 'throws on symbol argument, new');
}
number = new Number(42);
assert.same(typeof number.constructor(number), 'number');
check(`${ whitespaces }42`, 42);
check(`42${ whitespaces }`, 42);
check(`${ whitespaces }42${ whitespaces }`, 42);
check(`${ whitespaces }0x42`, 66);
check(`0x42${ whitespaces }`, 66);
check(`${ whitespaces }0x42${ whitespaces }`, 66);
check(`${ whitespaces }0X42`, 66);
check(`0X42${ whitespaces }`, 66);
check(`${ whitespaces }0X42${ whitespaces }`, 66);
});
QUnit.test('Number constructor: binary', assert => {
const check = getCheck(assert);
check('0b1', 1);
check('0B1', 1);
check('0b12', NaN);
check('0b234', NaN);
check('0b1!', NaN);
check('+0b1', NaN);
check('-0b1', NaN);
check(' 0b1', 1);
check('0b1\n', 1);
check('\n 0b1\n ', 1);
check(' 0B1', 1);
check('0B1\n', 1);
check('\n 0B1\n ', 1);
check({
valueOf() {
return '0b11';
},
}, 3);
check({
toString() {
return '0b111';
},
}, 7);
check({
valueOf() {
return '0b101010';
},
}, 42);
check({
toString() {
return '0b101010';
},
}, 42);
check(`${ whitespaces }0b11`, 3);
check(`0b11${ whitespaces }`, 3);
check(`${ whitespaces }0b11${ whitespaces }`, 3);
check(`${ whitespaces }0B11`, 3);
check(`0B11${ whitespaces }`, 3);
check(`${ whitespaces }0B11${ whitespaces }`, 3);
});
QUnit.test('Number constructor: octal', assert => {
const check = getCheck(assert);
check('0o7', 7);
check('0O7', 7);
check('0o18', NaN);
check('0o89a', NaN);
check('0o1!', NaN);
check('+0o1', NaN);
check('-0o1', NaN);
check(' 0o1', 1);
check('0o1\n', 1);
check('\n 0o1\n ', 1);
check(' 0O1', 1);
check('0O1\n', 1);
check('\n 0O1\n ', 1);
check({
valueOf() {
return '0o77';
},
}, 63);
check({
toString() {
return '0o777';
},
}, 511);
check({
valueOf() {
return '0o12345';
},
}, 5349);
check({
toString() {
return '0o12345';
},
}, 5349);
check(`${ whitespaces }0o11`, 9);
check(`0o11${ whitespaces }`, 9);
check(`${ whitespaces }0o11${ whitespaces }`, 9);
check(`${ whitespaces }0O11`, 9);
check(`0O11${ whitespaces }`, 9);
check(`${ whitespaces }0O11${ whitespaces }`, 9);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.number.epsilon.js
|
JavaScript
|
import EPSILON from 'core-js-pure/es/number/epsilon';
QUnit.test('Number.EPSILON', assert => {
assert.same(EPSILON, 2 ** -52, 'Is 2^-52');
assert.notSame(1, 1 + EPSILON, '1 is not 1 + EPSILON');
assert.same(1, 1 + EPSILON / 2, '1 is 1 + EPSILON / 2');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.number.is-finite.js
|
JavaScript
|
import create from 'core-js-pure/es/object/create';
import isFinite from 'core-js-pure/es/number/is-finite';
QUnit.test('Number.isFinite', assert => {
assert.isFunction(isFinite);
const finite = [
1,
0.1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
];
for (const value of finite) {
assert.true(isFinite(value), `isFinite ${ typeof value } ${ value }`);
}
const notFinite = [
NaN,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notFinite) {
assert.false(isFinite(value), `not isFinite ${ typeof value } ${ value }`);
}
assert.false(isFinite(create(null)), 'Number.isFinite(Object.create(null)) -> false');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.number.is-integer.js
|
JavaScript
|
import create from 'core-js-pure/es/object/create';
import isInteger from 'core-js-pure/es/number/is-integer';
QUnit.test('Number.isInteger', assert => {
assert.isFunction(isInteger);
const integers = [
1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
];
for (const value of integers) {
assert.true(isInteger(value), `isInteger ${ typeof value } ${ value }`);
}
const notIntegers = [
NaN,
0.1,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notIntegers) {
assert.false(isInteger(value), `not isInteger ${ typeof value } ${ value }`);
}
assert.false(isInteger(create(null)), 'Number.isInteger(Object.create(null)) -> false');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.number.is-nan.js
|
JavaScript
|
import create from 'core-js-pure/es/object/create';
import isNaN from 'core-js-pure/es/number/is-nan';
QUnit.test('Number.isNaN', assert => {
assert.isFunction(isNaN);
assert.true(isNaN(NaN), 'Number.isNaN NaN');
const notNaNs = [
1,
0.1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notNaNs) {
assert.false(isNaN(value), `not Number.isNaN ${ typeof value } ${ value }`);
}
assert.false(isNaN(create(null)), 'Number.isNaN(Object.create(null)) -> false');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-pure/es.number.is-safe-integer.js
|
JavaScript
|
import { MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
import create from 'core-js-pure/es/object/create';
import isSafeInteger from 'core-js-pure/es/number/is-safe-integer';
QUnit.test('Number.isSafeInteger', assert => {
assert.isFunction(isSafeInteger);
const safeIntegers = [
1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
MAX_SAFE_INTEGER,
MIN_SAFE_INTEGER,
];
for (const value of safeIntegers) {
assert.true(isSafeInteger(value), `isSafeInteger ${ typeof value } ${ value }`);
}
const notSafeIntegers = [
MAX_SAFE_INTEGER + 1,
MIN_SAFE_INTEGER - 1,
NaN,
0.1,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notSafeIntegers) {
assert.false(isSafeInteger(value), `not isSafeInteger ${ typeof value } ${ value }`);
}
assert.false(isSafeInteger(create(null)), 'Number.isSafeInteger(Object.create(null)) -> false');
});
|
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.