"}', 'replacer-function-object-deleted-property-2');
*/
assert.throws(() => stringify({ key: defineProperty(Array(1), '0', {
get() { throw new EvalError('t262'); },
}) }), EvalError, 'value-array-abrupt');
assert.throws(() => stringify(defineProperty({}, 'key', {
enumerable: true,
get() { throw new EvalError('t262'); },
})), EvalError, 'value-object-abrupt');
assert.throws(() => stringify(defineProperty({}, 'toJSON', {
get() { throw new EvalError('t262'); },
})), EvalError, 'value-tojson-abrupt-2');
}
});
QUnit.test('Symbols & JSON.stringify', assert => {
const symbol1 = Symbol('symbol & stringify test 1');
const symbol2 = Symbol('symbol & stringify test 2');
assert.same(stringify([
1,
symbol1,
false,
symbol2,
{},
]), '[1,null,false,null,{}]', 'array value');
assert.same(stringify({
symbol: symbol1,
}), '{}', 'object value');
if (DESCRIPTORS) {
const object = { bar: 2 };
object[symbol1] = 1;
assert.same(stringify(object), '{"bar":2}', 'object key');
}
assert.same(stringify(symbol1), undefined, 'symbol value');
if (typeof symbol1 == 'symbol') {
assert.same(stringify(Object(symbol1)), '{}', 'boxed symbol');
}
assert.same(stringify(undefined, () => 42), '42', 'replacer works with top-level undefined');
});
QUnit.test('Well‑formed JSON.stringify', assert => {
assert.same(stringify({ foo: 'bar' }), '{"foo":"bar"}', 'basic');
assert.same(stringify('\uDEAD'), '"\\udead"', 'r1');
assert.same(stringify('\uDF06\uD834'), '"\\udf06\\ud834"', 'r2');
assert.same(stringify('\uDF06ab\uD834'), '"\\udf06ab\\ud834"', 'r3');
assert.same(stringify('𠮷'), '"𠮷"', 'r4');
assert.same(stringify('\uD834\uDF06'), '"𝌆"', 'r5');
assert.same(stringify('\uD834\uD834\uDF06'), '"\\ud834𝌆"', 'r6');
assert.same(stringify('\uD834\uDF06\uDF06'), '"𝌆\\udf06"', 'r7');
assert.same(stringify({ '𠮷': ['\uDF06\uD834'] }), '{"𠮷":["\\udf06\\ud834"]}', 'r8');
});
}
================================================
FILE: tests/unit-pure/es.map.get-or-insert-computed.js
================================================
import { STRICT } from '../helpers/constants.js';
import Map from 'core-js-pure/es/map';
import from from 'core-js-pure/es/array/from';
QUnit.test('Map#getOrInsertComputed', assert => {
const { getOrInsertComputed } = Map.prototype;
assert.isFunction(getOrInsertComputed);
assert.arity(getOrInsertComputed, 2);
assert.name(getOrInsertComputed, 'getOrInsertComputed');
assert.nonEnumerable(Map.prototype, 'getOrInsertComputed');
let map = new Map([['a', 2]]);
assert.same(map.getOrInsertComputed('a', () => 3), 2, 'result#1');
assert.deepEqual(from(map), [['a', 2]], 'map#1');
map = new Map([['a', 2]]);
assert.same(map.getOrInsertComputed('b', () => 3), 3, 'result#2');
assert.deepEqual(from(map), [['a', 2], ['b', 3]], 'map#2');
map = new Map([['a', 2]]);
map.getOrInsertComputed('a', () => assert.avoid());
map = new Map([['a', 2]]);
map.getOrInsertComputed('b', function (key) {
if (STRICT) assert.same(this, undefined, 'correct handler in callback');
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(key, 'b', 'correct key in callback');
});
map = new Map([['a', 2]]);
map.getOrInsertComputed(-0, key => assert.same(key, 0, 'CanonicalizeKeyedCollectionKey'));
map = new Map([['a', 2]]);
assert.same(map.getOrInsertComputed('b', key => {
map.set(key, 4);
return 3;
}), 3, 'callback inserts same key');
assert.deepEqual(from(map), [['a', 2], ['b', 3]], 'map after callback inserts same key');
assert.throws(() => new Map().getOrInsertComputed('a', {}), TypeError, 'non-callable#1');
assert.throws(() => new Map().getOrInsertComputed('a', 1), TypeError, 'non-callable#2');
assert.throws(() => new Map().getOrInsertComputed('a', null), TypeError, 'non-callable#3');
assert.throws(() => new Map().getOrInsertComputed('a', undefined), TypeError, 'non-callable#4');
assert.throws(() => new Map().getOrInsertComputed('a'), TypeError, 'non-callable#5');
assert.throws(() => getOrInsertComputed.call({}, 'a', () => 3), TypeError, 'non-generic#1');
assert.throws(() => getOrInsertComputed.call([], 'a', () => 3), TypeError, 'non-generic#2');
assert.throws(() => getOrInsertComputed.call(undefined, 'a', () => 3), TypeError, 'non-generic#3');
assert.throws(() => getOrInsertComputed.call(null, 'a', () => 3), TypeError, 'non-generic#4');
});
================================================
FILE: tests/unit-pure/es.map.get-or-insert.js
================================================
import Map from 'core-js-pure/es/map';
import from from 'core-js-pure/es/array/from';
QUnit.test('Map#getOrInsert', assert => {
const { getOrInsert } = Map.prototype;
assert.isFunction(getOrInsert);
assert.arity(getOrInsert, 2);
assert.name(getOrInsert, 'getOrInsert');
assert.nonEnumerable(Map.prototype, 'getOrInsert');
let map = new Map([['a', 2]]);
assert.same(map.getOrInsert('a', 3), 2, 'result#1');
assert.deepEqual(from(map), [['a', 2]], 'map#1');
map = new Map([['a', 2]]);
assert.same(map.getOrInsert('b', 3), 3, 'result#2');
assert.deepEqual(from(map), [['a', 2], ['b', 3]], 'map#2');
assert.throws(() => getOrInsert.call({}, 'a', 1), TypeError, 'non-generic#1');
assert.throws(() => getOrInsert.call([], 'a', 1), TypeError, 'non-generic#2');
assert.throws(() => getOrInsert.call(undefined, 'a', 1), TypeError, 'non-generic#3');
assert.throws(() => getOrInsert.call(null, 'a', 1), TypeError, 'non-generic#4');
});
================================================
FILE: tests/unit-pure/es.map.group-by.js
================================================
import { createIterable } from '../helpers/helpers.js';
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/es/map';
QUnit.test('Map.groupBy', assert => {
const { groupBy } = Map;
assert.isFunction(groupBy);
assert.arity(groupBy, 2);
assert.name(groupBy, 'groupBy');
assert.true(groupBy([], it => it) instanceof Map);
assert.deepEqual(from(groupBy([], it => it)), []);
assert.deepEqual(from(groupBy([1, 2], it => it ** 2)), [[1, [1]], [4, [2]]]);
assert.deepEqual(from(groupBy([1, 2, 1], it => it ** 2)), [[1, [1, 1]], [4, [2]]]);
assert.deepEqual(from(groupBy(createIterable([1, 2]), it => it ** 2)), [[1, [1]], [4, [2]]]);
assert.deepEqual(from(groupBy('qwe', it => it)), [['q', ['q']], ['w', ['w']], ['e', ['e']]], 'iterable string');
const element = {};
groupBy([element], function (it, i) {
assert.same(arguments.length, 2, 'correct number of callback arguments');
assert.same(it, element, 'correct value in callback');
assert.same(i, 0, 'correct index in callback');
});
});
================================================
FILE: tests/unit-pure/es.map.js
================================================
/* eslint-disable sonarjs/no-element-overwrite -- required for testing */
import { createIterable, is, nativeSubclass } from '../helpers/helpers.js';
import { DESCRIPTORS } from '../helpers/constants.js';
import getIterator from 'core-js-pure/es/get-iterator';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import freeze from 'core-js-pure/es/object/freeze';
import getOwnPropertyDescriptor from 'core-js-pure/es/object/get-own-property-descriptor';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import keys from 'core-js-pure/es/object/keys';
import ownKeys from 'core-js-pure/es/reflect/own-keys';
import Symbol from 'core-js-pure/es/symbol';
import Set from 'core-js-pure/es/set';
import Map from 'core-js-pure/es/map';
QUnit.test('Map', assert => {
assert.isFunction(Map);
assert.true('clear' in Map.prototype, 'clear in Map.prototype');
assert.true('delete' in Map.prototype, 'delete in Map.prototype');
assert.true('forEach' in Map.prototype, 'forEach in Map.prototype');
assert.true('get' in Map.prototype, 'get in Map.prototype');
assert.true('has' in Map.prototype, 'has in Map.prototype');
assert.true('set' in Map.prototype, 'set in Map.prototype');
assert.true(new Map() instanceof Map, 'new Map instanceof Map');
assert.same(new Map(createIterable([[1, 1], [2, 2], [3, 3]])).size, 3, 'Init from iterable');
assert.same(new Map([[freeze({}), 1], [2, 3]]).size, 2, 'Support frozen objects');
let done = false;
try {
new Map(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.true(done, '.return #throw');
const array = [];
done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new Map(array);
assert.true(done);
const object = {};
new Map().set(object, 1);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(Map);
assert.true(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.true(new Subclass() instanceof Map, 'correct subclassing with native classes #2');
assert.same(new Subclass().set(1, 2).get(1), 2, 'correct subclassing with native classes #3');
}
if (typeof ArrayBuffer == 'function') {
const buffer = new ArrayBuffer(8);
const map = new Map([[buffer, 8]]);
assert.true(map.has(buffer), 'works with ArrayBuffer keys');
}
});
QUnit.test('Map#clear', assert => {
assert.isFunction(Map.prototype.clear);
let map = new Map();
map.clear();
assert.same(map.size, 0);
map = new Map().set(1, 2).set(2, 3).set(1, 4);
map.clear();
assert.same(map.size, 0);
assert.false(map.has(1));
assert.false(map.has(2));
const frozen = freeze({});
map = new Map().set(1, 2).set(frozen, 3);
map.clear();
assert.same(map.size, 0, 'Support frozen objects');
assert.false(map.has(1));
assert.false(map.has(frozen));
});
QUnit.test('Map#delete', assert => {
assert.isFunction(Map.prototype.delete);
const object = {};
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 7);
map.set(2, 5);
map.set(1, 4);
map.set(object, 9);
assert.same(map.size, 5);
assert.true(map.delete(NaN));
assert.same(map.size, 4);
assert.false(map.delete(4));
assert.same(map.size, 4);
map.delete([]);
assert.same(map.size, 4);
map.delete(object);
assert.same(map.size, 3);
const frozen = freeze({});
map.set(frozen, 42);
assert.same(map.size, 4);
map.delete(frozen);
assert.same(map.size, 3);
});
QUnit.test('Map#forEach', assert => {
assert.isFunction(Map.prototype.forEach);
let result = {};
let count = 0;
const object = {};
let map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 7);
map.set(2, 5);
map.set(1, 4);
map.set(object, 9);
map.forEach((value, key) => {
count++;
result[value] = key;
});
assert.same(count, 5);
assert.deepEqual(result, {
1: NaN,
7: 3,
5: 2,
4: 1,
9: object,
});
map = new Map();
map.set('0', 9);
map.set('1', 9);
map.set('2', 9);
map.set('3', 9);
result = '';
map.forEach((value, key) => {
result += key;
if (key === '2') {
map.delete('2');
map.delete('3');
map.delete('1');
map.set('4', 9);
}
});
assert.same(result, '0124');
map = new Map([['0', 1]]);
result = '';
map.forEach(it => {
map.delete('0');
if (result !== '') throw new Error();
result += it;
});
assert.same(result, '1');
assert.throws(() => Map.prototype.forEach.call(new Set(), () => { /* empty */ }), 'non-generic');
});
QUnit.test('Map#get', assert => {
assert.isFunction(Map.prototype.get);
const object = {};
const frozen = freeze({});
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(frozen, 42);
map.set(object, object);
assert.same(map.get(NaN), 1);
assert.same(map.get(4), undefined);
assert.same(map.get({}), undefined);
assert.same(map.get(object), object);
assert.same(map.get(frozen), 42);
assert.same(map.get(2), 5);
});
QUnit.test('Map#has', assert => {
assert.isFunction(Map.prototype.has);
const object = {};
const frozen = freeze({});
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(frozen, 42);
map.set(object, object);
assert.true(map.has(NaN));
assert.true(map.has(object));
assert.true(map.has(2));
assert.true(map.has(frozen));
assert.false(map.has(4));
assert.false(map.has({}));
});
QUnit.test('Map#set', assert => {
assert.isFunction(Map.prototype.set);
const object = {};
let map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(object, object);
assert.same(map.size, 5);
const chain = map.set(7, 2);
assert.same(chain, map);
map.set(7, 2);
assert.same(map.size, 6);
assert.same(map.get(7), 2);
assert.same(map.get(NaN), 1);
map.set(NaN, 42);
assert.same(map.size, 6);
assert.same(map.get(NaN), 42);
map.set({}, 11);
assert.same(map.size, 7);
assert.same(map.get(object), object);
map.set(object, 27);
assert.same(map.size, 7);
assert.same(map.get(object), 27);
map = new Map();
map.set(NaN, 2);
map.set(NaN, 3);
map.set(NaN, 4);
assert.same(map.size, 1);
const frozen = freeze({});
map = new Map().set(frozen, 42);
assert.same(map.get(frozen), 42);
});
QUnit.test('Map#size', assert => {
const map = new Map();
map.set(2, 1);
const { size } = map;
assert.same(typeof size, 'number', 'size is number');
assert.same(size, 1, 'size is correct');
if (DESCRIPTORS) {
const sizeDescriptor = getOwnPropertyDescriptor(Map.prototype, 'size');
const getter = sizeDescriptor && sizeDescriptor.get;
const setter = sizeDescriptor && sizeDescriptor.set;
assert.same(typeof getter, 'function', 'size is getter');
assert.same(typeof setter, 'undefined', 'size is not setter');
assert.throws(() => Map.prototype.size, TypeError);
}
});
QUnit.test('Map & -0', assert => {
let map = new Map();
map.set(-0, 1);
assert.same(map.size, 1);
assert.true(map.has(0));
assert.true(map.has(-0));
assert.same(map.get(0), 1);
assert.same(map.get(-0), 1);
map.forEach((val, key) => {
assert.false(is(key, -0));
});
map.delete(-0);
assert.same(map.size, 0);
map = new Map([[-0, 1]]);
map.forEach((val, key) => {
assert.false(is(key, -0));
});
map = new Map();
map.set(4, 4);
map.set(3, 3);
map.set(2, 2);
map.set(1, 1);
map.set(0, 0);
assert.true(map.has(-0));
});
QUnit.test('Map#@@toStringTag', assert => {
assert.same(Map.prototype[Symbol.toStringTag], 'Map', 'Map::@@toStringTag is `Map`');
assert.same(String(new Map()), '[object Map]', 'correct stringification');
});
QUnit.test('Map Iterator', assert => {
const map = new Map();
map.set('a', 1);
map.set('b', 2);
map.set('c', 3);
map.set('d', 4);
const results = [];
const iterator = map.keys();
results.push(iterator.next().value);
assert.true(map.delete('a'));
assert.true(map.delete('b'));
assert.true(map.delete('c'));
map.set('e');
results.push(iterator.next().value, iterator.next().value);
assert.true(iterator.next().done);
map.set('f');
assert.true(iterator.next().done);
assert.deepEqual(results, ['a', 'd', 'e']);
});
QUnit.test('Map#keys', assert => {
assert.isFunction(Map.prototype.keys);
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.keys();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: 'a',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 's',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'd',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#values', assert => {
assert.isFunction(Map.prototype.values);
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.values();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#entries', assert => {
assert.isFunction(Map.prototype.entries);
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.entries();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: ['a', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['s', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['d', 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#@@iterator', assert => {
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = getIterator(map);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Map Iterator');
assert.same(String(iterator), '[object Map Iterator]');
assert.deepEqual(iterator.next(), {
value: ['a', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['s', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['d', 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
================================================
FILE: tests/unit-pure/es.math.acosh.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import acosh from 'core-js-pure/es/math/acosh';
import EPSILON from 'core-js-pure/es/number/epsilon';
QUnit.test('Math.acosh', assert => {
assert.isFunction(acosh);
assert.name(acosh, 'acosh');
assert.arity(acosh, 1);
assert.same(acosh(NaN), NaN);
assert.same(acosh(0.5), NaN);
assert.same(acosh(-1), NaN);
assert.same(acosh(-1e300), NaN);
assert.same(acosh(1), 0);
assert.same(acosh(Infinity), Infinity);
assert.closeTo(acosh(1234), 7.811163220849231, 1e-11);
assert.closeTo(acosh(8.88), 2.8737631531629235, 1e-11);
assert.closeTo(acosh(1e+160), 369.10676205960726, 1e-11);
assert.closeTo(acosh(Number.MAX_VALUE), 710.475860073944, 1e-11);
assert.closeTo(acosh(1 + EPSILON), 2.1073424255447017e-8, 1e-11);
const checker = createConversionChecker(1234);
assert.closeTo(acosh(checker), 7.811163220849231, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.asinh.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import asinh from 'core-js-pure/es/math/asinh';
QUnit.test('Math.asinh', assert => {
assert.isFunction(asinh);
assert.name(asinh, 'asinh');
assert.arity(asinh, 1);
assert.same(asinh(NaN), NaN);
assert.same(asinh(0), 0);
assert.same(asinh(-0), -0);
assert.same(asinh(Infinity), Infinity);
assert.same(asinh(-Infinity), -Infinity);
assert.closeTo(asinh(1234), 7.811163549201245, 1e-11);
assert.closeTo(asinh(9.99), 2.997227420191335, 1e-11);
assert.closeTo(asinh(1e150), 346.0809111296668, 1e-11);
assert.closeTo(asinh(1e7), 16.811242831518268, 1e-11);
assert.closeTo(asinh(-1e7), -16.811242831518268, 1e-11);
assert.closeTo(asinh(1e200), 461.2101657793691, 1e-6, 'large value 1e200');
assert.closeTo(asinh(1e300), 691.4686750787736, 1e-6, 'large value 1e300');
assert.closeTo(asinh(Number.MAX_VALUE), 710.4758600739439, 1e-6, 'Number.MAX_VALUE');
assert.closeTo(asinh(-1e200), -461.2101657793691, 1e-6, 'large negative value');
const checker = createConversionChecker(1234);
assert.closeTo(asinh(checker), 7.811163549201245, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.atanh.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import atanh from 'core-js-pure/es/math/atanh';
QUnit.test('Math.atanh', assert => {
assert.isFunction(atanh);
assert.name(atanh, 'atanh');
assert.arity(atanh, 1);
assert.same(atanh(NaN), NaN);
assert.same(atanh(-2), NaN);
assert.same(atanh(-1.5), NaN);
assert.same(atanh(2), NaN);
assert.same(atanh(1.5), NaN);
assert.same(atanh(-1), -Infinity);
assert.same(atanh(1), Infinity);
assert.same(atanh(0), 0);
assert.same(atanh(-0), -0);
assert.same(atanh(-1e300), NaN);
assert.same(atanh(1e300), NaN);
assert.closeTo(atanh(0.5), 0.5493061443340549, 1e-11);
assert.closeTo(atanh(-0.5), -0.5493061443340549, 1e-11);
assert.closeTo(atanh(0.444), 0.47720201260109457, 1e-11);
assert.closeTo(atanh(1e-10), 1e-10, 1e-25, 'small value 1e-10');
assert.closeTo(atanh(1e-17), 1e-17, 1e-32, 'small value 1e-17');
assert.notSame(atanh(1e-20), 0, 'atanh(1e-20) should not be 0');
const checker = createConversionChecker(0.5);
assert.closeTo(atanh(checker), 0.5493061443340549, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.cbrt.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import cbrt from 'core-js-pure/es/math/cbrt';
QUnit.test('Math.cbrt', assert => {
assert.isFunction(cbrt);
assert.name(cbrt, 'cbrt');
assert.arity(cbrt, 1);
assert.same(cbrt(NaN), NaN);
assert.same(cbrt(0), 0);
assert.same(cbrt(-0), -0);
assert.same(cbrt(Infinity), Infinity);
assert.same(cbrt(-Infinity), -Infinity);
assert.same(cbrt(-8), -2);
assert.same(cbrt(8), 2);
assert.closeTo(cbrt(-1000), -10, 1e-11);
assert.closeTo(cbrt(1000), 10, 1e-11);
const checker = createConversionChecker(1000);
assert.closeTo(cbrt(checker), 10, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.clz32.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import clz32 from 'core-js-pure/es/math/clz32';
QUnit.test('Math.clz32', assert => {
assert.isFunction(clz32);
assert.name(clz32, 'clz32');
assert.arity(clz32, 1);
assert.same(clz32(0), 32);
assert.same(clz32(1), 31);
assert.same(clz32(-1), 0);
assert.same(clz32(0.6), 32);
assert.same(clz32(2 ** 32 - 1), 0);
assert.same(clz32(2 ** 32), 32);
const checker = createConversionChecker(1);
assert.same(clz32(checker), 31, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.cosh.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import cosh from 'core-js-pure/es/math/cosh';
QUnit.test('Math.cosh', assert => {
assert.isFunction(cosh);
assert.name(cosh, 'cosh');
assert.arity(cosh, 1);
assert.same(cosh(NaN), NaN);
assert.same(cosh(0), 1);
assert.same(cosh(-0), 1);
assert.same(cosh(Infinity), Infinity);
assert.same(cosh(-Infinity), Infinity);
assert.closeTo(cosh(12), 81377.395712574, 1e-9);
assert.closeTo(cosh(22), 1792456423.065796, 1e-5);
assert.closeTo(cosh(-10), 11013.232920103323, 1e-11);
assert.closeTo(cosh(-23), 4872401723.124452, 1e-5);
assert.closeTo(cosh(710), 1.1169973830808557e+308, 1e+295);
const checker = createConversionChecker(12);
assert.closeTo(cosh(checker), 81377.395712574, 1e-9, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.expm1.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import expm1 from 'core-js-pure/es/math/expm1';
QUnit.test('Math.expm1', assert => {
assert.isFunction(expm1);
assert.name(expm1, 'expm1');
assert.arity(expm1, 1);
assert.same(expm1(NaN), NaN);
assert.same(expm1(0), 0);
assert.same(expm1(-0), -0);
assert.same(expm1(Infinity), Infinity);
assert.same(expm1(-Infinity), -1);
assert.closeTo(expm1(10), 22025.465794806718, 1e-11);
assert.closeTo(expm1(-10), -0.9999546000702375, 1e-11);
const checker = createConversionChecker(10);
assert.closeTo(expm1(checker), 22025.465794806718, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.f16round.js
================================================
// some asserts based on https://github.com/petamoriken/float16/blob/master/test/f16round.js
import { createConversionChecker } from '../helpers/helpers.js';
import f16round from 'core-js-pure/es/math/f16round';
const { MAX_VALUE, MIN_VALUE } = Number;
QUnit.test('Math.f16round', assert => {
assert.isFunction(f16round);
assert.name(f16round, 'f16round');
assert.arity(f16round, 1);
assert.same(f16round(), NaN);
assert.same(f16round(undefined), NaN);
assert.same(f16round(NaN), NaN);
assert.same(f16round(null), 0);
assert.same(f16round(0), 0);
assert.same(f16round(-0), -0);
assert.same(f16round(MIN_VALUE), 0);
assert.same(f16round(-MIN_VALUE), -0);
assert.same(f16round(Infinity), Infinity);
assert.same(f16round(-Infinity), -Infinity);
assert.same(f16round(MAX_VALUE), Infinity);
assert.same(f16round(-MAX_VALUE), -Infinity);
const MAX_FLOAT16 = 65504;
const MIN_FLOAT16 = 2 ** -24;
assert.same(f16round(MAX_FLOAT16), MAX_FLOAT16);
assert.same(f16round(-MAX_FLOAT16), -MAX_FLOAT16);
assert.same(f16round(MIN_FLOAT16), MIN_FLOAT16);
assert.same(f16round(-MIN_FLOAT16), -MIN_FLOAT16);
assert.same(f16round(MIN_FLOAT16 / 2), 0);
assert.same(f16round(-MIN_FLOAT16 / 2), -0);
assert.same(f16round(2.980232238769531911744490042422139897126953655970282852649688720703125e-8), MIN_FLOAT16);
assert.same(f16round(-2.980232238769531911744490042422139897126953655970282852649688720703125e-8), -MIN_FLOAT16);
assert.same(f16round(1.337), 1.3369140625);
assert.same(f16round(0.499994), 0.5);
assert.same(f16round(7.9999999), 8);
const checker = createConversionChecker(1.1);
assert.same(f16round(checker), 1.099609375, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.fround.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import fround from 'core-js-pure/es/math/fround';
const { MAX_VALUE, MIN_VALUE } = Number;
QUnit.test('Math.fround', assert => {
assert.isFunction(fround);
assert.name(fround, 'fround');
assert.arity(fround, 1);
assert.same(fround(), NaN);
assert.same(fround(undefined), NaN);
assert.same(fround(NaN), NaN);
assert.same(fround(null), 0);
assert.same(fround(0), 0);
assert.same(fround(-0), -0);
assert.same(fround(MIN_VALUE), 0);
assert.same(fround(-MIN_VALUE), -0);
assert.same(fround(Infinity), Infinity);
assert.same(fround(-Infinity), -Infinity);
assert.same(fround(MAX_VALUE), Infinity);
assert.same(fround(-MAX_VALUE), -Infinity);
assert.same(fround(3.4028235677973366e+38), Infinity);
assert.same(fround(3), 3);
assert.same(fround(-3), -3);
const maxFloat32 = 3.4028234663852886e+38;
const minFloat32 = 1.401298464324817e-45;
assert.same(fround(maxFloat32), maxFloat32);
assert.same(fround(-maxFloat32), -maxFloat32);
assert.same(fround(maxFloat32 + 2 ** 102), maxFloat32);
assert.same(fround(minFloat32), minFloat32);
assert.same(fround(-minFloat32), -minFloat32);
assert.same(fround(minFloat32 / 2), 0);
assert.same(fround(-minFloat32 / 2), -0);
assert.same(fround(minFloat32 / 2 + 2 ** -202), minFloat32);
assert.same(fround(-minFloat32 / 2 - 2 ** -202), -minFloat32);
const maxSubnormal32 = 1.1754942106924411e-38;
const minNormal32 = 1.1754943508222875e-38;
assert.same(fround(1.1754942807573642e-38), maxSubnormal32, 'fround(1.1754942807573642e-38)');
assert.same(fround(1.1754942807573643e-38), minNormal32, 'fround(1.1754942807573643e-38)');
assert.same(fround(1.1754942807573644e-38), minNormal32, 'fround(1.1754942807573644e-38)');
assert.same(fround(-1.1754942807573642e-38), -maxSubnormal32, 'fround(-1.1754942807573642e-38)');
assert.same(fround(-1.1754942807573643e-38), -minNormal32, 'fround(-1.1754942807573643e-38)');
assert.same(fround(-1.1754942807573644e-38), -minNormal32, 'fround(-1.1754942807573644e-38)');
const checker = createConversionChecker(1.1754942807573642e-38);
assert.same(fround(checker), maxSubnormal32, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.hypot.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import hypot from 'core-js-pure/es/math/hypot';
QUnit.test('Math.hypot', assert => {
const { sqrt } = Math;
assert.isFunction(hypot);
assert.name(hypot, 'hypot');
assert.arity(hypot, 2);
assert.same(hypot(), 0);
assert.same(hypot(1), 1);
assert.same(hypot('', 0), 0);
assert.same(hypot(0, ''), 0);
assert.same(hypot(Infinity, 0), Infinity, 'Infinity, 0');
assert.same(hypot(-Infinity, 0), Infinity, '-Infinity, 0');
assert.same(hypot(0, Infinity), Infinity, '0, Infinity');
assert.same(hypot(0, -Infinity), Infinity, '0, -Infinity');
assert.same(hypot(Infinity, NaN), Infinity, 'Infinity, NaN');
assert.same(hypot(NaN, -Infinity), Infinity, 'NaN, -Infinity');
assert.same(hypot(NaN, 0), NaN, 'NaN, 0');
assert.same(hypot(0, NaN), NaN, '0, NaN');
assert.same(hypot(0, -0), 0);
assert.same(hypot(0, 0), 0);
assert.same(hypot(-0, -0), 0);
assert.same(hypot(-0, 0), 0);
assert.same(hypot(0, 1), 1);
assert.same(hypot(0, -1), 1);
assert.same(hypot(-0, 1), 1);
assert.same(hypot(-0, -1), 1);
assert.same(hypot(0), 0);
assert.same(hypot(1), 1);
assert.same(hypot(2), 2);
assert.same(hypot(0, 0, 1), 1);
assert.same(hypot(0, 1, 0), 1);
assert.same(hypot(1, 0, 0), 1);
assert.same(hypot(2, 3, 4), sqrt(2 ** 2 + 3 ** 2 + 4 ** 2));
assert.same(hypot(2, 3, 4, 5), sqrt(2 ** 2 + 3 ** 2 + 4 ** 2 + 5 ** 2));
assert.closeTo(hypot(66, 66), 93.33809511662427, 1e-11);
assert.closeTo(hypot(0.1, 100), 100.0000499999875, 1e-11);
assert.same(hypot(1e+300, 1e+300), 1.4142135623730952e+300);
assert.same(Math.floor(hypot(1e-300, 1e-300) * 1e308), 141421356);
assert.same(hypot(1e+300, 1e+300, 2, 3), 1.4142135623730952e+300);
assert.same(hypot(-3, 4), 5);
assert.same(hypot(3, -4), 5);
const checker1 = createConversionChecker(2);
const checker2 = createConversionChecker(3);
const checker3 = createConversionChecker(4);
const checker4 = createConversionChecker(5);
assert.same(hypot(checker1, checker2, checker3, checker4), sqrt(2 ** 2 + 3 ** 2 + 4 ** 2 + 5 ** 2), 'object wrapper');
assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
assert.same(checker1.$toString, 0, 'checker1 toString calls');
assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
assert.same(checker2.$toString, 0, 'checker2 toString calls');
assert.same(checker3.$valueOf, 1, 'checker3 valueOf calls');
assert.same(checker3.$toString, 0, 'checker3 toString calls');
assert.same(checker4.$valueOf, 1, 'checker4 valueOf calls');
assert.same(checker4.$toString, 0, 'checker4 toString calls');
});
================================================
FILE: tests/unit-pure/es.math.imul.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import imul from 'core-js-pure/es/math/imul';
QUnit.test('Math.imul', assert => {
assert.isFunction(imul);
assert.name(imul, 'imul');
assert.arity(imul, 2);
assert.same(imul(0, 0), 0);
assert.same(imul(123, 456), 56088);
assert.same(imul(-123, 456), -56088);
assert.same(imul(123, -456), -56088);
assert.same(imul(19088743, 4275878552), 602016552);
assert.same(imul(false, 7), 0);
assert.same(imul(7, false), 0);
assert.same(imul(false, false), 0);
assert.same(imul(true, 7), 7);
assert.same(imul(7, true), 7);
assert.same(imul(true, true), 1);
assert.same(imul(undefined, 7), 0);
assert.same(imul(7, undefined), 0);
assert.same(imul(undefined, undefined), 0);
assert.same(imul('str', 7), 0);
assert.same(imul(7, 'str'), 0);
assert.same(imul({}, 7), 0);
assert.same(imul(7, {}), 0);
assert.same(imul([], 7), 0);
assert.same(imul(7, []), 0);
assert.same(imul(0xFFFFFFFF, 5), -5);
assert.same(imul(0xFFFFFFFE, 5), -10);
assert.same(imul(2, 4), 8);
assert.same(imul(-1, 8), -8);
assert.same(imul(-2, -2), 4);
assert.same(imul(-0, 7), 0);
assert.same(imul(7, -0), 0);
assert.same(imul(0.1, 7), 0);
assert.same(imul(7, 0.1), 0);
assert.same(imul(0.9, 7), 0);
assert.same(imul(7, 0.9), 0);
assert.same(imul(1.1, 7), 7);
assert.same(imul(7, 1.1), 7);
assert.same(imul(1.9, 7), 7);
assert.same(imul(7, 1.9), 7);
const checker1 = createConversionChecker(-123);
const checker2 = createConversionChecker(456);
assert.same(imul(checker1, checker2), -56088, 'object wrapper');
assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
assert.same(checker1.$toString, 0, 'checker1 toString calls');
assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
assert.same(checker2.$toString, 0, 'checker2 toString calls');
});
================================================
FILE: tests/unit-pure/es.math.log10.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import log10 from 'core-js-pure/es/math/log10';
QUnit.test('Math.log10', assert => {
assert.isFunction(log10);
assert.name(log10, 'log10');
assert.arity(log10, 1);
assert.same(log10(''), log10(0));
assert.same(log10(NaN), NaN);
assert.same(log10(-1), NaN);
assert.same(log10(0), -Infinity);
assert.same(log10(-0), -Infinity);
assert.same(log10(1), 0);
assert.same(log10(Infinity), Infinity);
assert.closeTo(log10(0.1), -1, 1e-11);
assert.closeTo(log10(0.5), -0.3010299956639812, 1e-11);
assert.closeTo(log10(1.5), 0.17609125905568124, 1e-11);
assert.closeTo(log10(5), 0.6989700043360189, 1e-11);
assert.closeTo(log10(50), 1.6989700043360187, 1e-11);
assert.closeTo(log10(1000), 3, 1e-11);
const checker = createConversionChecker(0.5);
assert.closeTo(log10(checker), -0.3010299956639812, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.log1p.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import log1p from 'core-js-pure/es/math/log1p';
QUnit.test('Math.log1p', assert => {
assert.isFunction(log1p);
assert.name(log1p, 'log1p');
assert.arity(log1p, 1);
assert.same(log1p(''), log1p(0));
assert.same(log1p(NaN), NaN);
assert.same(log1p(-2), NaN);
assert.same(log1p(-1), -Infinity);
assert.same(log1p(0), 0);
assert.same(log1p(-0), -0);
assert.same(log1p(Infinity), Infinity);
assert.closeTo(log1p(5), 1.791759469228055, 1e-11);
assert.closeTo(log1p(50), 3.9318256327243257, 1e-11);
const checker = createConversionChecker(5);
assert.closeTo(log1p(checker), 1.791759469228055, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.log2.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import log2 from 'core-js-pure/es/math/log2';
QUnit.test('Math.log2', assert => {
assert.isFunction(log2);
assert.name(log2, 'log2');
assert.arity(log2, 1);
assert.same(log2(''), log2(0));
assert.same(log2(NaN), NaN);
assert.same(log2(-1), NaN);
assert.same(log2(0), -Infinity);
assert.same(log2(-0), -Infinity);
assert.same(log2(1), 0);
assert.same(log2(Infinity), Infinity);
assert.same(log2(0.5), -1);
assert.same(log2(32), 5);
assert.closeTo(log2(5), 2.321928094887362, 1e-11);
const checker = createConversionChecker(5);
assert.closeTo(log2(checker), 2.321928094887362, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.sign.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import sign from 'core-js-pure/es/math/sign';
QUnit.test('Math.sign', assert => {
assert.isFunction(sign);
assert.name(sign, 'sign');
assert.arity(sign, 1);
assert.same(sign(NaN), NaN);
assert.same(sign(), NaN);
assert.same(sign(-0), -0);
assert.same(sign(0), 0);
assert.same(sign(Infinity), 1);
assert.same(sign(-Infinity), -1);
assert.same(sign(13510798882111488), 1);
assert.same(sign(-13510798882111488), -1);
assert.same(sign(42.5), 1);
assert.same(sign(-42.5), -1);
const checker = createConversionChecker(-42.5);
assert.same(sign(checker), -1, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.sinh.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import sinh from 'core-js-pure/es/math/sinh';
QUnit.test('Math.sinh', assert => {
assert.isFunction(sinh);
assert.name(sinh, 'sinh');
assert.arity(sinh, 1);
assert.same(sinh(NaN), NaN);
assert.same(sinh(0), 0);
assert.same(sinh(-0), -0);
assert.same(sinh(Infinity), Infinity);
assert.same(sinh(-Infinity), -Infinity);
assert.closeTo(sinh(-5), -74.20321057778875, 1e-11);
assert.closeTo(sinh(2), 3.6268604078470186, 1e-11);
assert.same(sinh(-2e-17), -2e-17);
const checker = createConversionChecker(-5);
assert.closeTo(sinh(checker), -74.20321057778875, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.sum-precise.js
================================================
/* eslint-disable @stylistic/max-len -- ok */
import sumPrecise from 'core-js-pure/es/math/sum-precise';
import { createIterable } from '../helpers/helpers.js';
QUnit.test('Math.sumPrecise', assert => {
assert.isFunction(sumPrecise);
assert.name(sumPrecise, 'sumPrecise');
assert.arity(sumPrecise, 1);
assert.same(sumPrecise([1, 2, 3]), 6, 'basic');
assert.same(sumPrecise(createIterable([1, 2, 3])), 6, 'custom iterable');
assert.throws(() => sumPrecise(undefined), TypeError, 'undefined');
assert.throws(() => sumPrecise(null), TypeError, 'null');
assert.throws(() => sumPrecise({ 0: 1 }), TypeError, 'non-iterable');
assert.throws(() => sumPrecise(1, 2), TypeError, 'non-iterable #2');
assert.throws(() => sumPrecise([1, '2']), TypeError, 'non-number elements');
// Adapted from https://github.com/tc39/test262
// Copyright (C) 2024 Kevin Gibbons. All rights reserved.
// This code is governed by the BSD license
assert.same(sumPrecise([NaN]), NaN, '[NaN]');
assert.same(sumPrecise([Infinity, -Infinity]), NaN, '[Infinity, -Infinity]');
assert.same(sumPrecise([-Infinity, Infinity]), NaN, '[-Infinity, Infinity]');
assert.same(sumPrecise([Infinity]), Infinity, '[Infinity]');
assert.same(sumPrecise([Infinity, Infinity]), Infinity, '[Infinity, Infinity]');
assert.same(sumPrecise([-Infinity]), -Infinity, '[-Infinity]');
assert.same(sumPrecise([-Infinity, -Infinity]), -Infinity, '[-Infinity, -Infinity]');
assert.same(sumPrecise([]), -0, '[]');
assert.same(sumPrecise([-0]), -0, '[-0]');
assert.same(sumPrecise([-0, -0]), -0, '[-0, -0]');
assert.same(sumPrecise([-0, 0]), 0, '[-0, 0]');
assert.same(sumPrecise([1e308]), 1e308, '[1e308]');
assert.same(sumPrecise([1e308, -1e308]), 0, '[1e308, -1e308]');
assert.same(sumPrecise([0.1]), 0.1, '[0.1]');
assert.same(sumPrecise([0.1, 0.1]), 0.2, '[0.1, 0.1]');
assert.same(sumPrecise([0.1, -0.1]), 0, '[0.1, -0.1]');
assert.same(sumPrecise([1e308, 1e308, 0.1, 0.1, 1e30, 0.1, -1e30, -1e308, -1e308]), 0.30000000000000004, '[1e308, 1e308, 0.1, 0.1, 1e30, 0.1, -1e30, -1e308, -1e308]');
assert.same(sumPrecise([1e30, 0.1, -1e30]), 0.1, '[1e30, 0.1, -1e30]');
assert.same(sumPrecise([8.98846567431158e+307, 8.988465674311579e+307, -Number.MAX_VALUE]), 9.9792015476736e+291, '[8.98846567431158e+307, 8.988465674311579e+307, -Number.MAX_VALUE]');
assert.same(sumPrecise([-5.630637621603525e+255, 9.565271205476345e+307, 2.9937604643020797e+292]), 9.565271205476347e+307, '[-5.630637621603525e+255, 9.565271205476345e+307, 2.9937604643020797e+292]');
assert.same(sumPrecise([6.739986666787661e+66, 2, -1.2689709186578243e-116, 1.7046015739467354e+308, -9.979201547673601e+291, 6.160926733208294e+307, -3.179557053031852e+234, -7.027282978772846e+307, -0.7500000000000001]), 1.61796594939028e+308, '[6.739986666787661e+66, 2, -1.2689709186578243e-116, 1.7046015739467354e+308, -9.979201547673601e+291, 6.160926733208294e+307, -3.179557053031852e+234, -7.027282978772846e+307, -0.7500000000000001]');
assert.same(sumPrecise([0.31150493246968836, -8.988465674311582e+307, 1.8315037361673755e-270, -15.999999999999996, 2.9999999999999996, 7.345200721499384e+164, -2.033582473639399, -8.98846567431158e+307, -3.5737295155405993e+292, 4.13894772383715e-124, -3.6111186457260667e-35, 2.387234887098013e+180, 7.645295562778372e-298, 3.395189016861822e-103, -2.6331611115768973e-149]), -Infinity, '[0.31150493246968836, -8.988465674311582e+307, 1.8315037361673755e-270, -15.999999999999996, 2.9999999999999996, 7.345200721499384e+164, -2.033582473639399, -8.98846567431158e+307, -3.5737295155405993e+292, 4.13894772383715e-124, -3.6111186457260667e-35, 2.387234887098013e+180, 7.645295562778372e-298, 3.395189016861822e-103, -2.6331611115768973e-149]');
assert.same(sumPrecise([-1.1442589134409902e+308, 9.593842098384855e+138, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]), -1.5936821971565685e+308, '[-1.1442589134409902e+308, 9.593842098384855e+138, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]');
assert.same(sumPrecise([-1.1442589134409902e+308, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]), -1.5936821971565687e+308, '[-1.1442589134409902e+308, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]');
assert.same(sumPrecise([9.593842098384855e+138, -6.948356297254111e+307, -1.3482698511467367e+308, 4.494232837155792e+307]), -1.5936821971565685e+308, '[9.593842098384855e+138, -6.948356297254111e+307, -1.3482698511467367e+308, 4.494232837155792e+307]');
assert.same(sumPrecise([-2.534858246857893e+115, 8.988465674311579e+307, 8.98846567431158e+307]), Number.MAX_VALUE, '[-2.534858246857893e+115, 8.988465674311579e+307, 8.98846567431158e+307]');
assert.same(sumPrecise([1.3588124894186193e+308, 1.4803986201152006e+223, 6.741349255733684e+307]), Infinity, '[1.3588124894186193e+308, 1.4803986201152006e+223, 6.741349255733684e+307]');
assert.same(sumPrecise([6.741349255733684e+307, 1.7976931348623155e+308, -7.388327292663961e+41]), Infinity, '[6.741349255733684e+307, 1.7976931348623155e+308, -7.388327292663961e+41]');
assert.same(sumPrecise([-1.9807040628566093e+28, Number.MAX_VALUE, 9.9792015476736e+291]), Number.MAX_VALUE, '[-1.9807040628566093e+28, Number.MAX_VALUE, 9.9792015476736e+291]');
assert.same(sumPrecise([-1.0214557991173964e+61, Number.MAX_VALUE, 8.98846567431158e+307, -8.988465674311579e+307]), Number.MAX_VALUE, '[-1.0214557991173964e+61, Number.MAX_VALUE, 8.98846567431158e+307, -8.988465674311579e+307]');
assert.same(sumPrecise([Number.MAX_VALUE, 7.999999999999999, -1.908963895403937e-230, 1.6445950082320264e+292, 2.0734856707605806e+205]), Infinity, '[Number.MAX_VALUE, 7.999999999999999, -1.908963895403937e-230, 1.6445950082320264e+292, 2.0734856707605806e+205]');
assert.same(sumPrecise([6.197409167220438e-223, -9.979201547673601e+291, -Number.MAX_VALUE]), -Infinity, '[6.197409167220438e-223, -9.979201547673601e+291, -Number.MAX_VALUE]');
assert.same(sumPrecise([4.49423283715579e+307, 8.944251746776101e+307, -0.0002441406250000001, 1.1752060710043817e+308, 4.940846717201632e+292, -1.6836699406454528e+308]), 8.353845887521184e+307, '[4.49423283715579e+307, 8.944251746776101e+307, -0.0002441406250000001, 1.1752060710043817e+308, 4.940846717201632e+292, -1.6836699406454528e+308]');
assert.same(sumPrecise([8.988465674311579e+307, 7.999999999999998, 7.029158107234023e-308, -2.2303483759420562e-172, -Number.MAX_VALUE, -8.98846567431158e+307]), -Number.MAX_VALUE, '[8.988465674311579e+307, 7.999999999999998, 7.029158107234023e-308, -2.2303483759420562e-172, -Number.MAX_VALUE, -8.98846567431158e+307]');
assert.same(sumPrecise([8.98846567431158e+307, 8.98846567431158e+307]), Infinity, '[8.98846567431158e+307, 8.98846567431158e+307]');
});
================================================
FILE: tests/unit-pure/es.math.tanh.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import tanh from 'core-js-pure/es/math/tanh';
QUnit.test('Math.tanh', assert => {
assert.isFunction(tanh);
assert.name(tanh, 'tanh');
assert.arity(tanh, 1);
assert.same(tanh(NaN), NaN);
assert.same(tanh(0), 0);
assert.same(tanh(-0), -0);
assert.same(tanh(Infinity), 1);
assert.same(tanh(90), 1);
assert.closeTo(tanh(10), 0.9999999958776927, 1e-11);
const checker = createConversionChecker(10);
assert.closeTo(tanh(checker), 0.9999999958776927, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.math.trunc.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import trunc from 'core-js-pure/es/math/trunc';
QUnit.test('Math.trunc', assert => {
assert.isFunction(trunc);
assert.name(trunc, 'trunc');
assert.arity(trunc, 1);
assert.same(trunc(NaN), NaN, 'NaN -> NaN');
assert.same(trunc(-0), -0, '-0 -> -0');
assert.same(trunc(0), 0, '0 -> 0');
assert.same(trunc(Infinity), Infinity, 'Infinity -> Infinity');
assert.same(trunc(-Infinity), -Infinity, '-Infinity -> -Infinity');
assert.same(trunc(null), 0, 'null -> 0');
assert.same(trunc({}), NaN, '{} -> NaN');
assert.same(trunc([]), 0, '[] -> 0');
assert.same(trunc(1.01), 1, '1.01 -> 1');
assert.same(trunc(1.99), 1, '1.99 -> 1');
assert.same(trunc(-1), -1, '-1 -> -1');
assert.same(trunc(-1.99), -1, '-1.99 -> -1');
assert.same(trunc(-555.555), -555, '-555.555 -> -555');
assert.same(trunc(9007199254740992), 9007199254740992, '9007199254740992 -> 9007199254740992');
assert.same(trunc(-9007199254740992), -9007199254740992, '-9007199254740992 -> -9007199254740992');
const checker = createConversionChecker(-1.99);
assert.same(trunc(checker), -1, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/es.number.constructor.js
================================================
/* eslint-disable sonarjs/inconsistent-function-call -- required for testing */
import globalThis from 'core-js-pure/es/global-this';
import create from 'core-js-pure/es/object/create';
import Number from 'core-js-pure/es/number';
import Symbol from 'core-js-pure/es/symbol';
const NativeNumber = globalThis.Number;
const whitespaces = ' \t\u000B\f\u00A0\uFEFF\n\r\u2028\u2029\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000';
function getCheck(assert) {
return function (a, b) {
assert.same(Number(a), b, `Number ${ typeof a } ${ a } -> ${ b }`);
const x = new Number(a);
assert.same(x, Object(x), `new Number ${ typeof a } ${ a } is object`);
assert.same({}.toString.call(x).slice(8, -1), 'Number', `classof new Number ${ typeof a } ${ a } is Number`);
assert.same(x.valueOf(), b, `new Number(${ typeof a } ${ a }).valueOf() -> ${ b }`);
};
}
QUnit.test('Number constructor: regression', assert => {
const check = getCheck(assert);
assert.isFunction(Number);
assert.same(Number.prototype.constructor, NativeNumber);
assert.same(1.0.constructor, NativeNumber);
const constants = ['MAX_VALUE', 'MIN_VALUE', 'NaN', 'NEGATIVE_INFINITY', 'POSITIVE_INFINITY'];
for (const constant of constants) {
assert.true(constant in Number, `Number.${ constant }`);
assert.nonEnumerable(Number, constant);
}
assert.same(Number(), 0);
assert.same(new Number().valueOf(), 0);
check(42, 42);
check(42.42, 42.42);
check(new Number(42), 42);
check(new Number(42.42), 42.42);
check('42', 42);
check('42.42', 42.42);
check('0x42', 66);
check('0X42', 66);
check('0xzzz', NaN);
check('0x1g', NaN);
check('+0x1', NaN);
check('-0x1', NaN);
check('+0X1', NaN);
check('-0X1', NaN);
check(new String('42'), 42);
check(new String('42.42'), 42.42);
check(new String('0x42'), 66);
check(null, 0);
check(undefined, NaN);
check(false, 0);
check(true, 1);
check(new Boolean(false), 0);
check(new Boolean(true), 1);
check({}, NaN);
check({
valueOf: '1.1',
}, NaN);
check({
valueOf: '1.1',
toString() {
return '2.2';
},
}, 2.2);
check({
valueOf() {
return '1.1';
},
}, 1.1);
check({
valueOf() {
return '1.1';
},
toString() {
return '2.2';
},
}, 1.1);
check({
valueOf() {
return '-0x1a2b3c';
},
}, NaN);
check({
toString() {
return '-0x1a2b3c';
},
}, NaN);
check({
valueOf() {
return 42;
},
}, 42);
check({
valueOf() {
return '42';
},
}, 42);
check({
valueOf() {
return null;
},
}, 0);
check({
toString() {
return 42;
},
}, 42);
check({
toString() {
return '42';
},
}, 42);
check({
valueOf() {
return 1;
},
toString() {
return 2;
},
}, 1);
check({
valueOf: 1,
toString() {
return 2;
},
}, 2);
let number = 1;
assert.same(Number({
valueOf() {
return ++number;
},
}), 2, 'Number call valueOf only once #1');
assert.same(number, 2, 'Number call valueOf only once #2');
number = 1;
assert.same(Number({
toString() {
return ++number;
},
}), 2, 'Number call toString only once #1');
assert.same(number, 2, 'Number call toString only once #2');
number = 1;
assert.same(new Number({
valueOf() {
return ++number;
},
}).valueOf(), 2, 'new Number call valueOf only once #1');
assert.same(number, 2, 'new Number call valueOf only once #2');
number = 1;
assert.same(new Number({
toString() {
return ++number;
},
}).valueOf(), 2, 'new Number call toString only once #1');
assert.same(number, 2, 'new Number call toString only once #2');
assert.throws(() => Number(create(null)), TypeError, 'Number assert.throws on object w/o valueOf and toString');
assert.throws(() => Number({
valueOf: 1,
toString: 2,
}), TypeError, 'Number assert.throws on object then valueOf and toString are not functions');
assert.throws(() => new Number(create(null)), TypeError, 'new Number assert.throws on object w/o valueOf and toString');
assert.throws(() => new Number({
valueOf: 1,
toString: 2,
}), TypeError, 'new Number assert.throws on object then valueOf and toString are not functions');
if (typeof Symbol == 'function' && !Symbol.sham) {
const symbol = Symbol('Number constructor test');
assert.throws(() => Number(symbol), 'throws on symbol argument');
assert.throws(() => new Number(symbol), 'throws on symbol argument, new');
}
number = new Number(42);
assert.same(typeof number.constructor(number), 'number');
check(`${ whitespaces }42`, 42);
check(`42${ whitespaces }`, 42);
check(`${ whitespaces }42${ whitespaces }`, 42);
check(`${ whitespaces }0x42`, 66);
check(`0x42${ whitespaces }`, 66);
check(`${ whitespaces }0x42${ whitespaces }`, 66);
check(`${ whitespaces }0X42`, 66);
check(`0X42${ whitespaces }`, 66);
check(`${ whitespaces }0X42${ whitespaces }`, 66);
});
QUnit.test('Number constructor: binary', assert => {
const check = getCheck(assert);
check('0b1', 1);
check('0B1', 1);
check('0b12', NaN);
check('0b234', NaN);
check('0b1!', NaN);
check('+0b1', NaN);
check('-0b1', NaN);
check(' 0b1', 1);
check('0b1\n', 1);
check('\n 0b1\n ', 1);
check(' 0B1', 1);
check('0B1\n', 1);
check('\n 0B1\n ', 1);
check({
valueOf() {
return '0b11';
},
}, 3);
check({
toString() {
return '0b111';
},
}, 7);
check({
valueOf() {
return '0b101010';
},
}, 42);
check({
toString() {
return '0b101010';
},
}, 42);
check(`${ whitespaces }0b11`, 3);
check(`0b11${ whitespaces }`, 3);
check(`${ whitespaces }0b11${ whitespaces }`, 3);
check(`${ whitespaces }0B11`, 3);
check(`0B11${ whitespaces }`, 3);
check(`${ whitespaces }0B11${ whitespaces }`, 3);
});
QUnit.test('Number constructor: octal', assert => {
const check = getCheck(assert);
check('0o7', 7);
check('0O7', 7);
check('0o18', NaN);
check('0o89a', NaN);
check('0o1!', NaN);
check('+0o1', NaN);
check('-0o1', NaN);
check(' 0o1', 1);
check('0o1\n', 1);
check('\n 0o1\n ', 1);
check(' 0O1', 1);
check('0O1\n', 1);
check('\n 0O1\n ', 1);
check({
valueOf() {
return '0o77';
},
}, 63);
check({
toString() {
return '0o777';
},
}, 511);
check({
valueOf() {
return '0o12345';
},
}, 5349);
check({
toString() {
return '0o12345';
},
}, 5349);
check(`${ whitespaces }0o11`, 9);
check(`0o11${ whitespaces }`, 9);
check(`${ whitespaces }0o11${ whitespaces }`, 9);
check(`${ whitespaces }0O11`, 9);
check(`0O11${ whitespaces }`, 9);
check(`${ whitespaces }0O11${ whitespaces }`, 9);
});
================================================
FILE: tests/unit-pure/es.number.epsilon.js
================================================
import EPSILON from 'core-js-pure/es/number/epsilon';
QUnit.test('Number.EPSILON', assert => {
assert.same(EPSILON, 2 ** -52, 'Is 2^-52');
assert.notSame(1 + EPSILON, 1, '1 is not 1 + EPSILON');
assert.same(1 + EPSILON / 2, 1, '1 is 1 + EPSILON / 2');
});
================================================
FILE: tests/unit-pure/es.number.is-finite.js
================================================
import create from 'core-js-pure/es/object/create';
import isFinite from 'core-js-pure/es/number/is-finite';
QUnit.test('Number.isFinite', assert => {
assert.isFunction(isFinite);
assert.name(isFinite, 'isFinite');
assert.arity(isFinite, 1);
const finite = [
1,
0.1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
];
for (const value of finite) {
assert.true(isFinite(value), `isFinite ${ typeof value } ${ value }`);
}
const notFinite = [
NaN,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notFinite) {
assert.false(isFinite(value), `not isFinite ${ typeof value } ${ value }`);
}
assert.false(isFinite(create(null)), 'Number.isFinite(Object.create(null)) -> false');
});
================================================
FILE: tests/unit-pure/es.number.is-integer.js
================================================
import create from 'core-js-pure/es/object/create';
import isInteger from 'core-js-pure/es/number/is-integer';
QUnit.test('Number.isInteger', assert => {
assert.isFunction(isInteger);
assert.name(isInteger, 'isInteger');
assert.arity(isInteger, 1);
const integers = [
1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
];
for (const value of integers) {
assert.true(isInteger(value), `isInteger ${ typeof value } ${ value }`);
}
const notIntegers = [
NaN,
0.1,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notIntegers) {
assert.false(isInteger(value), `not isInteger ${ typeof value } ${ value }`);
}
assert.false(isInteger(create(null)), 'Number.isInteger(Object.create(null)) -> false');
});
================================================
FILE: tests/unit-pure/es.number.is-nan.js
================================================
import create from 'core-js-pure/es/object/create';
import isNaN from 'core-js-pure/es/number/is-nan';
QUnit.test('Number.isNaN', assert => {
assert.isFunction(isNaN);
assert.name(isNaN, 'isNaN');
assert.arity(isNaN, 1);
assert.true(isNaN(NaN), 'Number.isNaN NaN');
const notNaNs = [
1,
0.1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notNaNs) {
assert.false(isNaN(value), `not Number.isNaN ${ typeof value } ${ value }`);
}
assert.false(isNaN(create(null)), 'Number.isNaN(Object.create(null)) -> false');
});
================================================
FILE: tests/unit-pure/es.number.is-safe-integer.js
================================================
import { MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
import create from 'core-js-pure/es/object/create';
import isSafeInteger from 'core-js-pure/es/number/is-safe-integer';
QUnit.test('Number.isSafeInteger', assert => {
assert.isFunction(isSafeInteger);
assert.name(isSafeInteger, 'isSafeInteger');
assert.arity(isSafeInteger, 1);
const safeIntegers = [
1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
MAX_SAFE_INTEGER,
MIN_SAFE_INTEGER,
];
for (const value of safeIntegers) {
assert.true(isSafeInteger(value), `isSafeInteger ${ typeof value } ${ value }`);
}
const notSafeIntegers = [
MAX_SAFE_INTEGER + 1,
MIN_SAFE_INTEGER - 1,
NaN,
0.1,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notSafeIntegers) {
assert.false(isSafeInteger(value), `not isSafeInteger ${ typeof value } ${ value }`);
}
assert.false(isSafeInteger(create(null)), 'Number.isSafeInteger(Object.create(null)) -> false');
});
================================================
FILE: tests/unit-pure/es.number.max-safe-integer.js
================================================
import MAX_SAFE_INTEGER from 'core-js-pure/es/number/max-safe-integer';
QUnit.test('Number.MAX_SAFE_INTEGER', assert => {
assert.same(MAX_SAFE_INTEGER, 2 ** 53 - 1, 'Is 2^53 - 1');
});
================================================
FILE: tests/unit-pure/es.number.min-safe-integer.js
================================================
import MIN_SAFE_INTEGER from 'core-js-pure/es/number/min-safe-integer';
QUnit.test('Number.MIN_SAFE_INTEGER', assert => {
assert.same(MIN_SAFE_INTEGER, -(2 ** 53) + 1, 'Is -2^53 + 1');
});
================================================
FILE: tests/unit-pure/es.number.parse-float.js
================================================
import { WHITESPACES } from '../helpers/constants.js';
import parseFloat from 'core-js-pure/es/number/parse-float';
QUnit.test('Number.parseFloat', assert => {
assert.isFunction(parseFloat);
assert.arity(parseFloat, 1);
assert.name(parseFloat, 'parseFloat');
assert.same(parseFloat('0'), 0);
assert.same(parseFloat(' 0'), 0);
assert.same(parseFloat('+0'), 0);
assert.same(parseFloat(' +0'), 0);
assert.same(parseFloat('-0'), -0);
assert.same(parseFloat(' -0'), -0);
assert.same(parseFloat(`${ WHITESPACES }+0`), 0);
assert.same(parseFloat(`${ WHITESPACES }-0`), -0);
assert.same(parseFloat(null), NaN);
assert.same(parseFloat(undefined), NaN);
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
const symbol = Symbol('Number.parseFloat test');
assert.throws(() => parseFloat(symbol), 'throws on symbol argument');
assert.throws(() => parseFloat(Object(symbol)), 'throws on boxed symbol argument');
}
});
================================================
FILE: tests/unit-pure/es.number.parse-int.js
================================================
/* eslint-disable prefer-numeric-literals -- required for testing */
import { WHITESPACES } from '../helpers/constants.js';
import parseInt from 'core-js-pure/es/number/parse-int';
QUnit.test('Number.parseInt', assert => {
assert.isFunction(parseInt);
assert.arity(parseInt, 2);
assert.name(parseInt, 'parseInt');
for (let radix = 2; radix <= 36; ++radix) {
assert.same(parseInt('10', radix), radix, `radix ${ radix }`);
}
const strings = ['01', '08', '10', '42'];
for (const string of strings) {
assert.same(parseInt(string), parseInt(string, 10), `default radix is 10: ${ string }`);
}
assert.same(parseInt('0x16'), parseInt('0x16', 16), 'default radix is 16: 0x16');
assert.same(parseInt(' 0x16'), parseInt('0x16', 16), 'ignores leading whitespace #1');
assert.same(parseInt(' 42'), parseInt('42', 10), 'ignores leading whitespace #2');
assert.same(parseInt(' 08'), parseInt('08', 10), 'ignores leading whitespace #3');
assert.same(parseInt(`${ WHITESPACES }08`), parseInt('08', 10), 'ignores leading whitespace #4');
assert.same(parseInt(`${ WHITESPACES }0x16`), parseInt('0x16', 16), 'ignores leading whitespace #5');
const fakeZero = {
valueOf() {
return 0;
},
};
assert.same(parseInt('08', fakeZero), parseInt('08', 10), 'valueOf #1');
assert.same(parseInt('0x16', fakeZero), parseInt('0x16', 16), 'valueOf #2');
assert.same(parseInt('-0xF'), -15, 'signed hex #1');
assert.same(parseInt('-0xF', 16), -15, 'signed hex #2');
assert.same(parseInt('+0xF'), 15, 'signed hex #3');
assert.same(parseInt('+0xF', 16), 15, 'signed hex #4');
assert.same(parseInt('10', -4294967294), 2, 'radix uses ToUint32');
assert.same(parseInt(null), NaN);
assert.same(parseInt(undefined), NaN);
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
const symbol = Symbol('Number.parseInt test');
assert.throws(() => parseInt(symbol), 'throws on symbol argument');
assert.throws(() => parseInt(Object(symbol)), 'throws on boxed symbol argument');
}
});
================================================
FILE: tests/unit-pure/es.number.to-exponential.js
================================================
import toExponential from 'core-js-pure/es/number/virtual/to-exponential';
QUnit.test('Number#toExponential', assert => {
assert.isFunction(toExponential);
assert.same(toExponential.call(0.00008, 3), '8.000e-5');
assert.same(toExponential.call(0.9, 0), '9e-1');
assert.same(toExponential.call(1.255, 2), '1.25e+0');
assert.same(toExponential.call(1843654265.0774949, 5), '1.84365e+9');
assert.same(toExponential.call(1000000000000000128.0, 0), '1e+18');
assert.same(toExponential.call(1), '1e+0');
assert.same(toExponential.call(1, 0), '1e+0');
assert.same(toExponential.call(1, 1), '1.0e+0');
assert.same(toExponential.call(1, 1.1), '1.0e+0');
assert.same(toExponential.call(1, 0.9), '1e+0');
assert.same(toExponential.call(1, '0'), '1e+0');
assert.same(toExponential.call(1, '1'), '1.0e+0');
assert.same(toExponential.call(1, '1.1'), '1.0e+0');
assert.same(toExponential.call(1, '0.9'), '1e+0');
assert.same(toExponential.call(1, NaN), '1e+0');
assert.same(toExponential.call(1, 'some string'), '1e+0');
assert.notThrows(() => toExponential.call(1, -0.1) === '1e+0');
assert.same(toExponential.call(new Number(1)), '1e+0');
assert.same(toExponential.call(new Number(1), 0), '1e+0');
assert.same(toExponential.call(new Number(1), 1), '1.0e+0');
assert.same(toExponential.call(new Number(1), 1.1), '1.0e+0');
assert.same(toExponential.call(new Number(1), 0.9), '1e+0');
assert.same(toExponential.call(new Number(1), '0'), '1e+0');
assert.same(toExponential.call(new Number(1), '1'), '1.0e+0');
assert.same(toExponential.call(new Number(1), '1.1'), '1.0e+0');
assert.same(toExponential.call(new Number(1), '0.9'), '1e+0');
assert.same(toExponential.call(new Number(1), NaN), '1e+0');
assert.same(toExponential.call(new Number(1), 'some string'), '1e+0');
assert.notThrows(() => toExponential.call(new Number(1), -0.1) === '1e+0');
assert.same(toExponential.call(NaN), 'NaN');
assert.same(toExponential.call(NaN, 0), 'NaN');
assert.same(toExponential.call(NaN, 1), 'NaN');
assert.same(toExponential.call(NaN, 1.1), 'NaN');
assert.same(toExponential.call(NaN, 0.9), 'NaN');
assert.same(toExponential.call(NaN, '0'), 'NaN');
assert.same(toExponential.call(NaN, '1'), 'NaN');
assert.same(toExponential.call(NaN, '1.1'), 'NaN');
assert.same(toExponential.call(NaN, '0.9'), 'NaN');
assert.same(toExponential.call(NaN, NaN), 'NaN');
assert.same(toExponential.call(NaN, 'some string'), 'NaN');
assert.notThrows(() => toExponential.call(NaN, -0.1) === 'NaN');
assert.same(toExponential.call(new Number(1e21)), '1e+21');
assert.same(toExponential.call(new Number(1e21), 0), '1e+21');
assert.same(toExponential.call(new Number(1e21), 1), '1.0e+21');
assert.same(toExponential.call(new Number(1e21), 1.1), '1.0e+21');
assert.same(toExponential.call(new Number(1e21), 0.9), '1e+21');
assert.same(toExponential.call(new Number(1e21), '0'), '1e+21');
assert.same(toExponential.call(new Number(1e21), '1'), '1.0e+21');
assert.same(toExponential.call(new Number(1e21), '1.1'), '1.0e+21');
assert.same(toExponential.call(new Number(1e21), '0.9'), '1e+21');
assert.same(toExponential.call(new Number(1e21), NaN), '1e+21');
assert.same(toExponential.call(new Number(1e21), 'some string'), '1e+21');
assert.same(toExponential.call(5, 19), '5.0000000000000000000e+0');
// ported from tests262, the license: https://github.com/tc39/test262/blob/main/LICENSE
assert.same(toExponential.call(123.456, 0), '1e+2');
assert.same(toExponential.call(123.456, 1), '1.2e+2');
assert.same(toExponential.call(123.456, 2), '1.23e+2');
assert.same(toExponential.call(123.456, 3), '1.235e+2');
assert.same(toExponential.call(123.456, 4), '1.2346e+2');
assert.same(toExponential.call(123.456, 5), '1.23456e+2');
assert.same(toExponential.call(123.456, 6), '1.234560e+2');
assert.same(toExponential.call(123.456, 7), '1.2345600e+2');
// assert.same(toExponential.call(123.456, 17), '1.23456000000000003e+2');
// assert.same(toExponential.call(123.456, 20), '1.23456000000000003070e+2');
assert.same(toExponential.call(-123.456, 0), '-1e+2');
assert.same(toExponential.call(-123.456, 1), '-1.2e+2');
assert.same(toExponential.call(-123.456, 2), '-1.23e+2');
assert.same(toExponential.call(-123.456, 3), '-1.235e+2');
assert.same(toExponential.call(-123.456, 4), '-1.2346e+2');
assert.same(toExponential.call(-123.456, 5), '-1.23456e+2');
assert.same(toExponential.call(-123.456, 6), '-1.234560e+2');
assert.same(toExponential.call(-123.456, 7), '-1.2345600e+2');
// assert.same(toExponential.call(-123.456, 17), '-1.23456000000000003e+2');
// assert.same(toExponential.call(-123.456, 20), '-1.23456000000000003070e+2');
assert.same(toExponential.call(0.0001, 0), '1e-4');
assert.same(toExponential.call(0.0001, 1), '1.0e-4');
assert.same(toExponential.call(0.0001, 2), '1.00e-4');
assert.same(toExponential.call(0.0001, 3), '1.000e-4');
assert.same(toExponential.call(0.0001, 4), '1.0000e-4');
// assert.same(toExponential.call(0.0001, 16), '1.0000000000000000e-4');
// assert.same(toExponential.call(0.0001, 17), '1.00000000000000005e-4');
// assert.same(toExponential.call(0.0001, 18), '1.000000000000000048e-4');
// assert.same(toExponential.call(0.0001, 19), '1.0000000000000000479e-4');
// assert.same(toExponential.call(0.0001, 20), '1.00000000000000004792e-4');
assert.same(toExponential.call(0.9999, 0), '1e+0');
assert.same(toExponential.call(0.9999, 1), '1.0e+0');
assert.same(toExponential.call(0.9999, 2), '1.00e+0');
assert.same(toExponential.call(0.9999, 3), '9.999e-1');
assert.same(toExponential.call(0.9999, 4), '9.9990e-1');
// assert.same(toExponential.call(0.9999, 16), '9.9990000000000001e-1');
// assert.same(toExponential.call(0.9999, 17), '9.99900000000000011e-1');
// assert.same(toExponential.call(0.9999, 18), '9.999000000000000110e-1');
// assert.same(toExponential.call(0.9999, 19), '9.9990000000000001101e-1');
// assert.same(toExponential.call(0.9999, 20), '9.99900000000000011013e-1');
assert.same(toExponential.call(25, 0), '3e+1'); // FF86- and Chrome 49-50 bugs
assert.same(toExponential.call(12345, 3), '1.235e+4'); // FF86- and Chrome 49-50 bugs
assert.same(toExponential.call(Number.prototype, 0), '0e+0', 'Number.prototype, 0');
assert.same(toExponential.call(0, 0), '0e+0', '0, 0');
assert.same(toExponential.call(-0, 0), '0e+0', '-0, 0');
assert.same(toExponential.call(0, -0), '0e+0', '0, -0');
assert.same(toExponential.call(-0, -0), '0e+0', '-0, -0');
assert.same(toExponential.call(0, 1), '0.0e+0', '0 and 1');
assert.same(toExponential.call(0, 2), '0.00e+0', '0 and 2');
assert.same(toExponential.call(0, 7), '0.0000000e+0', '0 and 7');
assert.same(toExponential.call(0, 20), '0.00000000000000000000e+0', '0 and 20');
assert.same(toExponential.call(-0, 1), '0.0e+0', '-0 and 1');
assert.same(toExponential.call(-0, 2), '0.00e+0', '-0 and 2');
assert.same(toExponential.call(-0, 7), '0.0000000e+0', '-0 and 7');
assert.same(toExponential.call(-0, 20), '0.00000000000000000000e+0', '-0 and 20');
// overflow / underflow edge cases
assert.same(toExponential.call(9e307, 0), '9e+307', '9e307, 0');
assert.same(toExponential.call(-9e307, 0), '-9e+307', '-9e307, 0');
assert.same(toExponential.call(Number.MAX_VALUE, 0), '2e+308', 'MAX_VALUE, 0');
assert.same(toExponential.call(Number.MAX_VALUE, 5), '1.79769e+308', 'MAX_VALUE, 5');
assert.same(toExponential.call(Number.MIN_VALUE, 0), '5e-324', 'MIN_VALUE, 0');
assert.same(toExponential.call(Number.MIN_VALUE, 1), '4.9e-324', 'MIN_VALUE, 1');
assert.same(toExponential.call(1e-323, 0), '1e-323', '1e-323, 0');
assert.same(toExponential.call(NaN, 1000), 'NaN', 'NaN check before fractionDigits check');
assert.same(toExponential.call(Infinity, 1000), 'Infinity', 'Infinity check before fractionDigits check');
assert.notThrows(() => toExponential.call(new Number(1e21), -0.1) === '1e+21');
assert.throws(() => toExponential.call(1.0, -101), RangeError, 'If f < 0 or f > 20 (100), throw a RangeError exception.');
assert.throws(() => toExponential.call(1.0, 101), RangeError, 'If f < 0 or f > 20 (100), throw a RangeError exception.');
assert.throws(() => toExponential.call({}, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toExponential.call('123', 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toExponential.call(false, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toExponential.call(null, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toExponential.call(undefined, 1), TypeError, '? thisNumberValue(this value)');
});
================================================
FILE: tests/unit-pure/es.number.to-fixed.js
================================================
import toFixed from 'core-js-pure/es/number/to-fixed';
QUnit.test('Number#toFixed', assert => {
assert.isFunction(toFixed);
assert.same(toFixed(0.00008, 3), '0.000');
assert.same(toFixed(0.9, 0), '1');
assert.same(toFixed(1.255, 2), '1.25');
assert.same(toFixed(1843654265.0774949, 5), '1843654265.07749');
assert.same(toFixed(1000000000000000128, 0), '1000000000000000128');
assert.same(toFixed(1), '1');
assert.same(toFixed(1, 0), '1');
assert.same(toFixed(1, 1), '1.0');
assert.same(toFixed(1, 1.1), '1.0');
assert.same(toFixed(1, 0.9), '1');
assert.same(toFixed(1, '0'), '1');
assert.same(toFixed(1, '1'), '1.0');
assert.same(toFixed(1, '1.1'), '1.0');
assert.same(toFixed(1, '0.9'), '1');
assert.same(toFixed(1, NaN), '1');
assert.same(toFixed(1, 'some string'), '1');
assert.notThrows(() => toFixed(1, -0.1) === '1');
assert.same(toFixed(Object(1)), '1');
assert.same(toFixed(Object(1), 0), '1');
assert.same(toFixed(Object(1), 1), '1.0');
assert.same(toFixed(Object(1), 1.1), '1.0');
assert.same(toFixed(Object(1), 0.9), '1');
assert.same(toFixed(Object(1), '0'), '1');
assert.same(toFixed(Object(1), '1'), '1.0');
assert.same(toFixed(Object(1), '1.1'), '1.0');
assert.same(toFixed(Object(1), '0.9'), '1');
assert.same(toFixed(Object(1), NaN), '1');
assert.same(toFixed(Object(1), 'some string'), '1');
assert.notThrows(() => toFixed(Object(1), -0.1) === '1');
assert.same(toFixed(NaN), 'NaN');
assert.same(toFixed(NaN, 0), 'NaN');
assert.same(toFixed(NaN, 1), 'NaN');
assert.same(toFixed(NaN, 1.1), 'NaN');
assert.same(toFixed(NaN, 0.9), 'NaN');
assert.same(toFixed(NaN, '0'), 'NaN');
assert.same(toFixed(NaN, '1'), 'NaN');
assert.same(toFixed(NaN, '1.1'), 'NaN');
assert.same(toFixed(NaN, '0.9'), 'NaN');
assert.same(toFixed(NaN, NaN), 'NaN');
assert.same(toFixed(NaN, 'some string'), 'NaN');
assert.notThrows(() => toFixed(NaN, -0.1) === 'NaN');
assert.same(toFixed(1e21), String(1e21));
assert.same(toFixed(1e21, 0), String(1e21));
assert.same(toFixed(1e21, 1), String(1e21));
assert.same(toFixed(1e21, 1.1), String(1e21));
assert.same(toFixed(1e21, 0.9), String(1e21));
assert.same(toFixed(1e21, '0'), String(1e21));
assert.same(toFixed(1e21, '1'), String(1e21));
assert.same(toFixed(1e21, '1.1'), String(1e21));
assert.same(toFixed(1e21, '0.9'), String(1e21));
assert.same(toFixed(1e21, NaN), String(1e21));
assert.same(toFixed(1e21, 'some string'), String(1e21));
assert.notThrows(() => toFixed(1e21, -0.1) === String(1e21));
assert.throws(() => toFixed(1, -101), RangeError, 'If f < 0 or f > 20 (100), throw a RangeError exception.');
assert.throws(() => toFixed(1, 101), RangeError, 'If f < 0 or f > 20 (100), throw a RangeError exception.');
assert.throws(() => toFixed(NaN, Infinity), RangeError, 'If f < 0 or f > 20 (100), throw a RangeError exception.');
assert.throws(() => toFixed({}, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed('123', 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed(false, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed(null, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed(undefined, 1), TypeError, '? thisNumberValue(this value)');
});
================================================
FILE: tests/unit-pure/es.number.to-precision.js
================================================
import toPrecision from 'core-js-pure/es/number/to-precision';
QUnit.test('Number#toPrecision', assert => {
assert.isFunction(toPrecision);
assert.same(toPrecision(0.00008, 3), '0.0000800', '0.00008.toPrecision(3)');
assert.same(toPrecision(1.255, 2), '1.3', '1.255.toPrecision(2)');
assert.same(toPrecision(1843654265.0774949, 13), '1843654265.077', '1843654265.0774949.toPrecision(13)');
assert.same(toPrecision(NaN, 1), 'NaN', 'If x is NaN, return the String "NaN".');
assert.same(toPrecision(123.456), '123.456', 'If precision is undefined, return ! ToString(x).');
assert.same(toPrecision(123.456, undefined), '123.456', 'If precision is undefined, return ! ToString(x).');
assert.throws(() => toPrecision(0.9, 0), RangeError, 'If p < 1 or p > 21, throw a RangeError exception.');
assert.throws(() => toPrecision(0.9, 101), RangeError, 'If p < 1 or p > 21, throw a RangeError exception.');
assert.throws(() => toPrecision({}, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision('123', 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision(false, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision(null, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision(undefined, 1), TypeError, '? thisNumberValue(this value)');
});
================================================
FILE: tests/unit-pure/es.object.assign.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import defineProperty from 'core-js-pure/es/object/define-property';
import keys from 'core-js-pure/es/object/keys';
import assign from 'core-js-pure/es/object/assign';
QUnit.test('Object.assign', assert => {
assert.isFunction(assign);
assert.arity(assign, 2);
assert.name(assign, 'assign');
let object = { q: 1 };
assert.same(object, assign(object, { bar: 2 }), 'assign return target');
assert.same(object.bar, 2, 'assign define properties');
assert.deepEqual(assign({}, { q: 1 }, { w: 2 }), { q: 1, w: 2 });
assert.deepEqual(assign({}, 'qwe'), { 0: 'q', 1: 'w', 2: 'e' });
assert.throws(() => assign(null, { q: 1 }), TypeError);
assert.throws(() => assign(undefined, { q: 1 }), TypeError);
let string = assign('qwe', { q: 1 });
assert.same(typeof string, 'object');
assert.same(String(string), 'qwe');
assert.same(string.q, 1);
assert.same(assign({}, { valueOf: 42 }).valueOf, 42, 'IE enum keys bug');
if (DESCRIPTORS) {
object = { baz: 1 };
assign(object, defineProperty({}, 'bar', {
get() {
return this.baz + 1;
},
}));
assert.same(object.bar, undefined, "assign don't copy descriptors");
object = { a: 'a' };
const c = Symbol('c');
const d = Symbol('d');
object[c] = 'c';
defineProperty(object, 'b', { value: 'b' });
defineProperty(object, d, { value: 'd' });
const object2 = assign({}, object);
assert.same(object2.a, 'a', 'a');
assert.same(object2.b, undefined, 'b');
assert.same(object2[c], 'c', 'c');
assert.same(object2[d], undefined, 'd');
try {
assert.same(Function('assign', `
return assign({ b: 1 }, { get a() {
delete this.b;
}, b: 2 });
`)(assign).b, 1);
} catch { /* empty */ }
try {
assert.same(Function('assign', `
return assign({ b: 1 }, { get a() {
Object.defineProperty(this, "b", {
value: 3,
enumerable: false
});
}, b: 2 });
`)(assign).b, 1);
} catch { /* empty */ }
}
string = 'abcdefghijklmnopqrst';
const result = {};
for (let i = 0, { length } = string; i < length; ++i) {
const chr = string.charAt(i);
result[chr] = chr;
}
assert.same(keys(assign({}, result)).join(''), string);
});
================================================
FILE: tests/unit-pure/es.object.create.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import create from 'core-js-pure/es/object/create';
QUnit.test('Object.create', assert => {
function getPropertyNames(object) {
let result = [];
do {
result = result.concat(getOwnPropertyNames(object));
} while (object = getPrototypeOf(object));
return result;
}
assert.isFunction(create);
assert.arity(create, 2);
assert.name(create, 'create');
let object = { q: 1 };
assert.true({}.isPrototypeOf.call(object, create(object)));
assert.same(create(object).q, 1);
function C() {
return this.a = 1;
}
assert.true(create(new C()) instanceof C);
assert.same(C.prototype, getPrototypeOf(getPrototypeOf(create(new C()))));
assert.same(create(new C()).a, 1);
assert.same(create({}, { a: { value: 42 } }).a, 42);
object = create(null, { w: { value: 2 } });
assert.same(object, Object(object));
assert.false('toString' in object);
assert.same(object.w, 2);
assert.deepEqual(getPropertyNames(create(null)), []);
});
QUnit.test('Object.create.sham flag', assert => {
assert.same(create.sham, DESCRIPTORS ? undefined : true);
});
================================================
FILE: tests/unit-pure/es.object.define-getter.js
================================================
/* eslint-disable id-match -- unification with global tests */
import { DESCRIPTORS, STRICT } from '../helpers/constants.js';
import __defineGetter__ from 'core-js-pure/es/object/define-getter';
import __defineSetter__ from 'core-js-pure/es/object/define-setter';
if (DESCRIPTORS) {
QUnit.test('Object#__defineGetter__', assert => {
assert.isFunction(__defineGetter__);
const object = {};
assert.same(__defineGetter__(object, 'key', () => 42), undefined, 'void');
assert.same(object.key, 42, 'works');
__defineSetter__(object, 'key', function () {
this.foo = 43;
});
object.key = 44;
assert.same(object.key, 42, 'works with setter #1');
assert.same(object.foo, 43, 'works with setter #2');
if (STRICT) {
assert.throws(() => __defineGetter__(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __defineGetter__(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
================================================
FILE: tests/unit-pure/es.object.define-properties.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import defineProperties from 'core-js-pure/es/object/define-properties';
QUnit.test('Object.defineProperties', assert => {
assert.isFunction(defineProperties);
assert.arity(defineProperties, 2);
assert.name(defineProperties, 'defineProperties');
const source = {};
const result = defineProperties(source, { q: { value: 42 }, w: { value: 33 } });
assert.same(result, source);
assert.same(result.q, 42);
assert.same(result.w, 33);
if (DESCRIPTORS) {
// eslint-disable-next-line prefer-arrow-callback -- required for testing
assert.same(defineProperties(function () { /* empty */ }, { prototype: {
value: 42,
writable: false,
} }).prototype, 42, 'function prototype with non-writable descriptor');
}
});
QUnit.test('Object.defineProperties.sham flag', assert => {
assert.same(defineProperties.sham, DESCRIPTORS ? undefined : true);
});
================================================
FILE: tests/unit-pure/es.object.define-property.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import create from 'core-js-pure/es/object/create';
import defineProperty from 'core-js-pure/es/object/define-property';
QUnit.test('Object.defineProperty', assert => {
assert.isFunction(defineProperty);
assert.arity(defineProperty, 3);
assert.name(defineProperty, 'defineProperty');
const source = {};
const result = defineProperty(source, 'q', {
value: 42,
});
assert.same(result, source);
assert.same(result.q, 42);
if (DESCRIPTORS) {
// eslint-disable-next-line prefer-arrow-callback -- required for testing
assert.same(defineProperty(function () { /* empty */ }, 'prototype', {
value: 42,
writable: false,
}).prototype, 42, 'function prototype with non-writable descriptor');
}
assert.throws(() => defineProperty(42, 1, {}));
assert.throws(() => defineProperty({}, create(null), {}));
assert.throws(() => defineProperty({}, 1, 1));
});
QUnit.test('Object.defineProperty.sham flag', assert => {
assert.same(defineProperty.sham, DESCRIPTORS ? undefined : true);
});
================================================
FILE: tests/unit-pure/es.object.define-setter.js
================================================
/* eslint-disable id-match -- unification with global tests */
import { DESCRIPTORS, STRICT } from '../helpers/constants.js';
import __defineGetter__ from 'core-js-pure/es/object/define-getter';
import __defineSetter__ from 'core-js-pure/es/object/define-setter';
if (DESCRIPTORS) {
QUnit.test('Object#__defineSetter__', assert => {
assert.isFunction(__defineSetter__);
let object = {};
assert.same(__defineSetter__(object, 'key', function () {
this.foo = 43;
}), undefined, 'void');
object.key = 44;
assert.same(object.foo, 43, 'works');
object = {};
__defineSetter__(object, 'key', function () {
this.foo = 43;
});
__defineGetter__(object, 'key', () => 42);
object.key = 44;
assert.same(object.key, 42, 'works with getter #1');
assert.same(object.foo, 43, 'works with getter #2');
if (STRICT) {
assert.throws(() => __defineSetter__(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __defineSetter__(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
================================================
FILE: tests/unit-pure/es.object.entries.js
================================================
import assign from 'core-js-pure/es/object/assign';
import create from 'core-js-pure/es/object/create';
import entries from 'core-js-pure/es/object/entries';
QUnit.test('Object.entries', assert => {
assert.isFunction(entries);
assert.arity(entries, 1);
assert.name(entries, 'entries');
assert.deepEqual(entries({ q: 1, w: 2, e: 3 }), [['q', 1], ['w', 2], ['e', 3]]);
assert.deepEqual(entries(new String('qwe')), [['0', 'q'], ['1', 'w'], ['2', 'e']]);
assert.deepEqual(entries(assign(create({ q: 1, w: 2, e: 3 }), { a: 4, s: 5, d: 6 })), [['a', 4], ['s', 5], ['d', 6]]);
assert.deepEqual(entries({ valueOf: 42 }), [['valueOf', 42]], 'IE enum keys bug');
try {
assert.deepEqual(Function('entries', `
return entries({ a: 1, get b() {
delete this.c;
return 2;
}, c: 3 });
`)(entries), [['a', 1], ['b', 2]]);
} catch { /* empty */ }
try {
assert.deepEqual(Function('entries', `
return entries({ a: 1, get b() {
Object.defineProperty(this, "c", {
value: 4,
enumerable: false
});
return 2
}, c: 3 });
`)(entries), [['a', 1], ['b', 2]]);
} catch { /* empty */ }
});
================================================
FILE: tests/unit-pure/es.object.freeze.js
================================================
import ownKeys from 'core-js-pure/es/reflect/own-keys';
import keys from 'core-js-pure/es/object/keys';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import freeze from 'core-js-pure/es/object/freeze';
QUnit.test('Object.freeze', assert => {
assert.isFunction(freeze);
assert.arity(freeze, 1);
assert.name(freeze, 'freeze');
const data = [42, 'foo', false, null, undefined, {}];
for (const value of data) {
assert.notThrows(() => freeze(value) || true, `accept ${ {}.toString.call(value).slice(8, -1) }`);
assert.same(freeze(value), value, `returns target on ${ {}.toString.call(value).slice(8, -1) }`);
}
const results = [];
for (const key in freeze({})) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(freeze({})), []);
assert.arrayEqual(getOwnPropertyNames(freeze({})), []);
assert.arrayEqual(getOwnPropertySymbols(freeze({})), []);
assert.arrayEqual(ownKeys(freeze({})), []);
});
================================================
FILE: tests/unit-pure/es.object.from-entries.js
================================================
import { createIterable } from '../helpers/helpers.js';
import Set from 'core-js-pure/es/set';
import fromEntries from 'core-js-pure/es/object/from-entries';
QUnit.test('Object.fromEntries', assert => {
assert.isFunction(fromEntries);
assert.arity(fromEntries, 1);
assert.name(fromEntries, 'fromEntries');
assert.true(fromEntries([]) instanceof Object);
assert.same(fromEntries([['foo', 1]]).foo, 1);
assert.same(fromEntries(createIterable([['bar', 2]])).bar, 2);
class Unit {
constructor(id) {
this.id = id;
}
toString() {
return `unit${ this.id }`;
}
}
const units = new Set([new Unit(101), new Unit(102), new Unit(103)]);
const object = fromEntries(units.entries());
assert.same(object.unit101.id, 101);
assert.same(object.unit102.id, 102);
assert.same(object.unit103.id, 103);
});
================================================
FILE: tests/unit-pure/es.object.get-own-property-descriptor.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import getOwnPropertyDescriptor from 'core-js-pure/es/object/get-own-property-descriptor';
QUnit.test('Object.getOwnPropertyDescriptor', assert => {
assert.isFunction(getOwnPropertyDescriptor);
assert.arity(getOwnPropertyDescriptor, 2);
assert.name(getOwnPropertyDescriptor, 'getOwnPropertyDescriptor');
assert.deepEqual(getOwnPropertyDescriptor({ q: 42 }, 'q'), {
writable: true,
enumerable: true,
configurable: true,
value: 42,
});
assert.same(getOwnPropertyDescriptor({}, 'toString'), undefined);
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getOwnPropertyDescriptor(value) || true, `accept ${ typeof value }`);
}
assert.throws(() => getOwnPropertyDescriptor(null), TypeError, 'throws on null');
assert.throws(() => getOwnPropertyDescriptor(undefined), TypeError, 'throws on undefined');
});
QUnit.test('Object.getOwnPropertyDescriptor.sham flag', assert => {
assert.same(getOwnPropertyDescriptor.sham, DESCRIPTORS ? undefined : true);
});
================================================
FILE: tests/unit-pure/es.object.get-own-property-descriptors.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import create from 'core-js-pure/es/object/create';
import getOwnPropertyDescriptors from 'core-js-pure/es/object/get-own-property-descriptors';
QUnit.test('Object.getOwnPropertyDescriptors', assert => {
assert.isFunction(getOwnPropertyDescriptors);
assert.name(getOwnPropertyDescriptors, 'getOwnPropertyDescriptors');
assert.arity(getOwnPropertyDescriptors, 1);
const object = create({ q: 1 }, { e: { value: 3 } });
object.w = 2;
const symbol = Symbol('4');
object[symbol] = 4;
const descriptors = getOwnPropertyDescriptors(object);
assert.same(descriptors.q, undefined);
assert.deepEqual(descriptors.w, {
enumerable: true,
configurable: true,
writable: true,
value: 2,
});
if (DESCRIPTORS) {
assert.deepEqual(descriptors.e, {
enumerable: false,
configurable: false,
writable: false,
value: 3,
});
} else {
assert.deepEqual(descriptors.e, {
enumerable: true,
configurable: true,
writable: true,
value: 3,
});
}
assert.same(descriptors[symbol].value, 4);
});
QUnit.test('Object.getOwnPropertyDescriptors.sham flag', assert => {
assert.same(getOwnPropertyDescriptors.sham, DESCRIPTORS ? undefined : true);
});
================================================
FILE: tests/unit-pure/es.object.get-own-property-names.js
================================================
import { includes } from '../helpers/helpers.js';
import freeze from 'core-js-pure/es/object/freeze';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
QUnit.test('Object.getOwnPropertyNames', assert => {
assert.isFunction(getOwnPropertyNames);
assert.arity(getOwnPropertyNames, 1);
assert.name(getOwnPropertyNames, 'getOwnPropertyNames');
function F1() {
this.w = 1;
}
function F2() {
this.toString = 1;
}
F1.prototype.q = F2.prototype.q = 1;
const names = getOwnPropertyNames([1, 2, 3]);
assert.same(names.length, 4);
assert.true(includes(names, '0'));
assert.true(includes(names, '1'));
assert.true(includes(names, '2'));
assert.true(includes(names, 'length'));
assert.deepEqual(getOwnPropertyNames(new F1()), ['w']);
assert.deepEqual(getOwnPropertyNames(new F2()), ['toString']);
assert.true(includes(getOwnPropertyNames(Array.prototype), 'toString'));
assert.true(includes(getOwnPropertyNames(Object.prototype), 'toString'));
assert.true(includes(getOwnPropertyNames(Object.prototype), 'constructor'));
assert.deepEqual(getOwnPropertyNames(freeze({})), [], 'frozen');
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getOwnPropertyNames(value), `accept ${ typeof value }`);
}
assert.throws(() => getOwnPropertyNames(null), TypeError, 'throws on null');
assert.throws(() => getOwnPropertyNames(undefined), TypeError, 'throws on undefined');
/* Chakra bug
if (typeof document != 'undefined' && document.createElement) {
assert.notThrows(() => {
const iframe = document.createElement('iframe');
iframe.src = 'http://example.com';
document.documentElement.appendChild(iframe);
const window = iframe.contentWindow;
document.documentElement.removeChild(iframe);
return getOwnPropertyNames(window);
}, 'IE11 bug with iframe and window');
}
*/
});
================================================
FILE: tests/unit-pure/es.object.get-own-property-symbols.js
================================================
import create from 'core-js-pure/es/object/create';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Object.getOwnPropertySymbols', assert => {
assert.isFunction(getOwnPropertySymbols);
assert.name(getOwnPropertySymbols, 'getOwnPropertySymbols');
assert.arity(getOwnPropertySymbols, 1);
const prototype = { q: 1, w: 2, e: 3 };
prototype[Symbol('getOwnPropertySymbols test 1')] = 42;
prototype[Symbol('getOwnPropertySymbols test 2')] = 43;
assert.deepEqual(getOwnPropertyNames(prototype).sort(), ['e', 'q', 'w']);
assert.same(getOwnPropertySymbols(prototype).length, 2);
const object = create(prototype);
object.a = 1;
object.s = 2;
object.d = 3;
object[Symbol('getOwnPropertySymbols test 3')] = 44;
assert.deepEqual(getOwnPropertyNames(object).sort(), ['a', 'd', 's']);
assert.same(getOwnPropertySymbols(object).length, 1);
assert.same(getOwnPropertySymbols(Object.prototype).length, 0);
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getOwnPropertySymbols(value), `accept ${ typeof value }`);
}
});
================================================
FILE: tests/unit-pure/es.object.get-prototype-of.js
================================================
import { CORRECT_PROTOTYPE_GETTER } from '../helpers/constants.js';
import create from 'core-js-pure/es/object/create';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
QUnit.test('Object.getPrototypeOf', assert => {
assert.isFunction(getPrototypeOf);
assert.arity(getPrototypeOf, 1);
assert.name(getPrototypeOf, 'getPrototypeOf');
assert.same(getPrototypeOf({}), Object.prototype);
assert.same(getPrototypeOf([]), Array.prototype);
function F() { /* empty */ }
assert.same(getPrototypeOf(new F()), F.prototype);
const object = { q: 1 };
assert.same(getPrototypeOf(create(object)), object);
assert.same(getPrototypeOf(create(null)), null);
assert.same(getPrototypeOf(getPrototypeOf({})), null);
function Foo() { /* empty */ }
Foo.prototype.foo = 'foo';
function Bar() { /* empty */ }
Bar.prototype = create(Foo.prototype);
Bar.prototype.constructor = Bar;
assert.same(getPrototypeOf(Bar.prototype).foo, 'foo');
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getPrototypeOf(value), `accept ${ typeof value }`);
}
assert.throws(() => getPrototypeOf(null), TypeError, 'throws on null');
assert.throws(() => getPrototypeOf(undefined), TypeError, 'throws on undefined');
assert.same(getPrototypeOf('foo'), String.prototype);
});
QUnit.test('Object.getPrototypeOf.sham flag', assert => {
assert.same(getPrototypeOf.sham, CORRECT_PROTOTYPE_GETTER ? undefined : true);
});
================================================
FILE: tests/unit-pure/es.object.group-by.js
================================================
import { createIterable } from '../helpers/helpers.js';
import groupBy from 'core-js-pure/es/object/group-by';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
import entries from 'core-js-pure/es/object/entries';
import Symbol from 'core-js-pure/full/symbol';
QUnit.test('Object.groupBy', assert => {
assert.isFunction(groupBy);
assert.arity(groupBy, 2);
assert.name(groupBy, 'groupBy');
assert.same(getPrototypeOf(groupBy([], it => it)), null, 'null proto');
assert.deepEqual(entries(groupBy([], it => it)), []);
assert.deepEqual(entries(groupBy([1, 2], it => it ** 2)), [['1', [1]], ['4', [2]]]);
assert.deepEqual(entries(groupBy([1, 2, 1], it => it ** 2)), [['1', [1, 1]], ['4', [2]]]);
assert.deepEqual(entries(groupBy(createIterable([1, 2]), it => it ** 2)), [['1', [1]], ['4', [2]]]);
assert.deepEqual(entries(groupBy('qwe', it => it)), [['q', ['q']], ['w', ['w']], ['e', ['e']]], 'iterable string');
const element = {};
groupBy([element], function (it, i) {
assert.same(arguments.length, 2, 'correct number of callback arguments');
assert.same(it, element, 'correct value in callback');
assert.same(i, 0, 'correct index in callback');
});
const even = Symbol('even');
const odd = Symbol('odd');
const grouped = groupBy([1, 2, 3, 4, 5, 6], num => {
if (num % 2 === 0) return even;
return odd;
});
assert.deepEqual(grouped[even], [2, 4, 6]);
assert.deepEqual(grouped[odd], [1, 3, 5]);
});
================================================
FILE: tests/unit-pure/es.object.has-own.js
================================================
import create from 'core-js-pure/es/object/create';
import hasOwn from 'core-js-pure/es/object/has-own';
QUnit.test('Object.hasOwn', assert => {
assert.isFunction(hasOwn);
assert.arity(hasOwn, 2);
assert.name(hasOwn, 'hasOwn');
assert.true(hasOwn({ q: 42 }, 'q'));
assert.false(hasOwn({ q: 42 }, 'w'));
assert.false(hasOwn(create({ q: 42 }), 'q'));
assert.true(hasOwn(Object.prototype, 'hasOwnProperty'));
let called = false;
try {
hasOwn(null, { toString() { called = true; } });
} catch { /* empty */ }
assert.false(called, 'modern behaviour');
assert.throws(() => hasOwn(null, 'foo'), TypeError, 'throws on null');
assert.throws(() => hasOwn(undefined, 'foo'), TypeError, 'throws on undefined');
});
================================================
FILE: tests/unit-pure/es.object.is-extensible.js
================================================
import isExtensible from 'core-js-pure/es/object/is-extensible';
QUnit.test('Object.isExtensible', assert => {
assert.isFunction(isExtensible);
assert.arity(isExtensible, 1);
assert.name(isExtensible, 'isExtensible');
const primitives = [42, 'string', false, null, undefined];
for (const value of primitives) {
assert.notThrows(() => isExtensible(value) || true, `accept ${ value }`);
assert.false(isExtensible(value), `returns false on ${ value }`);
}
assert.true(isExtensible({}));
});
================================================
FILE: tests/unit-pure/es.object.is-frozen.js
================================================
import isFrozen from 'core-js-pure/es/object/is-frozen';
QUnit.test('Object.isFrozen', assert => {
assert.isFunction(isFrozen);
assert.arity(isFrozen, 1);
assert.name(isFrozen, 'isFrozen');
const primitives = [42, 'string', false, null, undefined];
for (const value of primitives) {
assert.notThrows(() => isFrozen(value) || true, `accept ${ value }`);
assert.true(isFrozen(value), `returns true on ${ value }`);
}
assert.false(isFrozen({}));
});
================================================
FILE: tests/unit-pure/es.object.is-sealed.js
================================================
import isSealed from 'core-js-pure/es/object/is-sealed';
QUnit.test('Object.isSealed', assert => {
assert.isFunction(isSealed);
assert.arity(isSealed, 1);
assert.name(isSealed, 'isSealed');
const primitives = [42, 'string', false, null, undefined];
for (const value of primitives) {
assert.notThrows(() => isSealed(value) || true, `accept ${ value }`);
assert.true(isSealed(value), `returns true on ${ value }`);
}
assert.false(isSealed({}));
});
================================================
FILE: tests/unit-pure/es.object.is.js
================================================
import is from 'core-js-pure/es/object/is';
QUnit.test('Object.is', assert => {
assert.isFunction(is);
assert.arity(is, 2);
assert.name(is, 'is');
assert.true(is(1, 1), '1 is 1');
assert.true(is(NaN, NaN), 'NaN is NaN');
assert.false(is(0, -0), '0 is not -0');
assert.false(is({}, {}), '{} is not {}');
});
================================================
FILE: tests/unit-pure/es.object.keys.js
================================================
import { includes } from '../helpers/helpers.js';
import keys from 'core-js-pure/es/object/keys';
QUnit.test('Object.keys', assert => {
assert.isFunction(keys);
assert.arity(keys, 1);
assert.name(keys, 'keys');
function F1() {
this.w = 1;
}
function F2() {
this.toString = 1;
}
F1.prototype.q = F2.prototype.q = 1;
assert.deepEqual(keys([1, 2, 3]), ['0', '1', '2']);
assert.deepEqual(keys(new F1()), ['w']);
assert.deepEqual(keys(new F2()), ['toString']);
assert.false(includes(keys(Array.prototype), 'push'));
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => keys(value), `accept ${ typeof value }`);
}
assert.throws(() => keys(null), TypeError, 'throws on null');
assert.throws(() => keys(undefined), TypeError, 'throws on undefined');
});
================================================
FILE: tests/unit-pure/es.object.lookup-getter.js
================================================
/* eslint-disable id-match -- unification with global tests */
import { DESCRIPTORS, STRICT } from '../helpers/constants.js';
import create from 'core-js-pure/es/object/create';
import __defineGetter__ from 'core-js-pure/es/object/define-getter';
import __lookupGetter__ from 'core-js-pure/es/object/lookup-getter';
if (DESCRIPTORS) {
QUnit.test('Object#__lookupGetter__', assert => {
assert.isFunction(__lookupGetter__);
assert.same(__lookupGetter__({}, 'key'), undefined, 'empty object');
assert.same(__lookupGetter__({ key: 42 }, 'key'), undefined, 'data descriptor');
const object = {};
function getter() { /* empty */ }
__defineGetter__(object, 'key', getter);
assert.same(__lookupGetter__(object, 'key'), getter, 'own getter');
assert.same(__lookupGetter__(create(object), 'key'), getter, 'proto getter');
assert.same(__lookupGetter__(create(object), 'foo'), undefined, 'empty proto');
if (STRICT) {
assert.throws(() => __lookupGetter__(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __lookupGetter__(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
================================================
FILE: tests/unit-pure/es.object.lookup-setter.js
================================================
/* eslint-disable id-match -- unification with global tests */
import { DESCRIPTORS, STRICT } from '../helpers/constants.js';
import create from 'core-js-pure/es/object/create';
import __defineSetter__ from 'core-js-pure/es/object/define-setter';
import __lookupSetter__ from 'core-js-pure/es/object/lookup-setter';
if (DESCRIPTORS) {
QUnit.test('Object#__lookupSetter__', assert => {
assert.isFunction(__lookupSetter__);
assert.same(__lookupSetter__({}, 'key'), undefined, 'empty object');
assert.same(__lookupSetter__({ key: 42 }, 'key'), undefined, 'data descriptor');
const object = {};
function setter() { /* empty */ }
__defineSetter__(object, 'key', setter);
assert.same(__lookupSetter__(object, 'key'), setter, 'own setter');
assert.same(__lookupSetter__(create(object), 'key'), setter, 'proto setter');
assert.same(__lookupSetter__(create(object), 'foo'), undefined, 'empty proto');
if (STRICT) {
assert.throws(() => __lookupSetter__(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __lookupSetter__(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
================================================
FILE: tests/unit-pure/es.object.prevent-extensions.js
================================================
import ownKeys from 'core-js-pure/es/reflect/own-keys';
import keys from 'core-js-pure/es/object/keys';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import preventExtensions from 'core-js-pure/es/object/prevent-extensions';
QUnit.test('Object.preventExtensions', assert => {
assert.isFunction(preventExtensions);
assert.arity(preventExtensions, 1);
assert.name(preventExtensions, 'preventExtensions');
const data = [42, 'foo', false, null, undefined, {}];
for (const value of data) {
assert.notThrows(() => preventExtensions(value) || true, `accept ${ {}.toString.call(value).slice(8, -1) }`);
assert.same(preventExtensions(value), value, `returns target on ${ {}.toString.call(value).slice(8, -1) }`);
}
const results = [];
for (const key in preventExtensions({})) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(preventExtensions({})), []);
assert.arrayEqual(getOwnPropertyNames(preventExtensions({})), []);
assert.arrayEqual(getOwnPropertySymbols(preventExtensions({})), []);
assert.arrayEqual(ownKeys(preventExtensions({})), []);
});
================================================
FILE: tests/unit-pure/es.object.seal.js
================================================
import ownKeys from 'core-js-pure/es/reflect/own-keys';
import keys from 'core-js-pure/es/object/keys';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import seal from 'core-js-pure/es/object/seal';
QUnit.test('Object.seal', assert => {
assert.isFunction(seal);
assert.arity(seal, 1);
assert.name(seal, 'seal');
const data = [42, 'foo', false, null, undefined, {}];
for (const value of data) {
assert.notThrows(() => seal(value) || true, `accept ${ {}.toString.call(value).slice(8, -1) }`);
assert.same(seal(value), value, `returns target on ${ {}.toString.call(value).slice(8, -1) }`);
}
const results = [];
for (const key in seal({})) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(seal({})), []);
assert.arrayEqual(getOwnPropertyNames(seal({})), []);
assert.arrayEqual(getOwnPropertySymbols(seal({})), []);
assert.arrayEqual(ownKeys(seal({})), []);
});
================================================
FILE: tests/unit-pure/es.object.set-prototype-of.js
================================================
import { PROTO } from '../helpers/constants.js';
import setPrototypeOf from 'core-js-pure/es/object/set-prototype-of';
if (PROTO) QUnit.test('Object.setPrototypeOf', assert => {
assert.isFunction(setPrototypeOf);
assert.arity(setPrototypeOf, 2);
assert.name(setPrototypeOf, 'setPrototypeOf');
assert.true('apply' in setPrototypeOf({}, Function.prototype), 'Parent properties in target');
assert.same(setPrototypeOf({ a: 2 }, {
b() {
return this.a ** 2;
},
}).b(), 4, 'Child and parent properties in target');
const object = {};
assert.same(setPrototypeOf(object, { a: 1 }), object, 'setPrototypeOf return target');
assert.false('toString' in setPrototypeOf({}, null), 'Can set null as prototype');
});
================================================
FILE: tests/unit-pure/es.object.values.js
================================================
import assign from 'core-js-pure/es/object/assign';
import create from 'core-js-pure/es/object/create';
import values from 'core-js-pure/es/object/values';
QUnit.test('Object.values', assert => {
assert.isFunction(values);
assert.arity(values, 1);
assert.name(values, 'values');
assert.deepEqual(values({ q: 1, w: 2, e: 3 }), [1, 2, 3]);
assert.deepEqual(values(new String('qwe')), ['q', 'w', 'e']);
assert.deepEqual(values(assign(create({ q: 1, w: 2, e: 3 }), { a: 4, s: 5, d: 6 })), [4, 5, 6]);
assert.deepEqual(values({ valueOf: 42 }), [42], 'IE enum keys bug');
try {
assert.deepEqual(Function('values', `
return values({ a: 1, get b() {
delete this.c;
return 2;
}, c: 3 });
`)(values), [1, 2]);
} catch { /* empty */ }
try {
assert.deepEqual(Function('values', `
return values({ a: 1, get b() {
Object.defineProperty(this, "c", {
value: 4,
enumerable: false
});
return 2;
}, c: 3 });
`)(values), [1, 2]);
} catch { /* empty */ }
});
================================================
FILE: tests/unit-pure/es.parse-float.js
================================================
import { WHITESPACES } from '../helpers/constants.js';
import parseFloat from 'core-js-pure/es/parse-float';
QUnit.test('parseFloat', assert => {
assert.isFunction(parseFloat);
assert.arity(parseFloat, 1);
assert.name(parseFloat, 'parseFloat');
assert.same(parseFloat('0'), 0);
assert.same(parseFloat(' 0'), 0);
assert.same(parseFloat('+0'), 0);
assert.same(parseFloat(' +0'), 0);
assert.same(parseFloat('-0'), -0);
assert.same(parseFloat(' -0'), -0);
assert.same(parseFloat(`${ WHITESPACES }+0`), 0);
assert.same(parseFloat(`${ WHITESPACES }-0`), -0);
assert.same(parseFloat(null), NaN);
assert.same(parseFloat(undefined), NaN);
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
const symbol = Symbol('parseFloat test');
assert.throws(() => parseFloat(symbol), 'throws on symbol argument');
assert.throws(() => parseFloat(Object(symbol)), 'throws on boxed symbol argument');
}
});
================================================
FILE: tests/unit-pure/es.parse-int.js
================================================
/* eslint-disable prefer-numeric-literals -- required for testing */
import { WHITESPACES } from '../helpers/constants.js';
import parseInt from 'core-js-pure/es/parse-int';
QUnit.test('parseInt', assert => {
assert.isFunction(parseInt);
assert.arity(parseInt, 2);
assert.name(parseInt, 'parseInt');
for (let radix = 2; radix <= 36; ++radix) {
assert.same(parseInt('10', radix), radix, `radix ${ radix }`);
}
const strings = ['01', '08', '10', '42'];
for (const string of strings) {
assert.same(parseInt(string), parseInt(string, 10), `default radix is 10: ${ string }`);
}
assert.same(parseInt('0x16'), parseInt('0x16', 16), 'default radix is 16: 0x16');
assert.same(parseInt(' 0x16'), parseInt('0x16', 16), 'ignores leading whitespace #1');
assert.same(parseInt(' 42'), parseInt('42', 10), 'ignores leading whitespace #2');
assert.same(parseInt(' 08'), parseInt('08', 10), 'ignores leading whitespace #3');
assert.same(parseInt(`${ WHITESPACES }08`), parseInt('08', 10), 'ignores leading whitespace #4');
assert.same(parseInt(`${ WHITESPACES }0x16`), parseInt('0x16', 16), 'ignores leading whitespace #5');
const fakeZero = {
valueOf() {
return 0;
},
};
assert.same(parseInt('08', fakeZero), parseInt('08', 10), 'valueOf #1');
assert.same(parseInt('0x16', fakeZero), parseInt('0x16', 16), 'valueOf #2');
assert.same(parseInt('-0xF'), -15, 'signed hex #1');
assert.same(parseInt('-0xF', 16), -15, 'signed hex #2');
assert.same(parseInt('+0xF'), 15, 'signed hex #3');
assert.same(parseInt('+0xF', 16), 15, 'signed hex #4');
assert.same(parseInt('10', -4294967294), 2, 'radix uses ToUint32');
assert.same(parseInt(null), NaN);
assert.same(parseInt(undefined), NaN);
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
const symbol = Symbol('parseInt test');
assert.throws(() => parseInt(symbol), 'throws on symbol argument');
assert.throws(() => parseInt(Object(symbol)), 'throws on boxed symbol argument');
}
});
================================================
FILE: tests/unit-pure/es.promise.all-settled.js
================================================
import { createIterable } from '../helpers/helpers.js';
import $allSettled from 'core-js-pure/es/promise/all-settled';
import bind from 'core-js-pure/es/function/bind';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Promise.allSettled', assert => {
assert.isFunction(Promise.allSettled);
assert.name(Promise.allSettled, 'allSettled');
assert.arity(Promise.allSettled, 1);
assert.true(Promise.allSettled([1, 2, 3]) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.allSettled, resolved', assert => {
return Promise.allSettled([
Promise.resolve(1),
Promise.resolve(2),
Promise.resolve(3),
]).then(it => {
assert.deepEqual(it, [
{ value: 1, status: 'fulfilled' },
{ value: 2, status: 'fulfilled' },
{ value: 3, status: 'fulfilled' },
], 'resolved with a correct value');
});
});
QUnit.test('Promise.allSettled, resolved with rejection', assert => {
return Promise.allSettled([
Promise.resolve(1),
Promise.reject(2),
Promise.resolve(3),
]).then(it => {
assert.deepEqual(it, [
{ value: 1, status: 'fulfilled' },
{ reason: 2, status: 'rejected' },
{ value: 3, status: 'fulfilled' },
], 'resolved with a correct value');
});
});
QUnit.test('Promise.allSettled, rejected', assert => {
// eslint-disable-next-line promise/valid-params -- required for testing
return Promise.allSettled().then(() => {
assert.avoid();
}, () => {
assert.required('rejected as expected');
});
});
QUnit.test('Promise.allSettled, resolved with timeouts', assert => {
return Promise.allSettled([
Promise.resolve(1),
new Promise(resolve => setTimeout(() => resolve(2), 10)),
Promise.resolve(3),
]).then(it => {
assert.deepEqual(it, [
{ value: 1, status: 'fulfilled' },
{ value: 2, status: 'fulfilled' },
{ value: 3, status: 'fulfilled' },
], 'keeps correct mapping, even with delays');
});
});
QUnit.test('Promise.allSettled, subclassing', assert => {
const { allSettled, resolve } = Promise;
function SubPromise(executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
}
SubPromise.resolve = bind(resolve, Promise);
assert.true(allSettled.call(SubPromise, [1, 2, 3]) instanceof SubPromise, 'subclassing, `this` pattern');
function FakePromise1() { /* empty */ }
function FakePromise2(executor) {
executor(null, () => { /* empty */ });
}
function FakePromise3(executor) {
executor(() => { /* empty */ }, null);
}
FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = bind(resolve, Promise);
assert.throws(() => {
allSettled.call(FakePromise1, [1, 2, 3]);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
allSettled.call(FakePromise2, [1, 2, 3]);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
allSettled.call(FakePromise3, [1, 2, 3]);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.allSettled, iterables', assert => {
const iterable = createIterable([1, 2, 3]);
Promise.allSettled(iterable).catch(() => { /* empty */ });
assert.true(iterable.received, 'works with iterables: iterator received');
assert.true(iterable.called, 'works with iterables: next called');
});
QUnit.test('Promise.allSettled, iterables 2', assert => {
const array = [];
let done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
Promise.allSettled(array);
assert.true(done);
});
QUnit.test('Promise.allSettled, iterator closing', assert => {
const { resolve } = Promise;
let done = false;
try {
Promise.resolve = function () {
throw new Error();
};
Promise.allSettled(createIterable([1, 2, 3], {
return() {
done = true;
},
})).catch(() => { /* empty */ });
} catch { /* empty */ }
Promise.resolve = resolve;
assert.true(done, 'iteration closing');
});
QUnit.test('Promise.allSettled, without constructor context', assert => {
const { allSettled } = Promise;
assert.throws(() => allSettled([]), TypeError, 'Throws if called without a constructor context');
assert.throws(() => allSettled.call(null, []), TypeError, 'Throws if called with null as this');
});
QUnit.test('Promise.allSettled, method from direct entry, without constructor context', assert => {
return $allSettled([
Promise.resolve(1),
Promise.resolve(2),
Promise.resolve(3),
]).then(it => {
assert.deepEqual(it, [
{ value: 1, status: 'fulfilled' },
{ value: 2, status: 'fulfilled' },
{ value: 3, status: 'fulfilled' },
], 'resolved with a correct value');
});
});
QUnit.test('Promise.allSettled, method from direct entry, with null context', assert => {
return $allSettled.call(null, [
Promise.resolve(1),
Promise.resolve(2),
Promise.resolve(3),
]).then(it => {
assert.deepEqual(it, [
{ value: 1, status: 'fulfilled' },
{ value: 2, status: 'fulfilled' },
{ value: 3, status: 'fulfilled' },
], 'resolved with a correct value');
});
});
================================================
FILE: tests/unit-pure/es.promise.all.js
================================================
import { createIterable } from '../helpers/helpers.js';
import bind from 'core-js-pure/es/function/bind';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Promise.all', assert => {
const { all } = Promise;
assert.isFunction(all);
assert.arity(all, 1);
assert.name(all, 'all');
assert.true(Promise.all([]) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.all, resolved', assert => {
return Promise.all([
Promise.resolve(1),
Promise.resolve(2),
Promise.resolve(3),
]).then(it => {
assert.deepEqual(it, [1, 2, 3], 'resolved with a correct value');
});
});
QUnit.test('Promise.all, resolved with rejection', assert => {
return Promise.all([
Promise.resolve(1),
Promise.reject(2),
Promise.resolve(3),
]).then(() => {
assert.avoid();
}, error => {
assert.same(error, 2, 'rejected with a correct value');
});
});
QUnit.test('Promise.all, resolved with empty array', assert => {
return Promise.all([]).then(it => {
assert.deepEqual(it, [], 'resolved with a correct value');
});
});
QUnit.test('Promise.all, resolved with timeouts', assert => {
return Promise.all([
Promise.resolve(1),
new Promise(resolve => setTimeout(() => resolve(2), 10)),
Promise.resolve(3),
]).then(it => {
assert.deepEqual(it, [1, 2, 3], 'keeps correct mapping, even with delays');
});
});
QUnit.test('Promise.all, subclassing', assert => {
const { all, resolve } = Promise;
function SubPromise(executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
}
SubPromise.resolve = bind(resolve, Promise);
assert.true(all.call(SubPromise, [1, 2, 3]) instanceof SubPromise, 'subclassing, `this` pattern');
function FakePromise1() { /* empty */ }
function FakePromise2(executor) {
executor(null, () => { /* empty */ });
}
function FakePromise3(executor) {
executor(() => { /* empty */ }, null);
}
FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = bind(resolve, Promise);
assert.throws(() => {
all.call(FakePromise1, [1, 2, 3]);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
all.call(FakePromise2, [1, 2, 3]);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
all.call(FakePromise3, [1, 2, 3]);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.all, iterables', assert => {
const iterable = createIterable([1, 2, 3]);
Promise.all(iterable).catch(() => { /* empty */ });
assert.true(iterable.received, 'works with iterables: iterator received');
assert.true(iterable.called, 'works with iterables: next called');
});
QUnit.test('Promise.all, iterables 2', assert => {
const array = [];
let done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
Promise.all(array);
assert.true(done);
});
QUnit.test('Promise.all, iterator closing', assert => {
const { resolve } = Promise;
let done = false;
try {
Promise.resolve = function () {
throw new Error();
};
Promise.all(createIterable([1, 2, 3], {
return() {
done = true;
},
})).catch(() => { /* empty */ });
} catch { /* empty */ }
Promise.resolve = resolve;
assert.true(done, 'iteration closing');
});
QUnit.test('Promise.all, without constructor context', assert => {
const { all } = Promise;
assert.throws(() => all([]), TypeError, 'Throws if called without a constructor context');
assert.throws(() => all.call(null, []), TypeError, 'Throws if called with null as this');
});
================================================
FILE: tests/unit-pure/es.promise.any.js
================================================
import { createIterable } from '../helpers/helpers.js';
import $any from 'core-js-pure/es/promise/any';
import AggregateError from 'core-js-pure/es/aggregate-error';
import bind from 'core-js-pure/es/function/bind';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Promise.any', assert => {
assert.isFunction(Promise.any);
assert.name(Promise.any, 'any');
assert.arity(Promise.any, 1);
assert.true(Promise.any([1, 2, 3]) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.any, resolved', assert => {
return Promise.any([
Promise.resolve(1),
Promise.reject(2),
Promise.resolve(3),
]).then(it => {
assert.same(it, 1, 'resolved with a correct value');
});
});
QUnit.test('Promise.any, rejected #1', assert => {
return Promise.any([
Promise.reject(1),
Promise.reject(2),
Promise.reject(3),
]).then(() => {
assert.avoid();
}, error => {
assert.true(error instanceof AggregateError, 'instanceof AggregateError');
assert.deepEqual(error.errors, [1, 2, 3], 'rejected with a correct value');
});
});
QUnit.test('Promise.any, rejected #2', assert => {
// eslint-disable-next-line promise/valid-params -- required for testing
return Promise.any().then(() => {
assert.avoid();
}, () => {
assert.required('rejected as expected');
});
});
QUnit.test('Promise.any, rejected #3', assert => {
return Promise.any([]).then(() => {
assert.avoid();
}, error => {
assert.true(error instanceof AggregateError, 'instanceof AggregateError');
assert.deepEqual(error.errors, [], 'rejected with a correct value');
});
});
QUnit.test('Promise.any, resolved with timeout', assert => {
return Promise.any([
new Promise(resolve => setTimeout(() => resolve(1), 50)),
Promise.resolve(2),
]).then(it => {
assert.same(it, 2, 'resolved with a correct value');
});
});
QUnit.test('Promise.any, subclassing', assert => {
const { any, resolve } = Promise;
function SubPromise(executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
}
SubPromise.resolve = bind(resolve, Promise);
assert.true(any.call(SubPromise, [1, 2, 3]) instanceof SubPromise, 'subclassing, `this` pattern');
function FakePromise1() { /* empty */ }
function FakePromise2(executor) {
executor(null, () => { /* empty */ });
}
function FakePromise3(executor) {
executor(() => { /* empty */ }, null);
}
FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = bind(resolve, Promise);
assert.throws(() => {
any.call(FakePromise1, [1, 2, 3]);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
any.call(FakePromise2, [1, 2, 3]);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
any.call(FakePromise3, [1, 2, 3]);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.any, iterables', assert => {
const iterable = createIterable([1, 2, 3]);
Promise.any(iterable).catch(() => { /* empty */ });
assert.true(iterable.received, 'works with iterables: iterator received');
assert.true(iterable.called, 'works with iterables: next called');
});
QUnit.test('Promise.any, empty iterables', assert => {
const array = [];
let done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
return Promise.any(array).then(() => {
assert.avoid();
}, error => {
assert.true(error instanceof AggregateError, 'instanceof AggregateError');
assert.true(done, 'iterator called');
});
});
QUnit.test('Promise.any, iterator closing', assert => {
const { resolve } = Promise;
let done = false;
try {
Promise.resolve = function () {
throw new Error();
};
Promise.any(createIterable([1, 2, 3], {
return() {
done = true;
},
})).catch(() => { /* empty */ });
} catch { /* empty */ }
Promise.resolve = resolve;
assert.true(done, 'iteration closing');
});
QUnit.test('Promise.any, without constructor context', assert => {
const { any } = Promise;
assert.throws(() => any([]), TypeError, 'Throws if called without a constructor context');
assert.throws(() => any.call(null, []), TypeError, 'Throws if called with null as this');
});
QUnit.test('Promise.any, method from direct entry, without constructor context', assert => {
return $any([
Promise.resolve(1),
Promise.resolve(2),
]).then(it => {
assert.same(it, 1, 'resolved with a correct value');
});
});
QUnit.test('Promise.any, method from direct entry, with null context', assert => {
return $any.call(null, [
Promise.resolve(1),
Promise.resolve(2),
]).then(it => {
assert.same(it, 1, 'resolved with a correct value');
});
});
================================================
FILE: tests/unit-pure/es.promise.catch.js
================================================
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Promise#catch', assert => {
assert.isFunction(Promise.prototype.catch);
assert.nonEnumerable(Promise.prototype, 'catch');
let promise = new Promise(resolve => {
resolve(42);
});
const FakePromise1 = promise.constructor = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
const FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.true(promise.catch(() => { /* empty */ }) instanceof FakePromise2, 'subclassing, @@species pattern');
promise = new Promise(resolve => {
resolve(42);
});
promise.constructor = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.true(promise.catch(() => { /* empty */ }) instanceof Promise, 'subclassing, incorrect `this` pattern');
promise = new Promise(resolve => {
resolve(42);
});
const FakePromise3 = promise.constructor = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise3[Symbol.species] = function () { /* empty */ };
assert.throws(() => {
promise.catch(() => { /* empty */ });
}, 'NewPromiseCapability validations, #1');
FakePromise3[Symbol.species] = function (executor) {
executor(null, () => { /* empty */ });
};
assert.throws(() => {
promise.catch(() => { /* empty */ });
}, 'NewPromiseCapability validations, #2');
FakePromise3[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, null);
};
assert.throws(() => {
promise.catch(() => { /* empty */ });
}, 'NewPromiseCapability validations, #3');
assert.same(Promise.prototype.catch.call({
// eslint-disable-next-line unicorn/no-thenable -- required for testing
then(x, y) {
return y;
},
}, 42), 42, 'calling `.then`');
});
================================================
FILE: tests/unit-pure/es.promise.constructor.js
================================================
import { DESCRIPTORS, GLOBAL, PROTO, STRICT } from '../helpers/constants.js';
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
import setPrototypeOf from 'core-js-pure/es/object/set-prototype-of';
import create from 'core-js-pure/es/object/create';
QUnit.test('Promise', assert => {
assert.isFunction(Promise);
new Promise(function (resolve, reject) {
assert.isFunction(resolve, 'resolver is function');
assert.isFunction(reject, 'rejector is function');
if (STRICT) assert.same(this, undefined, 'correct executor context');
});
assert.throws(() => {
// eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
Promise();
}, 'throws w/o `new`');
});
if (DESCRIPTORS) QUnit.test('Promise operations order', assert => {
let $resolve, $resolve2;
assert.expect(1);
const EXPECTED_ORDER = 'DEHAFGBC';
const async = assert.async();
let result = '';
const promise1 = new Promise(resolve => {
$resolve = resolve;
});
$resolve({
// eslint-disable-next-line unicorn/no-thenable -- required for testing
then() {
result += 'A';
throw new Error();
},
});
promise1.catch(() => {
result += 'B';
});
promise1.catch(() => {
result += 'C';
assert.same(result, EXPECTED_ORDER);
async();
});
const promise2 = new Promise(resolve => {
$resolve2 = resolve;
});
// eslint-disable-next-line es/no-object-defineproperty, unicorn/no-thenable -- required for testing
$resolve2(Object.defineProperty({}, 'then', {
get() {
result += 'D';
throw new Error();
},
}));
result += 'E';
promise2.catch(() => {
result += 'F';
});
promise2.catch(() => {
result += 'G';
});
result += 'H';
setTimeout(() => {
if (!~result.indexOf('C')) {
assert.same(result, EXPECTED_ORDER);
async();
}
}, 1e3);
});
QUnit.test('Promise#then', assert => {
assert.isFunction(Promise.prototype.then);
assert.arity(Promise.prototype.then, 2);
assert.name(Promise.prototype.then, 'then');
assert.nonEnumerable(Promise.prototype, 'then');
let promise = new Promise(resolve => {
resolve(42);
});
const FakePromise1 = promise.constructor = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
const FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.true(promise.then(() => { /* empty */ }) instanceof FakePromise2, 'subclassing, @@species pattern');
promise = new Promise(resolve => {
resolve(42);
});
promise.constructor = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.true(promise.then(() => { /* empty */ }) instanceof Promise, 'subclassing, incorrect `this` pattern');
promise = new Promise(resolve => {
resolve(42);
});
const FakePromise3 = promise.constructor = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise3[Symbol.species] = function () { /* empty */ };
assert.throws(() => {
promise.then(() => { /* empty */ });
}, 'NewPromiseCapability validations, #1');
FakePromise3[Symbol.species] = function (executor) {
executor(null, () => { /* empty */ });
};
assert.throws(() => {
promise.then(() => { /* empty */ });
}, 'NewPromiseCapability validations, #2');
FakePromise3[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, null);
};
assert.throws(() => {
promise.then(() => { /* empty */ });
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise#@@toStringTag', assert => {
assert.same(Promise.prototype[Symbol.toStringTag], 'Promise', 'Promise::@@toStringTag is `Promise`');
assert.same(String(new Promise(() => { /* empty */ })), '[object Promise]', 'correct stringification');
});
if (PROTO) QUnit.test('Promise subclassing', assert => {
function SubPromise(executor) {
const self = new Promise(executor);
setPrototypeOf(self, SubPromise.prototype);
self.mine = 'subclass';
return self;
}
setPrototypeOf(SubPromise, Promise);
SubPromise.prototype = create(Promise.prototype);
SubPromise.prototype.constructor = SubPromise;
let promise1 = SubPromise.resolve(5);
assert.same(promise1.mine, 'subclass');
promise1 = promise1.then(it => {
assert.same(it, 5);
});
assert.same(promise1.mine, 'subclass');
let promise2 = new SubPromise(resolve => {
resolve(6);
});
assert.same(promise2.mine, 'subclass');
promise2 = promise2.then(it => {
assert.same(it, 6);
});
assert.same(promise2.mine, 'subclass');
const promise3 = SubPromise.all([promise1, promise2]);
assert.same(promise3.mine, 'subclass');
assert.true(promise3 instanceof Promise);
assert.true(promise3 instanceof SubPromise);
promise3.then(assert.async(), error => {
assert.avoid(error);
});
});
// qunit@2.5 strange bug
QUnit.skip('Unhandled rejection tracking', assert => {
let done = false;
const resume = assert.async();
if (GLOBAL.process) {
assert.expect(3);
function onunhandledrejection(reason, promise) {
process.removeListener('unhandledRejection', onunhandledrejection);
assert.same(promise, $promise, 'unhandledRejection, promise');
assert.same(reason, 42, 'unhandledRejection, reason');
$promise.catch(() => {
// empty
});
}
function onrejectionhandled(promise) {
process.removeListener('rejectionHandled', onrejectionhandled);
assert.same(promise, $promise, 'rejectionHandled, promise');
done || resume();
done = true;
}
process.on('unhandledRejection', onunhandledrejection);
process.on('rejectionHandled', onrejectionhandled);
} else {
if (GLOBAL.addEventListener) {
assert.expect(8);
function onunhandledrejection(it) {
assert.same(it.promise, $promise, 'addEventListener(unhandledrejection), promise');
assert.same(it.reason, 42, 'addEventListener(unhandledrejection), reason');
GLOBAL.removeEventListener('unhandledrejection', onunhandledrejection);
}
GLOBAL.addEventListener('unhandledrejection', onunhandledrejection);
function onrejectionhandled(it) {
assert.same(it.promise, $promise, 'addEventListener(rejectionhandled), promise');
assert.same(it.reason, 42, 'addEventListener(rejectionhandled), reason');
GLOBAL.removeEventListener('rejectionhandled', onrejectionhandled);
}
GLOBAL.addEventListener('rejectionhandled', onrejectionhandled);
} else assert.expect(4);
GLOBAL.onunhandledrejection = function (it) {
assert.same(it.promise, $promise, 'onunhandledrejection, promise');
assert.same(it.reason, 42, 'onunhandledrejection, reason');
setTimeout(() => {
$promise.catch(() => {
// empty
});
}, 1);
GLOBAL.onunhandledrejection = null;
};
GLOBAL.onrejectionhandled = function (it) {
assert.same(it.promise, $promise, 'onrejectionhandled, promise');
assert.same(it.reason, 42, 'onrejectionhandled, reason');
GLOBAL.onrejectionhandled = null;
done || resume();
done = true;
};
}
Promise.reject(43).catch(() => {
// empty
});
const $promise = Promise.reject(42);
setTimeout(() => {
done || resume();
done = true;
}, 3e3);
});
================================================
FILE: tests/unit-pure/es.promise.finally.js
================================================
import Promise from 'core-js-pure/es/promise';
QUnit.test('Promise#finally', assert => {
assert.isFunction(Promise.prototype.finally);
assert.arity(Promise.prototype.finally, 1);
assert.nonEnumerable(Promise.prototype, 'finally');
assert.true(Promise.resolve(42).finally(() => { /* empty */ }) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise#finally, resolved', assert => {
let called = 0;
let argument = null;
return Promise.resolve(42).finally(it => {
called++;
argument = it;
}).then(it => {
assert.same(it, 42, 'resolved with a correct value');
assert.same(called, 1, 'onFinally function called one time');
assert.same(argument, undefined, 'onFinally function called with a correct argument');
});
});
QUnit.test('Promise#finally, rejected', assert => {
let called = 0;
let argument = null;
return Promise.reject(42).finally(it => {
called++;
argument = it;
}).then(() => {
assert.avoid();
}, () => {
assert.same(called, 1, 'onFinally function called one time');
assert.same(argument, undefined, 'onFinally function called with a correct argument');
});
});
================================================
FILE: tests/unit-pure/es.promise.race.js
================================================
import { createIterable } from '../helpers/helpers.js';
import bind from 'core-js-pure/es/function/bind';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Promise.race', assert => {
const { race } = Promise;
assert.isFunction(race);
assert.arity(race, 1);
assert.name(race, 'race');
assert.true(Promise.race([]) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.race, resolved', assert => {
return Promise.race([
Promise.resolve(1),
Promise.resolve(2),
]).then(it => {
assert.same(it, 1, 'resolved with a correct value');
});
});
QUnit.test('Promise.race, resolved with rejection', assert => {
return Promise.race([
Promise.reject(1),
Promise.resolve(2),
]).then(() => {
assert.avoid();
}, error => {
assert.same(error, 1, 'rejected with a correct value');
});
});
QUnit.test('Promise.race, resolved with timeouts', assert => {
return Promise.race([
new Promise(resolve => setTimeout(() => resolve(1), 50)),
Promise.resolve(2),
]).then(it => {
assert.same(it, 2, 'keeps correct mapping, even with delays');
});
});
QUnit.test('Promise.race, subclassing', assert => {
const { race, resolve } = Promise;
function SubPromise(executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
}
SubPromise.resolve = bind(resolve, Promise);
assert.true(race.call(SubPromise, [1, 2, 3]) instanceof SubPromise, 'subclassing, `this` pattern');
function FakePromise1() { /* empty */ }
function FakePromise2(executor) {
executor(null, () => { /* empty */ });
}
function FakePromise3(executor) {
executor(() => { /* empty */ }, null);
}
FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = bind(resolve, Promise);
assert.throws(() => {
race.call(FakePromise1, [1, 2, 3]);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
race.call(FakePromise2, [1, 2, 3]);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
race.call(FakePromise3, [1, 2, 3]);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.race, iterables', assert => {
const iterable = createIterable([1, 2, 3]);
Promise.race(iterable).catch(() => { /* empty */ });
assert.true(iterable.received, 'works with iterables: iterator received');
assert.true(iterable.called, 'works with iterables: next called');
});
QUnit.test('Promise.race, iterables 2', assert => {
const array = [];
let done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
Promise.race(array);
assert.true(done);
});
QUnit.test('Promise.race, iterator closing', assert => {
const { resolve } = Promise;
let done = false;
try {
Promise.resolve = function () {
throw new Error();
};
Promise.race(createIterable([1, 2, 3], {
return() {
done = true;
},
})).catch(() => { /* empty */ });
} catch { /* empty */ }
Promise.resolve = resolve;
assert.true(done, 'iteration closing');
});
QUnit.test('Promise.race, without constructor context', assert => {
const { race } = Promise;
assert.throws(() => race([]), TypeError, 'Throws if called without a constructor context');
assert.throws(() => race.call(null, []), TypeError, 'Throws if called with null as this');
});
================================================
FILE: tests/unit-pure/es.promise.reject.js
================================================
import Promise from 'core-js-pure/es/promise';
QUnit.test('Promise.reject', assert => {
const { reject } = Promise;
assert.isFunction(reject);
assert.arity(reject, 1);
assert.name(reject, 'reject');
});
QUnit.test('Promise.reject, rejects with value', assert => {
return Promise.reject(42)
.then(() => {
assert.avoid('Should not resolve');
}, error => {
assert.same(error, 42, 'rejected with correct reason');
});
});
QUnit.test('Promise.reject, rejects with undefined', assert => {
return Promise.reject()
.then(() => {
assert.avoid('Should not resolve');
}, error => {
assert.same(error, undefined, 'rejected with correct reason');
});
});
QUnit.test('Promise.reject, subclassing', assert => {
const { reject } = Promise;
function SubPromise(executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
}
assert.true(reject.call(SubPromise, 42) instanceof SubPromise, 'subclassing, `this` pattern');
function FakePromise1() { /* empty */ }
function FakePromise2(executor) {
executor(null, () => { /* empty */ });
}
function FakePromise3(executor) {
executor(() => { /* empty */ }, null);
}
assert.throws(() => {
reject.call(FakePromise1, 42);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
reject.call(FakePromise2, 42);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
reject.call(FakePromise3, 42);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.reject, without constructor context', assert => {
const { reject } = Promise;
assert.throws(() => reject(''), TypeError, 'Throws if called without a constructor context');
assert.throws(() => reject.call(null, ''), TypeError, 'Throws if called with null as this');
});
================================================
FILE: tests/unit-pure/es.promise.resolve.js
================================================
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Promise.resolve', assert => {
const { resolve } = Promise;
assert.isFunction(resolve);
assert.arity(resolve, 1);
assert.name(resolve, 'resolve');
assert.true(Promise.resolve(42) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.resolve, resolves with value', assert => {
return Promise.resolve(42).then(result => {
assert.same(result, 42, 'resolved with a correct value');
});
});
QUnit.test('Promise.resolve, resolves with thenable', assert => {
const thenable = {
// eslint-disable-next-line unicorn/no-thenable -- safe
then(resolve) { resolve('foo'); },
};
return Promise.resolve(thenable).then(result => {
assert.same(result, 'foo', 'resolved with a correct value');
});
});
QUnit.test('Promise.resolve, returns input if input is already promise', assert => {
const p = Promise.resolve('ok');
assert.same(Promise.resolve(p), p, 'resolved with a correct value');
});
QUnit.test('Promise.resolve, resolves with undefined', assert => {
return Promise.resolve().then(result => {
assert.same(result, undefined, 'resolved with a correct value');
});
});
QUnit.test('Promise.resolve, subclassing', assert => {
const { resolve } = Promise;
function SubPromise(executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
}
SubPromise[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.true(resolve.call(SubPromise, 42) instanceof SubPromise, 'subclassing, `this` pattern');
function FakePromise1() { /* empty */ }
function FakePromise2(executor) {
executor(null, () => { /* empty */ });
}
function FakePromise3(executor) {
executor(() => { /* empty */ }, null);
}
assert.throws(() => {
resolve.call(FakePromise1, 42);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
resolve.call(FakePromise2, 42);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
resolve.call(FakePromise3, 42);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.resolve, without constructor context', assert => {
const { resolve } = Promise;
assert.throws(() => resolve(''), TypeError, 'Throws if called without a constructor context');
assert.throws(() => resolve.call(null, ''), TypeError, 'Throws if called with null as this');
});
================================================
FILE: tests/unit-pure/es.promise.try.js
================================================
import $try from 'core-js-pure/es/promise/try';
import bind from 'core-js-pure/es/function/bind';
import Promise from 'core-js-pure/es/promise';
QUnit.test('Promise.try', assert => {
assert.isFunction(Promise.try);
assert.arity(Promise.try, 1);
assert.true(Promise.try(() => 42) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.try, resolved', assert => {
return Promise.try(() => 42).then(it => {
assert.same(it, 42, 'resolved with a correct value');
});
});
QUnit.test('Promise.try, resolved, with args', assert => {
return Promise.try((a, b) => Promise.resolve(a + b), 1, 2).then(it => {
assert.same(it, 3, 'resolved with a correct value');
});
});
QUnit.test('Promise.try, rejected', assert => {
return Promise.try(() => {
throw new Error();
}).then(() => {
assert.avoid();
}, () => {
assert.required('rejected as expected');
});
});
QUnit.test('Promise.try, subclassing', assert => {
const { try: promiseTry, resolve } = Promise;
function SubPromise(executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
}
SubPromise.resolve = bind(resolve, Promise);
assert.true(promiseTry.call(SubPromise, () => 42) instanceof SubPromise, 'subclassing, `this` pattern');
function FakePromise1() { /* empty */ }
function FakePromise2(executor) {
executor(null, () => { /* empty */ });
}
function FakePromise3(executor) {
executor(() => { /* empty */ }, null);
}
FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = bind(resolve, Promise);
assert.throws(() => {
promiseTry.call(FakePromise1, () => 42);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
promiseTry.call(FakePromise2, () => 42);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
promiseTry.call(FakePromise3, () => 42);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.try, without constructor context', assert => {
const { try: promiseTry } = Promise;
assert.throws(() => promiseTry(() => 42), TypeError, 'Throws if called without a constructor context');
assert.throws(() => promiseTry.call(null, () => 42), TypeError, 'Throws if called with null as this');
});
QUnit.test('Promise.try, method from direct entry, without constructor context', assert => {
return $try(() => 123).then(it => {
assert.same(it, 123, 'resolved with a correct value');
});
});
QUnit.test('Promise.try, method from direct entry, with null context', assert => {
return $try.call(null, () => 'foo').then(it => {
assert.same(it, 'foo', 'resolved with a correct value');
});
});
================================================
FILE: tests/unit-pure/es.promise.with-resolvers.js
================================================
import Promise from 'core-js-pure/es/promise';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
QUnit.test('Promise.withResolvers', assert => {
const { withResolvers } = Promise;
assert.isFunction(withResolvers);
assert.arity(withResolvers, 0);
assert.name(withResolvers, 'withResolvers');
const d1 = Promise.withResolvers();
assert.same(getPrototypeOf(d1), Object.prototype, 'proto is Object.prototype');
assert.true(d1.promise instanceof Promise, 'promise is promise');
assert.isFunction(d1.resolve, 'resolve is function');
assert.isFunction(d1.reject, 'reject is function');
const promise = {};
const resolve = () => { /* empty */ };
let reject = () => { /* empty */ };
function P(exec) {
exec(resolve, reject);
return promise;
}
const d2 = withResolvers.call(P);
assert.same(d2.promise, promise, 'promise is promise #2');
assert.same(d2.resolve, resolve, 'resolve is resolve #2');
assert.same(d2.reject, reject, 'reject is reject #2');
reject = {};
assert.throws(() => withResolvers.call(P), TypeError, 'broken resolver');
assert.throws(() => withResolvers.call({}), TypeError, 'broken constructor #1');
assert.throws(() => withResolvers.call(null), TypeError, 'broken constructor #2');
});
QUnit.test('Promise.withResolvers, resolve', assert => {
const d = Promise.withResolvers();
d.resolve(42);
return d.promise.then(it => {
assert.same(it, 42, 'resolved as expected');
}, () => {
assert.avoid();
});
});
QUnit.test('Promise.withResolvers, reject', assert => {
const d = Promise.withResolvers();
d.reject(42);
return d.promise.then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejected as expected');
});
});
================================================
FILE: tests/unit-pure/es.reflect.apply.js
================================================
import apply from 'core-js-pure/es/reflect/apply';
QUnit.test('Reflect.apply', assert => {
assert.isFunction(apply);
assert.arity(apply, 3);
if ('name' in apply) {
assert.name(apply, 'apply');
}
assert.same(apply(Array.prototype.push, [1, 2], [3, 4, 5]), 5);
function F(a, b, c) {
return a + b + c;
}
F.apply = 42;
assert.same(apply(F, null, ['foo', 'bar', 'baz']), 'foobarbaz', 'works with redefined apply');
assert.throws(() => apply(42, null, []), TypeError, 'throws on primitive');
assert.throws(() => apply(() => { /* empty */ }, null), TypeError, 'throws without third argument');
assert.throws(() => apply(() => { /* empty */ }, null, '123'), TypeError, 'throws on primitive as third argument');
});
================================================
FILE: tests/unit-pure/es.reflect.construct.js
================================================
import construct from 'core-js-pure/es/reflect/construct';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
QUnit.test('Reflect.construct', assert => {
assert.isFunction(construct);
assert.arity(construct, 2);
if ('name' in construct) {
assert.name(construct, 'construct');
}
function A(a, b, c) {
this.qux = a + b + c;
}
assert.same(construct(A, ['foo', 'bar', 'baz']).qux, 'foobarbaz', 'basic');
A.apply = 42;
assert.same(construct(A, ['foo', 'bar', 'baz']).qux, 'foobarbaz', 'works with redefined apply');
const instance = construct(function () {
this.x = 42;
}, [], Array);
assert.same(instance.x, 42, 'constructor with newTarget');
assert.true(instance instanceof Array, 'prototype with newTarget');
assert.throws(() => construct(42, []), TypeError, 'throws on primitive');
function B() { /* empty */ }
B.prototype = 42;
assert.notThrows(() => getPrototypeOf(construct(B, [])) === Object.prototype);
assert.notThrows(() => typeof construct(Date, []).getTime() == 'number', 'works with native constructors with 2 arguments');
// eslint-disable-next-line prefer-arrow-callback -- testing
assert.throws(() => construct(function () { /* empty */ }), TypeError, 'throws when the second argument is not an object');
});
================================================
FILE: tests/unit-pure/es.reflect.define-property.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import getOwnPropertyDescriptor from 'core-js-pure/es/object/get-own-property-descriptor';
import create from 'core-js-pure/es/object/create';
import defineProperty from 'core-js-pure/es/reflect/define-property';
QUnit.test('Reflect.defineProperty', assert => {
assert.isFunction(defineProperty);
assert.arity(defineProperty, 3);
if ('name' in defineProperty) {
assert.name(defineProperty, 'defineProperty');
}
let object = {};
assert.true(defineProperty(object, 'foo', { value: 123 }));
assert.same(object.foo, 123);
if (DESCRIPTORS) {
object = {};
defineProperty(object, 'foo', {
value: 123,
enumerable: true,
});
assert.deepEqual(getOwnPropertyDescriptor(object, 'foo'), {
value: 123,
enumerable: true,
configurable: false,
writable: false,
});
assert.false(defineProperty(object, 'foo', {
value: 42,
}));
}
assert.throws(() => defineProperty(42, 'foo', {
value: 42,
}), TypeError, 'throws on primitive');
assert.throws(() => defineProperty(42, 1, {}));
assert.throws(() => defineProperty({}, create(null), {}));
assert.throws(() => defineProperty({}, 1, 1));
// ToPropertyDescriptor errors should throw, not return false
assert.throws(() => defineProperty({}, 'a', { get: 42 }), TypeError, 'throws on non-callable getter');
assert.throws(() => defineProperty({}, 'a', { set: 'str' }), TypeError, 'throws on non-callable setter');
assert.throws(() => defineProperty({}, 'a', { get: null }), TypeError, 'throws on null getter');
assert.throws(() => defineProperty({}, 'a', { get: false }), TypeError, 'throws on false getter');
if (DESCRIPTORS) {
assert.throws(() => defineProperty({}, 'a', { get() { /* empty */ }, value: 1 }), TypeError, 'throws on mixed accessor/data descriptor');
assert.true(defineProperty({}, 'a', { get: undefined }), 'undefined getter is valid');
}
});
QUnit.test('Reflect.defineProperty.sham flag', assert => {
assert.same(defineProperty.sham, DESCRIPTORS ? undefined : true);
});
================================================
FILE: tests/unit-pure/es.reflect.delete-property.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import { createConversionChecker } from '../helpers/helpers.js';
import keys from 'core-js-pure/es/object/keys';
import defineProperty from 'core-js-pure/es/object/define-property';
import deleteProperty from 'core-js-pure/es/reflect/delete-property';
QUnit.test('Reflect.deleteProperty', assert => {
assert.isFunction(deleteProperty);
assert.arity(deleteProperty, 2);
if ('name' in deleteProperty) {
assert.name(deleteProperty, 'deleteProperty');
}
const object = { bar: 456 };
assert.true(deleteProperty(object, 'bar'));
assert.same(keys(object).length, 0);
if (DESCRIPTORS) {
assert.false(deleteProperty(defineProperty({}, 'foo', {
value: 42,
}), 'foo'));
}
assert.throws(() => deleteProperty(42, 'foo'), TypeError, 'throws on primitive');
// ToPropertyKey should be called exactly once
const keyObj = createConversionChecker(1, 'bar');
deleteProperty({ bar: 1 }, keyObj);
assert.same(keyObj.$valueOf, 0, 'ToPropertyKey called once in Reflect.deleteProperty, #1');
assert.same(keyObj.$toString, 1, 'ToPropertyKey called once in Reflect.deleteProperty, #2');
// argument order: target should be validated before ToPropertyKey
const orderChecker = createConversionChecker(1, 'qux');
assert.throws(() => deleteProperty(42, orderChecker), TypeError, 'throws on primitive before ToPropertyKey');
assert.same(orderChecker.$toString, 0, 'ToPropertyKey not called before target validation in Reflect.deleteProperty');
});
================================================
FILE: tests/unit-pure/es.reflect.get-own-property-descriptor.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import getOwnPropertyDescriptor from 'core-js-pure/es/reflect/get-own-property-descriptor';
QUnit.test('Reflect.getOwnPropertyDescriptor', assert => {
assert.isFunction(getOwnPropertyDescriptor);
assert.arity(getOwnPropertyDescriptor, 2);
if ('name' in getOwnPropertyDescriptor) {
assert.name(getOwnPropertyDescriptor, 'getOwnPropertyDescriptor');
}
const object = { baz: 789 };
const descriptor = getOwnPropertyDescriptor(object, 'baz');
assert.same(descriptor.value, 789);
assert.throws(() => getOwnPropertyDescriptor(42, 'constructor'), TypeError, 'throws on primitive');
});
QUnit.test('Reflect.getOwnPropertyDescriptor.sham flag', assert => {
assert.same(getOwnPropertyDescriptor.sham, DESCRIPTORS ? undefined : true);
});
================================================
FILE: tests/unit-pure/es.reflect.get-prototype-of.js
================================================
import { CORRECT_PROTOTYPE_GETTER } from '../helpers/constants.js';
import getPrototypeOf from 'core-js-pure/es/reflect/get-prototype-of';
QUnit.test('Reflect.getPrototypeOf', assert => {
assert.isFunction(getPrototypeOf);
assert.arity(getPrototypeOf, 1);
if ('name' in getPrototypeOf) {
assert.name(getPrototypeOf, 'getPrototypeOf');
}
assert.same(getPrototypeOf([]), Array.prototype);
assert.throws(() => getPrototypeOf(42), TypeError, 'throws on primitive');
});
QUnit.test('Reflect.getPrototypeOf.sham flag', assert => {
assert.same(getPrototypeOf.sham, CORRECT_PROTOTYPE_GETTER ? undefined : true);
});
================================================
FILE: tests/unit-pure/es.reflect.get.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import { createConversionChecker } from '../helpers/helpers.js';
import create from 'core-js-pure/es/object/create';
import defineProperty from 'core-js-pure/es/object/define-property';
import get from 'core-js-pure/es/reflect/get';
QUnit.test('Reflect.get', assert => {
assert.isFunction(get);
assert.arity(get, 2);
if ('name' in get) {
assert.name(get, 'get');
}
assert.same(get({ qux: 987 }, 'qux'), 987);
if (DESCRIPTORS) {
const target = create(defineProperty({ z: 3 }, 'w', {
get() {
return this;
},
}), {
x: {
value: 1,
},
y: {
get() {
return this;
},
},
});
const receiver = {};
assert.same(get(target, 'x', receiver), 1, 'get x');
assert.same(get(target, 'y', receiver), receiver, 'get y');
assert.same(get(target, 'z', receiver), 3, 'get z');
assert.same(get(target, 'w', receiver), receiver, 'get w');
assert.same(get(target, 'u', receiver), undefined, 'get u');
// ToPropertyKey should be called exactly once even with prototype chain traversal
const keyObj = createConversionChecker(1, 'x');
get(create({ x: 42 }), keyObj, {});
assert.same(keyObj.$valueOf, 0, 'ToPropertyKey called once in Reflect.get, #1');
assert.same(keyObj.$toString, 1, 'ToPropertyKey called once in Reflect.get, #2');
}
assert.throws(() => get(42, 'constructor'), TypeError, 'throws on primitive');
// argument order: target should be validated before ToPropertyKey
const orderChecker = createConversionChecker(1, 'qux');
assert.throws(() => get(42, orderChecker), TypeError, 'throws on primitive before ToPropertyKey');
assert.same(orderChecker.$toString, 0, 'ToPropertyKey not called before target validation in Reflect.get');
});
================================================
FILE: tests/unit-pure/es.reflect.has.js
================================================
import has from 'core-js-pure/es/reflect/has';
QUnit.test('Reflect.has', assert => {
assert.isFunction(has);
assert.arity(has, 2);
if ('name' in has) {
assert.name(has, 'has');
}
const object = { qux: 987 };
assert.true(has(object, 'qux'));
assert.false(has(object, 'qwe'));
assert.true(has(object, 'toString'));
assert.throws(() => has(42, 'constructor'), TypeError, 'throws on primitive');
});
================================================
FILE: tests/unit-pure/es.reflect.is-extensible.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import preventExtensions from 'core-js-pure/es/object/prevent-extensions';
import isExtensible from 'core-js-pure/es/reflect/is-extensible';
QUnit.test('Reflect.isExtensible', assert => {
assert.isFunction(isExtensible);
assert.arity(isExtensible, 1);
if ('name' in isExtensible) {
assert.name(isExtensible, 'isExtensible');
}
assert.true(isExtensible({}));
if (DESCRIPTORS) {
assert.false(isExtensible(preventExtensions({})));
}
assert.throws(() => isExtensible(42), TypeError, 'throws on primitive');
});
================================================
FILE: tests/unit-pure/es.reflect.own-keys.js
================================================
import { includes } from '../helpers/helpers.js';
import Symbol from 'core-js-pure/es/symbol';
import create from 'core-js-pure/es/object/create';
import defineProperty from 'core-js-pure/es/object/define-property';
import ownKeys from 'core-js-pure/es/reflect/own-keys';
QUnit.test('Reflect.ownKeys', assert => {
assert.isFunction(ownKeys);
assert.arity(ownKeys, 1);
if ('name' in ownKeys) {
assert.name(ownKeys, 'ownKeys');
}
const object = { a: 1 };
defineProperty(object, 'b', {
value: 2,
});
object[Symbol('c')] = 3;
let keys = ownKeys(object);
assert.same(keys.length, 3, 'ownKeys return all own keys');
assert.true(includes(keys, 'a'), 'ownKeys return all own keys: simple');
assert.true(includes(keys, 'b'), 'ownKeys return all own keys: hidden');
assert.same(object[keys[2]], 3, 'ownKeys return all own keys: symbol');
keys = ownKeys(create(object));
assert.same(keys.length, 0, 'ownKeys return only own keys');
assert.throws(() => ownKeys(42), TypeError, 'throws on primitive');
});
================================================
FILE: tests/unit-pure/es.reflect.prevent-extensions.js
================================================
import { DESCRIPTORS, FREEZING } from '../helpers/constants.js';
import preventExtensions from 'core-js-pure/es/reflect/prevent-extensions';
import isExtensible from 'core-js-pure/es/object/is-extensible';
QUnit.test('Reflect.preventExtensions', assert => {
assert.isFunction(preventExtensions);
assert.arity(preventExtensions, 1);
if ('name' in preventExtensions) {
assert.name(preventExtensions, 'preventExtensions');
}
const object = {};
assert.true(preventExtensions(object));
if (DESCRIPTORS) {
assert.false(isExtensible(object));
}
assert.throws(() => preventExtensions(42), TypeError, 'throws on primitive');
});
QUnit.test('Reflect.preventExtensions.sham flag', assert => {
assert.same(preventExtensions.sham, FREEZING ? undefined : true);
});
================================================
FILE: tests/unit-pure/es.reflect.set-prototype-of.js
================================================
import { PROTO } from '../helpers/constants.js';
import setPrototypeOf from 'core-js-pure/es/reflect/set-prototype-of';
if (PROTO) QUnit.test('Reflect.setPrototypeOf', assert => {
assert.isFunction(setPrototypeOf);
assert.arity(setPrototypeOf, 2);
if ('name' in setPrototypeOf) {
assert.name(setPrototypeOf, 'setPrototypeOf');
}
let object = {};
assert.true(setPrototypeOf(object, Array.prototype));
assert.true(object instanceof Array);
assert.throws(() => setPrototypeOf({}, 42), TypeError);
assert.throws(() => setPrototypeOf(42, {}), TypeError, 'throws on primitive');
object = {};
assert.false(setPrototypeOf(object, object), 'false on recursive __proto__');
});
================================================
FILE: tests/unit-pure/es.reflect.set.js
================================================
import { DESCRIPTORS, FREEZING } from '../helpers/constants.js';
import { createConversionChecker } from '../helpers/helpers.js';
import create from 'core-js-pure/es/object/create';
import defineProperty from 'core-js-pure/es/object/define-property';
import getOwnPropertyDescriptor from 'core-js-pure/es/object/get-own-property-descriptor';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
import freeze from 'core-js-pure/es/object/freeze';
import preventExtensions from 'core-js-pure/es/object/prevent-extensions';
import seal from 'core-js-pure/es/object/seal';
import set from 'core-js-pure/es/reflect/set';
QUnit.test('Reflect.set', assert => {
assert.isFunction(set);
assert.arity(set, 3);
if ('name' in set) {
assert.name(set, 'set');
}
const object = {};
assert.true(set(object, 'quux', 654));
assert.same(object.quux, 654);
let target = {};
const receiver = {};
set(target, 'foo', 1, receiver);
assert.same(target.foo, undefined, 'target.foo === undefined');
assert.same(receiver.foo, 1, 'receiver.foo === 1');
if (DESCRIPTORS) {
defineProperty(receiver, 'bar', {
value: 0,
writable: true,
enumerable: false,
configurable: true,
});
set(target, 'bar', 1, receiver);
assert.same(receiver.bar, 1, 'receiver.bar === 1');
assert.false(getOwnPropertyDescriptor(receiver, 'bar').enumerable, 'enumerability not overridden');
let out;
target = create(defineProperty({ z: 3 }, 'w', {
set() {
out = this;
},
}), {
x: {
value: 1,
writable: true,
configurable: true,
},
y: {
set() {
out = this;
},
},
c: {
value: 1,
writable: false,
configurable: false,
},
});
assert.true(set(target, 'x', 2, target), 'set x');
assert.same(target.x, 2, 'set x');
out = null;
assert.true(set(target, 'y', 2, target), 'set y');
assert.same(out, target, 'set y');
assert.true(set(target, 'z', 4, target));
assert.same(target.z, 4, 'set z');
out = null;
assert.true(set(target, 'w', 1, target), 'set w');
assert.same(out, target, 'set w');
assert.true(set(target, 'u', 0, target), 'set u');
assert.same(target.u, 0, 'set u');
assert.false(set(target, 'c', 2, target), 'set c');
assert.same(target.c, 1, 'set c');
// https://github.com/zloirock/core-js/issues/392
let o = defineProperty({}, 'test', {
writable: false,
configurable: true,
});
assert.false(set(getPrototypeOf(o), 'test', 1, o));
// https://github.com/zloirock/core-js/issues/393
o = defineProperty({}, 'test', {
get() { /* empty */ },
});
assert.notThrows(() => !set(getPrototypeOf(o), 'test', 1, o));
o = defineProperty({}, 'test', {
// eslint-disable-next-line no-unused-vars -- required for testing
set(v) { /* empty */ },
});
assert.notThrows(() => !set(getPrototypeOf(o), 'test', 1, o));
// accessor descriptor with get: undefined, set: undefined on receiver should return false
const accessorReceiver = {};
defineProperty(accessorReceiver, 'prop', { get: undefined, set: undefined, configurable: true });
const accessorTarget = defineProperty({}, 'prop', { value: 1, writable: true, configurable: true });
assert.false(set(accessorTarget, 'prop', 2, accessorReceiver), 'accessor descriptor on receiver with undefined get/set');
// ToPropertyKey should be called exactly once
const keyObj = createConversionChecker(1, 'x');
set(create({ x: 42 }), keyObj, 1);
assert.same(keyObj.$valueOf, 0, 'ToPropertyKey called once in Reflect.set, #1');
assert.same(keyObj.$toString, 1, 'ToPropertyKey called once in Reflect.set, #2');
}
assert.throws(() => set(42, 'q', 42), TypeError, 'throws on primitive');
// Reflect.set should pass only { value: V } to [[DefineOwnProperty]] when updating existing data property
if (DESCRIPTORS) {
const obj = defineProperty({}, 'x', { value: 1, writable: true, enumerable: true, configurable: true });
assert.true(set(obj, 'x', 42), 'set existing writable property');
const desc = getOwnPropertyDescriptor(obj, 'x');
assert.same(desc.value, 42, 'value updated');
assert.true(desc.writable, 'writable preserved');
assert.true(desc.enumerable, 'enumerable preserved');
assert.true(desc.configurable, 'configurable preserved');
}
// argument order: target should be validated before ToPropertyKey
const orderChecker = createConversionChecker(1, 'qux');
assert.throws(() => set(42, orderChecker, 1), TypeError, 'throws on primitive before ToPropertyKey');
// non-extensible receiver should return false, not throw
if (FREEZING) {
assert.false(set({}, 'x', 42, freeze({})), 'frozen empty receiver returns false');
assert.false(set({}, 'x', 42, preventExtensions({})), 'non-extensible receiver returns false');
assert.false(set({}, 'x', 42, seal({})), 'sealed empty receiver returns false');
}
assert.same(orderChecker.$toString, 0, 'ToPropertyKey not called before target validation in Reflect.set');
});
================================================
FILE: tests/unit-pure/es.regexp.escape.js
================================================
/* eslint-disable @stylistic/max-len -- ok*/
import escape from 'core-js-pure/es/regexp/escape';
QUnit.test('RegExp.escape', assert => {
assert.isFunction(escape);
assert.arity(escape, 1);
assert.name(escape, 'escape');
assert.same(escape('10$'), '\\x310\\$', '10$');
assert.same(escape('abcdefg_123456'), '\\x61bcdefg_123456', 'abcdefg_123456');
assert.same(escape('Привет'), 'Привет', 'Привет');
assert.same(
escape('(){}[]|,.?*+-^$=<>\\/#&!%:;@~\'"`'),
'\\(\\)\\{\\}\\[\\]\\|\\x2c\\.\\?\\*\\+\\x2d\\^\\$\\x3d\\x3c\\x3e\\\\\\/\\x23\\x26\\x21\\x25\\x3a\\x3b\\x40\\x7e\\x27\\x22\\x60',
'(){}[]|,.?*+-^$=<>\\/#&!%:;@~\'"`',
);
assert.same(
escape('\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'),
'\\t\\n\\v\\f\\r\\x20\\xa0\\u1680\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\u2028\\u2029\\ufeff',
'whitespaces and control',
);
assert.same(escape('💩'), '💩', '💩');
assert.same(escape('\uD83D'), '\\ud83d', '\\ud83d');
assert.same(escape('\uDCA9'), '\\udca9', '\\udca9');
assert.same(escape('\uDCA9\uD83D'), '\\udca9\\ud83d', '\\udca9\\ud83d');
assert.throws(() => escape(42), TypeError, 'throws on non-string #1');
assert.throws(() => escape({}), TypeError, 'throws on non-string #2');
// Test262
// Copyright 2024 Leo Balter. 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(escape('\u2028'), '\\u2028', 'line terminator \\u2028 is escaped correctly to \\\\u2028');
assert.same(escape('\u2029'), '\\u2029', 'line terminator \\u2029 is escaped correctly to \\\\u2029');
assert.same(escape('\u2028\u2029'), '\\u2028\\u2029', 'line terminators are escaped correctly');
assert.same(escape('\u2028a\u2029a'), '\\u2028a\\u2029a', 'mixed line terminators are escaped correctly');
assert.same(escape('.a/b'), '\\.a\\/b', 'mixed string with solidus character is escaped correctly');
assert.same(escape('/./'), '\\/\\.\\/', 'solidus character is escaped correctly - regexp similar');
assert.same(escape('./a\\/*b+c?d^e$f|g{2}h[i]j\\k'), '\\.\\/a\\\\\\/\\*b\\+c\\?d\\^e\\$f\\|g\\{2\\}h\\[i\\]j\\\\k', 'complex string with multiple special characters is escaped correctly');
assert.same(escape('/'), '\\/', 'solidus character is escaped correctly');
assert.same(escape('//'), '\\/\\/', 'solidus character is escaped correctly - multiple occurrences 1');
assert.same(escape('///'), '\\/\\/\\/', 'solidus character is escaped correctly - multiple occurrences 2');
assert.same(escape('////'), '\\/\\/\\/\\/', 'solidus character is escaped correctly - multiple occurrences 3');
assert.same(escape('.'), '\\.', 'dot character is escaped correctly');
assert.same(escape('*'), '\\*', 'asterisk character is escaped correctly');
assert.same(escape('+'), '\\+', 'plus character is escaped correctly');
assert.same(escape('?'), '\\?', 'question mark character is escaped correctly');
assert.same(escape('^'), '\\^', 'caret character is escaped correctly');
assert.same(escape('$'), '\\$', 'dollar character is escaped correctly');
assert.same(escape('|'), '\\|', 'pipe character is escaped correctly');
assert.same(escape('('), '\\(', 'open parenthesis character is escaped correctly');
assert.same(escape(')'), '\\)', 'close parenthesis character is escaped correctly');
assert.same(escape('['), '\\[', 'open bracket character is escaped correctly');
assert.same(escape(']'), '\\]', 'close bracket character is escaped correctly');
assert.same(escape('{'), '\\{', 'open brace character is escaped correctly');
assert.same(escape('}'), '\\}', 'close brace character is escaped correctly');
assert.same(escape('\\'), '\\\\', 'backslash character is escaped correctly');
const codePoints = String.fromCharCode(0x100, 0x200, 0x300);
assert.same(escape(codePoints), codePoints, 'characters are correctly not escaped');
assert.same(escape('你好'), '你好', 'Chinese characters are correctly not escaped');
assert.same(escape('こんにちは'), 'こんにちは', 'Japanese characters are correctly not escaped');
assert.same(escape('안녕하세요'), '안녕하세요', 'Korean characters are correctly not escaped');
assert.same(escape('Привет'), 'Привет', 'Cyrillic characters are correctly not escaped');
assert.same(escape('مرحبا'), 'مرحبا', 'Arabic characters are correctly not escaped');
assert.same(escape('हेलो'), 'हेलो', 'Devanagari characters are correctly not escaped');
assert.same(escape('Γειά σου'), 'Γειά\\x20σου', 'Greek characters are correctly not escaped');
assert.same(escape('שלום'), 'שלום', 'Hebrew characters are correctly not escaped');
assert.same(escape('สวัสดี'), 'สวัสดี', 'Thai characters are correctly not escaped');
assert.same(escape('नमस्ते'), 'नमस्ते', 'Hindi characters are correctly not escaped');
assert.same(escape('ሰላም'), 'ሰላም', 'Amharic characters are correctly not escaped');
assert.same(escape('हैलो'), 'हैलो', 'Hindi characters with diacritics are correctly not escaped');
assert.same(escape('안녕!'), '안녕\\x21', 'Korean character with special character is correctly escaped');
assert.same(escape('.hello\uD7FFworld'), '\\.hello\uD7FFworld', 'Mixed ASCII and Unicode characters are correctly escaped');
assert.same(escape('\uFEFF'), '\\ufeff', 'whitespace \\uFEFF is escaped correctly to \\uFEFF');
assert.same(escape('\u0020'), '\\x20', 'whitespace \\u0020 is escaped correctly to \\x20');
assert.same(escape('\u00A0'), '\\xa0', 'whitespace \\u00A0 is escaped correctly to \\xA0');
assert.same(escape('\u202F'), '\\u202f', 'whitespace \\u202F is escaped correctly to \\u202F');
assert.same(escape('\u0009'), '\\t', 'whitespace \\u0009 is escaped correctly to \\t');
assert.same(escape('\u000B'), '\\v', 'whitespace \\u000B is escaped correctly to \\v');
assert.same(escape('\u000C'), '\\f', 'whitespace \\u000C is escaped correctly to \\f');
assert.same(escape('\uFEFF\u0020\u00A0\u202F\u0009\u000B\u000C'), '\\ufeff\\x20\\xa0\\u202f\\t\\v\\f', 'whitespaces are escaped correctly');
// Escaping initial digits
assert.same(escape('1111'), '\\x31111', 'Initial decimal digit 1 is escaped');
assert.same(escape('2222'), '\\x32222', 'Initial decimal digit 2 is escaped');
assert.same(escape('3333'), '\\x33333', 'Initial decimal digit 3 is escaped');
assert.same(escape('4444'), '\\x34444', 'Initial decimal digit 4 is escaped');
assert.same(escape('5555'), '\\x35555', 'Initial decimal digit 5 is escaped');
assert.same(escape('6666'), '\\x36666', 'Initial decimal digit 6 is escaped');
assert.same(escape('7777'), '\\x37777', 'Initial decimal digit 7 is escaped');
assert.same(escape('8888'), '\\x38888', 'Initial decimal digit 8 is escaped');
assert.same(escape('9999'), '\\x39999', 'Initial decimal digit 9 is escaped');
assert.same(escape('0000'), '\\x30000', 'Initial decimal digit 0 is escaped');
// Escaping initial ASCII letters
assert.same(escape('aaa'), '\\x61aa', 'Initial ASCII letter a is escaped');
assert.same(escape('bbb'), '\\x62bb', 'Initial ASCII letter b is escaped');
assert.same(escape('ccc'), '\\x63cc', 'Initial ASCII letter c is escaped');
assert.same(escape('ddd'), '\\x64dd', 'Initial ASCII letter d is escaped');
assert.same(escape('eee'), '\\x65ee', 'Initial ASCII letter e is escaped');
assert.same(escape('fff'), '\\x66ff', 'Initial ASCII letter f is escaped');
assert.same(escape('ggg'), '\\x67gg', 'Initial ASCII letter g is escaped');
assert.same(escape('hhh'), '\\x68hh', 'Initial ASCII letter h is escaped');
assert.same(escape('iii'), '\\x69ii', 'Initial ASCII letter i is escaped');
assert.same(escape('jjj'), '\\x6ajj', 'Initial ASCII letter j is escaped');
assert.same(escape('kkk'), '\\x6bkk', 'Initial ASCII letter k is escaped');
assert.same(escape('lll'), '\\x6cll', 'Initial ASCII letter l is escaped');
assert.same(escape('mmm'), '\\x6dmm', 'Initial ASCII letter m is escaped');
assert.same(escape('nnn'), '\\x6enn', 'Initial ASCII letter n is escaped');
assert.same(escape('ooo'), '\\x6foo', 'Initial ASCII letter o is escaped');
assert.same(escape('ppp'), '\\x70pp', 'Initial ASCII letter p is escaped');
assert.same(escape('qqq'), '\\x71qq', 'Initial ASCII letter q is escaped');
assert.same(escape('rrr'), '\\x72rr', 'Initial ASCII letter r is escaped');
assert.same(escape('sss'), '\\x73ss', 'Initial ASCII letter s is escaped');
assert.same(escape('ttt'), '\\x74tt', 'Initial ASCII letter t is escaped');
assert.same(escape('uuu'), '\\x75uu', 'Initial ASCII letter u is escaped');
assert.same(escape('vvv'), '\\x76vv', 'Initial ASCII letter v is escaped');
assert.same(escape('www'), '\\x77ww', 'Initial ASCII letter w is escaped');
assert.same(escape('xxx'), '\\x78xx', 'Initial ASCII letter x is escaped');
assert.same(escape('yyy'), '\\x79yy', 'Initial ASCII letter y is escaped');
assert.same(escape('zzz'), '\\x7azz', 'Initial ASCII letter z is escaped');
assert.same(escape('AAA'), '\\x41AA', 'Initial ASCII letter A is escaped');
assert.same(escape('BBB'), '\\x42BB', 'Initial ASCII letter B is escaped');
assert.same(escape('CCC'), '\\x43CC', 'Initial ASCII letter C is escaped');
assert.same(escape('DDD'), '\\x44DD', 'Initial ASCII letter D is escaped');
assert.same(escape('EEE'), '\\x45EE', 'Initial ASCII letter E is escaped');
assert.same(escape('FFF'), '\\x46FF', 'Initial ASCII letter F is escaped');
assert.same(escape('GGG'), '\\x47GG', 'Initial ASCII letter G is escaped');
assert.same(escape('HHH'), '\\x48HH', 'Initial ASCII letter H is escaped');
assert.same(escape('III'), '\\x49II', 'Initial ASCII letter I is escaped');
assert.same(escape('JJJ'), '\\x4aJJ', 'Initial ASCII letter J is escaped');
assert.same(escape('KKK'), '\\x4bKK', 'Initial ASCII letter K is escaped');
assert.same(escape('LLL'), '\\x4cLL', 'Initial ASCII letter L is escaped');
assert.same(escape('MMM'), '\\x4dMM', 'Initial ASCII letter M is escaped');
assert.same(escape('NNN'), '\\x4eNN', 'Initial ASCII letter N is escaped');
assert.same(escape('OOO'), '\\x4fOO', 'Initial ASCII letter O is escaped');
assert.same(escape('PPP'), '\\x50PP', 'Initial ASCII letter P is escaped');
assert.same(escape('QQQ'), '\\x51QQ', 'Initial ASCII letter Q is escaped');
assert.same(escape('RRR'), '\\x52RR', 'Initial ASCII letter R is escaped');
assert.same(escape('SSS'), '\\x53SS', 'Initial ASCII letter S is escaped');
assert.same(escape('TTT'), '\\x54TT', 'Initial ASCII letter T is escaped');
assert.same(escape('UUU'), '\\x55UU', 'Initial ASCII letter U is escaped');
assert.same(escape('VVV'), '\\x56VV', 'Initial ASCII letter V is escaped');
assert.same(escape('WWW'), '\\x57WW', 'Initial ASCII letter W is escaped');
assert.same(escape('XXX'), '\\x58XX', 'Initial ASCII letter X is escaped');
assert.same(escape('YYY'), '\\x59YY', 'Initial ASCII letter Y is escaped');
assert.same(escape('ZZZ'), '\\x5aZZ', 'Initial ASCII letter Z is escaped');
// Mixed case with special characters
assert.same(escape('1+1'), '\\x31\\+1', 'Initial decimal digit 1 with special character is escaped');
assert.same(escape('2+2'), '\\x32\\+2', 'Initial decimal digit 2 with special character is escaped');
assert.same(escape('3+3'), '\\x33\\+3', 'Initial decimal digit 3 with special character is escaped');
assert.same(escape('4+4'), '\\x34\\+4', 'Initial decimal digit 4 with special character is escaped');
assert.same(escape('5+5'), '\\x35\\+5', 'Initial decimal digit 5 with special character is escaped');
assert.same(escape('6+6'), '\\x36\\+6', 'Initial decimal digit 6 with special character is escaped');
assert.same(escape('7+7'), '\\x37\\+7', 'Initial decimal digit 7 with special character is escaped');
assert.same(escape('8+8'), '\\x38\\+8', 'Initial decimal digit 8 with special character is escaped');
assert.same(escape('9+9'), '\\x39\\+9', 'Initial decimal digit 9 with special character is escaped');
assert.same(escape('0+0'), '\\x30\\+0', 'Initial decimal digit 0 with special character is escaped');
assert.same(escape('a*a'), '\\x61\\*a', 'Initial ASCII letter a with special character is escaped');
assert.same(escape('b*b'), '\\x62\\*b', 'Initial ASCII letter b with special character is escaped');
assert.same(escape('c*c'), '\\x63\\*c', 'Initial ASCII letter c with special character is escaped');
assert.same(escape('d*d'), '\\x64\\*d', 'Initial ASCII letter d with special character is escaped');
assert.same(escape('e*e'), '\\x65\\*e', 'Initial ASCII letter e with special character is escaped');
assert.same(escape('f*f'), '\\x66\\*f', 'Initial ASCII letter f with special character is escaped');
assert.same(escape('g*g'), '\\x67\\*g', 'Initial ASCII letter g with special character is escaped');
assert.same(escape('h*h'), '\\x68\\*h', 'Initial ASCII letter h with special character is escaped');
assert.same(escape('i*i'), '\\x69\\*i', 'Initial ASCII letter i with special character is escaped');
assert.same(escape('j*j'), '\\x6a\\*j', 'Initial ASCII letter j with special character is escaped');
assert.same(escape('k*k'), '\\x6b\\*k', 'Initial ASCII letter k with special character is escaped');
assert.same(escape('l*l'), '\\x6c\\*l', 'Initial ASCII letter l with special character is escaped');
assert.same(escape('m*m'), '\\x6d\\*m', 'Initial ASCII letter m with special character is escaped');
assert.same(escape('n*n'), '\\x6e\\*n', 'Initial ASCII letter n with special character is escaped');
assert.same(escape('o*o'), '\\x6f\\*o', 'Initial ASCII letter o with special character is escaped');
assert.same(escape('p*p'), '\\x70\\*p', 'Initial ASCII letter p with special character is escaped');
assert.same(escape('q*q'), '\\x71\\*q', 'Initial ASCII letter q with special character is escaped');
assert.same(escape('r*r'), '\\x72\\*r', 'Initial ASCII letter r with special character is escaped');
assert.same(escape('s*s'), '\\x73\\*s', 'Initial ASCII letter s with special character is escaped');
assert.same(escape('t*t'), '\\x74\\*t', 'Initial ASCII letter t with special character is escaped');
assert.same(escape('u*u'), '\\x75\\*u', 'Initial ASCII letter u with special character is escaped');
assert.same(escape('v*v'), '\\x76\\*v', 'Initial ASCII letter v with special character is escaped');
assert.same(escape('w*w'), '\\x77\\*w', 'Initial ASCII letter w with special character is escaped');
assert.same(escape('x*x'), '\\x78\\*x', 'Initial ASCII letter x with special character is escaped');
assert.same(escape('y*y'), '\\x79\\*y', 'Initial ASCII letter y with special character is escaped');
assert.same(escape('z*z'), '\\x7a\\*z', 'Initial ASCII letter z with special character is escaped');
assert.same(escape('A*A'), '\\x41\\*A', 'Initial ASCII letter A with special character is escaped');
assert.same(escape('B*B'), '\\x42\\*B', 'Initial ASCII letter B with special character is escaped');
assert.same(escape('C*C'), '\\x43\\*C', 'Initial ASCII letter C with special character is escaped');
assert.same(escape('D*D'), '\\x44\\*D', 'Initial ASCII letter D with special character is escaped');
assert.same(escape('E*E'), '\\x45\\*E', 'Initial ASCII letter E with special character is escaped');
assert.same(escape('F*F'), '\\x46\\*F', 'Initial ASCII letter F with special character is escaped');
assert.same(escape('G*G'), '\\x47\\*G', 'Initial ASCII letter G with special character is escaped');
assert.same(escape('H*H'), '\\x48\\*H', 'Initial ASCII letter H with special character is escaped');
assert.same(escape('I*I'), '\\x49\\*I', 'Initial ASCII letter I with special character is escaped');
assert.same(escape('J*J'), '\\x4a\\*J', 'Initial ASCII letter J with special character is escaped');
assert.same(escape('K*K'), '\\x4b\\*K', 'Initial ASCII letter K with special character is escaped');
assert.same(escape('L*L'), '\\x4c\\*L', 'Initial ASCII letter L with special character is escaped');
assert.same(escape('M*M'), '\\x4d\\*M', 'Initial ASCII letter M with special character is escaped');
assert.same(escape('N*N'), '\\x4e\\*N', 'Initial ASCII letter N with special character is escaped');
assert.same(escape('O*O'), '\\x4f\\*O', 'Initial ASCII letter O with special character is escaped');
assert.same(escape('P*P'), '\\x50\\*P', 'Initial ASCII letter P with special character is escaped');
assert.same(escape('Q*Q'), '\\x51\\*Q', 'Initial ASCII letter Q with special character is escaped');
assert.same(escape('R*R'), '\\x52\\*R', 'Initial ASCII letter R with special character is escaped');
assert.same(escape('S*S'), '\\x53\\*S', 'Initial ASCII letter S with special character is escaped');
assert.same(escape('T*T'), '\\x54\\*T', 'Initial ASCII letter T with special character is escaped');
assert.same(escape('U*U'), '\\x55\\*U', 'Initial ASCII letter U with special character is escaped');
assert.same(escape('V*V'), '\\x56\\*V', 'Initial ASCII letter V with special character is escaped');
assert.same(escape('W*W'), '\\x57\\*W', 'Initial ASCII letter W with special character is escaped');
assert.same(escape('X*X'), '\\x58\\*X', 'Initial ASCII letter X with special character is escaped');
assert.same(escape('Y*Y'), '\\x59\\*Y', 'Initial ASCII letter Y with special character is escaped');
assert.same(escape('Z*Z'), '\\x5a\\*Z', 'Initial ASCII letter Z with special character is escaped');
assert.same(escape('_'), '_', 'Single underscore character is not escaped');
assert.same(escape('__'), '__', 'Thunderscore character is not escaped');
assert.same(escape('hello_world'), '\\x68ello_world', 'String starting with ASCII letter and containing underscore is not escaped');
assert.same(escape('1_hello_world'), '\\x31_hello_world', 'String starting with digit and containing underscore is correctly escaped');
assert.same(escape('a_b_c'), '\\x61_b_c', 'String starting with ASCII letter and containing multiple underscores is correctly escaped');
assert.same(escape('3_b_4'), '\\x33_b_4', 'String starting with digit and containing multiple underscores is correctly escaped');
assert.same(escape('_hello'), '_hello', 'String starting with underscore and containing other characters is not escaped');
assert.same(escape('_1hello'), '_1hello', 'String starting with underscore and digit is not escaped');
assert.same(escape('_a_1_2'), '_a_1_2', 'String starting with underscore and mixed characters is not escaped');
// Specific surrogate points
assert.same(escape('\uD800'), '\\ud800', 'High surrogate \\uD800 is correctly escaped');
assert.same(escape('\uDBFF'), '\\udbff', 'High surrogate \\uDBFF is correctly escaped');
assert.same(escape('\uDC00'), '\\udc00', 'Low surrogate \\uDC00 is correctly escaped');
assert.same(escape('\uDFFF'), '\\udfff', 'Low surrogate \\uDFFF is correctly escaped');
// Leading Surrogates
const highSurrogatesGroup1 = '\uD800\uD801\uD802\uD803\uD804\uD805\uD806\uD807\uD808\uD809\uD80A\uD80B\uD80C\uD80D\uD80E\uD80F';
const highSurrogatesGroup2 = '\uD810\uD811\uD812\uD813\uD814\uD815\uD816\uD817\uD818\uD819\uD81A\uD81B\uD81C\uD81D\uD81E\uD81F';
const highSurrogatesGroup3 = '\uD820\uD821\uD822\uD823\uD824\uD825\uD826\uD827\uD828\uD829\uD82A\uD82B\uD82C\uD82D\uD82E\uD82F';
const highSurrogatesGroup4 = '\uD830\uD831\uD832\uD833\uD834\uD835\uD836\uD837\uD838\uD839\uD83A\uD83B\uD83C\uD83D\uD83E\uD83F';
const highSurrogatesGroup5 = '\uD840\uD841\uD842\uD843\uD844\uD845\uD846\uD847\uD848\uD849\uD84A\uD84B\uD84C\uD84D\uD84E\uD84F';
const highSurrogatesGroup6 = '\uD850\uD851\uD852\uD853\uD854\uD855\uD856\uD857\uD858\uD859\uD85A\uD85B\uD85C\uD85D\uD85E\uD85F';
const highSurrogatesGroup7 = '\uD860\uD861\uD862\uD863\uD864\uD865\uD866\uD867\uD868\uD869\uD86A\uD86B\uD86C\uD86D\uD86E\uD86F';
const highSurrogatesGroup8 = '\uD870\uD871\uD872\uD873\uD874\uD875\uD876\uD877\uD878\uD879\uD87A\uD87B\uD87C\uD87D\uD87E\uD87F';
const highSurrogatesGroup9 = '\uD880\uD881\uD882\uD883\uD884\uD885\uD886\uD887\uD888\uD889\uD88A\uD88B\uD88C\uD88D\uD88E\uD88F';
const highSurrogatesGroup10 = '\uD890\uD891\uD892\uD893\uD894\uD895\uD896\uD897\uD898\uD899\uD89A\uD89B\uD89C\uD89D\uD89E\uD89F';
const highSurrogatesGroup11 = '\uD8A0\uD8A1\uD8A2\uD8A3\uD8A4\uD8A5\uD8A6\uD8A7\uD8A8\uD8A9\uD8AA\uD8AB\uD8AC\uD8AD\uD8AE\uD8AF';
const highSurrogatesGroup12 = '\uD8B0\uD8B1\uD8B2\uD8B3\uD8B4\uD8B5\uD8B6\uD8B7\uD8B8\uD8B9\uD8BA\uD8BB\uD8BC\uD8BD\uD8BE\uD8BF';
const highSurrogatesGroup13 = '\uD8C0\uD8C1\uD8C2\uD8C3\uD8C4\uD8C5\uD8C6\uD8C7\uD8C8\uD8C9\uD8CA\uD8CB\uD8CC\uD8CD\uD8CE\uD8CF';
const highSurrogatesGroup14 = '\uD8D0\uD8D1\uD8D2\uD8D3\uD8D4\uD8D5\uD8D6\uD8D7\uD8D8\uD8D9\uD8DA\uD8DB\uD8DC\uD8DD\uD8DE\uD8DF';
const highSurrogatesGroup15 = '\uD8E0\uD8E1\uD8E2\uD8E3\uD8E4\uD8E5\uD8E6\uD8E7\uD8E8\uD8E9\uD8EA\uD8EB\uD8EC\uD8ED\uD8EE\uD8EF';
const highSurrogatesGroup16 = '\uD8F0\uD8F1\uD8F2\uD8F3\uD8F4\uD8F5\uD8F6\uD8F7\uD8F8\uD8F9\uD8FA\uD8FB\uD8FC\uD8FD\uD8FE\uD8FF';
assert.same(escape(highSurrogatesGroup1), '\\ud800\\ud801\\ud802\\ud803\\ud804\\ud805\\ud806\\ud807\\ud808\\ud809\\ud80a\\ud80b\\ud80c\\ud80d\\ud80e\\ud80f', 'High surrogates group 1 are correctly escaped');
assert.same(escape(highSurrogatesGroup2), '\\ud810\\ud811\\ud812\\ud813\\ud814\\ud815\\ud816\\ud817\\ud818\\ud819\\ud81a\\ud81b\\ud81c\\ud81d\\ud81e\\ud81f', 'High surrogates group 2 are correctly escaped');
assert.same(escape(highSurrogatesGroup3), '\\ud820\\ud821\\ud822\\ud823\\ud824\\ud825\\ud826\\ud827\\ud828\\ud829\\ud82a\\ud82b\\ud82c\\ud82d\\ud82e\\ud82f', 'High surrogates group 3 are correctly escaped');
assert.same(escape(highSurrogatesGroup4), '\\ud830\\ud831\\ud832\\ud833\\ud834\\ud835\\ud836\\ud837\\ud838\\ud839\\ud83a\\ud83b\\ud83c\\ud83d\\ud83e\\ud83f', 'High surrogates group 4 are correctly escaped');
assert.same(escape(highSurrogatesGroup5), '\\ud840\\ud841\\ud842\\ud843\\ud844\\ud845\\ud846\\ud847\\ud848\\ud849\\ud84a\\ud84b\\ud84c\\ud84d\\ud84e\\ud84f', 'High surrogates group 5 are correctly escaped');
assert.same(escape(highSurrogatesGroup6), '\\ud850\\ud851\\ud852\\ud853\\ud854\\ud855\\ud856\\ud857\\ud858\\ud859\\ud85a\\ud85b\\ud85c\\ud85d\\ud85e\\ud85f', 'High surrogates group 6 are correctly escaped');
assert.same(escape(highSurrogatesGroup7), '\\ud860\\ud861\\ud862\\ud863\\ud864\\ud865\\ud866\\ud867\\ud868\\ud869\\ud86a\\ud86b\\ud86c\\ud86d\\ud86e\\ud86f', 'High surrogates group 7 are correctly escaped');
assert.same(escape(highSurrogatesGroup8), '\\ud870\\ud871\\ud872\\ud873\\ud874\\ud875\\ud876\\ud877\\ud878\\ud879\\ud87a\\ud87b\\ud87c\\ud87d\\ud87e\\ud87f', 'High surrogates group 8 are correctly escaped');
assert.same(escape(highSurrogatesGroup9), '\\ud880\\ud881\\ud882\\ud883\\ud884\\ud885\\ud886\\ud887\\ud888\\ud889\\ud88a\\ud88b\\ud88c\\ud88d\\ud88e\\ud88f', 'High surrogates group 9 are correctly escaped');
assert.same(escape(highSurrogatesGroup10), '\\ud890\\ud891\\ud892\\ud893\\ud894\\ud895\\ud896\\ud897\\ud898\\ud899\\ud89a\\ud89b\\ud89c\\ud89d\\ud89e\\ud89f', 'High surrogates group 10 are correctly escaped');
assert.same(escape(highSurrogatesGroup11), '\\ud8a0\\ud8a1\\ud8a2\\ud8a3\\ud8a4\\ud8a5\\ud8a6\\ud8a7\\ud8a8\\ud8a9\\ud8aa\\ud8ab\\ud8ac\\ud8ad\\ud8ae\\ud8af', 'High surrogates group 11 are correctly escaped');
assert.same(escape(highSurrogatesGroup12), '\\ud8b0\\ud8b1\\ud8b2\\ud8b3\\ud8b4\\ud8b5\\ud8b6\\ud8b7\\ud8b8\\ud8b9\\ud8ba\\ud8bb\\ud8bc\\ud8bd\\ud8be\\ud8bf', 'High surrogates group 12 are correctly escaped');
assert.same(escape(highSurrogatesGroup13), '\\ud8c0\\ud8c1\\ud8c2\\ud8c3\\ud8c4\\ud8c5\\ud8c6\\ud8c7\\ud8c8\\ud8c9\\ud8ca\\ud8cb\\ud8cc\\ud8cd\\ud8ce\\ud8cf', 'High surrogates group 13 are correctly escaped');
assert.same(escape(highSurrogatesGroup14), '\\ud8d0\\ud8d1\\ud8d2\\ud8d3\\ud8d4\\ud8d5\\ud8d6\\ud8d7\\ud8d8\\ud8d9\\ud8da\\ud8db\\ud8dc\\ud8dd\\ud8de\\ud8df', 'High surrogates group 14 are correctly escaped');
assert.same(escape(highSurrogatesGroup15), '\\ud8e0\\ud8e1\\ud8e2\\ud8e3\\ud8e4\\ud8e5\\ud8e6\\ud8e7\\ud8e8\\ud8e9\\ud8ea\\ud8eb\\ud8ec\\ud8ed\\ud8ee\\ud8ef', 'High surrogates group 15 are correctly escaped');
assert.same(escape(highSurrogatesGroup16), '\\ud8f0\\ud8f1\\ud8f2\\ud8f3\\ud8f4\\ud8f5\\ud8f6\\ud8f7\\ud8f8\\ud8f9\\ud8fa\\ud8fb\\ud8fc\\ud8fd\\ud8fe\\ud8ff', 'High surrogates group 16 are correctly escaped');
// Trailing Surrogates
const lowSurrogatesGroup1 = '\uDC00\uDC01\uDC02\uDC03\uDC04\uDC05\uDC06\uDC07\uDC08\uDC09\uDC0A\uDC0B\uDC0C\uDC0D\uDC0E\uDC0F';
const lowSurrogatesGroup2 = '\uDC10\uDC11\uDC12\uDC13\uDC14\uDC15\uDC16\uDC17\uDC18\uDC19\uDC1A\uDC1B\uDC1C\uDC1D\uDC1E\uDC1F';
const lowSurrogatesGroup3 = '\uDC20\uDC21\uDC22\uDC23\uDC24\uDC25\uDC26\uDC27\uDC28\uDC29\uDC2A\uDC2B\uDC2C\uDC2D\uDC2E\uDC2F';
const lowSurrogatesGroup4 = '\uDC30\uDC31\uDC32\uDC33\uDC34\uDC35\uDC36\uDC37\uDC38\uDC39\uDC3A\uDC3B\uDC3C\uDC3D\uDC3E\uDC3F';
const lowSurrogatesGroup5 = '\uDC40\uDC41\uDC42\uDC43\uDC44\uDC45\uDC46\uDC47\uDC48\uDC49\uDC4A\uDC4B\uDC4C\uDC4D\uDC4E\uDC4F';
const lowSurrogatesGroup6 = '\uDC50\uDC51\uDC52\uDC53\uDC54\uDC55\uDC56\uDC57\uDC58\uDC59\uDC5A\uDC5B\uDC5C\uDC5D\uDC5E\uDC5F';
const lowSurrogatesGroup7 = '\uDC60\uDC61\uDC62\uDC63\uDC64\uDC65\uDC66\uDC67\uDC68\uDC69\uDC6A\uDC6B\uDC6C\uDC6D\uDC6E\uDC6F';
const lowSurrogatesGroup8 = '\uDC70\uDC71\uDC72\uDC73\uDC74\uDC75\uDC76\uDC77\uDC78\uDC79\uDC7A\uDC7B\uDC7C\uDC7D\uDC7E\uDC7F';
const lowSurrogatesGroup9 = '\uDC80\uDC81\uDC82\uDC83\uDC84\uDC85\uDC86\uDC87\uDC88\uDC89\uDC8A\uDC8B\uDC8C\uDC8D\uDC8E\uDC8F';
const lowSurrogatesGroup10 = '\uDC90\uDC91\uDC92\uDC93\uDC94\uDC95\uDC96\uDC97\uDC98\uDC99\uDC9A\uDC9B\uDC9C\uDC9D\uDC9E\uDC9F';
const lowSurrogatesGroup11 = '\uDCA0\uDCA1\uDCA2\uDCA3\uDCA4\uDCA5\uDCA6\uDCA7\uDCA8\uDCA9\uDCAA\uDCAB\uDCAC\uDCAD\uDCAE\uDCAF';
const lowSurrogatesGroup12 = '\uDCB0\uDCB1\uDCB2\uDCB3\uDCB4\uDCB5\uDCB6\uDCB7\uDCB8\uDCB9\uDCBA\uDCBB\uDCBC\uDCBD\uDCBE\uDCBF';
const lowSurrogatesGroup13 = '\uDCC0\uDCC1\uDCC2\uDCC3\uDCC4\uDCC5\uDCC6\uDCC7\uDCC8\uDCC9\uDCCA\uDCCB\uDCCC\uDCCD\uDCCE\uDCCF';
const lowSurrogatesGroup14 = '\uDCD0\uDCD1\uDCD2\uDCD3\uDCD4\uDCD5\uDCD6\uDCD7\uDCD8\uDCD9\uDCDA\uDCDB\uDCDC\uDCDD\uDCDE\uDCDF';
const lowSurrogatesGroup15 = '\uDCE0\uDCE1\uDCE2\uDCE3\uDCE4\uDCE5\uDCE6\uDCE7\uDCE8\uDCE9\uDCEA\uDCEB\uDCEC\uDCED\uDCEE\uDCEF';
const lowSurrogatesGroup16 = '\uDCF0\uDCF1\uDCF2\uDCF3\uDCF4\uDCF5\uDCF6\uDCF7\uDCF8\uDCF9\uDCFA\uDCFB\uDCFC\uDCFD\uDCFE\uDCFF';
assert.same(escape(lowSurrogatesGroup1), '\\udc00\\udc01\\udc02\\udc03\\udc04\\udc05\\udc06\\udc07\\udc08\\udc09\\udc0a\\udc0b\\udc0c\\udc0d\\udc0e\\udc0f', 'Low surrogates group 1 are correctly escaped');
assert.same(escape(lowSurrogatesGroup2), '\\udc10\\udc11\\udc12\\udc13\\udc14\\udc15\\udc16\\udc17\\udc18\\udc19\\udc1a\\udc1b\\udc1c\\udc1d\\udc1e\\udc1f', 'Low surrogates group 2 are correctly escaped');
assert.same(escape(lowSurrogatesGroup3), '\\udc20\\udc21\\udc22\\udc23\\udc24\\udc25\\udc26\\udc27\\udc28\\udc29\\udc2a\\udc2b\\udc2c\\udc2d\\udc2e\\udc2f', 'Low surrogates group 3 are correctly escaped');
assert.same(escape(lowSurrogatesGroup4), '\\udc30\\udc31\\udc32\\udc33\\udc34\\udc35\\udc36\\udc37\\udc38\\udc39\\udc3a\\udc3b\\udc3c\\udc3d\\udc3e\\udc3f', 'Low surrogates group 4 are correctly escaped');
assert.same(escape(lowSurrogatesGroup5), '\\udc40\\udc41\\udc42\\udc43\\udc44\\udc45\\udc46\\udc47\\udc48\\udc49\\udc4a\\udc4b\\udc4c\\udc4d\\udc4e\\udc4f', 'Low surrogates group 5 are correctly escaped');
assert.same(escape(lowSurrogatesGroup6), '\\udc50\\udc51\\udc52\\udc53\\udc54\\udc55\\udc56\\udc57\\udc58\\udc59\\udc5a\\udc5b\\udc5c\\udc5d\\udc5e\\udc5f', 'Low surrogates group 6 are correctly escaped');
assert.same(escape(lowSurrogatesGroup7), '\\udc60\\udc61\\udc62\\udc63\\udc64\\udc65\\udc66\\udc67\\udc68\\udc69\\udc6a\\udc6b\\udc6c\\udc6d\\udc6e\\udc6f', 'Low surrogates group 7 are correctly escaped');
assert.same(escape(lowSurrogatesGroup8), '\\udc70\\udc71\\udc72\\udc73\\udc74\\udc75\\udc76\\udc77\\udc78\\udc79\\udc7a\\udc7b\\udc7c\\udc7d\\udc7e\\udc7f', 'Low surrogates group 8 are correctly escaped');
assert.same(escape(lowSurrogatesGroup9), '\\udc80\\udc81\\udc82\\udc83\\udc84\\udc85\\udc86\\udc87\\udc88\\udc89\\udc8a\\udc8b\\udc8c\\udc8d\\udc8e\\udc8f', 'Low surrogates group 9 are correctly escaped');
assert.same(escape(lowSurrogatesGroup10), '\\udc90\\udc91\\udc92\\udc93\\udc94\\udc95\\udc96\\udc97\\udc98\\udc99\\udc9a\\udc9b\\udc9c\\udc9d\\udc9e\\udc9f', 'Low surrogates group 10 are correctly escaped');
assert.same(escape(lowSurrogatesGroup11), '\\udca0\\udca1\\udca2\\udca3\\udca4\\udca5\\udca6\\udca7\\udca8\\udca9\\udcaa\\udcab\\udcac\\udcad\\udcae\\udcaf', 'Low surrogates group 11 are correctly escaped');
assert.same(escape(lowSurrogatesGroup12), '\\udcb0\\udcb1\\udcb2\\udcb3\\udcb4\\udcb5\\udcb6\\udcb7\\udcb8\\udcb9\\udcba\\udcbb\\udcbc\\udcbd\\udcbe\\udcbf', 'Low surrogates group 12 are correctly escaped');
assert.same(escape(lowSurrogatesGroup13), '\\udcc0\\udcc1\\udcc2\\udcc3\\udcc4\\udcc5\\udcc6\\udcc7\\udcc8\\udcc9\\udcca\\udccb\\udccc\\udccd\\udcce\\udccf', 'Low surrogates group 13 are correctly escaped');
assert.same(escape(lowSurrogatesGroup14), '\\udcd0\\udcd1\\udcd2\\udcd3\\udcd4\\udcd5\\udcd6\\udcd7\\udcd8\\udcd9\\udcda\\udcdb\\udcdc\\udcdd\\udcde\\udcdf', 'Low surrogates group 14 are correctly escaped');
assert.same(escape(lowSurrogatesGroup15), '\\udce0\\udce1\\udce2\\udce3\\udce4\\udce5\\udce6\\udce7\\udce8\\udce9\\udcea\\udceb\\udcec\\udced\\udcee\\udcef', 'Low surrogates group 15 are correctly escaped');
assert.same(escape(lowSurrogatesGroup16), '\\udcf0\\udcf1\\udcf2\\udcf3\\udcf4\\udcf5\\udcf6\\udcf7\\udcf8\\udcf9\\udcfa\\udcfb\\udcfc\\udcfd\\udcfe\\udcff', 'Low surrogates group 16 are correctly escaped');
assert.same(escape('.a.b'), '\\.a\\.b', 'mixed string with dot character is escaped correctly');
assert.same(escape('.1+2'), '\\.1\\+2', 'mixed string with plus character is escaped correctly');
assert.same(escape('.a(b)c'), '\\.a\\(b\\)c', 'mixed string with parentheses is escaped correctly');
assert.same(escape('.a*b+c'), '\\.a\\*b\\+c', 'mixed string with asterisk and plus characters is escaped correctly');
assert.same(escape('.a?b^c'), '\\.a\\?b\\^c', 'mixed string with question mark and caret characters is escaped correctly');
assert.same(escape('.a{2}'), '\\.a\\{2\\}', 'mixed string with curly braces is escaped correctly');
assert.same(escape('.a|b'), '\\.a\\|b', 'mixed string with pipe character is escaped correctly');
assert.same(escape('.a\\b'), '\\.a\\\\b', 'mixed string with backslash is escaped correctly');
assert.same(escape('.a\\\\b'), '\\.a\\\\\\\\b', 'mixed string with backslash is escaped correctly');
assert.same(escape('.a^b'), '\\.a\\^b', 'mixed string with caret character is escaped correctly');
assert.same(escape('.a$b'), '\\.a\\$b', 'mixed string with dollar sign is escaped correctly');
assert.same(escape('.a[b]'), '\\.a\\[b\\]', 'mixed string with square brackets is escaped correctly');
assert.same(escape('.a.b(c)'), '\\.a\\.b\\(c\\)', 'mixed string with dot and parentheses is escaped correctly');
assert.same(escape('.a*b+c?d^e$f|g{2}h[i]j\\k'), '\\.a\\*b\\+c\\?d\\^e\\$f\\|g\\{2\\}h\\[i\\]j\\\\k', 'complex string with multiple special characters is escaped correctly');
assert.same(escape('^$\\.*+?()[]{}|'), '\\^\\$\\\\\\.\\*\\+\\?\\(\\)\\[\\]\\{\\}\\|', 'Syntax characters are correctly escaped');
assert.throws(() => escape(123), TypeError, 'non-string input (number) throws TypeError');
assert.throws(() => escape({}), TypeError, 'non-string input (object) throws TypeError');
assert.throws(() => escape([]), TypeError, 'non-string input (array) throws TypeError');
assert.throws(() => escape(null), TypeError, 'non-string input (null) throws TypeError');
assert.throws(() => escape(undefined), TypeError, 'non-string input (undefined) throws TypeError');
});
================================================
FILE: tests/unit-pure/es.set.difference.js
================================================
import { createIterable, createSetLike } from '../helpers/helpers.js';
import from from 'core-js-pure/es/array/from';
// TODO: use /es/ in core-js@4
import Set from 'core-js-pure/full/set';
QUnit.test('Set#difference', assert => {
const { difference } = Set.prototype;
assert.isFunction(difference);
assert.arity(difference, 1);
assert.name(difference, 'difference');
assert.nonEnumerable(Set.prototype, 'difference');
const set = new Set([1]);
assert.notSame(set.difference(new Set()), set);
assert.deepEqual(from(new Set([1, 2, 3]).difference(new Set([4, 5]))), [1, 2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).difference(new Set([3, 4]))), [1, 2]);
assert.deepEqual(from(new Set([1, 2, 3]).difference(createSetLike([4, 5]))), [1, 2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).difference(createSetLike([3, 4]))), [1, 2]);
// TODO: drop from core-js@4
assert.deepEqual(from(new Set([1, 2, 3]).difference([4, 5])), [1, 2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).difference([3, 4])), [1, 2]);
assert.deepEqual(from(new Set([1, 2, 3]).difference(createIterable([3, 4]))), [1, 2]);
assert.same(new Set([42, 43]).difference({
size: Infinity,
has() {
return true;
},
keys() {
throw new Error('Unexpected call to |keys| method');
},
}).size, 0);
assert.throws(() => new Set().difference({
size: -Infinity,
has() {
return true;
},
keys() {
throw new Error('Unexpected call to |keys| method');
},
}));
assert.throws(() => new Set([1, 2, 3]).difference(), TypeError);
assert.throws(() => difference.call({}, [1, 2, 3]), TypeError);
assert.throws(() => difference.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => difference.call(null, [1, 2, 3]), TypeError);
// A WebKit bug occurs when `this` is updated while Set.prototype.difference is being executed
// https://bugs.webkit.org/show_bug.cgi?id=288595
const values = [2];
const setLike = {
size: values.length,
has() { return true; },
keys() {
let index = 0;
return {
next() {
const done = index >= values.length;
if (baseSet.has(1)) baseSet.clear();
return { done, value: values[index++] };
},
};
},
};
const baseSet = new Set([1, 2, 3, 4]);
const result = baseSet.difference(setLike);
assert.deepEqual(from(result), [1, 3, 4], 'incorrect behavior when this updated while Set#difference is being executed');
// Mutation via has() in the size(O) <= otherRec.size branch should not skip elements
const mutatingSet = new Set([1, 2, 3]);
const mutatingResult = mutatingSet.difference({
size: 10,
has(v) {
if (v === 1) {
mutatingSet.delete(2);
return true;
}
return false;
},
keys() { return { next() { return { done: true }; } }; },
});
assert.deepEqual(from(mutatingResult), [2, 3], 'iterates copy, not live set in has() branch');
});
================================================
FILE: tests/unit-pure/es.set.intersection.js
================================================
import { createIterable, createSetLike } from '../helpers/helpers.js';
import from from 'core-js-pure/es/array/from';
// TODO: use /es/ in core-js@4
import Set from 'core-js-pure/full/set';
QUnit.test('Set#intersection', assert => {
const { intersection } = Set.prototype;
assert.isFunction(intersection);
assert.arity(intersection, 1);
assert.name(intersection, 'intersection');
assert.nonEnumerable(Set.prototype, 'intersection');
const set = new Set([1]);
assert.notSame(set.intersection(new Set()), set);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(new Set([4, 5]))), []);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(new Set([2, 3, 4]))), [2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(createSetLike([4, 5]))), []);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(createSetLike([2, 3, 4]))), [2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(new Set([3, 2]))), [3, 2]);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(new Set([3, 2, 1]))), [1, 2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(new Set([3, 2, 1, 0]))), [1, 2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(createSetLike([3, 2]))), [3, 2]);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(createSetLike([3, 2, 1]))), [1, 2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(createSetLike([3, 2, 1, 0]))), [1, 2, 3]);
// TODO: drop from core-js@4
assert.deepEqual(from(new Set([1, 2, 3]).intersection([4, 5])), []);
assert.deepEqual(from(new Set([1, 2, 3]).intersection([2, 3, 4])), [2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(createIterable([2, 3, 4]))), [2, 3]);
assert.deepEqual(from(new Set([42, 43]).intersection({
size: Infinity,
has() {
return true;
},
keys() {
throw new Error('Unexpected call to |keys| method');
},
})), [42, 43]);
assert.throws(() => new Set().intersection({
size: -Infinity,
has() {
return true;
},
keys() {
throw new Error('Unexpected call to |keys| method');
},
}));
const s1 = new Set([1, 2, 3]);
assert.deepEqual(from(s1.intersection({
size: 10,
has(v) { s1.delete(v + 1); return true; },
keys() { throw new Error('Unexpected call to |keys| method'); },
})), [1, 3], 'Set.prototype.intersection re-checks SetDataHas after has()');
assert.throws(() => new Set([1, 2, 3]).intersection(), TypeError);
assert.throws(() => intersection.call({}, [1, 2, 3]), TypeError);
assert.throws(() => intersection.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => intersection.call(null, [1, 2, 3]), TypeError);
});
================================================
FILE: tests/unit-pure/es.set.is-disjoint-from.js
================================================
import { createIterable, createSetLike } from '../helpers/helpers.js';
// TODO: use /es/ in core-js@4
import Set from 'core-js-pure/full/set';
QUnit.test('Set#isDisjointFrom', assert => {
const { isDisjointFrom } = Set.prototype;
assert.isFunction(isDisjointFrom);
assert.arity(isDisjointFrom, 1);
assert.name(isDisjointFrom, 'isDisjointFrom');
assert.nonEnumerable(Set.prototype, 'isDisjointFrom');
assert.true(new Set([1]).isDisjointFrom(new Set([2])));
assert.false(new Set([1]).isDisjointFrom(new Set([1])));
assert.true(new Set([1, 2, 3]).isDisjointFrom(new Set([4, 5, 6])));
assert.false(new Set([1, 2, 3]).isDisjointFrom(new Set([5, 4, 3])));
assert.true(new Set([1]).isDisjointFrom(createSetLike([2])));
assert.false(new Set([1]).isDisjointFrom(createSetLike([1])));
assert.true(new Set([1, 2, 3]).isDisjointFrom(createSetLike([4, 5, 6])));
assert.false(new Set([1, 2, 3]).isDisjointFrom(createSetLike([5, 4, 3])));
// TODO: drop from core-js@4
assert.true(new Set([1]).isDisjointFrom([2]));
assert.false(new Set([1]).isDisjointFrom([1]));
assert.true(new Set([1, 2, 3]).isDisjointFrom([4, 5, 6]));
assert.false(new Set([1, 2, 3]).isDisjointFrom([5, 4, 3]));
assert.true(new Set([1]).isDisjointFrom(createIterable([2])));
assert.false(new Set([1]).isDisjointFrom(createIterable([1])));
assert.false(new Set([42, 43]).isDisjointFrom({
size: Infinity,
has() {
return true;
},
keys() {
throw new Error('Unexpected call to |keys| method');
},
}));
assert.throws(() => new Set().isDisjointFrom({
size: -Infinity,
has() {
return true;
},
keys() {
throw new Error('Unexpected call to |keys| method');
},
}));
let closed = false;
assert.false(new Set([1, 2, 3, 4]).isDisjointFrom({
size: 3,
has() { return true; },
keys() {
let index = 0;
return {
next() {
return { value: [5, 1, 6][index++], done: index > 3 };
},
return() {
closed = true;
return { done: true };
},
};
},
}));
assert.true(closed, 'iterator is closed on early exit');
assert.throws(() => new Set([1, 2, 3]).isDisjointFrom(), TypeError);
assert.throws(() => isDisjointFrom.call({}, [1, 2, 3]), TypeError);
assert.throws(() => isDisjointFrom.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => isDisjointFrom.call(null, [1, 2, 3]), TypeError);
});
================================================
FILE: tests/unit-pure/es.set.is-subset-of.js
================================================
import { createIterable, createSetLike } from '../helpers/helpers.js';
// TODO: use /es/ in core-js@4
import Set from 'core-js-pure/full/set';
QUnit.test('Set#isSubsetOf', assert => {
const { isSubsetOf } = Set.prototype;
assert.isFunction(isSubsetOf);
assert.arity(isSubsetOf, 1);
assert.name(isSubsetOf, 'isSubsetOf');
assert.nonEnumerable(Set.prototype, 'isSubsetOf');
assert.true(new Set([1]).isSubsetOf(new Set([1, 2, 3])));
assert.false(new Set([1]).isSubsetOf(new Set([2, 3, 4])));
assert.true(new Set([1, 2, 3]).isSubsetOf(new Set([5, 4, 3, 2, 1])));
assert.false(new Set([1, 2, 3]).isSubsetOf(new Set([5, 4, 3, 2])));
assert.true(new Set([1]).isSubsetOf(createSetLike([1, 2, 3])));
assert.false(new Set([1]).isSubsetOf(createSetLike([2, 3, 4])));
assert.true(new Set([1, 2, 3]).isSubsetOf(createSetLike([5, 4, 3, 2, 1])));
assert.false(new Set([1, 2, 3]).isSubsetOf(createSetLike([5, 4, 3, 2])));
// TODO: drop from core-js@4
assert.true(new Set([1]).isSubsetOf([1, 2, 3]));
assert.false(new Set([1]).isSubsetOf([2, 3, 4]));
assert.true(new Set([1, 2, 3]).isSubsetOf([5, 4, 3, 2, 1]));
assert.false(new Set([1, 2, 3]).isSubsetOf([5, 4, 3, 2]));
assert.true(new Set([1]).isSubsetOf(createIterable([1, 2, 3])));
assert.false(new Set([1]).isSubsetOf(createIterable([2, 3, 4])));
assert.true(new Set([42, 43]).isSubsetOf({
size: Infinity,
has() {
return true;
},
keys() {
throw new Error('Unexpected call to |keys| method');
},
}));
assert.throws(() => new Set().isSubsetOf({
size: -Infinity,
has() {
return true;
},
keys() {
throw new Error('Unexpected call to |keys| method');
},
}));
assert.throws(() => new Set([1, 2, 3]).isSubsetOf(), TypeError);
assert.throws(() => isSubsetOf.call({}, [1, 2, 3]), TypeError);
assert.throws(() => isSubsetOf.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => isSubsetOf.call(null, [1, 2, 3]), TypeError);
});
================================================
FILE: tests/unit-pure/es.set.is-superset-of.js
================================================
import { createIterable, createSetLike } from '../helpers/helpers.js';
// TODO: use /es/ in core-js@4
import Set from 'core-js-pure/full/set';
QUnit.test('Set#isSupersetOf', assert => {
const { isSupersetOf } = Set.prototype;
assert.isFunction(isSupersetOf);
assert.arity(isSupersetOf, 1);
assert.name(isSupersetOf, 'isSupersetOf');
assert.nonEnumerable(Set.prototype, 'isSupersetOf');
assert.true(new Set([1, 2, 3]).isSupersetOf(new Set([1])));
assert.false(new Set([2, 3, 4]).isSupersetOf(new Set([1])));
assert.true(new Set([5, 4, 3, 2, 1]).isSupersetOf(new Set([1, 2, 3])));
assert.false(new Set([5, 4, 3, 2]).isSupersetOf(new Set([1, 2, 3])));
assert.true(new Set([1, 2, 3]).isSupersetOf(createSetLike([1])));
assert.false(new Set([2, 3, 4]).isSupersetOf(createSetLike([1])));
assert.true(new Set([5, 4, 3, 2, 1]).isSupersetOf(createSetLike([1, 2, 3])));
assert.false(new Set([5, 4, 3, 2]).isSupersetOf(createSetLike([1, 2, 3])));
// TODO: drop from core-js@4
assert.true(new Set([1, 2, 3]).isSupersetOf([1]));
assert.false(new Set([2, 3, 4]).isSupersetOf([1]));
assert.true(new Set([5, 4, 3, 2, 1]).isSupersetOf([1, 2, 3]));
assert.false(new Set([5, 4, 3, 2]).isSupersetOf([1, 2, 3]));
assert.true(new Set([1, 2, 3]).isSupersetOf(createIterable([1])));
assert.false(new Set([2, 3, 4]).isSupersetOf(createIterable([1])));
assert.false(new Set([42, 43]).isSupersetOf({
size: Infinity,
has() {
return true;
},
keys() {
throw new Error('Unexpected call to |keys| method');
},
}));
assert.throws(() => new Set().isSupersetOf({
size: -Infinity,
has() {
return true;
},
keys() {
throw new Error('Unexpected call to |keys| method');
},
}));
let closed = false;
assert.false(new Set([1, 2, 3, 4]).isSupersetOf({
size: 3,
has() { return true; },
keys() {
let index = 0;
return {
next() {
return { value: [1, 5, 3][index++], done: index > 3 };
},
return() {
closed = true;
return { done: true };
},
};
},
}));
assert.true(closed, 'iterator is closed on early exit');
assert.throws(() => new Set([1, 2, 3]).isSupersetOf(), TypeError);
assert.throws(() => isSupersetOf.call({}, [1, 2, 3]), TypeError);
assert.throws(() => isSupersetOf.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => isSupersetOf.call(null, [1, 2, 3]), TypeError);
});
================================================
FILE: tests/unit-pure/es.set.js
================================================
/* eslint-disable sonarjs/no-element-overwrite -- required for testing */
import { createIterable, is, nativeSubclass } from '../helpers/helpers.js';
import { DESCRIPTORS } from '../helpers/constants.js';
import getIterator from 'core-js-pure/es/get-iterator';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import from from 'core-js-pure/es/array/from';
import freeze from 'core-js-pure/es/object/freeze';
import getOwnPropertyDescriptor from 'core-js-pure/es/object/get-own-property-descriptor';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import keys from 'core-js-pure/es/object/keys';
import ownKeys from 'core-js-pure/es/reflect/own-keys';
import Symbol from 'core-js-pure/es/symbol';
import Map from 'core-js-pure/es/map';
import Set from 'core-js-pure/es/set';
QUnit.test('Set', assert => {
assert.isFunction(Set);
assert.true('add' in Set.prototype, 'add in Set.prototype');
assert.true('clear' in Set.prototype, 'clear in Set.prototype');
assert.true('delete' in Set.prototype, 'delete in Set.prototype');
assert.true('forEach' in Set.prototype, 'forEach in Set.prototype');
assert.true('has' in Set.prototype, 'has in Set.prototype');
assert.true(new Set() instanceof Set, 'new Set instanceof Set');
let set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
assert.same(set.size, 3);
const result = [];
set.forEach(val => {
result.push(val);
});
assert.deepEqual(result, [1, 2, 3]);
assert.same(new Set(createIterable([1, 2, 3])).size, 3, 'Init from iterable');
assert.same(new Set([freeze({}), 1]).size, 2, 'Support frozen objects');
assert.same(new Set([NaN, NaN, NaN]).size, 1);
assert.deepEqual(from(new Set([3, 4]).add(2).add(1)), [3, 4, 2, 1]);
let done = false;
const { add } = Set.prototype;
Set.prototype.add = function () {
throw new Error();
};
try {
new Set(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
Set.prototype.add = add;
assert.true(done, '.return #throw');
const array = [];
done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new Set(array);
assert.true(done);
const object = {};
new Set().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(Set);
assert.true(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.true(new Subclass() instanceof Set, 'correct subclassing with native classes #2');
assert.true(new Subclass().add(2).has(2), 'correct subclassing with native classes #3');
}
if (typeof ArrayBuffer == 'function') {
const buffer = new ArrayBuffer(8);
set = new Set([buffer]);
assert.true(set.has(buffer), 'works with ArrayBuffer keys');
}
});
QUnit.test('Set#add', assert => {
assert.isFunction(Set.prototype.add);
const array = [];
let set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(array);
assert.same(set.size, 5);
const chain = set.add(NaN);
assert.same(chain, set);
assert.same(set.size, 5);
set.add(2);
assert.same(set.size, 5);
set.add(array);
assert.same(set.size, 5);
set.add([]);
assert.same(set.size, 6);
set.add(4);
assert.same(set.size, 7);
const frozen = freeze({});
set = new Set();
set.add(frozen);
assert.true(set.has(frozen));
});
QUnit.test('Set#clear', assert => {
assert.isFunction(Set.prototype.clear);
let set = new Set();
set.clear();
assert.same(set.size, 0);
set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.clear();
assert.same(set.size, 0);
assert.false(set.has(1));
assert.false(set.has(2));
assert.false(set.has(3));
const frozen = freeze({});
set = new Set();
set.add(1);
set.add(frozen);
set.clear();
assert.same(set.size, 0, 'Support frozen objects');
assert.false(set.has(1));
assert.false(set.has(frozen));
});
QUnit.test('Set#delete', assert => {
assert.isFunction(Set.prototype.delete);
const array = [];
const set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(array);
assert.same(set.size, 5);
assert.true(set.delete(NaN));
assert.same(set.size, 4);
assert.false(set.delete(4));
assert.same(set.size, 4);
set.delete([]);
assert.same(set.size, 4);
set.delete(array);
assert.same(set.size, 3);
const frozen = freeze({});
set.add(frozen);
assert.same(set.size, 4);
set.delete(frozen);
assert.same(set.size, 3);
});
QUnit.test('Set#forEach', assert => {
assert.isFunction(Set.prototype.forEach);
let result = [];
let count = 0;
let set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.forEach(value => {
count++;
result.push(value);
});
assert.same(count, 3);
assert.deepEqual(result, [1, 2, 3]);
set = new Set();
set.add('0');
set.add('1');
set.add('2');
set.add('3');
result = '';
set.forEach(it => {
result += it;
if (it === '2') {
set.delete('2');
set.delete('3');
set.delete('1');
set.add('4');
}
});
assert.same(result, '0124');
set = new Set();
set.add('0');
result = '';
set.forEach(it => {
set.delete('0');
if (result !== '') throw new Error();
result += it;
});
assert.same(result, '0');
assert.throws(() => {
Set.prototype.forEach.call(new Map(), () => { /* empty */ });
}, 'non-generic');
});
QUnit.test('Set#has', assert => {
assert.isFunction(Set.prototype.has);
const array = [];
const frozen = freeze({});
const set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(frozen);
set.add(array);
assert.true(set.has(NaN));
assert.true(set.has(array));
assert.true(set.has(frozen));
assert.true(set.has(2));
assert.false(set.has(4));
assert.false(set.has([]));
});
QUnit.test('Set#size', assert => {
const set = new Set();
set.add(1);
const { size } = set;
assert.same(typeof size, 'number', 'size is number');
assert.same(size, 1, 'size is correct');
if (DESCRIPTORS) {
const sizeDescriptor = getOwnPropertyDescriptor(Set.prototype, 'size');
const getter = sizeDescriptor && sizeDescriptor.get;
const setter = sizeDescriptor && sizeDescriptor.set;
assert.same(typeof getter, 'function', 'size is getter');
assert.same(typeof setter, 'undefined', 'size is not setter');
assert.throws(() => {
Set.prototype.size;
}, TypeError);
}
});
QUnit.test('Set & -0', assert => {
let set = new Set();
set.add(-0);
assert.same(set.size, 1);
assert.true(set.has(0));
assert.true(set.has(-0));
set.forEach(it => {
assert.false(is(it, -0));
});
set.delete(-0);
assert.same(set.size, 0);
set = new Set([-0]);
set.forEach(key => {
assert.false(is(key, -0));
});
set = new Set();
set.add(4);
set.add(3);
set.add(2);
set.add(1);
set.add(0);
assert.true(set.has(-0));
});
QUnit.test('Set#@@toStringTag', assert => {
assert.same(Set.prototype[Symbol.toStringTag], 'Set', 'Set::@@toStringTag is `Set`');
assert.same(String(new Set()), '[object Set]', 'correct stringification');
});
QUnit.test('Set Iterator', assert => {
const set = new Set();
set.add('a');
set.add('b');
set.add('c');
set.add('d');
const results = [];
const iterator = set.keys();
results.push(iterator.next().value);
assert.true(set.delete('a'));
assert.true(set.delete('b'));
assert.true(set.delete('c'));
set.add('e');
results.push(iterator.next().value, iterator.next().value);
assert.true(iterator.next().done);
set.add('f');
assert.true(iterator.next().done);
assert.deepEqual(results, ['a', 'd', 'e']);
});
QUnit.test('Set#keys', assert => {
assert.isFunction(Set.prototype.keys);
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = set.keys();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Set Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Set#values', assert => {
assert.isFunction(Set.prototype.values);
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = set.values();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Set Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Set#entries', assert => {
assert.isFunction(Set.prototype.entries);
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = set.entries();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Set Iterator');
assert.deepEqual(iterator.next(), {
value: ['q', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['w', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['e', 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Set#@@iterator', assert => {
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = getIterator(set);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Set Iterator');
assert.same(String(iterator), '[object Set Iterator]');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
================================================
FILE: tests/unit-pure/es.set.symmetric-difference.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import { createIterable, createSetLike } from '../helpers/helpers.js';
import from from 'core-js-pure/es/array/from';
import defineProperty from 'core-js-pure/es/object/define-property';
// TODO: use /es/ in core-js@4
import Set from 'core-js-pure/full/set';
QUnit.test('Set#symmetricDifference', assert => {
const { symmetricDifference } = Set.prototype;
assert.isFunction(symmetricDifference);
assert.arity(symmetricDifference, 1);
assert.name(symmetricDifference, 'symmetricDifference');
assert.nonEnumerable(Set.prototype, 'symmetricDifference');
const set = new Set([1]);
assert.notSame(set.symmetricDifference(new Set()), set);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference(new Set([4, 5]))), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference(new Set([3, 4]))), [1, 2, 4]);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference(createSetLike([4, 5]))), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference(createSetLike([3, 4]))), [1, 2, 4]);
// TODO: drop from core-js@4
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference([4, 5])), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference([3, 4])), [1, 2, 4]);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference(createIterable([4, 5]))), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference(createIterable([3, 4]))), [1, 2, 4]);
assert.throws(() => new Set([1, 2, 3]).symmetricDifference(), TypeError);
assert.throws(() => symmetricDifference.call({}, [1, 2, 3]), TypeError);
assert.throws(() => symmetricDifference.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => symmetricDifference.call(null, [1, 2, 3]), TypeError);
// Duplicate keys in other's iterator: value present in O should be removed idempotently
{
const baseSet = new Set([1, 2, 3]);
const setLike = {
size: 2,
has() { return false; },
keys() {
const vals = [2, 2];
let i = 0;
return { next() { return i < vals.length ? { done: false, value: vals[i++] } : { done: true }; } };
},
};
assert.deepEqual(from(baseSet.symmetricDifference(setLike)), [1, 3]);
}
{
// https://github.com/WebKit/WebKit/pull/27264/files#diff-7bdbbad7ceaa222787994f2db702dd45403fa98e14d6270aa65aaf09754dcfe0R8
const baseSet = new Set(['a', 'b', 'c', 'd', 'e']);
const values = ['f', 'g', 'h', 'i', 'j'];
const setLike = {
size: values.length,
has() { return true; },
keys() {
let index = 0;
return {
next() {
const done = index >= values.length;
if (!baseSet.has('f')) baseSet.add('f');
return { done, value: values[index++] };
},
};
},
};
assert.deepEqual(from(baseSet.symmetricDifference(setLike)), ['a', 'b', 'c', 'd', 'e', 'g', 'h', 'i', 'j']);
}
if (DESCRIPTORS) {
// Should get iterator record of a set-like object before cloning this
// https://bugs.webkit.org/show_bug.cgi?id=289430
const baseSet = new Set();
const setLike = {
size: 0,
has() { return true; },
keys() {
return defineProperty({}, 'next', { get() {
baseSet.clear();
baseSet.add(4);
return function () {
return { done: true };
};
} });
},
};
assert.deepEqual(from(baseSet.symmetricDifference(setLike)), [4]);
}
});
================================================
FILE: tests/unit-pure/es.set.union.js
================================================
import { DESCRIPTORS } from '../helpers/constants.js';
import { createIterable, createSetLike } from '../helpers/helpers.js';
import from from 'core-js-pure/es/array/from';
import defineProperty from 'core-js-pure/es/object/define-property';
// TODO: use /es/ in core-js@4
import Set from 'core-js-pure/full/set';
QUnit.test('Set#union', assert => {
const { union } = Set.prototype;
assert.isFunction(union);
assert.arity(union, 1);
assert.name(union, 'union');
assert.nonEnumerable(Set.prototype, 'union');
const set = new Set([1]);
assert.notSame(set.union(new Set()), set);
assert.deepEqual(from(new Set([1, 2, 3]).union(new Set([4, 5]))), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).union(new Set([3, 4]))), [1, 2, 3, 4]);
assert.deepEqual(from(new Set([1, 2, 3]).union(createSetLike([4, 5]))), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).union(createSetLike([3, 4]))), [1, 2, 3, 4]);
// TODO: drop from core-js@4
assert.deepEqual(from(new Set([1, 2, 3]).union([4, 5])), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).union([3, 4])), [1, 2, 3, 4]);
assert.deepEqual(from(new Set([1, 2, 3]).union(createIterable([3, 4]))), [1, 2, 3, 4]);
assert.throws(() => new Set([1, 2, 3]).union(), TypeError);
assert.throws(() => union.call({}, [1, 2, 3]), TypeError);
assert.throws(() => union.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => union.call(null, [1, 2, 3]), TypeError);
if (DESCRIPTORS) {
// Should get iterator record of a set-like object before cloning this
// https://bugs.webkit.org/show_bug.cgi?id=289430
const baseSet = new Set();
const setLike = {
size: 0,
has() { return true; },
keys() {
return defineProperty({}, 'next', { get() {
baseSet.clear();
baseSet.add(4);
return function () {
return { done: true };
};
} });
},
};
assert.deepEqual(from(baseSet.union(setLike)), [4]);
}
});
================================================
FILE: tests/unit-pure/es.string.anchor.js
================================================
import anchor from 'core-js-pure/es/string/anchor';
QUnit.test('String#anchor', assert => {
assert.isFunction(anchor);
assert.same(anchor('a', 'b'), 'a', 'lower case');
assert.same(anchor('a', '"'), 'a', 'escape quotes');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
const symbol = Symbol('anchor test');
assert.throws(() => anchor(symbol, 'b'), 'throws on symbol context');
assert.throws(() => anchor('a', symbol), 'throws on symbol argument');
}
});
================================================
FILE: tests/unit-pure/es.string.at-alternative.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import at from 'core-js-pure/es/string/at';
QUnit.test('String#at', assert => {
assert.isFunction(at);
assert.same(at('123', 0), '1');
assert.same(at('123', 1), '2');
assert.same(at('123', 2), '3');
assert.same(at('123', 3), undefined);
assert.same(at('123', -1), '3');
assert.same(at('123', -2), '2');
assert.same(at('123', -3), '1');
assert.same(at('123', -4), undefined);
assert.same(at('123', 0.4), '1');
assert.same(at('123', 0.5), '1');
assert.same(at('123', 0.6), '1');
assert.same(at('1', NaN), '1');
assert.same(at('1'), '1');
assert.same(at('123', -0), '1');
// TODO: disabled by default because of the conflict with old proposal
// assert.same(at('𠮷'), '\uD842');
assert.same(at({ toString() { return '123'; } }, 0), '1');
assert.throws(() => at(Symbol('at-alternative test'), 0), 'throws on symbol context');
if (STRICT) {
assert.throws(() => at(null, 0), TypeError);
assert.throws(() => at(undefined, 0), TypeError);
}
});
================================================
FILE: tests/unit-pure/es.string.big.js
================================================
import big from 'core-js-pure/es/string/big';
QUnit.test('String#big', assert => {
assert.isFunction(big);
assert.same(big('a'), 'a', 'lower case');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => big(Symbol('big test')), 'throws on symbol context');
}
});
================================================
FILE: tests/unit-pure/es.string.blink.js
================================================
import blink from 'core-js-pure/es/string/blink';
QUnit.test('String#blink', assert => {
assert.isFunction(blink);
assert.same(blink('a'), '', 'lower case');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => blink(Symbol('blink test')), 'throws on symbol context');
}
});
================================================
FILE: tests/unit-pure/es.string.bold.js
================================================
import bold from 'core-js-pure/es/string/bold';
QUnit.test('String#bold', assert => {
assert.isFunction(bold);
assert.same(bold('a'), 'a', 'lower case');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => bold(Symbol('bold test')), 'throws on symbol context');
}
});
================================================
FILE: tests/unit-pure/es.string.code-point-at.js
================================================
import { STRICT } from '../helpers/constants.js';
import codePointAt from 'core-js-pure/es/string/code-point-at';
QUnit.test('String#codePointAt', assert => {
assert.isFunction(codePointAt);
assert.same(codePointAt('abc\uD834\uDF06def', ''), 0x61);
assert.same(codePointAt('abc\uD834\uDF06def', '_'), 0x61);
assert.same(codePointAt('abc\uD834\uDF06def'), 0x61);
assert.same(codePointAt('abc\uD834\uDF06def', -Infinity), undefined);
assert.same(codePointAt('abc\uD834\uDF06def', -1), undefined);
assert.same(codePointAt('abc\uD834\uDF06def', -0), 0x61);
assert.same(codePointAt('abc\uD834\uDF06def', 0), 0x61);
assert.same(codePointAt('abc\uD834\uDF06def', 3), 0x1D306);
assert.same(codePointAt('abc\uD834\uDF06def', 4), 0xDF06);
assert.same(codePointAt('abc\uD834\uDF06def', 5), 0x64);
assert.same(codePointAt('abc\uD834\uDF06def', 42), undefined);
assert.same(codePointAt('abc\uD834\uDF06def', Infinity), undefined);
assert.same(codePointAt('abc\uD834\uDF06def', -Infinity), undefined);
assert.same(codePointAt('abc\uD834\uDF06def', NaN), 0x61);
assert.same(codePointAt('abc\uD834\uDF06def', false), 0x61);
assert.same(codePointAt('abc\uD834\uDF06def', null), 0x61);
assert.same(codePointAt('abc\uD834\uDF06def', undefined), 0x61);
assert.same(codePointAt('\uD834\uDF06def', ''), 0x1D306);
assert.same(codePointAt('\uD834\uDF06def', '1'), 0xDF06);
assert.same(codePointAt('\uD834\uDF06def', '_'), 0x1D306);
assert.same(codePointAt('\uD834\uDF06def'), 0x1D306);
assert.same(codePointAt('\uD834\uDF06def', -1), undefined);
assert.same(codePointAt('\uD834\uDF06def', -0), 0x1D306);
assert.same(codePointAt('\uD834\uDF06def', 0), 0x1D306);
assert.same(codePointAt('\uD834\uDF06def', 1), 0xDF06);
assert.same(codePointAt('\uD834\uDF06def', 42), undefined);
assert.same(codePointAt('\uD834\uDF06def', false), 0x1D306);
assert.same(codePointAt('\uD834\uDF06def', null), 0x1D306);
assert.same(codePointAt('\uD834\uDF06def', undefined), 0x1D306);
assert.same(codePointAt('\uD834abc', ''), 0xD834);
assert.same(codePointAt('\uD834abc', '_'), 0xD834);
assert.same(codePointAt('\uD834abc'), 0xD834);
assert.same(codePointAt('\uD834abc', -1), undefined);
assert.same(codePointAt('\uD834abc', -0), 0xD834);
assert.same(codePointAt('\uD834abc', 0), 0xD834);
assert.same(codePointAt('\uD834abc', false), 0xD834);
assert.same(codePointAt('\uD834abc', NaN), 0xD834);
assert.same(codePointAt('\uD834abc', null), 0xD834);
assert.same(codePointAt('\uD834abc', undefined), 0xD834);
assert.same(codePointAt('\uDF06abc', ''), 0xDF06);
assert.same(codePointAt('\uDF06abc', '_'), 0xDF06);
assert.same(codePointAt('\uDF06abc'), 0xDF06);
assert.same(codePointAt('\uDF06abc', -1), undefined);
assert.same(codePointAt('\uDF06abc', -0), 0xDF06);
assert.same(codePointAt('\uDF06abc', 0), 0xDF06);
assert.same(codePointAt('\uDF06abc', false), 0xDF06);
assert.same(codePointAt('\uDF06abc', NaN), 0xDF06);
assert.same(codePointAt('\uDF06abc', null), 0xDF06);
assert.same(codePointAt('\uDF06abc', undefined), 0xDF06);
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => codePointAt(Symbol('codePointAt test'), 1), 'throws on symbol context');
}
if (STRICT) {
assert.throws(() => codePointAt(null, 0), TypeError);
assert.throws(() => codePointAt(undefined, 0), TypeError);
}
});
================================================
FILE: tests/unit-pure/es.string.ends-with.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import endsWith from 'core-js-pure/es/string/ends-with';
QUnit.test('String#endsWith', assert => {
assert.isFunction(endsWith);
assert.true(endsWith('undefined'));
assert.false(endsWith('undefined', null));
assert.true(endsWith('abc', ''));
assert.true(endsWith('abc', 'c'));
assert.true(endsWith('abc', 'bc'));
assert.false(endsWith('abc', 'ab'));
assert.true(endsWith('abc', '', NaN));
assert.false(endsWith('abc', 'c', -1));
assert.true(endsWith('abc', 'a', 1));
assert.true(endsWith('abc', 'c', Infinity));
assert.true(endsWith('abc', 'a', true));
assert.false(endsWith('abc', 'c', 'x'));
assert.false(endsWith('abc', 'a', 'x'));
if (!Symbol.sham) {
const symbol = Symbol('endsWith test');
assert.throws(() => endsWith(symbol, 'b'), 'throws on symbol context');
assert.throws(() => endsWith('a', symbol), 'throws on symbol argument');
}
if (STRICT) {
assert.throws(() => endsWith(null, '.'), TypeError);
assert.throws(() => endsWith(undefined, '.'), TypeError);
}
const regexp = /./;
assert.throws(() => endsWith('/./', regexp), TypeError);
regexp[Symbol.match] = false;
assert.notThrows(() => endsWith('/./', regexp));
const object = {};
assert.notThrows(() => endsWith('[object Object]', object));
object[Symbol.match] = true;
assert.throws(() => endsWith('[object Object]', object), TypeError);
// side-effect ordering: ToString(searchString) should happen before ToIntegerOrInfinity(endPosition)
const order = [];
endsWith(
'abc',
{ toString() { order.push('search'); return 'c'; } },
{ valueOf() { order.push('pos'); return 3; } },
);
assert.deepEqual(order, ['search', 'pos'], 'ToString(searchString) before ToIntegerOrInfinity(endPosition)');
});
================================================
FILE: tests/unit-pure/es.string.fixed.js
================================================
import fixed from 'core-js-pure/es/string/fixed';
QUnit.test('String#fixed', assert => {
assert.isFunction(fixed);
assert.same(fixed('a'), 'a', 'lower case');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => fixed(Symbol('fixed test')), 'throws on symbol context');
}
});
================================================
FILE: tests/unit-pure/es.string.fontcolor.js
================================================
import fontcolor from 'core-js-pure/es/string/fontcolor';
QUnit.test('String#fontcolor', assert => {
assert.isFunction(fontcolor);
assert.same(fontcolor('a', 'b'), 'a', 'lower case');
assert.same(fontcolor('a', '"'), 'a', 'escape quotes');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
const symbol = Symbol('fontcolor test');
assert.throws(() => fontcolor(symbol, 'b'), 'throws on symbol context');
assert.throws(() => fontcolor('a', symbol), 'throws on symbol argument');
}
});
================================================
FILE: tests/unit-pure/es.string.fontsize.js
================================================
import fontsize from 'core-js-pure/es/string/fontsize';
QUnit.test('String#fontsize', assert => {
assert.isFunction(fontsize);
assert.same(fontsize('a', 'b'), 'a', 'lower case');
assert.same(fontsize('a', '"'), 'a', 'escape quotes');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
const symbol = Symbol('fontsize test');
assert.throws(() => fontsize(symbol, 'b'), 'throws on symbol context');
assert.throws(() => fontsize('a', symbol), 'throws on symbol argument');
}
});
================================================
FILE: tests/unit-pure/es.string.from-code-point.js
================================================
/* eslint-disable prefer-spread -- required for testing */
import fromCodePoint from 'core-js-pure/es/string/from-code-point';
QUnit.test('String.fromCodePoint', assert => {
assert.isFunction(fromCodePoint);
assert.arity(fromCodePoint, 1);
if ('name' in fromCodePoint) {
assert.name(fromCodePoint, 'fromCodePoint');
}
assert.same(fromCodePoint(''), '\0');
assert.same(fromCodePoint(), '');
assert.same(fromCodePoint(-0), '\0');
assert.same(fromCodePoint(0), '\0');
assert.same(fromCodePoint(0x1D306), '\uD834\uDF06');
assert.same(fromCodePoint(0x1D306, 0x61, 0x1D307), '\uD834\uDF06a\uD834\uDF07');
assert.same(fromCodePoint(0x61, 0x62, 0x1D307), 'ab\uD834\uDF07');
assert.same(fromCodePoint(false), '\0');
assert.same(fromCodePoint(null), '\0');
assert.throws(() => fromCodePoint('_'), RangeError);
assert.throws(() => fromCodePoint('+Infinity'), RangeError);
assert.throws(() => fromCodePoint('-Infinity'), RangeError);
assert.throws(() => fromCodePoint(-1), RangeError);
assert.throws(() => fromCodePoint(0x10FFFF + 1), RangeError);
assert.throws(() => fromCodePoint(3.14), RangeError);
assert.throws(() => fromCodePoint(3e-2), RangeError);
assert.throws(() => fromCodePoint(-Infinity), RangeError);
assert.throws(() => fromCodePoint(Infinity), RangeError);
assert.throws(() => fromCodePoint(NaN), RangeError);
assert.throws(() => fromCodePoint(undefined), RangeError);
assert.throws(() => fromCodePoint({}), RangeError);
assert.throws(() => fromCodePoint(/./), RangeError);
let number = 0x60;
assert.same(fromCodePoint({
valueOf() {
return ++number;
},
}), 'a');
assert.same(number, 0x61);
// one code unit per symbol
let counter = 2 ** 15 * 3 / 2;
let result = [];
while (--counter >= 0) result.push(0);
// should not throw
fromCodePoint.apply(null, result);
counter = 2 ** 15 * 3 / 2;
result = [];
while (--counter >= 0) result.push(0xFFFF + 1);
// should not throw
fromCodePoint.apply(null, result);
});
================================================
FILE: tests/unit-pure/es.string.includes.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import includes from 'core-js-pure/es/string/includes';
QUnit.test('String#includes', assert => {
assert.isFunction(includes);
assert.false(includes('abc'));
assert.true(includes('aundefinedb'));
assert.true(includes('abcd', 'b', 1));
assert.false(includes('abcd', 'b', 2));
if (!Symbol.sham) {
const symbol = Symbol('includes test');
assert.throws(() => includes(symbol, 'b'), 'throws on symbol context');
assert.throws(() => includes('a', symbol), 'throws on symbol argument');
}
if (STRICT) {
assert.throws(() => includes(null, '.'), TypeError);
assert.throws(() => includes(undefined, '.'), TypeError);
}
const re = /./;
assert.throws(() => includes('/./', re), TypeError);
re[Symbol.match] = false;
assert.notThrows(() => includes('/./', re));
const O = {};
assert.notThrows(() => includes('[object Object]', O));
O[Symbol.match] = true;
assert.throws(() => includes('[object Object]', O), TypeError);
});
================================================
FILE: tests/unit-pure/es.string.is-well-formed.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import isWellFormed from 'core-js-pure/es/string/virtual/is-well-formed';
QUnit.test('String#isWellFormed', assert => {
assert.isFunction(isWellFormed);
assert.true(isWellFormed.call('a'), 'a');
assert.true(isWellFormed.call('abc'), 'abc');
assert.true(isWellFormed.call('💩'), '💩');
assert.true(isWellFormed.call('💩b'), '💩b');
assert.true(isWellFormed.call('a💩'), 'a💩');
assert.true(isWellFormed.call('a💩b'), 'a💩b');
assert.true(isWellFormed.call('💩a💩'), '💩a💩');
assert.true(!isWellFormed.call('\uD83D'), '\uD83D');
assert.true(!isWellFormed.call('\uDCA9'), '\uDCA9');
assert.true(!isWellFormed.call('\uDCA9\uD83D'), '\uDCA9\uD83D');
assert.true(!isWellFormed.call('a\uD83D'), 'a\uD83D');
assert.true(!isWellFormed.call('\uDCA9a'), '\uDCA9a');
assert.true(!isWellFormed.call('a\uD83Da'), 'a\uD83Da');
assert.true(!isWellFormed.call('a\uDCA9a'), 'a\uDCA9a');
assert.true(isWellFormed.call({
toString() {
return 'abc';
},
}), 'conversion #1');
assert.true(!isWellFormed.call({
toString() {
return '\uD83D';
},
}), 'conversion #2');
if (STRICT) {
assert.throws(() => isWellFormed.call(null), TypeError, 'coercible #1');
assert.throws(() => isWellFormed.call(undefined), TypeError, 'coercible #2');
}
assert.throws(() => isWellFormed.call(Symbol('isWellFormed test')), 'throws on symbol context');
});
================================================
FILE: tests/unit-pure/es.string.italics.js
================================================
import italics from 'core-js-pure/es/string/italics';
QUnit.test('String#italics', assert => {
assert.isFunction(italics);
assert.same(italics('a'), 'a', 'lower case');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => italics(Symbol('italics test')), 'throws on symbol context');
}
});
================================================
FILE: tests/unit-pure/es.string.iterator.js
================================================
import getIterator from 'core-js-pure/es/get-iterator';
// import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import Symbol from 'core-js-pure/es/symbol';
import from from 'core-js-pure/es/array/from';
QUnit.test('String#@@iterator', assert => {
let iterator = getIterator('qwe');
assert.isIterator(iterator);
assert.same(iterator[Symbol.toStringTag], 'String Iterator');
assert.same(String(iterator), '[object String Iterator]');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.same(from('𠮷𠮷𠮷').length, 3);
iterator = getIterator('𠮷𠮷𠮷');
assert.deepEqual(iterator.next(), {
value: '𠮷',
done: false,
});
assert.deepEqual(iterator.next(), {
value: '𠮷',
done: false,
});
assert.deepEqual(iterator.next(), {
value: '𠮷',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
// early FF case with native method, but polyfilled `Symbol`
// assert.throws(() => getIteratorMethod('').call(Symbol()), 'throws on symbol context');
});
================================================
FILE: tests/unit-pure/es.string.link.js
================================================
import link from 'core-js-pure/es/string/link';
QUnit.test('String#link', assert => {
assert.isFunction(link);
assert.same(link('a', 'b'), 'a', 'lower case');
assert.same(link('a', '"'), 'a', 'escape quotes');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
const symbol = Symbol('link test');
assert.throws(() => link(symbol, 'b'), 'throws on symbol context');
assert.throws(() => link('a', symbol), 'throws on symbol argument');
}
});
================================================
FILE: tests/unit-pure/es.string.match-all.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import assign from 'core-js-pure/es/object/assign';
import matchAll from 'core-js-pure/es/string/match-all';
QUnit.test('String#matchAll', assert => {
assert.isFunction(matchAll);
let data = ['aabc', { toString() {
return 'aabc';
} }];
for (const target of data) {
const iterator = matchAll(target, /[ac]/g);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: assign(['a'], {
input: 'aabc',
index: 0,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['a'], {
input: 'aabc',
index: 1,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['c'], {
input: 'aabc',
index: 3,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
}
let iterator = matchAll('1111a2b3cccc', /(\d)(\D)/g);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'RegExp String Iterator');
assert.same(String(iterator), '[object RegExp String Iterator]');
assert.deepEqual(iterator.next(), {
value: assign(['1a', '1', 'a'], {
input: '1111a2b3cccc',
index: 3,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['2b', '2', 'b'], {
input: '1111a2b3cccc',
index: 5,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['3c', '3', 'c'], {
input: '1111a2b3cccc',
index: 7,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.throws(() => matchAll('1111a2b3cccc', /(\d)(\D)/), TypeError);
iterator = matchAll('1111a2b3cccc', '(\\d)(\\D)');
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: assign(['1a', '1', 'a'], {
input: '1111a2b3cccc',
index: 3,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['2b', '2', 'b'], {
input: '1111a2b3cccc',
index: 5,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['3c', '3', 'c'], {
input: '1111a2b3cccc',
index: 7,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
/* IE8- issue
iterator = matchAll('abc', /\B/g);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: assign([''], {
input: 'abc',
index: 1,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign([''], {
input: 'abc',
index: 2,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
*/
data = [null, undefined, NaN, 42, {}, []];
for (const target of data) {
assert.notThrows(() => matchAll('', target), `Not throws on ${ target } as the first argument`);
}
assert.throws(() => matchAll(Symbol('matchAll test'), /./), 'throws on symbol context');
if (!Symbol.sham) {
assert.throws(() => matchAll('a', Symbol('matchAll test')), 'throws on symbol argument');
}
if (STRICT) {
assert.throws(() => matchAll(null, /./g), TypeError, 'Throws on null as `this`');
assert.throws(() => matchAll(undefined, /./g), TypeError, 'Throws on undefined as `this`');
}
});
================================================
FILE: tests/unit-pure/es.string.pad-end.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import padEnd from 'core-js-pure/es/string/pad-end';
QUnit.test('String#padEnd', assert => {
assert.isFunction(padEnd);
assert.same(padEnd('abc', 5), 'abc ');
assert.same(padEnd('abc', 4, 'de'), 'abcd');
assert.same(padEnd('abc'), 'abc');
assert.same(padEnd('abc', 5, '_'), 'abc__');
assert.same(padEnd('', 0), '');
assert.same(padEnd('foo', 1), 'foo');
assert.same(padEnd('foo', 5, ''), 'foo');
const thrower = { toString() { throw new Error('oops'); } };
assert.throws(() => padEnd('a', 10, thrower), 'throws on thrower argument conversion');
assert.same(padEnd('abc', 2, thrower), 'abc', 'does not throw on thrower argument when no padding needed');
const symbol = Symbol('padEnd test');
assert.throws(() => padEnd(symbol, 10, 'a'), 'throws on symbol context');
assert.throws(() => padEnd('a', 10, symbol), 'throws on symbol argument');
assert.same(padEnd('abc', 2, symbol), 'abc', 'does not throw on symbol fillString when no padding needed');
if (STRICT) {
assert.throws(() => padEnd(null, 0), TypeError);
assert.throws(() => padEnd(undefined, 0), TypeError);
}
});
================================================
FILE: tests/unit-pure/es.string.pad-start.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import padStart from 'core-js-pure/es/string/pad-start';
QUnit.test('String#padStart', assert => {
assert.isFunction(padStart);
assert.same(padStart('abc', 5), ' abc');
assert.same(padStart('abc', 4, 'de'), 'dabc');
assert.same(padStart('abc'), 'abc');
assert.same(padStart('abc', 5, '_'), '__abc');
assert.same(padStart('', 0), '');
assert.same(padStart('foo', 1), 'foo');
assert.same(padStart('foo', 5, ''), 'foo');
const thrower = { toString() { throw new Error('oops'); } };
assert.throws(() => padStart('a', 10, thrower), 'throws on thrower argument conversion');
assert.same(padStart('abc', 2, thrower), 'abc', 'does not throw on thrower argument when no padding needed');
const symbol = Symbol('padStart test');
assert.throws(() => padStart(symbol, 10, 'a'), 'throws on symbol context');
assert.throws(() => padStart('a', 10, symbol), 'throws on symbol argument');
assert.same(padStart('abc', 2, symbol), 'abc', 'does not throw on symbol fillString when no padding needed');
if (STRICT) {
assert.throws(() => padStart(null, 0), TypeError);
assert.throws(() => padStart(undefined, 0), TypeError);
}
});
================================================
FILE: tests/unit-pure/es.string.raw.js
================================================
import raw from 'core-js-pure/es/string/raw';
QUnit.test('String.raw', assert => {
assert.isFunction(raw);
assert.arity(raw, 1);
if ('name' in raw) {
assert.name(raw, 'raw');
}
assert.same(raw({ raw: ['Hi\\n', '!'] }, 'Bob'), 'Hi\\nBob!', 'raw is array');
assert.same(raw({ raw: 'test' }, 0, 1, 2), 't0e1s2t', 'raw is string');
assert.same(raw({ raw: 'test' }, 0), 't0est', 'lacks substituting');
assert.same(raw({ raw: [] }), '', 'empty template');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
const symbol = Symbol('raw test');
assert.throws(() => raw({ raw: [symbol] }, 0), TypeError, 'throws on symbol #1');
assert.throws(() => raw({ raw: 'test' }, symbol), TypeError, 'throws on symbol #2');
}
assert.throws(() => raw({}), TypeError);
assert.throws(() => raw({ raw: null }), TypeError);
});
================================================
FILE: tests/unit-pure/es.string.repeat.js
================================================
import { STRICT } from '../helpers/constants.js';
import repeat from 'core-js-pure/es/string/repeat';
QUnit.test('String#repeat', assert => {
assert.isFunction(repeat);
assert.same(repeat('qwe', 3), 'qweqweqwe');
assert.same(repeat('qwe', 2.5), 'qweqwe');
assert.throws(() => repeat('qwe', -1), RangeError);
assert.throws(() => repeat('qwe', Infinity), RangeError);
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => repeat(Symbol('repeat test')), 'throws on symbol context');
}
if (STRICT) {
assert.throws(() => repeat(null, 1), TypeError);
assert.throws(() => repeat(undefined, 1), TypeError);
}
});
================================================
FILE: tests/unit-pure/es.string.replace-all.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import replaceAll from 'core-js-pure/es/string/replace-all';
QUnit.test('String#replaceAll', assert => {
assert.isFunction(replaceAll);
assert.same(replaceAll('q=query+string+parameters', '+', ' '), 'q=query string parameters');
assert.same(replaceAll('foo', 'o', {}), 'f[object Object][object Object]');
assert.same(replaceAll('[object Object]x[object Object]', {}, 'y'), 'yxy');
assert.same(replaceAll({}, 'bject', 'lolo'), '[ololo Ololo]');
assert.same(replaceAll('aba', 'b', (search, i, string) => {
assert.same(search, 'b', '`search` is `b`');
assert.same(i, 1, '`i` is 1');
assert.same(string, 'aba', '`string` is `aba`');
return 'c';
}), 'aca');
const searcher = {
[Symbol.replace](O, replaceValue) {
assert.same(this, searcher, '`this` is `searcher`');
assert.same(String(O), 'aba', '`O` is `aba`');
assert.same(String(replaceValue), 'c', '`replaceValue` is `c`');
return 'foo';
},
};
assert.same(replaceAll('aba', searcher, 'c'), 'foo');
assert.same(replaceAll('aba', 'b'), 'aundefineda');
assert.same(replaceAll('xxx', '', '_'), '_x_x_x_');
assert.same(replaceAll('121314', '1', '$$'), '$2$3$4', '$$');
assert.same(replaceAll('121314', '1', '$&'), '121314', '$&');
assert.same(replaceAll('121314', '1', '$`'), '212312134', '$`');
assert.same(replaceAll('121314', '1', "$'"), '213142314344', "$'");
const symbol = Symbol('replaceAll test');
assert.throws(() => replaceAll(symbol, 'a', 'b'), 'throws on symbol context');
assert.throws(() => replaceAll('a', symbol, 'b'), 'throws on symbol argument 1');
assert.throws(() => replaceAll('a', 'b', symbol), 'throws on symbol argument 2');
if (STRICT) {
assert.throws(() => replaceAll(null, 'a', 'b'), TypeError);
assert.throws(() => replaceAll(undefined, 'a', 'b'), TypeError);
}
assert.throws(() => replaceAll('b.b.b.b.b', /\./, 'a'), TypeError);
assert.same(replaceAll('b.b.b.b.b', /\./g, 'a'), 'babababab');
const object = {};
assert.same(replaceAll('[object Object]', object, 'a'), 'a');
});
================================================
FILE: tests/unit-pure/es.string.small.js
================================================
import small from 'core-js-pure/es/string/small';
QUnit.test('String#small', assert => {
assert.isFunction(small);
assert.same(small('a'), 'a', 'lower case');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => small(Symbol('small test')), 'throws on symbol context');
}
});
================================================
FILE: tests/unit-pure/es.string.starts-with.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import startsWith from 'core-js-pure/es/string/starts-with';
QUnit.test('String#startsWith', assert => {
assert.isFunction(startsWith);
assert.true(startsWith('undefined'));
assert.false(startsWith('undefined', null));
assert.true(startsWith('abc', ''));
assert.true(startsWith('abc', 'a'));
assert.true(startsWith('abc', 'ab'));
assert.false(startsWith('abc', 'bc'));
assert.true(startsWith('abc', '', NaN));
assert.true(startsWith('abc', 'a', -1));
assert.false(startsWith('abc', 'a', 1));
assert.false(startsWith('abc', 'a', Infinity));
assert.true(startsWith('abc', 'b', true));
assert.true(startsWith('abc', 'a', 'x'));
if (!Symbol.sham) {
const symbol = Symbol('startsWith test');
assert.throws(() => startsWith(symbol, 'b'), 'throws on symbol context');
assert.throws(() => startsWith('a', symbol), 'throws on symbol argument');
}
if (STRICT) {
assert.throws(() => startsWith(null, '.'), TypeError);
assert.throws(() => startsWith(undefined, '.'), TypeError);
}
const regexp = /./;
assert.throws(() => startsWith('/./', regexp), TypeError);
regexp[Symbol.match] = false;
assert.notThrows(() => startsWith('/./', regexp));
const object = {};
assert.notThrows(() => startsWith('[object Object]', object));
object[Symbol.match] = true;
assert.throws(() => startsWith('[object Object]', object), TypeError);
// side-effect ordering: ToString(searchString) should happen before ToIntegerOrInfinity(position)
const order = [];
startsWith(
'abc',
{ toString() { order.push('search'); return 'a'; } },
{ valueOf() { order.push('pos'); return 0; } },
);
assert.deepEqual(order, ['search', 'pos'], 'ToString(searchString) before ToIntegerOrInfinity(position)');
});
================================================
FILE: tests/unit-pure/es.string.strike.js
================================================
import strike from 'core-js-pure/es/string/strike';
QUnit.test('String#strike', assert => {
assert.isFunction(strike);
assert.same(strike('a'), 'a', 'lower case');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => strike(Symbol('strike test')), 'throws on symbol context');
}
});
================================================
FILE: tests/unit-pure/es.string.sub.js
================================================
import sub from 'core-js-pure/es/string/sub';
QUnit.test('String#sub', assert => {
assert.isFunction(sub);
assert.same(sub('a'), 'a', 'lower case');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => sub(Symbol('sub test')), 'throws on symbol context');
}
});
================================================
FILE: tests/unit-pure/es.string.substr.js
================================================
import substr from 'core-js-pure/es/string/substr';
import { STRICT } from '../helpers/constants.js';
QUnit.test('String#substr', assert => {
assert.isFunction(substr);
assert.same(substr('12345', 1, 3), '234');
assert.same(substr('ab', -1), 'b');
assert.same(substr('hello', Infinity), '', 'Infinity start returns empty string');
assert.same(substr('hello', 1, Infinity), 'ello', 'Infinity length returns rest of string');
assert.same(substr('hello', -Infinity), 'hello', '-Infinity start treated as 0');
assert.same(substr('hello', 0, -1), '', 'negative length returns empty string');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => substr(Symbol('substr test'), 1, 3), 'throws on symbol context');
}
if (STRICT) {
assert.throws(() => substr(null, 1, 3), TypeError, 'Throws on null as `this`');
assert.throws(() => substr(undefined, 1, 3), TypeError, 'Throws on undefined as `this`');
}
});
================================================
FILE: tests/unit-pure/es.string.sup.js
================================================
import sup from 'core-js-pure/es/string/sup';
QUnit.test('String#sup', assert => {
assert.isFunction(sup);
assert.same(sup('a'), 'a', 'lower case');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => sup(Symbol('sup test')), 'throws on symbol context');
}
});
================================================
FILE: tests/unit-pure/es.string.to-well-formed.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import toWellFormed from 'core-js-pure/es/string/virtual/to-well-formed';
QUnit.test('String#toWellFormed', assert => {
assert.isFunction(toWellFormed);
assert.same(toWellFormed.call('a'), 'a', 'a');
assert.same(toWellFormed.call('abc'), 'abc', 'abc');
assert.same(toWellFormed.call('💩'), '💩', '💩');
assert.same(toWellFormed.call('💩b'), '💩b', '💩b');
assert.same(toWellFormed.call('a💩'), 'a💩', 'a💩');
assert.same(toWellFormed.call('a💩b'), 'a💩b', 'a💩b');
assert.same(toWellFormed.call('💩a💩'), '💩a💩');
assert.same(toWellFormed.call('\uD83D'), '\uFFFD', '\uD83D');
assert.same(toWellFormed.call('\uDCA9'), '\uFFFD', '\uDCA9');
assert.same(toWellFormed.call('\uDCA9\uD83D'), '\uFFFD\uFFFD', '\uDCA9\uD83D');
assert.same(toWellFormed.call('a\uD83D'), 'a\uFFFD', 'a\uD83D');
assert.same(toWellFormed.call('\uDCA9a'), '\uFFFDa', '\uDCA9a');
assert.same(toWellFormed.call('a\uD83Da'), 'a\uFFFDa', 'a\uD83Da');
assert.same(toWellFormed.call('a\uDCA9a'), 'a\uFFFDa', 'a\uDCA9a');
assert.same(toWellFormed.call({
toString() {
return 'abc';
},
}), 'abc', 'conversion #1');
assert.same(toWellFormed.call(1), '1', 'conversion #2');
if (STRICT) {
assert.throws(() => toWellFormed.call(null), TypeError, 'coercible #1');
assert.throws(() => toWellFormed.call(undefined), TypeError, 'coercible #2');
}
assert.throws(() => toWellFormed.call(Symbol('toWellFormed test')), 'throws on symbol context');
});
================================================
FILE: tests/unit-pure/es.string.trim-end.js
================================================
import { STRICT, WHITESPACES } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import trimEnd from 'core-js-pure/es/string/trim-end';
QUnit.test('String#trimEnd', assert => {
assert.isFunction(trimEnd);
assert.same(trimEnd(' \n q w e \n '), ' \n q w e', 'removes whitespaces at right side of string');
assert.same(trimEnd(WHITESPACES), '', 'removes all whitespaces');
assert.same(trimEnd('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
assert.throws(() => trimEnd(Symbol('trimEnd test')), 'throws on symbol context');
if (STRICT) {
assert.throws(() => trimEnd(null, 0), TypeError);
assert.throws(() => trimEnd(undefined, 0), TypeError);
}
});
================================================
FILE: tests/unit-pure/es.string.trim-left.js
================================================
import { STRICT, WHITESPACES } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import trimLeft from 'core-js-pure/es/string/trim-left';
QUnit.test('String#trimLeft', assert => {
assert.isFunction(trimLeft);
assert.same(trimLeft(' \n q w e \n '), 'q w e \n ', 'removes whitespaces at left side of string');
assert.same(trimLeft(WHITESPACES), '', 'removes all whitespaces');
assert.same(trimLeft('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
assert.throws(() => trimLeft(Symbol('trimLeft test')), 'throws on symbol context');
if (STRICT) {
assert.throws(() => trimLeft(null, 0), TypeError);
assert.throws(() => trimLeft(undefined, 0), TypeError);
}
});
================================================
FILE: tests/unit-pure/es.string.trim-right.js
================================================
import { STRICT, WHITESPACES } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import trimRight from 'core-js-pure/es/string/trim-right';
QUnit.test('String#trimRight', assert => {
assert.isFunction(trimRight);
assert.same(trimRight(' \n q w e \n '), ' \n q w e', 'removes whitespaces at right side of string');
assert.same(trimRight(WHITESPACES), '', 'removes all whitespaces');
assert.same(trimRight('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
assert.throws(() => trimRight(Symbol('trimRight test')), 'throws on symbol context');
if (STRICT) {
assert.throws(() => trimRight(null, 0), TypeError);
assert.throws(() => trimRight(undefined, 0), TypeError);
}
});
================================================
FILE: tests/unit-pure/es.string.trim-start.js
================================================
import { STRICT, WHITESPACES } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import trimStart from 'core-js-pure/es/string/trim-start';
QUnit.test('String#trimStart', assert => {
assert.isFunction(trimStart);
assert.same(trimStart(' \n q w e \n '), 'q w e \n ', 'removes whitespaces at left side of string');
assert.same(trimStart(WHITESPACES), '', 'removes all whitespaces');
assert.same(trimStart('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
assert.throws(() => trimStart(Symbol('trimStart test')), 'throws on symbol context');
if (STRICT) {
assert.throws(() => trimStart(null, 0), TypeError);
assert.throws(() => trimStart(undefined, 0), TypeError);
}
});
================================================
FILE: tests/unit-pure/es.string.trim.js
================================================
import { STRICT, WHITESPACES } from '../helpers/constants.js';
import trim from 'core-js-pure/es/string/trim';
QUnit.test('String#trim', assert => {
assert.isFunction(trim);
assert.same(trim(' \n q w e \n '), 'q w e', 'removes whitespaces at left & right side of string');
assert.same(trim(WHITESPACES), '', 'removes all whitespaces');
assert.same(trim('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => trim(Symbol('trim test')), 'throws on symbol context');
}
if (STRICT) {
assert.throws(() => trim(null, 0), TypeError);
assert.throws(() => trim(undefined, 0), TypeError);
}
});
================================================
FILE: tests/unit-pure/es.suppressed-error.constructor.js
================================================
/* eslint-disable unicorn/throw-new-error, sonarjs/inconsistent-function-call -- testing */
import SuppressedError from 'core-js-pure/es/suppressed-error';
import Symbol from 'core-js-pure/es/symbol';
import toString from 'core-js-pure/es/object/to-string';
QUnit.test('SuppressedError', assert => {
assert.isFunction(SuppressedError);
assert.arity(SuppressedError, 3);
assert.name(SuppressedError, 'SuppressedError');
assert.true(new SuppressedError() instanceof SuppressedError);
assert.true(new SuppressedError() instanceof Error);
assert.true(SuppressedError() instanceof SuppressedError);
assert.true(SuppressedError() instanceof Error);
assert.same(SuppressedError().error, undefined);
assert.same(SuppressedError().suppressed, undefined);
assert.same(SuppressedError().message, '');
assert.same(SuppressedError().cause, undefined);
assert.false('cause' in SuppressedError());
assert.same(SuppressedError().name, 'SuppressedError');
assert.same(new SuppressedError().error, undefined);
assert.same(new SuppressedError().suppressed, undefined);
assert.same(new SuppressedError().message, '');
assert.same(new SuppressedError().cause, undefined);
assert.false('cause' in new SuppressedError());
assert.same(new SuppressedError().name, 'SuppressedError');
const error1 = SuppressedError(1, 2, 3, { cause: 4 });
assert.same(error1.error, 1);
assert.same(error1.suppressed, 2);
assert.same(error1.message, '3');
assert.same(error1.cause, undefined);
assert.false('cause' in error1);
assert.same(error1.name, 'SuppressedError');
const error2 = new SuppressedError(1, 2, 3, { cause: 4 });
assert.same(error2.error, 1);
assert.same(error2.suppressed, 2);
assert.same(error2.message, '3');
assert.same(error2.cause, undefined);
assert.false('cause' in error2);
assert.same(error2.name, 'SuppressedError');
assert.throws(() => SuppressedError(1, 2, Symbol('SuppressedError constructor test')), 'throws on symbol as a message');
assert.same(toString(SuppressedError()), '[object Error]', 'Object#toString');
// eslint-disable-next-line no-prototype-builtins -- safe
assert.false(SuppressedError.prototype.hasOwnProperty('cause'), 'prototype has not cause');
});
================================================
FILE: tests/unit-pure/es.symbol.async-dispose.js
================================================
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol.asyncDispose', assert => {
assert.true('asyncDispose' in Symbol, 'Symbol.asyncDispose available');
assert.true(Object(Symbol.asyncDispose) instanceof Symbol, 'Symbol.asyncDispose is symbol');
});
================================================
FILE: tests/unit-pure/es.symbol.async-iterator.js
================================================
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol.asyncIterator', assert => {
assert.true('asyncIterator' in Symbol, 'Symbol.asyncIterator available');
assert.true(Object(Symbol.asyncIterator) instanceof Symbol, 'Symbol.asyncIterator is symbol');
});
================================================
FILE: tests/unit-pure/es.symbol.constructor.js
================================================
import { DESCRIPTORS, GLOBAL } from '../helpers/constants.js';
import create from 'core-js-pure/es/object/create';
import defineProperty from 'core-js-pure/es/object/define-property';
import defineProperties from 'core-js-pure/es/object/define-properties';
import getOwnPropertyDescriptor from 'core-js-pure/es/object/get-own-property-descriptor';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import keys from 'core-js-pure/es/object/keys';
import ownKeys from 'core-js-pure/es/reflect/own-keys';
import Map from 'core-js-pure/es/map';
import Set from 'core-js-pure/es/set';
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol', assert => {
assert.isFunction(Symbol);
const symbol1 = Symbol('symbol');
const symbol2 = Symbol('symbol');
assert.notSame(symbol1, symbol2, 'Symbol("symbol") !== Symbol("symbol")');
const object = {};
object[symbol1] = 42;
assert.same(object[symbol1], 42, 'Symbol() work as key');
assert.notSame(object[symbol2], 42, 'Various symbols from one description are various keys');
// assert.throws(() => Symbol(Symbol('foo')), 'throws on symbol argument');
if (DESCRIPTORS) {
let count = 0;
// eslint-disable-next-line no-unused-vars -- required for testing
for (const key in object) count++;
assert.same(count, 0, 'object[Symbol()] is not enumerable');
}
});
QUnit.test('Symbol as global key', assert => {
const TEXT = 'test global symbol key';
const symbol = Symbol(TEXT);
GLOBAL[symbol] = TEXT;
assert.same(GLOBAL[symbol], TEXT, TEXT);
});
QUnit.test('Well-known Symbols', assert => {
const wks = [
'hasInstance',
'isConcatSpreadable',
'iterator',
'match',
'matchAll',
'replace',
'search',
'species',
'split',
'toPrimitive',
'toStringTag',
'unscopables',
];
for (const name of wks) {
assert.true(name in Symbol, `Symbol.${ name } available`);
assert.true(Object(Symbol[name]) instanceof Symbol, `Symbol.${ name } is symbol`);
}
});
QUnit.test('Symbol#@@toPrimitive', assert => {
const symbol = Symbol('Symbol#@@toPrimitive test');
assert.isFunction(Symbol.prototype[Symbol.toPrimitive]);
assert.same(symbol, symbol[Symbol.toPrimitive](), 'works');
});
QUnit.test('Symbol#@@toStringTag', assert => {
assert.same(Symbol.prototype[Symbol.toStringTag], 'Symbol', 'Symbol::@@toStringTag is `Symbol`');
});
if (DESCRIPTORS) {
QUnit.test('Symbols & descriptors', assert => {
const d = Symbol('d');
const e = Symbol('e');
const f = Symbol('f');
const i = Symbol('i');
const j = Symbol('j');
const prototype = { g: 'g' };
prototype[i] = 'i';
defineProperty(prototype, 'h', {
value: 'h',
});
defineProperty(prototype, j, {
value: 'j',
});
const object = create(prototype);
object.a = 'a';
object[d] = 'd';
defineProperty(object, 'b', {
value: 'b',
});
defineProperty(object, 'c', {
value: 'c',
enumerable: true,
});
defineProperty(object, e, {
configurable: true,
writable: true,
value: 'e',
});
const descriptor = {
value: 'f',
enumerable: true,
};
defineProperty(object, f, descriptor);
assert.true(descriptor.enumerable, 'defineProperty not changes descriptor object');
assert.deepEqual(getOwnPropertyDescriptor(object, 'a'), {
configurable: true,
writable: true,
enumerable: true,
value: 'a',
}, 'getOwnPropertyDescriptor a');
assert.deepEqual(getOwnPropertyDescriptor(object, 'b'), {
configurable: false,
writable: false,
enumerable: false,
value: 'b',
}, 'getOwnPropertyDescriptor b');
assert.deepEqual(getOwnPropertyDescriptor(object, 'c'), {
configurable: false,
writable: false,
enumerable: true,
value: 'c',
}, 'getOwnPropertyDescriptor c');
assert.deepEqual(getOwnPropertyDescriptor(object, d), {
configurable: true,
writable: true,
enumerable: true,
value: 'd',
}, 'getOwnPropertyDescriptor d');
assert.deepEqual(getOwnPropertyDescriptor(object, e), {
configurable: true,
writable: true,
enumerable: false,
value: 'e',
}, 'getOwnPropertyDescriptor e');
assert.deepEqual(getOwnPropertyDescriptor(object, f), {
configurable: false,
writable: false,
enumerable: true,
value: 'f',
}, 'getOwnPropertyDescriptor f');
assert.same(getOwnPropertyDescriptor(object, 'g'), undefined, 'getOwnPropertyDescriptor g');
assert.same(getOwnPropertyDescriptor(object, 'h'), undefined, 'getOwnPropertyDescriptor h');
assert.same(getOwnPropertyDescriptor(object, i), undefined, 'getOwnPropertyDescriptor i');
assert.same(getOwnPropertyDescriptor(object, j), undefined, 'getOwnPropertyDescriptor j');
assert.same(getOwnPropertyDescriptor(object, 'k'), undefined, 'getOwnPropertyDescriptor k');
assert.false(getOwnPropertyDescriptor(Object.prototype, 'toString').enumerable, 'getOwnPropertyDescriptor on Object.prototype');
assert.same(getOwnPropertyDescriptor(Object.prototype, d), undefined, 'getOwnPropertyDescriptor on Object.prototype missed symbol');
assert.same(keys(object).length, 2, 'Object.keys');
assert.same(getOwnPropertyNames(object).length, 3, 'Object.getOwnPropertyNames');
assert.same(getOwnPropertySymbols(object).length, 3, 'Object.getOwnPropertySymbols');
assert.same(ownKeys(object).length, 6, 'Reflect.ownKeys');
delete object[e];
object[e] = 'e';
assert.deepEqual(getOwnPropertyDescriptor(object, e), {
configurable: true,
writable: true,
enumerable: true,
value: 'e',
}, 'redefined non-enum key');
const g = Symbol('g');
defineProperty(object, g, { configurable: true, enumerable: true, writable: true, value: 1 });
defineProperty(object, g, { value: 2 });
assert.deepEqual(getOwnPropertyDescriptor(object, g), {
configurable: true,
writable: true,
enumerable: true,
value: 2,
}, 'redefine with partial descriptor preserves enumerable');
});
QUnit.test('Symbols & Object.defineProperties', assert => {
const c = Symbol('c');
const d = Symbol('d');
const descriptors = {
a: {
value: 'a',
},
};
descriptors[c] = {
value: 'c',
};
defineProperty(descriptors, 'b', {
value: {
value: 'b',
},
});
defineProperty(descriptors, d, {
value: {
value: 'd',
},
});
const object = defineProperties({}, descriptors);
assert.same(object.a, 'a', 'a');
assert.same(object.b, undefined, 'b');
assert.same(object[c], 'c', 'c');
assert.same(object[d], undefined, 'd');
});
QUnit.test('Symbols & Object.create', assert => {
const c = Symbol('c');
const d = Symbol('d');
const descriptors = {
a: {
value: 'a',
},
};
descriptors[c] = {
value: 'c',
};
defineProperty(descriptors, 'b', {
value: {
value: 'b',
},
});
defineProperty(descriptors, d, {
value: {
value: 'd',
},
});
const object = create(null, descriptors);
assert.same(object.a, 'a', 'a');
assert.same(object.b, undefined, 'b');
assert.same(object[c], 'c', 'c');
assert.same(object[d], undefined, 'd');
});
const constructors = { Map, Set, Promise };
for (const name in constructors) {
QUnit.test(`${ name }@@species`, assert => {
assert.same(constructors[name][Symbol.species], constructors[name], `${ name }@@species === ${ name }`);
const Subclass = create(constructors[name]);
assert.same(Subclass[Symbol.species], Subclass, `${ name } subclass`);
});
}
QUnit.test('Array@@species', assert => {
assert.same(Array[Symbol.species], Array, 'Array@@species === Array');
const Subclass = create(Array);
assert.same(Subclass[Symbol.species], Subclass, 'Array subclass');
});
QUnit.test('Symbol.sham flag', assert => {
assert.same(Symbol.sham, typeof Symbol('Symbol.sham flag test') == 'symbol' ? undefined : true);
});
}
================================================
FILE: tests/unit-pure/es.symbol.dispose.js
================================================
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol.dispose', assert => {
assert.true('dispose' in Symbol, 'Symbol.dispose available');
assert.true(Object(Symbol.dispose) instanceof Symbol, 'Symbol.dispose is symbol');
});
================================================
FILE: tests/unit-pure/es.symbol.for.js
================================================
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol.for', assert => {
assert.isFunction(Symbol.for, 'Symbol.for is function');
const symbol = Symbol.for('foo');
assert.strictEqual(Symbol.for('foo'), symbol, 'registry');
assert.true(Object(symbol) instanceof Symbol, 'returns symbol');
assert.throws(() => Symbol.for(Symbol('foo')), 'throws on symbol argument');
});
================================================
FILE: tests/unit-pure/es.symbol.key-for.js
================================================
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('Symbol.keyFor', assert => {
assert.isFunction(Symbol.keyFor, 'Symbol.keyFor is function');
assert.strictEqual(Symbol.keyFor(Symbol.for('foo')), 'foo');
assert.strictEqual(Symbol.keyFor(Symbol('foo')), undefined);
assert.throws(() => Symbol.keyFor('foo'), 'throws on non-symbol');
});
================================================
FILE: tests/unit-pure/es.unescape.js
================================================
import unescape from 'core-js-pure/es/unescape';
QUnit.test('unescape', assert => {
assert.isFunction(unescape);
assert.arity(unescape, 1);
assert.name(unescape, 'unescape');
assert.same(unescape('%21q2%u0444'), '!q2ф');
assert.same(unescape('%u044q2%21'), '%u044q2!');
assert.same(unescape(null), 'null');
assert.same(unescape(undefined), 'undefined');
/* eslint-disable es/no-symbol -- safe */
if (typeof Symbol == 'function') {
assert.throws(() => unescape(Symbol('unescape test')), 'throws on symbol argument');
}
});
================================================
FILE: tests/unit-pure/es.weak-map.get-or-insert-computed.js
================================================
import { STRICT } from '../helpers/constants.js';
import WeakMap from 'core-js-pure/es/weak-map';
QUnit.test('WeakMap#getOrInsertComputed', assert => {
const { getOrInsertComputed } = WeakMap.prototype;
assert.isFunction(getOrInsertComputed);
assert.arity(getOrInsertComputed, 2);
assert.name(getOrInsertComputed, 'getOrInsertComputed');
assert.nonEnumerable(WeakMap.prototype, 'getOrInsertComputed');
const a = {};
const b = {};
let map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsertComputed(a, () => 3), 2, 'result#1');
assert.same(map.get(a), 2, 'map#1');
map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsertComputed(b, () => 3), 3, 'result#2');
assert.same(map.get(a), 2, 'map#2-1');
assert.same(map.get(b), 3, 'map#2-2');
map = new WeakMap([[a, 2]]);
map.getOrInsertComputed(a, () => assert.avoid());
map = new WeakMap([[a, 2]]);
map.getOrInsertComputed(b, function (key) {
if (STRICT) assert.same(this, undefined, 'correct handler in callback');
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(key, b, 'correct key in callback');
});
map = new WeakMap([[a, 2]]);
assert.throws(() => {
map.getOrInsertComputed(1, () => assert.avoid());
}, TypeError, 'key validation before call of callback');
map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsertComputed(b, key => {
map.set(key, 4);
return 3;
}), 3, 'callback inserts same key');
assert.same(map.get(b), 3, 'map after callback inserts same key');
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');
});
================================================
FILE: tests/unit-pure/es.weak-map.get-or-insert.js
================================================
import WeakMap from 'core-js-pure/es/weak-map';
QUnit.test('WeakMap#getOrInsert', assert => {
const { getOrInsert } = WeakMap.prototype;
assert.isFunction(getOrInsert);
assert.arity(getOrInsert, 2);
assert.name(getOrInsert, 'getOrInsert');
assert.nonEnumerable(WeakMap.prototype, 'getOrInsert');
const a = {};
const b = {};
let map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsert(a, 3), 2, 'result#1');
assert.same(map.get(a), 2, 'map#1');
map = new WeakMap([[a, 2]]);
assert.same(map.getOrInsert(b, 3), 3, 'result#2');
assert.same(map.get(a), 2, 'map#2-1');
assert.same(map.get(b), 3, 'map#2-2');
assert.throws(() => new WeakMap().getOrInsert(1, 1), TypeError, 'invalid key#1');
assert.throws(() => new WeakMap().getOrInsert(null, 1), TypeError, 'invalid key#2');
assert.throws(() => new WeakMap().getOrInsert(undefined, 1), TypeError, 'invalid key#3');
assert.throws(() => new WeakMap().getOrInsert(), TypeError, 'invalid key#4');
assert.throws(() => getOrInsert.call({}, a, 1), TypeError, 'non-generic#1');
assert.throws(() => getOrInsert.call([], a, 1), TypeError, 'non-generic#2');
assert.throws(() => getOrInsert.call(undefined, a, 1), TypeError, 'non-generic#3');
assert.throws(() => getOrInsert.call(null, a, 1), TypeError, 'non-generic#4');
});
================================================
FILE: tests/unit-pure/es.weak-map.js
================================================
import { createIterable, nativeSubclass } from '../helpers/helpers.js';
import { DESCRIPTORS, FREEZING } from '../helpers/constants.js';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import freeze from 'core-js-pure/es/object/freeze';
import isFrozen from 'core-js-pure/es/object/is-frozen';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import keys from 'core-js-pure/es/object/keys';
import ownKeys from 'core-js-pure/es/reflect/own-keys';
import Symbol from 'core-js-pure/es/symbol';
import WeakMap from 'core-js-pure/es/weak-map';
QUnit.test('WeakMap', assert => {
assert.isFunction(WeakMap);
assert.true('delete' in WeakMap.prototype, 'delete in WeakMap.prototype');
assert.true('get' in WeakMap.prototype, 'get in WeakMap.prototype');
assert.true('has' in WeakMap.prototype, 'has in WeakMap.prototype');
assert.true('set' in WeakMap.prototype, 'set in WeakMap.prototype');
assert.true(new WeakMap() instanceof WeakMap, 'new WeakMap instanceof WeakMap');
let object = {};
assert.same(new WeakMap(createIterable([[object, 42]])).get(object), 42, 'Init from iterable');
let weakmap = new WeakMap();
const frozen = freeze({});
weakmap.set(frozen, 42);
assert.same(weakmap.get(frozen), 42, 'Support frozen objects');
weakmap = new WeakMap();
weakmap.set(frozen, 42);
assert.true(weakmap.has(frozen), 'works with frozen objects, #1');
assert.same(weakmap.get(frozen), 42, 'works with frozen objects, #2');
weakmap.delete(frozen);
assert.false(weakmap.has(frozen), 'works with frozen objects, #3');
assert.same(weakmap.get(frozen), undefined, 'works with frozen objects, #4');
let done = false;
try {
new WeakMap(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.true(done, '.return #throw');
assert.false('clear' in WeakMap.prototype, 'should not contains `.clear` method');
const array = [];
done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new WeakMap(array);
assert.true(done);
object = {};
new WeakMap().set(object, 1);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakMap);
assert.true(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.true(new Subclass() instanceof WeakMap, 'correct subclassing with native classes #2');
object = {};
assert.same(new Subclass().set(object, 2).get(object), 2, 'correct subclassing with native classes #3');
}
if (typeof ArrayBuffer == 'function') {
const buffer = new ArrayBuffer(8);
const map = new WeakMap([[buffer, 8]]);
assert.true(map.has(buffer), 'works with ArrayBuffer keys');
}
});
QUnit.test('WeakMap#delete', assert => {
assert.isFunction(WeakMap.prototype.delete);
const a = {};
const b = {};
const weakmap = new WeakMap();
weakmap.set(a, 42);
weakmap.set(b, 21);
assert.true(weakmap.has(a), 'WeakMap has values before .delete() #1');
assert.true(weakmap.has(b), 'WeakMap has values before .delete() #2');
weakmap.delete(a);
assert.false(weakmap.has(a), 'WeakMap has not value after .delete() #1');
assert.true(weakmap.has(b), 'WeakMap still has value after .delete() #2');
assert.notThrows(() => !weakmap.delete(1), 'return false on primitive');
const object = {};
weakmap.set(object, 42);
freeze(object);
assert.true(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.false(weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#get', assert => {
assert.isFunction(WeakMap.prototype.get);
const weakmap = new WeakMap();
assert.same(weakmap.get({}), undefined, 'WeakMap .get() before .set() return undefined');
let object = {};
weakmap.set(object, 42);
assert.same(weakmap.get(object), 42, 'WeakMap .get() return value');
weakmap.delete(object);
assert.same(weakmap.get(object), undefined, 'WeakMap .get() after .delete() return undefined');
assert.notThrows(() => weakmap.get(1) === undefined, 'return undefined on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.same(weakmap.get(object), 42, 'works with frozen objects #1');
weakmap.delete(object);
assert.same(weakmap.get(object), undefined, 'works with frozen objects #2');
});
QUnit.test('WeakMap#has', assert => {
assert.isFunction(WeakMap.prototype.has);
const weakmap = new WeakMap();
assert.false(weakmap.has({}), 'WeakMap .has() before .set() return false');
let object = {};
weakmap.set(object, 42);
assert.true(weakmap.has(object), 'WeakMap .has() return true');
weakmap.delete(object);
assert.false(weakmap.has(object), 'WeakMap .has() after .delete() return false');
assert.notThrows(() => !weakmap.has(1), 'return false on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.true(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.false(weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#set', assert => {
assert.isFunction(WeakMap.prototype.set);
const weakmap = new WeakMap();
const object = {};
weakmap.set(object, 33);
assert.same(weakmap.get(object), 33, 'works with object as keys');
assert.same(weakmap.set({}, 42), weakmap, 'chaining');
assert.throws(() => new WeakMap().set(42, 42), 'throws with primitive keys');
const object1 = freeze({});
const object2 = {};
weakmap.set(object1, 42);
weakmap.set(object2, 42);
freeze(object);
assert.same(weakmap.get(object1), 42, 'works with frozen objects #1');
assert.same(weakmap.get(object2), 42, 'works with frozen objects #2');
weakmap.delete(object1);
weakmap.delete(object2);
assert.same(weakmap.get(object1), undefined, 'works with frozen objects #3');
assert.same(weakmap.get(object2), undefined, 'works with frozen objects #4');
const array = freeze([]);
weakmap.set(array, 42);
assert.same(weakmap.get(array), 42, 'works with frozen arrays #1');
if (FREEZING) assert.true(isFrozen(array), 'works with frozen arrays #2');
});
QUnit.test('WeakMap#@@toStringTag', assert => {
assert.same(WeakMap.prototype[Symbol.toStringTag], 'WeakMap', 'WeakMap::@@toStringTag is `WeakMap`');
assert.same(String(new WeakMap()), '[object WeakMap]', 'correct stringification');
});
================================================
FILE: tests/unit-pure/es.weak-set.js
================================================
import { createIterable, nativeSubclass } from '../helpers/helpers.js';
import { DESCRIPTORS } from '../helpers/constants.js';
import getIteratorMethod from 'core-js-pure/es/get-iterator-method';
import freeze from 'core-js-pure/es/object/freeze';
import getOwnPropertyNames from 'core-js-pure/es/object/get-own-property-names';
import getOwnPropertySymbols from 'core-js-pure/es/object/get-own-property-symbols';
import keys from 'core-js-pure/es/object/keys';
import ownKeys from 'core-js-pure/es/reflect/own-keys';
import Symbol from 'core-js-pure/es/symbol';
import WeakSet from 'core-js-pure/es/weak-set';
QUnit.test('WeakSet', assert => {
assert.isFunction(WeakSet);
assert.true('add' in WeakSet.prototype, 'add in WeakSet.prototype');
assert.true('delete' in WeakSet.prototype, 'delete in WeakSet.prototype');
assert.true('has' in WeakSet.prototype, 'has in WeakSet.prototype');
assert.true(new WeakSet() instanceof WeakSet, 'new WeakSet instanceof WeakSet');
let object = {};
assert.true(new WeakSet(createIterable([object])).has(object), 'Init from iterable');
const weakset = new WeakSet();
const frozen = freeze({});
weakset.add(frozen);
assert.true(weakset.has(frozen), 'works with frozen objects, #1');
weakset.delete(frozen);
assert.false(weakset.has(frozen), 'works with frozen objects, #2');
let done = false;
try {
new WeakSet(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.true(done, '.return #throw');
assert.false('clear' in WeakSet.prototype, 'should not contains `.clear` method');
const array = [];
done = false;
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new WeakSet(array);
assert.true(done);
object = {};
new WeakSet().add(object);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakSet);
assert.true(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.true(new Subclass() instanceof WeakSet, 'correct subclassing with native classes #2');
object = {};
assert.true(new Subclass().add(object).has(object), 'correct subclassing with native classes #3');
}
if (typeof ArrayBuffer == 'function') {
const buffer = new ArrayBuffer(8);
const set = new WeakSet([buffer]);
assert.true(set.has(buffer), 'works with ArrayBuffer keys');
}
});
QUnit.test('WeakSet#add', assert => {
assert.isFunction(WeakSet.prototype.add);
const weakset = new WeakSet();
assert.same(weakset.add({}), weakset, 'chaining');
assert.throws(() => new WeakSet().add(42), 'throws with primitive keys');
});
QUnit.test('WeakSet#delete', assert => {
assert.isFunction(WeakSet.prototype.delete);
const a = {};
const b = {};
const weakset = new WeakSet().add(a).add(b);
assert.true(weakset.has(a), 'WeakSet has values before .delete() #1');
assert.true(weakset.has(b), 'WeakSet has values before .delete() #2');
weakset.delete(a);
assert.false(weakset.has(a), 'WeakSet has not value after .delete() #1');
assert.true(weakset.has(b), 'WeakSet still has value after .delete() #2');
assert.notThrows(() => !weakset.delete(1), 'return false on primitive');
});
QUnit.test('WeakSet#has', assert => {
assert.isFunction(WeakSet.prototype.has);
const weakset = new WeakSet();
assert.false(weakset.has({}), 'WeakSet has`nt value');
const object = {};
weakset.add(object);
assert.true(weakset.has(object), 'WeakSet has value after .add()');
weakset.delete(object);
assert.false(weakset.has(object), 'WeakSet has not value after .delete()');
assert.notThrows(() => !weakset.has(1), 'return false on primitive');
});
QUnit.test('WeakSet#@@toStringTag', assert => {
assert.same(WeakSet.prototype[Symbol.toStringTag], 'WeakSet', 'WeakSet#@@toStringTag is `WeakSet`');
assert.same(String(new WeakSet()), '[object WeakSet]', 'correct stringification');
});
================================================
FILE: tests/unit-pure/esnext.array.filter-out.js
================================================
// TODO: Remove from `core-js@4`
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import filterOut from 'core-js-pure/full/array/filter-out';
QUnit.test('Array#filterOut', assert => {
assert.isFunction(filterOut);
let array = [1];
const context = {};
filterOut(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.deepEqual(filterOut([1, 2, 3, 'q', {}, 4, true, 5], it => typeof it != 'number'), [1, 2, 3, 4, 5]);
if (STRICT) {
assert.throws(() => filterOut(null, () => { /* empty */ }), TypeError);
assert.throws(() => filterOut(undefined, () => { /* empty */ }), TypeError);
}
assert.notThrows(() => filterOut({ 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(filterOut(array, Boolean).foo, 1, '@@species');
});
================================================
FILE: tests/unit-pure/esnext.array.filter-reject.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import filterReject from 'core-js-pure/full/array/filter-reject';
QUnit.test('Array#filterReject', assert => {
assert.isFunction(filterReject);
let array = [1];
const context = {};
filterReject(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.deepEqual(filterReject([1, 2, 3, 'q', {}, 4, true, 5], it => typeof it != 'number'), [1, 2, 3, 4, 5]);
if (STRICT) {
assert.throws(() => filterReject(null, () => { /* empty */ }), TypeError);
assert.throws(() => filterReject(undefined, () => { /* empty */ }), TypeError);
}
assert.notThrows(() => filterReject({ 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(filterReject(array, Boolean).foo, 1, '@@species');
});
================================================
FILE: tests/unit-pure/esnext.array.group-by-to-map.js
================================================
import { STRICT } from '../helpers/constants.js';
import Map from 'core-js-pure/es/map';
import Symbol from 'core-js-pure/es/symbol';
import from from 'core-js-pure/es/array/from';
import groupByToMap from 'core-js-pure/actual/array/group-by-to-map';
QUnit.test('Array#groupByToMap', assert => {
assert.isFunction(groupByToMap);
let array = [1];
const context = {};
groupByToMap(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(groupByToMap([], it => it) instanceof Map, 'returns Map');
assert.deepEqual(from(groupByToMap([1, 2, 3], it => it % 2)), [[1, [1, 3]], [0, [2]]], '#1');
assert.deepEqual(
from(groupByToMap([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], it => `i${ it % 5 }`)),
[['i1', [1, 6, 11]], ['i2', [2, 7, 12]], ['i3', [3, 8]], ['i4', [4, 9]], ['i0', [5, 10]]],
'#2',
);
assert.deepEqual(from(groupByToMap(Array(3), it => it)), [[undefined, [undefined, undefined, undefined]]], '#3');
if (STRICT) {
assert.throws(() => groupByToMap(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => groupByToMap(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(groupByToMap(array, Boolean).get(true).foo, undefined, 'no @@species');
});
================================================
FILE: tests/unit-pure/esnext.array.group-by.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
import groupBy from 'core-js-pure/actual/array/group-by';
QUnit.test('Array#groupBy', assert => {
assert.isFunction(groupBy);
let array = [1];
const context = {};
groupBy(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(getPrototypeOf(groupBy([], it => it)), null, 'null proto');
assert.deepEqual(groupBy([1, 2, 3], it => it % 2), { 1: [1, 3], 0: [2] }, '#1');
assert.deepEqual(
groupBy([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], it => `i${ it % 5 }`),
{ i1: [1, 6, 11], i2: [2, 7, 12], i3: [3, 8], i4: [4, 9], i0: [5, 10] },
'#2',
);
assert.deepEqual(groupBy(Array(3), it => it), { undefined: [undefined, undefined, undefined] }, '#3');
if (STRICT) {
assert.throws(() => groupBy(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => groupBy(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(groupBy(array, Boolean).true.foo, undefined, 'no @@species');
});
================================================
FILE: tests/unit-pure/esnext.array.group-to-map.js
================================================
import { STRICT } from '../helpers/constants.js';
import Map from 'core-js-pure/es/map';
import Symbol from 'core-js-pure/es/symbol';
import from from 'core-js-pure/es/array/from';
import groupToMap from 'core-js-pure/actual/array/group-to-map';
QUnit.test('Array#groupToMap', assert => {
assert.isFunction(groupToMap);
let array = [1];
const context = {};
groupToMap(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(groupToMap([], it => it) instanceof Map, 'returns Map');
assert.deepEqual(from(groupToMap([1, 2, 3], it => it % 2)), [[1, [1, 3]], [0, [2]]], '#1');
assert.deepEqual(
from(groupToMap([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], it => `i${ it % 5 }`)),
[['i1', [1, 6, 11]], ['i2', [2, 7, 12]], ['i3', [3, 8]], ['i4', [4, 9]], ['i0', [5, 10]]],
'#2',
);
assert.deepEqual(from(groupToMap(Array(3), it => it)), [[undefined, [undefined, undefined, undefined]]], '#3');
if (STRICT) {
assert.throws(() => groupToMap(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => groupToMap(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(groupToMap(array, Boolean).get(true).foo, undefined, 'no @@species');
});
================================================
FILE: tests/unit-pure/esnext.array.group.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
import group from 'core-js-pure/actual/array/group';
QUnit.test('Array#group', assert => {
assert.isFunction(group);
let array = [1];
const context = {};
group(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(getPrototypeOf(group([], it => it)), null, 'null proto');
assert.deepEqual(group([1, 2, 3], it => it % 2), { 1: [1, 3], 0: [2] }, '#1');
assert.deepEqual(
group([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], it => `i${ it % 5 }`),
{ i1: [1, 6, 11], i2: [2, 7, 12], i3: [3, 8], i4: [4, 9], i0: [5, 10] },
'#2',
);
assert.deepEqual(group(Array(3), it => it), { undefined: [undefined, undefined, undefined] }, '#3');
if (STRICT) {
assert.throws(() => group(null, () => { /* empty */ }), TypeError, 'null this -> TypeError');
assert.throws(() => group(undefined, () => { /* empty */ }), TypeError, 'undefined this -> TypeError');
}
array = [1];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.same(group(array, Boolean).true.foo, undefined, 'no @@species');
});
================================================
FILE: tests/unit-pure/esnext.array.is-template-object.js
================================================
import freeze from 'core-js-pure/es/object/freeze';
import isTemplateObject from 'core-js-pure/full/array/is-template-object';
QUnit.test('Array.isTemplateObject', assert => {
assert.isFunction(isTemplateObject);
assert.arity(isTemplateObject, 1);
assert.name(isTemplateObject, 'isTemplateObject');
assert.false(isTemplateObject(undefined));
assert.false(isTemplateObject(null));
assert.false(isTemplateObject({}));
assert.false(isTemplateObject(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()));
assert.false(isTemplateObject([]));
assert.false(isTemplateObject(freeze([])), 'frozen string array without .raw should return false #1');
assert.false(isTemplateObject(freeze(['hello'])), 'frozen string array without .raw should return false #2');
const template = (() => {
try {
// eslint-disable-next-line no-template-curly-in-string -- ignore
return Function('return (it => it)`qwe${ 123 }asd`')();
} catch { /* empty */ }
})();
if (template) assert.true(isTemplateObject(template));
});
================================================
FILE: tests/unit-pure/esnext.array.unique-by.js
================================================
import { STRICT } from '../helpers/constants.js';
import uniqueBy from 'core-js-pure/full/array/unique-by';
QUnit.test('Array#uniqueBy', assert => {
assert.isFunction(uniqueBy);
let array = [1, 2, 3, 2, 1];
assert.notSame(uniqueBy(array), array);
assert.deepEqual(uniqueBy(array), [1, 2, 3]);
array = [
{
id: 1,
uid: 10000,
},
{
id: 2,
uid: 10000,
},
{
id: 3,
uid: 10001,
},
];
assert.deepEqual(uniqueBy(array, it => it.uid), [
{
id: 1,
uid: 10000,
},
{
id: 3,
uid: 10001,
},
]);
assert.deepEqual(uniqueBy(array, ({ id, uid }) => `${ id }-${ uid }`), array);
assert.deepEqual(uniqueBy([1, undefined, 2, undefined, null, 1]), [1, undefined, 2, null]);
assert.deepEqual(uniqueBy([0, -0]), [0]);
assert.deepEqual(uniqueBy([NaN, NaN]), [NaN]);
assert.deepEqual(uniqueBy({ length: 1, 0: 1 }), [1]);
if (STRICT) {
assert.throws(() => uniqueBy(null), TypeError);
assert.throws(() => uniqueBy(undefined), TypeError);
}
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.as-indexed-pairs.js
================================================
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import AsyncIterator from 'core-js-pure/full/async-iterator';
QUnit.test('AsyncIterator#asIndexedPairs', assert => {
const { asIndexedPairs } = AsyncIterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
assert.nonEnumerable(AsyncIterator.prototype, 'asIndexedPairs');
if (STRICT) {
assert.throws(() => asIndexedPairs.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => asIndexedPairs.call(null, () => { /* empty */ }), TypeError);
}
return asIndexedPairs.call(createIterator(['a', 'b', 'c'])).toArray().then(it => {
assert.same(it.toString(), '0,a,1,b,2,c', 'basic functionality');
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.constructor.js
================================================
import { nativeSubclass } from '../helpers/helpers.js';
import Symbol from 'core-js-pure/es/symbol';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator', assert => {
assert.isFunction(AsyncIterator);
assert.arity(AsyncIterator, 0);
assert.name(AsyncIterator, 'AsyncIterator');
assert.true(AsyncIterator.from([1, 2, 3]) instanceof AsyncIterator, 'Async From Proxy');
assert.true(AsyncIterator.from([1, 2, 3]).drop(1) instanceof AsyncIterator, 'Async Drop Proxy');
if (nativeSubclass) {
const Sub = nativeSubclass(AsyncIterator);
assert.true(new Sub() instanceof AsyncIterator, 'abstract constructor');
}
assert.throws(() => new AsyncIterator(), 'direct constructor throws');
// eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
assert.throws(() => AsyncIterator(), 'throws w/o `new`');
});
QUnit.test('AsyncIterator#constructor', assert => {
assert.same(AsyncIterator.prototype.constructor, AsyncIterator, 'AsyncIterator#constructor is AsyncIterator');
});
QUnit.test('AsyncIterator#@@toStringTag', assert => {
assert.same(AsyncIterator.prototype[Symbol.toStringTag], 'AsyncIterator', 'AsyncIterator::@@toStringTag is `AsyncIterator`');
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.drop.js
================================================
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#drop', assert => {
const { drop } = AsyncIterator.prototype;
assert.isFunction(drop);
assert.arity(drop, 1);
assert.name(drop, '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');
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.every.js
================================================
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#every', assert => {
const { every } = AsyncIterator.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, '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');
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.filter.js
================================================
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#filter', assert => {
const { filter } = AsyncIterator.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, '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');
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.find.js
================================================
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#find', assert => {
const { find } = AsyncIterator.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, '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');
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.flat-map.js
================================================
import { createIterator, createIterable } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
import Promise from 'core-js-pure/es/promise';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('AsyncIterator#flatMap', assert => {
const { flatMap } = AsyncIterator.prototype;
assert.isFunction(flatMap);
assert.arity(flatMap, 1);
assert.name(flatMap, '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 = AsyncIterator.from({
next() {
return Promise.resolve({ value: [1, 2, 3], done: false });
},
return() {
assert.true(innerReturnAwaited, 'inner return() fully awaited before outer return()');
return Promise.resolve({ value: undefined, done: true });
},
[Symbol.asyncIterator]() { return this; },
});
const helper = outer.flatMap(arr => {
let i = 0;
return {
next() {
return Promise.resolve(i < arr.length
? { value: arr[i++], done: false }
: { value: undefined, done: true });
},
return() {
assert.required('inner return() called');
return new Promise(resolve => {
setTimeout(() => {
innerReturnAwaited = true;
resolve({ value: undefined, done: true });
}, 50);
});
},
[Symbol.asyncIterator]() { return this; },
};
});
helper.next().then(first => {
assert.same(first.value, 1, 'got first value');
return helper.return();
}).then(() => {
async();
}, () => {
assert.avoid();
async();
});
});
QUnit.test('AsyncIterator#flatMap, return() validates inner return result', assert => {
assert.expect(1);
const async = assert.async();
const outer = AsyncIterator.from({
next() {
return Promise.resolve({ value: [1, 2], done: false });
},
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() {
return null;
},
[Symbol.asyncIterator]() { return this; },
};
});
helper.next().then(() => {
return helper.return();
}).then(() => {
assert.avoid();
async();
}, error => {
assert.true(error instanceof TypeError, 'TypeError when inner return() returns non-object');
async();
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.for-each.js
================================================
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#forEach', assert => {
const { forEach } = AsyncIterator.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.name(forEach, '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');
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.from.js
================================================
import Promise from 'core-js-pure/es/promise';
import assign from 'core-js-pure/es/object/assign';
import create from 'core-js-pure/es/object/create';
import values from 'core-js-pure/es/array/values';
import Symbol from 'core-js-pure/es/symbol';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
import Iterator from 'core-js-pure/actual/iterator';
QUnit.test('AsyncIterator.from', assert => {
const { from } = AsyncIterator;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, '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,
[Symbol.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 `.next()` promise rejection');
assert.true(closableIterator.closed, 'closes 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.true(error instanceof TypeError, 'rejects with new TypeError');
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();
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.indexed.js
================================================
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import AsyncIterator from 'core-js-pure/full/async-iterator';
QUnit.test('AsyncIterator#indexed', assert => {
const { indexed } = AsyncIterator.prototype;
assert.isFunction(indexed);
assert.arity(indexed, 0);
assert.name(indexed, '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');
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.map.js
================================================
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#map', assert => {
const { map } = AsyncIterator.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.name(map, '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');
}).then(() => {
let calls = 0;
const iterator = createIterator([1, 2, 3], {
next() { calls++; throw 43; },
});
const mapped = map.call(iterator, it => it);
return mapped.next().then(() => {
assert.avoid();
}, error => {
assert.same(error, 43, 'rejection on next() sync error');
assert.same(calls, 1, 'next() called once');
return mapped.next();
}).then(result => {
assert.true(result.done, 'done after next() sync error');
assert.same(calls, 1, 'next() not called again after sync error');
});
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.reduce.js
================================================
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#reduce', assert => {
const { reduce } = AsyncIterator.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, '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');
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.some.js
================================================
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#some', assert => {
const { some } = AsyncIterator.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, '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');
}).then(() => {
return some.call(
createIterator([1, 2, 3], { return() { return 42; } }),
it => it === 1,
);
}).then(() => {
assert.avoid();
}, error => {
assert.true(error instanceof TypeError, 'rejects when return() yields non-object on normal close');
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.take.js
================================================
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
import Symbol from 'core-js-pure/es/symbol';
QUnit.test('AsyncIterator#take', assert => {
const { take } = AsyncIterator.prototype;
assert.isFunction(take);
assert.arity(take, 1);
assert.name(take, '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');
});
});
QUnit.test('AsyncIterator#take, return() does not pass extra argument', assert => {
assert.expect(2);
const async = assert.async();
let returnArgs;
const iter = {
i: 0,
next() { return { value: ++this.i, done: false }; },
return(...args) { returnArgs = args; return { value: undefined, done: true }; },
[Symbol.iterator]() { return this; },
};
AsyncIterator.from(iter).take(1).toArray().then(() => {
assert.same(returnArgs.length, 0, 'return() called with no arguments');
assert.true(true, 'take completes successfully');
async();
}).catch(() => {
assert.avoid();
async();
});
});
QUnit.test('AsyncIterator#take, return() result validated as object', assert => {
assert.expect(1);
const async = assert.async();
const iter = {
i: 0,
next() { return { value: ++this.i, done: false }; },
return() { return 42; },
[Symbol.iterator]() { return this; },
};
AsyncIterator.from(iter).take(1).toArray().then(() => {
assert.avoid();
async();
}).catch(error => {
assert.true(error instanceof TypeError, 'rejects with TypeError when return() gives non-object');
async();
});
});
================================================
FILE: tests/unit-pure/esnext.async-iterator.to-array.js
================================================
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import AsyncIterator from 'core-js-pure/actual/async-iterator';
QUnit.test('AsyncIterator#toArray', assert => {
const { toArray } = AsyncIterator.prototype;
assert.isFunction(toArray);
assert.arity(toArray, 0);
assert.name(toArray, '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]);
});
});
================================================
FILE: tests/unit-pure/esnext.bigint.range.js
================================================
/* eslint-disable es/no-bigint -- safe */
import from from 'core-js-pure/es/array/from';
import range from 'core-js-pure/full/bigint/range';
if (typeof BigInt == 'function') QUnit.test('BigInt.range', assert => {
assert.isFunction(range);
assert.name(range, 'range');
assert.arity(range, 3);
let iterator = range(BigInt(1), BigInt(2));
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: BigInt(1),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.deepEqual(from(range(BigInt(-1), BigInt(5))), [BigInt(-1), BigInt(0), BigInt(1), BigInt(2), BigInt(3), BigInt(4)]);
assert.deepEqual(from(range(BigInt(-5), BigInt(1))), [BigInt(-5), BigInt(-4), BigInt(-3), BigInt(-2), BigInt(-1), BigInt(0)]);
assert.deepEqual(
from(range(BigInt('9007199254740991'), BigInt('9007199254740992'), { inclusive: true })),
[BigInt('9007199254740991'), BigInt('9007199254740992')],
);
assert.deepEqual(from(range(BigInt(0), BigInt(0))), []);
assert.deepEqual(from(range(BigInt(0), BigInt(-5), BigInt(1))), []);
iterator = range(BigInt(1), BigInt(3));
assert.deepEqual(iterator.start, BigInt(1));
assert.deepEqual(iterator.end, BigInt(3));
assert.deepEqual(iterator.step, BigInt(1));
assert.false(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { inclusive: true });
assert.deepEqual(iterator.start, BigInt(-1));
assert.deepEqual(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(-1));
assert.true(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { step: BigInt(4), inclusive() { /* empty */ } });
assert.same(iterator.start, BigInt(-1));
assert.same(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(4));
assert.true(iterator.inclusive);
iterator = range(BigInt(0), BigInt(5));
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
assert.throws(() => Object.getOwnPropertyDescriptor(iterator, 'start').get.call({}), TypeError);
assert.throws(() => range(Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(-Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), Infinity), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), { step: Infinity }), TypeError);
assert.throws(() => range({}, BigInt(1)), TypeError);
assert.throws(() => range(BigInt(1), {}), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.composite-key.js
================================================
import { FREEZING } from '../helpers/constants.js';
import { getPrototypeOf, isFrozen } from 'core-js-pure/es/object';
import compositeKey from 'core-js-pure/full/composite-key';
QUnit.test('compositeKey', assert => {
assert.isFunction(compositeKey);
if (compositeKey.name) assert.name(compositeKey, 'compositeKey');
const key = compositeKey({});
assert.same(typeof key, 'object');
assert.same({}.toString.call(key), '[object Object]');
assert.same(getPrototypeOf(key), null);
if (FREEZING) assert.true(isFrozen(key));
const a = ['a'];
const b = ['b'];
const c = ['c'];
assert.same(compositeKey(a), compositeKey(a));
assert.notSame(compositeKey(a), compositeKey(['a']));
assert.notSame(compositeKey(a), compositeKey(a, 1));
assert.notSame(compositeKey(a), compositeKey(a, b));
assert.same(compositeKey(a, 1), compositeKey(a, 1));
assert.same(compositeKey(a, b), compositeKey(a, b));
assert.notSame(compositeKey(a, b), compositeKey(b, a));
assert.same(compositeKey(a, b, c), compositeKey(a, b, c));
assert.notSame(compositeKey(a, b, c), compositeKey(c, b, a));
assert.notSame(compositeKey(a, b, c), compositeKey(a, c, b));
assert.notSame(compositeKey(a, b, c, 1), compositeKey(a, b, c));
assert.same(compositeKey(a, b, c, 1), compositeKey(a, b, c, 1));
assert.same(compositeKey(1, a), compositeKey(1, a));
assert.notSame(compositeKey(1, a), compositeKey(a, 1));
assert.same(compositeKey(1, a, 2, b), compositeKey(1, a, 2, b));
assert.notSame(compositeKey(1, a, 2, b), compositeKey(1, a, b, 2));
assert.same(compositeKey(1, 2, a, b), compositeKey(1, 2, a, b));
assert.notSame(compositeKey(1, 2, a, b), compositeKey(1, a, b, 2));
assert.same(compositeKey(a, a), compositeKey(a, a));
assert.notSame(compositeKey(a, a), compositeKey(a, ['a']));
assert.notSame(compositeKey(a, a), compositeKey(a, b));
assert.throws(() => compositeKey(), TypeError);
assert.throws(() => compositeKey(1, 2), TypeError);
assert.throws(() => compositeKey('foo', null, true), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.composite-symbol.js
================================================
import Symbol from 'core-js-pure/es/symbol';
import compositeSymbol from 'core-js-pure/full/composite-symbol';
QUnit.test('compositeSymbol', assert => {
assert.isFunction(compositeSymbol);
if (compositeSymbol.name) assert.name(compositeSymbol, 'compositeSymbol');
assert.true(Object(compositeSymbol({})) instanceof Symbol);
const a = ['a'];
const b = ['b'];
const c = ['c'];
assert.same(compositeSymbol(a), compositeSymbol(a));
assert.notSame(compositeSymbol(a), compositeSymbol(['a']));
assert.notSame(compositeSymbol(a), compositeSymbol(a, 1));
assert.notSame(compositeSymbol(a), compositeSymbol(a, b));
assert.same(compositeSymbol(a, 1), compositeSymbol(a, 1));
assert.same(compositeSymbol(a, b), compositeSymbol(a, b));
assert.notSame(compositeSymbol(a, b), compositeSymbol(b, a));
assert.same(compositeSymbol(a, b, c), compositeSymbol(a, b, c));
assert.notSame(compositeSymbol(a, b, c), compositeSymbol(c, b, a));
assert.notSame(compositeSymbol(a, b, c), compositeSymbol(a, c, b));
assert.notSame(compositeSymbol(a, b, c, 1), compositeSymbol(a, b, c));
assert.same(compositeSymbol(a, b, c, 1), compositeSymbol(a, b, c, 1));
assert.same(compositeSymbol(1, a), compositeSymbol(1, a));
assert.notSame(compositeSymbol(1, a), compositeSymbol(a, 1));
assert.same(compositeSymbol(1, a, 2, b), compositeSymbol(1, a, 2, b));
assert.notSame(compositeSymbol(1, a, 2, b), compositeSymbol(1, a, b, 2));
assert.same(compositeSymbol(1, 2, a, b), compositeSymbol(1, 2, a, b));
assert.notSame(compositeSymbol(1, 2, a, b), compositeSymbol(1, a, b, 2));
assert.same(compositeSymbol(a, a), compositeSymbol(a, a));
assert.notSame(compositeSymbol(a, a), compositeSymbol(a, ['a']));
assert.notSame(compositeSymbol(a, a), compositeSymbol(a, b));
assert.same(compositeSymbol(), compositeSymbol());
assert.same(compositeSymbol(1, 2), compositeSymbol(1, 2));
assert.notSame(compositeSymbol(1, 2), compositeSymbol(2, 1));
assert.same(compositeSymbol('foo', null, true), compositeSymbol('foo', null, true));
assert.same(compositeSymbol('string'), Symbol.for('string'));
});
================================================
FILE: tests/unit-pure/esnext.function.demethodize.js
================================================
import demethodize from 'core-js-pure/full/function/demethodize';
QUnit.test('Function#demethodize', assert => {
assert.isFunction(demethodize);
// eslint-disable-next-line prefer-arrow-callback -- required for testing
assert.same(demethodize(function () { return 42; })(), 42);
assert.deepEqual(demethodize(Array.prototype.slice)([1, 2, 3], 1), [2, 3]);
});
================================================
FILE: tests/unit-pure/esnext.function.is-callable.js
================================================
import isCallable from 'core-js-pure/full/function/is-callable';
import { fromSource } from '../helpers/helpers.js';
QUnit.test('Function.isCallable', assert => {
assert.isFunction(isCallable);
assert.arity(isCallable, 1);
assert.name(isCallable, 'isCallable');
assert.false(isCallable({}), 'object');
assert.false(isCallable(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()), 'arguments');
assert.false(isCallable([]), 'array');
assert.false(isCallable(/./), 'regex');
assert.false(isCallable(1), 'number');
assert.false(isCallable(true), 'boolean');
assert.false(isCallable('1'), 'string');
assert.false(isCallable(null), 'null');
assert.false(isCallable(), 'undefined');
assert.true(isCallable(Function.call), 'native function');
// eslint-disable-next-line prefer-arrow-callback -- required
assert.true(isCallable(function () { /* empty */ }), 'function');
const arrow = fromSource('it => it');
if (arrow) assert.true(isCallable(arrow), 'arrow');
const klass = fromSource('class {}');
// Safari 9 and Edge 13- bugs
if (klass && !/constructor|function/.test(klass)) assert.false(isCallable(klass), 'class');
const gen = fromSource('function * () {}');
if (gen) assert.true(isCallable(gen), 'gen');
const asyncFunc = fromSource('async function () {}');
if (asyncFunc) assert.true(isCallable(asyncFunc), 'asyncFunc');
const asyncGen = fromSource('async function* () {}');
if (asyncGen) assert.true(isCallable(asyncGen), 'asyncGen');
const method = fromSource('({f(){}}).f');
// Safari 9 bug
if (method && !/function/.test(method)) assert.true(isCallable(method), 'method');
});
================================================
FILE: tests/unit-pure/esnext.function.is-constructor.js
================================================
import isConstructor from 'core-js-pure/full/function/is-constructor';
import { fromSource } from '../helpers/helpers.js';
QUnit.test('Function.isConstructor', assert => {
assert.isFunction(isConstructor);
assert.arity(isConstructor, 1);
assert.name(isConstructor, 'isConstructor');
assert.false(isConstructor({}), 'object');
assert.false(isConstructor(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()), 'arguments');
assert.false(isConstructor([]), 'array');
assert.false(isConstructor(/./), 'regex');
assert.false(isConstructor(1), 'number');
assert.false(isConstructor(true), 'boolean');
assert.false(isConstructor('1'), 'string');
assert.false(isConstructor(null), 'null');
assert.false(isConstructor(), 'undefined');
// assert.false(isConstructor(Function.call), 'native function'); // fails in some old engines
// eslint-disable-next-line prefer-arrow-callback -- required
assert.true(isConstructor(function () { /* empty */ }), 'function');
const arrow = fromSource('it => it');
if (arrow) assert.false(isConstructor(arrow), 'arrow');
const klass = fromSource('class {}');
// Safari 9 and Edge 13- bugs
if (klass && !/constructor|function/.test(klass)) assert.true(isConstructor(klass), 'class');
const Gen = fromSource('function * () {}');
// V8 ~ Chrome 49- bug
if (Gen) try {
new Gen();
} catch {
assert.false(isConstructor(Gen), 'gen');
}
const asyncFunc = fromSource('async function () {}');
if (asyncFunc) assert.false(isConstructor(asyncFunc), 'asyncFunc');
const asyncGen = fromSource('async function* () {}');
if (asyncGen) assert.false(isConstructor(asyncGen), 'asyncGen');
const method = fromSource('({f(){}}).f');
// Safari 9 bug
if (method && !/function/.test(method)) assert.false(isConstructor(method), 'method');
});
================================================
FILE: tests/unit-pure/esnext.function.metadata.js
================================================
import Symbol from 'core-js-pure/actual/symbol';
QUnit.test('Function#@@metadata', assert => {
assert.true(Symbol.metadata in Function.prototype);
assert.same(Function.prototype[Symbol.metadata], null, 'is null');
});
================================================
FILE: tests/unit-pure/esnext.function.un-this.js
================================================
import unThis from 'core-js-pure/full/function/un-this';
QUnit.test('Function#unThis', assert => {
assert.isFunction(unThis);
// eslint-disable-next-line prefer-arrow-callback -- required for testing
assert.same(unThis(function () { return 42; })(), 42);
assert.deepEqual(unThis(Array.prototype.slice)([1, 2, 3], 1), [2, 3]);
});
================================================
FILE: tests/unit-pure/esnext.iterator.as-indexed-pairs.js
================================================
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/full/iterator';
QUnit.test('Iterator#asIndexedPairs', assert => {
const { asIndexedPairs } = Iterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
assert.nonEnumerable(Iterator.prototype, 'asIndexedPairs');
assert.arrayEqual(asIndexedPairs.call(createIterator(['a', 'b', 'c'])).toArray().toString(), '0,a,1,b,2,c', 'basic functionality');
if (STRICT) {
assert.throws(() => asIndexedPairs.call(undefined), TypeError);
assert.throws(() => asIndexedPairs.call(null), TypeError);
}
assert.throws(() => asIndexedPairs.call({}).next(), TypeError);
assert.throws(() => asIndexedPairs.call([]).next(), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.iterator.chunks.js
================================================
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/full/iterator/index';
import from from 'core-js-pure/es/array/from';
QUnit.test('Iterator#chunks', assert => {
const { chunks } = Iterator.prototype;
assert.isFunction(chunks);
assert.arity(chunks, 1);
assert.name(chunks, 'chunks');
assert.nonEnumerable(Iterator.prototype, 'chunks');
assert.arrayEqual(from(chunks.call(createIterator([1, 2, 3]), 2)), [[1, 2], [3]], 'basic functionality #1');
assert.arrayEqual(from(chunks.call(createIterator([1, 2, 3, 4]), 2)), [[1, 2], [3, 4]], 'basic functionality #2');
assert.arrayEqual(from(chunks.call(createIterator([]), 2)), [], 'basic functionality on empty iterable');
const it = createIterator([1, 2, 3]);
const result = chunks.call(it, 3);
assert.isIterable(result, 'returns iterable');
assert.isIterator(result, 'returns iterator');
assert.true(result instanceof Iterator, 'returns iterator');
assert.deepEqual(result.next(), { done: false, value: [1, 2, 3] }, '.next with active inner iterator result');
assert.deepEqual(result.return(), { done: true, value: undefined }, '.return with active inner iterator result');
assert.deepEqual(result.next(), { done: true, value: undefined }, '.next 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');
});
================================================
FILE: tests/unit-pure/esnext.iterator.indexed.js
================================================
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/full/iterator';
QUnit.test('Iterator#indexed', assert => {
const { indexed } = Iterator.prototype;
assert.isFunction(indexed);
assert.name(indexed, 'indexed');
assert.arity(indexed, 0);
assert.nonEnumerable(Iterator.prototype, 'indexed');
assert.arrayEqual(indexed.call(createIterator(['a', 'b', 'c'])).toArray().toString(), '0,a,1,b,2,c', 'basic functionality');
if (STRICT) {
assert.throws(() => indexed.call(undefined), TypeError);
assert.throws(() => indexed.call(null), TypeError);
}
assert.throws(() => indexed.call({}).next(), TypeError);
assert.throws(() => indexed.call([]).next(), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.iterator.range.js
================================================
/* eslint-disable es/no-bigint -- safe */
import { MAX_SAFE_INTEGER } from '../helpers/constants.js';
import from from 'core-js-pure/es/array/from';
import range from 'core-js-pure/full/iterator/range';
QUnit.test('Iterator.range', assert => {
assert.isFunction(range);
assert.name(range, 'range');
assert.arity(range, 3);
let iterator = range(1, 2);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.deepEqual(from(range(-1, 5)), [-1, 0, 1, 2, 3, 4]);
assert.deepEqual(from(range(-5, 1)), [-5, -4, -3, -2, -1, 0]);
assert.deepEqual(
from(range(0, 1, 0.1)),
[0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9],
);
assert.deepEqual(
from(range(MAX_SAFE_INTEGER, MAX_SAFE_INTEGER + 1, { inclusive: true })),
[MAX_SAFE_INTEGER, MAX_SAFE_INTEGER + 1],
);
assert.deepEqual(from(range(0, 0)), []);
assert.deepEqual(from(range(0, 0, { step: 1, inclusive: true })), []);
assert.deepEqual(from(range(0, 0, -1)), [], 'start === end with negative step yields nothing');
assert.deepEqual(from(range(0, 0, { step: -1, inclusive: true })), [0], 'start === end with negative step inclusive yields start');
assert.deepEqual(from(range(0, -5, 1)), []);
assert.throws(() => range(NaN, 0), RangeError, 'NaN as start');
assert.throws(() => range(0, NaN), RangeError, 'NaN as end');
assert.throws(() => range(NaN, NaN), RangeError, 'NaN as start and end');
assert.throws(() => range(0, 0, { step: NaN }), RangeError, 'NaN as step option');
assert.throws(() => range(0, 5, NaN), RangeError, 'NaN as step argument');
iterator = range(1, 3);
assert.deepEqual(iterator.start, 1);
assert.deepEqual(iterator.end, 3);
assert.deepEqual(iterator.step, 1);
assert.false(iterator.inclusive);
iterator = range(-1, -3, { inclusive: true });
assert.deepEqual(iterator.start, -1);
assert.deepEqual(iterator.end, -3);
assert.same(iterator.step, -1);
assert.true(iterator.inclusive);
iterator = range(0, 5, null);
assert.same(iterator.start, 0, 'null option: start');
assert.same(iterator.end, 5, 'null option: end');
assert.same(iterator.step, 1, 'null option: step defaults to 1');
assert.false(iterator.inclusive, 'null option: inclusive defaults to false');
iterator = range(-1, -3, { step: 4, inclusive() { /* empty */ } });
assert.same(iterator.start, -1);
assert.same(iterator.end, -3);
assert.same(iterator.step, 4);
assert.true(iterator.inclusive);
iterator = range(0, 5);
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
assert.throws(() => Object.getOwnPropertyDescriptor(iterator, 'start').get.call({}), TypeError);
assert.throws(() => range(Infinity, 10, 0), RangeError);
assert.throws(() => range(-Infinity, 10, 0), RangeError);
assert.throws(() => range(0, 10, Infinity), RangeError);
assert.throws(() => range(0, 10, { step: Infinity }), RangeError);
assert.throws(() => range({}, 1), TypeError);
assert.throws(() => range(1, {}), TypeError);
assert.throws(() => range('1', 2), TypeError);
assert.throws(() => range({ valueOf() { return 1; } }, 2), TypeError);
if (typeof BigInt == 'function') {
iterator = range(BigInt(1), BigInt(2));
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: BigInt(1),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.deepEqual(from(range(BigInt(-1), BigInt(5))), [BigInt(-1), BigInt(0), BigInt(1), BigInt(2), BigInt(3), BigInt(4)]);
assert.deepEqual(from(range(BigInt(-5), BigInt(1))), [BigInt(-5), BigInt(-4), BigInt(-3), BigInt(-2), BigInt(-1), BigInt(0)]);
assert.deepEqual(
from(range(BigInt('9007199254740991'), BigInt('9007199254740992'), { inclusive: true })),
[BigInt('9007199254740991'), BigInt('9007199254740992')],
);
assert.deepEqual(from(range(BigInt(0), BigInt(0))), []);
assert.deepEqual(from(range(BigInt(0), BigInt(0), { step: BigInt(1), inclusive: true })), []);
assert.deepEqual(from(range(BigInt(0), BigInt(0), BigInt(-1))), [], 'BigInt: start === end with negative step yields nothing');
assert.deepEqual(from(range(BigInt(0), BigInt(0), { step: BigInt(-1), inclusive: true })), [BigInt(0)], 'BigInt: start === end with negative step inclusive yields start');
assert.deepEqual(from(range(BigInt(0), BigInt(-5), BigInt(1))), []);
iterator = range(BigInt(1), BigInt(3));
assert.deepEqual(iterator.start, BigInt(1));
assert.deepEqual(iterator.end, BigInt(3));
assert.deepEqual(iterator.step, BigInt(1));
assert.false(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { inclusive: true });
assert.deepEqual(iterator.start, BigInt(-1));
assert.deepEqual(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(-1));
assert.true(iterator.inclusive);
iterator = range(BigInt(-1), BigInt(-3), { step: BigInt(4), inclusive() { /* empty */ } });
assert.same(iterator.start, BigInt(-1));
assert.same(iterator.end, BigInt(-3));
assert.same(iterator.step, BigInt(4));
assert.true(iterator.inclusive);
iterator = range(BigInt(0), BigInt(5));
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
assert.throws(() => Object.getOwnPropertyDescriptor(iterator, 'start').get.call({}), TypeError);
assert.throws(() => range(Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(-Infinity, BigInt(10), BigInt(0)), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), Infinity), TypeError);
assert.throws(() => range(BigInt(0), BigInt(10), { step: Infinity }), TypeError);
assert.throws(() => range({}, BigInt(1)), TypeError);
assert.throws(() => range(BigInt(1), {}), TypeError);
}
});
================================================
FILE: tests/unit-pure/esnext.iterator.sliding.js
================================================
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/full/iterator/index';
import from from 'core-js-pure/es/array/from';
QUnit.test('Iterator#sliding', assert => {
const { sliding } = Iterator.prototype;
assert.isFunction(sliding);
assert.arity(sliding, 1);
assert.name(sliding, 'sliding');
assert.nonEnumerable(Iterator.prototype, 'sliding');
assert.arrayEqual(from(sliding.call(createIterator([1, 2, 3]), 2)), [[1, 2], [2, 3]], 'basic functionality #1');
assert.arrayEqual(from(sliding.call(createIterator([1, 2, 3, 4]), 2)), [[1, 2], [2, 3], [3, 4]], 'basic functionality #2');
assert.arrayEqual(from(sliding.call(createIterator([1, 2]), 3)), [[1, 2]], 'basic functionality #3');
assert.arrayEqual(from(sliding.call(createIterator([]), 2)), [], 'basic functionality on empty iterable');
const it = createIterator([1, 2, 3]);
const result = sliding.call(it, 3);
assert.isIterable(result, 'returns iterable');
assert.isIterator(result, 'returns iterator');
assert.true(result instanceof Iterator, 'returns iterator');
assert.deepEqual(result.next(), { done: false, value: [1, 2, 3] }, '.next with active inner iterator result');
assert.deepEqual(result.return(), { done: true, value: undefined }, '.return with active inner iterator result');
assert.deepEqual(result.next(), { done: true, value: undefined }, '.next 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');
});
================================================
FILE: tests/unit-pure/esnext.iterator.to-async.js
================================================
import { STRICT } from '../helpers/constants.js';
import Promise from 'core-js-pure/es/promise';
import Set from 'core-js-pure/es/set';
import ITERATOR from 'core-js-pure/es/symbol/iterator';
import Iterator from 'core-js-pure/actual/iterator';
import 'core-js-pure/actual/async-iterator';
QUnit.test('Iterator#toAsync', assert => {
const { toAsync } = Iterator.prototype;
assert.isFunction(toAsync);
assert.arity(toAsync, 0);
assert.name(toAsync, '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 Iterator.from([1, 2, 3]).toAsync().map(it => Promise.resolve(it)).toArray().then(it => {
assert.arrayEqual(it, [1, 2, 3]);
return Iterator.from(new Set([1, 2, 3])).toAsync().map(el => Promise.resolve(el)).toArray();
}).then(it => {
assert.arrayEqual(it, [1, 2, 3]);
}).then(() => {
return Iterator.from(closableIterator).toAsync().toArray();
}).then(() => {
assert.avoid();
}, error => {
assert.same(error, 42, 'rejection on a `.next()` promise rejection');
assert.true(closableIterator.closed, 'closes sync iterator on promise rejection');
});
});
================================================
FILE: tests/unit-pure/esnext.iterator.windows.js
================================================
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
import Iterator from 'core-js-pure/full/iterator/index';
import from from 'core-js-pure/es/array/from';
QUnit.test('Iterator#windows', assert => {
const { windows } = Iterator.prototype;
assert.isFunction(windows);
assert.arity(windows, 1);
assert.name(windows, 'windows');
assert.nonEnumerable(Iterator.prototype, 'windows');
assert.arrayEqual(from(windows.call(createIterator([1, 2, 3]), 2)), [[1, 2], [2, 3]], 'basic functionality #1');
assert.arrayEqual(from(windows.call(createIterator([1, 2, 3, 4]), 2)), [[1, 2], [2, 3], [3, 4]], 'basic functionality #2');
assert.arrayEqual(from(windows.call(createIterator([1, 2]), 3)), [], 'basic functionality #3');
assert.arrayEqual(from(windows.call(createIterator([]), 2)), [], 'basic functionality on empty iterable');
assert.arrayEqual(from(windows.call(createIterator([1, 2]), 3, 'only-full')), [], 'undersized #1');
assert.arrayEqual(from(windows.call(createIterator([1, 2]), 3, 'allow-partial')), [[1, 2]], 'undersized #2');
const it = createIterator([1, 2, 3]);
const result = windows.call(it, 3);
assert.isIterable(result, 'returns iterable');
assert.isIterator(result, 'returns iterator');
assert.true(result instanceof Iterator, 'returns iterator');
assert.deepEqual(result.next(), { done: false, value: [1, 2, 3] }, '.next with active inner iterator result');
assert.deepEqual(result.return(), { done: true, value: undefined }, '.return with active inner iterator result');
assert.deepEqual(result.next(), { done: true, value: undefined }, '.next 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');
// windows should return independent copies (not the same buffer)
{
const iter = windows.call(createIterator([1, 2, 3, 4, 5]), 3);
const w1 = iter.next().value;
assert.deepEqual(w1, [1, 2, 3], 'window 1');
w1[1] = 99;
const w2 = iter.next().value;
assert.deepEqual(w2, [2, 3, 4], 'window 2 not affected by mutation of window 1');
}
});
================================================
FILE: tests/unit-pure/esnext.iterator.zip-keyed.js
================================================
import { createIterator } from '../helpers/helpers.js';
import { DESCRIPTORS } from '../helpers/constants.js';
import defineProperty from 'core-js-pure/actual/object/define-property';
import from from 'core-js-pure/es/array/from';
import assign from 'core-js-pure/es/object/assign';
import create from 'core-js-pure/es/object/create';
import Symbol from 'core-js-pure/es/symbol';
import Iterator from 'core-js-pure/es/iterator';
import zipKeyed from 'core-js-pure/actual/iterator/zip-keyed';
function nullProto(obj) {
return assign(create(null), obj);
}
QUnit.test('Iterator.zipKeyed', assert => {
assert.isFunction(zipKeyed);
assert.arity(zipKeyed, 1);
assert.name(zipKeyed, 'zipKeyed');
let result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5], c: [7, 8, 9] });
assert.true(result instanceof Iterator, 'Iterator instance');
assert.deepEqual(from(result), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }]);
result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5, 6], c: [7, 8, 9] });
assert.deepEqual(from(result), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }]);
result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5, 6], c: [7, 8, 9] }, { mode: 'longest', padding: { c: 10 } });
assert.deepEqual(from(result), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }, { a: undefined, b: 6, c: 10 }]);
result = zipKeyed({ a: [0, 1, 2], b: [3, 4, 5, 6], c: [7, 8, 9] }, { mode: 'strict' });
assert.throws(() => from(result), TypeError);
if (DESCRIPTORS) {
let obj = {};
defineProperty(obj, 'a', { get: () => [0, 1, 2], enumerable: true });
defineProperty(obj, 'b', { get: () => [3, 4, 5], enumerable: true });
defineProperty(obj, 'c', { get: () => [7, 8, 9], enumerable: true });
defineProperty(obj, Symbol('d'), { get: () => [10, 11, 12] });
assert.deepEqual(from(zipKeyed(obj)), [{ a: 0, b: 3, c: 7 }, { a: 1, b: 4, c: 8 }, { a: 2, b: 5, c: 9 }]);
const it = createIterator([1, 2], {
return() {
this.called = true;
return { done: true, value: undefined };
},
});
obj = { a: it };
defineProperty(obj, 'b', { get: () => { throw new Error(); }, enumerable: true });
assert.throws(() => from(zipKeyed(obj)), Error);
assert.true(it.called, 'iterator return called');
const foo = Symbol('foo');
const bar = Symbol('bar');
const zipped = zipKeyed({ [foo]: [1, 2, 3], [bar]: [4, 5, 6], baz: [7, 8, 9] });
result = from(zipped);
assert.same(result[0][foo], 1);
assert.same(result[0][bar], 4);
assert.same(result[0].baz, 7);
assert.same(result[1][foo], 2);
assert.same(result[1][bar], 5);
assert.same(result[1].baz, 8);
assert.same(result[2][foo], 3);
assert.same(result[2][bar], 6);
assert.same(result[2].baz, 9);
}
{
const $result = zipKeyed({
a: [0, 1, 2],
b: [3, 4, 5, 6, 7],
c: [8, 9],
}, {
mode: 'longest',
});
assert.deepEqual(from($result), [
nullProto({ a: 0, b: 3, c: 8 }),
nullProto({ a: 1, b: 4, c: 9 }),
nullProto({ a: 2, b: 5, c: undefined }),
nullProto({ a: undefined, b: 6, c: undefined }),
nullProto({ a: undefined, b: 7, c: undefined }),
]);
}
{
const $result = zipKeyed({
a: [0, 1, 2],
b: [3, 4, 5, 6, 7],
c: [8, 9],
}, {
mode: 'longest',
padding: { a: 'A', b: 'B', c: 'C' },
});
assert.deepEqual(from($result), [
nullProto({ a: 0, b: 3, c: 8 }),
nullProto({ a: 1, b: 4, c: 9 }),
nullProto({ a: 2, b: 5, c: 'C' }),
nullProto({ a: 'A', b: 6, c: 'C' }),
nullProto({ a: 'A', b: 7, c: 'C' }),
]);
}
assert.throws(() => zipKeyed({ a: [1, 2], b: 'hello' }), TypeError, 'rejects string iterables');
assert.throws(() => zipKeyed({ a: [1, 2], b: 42 }), TypeError, 'rejects number iterables');
});
================================================
FILE: tests/unit-pure/esnext.iterator.zip.js
================================================
import { createIterator } from '../helpers/helpers.js';
import from from 'core-js-pure/es/array/from';
import Iterator from 'core-js-pure/es/iterator';
import Symbol from 'core-js-pure/es/symbol';
import zip from 'core-js-pure/actual/iterator/zip';
QUnit.test('Iterator.zip', assert => {
assert.isFunction(zip);
assert.arity(zip, 1);
assert.name(zip, 'zip');
let result = zip([[1, 2, 3], [4, 5, 6]]);
assert.true(result instanceof Iterator, 'Iterator instance');
assert.deepEqual(from(result), [[1, 4], [2, 5], [3, 6]]);
result = zip([[1, 2, 3], [4, 5, 6, 7]]);
assert.deepEqual(from(result), [[1, 4], [2, 5], [3, 6]]);
result = zip([[1, 2, 3], [4, 5, 6, 7]], { mode: 'longest', padding: [9] });
assert.deepEqual(from(result), [[1, 4], [2, 5], [3, 6], [9, 7]]);
result = zip([[1, 2, 3, 4], [5, 6, 7]], { mode: 'longest', padding: [1, 9] });
assert.deepEqual(from(result), [[1, 5], [2, 6], [3, 7], [4, 9]]);
result = zip([[1, 2, 3], [4, 5, 6], [7, 8, 9]], { mode: 'strict' });
assert.deepEqual(from(result), [[1, 4, 7], [2, 5, 8], [3, 6, 9]]);
result = zip([[1, 2, 3], [4, 5, 6, 7]], { mode: 'strict' });
assert.throws(() => from(result), TypeError);
const observableReturn = {
return() {
this.called = true;
return { done: true, value: undefined };
},
};
{
const it1 = createIterator([1, 2], observableReturn);
const it2 = createIterator([3, 4], observableReturn);
result = zip([it1, it2]);
assert.deepEqual(result.next().value, [1, 3]);
assert.deepEqual(result.return(), { done: true, value: undefined });
assert.deepEqual(result.next(), { done: true, value: undefined });
assert.true(it1.called, 'first iterator return called');
assert.true(it2.called, 'second iterator return called');
}
{
const it = createIterator([1, 2, 3], observableReturn);
result = zip([it, [4, 5]], { mode: 'strict' });
assert.throws(() => from(result), TypeError);
assert.true(it.called, 'iterator return called #1');
}
{
const it = createIterator([3, 4, 5], observableReturn);
result = zip([[1, 2], it], { mode: 'strict' });
assert.throws(() => from(result), TypeError);
assert.true(it.called, 'iterator return called #2');
}
{
const it1 = createIterator([1, 2], { next() { throw new Error(); } });
const it2 = createIterator([3, 4], observableReturn);
result = zip([it1, it2]);
assert.throws(() => from(result), Error);
assert.true(it2.called, 'iterator return called #4');
}
{
const expectedError = new TypeError('strict next error');
let it2calls = 0;
const it2 = createIterator([2], {
next() {
if (it2calls++) throw expectedError;
return { value: 2, done: false };
},
});
result = zip([createIterator([1]), it2], { mode: 'strict' });
result.next();
let caught;
try {
result.next();
} catch (error) {
caught = error;
}
assert.same(caught, expectedError, 'strict mode propagates error from .next() during exhaustion check');
}
{
const $result = zip([
[0, 1, 2],
[3, 4, 5, 6, 7],
[8, 9],
], {
mode: 'longest',
});
assert.deepEqual(from($result), [
[0, 3, 8],
[1, 4, 9],
[2, 5, undefined],
[undefined, 6, undefined],
[undefined, 7, undefined],
]);
}
{
const $result = zip([
[0, 1, 2],
[3, 4, 5, 6, 7],
[8, 9],
], {
mode: 'longest',
padding: ['A', 'B', 'C'],
});
assert.deepEqual(from($result), [
[0, 3, 8],
[1, 4, 9],
[2, 5, 'C'],
['A', 6, 'C'],
['A', 7, 'C'],
]);
}
{
const expectedError = new TypeError('not iterable');
const badIterable = { [Symbol.iterator]() { throw expectedError; } };
const it1 = createIterator([1, 2], observableReturn);
let caught;
try {
zip([it1, badIterable]);
} catch (error) {
caught = error;
}
assert.same(caught, expectedError, 'original error is preserved');
assert.true(it1.called, 'first iterator return called on non-iterable second element');
}
{
const expectedError = new TypeError('inner return error');
const throwingReturn = {
return() {
throw expectedError;
},
};
const it1 = createIterator([1, 2], throwingReturn);
const it2 = createIterator([3, 4], observableReturn);
result = zip([it1, it2]);
result.next();
let caught;
try {
result.return();
} catch (error) {
caught = error;
}
assert.same(caught, expectedError, 'propagates the original error from inner return()');
}
assert.throws(() => zip(['hello', [1, 2, 3]]), TypeError, 'rejects string iterables');
assert.throws(() => zip([42, [1, 2, 3]]), TypeError, 'rejects number iterables');
{
// iterator-zip: .next() result must be validated as an object
const primitiveNextIter = {
[Symbol.iterator]() {
return { next() { return 42; } };
},
};
const normalIter = [1, 2, 3];
const zipped = zip([primitiveNextIter, normalIter]);
assert.throws(() => zipped.next(), TypeError, 'throws on non-object .next() result');
}
});
================================================
FILE: tests/unit-pure/esnext.map.delete-all.js
================================================
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map#deleteAll', assert => {
const { deleteAll } = Map.prototype;
assert.isFunction(deleteAll);
assert.name(deleteAll, 'deleteAll');
assert.arity(deleteAll, 0);
assert.nonEnumerable(Map.prototype, 'deleteAll');
let map = new Map([[1, 2], [2, 3], [3, 4]]);
assert.true(map.deleteAll(1, 2));
assert.deepEqual(from(map), [[3, 4]]);
map = new Map([[1, 2], [2, 3], [3, 4]]);
assert.false(map.deleteAll(3, 4));
assert.deepEqual(from(map), [[1, 2], [2, 3]]);
map = new Map([[1, 2], [2, 3], [3, 4]]);
assert.false(map.deleteAll(4, 5));
assert.deepEqual(from(map), [[1, 2], [2, 3], [3, 4]]);
map = new Map([[1, 2], [2, 3], [3, 4]]);
assert.true(map.deleteAll());
assert.deepEqual(from(map), [[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);
});
================================================
FILE: tests/unit-pure/esnext.map.emplace.js
================================================
import Map from 'core-js-pure/full/map';
QUnit.test('Map#emplace', assert => {
const { emplace } = Map.prototype;
assert.isFunction(emplace);
assert.arity(emplace, 2);
assert.name(emplace, 'emplace');
assert.nonEnumerable(Map.prototype, 'emplace');
const map = new Map([['a', 2]]);
let handler = {
update(value, key, that) {
assert.same(this, handler, 'correct handler in callback');
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 'a', 'correct key in callback');
assert.same(that, map, 'correct map in callback');
return value ** 2;
},
insert() {
assert.avoid();
},
};
assert.same(map.emplace('a', handler), 4, 'returns a correct value');
handler = {
update() {
assert.avoid();
},
insert(key, that) {
assert.same(this, handler, 'correct handler in callback');
assert.same(arguments.length, 2, 'correct number of callback arguments');
assert.same(key, 'b', 'correct key in callback');
assert.same(that, map, 'correct map in callback');
return 3;
},
};
assert.same(map.emplace('b', handler), 3, 'returns a correct value');
assert.same(map.size, 2, 'correct size');
assert.same(map.get('a'), 4, 'correct result #1');
assert.same(map.get('b'), 3, 'correct result #2');
assert.same(new Map([['a', 2]]).emplace('b', { insert: () => 3 }), 3);
assert.same(new Map([['a', 2]]).emplace('a', { update: value => value ** 2 }), 4);
handler = { update() { /* empty */ }, insert() { /* empty */ } };
assert.throws(() => new Map().emplace('a'), TypeError);
assert.throws(() => emplace.call({}, 'a', handler), TypeError);
assert.throws(() => emplace.call([], 'a', handler), TypeError);
assert.throws(() => emplace.call(undefined, 'a', handler), TypeError);
assert.throws(() => emplace.call(null, 'a', handler), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.every.js
================================================
import Map from 'core-js-pure/full/map';
QUnit.test('Map#every', assert => {
const { every } = Map.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.nonEnumerable(Map.prototype, 'every');
let map = new Map([[9, 1]]);
const context = {};
map.every(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 9, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
map = new Map([[0, 1], [1, 2], [2, 3]]);
assert.true(map.every(it => typeof it == 'number'));
assert.true(map.every(it => it < 4));
assert.false(map.every(it => it < 3));
assert.false(map.every(it => typeof it == 'string'));
assert.true(map.every(function () {
return +this === 1;
}, 1));
let result = '';
map.every((value, key) => result += key);
assert.same(result, '012');
assert.true(map.every((value, key, that) => that === map));
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.filter.js
================================================
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map#filter', assert => {
const { filter } = Map.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.nonEnumerable(Map.prototype, 'filter');
const map = new Map([[1, 2]]);
const context = {};
map.filter(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).filter(it => typeof it == 'number')), [
['a', 1],
[1, 2],
['b', 3],
[3, 4],
[4, 5],
]);
assert.true(new Map().filter(it => it) instanceof Map);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.find-key.js
================================================
import Map from 'core-js-pure/full/map';
QUnit.test('Map#findKey', assert => {
const { findKey } = Map.prototype;
assert.isFunction(findKey);
assert.name(findKey, 'findKey');
assert.arity(findKey, 1);
assert.nonEnumerable(Map.prototype, 'findKey');
const map = new Map([[1, 2]]);
const context = {};
map.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, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Map([[1, 2], [2, 3], [3, 4]]).findKey(it => it % 2), 2);
assert.same(new Map().findKey(it => it === 42), undefined);
assert.throws(() => findKey.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.find.js
================================================
import Map from 'core-js-pure/full/map';
QUnit.test('Map#find', assert => {
const { find } = Map.prototype;
assert.isFunction(find);
assert.name(find, 'find');
assert.arity(find, 1);
assert.nonEnumerable(Map.prototype, 'find');
const map = new Map([[1, 2]]);
const context = {};
map.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, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Map([[1, 2], [2, 3], [3, 4]]).find(it => it % 2), 3);
assert.same(new Map().find(it => it === 42), undefined);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.from.js
================================================
import { createIterable } from '../helpers/helpers.js';
import toArray from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map.from', assert => {
const { from } = Map;
assert.isFunction(from);
assert.name(from, 'from');
assert.arity(from, 1);
assert.true(from([]) instanceof Map);
assert.deepEqual(toArray(from([])), []);
assert.deepEqual(toArray(from([[1, 2]])), [[1, 2]]);
assert.deepEqual(toArray(from([[1, 2], [2, 3], [1, 4]])), [[1, 4], [2, 3]]);
assert.deepEqual(toArray(from(createIterable([[1, 2], [2, 3], [1, 4]]))), [[1, 4], [2, 3]]);
const pair = [1, 2];
const context = {};
from([pair], function (element, index) {
assert.same(element, pair);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
});
================================================
FILE: tests/unit-pure/esnext.map.includes.js
================================================
import Map from 'core-js-pure/full/map';
QUnit.test('Map#includes', assert => {
const { includes } = Map.prototype;
assert.isFunction(includes);
assert.name(includes, 'includes');
assert.arity(includes, 1);
assert.nonEnumerable(Map.prototype, 'includes');
const object = {};
const map = new Map([[1, 1], [2, 2], [3, 3], [4, -0], [5, object], [6, NaN]]);
assert.true(map.includes(1));
assert.true(map.includes(-0));
assert.true(map.includes(0));
assert.true(map.includes(object));
assert.false(map.includes(4));
assert.false(map.includes(-0.5));
assert.false(map.includes({}));
assert.true(map.includes(NaN));
assert.throws(() => includes.call({}, 1), TypeError);
assert.throws(() => includes.call(undefined, 1), TypeError);
assert.throws(() => includes.call(null, 1), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.key-by.js
================================================
import { createIterable } from '../helpers/helpers.js';
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map.keyBy', assert => {
const { keyBy } = Map;
assert.isFunction(keyBy);
assert.arity(keyBy, 2);
assert.name(keyBy, 'keyBy');
assert.true(Map.keyBy([], it => it) instanceof Map);
assert.deepEqual(from(Map.keyBy([], it => it)), []);
assert.deepEqual(from(Map.keyBy([1, 2], it => it ** 2)), [[1, 1], [4, 2]]);
assert.deepEqual(from(Map.keyBy([1, 2, 1], it => it ** 2)), [[1, 1], [4, 2]]);
assert.deepEqual(from(Map.keyBy(createIterable([1, 2]), it => it ** 2)), [[1, 1], [4, 2]]);
const element = {};
Map.keyBy([element], it => assert.same(it, element));
// assert.throws(() => keyBy([1, 2], it => it));
});
================================================
FILE: tests/unit-pure/esnext.map.key-of.js
================================================
import Map from 'core-js-pure/full/map';
QUnit.test('Map#keyOf', assert => {
const { keyOf } = Map.prototype;
assert.isFunction(keyOf);
assert.name(keyOf, 'keyOf');
assert.arity(keyOf, 1);
assert.nonEnumerable(Map.prototype, 'keyOf');
const object = {};
const map = new Map([[1, 1], [2, 2], [3, 3], [4, -0], [5, object], [6, NaN]]);
assert.same(map.keyOf(1), 1);
assert.same(map.keyOf(-0), 4);
assert.same(map.keyOf(0), 4);
assert.same(map.keyOf(object), 5);
assert.same(map.keyOf(4), undefined);
assert.same(map.keyOf(-0.5), undefined);
assert.same(map.keyOf({}), undefined);
assert.same(map.keyOf(NaN), undefined);
assert.throws(() => keyOf.call({}, 1), TypeError);
assert.throws(() => keyOf.call(undefined, 1), TypeError);
assert.throws(() => keyOf.call(null, 1), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.map-keys.js
================================================
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map#mapKeys', assert => {
const { mapKeys } = Map.prototype;
assert.isFunction(mapKeys);
assert.arity(mapKeys, 1);
assert.name(mapKeys, 'mapKeys');
assert.nonEnumerable(Map.prototype, 'mapKeys');
const map = new Map([[1, 2]]);
const context = {};
map.mapKeys(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(new Map().mapKeys(it => it) instanceof Map);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).mapKeys((value, key) => `${ key }${ value }`)), [
['a1', 1],
['12', 2],
['b3', 3],
['2q', 'q'],
['c[object Object]', {}],
['34', 4],
['dtrue', true],
['45', 5],
]);
assert.throws(() => mapKeys.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => mapKeys.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => mapKeys.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.map-values.js
================================================
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map#mapValues', assert => {
const { mapValues } = Map.prototype;
assert.isFunction(mapValues);
assert.arity(mapValues, 1);
assert.name(mapValues, 'mapValues');
assert.nonEnumerable(Map.prototype, 'mapValues');
const map = new Map([[1, 2]]);
const context = {};
map.mapValues(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(new Map().mapValues(it => it) instanceof Map);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).mapValues((value, key) => `${ key }${ value }`)), [
['a', 'a1'],
[1, '12'],
['b', 'b3'],
[2, '2q'],
['c', 'c[object Object]'],
[3, '34'],
['d', 'dtrue'],
[4, '45'],
]);
assert.throws(() => mapValues.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => mapValues.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => mapValues.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.merge.js
================================================
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map#merge', assert => {
const { merge } = Map.prototype;
assert.isFunction(merge);
assert.arity(merge, 1);
assert.name(merge, 'merge');
assert.nonEnumerable(Map.prototype, 'merge');
const map = new Map([[1, 2]]);
const result = map.merge([[3, 4]]);
assert.same(result, map);
assert.true(result instanceof Map);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[5, 6]])), [[1, 2], [3, 4], [5, 6]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[3, 5], [5, 6]])), [[1, 2], [3, 5], [5, 6]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([])), [[1, 2], [3, 4]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[3, 5]], [[5, 6]])), [[1, 2], [3, 5], [5, 6]]);
assert.throws(() => merge.call({}, [[1, 2]]), TypeError);
assert.throws(() => merge.call(undefined, [[1, 2]]), TypeError);
assert.throws(() => merge.call(null, [[1, 2]]), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.of.js
================================================
import from from 'core-js-pure/es/array/from';
import Map from 'core-js-pure/full/map';
QUnit.test('Map.of', assert => {
const { of } = Map;
assert.isFunction(of);
assert.name(of, 'of');
assert.arity(of, 0);
assert.true(of() instanceof Map);
assert.deepEqual(from(of([1, 2])), [[1, 2]]);
assert.deepEqual(from(of([1, 2], [2, 3], [1, 4])), [[1, 4], [2, 3]]);
});
================================================
FILE: tests/unit-pure/esnext.map.reduce.js
================================================
import Map from 'core-js-pure/full/map';
QUnit.test('Map#reduce', assert => {
const { reduce } = Map.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.nonEnumerable(Map.prototype, 'reduce');
const map = new Map([['a', 1]]);
const accumulator = {};
map.reduce(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 'a', 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
}, accumulator);
assert.same(new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce((a, b) => a + b, 1), 7, 'works with initial accumulator');
new Map([
['a', 1],
['b', 2],
]).reduce((memo, value, key) => {
assert.same(memo, 1, 'correct default accumulator');
assert.same(value, 2, 'correct start value without initial accumulator');
assert.same(key, 'b', 'correct start key without initial accumulator');
});
assert.same(new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce((memo, value, key, s) => {
s.delete('b');
values += value;
keys += key;
}, 0);
assert.same(values, '13', 'correct order #1');
assert.same(keys, 'ac', 'correct order #2');
assert.throws(() => reduce.call({}, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.some.js
================================================
import Map from 'core-js-pure/full/map';
QUnit.test('Map#some', assert => {
const { some } = Map.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.nonEnumerable(Map.prototype, 'some');
let map = new Map([[9, 1]]);
const context = {};
map.some(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 9, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
map = new Map([[0, 1], [1, '2'], [2, 3]]);
assert.true(map.some(it => typeof it == 'number'));
assert.true(map.some(it => it < 3));
assert.false(map.some(it => it < 0));
assert.true(map.some(it => typeof it == 'string'));
assert.false(map.some(function () {
return +this !== 1;
}, 1));
let result = '';
map.some((value, key) => {
result += key;
return false;
});
assert.same(result, '012');
assert.true(map.some((value, key, that) => that === map));
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.update-or-insert.js
================================================
import Map from 'core-js-pure/full/map';
QUnit.test('Map#updateOrInsert', assert => {
const { updateOrInsert } = Map.prototype;
assert.isFunction(updateOrInsert);
assert.arity(updateOrInsert, 2);
assert.nonEnumerable(Map.prototype, 'updateOrInsert');
const map = new Map([['a', 2]]);
assert.same(map.updateOrInsert('a', function (value) {
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
return value ** 2;
}, () => {
assert.avoid();
return 3;
}), 4, 'returns a correct value');
assert.same(map.updateOrInsert('b', value => {
assert.avoid();
return value ** 2;
}, function () {
assert.same(arguments.length, 0, 'correct number of callback arguments');
return 3;
}), 3, 'returns a correct value');
assert.same(map.size, 2, 'correct size');
assert.same(map.get('a'), 4, 'correct result #1');
assert.same(map.get('b'), 3, 'correct result #2');
assert.same(new Map([['a', 2]]).updateOrInsert('b', null, () => 3), 3);
assert.same(new Map([['a', 2]]).updateOrInsert('a', value => value ** 2), 4);
assert.throws(() => new Map().updateOrInsert('a'), TypeError);
assert.throws(() => updateOrInsert.call({}, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call([], 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call(undefined, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call(null, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.update.js
================================================
import Map from 'core-js-pure/full/map';
QUnit.test('Map#update', assert => {
const { update } = Map.prototype;
assert.isFunction(update);
assert.arity(update, 2);
assert.name(update, 'update');
assert.nonEnumerable(Map.prototype, 'update');
let map = new Map([[9, 2]]);
assert.same(map.update(9, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 9, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
return value * 2;
}), map, 'returns this');
assert.same(map.size, 1, 'correct size');
assert.same(map.get(9), 4, 'correct result');
map = new Map([[4, 5]]);
map.update(9, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 9, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
return value * 2;
}, function (key, that) {
assert.same(arguments.length, 2, 'correct number of thunk arguments');
assert.same(key, 9, 'correct key in thunk');
assert.same(that, map, 'correct link to map in thunk');
return 2;
});
assert.same(map.size, 2, 'correct size');
assert.same(map.get(4), 5, 'correct result #1');
assert.same(map.get(9), 4, 'correct result #2');
assert.throws(() => new Map([[9, 2]]).update(9), TypeError);
assert.throws(() => new Map().update(9, () => { /* empty */ }), TypeError);
assert.throws(() => update.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => update.call([], () => { /* empty */ }), TypeError);
assert.throws(() => update.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => update.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.map.upsert.js
================================================
import Map from 'core-js-pure/full/map';
QUnit.test('Map#upsert', assert => {
const { upsert } = Map.prototype;
assert.isFunction(upsert);
assert.name(upsert, 'upsert');
assert.arity(upsert, 2);
assert.nonEnumerable(Map.prototype, 'upsert');
const map = new Map([['a', 2]]);
assert.same(map.upsert('a', function (value) {
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
return value ** 2;
}, () => {
assert.avoid();
return 3;
}), 4, 'returns a correct value');
assert.same(map.upsert('b', value => {
assert.avoid();
return value ** 2;
}, function () {
assert.same(arguments.length, 0, 'correct number of callback arguments');
return 3;
}), 3, 'returns a correct value');
assert.same(map.size, 2, 'correct size');
assert.same(map.get('a'), 4, 'correct result #1');
assert.same(map.get('b'), 3, 'correct result #2');
assert.same(new Map([['a', 2]]).upsert('b', null, () => 3), 3);
assert.same(new Map([['a', 2]]).upsert('a', value => value ** 2), 4);
assert.throws(() => new Map().upsert('a'), TypeError);
assert.throws(() => upsert.call({}, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call([], 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(undefined, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(null, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.math.clamp.js
================================================
import clamp from 'core-js-pure/full/math/clamp';
QUnit.test('Math.clamp', assert => {
assert.isFunction(clamp);
assert.arity(clamp, 3);
assert.name(clamp, 'clamp');
assert.same(clamp(2, 4, 6), 4);
assert.same(clamp(4, 2, 6), 4);
assert.same(clamp(6, 2, 4), 4);
assert.same(clamp(-0, 0, 1), 0, 'If value is -0𝔽 and min is +0𝔽, return +0𝔽.');
assert.same(clamp(0, -0, 1), 0, 'If value is +0𝔽 and min is -0𝔽, return +0𝔽.');
assert.same(clamp(-0, -1, 0), -0, 'If value is -0𝔽 and max is +0𝔽, return -0𝔽.');
assert.same(clamp(0, -1, -0), -0, 'If value is +0𝔽 and max is -0𝔽, return -0𝔽.');
assert.same(clamp(0, -0, -0), -0, 'If min = max return min.');
assert.same(clamp(2, 0, -0), -0, 'min is +0𝔽 and max is -0𝔽');
assert.same(clamp(2, 3, 1), 1, 'min > max');
assert.same(clamp(NaN, 3, 1), NaN, 'If value is NaN, return NaN.');
assert.same(clamp(2, NaN, 1), NaN, 'If min is NaN, return NaN.');
assert.same(clamp(2, 3, NaN), NaN, 'If max is NaN, return NaN.');
assert.throws(() => clamp({ valueOf: () => 2 }, 1, 3), TypeError, 'If value is not a Number, throw a TypeError exception');
assert.throws(() => clamp(2, Object(1), 3), TypeError, 'If min is not a Number, throw a TypeError exception.');
assert.throws(() => clamp(2, 1, Object(3)), TypeError, 'If max is not a Number, throw a TypeError exception.');
});
================================================
FILE: tests/unit-pure/esnext.math.deg-per-rad.js
================================================
import DEG_PER_RAD from 'core-js-pure/full/math/deg-per-rad';
QUnit.test('Math.DEG_PER_RAD', assert => {
assert.same(DEG_PER_RAD, Math.PI / 180, 'Is Math.PI / 180');
});
================================================
FILE: tests/unit-pure/esnext.math.degrees.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import degrees from 'core-js-pure/full/math/degrees';
QUnit.test('Math.degrees', assert => {
assert.isFunction(degrees);
assert.arity(degrees, 1);
assert.name(degrees, 'degrees');
assert.same(degrees(0), 0);
assert.same(degrees(Math.PI / 2), 90);
assert.same(degrees(Math.PI), 180);
assert.same(degrees(3 * Math.PI / 2), 270);
const checker = createConversionChecker(3 * Math.PI / 2);
assert.same(degrees(checker), 270, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/esnext.math.fscale.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import fround from 'core-js-pure/full/math/fround';
import fscale from 'core-js-pure/full/math/fscale';
QUnit.test('Math.fscale', assert => {
assert.isFunction(fscale);
assert.arity(fscale, 5);
assert.name(fscale, 'fscale');
assert.same(fscale(3, 1, 2, 1, 2), 3);
assert.same(fscale(0, 3, 5, 8, 10), 5);
assert.same(fscale(1, 1, 1, 1, 1), NaN);
assert.same(fscale(-1, -1, -1, -1, -1), NaN);
assert.same(fscale(3, 1, 2, 1, Math.PI), fround((3 - 1) * (Math.PI - 1) / (2 - 1) + 1));
const checker1 = createConversionChecker(3);
const checker2 = createConversionChecker(1);
const checker3 = createConversionChecker(2);
const checker4 = createConversionChecker(1);
const checker5 = createConversionChecker(2);
assert.same(fscale(checker1, checker2, checker3, checker4, checker5), 3, 'object wrapper');
assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
assert.same(checker1.$toString, 0, 'checker1 toString calls');
assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
assert.same(checker2.$toString, 0, 'checker2 toString calls');
assert.same(checker3.$valueOf, 1, 'checker3 valueOf calls');
assert.same(checker3.$toString, 0, 'checker3 toString calls');
assert.same(checker4.$valueOf, 1, 'checker4 valueOf calls');
assert.same(checker4.$toString, 0, 'checker4 toString calls');
assert.same(checker5.$valueOf, 1, 'checker5 valueOf calls');
assert.same(checker5.$toString, 0, 'checker5 toString calls');
});
================================================
FILE: tests/unit-pure/esnext.math.iaddh.js
================================================
import iaddh from 'core-js-pure/full/math/iaddh';
QUnit.test('Math.iaddh', assert => {
assert.isFunction(iaddh);
assert.arity(iaddh, 4);
assert.name(iaddh, 'iaddh');
assert.same(iaddh(0, 2, 1, 0), 2);
assert.same(iaddh(0, 4, 1, 1), 5);
assert.same(iaddh(2, 4, 1, 1), 5);
assert.same(iaddh(0xFFFFFFFF, 4, 1, 1), 6);
assert.same(iaddh(1, 4, 0xFFFFFFFF, 1), 6);
});
================================================
FILE: tests/unit-pure/esnext.math.imulh.js
================================================
import imulh from 'core-js-pure/full/math/imulh';
QUnit.test('Math.imulh', assert => {
assert.isFunction(imulh);
assert.arity(imulh, 2);
assert.name(imulh, 'imulh');
assert.same(imulh(0xFFFFFFFF, 7), -1);
assert.same(imulh(0xFFFFFFF, 77), 4);
assert.same(imulh(1, 7), 0);
assert.same(imulh(-1, 7), -1);
});
================================================
FILE: tests/unit-pure/esnext.math.isubh.js
================================================
import isubh from 'core-js-pure/full/math/isubh';
QUnit.test('Math.isubh', assert => {
assert.isFunction(isubh);
assert.arity(isubh, 4);
assert.name(isubh, 'isubh');
assert.same(isubh(0, 2, 1, 0), 1);
assert.same(isubh(0, 4, 1, 1), 2);
assert.same(isubh(2, 4, 1, 1), 3);
assert.same(isubh(0xFFFFFFFF, 4, 1, 1), 3);
assert.same(isubh(1, 4, 0xFFFFFFFF, 1), 2);
});
================================================
FILE: tests/unit-pure/esnext.math.rad-per-deg.js
================================================
import RAD_PER_DEG from 'core-js-pure/full/math/rad-per-deg';
QUnit.test('Math.RAD_PER_DEG', assert => {
assert.same(RAD_PER_DEG, 180 / Math.PI, 'Is 180 / Math.PI');
});
================================================
FILE: tests/unit-pure/esnext.math.radians.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import radians from 'core-js-pure/full/math/radians';
QUnit.test('Math.radians', assert => {
assert.isFunction(radians);
assert.arity(radians, 1);
assert.name(radians, 'radians');
assert.same(radians(0), 0);
assert.same(radians(90), Math.PI / 2);
assert.same(radians(180), Math.PI);
assert.same(radians(270), 3 * Math.PI / 2);
const checker = createConversionChecker(270);
assert.same(radians(checker), 3 * Math.PI / 2, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/esnext.math.scale.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import scale from 'core-js-pure/full/math/scale';
QUnit.test('Math.scale', assert => {
assert.isFunction(scale);
assert.arity(scale, 5);
assert.name(scale, 'scale');
assert.same(scale(3, 1, 2, 1, 2), 3);
assert.same(scale(0, 3, 5, 8, 10), 5);
assert.same(scale(1, 1, 1, 1, 1), NaN);
assert.same(scale(-1, -1, -1, -1, -1), NaN);
const checker1 = createConversionChecker(3);
const checker2 = createConversionChecker(1);
const checker3 = createConversionChecker(2);
const checker4 = createConversionChecker(1);
const checker5 = createConversionChecker(2);
assert.same(scale(checker1, checker2, checker3, checker4, checker5), 3, 'object wrapper');
assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
assert.same(checker1.$toString, 0, 'checker1 toString calls');
assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
assert.same(checker2.$toString, 0, 'checker2 toString calls');
assert.same(checker3.$valueOf, 1, 'checker3 valueOf calls');
assert.same(checker3.$toString, 0, 'checker3 toString calls');
assert.same(checker4.$valueOf, 1, 'checker4 valueOf calls');
assert.same(checker4.$toString, 0, 'checker4 toString calls');
assert.same(checker5.$valueOf, 1, 'checker5 valueOf calls');
assert.same(checker5.$toString, 0, 'checker5 toString calls');
});
================================================
FILE: tests/unit-pure/esnext.math.seeded-prng.js
================================================
import seededPRNG from 'core-js-pure/full/math/seeded-prng';
QUnit.test('Math.seededPRNG', assert => {
assert.isFunction(seededPRNG);
assert.arity(seededPRNG, 1);
assert.name(seededPRNG, 'seededPRNG');
for (const gen of [seededPRNG({ seed: 42 }), seededPRNG({ seed: 42 })]) {
assert.deepEqual(gen.next(), { value: 0.16461519912315087, done: false });
assert.deepEqual(gen.next(), { value: 0.2203933906000046, done: false });
assert.deepEqual(gen.next(), { value: 0.8249682894209105, done: false });
assert.deepEqual(gen.next(), { value: 0.10750079537509083, done: false });
assert.deepEqual(gen.next(), { value: 0.004673248161257476, done: false });
}
for (const gen of [seededPRNG({ seed: 43 }), seededPRNG({ seed: 43 })]) {
assert.deepEqual(gen.next(), { value: 0.1923438591811283, done: false });
assert.deepEqual(gen.next(), { value: 0.7896811578326683, done: false });
assert.deepEqual(gen.next(), { value: 0.9518230761883996, done: false });
assert.deepEqual(gen.next(), { value: 0.1414634102410296, done: false });
assert.deepEqual(gen.next(), { value: 0.7379838030207752, done: false });
}
assert.throws(() => seededPRNG(), TypeError);
assert.throws(() => seededPRNG(5), TypeError);
assert.throws(() => seededPRNG({ seed: null }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.math.signbit.js
================================================
import { createConversionChecker } from '../helpers/helpers.js';
import signbit from 'core-js-pure/full/math/signbit';
QUnit.test('Math.signbit', assert => {
assert.isFunction(signbit);
assert.arity(signbit, 1);
assert.name(signbit, 'signbit');
assert.false(signbit(NaN));
assert.false(signbit());
assert.true(signbit(-0));
assert.false(signbit(0));
assert.false(signbit(Infinity));
assert.true(signbit(-Infinity));
assert.false(signbit(13510798882111488));
assert.true(signbit(-13510798882111488));
assert.false(signbit(42.5));
assert.true(signbit(-42.5));
const checker = createConversionChecker(-13510798882111488);
assert.true(signbit(checker), 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
================================================
FILE: tests/unit-pure/esnext.math.umulh.js
================================================
import umulh from 'core-js-pure/full/math/umulh';
QUnit.test('Math.umulh', assert => {
assert.isFunction(umulh);
assert.arity(umulh, 2);
assert.name(umulh, 'umulh');
assert.same(umulh(0xFFFFFFFF, 7), 6);
assert.same(umulh(0xFFFFFFF, 77), 4);
assert.same(umulh(1, 7), 0);
assert.same(umulh(-1, 7), 6);
});
================================================
FILE: tests/unit-pure/esnext.number.clamp.js
================================================
import clamp from 'core-js-pure/full/number/clamp';
QUnit.test('Number#clamp', assert => {
assert.isFunction(clamp);
assert.same(clamp(2, 4, 6), 4);
assert.same(clamp(4, 2, 6), 4);
assert.same(clamp(6, 2, 4), 4);
assert.same(clamp(-0, 0, 1), 0, 'If value is -0𝔽 and min is +0𝔽, return +0𝔽.');
assert.same(clamp(0, -0, 1), 0, 'If value is +0𝔽 and min is -0𝔽, return +0𝔽.');
assert.same(clamp(-0, -1, 0), -0, 'If value is -0𝔽 and max is +0𝔽, return -0𝔽.');
assert.same(clamp(0, -1, -0), -0, 'If value is +0𝔽 and max is -0𝔽, return -0𝔽.');
assert.same(clamp(0, -0, -0), -0, 'If min = max return min.');
assert.same(clamp(2, 0, -0), -0, 'min is +0𝔽 and max is -0𝔽');
assert.same(clamp(2, 3, 1), 1, 'min > max');
assert.same(clamp(NaN, 3, 1), NaN, 'If value is NaN, return NaN.');
assert.same(clamp(2, NaN, 1), NaN, 'If min is NaN, return NaN.');
assert.same(clamp(2, 3, NaN), NaN, 'If max is NaN, return NaN.');
assert.throws(() => clamp({ valueOf: () => 2 }, 1, 3), TypeError, 'If value is not a Number, throw a TypeError exception');
assert.throws(() => clamp(2, Object(1), 3), TypeError, 'If min is not a Number, throw a TypeError exception.');
assert.throws(() => clamp(2, 1, Object(3)), TypeError, 'If max is not a Number, throw a TypeError exception.');
});
================================================
FILE: tests/unit-pure/esnext.number.from-string.js
================================================
import fromString from 'core-js-pure/full/number/from-string';
QUnit.test('Number.fromString', assert => {
assert.isFunction(fromString);
assert.name(fromString, 'fromString');
assert.arity(fromString, 2);
assert.throws(() => fromString(undefined), TypeError, 'The first argument should be a string #1');
assert.throws(() => fromString(Object('10')), TypeError, 'The first argument should be a string #2');
assert.throws(() => fromString(''), SyntaxError, 'Empty string');
assert.same(fromString('-10', 2), -2, 'Works with negative numbers');
assert.throws(() => fromString('-'), SyntaxError, '-');
assert.same(fromString('10'), 10, 'Default radix is 10 #1');
assert.same(fromString('10', undefined), 10, 'Default radix is 10 #2');
for (let radix = 2; radix <= 36; ++radix) {
assert.same(fromString('10', radix), radix, `Radix ${ radix }`);
}
assert.throws(() => fromString('10', -4294967294), RangeError, 'Radix uses ToInteger #1');
assert.same(fromString('10', 2.5), 2, 'Radix uses ToInteger #2');
assert.same(fromString('42'), 42);
assert.same(fromString('42', 10), 42);
assert.same(fromString('3.14159', 10), 3.14159);
assert.same(fromString('-100.11', 2), -4.75);
assert.same(fromString('202.1', 3), 20.333333333333332);
assert.same(fromString('0'), 0);
assert.same(fromString('0', 2), 0);
assert.same(fromString('-0'), -0);
assert.same(fromString('-0', 2), -0);
assert.throws(() => fromString('0xc0ffee'), SyntaxError);
assert.throws(() => fromString('0o755'), SyntaxError);
assert.throws(() => fromString('0b00101010'), SyntaxError);
assert.throws(() => fromString('C0FFEE', 16), SyntaxError);
assert.same(fromString('c0ffee', 16), 12648430);
assert.same(fromString('755', 8), 493);
assert.throws(() => fromString(' '), SyntaxError);
assert.throws(() => fromString(' 1'), SyntaxError);
assert.throws(() => fromString(' \n '), SyntaxError);
assert.throws(() => fromString('x'), SyntaxError);
assert.throws(() => fromString('1234', 0), RangeError);
assert.throws(() => fromString('1234', 1), RangeError);
assert.throws(() => fromString('1234', 37), RangeError);
assert.throws(() => fromString('010'), SyntaxError);
assert.throws(() => fromString('1_000_000_000'), SyntaxError);
assert.same(fromString('1.0'), 1, 'trailing fractional zero');
assert.same(fromString('1.00'), 1, 'trailing fractional zeros');
assert.same(fromString('1.10'), 1.1, 'trailing fractional zero after non-zero');
assert.same(fromString('0.0'), 0, 'zero with trailing fractional zero');
assert.same(fromString('-1.0'), -1, 'negative with trailing fractional zero');
assert.throws(() => fromString('19', 8), SyntaxError, 'Invalid digit for radix #1');
assert.throws(() => fromString('1g', 16), SyntaxError, 'Invalid digit for radix #2');
assert.throws(() => fromString('fg', 16), SyntaxError, 'Invalid digit for radix #3');
assert.throws(() => fromString('89', 8), SyntaxError, 'Invalid digit for radix #4');
assert.throws(() => fromString('1.2.3', 16), SyntaxError, 'Multiple dots #1');
assert.throws(() => fromString('1.2.3', 10), SyntaxError, 'Multiple dots #2');
assert.throws(() => fromString('.5', 16), SyntaxError, 'Leading dot #1');
assert.throws(() => fromString('5.', 16), SyntaxError, 'Trailing dot #1');
assert.throws(() => fromString('.5', 10), SyntaxError, 'Leading dot #2');
assert.throws(() => fromString('5.', 10), SyntaxError, 'Trailing dot #2');
});
================================================
FILE: tests/unit-pure/esnext.number.range.js
================================================
import { MAX_SAFE_INTEGER } from '../helpers/constants.js';
import from from 'core-js-pure/es/array/from';
import range from 'core-js-pure/full/number/range';
QUnit.test('Number.range', assert => {
assert.isFunction(range);
assert.name(range, 'range');
assert.arity(range, 3);
let iterator = range(1, 2);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.deepEqual(from(range(-1, 5)), [-1, 0, 1, 2, 3, 4]);
assert.deepEqual(from(range(-5, 1)), [-5, -4, -3, -2, -1, 0]);
assert.deepEqual(
from(range(0, 1, 0.1)),
[0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9],
);
assert.deepEqual(
from(range(MAX_SAFE_INTEGER, MAX_SAFE_INTEGER + 1, { inclusive: true })),
[MAX_SAFE_INTEGER, MAX_SAFE_INTEGER + 1],
);
assert.deepEqual(from(range(0, 0)), []);
assert.deepEqual(from(range(0, -5, 1)), []);
assert.throws(() => range(NaN, 0), RangeError, 'NaN as start');
assert.throws(() => range(0, NaN), RangeError, 'NaN as end');
assert.throws(() => range(NaN, NaN), RangeError, 'NaN as start and end');
assert.throws(() => range(0, 0, { step: NaN }), RangeError, 'NaN as step option');
assert.throws(() => range(0, 5, NaN), RangeError, 'NaN as step argument');
iterator = range(1, 3);
assert.deepEqual(iterator.start, 1);
assert.deepEqual(iterator.end, 3);
assert.deepEqual(iterator.step, 1);
assert.false(iterator.inclusive);
iterator = range(-1, -3, { inclusive: true });
assert.deepEqual(iterator.start, -1);
assert.deepEqual(iterator.end, -3);
assert.same(iterator.step, -1);
assert.true(iterator.inclusive);
iterator = range(-1, -3, { step: 4, inclusive() { /* empty */ } });
assert.same(iterator.start, -1);
assert.same(iterator.end, -3);
assert.same(iterator.step, 4);
assert.true(iterator.inclusive);
iterator = range(0, 5);
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
assert.throws(() => Object.getOwnPropertyDescriptor(iterator, 'start').get.call({}), TypeError);
assert.throws(() => range(Infinity, 10, 0), RangeError);
assert.throws(() => range(-Infinity, 10, 0), RangeError);
assert.throws(() => range(0, 10, Infinity), RangeError);
assert.throws(() => range(0, 10, { step: Infinity }), RangeError);
assert.throws(() => range({}, 1), TypeError);
assert.throws(() => range(1, {}), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.object.iterate-entries.js
================================================
import Symbol from 'core-js-pure/es/symbol';
import iterateEntries from 'core-js-pure/full/object/iterate-entries';
QUnit.test('Object.iterateEntries', assert => {
assert.isFunction(iterateEntries);
assert.name(iterateEntries, 'iterateEntries');
assert.arity(iterateEntries, 1);
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateEntries(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: ['q', 1],
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: ['e', 3],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
================================================
FILE: tests/unit-pure/esnext.object.iterate-keys.js
================================================
import Symbol from 'core-js-pure/es/symbol';
import iterateKeys from 'core-js-pure/full/object/iterate-keys';
QUnit.test('Object.iterateKeys', assert => {
assert.isFunction(iterateKeys);
assert.name(iterateKeys, 'iterateKeys');
assert.arity(iterateKeys, 1);
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateKeys(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
================================================
FILE: tests/unit-pure/esnext.object.iterate-values.js
================================================
import Symbol from 'core-js-pure/es/symbol';
import iterateValues from 'core-js-pure/full/object/iterate-values';
QUnit.test('Object.iterateValues', assert => {
assert.isFunction(iterateValues);
assert.name(iterateValues, 'iterateValues');
assert.arity(iterateValues, 1);
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateValues(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: 3,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
================================================
FILE: tests/unit-pure/esnext.observable.constructor.js
================================================
import { STRICT } from '../helpers/constants.js';
import Symbol from 'core-js-pure/full/symbol';
import Observable from 'core-js-pure/full/observable';
QUnit.test('Observable', assert => {
assert.isFunction(Observable);
assert.arity(Observable, 1);
assert.name(Observable, 'Observable');
const observable = new Observable(function (subscriptionObserver) {
assert.same(typeof subscriptionObserver, 'object', 'Subscription observer is object');
assert.same(subscriptionObserver.constructor, Object);
const { next, error, complete } = subscriptionObserver;
assert.isFunction(next);
assert.isFunction(error);
assert.isFunction(complete);
assert.arity(next, 1);
assert.arity(error, 1);
assert.arity(complete, 0);
if (STRICT) {
assert.same(this, undefined, 'correct executor context');
}
});
observable.subscribe({});
assert.true(observable instanceof Observable);
// eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
assert.throws(() => Observable(() => { /* empty */ }), 'throws w/o `new`');
});
QUnit.test('Observable#subscribe', assert => {
assert.isFunction(Observable.prototype.subscribe);
assert.arity(Observable.prototype.subscribe, 1);
const subscription = new Observable(() => { /* empty */ }).subscribe({});
assert.same(typeof subscription, 'object', 'Subscription is object');
assert.same(subscription.constructor, Object);
assert.isFunction(subscription.unsubscribe);
assert.arity(subscription.unsubscribe, 0);
});
QUnit.test('Observable#constructor', assert => {
assert.same(Observable.prototype.constructor, Observable);
});
QUnit.test('Observable#@@observable', assert => {
assert.isFunction(Observable.prototype[Symbol.observable]);
const observable = new Observable(() => { /* empty*/ });
assert.same(observable[Symbol.observable](), observable);
});
================================================
FILE: tests/unit-pure/esnext.observable.from.js
================================================
import Observable from 'core-js-pure/full/observable';
QUnit.test('Observable.from', assert => {
assert.isFunction(Observable.from);
assert.arity(Observable.from, 1);
assert.name(Observable.from, 'from');
const results1 = [];
Observable.from([1, 2, 3]).subscribe({ next: v => results1.push(v) });
assert.deepEqual(results1, [1, 2, 3], 'first subscription receives all values');
const obs = Observable.from([4, 5, 6]);
const sub1 = [];
const sub2 = [];
obs.subscribe({ next: v => sub1.push(v) });
obs.subscribe({ next: v => sub2.push(v) });
assert.deepEqual(sub1, [4, 5, 6], 'multi-subscribe: first subscription');
assert.deepEqual(sub2, [4, 5, 6], 'multi-subscribe: second subscription gets fresh iterator');
});
================================================
FILE: tests/unit-pure/esnext.observable.of.js
================================================
import Observable from 'core-js-pure/full/observable';
QUnit.test('Observable.of', assert => {
assert.isFunction(Observable.of);
assert.arity(Observable.of, 0);
assert.name(Observable.of, 'of');
});
================================================
FILE: tests/unit-pure/esnext.reflect.define-metadata.js
================================================
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
QUnit.test('Reflect.defineMetadata', assert => {
assert.isFunction(defineMetadata);
assert.arity(defineMetadata, 3);
assert.name(defineMetadata, 'defineMetadata');
assert.throws(() => defineMetadata('key', 'value', undefined, undefined), TypeError);
assert.same(defineMetadata('key', 'value', {}, undefined), undefined);
assert.same(defineMetadata('key', 'value', {}, 'name'), undefined);
});
================================================
FILE: tests/unit-pure/esnext.reflect.delete-metadata.js
================================================
import create from 'core-js-pure/full/object/create';
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
import hasOwnMetadata from 'core-js-pure/full/reflect/has-own-metadata';
import deleteMetadata from 'core-js-pure/full/reflect/delete-metadata';
QUnit.test('Reflect.deleteMetadata', assert => {
assert.isFunction(deleteMetadata);
assert.arity(deleteMetadata, 2);
assert.name(deleteMetadata, 'deleteMetadata');
assert.throws(() => deleteMetadata('key', undefined, undefined), TypeError);
assert.false(deleteMetadata('key', {}, undefined));
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.true(deleteMetadata('key', object, undefined));
const prototype = {};
defineMetadata('key', 'value', prototype, undefined);
assert.false(deleteMetadata('key', create(prototype), undefined));
object = {};
defineMetadata('key', 'value', object, undefined);
deleteMetadata('key', object, undefined);
assert.false(hasOwnMetadata('key', object, undefined));
});
================================================
FILE: tests/unit-pure/esnext.reflect.get-metadata-keys.js
================================================
import create from 'core-js-pure/full/object/create';
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
import getMetadataKeys from 'core-js-pure/full/reflect/get-metadata-keys';
QUnit.test('Reflect.getMetadataKeys', assert => {
assert.isFunction(getMetadataKeys);
assert.arity(getMetadataKeys, 1);
assert.name(getMetadataKeys, 'getMetadataKeys');
assert.throws(() => getMetadataKeys(undefined, undefined), TypeError);
assert.deepEqual(getMetadataKeys({}, undefined), []);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key']);
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key']);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1']);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
defineMetadata('key0', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, undefined);
object = create(prototype);
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1', 'key2']);
assert.deepEqual(getMetadataKeys({}, 'name'), []);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key']);
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key']);
object = {};
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
defineMetadata('key0', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, 'name');
object = create(prototype);
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key0', 'key1', 'key2']);
});
================================================
FILE: tests/unit-pure/esnext.reflect.get-metadata.js
================================================
import create from 'core-js-pure/full/object/create';
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
import getMetadata from 'core-js-pure/full/reflect/get-metadata';
QUnit.test('Reflect.getMetadata', assert => {
assert.isFunction(getMetadata);
assert.arity(getMetadata, 2);
assert.name(getMetadata, 'getMetadata');
assert.throws(() => getMetadata('key', undefined, undefined), TypeError);
assert.same(getMetadata('key', {}, undefined), undefined);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(getMetadata('key', object, undefined), 'value');
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.same(getMetadata('key', object, undefined), 'value');
assert.same(getMetadata('key', {}, 'name'), undefined);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.same(getMetadata('key', object, 'name'), 'value');
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.same(getMetadata('key', object, 'name'), 'value');
});
================================================
FILE: tests/unit-pure/esnext.reflect.get-own-metadata-keys.js
================================================
import create from 'core-js-pure/full/object/create';
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
import getOwnMetadataKeys from 'core-js-pure/full/reflect/get-own-metadata-keys';
QUnit.test('Reflect.getOwnMetadataKeys', assert => {
assert.isFunction(getOwnMetadataKeys);
assert.arity(getOwnMetadataKeys, 1);
assert.name(getOwnMetadataKeys, 'getOwnMetadataKeys');
assert.throws(() => getOwnMetadataKeys(undefined, undefined), TypeError);
assert.deepEqual(getOwnMetadataKeys({}, undefined), []);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key']);
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), []);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key0', 'key1']);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
defineMetadata('key0', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, undefined);
object = create(prototype);
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key0', 'key1']);
assert.deepEqual(getOwnMetadataKeys({}, 'name'), []);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), ['key']);
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), []);
object = {};
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
defineMetadata('key0', 'value', object, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, 'name');
object = create(prototype);
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), ['key0', 'key1']);
});
================================================
FILE: tests/unit-pure/esnext.reflect.get-own-metadata.js
================================================
import create from 'core-js-pure/full/object/create';
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
import getOwnMetadata from 'core-js-pure/full/reflect/get-own-metadata';
QUnit.test('Reflect.getOwnMetadata', assert => {
assert.isFunction(getOwnMetadata);
assert.arity(getOwnMetadata, 2);
assert.name(getOwnMetadata, 'getOwnMetadata');
assert.throws(() => getOwnMetadata('key', undefined, undefined), TypeError);
assert.same(getOwnMetadata('key', {}, undefined), undefined);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(getOwnMetadata('key', object, undefined), 'value');
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.same(getOwnMetadata('key', object, undefined), undefined);
assert.same(getOwnMetadata('key', {}, 'name'), undefined);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.same(getOwnMetadata('key', object, 'name'), 'value');
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.same(getOwnMetadata('key', object, 'name'), undefined);
});
================================================
FILE: tests/unit-pure/esnext.reflect.has-metadata.js
================================================
import create from 'core-js-pure/full/object/create';
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
import hasMetadata from 'core-js-pure/full/reflect/has-metadata';
QUnit.test('Reflect.hasMetadata', assert => {
assert.isFunction(hasMetadata);
assert.arity(hasMetadata, 2);
assert.name(hasMetadata, 'hasMetadata');
assert.throws(() => hasMetadata('key', undefined, undefined), TypeError);
assert.false(hasMetadata('key', {}, undefined));
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.true(hasMetadata('key', object, undefined));
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.true(hasMetadata('key', object, undefined));
assert.false(hasMetadata('key', {}, 'name'));
object = {};
defineMetadata('key', 'value', object, 'name');
assert.true(hasMetadata('key', object, 'name'));
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.true(hasMetadata('key', object, 'name'));
});
================================================
FILE: tests/unit-pure/esnext.reflect.has-own-metadata.js
================================================
import create from 'core-js-pure/full/object/create';
import defineMetadata from 'core-js-pure/full/reflect/define-metadata';
import hasOwnMetadata from 'core-js-pure/full/reflect/has-own-metadata';
QUnit.test('Reflect.hasOwnMetadata', assert => {
assert.isFunction(hasOwnMetadata);
assert.arity(hasOwnMetadata, 2);
assert.name(hasOwnMetadata, 'hasOwnMetadata');
assert.throws(() => hasOwnMetadata('key', undefined, undefined), TypeError);
assert.false(hasOwnMetadata('key', {}, undefined));
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.true(hasOwnMetadata('key', object, undefined));
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.false(hasOwnMetadata('key', object, undefined));
assert.false(hasOwnMetadata('key', {}, 'name'));
object = {};
defineMetadata('key', 'value', object, 'name');
assert.true(hasOwnMetadata('key', object, 'name'));
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.false(hasOwnMetadata('key', object, 'name'));
});
================================================
FILE: tests/unit-pure/esnext.reflect.metadata.js
================================================
import hasOwnMetadata from 'core-js-pure/full/reflect/has-own-metadata';
import metadata from 'core-js-pure/full/reflect/metadata';
QUnit.test('Reflect.metadata', assert => {
assert.isFunction(metadata);
assert.arity(metadata, 2);
assert.name(metadata, 'metadata');
assert.isFunction(metadata('key', 'value'));
const decorator = metadata('key', 'value');
assert.throws(() => decorator(undefined, 'name'), TypeError);
let target = function () { /* empty */ };
decorator(target);
assert.true(hasOwnMetadata('key', target, undefined));
target = {};
decorator(target, 'name');
assert.true(hasOwnMetadata('key', target, 'name'));
});
================================================
FILE: tests/unit-pure/esnext.set.add-all.js
================================================
import from from 'core-js-pure/es/array/from';
import Set from 'core-js-pure/full/set';
QUnit.test('Set#addAll', assert => {
const { addAll } = Set.prototype;
assert.isFunction(addAll);
assert.arity(addAll, 0);
assert.name(addAll, 'addAll');
assert.nonEnumerable(Set.prototype, 'addAll');
const set = new Set([1]);
assert.same(set.addAll(2), set);
assert.deepEqual(from(new Set([1, 2, 3]).addAll(4, 5)), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).addAll(3, 4)), [1, 2, 3, 4]);
assert.deepEqual(from(new Set([1, 2, 3]).addAll()), [1, 2, 3]);
assert.throws(() => addAll.call({ add() { /* empty */ } }, 1, 2, 3));
assert.throws(() => addAll.call({}, 1, 2, 3), TypeError);
assert.throws(() => addAll.call(undefined, 1, 2, 3), TypeError);
assert.throws(() => addAll.call(null, 1, 2, 3), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.set.delete-all.js
================================================
import from from 'core-js-pure/es/array/from';
import Set from 'core-js-pure/full/set';
QUnit.test('Set#deleteAll', assert => {
const { deleteAll } = Set.prototype;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.nonEnumerable(Set.prototype, 'deleteAll');
let set = new Set([1, 2, 3]);
assert.true(set.deleteAll(1, 2));
assert.deepEqual(from(set), [3]);
set = new Set([1, 2, 3]);
assert.false(set.deleteAll(3, 4));
assert.deepEqual(from(set), [1, 2]);
set = new Set([1, 2, 3]);
assert.false(set.deleteAll(4, 5));
assert.deepEqual(from(set), [1, 2, 3]);
set = new Set([1, 2, 3]);
assert.true(set.deleteAll());
assert.deepEqual(from(set), [1, 2, 3]);
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);
});
================================================
FILE: tests/unit-pure/esnext.set.every.js
================================================
import Set from 'core-js-pure/full/set';
QUnit.test('Set#every', assert => {
const { every } = Set.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.nonEnumerable(Set.prototype, 'every');
const set = new Set([1]);
const context = {};
set.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, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(new Set([1, 2, 3]).every(it => typeof it == 'number'));
assert.false(new Set(['1', '2', '3']).every(it => typeof it == 'number'));
assert.false(new Set([1, '2', 3]).every(it => typeof it == 'number'));
assert.true(new Set().every(it => typeof it == 'number'));
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.set.filter.js
================================================
import from from 'core-js-pure/es/array/from';
import Set from 'core-js-pure/full/set';
QUnit.test('Set#filter', assert => {
const { filter } = Set.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.nonEnumerable(Set.prototype, 'filter');
const set = new Set([1]);
const context = {};
set.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, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(new Set().filter(it => it) instanceof Set);
assert.deepEqual(from(new Set([1, 2, 3, 'q', {}, 4, true, 5]).filter(it => typeof it == 'number')), [1, 2, 3, 4, 5]);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.set.find.js
================================================
import Set from 'core-js-pure/full/set';
QUnit.test('Set#find', assert => {
const { find } = Set.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.nonEnumerable(Set.prototype, 'find');
const set = new Set([1]);
const context = {};
set.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, 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 Set([2, 3, 4]).find(it => it % 2), 3);
assert.same(new Set().find(it => it === 42), undefined);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.set.from.js
================================================
import { createIterable } from '../helpers/helpers.js';
import toArray from 'core-js-pure/es/array/from';
import Set from 'core-js-pure/full/set';
QUnit.test('Set.from', assert => {
const { from } = Set;
assert.isFunction(from);
assert.name(from, 'from');
assert.arity(from, 1);
assert.true(from([]) instanceof Set);
assert.deepEqual(toArray(from([])), []);
assert.deepEqual(toArray(from([1])), [1]);
assert.deepEqual(toArray(from([1, 2, 3, 2, 1])), [1, 2, 3]);
assert.deepEqual(toArray(from(createIterable([1, 2, 3, 2, 1]))), [1, 2, 3]);
const context = {};
from([1], function (element, index) {
assert.same(element, 1);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
});
================================================
FILE: tests/unit-pure/esnext.set.join.js
================================================
/* eslint-disable unicorn/require-array-join-separator -- required for testing */
import Set from 'core-js-pure/full/set';
QUnit.test('Set#join', assert => {
const { join } = Set.prototype;
assert.isFunction(join);
assert.arity(join, 1);
assert.name(join, 'join');
assert.nonEnumerable(Set.prototype, 'join');
assert.same(new Set([1, 2, 3]).join(), '1,2,3');
assert.same(new Set([1, 2, 3]).join(undefined), '1,2,3');
assert.same(new Set([1, 2, 3]).join('|'), '1|2|3');
assert.throws(() => join.call({}), TypeError);
assert.throws(() => join.call(undefined), TypeError);
assert.throws(() => join.call(null), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.set.map.js
================================================
import from from 'core-js-pure/es/array/from';
import Set from 'core-js-pure/full/set';
QUnit.test('Set#map', assert => {
const { map } = Set.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.name(map, 'map');
assert.nonEnumerable(Set.prototype, 'map');
const set = new Set([1]);
const context = {};
set.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, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(new Set().map(it => it) instanceof Set);
assert.deepEqual(from(new Set([1, 2, 3]).map(it => it ** 2)), [1, 4, 9]);
assert.deepEqual(from(new Set([1, 2, 3]).map(it => it % 2)), [1, 0]);
assert.throws(() => map.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.set.of.js
================================================
import from from 'core-js-pure/es/array/from';
import Set from 'core-js-pure/full/set';
QUnit.test('Set.of', assert => {
const { of } = Set;
assert.isFunction(of);
assert.name(of, 'of');
assert.arity(of, 0);
assert.true(of() instanceof Set);
assert.deepEqual(from(of(1)), [1]);
assert.deepEqual(from(of(1, 2, 3, 2, 1)), [1, 2, 3]);
});
================================================
FILE: tests/unit-pure/esnext.set.reduce.js
================================================
import Set from 'core-js-pure/full/set';
QUnit.test('Set#reduce', assert => {
const { reduce } = Set.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.nonEnumerable(Set.prototype, 'reduce');
const set = new Set([1]);
const accumulator = {};
set.reduce(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
}, accumulator);
assert.same(new Set([1, 2, 3]).reduce((a, b) => a + b, 1), 7, 'works with initial accumulator');
new Set([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, 2, 'correct start key without initial accumulator');
});
assert.same(new Set([1, 2, 3]).reduce((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
new Set([1, 2, 3]).reduce((memo, value, key, s) => {
s.delete(2);
values += value;
keys += key;
}, 0);
assert.same(values, '13', 'correct order #1');
assert.same(keys, '13', 'correct order #2');
assert.throws(() => reduce.call({}, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.set.some.js
================================================
import Set from 'core-js-pure/full/set';
QUnit.test('Set#some', assert => {
const { some } = Set.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.nonEnumerable(Set.prototype, 'some');
const set = new Set([1]);
const context = {};
set.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, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.true(new Set([1, 2, 3]).some(it => typeof it == 'number'));
assert.false(new Set(['1', '2', '3']).some(it => typeof it == 'number'));
assert.true(new Set([1, '2', 3]).some(it => typeof it == 'number'));
assert.false(new Set().some(it => typeof it == 'number'));
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.string.at.js
================================================
import { STRICT } from '../helpers/constants.js';
import at from 'core-js-pure/full/string/at';
QUnit.test('String#at', assert => {
assert.isFunction(at);
// String that starts with a BMP symbol
// assert.same(at('abc\uD834\uDF06def', -Infinity), '');
// assert.same(at('abc\uD834\uDF06def', -1), '');
assert.same(at('abc\uD834\uDF06def', -0), 'a');
assert.same(at('abc\uD834\uDF06def', +0), 'a');
assert.same(at('abc\uD834\uDF06def', 1), 'b');
assert.same(at('abc\uD834\uDF06def', 3), '\uD834\uDF06');
assert.same(at('abc\uD834\uDF06def', 4), '\uDF06');
assert.same(at('abc\uD834\uDF06def', 5), 'd');
// assert.same(at('abc\uD834\uDF06def', 42), '');
// assert.same(at('abc\uD834\uDF06def', Infinity), '');
assert.same(at('abc\uD834\uDF06def', null), 'a');
assert.same(at('abc\uD834\uDF06def', undefined), 'a');
assert.same(at('abc\uD834\uDF06def'), 'a');
assert.same(at('abc\uD834\uDF06def', false), 'a');
assert.same(at('abc\uD834\uDF06def', NaN), 'a');
assert.same(at('abc\uD834\uDF06def', ''), 'a');
assert.same(at('abc\uD834\uDF06def', '_'), 'a');
assert.same(at('abc\uD834\uDF06def', '1'), 'b');
assert.same(at('abc\uD834\uDF06def', []), 'a');
assert.same(at('abc\uD834\uDF06def', {}), 'a');
assert.same(at('abc\uD834\uDF06def', -0.9), 'a');
assert.same(at('abc\uD834\uDF06def', 1.9), 'b');
assert.same(at('abc\uD834\uDF06def', 7.9), 'f');
// assert.same(at('abc\uD834\uDF06def', 2 ** 32), '');
// String that starts with an astral symbol
// assert.same(at('\uD834\uDF06def', -Infinity), '');
// assert.same(at('\uD834\uDF06def', -1), '');
assert.same(at('\uD834\uDF06def', -0), '\uD834\uDF06');
assert.same(at('\uD834\uDF06def', 0), '\uD834\uDF06');
assert.same(at('\uD834\uDF06def', 1), '\uDF06');
assert.same(at('\uD834\uDF06def', 2), 'd');
assert.same(at('\uD834\uDF06def', 3), 'e');
assert.same(at('\uD834\uDF06def', 4), 'f');
// assert.same(at('\uD834\uDF06def', 42), '');
// assert.same(at('\uD834\uDF06def', Infinity), '');
assert.same(at('\uD834\uDF06def', null), '\uD834\uDF06');
assert.same(at('\uD834\uDF06def', undefined), '\uD834\uDF06');
assert.same(at('\uD834\uDF06def'), '\uD834\uDF06');
assert.same(at('\uD834\uDF06def', false), '\uD834\uDF06');
assert.same(at('\uD834\uDF06def', NaN), '\uD834\uDF06');
assert.same(at('\uD834\uDF06def', ''), '\uD834\uDF06');
assert.same(at('\uD834\uDF06def', '_'), '\uD834\uDF06');
assert.same(at('\uD834\uDF06def', '1'), '\uDF06');
// Lone high surrogates
// assert.same(at('\uD834abc', -Infinity), '');
// assert.same(at('\uD834abc', -1), '');
assert.same(at('\uD834abc', -0), '\uD834');
assert.same(at('\uD834abc', 0), '\uD834');
assert.same(at('\uD834abc', 1), 'a');
// assert.same(at('\uD834abc', 42), '');
// assert.same(at('\uD834abc', Infinity), '');
assert.same(at('\uD834abc', null), '\uD834');
assert.same(at('\uD834abc', undefined), '\uD834');
assert.same(at('\uD834abc'), '\uD834');
assert.same(at('\uD834abc', false), '\uD834');
assert.same(at('\uD834abc', NaN), '\uD834');
assert.same(at('\uD834abc', ''), '\uD834');
assert.same(at('\uD834abc', '_'), '\uD834');
assert.same(at('\uD834abc', '1'), 'a');
// Lone low surrogates
// assert.same(at('\uDF06abc', -Infinity), '');
// assert.same(at('\uDF06abc', -1), '');
assert.same(at('\uDF06abc', -0), '\uDF06');
assert.same(at('\uDF06abc', 0), '\uDF06');
assert.same(at('\uDF06abc', 1), 'a');
// assert.same(at('\uDF06abc', 42), '');
// assert.same(at('\uDF06abc', Infinity), '');
assert.same(at('\uDF06abc', null), '\uDF06');
assert.same(at('\uDF06abc', undefined), '\uDF06');
assert.same(at('\uDF06abc'), '\uDF06');
assert.same(at('\uDF06abc', false), '\uDF06');
assert.same(at('\uDF06abc', NaN), '\uDF06');
assert.same(at('\uDF06abc', ''), '\uDF06');
assert.same(at('\uDF06abc', '_'), '\uDF06');
assert.same(at('\uDF06abc', '1'), 'a');
assert.same(at(42, 0), '4');
assert.same(at(42, 1), '2');
assert.same(at({
toString() {
return 'abc';
},
}, 2), 'c');
if (STRICT) {
assert.throws(() => at(null, 0), TypeError);
assert.throws(() => at(undefined, 0), TypeError);
}
});
================================================
FILE: tests/unit-pure/esnext.string.code-points.js
================================================
import Symbol from 'core-js-pure/es/symbol';
import codePoints from 'core-js-pure/full/string/code-points';
QUnit.test('String#codePoints', assert => {
assert.isFunction(codePoints);
let iterator = codePoints('qwe');
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'String Iterator');
assert.same(String(iterator), '[object String Iterator]');
assert.deepEqual(iterator.next(), {
value: { codePoint: 113, position: 0 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 119, position: 1 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 101, position: 2 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
iterator = codePoints('𠮷𠮷𠮷');
assert.deepEqual(iterator.next(), {
value: { codePoint: 134071, position: 0 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 134071, position: 2 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 134071, position: 4 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.throws(() => codePoints(Symbol()), 'throws on symbol context');
});
================================================
FILE: tests/unit-pure/esnext.string.cooked.js
================================================
import Symbol from 'core-js-pure/es/symbol';
import cooked from 'core-js-pure/full/string/cooked';
QUnit.test('String.cooked', assert => {
assert.isFunction(cooked);
assert.arity(cooked, 1);
assert.name(cooked, 'cooked');
assert.same(cooked(['Hi\\n', '!'], 'Bob'), 'Hi\\nBob!', 'template is an array');
assert.same(cooked('test', 0, 1, 2), 't0e1s2t', 'template is a string');
assert.same(cooked('test', 0), 't0est', 'lacks substituting');
assert.same(cooked([]), '', 'empty template');
if (typeof Symbol == 'function' && !Symbol.sham) {
const symbol = Symbol('cooked test');
assert.throws(() => cooked([symbol]), TypeError, 'throws on symbol #1');
assert.throws(() => cooked('test', symbol), TypeError, 'throws on symbol #2');
}
assert.throws(() => cooked([undefined]), TypeError);
assert.throws(() => cooked(null), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.string.dedent.js
================================================
import Symbol from 'core-js-pure/es/symbol';
import cooked from 'core-js-pure/full/string/cooked';
import dedent from 'core-js-pure/full/string/dedent';
import freeze from 'core-js-pure/es/object/freeze';
QUnit.test('String.dedent', assert => {
assert.isFunction(dedent);
assert.arity(dedent, 1);
assert.name(dedent, 'dedent');
assert.same(dedent`
qwe
asd
zxc
`, 'qwe\nasd\nzxc', '#1');
assert.same(dedent`
qwe
asd
zxc
`, ' qwe\nasd\n zxc', '#2');
assert.same(dedent`
qwe
asd
${ ' zxc' }
`, ' qwe\n asd\n zxc', '#3');
assert.same(dedent({ raw: freeze(['\n qwe\n ']) }), 'qwe', '#4');
assert.same(dedent({ raw: freeze(['\n qwe', '\n ']) }, 1), 'qwe1', '#5');
assert.same(dedent(cooked)`
qwe
asd
zxc
`, ' qwe\nasd\n zxc', '#6');
const tag = (it => it)`
abc
`;
assert.same(dedent(tag), dedent(tag), '#7');
if (typeof Symbol == 'function' && !Symbol.sham) {
assert.throws(() => dedent({ raw: freeze(['\n', Symbol('dedent test'), '\n']) }), TypeError, 'throws on symbol');
}
assert.throws(() => dedent([]), TypeError, '[]');
assert.throws(() => dedent(['qwe']), TypeError, '[qwe]');
assert.throws(() => dedent({ raw: freeze([]) }), TypeError, 'empty tpl');
assert.throws(() => dedent({ raw: freeze(['qwe']) }), TypeError, 'wrong start');
assert.throws(() => dedent({ raw: freeze(['\n', 'qwe']) }), TypeError, 'wrong start');
assert.throws(() => dedent({ raw: freeze(['\n qwe', 5, '\n ']) }, 1, 2), TypeError, 'wrong part');
assert.throws(() => dedent([undefined]), TypeError);
assert.throws(() => dedent(null), TypeError);
// \u{} (empty braces) should be an invalid escape, causing TypeError
assert.same(dedent({ raw: freeze(['\n \\u{41}\n ']) }), 'A', 'valid unicode brace escape in raw');
assert.throws(() => dedent({ raw: freeze(['\n \\u{}\n ']) }), TypeError, '\\u{} is an invalid escape');
// hex/unicode escapes at end of string segment
assert.same(dedent({ raw: freeze(['\n \\x41\n ']) }), 'A', 'hex escape at end of raw string');
assert.same(dedent({ raw: freeze(['\n \\u0041\n ']) }), 'A', 'unicode escape at end of raw string');
});
================================================
FILE: tests/unit-pure/esnext.symbol.custom-matcher.js
================================================
import Symbol from 'core-js-pure/full/symbol';
QUnit.test('Symbol.customMatcher', assert => {
assert.true('customMatcher' in Symbol, 'Symbol.customMatcher available');
assert.true(Object(Symbol.customMatcher) instanceof Symbol, 'Symbol.customMatcher is symbol');
});
================================================
FILE: tests/unit-pure/esnext.symbol.is-registered-symbol.js
================================================
import Symbol from 'core-js-pure/full/symbol';
QUnit.test('Symbol.isRegisteredSymbol', assert => {
const { isRegisteredSymbol } = Symbol;
assert.isFunction(isRegisteredSymbol, 'Symbol.isRegisteredSymbol is function');
assert.arity(isRegisteredSymbol, 1, 'Symbol.isRegisteredSymbol arity is 1');
assert.name(isRegisteredSymbol, 'isRegisteredSymbol', 'Symbol.isRegisteredSymbol.name is "isRegisteredSymbol"');
assert.true(isRegisteredSymbol(Symbol.for('foo')), 'registered');
assert.true(isRegisteredSymbol(Object(Symbol.for('foo'))), 'registered, boxed');
const symbol = Symbol('Symbol.isRegisteredSymbol test');
assert.false(isRegisteredSymbol(symbol), 'non-registered');
assert.false(isRegisteredSymbol(Object(symbol)), 'non-registered, boxed');
assert.false(isRegisteredSymbol(1), '1');
assert.false(isRegisteredSymbol(true), 'true');
assert.false(isRegisteredSymbol('1'), 'string');
assert.false(isRegisteredSymbol(null), 'null');
assert.false(isRegisteredSymbol(), 'undefined');
assert.false(isRegisteredSymbol({}), 'object');
assert.false(isRegisteredSymbol([]), 'array');
});
================================================
FILE: tests/unit-pure/esnext.symbol.is-registered.js
================================================
import Symbol from 'core-js-pure/full/symbol';
QUnit.test('Symbol.isRegistered', assert => {
const { isRegistered } = Symbol;
assert.isFunction(isRegistered, 'Symbol.isRegistered is function');
assert.arity(isRegistered, 1, 'Symbol.isRegistered arity is 1');
assert.name(isRegistered, 'isRegisteredSymbol', 'Symbol.isRegistered.name is "isRegisteredSymbol"');
assert.true(isRegistered(Symbol.for('foo')), 'registered');
assert.true(isRegistered(Object(Symbol.for('foo'))), 'registered, boxed');
const symbol = Symbol('Symbol.isRegistered test');
assert.false(isRegistered(symbol), 'non-registered');
assert.false(isRegistered(Object(symbol)), 'non-registered, boxed');
assert.false(isRegistered(1), '1');
assert.false(isRegistered(true), 'true');
assert.false(isRegistered('1'), 'string');
assert.false(isRegistered(null), 'null');
assert.false(isRegistered(), 'undefined');
assert.false(isRegistered({}), 'object');
assert.false(isRegistered([]), 'array');
});
================================================
FILE: tests/unit-pure/esnext.symbol.is-well-known-symbol.js
================================================
import Symbol from 'core-js-pure/full/symbol';
QUnit.test('Symbol.isWellKnownSymbol', assert => {
const { isWellKnownSymbol } = Symbol;
assert.isFunction(isWellKnownSymbol, 'Symbol.isWellKnownSymbol is function');
assert.arity(isWellKnownSymbol, 1, 'Symbol.isWellKnownSymbol arity is 1');
assert.name(isWellKnownSymbol, 'isWellKnownSymbol', 'Symbol.isWellKnownSymbol.name is "isWellKnownSymbol"');
assert.true(isWellKnownSymbol(Symbol.iterator), 'well-known-1');
assert.true(isWellKnownSymbol(Object(Symbol.iterator)), 'well-known-2, boxed');
assert.true(isWellKnownSymbol(Symbol.patternMatch), 'well-known-3');
assert.true(isWellKnownSymbol(Object(Symbol.patternMatch)), 'well-known-4, boxed');
const symbol = Symbol('Symbol.isWellKnownSymbol test');
assert.false(isWellKnownSymbol(symbol), 'non-well-known');
assert.false(isWellKnownSymbol(Object(symbol)), 'non-well-known, boxed');
assert.false(isWellKnownSymbol(1), '1');
assert.false(isWellKnownSymbol(true), 'true');
assert.false(isWellKnownSymbol('1'), 'string');
assert.false(isWellKnownSymbol(null), 'null');
assert.false(isWellKnownSymbol(), 'undefined');
assert.false(isWellKnownSymbol({}), 'object');
assert.false(isWellKnownSymbol([]), 'array');
});
================================================
FILE: tests/unit-pure/esnext.symbol.is-well-known.js
================================================
import Symbol from 'core-js-pure/full/symbol';
QUnit.test('Symbol.isWellKnown', assert => {
const { isWellKnown } = Symbol;
assert.isFunction(isWellKnown, 'Symbol.isWellKnown is function');
assert.arity(isWellKnown, 1, 'Symbol.isWellKnown arity is 1');
assert.name(isWellKnown, 'isWellKnownSymbol', 'Symbol.isWellKnown.name is "isWellKnownSymbol"');
assert.true(isWellKnown(Symbol.iterator), 'well-known-1');
assert.true(isWellKnown(Object(Symbol.iterator)), 'well-known-2, boxed');
assert.true(isWellKnown(Symbol.patternMatch), 'well-known-3');
assert.true(isWellKnown(Object(Symbol.patternMatch)), 'well-known-4, boxed');
const symbol = Symbol('Symbol.isWellKnown test');
assert.false(isWellKnown(symbol), 'non-well-known');
assert.false(isWellKnown(Object(symbol)), 'non-well-known, boxed');
assert.false(isWellKnown(1), '1');
assert.false(isWellKnown(true), 'true');
assert.false(isWellKnown('1'), 'string');
assert.false(isWellKnown(null), 'null');
assert.false(isWellKnown(), 'undefined');
assert.false(isWellKnown({}), 'object');
assert.false(isWellKnown([]), 'array');
});
================================================
FILE: tests/unit-pure/esnext.symbol.matcher.js
================================================
import Symbol from 'core-js-pure/full/symbol';
QUnit.test('Symbol.matcher', assert => {
assert.true('matcher' in Symbol, 'Symbol.matcher available');
assert.true(Object(Symbol.matcher) instanceof Symbol, 'Symbol.matcher is symbol');
});
================================================
FILE: tests/unit-pure/esnext.symbol.metadata-key.js
================================================
import Symbol from 'core-js-pure/full/symbol';
QUnit.test('Symbol.metadataKey', assert => {
assert.true('metadataKey' in Symbol, 'Symbol.metadataKey available');
assert.true(Object(Symbol.metadataKey) instanceof Symbol, 'Symbol.metadataKey is symbol');
});
================================================
FILE: tests/unit-pure/esnext.symbol.metadata.js
================================================
import Symbol from 'core-js-pure/actual/symbol';
QUnit.test('Symbol.metadata', assert => {
assert.true('metadata' in Symbol, 'Symbol.metadata available');
assert.true(Object(Symbol.metadata) instanceof Symbol, 'Symbol.metadata is symbol');
});
================================================
FILE: tests/unit-pure/esnext.symbol.observable.js
================================================
import Symbol from 'core-js-pure/full/symbol';
QUnit.test('Symbol.observable', assert => {
assert.true('observable' in Symbol, 'Symbol.observable available');
assert.true(Object(Symbol.observable) instanceof Symbol, 'Symbol.observable is symbol');
});
================================================
FILE: tests/unit-pure/esnext.symbol.pattern-match.js
================================================
import Symbol from 'core-js-pure/full/symbol';
QUnit.test('Symbol.patternMatch', assert => {
assert.true('patternMatch' in Symbol, 'Symbol.patternMatch available');
assert.true(Object(Symbol.patternMatch) instanceof Symbol, 'Symbol.patternMatch is symbol');
});
================================================
FILE: tests/unit-pure/esnext.symbol.replace-all.js
================================================
import Symbol from 'core-js-pure/full/symbol';
QUnit.test('Symbol.replaceAll', assert => {
assert.true('replaceAll' in Symbol, 'Symbol.replaceAll is available');
assert.true(Object(Symbol.replaceAll) instanceof Symbol, 'Symbol.replaceAll is symbol');
});
================================================
FILE: tests/unit-pure/esnext.weak-map.delete-all.js
================================================
import WeakMap from 'core-js-pure/full/weak-map';
QUnit.test('WeakMap#deleteAll', assert => {
const { deleteAll } = WeakMap.prototype;
assert.isFunction(deleteAll);
assert.name(deleteAll, 'deleteAll');
assert.arity(deleteAll, 0);
assert.nonEnumerable(WeakMap.prototype, 'deleteAll');
const a = [];
const b = [];
const c = [];
const d = [];
const e = [];
let map = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.true(map.deleteAll(a, b));
assert.false(map.has(a));
assert.false(map.has(b));
assert.true(map.has(c));
assert.false(map.has(d));
assert.false(map.has(e));
map = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.false(map.deleteAll(c, d));
assert.true(map.has(a));
assert.true(map.has(b));
assert.false(map.has(c));
assert.false(map.has(d));
assert.false(map.has(e));
map = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.false(map.deleteAll(d, e));
assert.true(map.has(a));
assert.true(map.has(b));
assert.true(map.has(c));
assert.false(map.has(d));
assert.false(map.has(e));
map = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.true(map.deleteAll());
assert.true(map.has(a));
assert.true(map.has(b));
assert.true(map.has(c));
assert.false(map.has(d));
assert.false(map.has(e));
assert.throws(() => deleteAll.call({ delete() { /* empty */ } }, a, b, c));
assert.throws(() => deleteAll.call({}, a, b, c), TypeError);
assert.throws(() => deleteAll.call(undefined, a, b, c), TypeError);
assert.throws(() => deleteAll.call(null, a, b, c), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.weak-map.emplace.js
================================================
import WeakMap from 'core-js-pure/full/weak-map';
QUnit.test('WeakMap#emplace', assert => {
const { emplace } = WeakMap.prototype;
assert.isFunction(emplace);
assert.arity(emplace, 2);
assert.name(emplace, 'emplace');
assert.nonEnumerable(WeakMap.prototype, 'emplace');
const a = {};
const b = {};
const map = new WeakMap([[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.get(a), 4, 'correct result #1');
assert.same(map.get(b), 3, 'correct result #2');
assert.same(new WeakMap([[a, 2]]).emplace(b, { insert: () => 3 }), 3);
assert.same(new WeakMap([[a, 2]]).emplace(a, { update: value => value ** 2 }), 4);
handler = { update() { /* empty */ }, insert() { /* empty */ } };
assert.throws(() => new WeakMap().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);
});
================================================
FILE: tests/unit-pure/esnext.weak-map.from.js
================================================
import { createIterable } from '../helpers/helpers.js';
import WeakMap from 'core-js-pure/full/weak-map';
QUnit.test('WeakMap.from', assert => {
const { from } = WeakMap;
assert.isFunction(from);
assert.name(from, 'from');
assert.arity(from, 1);
assert.true(from([]) instanceof WeakMap);
const array = [];
assert.same(from([[array, 2]]).get(array), 2);
assert.same(from(createIterable([[array, 2]])).get(array), 2);
const pair = [{}, 1];
const context = {};
from([pair], function (element, index) {
assert.same(element, pair);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
});
================================================
FILE: tests/unit-pure/esnext.weak-map.of.js
================================================
import WeakMap from 'core-js-pure/full/weak-map';
QUnit.test('WeakMap.of', assert => {
const { of } = WeakMap;
assert.isFunction(of);
assert.name(of, 'of');
assert.arity(of, 0);
const array = [];
assert.true(of() instanceof WeakMap);
assert.same(of([array, 2]).get(array), 2);
});
================================================
FILE: tests/unit-pure/esnext.weak-map.upsert.js
================================================
import WeakMap from 'core-js-pure/full/weak-map';
QUnit.test('WeakMap#upsert', assert => {
const { upsert } = WeakMap.prototype;
assert.isFunction(upsert);
assert.name(upsert, 'upsert');
assert.arity(upsert, 2);
assert.nonEnumerable(WeakMap.prototype, 'upsert');
const a = {};
const b = {};
const map = new WeakMap([[a, 2]]);
assert.same(map.upsert(a, function (value) {
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
return value ** 2;
}, () => {
assert.avoid();
return 3;
}), 4, 'returns a correct value');
assert.same(map.upsert(b, value => {
assert.avoid();
return value ** 2;
}, function () {
assert.same(arguments.length, 0, 'correct number of callback arguments');
return 3;
}), 3, 'returns a correct value');
assert.same(map.get(a), 4, 'correct result #1');
assert.same(map.get(b), 3, 'correct result #2');
assert.same(new WeakMap([[a, 2]]).upsert(b, null, () => 3), 3);
assert.same(new WeakMap([[a, 2]]).upsert(a, value => value ** 2), 4);
assert.throws(() => new WeakMap().upsert(a), TypeError);
assert.throws(() => upsert.call({}, a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call([], a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(undefined, a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(null, a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.weak-set.add-all.js
================================================
import WeakSet from 'core-js-pure/full/weak-set';
QUnit.test('WeakSet#addAll', assert => {
const { addAll } = WeakSet.prototype;
assert.isFunction(addAll);
assert.arity(addAll, 0);
assert.name(addAll, 'addAll');
assert.nonEnumerable(WeakSet.prototype, 'addAll');
const a = [];
const b = [];
const c = [];
let set = new WeakSet([a]);
assert.same(set.addAll(b), set);
set = new WeakSet([a]).addAll(b, c);
assert.true(set.has(a));
assert.true(set.has(b));
assert.true(set.has(c));
set = new WeakSet([a]).addAll(a, b);
assert.true(set.has(a));
assert.true(set.has(b));
set = new WeakSet([a]).addAll();
assert.true(set.has(a));
assert.throws(() => addAll.call({ add() { /* empty */ } }, a, b, c));
assert.throws(() => addAll.call({}, a, b, c), TypeError);
assert.throws(() => addAll.call(undefined, a, b, c), TypeError);
assert.throws(() => addAll.call(null, a, b, c), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.weak-set.delete-all.js
================================================
import WeakSet from 'core-js-pure/full/weak-set';
QUnit.test('WeakSet#deleteAll', assert => {
const { deleteAll } = WeakSet.prototype;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.nonEnumerable(WeakSet.prototype, 'deleteAll');
const a = [];
const b = [];
const c = [];
const d = [];
const e = [];
let set = new WeakSet([a, b, c]);
assert.true(set.deleteAll(a, b));
assert.false(set.has(a));
assert.false(set.has(b));
assert.true(set.has(c));
assert.false(set.has(d));
assert.false(set.has(e));
set = new WeakSet([a, b, c]);
assert.false(set.deleteAll(c, d));
assert.true(set.has(a));
assert.true(set.has(b));
assert.false(set.has(c));
assert.false(set.has(d));
assert.false(set.has(e));
set = new WeakSet([a, b, c]);
assert.false(set.deleteAll(d, e));
assert.true(set.has(a));
assert.true(set.has(b));
assert.true(set.has(c));
assert.false(set.has(d));
assert.false(set.has(e));
set = new WeakSet([a, b, c]);
assert.true(set.deleteAll());
assert.true(set.has(a));
assert.true(set.has(b));
assert.true(set.has(c));
assert.false(set.has(d));
assert.false(set.has(e));
assert.throws(() => deleteAll.call({ delete() { /* empty */ } }, a, b, c));
assert.throws(() => deleteAll.call({}, a, b, c), TypeError);
assert.throws(() => deleteAll.call(undefined, a, b, c), TypeError);
assert.throws(() => deleteAll.call(null, a, b, c), TypeError);
});
================================================
FILE: tests/unit-pure/esnext.weak-set.from.js
================================================
import { createIterable } from '../helpers/helpers.js';
import WeakSet from 'core-js-pure/full/weak-set';
QUnit.test('WeakSet.from', assert => {
const { from } = WeakSet;
assert.isFunction(from);
assert.name(from, 'from');
assert.arity(from, 1);
assert.true(from([]) instanceof WeakSet);
const array = [];
assert.true(from([array]).has(array));
assert.true(from(createIterable([array])).has(array));
const object = {};
const context = {};
from([object], function (element, index) {
assert.same(element, object);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
});
================================================
FILE: tests/unit-pure/esnext.weak-set.of.js
================================================
import WeakSet from 'core-js-pure/full/weak-set';
QUnit.test('WeakSet.of', assert => {
const { of } = WeakSet;
assert.isFunction(of);
assert.name(of, 'of');
assert.arity(of, 0);
const array = [];
assert.true(of() instanceof WeakSet);
assert.true(of(array).has(array));
});
================================================
FILE: tests/unit-pure/helpers.get-iterator-method.js
================================================
import { createIterable } from '../helpers/helpers.js';
import getIteratorMethod from 'core-js-pure/full/get-iterator-method';
QUnit.test('getIteratorMethod helper', assert => {
assert.isFunction(getIteratorMethod);
const iterable = createIterable([]);
const iterFn = getIteratorMethod(iterable);
assert.isFunction(iterFn);
assert.isIterator(iterFn.call(iterable));
assert.isFunction(getIteratorMethod([]));
assert.isFunction(getIteratorMethod(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()));
assert.isFunction(getIteratorMethod(Array.prototype));
assert.same(getIteratorMethod({}), undefined);
});
================================================
FILE: tests/unit-pure/helpers.get-iterator.js
================================================
import { createIterable } from '../helpers/helpers.js';
import getIterator from 'core-js-pure/full/get-iterator';
QUnit.test('getIterator helper', assert => {
assert.isFunction(getIterator);
assert.isIterator(getIterator([]));
assert.isIterator(getIterator(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()));
assert.isIterator(getIterator(createIterable([])));
assert.throws(() => getIterator({}), TypeError);
});
================================================
FILE: tests/unit-pure/helpers.is-iterable.js
================================================
import { createIterable } from '../helpers/helpers.js';
import isIterable from 'core-js-pure/full/is-iterable';
QUnit.test('isIterable helper', assert => {
assert.isFunction(isIterable);
assert.true(isIterable(createIterable([])));
assert.true(isIterable([]));
assert.true(isIterable(function () {
// eslint-disable-next-line prefer-rest-params -- required for testing
return arguments;
}()));
assert.true(isIterable(Array.prototype));
assert.false(isIterable({}));
});
================================================
FILE: tests/unit-pure/web.atob.js
================================================
// based on https://github.com/davidchambers/Base64.js/blob/master/test/base64.js
import atob from 'core-js-pure/stable/atob';
QUnit.test('atob', assert => {
assert.isFunction(atob);
assert.arity(atob, 1);
assert.same(atob(''), '');
assert.same(atob('Zg=='), 'f');
assert.same(atob('Zm8='), 'fo');
assert.same(atob('Zm9v'), 'foo');
assert.same(atob('cXV1eA=='), 'quux');
assert.same(atob('ISIjJCU='), '!"#$%');
assert.same(atob('JicoKSor'), "&'()*+");
assert.same(atob('LC0uLzAxMg=='), ',-./012');
assert.same(atob('MzQ1Njc4OTo='), '3456789:');
assert.same(atob('Ozw9Pj9AQUJD'), ';<=>?@ABC');
assert.same(atob('REVGR0hJSktMTQ=='), 'DEFGHIJKLM');
assert.same(atob('Tk9QUVJTVFVWV1g='), 'NOPQRSTUVWX');
assert.same(atob('WVpbXF1eX2BhYmM='), 'YZ[\\]^_`abc');
assert.same(atob('ZGVmZ2hpamtsbW5vcA=='), 'defghijklmnop');
assert.same(atob('cXJzdHV2d3h5ent8fX4='), 'qrstuvwxyz{|}~');
assert.same(atob(' '), '');
assert.same(atob(42), atob('42'));
assert.same(atob(null), atob('null'));
assert.throws(() => atob(), TypeError, 'no args');
assert.throws(() => atob('a'), 'invalid #1');
assert.throws(() => atob('a '), 'invalid #2');
assert.throws(() => atob('aaaaa'), 'invalid #3');
assert.throws(() => atob('[object Object]'), 'invalid #4');
});
================================================
FILE: tests/unit-pure/web.btoa.js
================================================
// based on https://github.com/davidchambers/Base64.js/blob/master/test/base64.js
import btoa from 'core-js-pure/stable/btoa';
QUnit.test('btoa', assert => {
assert.isFunction(btoa);
assert.arity(btoa, 1);
assert.same(btoa(''), '');
assert.same(btoa('f'), 'Zg==');
assert.same(btoa('fo'), 'Zm8=');
assert.same(btoa('foo'), 'Zm9v');
assert.same(btoa('quux'), 'cXV1eA==');
assert.same(btoa('!"#$%'), 'ISIjJCU=');
assert.same(btoa("&'()*+"), 'JicoKSor');
assert.same(btoa(',-./012'), 'LC0uLzAxMg==');
assert.same(btoa('3456789:'), 'MzQ1Njc4OTo=');
assert.same(btoa(';<=>?@ABC'), 'Ozw9Pj9AQUJD');
assert.same(btoa('DEFGHIJKLM'), 'REVGR0hJSktMTQ==');
assert.same(btoa('NOPQRSTUVWX'), 'Tk9QUVJTVFVWV1g=');
assert.same(btoa('YZ[\\]^_`abc'), 'WVpbXF1eX2BhYmM=');
assert.same(btoa('defghijklmnop'), 'ZGVmZ2hpamtsbW5vcA==');
assert.same(btoa('qrstuvwxyz{|}~'), 'cXJzdHV2d3h5ent8fX4=');
assert.same(btoa(42), btoa('42'));
assert.same(btoa(null), btoa('null'));
assert.same(btoa({ x: 1 }), btoa('[object Object]'));
assert.throws(() => btoa(), TypeError, 'no args');
assert.throws(() => btoa('✈'), 'non-ASCII');
});
================================================
FILE: tests/unit-pure/web.dom-collections.iterator.js
================================================
import { GLOBAL } from '../helpers/constants.js';
import Symbol from 'core-js-pure/es/symbol';
import getIteratorMethod from 'core-js-pure/stable/get-iterator-method';
QUnit.test('Iterable DOM collections', assert => {
let absent = true;
const collections = [
'CSSRuleList',
'CSSStyleDeclaration',
'CSSValueList',
'ClientRectList',
'DOMRectList',
'DOMStringList',
'DOMTokenList',
'DataTransferItemList',
'FileList',
'HTMLAllCollection',
'HTMLCollection',
'HTMLFormElement',
'HTMLSelectElement',
'MediaList',
'MimeTypeArray',
'NamedNodeMap',
'NodeList',
'PaintRequestList',
'Plugin',
'PluginArray',
'SVGLengthList',
'SVGNumberList',
'SVGPathSegList',
'SVGPointList',
'SVGStringList',
'SVGTransformList',
'SourceBufferList',
'StyleSheetList',
'TextTrackCueList',
'TextTrackList',
'TouchList',
];
for (const name of collections) {
const Collection = GLOBAL[name];
if (Collection) {
absent = false;
assert.same(Collection.prototype[Symbol.toStringTag], name, `${ name }::@@toStringTag is '${ name }'`);
if (Object.prototype.toString.call(Collection.prototype).slice(8, -1) === name) {
assert.isFunction(getIteratorMethod(Collection.prototype), `${ name }::@@iterator is function`);
}
}
}
if (GLOBAL.NodeList && GLOBAL.document && document.querySelectorAll && document.querySelectorAll('div') instanceof NodeList) {
assert.isFunction(getIteratorMethod(document.querySelectorAll('div')), 'works with document.querySelectorAll');
}
if (absent) {
assert.required('DOM collections are absent');
}
});
================================================
FILE: tests/unit-pure/web.dom-exception.constructor.js
================================================
import { DESCRIPTORS, NODE } from '../helpers/constants.js';
import DOMException from 'core-js-pure/stable/dom-exception';
import Symbol from 'core-js-pure/es/symbol';
const errors = {
IndexSizeError: { s: 'INDEX_SIZE_ERR', c: 1, m: 1 },
DOMStringSizeError: { s: 'DOMSTRING_SIZE_ERR', c: 2, m: 0 },
HierarchyRequestError: { s: 'HIERARCHY_REQUEST_ERR', c: 3, m: 1 },
WrongDocumentError: { s: 'WRONG_DOCUMENT_ERR', c: 4, m: 1 },
InvalidCharacterError: { s: 'INVALID_CHARACTER_ERR', c: 5, m: 1 },
NoDataAllowedError: { s: 'NO_DATA_ALLOWED_ERR', c: 6, m: 0 },
NoModificationAllowedError: { s: 'NO_MODIFICATION_ALLOWED_ERR', c: 7, m: 1 },
NotFoundError: { s: 'NOT_FOUND_ERR', c: 8, m: 1 },
NotSupportedError: { s: 'NOT_SUPPORTED_ERR', c: 9, m: 1 },
InUseAttributeError: { s: 'INUSE_ATTRIBUTE_ERR', c: 10, m: 1 },
InvalidStateError: { s: 'INVALID_STATE_ERR', c: 11, m: 1 },
SyntaxError: { s: 'SYNTAX_ERR', c: 12, m: 1 },
InvalidModificationError: { s: 'INVALID_MODIFICATION_ERR', c: 13, m: 1 },
NamespaceError: { s: 'NAMESPACE_ERR', c: 14, m: 1 },
InvalidAccessError: { s: 'INVALID_ACCESS_ERR', c: 15, m: 1 },
ValidationError: { s: 'VALIDATION_ERR', c: 16, m: 0 },
TypeMismatchError: { s: 'TYPE_MISMATCH_ERR', c: 17, m: 1 },
SecurityError: { s: 'SECURITY_ERR', c: 18, m: 1 },
NetworkError: { s: 'NETWORK_ERR', c: 19, m: 1 },
AbortError: { s: 'ABORT_ERR', c: 20, m: 1 },
URLMismatchError: { s: 'URL_MISMATCH_ERR', c: 21, m: 1 },
// https://github.com/whatwg/webidl/pull/1465
// QuotaExceededError: { s: 'QUOTA_EXCEEDED_ERR', c: 22, m: 1 },
TimeoutError: { s: 'TIMEOUT_ERR', c: 23, m: 1 },
InvalidNodeTypeError: { s: 'INVALID_NODE_TYPE_ERR', c: 24, m: 1 },
DataCloneError: { s: 'DATA_CLONE_ERR', c: 25, m: 1 },
};
const HAS_STACK = 'stack' in new Error('1');
QUnit.test('DOMException', assert => {
assert.isFunction(DOMException);
assert.arity(DOMException, 0);
assert.name(DOMException, 'DOMException');
let error = new DOMException({}, 'Foo');
assert.true(error instanceof DOMException, 'new DOMException({}, "Foo") instanceof DOMException');
assert.same(error.message, '[object Object]', 'new DOMException({}, "Foo").message');
assert.same(error.name, 'Foo', 'new DOMException({}, "Foo").name');
assert.same(error.code, 0, 'new DOMException({}, "Foo").code');
assert.same(String(error), 'Foo: [object Object]', 'String(new DOMException({}, "Foo"))'); // Safari 10.1 bug
// assert.same(error.constructor, DOMException, 'new DOMException({}, "Foo").constructor');
assert.same(error[Symbol.toStringTag], 'DOMException', 'DOMException.prototype[Symbol.toStringTag]');
if (HAS_STACK) assert.true('stack' in error, "'stack' in new DOMException()");
assert.same(new DOMException().message, '', 'new DOMException().message');
assert.same(new DOMException(undefined).message, '', 'new DOMException(undefined).message');
assert.same(new DOMException(42).name, 'Error', 'new DOMException(42).name');
assert.same(new DOMException(42, undefined).name, 'Error', 'new DOMException(42, undefined).name');
for (const name in errors) {
error = new DOMException(42, name);
assert.true(error instanceof DOMException, `new DOMException(42, "${ name }") instanceof DOMException`);
assert.same(error.message, '42', `new DOMException(42, "${ name }").message`);
assert.same(error.name, name, `new DOMException(42, "${ name }").name`);
if (errors[name].m) assert.same(error.code, errors[name].c, `new DOMException(42, "${ name }").code`);
// NodeJS and Deno set codes to deprecated errors
else if (!NODE) assert.same(error.code, 0, `new DOMException(42, "${ name }").code`);
assert.same(String(error), `${ name }: 42`, `String(new DOMException(42, "${ name }"))`); // Safari 10.1 bug
if (HAS_STACK) assert.true('stack' in error, `'stack' in new DOMException(42, "${ name }")`);
assert.same(DOMException[errors[name].s], errors[name].c, `DOMException.${ errors[name].s }`);
assert.same(DOMException.prototype[errors[name].s], errors[name].c, `DOMException.prototype.${ errors[name].s }`);
}
// eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
assert.throws(() => DOMException(42, 'DataCloneError'), "DOMException(42, 'DataCloneError')");
const symbol = Symbol('DOMException constructor test');
assert.throws(() => new DOMException(symbol, 'DataCloneError'), "new DOMException(Symbol(), 'DataCloneError')");
assert.throws(() => new DOMException(42, symbol), 'new DOMException(42, Symbol())');
if (DESCRIPTORS) {
// assert.throws(() => DOMException.prototype.message, 'DOMException.prototype.message'); // FF55- , Safari 10.1 bug
// assert.throws(() => DOMException.prototype.name, 'DOMException.prototype.name'); // FF55-, Safari 10.1 bug bug
// assert.throws(() => DOMException.prototype.code, 'DOMException.prototype.code'); // Safari 10.1 bug
// assert.throws(() => DOMException.prototype.toString(), 'DOMException.prototype.toString()'); // FF55- bug
}
});
================================================
FILE: tests/unit-pure/web.queue-microtask.js
================================================
import { timeLimitedPromise } from '../helpers/helpers.js';
import queueMicrotask from 'core-js-pure/full/queue-microtask';
QUnit.test('queueMicrotask', assert => {
assert.isFunction(queueMicrotask);
assert.arity(queueMicrotask, 1);
assert.name(queueMicrotask, 'queueMicrotask');
return timeLimitedPromise(3e3, resolve => {
let called = false;
queueMicrotask(() => {
called = true;
resolve();
});
assert.false(called, 'async');
}).then(() => {
assert.required('works');
});
});
================================================
FILE: tests/unit-pure/web.self.js
================================================
import self from 'core-js-pure/stable/self';
QUnit.test('self', assert => {
assert.same(self, Object(self), 'is object');
assert.same(self.Math, Math, 'contains globals');
});
================================================
FILE: tests/unit-pure/web.set-immediate.js
================================================
import { timeLimitedPromise } from '../helpers/helpers.js';
import setImmediate from 'core-js-pure/stable/set-immediate';
import clearImmediate from 'core-js-pure/stable/clear-immediate';
QUnit.test('setImmediate / clearImmediate', assert => {
assert.isFunction(setImmediate, 'setImmediate is function');
assert.isFunction(clearImmediate, 'clearImmediate is function');
let called = false;
const promise = timeLimitedPromise(1e3, resolve => {
setImmediate(() => {
called = true;
resolve();
});
}).then(() => {
assert.required('setImmediate works');
}, () => {
assert.avoid('setImmediate works');
}).then(() => {
return timeLimitedPromise(1e3, resolve => {
setImmediate((a, b) => {
resolve(a + b);
}, 'a', 'b');
});
}).then(it => {
assert.same(it, 'ab', 'setImmediate works with additional args');
}, () => {
assert.avoid('setImmediate works with additional args');
}).then(() => {
return timeLimitedPromise(50, resolve => {
clearImmediate(setImmediate(resolve));
});
}).then(() => {
assert.avoid('clearImmediate works');
}, () => {
assert.required('clearImmediate works');
});
assert.false(called, 'setImmediate is async');
return promise;
});
================================================
FILE: tests/unit-pure/web.set-interval.js
================================================
import { timeLimitedPromise } from '../helpers/helpers.js';
import setTimeout from 'core-js-pure/stable/set-timeout';
import setInterval from 'core-js-pure/stable/set-interval';
QUnit.test('setInterval / clearInterval', assert => {
assert.isFunction(setInterval, 'setInterval is function');
assert.isFunction(clearInterval, 'clearInterval is function');
return timeLimitedPromise(1e4, (resolve, reject) => {
let i = 0;
const interval = setInterval((a, b) => {
if (a + b !== 'ab' || i > 2) reject({ a, b, i });
if (i++ === 2) {
clearInterval(interval);
setTimeout(resolve, 30);
}
}, 5, 'a', 'b');
}).then(() => {
assert.required('setInterval & clearInterval works with additional args');
}, (error = {}) => {
assert.avoid(`setInterval & clearInterval works with additional args: ${ error.a }, ${ error.b }, times: ${ error.i }`);
});
});
================================================
FILE: tests/unit-pure/web.set-timeout.js
================================================
import { timeLimitedPromise } from '../helpers/helpers.js';
import setTimeout from 'core-js-pure/stable/set-timeout';
QUnit.test('setTimeout / clearTimeout', assert => {
assert.isFunction(setTimeout, 'setTimeout is function');
assert.isFunction(clearTimeout, 'clearTimeout is function');
return timeLimitedPromise(1e3, resolve => {
setTimeout((a, b) => { resolve(a + b); }, 10, 'a', 'b');
}).then(it => {
assert.same(it, 'ab', 'setTimeout works with additional args');
}, () => {
assert.avoid('setTimeout works with additional args');
}).then(() => {
return timeLimitedPromise(50, resolve => {
clearTimeout(setTimeout(resolve, 10));
});
}).then(() => {
assert.avoid('clearTimeout works with wrapped setTimeout');
}, () => {
assert.required('clearTimeout works with wrapped setTimeout');
});
});
================================================
FILE: tests/unit-pure/web.structured-clone.js
================================================
// Originally from: https://github.com/web-platform-tests/wpt/blob/4b35e758e2fc4225368304b02bcec9133965fd1a/IndexedDB/structured-clone.any.js
// Copyright © web-platform-tests contributors. Available under the 3-Clause BSD License.
/* eslint-disable es/no-error-cause, es/no-typed-arrays -- safe */
import { GLOBAL, NODE, BUN } from '../helpers/constants.js';
import { bufferToArray, fromSource } from '../helpers/helpers.js';
import structuredClone from 'core-js-pure/stable/structured-clone';
import from from 'core-js-pure/es/array/from';
import assign from 'core-js-pure/es/object/assign';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
import keys from 'core-js-pure/es/object/keys';
import Symbol from 'core-js-pure/es/symbol';
import Map from 'core-js-pure/es/map';
import Set from 'core-js-pure/es/set';
import AggregateError from 'core-js-pure/es/aggregate-error';
import DOMException from 'core-js-pure/stable/dom-exception';
QUnit.module('structuredClone', () => {
QUnit.test('identity', assert => {
assert.isFunction(structuredClone, 'structuredClone is a function');
assert.name(structuredClone, 'structuredClone');
assert.arity(structuredClone, 1);
assert.throws(() => structuredClone(), 'throws without arguments');
assert.same(structuredClone(1, null), 1, 'null as options');
assert.same(structuredClone(1, undefined), 1, 'undefined as options');
});
function cloneTest(value, verifyFunc) {
verifyFunc(value, structuredClone(value));
}
// Specialization of cloneTest() for objects, with common asserts.
function cloneObjectTest(assert, value, verifyFunc) {
cloneTest(value, (orig, clone) => {
assert.notSame(orig, clone, 'clone should have different reference');
assert.same(typeof clone, 'object', 'clone should be an object');
// https://github.com/qunitjs/node-qunit/issues/146
assert.true(getPrototypeOf(orig) === getPrototypeOf(clone), 'clone should have same prototype');
verifyFunc(orig, clone);
});
}
// ECMAScript types
// Primitive values: Undefined, Null, Boolean, Number, BigInt, String
const booleans = [false, true];
const numbers = [
NaN,
-Infinity,
-Number.MAX_VALUE,
-0xFFFFFFFF,
-0x80000000,
-0x7FFFFFFF,
-1,
-Number.MIN_VALUE,
-0,
0,
1,
Number.MIN_VALUE,
0x7FFFFFFF,
0x80000000,
0xFFFFFFFF,
Number.MAX_VALUE,
Infinity,
];
const bigints = fromSource(`[
-12345678901234567890n,
-1n,
0n,
1n,
12345678901234567890n,
]`) || [];
const strings = [
'',
'this is a sample string',
'null(\0)',
];
QUnit.test('primitives', assert => {
const primitives = [undefined, null, ...booleans, ...numbers, ...bigints, ...strings];
for (const value of primitives) cloneTest(value, (orig, clone) => {
assert.same(orig, clone, 'primitives should be same after cloned');
});
});
// "Primitive" Objects (Boolean, Number, BigInt, String)
QUnit.test('primitive objects', assert => {
const primitives = [...booleans, ...numbers, ...bigints, ...strings];
for (const value of primitives) cloneObjectTest(assert, Object(value), (orig, clone) => {
assert.same(orig.valueOf(), clone.valueOf(), 'primitive wrappers should have same value');
});
});
// Dates
QUnit.test('Date', assert => {
const dates = [
new Date(-1e13),
new Date(-1e12),
new Date(-1e9),
new Date(-1e6),
new Date(-1e3),
new Date(0),
new Date(1e3),
new Date(1e6),
new Date(1e9),
new Date(1e12),
new Date(1e13),
];
for (const date of dates) cloneTest(date, (orig, clone) => {
assert.notSame(orig, clone);
assert.same(typeof clone, 'object');
assert.same(getPrototypeOf(orig), getPrototypeOf(clone));
assert.same(orig.valueOf(), clone.valueOf());
});
});
// Regular Expressions
QUnit.test('RegExp', assert => {
const regexes = [
new RegExp(),
/abc/,
/abc/g,
/abc/i,
/abc/gi,
];
const giuy = fromSource('/abc/giuy');
if (giuy) regexes.push(giuy);
for (const regex of regexes) cloneObjectTest(assert, regex, (orig, clone) => {
assert.same(orig.toString(), clone.toString(), `regex ${ regex }`);
});
});
if (fromSource('ArrayBuffer.prototype.slice || DataView')) {
// ArrayBuffer
if (typeof Uint8Array == 'function') QUnit.test('ArrayBuffer', assert => { // Crashes
cloneObjectTest(assert, new Uint8Array([0, 1, 254, 255]).buffer, (orig, clone) => {
assert.arrayEqual(new Uint8Array(orig), new Uint8Array(clone));
});
});
// TODO SharedArrayBuffer
// Array Buffer Views
if (typeof Int8Array != 'undefined') {
QUnit.test('%TypedArray%', assert => {
const arrays = [
new Uint8Array([]),
new Uint8Array([0, 1, 254, 255]),
new Uint16Array([0x0000, 0x0001, 0xFFFE, 0xFFFF]),
new Uint32Array([0x00000000, 0x00000001, 0xFFFFFFFE, 0xFFFFFFFF]),
new Int8Array([0, 1, 254, 255]),
new Int16Array([0x0000, 0x0001, 0xFFFE, 0xFFFF]),
new Int32Array([0x00000000, 0x00000001, 0xFFFFFFFE, 0xFFFFFFFF]),
new Float32Array([-Infinity, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, Infinity, NaN]),
new Float64Array([-Infinity, -Number.MAX_VALUE, -Number.MIN_VALUE, 0, Number.MIN_VALUE, Number.MAX_VALUE, Infinity, NaN]),
];
if (typeof Uint8ClampedArray != 'undefined') {
arrays.push(new Uint8ClampedArray([0, 1, 254, 255]));
}
for (const array of arrays) cloneObjectTest(assert, array, (orig, clone) => {
assert.arrayEqual(orig, clone);
});
});
if (fromSource('({}).toString.call(new DataView(new ArrayBuffer([1, 2]))) === "[object DataView]"')) {
QUnit.test('DataView', assert => {
const array = new Int8Array([1, 2, 3, 4]);
const view = new DataView(array.buffer);
cloneObjectTest(assert, view, (orig, clone) => {
assert.same(orig.byteLength, clone.byteLength);
assert.same(orig.byteOffset, clone.byteOffset);
assert.arrayEqual(new Int8Array(orig.buffer), new Int8Array(clone.buffer));
});
});
}
}
if ('resizable' in ArrayBuffer.prototype) {
QUnit.test('Resizable ArrayBuffer', assert => {
const array = [1, 2, 3, 4, 5, 6, 7, 8];
// eslint-disable-next-line es/no-resizable-and-growable-arraybuffers -- safe
let buffer = new ArrayBuffer(8, { maxByteLength: 16 });
new Int8Array(buffer).set(array);
let copy = structuredClone(buffer);
assert.arrayEqual(bufferToArray(copy), array, 'resizable-ab-1');
assert.true(copy.resizable, 'resizable-ab-1');
buffer = new ArrayBuffer(8);
new Int8Array(buffer).set(array);
copy = structuredClone(buffer);
assert.arrayEqual(bufferToArray(copy), array, 'non-resizable-ab-1');
assert.false(copy.resizable, 'non-resizable-ab-1');
// eslint-disable-next-line es/no-resizable-and-growable-arraybuffers -- safe
buffer = new ArrayBuffer(8, { maxByteLength: 16 });
let tarray = new Int8Array(buffer);
tarray.set(array);
copy = structuredClone(tarray).buffer;
assert.arrayEqual(bufferToArray(copy), array, 'resizable-ab-2');
assert.true(copy.resizable, 'resizable-ab-2');
buffer = new ArrayBuffer(8);
tarray = new Int8Array(buffer);
tarray.set(array);
copy = structuredClone(tarray).buffer;
assert.arrayEqual(bufferToArray(copy), array, 'non-resizable-ab-2');
assert.false(copy.resizable, 'non-resizable-ab-2');
});
}
}
// Map
QUnit.test('Map', assert => {
cloneObjectTest(assert, new Map([[1, 2], [3, 4]]), (orig, clone) => {
assert.deepEqual(from(orig.keys()), from(clone.keys()));
assert.deepEqual(from(orig.values()), from(clone.values()));
});
});
// Set
QUnit.test('Set', assert => {
cloneObjectTest(assert, new Set([1, 2, 3, 4]), (orig, clone) => {
assert.deepEqual(from(orig.values()), from(clone.values()));
});
});
// Error
QUnit.test('Error', assert => {
const errors = [
['Error', new Error()],
['Error', new Error('msg', { cause: 42 })],
['EvalError', new EvalError()],
['EvalError', new EvalError('msg', { cause: 42 })],
['RangeError', new RangeError()],
['RangeError', new RangeError('msg', { cause: 42 })],
['ReferenceError', new ReferenceError()],
['ReferenceError', new ReferenceError('msg', { cause: 42 })],
['SyntaxError', new SyntaxError()],
['SyntaxError', new SyntaxError('msg', { cause: 42 })],
['TypeError', new TypeError()],
['TypeError', new TypeError('msg', { cause: 42 })],
['URIError', new URIError()],
['URIError', new URIError('msg', { cause: 42 })],
['AggregateError', new AggregateError([1, 2])],
['AggregateError', new AggregateError([1, 2], 'msg', { cause: 42 })],
];
const compile = fromSource('WebAssembly.CompileError()');
const link = fromSource('WebAssembly.LinkError()');
const runtime = fromSource('WebAssembly.RuntimeError()');
if (compile && compile.name === 'CompileError') errors.push(['CompileError', compile]);
if (link && link.name === 'LinkError') errors.push(['LinkError', link]);
if (runtime && runtime.name === 'RuntimeError') errors.push(['RuntimeError', runtime]);
for (const [name, error] of errors) cloneObjectTest(assert, error, (orig, clone) => {
assert.same(orig.constructor, clone.constructor, `${ name }#constructor`);
assert.same(orig.name, clone.name, `${ name }#name`);
assert.same(orig.message, clone.message, `${ name }#message`);
assert.same(orig.stack, clone.stack, `${ name }#stack`);
assert.same(orig.cause, clone.cause, `${ name }#cause`);
assert.deepEqual(orig.errors, clone.errors, `${ name }#errors`);
});
});
// Arrays
QUnit.test('Array', assert => {
const arrays = [
[],
[1, 2, 3],
Array(1),
assign(
['foo', 'bar'],
{ 10: true, 11: false, 20: 123, 21: 456, 30: null }),
assign(
['foo', 'bar'],
{ a: true, b: false, foo: 123, bar: 456, '': null }),
];
for (const array of arrays) cloneObjectTest(assert, array, (orig, clone) => {
assert.deepEqual(orig, clone, `array content should be same: ${ array }`);
assert.deepEqual(orig.length, clone.length, `array length should be same: ${ array }`);
assert.deepEqual(keys(orig), keys(clone), `array key should be same: ${ array }`);
for (const key of keys(orig)) {
assert.same(orig[key], clone[key], `Property ${ key }`);
}
});
});
// Objects
QUnit.test('Object', assert => {
cloneObjectTest(assert, { foo: true, bar: false }, (orig, clone) => {
assert.deepEqual(keys(orig), keys(clone));
for (const key of keys(orig)) {
assert.same(orig[key], clone[key], `Property ${ key }`);
}
});
});
// [Serializable] Platform objects
// Geometry types
if (typeof DOMMatrix == 'function') {
QUnit.test('Geometry types, DOMMatrix', assert => {
cloneObjectTest(assert, new DOMMatrix(), (orig, clone) => {
for (const key of keys(getPrototypeOf(orig))) {
assert.same(orig[key], clone[key], `Property ${ key }`);
}
});
});
}
if (typeof DOMMatrixReadOnly == 'function' && typeof DOMMatrixReadOnly.fromMatrix == 'function') {
QUnit.test('Geometry types, DOMMatrixReadOnly', assert => {
cloneObjectTest(assert, new DOMMatrixReadOnly(), (orig, clone) => {
for (const key of keys(getPrototypeOf(orig))) {
assert.same(orig[key], clone[key], `Property ${ key }`);
}
});
});
}
if (typeof DOMPoint == 'function') {
QUnit.test('Geometry types, DOMPoint', assert => {
cloneObjectTest(assert, new DOMPoint(1, 2, 3, 4), (orig, clone) => {
for (const key of keys(getPrototypeOf(orig))) {
assert.same(orig[key], clone[key], `Property ${ key }`);
}
});
});
}
if (typeof DOMPointReadOnly == 'function' && typeof DOMPointReadOnly.fromPoint == 'function') {
QUnit.test('Geometry types, DOMPointReadOnly', assert => {
cloneObjectTest(assert, new DOMPointReadOnly(1, 2, 3, 4), (orig, clone) => {
for (const key of keys(getPrototypeOf(orig))) {
assert.same(orig[key], clone[key], `Property ${ key }`);
}
});
});
}
if (typeof DOMQuad == 'function' && typeof DOMPoint == 'function') {
QUnit.test('Geometry types, DOMQuad', assert => {
cloneObjectTest(assert, new DOMQuad(
new DOMPoint(1, 2, 3, 4),
new DOMPoint(2, 2, 3, 4),
new DOMPoint(1, 3, 3, 4),
new DOMPoint(1, 2, 4, 4),
), (orig, clone) => {
for (const key of keys(getPrototypeOf(orig))) {
assert.deepEqual(orig[key], clone[key], `Property ${ key }`);
}
});
});
}
if (fromSource('new DOMRect(1, 2, 3, 4)')) {
QUnit.test('Geometry types, DOMRect', assert => {
cloneObjectTest(assert, new DOMRect(1, 2, 3, 4), (orig, clone) => {
for (const key of keys(getPrototypeOf(orig))) {
assert.same(orig[key], clone[key], `Property ${ key }`);
}
});
});
}
if (typeof DOMRectReadOnly == 'function' && typeof DOMRectReadOnly.fromRect == 'function') {
QUnit.test('Geometry types, DOMRectReadOnly', assert => {
cloneObjectTest(assert, new DOMRectReadOnly(1, 2, 3, 4), (orig, clone) => {
for (const key of keys(getPrototypeOf(orig))) {
assert.same(orig[key], clone[key], `Property ${ key }`);
}
});
});
}
// Safari 8- does not support `{ colorSpace }` option
if (fromSource('new ImageData(new ImageData(8, 8).data, 8, 8, { colorSpace: new ImageData(8, 8).colorSpace })')) {
QUnit.test('ImageData', assert => {
const imageData = new ImageData(8, 8);
for (let i = 0; i < 256; ++i) {
imageData.data[i] = i;
}
cloneObjectTest(assert, imageData, (orig, clone) => {
assert.same(orig.width, clone.width);
assert.same(orig.height, clone.height);
assert.same(orig.colorSpace, clone.colorSpace);
assert.arrayEqual(orig.data, clone.data);
});
});
}
if (fromSource('new Blob(["test"])')) QUnit.test('Blob', assert => {
cloneObjectTest(
assert,
new Blob(['This is a test.'], { type: 'a/b' }),
(orig, clone) => {
assert.same(orig.size, clone.size);
assert.same(orig.type, clone.type);
// TODO: async
// assert.same(await orig.text(), await clone.text());
});
});
QUnit.test('DOMException', assert => {
const errors = [
new DOMException(),
new DOMException('foo', 'DataCloneError'),
];
for (const error of errors) cloneObjectTest(assert, error, (orig, clone) => {
assert.same(orig.name, clone.name);
assert.same(orig.message, clone.message);
assert.same(orig.code, clone.code);
assert.same(orig.stack, clone.stack);
});
});
// https://github.com/oven-sh/bun/issues/11696
if (!BUN && fromSource('new File(["test"], "foo.txt")')) QUnit.test('File', assert => {
cloneObjectTest(
assert,
new File(['This is a test.'], 'foo.txt', { type: 'c/d' }),
(orig, clone) => {
assert.same(orig.size, clone.size);
assert.same(orig.type, clone.type);
assert.same(orig.name, clone.name);
assert.same(orig.lastModified, clone.lastModified);
// TODO: async
// assert.same(await orig.text(), await clone.text());
});
});
// FileList
if (fromSource('new File(["test"], "foo.txt")') && fromSource('new DataTransfer() && "items" in DataTransfer.prototype')) QUnit.test('FileList', assert => {
const transfer = new DataTransfer();
transfer.items.add(new File(['test'], 'foo.txt'));
cloneObjectTest(
assert,
transfer.files,
(orig, clone) => {
assert.same(clone.length, 1);
assert.same(orig[0].size, clone[0].size);
assert.same(orig[0].type, clone[0].type);
assert.same(orig[0].name, clone[0].name);
assert.same(orig[0].lastModified, clone[0].lastModified);
},
);
});
// Non-serializable types
QUnit.test('Non-serializable types', assert => {
const nons = [
function () { return 1; },
Symbol('desc'),
GLOBAL,
];
const event = fromSource('new Event("")');
const port = fromSource('new MessageChannel().port1');
// NodeJS events are simple objects
if (event && !NODE) nons.push(event);
if (port) nons.push(port);
for (const it of nons) {
// native NodeJS `structuredClone` throws a `TypeError` on transferable non-serializable instead of `DOMException`
// https://github.com/nodejs/node/issues/40841
assert.throws(() => structuredClone(it));
}
});
});
================================================
FILE: tests/unit-pure/web.url-search-params.js
================================================
import { DESCRIPTORS, BUN } from '../helpers/constants.js';
import { createIterable } from '../helpers/helpers.js';
import getPrototypeOf from 'core-js-pure/es/object/get-prototype-of';
import getOwnPropertyDescriptor from 'core-js-pure/es/object/get-own-property-descriptor';
import Symbol from 'core-js-pure/es/symbol';
import URL from 'core-js-pure/stable/url';
import URLSearchParams from 'core-js-pure/stable/url-search-params';
QUnit.test('URLSearchParams', assert => {
assert.isFunction(URLSearchParams);
assert.arity(URLSearchParams, 0);
assert.same(String(new URLSearchParams()), '');
assert.same(String(new URLSearchParams('')), '');
assert.same(String(new URLSearchParams('a=b')), 'a=b');
assert.same(String(new URLSearchParams(new URLSearchParams('a=b'))), 'a=b');
assert.same(String(new URLSearchParams([])), '');
assert.same(String(new URLSearchParams([[1, 2], ['a', 'b']])), '1=2&a=b');
assert.same(String(new URLSearchParams(createIterable([createIterable(['a', 'b']), createIterable(['c', 'd'])]))), 'a=b&c=d');
assert.same(String(new URLSearchParams({})), '');
assert.same(String(new URLSearchParams({ 1: 2, a: 'b' })), '1=2&a=b');
assert.same(String(new URLSearchParams('?a=b')), 'a=b', 'leading ? should be ignored');
assert.same(String(new URLSearchParams('??a=b')), '%3Fa=b');
assert.same(String(new URLSearchParams('?')), '');
assert.same(String(new URLSearchParams('??')), '%3F=');
assert.same(String(new URLSearchParams('a=b c')), 'a=b+c');
assert.same(String(new URLSearchParams('a=b&b=c&a=d')), 'a=b&b=c&a=d');
assert.same(String(new URLSearchParams('a==')), 'a=%3D');
assert.same(String(new URLSearchParams('a=b=')), 'a=b%3D');
assert.same(String(new URLSearchParams('a=b=c')), 'a=b%3Dc');
assert.same(String(new URLSearchParams('a==b')), 'a=%3Db');
let params = new URLSearchParams('a=b');
assert.true(params.has('a'), 'search params object has name "a"');
assert.false(params.has('b'), 'search params object has not got name "b"');
params = new URLSearchParams('a=b&c');
assert.true(params.has('a'), 'search params object has name "a"');
assert.true(params.has('c'), 'search params object has name "c"');
params = new URLSearchParams('&a&&& &&&&&a+b=& c&m%c3%b8%c3%b8');
assert.true(params.has('a'), 'search params object has name "a"');
assert.true(params.has('a b'), 'search params object has name "a b"');
assert.true(params.has(' '), 'search params object has name " "');
assert.false(params.has('c'), 'search params object did not have the name "c"');
assert.true(params.has(' c'), 'search params object has name " c"');
assert.true(params.has('møø'), 'search params object has name "møø"');
params = new URLSearchParams('a=b+c');
assert.same(params.get('a'), 'b c', 'parse +');
params = new URLSearchParams('a+b=c');
assert.same(params.get('a b'), 'c', 'parse +');
params = new URLSearchParams('a=b c');
assert.same(params.get('a'), 'b c', 'parse " "');
params = new URLSearchParams('a b=c');
assert.same(params.get('a b'), 'c', 'parse " "');
params = new URLSearchParams('a=b%20c');
assert.same(params.get('a'), 'b c', 'parse %20');
params = new URLSearchParams('a%20b=c');
assert.same(params.get('a b'), 'c', 'parse %20');
params = new URLSearchParams('a=b\0c');
assert.same(params.get('a'), 'b\0c', 'parse \\0');
params = new URLSearchParams('a\0b=c');
assert.same(params.get('a\0b'), 'c', 'parse \\0');
params = new URLSearchParams('a=b%00c');
assert.same(params.get('a'), 'b\0c', 'parse %00');
params = new URLSearchParams('a%00b=c');
assert.same(params.get('a\0b'), 'c', 'parse %00');
params = new URLSearchParams('a=b\u2384');
assert.same(params.get('a'), 'b\u2384', 'parse \u2384');
params = new URLSearchParams('a\u2384b=c');
assert.same(params.get('a\u2384b'), 'c', 'parse \u2384');
params = new URLSearchParams('a=b%e2%8e%84');
assert.same(params.get('a'), 'b\u2384', 'parse %e2%8e%84');
params = new URLSearchParams('a%e2%8e%84b=c');
assert.same(params.get('a\u2384b'), 'c', 'parse %e2%8e%84');
params = new URLSearchParams('a=b\uD83D\uDCA9c');
assert.same(params.get('a'), 'b\uD83D\uDCA9c', 'parse \uD83D\uDCA9');
params = new URLSearchParams('a\uD83D\uDCA9b=c');
assert.same(params.get('a\uD83D\uDCA9b'), 'c', 'parse \uD83D\uDCA9');
params = new URLSearchParams('a=b%f0%9f%92%a9c');
assert.same(params.get('a'), 'b\uD83D\uDCA9c', 'parse %f0%9f%92%a9');
params = new URLSearchParams('a%f0%9f%92%a9b=c');
assert.same(params.get('a\uD83D\uDCA9b'), 'c', 'parse %f0%9f%92%a9');
params = new URLSearchParams();
params.set('query', '+15555555555');
assert.same(params.toString(), 'query=%2B15555555555');
assert.same(params.get('query'), '+15555555555', 'parse encoded +');
params = new URLSearchParams(params.toString());
assert.same(params.get('query'), '+15555555555', 'parse encoded +');
params = new URLSearchParams('b=%2sf%2a');
assert.same(params.get('b'), '%2sf*', 'parse encoded %2sf%2a');
params = new URLSearchParams('b=%%2a');
assert.same(params.get('b'), '%*', 'parse encoded b=%%2a');
assert.same(String(new URLSearchParams('%C2')), '%EF%BF%BD=');
assert.same(String(new URLSearchParams('%F0%9F%D0%90')), '%EF%BF%BD%D0%90=');
assert.same(String(new URLSearchParams('%25')), '%25=');
assert.same(String(new URLSearchParams('%4')), '%254=');
assert.same(String(new URLSearchParams('%C3%ZZ')), '%EF%BF%BD%25ZZ=', 'invalid hex in continuation byte preserved');
// overlong UTF-8 encodings
assert.same(String(new URLSearchParams('%C0%AF')), '%EF%BF%BD%EF%BF%BD=', 'overlong 2-byte slash');
assert.same(String(new URLSearchParams('%C0%80')), '%EF%BF%BD%EF%BF%BD=', 'overlong 2-byte NUL');
assert.same(String(new URLSearchParams('%E0%80%AF')), '%EF%BF%BD%EF%BF%BD%EF%BF%BD=', 'overlong 3-byte slash');
assert.same(String(new URLSearchParams('%F0%80%80%AF')), '%EF%BF%BD%EF%BF%BD%EF%BF%BD%EF%BF%BD=', 'overlong 4-byte slash');
// surrogate codepoints encoded in UTF-8
assert.same(String(new URLSearchParams('%ED%A0%80')), '%EF%BF%BD%EF%BF%BD%EF%BF%BD=', 'UTF-8 encoded U+D800');
assert.same(String(new URLSearchParams('%ED%BF%BF')), '%EF%BF%BD%EF%BF%BD%EF%BF%BD=', 'UTF-8 encoded U+DFFF');
// incomplete sequences with out-of-range continuation bytes per WHATWG encoding spec
assert.same(String(new URLSearchParams('%ED%A0')), '%EF%BF%BD%EF%BF%BD=', 'incomplete surrogate: ED A0');
assert.same(String(new URLSearchParams('%E0%80')), '%EF%BF%BD%EF%BF%BD=', 'incomplete overlong 3-byte: E0 80');
assert.same(String(new URLSearchParams('%F0%80%80')), '%EF%BF%BD%EF%BF%BD%EF%BF%BD=', 'incomplete overlong 4-byte: F0 80 80');
assert.same(String(new URLSearchParams('%F4%90')), '%EF%BF%BD%EF%BF%BD=', 'incomplete out-of-range 4-byte: F4 90');
const testData = [
{ input: '?a=%', output: [['a', '%']], name: 'handling %' },
{ input: { '+': '%C2' }, output: [['+', '%C2']], name: 'object with +' },
{ input: { c: 'x', a: '?' }, output: [['c', 'x'], ['a', '?']], name: 'object with two keys' },
{ input: [['c', 'x'], ['a', '?']], output: [['c', 'x'], ['a', '?']], name: 'array with two keys' },
// eslint-disable-next-line @stylistic/max-len -- ignore
// !!! { input: { 'a\0b': '42', 'c\uD83D': '23', dሴ: 'foo' }, output: [['a\0b', '42'], ['c\uFFFD', '23'], ['d\u1234', 'foo']], name: 'object with NULL, non-ASCII, and surrogate keys' },
];
for (const { input, output, name } of testData) {
params = new URLSearchParams(input);
let i = 0;
params.forEach((value, key) => {
const [reqKey, reqValue] = output[i++];
assert.same(key, reqKey, `construct with ${ name }`);
assert.same(value, reqValue, `construct with ${ name }`);
});
}
// https://github.com/oven-sh/bun/issues/9253
if (!BUN) assert.throws(() => {
// eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
URLSearchParams('');
}, 'throws w/o `new`');
assert.throws(() => {
new URLSearchParams([[1, 2, 3]]);
}, 'sequence elements must be pairs #1');
assert.throws(() => {
new URLSearchParams([createIterable([createIterable([1, 2, 3])])]);
}, 'sequence elements must be pairs #2');
assert.throws(() => {
new URLSearchParams([[1]]);
}, 'sequence elements must be pairs #3');
assert.throws(() => {
new URLSearchParams([createIterable([createIterable([1])])]);
}, 'sequence elements must be pairs #4');
});
QUnit.test('URLSearchParams#append', assert => {
const { append } = URLSearchParams.prototype;
assert.isFunction(append);
assert.arity(append, 2);
assert.enumerable(URLSearchParams.prototype, 'append');
assert.same(new URLSearchParams().append('a', 'b'), undefined, 'void');
let params = new URLSearchParams();
params.append('a', 'b');
assert.same(String(params), 'a=b');
params.append('a', 'b');
assert.same(String(params), 'a=b&a=b');
params.append('a', 'c');
assert.same(String(params), 'a=b&a=b&a=c');
params = new URLSearchParams();
params.append('', '');
assert.same(String(params), '=');
params.append('', '');
assert.same(String(params), '=&=');
params = new URLSearchParams();
params.append(undefined, undefined);
assert.same(String(params), 'undefined=undefined');
params.append(undefined, undefined);
assert.same(String(params), 'undefined=undefined&undefined=undefined');
params = new URLSearchParams();
params.append(null, null);
assert.same(String(params), 'null=null');
params.append(null, null);
assert.same(String(params), 'null=null&null=null');
params = new URLSearchParams();
params.append('first', 1);
params.append('second', 2);
params.append('third', '');
params.append('first', 10);
assert.true(params.has('first'), 'search params object has name "first"');
assert.same(params.get('first'), '1', 'search params object has name "first" with value "1"');
assert.same(params.get('second'), '2', 'search params object has name "second" with value "2"');
assert.same(params.get('third'), '', 'search params object has name "third" with value ""');
params.append('first', 10);
assert.same(params.get('first'), '1', 'search params object has name "first" with value "1"');
assert.throws(() => {
return new URLSearchParams('').append();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#delete', assert => {
const $delete = URLSearchParams.prototype.delete;
assert.isFunction($delete);
assert.arity($delete, 1);
assert.enumerable(URLSearchParams.prototype, 'delete');
let params = new URLSearchParams('a=b&c=d');
params.delete('a');
assert.same(String(params), 'c=d');
params = new URLSearchParams('a=a&b=b&a=a&c=c');
params.delete('a');
assert.same(String(params), 'b=b&c=c');
params = new URLSearchParams('a=a&=&b=b&c=c');
params.delete('');
assert.same(String(params), 'a=a&b=b&c=c');
params = new URLSearchParams('a=a&null=null&b=b');
params.delete(null);
assert.same(String(params), 'a=a&b=b');
params = new URLSearchParams('a=a&undefined=undefined&b=b');
params.delete(undefined);
assert.same(String(params), 'a=a&b=b');
params = new URLSearchParams();
params.append('first', 1);
assert.true(params.has('first'), 'search params object has name "first"');
assert.same(params.get('first'), '1', 'search params object has name "first" with value "1"');
params.delete('first');
assert.false(params.has('first'), 'search params object has no "first" name');
params.append('first', 1);
params.append('first', 10);
params.delete('first');
assert.false(params.has('first'), 'search params object has no "first" name');
params = new URLSearchParams('a=1&a=2&a=null&a=3&b=4');
params.delete('a', 2);
assert.same(String(params), 'a=1&a=null&a=3&b=4');
params = new URLSearchParams('a=1&a=1&b=2&a=1');
params.delete('a', '1');
assert.same(String(params), 'b=2', 'delete with value removes all matching name+value pairs');
params = new URLSearchParams('a=1&a=2&a=null&a=3&b=4');
params.delete('a', null);
assert.same(String(params), 'a=1&a=2&a=3&b=4');
params = new URLSearchParams('a=1&a=2&a=null&a=3&b=4');
params.delete('a', undefined);
assert.same(String(params), 'b=4');
// delete with value should not drop entries with the same key before the target
params = new URLSearchParams('b=1&a=2&b=3');
params.delete('a', '2');
assert.same(String(params), 'b=1&b=3', 'entries before target with same key preserved');
params = new URLSearchParams('a=1&a=2&b=3');
params.delete('a', '1');
assert.same(String(params), 'a=2&b=3', 'only matching name+value pairs removed, rest preserved');
params = new URLSearchParams('a=1&b=2');
params.delete('a', '999');
assert.same(String(params), 'a=1&b=2', 'no match leaves all entries intact');
if (DESCRIPTORS) {
let url = new URL('http://example.com/?param1¶m2');
url.searchParams.delete('param1');
url.searchParams.delete('param2');
assert.same(String(url), 'http://example.com/', 'url.href does not have ?');
assert.same(url.search, '', 'url.search does not have ?');
url = new URL('http://example.com/?');
url.searchParams.delete('param1');
// assert.same(String(url), 'http://example.com/', 'url.href does not have ?'); // Safari bug
assert.same(url.search, '', 'url.search does not have ?');
}
assert.throws(() => {
return new URLSearchParams('').delete();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#get', assert => {
const { get } = URLSearchParams.prototype;
assert.isFunction(get);
assert.arity(get, 1);
assert.enumerable(URLSearchParams.prototype, 'get');
let params = new URLSearchParams('a=b&c=d');
assert.same(params.get('a'), 'b');
assert.same(params.get('c'), 'd');
assert.same(params.get('e'), null);
params = new URLSearchParams('a=b&c=d&a=e');
assert.same(params.get('a'), 'b');
params = new URLSearchParams('=b&c=d');
assert.same(params.get(''), 'b');
params = new URLSearchParams('a=&c=d&a=e');
assert.same(params.get('a'), '');
params = new URLSearchParams('first=second&third&&');
assert.true(params.has('first'), 'Search params object has name "first"');
assert.same(params.get('first'), 'second', 'Search params object has name "first" with value "second"');
assert.same(params.get('third'), '', 'Search params object has name "third" with the empty value.');
assert.same(params.get('fourth'), null, 'Search params object has no "fourth" name and value.');
assert.same(new URLSearchParams('a=b c').get('a'), 'b c');
assert.same(new URLSearchParams('a b=c').get('a b'), 'c');
assert.same(new URLSearchParams('a=b%20c').get('a'), 'b c', 'parse %20');
assert.same(new URLSearchParams('a%20b=c').get('a b'), 'c', 'parse %20');
assert.same(new URLSearchParams('a=b\0c').get('a'), 'b\0c', 'parse \\0');
assert.same(new URLSearchParams('a\0b=c').get('a\0b'), 'c', 'parse \\0');
assert.same(new URLSearchParams('a=b%2Bc').get('a'), 'b+c', 'parse %2B');
assert.same(new URLSearchParams('a%2Bb=c').get('a+b'), 'c', 'parse %2B');
assert.same(new URLSearchParams('a=b%00c').get('a'), 'b\0c', 'parse %00');
assert.same(new URLSearchParams('a%00b=c').get('a\0b'), 'c', 'parse %00');
assert.same(new URLSearchParams('a==').get('a'), '=', 'parse =');
assert.same(new URLSearchParams('a=b=').get('a'), 'b=', 'parse =');
assert.same(new URLSearchParams('a=b=c').get('a'), 'b=c', 'parse =');
assert.same(new URLSearchParams('a==b').get('a'), '=b', 'parse =');
assert.same(new URLSearchParams('a=b\u2384').get('a'), 'b\u2384', 'parse \\u2384');
assert.same(new URLSearchParams('a\u2384b=c').get('a\u2384b'), 'c', 'parse \\u2384');
assert.same(new URLSearchParams('a=b%e2%8e%84').get('a'), 'b\u2384', 'parse %e2%8e%84');
assert.same(new URLSearchParams('a%e2%8e%84b=c').get('a\u2384b'), 'c', 'parse %e2%8e%84');
assert.same(new URLSearchParams('a=b\uD83D\uDCA9c').get('a'), 'b\uD83D\uDCA9c', 'parse \\uD83D\\uDCA9');
assert.same(new URLSearchParams('a\uD83D\uDCA9b=c').get('a\uD83D\uDCA9b'), 'c', 'parse \\uD83D\\uDCA9');
assert.same(new URLSearchParams('a=b%f0%9f%92%a9c').get('a'), 'b\uD83D\uDCA9c', 'parse %f0%9f%92%a9');
assert.same(new URLSearchParams('a%f0%9f%92%a9b=c').get('a\uD83D\uDCA9b'), 'c', 'parse %f0%9f%92%a9');
assert.same(new URLSearchParams('=').get(''), '', 'parse =');
assert.throws(() => {
return new URLSearchParams('').get();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#getAll', assert => {
const { getAll } = URLSearchParams.prototype;
assert.isFunction(getAll);
assert.arity(getAll, 1);
assert.enumerable(URLSearchParams.prototype, 'getAll');
let params = new URLSearchParams('a=b&c=d');
assert.arrayEqual(params.getAll('a'), ['b']);
assert.arrayEqual(params.getAll('c'), ['d']);
assert.arrayEqual(params.getAll('e'), []);
params = new URLSearchParams('a=b&c=d&a=e');
assert.arrayEqual(params.getAll('a'), ['b', 'e']);
params = new URLSearchParams('=b&c=d');
assert.arrayEqual(params.getAll(''), ['b']);
params = new URLSearchParams('a=&c=d&a=e');
assert.arrayEqual(params.getAll('a'), ['', 'e']);
params = new URLSearchParams('a=1&a=2&a=3&a');
assert.arrayEqual(params.getAll('a'), ['1', '2', '3', ''], 'search params object has expected name "a" values');
params.set('a', 'one');
assert.arrayEqual(params.getAll('a'), ['one'], 'search params object has expected name "a" values');
assert.throws(() => {
return new URLSearchParams('').getAll();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#has', assert => {
const { has } = URLSearchParams.prototype;
assert.isFunction(has);
assert.arity(has, 1);
assert.enumerable(URLSearchParams.prototype, 'has');
let params = new URLSearchParams('a=b&c=d');
assert.true(params.has('a'));
assert.true(params.has('c'));
assert.false(params.has('e'));
params = new URLSearchParams('a=b&c=d&a=e');
assert.true(params.has('a'));
params = new URLSearchParams('=b&c=d');
assert.true(params.has(''));
params = new URLSearchParams('null=a');
assert.true(params.has(null));
params = new URLSearchParams('a=b&c=d&&');
params.append('first', 1);
params.append('first', 2);
assert.true(params.has('a'), 'search params object has name "a"');
assert.true(params.has('c'), 'search params object has name "c"');
assert.true(params.has('first'), 'search params object has name "first"');
assert.false(params.has('d'), 'search params object has no name "d"');
params.delete('first');
assert.false(params.has('first'), 'search params object has no name "first"');
params = new URLSearchParams('a=1&a=2&a=null&a=3&b=4');
assert.true(params.has('a', 2));
assert.true(params.has('a', null));
assert.false(params.has('a', 4));
assert.true(params.has('b', 4));
assert.false(params.has('b', null));
assert.true(params.has('b', undefined));
assert.false(params.has('c', undefined));
assert.throws(() => {
return new URLSearchParams('').has();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#set', assert => {
const { set } = URLSearchParams.prototype;
assert.isFunction(set);
assert.arity(set, 2);
assert.enumerable(URLSearchParams.prototype, 'set');
let params = new URLSearchParams('a=b&c=d');
params.set('a', 'B');
assert.same(String(params), 'a=B&c=d');
params = new URLSearchParams('a=b&c=d&a=e');
params.set('a', 'B');
assert.same(String(params), 'a=B&c=d');
params.set('e', 'f');
assert.same(String(params), 'a=B&c=d&e=f');
params = new URLSearchParams('a=1&a=2&a=3');
assert.true(params.has('a'), 'search params object has name "a"');
assert.same(params.get('a'), '1', 'search params object has name "a" with value "1"');
params.set('first', 4);
assert.true(params.has('a'), 'search params object has name "a"');
assert.same(params.get('a'), '1', 'search params object has name "a" with value "1"');
assert.same(String(params), 'a=1&a=2&a=3&first=4');
params.set('a', 4);
assert.true(params.has('a'), 'search params object has name "a"');
assert.same(params.get('a'), '4', 'search params object has name "a" with value "4"');
assert.same(String(params), 'a=4&first=4');
assert.throws(() => new URLSearchParams('').set(), 'throws w/o arguments');
assert.throws(() => new URLSearchParams('').set('a'), 'throws with only 1 argument');
});
QUnit.test('URLSearchParams#sort', assert => {
const { sort } = URLSearchParams.prototype;
assert.isFunction(sort);
assert.arity(sort, 0);
assert.enumerable(URLSearchParams.prototype, 'sort');
let params = new URLSearchParams('a=1&b=4&a=3&b=2');
params.sort();
assert.same(String(params), 'a=1&a=3&b=4&b=2');
params.delete('a');
params.append('a', '0');
params.append('b', '0');
params.sort();
assert.same(String(params), 'a=0&b=4&b=2&b=0');
const testData = [
{
input: 'z=b&a=b&z=a&a=a',
output: [['a', 'b'], ['a', 'a'], ['z', 'b'], ['z', 'a']],
},
{
input: '\uFFFD=x&\uFFFC&\uFFFD=a',
output: [['\uFFFC', ''], ['\uFFFD', 'x'], ['\uFFFD', 'a']],
},
{
input: 'ffi&🌈', // 🌈 > code point, but < code unit because two code units
output: [['🌈', ''], ['ffi', '']],
},
{
input: 'é&e\uFFFD&e\u0301',
output: [['e\u0301', ''], ['e\uFFFD', ''], ['é', '']],
},
{
input: 'z=z&a=a&z=y&a=b&z=x&a=c&z=w&a=d&z=v&a=e&z=u&a=f&z=t&a=g',
output: [
['a', 'a'],
['a', 'b'],
['a', 'c'],
['a', 'd'],
['a', 'e'],
['a', 'f'],
['a', 'g'],
['z', 'z'],
['z', 'y'],
['z', 'x'],
['z', 'w'],
['z', 'v'],
['z', 'u'],
['z', 't'],
],
},
{
input: 'bbb&bb&aaa&aa=x&aa=y',
output: [['aa', 'x'], ['aa', 'y'], ['aaa', ''], ['bb', ''], ['bbb', '']],
},
{
input: 'z=z&=f&=t&=x',
output: [['', 'f'], ['', 't'], ['', 'x'], ['z', 'z']],
},
{
input: 'a🌈&a💩',
output: [['a🌈', ''], ['a💩', '']],
},
];
for (const { input, output } of testData) {
let i = 0;
params = new URLSearchParams(input);
params.sort();
params.forEach((value, key) => {
const [reqKey, reqValue] = output[i++];
assert.same(key, reqKey);
assert.same(value, reqValue);
});
i = 0;
const url = new URL(`?${ input }`, 'https://example/');
params = url.searchParams;
params.sort();
params.forEach((value, key) => {
const [reqKey, reqValue] = output[i++];
assert.same(key, reqKey);
assert.same(value, reqValue);
});
}
if (DESCRIPTORS) {
const url = new URL('http://example.com/?');
url.searchParams.sort();
assert.same(url.href, 'http://example.com/', 'Sorting non-existent params removes ? from URL');
assert.same(url.search, '', 'Sorting non-existent params removes ? from URL');
}
});
QUnit.test('URLSearchParams#toString', assert => {
const { toString } = URLSearchParams.prototype;
assert.isFunction(toString);
assert.arity(toString, 0);
let params = new URLSearchParams();
params.append('a', 'b c');
assert.same(String(params), 'a=b+c');
params.delete('a');
params.append('a b', 'c');
assert.same(String(params), 'a+b=c');
params = new URLSearchParams();
params.append('a', '');
assert.same(String(params), 'a=');
params.append('a', '');
assert.same(String(params), 'a=&a=');
params.append('', 'b');
assert.same(String(params), 'a=&a=&=b');
params.append('', '');
assert.same(String(params), 'a=&a=&=b&=');
params.append('', '');
assert.same(String(params), 'a=&a=&=b&=&=');
params = new URLSearchParams();
params.append('', 'b');
assert.same(String(params), '=b');
params.append('', 'b');
assert.same(String(params), '=b&=b');
params = new URLSearchParams();
params.append('', '');
assert.same(String(params), '=');
params.append('', '');
assert.same(String(params), '=&=');
params = new URLSearchParams();
params.append('a', 'b+c');
assert.same(String(params), 'a=b%2Bc');
params.delete('a');
params.append('a+b', 'c');
assert.same(String(params), 'a%2Bb=c');
params = new URLSearchParams();
params.append('=', 'a');
assert.same(String(params), '%3D=a');
params.append('b', '=');
assert.same(String(params), '%3D=a&b=%3D');
params = new URLSearchParams();
params.append('&', 'a');
assert.same(String(params), '%26=a');
params.append('b', '&');
assert.same(String(params), '%26=a&b=%26');
params = new URLSearchParams();
params.append('a', '\r');
assert.same(String(params), 'a=%0D');
params = new URLSearchParams();
params.append('a', '\n');
assert.same(String(params), 'a=%0A');
params = new URLSearchParams();
params.append('a', '\r\n');
assert.same(String(params), 'a=%0D%0A');
params = new URLSearchParams();
params.append('a', 'b%c');
assert.same(String(params), 'a=b%25c');
params.delete('a');
params.append('a%b', 'c');
assert.same(String(params), 'a%25b=c');
params = new URLSearchParams();
params.append('a', 'b\0c');
assert.same(String(params), 'a=b%00c');
params.delete('a');
params.append('a\0b', 'c');
assert.same(String(params), 'a%00b=c');
params = new URLSearchParams();
params.append('a', 'b\uD83D\uDCA9c');
assert.same(String(params), 'a=b%F0%9F%92%A9c');
params.delete('a');
params.append('a\uD83D\uDCA9b', 'c');
assert.same(String(params), 'a%F0%9F%92%A9b=c');
params = new URLSearchParams('a=b&c=d&&e&&');
assert.same(String(params), 'a=b&c=d&e=');
params = new URLSearchParams('a = b &a=b&c=d%20');
assert.same(String(params), 'a+=+b+&a=b&c=d+');
params = new URLSearchParams('a=&a=b');
assert.same(String(params), 'a=&a=b');
});
QUnit.test('URLSearchParams#forEach', assert => {
const { forEach } = URLSearchParams.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.enumerable(URLSearchParams.prototype, 'forEach');
const expectedValues = { a: '1', b: '2', c: '3' };
let params = new URLSearchParams('a=1&b=2&c=3');
let result = '';
params.forEach((value, key, that) => {
assert.same(params.get(key), expectedValues[key]);
assert.same(value, expectedValues[key]);
assert.same(that, params);
result += key;
});
assert.same(result, 'abc');
new URL('http://a.b/c').searchParams.forEach(() => {
assert.avoid();
});
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
params = url.searchParams;
result = '';
params.forEach((val, key) => {
url.search = 'x=1&y=2&z=3';
result += key + val;
});
assert.same(result, 'a1y2z3');
}
// fails in Chrome 66-
params = new URLSearchParams('a=1&b=2&c=3');
result = '';
params.forEach((value, key) => {
params.delete('b');
result += key + value;
});
assert.same(result, 'a1c3');
});
QUnit.test('URLSearchParams#entries', assert => {
const { entries } = URLSearchParams.prototype;
assert.isFunction(entries);
assert.arity(entries, 0);
assert.enumerable(URLSearchParams.prototype, 'entries');
const expectedValues = { a: '1', b: '2', c: '3' };
let params = new URLSearchParams('a=1&b=2&c=3');
let iterator = params.entries();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
assert.same(params.get(key), expectedValues[key]);
assert.same(value, expectedValues[key]);
result += key;
}
assert.same(result, 'abc');
assert.true(new URL('http://a.b/c').searchParams.entries().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
iterator = url.searchParams.entries();
result = '';
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
url.search = 'x=1&y=2&z=3';
result += key + value;
}
assert.same(result, 'a1y2z3');
}
// fails in Chrome 66-
params = new URLSearchParams('a=1&b=2&c=3');
iterator = params.entries();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const [key, value] = entry.value;
result += key + value;
}
assert.same(result, 'a1c3');
if (DESCRIPTORS) assert.true(getOwnPropertyDescriptor(getPrototypeOf(new URLSearchParams().entries()), 'next').enumerable, 'enumerable .next');
});
QUnit.test('URLSearchParams#keys', assert => {
const { keys } = URLSearchParams.prototype;
assert.isFunction(keys);
assert.arity(keys, 0);
assert.enumerable(URLSearchParams.prototype, 'keys');
let iterator = new URLSearchParams('a=1&b=2&c=3').keys();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
result += entry.value;
}
assert.same(result, 'abc');
assert.true(new URL('http://a.b/c').searchParams.keys().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
iterator = url.searchParams.keys();
result = '';
while (!(entry = iterator.next()).done) {
const key = entry.value;
url.search = 'x=1&y=2&z=3';
result += key;
}
assert.same(result, 'ayz');
}
// fails in Chrome 66-
const params = new URLSearchParams('a=1&b=2&c=3');
iterator = params.keys();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const key = entry.value;
result += key;
}
assert.same(result, 'ac');
if (DESCRIPTORS) assert.true(getOwnPropertyDescriptor(getPrototypeOf(new URLSearchParams().keys()), 'next').enumerable, 'enumerable .next');
});
QUnit.test('URLSearchParams#values', assert => {
const { values } = URLSearchParams.prototype;
assert.isFunction(values);
assert.arity(values, 0);
assert.enumerable(URLSearchParams.prototype, 'values');
let iterator = new URLSearchParams('a=1&b=2&c=3').values();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
result += entry.value;
}
assert.same(result, '123');
assert.true(new URL('http://a.b/c').searchParams.values().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=a&b=b&c=c&d=d');
iterator = url.searchParams.values();
result = '';
while (!(entry = iterator.next()).done) {
const { value } = entry;
url.search = 'x=x&y=y&z=z';
result += value;
}
assert.same(result, 'ayz');
}
// fails in Chrome 66-
const params = new URLSearchParams('a=1&b=2&c=3');
iterator = params.values();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const key = entry.value;
result += key;
}
assert.same(result, '13');
if (DESCRIPTORS) assert.true(getOwnPropertyDescriptor(getPrototypeOf(new URLSearchParams().values()), 'next').enumerable, 'enumerable .next');
});
QUnit.test('URLSearchParams#@@iterator', assert => {
const entries = URLSearchParams.prototype[Symbol.iterator];
assert.isFunction(entries);
assert.arity(entries, 0);
assert.same(entries, URLSearchParams.prototype.entries);
const expectedValues = { a: '1', b: '2', c: '3' };
let params = new URLSearchParams('a=1&b=2&c=3');
let iterator = params[Symbol.iterator]();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
assert.same(params.get(key), expectedValues[key]);
assert.same(value, expectedValues[key]);
result += key;
}
assert.same(result, 'abc');
assert.true(new URL('http://a.b/c').searchParams[Symbol.iterator]().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
iterator = url.searchParams[Symbol.iterator]();
result = '';
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
url.search = 'x=1&y=2&z=3';
result += key + value;
}
assert.same(result, 'a1y2z3');
}
// fails in Chrome 66-
params = new URLSearchParams('a=1&b=2&c=3');
iterator = params[Symbol.iterator]();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const [key, value] = entry.value;
result += key + value;
}
assert.same(result, 'a1c3');
if (DESCRIPTORS) assert.true(getOwnPropertyDescriptor(getPrototypeOf(new URLSearchParams()[Symbol.iterator]()), 'next').enumerable, 'enumerable .next');
});
QUnit.test('URLSearchParams#size', assert => {
const params = new URLSearchParams('a=1&b=2&b=3');
assert.true('size' in params);
assert.same(params.size, 3);
if (DESCRIPTORS) {
assert.true('size' in URLSearchParams.prototype);
const { enumerable, configurable, get } = getOwnPropertyDescriptor(URLSearchParams.prototype, 'size');
assert.true(enumerable, 'enumerable');
// https://github.com/oven-sh/bun/issues/9251
if (!BUN) assert.true(configurable, 'configurable');
assert.throws(() => get.call([]));
}
});
================================================
FILE: tests/unit-pure/web.url.can-parse.js
================================================
import canParse from 'core-js-pure/stable/url/can-parse';
QUnit.test('URL.canParse', assert => {
assert.isFunction(canParse);
assert.arity(canParse, 1);
assert.name(canParse, 'canParse');
assert.false(canParse(undefined), 'undefined');
assert.false(canParse(undefined, undefined), 'undefined, undefined');
assert.true(canParse('q:w'), 'q:w');
assert.true(canParse('q:w', undefined), 'q:w, undefined');
// assert.false(canParse(undefined, 'q:w'), 'undefined, q:w'); // fails in Chromium on Windows
assert.true(canParse('q:/w'), 'q:/w');
assert.true(canParse('q:/w', undefined), 'q:/w, undefined');
assert.true(canParse(undefined, 'q:/w'), 'undefined, q:/w');
assert.false(canParse('https://login:password@examp:le.com:8080/?a=1&b=2&a=3&c=4#fragment'), 'https://login:password@examp:le.com:8080/?a=1&b=2&a=3&c=4#fragment');
assert.true(canParse('https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment'), 'https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment');
assert.true(canParse('https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment', undefined), 'https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment, undefined');
assert.true(canParse('x', 'https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment'), 'x, https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment');
assert.throws(() => canParse(), 'no args');
assert.throws(() => canParse({ toString() { throw new Error('thrower'); } }), 'conversion thrower #1');
assert.throws(() => canParse('q:w', { toString() { throw new Error('thrower'); } }), 'conversion thrower #2');
});
================================================
FILE: tests/unit-pure/web.url.js
================================================
/* eslint-disable es/no-object-getownpropertydescriptor, unicorn/relative-url-style -- required for testing */
import { DESCRIPTORS, NODE } from '../helpers/constants.js';
import urlTestData from '../wpt-url-resources/urltestdata.js';
import settersTestData from '../wpt-url-resources/setters.js';
import toASCIITestData from '../wpt-url-resources/toascii.js';
import URL from 'core-js-pure/stable/url';
import URLSearchParams from 'core-js-pure/stable/url-search-params';
const { hasOwnProperty } = Object.prototype;
QUnit.test('URL constructor', assert => {
assert.isFunction(URL);
if (!NODE) assert.arity(URL, 1);
assert.same(String(new URL('http://www.domain.com/a/b')), 'http://www.domain.com/a/b');
assert.same(String(new URL('/c/d', 'http://www.domain.com/a/b')), 'http://www.domain.com/c/d');
assert.same(String(new URL('b/c', 'http://www.domain.com/a/b')), 'http://www.domain.com/a/b/c');
assert.same(String(new URL('b/c', new URL('http://www.domain.com/a/b'))), 'http://www.domain.com/a/b/c');
assert.same(String(new URL({ toString: () => 'https://example.org/' })), 'https://example.org/');
assert.same(String(new URL('nonspecial://example.com/')), 'nonspecial://example.com/');
// SPECIAL_AUTHORITY_SLASHES state - special schemes without base
assert.same(String(new URL('http://example.com/path')), 'http://example.com/path', 'special authority slashes with //');
assert.same(String(new URL('http:/example.com/path')), 'http://example.com/path', 'special authority slashes with single /');
assert.same(String(new URL('http:example.com/path')), 'http://example.com/path', 'special authority slashes without /');
assert.same(String(new URL('https:////example.com/path')), 'https://example.com/path', 'special authority slashes with extra /');
assert.same(String(new URL('https://測試')), 'https://xn--g6w251d/', 'unicode parsing');
assert.same(String(new URL('https://xxпривет.тест')), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(new URL('https://xxПРИВЕТ.тест')), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(new URL('http://Example.com/', 'https://example.org/')), 'http://example.com/');
assert.same(String(new URL('https://Example.com/', 'https://example.org/')), 'https://example.com/');
assert.same(String(new URL('nonspecial://Example.com/', 'https://example.org/')), 'nonspecial://Example.com/');
assert.same(String(new URL('http:Example.com/', 'https://example.org/')), 'http://example.com/');
assert.same(String(new URL('https:Example.com/', 'https://example.org/')), 'https://example.org/Example.com/');
assert.same(String(new URL('nonspecial:Example.com/', 'https://example.org/')), 'nonspecial:Example.com/');
assert.same(String(new URL('http://0300.168.0xF0')), 'http://192.168.0.240/');
assert.same(String(new URL('http://[20:0:0:1:0:0:0:ff]')), 'http://[20:0:0:1::ff]/');
// assert.same(String(new URL('http://257.168.0xF0')), 'http://257.168.0xf0/', 'incorrect IPv4 parsed as host'); // TypeError in Chrome and Safari
assert.throws(() => new URL('http://257.168.0xF0'), 'invalid IPv4: octet > 255');
assert.same(String(new URL('http://0300.168.0xG0')), 'http://0300.168.0xg0/', 'incorrect IPv4 parsed as host');
assert.throws(() => new URL('http://1.2.3.4.5/'), 'IPv4 with > 4 parts');
assert.throws(() => new URL('http://a.b.c.d.5/'), 'host ending in number with non-numeric parts');
assert.throws(() => new URL('http://foo.1/'), 'host ending in number with non-IPv4');
assert.same(String(new URL('file:///var/log/system.log')), 'file:///var/log/system.log', 'file scheme');
// Chromium ~ 145 on Windows works differently
// assert.same(String(new URL('file:foo')), 'file:///foo', 'file scheme without slashes');
// assert.same(new URL('file:foo').host, '', 'file scheme without slashes: host');
// assert.same(String(new URL('file://nnsc.nsf.net/bar/baz')), 'file://nnsc.nsf.net/bar/baz', 'file scheme'); // 'file:///bar/baz' in FF
// assert.same(String(new URL('file://localhost/bar/baz')), 'file:///bar/baz', 'file scheme'); // 'file://localhost/bar/baz' in Chrome
// FILE_SLASH state: host should be inherited from file: base
// some browsers have a non-spec-compliant native URL implementation for this case
if (new URL('file:/path', 'file://somehost/dir/file').host === 'somehost') {
assert.same(new URL('file:/path', 'file://somehost/dir/file').href, 'file://somehost/path', 'file slash: href with inherited host');
}
assert.throws(() => new URL(), 'TypeError: Failed to construct URL: 1 argument required, but only 0 present.');
assert.throws(() => new URL(''), 'TypeError: Failed to construct URL: Invalid URL');
// Node 19.7
// https://github.com/nodejs/node/issues/46755
// assert.throws(() => new URL('', 'about:blank'), 'TypeError: Failed to construct URL: Invalid URL');
assert.throws(() => new URL('abc'), 'TypeError: Failed to construct URL: Invalid URL');
assert.throws(() => new URL('//abc'), 'TypeError: Failed to construct URL: Invalid URL');
assert.throws(() => new URL('http:///www.domain.com/', 'abc'), 'TypeError: Failed to construct URL: Invalid base URL');
assert.throws(() => new URL('http:///www.domain.com/', null), 'TypeError: Failed to construct URL: Invalid base URL');
assert.throws(() => new URL('//abc', null), 'TypeError: Failed to construct URL: Invalid base URL');
assert.throws(() => new URL('http://[20:0:0:1:0:0:0:ff'), 'incorrect IPv6');
assert.throws(() => new URL('http://[20:0:0:1:0:0:0:fg]'), 'incorrect IPv6');
// assert.throws(() => new URL('http://a%b'), 'forbidden host code point'); // no error in FF
assert.throws(() => new URL('1http://zloirock.ru'), 'incorrect scheme');
assert.throws(() => new URL('a,b://example.com'), 'comma in scheme');
assert.same(String(new URL('a+b-c.d://example.com')), 'a+b-c.d://example.com', 'valid scheme with +, -, .');
assert.same(String(new URL('relative', 'foo://host')), 'foo://host/relative', 'relative URL with non-special base with empty path');
assert.same(String(new URL('bar', 'foo://host/a/b')), 'foo://host/a/bar', 'relative URL with non-special base with path');
});
QUnit.test('URL#href', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'href'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'href');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.href, 'http://zloirock.ru/');
if (DESCRIPTORS) {
url.searchParams.append('foo', 'bar');
assert.same(url.href, 'http://zloirock.ru/?foo=bar');
url = new URL('http://zloirock.ru/foo');
url.href = 'https://測試';
assert.same(url.href, 'https://xn--g6w251d/', 'unicode parsing');
assert.same(String(url), 'https://xn--g6w251d/', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.href = 'https://xxпривет.тест';
assert.same(url.href, 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(url), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.href = 'https://xxПРИВЕТ.тест';
assert.same(url.href, 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(url), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
url = new URL('http://zloirock.ru/');
url.href = 'http://0300.168.0xF0';
assert.same(url.href, 'http://192.168.0.240/');
assert.same(String(url), 'http://192.168.0.240/');
url = new URL('http://zloirock.ru/');
url.href = 'http://[20:0:0:1:0:0:0:ff]';
assert.same(url.href, 'http://[20:0:0:1::ff]/');
assert.same(String(url), 'http://[20:0:0:1::ff]/');
// url = new URL('http://zloirock.ru/');
// url.href = 'http://257.168.0xF0'; // TypeError and Safari
// assert.same(url.href, 'http://257.168.0xf0/', 'incorrect IPv4 parsed as host'); // `F` instead of `f` in Chrome
// assert.same(String(url), 'http://257.168.0xf0/', 'incorrect IPv4 parsed as host'); // `F` instead of `f` in Chrome
url = new URL('http://zloirock.ru/');
url.href = 'http://0300.168.0xG0';
assert.same(url.href, 'http://0300.168.0xg0/', 'incorrect IPv4 parsed as host');
assert.same(String(url), 'http://0300.168.0xg0/', 'incorrect IPv4 parsed as host');
url = new URL('http://192.168.0.240/');
url.href = 'file:///var/log/system.log';
assert.same(url.href, 'file:///var/log/system.log', 'file -> ip');
assert.same(String(url), 'file:///var/log/system.log', 'file -> ip');
url = new URL('file:///var/log/system.log');
url.href = 'http://0300.168.0xF0';
// Node 19.7
// https://github.com/nodejs/node/issues/46755
// assert.same(url.href, 'http://192.168.0.240/', 'file -> http');
// assert.same(String(url), 'http://192.168.0.240/', 'file -> http');
// assert.throws(() => new URL('http://zloirock.ru/').href = undefined, 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = '', 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'abc', 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = '//abc', 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'http://[20:0:0:1:0:0:0:ff', 'incorrect IPv6'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'http://[20:0:0:1:0:0:0:fg]', 'incorrect IPv6'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'http://a%b', 'forbidden host code point'); // no error in Chrome and FF
// assert.throws(() => new URL('http://zloirock.ru/').href = '1http://zloirock.ru', 'incorrect scheme'); // no error in Chrome
}
// URL serializing step 3 - /. prefix for non-special URLs with null host and path starting with empty segment
// Chromium ~ 145 on Windows works differently
// assert.same(new URL('x:/a/..//b').href, 'x:/.//b', '/. prefix prevents ambiguous serialization');
// assert.same(new URL('x:/a/..//b').pathname, '//b', 'pathname is not affected by /. prefix');
// assert.same(new URL('x:/.//b').href, 'x:/.//b', '/. prefix is idempotent');
// assert.same(new URL(new URL('x:/a/..//b').href).pathname, '//b', '/. prefix round-trips correctly');
});
QUnit.test('URL#origin', assert => {
const url = new URL('http://es6.zloirock.ru/tests.html');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'origin'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'origin');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
}
assert.same(url.origin, 'http://es6.zloirock.ru');
assert.same(new URL('https://測試/tests').origin, 'https://xn--g6w251d');
// blob URL origin should resolve to the inner URL's origin
assert.same(new URL('blob:https://example.com/some-uuid').origin, 'https://example.com');
});
QUnit.test('URL#protocol', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'protocol'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'protocol');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.protocol, 'http:');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.protocol = 'https';
assert.same(url.protocol, 'https:');
assert.same(String(url), 'https://zloirock.ru/');
// https://nodejs.org/api/url.html#url_special_schemes
// url = new URL('http://zloirock.ru/');
// url.protocol = 'fish';
// assert.same(url.protocol, 'http:');
// assert.same(url.href, 'http://zloirock.ru/');
// assert.same(String(url), 'http://zloirock.ru/');
url = new URL('http://zloirock.ru/');
url.protocol = '1http';
assert.same(url.protocol, 'http:');
assert.same(url.href, 'http://zloirock.ru/', 'incorrect scheme');
assert.same(String(url), 'http://zloirock.ru/', 'incorrect scheme');
// Chromium ~ 145 on Windows works differently
// url = new URL('file:foo');
// url.protocol = 'http:';
// assert.same(url.protocol, 'file:', 'file with empty host: protocol change blocked');
}
});
QUnit.test('URL#username', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'username'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'username');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.username, '');
url = new URL('http://username@zloirock.ru/');
assert.same(url.username, 'username');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.username = 'username';
assert.same(url.username, 'username');
assert.same(String(url), 'http://username@zloirock.ru/');
// IPv4 address 0.0.0.0 (stored as number 0) should allow username
url = new URL('http://0.0.0.0/');
url.username = 'user';
assert.same(url.username, 'user', 'username settable on 0.0.0.0');
assert.same(String(url), 'http://user@0.0.0.0/', 'href correct after setting username on 0.0.0.0');
}
});
QUnit.test('URL#password', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'password'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'password');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.password, '');
url = new URL('http://username:password@zloirock.ru/');
assert.same(url.password, 'password');
// url = new URL('http://:password@zloirock.ru/'); // TypeError in FF
// assert.same(url.password, 'password');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.username = 'username';
url.password = 'password';
assert.same(url.password, 'password');
assert.same(String(url), 'http://username:password@zloirock.ru/');
// url = new URL('http://zloirock.ru/');
// url.password = 'password';
// assert.same(url.password, 'password'); // '' in FF
// assert.same(String(url), 'http://:password@zloirock.ru/'); // 'http://zloirock.ru/' in FF
}
});
QUnit.test('URL#host', assert => {
let url = new URL('http://zloirock.ru:81/path');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'host'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'host');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.host, 'zloirock.ru:81');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru:81/path');
url.host = 'example.com:82';
assert.same(url.host, 'example.com:82');
assert.same(String(url), 'http://example.com:82/path');
// url = new URL('http://zloirock.ru:81/path');
// url.host = 'other?domain.com';
// assert.same(String(url), 'http://other:81/path'); // 'http://other/?domain.com/path' in Safari
url = new URL('https://www.mydomain.com:8080/path/');
url.host = 'www.otherdomain.com:80';
assert.same(url.href, 'https://www.otherdomain.com:80/path/', 'set default port for another protocol');
// url = new URL('https://www.mydomain.com:8080/path/');
// url.host = 'www.otherdomain.com:443';
// assert.same(url.href, 'https://www.otherdomain.com/path/', 'set default port');
url = new URL('http://zloirock.ru/foo');
url.host = '測試';
assert.same(url.host, 'xn--g6w251d', 'unicode parsing');
assert.same(String(url), 'http://xn--g6w251d/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.host = 'xxпривет.тест';
assert.same(url.host, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.host = 'xxПРИВЕТ.тест';
assert.same(url.host, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.host = '0300.168.0xF0';
assert.same(url.host, '192.168.0.240');
assert.same(String(url), 'http://192.168.0.240/foo');
// url = new URL('http://zloirock.ru/foo');
// url.host = '[20:0:0:1:0:0:0:ff]';
// assert.same(url.host, '[20:0:0:1::ff]'); // ':0' in Chrome, 'zloirock.ru' in Safari
// assert.same(String(url), 'http://[20:0:0:1::ff]/foo'); // 'http://[20:0/foo' in Chrome, 'http://zloirock.ru/foo' in Safari
// url = new URL('file:///var/log/system.log');
// url.host = 'nnsc.nsf.net'; // does not work in FF
// assert.same(url.hostname, 'nnsc.nsf.net', 'file');
// assert.same(String(url), 'file://nnsc.nsf.net/var/log/system.log', 'file');
// url = new URL('http://zloirock.ru/');
// url.host = '[20:0:0:1:0:0:0:ff';
// assert.same(url.host, 'zloirock.ru', 'incorrect IPv6'); // ':0' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0/' in Chrome
// url = new URL('http://zloirock.ru/');
// url.host = '[20:0:0:1:0:0:0:fg]';
// assert.same(url.host, 'zloirock.ru', 'incorrect IPv6'); // ':0' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0/' in Chrome
// url = new URL('http://zloirock.ru/');
// url.host = 'a%b';
// assert.same(url.host, 'zloirock.ru', 'forbidden host code point'); // '' in Chrome, 'a%b' in FF
// assert.same(String(url), 'http://zloirock.ru/', 'forbidden host code point'); // 'http://a%25b/' in Chrome, 'http://a%b/' in FF
}
});
QUnit.test('URL#hostname', assert => {
let url = new URL('http://zloirock.ru:81/');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'hostname'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'hostname');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.hostname, 'zloirock.ru');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru:81/');
url.hostname = 'example.com';
assert.same(url.hostname, 'example.com');
assert.same(String(url), 'http://example.com:81/');
url = new URL('http://zloirock.ru:81/');
url.hostname = 'example.com:82';
assert.same(url.hostname, 'zloirock.ru', 'hostname with port is rejected');
assert.same(String(url), 'http://zloirock.ru:81/', 'hostname with port is rejected');
url = new URL('http://zloirock.ru/foo');
url.hostname = '測試';
assert.same(url.hostname, 'xn--g6w251d', 'unicode parsing');
assert.same(String(url), 'http://xn--g6w251d/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.hostname = 'xxпривет.тест';
assert.same(url.hostname, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.hostname = 'xxПРИВЕТ.тест';
assert.same(url.hostname, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.hostname = '0300.168.0xF0';
assert.same(url.hostname, '192.168.0.240');
assert.same(String(url), 'http://192.168.0.240/foo');
// url = new URL('http://zloirock.ru/foo');
// url.hostname = '[20:0:0:1:0:0:0:ff]';
// assert.same(url.hostname, '[20:0:0:1::ff]'); // 'zloirock.ru' in Safari
// assert.same(String(url), 'http://[20:0:0:1::ff]/foo'); // 'http://zloirock.ru/foo' in Safari
// url = new URL('file:///var/log/system.log');
// url.hostname = 'nnsc.nsf.net'; // does not work in FF
// assert.same(url.hostname, 'nnsc.nsf.net', 'file');
// assert.same(String(url), 'file://nnsc.nsf.net/var/log/system.log', 'file');
// url = new URL('http://zloirock.ru/');
// url.hostname = '[20:0:0:1:0:0:0:ff';
// assert.same(url.hostname, 'zloirock.ru', 'incorrect IPv6'); // '' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0:0:1:0:0:0:ff' in Chrome
// url = new URL('http://zloirock.ru/');
// url.hostname = '[20:0:0:1:0:0:0:fg]';
// assert.same(url.hostname, 'zloirock.ru', 'incorrect IPv6'); // '' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0:0:1:0:0:0:ff/' in Chrome
// url = new URL('http://zloirock.ru/');
// url.hostname = 'a%b';
// assert.same(url.hostname, 'zloirock.ru', 'forbidden host code point'); // '' in Chrome, 'a%b' in FF
// assert.same(String(url), 'http://zloirock.ru/', 'forbidden host code point'); // 'http://a%25b/' in Chrome, 'http://a%b/' in FF
}
});
QUnit.test('URL#port', assert => {
let url = new URL('http://zloirock.ru:1337/');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'port'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'port');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.port, '1337');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.port = 80;
assert.same(url.port, '');
assert.same(String(url), 'http://zloirock.ru/');
url.port = 1337;
assert.same(url.port, '1337');
assert.same(String(url), 'http://zloirock.ru:1337/');
// url.port = 'abcd';
// assert.same(url.port, '1337'); // '0' in Chrome
// assert.same(String(url), 'http://zloirock.ru:1337/'); // 'http://zloirock.ru:0/' in Chrome
// url.port = '5678abcd';
// assert.same(url.port, '5678'); // '1337' in FF
// assert.same(String(url), 'http://zloirock.ru:5678/'); // 'http://zloirock.ru:1337/"' in FF
url.port = 1234.5678;
assert.same(url.port, '1234');
assert.same(String(url), 'http://zloirock.ru:1234/');
// url.port = 1e10;
// assert.same(url.port, '1234'); // '0' in Chrome
// assert.same(String(url), 'http://zloirock.ru:1234/'); // 'http://zloirock.ru:0/' in Chrome
// IPv4 address 0.0.0.0 (stored as number 0) should allow port
url = new URL('http://0.0.0.0/');
url.port = '8080';
assert.same(url.port, '8080', 'port settable on 0.0.0.0');
assert.same(String(url), 'http://0.0.0.0:8080/', 'href correct after setting port on 0.0.0.0');
}
});
QUnit.test('URL#pathname', assert => {
let url = new URL('http://zloirock.ru/foo/bar');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'pathname'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'pathname');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.pathname, '/foo/bar');
// fails in Node 23-
// url = new URL('http://example.com/a^b');
// assert.same(url.pathname, '/a%5Eb', 'caret in path is percent-encoded');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.pathname = 'bar/baz';
assert.same(url.pathname, '/bar/baz');
assert.same(String(url), 'http://zloirock.ru/bar/baz');
}
});
QUnit.test('URL#search', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'search'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'search');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.search, '');
url = new URL('http://zloirock.ru/?foo=bar');
assert.same(url.search, '?foo=bar');
// query percent-encode set
assert.same(new URL('http://x/?a="<>').search, '?a=%22%3C%3E', 'query percent-encodes ", <, >');
assert.same(new URL('http://x/?a=\'').search, '?a=%27', 'special query percent-encodes \'');
// fails in modern Chrome (~145)
// assert.same(new URL('foo://x/?a=\'').search, '?a=\'', 'non-special query does not percent-encode \'');
// space in opaque paths should not be percent-encoded
// eslint-disable-next-line no-script-url -- safe
assert.same(new URL('javascript:void 0').href, 'javascript:void 0', 'space preserved in opaque path');
// eslint-disable-next-line no-script-url -- safe
assert.same(new URL('javascript:void 0').pathname, 'void 0', 'space preserved in opaque pathname');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/?');
assert.same(url.search, '');
assert.same(String(url), 'http://zloirock.ru/?');
url.search = 'foo=bar';
assert.same(url.search, '?foo=bar');
assert.same(String(url), 'http://zloirock.ru/?foo=bar');
url.search = '?bar=baz';
assert.same(url.search, '?bar=baz');
assert.same(String(url), 'http://zloirock.ru/?bar=baz');
url.search = '';
assert.same(url.search, '');
assert.same(String(url), 'http://zloirock.ru/');
}
});
QUnit.test('URL#searchParams', assert => {
let url = new URL('http://zloirock.ru/?foo=bar&bar=baz');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'searchParams'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'searchParams');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
}
assert.true(url.searchParams instanceof URLSearchParams);
assert.same(url.searchParams.get('foo'), 'bar');
assert.same(url.searchParams.get('bar'), 'baz');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.searchParams.append('foo', 'bar');
assert.same(String(url), 'http://zloirock.ru/?foo=bar');
url = new URL('http://zloirock.ru/');
url.search = 'foo=bar';
assert.same(url.searchParams.get('foo'), 'bar');
url = new URL('http://zloirock.ru/?foo=bar&bar=baz');
url.search = '';
assert.false(url.searchParams.has('foo'));
}
});
QUnit.test('URL#hash', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.false(hasOwnProperty.call(url, 'hash'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'hash');
assert.true(descriptor.enumerable);
assert.true(descriptor.configurable);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.hash, '');
url = new URL('http://zloirock.ru/#foo');
assert.same(url.hash, '#foo');
url = new URL('http://zloirock.ru/#');
assert.same(url.hash, '');
assert.same(String(url), 'http://zloirock.ru/#');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/#');
url.hash = 'foo';
assert.same(url.hash, '#foo');
assert.same(String(url), 'http://zloirock.ru/#foo');
url.hash = '';
assert.same(url.hash, '');
assert.same(String(url), 'http://zloirock.ru/');
// url.hash = '#';
// assert.same(url.hash, '');
// assert.same(String(url), 'http://zloirock.ru/'); // 'http://zloirock.ru/#' in FF
url.hash = '#foo';
assert.same(url.hash, '#foo');
assert.same(String(url), 'http://zloirock.ru/#foo');
url.hash = '#foo#bar';
assert.same(url.hash, '#foo#bar');
assert.same(String(url), 'http://zloirock.ru/#foo#bar');
url = new URL('http://zloirock.ru/');
url.hash = 'абa';
assert.same(url.hash, '#%D0%B0%D0%B1a');
// url = new URL('http://zloirock.ru/');
// url.hash = '\udc01\ud802a';
// assert.same(url.hash, '#%EF%BF%BD%EF%BF%BDa', 'unmatched surrogates');
}
});
QUnit.test('URL#toJSON', assert => {
const { toJSON } = URL.prototype;
assert.isFunction(toJSON);
assert.arity(toJSON, 0);
assert.enumerable(URL.prototype, 'toJSON');
const url = new URL('http://zloirock.ru/');
assert.same(url.toJSON(), 'http://zloirock.ru/');
if (DESCRIPTORS) {
url.searchParams.append('foo', 'bar');
assert.same(url.toJSON(), 'http://zloirock.ru/?foo=bar');
}
});
QUnit.test('URL#toString', assert => {
const { toString } = URL.prototype;
assert.isFunction(toString);
assert.arity(toString, 0);
assert.enumerable(URL.prototype, 'toString');
const url = new URL('http://zloirock.ru/');
assert.same(url.toString(), 'http://zloirock.ru/');
if (DESCRIPTORS) {
url.searchParams.append('foo', 'bar');
assert.same(url.toString(), 'http://zloirock.ru/?foo=bar');
}
});
QUnit.test('URL.sham', assert => {
assert.same(URL.sham, DESCRIPTORS ? undefined : true);
});
// `core-js` URL implementation pass all (exclude some encoding-related) tests
// from the next 3 test cases, but URLs from all of popular browsers fail a serious part of tests.
// Replacing all of them does not looks like a good idea, so next test cases disabled by default.
// see https://github.com/web-platform-tests/wpt/blob/master/url
QUnit.skip('WPT URL constructor tests', assert => {
for (const expected of urlTestData) {
if (typeof expected == 'string') continue;
const name = `Parsing: <${ expected.input }> against <${ expected.base }>`;
if (expected.failure) {
assert.throws(() => new URL(expected.input, expected.base || 'about:blank'), name);
} else {
const url = new URL(expected.input, expected.base || 'about:blank');
assert.same(url.href, expected.href, `${ name }: href`);
assert.same(url.protocol, expected.protocol, `${ name }: protocol`);
assert.same(url.username, expected.username, `${ name }: username`);
assert.same(url.password, expected.password, `${ name }: password`);
assert.same(url.host, expected.host, `${ name }: host`);
assert.same(url.hostname, expected.hostname, `${ name }: hostname`);
assert.same(url.port, expected.port, `${ name }: port`);
assert.same(url.pathname, expected.pathname, `${ name }: pathname`);
assert.same(url.search, expected.search, `${ name }: search`);
if ('searchParams' in expected) {
assert.same(url.searchParams.toString(), expected.searchParams, `${ name }: searchParams`);
}
assert.same(url.hash, expected.hash, `${ name }: hash`);
if ('origin' in expected) {
assert.same(url.origin, expected.origin, `${ name }: origin`);
}
}
}
});
// see https://github.com/web-platform-tests/wpt/blob/master/url
if (DESCRIPTORS) QUnit.skip('WPT URL setters tests', assert => {
for (const setter in settersTestData) {
const testCases = settersTestData[setter];
for (const { href, newValue, comment, expected } of testCases) {
let name = `Setting <${ href }>.${ setter } = '${ newValue }'.`;
if (comment) name += ` ${ comment }`;
const url = new URL(href);
url[setter] = newValue;
for (const attribute in expected) {
assert.same(url[attribute], expected[attribute], name);
}
}
}
});
// see https://github.com/web-platform-tests/wpt/blob/master/url
QUnit.skip('WPT conversion to ASCII tests', assert => {
for (const { comment, input, output } of toASCIITestData) {
let name = `Parsing: <${ input }>`;
if (comment) name += ` ${ comment }`;
if (output === null) {
assert.throws(() => new URL(`https://${ input }/x`), name);
} else {
const url = new URL(`https://${ input }/x`);
assert.same(url.host, output, name);
assert.same(url.hostname, output, name);
assert.same(url.pathname, '/x', name);
assert.same(url.href, `https://${ output }/x`, name);
}
}
});
================================================
FILE: tests/unit-pure/web.url.parse.js
================================================
import URL from 'core-js-pure/stable/url';
import parse from 'core-js-pure/stable/url/parse';
QUnit.test('URL.parse', assert => {
assert.isFunction(parse);
assert.arity(parse, 1);
assert.name(parse, 'parse');
assert.same(parse(undefined), null, 'undefined');
assert.same(parse(undefined, undefined), null, 'undefined, undefined');
assert.deepEqual(parse('q:w'), new URL('q:w'), 'q:w');
assert.deepEqual(parse('q:w', undefined), new URL('q:w'), 'q:w, undefined');
assert.deepEqual(parse('q:/w'), new URL('q:/w'), 'q:/w');
assert.deepEqual(parse('q:/w', undefined), new URL('q:/w', undefined), 'q:/w, undefined');
assert.deepEqual(parse(undefined, 'q:/w'), new URL(undefined, 'q:/w'), 'undefined, q:/w');
assert.same(parse('https://login:password@examp:le.com:8080/?a=1&b=2&a=3&c=4#fragment'), null, 'https://login:password@examp:le.com:8080/?a=1&b=2&a=3&c=4#fragment');
assert.deepEqual(parse('https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment'), new URL('https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment'), 'https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment');
assert.deepEqual(parse('https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment', undefined), new URL('https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment', undefined), 'https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment, undefined');
// eslint-disable-next-line unicorn/relative-url-style -- required for testing
assert.deepEqual(parse('x', 'https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment'), new URL('x', 'https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment'), 'x, https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment');
assert.throws(() => parse(), 'no args');
assert.throws(() => parse({ toString() { throw new Error('thrower'); } }), 'conversion thrower #1');
assert.throws(() => parse('q:w', { toString() { throw new Error('thrower'); } }), 'conversion thrower #2');
});
================================================
FILE: tests/wpt-url-resources/setters.js
================================================
// Copyright © web-platform-tests contributors
// Originally from https://github.com/web-platform-tests/wpt
// Available under the 3-Clause BSD License https://github.com/web-platform-tests/wpt/blob/master/LICENSE.md
/* eslint-disable no-script-url -- required for testing */
export default {
protocol: [
{
comment: 'The empty string is not a valid scheme. Setter leaves the URL unchanged.',
href: 'a://example.net',
newValue: '',
expected: {
href: 'a://example.net',
protocol: 'a:',
},
},
{
href: 'a://example.net',
newValue: 'b',
expected: {
href: 'b://example.net',
protocol: 'b:',
},
},
{
href: 'javascript:alert(1)',
newValue: 'defuse',
expected: {
href: 'defuse:alert(1)',
protocol: 'defuse:',
},
},
{
comment: 'Upper-case ASCII is lower-cased',
href: 'a://example.net',
newValue: 'B',
expected: {
href: 'b://example.net',
protocol: 'b:',
},
},
{
comment: 'Non-ASCII is rejected',
href: 'a://example.net',
newValue: 'é',
expected: {
href: 'a://example.net',
protocol: 'a:',
},
},
{
comment: 'No leading digit',
href: 'a://example.net',
newValue: '0b',
expected: {
href: 'a://example.net',
protocol: 'a:',
},
},
{
comment: 'No leading punctuation',
href: 'a://example.net',
newValue: '+b',
expected: {
href: 'a://example.net',
protocol: 'a:',
},
},
{
href: 'a://example.net',
newValue: 'bC0+-.',
expected: {
href: 'bc0+-.://example.net',
protocol: 'bc0+-.:',
},
},
{
comment: 'Only some punctuation is acceptable',
href: 'a://example.net',
newValue: 'b,c',
expected: {
href: 'a://example.net',
protocol: 'a:',
},
},
{
comment: 'Non-ASCII is rejected',
href: 'a://example.net',
newValue: 'bé',
expected: {
href: 'a://example.net',
protocol: 'a:',
},
},
{
comment: 'Can’t switch from URL containing username/password/port to file',
href: 'http://test@example.net',
newValue: 'file',
expected: {
href: 'http://test@example.net/',
protocol: 'http:',
},
},
{
href: 'wss://x:x@example.net:1234',
newValue: 'file',
expected: {
href: 'wss://x:x@example.net:1234/',
protocol: 'wss:',
},
},
{
comment: 'Can’t switch from file URL with no host',
href: 'file://localhost/',
newValue: 'http',
expected: {
href: 'file:///',
protocol: 'file:',
},
},
{
href: 'file:',
newValue: 'wss',
expected: {
href: 'file:///',
protocol: 'file:',
},
},
{
comment: 'Can’t switch from special scheme to non-special',
href: 'http://example.net',
newValue: 'b',
expected: {
href: 'http://example.net/',
protocol: 'http:',
},
},
{
href: 'file://hi/path',
newValue: 's',
expected: {
href: 'file://hi/path',
protocol: 'file:',
},
},
{
href: 'https://example.net',
newValue: 's',
expected: {
href: 'https://example.net/',
protocol: 'https:',
},
},
{
href: 'ftp://example.net',
newValue: 'test',
expected: {
href: 'ftp://example.net/',
protocol: 'ftp:',
},
},
{
comment: 'Cannot-be-a-base URL doesn’t have a host, but URL in a special scheme must.',
href: 'mailto:me@example.net',
newValue: 'http',
expected: {
href: 'mailto:me@example.net',
protocol: 'mailto:',
},
},
{
comment: 'Can’t switch from non-special scheme to special',
href: 'ssh://me@example.net',
newValue: 'http',
expected: {
href: 'ssh://me@example.net',
protocol: 'ssh:',
},
},
{
href: 'ssh://me@example.net',
newValue: 'file',
expected: {
href: 'ssh://me@example.net',
protocol: 'ssh:',
},
},
{
href: 'ssh://example.net',
newValue: 'file',
expected: {
href: 'ssh://example.net',
protocol: 'ssh:',
},
},
{
href: 'nonsense:///test',
newValue: 'https',
expected: {
href: 'nonsense:///test',
protocol: 'nonsense:',
},
},
{
comment: "Stuff after the first ':' is ignored",
href: 'http://example.net',
newValue: 'https:foo : bar',
expected: {
href: 'https://example.net/',
protocol: 'https:',
},
},
{
comment: "Stuff after the first ':' is ignored",
href: 'data:text/html,Test',
newValue: 'view-source+data:foo : bar',
expected: {
href: 'view-source+data:text/html,
Test',
protocol: 'view-source+data:',
},
},
{
comment: 'Port is set to null if it is the default for new scheme.',
href: 'http://foo.com:443/',
newValue: 'https',
expected: {
href: 'https://foo.com/',
protocol: 'https:',
port: '',
},
},
],
username: [
{
comment: 'No host means no username',
href: 'file:///home/you/index.html',
newValue: 'me',
expected: {
href: 'file:///home/you/index.html',
username: '',
},
},
{
comment: 'No host means no username',
href: 'unix:/run/foo.socket',
newValue: 'me',
expected: {
href: 'unix:/run/foo.socket',
username: '',
},
},
{
comment: 'Cannot-be-a-base means no username',
href: 'mailto:you@example.net',
newValue: 'me',
expected: {
href: 'mailto:you@example.net',
username: '',
},
},
{
href: 'javascript:alert(1)',
newValue: 'wario',
expected: {
href: 'javascript:alert(1)',
username: '',
},
},
{
href: 'http://example.net',
newValue: 'me',
expected: {
href: 'http://me@example.net/',
username: 'me',
},
},
{
href: 'http://:secret@example.net',
newValue: 'me',
expected: {
href: 'http://me:secret@example.net/',
username: 'me',
},
},
{
href: 'http://me@example.net',
newValue: '',
expected: {
href: 'http://example.net/',
username: '',
},
},
{
href: 'http://me:secret@example.net',
newValue: '',
expected: {
href: 'http://:secret@example.net/',
username: '',
},
},
{
comment: 'UTF-8 percent encoding with the userinfo encode set.',
href: 'http://example.net',
newValue: "\u0000\u0001\t\n\r\u001F !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\u007F\u0080\u0081Éé",
expected: {
href: "http://%00%01%09%0A%0D%1F%20!%22%23$%&'()*+,-.%2F09%3A%3B%3C%3D%3E%3F%40AZ%5B%5C%5D%5E_%60az%7B%7C%7D~%7F%C2%80%C2%81%C3%89%C3%A9@example.net/",
username: "%00%01%09%0A%0D%1F%20!%22%23$%&'()*+,-.%2F09%3A%3B%3C%3D%3E%3F%40AZ%5B%5C%5D%5E_%60az%7B%7C%7D~%7F%C2%80%C2%81%C3%89%C3%A9",
},
},
{
comment: 'Bytes already percent-encoded are left as-is.',
href: 'http://example.net',
newValue: '%c3%89té',
expected: {
href: 'http://%c3%89t%C3%A9@example.net/',
username: '%c3%89t%C3%A9',
},
},
{
href: 'sc:///',
newValue: 'x',
expected: {
href: 'sc:///',
username: '',
},
},
{
href: 'javascript://x/',
newValue: 'wario',
expected: {
href: 'javascript://wario@x/',
username: 'wario',
},
},
{
href: 'file://test/',
newValue: 'test',
expected: {
href: 'file://test/',
username: '',
},
},
],
password: [
{
comment: 'No host means no password',
href: 'file:///home/me/index.html',
newValue: 'secret',
expected: {
href: 'file:///home/me/index.html',
password: '',
},
},
{
comment: 'No host means no password',
href: 'unix:/run/foo.socket',
newValue: 'secret',
expected: {
href: 'unix:/run/foo.socket',
password: '',
},
},
{
comment: 'Cannot-be-a-base means no password',
href: 'mailto:me@example.net',
newValue: 'secret',
expected: {
href: 'mailto:me@example.net',
password: '',
},
},
{
href: 'http://example.net',
newValue: 'secret',
expected: {
href: 'http://:secret@example.net/',
password: 'secret',
},
},
{
href: 'http://me@example.net',
newValue: 'secret',
expected: {
href: 'http://me:secret@example.net/',
password: 'secret',
},
},
{
href: 'http://:secret@example.net',
newValue: '',
expected: {
href: 'http://example.net/',
password: '',
},
},
{
href: 'http://me:secret@example.net',
newValue: '',
expected: {
href: 'http://me@example.net/',
password: '',
},
},
{
comment: 'UTF-8 percent encoding with the userinfo encode set.',
href: 'http://example.net',
newValue: "\u0000\u0001\t\n\r\u001F !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\u007F\u0080\u0081Éé",
expected: {
href: "http://:%00%01%09%0A%0D%1F%20!%22%23$%&'()*+,-.%2F09%3A%3B%3C%3D%3E%3F%40AZ%5B%5C%5D%5E_%60az%7B%7C%7D~%7F%C2%80%C2%81%C3%89%C3%A9@example.net/",
password: "%00%01%09%0A%0D%1F%20!%22%23$%&'()*+,-.%2F09%3A%3B%3C%3D%3E%3F%40AZ%5B%5C%5D%5E_%60az%7B%7C%7D~%7F%C2%80%C2%81%C3%89%C3%A9",
},
},
{
comment: 'Bytes already percent-encoded are left as-is.',
href: 'http://example.net',
newValue: '%c3%89té',
expected: {
href: 'http://:%c3%89t%C3%A9@example.net/',
password: '%c3%89t%C3%A9',
},
},
{
href: 'sc:///',
newValue: 'x',
expected: {
href: 'sc:///',
password: '',
},
},
{
href: 'javascript://x/',
newValue: 'bowser',
expected: {
href: 'javascript://:bowser@x/',
password: 'bowser',
},
},
{
href: 'file://test/',
newValue: 'test',
expected: {
href: 'file://test/',
password: '',
},
},
],
host: [
{
comment: 'Non-special scheme',
href: 'sc://x/',
newValue: '\u0000',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
href: 'sc://x/',
newValue: '\u0009',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '\u000A',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '\u000D',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: ' ',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
href: 'sc://x/',
newValue: '#',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '/',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '?',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '@',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
href: 'sc://x/',
newValue: 'ß',
expected: {
href: 'sc://%C3%9F/',
host: '%C3%9F',
hostname: '%C3%9F',
},
},
{
comment: 'IDNA Nontransitional_Processing',
href: 'https://x/',
newValue: 'ß',
expected: {
href: 'https://xn--zca/',
host: 'xn--zca',
hostname: 'xn--zca',
},
},
{
comment: 'Cannot-be-a-base means no host',
href: 'mailto:me@example.net',
newValue: 'example.com',
expected: {
href: 'mailto:me@example.net',
host: '',
},
},
{
comment: 'Cannot-be-a-base means no password',
href: 'data:text/plain,Stuff',
newValue: 'example.net',
expected: {
href: 'data:text/plain,Stuff',
host: '',
},
},
{
href: 'http://example.net',
newValue: 'example.com:8080',
expected: {
href: 'http://example.com:8080/',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Port number is unchanged if not specified in the new value',
href: 'http://example.net:8080',
newValue: 'example.com',
expected: {
href: 'http://example.com:8080/',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Port number is unchanged if not specified',
href: 'http://example.net:8080',
newValue: 'example.com:',
expected: {
href: 'http://example.com:8080/',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'The empty host is not valid for special schemes',
href: 'http://example.net',
newValue: '',
expected: {
href: 'http://example.net/',
host: 'example.net',
},
},
{
comment: 'The empty host is OK for non-special schemes',
href: 'view-source+http://example.net/foo',
newValue: '',
expected: {
href: 'view-source+http:///foo',
host: '',
},
},
{
comment: 'Path-only URLs can gain a host',
href: 'a:/foo',
newValue: 'example.net',
expected: {
href: 'a://example.net/foo',
host: 'example.net',
},
},
{
comment: 'IPv4 address syntax is normalized',
href: 'http://example.net',
newValue: '0x7F000001:8080',
expected: {
href: 'http://127.0.0.1:8080/',
host: '127.0.0.1:8080',
hostname: '127.0.0.1',
port: '8080',
},
},
{
comment: 'IPv6 address syntax is normalized',
href: 'http://example.net',
newValue: '[::0:01]:2',
expected: {
href: 'http://[::1]:2/',
host: '[::1]:2',
hostname: '[::1]',
port: '2',
},
},
{
comment: 'Default port number is removed',
href: 'http://example.net',
newValue: 'example.com:80',
expected: {
href: 'http://example.com/',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Default port number is removed',
href: 'https://example.net',
newValue: 'example.com:443',
expected: {
href: 'https://example.com/',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Default port number is only removed for the relevant scheme',
href: 'https://example.net',
newValue: 'example.com:80',
expected: {
href: 'https://example.com:80/',
host: 'example.com:80',
hostname: 'example.com',
port: '80',
},
},
{
comment: 'Port number is removed if new port is scheme default and existing URL has a non-default port',
href: 'http://example.net:8080',
newValue: 'example.com:80',
expected: {
href: 'http://example.com/',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a / delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com/stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a / delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com:8080/stuff',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Stuff after a ? delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com?stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a ? delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com:8080?stuff',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Stuff after a # delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com#stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a # delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com:8080#stuff',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Stuff after a \\ delimiter is ignored for special schemes',
href: 'http://example.net/path',
newValue: 'example.com\\stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a \\ delimiter is ignored for special schemes',
href: 'http://example.net/path',
newValue: 'example.com:8080\\stuff',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: '\\ is not a delimiter for non-special schemes, but still forbidden in hosts',
href: 'view-source+http://example.net/path',
newValue: 'example.com\\stuff',
expected: {
href: 'view-source+http://example.net/path',
host: 'example.net',
hostname: 'example.net',
port: '',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'view-source+http://example.net/path',
newValue: 'example.com:8080stuff2',
expected: {
href: 'view-source+http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'http://example.net/path',
newValue: 'example.com:8080stuff2',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'http://example.net/path',
newValue: 'example.com:8080+2',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Port numbers are 16 bit integers',
href: 'http://example.net/path',
newValue: 'example.com:65535',
expected: {
href: 'http://example.com:65535/path',
host: 'example.com:65535',
hostname: 'example.com',
port: '65535',
},
},
{
comment: 'Port numbers are 16 bit integers, overflowing is an error. Hostname is still set, though.',
href: 'http://example.net/path',
newValue: 'example.com:65536',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Broken IPv6',
href: 'http://example.net/',
newValue: '[google.com]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.3.4x]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.3.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'file://y/',
newValue: 'x:123',
expected: {
href: 'file://y/',
host: 'y',
hostname: 'y',
port: '',
},
},
{
href: 'file://y/',
newValue: 'loc%41lhost',
expected: {
href: 'file:///',
host: '',
hostname: '',
port: '',
},
},
{
href: 'file://hi/x',
newValue: '',
expected: {
href: 'file:///x',
host: '',
hostname: '',
port: '',
},
},
{
href: 'sc://test@test/',
newValue: '',
expected: {
href: 'sc://test@test/',
host: 'test',
hostname: 'test',
username: 'test',
},
},
{
href: 'sc://test:12/',
newValue: '',
expected: {
href: 'sc://test:12/',
host: 'test:12',
hostname: 'test',
port: '12',
},
},
],
hostname: [
{
comment: 'Non-special scheme',
href: 'sc://x/',
newValue: '\u0000',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
href: 'sc://x/',
newValue: '\u0009',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '\u000A',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '\u000D',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: ' ',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
href: 'sc://x/',
newValue: '#',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '/',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '?',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '@',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
comment: 'Cannot-be-a-base means no host',
href: 'mailto:me@example.net',
newValue: 'example.com',
expected: {
href: 'mailto:me@example.net',
host: '',
},
},
{
comment: 'Cannot-be-a-base means no password',
href: 'data:text/plain,Stuff',
newValue: 'example.net',
expected: {
href: 'data:text/plain,Stuff',
host: '',
},
},
{
href: 'http://example.net:8080',
newValue: 'example.com',
expected: {
href: 'http://example.com:8080/',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'The empty host is not valid for special schemes',
href: 'http://example.net',
newValue: '',
expected: {
href: 'http://example.net/',
host: 'example.net',
},
},
{
comment: 'The empty host is OK for non-special schemes',
href: 'view-source+http://example.net/foo',
newValue: '',
expected: {
href: 'view-source+http:///foo',
host: '',
},
},
{
comment: 'Path-only URLs can gain a host',
href: 'a:/foo',
newValue: 'example.net',
expected: {
href: 'a://example.net/foo',
host: 'example.net',
},
},
{
comment: 'IPv4 address syntax is normalized',
href: 'http://example.net:8080',
newValue: '0x7F000001',
expected: {
href: 'http://127.0.0.1:8080/',
host: '127.0.0.1:8080',
hostname: '127.0.0.1',
port: '8080',
},
},
{
comment: 'IPv6 address syntax is normalized',
href: 'http://example.net',
newValue: '[::0:01]',
expected: {
href: 'http://[::1]/',
host: '[::1]',
hostname: '[::1]',
port: '',
},
},
{
comment: 'Stuff after a : delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com:8080',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a : delimiter is ignored',
href: 'http://example.net:8080/path',
newValue: 'example.com:',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Stuff after a / delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com/stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a ? delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com?stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a # delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com#stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a \\ delimiter is ignored for special schemes',
href: 'http://example.net/path',
newValue: 'example.com\\stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: '\\ is not a delimiter for non-special schemes, but still forbidden in hosts',
href: 'view-source+http://example.net/path',
newValue: 'example.com\\stuff',
expected: {
href: 'view-source+http://example.net/path',
host: 'example.net',
hostname: 'example.net',
port: '',
},
},
{
comment: 'Broken IPv6',
href: 'http://example.net/',
newValue: '[google.com]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.3.4x]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.3.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'file://y/',
newValue: 'x:123',
expected: {
href: 'file://y/',
host: 'y',
hostname: 'y',
port: '',
},
},
{
href: 'file://y/',
newValue: 'loc%41lhost',
expected: {
href: 'file:///',
host: '',
hostname: '',
port: '',
},
},
{
href: 'file://hi/x',
newValue: '',
expected: {
href: 'file:///x',
host: '',
hostname: '',
port: '',
},
},
{
href: 'sc://test@test/',
newValue: '',
expected: {
href: 'sc://test@test/',
host: 'test',
hostname: 'test',
username: 'test',
},
},
{
href: 'sc://test:12/',
newValue: '',
expected: {
href: 'sc://test:12/',
host: 'test:12',
hostname: 'test',
port: '12',
},
},
],
port: [
{
href: 'http://example.net',
newValue: '8080',
expected: {
href: 'http://example.net:8080/',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Port number is removed if empty is the new value',
href: 'http://example.net:8080',
newValue: '',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
port: '',
},
},
{
comment: 'Default port number is removed',
href: 'http://example.net:8080',
newValue: '80',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
port: '',
},
},
{
comment: 'Default port number is removed',
href: 'https://example.net:4433',
newValue: '443',
expected: {
href: 'https://example.net/',
host: 'example.net',
hostname: 'example.net',
port: '',
},
},
{
comment: 'Default port number is only removed for the relevant scheme',
href: 'https://example.net',
newValue: '80',
expected: {
href: 'https://example.net:80/',
host: 'example.net:80',
hostname: 'example.net',
port: '80',
},
},
{
comment: 'Stuff after a / delimiter is ignored',
href: 'http://example.net/path',
newValue: '8080/stuff',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Stuff after a ? delimiter is ignored',
href: 'http://example.net/path',
newValue: '8080?stuff',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Stuff after a # delimiter is ignored',
href: 'http://example.net/path',
newValue: '8080#stuff',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Stuff after a \\ delimiter is ignored for special schemes',
href: 'http://example.net/path',
newValue: '8080\\stuff',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'view-source+http://example.net/path',
newValue: '8080stuff2',
expected: {
href: 'view-source+http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'http://example.net/path',
newValue: '8080stuff2',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'http://example.net/path',
newValue: '8080+2',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Port numbers are 16 bit integers',
href: 'http://example.net/path',
newValue: '65535',
expected: {
href: 'http://example.net:65535/path',
host: 'example.net:65535',
hostname: 'example.net',
port: '65535',
},
},
{
comment: 'Port numbers are 16 bit integers, overflowing is an error',
href: 'http://example.net:8080/path',
newValue: '65536',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Port numbers are 16 bit integers, overflowing is an error',
href: 'non-special://example.net:8080/path',
newValue: '65536',
expected: {
href: 'non-special://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
href: 'file://test/',
newValue: '12',
expected: {
href: 'file://test/',
port: '',
},
},
{
href: 'file://localhost/',
newValue: '12',
expected: {
href: 'file:///',
port: '',
},
},
{
href: 'non-base:value',
newValue: '12',
expected: {
href: 'non-base:value',
port: '',
},
},
{
href: 'sc:///',
newValue: '12',
expected: {
href: 'sc:///',
port: '',
},
},
{
href: 'sc://x/',
newValue: '12',
expected: {
href: 'sc://x:12/',
port: '12',
},
},
{
href: 'javascript://x/',
newValue: '12',
expected: {
href: 'javascript://x:12/',
port: '12',
},
},
],
pathname: [
{
comment: 'Cannot-be-a-base don’t have a path',
href: 'mailto:me@example.net',
newValue: '/foo',
expected: {
href: 'mailto:me@example.net',
pathname: 'me@example.net',
},
},
{
href: 'unix:/run/foo.socket?timeout=10',
newValue: '/var/log/../run/bar.socket',
expected: {
href: 'unix:/var/run/bar.socket?timeout=10',
pathname: '/var/run/bar.socket',
},
},
{
href: 'https://example.net#nav',
newValue: 'home',
expected: {
href: 'https://example.net/home#nav',
pathname: '/home',
},
},
{
href: 'https://example.net#nav',
newValue: '../home',
expected: {
href: 'https://example.net/home#nav',
pathname: '/home',
},
},
{
comment: "\\ is a segment delimiter for 'special' URLs",
href: 'http://example.net/home?lang=fr#nav',
newValue: '\\a\\%2E\\b\\%2e.\\c',
expected: {
href: 'http://example.net/a/c?lang=fr#nav',
pathname: '/a/c',
},
},
{
comment: "\\ is *not* a segment delimiter for non-'special' URLs",
href: 'view-source+http://example.net/home?lang=fr#nav',
newValue: '\\a\\%2E\\b\\%2e.\\c',
expected: {
href: 'view-source+http://example.net/\\a\\%2E\\b\\%2e.\\c?lang=fr#nav',
pathname: '/\\a\\%2E\\b\\%2e.\\c',
},
},
{
comment: 'UTF-8 percent encoding with the default encode set. Tabs and newlines are removed.',
href: 'a:/',
newValue: "\u0000\u0001\t\n\r\u001F !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\u007F\u0080\u0081Éé",
expected: {
href: "a:/%00%01%1F%20!%22%23$%&'()*+,-./09:;%3C=%3E%3F@AZ[\\]^_%60az%7B|%7D~%7F%C2%80%C2%81%C3%89%C3%A9",
pathname: "/%00%01%1F%20!%22%23$%&'()*+,-./09:;%3C=%3E%3F@AZ[\\]^_%60az%7B|%7D~%7F%C2%80%C2%81%C3%89%C3%A9",
},
},
{
comment: 'Bytes already percent-encoded are left as-is, including %2E outside dotted segments.',
href: 'http://example.net',
newValue: '%2e%2E%c3%89té',
expected: {
href: 'http://example.net/%2e%2E%c3%89t%C3%A9',
pathname: '/%2e%2E%c3%89t%C3%A9',
},
},
{
comment: '? needs to be encoded',
href: 'http://example.net',
newValue: '?',
expected: {
href: 'http://example.net/%3F',
pathname: '/%3F',
},
},
{
comment: '# needs to be encoded',
href: 'http://example.net',
newValue: '#',
expected: {
href: 'http://example.net/%23',
pathname: '/%23',
},
},
{
comment: '? needs to be encoded, non-special scheme',
href: 'sc://example.net',
newValue: '?',
expected: {
href: 'sc://example.net/%3F',
pathname: '/%3F',
},
},
{
comment: '# needs to be encoded, non-special scheme',
href: 'sc://example.net',
newValue: '#',
expected: {
href: 'sc://example.net/%23',
pathname: '/%23',
},
},
{
comment: 'File URLs and (back)slashes',
href: 'file://monkey/',
newValue: '\\\\',
expected: {
href: 'file://monkey/',
pathname: '/',
},
},
{
comment: 'File URLs and (back)slashes',
href: 'file:///unicorn',
newValue: '//\\/',
expected: {
href: 'file:///',
pathname: '/',
},
},
{
comment: 'File URLs and (back)slashes',
href: 'file:///unicorn',
newValue: '//monkey/..//',
expected: {
href: 'file:///',
pathname: '/',
},
},
],
search: [
{
href: 'https://example.net#nav',
newValue: 'lang=fr',
expected: {
href: 'https://example.net/?lang=fr#nav',
search: '?lang=fr',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: 'lang=fr',
expected: {
href: 'https://example.net/?lang=fr#nav',
search: '?lang=fr',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '?lang=fr',
expected: {
href: 'https://example.net/?lang=fr#nav',
search: '?lang=fr',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '??lang=fr',
expected: {
href: 'https://example.net/??lang=fr#nav',
search: '??lang=fr',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '?',
expected: {
href: 'https://example.net/?#nav',
search: '',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '',
expected: {
href: 'https://example.net/#nav',
search: '',
},
},
{
href: 'https://example.net?lang=en-US',
newValue: '',
expected: {
href: 'https://example.net/',
search: '',
},
},
{
href: 'https://example.net',
newValue: '',
expected: {
href: 'https://example.net/',
search: '',
},
},
/* URI malformed
{
comment: 'UTF-8 percent encoding with the query encode set. Tabs and newlines are removed.',
href: 'a:/',
newValue: "\u0000\u0001\t\n\r\u001f !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\u007f\u0080\u0081Éé",
expected: {
href: "a:/?%00%01%1F%20!%22%23$%&'()*+,-./09:;%3C=%3E?@AZ[\\]^_`az{|}~%7F%C2%80%C2%81%C3%89%C3%A9",
search: "?%00%01%1F%20!%22%23$%&'()*+,-./09:;%3C=%3E?@AZ[\\]^_`az{|}~%7F%C2%80%C2%81%C3%89%C3%A9",
},
},
*/
{
comment: 'Bytes already percent-encoded are left as-is',
href: 'http://example.net',
newValue: '%c3%89té',
expected: {
href: 'http://example.net/?%c3%89t%C3%A9',
search: '?%c3%89t%C3%A9',
},
},
],
hash: [
{
href: 'https://example.net',
newValue: 'main',
expected: {
href: 'https://example.net/#main',
hash: '#main',
},
},
{
href: 'https://example.net#nav',
newValue: 'main',
expected: {
href: 'https://example.net/#main',
hash: '#main',
},
},
{
href: 'https://example.net?lang=en-US',
newValue: '##nav',
expected: {
href: 'https://example.net/?lang=en-US##nav',
hash: '##nav',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '#main',
expected: {
href: 'https://example.net/?lang=en-US#main',
hash: '#main',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '#',
expected: {
href: 'https://example.net/?lang=en-US#',
hash: '',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '',
expected: {
href: 'https://example.net/?lang=en-US',
hash: '',
},
},
{
href: 'http://example.net',
newValue: '#foo bar',
expected: {
href: 'http://example.net/#foo%20bar',
hash: '#foo%20bar',
},
},
{
href: 'http://example.net',
newValue: '#foo"bar',
expected: {
href: 'http://example.net/#foo%22bar',
hash: '#foo%22bar',
},
},
{
href: 'http://example.net',
newValue: '#foobar',
expected: {
href: 'http://example.net/#foo%3Ebar',
hash: '#foo%3Ebar',
},
},
{
href: 'http://example.net',
newValue: '#foo`bar',
expected: {
href: 'http://example.net/#foo%60bar',
hash: '#foo%60bar',
},
},
{
comment: 'Simple percent-encoding; nuls, tabs, and newlines are removed',
href: 'a:/',
newValue: "\u0000\u0001\t\n\r\u001F !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\u007F\u0080\u0081Éé",
expected: {
href: "a:/#%01%1F%20!%22#$%&'()*+,-./09:;%3C=%3E?@AZ[\\]^_%60az{|}~%7F%C2%80%C2%81%C3%89%C3%A9",
hash: "#%01%1F%20!%22#$%&'()*+,-./09:;%3C=%3E?@AZ[\\]^_%60az{|}~%7F%C2%80%C2%81%C3%89%C3%A9",
},
},
{
comment: 'Bytes already percent-encoded are left as-is',
href: 'http://example.net',
newValue: '%c3%89té',
expected: {
href: 'http://example.net/#%c3%89t%C3%A9',
hash: '#%c3%89t%C3%A9',
},
},
{
href: 'javascript:alert(1)',
newValue: 'castle',
expected: {
href: 'javascript:alert(1)#castle',
hash: '#castle',
},
},
],
};
================================================
FILE: tests/wpt-url-resources/toascii.js
================================================
// Copyright © web-platform-tests contributors
// Originally from https://github.com/web-platform-tests/wpt
// Available under the 3-Clause BSD License https://github.com/web-platform-tests/wpt/blob/master/LICENSE.md
/* eslint-disable @stylistic/max-len -- ignore */
export default [
{
comment: 'Label with hyphens in 3rd and 4th position',
input: 'aa--',
output: 'aa--',
},
{
input: 'a†--',
output: 'xn--a---kp0a',
},
{
input: 'ab--c',
output: 'ab--c',
},
{
comment: 'Label with leading hyphen',
input: '-x',
output: '-x',
},
{
input: '-†',
output: 'xn----xhn',
},
{
input: '-x.xn--nxa',
output: '-x.xn--nxa',
},
{
input: '-x.β',
output: '-x.xn--nxa',
},
{
comment: 'Label with trailing hyphen',
input: 'x-.xn--nxa',
output: 'x-.xn--nxa',
},
{
input: 'x-.β',
output: 'x-.xn--nxa',
},
{
comment: 'Empty labels',
input: 'x..xn--nxa',
output: 'x..xn--nxa',
},
{
input: 'x..β',
output: 'x..xn--nxa',
},
{
comment: 'Invalid Punycode',
input: 'xn--a',
output: null,
},
{
input: 'xn--a.xn--nxa',
output: null,
},
{
input: 'xn--a.β',
output: null,
},
{
comment: 'Valid Punycode',
input: 'xn--nxa.xn--nxa',
output: 'xn--nxa.xn--nxa',
},
{
comment: 'Mixed',
input: 'xn--nxa.β',
output: 'xn--nxa.xn--nxa',
},
{
input: 'ab--c.xn--nxa',
output: 'ab--c.xn--nxa',
},
{
input: 'ab--c.β',
output: 'ab--c.xn--nxa',
},
{
comment: 'CheckJoiners is true',
input: '\u200D.example',
output: null,
},
{
input: 'xn--1ug.example',
output: null,
},
{
comment: 'CheckBidi is true',
input: 'يa',
output: null,
},
{
input: 'xn--a-yoc',
output: null,
},
{
comment: 'processing_option is Nontransitional_Processing',
input: 'ශ්රී',
output: 'xn--10cl1a0b660p',
},
{
input: 'نامهای',
output: 'xn--mgba3gch31f060k',
},
{
comment: 'U+FFFD',
input: '\uFFFD.com',
output: null,
},
{
comment: 'U+FFFD character encoded in Punycode',
input: 'xn--zn7c.com',
output: null,
},
{
comment: 'Label longer than 63 code points',
input: 'x01234567890123456789012345678901234567890123456789012345678901x',
output: 'x01234567890123456789012345678901234567890123456789012345678901x',
},
{
input: 'x01234567890123456789012345678901234567890123456789012345678901†',
output: 'xn--x01234567890123456789012345678901234567890123456789012345678901-6963b',
},
{
input: 'x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa',
output: 'x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa',
},
{
input: 'x01234567890123456789012345678901234567890123456789012345678901x.β',
output: 'x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa',
},
{
comment: 'Domain excluding TLD longer than 253 code points',
input: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.x',
output: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.x',
},
{
input: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa',
output: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa',
},
{
input: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.β',
output: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa',
},
];
================================================
FILE: tests/wpt-url-resources/urltestdata.js
================================================
// Copyright © web-platform-tests contributors
// Originally from https://github.com/web-platform-tests/wpt
// Available under the 3-Clause BSD License https://github.com/web-platform-tests/wpt/blob/master/LICENSE.md
/* eslint-disable no-script-url -- required for testing */
export default [
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/script-tests/segments.js',
{
input: 'http://example\t.\norg',
base: 'http://example.org/foo/bar',
href: 'http://example.org/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://user:pass@foo:21/bar;par?b#c',
base: 'http://example.org/foo/bar',
href: 'http://user:pass@foo:21/bar;par?b#c',
origin: 'http://foo:21',
protocol: 'http:',
username: 'user',
password: 'pass',
host: 'foo:21',
hostname: 'foo',
port: '21',
pathname: '/bar;par',
search: '?b',
hash: '#c',
},
{
input: 'https://test:@test',
base: 'about:blank',
href: 'https://test@test/',
origin: 'https://test',
protocol: 'https:',
username: 'test',
password: '',
host: 'test',
hostname: 'test',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://:@test',
base: 'about:blank',
href: 'https://test/',
origin: 'https://test',
protocol: 'https:',
username: '',
password: '',
host: 'test',
hostname: 'test',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'non-special://test:@test/x',
base: 'about:blank',
href: 'non-special://test@test/x',
origin: 'null',
protocol: 'non-special:',
username: 'test',
password: '',
host: 'test',
hostname: 'test',
port: '',
pathname: '/x',
search: '',
hash: '',
},
{
input: 'non-special://:@test/x',
base: 'about:blank',
href: 'non-special://test/x',
origin: 'null',
protocol: 'non-special:',
username: '',
password: '',
host: 'test',
hostname: 'test',
port: '',
pathname: '/x',
search: '',
hash: '',
},
{
input: 'http:foo.com',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/foo.com',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/foo.com',
search: '',
hash: '',
},
{
input: '\t :foo.com \n',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:foo.com',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:foo.com',
search: '',
hash: '',
},
{
input: ' foo.com ',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/foo.com',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/foo.com',
search: '',
hash: '',
},
{
input: 'a:\t foo.com',
base: 'http://example.org/foo/bar',
href: 'a: foo.com',
origin: 'null',
protocol: 'a:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: ' foo.com',
search: '',
hash: '',
},
{
input: 'http://f:21/ b ? d # e ',
base: 'http://example.org/foo/bar',
href: 'http://f:21/%20b%20?%20d%20#%20e',
origin: 'http://f:21',
protocol: 'http:',
username: '',
password: '',
host: 'f:21',
hostname: 'f',
port: '21',
pathname: '/%20b%20',
search: '?%20d%20',
hash: '#%20e',
},
{
input: 'lolscheme:x x#x x',
base: 'about:blank',
href: 'lolscheme:x x#x%20x',
protocol: 'lolscheme:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'x x',
search: '',
hash: '#x%20x',
},
{
input: 'http://f:/c',
base: 'http://example.org/foo/bar',
href: 'http://f/c',
origin: 'http://f',
protocol: 'http:',
username: '',
password: '',
host: 'f',
hostname: 'f',
port: '',
pathname: '/c',
search: '',
hash: '',
},
{
input: 'http://f:0/c',
base: 'http://example.org/foo/bar',
href: 'http://f:0/c',
origin: 'http://f:0',
protocol: 'http:',
username: '',
password: '',
host: 'f:0',
hostname: 'f',
port: '0',
pathname: '/c',
search: '',
hash: '',
},
{
input: 'http://f:00000000000000/c',
base: 'http://example.org/foo/bar',
href: 'http://f:0/c',
origin: 'http://f:0',
protocol: 'http:',
username: '',
password: '',
host: 'f:0',
hostname: 'f',
port: '0',
pathname: '/c',
search: '',
hash: '',
},
{
input: 'http://f:00000000000000000000080/c',
base: 'http://example.org/foo/bar',
href: 'http://f/c',
origin: 'http://f',
protocol: 'http:',
username: '',
password: '',
host: 'f',
hostname: 'f',
port: '',
pathname: '/c',
search: '',
hash: '',
},
{
input: 'http://f:b/c',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://f: /c',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://f:\n/c',
base: 'http://example.org/foo/bar',
href: 'http://f/c',
origin: 'http://f',
protocol: 'http:',
username: '',
password: '',
host: 'f',
hostname: 'f',
port: '',
pathname: '/c',
search: '',
hash: '',
},
{
input: 'http://f:fifty-two/c',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://f:999999/c',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'non-special://f:999999/c',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://f: 21 / b ? d # e ',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: '',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '',
},
{
input: ' \t',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '',
},
{
input: ':foo.com/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:foo.com/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:foo.com/',
search: '',
hash: '',
},
{
input: ':foo.com\\',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:foo.com/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:foo.com/',
search: '',
hash: '',
},
{
input: ':',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:',
search: '',
hash: '',
},
{
input: ':a',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:a',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:a',
search: '',
hash: '',
},
{
input: ':/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:/',
search: '',
hash: '',
},
{
input: ':\\',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:/',
search: '',
hash: '',
},
{
input: ':#',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:#',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:',
search: '',
hash: '',
},
{
input: '#',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar#',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '',
},
{
input: '#/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar#/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '#/',
},
{
input: '#\\',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar#\\',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '#\\',
},
{
input: '#;?',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar#;?',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '#;?',
},
{
input: '?',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar?',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '',
},
{
input: '/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: ':23',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:23',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:23',
search: '',
hash: '',
},
{
input: '/:23',
base: 'http://example.org/foo/bar',
href: 'http://example.org/:23',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/:23',
search: '',
hash: '',
},
{
input: '::',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/::',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/::',
search: '',
hash: '',
},
{
input: '::23',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/::23',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/::23',
search: '',
hash: '',
},
{
input: 'foo://',
base: 'http://example.org/foo/bar',
href: 'foo://',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '',
search: '',
hash: '',
},
{
input: 'http://a:b@c:29/d',
base: 'http://example.org/foo/bar',
href: 'http://a:b@c:29/d',
origin: 'http://c:29',
protocol: 'http:',
username: 'a',
password: 'b',
host: 'c:29',
hostname: 'c',
port: '29',
pathname: '/d',
search: '',
hash: '',
},
{
input: 'http::@c:29',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:@c:29',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:@c:29',
search: '',
hash: '',
},
{
input: 'http://&a:foo(b]c@d:2/',
base: 'http://example.org/foo/bar',
href: 'http://&a:foo(b%5Dc@d:2/',
origin: 'http://d:2',
protocol: 'http:',
username: '&a',
password: 'foo(b%5Dc',
host: 'd:2',
hostname: 'd',
port: '2',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://::@c@d:2',
base: 'http://example.org/foo/bar',
href: 'http://:%3A%40c@d:2/',
origin: 'http://d:2',
protocol: 'http:',
username: '',
password: '%3A%40c',
host: 'd:2',
hostname: 'd',
port: '2',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://foo.com:b@d/',
base: 'http://example.org/foo/bar',
href: 'http://foo.com:b@d/',
origin: 'http://d',
protocol: 'http:',
username: 'foo.com',
password: 'b',
host: 'd',
hostname: 'd',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://foo.com/\\@',
base: 'http://example.org/foo/bar',
href: 'http://foo.com//@',
origin: 'http://foo.com',
protocol: 'http:',
username: '',
password: '',
host: 'foo.com',
hostname: 'foo.com',
port: '',
pathname: '//@',
search: '',
hash: '',
},
{
input: 'http:\\\\foo.com\\',
base: 'http://example.org/foo/bar',
href: 'http://foo.com/',
origin: 'http://foo.com',
protocol: 'http:',
username: '',
password: '',
host: 'foo.com',
hostname: 'foo.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:\\\\a\\b:c\\d@foo.com\\',
base: 'http://example.org/foo/bar',
href: 'http://a/b:c/d@foo.com/',
origin: 'http://a',
protocol: 'http:',
username: '',
password: '',
host: 'a',
hostname: 'a',
port: '',
pathname: '/b:c/d@foo.com/',
search: '',
hash: '',
},
{
input: 'foo:/',
base: 'http://example.org/foo/bar',
href: 'foo:/',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'foo:/bar.com/',
base: 'http://example.org/foo/bar',
href: 'foo:/bar.com/',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/bar.com/',
search: '',
hash: '',
},
{
input: 'foo://///////',
base: 'http://example.org/foo/bar',
href: 'foo://///////',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '///////',
search: '',
hash: '',
},
{
input: 'foo://///////bar.com/',
base: 'http://example.org/foo/bar',
href: 'foo://///////bar.com/',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '///////bar.com/',
search: '',
hash: '',
},
{
input: 'foo:////://///',
base: 'http://example.org/foo/bar',
href: 'foo:////://///',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '//://///',
search: '',
hash: '',
},
{
input: 'c:/foo',
base: 'http://example.org/foo/bar',
href: 'c:/foo',
origin: 'null',
protocol: 'c:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/foo',
search: '',
hash: '',
},
{
input: '//foo/bar',
base: 'http://example.org/foo/bar',
href: 'http://foo/bar',
origin: 'http://foo',
protocol: 'http:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/bar',
search: '',
hash: '',
},
{
input: 'http://foo/path;a??e#f#g',
base: 'http://example.org/foo/bar',
href: 'http://foo/path;a??e#f#g',
origin: 'http://foo',
protocol: 'http:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/path;a',
search: '??e',
hash: '#f#g',
},
{
input: 'http://foo/abcd?efgh?ijkl',
base: 'http://example.org/foo/bar',
href: 'http://foo/abcd?efgh?ijkl',
origin: 'http://foo',
protocol: 'http:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/abcd',
search: '?efgh?ijkl',
hash: '',
},
{
input: 'http://foo/abcd#foo?bar',
base: 'http://example.org/foo/bar',
href: 'http://foo/abcd#foo?bar',
origin: 'http://foo',
protocol: 'http:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/abcd',
search: '',
hash: '#foo?bar',
},
{
input: '[61:24:74]:98',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/[61:24:74]:98',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/[61:24:74]:98',
search: '',
hash: '',
},
{
input: 'http:[61:27]/:foo',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/[61:27]/:foo',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/[61:27]/:foo',
search: '',
hash: '',
},
{
input: 'http://[1::2]:3:4',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://2001::1',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://2001::1]',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://2001::1]:80',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://[2001::1]',
base: 'http://example.org/foo/bar',
href: 'http://[2001::1]/',
origin: 'http://[2001::1]',
protocol: 'http:',
username: '',
password: '',
host: '[2001::1]',
hostname: '[2001::1]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://[::127.0.0.1]',
base: 'http://example.org/foo/bar',
href: 'http://[::7f00:1]/',
origin: 'http://[::7f00:1]',
protocol: 'http:',
username: '',
password: '',
host: '[::7f00:1]',
hostname: '[::7f00:1]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://[0:0:0:0:0:0:13.1.68.3]',
base: 'http://example.org/foo/bar',
href: 'http://[::d01:4403]/',
origin: 'http://[::d01:4403]',
protocol: 'http:',
username: '',
password: '',
host: '[::d01:4403]',
hostname: '[::d01:4403]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://[2001::1]:80',
base: 'http://example.org/foo/bar',
href: 'http://[2001::1]/',
origin: 'http://[2001::1]',
protocol: 'http:',
username: '',
password: '',
host: '[2001::1]',
hostname: '[2001::1]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/example.com/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/example.com/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'ftp:/example.com/',
base: 'http://example.org/foo/bar',
href: 'ftp://example.com/',
origin: 'ftp://example.com',
protocol: 'ftp:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https:/example.com/',
base: 'http://example.org/foo/bar',
href: 'https://example.com/',
origin: 'https://example.com',
protocol: 'https:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'madeupscheme:/example.com/',
base: 'http://example.org/foo/bar',
href: 'madeupscheme:/example.com/',
origin: 'null',
protocol: 'madeupscheme:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'file:/example.com/',
base: 'http://example.org/foo/bar',
href: 'file:///example.com/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'file://example:1/',
base: 'about:blank',
failure: true,
},
{
input: 'file://example:test/',
base: 'about:blank',
failure: true,
},
{
input: 'file://example%/',
base: 'about:blank',
failure: true,
},
{
input: 'file://[example]/',
base: 'about:blank',
failure: true,
},
{
input: 'ftps:/example.com/',
base: 'http://example.org/foo/bar',
href: 'ftps:/example.com/',
origin: 'null',
protocol: 'ftps:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'ws:/example.com/',
base: 'http://example.org/foo/bar',
href: 'ws://example.com/',
origin: 'ws://example.com',
protocol: 'ws:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss:/example.com/',
base: 'http://example.org/foo/bar',
href: 'wss://example.com/',
origin: 'wss://example.com',
protocol: 'wss:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'data:/example.com/',
base: 'http://example.org/foo/bar',
href: 'data:/example.com/',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'javascript:/example.com/',
base: 'http://example.org/foo/bar',
href: 'javascript:/example.com/',
origin: 'null',
protocol: 'javascript:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'mailto:/example.com/',
base: 'http://example.org/foo/bar',
href: 'mailto:/example.com/',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'http:example.com/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/example.com/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/example.com/',
search: '',
hash: '',
},
{
input: 'ftp:example.com/',
base: 'http://example.org/foo/bar',
href: 'ftp://example.com/',
origin: 'ftp://example.com',
protocol: 'ftp:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https:example.com/',
base: 'http://example.org/foo/bar',
href: 'https://example.com/',
origin: 'https://example.com',
protocol: 'https:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'madeupscheme:example.com/',
base: 'http://example.org/foo/bar',
href: 'madeupscheme:example.com/',
origin: 'null',
protocol: 'madeupscheme:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'ftps:example.com/',
base: 'http://example.org/foo/bar',
href: 'ftps:example.com/',
origin: 'null',
protocol: 'ftps:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'ws:example.com/',
base: 'http://example.org/foo/bar',
href: 'ws://example.com/',
origin: 'ws://example.com',
protocol: 'ws:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss:example.com/',
base: 'http://example.org/foo/bar',
href: 'wss://example.com/',
origin: 'wss://example.com',
protocol: 'wss:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'data:example.com/',
base: 'http://example.org/foo/bar',
href: 'data:example.com/',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'javascript:example.com/',
base: 'http://example.org/foo/bar',
href: 'javascript:example.com/',
origin: 'null',
protocol: 'javascript:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'mailto:example.com/',
base: 'http://example.org/foo/bar',
href: 'mailto:example.com/',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: '/a/b/c',
base: 'http://example.org/foo/bar',
href: 'http://example.org/a/b/c',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/a/b/c',
search: '',
hash: '',
},
{
input: '/a/ /c',
base: 'http://example.org/foo/bar',
href: 'http://example.org/a/%20/c',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/a/%20/c',
search: '',
hash: '',
},
{
input: '/a%2fc',
base: 'http://example.org/foo/bar',
href: 'http://example.org/a%2fc',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/a%2fc',
search: '',
hash: '',
},
{
input: '/a/%2f/c',
base: 'http://example.org/foo/bar',
href: 'http://example.org/a/%2f/c',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/a/%2f/c',
search: '',
hash: '',
},
{
input: '#β',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar#%CE%B2',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '#%CE%B2',
},
{
input: 'data:text/html,test#test',
base: 'http://example.org/foo/bar',
href: 'data:text/html,test#test',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'text/html,test',
search: '',
hash: '#test',
},
{
input: 'tel:1234567890',
base: 'http://example.org/foo/bar',
href: 'tel:1234567890',
origin: 'null',
protocol: 'tel:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '1234567890',
search: '',
hash: '',
},
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/file.html',
{
input: 'file:c:\\foo\\bar.html',
base: 'file:///tmp/mock/path',
href: 'file:///c:/foo/bar.html',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:/foo/bar.html',
search: '',
hash: '',
},
{
input: ' File:c|////foo\\bar.html',
base: 'file:///tmp/mock/path',
href: 'file:///c:////foo/bar.html',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:////foo/bar.html',
search: '',
hash: '',
},
{
input: 'C|/foo/bar',
base: 'file:///tmp/mock/path',
href: 'file:///C:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/foo/bar',
search: '',
hash: '',
},
{
input: '/C|\\foo\\bar',
base: 'file:///tmp/mock/path',
href: 'file:///C:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/foo/bar',
search: '',
hash: '',
},
{
input: '//C|/foo/bar',
base: 'file:///tmp/mock/path',
href: 'file:///C:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/foo/bar',
search: '',
hash: '',
},
{
input: '//server/file',
base: 'file:///tmp/mock/path',
href: 'file://server/file',
protocol: 'file:',
username: '',
password: '',
host: 'server',
hostname: 'server',
port: '',
pathname: '/file',
search: '',
hash: '',
},
{
input: '\\\\server\\file',
base: 'file:///tmp/mock/path',
href: 'file://server/file',
protocol: 'file:',
username: '',
password: '',
host: 'server',
hostname: 'server',
port: '',
pathname: '/file',
search: '',
hash: '',
},
{
input: '/\\server/file',
base: 'file:///tmp/mock/path',
href: 'file://server/file',
protocol: 'file:',
username: '',
password: '',
host: 'server',
hostname: 'server',
port: '',
pathname: '/file',
search: '',
hash: '',
},
{
input: 'file:///foo/bar.txt',
base: 'file:///tmp/mock/path',
href: 'file:///foo/bar.txt',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/foo/bar.txt',
search: '',
hash: '',
},
{
input: 'file:///home/me',
base: 'file:///tmp/mock/path',
href: 'file:///home/me',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/home/me',
search: '',
hash: '',
},
{
input: '//',
base: 'file:///tmp/mock/path',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '///',
base: 'file:///tmp/mock/path',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '///test',
base: 'file:///tmp/mock/path',
href: 'file:///test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '',
hash: '',
},
{
input: 'file://test',
base: 'file:///tmp/mock/path',
href: 'file://test/',
protocol: 'file:',
username: '',
password: '',
host: 'test',
hostname: 'test',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file://localhost',
base: 'file:///tmp/mock/path',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file://localhost/',
base: 'file:///tmp/mock/path',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file://localhost/test',
base: 'file:///tmp/mock/path',
href: 'file:///test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '',
hash: '',
},
{
input: 'test',
base: 'file:///tmp/mock/path',
href: 'file:///tmp/mock/test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/tmp/mock/test',
search: '',
hash: '',
},
{
input: 'file:test',
base: 'file:///tmp/mock/path',
href: 'file:///tmp/mock/test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/tmp/mock/test',
search: '',
hash: '',
},
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/script-tests/path.js',
{
input: 'http://example.com/././foo',
base: 'about:blank',
href: 'http://example.com/foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo',
search: '',
hash: '',
},
{
input: 'http://example.com/./.foo',
base: 'about:blank',
href: 'http://example.com/.foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/.foo',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/.',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/./',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar/..',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar/../',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/..bar',
base: 'about:blank',
href: 'http://example.com/foo/..bar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/..bar',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar/../ton',
base: 'about:blank',
href: 'http://example.com/foo/ton',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/ton',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar/../ton/../../a',
base: 'about:blank',
href: 'http://example.com/a',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/a',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/../../..',
base: 'about:blank',
href: 'http://example.com/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/../../../ton',
base: 'about:blank',
href: 'http://example.com/ton',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/ton',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/%2e',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/%2e%2',
base: 'about:blank',
href: 'http://example.com/foo/%2e%2',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/%2e%2',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/%2e./%2e%2e/.%2e/%2e.bar',
base: 'about:blank',
href: 'http://example.com/%2e.bar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%2e.bar',
search: '',
hash: '',
},
{
input: 'http://example.com////../..',
base: 'about:blank',
href: 'http://example.com//',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '//',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar//../..',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar//..',
base: 'about:blank',
href: 'http://example.com/foo/bar/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/bar/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo',
base: 'about:blank',
href: 'http://example.com/foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo',
search: '',
hash: '',
},
{
input: 'http://example.com/%20foo',
base: 'about:blank',
href: 'http://example.com/%20foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%20foo',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%',
base: 'about:blank',
href: 'http://example.com/foo%',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%2',
base: 'about:blank',
href: 'http://example.com/foo%2',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%2',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%2zbar',
base: 'about:blank',
href: 'http://example.com/foo%2zbar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%2zbar',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%2©zbar',
base: 'about:blank',
href: 'http://example.com/foo%2%C3%82%C2%A9zbar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%2%C3%82%C2%A9zbar',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%41%7a',
base: 'about:blank',
href: 'http://example.com/foo%41%7a',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%41%7a',
search: '',
hash: '',
},
{
input: 'http://example.com/foo\t\u0091%91',
base: 'about:blank',
href: 'http://example.com/foo%C2%91%91',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%C2%91%91',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%00%51',
base: 'about:blank',
href: 'http://example.com/foo%00%51',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%00%51',
search: '',
hash: '',
},
{
input: 'http://example.com/(%28:%3A%29)',
base: 'about:blank',
href: 'http://example.com/(%28:%3A%29)',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/(%28:%3A%29)',
search: '',
hash: '',
},
{
input: 'http://example.com/%3A%3a%3C%3c',
base: 'about:blank',
href: 'http://example.com/%3A%3a%3C%3c',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%3A%3a%3C%3c',
search: '',
hash: '',
},
{
input: 'http://example.com/foo\tbar',
base: 'about:blank',
href: 'http://example.com/foobar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foobar',
search: '',
hash: '',
},
{
input: 'http://example.com\\\\foo\\\\bar',
base: 'about:blank',
href: 'http://example.com//foo//bar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '//foo//bar',
search: '',
hash: '',
},
{
input: 'http://example.com/%7Ffp3%3Eju%3Dduvgw%3Dd',
base: 'about:blank',
href: 'http://example.com/%7Ffp3%3Eju%3Dduvgw%3Dd',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%7Ffp3%3Eju%3Dduvgw%3Dd',
search: '',
hash: '',
},
{
input: 'http://example.com/@asdf%40',
base: 'about:blank',
href: 'http://example.com/@asdf%40',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/@asdf%40',
search: '',
hash: '',
},
{
input: 'http://example.com/你好你好',
base: 'about:blank',
href: 'http://example.com/%E4%BD%A0%E5%A5%BD%E4%BD%A0%E5%A5%BD',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%E4%BD%A0%E5%A5%BD%E4%BD%A0%E5%A5%BD',
search: '',
hash: '',
},
{
input: 'http://example.com/‥/foo',
base: 'about:blank',
href: 'http://example.com/%E2%80%A5/foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%E2%80%A5/foo',
search: '',
hash: '',
},
{
input: 'http://example.com//foo',
base: 'about:blank',
href: 'http://example.com/%EF%BB%BF/foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%EF%BB%BF/foo',
search: '',
hash: '',
},
{
input: 'http://example.com//foo//bar',
base: 'about:blank',
href: 'http://example.com/%E2%80%AE/foo/%E2%80%AD/bar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%E2%80%AE/foo/%E2%80%AD/bar',
search: '',
hash: '',
},
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/script-tests/relative.js',
{
input: 'http://www.google.com/foo?bar=baz#',
base: 'about:blank',
href: 'http://www.google.com/foo?bar=baz#',
origin: 'http://www.google.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.google.com',
hostname: 'www.google.com',
port: '',
pathname: '/foo',
search: '?bar=baz',
hash: '',
},
{
input: 'http://www.google.com/foo?bar=baz# »',
base: 'about:blank',
href: 'http://www.google.com/foo?bar=baz#%20%C2%BB',
origin: 'http://www.google.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.google.com',
hostname: 'www.google.com',
port: '',
pathname: '/foo',
search: '?bar=baz',
hash: '#%20%C2%BB',
},
{
input: 'data:test# »',
base: 'about:blank',
href: 'data:test#%20%C2%BB',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'test',
search: '',
hash: '#%20%C2%BB',
},
{
input: 'http://www.google.com',
base: 'about:blank',
href: 'http://www.google.com/',
origin: 'http://www.google.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.google.com',
hostname: 'www.google.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://192.0x00A80001',
base: 'about:blank',
href: 'http://192.168.0.1/',
origin: 'http://192.168.0.1',
protocol: 'http:',
username: '',
password: '',
host: '192.168.0.1',
hostname: '192.168.0.1',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://www/foo%2Ehtml',
base: 'about:blank',
href: 'http://www/foo%2Ehtml',
origin: 'http://www',
protocol: 'http:',
username: '',
password: '',
host: 'www',
hostname: 'www',
port: '',
pathname: '/foo%2Ehtml',
search: '',
hash: '',
},
{
input: 'http://www/foo/%2E/html',
base: 'about:blank',
href: 'http://www/foo/html',
origin: 'http://www',
protocol: 'http:',
username: '',
password: '',
host: 'www',
hostname: 'www',
port: '',
pathname: '/foo/html',
search: '',
hash: '',
},
{
input: 'http://user:pass@/',
base: 'about:blank',
failure: true,
},
{
input: 'http://%25DOMAIN:foobar@foodomain.com/',
base: 'about:blank',
href: 'http://%25DOMAIN:foobar@foodomain.com/',
origin: 'http://foodomain.com',
protocol: 'http:',
username: '%25DOMAIN',
password: 'foobar',
host: 'foodomain.com',
hostname: 'foodomain.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:\\\\www.google.com\\foo',
base: 'about:blank',
href: 'http://www.google.com/foo',
origin: 'http://www.google.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.google.com',
hostname: 'www.google.com',
port: '',
pathname: '/foo',
search: '',
hash: '',
},
{
input: 'http://foo:80/',
base: 'about:blank',
href: 'http://foo/',
origin: 'http://foo',
protocol: 'http:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://foo:81/',
base: 'about:blank',
href: 'http://foo:81/',
origin: 'http://foo:81',
protocol: 'http:',
username: '',
password: '',
host: 'foo:81',
hostname: 'foo',
port: '81',
pathname: '/',
search: '',
hash: '',
},
{
input: 'httpa://foo:80/',
base: 'about:blank',
href: 'httpa://foo:80/',
origin: 'null',
protocol: 'httpa:',
username: '',
password: '',
host: 'foo:80',
hostname: 'foo',
port: '80',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://foo:-80/',
base: 'about:blank',
failure: true,
},
{
input: 'https://foo:443/',
base: 'about:blank',
href: 'https://foo/',
origin: 'https://foo',
protocol: 'https:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://foo:80/',
base: 'about:blank',
href: 'https://foo:80/',
origin: 'https://foo:80',
protocol: 'https:',
username: '',
password: '',
host: 'foo:80',
hostname: 'foo',
port: '80',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ftp://foo:21/',
base: 'about:blank',
href: 'ftp://foo/',
origin: 'ftp://foo',
protocol: 'ftp:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ftp://foo:80/',
base: 'about:blank',
href: 'ftp://foo:80/',
origin: 'ftp://foo:80',
protocol: 'ftp:',
username: '',
password: '',
host: 'foo:80',
hostname: 'foo',
port: '80',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ws://foo:80/',
base: 'about:blank',
href: 'ws://foo/',
origin: 'ws://foo',
protocol: 'ws:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ws://foo:81/',
base: 'about:blank',
href: 'ws://foo:81/',
origin: 'ws://foo:81',
protocol: 'ws:',
username: '',
password: '',
host: 'foo:81',
hostname: 'foo',
port: '81',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ws://foo:443/',
base: 'about:blank',
href: 'ws://foo:443/',
origin: 'ws://foo:443',
protocol: 'ws:',
username: '',
password: '',
host: 'foo:443',
hostname: 'foo',
port: '443',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ws://foo:815/',
base: 'about:blank',
href: 'ws://foo:815/',
origin: 'ws://foo:815',
protocol: 'ws:',
username: '',
password: '',
host: 'foo:815',
hostname: 'foo',
port: '815',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss://foo:80/',
base: 'about:blank',
href: 'wss://foo:80/',
origin: 'wss://foo:80',
protocol: 'wss:',
username: '',
password: '',
host: 'foo:80',
hostname: 'foo',
port: '80',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss://foo:81/',
base: 'about:blank',
href: 'wss://foo:81/',
origin: 'wss://foo:81',
protocol: 'wss:',
username: '',
password: '',
host: 'foo:81',
hostname: 'foo',
port: '81',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss://foo:443/',
base: 'about:blank',
href: 'wss://foo/',
origin: 'wss://foo',
protocol: 'wss:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss://foo:815/',
base: 'about:blank',
href: 'wss://foo:815/',
origin: 'wss://foo:815',
protocol: 'wss:',
username: '',
password: '',
host: 'foo:815',
hostname: 'foo',
port: '815',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/example.com/',
base: 'about:blank',
href: 'http://example.com/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ftp:/example.com/',
base: 'about:blank',
href: 'ftp://example.com/',
origin: 'ftp://example.com',
protocol: 'ftp:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https:/example.com/',
base: 'about:blank',
href: 'https://example.com/',
origin: 'https://example.com',
protocol: 'https:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'madeupscheme:/example.com/',
base: 'about:blank',
href: 'madeupscheme:/example.com/',
origin: 'null',
protocol: 'madeupscheme:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'file:/example.com/',
base: 'about:blank',
href: 'file:///example.com/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'ftps:/example.com/',
base: 'about:blank',
href: 'ftps:/example.com/',
origin: 'null',
protocol: 'ftps:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'ws:/example.com/',
base: 'about:blank',
href: 'ws://example.com/',
origin: 'ws://example.com',
protocol: 'ws:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss:/example.com/',
base: 'about:blank',
href: 'wss://example.com/',
origin: 'wss://example.com',
protocol: 'wss:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'data:/example.com/',
base: 'about:blank',
href: 'data:/example.com/',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'javascript:/example.com/',
base: 'about:blank',
href: 'javascript:/example.com/',
origin: 'null',
protocol: 'javascript:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'mailto:/example.com/',
base: 'about:blank',
href: 'mailto:/example.com/',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'http:example.com/',
base: 'about:blank',
href: 'http://example.com/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ftp:example.com/',
base: 'about:blank',
href: 'ftp://example.com/',
origin: 'ftp://example.com',
protocol: 'ftp:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https:example.com/',
base: 'about:blank',
href: 'https://example.com/',
origin: 'https://example.com',
protocol: 'https:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'madeupscheme:example.com/',
base: 'about:blank',
href: 'madeupscheme:example.com/',
origin: 'null',
protocol: 'madeupscheme:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'ftps:example.com/',
base: 'about:blank',
href: 'ftps:example.com/',
origin: 'null',
protocol: 'ftps:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'ws:example.com/',
base: 'about:blank',
href: 'ws://example.com/',
origin: 'ws://example.com',
protocol: 'ws:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss:example.com/',
base: 'about:blank',
href: 'wss://example.com/',
origin: 'wss://example.com',
protocol: 'wss:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'data:example.com/',
base: 'about:blank',
href: 'data:example.com/',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'javascript:example.com/',
base: 'about:blank',
href: 'javascript:example.com/',
origin: 'null',
protocol: 'javascript:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'mailto:example.com/',
base: 'about:blank',
href: 'mailto:example.com/',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/segments-userinfo-vs-host.html',
{
input: 'http:@www.example.com',
base: 'about:blank',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/@www.example.com',
base: 'about:blank',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://@www.example.com',
base: 'about:blank',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:a:b@www.example.com',
base: 'about:blank',
href: 'http://a:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/a:b@www.example.com',
base: 'about:blank',
href: 'http://a:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://a:b@www.example.com',
base: 'about:blank',
href: 'http://a:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://@pple.com',
base: 'about:blank',
href: 'http://pple.com/',
origin: 'http://pple.com',
protocol: 'http:',
username: '',
password: '',
host: 'pple.com',
hostname: 'pple.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http::b@www.example.com',
base: 'about:blank',
href: 'http://:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/:b@www.example.com',
base: 'about:blank',
href: 'http://:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://:b@www.example.com',
base: 'about:blank',
href: 'http://:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/:@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http://user@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:/@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http://@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'https:@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:a:b@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:/a:b@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http://a:b@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http::@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:a:@www.example.com',
base: 'about:blank',
href: 'http://a@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/a:@www.example.com',
base: 'about:blank',
href: 'http://a@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://a:@www.example.com',
base: 'about:blank',
href: 'http://a@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://www.@pple.com',
base: 'about:blank',
href: 'http://www.@pple.com/',
origin: 'http://pple.com',
protocol: 'http:',
username: 'www.',
password: '',
host: 'pple.com',
hostname: 'pple.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:@:www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:/@:www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http://@:www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http://:@www.example.com',
base: 'about:blank',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
'# Others',
{
input: '/',
base: 'http://www.example.com/test',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '/test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/test.txt',
search: '',
hash: '',
},
{
input: '.',
base: 'http://www.example.com/test',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '..',
base: 'http://www.example.com/test',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/test.txt',
search: '',
hash: '',
},
{
input: './test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/test.txt',
search: '',
hash: '',
},
{
input: '../test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/test.txt',
search: '',
hash: '',
},
{
input: '../aaa/test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/aaa/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/aaa/test.txt',
search: '',
hash: '',
},
{
input: '../../test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/test.txt',
search: '',
hash: '',
},
{
input: '中/test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/%E4%B8%AD/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/%E4%B8%AD/test.txt',
search: '',
hash: '',
},
{
input: 'http://www.example2.com',
base: 'http://www.example.com/test',
href: 'http://www.example2.com/',
origin: 'http://www.example2.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example2.com',
hostname: 'www.example2.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '//www.example2.com',
base: 'http://www.example.com/test',
href: 'http://www.example2.com/',
origin: 'http://www.example2.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example2.com',
hostname: 'www.example2.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:...',
base: 'http://www.example.com/test',
href: 'file:///...',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/...',
search: '',
hash: '',
},
{
input: 'file:..',
base: 'http://www.example.com/test',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:a',
base: 'http://www.example.com/test',
href: 'file:///a',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/a',
search: '',
hash: '',
},
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/host.html',
'Basic canonicalization, uppercase should be converted to lowercase',
{
input: 'http://ExAmPlE.CoM',
base: 'http://other.com/',
href: 'http://example.com/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://example example.com',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://Goo%20 goo%7C|.com',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[]',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[:]',
base: 'http://other.com/',
failure: true,
},
'U+3000 is mapped to U+0020 (space) which is disallowed',
{
input: 'http://GOO\u00A0\u3000goo.com',
base: 'http://other.com/',
failure: true,
},
'Other types of space (no-break, zero-width, zero-width-no-break) are name-prepped away to nothing. U+200B, U+2060, and U+FEFF, are ignored',
{
input: 'http://GOO\u200B\u2060\uFEFFgoo.com',
base: 'http://other.com/',
href: 'http://googoo.com/',
origin: 'http://googoo.com',
protocol: 'http:',
username: '',
password: '',
host: 'googoo.com',
hostname: 'googoo.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Leading and trailing C0 control or space',
{
input: '\u0000\u001B\u0004\u0012 http://example.com/\u001F \u000D ',
base: 'about:blank',
href: 'http://example.com/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Ideographic full stop (full-width period for Chinese, etc.) should be treated as a dot. U+3002 is mapped to U+002E (dot)',
{
input: 'http://www.foo。bar.com',
base: 'http://other.com/',
href: 'http://www.foo.bar.com/',
origin: 'http://www.foo.bar.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.foo.bar.com',
hostname: 'www.foo.bar.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Invalid unicode characters should fail... U+FDD0 is disallowed; %ef%b7%90 is U+FDD0',
{
input: 'http://\uFDD0zyx.com',
base: 'http://other.com/',
failure: true,
},
'This is the same as previous but escaped',
{
input: 'http://%ef%b7%90zyx.com',
base: 'http://other.com/',
failure: true,
},
'U+FFFD',
{
input: 'https://\uFFFD',
base: 'about:blank',
failure: true,
},
{
input: 'https://%EF%BF%BD',
base: 'about:blank',
failure: true,
},
{
input: 'https://x/\uFFFD?\uFFFD#\uFFFD',
base: 'about:blank',
href: 'https://x/%EF%BF%BD?%EF%BF%BD#%EF%BF%BD',
origin: 'https://x',
protocol: 'https:',
username: '',
password: '',
host: 'x',
hostname: 'x',
port: '',
pathname: '/%EF%BF%BD',
search: '?%EF%BF%BD',
hash: '#%EF%BF%BD',
},
"Test name prepping, fullwidth input should be converted to ASCII and NOT IDN-ized. This is 'Go' in fullwidth UTF-8/UTF-16.",
{
input: 'http://Ｇｏ.com',
base: 'http://other.com/',
href: 'http://go.com/',
origin: 'http://go.com',
protocol: 'http:',
username: '',
password: '',
host: 'go.com',
hostname: 'go.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
'URL spec forbids the following. https://www.w3.org/Bugs/Public/show_bug.cgi?id=24257',
{
input: 'http://％４１.com',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://%ef%bc%85%ef%bc%94%ef%bc%91.com',
base: 'http://other.com/',
failure: true,
},
'...%00 in fullwidth should fail (also as escaped UTF-8 input)',
{
input: 'http://％００.com',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://%ef%bc%85%ef%bc%90%ef%bc%90.com',
base: 'http://other.com/',
failure: true,
},
'Basic IDN support, UTF-8 and UTF-16 input should be converted to IDN',
{
input: 'http://你好你好',
base: 'http://other.com/',
href: 'http://xn--6qqa088eba/',
origin: 'http://xn--6qqa088eba',
protocol: 'http:',
username: '',
password: '',
host: 'xn--6qqa088eba',
hostname: 'xn--6qqa088eba',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://faß.ExAmPlE/',
base: 'about:blank',
href: 'https://xn--fa-hia.example/',
origin: 'https://xn--fa-hia.example',
protocol: 'https:',
username: '',
password: '',
host: 'xn--fa-hia.example',
hostname: 'xn--fa-hia.example',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'sc://faß.ExAmPlE/',
base: 'about:blank',
href: 'sc://fa%C3%9F.ExAmPlE/',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'fa%C3%9F.ExAmPlE',
hostname: 'fa%C3%9F.ExAmPlE',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Invalid escaped characters should fail and the percents should be escaped. https://www.w3.org/Bugs/Public/show_bug.cgi?id=24191',
{
input: 'http://%zz%66%a.com',
base: 'http://other.com/',
failure: true,
},
'If we get an invalid character that has been escaped.',
{
input: 'http://%25',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://hello%00',
base: 'http://other.com/',
failure: true,
},
'Escaped numbers should be treated like IP addresses if they are.',
/*
{
input: 'http://%30%78%63%30%2e%30%32%35%30.01',
base: 'http://other.com/',
href: 'http://192.168.0.1/',
origin: 'http://192.168.0.1',
protocol: 'http:',
username: '',
password: '',
host: '192.168.0.1',
hostname: '192.168.0.1',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://%30%78%63%30%2e%30%32%35%30.01%2e',
base: 'http://other.com/',
href: 'http://192.168.0.1/',
origin: 'http://192.168.0.1',
protocol: 'http:',
username: '',
password: '',
host: '192.168.0.1',
hostname: '192.168.0.1',
port: '',
pathname: '/',
search: '',
hash: '',
},
*/
{
input: 'http://192.168.0.257',
base: 'http://other.com/',
failure: true,
},
'Invalid escaping in hosts causes failure',
{
input: 'http://%3g%78%63%30%2e%30%32%35%30%2E.01',
base: 'http://other.com/',
failure: true,
},
'A space in a host causes failure',
{
input: 'http://192.168.0.1 hello',
base: 'http://other.com/',
failure: true,
},
{
input: 'https://x x:12',
base: 'about:blank',
failure: true,
},
'Fullwidth and escaped UTF-8 fullwidth should still be treated as IP',
{
input: 'http://０Ｘｃ０．０２５０．０１',
base: 'http://other.com/',
href: 'http://192.168.0.1/',
origin: 'http://192.168.0.1',
protocol: 'http:',
username: '',
password: '',
host: '192.168.0.1',
hostname: '192.168.0.1',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Domains with empty labels',
{
input: 'http://./',
base: 'about:blank',
href: 'http://./',
origin: 'http://.',
protocol: 'http:',
username: '',
password: '',
host: '.',
hostname: '.',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://../',
base: 'about:blank',
href: 'http://../',
origin: 'http://..',
protocol: 'http:',
username: '',
password: '',
host: '..',
hostname: '..',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://0..0x300/',
base: 'about:blank',
href: 'http://0..0x300/',
origin: 'http://0..0x300',
protocol: 'http:',
username: '',
password: '',
host: '0..0x300',
hostname: '0..0x300',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Broken IPv6',
{
input: 'http://[www.google.com]/',
base: 'about:blank',
failure: true,
},
{
input: 'http://[google.com]',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[::1.2.3.4x]',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[::1.2.3.]',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[::1.2.]',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[::1.]',
base: 'http://other.com/',
failure: true,
},
'Misc Unicode',
{
input: 'http://foo:💩@example.com/bar',
base: 'http://other.com/',
href: 'http://foo:%F0%9F%92%A9@example.com/bar',
origin: 'http://example.com',
protocol: 'http:',
username: 'foo',
password: '%F0%9F%92%A9',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/bar',
search: '',
hash: '',
},
'# resolving a fragment against any scheme succeeds',
{
input: '#',
base: 'test:test',
href: 'test:test#',
origin: 'null',
protocol: 'test:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'test',
search: '',
hash: '',
},
{
input: '#x',
base: 'mailto:x@x.com',
href: 'mailto:x@x.com#x',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'x@x.com',
search: '',
hash: '#x',
},
{
input: '#x',
base: 'data:,',
href: 'data:,#x',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: ',',
search: '',
hash: '#x',
},
{
input: '#x',
base: 'about:blank',
href: 'about:blank#x',
origin: 'null',
protocol: 'about:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'blank',
search: '',
hash: '#x',
},
{
input: '#',
base: 'test:test?test',
href: 'test:test?test#',
origin: 'null',
protocol: 'test:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'test',
search: '?test',
hash: '',
},
'# multiple @ in authority state',
{
input: 'https://@test@test@example:800/',
base: 'http://doesnotmatter/',
href: 'https://%40test%40test@example:800/',
origin: 'https://example:800',
protocol: 'https:',
username: '%40test%40test',
password: '',
host: 'example:800',
hostname: 'example',
port: '800',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://@@@example',
base: 'http://doesnotmatter/',
href: 'https://%40%40@example/',
origin: 'https://example',
protocol: 'https:',
username: '%40%40',
password: '',
host: 'example',
hostname: 'example',
port: '',
pathname: '/',
search: '',
hash: '',
},
'non-az-09 characters',
{
input: 'http://`{}:`{}@h/`{}?`{}',
base: 'http://doesnotmatter/',
href: 'http://%60%7B%7D:%60%7B%7D@h/%60%7B%7D?`{}',
origin: 'http://h',
protocol: 'http:',
username: '%60%7B%7D',
password: '%60%7B%7D',
host: 'h',
hostname: 'h',
port: '',
pathname: '/%60%7B%7D',
search: '?`{}',
hash: '',
},
"byte is ' and url is special",
{
input: "http://host/?'",
base: 'about:blank',
href: 'http://host/?%27',
origin: 'http://host',
protocol: 'http:',
username: '',
password: '',
host: 'host',
hostname: 'host',
port: '',
pathname: '/',
search: '?%27',
hash: '',
},
{
input: "notspecial://host/?'",
base: 'about:blank',
href: "notspecial://host/?'",
origin: 'null',
protocol: 'notspecial:',
username: '',
password: '',
host: 'host',
hostname: 'host',
port: '',
pathname: '/',
search: "?'",
hash: '',
},
'# Credentials in base',
{
input: '/some/path',
base: 'http://user@example.org/smth',
href: 'http://user@example.org/some/path',
origin: 'http://example.org',
protocol: 'http:',
username: 'user',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/some/path',
search: '',
hash: '',
},
{
input: '',
base: 'http://user:pass@example.org:21/smth',
href: 'http://user:pass@example.org:21/smth',
origin: 'http://example.org:21',
protocol: 'http:',
username: 'user',
password: 'pass',
host: 'example.org:21',
hostname: 'example.org',
port: '21',
pathname: '/smth',
search: '',
hash: '',
},
{
input: '/some/path',
base: 'http://user:pass@example.org:21/smth',
href: 'http://user:pass@example.org:21/some/path',
origin: 'http://example.org:21',
protocol: 'http:',
username: 'user',
password: 'pass',
host: 'example.org:21',
hostname: 'example.org',
port: '21',
pathname: '/some/path',
search: '',
hash: '',
},
'# a set of tests designed by zcorpan for relative URLs with unknown schemes',
{
input: 'i',
base: 'sc:sd',
failure: true,
},
{
input: 'i',
base: 'sc:sd/sd',
failure: true,
},
{
input: 'i',
base: 'sc:/pa/pa',
href: 'sc:/pa/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/i',
search: '',
hash: '',
},
{
input: 'i',
base: 'sc://ho/pa',
href: 'sc://ho/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'ho',
hostname: 'ho',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: 'i',
base: 'sc:///pa/pa',
href: 'sc:///pa/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/i',
search: '',
hash: '',
},
{
input: '../i',
base: 'sc:sd',
failure: true,
},
{
input: '../i',
base: 'sc:sd/sd',
failure: true,
},
{
input: '../i',
base: 'sc:/pa/pa',
href: 'sc:/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '../i',
base: 'sc://ho/pa',
href: 'sc://ho/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'ho',
hostname: 'ho',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '../i',
base: 'sc:///pa/pa',
href: 'sc:///i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '/i',
base: 'sc:sd',
failure: true,
},
{
input: '/i',
base: 'sc:sd/sd',
failure: true,
},
{
input: '/i',
base: 'sc:/pa/pa',
href: 'sc:/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '/i',
base: 'sc://ho/pa',
href: 'sc://ho/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'ho',
hostname: 'ho',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '/i',
base: 'sc:///pa/pa',
href: 'sc:///i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '?i',
base: 'sc:sd',
failure: true,
},
{
input: '?i',
base: 'sc:sd/sd',
failure: true,
},
{
input: '?i',
base: 'sc:/pa/pa',
href: 'sc:/pa/pa?i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/pa',
search: '?i',
hash: '',
},
{
input: '?i',
base: 'sc://ho/pa',
href: 'sc://ho/pa?i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'ho',
hostname: 'ho',
port: '',
pathname: '/pa',
search: '?i',
hash: '',
},
{
input: '?i',
base: 'sc:///pa/pa',
href: 'sc:///pa/pa?i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/pa',
search: '?i',
hash: '',
},
{
input: '#i',
base: 'sc:sd',
href: 'sc:sd#i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'sd',
search: '',
hash: '#i',
},
{
input: '#i',
base: 'sc:sd/sd',
href: 'sc:sd/sd#i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'sd/sd',
search: '',
hash: '#i',
},
{
input: '#i',
base: 'sc:/pa/pa',
href: 'sc:/pa/pa#i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/pa',
search: '',
hash: '#i',
},
{
input: '#i',
base: 'sc://ho/pa',
href: 'sc://ho/pa#i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'ho',
hostname: 'ho',
port: '',
pathname: '/pa',
search: '',
hash: '#i',
},
{
input: '#i',
base: 'sc:///pa/pa',
href: 'sc:///pa/pa#i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/pa',
search: '',
hash: '#i',
},
'# make sure that relative URL logic works on known typically non-relative schemes too',
{
input: 'about:/../',
base: 'about:blank',
href: 'about:/',
origin: 'null',
protocol: 'about:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'data:/../',
base: 'about:blank',
href: 'data:/',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'javascript:/../',
base: 'about:blank',
href: 'javascript:/',
origin: 'null',
protocol: 'javascript:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'mailto:/../',
base: 'about:blank',
href: 'mailto:/',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
'# unknown schemes and their hosts',
{
input: 'sc://ñ.test/',
base: 'about:blank',
href: 'sc://%C3%B1.test/',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1.test',
hostname: '%C3%B1.test',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: "sc://\u001F!\"$&'()*+,-.;<=>^_`{|}~/",
base: 'about:blank',
href: "sc://%1F!\"$&'()*+,-.;<=>^_`{|}~/",
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: "%1F!\"$&'()*+,-.;<=>^_`{|}~",
hostname: "%1F!\"$&'()*+,-.;<=>^_`{|}~",
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'sc://\u0000/',
base: 'about:blank',
failure: true,
},
{
input: 'sc:// /',
base: 'about:blank',
failure: true,
},
/*
{
input: 'sc://%/',
base: 'about:blank',
href: 'sc://%/',
protocol: 'sc:',
username: '',
password: '',
host: '%',
hostname: '%',
port: '',
pathname: '/',
search: '',
hash: '',
},
*/
{
input: 'sc://@/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://tes@s:t@/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://:/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://:12/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://[/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://\\/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://]/',
base: 'about:blank',
failure: true,
},
{
input: 'x',
base: 'sc://ñ',
href: 'sc://%C3%B1/x',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '/x',
search: '',
hash: '',
},
'# unknown schemes and backslashes',
{
input: 'sc:\\../',
base: 'about:blank',
href: 'sc:\\../',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '\\../',
search: '',
hash: '',
},
'# unknown scheme with path looking like a password',
{
input: 'sc::a@example.net',
base: 'about:blank',
href: 'sc::a@example.net',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: ':a@example.net',
search: '',
hash: '',
},
'# unknown scheme with bogus percent-encoding',
{
input: 'wow:%NBD',
base: 'about:blank',
href: 'wow:%NBD',
origin: 'null',
protocol: 'wow:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '%NBD',
search: '',
hash: '',
},
{
input: 'wow:%1G',
base: 'about:blank',
href: 'wow:%1G',
origin: 'null',
protocol: 'wow:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '%1G',
search: '',
hash: '',
},
'# Hosts and percent-encoding',
{
input: 'ftp://example.com%80/',
base: 'about:blank',
failure: true,
},
{
input: 'ftp://example.com%A0/',
base: 'about:blank',
failure: true,
},
{
input: 'https://example.com%80/',
base: 'about:blank',
failure: true,
},
{
input: 'https://example.com%A0/',
base: 'about:blank',
failure: true,
},
/*
{
input: 'ftp://%e2%98%83',
base: 'about:blank',
href: 'ftp://xn--n3h/',
origin: 'ftp://xn--n3h',
protocol: 'ftp:',
username: '',
password: '',
host: 'xn--n3h',
hostname: 'xn--n3h',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://%e2%98%83',
base: 'about:blank',
href: 'https://xn--n3h/',
origin: 'https://xn--n3h',
protocol: 'https:',
username: '',
password: '',
host: 'xn--n3h',
hostname: 'xn--n3h',
port: '',
pathname: '/',
search: '',
hash: '',
},
*/
'# tests from jsdom/whatwg-url designed for code coverage',
{
input: 'http://127.0.0.1:10100/relative_import.html',
base: 'about:blank',
href: 'http://127.0.0.1:10100/relative_import.html',
origin: 'http://127.0.0.1:10100',
protocol: 'http:',
username: '',
password: '',
host: '127.0.0.1:10100',
hostname: '127.0.0.1',
port: '10100',
pathname: '/relative_import.html',
search: '',
hash: '',
},
{
input: 'http://facebook.com/?foo=%7B%22abc%22',
base: 'about:blank',
href: 'http://facebook.com/?foo=%7B%22abc%22',
origin: 'http://facebook.com',
protocol: 'http:',
username: '',
password: '',
host: 'facebook.com',
hostname: 'facebook.com',
port: '',
pathname: '/',
search: '?foo=%7B%22abc%22',
hash: '',
},
{
input: 'https://localhost:3000/jqueryui@1.2.3',
base: 'about:blank',
href: 'https://localhost:3000/jqueryui@1.2.3',
origin: 'https://localhost:3000',
protocol: 'https:',
username: '',
password: '',
host: 'localhost:3000',
hostname: 'localhost',
port: '3000',
pathname: '/jqueryui@1.2.3',
search: '',
hash: '',
},
'# tab/LF/CR',
{
input: 'h\tt\nt\rp://h\to\ns\rt:9\t0\n0\r0/p\ta\nt\rh?q\tu\ne\rry#f\tr\na\rg',
base: 'about:blank',
href: 'http://host:9000/path?query#frag',
origin: 'http://host:9000',
protocol: 'http:',
username: '',
password: '',
host: 'host:9000',
hostname: 'host',
port: '9000',
pathname: '/path',
search: '?query',
hash: '#frag',
},
'# Stringification of URL.searchParams',
{
input: '?a=b&c=d',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar?a=b&c=d',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '?a=b&c=d',
searchParams: 'a=b&c=d',
hash: '',
},
{
input: '??a=b&c=d',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar??a=b&c=d',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '??a=b&c=d',
searchParams: '%3Fa=b&c=d',
hash: '',
},
'# Scheme only',
{
input: 'http:',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
searchParams: '',
hash: '',
},
{
input: 'http:',
base: 'https://example.org/foo/bar',
failure: true,
},
{
input: 'sc:',
base: 'https://example.org/foo/bar',
href: 'sc:',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '',
search: '',
searchParams: '',
hash: '',
},
'# Percent encoding of fragments',
{
input: 'http://foo.bar/baz?qux#foo\bbar',
base: 'about:blank',
href: 'http://foo.bar/baz?qux#foo%08bar',
origin: 'http://foo.bar',
protocol: 'http:',
username: '',
password: '',
host: 'foo.bar',
hostname: 'foo.bar',
port: '',
pathname: '/baz',
search: '?qux',
searchParams: 'qux=',
hash: '#foo%08bar',
},
{
input: 'http://foo.bar/baz?qux#foo"bar',
base: 'about:blank',
href: 'http://foo.bar/baz?qux#foo%22bar',
origin: 'http://foo.bar',
protocol: 'http:',
username: '',
password: '',
host: 'foo.bar',
hostname: 'foo.bar',
port: '',
pathname: '/baz',
search: '?qux',
searchParams: 'qux=',
hash: '#foo%22bar',
},
{
input: 'http://foo.bar/baz?qux#foobar',
base: 'about:blank',
href: 'http://foo.bar/baz?qux#foo%3Ebar',
origin: 'http://foo.bar',
protocol: 'http:',
username: '',
password: '',
host: 'foo.bar',
hostname: 'foo.bar',
port: '',
pathname: '/baz',
search: '?qux',
searchParams: 'qux=',
hash: '#foo%3Ebar',
},
{
input: 'http://foo.bar/baz?qux#foo`bar',
base: 'about:blank',
href: 'http://foo.bar/baz?qux#foo%60bar',
origin: 'http://foo.bar',
protocol: 'http:',
username: '',
password: '',
host: 'foo.bar',
hostname: 'foo.bar',
port: '',
pathname: '/baz',
search: '?qux',
searchParams: 'qux=',
hash: '#foo%60bar',
},
'# IPv4 parsing (via https://github.com/nodejs/node/pull/10317)',
{
input: 'http://192.168.257',
base: 'http://other.com/',
href: 'http://192.168.1.1/',
origin: 'http://192.168.1.1',
protocol: 'http:',
username: '',
password: '',
host: '192.168.1.1',
hostname: '192.168.1.1',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://192.168.257.com',
base: 'http://other.com/',
href: 'http://192.168.257.com/',
origin: 'http://192.168.257.com',
protocol: 'http:',
username: '',
password: '',
host: '192.168.257.com',
hostname: '192.168.257.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://256',
base: 'http://other.com/',
href: 'http://0.0.1.0/',
origin: 'http://0.0.1.0',
protocol: 'http:',
username: '',
password: '',
host: '0.0.1.0',
hostname: '0.0.1.0',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://256.com',
base: 'http://other.com/',
href: 'http://256.com/',
origin: 'http://256.com',
protocol: 'http:',
username: '',
password: '',
host: '256.com',
hostname: '256.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://999999999',
base: 'http://other.com/',
href: 'http://59.154.201.255/',
origin: 'http://59.154.201.255',
protocol: 'http:',
username: '',
password: '',
host: '59.154.201.255',
hostname: '59.154.201.255',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://999999999.com',
base: 'http://other.com/',
href: 'http://999999999.com/',
origin: 'http://999999999.com',
protocol: 'http:',
username: '',
password: '',
host: '999999999.com',
hostname: '999999999.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://10000000000',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://10000000000.com',
base: 'http://other.com/',
href: 'http://10000000000.com/',
origin: 'http://10000000000.com',
protocol: 'http:',
username: '',
password: '',
host: '10000000000.com',
hostname: '10000000000.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://4294967295',
base: 'http://other.com/',
href: 'http://255.255.255.255/',
origin: 'http://255.255.255.255',
protocol: 'http:',
username: '',
password: '',
host: '255.255.255.255',
hostname: '255.255.255.255',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://4294967296',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://0xffffffff',
base: 'http://other.com/',
href: 'http://255.255.255.255/',
origin: 'http://255.255.255.255',
protocol: 'http:',
username: '',
password: '',
host: '255.255.255.255',
hostname: '255.255.255.255',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://0xffffffff1',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://256.256.256.256',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://256.256.256.256.256',
base: 'http://other.com/',
href: 'http://256.256.256.256.256/',
origin: 'http://256.256.256.256.256',
protocol: 'http:',
username: '',
password: '',
host: '256.256.256.256.256',
hostname: '256.256.256.256.256',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://0x.0x.0',
base: 'about:blank',
href: 'https://0.0.0.0/',
origin: 'https://0.0.0.0',
protocol: 'https:',
username: '',
password: '',
host: '0.0.0.0',
hostname: '0.0.0.0',
port: '',
pathname: '/',
search: '',
hash: '',
},
'More IPv4 parsing (via https://github.com/jsdom/whatwg-url/issues/92)',
{
input: 'https://0x100000000/test',
base: 'about:blank',
failure: true,
},
{
input: 'https://256.0.0.1/test',
base: 'about:blank',
failure: true,
},
"# file URLs containing percent-encoded Windows drive letters (shouldn't work)",
{
input: 'file:///C%3A/',
base: 'about:blank',
href: 'file:///C%3A/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C%3A/',
search: '',
hash: '',
},
{
input: 'file:///C%7C/',
base: 'about:blank',
href: 'file:///C%7C/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C%7C/',
search: '',
hash: '',
},
'# file URLs relative to other file URLs (via https://github.com/jsdom/whatwg-url/pull/60)',
{
input: 'pix/submit.gif',
base: 'file:///C:/Users/Domenic/Dropbox/GitHub/tmpvar/jsdom/test/level2/html/files/anchor.html',
href: 'file:///C:/Users/Domenic/Dropbox/GitHub/tmpvar/jsdom/test/level2/html/files/pix/submit.gif',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/Users/Domenic/Dropbox/GitHub/tmpvar/jsdom/test/level2/html/files/pix/submit.gif',
search: '',
hash: '',
},
{
input: '..',
base: 'file:///C:/',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: '..',
base: 'file:///',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
'# More file URL tests by zcorpan and annevk',
{
input: '/',
base: 'file:///C:/a/b',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: '//d:',
base: 'file:///C:/a/b',
href: 'file:///d:',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/d:',
search: '',
hash: '',
},
{
input: '//d:/..',
base: 'file:///C:/a/b',
href: 'file:///d:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/d:/',
search: '',
hash: '',
},
{
input: '..',
base: 'file:///ab:/',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '..',
base: 'file:///1:/',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '',
base: 'file:///test?test#test',
href: 'file:///test?test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?test',
hash: '',
},
{
input: 'file:',
base: 'file:///test?test#test',
href: 'file:///test?test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?test',
hash: '',
},
{
input: '?x',
base: 'file:///test?test#test',
href: 'file:///test?x',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?x',
hash: '',
},
{
input: 'file:?x',
base: 'file:///test?test#test',
href: 'file:///test?x',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?x',
hash: '',
},
{
input: '#x',
base: 'file:///test?test#test',
href: 'file:///test?test#x',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?test',
hash: '#x',
},
{
input: 'file:#x',
base: 'file:///test?test#test',
href: 'file:///test?test#x',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?test',
hash: '#x',
},
'# File URLs and many (back)slashes',
{
input: 'file:\\\\//',
base: 'about:blank',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:\\\\\\\\',
base: 'about:blank',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:\\\\\\\\?fox',
base: 'about:blank',
href: 'file:///?fox',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '?fox',
hash: '',
},
{
input: 'file:\\\\\\\\#guppy',
base: 'about:blank',
href: 'file:///#guppy',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '#guppy',
},
{
input: 'file://spider///',
base: 'about:blank',
href: 'file://spider/',
protocol: 'file:',
username: '',
password: '',
host: 'spider',
hostname: 'spider',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:\\\\localhost//',
base: 'about:blank',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:///localhost//cat',
base: 'about:blank',
href: 'file:///localhost//cat',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/localhost//cat',
search: '',
hash: '',
},
{
input: 'file://\\/localhost//cat',
base: 'about:blank',
href: 'file:///localhost//cat',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/localhost//cat',
search: '',
hash: '',
},
{
input: 'file://localhost//a//../..//',
base: 'about:blank',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '/////mouse',
base: 'file:///elephant',
href: 'file:///mouse',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/mouse',
search: '',
hash: '',
},
{
input: '\\//pig',
base: 'file://lion/',
href: 'file:///pig',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pig',
search: '',
hash: '',
},
{
input: '\\/localhost//pig',
base: 'file://lion/',
href: 'file:///pig',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pig',
search: '',
hash: '',
},
{
input: '//localhost//pig',
base: 'file://lion/',
href: 'file:///pig',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pig',
search: '',
hash: '',
},
{
input: '/..//localhost//pig',
base: 'file://lion/',
href: 'file://lion/localhost//pig',
protocol: 'file:',
username: '',
password: '',
host: 'lion',
hostname: 'lion',
port: '',
pathname: '/localhost//pig',
search: '',
hash: '',
},
{
input: 'file://',
base: 'file://ape/',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
'# File URLs with non-empty hosts',
{
input: '/rooibos',
base: 'file://tea/',
href: 'file://tea/rooibos',
protocol: 'file:',
username: '',
password: '',
host: 'tea',
hostname: 'tea',
port: '',
pathname: '/rooibos',
search: '',
hash: '',
},
{
input: '/?chai',
base: 'file://tea/',
href: 'file://tea/?chai',
protocol: 'file:',
username: '',
password: '',
host: 'tea',
hostname: 'tea',
port: '',
pathname: '/',
search: '?chai',
hash: '',
},
"# Windows drive letter handling with the 'file:' base URL",
{
input: 'C|',
base: 'file://host/dir/file',
href: 'file:///C:',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:',
search: '',
hash: '',
},
{
input: 'C|#',
base: 'file://host/dir/file',
href: 'file:///C:#',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:',
search: '',
hash: '',
},
{
input: 'C|?',
base: 'file://host/dir/file',
href: 'file:///C:?',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:',
search: '',
hash: '',
},
{
input: 'C|/',
base: 'file://host/dir/file',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'C|\n/',
base: 'file://host/dir/file',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'C|\\',
base: 'file://host/dir/file',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'C',
base: 'file://host/dir/file',
href: 'file://host/dir/C',
protocol: 'file:',
username: '',
password: '',
host: 'host',
hostname: 'host',
port: '',
pathname: '/dir/C',
search: '',
hash: '',
},
{
input: 'C|a',
base: 'file://host/dir/file',
href: 'file://host/dir/C|a',
protocol: 'file:',
username: '',
password: '',
host: 'host',
hostname: 'host',
port: '',
pathname: '/dir/C|a',
search: '',
hash: '',
},
'# Windows drive letter quirk in the file slash state',
{
input: '/c:/foo/bar',
base: 'file:///c:/baz/qux',
href: 'file:///c:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:/foo/bar',
search: '',
hash: '',
},
{
input: '/c|/foo/bar',
base: 'file:///c:/baz/qux',
href: 'file:///c:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:/foo/bar',
search: '',
hash: '',
},
{
input: 'file:\\c:\\foo\\bar',
base: 'file:///c:/baz/qux',
href: 'file:///c:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:/foo/bar',
search: '',
hash: '',
},
{
input: '/c:/foo/bar',
base: 'file://host/path',
href: 'file:///c:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:/foo/bar',
search: '',
hash: '',
},
'# Windows drive letter quirk with not empty host',
{
input: 'file://example.net/C:/',
base: 'about:blank',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'file://1.2.3.4/C:/',
base: 'about:blank',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'file://[1::8]/C:/',
base: 'about:blank',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
'# Windows drive letter quirk (no host)',
{
input: 'file:/C|/',
base: 'about:blank',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'file://C|/',
base: 'about:blank',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
'# file URLs without base URL by Rimas Misevičius',
{
input: 'file:',
base: 'about:blank',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:?q=v',
base: 'about:blank',
href: 'file:///?q=v',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '?q=v',
hash: '',
},
{
input: 'file:#frag',
base: 'about:blank',
href: 'file:///#frag',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '#frag',
},
'# IPv6 tests',
{
input: 'http://[1:0::]',
base: 'http://example.net/',
href: 'http://[1::]/',
origin: 'http://[1::]',
protocol: 'http:',
username: '',
password: '',
host: '[1::]',
hostname: '[1::]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://[0:1:2:3:4:5:6:7:8]',
base: 'http://example.net/',
failure: true,
},
{
input: 'https://[0::0::0]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:.0]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:0:]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:1:2:3:4:5:6:7.0.0.0.1]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:1.00.0.0.0]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:1.290.0.0.0]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:1.23.23]',
base: 'about:blank',
failure: true,
},
'# Empty host',
{
input: 'http://?',
base: 'about:blank',
failure: true,
},
{
input: 'http://#',
base: 'about:blank',
failure: true,
},
'Port overflow (2^32 + 81)',
{
input: 'http://f:4294967377/c',
base: 'http://example.org/',
failure: true,
},
'Port overflow (2^64 + 81)',
{
input: 'http://f:18446744073709551697/c',
base: 'http://example.org/',
failure: true,
},
'Port overflow (2^128 + 81)',
{
input: 'http://f:340282366920938463463374607431768211537/c',
base: 'http://example.org/',
failure: true,
},
'# Non-special-URL path tests',
{
input: 'sc://ñ',
base: 'about:blank',
href: 'sc://%C3%B1',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '',
search: '',
hash: '',
},
{
input: 'sc://ñ?x',
base: 'about:blank',
href: 'sc://%C3%B1?x',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '',
search: '?x',
hash: '',
},
{
input: 'sc://ñ#x',
base: 'about:blank',
href: 'sc://%C3%B1#x',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '',
search: '',
hash: '#x',
},
{
input: '#x',
base: 'sc://ñ',
href: 'sc://%C3%B1#x',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '',
search: '',
hash: '#x',
},
{
input: '?x',
base: 'sc://ñ',
href: 'sc://%C3%B1?x',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '',
search: '?x',
hash: '',
},
{
input: 'sc://?',
base: 'about:blank',
href: 'sc://?',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '',
search: '',
hash: '',
},
{
input: 'sc://#',
base: 'about:blank',
href: 'sc://#',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '',
search: '',
hash: '',
},
{
input: '///',
base: 'sc://x/',
href: 'sc:///',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '////',
base: 'sc://x/',
href: 'sc:////',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '//',
search: '',
hash: '',
},
{
input: '////x/',
base: 'sc://x/',
href: 'sc:////x/',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '//x/',
search: '',
hash: '',
},
{
input: 'tftp://foobar.com/someconfig;mode=netascii',
base: 'about:blank',
href: 'tftp://foobar.com/someconfig;mode=netascii',
origin: 'null',
protocol: 'tftp:',
username: '',
password: '',
host: 'foobar.com',
hostname: 'foobar.com',
port: '',
pathname: '/someconfig;mode=netascii',
search: '',
hash: '',
},
{
input: 'telnet://user:pass@foobar.com:23/',
base: 'about:blank',
href: 'telnet://user:pass@foobar.com:23/',
origin: 'null',
protocol: 'telnet:',
username: 'user',
password: 'pass',
host: 'foobar.com:23',
hostname: 'foobar.com',
port: '23',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ut2004://10.10.10.10:7777/Index.ut2',
base: 'about:blank',
href: 'ut2004://10.10.10.10:7777/Index.ut2',
origin: 'null',
protocol: 'ut2004:',
username: '',
password: '',
host: '10.10.10.10:7777',
hostname: '10.10.10.10',
port: '7777',
pathname: '/Index.ut2',
search: '',
hash: '',
},
{
input: 'redis://foo:bar@somehost:6379/0?baz=bam&qux=baz',
base: 'about:blank',
href: 'redis://foo:bar@somehost:6379/0?baz=bam&qux=baz',
origin: 'null',
protocol: 'redis:',
username: 'foo',
password: 'bar',
host: 'somehost:6379',
hostname: 'somehost',
port: '6379',
pathname: '/0',
search: '?baz=bam&qux=baz',
hash: '',
},
{
input: 'rsync://foo@host:911/sup',
base: 'about:blank',
href: 'rsync://foo@host:911/sup',
origin: 'null',
protocol: 'rsync:',
username: 'foo',
password: '',
host: 'host:911',
hostname: 'host',
port: '911',
pathname: '/sup',
search: '',
hash: '',
},
{
input: 'git://github.com/foo/bar.git',
base: 'about:blank',
href: 'git://github.com/foo/bar.git',
origin: 'null',
protocol: 'git:',
username: '',
password: '',
host: 'github.com',
hostname: 'github.com',
port: '',
pathname: '/foo/bar.git',
search: '',
hash: '',
},
{
input: 'irc://myserver.com:6999/channel?passwd',
base: 'about:blank',
href: 'irc://myserver.com:6999/channel?passwd',
origin: 'null',
protocol: 'irc:',
username: '',
password: '',
host: 'myserver.com:6999',
hostname: 'myserver.com',
port: '6999',
pathname: '/channel',
search: '?passwd',
hash: '',
},
{
input: 'dns://fw.example.org:9999/foo.bar.org?type=TXT',
base: 'about:blank',
href: 'dns://fw.example.org:9999/foo.bar.org?type=TXT',
origin: 'null',
protocol: 'dns:',
username: '',
password: '',
host: 'fw.example.org:9999',
hostname: 'fw.example.org',
port: '9999',
pathname: '/foo.bar.org',
search: '?type=TXT',
hash: '',
},
{
input: 'ldap://localhost:389/ou=People,o=JNDITutorial',
base: 'about:blank',
href: 'ldap://localhost:389/ou=People,o=JNDITutorial',
origin: 'null',
protocol: 'ldap:',
username: '',
password: '',
host: 'localhost:389',
hostname: 'localhost',
port: '389',
pathname: '/ou=People,o=JNDITutorial',
search: '',
hash: '',
},
{
input: 'git+https://github.com/foo/bar',
base: 'about:blank',
href: 'git+https://github.com/foo/bar',
origin: 'null',
protocol: 'git+https:',
username: '',
password: '',
host: 'github.com',
hostname: 'github.com',
port: '',
pathname: '/foo/bar',
search: '',
hash: '',
},
{
input: 'urn:ietf:rfc:2648',
base: 'about:blank',
href: 'urn:ietf:rfc:2648',
origin: 'null',
protocol: 'urn:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'ietf:rfc:2648',
search: '',
hash: '',
},
{
input: 'tag:joe@example.org,2001:foo/bar',
base: 'about:blank',
href: 'tag:joe@example.org,2001:foo/bar',
origin: 'null',
protocol: 'tag:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'joe@example.org,2001:foo/bar',
search: '',
hash: '',
},
'# percent encoded hosts in non-special-URLs',
{
input: 'non-special://%E2%80%A0/',
base: 'about:blank',
href: 'non-special://%E2%80%A0/',
protocol: 'non-special:',
username: '',
password: '',
host: '%E2%80%A0',
hostname: '%E2%80%A0',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'non-special://H%4fSt/path',
base: 'about:blank',
href: 'non-special://H%4fSt/path',
protocol: 'non-special:',
username: '',
password: '',
host: 'H%4fSt',
hostname: 'H%4fSt',
port: '',
pathname: '/path',
search: '',
hash: '',
},
'# IPv6 in non-special-URLs',
{
input: 'non-special://[1:2:0:0:5:0:0:0]/',
base: 'about:blank',
href: 'non-special://[1:2:0:0:5::]/',
protocol: 'non-special:',
username: '',
password: '',
host: '[1:2:0:0:5::]',
hostname: '[1:2:0:0:5::]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'non-special://[1:2:0:0:0:0:0:3]/',
base: 'about:blank',
href: 'non-special://[1:2::3]/',
protocol: 'non-special:',
username: '',
password: '',
host: '[1:2::3]',
hostname: '[1:2::3]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'non-special://[1:2::3]:80/',
base: 'about:blank',
href: 'non-special://[1:2::3]:80/',
protocol: 'non-special:',
username: '',
password: '',
host: '[1:2::3]:80',
hostname: '[1:2::3]',
port: '80',
pathname: '/',
search: '',
hash: '',
},
{
input: 'non-special://[:80/',
base: 'about:blank',
failure: true,
},
{
input: 'blob:https://example.com:443/',
base: 'about:blank',
href: 'blob:https://example.com:443/',
protocol: 'blob:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'https://example.com:443/',
search: '',
hash: '',
},
{
input: 'blob:d3958f5c-0777-0845-9dcf-2cb28783acaf',
base: 'about:blank',
href: 'blob:d3958f5c-0777-0845-9dcf-2cb28783acaf',
protocol: 'blob:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'd3958f5c-0777-0845-9dcf-2cb28783acaf',
search: '',
hash: '',
},
'Invalid IPv4 radix digits',
{
input: 'http://0177.0.0.0189',
base: 'about:blank',
href: 'http://0177.0.0.0189/',
protocol: 'http:',
username: '',
password: '',
host: '0177.0.0.0189',
hostname: '0177.0.0.0189',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://0x7f.0.0.0x7g',
base: 'about:blank',
href: 'http://0x7f.0.0.0x7g/',
protocol: 'http:',
username: '',
password: '',
host: '0x7f.0.0.0x7g',
hostname: '0x7f.0.0.0x7g',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://0X7F.0.0.0X7G',
base: 'about:blank',
href: 'http://0x7f.0.0.0x7g/',
protocol: 'http:',
username: '',
password: '',
host: '0x7f.0.0.0x7g',
hostname: '0x7f.0.0.0x7g',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Invalid IPv4 portion of IPv6 address',
{
input: 'http://[::127.0.0.0.1]',
base: 'about:blank',
failure: true,
},
'Uncompressed IPv6 addresses with 0',
{
input: 'http://[0:1:0:1:0:1:0:1]',
base: 'about:blank',
href: 'http://[0:1:0:1:0:1:0:1]/',
protocol: 'http:',
username: '',
password: '',
host: '[0:1:0:1:0:1:0:1]',
hostname: '[0:1:0:1:0:1:0:1]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://[1:0:1:0:1:0:1:0]',
base: 'about:blank',
href: 'http://[1:0:1:0:1:0:1:0]/',
protocol: 'http:',
username: '',
password: '',
host: '[1:0:1:0:1:0:1:0]',
hostname: '[1:0:1:0:1:0:1:0]',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Percent-encoded query and fragment',
{
input: 'http://example.org/test?\u0022',
base: 'about:blank',
href: 'http://example.org/test?%22',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%22',
hash: '',
},
{
input: 'http://example.org/test?\u0023',
base: 'about:blank',
href: 'http://example.org/test?#',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '',
hash: '',
},
{
input: 'http://example.org/test?\u003C',
base: 'about:blank',
href: 'http://example.org/test?%3C',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%3C',
hash: '',
},
{
input: 'http://example.org/test?\u003E',
base: 'about:blank',
href: 'http://example.org/test?%3E',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%3E',
hash: '',
},
{
input: 'http://example.org/test?\u2323',
base: 'about:blank',
href: 'http://example.org/test?%E2%8C%A3',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%E2%8C%A3',
hash: '',
},
{
input: 'http://example.org/test?%23%23',
base: 'about:blank',
href: 'http://example.org/test?%23%23',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%23%23',
hash: '',
},
/*
{
input: 'http://example.org/test?%GH',
base: 'about:blank',
href: 'http://example.org/test?%GH',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%GH',
hash: '',
},
*/
{
input: 'http://example.org/test?a#%EF',
base: 'about:blank',
href: 'http://example.org/test?a#%EF',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?a',
hash: '#%EF',
},
{
input: 'http://example.org/test?a#%GH',
base: 'about:blank',
href: 'http://example.org/test?a#%GH',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?a',
hash: '#%GH',
},
'URLs that require a non-about:blank base. (Also serve as invalid base tests.)',
{
input: 'a',
base: 'about:blank',
failure: true,
},
{
input: 'a/',
base: 'about:blank',
failure: true,
},
{
input: 'a//',
base: 'about:blank',
failure: true,
},
"Bases that don't fail to parse but fail to be bases",
{
input: 'test-a-colon.html',
base: 'a:',
failure: true,
},
{
input: 'test-a-colon-b.html',
base: 'a:b',
failure: true,
},
'Other base URL tests, that must succeed',
{
input: 'test-a-colon-slash.html',
base: 'a:/',
href: 'a:/test-a-colon-slash.html',
protocol: 'a:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test-a-colon-slash.html',
search: '',
hash: '',
},
{
input: 'test-a-colon-slash-slash.html',
base: 'a://',
href: 'a:///test-a-colon-slash-slash.html',
protocol: 'a:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test-a-colon-slash-slash.html',
search: '',
hash: '',
},
{
input: 'test-a-colon-slash-b.html',
base: 'a:/b',
href: 'a:/test-a-colon-slash-b.html',
protocol: 'a:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test-a-colon-slash-b.html',
search: '',
hash: '',
},
{
input: 'test-a-colon-slash-slash-b.html',
base: 'a://b',
href: 'a://b/test-a-colon-slash-slash-b.html',
protocol: 'a:',
username: '',
password: '',
host: 'b',
hostname: 'b',
port: '',
pathname: '/test-a-colon-slash-slash-b.html',
search: '',
hash: '',
},
'Null code point in fragment',
{
input: 'http://example.org/test?a#b\u0000c',
base: 'about:blank',
href: 'http://example.org/test?a#bc',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?a',
hash: '#bc',
},
];
================================================
FILE: website/build-local.mjs
================================================
import {
isExists, copyBlogPosts, copyBabelStandalone, copyCommonFiles, buildWeb, getCurrentBranch, buildAndCopyCoreJS,
} from './scripts/helpers.mjs';
import { join } from 'node:path';
const BUILD_SRC_DIR = './';
async function hasDocsLocal(srcDir) {
const target = join(srcDir, 'docs/web/docs');
console.log(`Checking if docs exist in "${ target }"...`);
if (!await isExists(target)) {
throw new Error(`Docs not found in "${ target }".`);
}
}
try {
console.time('Finished in');
const targetBranch = await getCurrentBranch(BUILD_SRC_DIR);
const version = { branch: targetBranch, label: targetBranch };
await hasDocsLocal(BUILD_SRC_DIR);
await buildAndCopyCoreJS(version, BUILD_SRC_DIR);
await copyBabelStandalone(BUILD_SRC_DIR);
await copyBlogPosts(BUILD_SRC_DIR);
await copyCommonFiles(BUILD_SRC_DIR);
await buildWeb(targetBranch, BUILD_SRC_DIR, true);
console.timeEnd('Finished in');
} catch (error) {
console.error(error);
}
================================================
FILE: website/build.mjs
================================================
import { expandVersionsConfig, getDefaultVersion } from './scripts/helpers.mjs';
import fm from 'front-matter';
import { JSDOM } from 'jsdom';
import { Marked } from 'marked';
import { gfmHeadingId, getHeadingList } from 'marked-gfm-heading-id';
import markedAlert from 'marked-alert';
import config from './config/config.mjs';
import { argv, fs } from 'zx';
const { copy, mkdir, readFile, readJson, readdir, writeFile } = fs;
const branchArg = argv._.find(item => item.startsWith('branch='));
const BRANCH = branchArg ? branchArg.slice('branch='.length) : undefined;
const LOCAL = argv._.includes('local');
const BASE = LOCAL && BRANCH ? '/core-js/website/dist/' : BRANCH ? `/branches/${ BRANCH }/` : '/';
const DEFAULT_VERSION = await getDefaultVersion(config.versionsFile, BRANCH);
let htmlFileName = '';
let docsMenu = '';
let isBlog = false;
let isDocs = false;
async function getAllMdFiles(dir) {
const entries = await readdir(dir, { withFileTypes: true });
const files = [];
for (const entry of entries) {
const fullPath = path.join(dir, entry.name);
if (entry.isDirectory()) {
const subFiles = await getAllMdFiles(fullPath);
files.push(...subFiles);
} else if (entry.isFile() && entry.name.endsWith('.md')) {
files.push(fullPath);
}
}
return files;
}
async function buildDocsMenu(item) {
if (Object.hasOwn(item, 'children')) {
let result = `${ item.title }`;
for (const child of item.children) {
result += await buildDocsMenu(child);
}
result += '
';
return result;
}
return `${ item.title }`;
}
const docsMenus = [];
const docsMenuItems = [];
async function getDocsMenuItems(version) {
if (docsMenuItems[version]) return docsMenuItems[version];
echo(chalk.green(`Getting menu items from file for version: ${ version }`));
const jsonPath = BRANCH ? `${ config.docsDir }docs/menu.json` : `${ config.docsDir }${ version }/docs/menu.json`;
try {
const docsMenuJson = await readJson(jsonPath);
docsMenuItems[version] = docsMenuJson === '' ? [] : docsMenuJson;
return docsMenuItems[version];
} catch {
echo(chalk.yellow(`Menu JSON file not found: ${ jsonPath }`));
return [];
}
}
async function buildDocsMenuForVersion(version) {
if (docsMenus[version]) return docsMenus[version];
echo(chalk.green(`Building docs menu for version: ${ version }`));
const menuItems = await getDocsMenuItems(version);
if (!menuItems.length) return '';
let menu = '- {versions-menu}
';
for (const item of menuItems) {
menu += await buildDocsMenu(item);
}
menu += '
';
docsMenus[version] = menu;
return menu;
}
function getBundlesPath(version) {
return path.join(config.bundlesPath, version.branch ?? version.tag);
}
async function buildVersionsMenuList(versions, currentVersion, section) {
let versionsMenuHtml = '';
for (const v of versions) {
const activityClass = v.label === currentVersion && !v.default ? ' class="active"' : '';
const defaultBadge = v.default ? ' (default)' : '';
const versionPath = v.default ? '' : `${ v.path }/`;
versionsMenuHtml += `
${ v.label }${ defaultBadge }`;
}
versionsMenuHtml += '
';
if (isBlog || isDocs) {
result += `
---
---
[*Example of usage*](https://tinyurl.com/28zqjbun):
```js
import 'core-js/actual';
Promise.try(() => 42).then(it => console.log(it)); // => 42
Array.from(new Set([1, 2, 3]).union(new Set([3, 4, 5]))); // => [1, 2, 3, 4, 5]
[1, 2].flatMap(it => [it, it]); // => [1, 1, 2, 2]
Iterator.concat([1, 2], function * (i) { while (true) yield i++; }(3))
.drop(1).take(5)
.filter(it => it % 2)
.map(it => it ** 2)
.toArray(); // => [9, 25]
structuredClone(new Set([1, 2, 3])); // => new Set([1, 2, 3])
```
*You can load only required features*:
```js
import 'core-js/actual/promise';
import 'core-js/actual/set';
import 'core-js/actual/iterator';
import 'core-js/actual/array/from';
import 'core-js/actual/array/flat-map';
import 'core-js/actual/structured-clone';
Promise.try(() => 42).then(it => console.log(it)); // => 42
Array.from(new Set([1, 2, 3]).union(new Set([3, 4, 5]))); // => [1, 2, 3, 4, 5]
[1, 2].flatMap(it => [it, it]); // => [1, 1, 2, 2]
Iterator.concat([1, 2], function * (i) { while (true) yield i++; }(3))
.drop(1).take(5)
.filter(it => it % 2)
.map(it => it ** 2)
.toArray(); // => [9, 25]
structuredClone(new Set([1, 2, 3])); // => new Set([1, 2, 3])
```
*Or use it without global namespace pollution*:
```js
import Promise from 'core-js-pure/actual/promise';
import Set from 'core-js-pure/actual/set';
import Iterator from 'core-js-pure/actual/iterator';
import from from 'core-js-pure/actual/array/from';
import flatMap from 'core-js-pure/actual/array/flat-map';
import structuredClone from 'core-js-pure/actual/structured-clone';
Promise.try(() => 42).then(it => console.log(it)); // => 42
from(new Set([1, 2, 3]).union(new Set([3, 4, 5]))); // => [1, 2, 3, 4, 5]
flatMap([1, 2], it => [it, it]); // => [1, 1, 2, 2]
Iterator.concat([1, 2], function * (i) { while (true) yield i++; }(3))
.drop(1).take(5)
.filter(it => it % 2)
.map(it => it ** 2)
.toArray(); // => [9, 25]
structuredClone(new Set([1, 2, 3])); // => new Set([1, 2, 3])
```
### Index
- [Usage](#usage)
- [Installation](#installation)
- [`postinstall` message](#postinstall-message)
- [CommonJS API](#commonjs-api)
- [Babel](#babel)
- [`@babel/polyfill`](#babelpolyfill)
- [`@babel/preset-env`](#babelpreset-env)
- [`@babel/runtime`](#babelruntime)
- [swc](#swc)
- [Configurable level of aggressiveness](#configurable-level-of-aggressiveness)
- [Custom build](#custom-build)
- [Supported engines and compatibility data](#supported-engines-and-compatibility-data)
- [Features](#features)
- [ECMAScript](#ecmascript)
- [ECMAScript: Object](#ecmascript-object)
- [ECMAScript: Function](#ecmascript-function)
- [ECMAScript: Error](#ecmascript-error)
- [ECMAScript: Array](#ecmascript-array)
- [ECMAScript: Iterator](#ecmascript-iterator)
- [ECMAScript: String and RegExp](#ecmascript-string-and-regexp)
- [ECMAScript: Number](#ecmascript-number)
- [ECMAScript: Math](#ecmascript-math)
- [ECMAScript: Date](#ecmascript-date)
- [ECMAScript: Promise](#ecmascript-promise)
- [ECMAScript: Symbol](#ecmascript-symbol)
- [ECMAScript: Collections](#ecmascript-collections)
- [ECMAScript: Explicit Resource Management](#ecmascript-explicit-resource-management)
- [ECMAScript: Typed Arrays](#ecmascript-typed-arrays)
- [ECMAScript: Reflect](#ecmascript-reflect)
- [ECMAScript: JSON](#ecmascript-json)
- [ECMAScript: globalThis](#ecmascript-globalthis)
- [ECMAScript proposals](#ecmascript-proposals)
- [Finished proposals](#finished-proposals)
- [`globalThis`](#globalthis)
- [Relative indexing method](#relative-indexing-method)
- [`Array.prototype.includes`](#arrayprototypeincludes)
- [`Array.prototype.flat` / `Array.prototype.flatMap`](#arrayprototypeflat--arrayprototypeflatmap)
- [`Array` find from last](#array-find-from-last)
- [Change `Array` by copy](#change-array-by-copy)
- [`Array` grouping](#array-grouping)
- [`Array.fromAsync`](#arrayfromasync)
- [`ArrayBuffer.prototype.transfer` and friends](#arraybufferprototypetransfer-and-friends)
- [`Uint8Array` to / from base64 and hex](#uint8array-to--from-base64-and-hex)
- [`Error.isError`](#erroriserror)
- [Explicit Resource Management](#explicit-resource-management)
- [`Float16` methods](#float16-methods)
- [`Iterator` helpers](#iterator-helpers)
- [`Iterator` sequencing](#iterator-sequencing)
- [`Object.values` / `Object.entries`](#objectvalues--objectentries)
- [`Object.fromEntries`](#objectfromentries)
- [`Object.getOwnPropertyDescriptors`](#objectgetownpropertydescriptors)
- [Accessible `Object.prototype.hasOwnProperty`](#accessible-objectprototypehasownproperty)
- [`String` padding](#string-padding)
- [`String.prototype.matchAll`](#stringmatchall)
- [`String.prototype.replaceAll`](#stringreplaceall)
- [`String.prototype.trimStart` / `String.prototype.trimEnd`](#stringprototypetrimstart-stringprototypetrimend)
- [`RegExp` `s` (`dotAll`) flag](#regexp-s-dotall-flag)
- [`RegExp` named capture groups](#regexp-named-capture-groups)
- [`RegExp` escaping](#regexp-escaping)
- [`Promise.allSettled`](#promiseallsettled)
- [`Promise.any`](#promiseany)
- [`Promise.prototype.finally`](#promiseprototypefinally)
- [`Promise.try`](#promisetry)
- [`Promise.withResolvers`](#promisewithresolvers)
- [`Symbol.asyncIterator` for asynchronous iteration](#symbolasynciterator-for-asynchronous-iteration)
- [`Symbol.prototype.description`](#symbolprototypedescription)
- [`JSON.parse` source text access](#jsonparse-source-text-access)
- [Well-formed `JSON.stringify`](#well-formed-jsonstringify)
- [Well-formed unicode strings](#well-formed-unicode-strings)
- [New `Set` methods](#new-set-methods)
- [`Map` upsert](#map-upsert)
- [`Math.sumPrecise`](#mathsumprecise)
- [Stage 3 proposals](#stage-3-proposals)
- [Joint iteration](#joint-iteration)
- [`Symbol.metadata` for decorators metadata proposal](#symbolmetadata-for-decorators-metadata-proposal)
- [Stage 2.7 proposals](#stage-27-proposals)
- [`Iterator` chunking](#iterator-chunking)
- [Stage 2 proposals](#stage-2-proposals)
- [`AsyncIterator` helpers](#asynciterator-helpers)
- [`Iterator.range`](#iteratorrange)
- [`Array.isTemplateObject`](#arrayistemplateobject)
- [`Number.prototype.clamp`](#numberprototypeclamp)
- [`String.dedent`](#stringdedent)
- [`Symbol` predicates](#symbol-predicates)
- [`Symbol.customMatcher` for extractors](#symbolcustommatcher-for-extractors)
- [Stage 1 proposals](#stage-1-proposals)
- [`Observable`](#observable)
- [New collections methods](#new-collections-methods)
- [`.of` and `.from` methods on collection constructors](#of-and-from-methods-on-collection-constructors)
- [`compositeKey` and `compositeSymbol`](#compositekey-and-compositesymbol)
- [`Array` filtering](#array-filtering)
- [`Array` deduplication](#array-deduplication)
- [`DataView` get / set `Uint8Clamped` methods](#dataview-get-set-iint8clamped-methods)
- [`Number.fromString`](#numberfromstring)
- [`String.cooked`](#stringcooked)
- [`String.prototype.codePoints`](#stringprototypecodepoints)
- [`Symbol.customMatcher` for pattern matching](#symbolcustommatcher-for-pattern-matching)
- [Stage 0 proposals](#stage-0-proposals)
- [`Function.prototype.demethodize`](#functionprototypedemethodize)
- [`Function.{ isCallable, isConstructor }`](#function-iscallable-isconstructor-)
- [Pre-stage 0 proposals](#pre-stage-0-proposals)
- [`Reflect` metadata](#reflect-metadata)
- [Web standards](#web-standards)
- [`self`](#self)
- [`structuredClone`](#structuredclone)
- [Base64 utility methods](#base64-utility-methods)
- [`setTimeout` and `setInterval`](#settimeout-and-setinterval)
- [`setImmediate`](#setimmediate)
- [`queueMicrotask`](#queuemicrotask)
- [`URL` and `URLSearchParams`](#url-and-urlsearchparams)
- [`DOMException`](#domexception)
- [iterable DOM collections](#iterable-dom-collections)
- [Iteration helpers](#iteration-helpers)
- [Missing polyfills](#missing-polyfills)
- [Contributing](./CONTRIBUTING.md)
- [Security policy](https://github.com/zloirock/core-js/blob/master/SECURITY.md)
- [Changelog](./CHANGELOG.md)
## Usage[⬆](#index)
### Installation:[⬆](#index)
```sh
// global version
npm install --save core-js@3.49.0
// version without global namespace pollution
npm install --save core-js-pure@3.49.0
// bundled global version
npm install --save core-js-bundle@3.49.0
```
### `postinstall` message[⬆](#index)
The `core-js` project needs your help, so the package shows a message about it after installation. If it causes problems for you, you can disable it:
```sh
ADBLOCK=true npm install
// or
DISABLE_OPENCOLLECTIVE=true npm install
// or
npm install --loglevel silent
```
### CommonJS API[⬆](#index)
You can import only-required-for-you polyfills, like in the examples at the top of `README.md`. Available CommonJS entry points for all polyfilled methods / constructors and namespaces. Just some examples:
```ts
// polyfill all `core-js` features, including early-stage proposals:
import "core-js";
// or:
import "core-js/full";
// polyfill all actual features - stable ES, web standards and stage 3 ES proposals:
import "core-js/actual";
// polyfill only stable features - ES and web standards:
import "core-js/stable";
// polyfill only stable ES features:
import "core-js/es";
// if you want to polyfill `Set`:
// all `Set`-related features, with early-stage ES proposals:
import "core-js/full/set";
// stable required for `Set` ES features, features from web standards and stage 3 ES proposals:
import "core-js/actual/set";
// stable required for `Set` ES features and features from web standards
// (DOM collections iterator in this case):
import "core-js/stable/set";
// only stable ES features required for `Set`:
import "core-js/es/set";
// the same without global namespace pollution:
import Set from "core-js-pure/full/set";
import Set from "core-js-pure/actual/set";
import Set from "core-js-pure/stable/set";
import Set from "core-js-pure/es/set";
// if you want to polyfill just the required methods:
import "core-js/full/set/intersection";
import "core-js/actual/array/find-last";
import "core-js/stable/queue-microtask";
import "core-js/es/array/from";
// polyfill iterator helpers proposal:
import "core-js/proposals/iterator-helpers";
// polyfill all stage 2+ proposals:
import "core-js/stage/2";
```
> [!TIP]
> The usage of the `/actual/` namespace is recommended since it includes all actual JavaScript features and does not include unstable early-stage proposals that are available mainly for experiments.
> [!WARNING]
> - The `modules` path is an internal API, does not inject all required dependencies and can be changed in minor or patch releases. Use it only for a custom build and/or if you know what are you doing.
> - If you use `core-js` with the extension of native objects, recommended to load all `core-js` modules at the top of the entry point of your application, otherwise, you can have conflicts.
> - For example, Google Maps use their own `Symbol.iterator`, conflicting with `Array.from`, `URLSearchParams` and / or something else from `core-js`, see [related issues](https://github.com/zloirock/core-js/search?q=Google+Maps&type=Issues).
> - Such conflicts are also resolvable by discovering and manually adding each conflicting entry from `core-js`.
> - `core-js` is extremely modular and uses a lot of very tiny modules, because of that for usage in browsers bundle up `core-js` instead of a usage loader for each file, otherwise, you will have hundreds of requests.
#### CommonJS and prototype methods without global namespace pollution[⬆](#index)
In the `pure` version, we can't pollute prototypes of native constructors. Because of that, prototype methods transformed into static methods like in examples above. But with transpilers, we can use one more trick - [bind operator and virtual methods](https://github.com/tc39/proposal-bind-operator). Special for that, available `/virtual/` entry points. Example:
```ts
import fill from 'core-js-pure/actual/array/virtual/fill';
import findIndex from 'core-js-pure/actual/array/virtual/find-index';
Array(10)::fill(0).map((a, b) => b * b)::findIndex(it => it && !(it % 8)); // => 4
```
> [!WARNING]
> The bind operator is an early-stage ECMAScript proposal and usage of this syntax can be dangerous.
### Babel[⬆](#index)
`core-js` is integrated with `babel` and is the base for polyfilling-related `babel` features:
#### `@babel/polyfill`[⬆](#index)
[`@babel/polyfill`](https://babeljs.io/docs/usage/polyfill) [**IS** just the import of stable `core-js` features and `regenerator-runtime`](https://github.com/babel/babel/blob/c8bb4500326700e7dc68ce8c4b90b6482c48d82f/packages/babel-polyfill/src/index.js) for generators and async functions, so loading `@babel/polyfill` means loading the global version of `core-js` without ES proposals.
Now it's deprecated in favor of separate inclusion of required parts of `core-js` and `regenerator-runtime` and, for backward compatibility, `@babel/polyfill` is still based on `core-js@2`.
As a full equal of `@babel/polyfill`, you can use the following:
```js
import 'core-js/stable';
import 'regenerator-runtime/runtime';
```
#### `@babel/preset-env`[⬆](#index)
[`@babel/preset-env`](https://github.com/babel/babel/tree/master/packages/babel-preset-env) has `useBuiltIns` option, which optimizes the use of the global version of `core-js`. With `useBuiltIns` option, you should also set `corejs` option to the used version of `core-js`, like `corejs: '3.49'`.
> [!IMPORTANT]
> It is recommended to specify the used minor `core-js` version, like `corejs: '3.49'`, instead of `corejs: 3`, since with `corejs: 3` will not be injected modules which were added in minor `core-js` releases.
---
- `useBuiltIns: 'entry'` replaces imports of `core-js` to import only required for a target environment modules. So, for example,
```js
import 'core-js/stable';
```
with `chrome 71` target will be replaced just to:
```js
import 'core-js/modules/es.array.unscopables.flat';
import 'core-js/modules/es.array.unscopables.flat-map';
import 'core-js/modules/es.object.from-entries';
import 'core-js/modules/web.immediate';
```
It works for all entry points of global version of `core-js` and their combinations, for example for
```js
import 'core-js/es';
import 'core-js/proposals/set-methods';
import 'core-js/full/set/map';
```
with `chrome 71` target you will have as the result:
```js
import 'core-js/modules/es.array.unscopables.flat';
import 'core-js/modules/es.array.unscopables.flat-map';
import 'core-js/modules/es.object.from-entries';
import 'core-js/modules/esnext.set.difference';
import 'core-js/modules/esnext.set.intersection';
import 'core-js/modules/esnext.set.is-disjoint-from';
import 'core-js/modules/esnext.set.is-subset-of';
import 'core-js/modules/esnext.set.is-superset-of';
import 'core-js/modules/esnext.set.map';
import 'core-js/modules/esnext.set.symmetric-difference';
import 'core-js/modules/esnext.set.union';
```
- `useBuiltIns: 'usage'` adds to the top of each file import of polyfills for features used in this file and not supported by target environments, so for:
```js
// first file:
let set = new Set([1, 2, 3]);
```
```js
// second file:
let array = Array.of(1, 2, 3);
```
if the target contains an old environment like `IE 11` we will have something like:
```js
// first file:
import 'core-js/modules/es.array.iterator';
import 'core-js/modules/es.object.to-string';
import 'core-js/modules/es.set';
var set = new Set([1, 2, 3]);
```
```js
// second file:
import 'core-js/modules/es.array.of';
var array = Array.of(1, 2, 3);
```
By default, `@babel/preset-env` with `useBuiltIns: 'usage'` option only polyfills stable features, but you can enable polyfilling of proposals by the `proposals` option, as `corejs: { version: '3.49', proposals: true }`.
> [!IMPORTANT]
> In the case of `useBuiltIns: 'usage'`, you should not add `core-js` imports by yourself, they will be added automatically.
#### `@babel/runtime`[⬆](#index)
[`@babel/runtime`](https://babeljs.io/docs/plugins/transform-runtime/) with `corejs: 3` option simplifies work with the `core-js-pure`. It automatically replaces the usage of modern features from the JS standard library to imports from the version of `core-js` without global namespace pollution, so instead of:
```js
import from from 'core-js-pure/stable/array/from';
import flat from 'core-js-pure/stable/array/flat';
import Set from 'core-js-pure/stable/set';
import Promise from 'core-js-pure/stable/promise';
from(new Set([1, 2, 3, 2, 1]));
flat([1, [2, 3], [4, [5]]], 2);
Promise.resolve(32).then(x => console.log(x));
```
you can write just:
```js
Array.from(new Set([1, 2, 3, 2, 1]));
[1, [2, 3], [4, [5]]].flat(2);
Promise.resolve(32).then(x => console.log(x));
```
By default, `@babel/runtime` only polyfills stable features, but like in `@babel/preset-env`, you can enable polyfilling of proposals by `proposals` option, as `corejs: { version: 3, proposals: true }`.
> [!WARNING]
> If you use `@babel/preset-env` and `@babel/runtime` together, use `corejs` option only in one place since it's duplicate functionality and will cause conflicts.
### swc[⬆](#index)
Fast JavaScript transpiler `swc` [contains integration with `core-js`](https://swc.rs/docs/configuration/supported-browsers), that optimizes work with the global version of `core-js`. [Like `@babel/preset-env`](#babelpreset-env), it has 2 modes: `usage` and `entry`, but `usage` mode still works not so well as in `babel`. Example of configuration in `.swcrc`:
```json
{
"env": {
"targets": "> 0.25%, not dead",
"mode": "entry",
"coreJs": "3.49"
}
}
```
### Configurable level of aggressiveness[⬆](#index)
By default, `core-js` sets polyfills only when they are required. That means that `core-js` checks if a feature is available and works correctly or not and if it has no problems, `core-js` uses native implementation.
But sometimes `core-js` feature detection could be too strict for your case. For example, `Promise` constructor requires the support of unhandled rejection tracking and `@@species`.
Sometimes we could have an inverse problem - a knowingly broken environment with problems not covered by `core-js` feature detection.
For those cases, we could redefine this behavior for certain polyfills:
```js
const configurator = require('core-js/configurator');
configurator({
useNative: ['Promise'], // polyfills will be used only if natives are completely unavailable
usePolyfill: ['Array.from', 'String.prototype.padEnd'], // polyfills will be used anyway
useFeatureDetection: ['Map', 'Set'], // default behavior
});
require('core-js/actual');
```
It does not work with some features. Also, if you change the default behavior, even `core-js` internals may not work correctly.
### Custom build[⬆](#index)
For some cases could be useful to exclude some `core-js` features or generate a polyfill for target engines. You could use [`core-js-builder`](/packages/core-js-builder) package for that.
## Supported engines and compatibility data[⬆](#index)
`core-js` tries to support all possible JS engines and environments with ES3 support. Some features have a higher lower bar - for example, *some* accessors can properly work only from ES5, promises require a way to set a microtask or a task, etc.
However, I have no possibility to test `core-js` absolutely everywhere - for example, testing in IE7- and some other ancient was stopped. The list of definitely supported engines you can see in the compatibility table by the link below. [Write](https://github.com/zloirock/core-js/issues) if you have issues or questions with the support of any engine.
`core-js` project provides (as [`core-js-compat`](/packages/core-js-compat) package) all required data about the necessity of `core-js` modules, entry points, and tools for work with it - it's useful for integration with tools like `babel` or `swc`. If you wanna help, you could take a look at the related section of [`CONTRIBUTING.md`](/CONTRIBUTING.md#how-to-update-core-js-compat-data). The visualization of compatibility data and the browser tests runner is available [here](http://zloirock.github.io/core-js/master/compat/), the example:
## Features:[⬆](#index)
[*CommonJS entry points:*](#commonjs-api)
```
core-js(-pure)
```
### ECMAScript[⬆](#index)
[*CommonJS entry points:*](#commonjs-api)
```
core-js(-pure)/es
```
#### ECMAScript: Object[⬆](#index)
Modules [`es.object.assign`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.assign.js), [`es.object.create`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.create.js), [`es.object.define-getter`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.define-getter.js), [`es.object.define-property`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.define-property.js), [`es.object.define-properties`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.define-properties.js), [`es.object.define-setter`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.define-setter.js), [`es.object.entries`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.entries.js), [`es.object.freeze`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.freeze.js), [`es.object.from-entries`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.from-entries.js), [`es.object.get-own-property-descriptor`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.get-own-property-descriptor.js), [`es.object.get-own-property-descriptors`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.get-own-property-descriptors.js), [`es.object.get-own-property-names`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.get-own-property-names.js), [`es.object.get-prototype-of`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.get-prototype-of.js), [`es.object.group-by`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.group-by.js), [`es.object.has-own`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.has-own.js), [`es.object.is`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.is.js), [`es.object.is-extensible`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.is-extensible.js), [`es.object.is-frozen`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.is-frozen.js), [`es.object.is-sealed`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.is-sealed.js), [`es.object.keys`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.keys.js), [`es.object.lookup-setter`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.lookup-setter.js), [`es.object.lookup-getter`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.lookup-getter.js), [`es.object.prevent-extensions`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.prevent-extensions.js), [`es.object.proto`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.proto.js), [`es.object.to-string`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.to-string.js), [`es.object.seal`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.seal.js), [`es.object.set-prototype-of`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.set-prototype-of.js), [`es.object.values`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.object.values.js).
```ts
class Object {
toString(): string; // ES2015+ fix: @@toStringTag support
__defineGetter__(property: PropertyKey, getter: Function): void;
__defineSetter__(property: PropertyKey, setter: Function): void;
__lookupGetter__(property: PropertyKey): Function | void;
__lookupSetter__(property: PropertyKey): Function | void;
__proto__: Object | null; // required a way setting of prototype - will not in IE10-, it's for modern engines like Deno
static assign(target: Object, ...sources: Array