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-global/es.typed-array.fill.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.fill', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { fill } = TypedArray.prototype;
assert.isFunction(fill, `${ name }::fill is function`);
assert.arity(fill, 1, `${ name }::fill arity is 1`);
assert.name(fill, 'fill', `${ name }::fill name is 'fill'`);
assert.looksNative(fill, `${ name }::fill looks native`);
const array = new TypedArray(5);
assert.same(array.fill(5), array, 'return this');
assert.arrayEqual(new TypedArray(5).fill(5), [5, 5, 5, 5, 5], 'basic');
assert.arrayEqual(new TypedArray(5).fill(5, 1), [0, 5, 5, 5, 5], 'start index');
assert.arrayEqual(new TypedArray(5).fill(5, 1, 4), [0, 5, 5, 5, 0], 'end index');
assert.arrayEqual(new TypedArray(5).fill(5, 6, 1), [0, 0, 0, 0, 0], 'start > end');
assert.arrayEqual(new TypedArray(5).fill(5, -3, 4), [0, 0, 5, 5, 0], 'negative start index');
assert.throws(() => fill.call([0], 1), "isn't generic");
const checker = createConversionChecker(10);
assert.same(new TypedArray(5).fill(checker)[2], 10);
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-global/es.typed-array.filter.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.filter', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { filter } = TypedArray.prototype;
assert.isFunction(filter, `${ name }::filter is function`);
assert.arity(filter, 1, `${ name }::filter arity is 1`);
assert.name(filter, 'filter', `${ name }::filter name is 'filter'`);
assert.looksNative(filter, `${ name }::filter looks native`);
const array = new TypedArray([1]);
const context = {};
array.filter(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);
const instance = new TypedArray([1, 2, 3, 4, 5, 6, 7, 8, 9]).filter(it => it % 2);
assert.true(instance instanceof TypedArray, 'correct instance');
assert.arrayEqual(instance, [1, 3, 5, 7, 9], 'works');
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).filter((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => filter.call([0], () => { /* empty */ }), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.find-index.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.findIndex', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { findIndex } = TypedArray.prototype;
assert.isFunction(findIndex, `${ name }::findIndex is function`);
assert.arity(findIndex, 1, `${ name }::findIndex arity is 1`);
assert.name(findIndex, 'findIndex', `${ name }::findIndex name is 'findIndex'`);
assert.looksNative(findIndex, `${ name }::findIndex looks native`);
const array = new TypedArray([1]);
const context = {};
array.findIndex(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(new TypedArray([1, 2, 3]).findIndex(it => !(it % 2)), 1);
// eslint-disable-next-line unicorn/prefer-array-index-of -- ignore
assert.same(new TypedArray([1, 2, 3]).findIndex(it => it === 4), -1);
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).findIndex((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => findIndex.call([0], () => { /* empty */ }), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.find-last-index.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.findLastIndex', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { findLastIndex } = TypedArray.prototype;
assert.isFunction(findLastIndex, `${ name }::findLastIndex is function`);
assert.arity(findLastIndex, 1, `${ name }::findLastIndex arity is 1`);
assert.name(findLastIndex, 'findLastIndex', `${ name }::findLastIndex name is 'findLastIndex'`);
assert.looksNative(findLastIndex, `${ name }::findLastIndex looks native`);
const array = new TypedArray([1]);
const context = {};
array.findLastIndex(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(new TypedArray([1, 2, 3, 2, 1]).findLastIndex(it => !(it % 2)), 3);
assert.same(new TypedArray([1, 2, 3, 2, 1]).findLastIndex(it => it > 3), -1);
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).findLastIndex((value, key) => {
values += value;
keys += key;
});
assert.same(values, '321');
assert.same(keys, '210');
assert.throws(() => findLastIndex.call([0], () => { /* empty */ }), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.find-last.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.findLast', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { findLast } = TypedArray.prototype;
assert.isFunction(findLast, `${ name }::findLast is function`);
assert.arity(findLast, 1, `${ name }::findLast arity is 1`);
assert.name(findLast, 'findLast', `${ name }::findLast name is 'findLast'`);
assert.looksNative(findLast, `${ name }::findLast looks native`);
const array = new TypedArray([1]);
const context = {};
array.findLast(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(new TypedArray([1, 2, 3, 4, 5]).findLast(it => !(it % 2)), 4);
assert.same(new TypedArray([1, 2, 3, 4, 5]).findLast(it => it === 6), undefined);
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).findLast((value, key) => {
values += value;
keys += key;
});
assert.same(values, '321');
assert.same(keys, '210');
assert.throws(() => findLast.call([0], () => { /* empty */ }), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.find.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.find', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { find } = TypedArray.prototype;
assert.isFunction(find, `${ name }::find is function`);
assert.arity(find, 1, `${ name }::find arity is 1`);
assert.name(find, 'find', `${ name }::find name is 'find'`);
assert.looksNative(find, `${ name }::find looks native`);
const array = new TypedArray([1]);
const context = {};
array.find(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(new TypedArray([1, 2, 3]).find(it => !(it % 2)), 2);
assert.same(new TypedArray([1, 2, 3]).find(it => it === 4), undefined);
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).find((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => find.call([0], () => { /* empty */ }), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.for-each.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.forEach', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { forEach } = TypedArray.prototype;
assert.isFunction(forEach, `${ name }::forEach is function`);
assert.arity(forEach, 1, `${ name }::forEach arity is 1`);
assert.name(forEach, 'forEach', `${ name }::forEach name is 'forEach'`);
assert.looksNative(forEach, `${ name }::forEach looks native`);
const array = new TypedArray([1]);
const context = {};
array.forEach(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(new TypedArray([1, 2, 3]).forEach(it => it % 2), undefined);
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).forEach((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => forEach.call([0], () => { /* empty */ }), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.from.js
|
JavaScript
|
import { DESCRIPTORS, NATIVE, TYPED_ARRAYS_WITH_BIG_INT } from '../helpers/constants.js';
import { createIterable } from '../helpers/helpers.js';
if (DESCRIPTORS) QUnit.test('%TypedArray%.from', assert => {
// we can't implement %TypedArray% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray, $ } of TYPED_ARRAYS_WITH_BIG_INT) {
assert.isFunction(TypedArray.from, `${ name }.from is function`);
assert.arity(TypedArray.from, 1, `${ name }.from arity is 1`);
assert.name(TypedArray.from, 'from', `${ name }.from name is 'from'`);
assert.looksNative(TypedArray.from, `${ name }.from looks native`);
let instance = TypedArray.from([$(1), $(2), $(3)]);
assert.true(instance instanceof TypedArray, 'correct instance with array');
assert.deepEqual(instance, new TypedArray([$(1), $(2), $(3)]), 'correct elements with array');
instance = TypedArray.from({
0: $(1),
1: $(2),
2: $(3),
length: 3,
});
assert.true(instance instanceof TypedArray, 'correct instance with array-like');
assert.deepEqual(instance, new TypedArray([$(1), $(2), $(3)]), 'correct elements with array-like');
instance = TypedArray.from(createIterable([$(1), $(2), $(3)]));
assert.true(instance instanceof TypedArray, 'correct instance with iterable');
assert.deepEqual(instance, new TypedArray([$(1), $(2), $(3)]), 'correct elements with iterable');
assert.deepEqual(TypedArray.from([1, 2, 3], it => String(it ** 2)), new TypedArray([$(1), $(4), $(9)]), 'accept callback');
assert.deepEqual(TypedArray.from([{ valueOf() { return $(2); } }]), new TypedArray([$(2)]), 'passed array with object convertible to primitive');
assert.deepEqual(TypedArray.from(createIterable([{ valueOf() { return $(2); } }])), new TypedArray([$(2)]), 'passed iterable with object convertible to primitive');
const context = {};
TypedArray.from([$(1)], function (value, key) {
assert.same(arguments.length, 2, 'correct number of callback arguments');
assert.same(value, $(1), 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(this, context, 'correct callback context');
return $(1);
}, context);
assert.throws(() => TypedArray.from.call(undefined, []), "isn't generic #1");
if (NATIVE) {
assert.throws(() => TypedArray.from.call(Array, []), "isn't generic #2");
assert.notThrows(() => TypedArray.from({
0: $(1),
length: -1,
}, () => {
throw new Error();
}), 'uses ToLength');
}
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.includes.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.includes', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { includes } = TypedArray.prototype;
assert.isFunction(includes, `${ name }::includes is function`);
assert.arity(includes, 1, `${ name }::includes arity is 1`);
assert.name(includes, 'includes', `${ name }::includes name is 'includes'`);
assert.looksNative(includes, `${ name }::includes looks native`);
assert.true(new TypedArray([1, 1, 1]).includes(1));
assert.false(new TypedArray([1, 2, 3]).includes(1, 1));
assert.true(new TypedArray([1, 2, 3]).includes(2, 1));
assert.false(new TypedArray([1, 2, 3]).includes(2, -1));
assert.true(new TypedArray([1, 2, 3]).includes(2, -2));
assert.throws(() => includes.call([1], 1), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.index-of.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.indexOf', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { indexOf } = TypedArray.prototype;
assert.isFunction(indexOf, `${ name }::indexOf is function`);
assert.arity(indexOf, 1, `${ name }::indexOf arity is 1`);
assert.name(indexOf, 'indexOf', `${ name }::indexOf name is 'indexOf'`);
assert.looksNative(indexOf, `${ name }::indexOf looks native`);
assert.same(new TypedArray([1, 1, 1]).indexOf(1), 0);
assert.same(new TypedArray([1, 2, 3]).indexOf(1, 1), -1);
assert.same(new TypedArray([1, 2, 3]).indexOf(2, 1), 1);
assert.same(new TypedArray([1, 2, 3]).indexOf(2, -1), -1);
assert.same(new TypedArray([1, 2, 3]).indexOf(2, -2), 1);
assert.throws(() => indexOf.call([1], 1), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.iterator.js
|
JavaScript
|
import { DESCRIPTORS, GLOBAL, NATIVE, TYPED_ARRAYS } from '../helpers/constants.js';
const Symbol = GLOBAL.Symbol || {};
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.keys', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { keys } = TypedArray.prototype;
assert.isFunction(keys, `${ name }::keys is function`);
assert.arity(keys, 0, `${ name }::keys arity is 0`);
assert.name(keys, 'keys', `${ name }::keys name is 'keys'`);
assert.looksNative(keys, `${ name }::keys looks native`);
const iterator = new TypedArray([1, 2, 3]).keys();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 0,
done: false,
}, 'step 1');
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
}, 'step 2');
assert.deepEqual(iterator.next(), {
value: 2,
done: false,
}, 'step 3');
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
}, 'done');
if (NATIVE) assert.throws(() => keys.call([1, 2]), "isn't generic");
}
});
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.values', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { values } = TypedArray.prototype;
assert.isFunction(values, `${ name }::values is function`);
assert.arity(values, 0, `${ name }::values arity is 0`);
assert.name(values, 'values', `${ name }::values name is 'values'`);
assert.looksNative(values, `${ name }::values looks native`);
const iterator = new TypedArray([1, 2, 3]).values();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
}, 'step 1');
assert.deepEqual(iterator.next(), {
value: 2,
done: false,
}, 'step 2');
assert.deepEqual(iterator.next(), {
value: 3,
done: false,
}, 'step 3');
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
}, 'done');
if (NATIVE) assert.throws(() => values.call([1, 2]), "isn't generic");
}
});
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.entries', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { entries } = TypedArray.prototype;
assert.isFunction(entries, `${ name }::entries is function`);
assert.arity(entries, 0, `${ name }::entries arity is 0`);
assert.name(entries, 'entries', `${ name }::entries name is 'entries'`);
assert.looksNative(entries, `${ name }::entries looks native`);
const iterator = new TypedArray([1, 2, 3]).entries();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: [0, 1],
done: false,
}, 'step 1');
assert.deepEqual(iterator.next(), {
value: [1, 2],
done: false,
}, 'step 2');
assert.deepEqual(iterator.next(), {
value: [2, 3],
done: false,
}, 'step 3');
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
}, 'done');
if (NATIVE) assert.throws(() => entries.call([1, 2]), "isn't generic");
}
});
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.@@iterator', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
assert.isIterable(TypedArray.prototype, `${ name } is iterable`);
assert.arity(TypedArray.prototype[Symbol.iterator], 0, `${ name }::@@iterator arity is 0`);
assert.name(TypedArray.prototype[Symbol.iterator], 'values', `${ name }::@@iterator name is 'values'`);
assert.looksNative(TypedArray.prototype[Symbol.iterator], `${ name }::@@iterator looks native`);
assert.same(TypedArray.prototype[Symbol.iterator], TypedArray.prototype.values);
const iterator = new TypedArray([1, 2, 3])[Symbol.iterator]();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
}, 'step 1');
assert.deepEqual(iterator.next(), {
value: 2,
done: false,
}, 'step 2');
assert.deepEqual(iterator.next(), {
value: 3,
done: false,
}, 'step 3');
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
}, 'done');
if (NATIVE) assert.throws(() => TypedArray.prototype[Symbol.iterator].call([1, 2]), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.join.js
|
JavaScript
|
/* eslint-disable unicorn/require-array-join-separator -- required for testing */
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.join', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { join } = TypedArray.prototype;
assert.isFunction(join, `${ name }::join is function`);
assert.arity(join, 1, `${ name }::join arity is 1`);
assert.name(join, 'join', `${ name }::join name is 'join'`);
assert.looksNative(join, `${ name }::join looks native`);
assert.same(new TypedArray([1, 2, 3]).join('|'), '1|2|3', 'works #1');
assert.same(new TypedArray([1, 2, 3]).join(), '1,2,3', 'works #2');
assert.throws(() => join.call([1, 2, 3]), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.last-index-of.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.lastIndexOf', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { lastIndexOf } = TypedArray.prototype;
assert.isFunction(lastIndexOf, `${ name }::lastIndexOf is function`);
assert.arity(lastIndexOf, 1, `${ name }::lastIndexOf arity is 1`);
assert.name(lastIndexOf, 'lastIndexOf', `${ name }::lastIndexOf name is 'lastIndexOf'`);
assert.looksNative(lastIndexOf, `${ name }::lastIndexOf looks native`);
assert.same(new TypedArray([1, 1, 1]).lastIndexOf(1), 2);
assert.same(new TypedArray([1, 2, 3]).lastIndexOf(3, 1), -1);
assert.same(new TypedArray([1, 2, 3]).lastIndexOf(2, 1), 1);
assert.same(new TypedArray([1, 2, 3]).lastIndexOf(2, -3), -1);
assert.same(new TypedArray([1, 2, 3]).lastIndexOf(2, -2), 1);
assert.throws(() => lastIndexOf.call([1], 1), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.map.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.map', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { map } = TypedArray.prototype;
assert.isFunction(map, `${ name }::map is function`);
assert.arity(map, 1, `${ name }::map arity is 1`);
assert.name(map, 'map', `${ name }::map name is 'map'`);
assert.looksNative(map, `${ name }::map looks native`);
const array = new TypedArray([1]);
const context = {};
array.map(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);
const instance = new TypedArray([1, 2, 3, 4, 5]).map(it => it * 2);
assert.true(instance instanceof TypedArray, 'correct instance');
assert.arrayEqual(instance, [2, 4, 6, 8, 10], 'works');
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).map((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => map.call([0], () => { /* empty */ }), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.of.js
|
JavaScript
|
import { DESCRIPTORS, NATIVE, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArray%.of', assert => {
// we can't implement %TypedArray% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
assert.isFunction(TypedArray.of, `${ name }.of is function`);
assert.arity(TypedArray.of, 0, `${ name }.of arity is 0`);
assert.name(TypedArray.of, 'of', `${ name }.of name is 'of'`);
assert.looksNative(TypedArray.of, `${ name }.of looks native`);
let instance = TypedArray.of();
assert.true(instance instanceof TypedArray, 'correct instance with 0 arguments');
assert.arrayEqual(instance, [], 'correct elements with 0 arguments');
instance = TypedArray.of(1);
assert.true(instance instanceof TypedArray, 'correct instance with 1 argument');
assert.arrayEqual(instance, [1], 'correct elements with 1 argument');
instance = TypedArray.of(1, 2, 3);
assert.true(instance instanceof TypedArray, 'correct instance with several arguments');
assert.arrayEqual(instance, [1, 2, 3], 'correct elements with several arguments');
assert.throws(() => TypedArray.of.call(undefined, 1), "isn't generic #1");
if (NATIVE) assert.throws(() => TypedArray.of.call(Array, 1), "isn't generic #2");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.reduce-right.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.reduceRight', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { reduceRight } = TypedArray.prototype;
assert.isFunction(reduceRight, `${ name }::reduceRight is function`);
assert.arity(reduceRight, 1, `${ name }::reduceRight arity is 1`);
assert.name(reduceRight, 'reduceRight', `${ name }::reduceRight name is 'reduceRight'`);
assert.looksNative(reduceRight, `${ name }::reduceRight looks native`);
const array = new TypedArray([1]);
const accumulator = {};
array.reduceRight(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(new TypedArray([1, 2, 3]).reduceRight((a, b) => a + b, 1), 7, 'works with initial accumulator');
new TypedArray([1, 2]).reduceRight((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(new TypedArray([1, 2, 3]).reduceRight((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).reduceRight((memo, value, key) => {
values += value;
keys += key;
}, 0);
assert.same(values, '321', 'correct order #1');
assert.same(keys, '210', 'correct order #2');
assert.throws(() => reduceRight.call([0], () => { /* empty */ }), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.reduce.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.reduce', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { reduce } = TypedArray.prototype;
assert.isFunction(reduce, `${ name }::reduce is function`);
assert.arity(reduce, 1, `${ name }::reduce arity is 1`);
assert.name(reduce, 'reduce', `${ name }::reduce name is 'reduce'`);
assert.looksNative(reduce, `${ name }::reduce looks native`);
const array = new TypedArray([1]);
const accumulator = {};
array.reduce(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
}, accumulator);
assert.same(new TypedArray([1, 2, 3]).reduce((a, b) => a + b, 1), 7, 'works with initial accumulator');
new TypedArray([1, 2]).reduce((memo, value, key) => {
assert.same(memo, 1, 'correct default accumulator');
assert.same(value, 2, 'correct start value without initial accumulator');
assert.same(key, 1, 'correct start index without initial accumulator');
});
assert.same(new TypedArray([1, 2, 3]).reduce((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).reduce((memo, value, key) => {
values += value;
keys += key;
}, 0);
assert.same(values, '123', 'correct order #1');
assert.same(keys, '012', 'correct order #2');
assert.throws(() => reduce.call([0], () => { /* empty */ }), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.reverse.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.reverse', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { reverse } = TypedArray.prototype;
assert.isFunction(reverse, `${ name }::reverse is function`);
assert.arity(reverse, 0, `${ name }::reverse arity is 0`);
assert.name(reverse, 'reverse', `${ name }::reverse name is 'reverse'`);
assert.looksNative(reverse, `${ name }::reverse looks native`);
const array = new TypedArray([1, 2]);
assert.same(array.reverse(), array, 'return this');
assert.arrayEqual(new TypedArray([1, 2, 3, 4]).reverse(), [4, 3, 2, 1], 'works #1');
assert.arrayEqual(new TypedArray([1, 2, 3]).reverse(), [3, 2, 1], 'works #2');
assert.throws(() => reverse.call([1, 2]), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.set.js
|
JavaScript
|
import { DESCRIPTORS, NATIVE, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.set', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { set } = TypedArray.prototype;
assert.isFunction(set, `${ name }::set is function`);
if (NATIVE) assert.arity(set, 1, `${ name }::set arity is 1`);
assert.name(set, 'set', `${ name }::set name is 'set'`);
assert.looksNative(set, `${ name }::set looks native`);
assert.same(new TypedArray(1).set([1]), undefined, 'void');
const array1 = new TypedArray([1, 2, 3, 4, 5]);
const array2 = new TypedArray(5);
array2.set(array1);
assert.arrayEqual(array2, [1, 2, 3, 4, 5]);
assert.throws(() => array2.set(array1, 1));
assert.throws(() => array2.set(array1, -1));
array2.set(new TypedArray([99, 98]), 2);
assert.arrayEqual(array2, [1, 2, 99, 98, 5]);
array2.set(new TypedArray([99, 98, 97]), 2);
assert.arrayEqual(array2, [1, 2, 99, 98, 97]);
assert.throws(() => array2.set(new TypedArray([99, 98, 97, 96]), 2));
assert.throws(() => array2.set([101, 102, 103, 104], 4));
const array3 = new TypedArray(2);
assert.notThrows(() => array3.set({ length: 2, 0: 1, 1: 2 }), 'set array-like #1');
assert.arrayEqual(array3, [1, 2], 'set array-like #2');
assert.notThrows(() => array3.set('34'), 'set string #1');
assert.arrayEqual(array3, [3, 4], 'set string #2');
assert.notThrows(() => array3.set(1), 'set number #1');
assert.arrayEqual(array3, [3, 4], 'set number #2');
assert.throws(() => set.call([1, 2, 3], [1]), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.slice.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.slice', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { slice } = TypedArray.prototype;
assert.isFunction(slice, `${ name }::slice is function`);
assert.arity(slice, 2, `${ name }::slice arity is 0`);
assert.name(slice, 'slice', `${ name }::slice name is 'slice'`);
assert.looksNative(slice, `${ name }::slice looks native`);
const array = new TypedArray([1, 2, 3, 4, 5]);
assert.notSame(array.slice(), array, 'returns new array');
assert.true(array.slice() instanceof TypedArray, 'correct instance');
assert.notSame(array.slice().buffer, array.buffer, 'with new buffer');
assert.arrayEqual(array.slice(), array);
assert.arrayEqual(array.slice(1, 3), [2, 3]);
assert.arrayEqual(array.slice(1, undefined), [2, 3, 4, 5]);
assert.arrayEqual(array.slice(1, -1), [2, 3, 4]);
assert.arrayEqual(array.slice(-2, -1), [4]);
assert.arrayEqual(array.slice(-2, -3), []);
assert.throws(() => slice.call([1, 2], 1), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.some.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.some', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { some } = TypedArray.prototype;
assert.isFunction(some, `${ name }::some is function`);
assert.arity(some, 1, `${ name }::some arity is 1`);
assert.name(some, 'some', `${ name }::some name is 'some'`);
assert.looksNative(some, `${ name }::some looks native`);
const array = new TypedArray([1]);
const context = {};
array.some(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 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(new TypedArray([1, 2, 3]).some(it => typeof it == 'number'));
assert.true(new TypedArray([1, 2, 3]).some(it => it < 3));
assert.false(new TypedArray([1, 2, 3]).some(it => it < 0));
assert.false(new TypedArray([1, 2, 3]).some(it => typeof it == 'string'));
assert.true(new TypedArray([1, 2, 3]).some(function () {
return +this === 1;
}, 1));
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).some((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => some.call([0], () => { /* empty */ }), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.sort.js
|
JavaScript
|
import { DESCRIPTORS, STRICT, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.sort', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { sort } = TypedArray.prototype;
assert.isFunction(sort, `${ name }::sort is function`);
assert.arity(sort, 1, `${ name }::sort arity is 1`);
assert.name(sort, 'sort', `${ name }::sort name is 'sort'`);
assert.looksNative(sort, `${ name }::sort looks native`);
if (name.indexOf('Float') === 0) {
assert.deepEqual(new TypedArray([1, -1, 3, NaN, 2, 0, 11, -0]).sort(), new TypedArray([-1, -0, 0, 1, 2, 3, 11, NaN]), '#1');
assert.true(1 / new TypedArray([0, -0]).sort()[0] < 0, '-0');
assert.deepEqual(new TypedArray([NaN, 1, NaN]).sort(), new TypedArray([1, NaN, NaN]), 'NaN');
}
if (name.indexOf('8') === -1) {
const expected = Array(516);
let array = new TypedArray(516);
let index, mod, j, k, postfix;
for (index = 0; index < 516; index++) {
mod = index % 4;
array[index] = 515 - index;
expected[index] = index - 2 * mod + 3;
}
array.sort((a, b) => (a / 4 | 0) - (b / 4 | 0));
assert.same(String(array), String(expected), 'stable #1');
let result = '';
array = new TypedArray(520);
index = 0;
for (j = 0; j < 10; j++) {
switch (j) {
case 1: case 4: case 5: case 7: postfix = 3; break;
case 3: case 6: postfix = 4; break;
default: postfix = 2;
}
for (k = 0; k < 52; k++) {
array[index] = 10 * index++ + postfix;
}
}
array.sort((a, b) => b % 10 - a % 10);
for (index = 0; index < array.length; index++) {
j = String((array[index] / 520) | 0);
if (result.charAt(result.length - 1) !== j) result += j;
}
assert.same(result, '3614570289', 'stable #2');
}
assert.throws(() => sort.call([0], () => { /* empty */ }), "isn't generic");
assert.notThrows(() => new TypedArray([1, 2, 3]).sort(undefined).length === 3, 'works with undefined');
assert.throws(() => new TypedArray([1, 2, 3]).sort(null), 'throws on null');
assert.throws(() => new TypedArray([1, 2, 3]).sort({}), 'throws on {}');
if (STRICT) {
assert.throws(() => sort.call(null), TypeError, 'ToObject(this)');
assert.throws(() => sort.call(undefined), TypeError, 'ToObject(this)');
}
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.subarray.js
|
JavaScript
|
import { DESCRIPTORS, NATIVE, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.subarray', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { subarray } = TypedArray.prototype;
assert.isFunction(subarray, `${ name }::subarray is function`);
if (NATIVE) assert.arity(subarray, 2, `${ name }::subarray arity is 2`);
assert.name(subarray, 'subarray', `${ name }::subarray name is 'subarray'`);
assert.looksNative(subarray, `${ name }::subarray looks native`);
const array1 = new TypedArray([1, 2, 3, 4, 5]);
const array2 = array1.subarray(3);
assert.notSame(array1, array2, 'creates new array');
assert.true(array2 instanceof TypedArray, `instance ${ name }`);
assert.same(array1.buffer, array2.buffer, 'with the same buffer');
assert.arrayEqual(array2, [4, 5]);
assert.arrayEqual(array1.subarray(1, 3), [2, 3]);
assert.arrayEqual(array1.subarray(-3), [3, 4, 5]);
assert.arrayEqual(array1.subarray(-3, -1), [3, 4]);
assert.arrayEqual(array1.subarray(3, 2), []);
assert.arrayEqual(array1.subarray(-2, -3), []);
assert.arrayEqual(array1.subarray(4, 1), []);
assert.arrayEqual(array1.subarray(-1, -4), []);
assert.arrayEqual(array1.subarray(1).subarray(1), [3, 4, 5]);
assert.arrayEqual(array1.subarray(1, 4).subarray(1, 2), [3]);
assert.throws(() => subarray.call([1, 2, 3], 1), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.to-locale-string.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.toLocaleString', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { toLocaleString } = TypedArray.prototype;
assert.isFunction(toLocaleString, `${ name }::toLocaleString is function`);
assert.arity(toLocaleString, 0, `${ name }::toLocaleString arity is 0`);
assert.name(toLocaleString, 'toLocaleString', `${ name }::toLocaleString name is 'toLocaleString'`);
assert.looksNative(toLocaleString, `${ name }::toLocaleString looks native`);
assert.same(new TypedArray([1, 2, 3]).toLocaleString(), [1, 2, 3].toLocaleString(), 'works');
assert.throws(() => toLocaleString.call([1, 2, 3]), "isn't generic");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.to-reversed.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS_WITH_BIG_INT } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.toReversed', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray, $ } of TYPED_ARRAYS_WITH_BIG_INT) {
const { toReversed } = TypedArray.prototype;
assert.isFunction(toReversed, `${ name }::toReversed is function`);
assert.arity(toReversed, 0, `${ name }::toReversed arity is 0`);
assert.name(toReversed, 'toReversed', `${ name }::toReversed name is 'toReversed'`);
assert.looksNative(toReversed, `${ name }::toReversed looks native`);
const array = new TypedArray([$(1), $(2)]);
assert.notSame(array.toReversed(), array, 'immutable');
assert.deepEqual(new TypedArray([$(1), $(2), $(3), $(4)]).toReversed(), new TypedArray([$(4), $(3), $(2), $(1)]), 'works #1');
assert.deepEqual(new TypedArray([$(1), $(2), $(3)]).toReversed(), new TypedArray([$(3), $(2), $(1)]), 'works #2');
assert.throws(() => toReversed.call(null), TypeError, "isn't generic #1");
assert.throws(() => toReversed.call(undefined), TypeError, "isn't generic #2");
assert.throws(() => toReversed.call([$(1), $(2)]), TypeError, "isn't generic #3");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.to-sorted.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.toSorted', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { toSorted } = TypedArray.prototype;
assert.isFunction(toSorted, `${ name }::toSorted is function`);
assert.arity(toSorted, 1, `${ name }::toSorted arity is 1`);
assert.name(toSorted, 'toSorted', `${ name }::toSorted name is 'toSorted'`);
assert.looksNative(toSorted, `${ name }::toSorted looks native`);
let array = new TypedArray([1]);
assert.notSame(array.toSorted(), array, 'immutable');
if (name.indexOf('Float') === 0) {
assert.deepEqual(new TypedArray([1, -1, 3, NaN, 2, 0, 11, -0]).toSorted(), new TypedArray([-1, -0, 0, 1, 2, 3, 11, NaN]), '#1');
assert.true(1 / new TypedArray([0, -0]).toSorted()[0] < 0, '-0');
assert.deepEqual(new TypedArray([NaN, 1, NaN]).toSorted(), new TypedArray([1, NaN, NaN]), 'NaN');
}
if (name.indexOf('8') === -1) {
const expected = Array(516);
array = new TypedArray(516);
let index, mod, j, k, postfix;
for (index = 0; index < 516; index++) {
mod = index % 4;
array[index] = 515 - index;
expected[index] = index - 2 * mod + 3;
}
array = array.toSorted((a, b) => (a / 4 | 0) - (b / 4 | 0));
assert.arrayEqual(array, expected, 'stable #1');
let result = '';
array = new TypedArray(520);
index = 0;
for (j = 0; j < 10; j++) {
switch (j) {
case 1: case 4: case 5: case 7: postfix = 3; break;
case 3: case 6: postfix = 4; break;
default: postfix = 2;
}
for (k = 0; k < 52; k++) {
array[index] = 10 * index++ + postfix;
}
}
array = array.toSorted((a, b) => b % 10 - a % 10);
for (index = 0; index < array.length; index++) {
j = String((array[index] / 520) | 0);
if (result.charAt(result.length - 1) !== j) result += j;
}
assert.same(result, '3614570289', 'stable #2');
}
assert.notThrows(() => new TypedArray([1, 2, 3]).toSorted(undefined).length === 3, 'works with undefined');
assert.throws(() => new TypedArray([1, 2, 3]).toSorted(null), 'throws on null');
assert.throws(() => new TypedArray([1, 2, 3]).toSorted({}), 'throws on {}');
assert.throws(() => toSorted.call(null), TypeError, "isn't generic #1");
assert.throws(() => toSorted.call(undefined), TypeError, "isn't generic #2");
assert.throws(() => toSorted.call([1, 2]), TypeError, "isn't generic #3");
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.to-string.js
|
JavaScript
|
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.toString', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { toString } = TypedArray.prototype;
assert.isFunction(toString, `${ name }::toString is function`);
assert.arity(toString, 0, `${ name }::toString arity is 0`);
assert.name(toString, 'toString', `${ name }::toString name is 'toString'`);
assert.looksNative(toString, `${ name }::toString looks native`);
assert.same(new TypedArray([1, 2, 3]).toString(), '1,2,3', 'works');
assert.same(toString.call([1, 2, 3]), '1,2,3', 'generic');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed-array.with.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
import { DESCRIPTORS, TYPED_ARRAYS_WITH_BIG_INT } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.with', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray, $ } of TYPED_ARRAYS_WITH_BIG_INT) {
const { with: withAt } = TypedArray.prototype;
assert.isFunction(withAt, `${ name }::with is function`);
assert.arity(withAt, 2, `${ name }::with arity is 0`);
// assert.name(withAt, 'with', `${ name }::with name is 'with'`);
assert.looksNative(withAt, `${ name }::with looks native`);
const array = new TypedArray([$(1), $(2), $(3), $(4), $(5)]);
assert.notSame(array.with(2, $(1)), array, 'immutable');
assert.deepEqual(new TypedArray([$(1), $(2), $(3), $(4), $(5)]).with(2, $(6)), new TypedArray([$(1), $(2), $(6), $(4), $(5)]));
assert.deepEqual(new TypedArray([$(1), $(2), $(3), $(4), $(5)]).with(-2, $(6)), new TypedArray([$(1), $(2), $(3), $(6), $(5)]));
assert.deepEqual(new TypedArray([$(1), $(2), $(3), $(4), $(5)]).with('1', $(6)), new TypedArray([$(1), $(6), $(3), $(4), $(5)]));
assert.throws(() => new TypedArray([$(1), $(2), $(3), $(4), $(5)]).with(5, $(6)), RangeError);
assert.throws(() => new TypedArray([$(1), $(2), $(3), $(4), $(5)]).with(-6, $(6)), RangeError);
assert.throws(() => withAt.call(null, 1, $(2)), TypeError, "isn't generic #1");
assert.throws(() => withAt.call(undefined, 1, $(2)), TypeError, "isn't generic #2");
assert.throws(() => withAt.call([1, 2], 1, $(3)), TypeError, "isn't generic #3");
const checker = createConversionChecker($(10));
assert.same(new TypedArray(5).with(2, checker)[2], $(10));
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
assert.true(!!function () {
try {
new TypedArray(1).with(2, { valueOf() { throw 8; } });
} catch (error) {
// some early implementations, like WebKit, does not follow the final semantic
// https://github.com/tc39/proposal-change-array-by-copy/pull/86
return error === 8;
}
}(), 'proper order of operations');
// WebKit doesn't handle this correctly. It should truncate a negative fractional index to zero, but instead throws an error
assert.same(new TypedArray(1).with(-0.5, $(1))[0], $(1));
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed.conversions.float32.js
|
JavaScript
|
import { DESCRIPTORS, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Float32 conversions', assert => {
const float32array = new Float32Array(1);
const uint8array = new Uint8Array(float32array.buffer);
const dataview = new DataView(float32array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0, 0, 0, 0]],
[-0, -0, [0, 0, 0, 128]],
[1, 1, [0, 0, 128, 63]],
[-1, -1, [0, 0, 128, 191]],
[1.1, 1.100000023841858, [205, 204, 140, 63]],
[-1.1, -1.100000023841858, [205, 204, 140, 191]],
[1.9, 1.899999976158142, [51, 51, 243, 63]],
[-1.9, -1.899999976158142, [51, 51, 243, 191]],
[127, 127, [0, 0, 254, 66]],
[-127, -127, [0, 0, 254, 194]],
[128, 128, [0, 0, 0, 67]],
[-128, -128, [0, 0, 0, 195]],
[255, 255, [0, 0, 127, 67]],
[-255, -255, [0, 0, 127, 195]],
// eslint-disable-next-line no-loss-of-precision -- false positive
[255.1, 255.10000610351562, [154, 25, 127, 67]],
[255.9, 255.89999389648438, [102, 230, 127, 67]],
[256, 256, [0, 0, 128, 67]],
[32767, 32767, [0, 254, 255, 70]],
[-32767, -32767, [0, 254, 255, 198]],
[32768, 32768, [0, 0, 0, 71]],
[-32768, -32768, [0, 0, 0, 199]],
[65535, 65535, [0, 255, 127, 71]],
[65536, 65536, [0, 0, 128, 71]],
[65537, 65537, [128, 0, 128, 71]],
[65536.54321, 65536.546875, [70, 0, 128, 71]],
[-65536.54321, -65536.546875, [70, 0, 128, 199]],
[2147483647, 2147483648, [0, 0, 0, 79]],
[-2147483647, -2147483648, [0, 0, 0, 207]],
[2147483648, 2147483648, [0, 0, 0, 79]],
[-2147483648, -2147483648, [0, 0, 0, 207]],
[2147483649, 2147483648, [0, 0, 0, 79]],
[-2147483649, -2147483648, [0, 0, 0, 207]],
[4294967295, 4294967296, [0, 0, 128, 79]],
[4294967296, 4294967296, [0, 0, 128, 79]],
[4294967297, 4294967296, [0, 0, 128, 79]],
[MAX_SAFE_INTEGER, MAX_SAFE_INTEGER + 1, [0, 0, 0, 90]],
[MIN_SAFE_INTEGER, MIN_SAFE_INTEGER - 1, [0, 0, 0, 218]],
[MAX_SAFE_INTEGER + 1, MAX_SAFE_INTEGER + 1, [0, 0, 0, 90]],
[MIN_SAFE_INTEGER - 1, MIN_SAFE_INTEGER - 1, [0, 0, 0, 218]],
[MAX_SAFE_INTEGER + 3, MAX_SAFE_INTEGER + 1, [0, 0, 0, 90]],
[MIN_SAFE_INTEGER - 3, MIN_SAFE_INTEGER - 1, [0, 0, 0, 218]],
[Infinity, Infinity, [0, 0, 128, 127]],
[-Infinity, -Infinity, [0, 0, 128, 255]],
[Number.MAX_VALUE, Infinity, [0, 0, 128, 127]],
[-Number.MAX_VALUE, -Infinity, [0, 0, 128, 255]],
[Number.MIN_VALUE, 0, [0, 0, 0, 0]],
[-Number.MIN_VALUE, -0, [0, 0, 0, 128]],
];
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
float32array[0] = value;
assert.same(float32array[0], conversion, `Float32Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Float32Array ${ toString(value) } -> [${ representation }]`);
dataview.setFloat32(0, value);
assert.arrayEqual(uint8array, big, `dataview.setFloat32(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getFloat32(0), conversion, `dataview{${ big }}.getFloat32(0) -> ${ toString(conversion) }`);
dataview.setFloat32(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setFloat32(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getFloat32(0, false), conversion, `dataview{${ big }}.getFloat32(0, false) -> ${ toString(conversion) }`);
dataview.setFloat32(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setFloat32(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getFloat32(0, true), conversion, `dataview{${ little }}.getFloat32(0, true) -> ${ toString(conversion) }`);
}
float32array[0] = NaN;
assert.same(float32array[0], NaN, 'NaN -> NaN');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed.conversions.float64.js
|
JavaScript
|
import { DESCRIPTORS, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Float64 conversions', assert => {
const float64array = new Float64Array(1);
const uint8array = new Uint8Array(float64array.buffer);
const dataview = new DataView(float64array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0, 0, 0, 0, 0, 0, 0, 0]],
[-0, -0, [0, 0, 0, 0, 0, 0, 0, 128]],
[1, 1, [0, 0, 0, 0, 0, 0, 240, 63]],
[-1, -1, [0, 0, 0, 0, 0, 0, 240, 191]],
[1.1, 1.1, [154, 153, 153, 153, 153, 153, 241, 63]],
[-1.1, -1.1, [154, 153, 153, 153, 153, 153, 241, 191]],
[1.9, 1.9, [102, 102, 102, 102, 102, 102, 254, 63]],
[-1.9, -1.9, [102, 102, 102, 102, 102, 102, 254, 191]],
[127, 127, [0, 0, 0, 0, 0, 192, 95, 64]],
[-127, -127, [0, 0, 0, 0, 0, 192, 95, 192]],
[128, 128, [0, 0, 0, 0, 0, 0, 96, 64]],
[-128, -128, [0, 0, 0, 0, 0, 0, 96, 192]],
[255, 255, [0, 0, 0, 0, 0, 224, 111, 64]],
[-255, -255, [0, 0, 0, 0, 0, 224, 111, 192]],
[255.1, 255.1, [51, 51, 51, 51, 51, 227, 111, 64]],
[255.9, 255.9, [205, 204, 204, 204, 204, 252, 111, 64]],
[256, 256, [0, 0, 0, 0, 0, 0, 112, 64]],
[32767, 32767, [0, 0, 0, 0, 192, 255, 223, 64]],
[-32767, -32767, [0, 0, 0, 0, 192, 255, 223, 192]],
[32768, 32768, [0, 0, 0, 0, 0, 0, 224, 64]],
[-32768, -32768, [0, 0, 0, 0, 0, 0, 224, 192]],
[65535, 65535, [0, 0, 0, 0, 224, 255, 239, 64]],
[65536, 65536, [0, 0, 0, 0, 0, 0, 240, 64]],
[65537, 65537, [0, 0, 0, 0, 16, 0, 240, 64]],
[65536.54321, 65536.54321, [14, 248, 252, 176, 8, 0, 240, 64]],
[-65536.54321, -65536.54321, [14, 248, 252, 176, 8, 0, 240, 192]],
[2147483647, 2147483647, [0, 0, 192, 255, 255, 255, 223, 65]],
[-2147483647, -2147483647, [0, 0, 192, 255, 255, 255, 223, 193]],
[2147483648, 2147483648, [0, 0, 0, 0, 0, 0, 224, 65]],
[-2147483648, -2147483648, [0, 0, 0, 0, 0, 0, 224, 193]],
[2147483649, 2147483649, [0, 0, 32, 0, 0, 0, 224, 65]],
[-2147483649, -2147483649, [0, 0, 32, 0, 0, 0, 224, 193]],
[4294967295, 4294967295, [0, 0, 224, 255, 255, 255, 239, 65]],
[4294967296, 4294967296, [0, 0, 0, 0, 0, 0, 240, 65]],
[4294967297, 4294967297, [0, 0, 16, 0, 0, 0, 240, 65]],
[MAX_SAFE_INTEGER, MAX_SAFE_INTEGER, [255, 255, 255, 255, 255, 255, 63, 67]],
[MIN_SAFE_INTEGER, MIN_SAFE_INTEGER, [255, 255, 255, 255, 255, 255, 63, 195]],
[MAX_SAFE_INTEGER + 1, MAX_SAFE_INTEGER + 1, [0, 0, 0, 0, 0, 0, 64, 67]],
[MIN_SAFE_INTEGER - 1, MIN_SAFE_INTEGER - 1, [0, 0, 0, 0, 0, 0, 64, 195]],
[MAX_SAFE_INTEGER + 3, MAX_SAFE_INTEGER + 3, [1, 0, 0, 0, 0, 0, 64, 67]],
[MIN_SAFE_INTEGER - 3, MIN_SAFE_INTEGER - 3, [1, 0, 0, 0, 0, 0, 64, 195]],
[Infinity, Infinity, [0, 0, 0, 0, 0, 0, 240, 127]],
[-Infinity, -Infinity, [0, 0, 0, 0, 0, 0, 240, 255]],
[-Number.MAX_VALUE, -Number.MAX_VALUE, [255, 255, 255, 255, 255, 255, 239, 255]],
[Number.MAX_VALUE, Number.MAX_VALUE, [255, 255, 255, 255, 255, 255, 239, 127]],
[Number.MIN_VALUE, Number.MIN_VALUE, [1, 0, 0, 0, 0, 0, 0, 0]],
[-Number.MIN_VALUE, -Number.MIN_VALUE, [1, 0, 0, 0, 0, 0, 0, 128]],
];
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
float64array[0] = value;
assert.same(float64array[0], conversion, `Float64Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Float64Array ${ toString(value) } -> [${ representation }]`);
dataview.setFloat64(0, value);
assert.arrayEqual(uint8array, big, `dataview.setFloat64(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getFloat64(0), conversion, `dataview{${ big }}.getFloat64(0) -> ${ toString(conversion) }`);
dataview.setFloat64(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setFloat64(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getFloat64(0, false), conversion, `dataview{${ big }}.getFloat64(0, false) -> ${ toString(conversion) }`);
dataview.setFloat64(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setFloat64(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getFloat64(0, true), conversion, `dataview{${ little }}.getFloat64(0, true) -> ${ toString(conversion) }`);
}
float64array[0] = NaN;
assert.same(float64array[0], NaN, 'NaN -> NaN');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed.conversions.int16.js
|
JavaScript
|
import { DESCRIPTORS, GLOBAL, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, NATIVE } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Int16 conversions', assert => {
const int16array = new Int16Array(1);
const uint8array = new Uint8Array(int16array.buffer);
const dataview = new DataView(int16array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0, 0]],
[-0, 0, [0, 0]],
[1, 1, [1, 0]],
[-1, -1, [255, 255]],
[1.1, 1, [1, 0]],
[-1.1, -1, [255, 255]],
[1.9, 1, [1, 0]],
[-1.9, -1, [255, 255]],
[127, 127, [127, 0]],
[-127, -127, [129, 255]],
[128, 128, [128, 0]],
[-128, -128, [128, 255]],
[255, 255, [255, 0]],
[-255, -255, [1, 255]],
[255.1, 255, [255, 0]],
[255.9, 255, [255, 0]],
[256, 256, [0, 1]],
[32767, 32767, [255, 127]],
[-32767, -32767, [1, 128]],
[32768, -32768, [0, 128]],
[-32768, -32768, [0, 128]],
[65535, -1, [255, 255]],
[65536, 0, [0, 0]],
[65537, 1, [1, 0]],
[65536.54321, 0, [0, 0]],
[-65536.54321, 0, [0, 0]],
[2147483647, -1, [255, 255]],
[-2147483647, 1, [1, 0]],
[2147483648, 0, [0, 0]],
[-2147483648, 0, [0, 0]],
[4294967296, 0, [0, 0]],
[MAX_SAFE_INTEGER + 1, 0, [0, 0]],
[MIN_SAFE_INTEGER - 1, 0, [0, 0]],
[Infinity, 0, [0, 0]],
[-Infinity, 0, [0, 0]],
[-Number.MAX_VALUE, 0, [0, 0]],
[Number.MAX_VALUE, 0, [0, 0]],
[Number.MIN_VALUE, 0, [0, 0]],
[-Number.MIN_VALUE, 0, [0, 0]],
[NaN, 0, [0, 0]],
];
// Android 4.3- bug
if (NATIVE || !/Android [2-4]/.test(GLOBAL.navigator && navigator.userAgent)) {
data.push(
[2147483649, 1, [1, 0]],
[-2147483649, -1, [255, 255]],
[4294967295, -1, [255, 255]],
[4294967297, 1, [1, 0]],
[MAX_SAFE_INTEGER, -1, [255, 255]],
[MIN_SAFE_INTEGER, 1, [1, 0]],
[MAX_SAFE_INTEGER + 3, 2, [2, 0]],
[MIN_SAFE_INTEGER - 3, -2, [254, 255]],
);
}
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
int16array[0] = value;
assert.same(int16array[0], conversion, `Int16Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Int16Array ${ toString(value) } -> [${ representation }]`);
dataview.setInt16(0, value);
assert.arrayEqual(uint8array, big, `dataview.setInt16(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getInt16(0), conversion, `dataview{${ big }}.getInt16(0) -> ${ toString(conversion) }`);
dataview.setInt16(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setInt16(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getInt16(0, false), conversion, `dataview{${ big }}.getInt16(0, false) -> ${ toString(conversion) }`);
dataview.setInt16(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setInt16(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getInt16(0, true), conversion, `dataview{${ little }}.getInt16(0, true) -> ${ toString(conversion) }`);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed.conversions.int32.js
|
JavaScript
|
import { DESCRIPTORS, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Int32 conversions', assert => {
const int32array = new Int32Array(1);
const uint8array = new Uint8Array(int32array.buffer);
const dataview = new DataView(int32array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0, 0, 0, 0]],
[-0, 0, [0, 0, 0, 0]],
[1, 1, [1, 0, 0, 0]],
[-1, -1, [255, 255, 255, 255]],
[1.1, 1, [1, 0, 0, 0]],
[-1.1, -1, [255, 255, 255, 255]],
[1.9, 1, [1, 0, 0, 0]],
[-1.9, -1, [255, 255, 255, 255]],
[127, 127, [127, 0, 0, 0]],
[-127, -127, [129, 255, 255, 255]],
[128, 128, [128, 0, 0, 0]],
[-128, -128, [128, 255, 255, 255]],
[255, 255, [255, 0, 0, 0]],
[-255, -255, [1, 255, 255, 255]],
[255.1, 255, [255, 0, 0, 0]],
[255.9, 255, [255, 0, 0, 0]],
[256, 256, [0, 1, 0, 0]],
[32767, 32767, [255, 127, 0, 0]],
[-32767, -32767, [1, 128, 255, 255]],
[32768, 32768, [0, 128, 0, 0]],
[-32768, -32768, [0, 128, 255, 255]],
[65535, 65535, [255, 255, 0, 0]],
[65536, 65536, [0, 0, 1, 0]],
[65537, 65537, [1, 0, 1, 0]],
[65536.54321, 65536, [0, 0, 1, 0]],
[-65536.54321, -65536, [0, 0, 255, 255]],
[2147483647, 2147483647, [255, 255, 255, 127]],
[-2147483647, -2147483647, [1, 0, 0, 128]],
[2147483648, -2147483648, [0, 0, 0, 128]],
[-2147483648, -2147483648, [0, 0, 0, 128]],
[2147483649, -2147483647, [1, 0, 0, 128]],
[-2147483649, 2147483647, [255, 255, 255, 127]],
[4294967295, -1, [255, 255, 255, 255]],
[4294967296, 0, [0, 0, 0, 0]],
[4294967297, 1, [1, 0, 0, 0]],
[MAX_SAFE_INTEGER, -1, [255, 255, 255, 255]],
[MIN_SAFE_INTEGER, 1, [1, 0, 0, 0]],
[MAX_SAFE_INTEGER + 1, 0, [0, 0, 0, 0]],
[MIN_SAFE_INTEGER - 1, 0, [0, 0, 0, 0]],
[MAX_SAFE_INTEGER + 3, 2, [2, 0, 0, 0]],
[MIN_SAFE_INTEGER - 3, -2, [254, 255, 255, 255]],
[Infinity, 0, [0, 0, 0, 0]],
[-Infinity, 0, [0, 0, 0, 0]],
[-Number.MAX_VALUE, 0, [0, 0, 0, 0]],
[Number.MAX_VALUE, 0, [0, 0, 0, 0]],
[Number.MIN_VALUE, 0, [0, 0, 0, 0]],
[-Number.MIN_VALUE, 0, [0, 0, 0, 0]],
[NaN, 0, [0, 0, 0, 0]],
];
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
int32array[0] = value;
assert.same(int32array[0], conversion, `Int32Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Int32Array ${ toString(value) } -> [${ representation }]`);
dataview.setInt32(0, value);
assert.arrayEqual(uint8array, big, `dataview.setInt32(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getInt32(0), conversion, `dataview{${ big }}.getInt32(0) -> ${ toString(conversion) }`);
dataview.setInt32(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setInt32(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getInt32(0, false), conversion, `dataview{${ big }}.getInt32(0, false) -> ${ toString(conversion) }`);
dataview.setInt32(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setInt32(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getInt32(0, true), conversion, `dataview{${ little }}.getInt32(0, true) -> ${ toString(conversion) }`);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed.conversions.int8.js
|
JavaScript
|
import { DESCRIPTORS, GLOBAL, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, NATIVE } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Int8 conversions', assert => {
const int8array = new Int8Array(1);
const uint8array = new Uint8Array(int8array.buffer);
const dataview = new DataView(int8array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0]],
[-0, 0, [0]],
[1, 1, [1]],
[-1, -1, [255]],
[1.1, 1, [1]],
[-1.1, -1, [255]],
[1.9, 1, [1]],
[-1.9, -1, [255]],
[127, 127, [127]],
[-127, -127, [129]],
[128, -128, [128]],
[-128, -128, [128]],
[255, -1, [255]],
[-255, 1, [1]],
[255.1, -1, [255]],
[255.9, -1, [255]],
[256, 0, [0]],
[32767, -1, [255]],
[-32767, 1, [1]],
[32768, 0, [0]],
[-32768, 0, [0]],
[65535, -1, [255]],
[65536, 0, [0]],
[65537, 1, [1]],
[65536.54321, 0, [0]],
[-65536.54321, 0, [0]],
[2147483647, -1, [255]],
[-2147483647, 1, [1]],
[2147483648, 0, [0]],
[-2147483648, 0, [0]],
[4294967296, 0, [0]],
[MAX_SAFE_INTEGER + 1, 0, [0]],
[MIN_SAFE_INTEGER - 1, 0, [0]],
[Infinity, 0, [0]],
[-Infinity, 0, [0]],
[-Number.MAX_VALUE, 0, [0]],
[Number.MAX_VALUE, 0, [0]],
[Number.MIN_VALUE, 0, [0]],
[-Number.MIN_VALUE, 0, [0]],
[NaN, 0, [0]],
];
// Android 4.3- bug
if (NATIVE || !/Android [2-4]/.test(GLOBAL.navigator && navigator.userAgent)) {
data.push(
[2147483649, 1, [1]],
[-2147483649, -1, [255]],
[4294967295, -1, [255]],
[4294967297, 1, [1]],
[MAX_SAFE_INTEGER, -1, [255]],
[MIN_SAFE_INTEGER, 1, [1]],
[MAX_SAFE_INTEGER + 3, 2, [2]],
[MIN_SAFE_INTEGER - 3, -2, [254]],
);
}
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
int8array[0] = value;
assert.same(int8array[0], conversion, `Int8Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Int8Array ${ toString(value) } -> [${ representation }]`);
dataview.setInt8(0, value);
assert.arrayEqual(uint8array, big, `dataview.setInt8(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getInt8(0), conversion, `dataview{${ big }}.getInt8(0) -> ${ toString(conversion) }`);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed.conversions.uint16.js
|
JavaScript
|
import { DESCRIPTORS, GLOBAL, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, NATIVE } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint16 conversions', assert => {
const uint16array = new Uint16Array(1);
const uint8array = new Uint8Array(uint16array.buffer);
const dataview = new DataView(uint16array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0, 0]],
[-0, 0, [0, 0]],
[1, 1, [1, 0]],
[-1, 65535, [255, 255]],
[1.1, 1, [1, 0]],
[-1.1, 65535, [255, 255]],
[1.9, 1, [1, 0]],
[-1.9, 65535, [255, 255]],
[127, 127, [127, 0]],
[-127, 65409, [129, 255]],
[128, 128, [128, 0]],
[-128, 65408, [128, 255]],
[255, 255, [255, 0]],
[-255, 65281, [1, 255]],
[255.1, 255, [255, 0]],
[255.9, 255, [255, 0]],
[256, 256, [0, 1]],
[32767, 32767, [255, 127]],
[-32767, 32769, [1, 128]],
[32768, 32768, [0, 128]],
[-32768, 32768, [0, 128]],
[65535, 65535, [255, 255]],
[65536, 0, [0, 0]],
[65537, 1, [1, 0]],
[65536.54321, 0, [0, 0]],
[-65536.54321, 0, [0, 0]],
[2147483647, 65535, [255, 255]],
[-2147483647, 1, [1, 0]],
[2147483648, 0, [0, 0]],
[-2147483648, 0, [0, 0]],
[4294967296, 0, [0, 0]],
[MAX_SAFE_INTEGER + 1, 0, [0, 0]],
[MIN_SAFE_INTEGER - 1, 0, [0, 0]],
[Infinity, 0, [0, 0]],
[-Infinity, 0, [0, 0]],
[-Number.MAX_VALUE, 0, [0, 0]],
[Number.MAX_VALUE, 0, [0, 0]],
[Number.MIN_VALUE, 0, [0, 0]],
[-Number.MIN_VALUE, 0, [0, 0]],
[NaN, 0, [0, 0]],
];
// Android 4.3- bug
if (NATIVE || !/Android [2-4]/.test(GLOBAL.navigator && navigator.userAgent)) {
data.push(
[2147483649, 1, [1, 0]],
[-2147483649, 65535, [255, 255]],
[4294967295, 65535, [255, 255]],
[4294967297, 1, [1, 0]],
[MAX_SAFE_INTEGER, 65535, [255, 255]],
[MIN_SAFE_INTEGER, 1, [1, 0]],
[MAX_SAFE_INTEGER + 3, 2, [2, 0]],
[MIN_SAFE_INTEGER - 3, 65534, [254, 255]],
);
}
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
uint16array[0] = value;
assert.same(uint16array[0], conversion, `Uint16Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Uint16Array ${ toString(value) } -> [${ representation }]`);
dataview.setUint16(0, value);
assert.arrayEqual(uint8array, big, `dataview.setUint16(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getUint16(0), conversion, `dataview{${ big }}.getUint16(0) -> ${ toString(conversion) }`);
dataview.setUint16(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setUint16(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getUint16(0, false), conversion, `dataview{${ big }}.getUint16(0, false) -> ${ toString(conversion) }`);
dataview.setUint16(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setUint16(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getUint16(0, true), conversion, `dataview{${ little }}.getUint16(0, true) -> ${ toString(conversion) }`);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed.conversions.uint32.js
|
JavaScript
|
import { DESCRIPTORS, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint32 conversions', assert => {
const uint32array = new Uint32Array(1);
const uint8array = new Uint8Array(uint32array.buffer);
const dataview = new DataView(uint32array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0, 0, 0, 0]],
[-0, 0, [0, 0, 0, 0]],
[1, 1, [1, 0, 0, 0]],
[-1, 4294967295, [255, 255, 255, 255]],
[1.1, 1, [1, 0, 0, 0]],
[-1.1, 4294967295, [255, 255, 255, 255]],
[1.9, 1, [1, 0, 0, 0]],
[-1.9, 4294967295, [255, 255, 255, 255]],
[127, 127, [127, 0, 0, 0]],
[-127, 4294967169, [129, 255, 255, 255]],
[128, 128, [128, 0, 0, 0]],
[-128, 4294967168, [128, 255, 255, 255]],
[255, 255, [255, 0, 0, 0]],
[-255, 4294967041, [1, 255, 255, 255]],
[255.1, 255, [255, 0, 0, 0]],
[255.9, 255, [255, 0, 0, 0]],
[256, 256, [0, 1, 0, 0]],
[32767, 32767, [255, 127, 0, 0]],
[-32767, 4294934529, [1, 128, 255, 255]],
[32768, 32768, [0, 128, 0, 0]],
[-32768, 4294934528, [0, 128, 255, 255]],
[65535, 65535, [255, 255, 0, 0]],
[65536, 65536, [0, 0, 1, 0]],
[65537, 65537, [1, 0, 1, 0]],
[65536.54321, 65536, [0, 0, 1, 0]],
[-65536.54321, 4294901760, [0, 0, 255, 255]],
[2147483647, 2147483647, [255, 255, 255, 127]],
[-2147483647, 2147483649, [1, 0, 0, 128]],
[2147483648, 2147483648, [0, 0, 0, 128]],
[-2147483648, 2147483648, [0, 0, 0, 128]],
[2147483649, 2147483649, [1, 0, 0, 128]],
[-2147483649, 2147483647, [255, 255, 255, 127]],
[4294967295, 4294967295, [255, 255, 255, 255]],
[4294967296, 0, [0, 0, 0, 0]],
[4294967297, 1, [1, 0, 0, 0]],
[MAX_SAFE_INTEGER, 4294967295, [255, 255, 255, 255]],
[MIN_SAFE_INTEGER, 1, [1, 0, 0, 0]],
[MAX_SAFE_INTEGER + 1, 0, [0, 0, 0, 0]],
[MIN_SAFE_INTEGER - 1, 0, [0, 0, 0, 0]],
[MAX_SAFE_INTEGER + 3, 2, [2, 0, 0, 0]],
[MIN_SAFE_INTEGER - 3, 4294967294, [254, 255, 255, 255]],
[Infinity, 0, [0, 0, 0, 0]], [-Infinity, 0, [0, 0, 0, 0]],
[-Number.MAX_VALUE, 0, [0, 0, 0, 0]],
[Number.MAX_VALUE, 0, [0, 0, 0, 0]],
[Number.MIN_VALUE, 0, [0, 0, 0, 0]],
[-Number.MIN_VALUE, 0, [0, 0, 0, 0]],
[NaN, 0, [0, 0, 0, 0]],
];
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
uint32array[0] = value;
assert.same(uint32array[0], conversion, `Uint32Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Uint32Array ${ toString(value) } -> [${ representation }]`);
dataview.setUint32(0, value);
assert.arrayEqual(uint8array, big, `dataview.setUint32(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getUint32(0), conversion, `dataview{${ big }}.getUint32(0) -> ${ toString(conversion) }`);
dataview.setUint32(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setUint32(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getUint32(0, false), conversion, `dataview{${ big }}.getUint32(0, false) -> ${ toString(conversion) }`);
dataview.setUint32(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setUint32(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getUint32(0, true), conversion, `dataview{${ little }}.getUint32(0, true) -> ${ toString(conversion) }`);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed.conversions.uint8-clamped.js
|
JavaScript
|
import { DESCRIPTORS, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Clamped conversions', assert => {
const uint8clamped = new Uint8ClampedArray(1);
const uint8array = new Uint8Array(uint8clamped.buffer);
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0]],
[-0, 0, [0]],
[1, 1, [1]],
[-1, 0, [0]],
[1.1, 1, [1]],
[-1.1, 0, [0]],
[1.9, 2, [2]],
[-1.9, 0, [0]],
// round-half-to-even (banker's rounding)
[0.5, 0, [0]],
[1.5, 2, [2]],
[2.5, 2, [2]],
[3.5, 4, [4]],
[4.5, 4, [4]],
[253.5, 254, [254]],
[254.5, 254, [254]],
[127, 127, [127]],
[-127, 0, [0]],
[128, 128, [128]],
[-128, 0, [0]],
[255, 255, [255]],
[-255, 0, [0]],
[255.1, 255, [255]],
[255.9, 255, [255]],
[256, 255, [255]],
[32767, 255, [255]],
[-32767, 0, [0]],
[32768, 255, [255]],
[-32768, 0, [0]],
[65535, 255, [255]],
[65536, 255, [255]],
[65537, 255, [255]],
[65536.54321, 255, [255]],
[-65536.54321, 0, [0]],
[2147483647, 255, [255]],
[-2147483647, 0, [0]],
[2147483648, 255, [255]],
[-2147483648, 0, [0]],
[2147483649, 255, [255]],
[-2147483649, 0, [0]],
[4294967295, 255, [255]],
[4294967296, 255, [255]],
[4294967297, 255, [255]],
[MAX_SAFE_INTEGER, 255, [255]],
[MIN_SAFE_INTEGER, 0, [0]],
[MAX_SAFE_INTEGER + 1, 255, [255]],
[MIN_SAFE_INTEGER - 1, 0, [0]],
[MAX_SAFE_INTEGER + 3, 255, [255]],
[MIN_SAFE_INTEGER - 3, 0, [0]],
[Infinity, 255, [255]],
[-Infinity, 0, [0]],
[-Number.MAX_VALUE, 0, [0]],
[Number.MAX_VALUE, 255, [255]],
[Number.MIN_VALUE, 0, [0]],
[-Number.MIN_VALUE, 0, [0]],
[NaN, 0, [0]],
];
for (const [value, conversion, little] of data) {
uint8clamped[0] = value;
assert.same(uint8clamped[0], conversion, `Uint8ClampedArray ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, little, `Uint8ClampedArray ${ toString(value) } -> [${ little }]`);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.typed.conversions.uint8.js
|
JavaScript
|
import { DESCRIPTORS, GLOBAL, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, NATIVE } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8 conversions', assert => {
const uint8array = new Uint8Array(1);
const dataview = new DataView(uint8array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0]],
[-0, 0, [0]],
[1, 1, [1]],
[-1, 255, [255]],
[1.1, 1, [1]],
[-1.1, 255, [255]],
[1.9, 1, [1]],
[-1.9, 255, [255]],
[127, 127, [127]],
[-127, 129, [129]],
[128, 128, [128]],
[-128, 128, [128]],
[255, 255, [255]],
[-255, 1, [1]],
[255.1, 255, [255]],
[255.9, 255, [255]],
[256, 0, [0]],
[32767, 255, [255]],
[-32767, 1, [1]],
[32768, 0, [0]],
[-32768, 0, [0]],
[65535, 255, [255]],
[65536, 0, [0]],
[65537, 1, [1]],
[65536.54321, 0, [0]],
[-65536.54321, 0, [0]],
[2147483647, 255, [255]],
[-2147483647, 1, [1]],
[2147483648, 0, [0]],
[-2147483648, 0, [0]],
[4294967296, 0, [0]],
[MAX_SAFE_INTEGER + 1, 0, [0]],
[MIN_SAFE_INTEGER - 1, 0, [0]],
[Infinity, 0, [0]], [-Infinity, 0, [0]],
[-Number.MAX_VALUE, 0, [0]],
[Number.MAX_VALUE, 0, [0]],
[Number.MIN_VALUE, 0, [0]],
[-Number.MIN_VALUE, 0, [0]],
[NaN, 0, [0]],
];
// Android 4.3- bug
if (NATIVE || !/Android [2-4]/.test(GLOBAL.navigator && navigator.userAgent)) {
data.push(
[2147483649, 1, [1]],
[-2147483649, 255, [255]],
[4294967295, 255, [255]],
[4294967297, 1, [1]],
[MAX_SAFE_INTEGER, 255, [255]],
[MIN_SAFE_INTEGER, 1, [1]],
[MAX_SAFE_INTEGER + 3, 2, [2]],
[MIN_SAFE_INTEGER - 3, 254, [254]],
);
}
for (const [value, conversion, little] of data) {
uint8array[0] = value;
assert.same(uint8array[0], conversion, `Uint8Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, little, `Uint8Array ${ toString(value) } -> [${ little }]`);
dataview.setUint8(0, value);
assert.arrayEqual(uint8array, little, `dataview.setUint8(0, ${ toString(value) }) -> [${ little }]`);
assert.same(viewFrom(little).getUint8(0), conversion, `dataview{${ little }}.getUint8(0) -> ${ toString(conversion) }`);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.uint8-array.from-base64.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.fromBase64', assert => {
const { fromBase64 } = Uint8Array;
assert.isFunction(fromBase64);
assert.arity(fromBase64, 1);
assert.name(fromBase64, 'fromBase64');
assert.looksNative(fromBase64);
const array = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);
assert.true(fromBase64('SGVsbG8gV29ybGQ=') instanceof Uint8Array, 'returns Uint8Array instance #1');
assert.true(fromBase64.call(Int16Array, 'SGVsbG8gV29ybGQ=') instanceof Uint8Array, 'returns Uint8Array instance #2');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ='), array, 'proper result');
assert.deepEqual(fromBase64('12/3'), new Uint8Array([215, 111, 247]), 'encoding #1');
assert.throws(() => fromBase64('12_3'), SyntaxError, 'encoding #2');
assert.deepEqual(fromBase64('12+3'), new Uint8Array([215, 111, 183]), 'encoding #3');
assert.throws(() => fromBase64('12-3'), SyntaxError, 'encoding #4');
assert.deepEqual(fromBase64('12/3', { alphabet: 'base64' }), new Uint8Array([215, 111, 247]), 'encoding #5');
assert.throws(() => fromBase64('12_3', { alphabet: 'base64' }), SyntaxError, 'encoding #6');
assert.deepEqual(fromBase64('12+3', { alphabet: 'base64' }), new Uint8Array([215, 111, 183]), 'encoding #7');
assert.throws(() => fromBase64('12-3', { alphabet: 'base64' }), SyntaxError, 'encoding #8');
assert.deepEqual(fromBase64('12_3', { alphabet: 'base64url' }), new Uint8Array([215, 111, 247]), 'encoding #9');
assert.throws(() => fromBase64('12/3', { alphabet: 'base64url' }), SyntaxError, 'encoding #10');
assert.deepEqual(fromBase64('12-3', { alphabet: 'base64url' }), new Uint8Array([215, 111, 183]), 'encoding #11');
assert.throws(() => fromBase64('12+3', { alphabet: 'base64url' }), SyntaxError, 'encoding #12');
assert.throws(() => fromBase64(null), TypeError, "isn't generic #1");
assert.throws(() => fromBase64(undefined), TypeError, "isn't generic #2");
assert.throws(() => fromBase64(1234), TypeError, "isn't generic #3");
assert.throws(() => fromBase64(Object('SGVsbG8gV29ybGQ=')), TypeError, "isn't generic #4");
assert.throws(() => fromBase64('SGVsbG8gV29ybG%='), SyntaxError, 'throws on invalid #1');
assert.throws(() => fromBase64('SGVsbG8gV29ybGQ1='), SyntaxError, 'throws on invalid #2');
assert.throws(() => fromBase64('SGVsbG8gV29ybGQ1=', null), TypeError, 'incorrect options argument #1');
assert.throws(() => fromBase64('SGVsbG8gV29ybGQ1=', 1), TypeError, 'incorrect options argument #2');
assert.throws(() => fromBase64('SGVsbG8gV29ybGQ1=', { alphabet: 'base32' }), TypeError, 'incorrect encoding');
assert.throws(() => fromBase64('SGVsbG8gV29ybGQ1=', { lastChunkHandling: 'fff' }), TypeError, 'incorrect lastChunkHandling');
assert.deepEqual(fromBase64('BBB'), new Uint8Array([4, 16]), 'ending #1');
assert.deepEqual(fromBase64('BBB', { lastChunkHandling: 'loose' }), new Uint8Array([4, 16]), 'ending #2');
assert.deepEqual(fromBase64('BBB', { lastChunkHandling: 'stop-before-partial' }), new Uint8Array([]), 'ending #3');
assert.throws(() => fromBase64('BBB', { lastChunkHandling: 'strict' }), SyntaxError, 'ending #4');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ'), array, 'ending #5');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ', { lastChunkHandling: 'loose' }), array, 'ending #6');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ', { lastChunkHandling: 'stop-before-partial' }), array.slice(0, -2), 'ending #7');
assert.throws(() => fromBase64('SGVsbG8gV29ybGQ', { lastChunkHandling: 'strict' }), SyntaxError, 'ending #8');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ= '), array, 'spaces #1');
assert.deepEqual(fromBase64('SGVsbG8gV2 9ybGQ='), array, 'spaces #2');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ=\n'), array, 'spaces #3');
assert.deepEqual(fromBase64('SGVsbG8gV2\n9ybGQ='), array, 'spaces #4');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ= ', { lastChunkHandling: 'loose' }), array, 'spaces #5');
assert.deepEqual(fromBase64('SGVsbG8gV2 9ybGQ=', { lastChunkHandling: 'loose' }), array, 'spaces #6');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ=\n', { lastChunkHandling: 'loose' }), array, 'spaces #7');
assert.deepEqual(fromBase64('SGVsbG8gV2\n9ybGQ=', { lastChunkHandling: 'loose' }), array, 'spaces #8');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ= ', { lastChunkHandling: 'stop-before-partial' }), array, 'spaces #9');
assert.deepEqual(fromBase64('SGVsbG8gV2 9ybGQ=', { lastChunkHandling: 'stop-before-partial' }), array, 'spaces #10');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ=\n', { lastChunkHandling: 'stop-before-partial' }), array, 'spaces #11');
assert.deepEqual(fromBase64('SGVsbG8gV2\n9ybGQ=', { lastChunkHandling: 'stop-before-partial' }), array, 'spaces #12');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ= ', { lastChunkHandling: 'strict' }), array, 'spaces #13');
assert.deepEqual(fromBase64('SGVsbG8gV2 9ybGQ=', { lastChunkHandling: 'strict' }), array, 'spaces #14');
assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ=\n', { lastChunkHandling: 'strict' }), array, 'spaces #15');
assert.deepEqual(fromBase64('SGVsbG8gV2\n9ybGQ=', { lastChunkHandling: 'strict' }), array, 'spaces #16');
// Test262
// Copyright 2024 Kevin Gibbons. All rights reserved.
// This code is governed by the BSD license found in the https://github.com/tc39/test262/blob/main/LICENSE file.
assert.arrayEqual(Uint8Array.fromBase64('x+/y'), [199, 239, 242]);
assert.arrayEqual(Uint8Array.fromBase64('x+/y', { alphabet: 'base64' }), [199, 239, 242]);
assert.throws(() => Uint8Array.fromBase64('x+/y', { alphabet: 'base64url' }), SyntaxError);
assert.arrayEqual(Uint8Array.fromBase64('x-_y', { alphabet: 'base64url' }), [199, 239, 242]);
assert.throws(() => Uint8Array.fromBase64('x-_y'), SyntaxError);
assert.throws(() => Uint8Array.fromBase64('x-_y', { alphabet: 'base64' }), SyntaxError);
[
'Zm.9v',
'Zm9v^',
'Zg==&',
'Z−==', // U+2212 'Minus Sign'
'Z＋==', // U+FF0B 'Fullwidth Plus Sign'
'Zg\u00A0==', // nbsp
'Zg\u2009==', // thin space
'Zg\u2028==', // line separator
].forEach(value => assert.throws(() => Uint8Array.fromBase64(value), SyntaxError));
// padding
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZg=='), [101, 120, 97, 102]);
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZg==', { lastChunkHandling: 'loose' }), [101, 120, 97, 102]);
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZg==', { lastChunkHandling: 'stop-before-partial' }), [101, 120, 97, 102]);
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZg==', { lastChunkHandling: 'strict' }), [101, 120, 97, 102]);
// no padding
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZg'), [101, 120, 97, 102]);
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZg', { lastChunkHandling: 'loose' }), [101, 120, 97, 102]);
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZg', { lastChunkHandling: 'stop-before-partial' }), [101, 120, 97]);
assert.throws(() => Uint8Array.fromBase64('ZXhhZg', { lastChunkHandling: 'strict' }), SyntaxError);
// non-zero padding bits
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZh=='), [101, 120, 97, 102]);
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZh==', { lastChunkHandling: 'loose' }), [101, 120, 97, 102]);
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZh==', { lastChunkHandling: 'stop-before-partial' }), [101, 120, 97, 102]);
assert.throws(() => Uint8Array.fromBase64('ZXhhZh==', { lastChunkHandling: 'strict' }), SyntaxError);
// non-zero padding bits, no padding
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZh'), [101, 120, 97, 102]);
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZh', { lastChunkHandling: 'loose' }), [101, 120, 97, 102]);
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZh', { lastChunkHandling: 'stop-before-partial' }), [101, 120, 97]);
assert.throws(() => Uint8Array.fromBase64('ZXhhZh', { lastChunkHandling: 'strict' }), SyntaxError);
// partial padding
assert.throws(() => Uint8Array.fromBase64('ZXhhZg='), SyntaxError);
assert.throws(() => Uint8Array.fromBase64('ZXhhZg=', { lastChunkHandling: 'loose' }), SyntaxError);
assert.arrayEqual(Uint8Array.fromBase64('ZXhhZg=', { lastChunkHandling: 'stop-before-partial' }), [101, 120, 97]);
assert.throws(() => Uint8Array.fromBase64('ZXhhZg=', { lastChunkHandling: 'strict' }), SyntaxError);
// excess padding
assert.throws(() => Uint8Array.fromBase64('ZXhhZg==='), SyntaxError);
assert.throws(() => Uint8Array.fromBase64('ZXhhZg===', { lastChunkHandling: 'loose' }), SyntaxError);
assert.throws(() => Uint8Array.fromBase64('ZXhhZg===', { lastChunkHandling: 'stop-before-partial' }), SyntaxError);
assert.throws(() => Uint8Array.fromBase64('ZXhhZg===', { lastChunkHandling: 'strict' }), SyntaxError);
// standard test vectors from https://datatracker.ietf.org/doc/html/rfc4648#section-10
[
['', []],
['Zg==', [102]],
['Zm8=', [102, 111]],
['Zm9v', [102, 111, 111]],
['Zm9vYg==', [102, 111, 111, 98]],
['Zm9vYmE=', [102, 111, 111, 98, 97]],
['Zm9vYmFy', [102, 111, 111, 98, 97, 114]],
].forEach(([string, bytes]) => {
const result = Uint8Array.fromBase64(string);
assert.same(Object.getPrototypeOf(result), Uint8Array.prototype, `decoding ${ string }`);
assert.same(result.length, bytes.length, `decoding ${ string }`);
assert.same(result.buffer.byteLength, bytes.length, `decoding ${ string }`);
assert.arrayEqual(result, bytes, `decoding ${ string }`);
});
[
['Z g==', 'space'],
['Z\tg==', 'tab'],
['Z\u000Ag==', 'LF'],
['Z\u000Cg==', 'FF'],
['Z\u000Dg==', 'CR'],
].forEach(([string, name]) => {
const arr = Uint8Array.fromBase64(string);
assert.same(arr.length, 1);
assert.same(arr.buffer.byteLength, 1);
assert.arrayEqual(arr, [102], `ascii whitespace: ${ name }`);
});
assert.throws(() => Uint8Array.fromBase64('a'), SyntaxError, 'throws error on incorrect length of base64 string');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.uint8-array.from-hex.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.fromHex', assert => {
const { fromHex } = Uint8Array;
assert.isFunction(fromHex);
assert.arity(fromHex, 1);
assert.name(fromHex, 'fromHex');
assert.looksNative(fromHex);
assert.true(fromHex('48656c6c6f20576f726c64') instanceof Uint8Array, 'returns Uint8Array instance #1');
assert.true(fromHex.call(Int16Array, '48656c6c6f20576f726c64') instanceof Uint8Array, 'returns Uint8Array instance #2');
assert.deepEqual(fromHex('48656c6c6f20576f726c64'), new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]), 'proper result');
assert.throws(() => fromHex(null), TypeError, "isn't generic #1");
assert.throws(() => fromHex(undefined), TypeError, "isn't generic #2");
assert.throws(() => fromHex(1234), TypeError, "isn't generic #3");
assert.throws(() => fromHex(Object('48656c6c6f20576f726c64')), TypeError, "isn't generic #4");
assert.throws(() => fromHex('4865gc6c6f20576f726c64'), SyntaxError, 'throws on invalid #1');
assert.throws(() => fromHex('48656c6c6f20576f726c641'), SyntaxError, 'throws on invalid #2');
assert.throws(() => fromHex('48656c6c6f20576f726c64 '), SyntaxError, 'throws on invalid #3');
assert.throws(() => fromHex('48656c6c6f20576f726c64\n'), SyntaxError, 'throws on invalid #4');
// Test262
// Copyright 2024 Kevin Gibbons. All rights reserved.
// This code is governed by the BSD license found in the https://github.com/tc39/test262/blob/main/LICENSE file.
[
'a.a',
'aa^',
'a a',
'a\ta',
'a\u000Aa',
'a\u000Ca',
'a\u000Da',
'a\u00A0a', // nbsp
'a\u2009a', // thin space
'a\u2028a', // line separator
].forEach(value => assert.throws(() => Uint8Array.fromHex(value), SyntaxError));
assert.throws(() => Uint8Array.fromHex('a'), SyntaxError);
[
['', []],
['66', [102]],
['666f', [102, 111]],
['666F', [102, 111]],
['666f6f', [102, 111, 111]],
['666F6f', [102, 111, 111]],
['666f6f62', [102, 111, 111, 98]],
['666f6f6261', [102, 111, 111, 98, 97]],
['666f6f626172', [102, 111, 111, 98, 97, 114]],
].forEach(([string, bytes]) => {
const arr = Uint8Array.fromHex(string);
assert.same(Object.getPrototypeOf(arr), Uint8Array.prototype, `decoding ${ string }`);
assert.same(arr.length, bytes.length, `decoding ${ string }`);
assert.same(arr.buffer.byteLength, bytes.length, `decoding ${ string }`);
assert.arrayEqual(arr, bytes, `decoding ${ string }`);
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.uint8-array.set-from-base64.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.prototype.setFromBase64', assert => {
const { setFromBase64 } = Uint8Array.prototype;
assert.isFunction(setFromBase64);
assert.arity(setFromBase64, 1);
assert.name(setFromBase64, 'setFromBase64');
assert.looksNative(setFromBase64);
const template = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 0, 0, 0, 0, 0]);
const array1 = new Uint8Array(16);
const result1 = array1.setFromBase64('SGVsbG8gV29ybGQ=');
assert.deepEqual(array1, template, 'proper result array #1');
assert.deepEqual(result1, { read: 16, written: 11 }, 'proper result #1');
assert.throws(() => setFromBase64.call(Array(16), 'SGVsbG8gV29ybGQ='), TypeError, "isn't generic, this #1");
assert.throws(() => setFromBase64.call(new Int8Array(16), 'SGVsbG8gV29ybGQ='), TypeError, "isn't generic, this #2");
assert.throws(() => new Uint8Array(16).setFromBase64(null), TypeError, "isn't generic, arg #1");
assert.throws(() => new Uint8Array(16).setFromBase64(undefined), TypeError, "isn't generic, arg #2");
assert.throws(() => new Uint8Array(16).setFromBase64(1234), TypeError, "isn't generic, arg #3");
assert.throws(() => new Uint8Array(16).setFromBase64(Object('SGVsbG8gV29ybGQ=')), TypeError, "isn't generic, arg #4");
assert.throws(() => new Uint8Array(16).setFromBase64('^'), SyntaxError, 'throws on invalid #1');
assert.throws(() => new Uint8Array(16).setFromBase64('SGVsbG8gV29ybGQ=', null), TypeError, 'incorrect options argument #1');
assert.throws(() => new Uint8Array(16).setFromBase64('SGVsbG8gV29ybGQ=', 1), TypeError, 'incorrect options argument #2');
assert.throws(() => new Uint8Array(16).setFromBase64('SGVsbG8gV29ybGQ=', { alphabet: 'base32' }), TypeError, 'incorrect encoding');
assert.throws(() => new Uint8Array(16).setFromBase64('SGVsbG8gV29ybGQ=', { lastChunkHandling: 'fff' }), TypeError, 'incorrect lastChunkHandling');
if (ArrayBuffer.prototype.transfer) {
const array = new Uint8Array(16);
array.buffer.transfer();
assert.throws(() => array.setFromHex('SGVsbG8gV29ybGQ='), TypeError, 'detached');
}
// Test262
// Copyright 2024 Kevin Gibbons. All rights reserved.
// This code is governed by the BSD license found in the https://github.com/tc39/test262/blob/main/LICENSE file.
let target = new Uint8Array([255, 255, 255, 255]);
let result = target.setFromBase64('x+/y');
assert.same(result.read, 4);
assert.same(result.written, 3);
assert.arrayEqual(target, [199, 239, 242, 255]);
target = new Uint8Array([255, 255, 255, 255]);
result = target.setFromBase64('x+/y', { alphabet: 'base64' });
assert.same(result.read, 4);
assert.same(result.written, 3);
assert.arrayEqual(target, [199, 239, 242, 255]);
assert.throws(() => new Uint8Array([255, 255, 255, 255]).setFromBase64('x+/y', { alphabet: 'base64url' }), SyntaxError);
target = new Uint8Array([255, 255, 255, 255]);
result = target.setFromBase64('x-_y', { alphabet: 'base64url' });
assert.same(result.read, 4);
assert.same(result.written, 3);
assert.arrayEqual(target, [199, 239, 242, 255]);
assert.throws(() => new Uint8Array([255, 255, 255, 255]).setFromBase64('x-_y'), SyntaxError);
assert.throws(() => new Uint8Array([255, 255, 255, 255]).setFromBase64('x-_y', { alphabet: 'base64' }), SyntaxError);
[
'Zm.9v',
'Zm9v^',
'Zg==&',
'Z−==', // U+2212 'Minus Sign'
'Z＋==', // U+FF0B 'Fullwidth Plus Sign'
'Zg\u00A0==', // nbsp
'Zg\u2009==', // thin space
'Zg\u2028==', // line separator
].forEach(value => assert.throws(() => new Uint8Array([255, 255, 255, 255, 255]).setFromBase64(value), SyntaxError));
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZg==');
assert.same(result.read, 8);
assert.same(result.written, 4);
assert.arrayEqual(target, [101, 120, 97, 102, 255, 255]);
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZg==', { lastChunkHandling: 'loose' });
assert.same(result.read, 8);
assert.same(result.written, 4);
assert.arrayEqual(target, [101, 120, 97, 102, 255, 255]);
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZg==', { lastChunkHandling: 'stop-before-partial' });
assert.same(result.read, 8);
assert.same(result.written, 4);
assert.arrayEqual(target, [101, 120, 97, 102, 255, 255]);
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZg==', { lastChunkHandling: 'strict' });
assert.same(result.read, 8);
assert.same(result.written, 4);
assert.arrayEqual(target, [101, 120, 97, 102, 255, 255]);
// no padding
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZg');
assert.same(result.read, 6);
assert.same(result.written, 4);
assert.arrayEqual(target, [101, 120, 97, 102, 255, 255]);
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZg', { lastChunkHandling: 'loose' });
assert.same(result.read, 6);
assert.same(result.written, 4);
assert.arrayEqual(target, [101, 120, 97, 102, 255, 255]);
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZg', { lastChunkHandling: 'stop-before-partial' });
assert.same(result.read, 4);
assert.same(result.written, 3);
assert.arrayEqual(target, [101, 120, 97, 255, 255, 255]);
assert.throws(() => new Uint8Array([255, 255, 255, 255, 255, 255]).setFromBase64('ZXhhZg', { lastChunkHandling: 'strict' }), SyntaxError);
// non-zero padding bits
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZh==');
assert.same(result.read, 8);
assert.same(result.written, 4);
assert.arrayEqual(target, [101, 120, 97, 102, 255, 255]);
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZh==', { lastChunkHandling: 'loose' });
assert.same(result.read, 8);
assert.same(result.written, 4);
assert.arrayEqual(target, [101, 120, 97, 102, 255, 255]);
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZh==', { lastChunkHandling: 'stop-before-partial' });
assert.same(result.read, 8);
assert.same(result.written, 4);
assert.arrayEqual(target, [101, 120, 97, 102, 255, 255]);
assert.throws(() => new Uint8Array([255, 255, 255, 255, 255, 255]).setFromBase64('ZXhhZh==', { lastChunkHandling: 'strict' }), SyntaxError);
// non-zero padding bits, no padding
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZh');
assert.same(result.read, 6);
assert.same(result.written, 4);
assert.arrayEqual(target, [101, 120, 97, 102, 255, 255]);
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZh', { lastChunkHandling: 'loose' });
assert.same(result.read, 6);
assert.same(result.written, 4);
assert.arrayEqual(target, [101, 120, 97, 102, 255, 255]);
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZh', { lastChunkHandling: 'stop-before-partial' });
assert.same(result.read, 4);
assert.same(result.written, 3);
assert.arrayEqual(target, [101, 120, 97, 255, 255, 255]);
assert.throws(() => new Uint8Array([255, 255, 255, 255, 255, 255]).setFromBase64('ZXhhZh', { lastChunkHandling: 'strict' }), SyntaxError);
// partial padding
assert.throws(() => new Uint8Array([255, 255, 255, 255, 255, 255]).setFromBase64('ZXhhZg='), SyntaxError);
assert.throws(() => new Uint8Array([255, 255, 255, 255, 255, 255]).setFromBase64('ZXhhZg=', { lastChunkHandling: 'loose' }), SyntaxError);
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('ZXhhZg=', { lastChunkHandling: 'stop-before-partial' });
assert.same(result.read, 4);
assert.same(result.written, 3);
assert.arrayEqual(target, [101, 120, 97, 255, 255, 255]);
assert.throws(() => new Uint8Array([255, 255, 255, 255, 255, 255]).setFromBase64('ZXhhZg=', { lastChunkHandling: 'strict' }), SyntaxError);
// excess padding
assert.throws(() => new Uint8Array([255, 255, 255, 255, 255, 255]).setFromBase64('ZXhhZg==='), SyntaxError);
assert.throws(() => new Uint8Array([255, 255, 255, 255, 255, 255]).setFromBase64('ZXhhZg===', { lastChunkHandling: 'loose' }), SyntaxError);
assert.throws(() => new Uint8Array([255, 255, 255, 255, 255, 255]).setFromBase64('ZXhhZg===', { lastChunkHandling: 'stop-before-partial' }), SyntaxError);
assert.throws(() => new Uint8Array([255, 255, 255, 255, 255, 255]).setFromBase64('ZXhhZg===', { lastChunkHandling: 'strict' }), SyntaxError);
// standard test vectors from https://datatracker.ietf.org/doc/html/rfc4648#section-10
[
['', []],
['Zg==', [102]],
['Zm8=', [102, 111]],
['Zm9v', [102, 111, 111]],
['Zm9vYg==', [102, 111, 111, 98]],
['Zm9vYmE=', [102, 111, 111, 98, 97]],
['Zm9vYmFy', [102, 111, 111, 98, 97, 114]],
].forEach(([string, bytes]) => {
const allFF = [255, 255, 255, 255, 255, 255, 255, 255];
target = new Uint8Array(allFF);
result = target.setFromBase64(string);
assert.same(result.read, string.length);
assert.same(result.written, bytes.length);
const expected = bytes.concat(allFF.slice(bytes.length));
assert.arrayEqual(target, expected, `decoding ${ string }`);
});
const base = new Uint8Array([255, 255, 255, 255, 255, 255, 255]);
const subarray = base.subarray(2, 5);
result = subarray.setFromBase64('Zm9vYmFy');
assert.same(result.read, 4);
assert.same(result.written, 3);
assert.arrayEqual(subarray, [102, 111, 111]);
assert.arrayEqual(base, [255, 255, 102, 111, 111, 255, 255]);
// buffer too small
target = new Uint8Array([255, 255, 255, 255, 255]);
result = target.setFromBase64('Zm9vYmFy');
assert.same(result.read, 4);
assert.same(result.written, 3);
assert.arrayEqual(target, [102, 111, 111, 255, 255]);
// buffer too small, padded
target = new Uint8Array([255, 255, 255, 255]);
result = target.setFromBase64('Zm9vYmE=');
assert.same(result.read, 4);
assert.same(result.written, 3);
assert.arrayEqual(target, [102, 111, 111, 255]);
// buffer exact
target = new Uint8Array([255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('Zm9vYmFy');
assert.same(result.read, 8);
assert.same(result.written, 6);
assert.arrayEqual(target, [102, 111, 111, 98, 97, 114]);
// buffer exact, padded
target = new Uint8Array([255, 255, 255, 255, 255]);
result = target.setFromBase64('Zm9vYmE=');
assert.same(result.read, 8);
assert.same(result.written, 5);
assert.arrayEqual(target, [102, 111, 111, 98, 97]);
// buffer exact, not padded
target = new Uint8Array([255, 255, 255, 255, 255]);
result = target.setFromBase64('Zm9vYmE');
assert.same(result.read, 7);
assert.same(result.written, 5);
assert.arrayEqual(target, [102, 111, 111, 98, 97]);
// buffer exact, padded, stop-before-partial
target = new Uint8Array([255, 255, 255, 255, 255]);
result = target.setFromBase64('Zm9vYmE=', { lastChunkHandling: 'stop-before-partial' });
assert.same(result.read, 8);
assert.same(result.written, 5);
assert.arrayEqual(target, [102, 111, 111, 98, 97]);
// buffer exact, not padded, stop-before-partial
target = new Uint8Array([255, 255, 255, 255, 255]);
result = target.setFromBase64('Zm9vYmE', { lastChunkHandling: 'stop-before-partial' });
assert.same(result.read, 4);
assert.same(result.written, 3);
assert.arrayEqual(target, [102, 111, 111, 255, 255]);
// buffer too large
target = new Uint8Array([255, 255, 255, 255, 255, 255, 255]);
result = target.setFromBase64('Zm9vYmFy');
assert.same(result.read, 8);
assert.same(result.written, 6);
assert.arrayEqual(target, [102, 111, 111, 98, 97, 114, 255]);
[
['Z g==', 'space'],
['Z\tg==', 'tab'],
['Z\u000Ag==', 'LF'],
['Z\u000Cg==', 'FF'],
['Z\u000Dg==', 'CR'],
].forEach(([string, name]) => {
target = new Uint8Array([255, 255, 255]);
result = target.setFromBase64(string);
assert.same(result.read, 5);
assert.same(result.written, 1);
assert.arrayEqual(target, [102, 255, 255], `ascii whitespace: ${ name }`);
});
target = new Uint8Array([255, 255, 255, 255, 255]);
assert.throws(() => target.setFromBase64('MjYyZm.9v'), SyntaxError, 'illegal character in second chunk');
assert.arrayEqual(target, [50, 54, 50, 255, 255], 'decoding from MjYyZm.9v should only write the valid chunks');
target = new Uint8Array([255, 255, 255, 255, 255]);
assert.throws(() => target.setFromBase64('MjYyZg', { lastChunkHandling: 'strict' }), SyntaxError, 'padding omitted with lastChunkHandling: strict');
assert.arrayEqual(target, [50, 54, 50, 255, 255], 'decoding from MjYyZg should only write the valid chunks');
target = new Uint8Array([255, 255, 255, 255, 255]);
assert.throws(() => target.setFromBase64('MjYyZg==='), SyntaxError, 'extra characters after padding');
assert.arrayEqual(target, [50, 54, 50, 255, 255], 'decoding from MjYyZg=== should not write the last chunk because it has extra padding');
target = new Uint8Array([255, 255, 255, 255, 255]);
assert.throws(() => target.setFromBase64('a'), SyntaxError, 'throws error on incorrect length of base64 string');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.uint8-array.set-from-hex.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.prototype.setFromHex', assert => {
const { setFromHex } = Uint8Array.prototype;
assert.isFunction(setFromHex);
assert.arity(setFromHex, 1);
assert.name(setFromHex, 'setFromHex');
assert.looksNative(setFromHex);
const array1 = new Uint8Array(11);
const result1 = array1.setFromHex('48656c6c6f20576f726c64');
assert.deepEqual(array1, new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]), 'array #1');
assert.deepEqual(result1, { read: 22, written: 11 }, 'result #1');
const array2 = new Uint8Array(10);
const result2 = array2.setFromHex('48656c6c6f20576f726c64');
assert.deepEqual(array2, new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108]), 'array #2');
assert.deepEqual(result2, { read: 20, written: 10 }, 'result #2');
const array3 = new Uint8Array(12);
const result3 = array3.setFromHex('48656c6c6f20576f726c64');
assert.deepEqual(array3, new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 0]), 'array #3');
assert.deepEqual(result3, { read: 22, written: 11 }, 'result #3');
const array4 = new Uint8Array(11);
assert.throws(() => array4.setFromHex('4865gc6c6f20576f726c64'), SyntaxError, 'throws on invalid #1');
assert.deepEqual(array4, new Uint8Array([72, 101, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'array #4');
if (ArrayBuffer.prototype.transfer) {
const array5 = new Uint8Array(11);
array5.buffer.transfer();
assert.throws(() => array5.setFromHex('48656c6c6f20576f726c64'), TypeError, 'detached');
}
// Should not throw an error on length-tracking views over ResizableArrayBuffer
// https://issues.chromium.org/issues/454630441
assert.notThrows(() => {
const rab = new ArrayBuffer(16, { maxByteLength: 1024 });
new Uint8Array(rab).setFromHex('cafed00d');
}, 'not throw an error on ResizableArrayBuffer');
assert.throws(() => setFromHex.call(Array(11), '48656c6c6f20576f726c64'), TypeError, "isn't generic, this #1");
assert.throws(() => setFromHex.call(new Int8Array(11), '48656c6c6f20576f726c64'), TypeError, "isn't generic, this #2");
assert.throws(() => new Uint8Array(11).setFromHex(null), TypeError, "isn't generic, arg #1");
assert.throws(() => new Uint8Array(11).setFromHex(undefined), TypeError, "isn't generic, arg #2");
assert.throws(() => new Uint8Array(11).setFromHex(1234), TypeError, "isn't generic, arg #3");
assert.throws(() => new Uint8Array(11).setFromHex(Object('48656c6c6f20576f726c64')), TypeError, "isn't generic, arg #4");
assert.throws(() => new Uint8Array(11).setFromHex('48656c6c6f20576f726c641'), SyntaxError, 'throws on invalid #2');
assert.throws(() => new Uint8Array(11).setFromHex('48656c6c6f20576f726c64 '), SyntaxError, 'throws on invalid #3');
assert.throws(() => new Uint8Array(11).setFromHex('48656c6c6f20576f726c64\n'), SyntaxError, 'throws on invalid #4');
// Test262
// Copyright 2024 Kevin Gibbons. All rights reserved.
// This code is governed by the BSD license found in the https://github.com/tc39/test262/blob/main/LICENSE file.
[
'a.a',
'aa^',
'a a',
'a\ta',
'a\u000Aa',
'a\u000Ca',
'a\u000Da',
'a\u00A0a', // nbsp
'a\u2009a', // thin space
'a\u2028a', // line separator
].forEach(value => assert.throws(() => new Uint8Array([255, 255, 255, 255, 255]).setFromHex(value), SyntaxError));
[
['', []],
['66', [102]],
['666f', [102, 111]],
['666F', [102, 111]],
['666f6f', [102, 111, 111]],
['666F6f', [102, 111, 111]],
['666f6f62', [102, 111, 111, 98]],
['666f6f6261', [102, 111, 111, 98, 97]],
['666f6f626172', [102, 111, 111, 98, 97, 114]],
].forEach(([string, bytes]) => {
const allFF = [255, 255, 255, 255, 255, 255, 255, 255];
const target = new Uint8Array(allFF);
const result = target.setFromHex(string);
assert.same(result.read, string.length);
assert.same(result.written, bytes.length);
const expected = bytes.concat(allFF.slice(bytes.length));
assert.arrayEqual(target, expected, `decoding ${ string }`);
});
const base = new Uint8Array([255, 255, 255, 255, 255, 255, 255]);
const subarray = base.subarray(2, 5);
let result = subarray.setFromHex('aabbcc');
assert.same(result.read, 6);
assert.same(result.written, 3);
assert.arrayEqual(subarray, [170, 187, 204]);
assert.arrayEqual(base, [255, 255, 170, 187, 204, 255, 255]);
// buffer too small
let target = new Uint8Array([255, 255]);
result = target.setFromHex('aabbcc');
assert.same(result.read, 4);
assert.same(result.written, 2);
assert.arrayEqual(target, [170, 187]);
// buffer exact
target = new Uint8Array([255, 255, 255]);
result = target.setFromHex('aabbcc');
assert.same(result.read, 6);
assert.same(result.written, 3);
assert.arrayEqual(target, [170, 187, 204]);
// buffer too large
target = new Uint8Array([255, 255, 255, 255]);
result = target.setFromHex('aabbcc');
assert.same(result.read, 6);
assert.same(result.written, 3);
assert.arrayEqual(target, [170, 187, 204, 255]);
[
'aaa ',
'aaag',
].forEach(value => {
target = new Uint8Array([255, 255, 255, 255, 255]);
assert.throws(() => target.setFromHex(value), SyntaxError);
assert.arrayEqual(target, [170, 255, 255, 255, 255], `decoding from ${ value }`);
});
target = new Uint8Array([255, 255, 255, 255, 255]);
assert.throws(() => target.setFromHex('aaa'), SyntaxError);
assert.arrayEqual(target, [255, 255, 255, 255, 255], 'when length is odd no data is written');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.uint8-array.to-base64.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.prototype.toBase64', assert => {
const { toBase64 } = Uint8Array.prototype;
assert.isFunction(toBase64);
assert.arity(toBase64, 0);
assert.name(toBase64, 'toBase64');
assert.looksNative(toBase64);
const array = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);
assert.same(array.toBase64(), 'SGVsbG8gV29ybGQ=', 'proper result');
assert.same(array.toBase64({ alphabet: 'base64' }), 'SGVsbG8gV29ybGQ=', 'proper result, base64');
assert.same(array.toBase64({ alphabet: 'base64url' }), 'SGVsbG8gV29ybGQ=', 'proper result, base64url');
assert.same(array.toBase64({ omitPadding: true }), 'SGVsbG8gV29ybGQ', 'proper result');
assert.same(array.toBase64({ omitPadding: false }), 'SGVsbG8gV29ybGQ=', 'proper result');
assert.throws(() => array.toBase64(null), TypeError, 'incorrect options argument #1');
assert.throws(() => array.toBase64(1), TypeError, 'incorrect options argument #2');
assert.throws(() => array.toBase64({ alphabet: 'base32' }), TypeError, 'incorrect encoding');
assert.same(new Uint8Array([215, 111, 247]).toBase64(), '12/3', 'encoding #1');
assert.same(new Uint8Array([215, 111, 247]).toBase64({ alphabet: 'base64' }), '12/3', 'encoding #2');
assert.same(new Uint8Array([215, 111, 247]).toBase64({ alphabet: 'base64url' }), '12_3', 'encoding #3');
assert.same(new Uint8Array([215, 111, 183]).toBase64(), '12+3', 'encoding #4');
assert.same(new Uint8Array([215, 111, 183]).toBase64({ alphabet: 'base64' }), '12+3', 'encoding #5');
assert.same(new Uint8Array([215, 111, 183]).toBase64({ alphabet: 'base64url' }), '12-3', 'encoding #6');
if (ArrayBuffer.prototype.transfer) {
const array2 = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);
array2.buffer.transfer();
assert.throws(() => array2.toBase64(), TypeError, 'detached');
}
assert.throws(() => toBase64.call(null), TypeError, "isn't generic #1");
assert.throws(() => toBase64.call(undefined), TypeError, "isn't generic #2");
assert.throws(() => toBase64.call(new Int16Array([1])), TypeError, "isn't generic #3");
assert.throws(() => toBase64.call([1]), TypeError, "isn't generic #4");
// Test262
// Copyright 2024 Kevin Gibbons. All rights reserved.
// This code is governed by the BSD license found in the https://github.com/tc39/test262/blob/main/LICENSE file.
assert.same(new Uint8Array([199, 239, 242]).toBase64(), 'x+/y');
assert.same(new Uint8Array([199, 239, 242]).toBase64({ alphabet: 'base64' }), 'x+/y');
assert.same(new Uint8Array([199, 239, 242]).toBase64({ alphabet: 'base64url' }), 'x-_y');
assert.throws(() => new Uint8Array([199, 239, 242]).toBase64({ alphabet: 'other' }), TypeError);
// works with default alphabet
assert.same(new Uint8Array([199, 239]).toBase64(), 'x+8=');
assert.same(new Uint8Array([199, 239]).toBase64({ omitPadding: false }), 'x+8=');
assert.same(new Uint8Array([199, 239]).toBase64({ omitPadding: true }), 'x+8');
assert.same(new Uint8Array([255]).toBase64({ omitPadding: true }), '/w');
// works with base64url alphabet
assert.same(new Uint8Array([199, 239]).toBase64({ alphabet: 'base64url' }), 'x-8=');
assert.same(new Uint8Array([199, 239]).toBase64({ alphabet: 'base64url', omitPadding: false }), 'x-8=');
assert.same(new Uint8Array([199, 239]).toBase64({ alphabet: 'base64url', omitPadding: true }), 'x-8');
assert.same(new Uint8Array([255]).toBase64({ alphabet: 'base64url', omitPadding: true }), '_w');
// performs ToBoolean on the argument
assert.same(new Uint8Array([255]).toBase64({ omitPadding: 0 }), '/w==');
assert.same(new Uint8Array([255]).toBase64({ omitPadding: 1 }), '/w');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.uint8-array.to-hex.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.prototype.toHex', assert => {
const { toHex } = Uint8Array.prototype;
assert.isFunction(toHex);
assert.arity(toHex, 0);
assert.name(toHex, 'toHex');
assert.looksNative(toHex);
assert.same(new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]).toHex(), '48656c6c6f20576f726c64', 'proper result #1');
assert.same(new Uint8Array([255, 255, 255, 255, 255, 255, 255, 255]).toHex(), 'ffffffffffffffff', 'proper result #2');
if (ArrayBuffer.prototype.transfer) {
const array = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);
array.buffer.transfer();
assert.throws(() => array.toHex(), TypeError, 'detached');
}
assert.throws(() => toHex.call(null), TypeError, "isn't generic #1");
assert.throws(() => toHex.call(undefined), TypeError, "isn't generic #2");
assert.throws(() => toHex.call(new Int16Array([1])), TypeError, "isn't generic #3");
assert.throws(() => toHex.call([1]), TypeError, "isn't generic #4");
// Test262
// Copyright 2024 Kevin Gibbons. All rights reserved.
// This code is governed by the BSD license found in the https://github.com/tc39/test262/blob/main/LICENSE file.
assert.same(new Uint8Array([]).toHex(), '');
assert.same(new Uint8Array([102]).toHex(), '66');
assert.same(new Uint8Array([102, 111]).toHex(), '666f');
assert.same(new Uint8Array([102, 111, 111]).toHex(), '666f6f');
assert.same(new Uint8Array([102, 111, 111, 98]).toHex(), '666f6f62');
assert.same(new Uint8Array([102, 111, 111, 98, 97]).toHex(), '666f6f6261');
assert.same(new Uint8Array([102, 111, 111, 98, 97, 114]).toHex(), '666f6f626172');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.unescape.js
|
JavaScript
|
QUnit.test('unescape', assert => {
assert.isFunction(unescape);
assert.name(unescape, 'unescape');
assert.arity(unescape, 1);
assert.looksNative(unescape);
assert.same(unescape('%21q2%u0444'), '!q2ф');
assert.same(unescape('%u044q2%21'), '%u044q2!');
assert.same(unescape(null), 'null');
assert.same(unescape(undefined), 'undefined');
if (typeof Symbol == 'function' && !Symbol.sham) {
assert.throws(() => unescape(Symbol('unescape test')), 'throws on symbol argument');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.weak-map.get-or-insert-computed.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
QUnit.test('WeakMap#getOrInsertComputed', assert => {
const { getOrInsertComputed } = WeakMap.prototype;
assert.isFunction(getOrInsertComputed);
assert.arity(getOrInsertComputed, 2);
assert.name(getOrInsertComputed, 'getOrInsertComputed');
assert.looksNative(getOrInsertComputed);
assert.nonEnumerable(WeakMap.prototype, 'getOrInsertComputed');
const a = {};
const b = {};
let map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsertComputed(a, () => 3), 2, 'result#1');
assert.same(map.get(a), 2, 'map#1');
map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsertComputed(b, () => 3), 3, 'result#2');
assert.same(map.get(a), 2, 'map#2-1');
assert.same(map.get(b), 3, 'map#2-2');
map = new WeakMap([[a, 2]]);
map.getOrInsertComputed(a, () => assert.avoid());
map = new WeakMap([[a, 2]]);
map.getOrInsertComputed(b, function (key) {
if (STRICT) assert.same(this, undefined, 'correct handler in callback');
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(key, b, 'correct key in callback');
});
map = new WeakMap([[a, 2]]);
assert.throws(() => {
map.getOrInsertComputed(1, () => assert.avoid());
}, TypeError, 'key validation before call of callback');
assert.throws(() => new WeakMap().getOrInsertComputed(1, () => 3), TypeError, 'invalid key#1');
assert.throws(() => new WeakMap().getOrInsertComputed(null, () => 3), TypeError, 'invalid key#2');
assert.throws(() => new WeakMap().getOrInsertComputed(undefined, () => 3), TypeError, 'invalid key#3');
assert.throws(() => new WeakMap().getOrInsertComputed(a, {}), TypeError, 'non-callable#1');
assert.throws(() => new WeakMap().getOrInsertComputed(a, 1), TypeError, 'non-callable#2');
assert.throws(() => new WeakMap().getOrInsertComputed(a, null), TypeError, 'non-callable#3');
assert.throws(() => new WeakMap().getOrInsertComputed(a, undefined), TypeError, 'non-callable#4');
assert.throws(() => new WeakMap().getOrInsertComputed(a), TypeError, 'non-callable#5');
assert.throws(() => getOrInsertComputed.call({}, a, () => 3), TypeError, 'non-generic#1');
assert.throws(() => getOrInsertComputed.call([], a, () => 3), TypeError, 'non-generic#2');
assert.throws(() => getOrInsertComputed.call(undefined, a, () => 3), TypeError, 'non-generic#3');
assert.throws(() => getOrInsertComputed.call(null, a, () => 3), TypeError, 'non-generic#4');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.weak-map.get-or-insert.js
|
JavaScript
|
QUnit.test('WeakMap#getOrInsert', assert => {
const { getOrInsert } = WeakMap.prototype;
assert.isFunction(getOrInsert);
assert.arity(getOrInsert, 2);
assert.name(getOrInsert, 'getOrInsert');
assert.looksNative(getOrInsert);
assert.nonEnumerable(WeakMap.prototype, 'getOrInsert');
const a = {};
const b = {};
let map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsert(a, 3), 2, 'result#1');
assert.same(map.get(a), 2, 'map#1');
map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsert(b, 3), 3, 'result#2');
assert.same(map.get(a), 2, 'map#2-1');
assert.same(map.get(b), 3, 'map#2-2');
assert.throws(() => new WeakMap().getOrInsert(1, 1), TypeError, 'invalid key#1');
assert.throws(() => new WeakMap().getOrInsert(null, 1), TypeError, 'invalid key#2');
assert.throws(() => new WeakMap().getOrInsert(undefined, 1), TypeError, 'invalid key#3');
assert.throws(() => new WeakMap().getOrInsert(), TypeError, 'invalid key#4');
assert.throws(() => getOrInsert.call({}, a, 1), TypeError, 'non-generic#1');
assert.throws(() => getOrInsert.call([], a, 1), TypeError, 'non-generic#2');
assert.throws(() => getOrInsert.call(undefined, a, 1), TypeError, 'non-generic#3');
assert.throws(() => getOrInsert.call(null, a, 1), TypeError, 'non-generic#4');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.weak-map.js
|
JavaScript
|
import { DESCRIPTORS, FREEZING, GLOBAL, NATIVE } from '../helpers/constants.js';
import { createIterable, nativeSubclass } from '../helpers/helpers.js';
const Symbol = GLOBAL.Symbol || {};
const { freeze, isFrozen, keys, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
QUnit.test('WeakMap', assert => {
assert.isFunction(WeakMap);
assert.name(WeakMap, 'WeakMap');
assert.arity(WeakMap, 0);
assert.looksNative(WeakMap);
assert.true('delete' in WeakMap.prototype, 'delete in WeakMap.prototype');
assert.true('get' in WeakMap.prototype, 'get in WeakMap.prototype');
assert.true('has' in WeakMap.prototype, 'has in WeakMap.prototype');
assert.true('set' in WeakMap.prototype, 'set in WeakMap.prototype');
assert.true(new WeakMap() instanceof WeakMap, 'new WeakMap instanceof WeakMap');
let object = {};
assert.same(new WeakMap(createIterable([[object, 42]])).get(object), 42, 'Init from iterable');
let weakmap = new WeakMap();
const frozen = freeze({});
weakmap.set(frozen, 42);
assert.same(weakmap.get(frozen), 42, 'Support frozen objects');
weakmap = new WeakMap();
weakmap.set(frozen, 42);
assert.true(weakmap.has(frozen), 'works with frozen objects, #1');
assert.same(weakmap.get(frozen), 42, 'works with frozen objects, #2');
weakmap.delete(frozen);
assert.false(weakmap.has(frozen), 'works with frozen objects, #3');
assert.same(weakmap.get(frozen), undefined, 'works with frozen objects, #4');
let done = false;
try {
new WeakMap(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.true(done, '.return #throw');
assert.false('clear' in WeakMap.prototype, 'should not contains `.clear` method');
const array = [];
done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return [][Symbol.iterator].call(this);
};
new WeakMap(array);
assert.true(done);
object = {};
new WeakMap().set(object, 1);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakMap);
assert.true(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.true(new Subclass() instanceof WeakMap, 'correct subclassing with native classes #2');
object = {};
assert.same(new Subclass().set(object, 2).get(object), 2, 'correct subclassing with native classes #3');
}
const buffer = new ArrayBuffer(8);
const map = new WeakMap([[buffer, 8]]);
assert.true(map.has(buffer), 'works with ArrayBuffer keys');
});
QUnit.test('WeakMap#delete', assert => {
assert.isFunction(WeakMap.prototype.delete);
if (NATIVE) assert.name(WeakMap.prototype.delete, 'delete');
if (NATIVE) assert.arity(WeakMap.prototype.delete, 1);
assert.looksNative(WeakMap.prototype.delete);
assert.nonEnumerable(WeakMap.prototype, 'delete');
const a = {};
const b = {};
const weakmap = new WeakMap();
weakmap.set(a, 42);
weakmap.set(b, 21);
assert.true(weakmap.has(a), 'WeakMap has values before .delete() #1');
assert.true(weakmap.has(b), 'WeakMap has values before .delete() #2');
weakmap.delete(a);
assert.false(weakmap.has(a), 'WeakMap has not value after .delete() #1');
assert.true(weakmap.has(b), 'WeakMap has not value after .delete() #2');
assert.notThrows(() => !weakmap.delete(1), 'return false on primitive');
const object = {};
weakmap.set(object, 42);
freeze(object);
assert.true(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.false(weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#get', assert => {
assert.isFunction(WeakMap.prototype.get);
assert.name(WeakMap.prototype.get, 'get');
if (NATIVE) assert.arity(WeakMap.prototype.get, 1);
assert.looksNative(WeakMap.prototype.get);
assert.nonEnumerable(WeakMap.prototype, 'get');
const weakmap = new WeakMap();
assert.same(weakmap.get({}), undefined, 'WeakMap .get() before .set() return undefined');
let object = {};
weakmap.set(object, 42);
assert.same(weakmap.get(object), 42, 'WeakMap .get() return value');
weakmap.delete(object);
assert.same(weakmap.get(object), undefined, 'WeakMap .get() after .delete() return undefined');
assert.notThrows(() => weakmap.get(1) === undefined, 'return undefined on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.same(weakmap.get(object), 42, 'works with frozen objects #1');
weakmap.delete(object);
assert.same(weakmap.get(object), undefined, 'works with frozen objects #2');
});
QUnit.test('WeakMap#has', assert => {
assert.isFunction(WeakMap.prototype.has);
assert.name(WeakMap.prototype.has, 'has');
if (NATIVE) assert.arity(WeakMap.prototype.has, 1);
assert.looksNative(WeakMap.prototype.has);
assert.nonEnumerable(WeakMap.prototype, 'has');
const weakmap = new WeakMap();
assert.false(weakmap.has({}), 'WeakMap .has() before .set() return false');
let object = {};
weakmap.set(object, 42);
assert.true(weakmap.has(object), 'WeakMap .has() return true');
weakmap.delete(object);
assert.false(weakmap.has(object), 'WeakMap .has() after .delete() return false');
assert.notThrows(() => !weakmap.has(1), 'return false on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.true(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.false(weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#set', assert => {
assert.isFunction(WeakMap.prototype.set);
assert.name(WeakMap.prototype.set, 'set');
assert.arity(WeakMap.prototype.set, 2);
assert.looksNative(WeakMap.prototype.set);
assert.nonEnumerable(WeakMap.prototype, 'set');
const weakmap = new WeakMap();
const object = {};
weakmap.set(object, 33);
assert.same(weakmap.get(object), 33, 'works with object as keys');
assert.same(weakmap.set({}, 42), weakmap, 'chaining');
assert.throws(() => new WeakMap().set(42, 42), 'throws with primitive keys');
const object1 = freeze({});
const object2 = {};
weakmap.set(object1, 42);
weakmap.set(object2, 42);
freeze(object);
assert.same(weakmap.get(object1), 42, 'works with frozen objects #1');
assert.same(weakmap.get(object2), 42, 'works with frozen objects #2');
weakmap.delete(object1);
weakmap.delete(object2);
assert.same(weakmap.get(object1), undefined, 'works with frozen objects #3');
assert.same(weakmap.get(object2), undefined, 'works with frozen objects #4');
const array = freeze([]);
weakmap.set(array, 42);
assert.same(weakmap.get(array), 42, 'works with frozen arrays #1');
if (FREEZING) assert.true(isFrozen(array), 'works with frozen arrays #2');
});
QUnit.test('WeakMap#@@toStringTag', assert => {
assert.same(WeakMap.prototype[Symbol.toStringTag], 'WeakMap', 'WeakMap::@@toStringTag is `WeakMap`');
assert.same(String(new WeakMap()), '[object WeakMap]', 'correct stringification');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.weak-set.js
|
JavaScript
|
import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants.js';
import { createIterable, nativeSubclass } from '../helpers/helpers.js';
const Symbol = GLOBAL.Symbol || {};
const { freeze, keys, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
QUnit.test('WeakSet', assert => {
assert.isFunction(WeakSet);
assert.name(WeakSet, 'WeakSet');
assert.arity(WeakSet, 0);
assert.looksNative(WeakSet);
assert.true('add' in WeakSet.prototype, 'add in WeakSet.prototype');
assert.true('delete' in WeakSet.prototype, 'delete in WeakSet.prototype');
assert.true('has' in WeakSet.prototype, 'has in WeakSet.prototype');
assert.true(new WeakSet() instanceof WeakSet, 'new WeakSet instanceof WeakSet');
let object = {};
assert.true(new WeakSet(createIterable([object])).has(object), 'Init from iterable');
const weakset = new WeakSet();
const frozen = freeze({});
weakset.add(frozen);
assert.true(weakset.has(frozen), 'works with frozen objects, #1');
weakset.delete(frozen);
assert.false(weakset.has(frozen), 'works with frozen objects, #2');
let done = false;
try {
new WeakSet(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.true(done, '.return #throw');
assert.false('clear' in WeakSet.prototype, 'should not contains `.clear` method');
const array = [];
done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return [][Symbol.iterator].call(this);
};
new WeakSet(array);
assert.true(done);
object = {};
new WeakSet().add(object);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakSet);
assert.true(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.true(new Subclass() instanceof WeakSet, 'correct subclassing with native classes #2');
object = {};
assert.true(new Subclass().add(object).has(object), 'correct subclassing with native classes #3');
}
const buffer = new ArrayBuffer(8);
const set = new WeakSet([buffer]);
assert.true(set.has(buffer), 'works with ArrayBuffer keys');
});
QUnit.test('WeakSet#add', assert => {
assert.isFunction(WeakSet.prototype.add);
assert.name(WeakSet.prototype.add, 'add');
assert.arity(WeakSet.prototype.add, 1);
assert.looksNative(WeakSet.prototype.add);
assert.nonEnumerable(WeakSet.prototype, 'add');
const weakset = new WeakSet();
assert.same(weakset.add({}), weakset, 'chaining');
assert.throws(() => new WeakSet().add(42), 'throws with primitive keys');
});
QUnit.test('WeakSet#delete', assert => {
assert.isFunction(WeakSet.prototype.delete);
if (NATIVE) assert.arity(WeakSet.prototype.delete, 1);
assert.looksNative(WeakSet.prototype.delete);
assert.nonEnumerable(WeakSet.prototype, 'delete');
const a = {};
const b = {};
const weakset = new WeakSet().add(a).add(b);
assert.true(weakset.has(a), 'WeakSet has values before .delete() #1');
assert.true(weakset.has(b), 'WeakSet has values before .delete() #2');
weakset.delete(a);
assert.false(weakset.has(a), 'WeakSet has not value after .delete() #1');
assert.true(weakset.has(b), 'WeakSet has not value after .delete() #2');
assert.notThrows(() => !weakset.delete(1), 'return false on primitive');
});
QUnit.test('WeakSet#has', assert => {
assert.isFunction(WeakSet.prototype.has);
assert.name(WeakSet.prototype.has, 'has');
assert.arity(WeakSet.prototype.has, 1);
assert.looksNative(WeakSet.prototype.has);
assert.nonEnumerable(WeakSet.prototype, 'has');
const weakset = new WeakSet();
assert.false(weakset.has({}), 'WeakSet has`nt value');
const object = {};
weakset.add(object);
assert.true(weakset.has(object), 'WeakSet has value after .add()');
weakset.delete(object);
assert.false(weakset.has(object), 'WeakSet has not value after .delete()');
assert.notThrows(() => !weakset.has(1), 'return false on primitive');
});
QUnit.test('WeakSet::@@toStringTag', assert => {
assert.same(WeakSet.prototype[Symbol.toStringTag], 'WeakSet', 'WeakSet::@@toStringTag is `WeakSet`');
assert.same(String(new WeakSet()), '[object WeakSet]', 'correct stringification');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.array.filter-out.js
|
JavaScript
|
// TODO: Remove from `core-js@4`
import { STRICT } from '../helpers/constants.js';
QUnit.test('Array#filterOut', assert => {
const { filterOut } = Array.prototype;
assert.isFunction(filterOut);
assert.arity(filterOut, 1);
assert.name(filterOut, 'filterOut');
assert.looksNative(filterOut);
assert.nonEnumerable(Array.prototype, 'filterOut');
let array = [1];
const context = {};
array.filterOut(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], [1, 2, 3, 'q', {}, 4, true, 5].filterOut(it => typeof it != 'number'));
if (STRICT) {
assert.throws(() => filterOut.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => filterOut.call(undefined, () => { /* empty */ }), TypeError);
}
assert.notThrows(() => filterOut.call({
length: -1,
0: 1,
}, () => {
throw new Error();
}), 'uses ToLength');
array = [];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(array.filterOut(Boolean).foo, 1, '@@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.array.filter-reject.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
QUnit.test('Array#filterReject', assert => {
const { filterReject } = Array.prototype;
assert.isFunction(filterReject);
assert.arity(filterReject, 1);
assert.name(filterReject, 'filterReject');
assert.looksNative(filterReject);
assert.nonEnumerable(Array.prototype, 'filterReject');
let array = [1];
const context = {};
array.filterReject(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], [1, 2, 3, 'q', {}, 4, true, 5].filterReject(it => typeof it != 'number'));
if (STRICT) {
assert.throws(() => filterReject.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => filterReject.call(undefined, () => { /* empty */ }), TypeError);
}
assert.notThrows(() => filterReject.call({
length: -1,
0: 1,
}, () => {
throw new Error();
}), 'uses ToLength');
array = [];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(array.filterReject(Boolean).foo, 1, '@@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.array.group-by-to-map.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
const { from } = Array;
QUnit.test('Array#groupByToMap', assert => {
const { groupByToMap } = Array.prototype;
assert.isFunction(groupByToMap);
assert.arity(groupByToMap, 1);
assert.looksNative(groupByToMap);
assert.nonEnumerable(Array.prototype, 'groupByToMap');
let array = [1];
const context = {};
array.groupByToMap(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true([].groupByToMap(it => it) instanceof Map, 'returns Map');
assert.deepEqual(from([1, 2, 3].groupByToMap(it => it % 2)), [[1, [1, 3]], [0, [2]]], '#1');
assert.deepEqual(
from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].groupByToMap(it => `i${ it % 5 }`)),
[['i1', [1, 6, 11]], ['i2', [2, 7, 12]], ['i3', [3, 8]], ['i4', [4, 9]], ['i0', [5, 10]]],
'#2',
);
assert.deepEqual(from(Array(3).groupByToMap(it => it)), [[undefined, [undefined, undefined, undefined]]], '#3');
if (STRICT) {
assert.throws(() => groupByToMap.call(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => groupByToMap.call(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(array.groupByToMap(Boolean).get(true).foo, undefined, 'no @@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.array.group-by.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
const { getPrototypeOf } = Object;
QUnit.test('Array#groupBy', assert => {
const { groupBy } = Array.prototype;
assert.isFunction(groupBy);
assert.arity(groupBy, 1);
assert.name(groupBy, 'groupBy');
assert.looksNative(groupBy);
assert.nonEnumerable(Array.prototype, 'groupBy');
let array = [1];
const context = {};
array.groupBy(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(getPrototypeOf([].groupBy(it => it)), null, 'null proto');
assert.deepEqual([1, 2, 3].groupBy(it => it % 2), { 1: [1, 3], 0: [2] }, '#1');
assert.deepEqual(
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].groupBy(it => `i${ it % 5 }`),
{ i1: [1, 6, 11], i2: [2, 7, 12], i3: [3, 8], i4: [4, 9], i0: [5, 10] },
'#2',
);
assert.deepEqual(Array(3).groupBy(it => it), { undefined: [undefined, undefined, undefined] }, '#3');
if (STRICT) {
assert.throws(() => groupBy.call(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => groupBy.call(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(array.groupBy(Boolean).true.foo, undefined, 'no @@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.array.group-to-map.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
const { from } = Array;
QUnit.test('Array#groupToMap', assert => {
const { groupToMap } = Array.prototype;
assert.isFunction(groupToMap);
assert.arity(groupToMap, 1);
assert.name(groupToMap, 'groupToMap');
assert.looksNative(groupToMap);
assert.nonEnumerable(Array.prototype, 'groupToMap');
let array = [1];
const context = {};
array.groupToMap(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true([].groupToMap(it => it) instanceof Map, 'returns Map');
assert.deepEqual(from([1, 2, 3].groupToMap(it => it % 2)), [[1, [1, 3]], [0, [2]]], '#1');
assert.deepEqual(
from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].groupToMap(it => `i${ it % 5 }`)),
[['i1', [1, 6, 11]], ['i2', [2, 7, 12]], ['i3', [3, 8]], ['i4', [4, 9]], ['i0', [5, 10]]],
'#2',
);
assert.deepEqual(from(Array(3).groupToMap(it => it)), [[undefined, [undefined, undefined, undefined]]], '#3');
if (STRICT) {
assert.throws(() => groupToMap.call(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => groupToMap.call(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(array.groupToMap(Boolean).get(true).foo, undefined, 'no @@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.array.group.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
const { getPrototypeOf } = Object;
QUnit.test('Array#group', assert => {
const { group } = Array.prototype;
assert.isFunction(group);
assert.arity(group, 1);
assert.name(group, 'group');
assert.looksNative(group);
assert.nonEnumerable(Array.prototype, 'group');
let array = [1];
const context = {};
array.group(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(getPrototypeOf([].group(it => it)), null, 'null proto');
assert.deepEqual([1, 2, 3].group(it => it % 2), { 1: [1, 3], 0: [2] }, '#1');
assert.deepEqual(
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].group(it => `i${ it % 5 }`),
{ i1: [1, 6, 11], i2: [2, 7, 12], i3: [3, 8], i4: [4, 9], i0: [5, 10] },
'#2',
);
assert.deepEqual(Array(3).group(it => it), { undefined: [undefined, undefined, undefined] }, '#3');
if (STRICT) {
assert.throws(() => group.call(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => group.call(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(array.group(Boolean).true.foo, undefined, 'no @@species');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.array.is-template-object.js
|
JavaScript
|
QUnit.test('Array.isTemplateObject', assert => {
const { isTemplateObject } = Array;
const { freeze } = Object;
assert.isFunction(isTemplateObject);
assert.arity(isTemplateObject, 1);
assert.name(isTemplateObject, 'isTemplateObject');
assert.looksNative(isTemplateObject);
assert.nonEnumerable(Array, 'isTemplateObject');
assert.false(isTemplateObject(undefined));
assert.false(isTemplateObject(null));
assert.false(isTemplateObject({}));
assert.false(isTemplateObject(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()));
assert.false(isTemplateObject([]));
assert.false(isTemplateObject(freeze([])));
const template = (() => {
try {
// eslint-disable-next-line no-template-curly-in-string -- safe
return Function('return (it => it)`qwe${ 123 }asd`')();
} catch { /* empty */ }
})();
if (template) assert.true(isTemplateObject(template));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.array.last-index.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Array#lastIndex', assert => {
const descriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'lastIndex');
assert.isFunction(descriptor.get);
assert.false(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same([1, 2, 3].lastIndex, 2);
assert.same([].lastIndex, 0);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.array.last-item.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Array#lastItem', assert => {
const descriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'lastItem');
assert.isFunction(descriptor.get);
assert.isFunction(descriptor.set);
assert.false(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same([1, 2, 3].lastItem, 3);
assert.same([].lastItem, undefined);
let array = [1, 2, 3];
array.lastItem = 4;
assert.deepEqual(array, [1, 2, 4]);
array = [];
array.lastItem = 5;
assert.deepEqual(array, [5]);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.array.unique-by.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
QUnit.test('Array#uniqueBy', assert => {
const { uniqueBy } = Array.prototype;
assert.isFunction(uniqueBy);
assert.arity(uniqueBy, 1);
assert.name(uniqueBy, 'uniqueBy');
assert.looksNative(uniqueBy);
assert.nonEnumerable(Array.prototype, 'uniqueBy');
let array = [1, 2, 3, 2, 1];
assert.notSame(array.uniqueBy(), array);
assert.deepEqual(array.uniqueBy(), [1, 2, 3]);
array = [
{
id: 1,
uid: 10000,
},
{
id: 2,
uid: 10000,
},
{
id: 3,
uid: 10001,
},
];
assert.deepEqual(array.uniqueBy(it => it.uid), [
{
id: 1,
uid: 10000,
},
{
id: 3,
uid: 10001,
},
]);
assert.deepEqual(array.uniqueBy(({ id, uid }) => `${ id }-${ uid }`), array);
assert.deepEqual([1, undefined, 2, undefined, null, 1].uniqueBy(), [1, undefined, 2, null]);
assert.deepEqual([0, -0].uniqueBy(), [0]);
assert.deepEqual([NaN, NaN].uniqueBy(), [NaN]);
assert.deepEqual(uniqueBy.call({ length: 1, 0: 1 }), [1]);
if (STRICT) {
assert.throws(() => uniqueBy.call(null), TypeError);
assert.throws(() => uniqueBy.call(undefined), TypeError);
}
assert.true('uniqueBy' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.as-indexed-pairs.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('AsyncIterator#asIndexedPairs', assert => {
const { asIndexedPairs } = AsyncIterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
// assert.name(asIndexedPairs, 'asIndexedPairs');
assert.looksNative(asIndexedPairs);
assert.nonEnumerable(AsyncIterator.prototype, 'asIndexedPairs');
if (STRICT) {
assert.throws(() => asIndexedPairs.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => asIndexedPairs.call(null, () => { /* empty */ }), TypeError);
}
return asIndexedPairs.call(createIterator(['a', 'b', 'c'])).toArray().then(it => {
assert.same(it.toString(), '0,a,1,b,2,c', 'basic functionality');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.constructor.js
|
JavaScript
|
import { nativeSubclass } from '../helpers/helpers.js';
const { getPrototypeOf } = Object;
QUnit.test('AsyncIterator', assert => {
assert.isFunction(AsyncIterator);
assert.arity(AsyncIterator, 0);
assert.name(AsyncIterator, 'AsyncIterator');
assert.looksNative(AsyncIterator);
const asyncGenerator = (() => {
try {
return Function('return async function*(){}()')();
} catch { /* empty */ }
})();
if (asyncGenerator && globalThis.USE_FUNCTION_CONSTRUCTOR) {
const proto = getPrototypeOf(getPrototypeOf(getPrototypeOf(asyncGenerator)));
if (proto !== Object.prototype && proto !== null) {
assert.true(asyncGenerator instanceof AsyncIterator, 'AsyncGenerator');
}
}
assert.true(AsyncIterator.from([1, 2, 3]) instanceof AsyncIterator, 'Async From Proxy');
assert.true(AsyncIterator.from([1, 2, 3]).drop(1) instanceof AsyncIterator, 'Async Drop Proxy');
if (nativeSubclass) {
const Sub = nativeSubclass(AsyncIterator);
assert.true(new Sub() instanceof AsyncIterator, 'abstract constructor');
}
assert.throws(() => new AsyncIterator(), 'direct constructor throws');
assert.throws(() => AsyncIterator(), 'throws w/o `new`');
});
QUnit.test('AsyncIterator#constructor', assert => {
assert.same(AsyncIterator.prototype.constructor, AsyncIterator, 'AsyncIterator#constructor is AsyncIterator');
});
QUnit.test('AsyncIterator#@@toStringTag', assert => {
assert.same(AsyncIterator.prototype[Symbol.toStringTag], 'AsyncIterator', 'AsyncIterator::@@toStringTag is `AsyncIterator`');
assert.same(String(AsyncIterator.from([1, 2, 3])), '[object AsyncIterator]', 'correct stringification');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.drop.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('AsyncIterator#drop', assert => {
const { drop } = AsyncIterator.prototype;
assert.isFunction(drop);
assert.arity(drop, 1);
assert.name(drop, 'drop');
assert.looksNative(drop);
assert.nonEnumerable(AsyncIterator.prototype, 'drop');
if (STRICT) {
assert.throws(() => drop.call(undefined, 1), TypeError);
assert.throws(() => drop.call(null, 1), TypeError);
}
assert.throws(() => drop.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
assert.throws(() => drop.call(createIterator([1, 2, 3]), NaN), RangeError, 'NaN');
return drop.call(createIterator([1, 2, 3]), 1).toArray().then(it => {
assert.arrayEqual(it, [2, 3], 'basic functionality');
return drop.call(createIterator([1, 2, 3]), 1.5).toArray();
}).then(it => {
assert.arrayEqual(it, [2, 3], 'float');
return drop.call(createIterator([1, 2, 3]), 4).toArray();
}).then(it => {
assert.arrayEqual(it, [], 'big');
return drop.call(createIterator([1, 2, 3]), 0).toArray();
}).then(it => {
assert.arrayEqual(it, [1, 2, 3], 'zero');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.every.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#every', assert => {
const { every } = AsyncIterator.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.looksNative(every);
assert.nonEnumerable(AsyncIterator.prototype, 'every');
if (STRICT) {
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => every.call(createIterator([1]), undefined), TypeError);
assert.throws(() => every.call(createIterator([1]), null), TypeError);
assert.throws(() => every.call(createIterator([1]), {}), TypeError);
const counters = [];
return every.call(createIterator([1, 2, 3]), it => typeof it == 'number').then(result => {
assert.true(result, 'basic functionality, +');
return every.call(createIterator([1, 2, 3]), it => it === 2);
}).then(result => {
assert.false(result, 'basic functionality, -');
return every.call(createIterator([1, 2, 3]), (value, counter) => {
counters.push(counter);
return true;
});
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return every.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
}).then(() => {
return every.call(createIterator([1]), () => { throw 42; });
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => {
return every.call(
createIterator([1], { return() { throw 43; } }),
() => { throw 42; },
);
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error even if return() throws');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.filter.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#filter', assert => {
const { filter } = AsyncIterator.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.looksNative(filter);
assert.nonEnumerable(AsyncIterator.prototype, 'filter');
if (STRICT) {
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => filter.call(createIterator([1]), undefined), TypeError);
assert.throws(() => filter.call(createIterator([1]), null), TypeError);
assert.throws(() => filter.call(createIterator([1]), {}), TypeError);
const counters = [];
return filter.call(createIterator([1, 2, 3]), it => it % 2).toArray().then(it => {
assert.arrayEqual(it, [1, 3], 'basic functionality');
return filter.call(createIterator([1, 2, 3]), (value, counter) => {
counters.push(counter);
return value;
}).toArray();
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return filter.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
}).toArray();
}).then(() => {
return filter.call(createIterator([1]), () => { throw 42; }).toArray();
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.find.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#find', assert => {
const { find } = AsyncIterator.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.looksNative(find);
assert.nonEnumerable(AsyncIterator.prototype, 'find');
if (STRICT) {
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => find.call(createIterator([1]), undefined), TypeError);
assert.throws(() => find.call(createIterator([1]), null), TypeError);
assert.throws(() => find.call(createIterator([1]), {}), TypeError);
const counters = [];
return find.call(createIterator([2, 3, 4]), it => it % 2).then(result => {
assert.same(result, 3, 'basic functionality, +');
return find.call(createIterator([1, 2, 3]), it => it === 4);
}).then(result => {
assert.same(result, undefined, 'basic functionality, -');
return find.call(createIterator([1, 2, 3]), (value, counter) => {
counters.push(counter);
return false;
});
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return find.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
}).then(() => {
return find.call(createIterator([1]), () => { throw 42; });
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => {
return find.call(
createIterator([1], { return() { throw 43; } }),
() => { throw 42; },
);
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error even if return() throws');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.flat-map.js
|
JavaScript
|
import { createIterator, createIterable } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
const { from } = AsyncIterator;
QUnit.test('AsyncIterator#flatMap', assert => {
const { flatMap } = AsyncIterator.prototype;
assert.isFunction(flatMap);
assert.arity(flatMap, 1);
assert.name(flatMap, 'flatMap');
assert.looksNative(flatMap);
assert.nonEnumerable(AsyncIterator.prototype, 'flatMap');
if (STRICT) {
assert.throws(() => flatMap.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => flatMap.call(createIterator([1]), undefined), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), null), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), {}), TypeError);
return flatMap.call(createIterator([1, [], 2, createIterable([3, 4]), [5, 6]]), it => typeof it == 'number' ? [-it] : it).toArray().then(it => {
assert.arrayEqual(it, [-1, -2, 3, 4, 5, 6], 'basic functionality');
return flatMap.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
return [arg];
}).toArray();
}).then(() => {
return flatMap.call(createIterator([1]), () => { throw 42; }).toArray();
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
});
});
QUnit.test('AsyncIterator#flatMap, inner iterator async close on return', assert => {
assert.expect(3);
const async = assert.async();
let innerReturnAwaited = false;
const outer = from({
next() {
return Promise.resolve({ value: [1, 2, 3], done: false });
},
return() {
assert.true(innerReturnAwaited, 'inner return() fully awaited before outer return()');
return Promise.resolve({ value: undefined, done: true });
},
[Symbol.asyncIterator]() { return this; },
});
const helper = outer.flatMap(arr => {
let i = 0;
return {
next() {
return Promise.resolve(i < arr.length
? { value: arr[i++], done: false }
: { value: undefined, done: true });
},
return() {
assert.required('inner return() called');
return new Promise(resolve => {
setTimeout(() => {
innerReturnAwaited = true;
resolve({ value: undefined, done: true });
}, 50);
});
},
[Symbol.asyncIterator]() { return this; },
};
});
helper.next().then(first => {
assert.same(first.value, 1, 'got first value');
return helper.return();
}).then(() => {
async();
}, () => {
assert.avoid();
async();
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.for-each.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#forEach', assert => {
const { forEach } = AsyncIterator.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.name(forEach, 'forEach');
assert.looksNative(forEach);
assert.nonEnumerable(AsyncIterator.prototype, 'forEach');
if (STRICT) {
assert.throws(() => forEach.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => forEach.call(createIterator([1]), undefined), TypeError);
assert.throws(() => forEach.call(createIterator([1]), null), TypeError);
assert.throws(() => forEach.call(createIterator([1]), {}), TypeError);
const array = [];
const counters = [];
return forEach.call(createIterator([1, 2, 3]), it => array.push(it)).then(() => {
assert.arrayEqual(array, [1, 2, 3], 'basic functionality');
return forEach.call(createIterator([1, 2, 3]), (value, counter) => counters.push(counter));
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return forEach.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
}).then(() => {
return forEach.call(createIterator([1]), () => { throw 42; });
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => {
return forEach.call(
createIterator([1], { return() { throw 43; } }),
() => { throw 42; },
);
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error even if return() throws');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.from.js
|
JavaScript
|
import ITERATOR from 'core-js-pure/es/symbol/iterator';
const { assign, create } = Object;
QUnit.test('AsyncIterator.from', assert => {
const { from } = AsyncIterator;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(AsyncIterator, 'from');
assert.true(AsyncIterator.from([].values()) instanceof AsyncIterator, 'proxy, iterator');
assert.true(AsyncIterator.from([]) instanceof AsyncIterator, 'proxy, iterable');
const asyncIterator = assign(create(AsyncIterator.prototype), {
next: () => { /* empty */ },
});
assert.same(AsyncIterator.from(asyncIterator), asyncIterator, 'does not wrap AsyncIterator instances');
assert.throws(() => from(undefined), TypeError);
assert.throws(() => from(null), TypeError);
const closableIterator = {
closed: false,
[ITERATOR]() { return this; },
next() {
return { value: Promise.reject(42), done: false };
},
return() {
this.closed = true;
return { value: undefined, done: true };
},
};
return AsyncIterator.from([1, Promise.resolve(2), 3]).toArray().then(result => {
assert.arrayEqual(result, [1, 2, 3], 'unwrap promises');
}).then(() => {
return from(Iterator.from(closableIterator)).toArray();
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
assert.true(closableIterator.closed, 'doesn\'t close sync iterator on promise rejection');
});
});
QUnit.test('AsyncIterator.from, sync iterator value forwarding', assert => {
assert.expect(5);
const async = assert.async();
function * gen() {
const x = yield 1;
yield x;
}
const asyncIter = AsyncIterator.from(gen());
asyncIter.next().then(r1 => {
assert.same(r1.value, 1, 'first yield value');
assert.false(r1.done, 'not done after first yield');
return asyncIter.next(42);
}).then(r2 => {
assert.same(r2.value, 42, 'next(value) forwarded to sync generator');
assert.false(r2.done, 'not done after second yield');
return asyncIter.next();
}).then(r3 => {
assert.true(r3.done, 'done after generator completes');
async();
}).catch(() => {
assert.avoid();
async();
});
});
QUnit.test('AsyncIterator.from, sync iterator throw forwarding', assert => {
assert.expect(2);
const async = assert.async();
function * gen() {
try {
yield 1;
} catch (error) {
yield `caught: ${ error }`;
}
}
const asyncIter = AsyncIterator.from(gen());
asyncIter.next().then(() => {
return asyncIter.throw('boom');
}).then(result => {
assert.same(result.value, 'caught: boom', 'throw(value) forwarded to sync generator');
assert.false(result.done, 'not done after catch yield');
async();
}).catch(() => {
assert.avoid();
async();
});
});
QUnit.test('AsyncIterator.from, throw closes iterator without throw method', assert => {
assert.expect(2);
const async = assert.async();
let closeCalled = false;
const iter = AsyncIterator.from({
next() { return { value: 1, done: false }; },
return() { closeCalled = true; return { value: undefined, done: true }; },
[Symbol.iterator]() { return this; },
});
iter.next().then(() => {
return iter.throw('error');
}).then(() => {
assert.avoid();
async();
}, error => {
assert.same(error, 'error', 'rejects with thrown value');
assert.true(closeCalled, 'closes iterator when no throw method');
async();
});
});
QUnit.test('AsyncIterator.from, return(value) without iterator return method', assert => {
assert.expect(2);
const async = assert.async();
const iter = AsyncIterator.from({
next() { return { value: 1, done: false }; },
[Symbol.iterator]() { return this; },
});
iter.return(42).then(result => {
assert.same(result.value, 42, 'return(value) forwards value when no return method');
assert.true(result.done, 'done is true');
async();
}).catch(() => {
assert.avoid();
async();
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.indexed.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('AsyncIterator#indexed', assert => {
const { indexed } = AsyncIterator.prototype;
assert.isFunction(indexed);
assert.arity(indexed, 0);
assert.name(indexed, 'indexed');
assert.looksNative(indexed);
assert.nonEnumerable(AsyncIterator.prototype, 'indexed');
if (STRICT) {
assert.throws(() => indexed.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => indexed.call(null, () => { /* empty */ }), TypeError);
}
return indexed.call(createIterator(['a', 'b', 'c'])).toArray().then(it => {
assert.same(it.toString(), '0,a,1,b,2,c', 'basic functionality');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.map.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#map', assert => {
const { map } = AsyncIterator.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.name(map, 'map');
assert.looksNative(map);
assert.nonEnumerable(AsyncIterator.prototype, 'map');
if (STRICT) {
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => map.call(createIterator([1]), undefined), TypeError);
assert.throws(() => map.call(createIterator([1]), null), TypeError);
assert.throws(() => map.call(createIterator([1]), {}), TypeError);
const counters = [];
return map.call(createIterator([1, 2, 3]), it => it ** 2).toArray().then(it => {
assert.arrayEqual(it, [1, 4, 9], 'basic functionality');
return map.call(createIterator([1, 2, 3]), (value, counter) => {
counters.push(counter);
return value;
}).toArray();
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return map.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
}).toArray();
}).then(() => {
return map.call(createIterator([1]), () => { throw 42; }).toArray();
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.reduce.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#reduce', assert => {
const { reduce } = AsyncIterator.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.looksNative(reduce);
assert.nonEnumerable(AsyncIterator.prototype, 'reduce');
if (STRICT) {
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
}
assert.throws(() => reduce.call(createIterator([1]), undefined, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), null, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), {}, 1), TypeError);
return reduce.call(createIterator([1, 2, 3]), (a, b) => a + b, 1).then(it => {
assert.same(it, 7, 'basic functionality, initial');
return reduce.call(createIterator([2]), function (a, b, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 3, 'arguments length');
assert.same(a, 1, 'argument 1');
assert.same(b, 2, 'argument 2');
assert.same(counter, 0, 'counter');
}, 1);
}).then(() => {
return reduce.call(createIterator([1, 2, 3]), (a, b) => a + b);
}).then(it => {
assert.same(it, 6, 'basic functionality, no initial');
// counter increments unconditionally, so first reducer call gets counter=1
const countersNoInit = [];
return reduce.call(createIterator([10, 20, 30]), (a, b, counter) => {
countersNoInit.push(counter);
return a + b;
}).then(() => {
assert.deepEqual(countersNoInit, [1, 2], 'counter without initial value');
});
}).then(() => {
return reduce.call(createIterator([]), (a, b) => a + b);
}).catch(() => {
assert.required('reduce an empty iterable with no initial');
return reduce.call(createIterator([1]), () => { throw 42; }, 1);
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.some.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#some', assert => {
const { some } = AsyncIterator.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.looksNative(some);
assert.nonEnumerable(AsyncIterator.prototype, 'some');
if (STRICT) {
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => some.call(createIterator([1]), undefined), TypeError);
assert.throws(() => some.call(createIterator([1]), null), TypeError);
assert.throws(() => some.call(createIterator([1]), {}), TypeError);
const counters = [];
return some.call(createIterator([1, 2, 3]), it => it === 2).then(result => {
assert.true(result, 'basic functionality, +');
return some.call(createIterator([1, 2, 3]), it => it === 4);
}).then(result => {
assert.false(result, 'basic functionality, -');
return some.call(createIterator([1, 2, 3]), (value, counter) => {
counters.push(counter);
return false;
});
}).then(() => {
assert.arrayEqual(counters, [0, 1, 2], 'counter incremented');
return some.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
}).then(() => {
return some.call(createIterator([1]), () => { throw 42; });
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => {
return some.call(
createIterator([1], { return() { throw 43; } }),
() => { throw 42; },
);
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error even if return() throws');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.take.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('AsyncIterator#take', assert => {
const { take } = AsyncIterator.prototype;
assert.isFunction(take);
assert.arity(take, 1);
assert.name(take, 'take');
assert.looksNative(take);
assert.nonEnumerable(AsyncIterator.prototype, 'take');
if (STRICT) {
assert.throws(() => take.call(undefined, 1), TypeError);
assert.throws(() => take.call(null, 1), TypeError);
}
assert.throws(() => take.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
assert.throws(() => take.call(createIterator([1, 2, 3]), NaN), RangeError, 'NaN');
return take.call(createIterator([1, 2, 3]), 2).toArray().then(it => {
assert.arrayEqual(it, [1, 2], 'basic functionality');
return take.call(createIterator([1, 2, 3]), 1.5).toArray();
}).then(it => {
assert.arrayEqual(it, [1], 'float');
return take.call(createIterator([1, 2, 3]), 4).toArray();
}).then(it => {
assert.arrayEqual(it, [1, 2, 3], 'big');
return take.call(createIterator([1, 2, 3]), 0).toArray();
}).then(it => {
assert.arrayEqual(it, [], 'zero');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.async-iterator.to-array.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('AsyncIterator#toArray', assert => {
const { toArray } = AsyncIterator.prototype;
assert.isFunction(toArray);
assert.arity(toArray, 0);
assert.name(toArray, 'toArray');
assert.looksNative(toArray);
assert.nonEnumerable(AsyncIterator.prototype, 'toArray');
if (STRICT) {
assert.throws(() => toArray.call(undefined), TypeError);
assert.throws(() => toArray.call(null), TypeError);
}
return toArray.call(createIterator([1, 2, 3])).then(it => {
assert.arrayEqual(it, [1, 2, 3]);
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.bigint.range.js
|
JavaScript
|
/* eslint-disable es/no-bigint -- safe */
if (typeof BigInt == 'function') QUnit.test('BigInt.range', assert => {
const { range } = BigInt;
const { from } = Array;
assert.isFunction(range);
assert.name(range, 'range');
assert.arity(range, 3);
assert.looksNative(range);
assert.nonEnumerable(BigInt, 'range');
let iterator = range(BigInt(1), BigInt(2));
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: BigInt(1),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.deepEqual(from(range(BigInt(-1), BigInt(5))), [BigInt(-1), BigInt(0), BigInt(1), BigInt(2), BigInt(3), BigInt(4)]);
assert.deepEqual(from(range(BigInt(-5), BigInt(1))), [BigInt(-5), BigInt(-4), BigInt(-3), BigInt(-2), BigInt(-1), BigInt(0)]);
assert.deepEqual(
from(range(BigInt('9007199254740991'), BigInt('9007199254740992'), { inclusive: true })),
[BigInt('9007199254740991'), BigInt('9007199254740992')],
);
assert.deepEqual(from(range(BigInt(0), BigInt(0))), []);
assert.deepEqual(from(range(BigInt(0), BigInt(-5), BigInt(1))), []);
iterator = range(BigInt(1), BigInt(3));
assert.deepEqual(iterator.start, BigInt(1));
assert.deepEqual(iterator.end, BigInt(3));
assert.deepEqual(iterator.step, BigInt(1));
assert.false(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { inclusive: true });
assert.deepEqual(iterator.start, BigInt(-1));
assert.deepEqual(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(-1));
assert.true(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { step: BigInt(4), inclusive() { /* empty */ } });
assert.same(iterator.start, BigInt(-1));
assert.same(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(4));
assert.true(iterator.inclusive);
iterator = range(BigInt(0), BigInt(5));
assert.throws(() => Object.getOwnPropertyDescriptor(iterator, 'start').get.call({}), TypeError);
assert.throws(() => range(Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(-Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), Infinity), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), { step: Infinity }), TypeError);
assert.throws(() => range({}, BigInt(1)), TypeError);
assert.throws(() => range(BigInt(1), {}), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.composite-key.js
|
JavaScript
|
import { FREEZING } from '../helpers/constants.js';
const { getPrototypeOf, isFrozen } = Object;
QUnit.test('compositeKey', assert => {
assert.isFunction(compositeKey);
assert.name(compositeKey, 'compositeKey');
assert.looksNative(compositeKey);
const key = compositeKey({});
assert.same(typeof key, 'object');
assert.same({}.toString.call(key), '[object Object]');
assert.same(getPrototypeOf(key), null);
if (FREEZING) assert.true(isFrozen(key));
const a = ['a'];
const b = ['b'];
const c = ['c'];
assert.same(compositeKey(a), compositeKey(a));
assert.notSame(compositeKey(a), compositeKey(['a']));
assert.notSame(compositeKey(a), compositeKey(a, 1));
assert.notSame(compositeKey(a), compositeKey(a, b));
assert.same(compositeKey(a, 1), compositeKey(a, 1));
assert.same(compositeKey(a, b), compositeKey(a, b));
assert.notSame(compositeKey(a, b), compositeKey(b, a));
assert.same(compositeKey(a, b, c), compositeKey(a, b, c));
assert.notSame(compositeKey(a, b, c), compositeKey(c, b, a));
assert.notSame(compositeKey(a, b, c), compositeKey(a, c, b));
assert.notSame(compositeKey(a, b, c, 1), compositeKey(a, b, c));
assert.same(compositeKey(a, b, c, 1), compositeKey(a, b, c, 1));
assert.same(compositeKey(1, a), compositeKey(1, a));
assert.notSame(compositeKey(1, a), compositeKey(a, 1));
assert.same(compositeKey(1, a, 2, b), compositeKey(1, a, 2, b));
assert.notSame(compositeKey(1, a, 2, b), compositeKey(1, a, b, 2));
assert.same(compositeKey(1, 2, a, b), compositeKey(1, 2, a, b));
assert.notSame(compositeKey(1, 2, a, b), compositeKey(1, a, b, 2));
assert.same(compositeKey(a, a), compositeKey(a, a));
assert.notSame(compositeKey(a, a), compositeKey(a, ['a']));
assert.notSame(compositeKey(a, a), compositeKey(a, b));
assert.throws(() => compositeKey(), TypeError);
assert.throws(() => compositeKey(1, 2), TypeError);
assert.throws(() => compositeKey('foo', null, true), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.composite-symbol.js
|
JavaScript
|
QUnit.test('compositeSymbol', assert => {
assert.isFunction(compositeSymbol);
assert.name(compositeSymbol, 'compositeSymbol');
assert.looksNative(compositeSymbol);
assert.true(Object(compositeSymbol({})) instanceof Symbol);
const a = ['a'];
const b = ['b'];
const c = ['c'];
assert.same(compositeSymbol(a), compositeSymbol(a));
assert.notSame(compositeSymbol(a), compositeSymbol(['a']));
assert.notSame(compositeSymbol(a), compositeSymbol(a, 1));
assert.notSame(compositeSymbol(a), compositeSymbol(a, b));
assert.same(compositeSymbol(a, 1), compositeSymbol(a, 1));
assert.same(compositeSymbol(a, b), compositeSymbol(a, b));
assert.notSame(compositeSymbol(a, b), compositeSymbol(b, a));
assert.same(compositeSymbol(a, b, c), compositeSymbol(a, b, c));
assert.notSame(compositeSymbol(a, b, c), compositeSymbol(c, b, a));
assert.notSame(compositeSymbol(a, b, c), compositeSymbol(a, c, b));
assert.notSame(compositeSymbol(a, b, c, 1), compositeSymbol(a, b, c));
assert.same(compositeSymbol(a, b, c, 1), compositeSymbol(a, b, c, 1));
assert.same(compositeSymbol(1, a), compositeSymbol(1, a));
assert.notSame(compositeSymbol(1, a), compositeSymbol(a, 1));
assert.same(compositeSymbol(1, a, 2, b), compositeSymbol(1, a, 2, b));
assert.notSame(compositeSymbol(1, a, 2, b), compositeSymbol(1, a, b, 2));
assert.same(compositeSymbol(1, 2, a, b), compositeSymbol(1, 2, a, b));
assert.notSame(compositeSymbol(1, 2, a, b), compositeSymbol(1, a, b, 2));
assert.same(compositeSymbol(a, a), compositeSymbol(a, a));
assert.notSame(compositeSymbol(a, a), compositeSymbol(a, ['a']));
assert.notSame(compositeSymbol(a, a), compositeSymbol(a, b));
assert.same(compositeSymbol(), compositeSymbol());
assert.same(compositeSymbol(1, 2), compositeSymbol(1, 2));
assert.notSame(compositeSymbol(1, 2), compositeSymbol(2, 1));
assert.same(compositeSymbol('foo', null, true), compositeSymbol('foo', null, true));
assert.same(compositeSymbol('string'), Symbol.for('string'));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.data-view.set-uint8-clamped.js
|
JavaScript
|
import { DESCRIPTORS, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
QUnit.test('DataView.prototype.{ getUint8Clamped, setUint8Clamped }', assert => {
const { getUint8Clamped, setUint8Clamped } = DataView.prototype;
assert.isFunction(getUint8Clamped);
assert.arity(getUint8Clamped, 1);
assert.name(getUint8Clamped, 'getUint8Clamped');
assert.isFunction(setUint8Clamped);
assert.arity(setUint8Clamped, 2);
assert.name(setUint8Clamped, 'setUint8Clamped');
assert.same(new DataView(new ArrayBuffer(8)).setUint8Clamped(0, 0), undefined, 'void');
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0]],
[-0, 0, [0]],
[1, 1, [1]],
[-1, 0, [0]],
[1.1, 1, [1]],
[-1.1, 0, [0]],
[1.9, 2, [2]],
[-1.9, 0, [0]],
// round-half-to-even (banker's rounding)
[0.5, 0, [0]],
[1.5, 2, [2]],
[2.5, 2, [2]],
[3.5, 4, [4]],
[4.5, 4, [4]],
[253.5, 254, [254]],
[254.5, 254, [254]],
[127, 127, [127]],
[-127, 0, [0]],
[128, 128, [128]],
[-128, 0, [0]],
[255, 255, [255]],
[-255, 0, [0]],
[255.1, 255, [255]],
[255.9, 255, [255]],
[256, 255, [255]],
[32767, 255, [255]],
[-32767, 0, [0]],
[32768, 255, [255]],
[-32768, 0, [0]],
[65535, 255, [255]],
[65536, 255, [255]],
[65537, 255, [255]],
[65536.54321, 255, [255]],
[-65536.54321, 0, [0]],
[2147483647, 255, [255]],
[-2147483647, 0, [0]],
[2147483648, 255, [255]],
[-2147483648, 0, [0]],
[2147483649, 255, [255]],
[-2147483649, 0, [0]],
[4294967295, 255, [255]],
[4294967296, 255, [255]],
[4294967297, 255, [255]],
[MAX_SAFE_INTEGER, 255, [255]],
[MIN_SAFE_INTEGER, 0, [0]],
[MAX_SAFE_INTEGER + 1, 255, [255]],
[MIN_SAFE_INTEGER - 1, 0, [0]],
[MAX_SAFE_INTEGER + 3, 255, [255]],
[MIN_SAFE_INTEGER - 3, 0, [0]],
[Infinity, 255, [255]],
[-Infinity, 0, [0]],
[-Number.MAX_VALUE, 0, [0]],
[Number.MAX_VALUE, 255, [255]],
[Number.MIN_VALUE, 0, [0]],
[-Number.MIN_VALUE, 0, [0]],
[NaN, 0, [0]],
];
const buffer = new ArrayBuffer(1);
const view = new DataView(buffer);
const array = DESCRIPTORS ? new Uint8Array(buffer) : null;
for (const [value, conversion, little] of data) {
view.setUint8Clamped(0, value);
assert.same(view.getUint8Clamped(0), conversion, `DataView.prototype.setUint8Clamped + DataView.prototype.getUint8Clamped, ${ toString(value) } -> ${ toString(conversion) }`);
assert.same(view.getUint8(0), conversion, `DataView.prototype.setUint8Clamped + DataView.prototype.getUint8, ${ toString(value) } -> ${ toString(conversion) }`);
if (DESCRIPTORS) assert.arrayEqual(array, little, `DataView.prototype.setUint8Clamped + Uint8Array ${ toString(value) } -> [${ little }]`);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.function.demethodize.js
|
JavaScript
|
QUnit.test('Function#demethodize', assert => {
const { demethodize } = Function.prototype;
assert.isFunction(demethodize);
assert.arity(demethodize, 0);
assert.name(demethodize, 'demethodize');
assert.looksNative(demethodize);
assert.nonEnumerable(Function.prototype, 'demethodize');
assert.same(function () { return 42; }.demethodize()(), 42);
assert.deepEqual(Array.prototype.slice.demethodize()([1, 2, 3], 1), [2, 3]);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.function.is-callable.js
|
JavaScript
|
import { fromSource } from '../helpers/helpers.js';
QUnit.test('Function.isCallable', assert => {
const { isCallable } = Function;
assert.isFunction(isCallable);
assert.arity(isCallable, 1);
assert.name(isCallable, 'isCallable');
assert.looksNative(isCallable);
assert.nonEnumerable(Function, 'isCallable');
assert.false(isCallable({}), 'object');
assert.false(isCallable(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()), 'arguments');
assert.false(isCallable([]), 'array');
assert.false(isCallable(/./), 'regex');
assert.false(isCallable(1), 'number');
assert.false(isCallable(true), 'boolean');
assert.false(isCallable('1'), 'string');
assert.false(isCallable(null), 'null');
assert.false(isCallable(), 'undefined');
assert.true(isCallable(Function.call), 'native function');
// eslint-disable-next-line prefer-arrow-callback -- required
assert.true(isCallable(function () { /* empty */ }), 'function');
const arrow = fromSource('it => it');
if (arrow) assert.true(isCallable(arrow), 'arrow');
const klass = fromSource('class {}');
// Safari 9 and Edge 13- bugs
if (klass && !/constructor|function/.test(klass)) assert.false(isCallable(klass), 'class');
const gen = fromSource('function * () {}');
if (gen) assert.true(isCallable(gen), 'gen');
const asyncFunc = fromSource('async function () {}');
if (asyncFunc) assert.true(isCallable(asyncFunc), 'asyncFunc');
const asyncGen = fromSource('async * function () {}');
if (asyncGen) assert.true(isCallable(asyncGen), 'asyncGen');
const method = fromSource('({f(){}}).f');
// Safari 9 bug
if (method && !/function/.test(method)) assert.true(isCallable(method), 'method');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.function.is-constructor.js
|
JavaScript
|
import { fromSource } from '../helpers/helpers.js';
QUnit.test('Function.isConstructor', assert => {
const { isConstructor } = Function;
assert.isFunction(isConstructor);
assert.arity(isConstructor, 1);
assert.name(isConstructor, 'isConstructor');
assert.looksNative(isConstructor);
assert.nonEnumerable(Function, 'isConstructor');
assert.false(isConstructor({}), 'object');
assert.false(isConstructor(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()), 'arguments');
assert.false(isConstructor([]), 'array');
assert.false(isConstructor(/./), 'regex');
assert.false(isConstructor(1), 'number');
assert.false(isConstructor(true), 'boolean');
assert.false(isConstructor('1'), 'string');
assert.false(isConstructor(null), 'null');
assert.false(isConstructor(), 'undefined');
// assert.false(isConstructor(Function.call), 'native function'); // fails in some old engines
// eslint-disable-next-line prefer-arrow-callback -- required
assert.true(isConstructor(function () { /* empty */ }), 'function');
const arrow = fromSource('it => it');
if (arrow) assert.false(isConstructor(arrow), 'arrow');
const klass = fromSource('class {}');
// Safari 9 and Edge 13- bugs
if (klass && !/constructor|function/.test(klass)) assert.true(isConstructor(klass), 'class');
const Gen = fromSource('function * () {}');
// V8 ~ Chrome 49- bug
if (Gen) try {
new Gen();
} catch {
assert.false(isConstructor(Gen), 'gen');
}
const asyncFunc = fromSource('async function () {}');
if (asyncFunc) assert.false(isConstructor(asyncFunc), 'asyncFunc');
const asyncGen = fromSource('async * function () {}');
if (asyncGen) assert.false(isConstructor(asyncGen), 'asyncGen');
const method = fromSource('({f(){}}).f');
// Safari 9 bug
if (method && !/function/.test(method)) assert.false(isConstructor(method), 'method');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.function.metadata.js
|
JavaScript
|
QUnit.test('Function#@@metadata', assert => {
assert.true(Symbol.metadata in Function.prototype);
assert.same(Function.prototype[Symbol.metadata], null, 'is null');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.function.un-this.js
|
JavaScript
|
QUnit.test('Function#unThis', assert => {
const { unThis } = Function.prototype;
assert.isFunction(unThis);
assert.arity(unThis, 0);
// assert.name(unThis, 'unThis');
assert.looksNative(unThis);
assert.nonEnumerable(Function.prototype, 'unThis');
assert.same(function () { return 42; }.unThis()(), 42);
assert.deepEqual(Array.prototype.slice.unThis()([1, 2, 3], 1), [2, 3]);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.iterator.as-indexed-pairs.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('Iterator#asIndexedPairs', assert => {
const { asIndexedPairs } = Iterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
// assert.name(asIndexedPairs, 'asIndexedPairs');
assert.looksNative(asIndexedPairs);
assert.nonEnumerable(Iterator.prototype, 'asIndexedPairs');
assert.arrayEqual(asIndexedPairs.call(createIterator(['a', 'b', 'c'])).toArray().toString(), '0,a,1,b,2,c', 'basic functionality');
if (STRICT) {
assert.throws(() => asIndexedPairs.call(undefined), TypeError);
assert.throws(() => asIndexedPairs.call(null), TypeError);
}
assert.throws(() => asIndexedPairs.call({}).next(), TypeError);
assert.throws(() => asIndexedPairs.call([]).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.iterator.chunks.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
const { from } = Array;
QUnit.test('Iterator#chunks', assert => {
const { chunks } = Iterator.prototype;
assert.isFunction(chunks);
assert.arity(chunks, 1);
assert.name(chunks, 'chunks');
assert.looksNative(chunks);
assert.nonEnumerable(Iterator.prototype, 'chunks');
assert.arrayEqual(from(chunks.call(createIterator([1, 2, 3]), 2)), [[1, 2], [3]], 'basic functionality');
assert.arrayEqual(from(chunks.call(createIterator([1, 2, 3, 4]), 2)), [[1, 2], [3, 4]], 'basic functionality');
assert.arrayEqual(from(chunks.call(createIterator([]), 2)), [], 'basic functionality on empty iterable');
const it = createIterator([1, 2, 3]);
const result = chunks.call(it, 3);
assert.isIterable(result, 'returns iterable');
assert.isIterator(result, 'returns iterator');
assert.true(result instanceof Iterator, 'returns iterator');
assert.deepEqual(result.next(), { done: false, value: [1, 2, 3] }, '.next with active inner iterator result');
assert.deepEqual(result.return(), { done: true, value: undefined }, '.return with active inner iterator result');
assert.deepEqual(result.next(), { done: true, value: undefined }, '.return with active inner iterator result on closed iterator');
if (STRICT) {
assert.throws(() => chunks.call('', 1), TypeError, 'iterable non-object this');
assert.throws(() => chunks.call(undefined, 1), TypeError, 'non-iterable-object this #1');
assert.throws(() => chunks.call(null, 1), TypeError, 'non-iterable-object this #2');
assert.throws(() => chunks.call(5, 1), TypeError, 'non-iterable-object this #3');
}
assert.throws(() => chunks.call(it), RangeError, 'throws on empty argument');
assert.throws(() => chunks.call(it, -1), RangeError, 'throws on negative argument');
const observableReturn = {
return() {
this.called = true;
return { done: true, value: undefined };
},
};
const itObservable = createIterator([1, 2, 3], observableReturn);
assert.throws(() => chunks.call(itObservable, 0x100000000), RangeError, 'throws on argument more then 2^32 - 1');
assert.true(itObservable.called, 'iterator closed on argument validation error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.iterator.indexed.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('Iterator#indexed', assert => {
const { indexed } = Iterator.prototype;
assert.isFunction(indexed);
assert.arity(indexed, 0);
assert.name(indexed, 'indexed');
assert.looksNative(indexed);
assert.nonEnumerable(Iterator.prototype, 'indexed');
assert.arrayEqual(indexed.call(createIterator(['a', 'b', 'c'])).toArray().toString(), '0,a,1,b,2,c', 'basic functionality');
if (STRICT) {
assert.throws(() => indexed.call(undefined), TypeError);
assert.throws(() => indexed.call(null), TypeError);
}
assert.throws(() => indexed.call({}).next(), TypeError);
assert.throws(() => indexed.call([]).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.iterator.range.js
|
JavaScript
|
import { MAX_SAFE_INTEGER } from '../helpers/constants.js';
/* eslint-disable es/no-bigint -- safe */
QUnit.test('Iterator.range', assert => {
const { range } = Iterator;
const { from } = Array;
assert.isFunction(range);
assert.name(range, 'range');
assert.arity(range, 3);
assert.looksNative(range);
assert.nonEnumerable(Iterator, 'range');
let iterator = range(1, 2);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.deepEqual(from(range(-1, 5)), [-1, 0, 1, 2, 3, 4]);
assert.deepEqual(from(range(-5, 1)), [-5, -4, -3, -2, -1, 0]);
assert.deepEqual(
from(range(0, 1, 0.1)),
[0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9],
);
assert.deepEqual(
from(range(MAX_SAFE_INTEGER, MAX_SAFE_INTEGER + 1, { inclusive: true })),
[MAX_SAFE_INTEGER, MAX_SAFE_INTEGER + 1],
);
assert.deepEqual(from(range(0, 0)), []);
assert.deepEqual(from(range(0, -5, 1)), []);
assert.throws(() => range(NaN, 0), RangeError, 'NaN as start');
assert.throws(() => range(0, NaN), RangeError, 'NaN as end');
assert.throws(() => range(NaN, NaN), RangeError, 'NaN as start and end');
assert.throws(() => range(0, 0, { step: NaN }), RangeError, 'NaN as step option');
assert.throws(() => range(0, 5, NaN), RangeError, 'NaN as step argument');
iterator = range(1, 3);
assert.deepEqual(iterator.start, 1);
assert.deepEqual(iterator.end, 3);
assert.deepEqual(iterator.step, 1);
assert.false(iterator.inclusive);
iterator = range(-1, -3, { inclusive: true });
assert.deepEqual(iterator.start, -1);
assert.deepEqual(iterator.end, -3);
assert.same(iterator.step, -1);
assert.true(iterator.inclusive);
iterator = range(0, 5, null);
assert.same(iterator.start, 0, 'null option: start');
assert.same(iterator.end, 5, 'null option: end');
assert.same(iterator.step, 1, 'null option: step defaults to 1');
assert.false(iterator.inclusive, 'null option: inclusive defaults to false');
iterator = range(-1, -3, { step: 4, inclusive() { /* empty */ } });
assert.same(iterator.start, -1);
assert.same(iterator.end, -3);
assert.same(iterator.step, 4);
assert.true(iterator.inclusive);
iterator = range(0, 5);
assert.throws(() => Object.getOwnPropertyDescriptor(iterator, 'start').get.call({}), TypeError);
assert.throws(() => range(Infinity, 10, 0), RangeError);
assert.throws(() => range(-Infinity, 10, 0), RangeError);
assert.throws(() => range(0, 10, Infinity), RangeError);
assert.throws(() => range(0, 10, { step: Infinity }), RangeError);
assert.throws(() => range({}, 1), TypeError);
assert.throws(() => range(1, {}), TypeError);
assert.throws(() => range('1', 2), TypeError);
assert.throws(() => range({ valueOf() { return 1; } }, 2), TypeError);
if (typeof BigInt == 'function') {
iterator = range(BigInt(1), BigInt(2));
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: BigInt(1),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.deepEqual(from(range(BigInt(-1), BigInt(5))), [BigInt(-1), BigInt(0), BigInt(1), BigInt(2), BigInt(3), BigInt(4)]);
assert.deepEqual(from(range(BigInt(-5), BigInt(1))), [BigInt(-5), BigInt(-4), BigInt(-3), BigInt(-2), BigInt(-1), BigInt(0)]);
assert.deepEqual(
from(range(BigInt('9007199254740991'), BigInt('9007199254740992'), { inclusive: true })),
[BigInt('9007199254740991'), BigInt('9007199254740992')],
);
assert.deepEqual(from(range(BigInt(0), BigInt(0))), []);
assert.deepEqual(from(range(BigInt(0), BigInt(-5), BigInt(1))), []);
iterator = range(BigInt(1), BigInt(3));
assert.deepEqual(iterator.start, BigInt(1));
assert.deepEqual(iterator.end, BigInt(3));
assert.deepEqual(iterator.step, BigInt(1));
assert.false(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { inclusive: true });
assert.deepEqual(iterator.start, BigInt(-1));
assert.deepEqual(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(-1));
assert.true(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { step: BigInt(4), inclusive() { /* empty */ } });
assert.same(iterator.start, BigInt(-1));
assert.same(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(4));
assert.true(iterator.inclusive);
iterator = range(BigInt(0), BigInt(5));
assert.throws(() => Object.getOwnPropertyDescriptor(iterator, 'start').get.call({}), TypeError);
assert.throws(() => range(Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(-Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), Infinity), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), { step: Infinity }), TypeError);
assert.throws(() => range({}, BigInt(1)), TypeError);
assert.throws(() => range(BigInt(1), {}), TypeError);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.iterator.sliding.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
const { from } = Array;
QUnit.test('Iterator#sliding', assert => {
const { sliding } = Iterator.prototype;
assert.isFunction(sliding);
assert.arity(sliding, 1);
assert.name(sliding, 'sliding');
assert.looksNative(sliding);
assert.nonEnumerable(Iterator.prototype, 'sliding');
assert.arrayEqual(from(sliding.call(createIterator([1, 2, 3]), 2)), [[1, 2], [2, 3]], 'basic functionality #1');
assert.arrayEqual(from(sliding.call(createIterator([1, 2, 3, 4]), 2)), [[1, 2], [2, 3], [3, 4]], 'basic functionality #2');
assert.arrayEqual(from(sliding.call(createIterator([1, 2]), 3)), [[1, 2]], 'basic functionality #3');
assert.arrayEqual(from(sliding.call(createIterator([]), 2)), [], 'basic functionality on empty iterable');
const it = createIterator([1, 2, 3]);
const result = sliding.call(it, 3);
assert.isIterable(result, 'returns iterable');
assert.isIterator(result, 'returns iterator');
assert.true(result instanceof Iterator, 'returns iterator');
assert.deepEqual(result.next(), { done: false, value: [1, 2, 3] }, '.next with active inner iterator result');
assert.deepEqual(result.return(), { done: true, value: undefined }, '.return with active inner iterator result');
assert.deepEqual(result.next(), { done: true, value: undefined }, '.return with active inner iterator result on closed iterator');
if (STRICT) {
assert.throws(() => sliding.call('', 1), TypeError, 'iterable non-object this');
assert.throws(() => sliding.call(undefined, 1), TypeError, 'non-iterable-object this #1');
assert.throws(() => sliding.call(null, 1), TypeError, 'non-iterable-object this #2');
assert.throws(() => sliding.call(5, 1), TypeError, 'non-iterable-object this #3');
}
assert.throws(() => sliding.call(it), RangeError, 'throws on empty argument');
assert.throws(() => sliding.call(it, -1), RangeError, 'throws on negative argument');
const observableReturn = {
return() {
this.called = true;
return { done: true, value: undefined };
},
};
const itObservable = createIterator([1, 2, 3], observableReturn);
assert.throws(() => sliding.call(itObservable, 0x100000000), RangeError, 'throws on argument more then 2^32 - 1');
assert.true(itObservable.called, 'iterator closed on argument validation error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.iterator.to-async.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import ITERATOR from 'core-js-pure/es/symbol/iterator';
QUnit.test('Iterator#toAsync', assert => {
const { toAsync } = Iterator.prototype;
assert.isFunction(toAsync);
assert.arity(toAsync, 0);
assert.name(toAsync, 'toAsync');
assert.looksNative(toAsync);
assert.nonEnumerable(Iterator.prototype, 'toAsync');
if (STRICT) {
assert.throws(() => toAsync.call(undefined), TypeError);
assert.throws(() => toAsync.call(null), TypeError);
}
const closableIterator = {
closed: false,
[ITERATOR]() { return this; },
next() {
return { value: Promise.reject(42), done: false };
},
return() {
this.closed = true;
return { value: undefined, done: true };
},
};
return [1, 2, 3].values().toAsync().map(it => Promise.resolve(it)).toArray().then(it => {
assert.arrayEqual(it, [1, 2, 3]);
return new Set([1, 2, 3]).values().toAsync().map(el => Promise.resolve(el)).toArray();
}).then(it => {
assert.arrayEqual(it, [1, 2, 3]);
}).then(() => {
return Iterator.from(closableIterator).toAsync().toArray();
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a callback error');
assert.true(closableIterator.closed, 'doesn\'t close sync iterator on promise rejection');
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.iterator.windows.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
const { from } = Array;
QUnit.test('Iterator#windows', assert => {
const { windows } = Iterator.prototype;
assert.isFunction(windows);
assert.arity(windows, 1);
assert.name(windows, 'windows');
assert.looksNative(windows);
assert.nonEnumerable(Iterator.prototype, 'windows');
assert.arrayEqual(from(windows.call(createIterator([1, 2, 3]), 2)), [[1, 2], [2, 3]], 'basic functionality #1');
assert.arrayEqual(from(windows.call(createIterator([1, 2, 3, 4]), 2)), [[1, 2], [2, 3], [3, 4]], 'basic functionality #2');
assert.arrayEqual(from(windows.call(createIterator([1, 2]), 3)), [], 'basic functionality #3');
assert.arrayEqual(from(windows.call(createIterator([]), 2)), [], 'basic functionality on empty iterable');
assert.arrayEqual(from(windows.call(createIterator([1, 2]), 3, 'only-full')), [], 'undersized #1');
assert.arrayEqual(from(windows.call(createIterator([1, 2]), 3, 'allow-partial')), [[1, 2]], 'undersized #2');
const it = createIterator([1, 2, 3]);
const result = windows.call(it, 3);
assert.isIterable(result, 'returns iterable');
assert.isIterator(result, 'returns iterator');
assert.true(result instanceof Iterator, 'returns iterator');
assert.deepEqual(result.next(), { done: false, value: [1, 2, 3] }, '.next with active inner iterator result');
assert.deepEqual(result.return(), { done: true, value: undefined }, '.return with active inner iterator result');
assert.deepEqual(result.next(), { done: true, value: undefined }, '.return with active inner iterator result on closed iterator');
if (STRICT) {
assert.throws(() => windows.call('', 1), TypeError, 'iterable non-object this');
assert.throws(() => windows.call(undefined, 1), TypeError, 'non-iterable-object this #1');
assert.throws(() => windows.call(null, 1), TypeError, 'non-iterable-object this #2');
assert.throws(() => windows.call(5, 1), TypeError, 'non-iterable-object this #3');
}
assert.throws(() => windows.call(it), RangeError, 'throws on empty argument');
assert.throws(() => windows.call(it, -1), RangeError, 'throws on negative argument');
const observableReturn = {
return() {
this.called = true;
return { done: true, value: undefined };
},
};
const itObservable = createIterator([1, 2, 3], observableReturn);
assert.throws(() => windows.call(itObservable, 0x100000000), RangeError, 'throws on argument more then 2^32 - 1');
assert.true(itObservable.called, 'iterator closed on argument validation error');
assert.throws(() => windows.call(createIterator([1]), 2, null), TypeError, 'incorrect `undersized` argument #1');
assert.throws(() => windows.call(createIterator([1]), 2, 'allowpartial'), TypeError, 'incorrect `undersized` argument #2');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.iterator.zip-keyed.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { DESCRIPTORS } from '../helpers/constants.js';
function nullProto(obj) {
return Object.assign(Object.create(null), obj);
}
QUnit.test('Iterator.zipKeyed', assert => {
const { zipKeyed } = Iterator;
const { from } = Array;
const { defineProperty } = Object;
assert.isFunction(zipKeyed);
assert.arity(zipKeyed, 1);
assert.name(zipKeyed, 'zipKeyed');
assert.looksNative(zipKeyed);
assert.nonEnumerable(Iterator, 'zipKeyed');
let result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5], c: [7, 8, 9] });
assert.true(result instanceof Iterator, 'Iterator instance');
assert.deepEqual(from(result), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }]);
result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5, 6], c: [7, 8, 9] });
assert.deepEqual(from(result), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }]);
result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5, 6], c: [7, 8, 9] }, { mode: 'longest', padding: { c: 10 } });
assert.deepEqual(from(result), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }, { a: undefined, b: 6, c: 10 }]);
result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5, 6], c: [7, 8, 9] }, { mode: 'strict' });
assert.throws(() => from(result), TypeError);
if (DESCRIPTORS) {
let obj = {};
defineProperty(obj, 'a', { get: () => [0, 1, 2], enumerable: true });
defineProperty(obj, 'b', { get: () => [3, 4, 5], enumerable: true });
defineProperty(obj, 'c', { get: () => [7, 8, 9], enumerable: true });
defineProperty(obj, Symbol('d'), { get: () => [10, 11, 12] });
assert.deepEqual(from(zipKeyed(obj)), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }]);
const it = createIterator([1, 2], {
return() {
this.called = true;
return { done: true, value: undefined };
},
});
obj = { a: it };
defineProperty(obj, 'b', { get: () => { throw new Error(); }, enumerable: true });
assert.throws(() => from(zipKeyed(obj)), Error);
assert.true(it.called, 'iterator return called');
const foo = Symbol('foo');
const bar = Symbol('bar');
const zipped = Iterator.zipKeyed({ [foo]: [1, 2, 3], [bar]: [4, 5, 6], baz: [7, 8, 9] });
result = from(zipped);
assert.same(result[0][foo], 1);
assert.same(result[0][bar], 4);
assert.same(result[0].baz, 7);
assert.same(result[1][foo], 2);
assert.same(result[1][bar], 5);
assert.same(result[1].baz, 8);
assert.same(result[2][foo], 3);
assert.same(result[2][bar], 6);
assert.same(result[2].baz, 9);
}
{
const $result = zipKeyed({
a: [0, 1, 2],
b: [3, 4, 5, 6, 7],
c: [8, 9],
}, {
mode: 'longest',
});
assert.deepEqual(from($result), [
nullProto({ a: 0, b: 3, c: 8 }),
nullProto({ a: 1, b: 4, c: 9 }),
nullProto({ a: 2, b: 5, c: undefined }),
nullProto({ a: undefined, b: 6, c: undefined }),
nullProto({ a: undefined, b: 7, c: undefined }),
]);
}
{
const $result = zipKeyed({
a: [0, 1, 2],
b: [3, 4, 5, 6, 7],
c: [8, 9],
}, {
mode: 'longest',
padding: { a: 'A', b: 'B', c: 'C' },
});
assert.deepEqual(from($result), [
nullProto({ a: 0, b: 3, c: 8 }),
nullProto({ a: 1, b: 4, c: 9 }),
nullProto({ a: 2, b: 5, c: 'C' }),
nullProto({ a: 'A', b: 6, c: 'C' }),
nullProto({ a: 'A', b: 7, c: 'C' }),
]);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.iterator.zip.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
QUnit.test('Iterator.zip', assert => {
const { zip } = Iterator;
const { from } = Array;
assert.isFunction(zip);
assert.arity(zip, 1);
assert.name(zip, 'zip');
assert.looksNative(zip);
assert.nonEnumerable(Iterator, 'zip');
let result = zip([[1, 2, 3], [4, 5, 6]]);
assert.true(result instanceof Iterator, 'Iterator instance');
assert.deepEqual(from(result), [[1, 4], [2, 5], [3, 6]]);
result = zip([[1, 2, 3], [4, 5, 6, 7]]);
assert.deepEqual(from(result), [[1, 4], [2, 5], [3, 6]]);
result = zip([[1, 2, 3], [4, 5, 6, 7]], { mode: 'longest', padding: [9] });
assert.deepEqual(from(result), [[1, 4], [2, 5], [3, 6], [9, 7]]);
result = zip([[1, 2, 3, 4], [5, 6, 7]], { mode: 'longest', padding: [1, 9] });
assert.deepEqual(from(result), [[1, 5], [2, 6], [3, 7], [4, 9]]);
result = zip([[1, 2, 3], [4, 5, 6], [7, 8, 9]], { mode: 'strict' });
assert.deepEqual(from(result), [[1, 4, 7], [2, 5, 8], [3, 6, 9]]);
result = zip([[1, 2, 3], [4, 5, 6, 7]], { mode: 'strict' });
assert.throws(() => from(result), TypeError);
const observableReturn = {
return() {
this.called = true;
return { done: true, value: undefined };
},
};
{
const it1 = createIterator([1, 2], observableReturn);
const it2 = createIterator([3, 4], observableReturn);
result = zip([it1, it2]);
assert.deepEqual(result.next().value, [1, 3]);
assert.deepEqual(result.return(), { done: true, value: undefined });
assert.deepEqual(result.next(), { done: true, value: undefined });
assert.true(it1.called, 'first iterator return called');
assert.true(it2.called, 'second iterator return called');
}
{
const it = createIterator([1, 2, 3], observableReturn);
result = zip([it, [4, 5]], { mode: 'strict' });
assert.throws(() => from(result), TypeError);
assert.true(it.called, 'iterator return called #1');
}
{
const it = createIterator([3, 4, 5], observableReturn);
result = zip([[1, 2], it], { mode: 'strict' });
assert.throws(() => from(result), TypeError);
assert.true(it.called, 'iterator return called #2');
}
{
const it1 = createIterator([1, 2], { next() { throw new Error(); } });
const it2 = createIterator([3, 4], observableReturn);
result = zip([it1, it2]);
assert.throws(() => from(result), Error);
assert.true(it2.called, 'iterator return called #4');
}
{
const expectedError = new TypeError('strict next error');
let it2calls = 0;
const it2 = createIterator([2], {
next() {
if (it2calls++) throw expectedError;
return { value: 2, done: false };
},
});
result = zip([createIterator([1]), it2], { mode: 'strict' });
result.next();
let caught;
try {
result.next();
} catch (error) {
caught = error;
}
assert.same(caught, expectedError, 'strict mode propagates error from .next() during exhaustion check');
}
{
const $result = zip([
[0, 1, 2],
[3, 4, 5, 6, 7],
[8, 9],
], {
mode: 'longest',
});
assert.deepEqual(from($result), [
[0, 3, 8],
[1, 4, 9],
[2, 5, undefined],
[undefined, 6, undefined],
[undefined, 7, undefined],
]);
}
{
const $result = zip([
[0, 1, 2],
[3, 4, 5, 6, 7],
[8, 9],
], {
mode: 'longest',
padding: ['A', 'B', 'C'],
});
assert.deepEqual(from($result), [
[0, 3, 8],
[1, 4, 9],
[2, 5, 'C'],
['A', 6, 'C'],
['A', 7, 'C'],
]);
}
{
const expectedError = new TypeError('not iterable');
const badIterable = { [Symbol.iterator]() { throw expectedError; } };
const it1 = createIterator([1, 2], observableReturn);
let caught;
try {
zip([it1, badIterable]);
} catch (error) {
caught = error;
}
assert.same(caught, expectedError, 'original error is preserved');
assert.true(it1.called, 'first iterator return called on non-iterable second element');
}
{
const expectedError = new TypeError('inner return error');
const throwingReturn = {
return() {
throw expectedError;
},
};
const it1 = createIterator([1, 2], throwingReturn);
const it2 = createIterator([3, 4], observableReturn);
result = zip([it1, it2]);
result.next();
let caught;
try {
result.return();
} catch (error) {
caught = error;
}
assert.same(caught, expectedError, 'propagates the original error from inner return()');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.map.delete-all.js
|
JavaScript
|
QUnit.test('Map#deleteAll', assert => {
const { deleteAll } = Map.prototype;
const { from } = Array;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.looksNative(deleteAll);
assert.nonEnumerable(Map.prototype, 'deleteAll');
let set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.true(set.deleteAll(1, 2));
assert.deepEqual(from(set), [[3, 4]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.false(set.deleteAll(3, 4));
assert.deepEqual(from(set), [[1, 2], [2, 3]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.false(set.deleteAll(4, 5));
assert.deepEqual(from(set), [[1, 2], [2, 3], [3, 4]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.true(set.deleteAll());
assert.deepEqual(from(set), [[1, 2], [2, 3], [3, 4]]);
assert.throws(() => deleteAll.call({ delete() { /* empty */ } }, 1, 2, 3));
assert.throws(() => deleteAll.call({}, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(undefined, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(null, 1, 2, 3), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.map.emplace.js
|
JavaScript
|
QUnit.test('Map#emplace', assert => {
const { emplace } = Map.prototype;
assert.isFunction(emplace);
assert.arity(emplace, 2);
assert.name(emplace, 'emplace');
assert.looksNative(emplace);
assert.nonEnumerable(Map.prototype, 'emplace');
const map = new Map([['a', 2]]);
let handler = {
update(value, key, that) {
assert.same(this, handler, 'correct handler in callback');
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 'a', 'correct key in callback');
assert.same(that, map, 'correct map in callback');
return value ** 2;
},
insert() {
assert.avoid();
},
};
assert.same(map.emplace('a', handler), 4, 'returns a correct value');
handler = {
update() {
assert.avoid();
},
insert(key, that) {
assert.same(this, handler, 'correct handler in callback');
assert.same(arguments.length, 2, 'correct number of callback arguments');
assert.same(key, 'b', 'correct key in callback');
assert.same(that, map, 'correct map in callback');
return 3;
},
};
assert.same(map.emplace('b', handler), 3, 'returns a correct value');
assert.same(map.size, 2, 'correct size');
assert.same(map.get('a'), 4, 'correct result #1');
assert.same(map.get('b'), 3, 'correct result #2');
assert.same(new Map([['a', 2]]).emplace('b', { insert: () => 3 }), 3);
assert.same(new Map([['a', 2]]).emplace('a', { update: value => value ** 2 }), 4);
handler = { update() { /* empty */ }, insert() { /* empty */ } };
assert.throws(() => new Map().emplace('a'), TypeError);
assert.throws(() => emplace.call({}, 'a', handler), TypeError);
assert.throws(() => emplace.call([], 'a', handler), TypeError);
assert.throws(() => emplace.call(undefined, 'a', handler), TypeError);
assert.throws(() => emplace.call(null, 'a', handler), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.map.every.js
|
JavaScript
|
QUnit.test('Map#every', assert => {
const { every } = Map.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.looksNative(every);
assert.nonEnumerable(Map.prototype, 'every');
let map = new Map([[9, 1]]);
const context = {};
map.every(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 9, 'correct index in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
map = new Map([[0, 1], [1, 2], [2, 3]]);
assert.true(map.every(it => typeof it == 'number'));
assert.true(map.every(it => it < 4));
assert.false(map.every(it => it < 3));
assert.false(map.every(it => typeof it == 'string'));
assert.true(map.every(function () {
return +this === 1;
}, 1));
let result = '';
map.every((value, key) => result += key);
assert.same(result, '012');
assert.true(map.every((value, key, that) => that === map));
assert.throws(() => every.call(new Set(), () => { /* empty */ }), TypeError);
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call([], () => { /* empty */ }), TypeError);
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.map.filter.js
|
JavaScript
|
QUnit.test('Map#filter', assert => {
const { filter } = Map.prototype;
const { from } = Array;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.looksNative(filter);
assert.nonEnumerable(Map.prototype, 'filter');
const map = new Map([[1, 2]]);
const context = {};
map.filter(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(new Map().filter(it => it) instanceof Map);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).filter(it => typeof it == 'number')), [
['a', 1],
[1, 2],
['b', 3],
[3, 4],
[4, 5],
]);
assert.throws(() => filter.call(new Set(), () => { /* empty */ }), TypeError);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call([], () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.map.find-key.js
|
JavaScript
|
QUnit.test('Map#findKey', assert => {
const { findKey } = Map.prototype;
assert.isFunction(findKey);
assert.arity(findKey, 1);
assert.name(findKey, 'findKey');
assert.looksNative(findKey);
assert.nonEnumerable(Map.prototype, 'findKey');
const set = new Map([[1, 2]]);
const context = {};
set.findKey(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Map([[1, 2], [2, 3], [3, 4]]).findKey(it => it % 2), 2);
assert.same(new Map().findKey(it => it === 42), undefined);
assert.throws(() => findKey.call(new Set(), () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call([], () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.map.find.js
|
JavaScript
|
QUnit.test('Map#find', assert => {
const { find } = Map.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.looksNative(find);
assert.nonEnumerable(Map.prototype, 'find');
const set = new Map([[1, 2]]);
const context = {};
set.find(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Map([[1, 2], [2, 3], [3, 4]]).find(it => it % 2), 3);
assert.same(new Map().find(it => it === 42), undefined);
assert.throws(() => find.call(new Set(), () => { /* empty */ }), TypeError);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call([], () => { /* empty */ }), TypeError);
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.map.from.js
|
JavaScript
|
import { createIterable } from '../helpers/helpers.js';
QUnit.test('Map.from', assert => {
const { from } = Map;
const toArray = Array.from;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(Map, 'from');
assert.true(from([]) instanceof Map);
assert.deepEqual(toArray(from([])), []);
assert.deepEqual(toArray(from([[1, 2]])), [[1, 2]]);
assert.deepEqual(toArray(from([[1, 2], [2, 3], [1, 4]])), [[1, 4], [2, 3]]);
assert.deepEqual(toArray(from(createIterable([[1, 2], [2, 3], [1, 4]]))), [[1, 4], [2, 3]]);
const pair = [1, 2];
const context = {};
from([pair], function (element, index) {
assert.same(element, pair);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.map.includes.js
|
JavaScript
|
QUnit.test('Map#includes', assert => {
const { includes } = Map.prototype;
assert.isFunction(includes);
assert.name(includes, 'includes');
assert.arity(includes, 1);
assert.looksNative(includes);
assert.nonEnumerable(Map.prototype, 'includes');
const object = {};
const map = new Map([[1, 1], [2, 2], [3, 3], [4, -0], [5, object], [6, NaN]]);
assert.true(map.includes(1));
assert.true(map.includes(-0));
assert.true(map.includes(0));
assert.true(map.includes(object));
assert.false(map.includes(4));
assert.false(map.includes(-0.5));
assert.false(map.includes({}));
assert.true(map.includes(NaN));
assert.throws(() => includes.call(new Set(), 1), TypeError);
assert.throws(() => includes.call({}, 1), TypeError);
assert.throws(() => includes.call([], 1), TypeError);
assert.throws(() => includes.call(undefined, 1), TypeError);
assert.throws(() => includes.call(null, 1), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/esnext.map.key-by.js
|
JavaScript
|
import { createIterable } from '../helpers/helpers.js';
QUnit.test('Map.keyBy', assert => {
const { keyBy } = Map;
const toArray = Array.from;
assert.isFunction(keyBy);
assert.arity(keyBy, 2);
assert.name(keyBy, 'keyBy');
assert.looksNative(keyBy);
assert.nonEnumerable(Map, 'keyBy');
assert.true(Map.keyBy([], it => it) instanceof Map);
assert.deepEqual(toArray(Map.keyBy([], it => it)), []);
assert.deepEqual(toArray(Map.keyBy([1, 2], it => it ** 2)), [[1, 1], [4, 2]]);
assert.deepEqual(toArray(Map.keyBy([1, 2, 1], it => it ** 2)), [[1, 1], [4, 2]]);
assert.deepEqual(toArray(Map.keyBy(createIterable([1, 2]), it => it ** 2)), [[1, 1], [4, 2]]);
const element = {};
Map.keyBy([element], it => assert.same(it, element));
// assert.throws(() => keyBy([1, 2], it => it));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.