file_path
stringlengths 3
280
| file_language
stringclasses 66
values | content
stringlengths 1
1.04M
| repo_name
stringlengths 5
92
| repo_stars
int64 0
154k
| repo_description
stringlengths 0
402
| repo_primary_language
stringclasses 108
values | developer_username
stringlengths 1
25
| developer_name
stringlengths 0
30
| developer_company
stringlengths 0
82
|
|---|---|---|---|---|---|---|---|---|---|
tests/unit-global/es.array.with.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
QUnit.test('Array#with', assert => {
const { with: withAt } = Array.prototype;
assert.isFunction(withAt);
assert.arity(withAt, 2);
// assert.name(withAt, 'with');
assert.looksNative(withAt);
assert.nonEnumerable(Array.prototype, 'with');
let array = [1, 2, 3, 4, 5];
assert.notSame(array.with(2, 1), array, 'immutable');
assert.deepEqual([1, 2, 3, 4, 5].with(2, 6), [1, 2, 6, 4, 5]);
assert.deepEqual([1, 2, 3, 4, 5].with(-2, 6), [1, 2, 3, 6, 5]);
assert.deepEqual([1, 2, 3, 4, 5].with('1', 6), [1, 6, 3, 4, 5]);
assert.throws(() => [1, 2, 3, 4, 5].with(5, 6), RangeError);
assert.throws(() => [1, 2, 3, 4, 5].with(-6, 6), RangeError);
if (STRICT) {
assert.throws(() => withAt.call(null, 1, 2), TypeError);
assert.throws(() => withAt.call(undefined, 1, 2), TypeError);
}
array = [1, 2];
// eslint-disable-next-line object-shorthand -- constructor
array.constructor = { [Symbol.species]: function () {
return { foo: 1 };
} };
assert.true(array.with(1, 2) instanceof Array, 'non-generic');
// Incorrect exception thrown when index coercion fails in Firefox
function CustomError() { /* empty */ }
const index = { valueOf() { throw new CustomError(); } };
assert.throws(() => withAt.call([], index, null), CustomError, 'incorrect error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.async-disposable-stack.constructor.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
QUnit.test('AsyncDisposableStack constructor', assert => {
assert.isFunction(AsyncDisposableStack);
assert.arity(AsyncDisposableStack, 0);
assert.name(AsyncDisposableStack, 'AsyncDisposableStack');
assert.looksNative(AsyncDisposableStack);
assert.throws(() => AsyncDisposableStack(), 'throws w/o `new`');
assert.true(new AsyncDisposableStack() instanceof AsyncDisposableStack);
assert.same(AsyncDisposableStack.prototype.constructor, AsyncDisposableStack);
});
QUnit.test('AsyncDisposableStack#disposeAsync', assert => {
assert.isFunction(AsyncDisposableStack.prototype.disposeAsync);
assert.arity(AsyncDisposableStack.prototype.disposeAsync, 0);
assert.name(AsyncDisposableStack.prototype.disposeAsync, 'disposeAsync');
assert.looksNative(AsyncDisposableStack.prototype.disposeAsync);
assert.nonEnumerable(AsyncDisposableStack.prototype, 'disposeAsync');
});
QUnit.test('AsyncDisposableStack#use', assert => {
assert.isFunction(AsyncDisposableStack.prototype.use);
assert.arity(AsyncDisposableStack.prototype.use, 1);
assert.name(AsyncDisposableStack.prototype.use, 'use');
assert.looksNative(AsyncDisposableStack.prototype.use);
assert.nonEnumerable(AsyncDisposableStack.prototype, 'use');
let result = '';
const stack = new AsyncDisposableStack();
const resource = {
[Symbol.asyncDispose]() {
result += '1';
assert.same(this, resource);
assert.same(arguments.length, 0);
},
};
assert.same(stack.use(resource), resource);
return stack.disposeAsync().then(it => {
assert.same(it, undefined);
assert.same(result, '1');
});
});
QUnit.test('AsyncDisposableStack#adopt', assert => {
assert.isFunction(AsyncDisposableStack.prototype.adopt);
assert.arity(AsyncDisposableStack.prototype.adopt, 2);
assert.name(AsyncDisposableStack.prototype.adopt, 'adopt');
assert.looksNative(AsyncDisposableStack.prototype.adopt);
assert.nonEnumerable(AsyncDisposableStack.prototype, 'adopt');
let result = '';
const stack = new AsyncDisposableStack();
const resource = {};
assert.same(stack.adopt(resource, function (arg) {
result += '1';
if (STRICT) assert.same(this, undefined);
assert.same(arguments.length, 1);
assert.same(arg, resource);
}), resource);
return stack.disposeAsync().then(it => {
assert.same(it, undefined);
assert.same(result, '1');
});
});
QUnit.test('AsyncDisposableStack#defer', assert => {
assert.isFunction(AsyncDisposableStack.prototype.defer);
assert.arity(AsyncDisposableStack.prototype.defer, 1);
assert.name(AsyncDisposableStack.prototype.defer, 'defer');
assert.looksNative(AsyncDisposableStack.prototype.defer);
assert.nonEnumerable(AsyncDisposableStack.prototype, 'defer');
let result = '';
const stack = new AsyncDisposableStack();
assert.same(stack.defer(function () {
result += '1';
if (STRICT) assert.same(this, undefined);
assert.same(arguments.length, 0);
}), undefined);
return stack.disposeAsync().then(it => {
assert.same(it, undefined);
assert.same(result, '1');
});
});
QUnit.test('AsyncDisposableStack#move', assert => {
assert.isFunction(AsyncDisposableStack.prototype.move);
assert.arity(AsyncDisposableStack.prototype.move, 0);
assert.name(AsyncDisposableStack.prototype.move, 'move');
assert.looksNative(AsyncDisposableStack.prototype.move);
assert.nonEnumerable(AsyncDisposableStack.prototype, 'move');
let result = '';
const stack1 = new AsyncDisposableStack();
stack1.defer(() => result += '2');
stack1.defer(() => result += '1');
const stack2 = stack1.move();
assert.true(stack1.disposed);
return stack2.disposeAsync().then(() => {
assert.same(result, '12');
});
});
QUnit.test('AsyncDisposableStack#@@asyncDispose', assert => {
assert.same(AsyncDisposableStack.prototype[Symbol.asyncDispose], AsyncDisposableStack.prototype.disposeAsync);
});
QUnit.test('AsyncDisposableStack#@@toStringTag', assert => {
assert.same(AsyncDisposableStack.prototype[Symbol.toStringTag], 'AsyncDisposableStack', '@@toStringTag');
});
QUnit.test('AsyncDisposableStack#1', assert => {
let result = '';
const stack = new AsyncDisposableStack();
stack.use({ [Symbol.asyncDispose]: () => result += '6' });
stack.adopt({}, () => result += '5');
stack.defer(() => result += '4');
stack.use({ [Symbol.asyncDispose]: () => Promise.resolve(result += '3') });
stack.adopt({}, () => Promise.resolve(result += '2'));
stack.defer(() => Promise.resolve(result += '1'));
assert.false(stack.disposed);
return stack.disposeAsync().then(it => {
assert.same(it, undefined);
assert.same(result, '123456');
assert.true(stack.disposed);
return stack.disposeAsync();
}).then(it => {
assert.same(it, undefined);
});
});
QUnit.test('AsyncDisposableStack#2', assert => {
let result = '';
const stack = new AsyncDisposableStack();
stack.use({ [Symbol.asyncDispose]: () => result += '6' });
stack.adopt({}, () => { throw new Error(5); });
stack.defer(() => result += '4');
stack.use({ [Symbol.asyncDispose]: () => Promise.resolve(result += '3') });
stack.adopt({}, () => Promise.resolve(result += '2'));
stack.defer(() => Promise.resolve(result += '1'));
return stack.disposeAsync().then(() => {
assert.avoid();
}, error => {
assert.same(result, '12346');
assert.true(error instanceof Error);
assert.same(error.message, '5');
});
});
QUnit.test('AsyncDisposableStack#3', assert => {
let result = '';
const stack = new AsyncDisposableStack();
stack.use({ [Symbol.asyncDispose]: () => result += '6' });
stack.adopt({}, () => { throw new Error(5); });
stack.defer(() => result += '4');
stack.use({ [Symbol.asyncDispose]: () => Promise.reject(new Error(3)) });
stack.adopt({}, () => Promise.resolve(result += '2'));
stack.defer(() => Promise.resolve(result += '1'));
return stack.disposeAsync().then(() => {
assert.avoid();
}, error => {
assert.same(result, '1246');
assert.true(error instanceof SuppressedError);
assert.same(error.error.message, '5');
assert.same(error.suppressed.message, '3');
});
});
// https://github.com/tc39/proposal-explicit-resource-management/issues/256
QUnit.test('AsyncDisposableStack#256', assert => {
const resume = assert.async();
assert.expect(1);
let called = false;
const stack = new AsyncDisposableStack();
const neverResolves = new Promise(() => { /* empty */ });
stack.use({ [Symbol.dispose]() { return neverResolves; } });
stack.disposeAsync().then(() => {
called = true;
assert.required('It should be called');
resume();
});
setTimeout(() => called || resume(), 3e3);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.async-iterator.async-dispose.js
|
JavaScript
|
const { create } = Object;
QUnit.test('AsyncIterator#@@asyncDispose', assert => {
const asyncDispose = AsyncIterator.prototype[Symbol.asyncDispose];
assert.isFunction(asyncDispose);
assert.arity(asyncDispose, 0);
assert.looksNative(asyncDispose);
return create(AsyncIterator.prototype)[Symbol.asyncDispose]().then(result => {
assert.same(result, undefined);
}).then(() => {
let called = false;
const iterator2 = create(AsyncIterator.prototype);
iterator2.return = function () {
called = true;
assert.same(this, iterator2);
return 7;
};
return iterator2[Symbol.asyncDispose]().then(result => {
assert.same(result, undefined);
assert.true(called);
});
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.data-view.js
|
JavaScript
|
import { DESCRIPTORS, NATIVE } from '../helpers/constants.js';
QUnit.test('DataView', assert => {
assert.same(DataView, Object(DataView), 'is object'); // in Safari 5 typeof DataView is 'object'
if (NATIVE) assert.arity(DataView, 3); // 1 in IE11
if (NATIVE) assert.name(DataView, 'DataView'); // Safari 5 bug
if (NATIVE) assert.looksNative(DataView); // Safari 5 bug
let dataview = new DataView(new ArrayBuffer(8));
assert.same(dataview.byteOffset, 0, '#byteOffset, passed buffer');
assert.same(dataview.byteLength, 8, '#byteLength, passed buffer');
dataview = new DataView(new ArrayBuffer(16), 8);
assert.same(dataview.byteOffset, 8, '#byteOffset, passed buffer and byteOffset');
assert.same(dataview.byteLength, 8, '#byteLength, passed buffer and byteOffset');
dataview = new DataView(new ArrayBuffer(24), 8, 8);
assert.same(dataview.byteOffset, 8, '#byteOffset, passed buffer, byteOffset and length');
assert.same(dataview.byteLength, 8, '#byteLength, passed buffer, byteOffset and length');
if (NATIVE) {
// fails in IE / MS Edge
dataview = new DataView(new ArrayBuffer(8), undefined);
assert.same(dataview.byteOffset, 0, '#byteOffset, passed buffer and undefined');
assert.same(dataview.byteLength, 8, '#byteLength, passed buffer and undefined');
// fails in IE / MS Edge
dataview = new DataView(new ArrayBuffer(16), 8, undefined);
assert.same(dataview.byteOffset, 8, '#byteOffset, passed buffer, byteOffset and undefined');
assert.same(dataview.byteLength, 8, '#byteLength, passed buffer, byteOffset and undefined');
// fails in IE10
dataview = new DataView(new ArrayBuffer(8), 8);
assert.same(dataview.byteOffset, 8, '#byteOffset, passed buffer and byteOffset with buffer length');
assert.same(dataview.byteLength, 0, '#byteLength, passed buffer and byteOffset with buffer length');
// TypeError in IE + FF bug - TypeError instead of RangeError
assert.throws(() => new DataView(new ArrayBuffer(8), -1), RangeError, 'If offset < 0, throw a RangeError exception');
assert.throws(() => new DataView(new ArrayBuffer(8), 16), RangeError, 'If newByteLength < 0, throw a RangeError exception');
assert.throws(() => new DataView(new ArrayBuffer(24), 8, 24), RangeError, 'If offset+newByteLength > bufferByteLength, throw a RangeError exception');
// Android ~ 4.0
assert.throws(() => DataView(1), TypeError, 'throws without `new`');
assert.throws(() => DataView(1), 'throws without `new`');
} else {
// FF bug - TypeError instead of RangeError
assert.throws(() => new DataView(new ArrayBuffer(8), -1), 'If offset < 0, throw a RangeError exception');
assert.throws(() => new DataView(new ArrayBuffer(8), 16), 'If newByteLength < 0, throw a RangeError exception');
assert.throws(() => new DataView(new ArrayBuffer(24), 8, 24), 'If offset+newByteLength > bufferByteLength, throw a RangeError exception');
}
dataview = new DataView(new ArrayBuffer(8));
dataview.setUint32(0, 0x12345678);
assert.same(dataview.getUint32(0), 0x12345678, 'big endian/big endian');
dataview.setUint32(0, 0x12345678, true);
assert.same(dataview.getUint32(0, true), 0x12345678, 'little endian/little endian');
dataview.setUint32(0, 0x12345678, true);
assert.same(dataview.getUint32(0), 0x78563412, 'little endian/big endian');
dataview.setUint32(0, 0x12345678);
assert.same(dataview.getUint32(0, true), 0x78563412, 'big endian/little endian');
assert.throws(() => new DataView({}), 'non-ArrayBuffer argument, object');
assert.throws(() => new DataView('foo'), 'non-ArrayBuffer argument, string');
});
if (DESCRIPTORS) {
QUnit.test('DataView accessors', assert => {
const uint8array = new Uint8Array(8);
const dataview = new DataView(uint8array.buffer);
assert.arrayEqual(uint8array, [0, 0, 0, 0, 0, 0, 0, 0]);
dataview.setUint8(0, 255);
assert.arrayEqual(uint8array, [0xFF, 0, 0, 0, 0, 0, 0, 0]);
dataview.setInt8(1, -1);
assert.arrayEqual(uint8array, [0xFF, 0xFF, 0, 0, 0, 0, 0, 0]);
dataview.setUint16(2, 0x1234);
assert.arrayEqual(uint8array, [0xFF, 0xFF, 0x12, 0x34, 0, 0, 0, 0]);
dataview.setInt16(4, -1);
assert.arrayEqual(uint8array, [0xFF, 0xFF, 0x12, 0x34, 0xFF, 0xFF, 0, 0]);
dataview.setUint32(1, 0x12345678);
assert.arrayEqual(uint8array, [0xFF, 0x12, 0x34, 0x56, 0x78, 0xFF, 0, 0]);
dataview.setInt32(4, -2023406815);
assert.arrayEqual(uint8array, [0xFF, 0x12, 0x34, 0x56, 0x87, 0x65, 0x43, 0x21]);
dataview.setFloat32(2, 1.2e+38);
assert.arrayEqual(uint8array, [0xFF, 0x12, 0x7E, 0xB4, 0x8E, 0x52, 0x43, 0x21]);
dataview.setFloat64(0, -1.2345678e+301);
assert.arrayEqual(uint8array, [0xFE, 0x72, 0x6F, 0x51, 0x5F, 0x61, 0x77, 0xE5]);
const data = [0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87];
for (let i = 0, { length } = data; i < length; ++i) {
uint8array[i] = data[i];
}
assert.same(dataview.getUint8(0), 128);
assert.same(dataview.getInt8(1), -127);
assert.same(dataview.getUint16(2), 33411);
assert.same(dataview.getInt16(3), -31868);
assert.same(dataview.getUint32(4), 2223343239);
assert.same(dataview.getInt32(2), -2105310075);
assert.same(dataview.getFloat32(2), -1.932478247535851e-37);
assert.same(dataview.getFloat64(0), -3.116851295377095e-306);
});
QUnit.test('DataView endian', assert => {
const { buffer } = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7]);
let dataview = new DataView(buffer);
assert.same(dataview.byteLength, 8, 'buffer');
assert.same(dataview.byteOffset, 0, 'buffer');
assert.throws(() => dataview.getUint8(-2));
assert.throws(() => dataview.getUint8(8), 'bounds for buffer');
assert.throws(() => dataview.setUint8(-2, 0), 'bounds for buffer');
assert.throws(() => dataview.setUint8(8, 0), 'bounds for buffer');
dataview = new DataView(buffer, 2);
assert.same(dataview.byteLength, 6, 'buffer, byteOffset');
assert.same(dataview.byteOffset, 2, 'buffer, byteOffset');
assert.same(dataview.getUint8(5), 7, 'buffer, byteOffset');
assert.throws(() => dataview.getUint8(-2), 'bounds for buffer, byteOffset');
assert.throws(() => dataview.getUint8(6), 'bounds for buffer, byteOffset');
assert.throws(() => dataview.setUint8(-2, 0), 'bounds for buffer, byteOffset');
assert.throws(() => dataview.setUint8(6, 0), 'bounds for buffer, byteOffset');
assert.throws(() => new DataView(buffer, -1), 'invalid byteOffset');
assert.throws(() => new DataView(buffer, 9), 'invalid byteOffset');
dataview = new DataView(buffer, 2, 4);
assert.same(dataview.byteLength, 4, 'buffer, byteOffset, length');
assert.same(dataview.byteOffset, 2, 'buffer, byteOffset, length');
assert.same(dataview.getUint8(3), 5, 'buffer, byteOffset, length');
assert.throws(() => dataview.getUint8(-2), 'bounds for buffer, byteOffset, length');
assert.throws(() => dataview.getUint8(4), 'bounds for buffer, byteOffset, length');
assert.throws(() => dataview.setUint8(-2, 0), 'bounds for buffer, byteOffset, length');
assert.throws(() => dataview.setUint8(4, 0), 'bounds for buffer, byteOffset, length');
assert.throws(() => new DataView(buffer, 0, 9), 'invalid byteOffset+length');
assert.throws(() => new DataView(buffer, 8, 1), 'invalid byteOffset+length');
assert.throws(() => new DataView(buffer, 9, -1), 'invalid byteOffset+length');
});
}
const types = ['Uint8', 'Int8', 'Uint16', 'Int16', 'Uint32', 'Int32', 'Float32', 'Float64'];
for (const type of types) {
const GETTER = `get${ type }`;
const SETTER = `set${ type }`;
QUnit.test(`DataView#${ GETTER }`, assert => {
assert.isFunction(DataView.prototype[GETTER]);
NATIVE && assert.arity(DataView.prototype[GETTER], 1);
assert.same(new DataView(new ArrayBuffer(8))[GETTER](0), 0, 'returns element');
});
QUnit.test(`DataView#${ SETTER }`, assert => {
assert.isFunction(DataView.prototype[SETTER]);
NATIVE && assert.arity(DataView.prototype[SETTER], 2);
assert.same(new DataView(new ArrayBuffer(8))[SETTER](0, 0), undefined, 'void');
});
}
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.data-view.set-float16.js
|
JavaScript
|
QUnit.test('DataView.prototype.{ getFloat16, setFloat16 }', assert => {
const { getFloat16, setFloat16 } = DataView.prototype;
assert.isFunction(getFloat16);
assert.arity(getFloat16, 1);
assert.name(getFloat16, 'getFloat16');
assert.isFunction(setFloat16);
assert.arity(setFloat16, 2);
assert.name(setFloat16, 'setFloat16');
assert.same(new DataView(new ArrayBuffer(8)).setFloat16(0, 0), undefined, 'void');
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0b0000000000000000, 0],
[0b1000000000000000, -0],
[0b0011110000000000, 1],
[0b1011110000000000, -1],
[0b0100001001001000, 3.140625],
[0b0000001000000000, 0.000030517578125],
[0b0111101111111111, 65504],
[0b1111101111111111, -65504],
[0b0000000000000001, 2 ** -24],
[0b1000000000000001, -(2 ** -24)],
// [0b0111110000000001, NaN], <- what NaN representation should be used?
[0b0111110000000000, Infinity],
[0b1111110000000000, -Infinity],
// normal values in (0, 1) — regression test for floor vs truncation of log2
[0b0011100000000000, 0.5],
[0b0011101000000000, 0.75],
[0b0011010000000000, 0.25],
[0b0011000000000000, 0.125],
];
const buffer = new ArrayBuffer(2);
const view = new DataView(buffer);
for (const [bin, f16] of data) for (const LE of [false, true]) {
view.setUint16(0, bin, LE);
assert.same(view.getFloat16(0, LE), f16, `DataView.prototype.setUint16 + DataView.prototype.getFloat16, LE: ${ LE }, ${ toString(bin) } -> ${ toString(f16) }`);
view.setFloat16(0, f16, LE);
assert.same(view.getUint16(0, LE), bin, `DataView.prototype.setFloat16 + DataView.prototype.getUint16, LE: ${ LE }, ${ toString(f16) } -> ${ toString(bin) }`);
assert.same(view.getFloat16(0, LE), f16, `DataView.prototype.setFloat16 + DataView.prototype.getFloat16, LE: ${ LE }, ${ toString(f16) }`);
}
const MAX_FLOAT16 = 65504;
const MIN_FLOAT16 = 2 ** -24;
const conversions = [
[1.337, 1.3369140625],
[0.499994, 0.5],
[7.9999999, 8],
[MAX_FLOAT16, MAX_FLOAT16],
[-MAX_FLOAT16, -MAX_FLOAT16],
[MIN_FLOAT16, MIN_FLOAT16],
[-MIN_FLOAT16, -MIN_FLOAT16],
[MIN_FLOAT16 / 2, 0],
[-MIN_FLOAT16 / 2, -0],
[2.980232238769531911744490042422139897126953655970282852649688720703125e-8, MIN_FLOAT16],
[-2.980232238769531911744490042422139897126953655970282852649688720703125e-8, -MIN_FLOAT16],
// normal values in (0, 1) — regression test for floor vs truncation of log2
[0.3, 0.300048828125],
[0.7, 0.7001953125],
[-0.3, -0.300048828125],
[-0.7, -0.7001953125],
];
for (const [from, to] of conversions) for (const LE of [false, true]) {
view.setFloat16(0, from, LE);
assert.same(view.getFloat16(0, LE), to, `DataView.prototype.setFloat16 + DataView.prototype.getFloat16, LE: ${ LE }, ${ toString(from) } -> ${ toString(to) }`);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.date.get-year.js
|
JavaScript
|
QUnit.test('Date#getYear', assert => {
const { getYear } = Date.prototype;
assert.isFunction(getYear);
assert.arity(getYear, 0);
assert.name(getYear, 'getYear');
assert.looksNative(getYear);
assert.nonEnumerable(Date.prototype, 'getYear');
const date = new Date();
assert.same(date.getYear(), date.getFullYear() - 1900);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.date.now.js
|
JavaScript
|
QUnit.test('Date.now', assert => {
const { now } = Date;
assert.isFunction(now);
assert.arity(now, 0);
assert.name(now, 'now');
assert.looksNative(now);
assert.nonEnumerable(Date, 'now');
assert.same(typeof now(), 'number', 'typeof');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.date.set-year.js
|
JavaScript
|
QUnit.test('Date#setYear', assert => {
const { setYear } = Date.prototype;
assert.isFunction(setYear);
assert.arity(setYear, 1);
assert.name(setYear, 'setYear');
assert.looksNative(setYear);
assert.nonEnumerable(Date.prototype, 'setYear');
const date = new Date();
date.setYear(1);
assert.same(date.getFullYear(), 1901);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.date.to-gmt-string.js
|
JavaScript
|
QUnit.test('Date#toGMTString', assert => {
const { toGMTString } = Date.prototype;
assert.isFunction(toGMTString);
assert.arity(toGMTString, 0);
// assert.name(toGMTString, 'toUTCString'); // at least old WebKit
assert.looksNative(toGMTString);
assert.nonEnumerable(Date.prototype, 'toGMTString');
// assert.same(toGMTString, Date.prototype.toUTCString); // at least old WebKit
const date = new Date();
assert.same(date.toGMTString(), date.toUTCString());
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.date.to-iso-string.js
|
JavaScript
|
QUnit.test('Date#toISOString', assert => {
const { toISOString } = Date.prototype;
assert.isFunction(toISOString);
assert.arity(toISOString, 0);
assert.name(toISOString, 'toISOString');
assert.looksNative(toISOString);
assert.nonEnumerable(Date.prototype, 'toISOString');
assert.same(new Date(0).toISOString(), '1970-01-01T00:00:00.000Z');
assert.same(new Date(1e12 + 1).toISOString(), '2001-09-09T01:46:40.001Z');
assert.same(new Date(-5e13 - 1).toISOString(), '0385-07-25T07:06:39.999Z');
const future = new Date(1e15 + 1).toISOString();
const properFuture = future === '+033658-09-27T01:46:40.001Z' || future === '33658-09-27T01:46:40.001Z';
assert.true(properFuture);
const prehistoric = new Date(-1e15 + 1).toISOString();
const properPrehistoric = prehistoric === '-029719-04-05T22:13:20.001Z' || prehistoric === '-29719-04-05T22:13:20.001Z';
assert.true(properPrehistoric);
assert.throws(() => new Date(NaN).toISOString(), RangeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.date.to-json.js
|
JavaScript
|
QUnit.test('Date#toJSON', assert => {
const { toJSON } = Date.prototype;
assert.isFunction(toJSON);
assert.arity(toJSON, 1);
assert.name(toJSON, 'toJSON');
assert.looksNative(toJSON);
assert.nonEnumerable(Date.prototype, 'toJSON');
const date = new Date();
assert.same(date.toJSON(), date.toISOString(), 'base');
assert.same(new Date(NaN).toJSON(), null, 'not finite');
assert.same(toJSON.call({
toISOString() {
return 42;
},
}), 42, 'generic');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.date.to-primitive.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
QUnit.test('Date#@@toPrimitive', assert => {
const toPrimitive = Date.prototype[Symbol.toPrimitive];
assert.isFunction(toPrimitive);
assert.arity(toPrimitive, 1);
assert.nonEnumerable(Date.prototype, Symbol.toPrimitive);
const date = new Date();
assert.same(date[Symbol.toPrimitive]('string'), date.toString(), 'generic, hint "string"');
assert.same(date[Symbol.toPrimitive]('number'), +date, 'generic, hint "number"');
assert.same(date[Symbol.toPrimitive]('default'), date.toString(), 'generic, hint "default"');
assert.same(toPrimitive.call(Object(2), 'string'), '2', 'generic, hint "string"');
assert.same(toPrimitive.call(Object(2), 'number'), 2, 'generic, hint "number"');
assert.same(toPrimitive.call(Object(2), 'default'), '2', 'generic, hint "default"');
let data = [undefined, '', 'foo', { toString() { return 'string'; } }];
for (const value of data) {
assert.throws(() => new Date()[Symbol.toPrimitive](value), TypeError, `throws on ${ value } as a hint`);
}
if (STRICT) {
data = [1, false, 'string', null, undefined];
for (const value of data) {
assert.throws(() => toPrimitive.call(value, 'string'), TypeError, `throws on ${ value } as \`this\``);
}
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.date.to-string.js
|
JavaScript
|
QUnit.test('Date#toString', assert => {
const { toString } = Date.prototype;
assert.isFunction(toString);
assert.arity(toString, 0);
assert.name(toString, 'toString');
assert.looksNative(toString);
assert.nonEnumerable(Date.prototype, 'toString');
assert.same(String(new Date(NaN)), 'Invalid Date');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.disposable-stack.constructor.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
QUnit.test('DisposableStack constructor', assert => {
assert.isFunction(DisposableStack);
assert.arity(DisposableStack, 0);
assert.name(DisposableStack, 'DisposableStack');
assert.looksNative(DisposableStack);
assert.throws(() => DisposableStack(), 'throws w/o `new`');
assert.true(new DisposableStack() instanceof DisposableStack);
assert.same(DisposableStack.prototype.constructor, DisposableStack);
});
QUnit.test('DisposableStack#dispose', assert => {
assert.isFunction(DisposableStack.prototype.dispose);
assert.arity(DisposableStack.prototype.dispose, 0);
assert.name(DisposableStack.prototype.dispose, 'dispose');
assert.looksNative(DisposableStack.prototype.dispose);
assert.nonEnumerable(DisposableStack.prototype, 'dispose');
});
QUnit.test('DisposableStack#use', assert => {
assert.isFunction(DisposableStack.prototype.use);
assert.arity(DisposableStack.prototype.use, 1);
assert.name(DisposableStack.prototype.use, 'use');
assert.looksNative(DisposableStack.prototype.use);
assert.nonEnumerable(DisposableStack.prototype, 'use');
let result = '';
const stack1 = new DisposableStack();
const resource = {
[Symbol.dispose]() {
result += '1';
assert.same(this, resource);
assert.same(arguments.length, 0);
},
};
assert.same(stack1.use(resource), resource);
assert.same(stack1.dispose(), undefined);
assert.same(result, '1');
});
QUnit.test('DisposableStack#adopt', assert => {
assert.isFunction(DisposableStack.prototype.adopt);
assert.arity(DisposableStack.prototype.adopt, 2);
assert.name(DisposableStack.prototype.adopt, 'adopt');
assert.looksNative(DisposableStack.prototype.adopt);
assert.nonEnumerable(DisposableStack.prototype, 'adopt');
let result = '';
const stack = new DisposableStack();
const resource = {};
assert.same(stack.adopt(resource, function (arg) {
result += '1';
if (STRICT) assert.same(this, undefined);
assert.same(arguments.length, 1);
assert.same(arg, resource);
}), resource);
assert.same(stack.dispose(), undefined);
assert.same(result, '1');
});
QUnit.test('DisposableStack#defer', assert => {
assert.isFunction(DisposableStack.prototype.defer);
assert.arity(DisposableStack.prototype.defer, 1);
assert.name(DisposableStack.prototype.defer, 'defer');
assert.looksNative(DisposableStack.prototype.defer);
assert.nonEnumerable(DisposableStack.prototype, 'defer');
let result = '';
const stack = new DisposableStack();
assert.same(stack.defer(function () {
result += '1';
if (STRICT) assert.same(this, undefined);
assert.same(arguments.length, 0);
}), undefined);
assert.same(stack.dispose(), undefined);
assert.same(result, '1');
});
QUnit.test('DisposableStack#move', assert => {
assert.isFunction(DisposableStack.prototype.move);
assert.arity(DisposableStack.prototype.move, 0);
assert.name(DisposableStack.prototype.move, 'move');
assert.looksNative(DisposableStack.prototype.move);
assert.nonEnumerable(DisposableStack.prototype, 'move');
let result = '';
const stack = new DisposableStack();
stack.defer(() => result += '2');
stack.defer(() => result += '1');
const stack2 = stack.move();
assert.true(stack.disposed);
stack2.dispose();
assert.same(result, '12');
});
QUnit.test('DisposableStack#@@dispose', assert => {
assert.same(DisposableStack.prototype[Symbol.dispose], DisposableStack.prototype.dispose);
});
QUnit.test('DisposableStack#@@toStringTag', assert => {
assert.same(DisposableStack.prototype[Symbol.toStringTag], 'DisposableStack', '@@toStringTag');
});
QUnit.test('DisposableStack', assert => {
let result1 = '';
const stack1 = new DisposableStack();
stack1.use({ [Symbol.dispose]: () => result1 += '6' });
stack1.adopt({}, () => result1 += '5');
stack1.defer(() => result1 += '4');
stack1.use({ [Symbol.dispose]: () => result1 += '3' });
stack1.adopt({}, () => result1 += '2');
stack1.defer(() => result1 += '1');
assert.false(stack1.disposed);
assert.same(stack1.dispose(), undefined);
assert.same(result1, '123456');
assert.true(stack1.disposed);
assert.same(stack1.dispose(), undefined);
let result2 = '';
const stack2 = new DisposableStack();
let error2;
stack2.use({ [Symbol.dispose]: () => result2 += '6' });
stack2.adopt({}, () => { throw new Error(5); });
stack2.defer(() => result2 += '4');
stack2.use({ [Symbol.dispose]: () => result2 += '3' });
stack2.adopt({}, () => result2 += '2');
stack2.defer(() => result2 += '1');
try {
stack2.dispose();
} catch (error2$) {
error2 = error2$;
}
assert.same(result2, '12346');
assert.true(error2 instanceof Error);
assert.same(error2.message, '5');
let result3 = '';
const stack3 = new DisposableStack();
let error3;
stack3.use({ [Symbol.dispose]: () => result3 += '6' });
stack3.adopt({}, () => { throw new Error(5); });
stack3.defer(() => result3 += '4');
stack3.use({ [Symbol.dispose]: () => { throw new Error(3); } });
stack3.adopt({}, () => result3 += '2');
stack3.defer(() => result3 += '1');
try {
stack3.dispose();
} catch (error3$) {
error3 = error3$;
}
assert.same(result3, '1246');
assert.true(error3 instanceof SuppressedError);
assert.same(error3.error.message, '5');
assert.same(error3.suppressed.message, '3');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.error.cause.js
|
JavaScript
|
/* eslint-disable sonarjs/inconsistent-function-call -- required for testing */
import { GLOBAL, PROTO } from '../helpers/constants.js';
const { create } = Object;
function runErrorTestCase($Error, ERROR_NAME) {
QUnit.test(`${ ERROR_NAME } constructor with 'cause' param`, assert => {
assert.isFunction($Error);
assert.arity($Error, 1);
assert.name($Error, ERROR_NAME);
assert.looksNative($Error);
if (PROTO && $Error !== Error) {
// eslint-disable-next-line no-prototype-builtins -- safe
assert.true(Error.isPrototypeOf($Error), 'constructor has `Error` in the prototype chain');
}
assert.same($Error.prototype.constructor, $Error, 'prototype constructor');
// eslint-disable-next-line no-prototype-builtins -- safe
assert.false($Error.prototype.hasOwnProperty('cause'), 'prototype has not cause');
assert.true($Error(1) instanceof $Error, 'no cause, without new');
assert.true(new $Error(1) instanceof $Error, 'no cause, with new');
assert.true($Error(1, {}) instanceof $Error, 'with options, without new');
assert.true(new $Error(1, {}) instanceof $Error, 'with options, with new');
assert.true($Error(1, 'foo') instanceof $Error, 'non-object options, without new');
assert.true(new $Error(1, 'foo') instanceof $Error, 'non-object options, with new');
assert.same($Error(1, { cause: 7 }).cause, 7, 'cause, without new');
assert.same(new $Error(1, { cause: 7 }).cause, 7, 'cause, with new');
assert.same($Error(1, create({ cause: 7 })).cause, 7, 'prototype cause, without new');
assert.same(new $Error(1, create({ cause: 7 })).cause, 7, 'prototype cause, with new');
let error = $Error(1, { cause: 7 });
assert.same(error.name, ERROR_NAME, 'instance name');
assert.same(error.message, '1', 'instance message');
assert.same(error.cause, 7, 'instance cause');
// eslint-disable-next-line no-prototype-builtins -- safe
assert.true(error.hasOwnProperty('cause'), 'cause is own');
error = $Error();
assert.same(error.message, '', 'default instance message');
assert.same(error.cause, undefined, 'default instance cause undefined');
// eslint-disable-next-line no-prototype-builtins -- safe
assert.false(error.hasOwnProperty('cause'), 'default instance cause missed');
});
}
for (const ERROR_NAME of ['Error', 'EvalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError']) {
runErrorTestCase(GLOBAL[ERROR_NAME], ERROR_NAME);
}
if (GLOBAL.WebAssembly) for (const ERROR_NAME of ['CompileError', 'LinkError', 'RuntimeError']) {
if (GLOBAL.WebAssembly[ERROR_NAME]) runErrorTestCase(GLOBAL.WebAssembly[ERROR_NAME], ERROR_NAME);
}
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.error.is-error.js
|
JavaScript
|
QUnit.test('Error.isError', assert => {
const { isError } = Error;
assert.isFunction(isError);
assert.arity(isError, 1);
assert.name(isError, 'isError');
assert.looksNative(isError);
assert.nonEnumerable(Error, 'isError');
assert.true(isError(new Error('error')));
assert.true(isError(new TypeError('error')));
assert.true(isError(new AggregateError([1, 2, 3], 'error')));
assert.true(isError(new SuppressedError(1, 2, 'error')));
assert.true(isError(new DOMException('error')));
assert.false(isError(null));
assert.false(isError({}));
assert.false(isError(Object.create(Error.prototype)));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.error.to-string.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
QUnit.test('Error#toString', assert => {
const { toString } = Error.prototype;
assert.isFunction(toString);
assert.arity(toString, 0);
assert.name(toString, 'toString');
assert.looksNative(toString);
assert.nonEnumerable(Error.prototype, 'toString');
assert.same(String(new Error('something')), 'Error: something');
assert.same(String(new TypeError('something')), 'TypeError: something');
assert.same(String(new Error()), 'Error');
assert.same(toString.call({}), 'Error');
assert.same(toString.call({ name: 'foo' }), 'foo');
assert.same(toString.call({ message: 'bar' }), 'Error: bar');
assert.same(toString.call({ name: '', message: 'bar' }), 'bar');
assert.same(toString.call({ name: 'foo', message: 'bar' }), 'foo: bar');
assert.same(toString.call({ name: 1, message: 2 }), '1: 2');
if (STRICT) {
assert.throws(() => toString.call(7));
assert.throws(() => toString.call('a'));
assert.throws(() => toString.call(false));
assert.throws(() => toString.call(null));
assert.throws(() => toString.call(undefined));
}
// assert.throws(() => toString.call({ name: Symbol() }), 'throws on symbol #1');
// assert.throws(() => toString.call({ name: Symbol() }), 'throws on symbol #2');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.escape.js
|
JavaScript
|
QUnit.test('escape', assert => {
assert.isFunction(escape);
assert.name(escape, 'escape');
assert.arity(escape, 1);
assert.looksNative(escape);
assert.same(escape('!q2ф'), '%21q2%u0444');
assert.same(escape(null), 'null');
assert.same(escape(undefined), 'undefined');
if (typeof Symbol == 'function' && !Symbol.sham) {
assert.throws(() => unescape(Symbol('escape test')), 'throws on symbol argument');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.function.bind.js
|
JavaScript
|
QUnit.test('Function#bind', assert => {
const { bind } = Function.prototype;
assert.isFunction(bind);
assert.arity(bind, 1);
assert.name(bind, 'bind');
assert.looksNative(bind);
assert.nonEnumerable(Function.prototype, 'bind');
assert.same(function () {
return this.a;
}.bind({ a: 42 })(), 42);
assert.same(new function () { /* empty */ }().a, undefined);
function A(a, b) {
this.a = a;
this.b = b;
}
const instance = new (A.bind(null, 1))(2);
assert.true(instance instanceof A);
assert.same(instance.a, 1);
assert.same(instance.b, 2);
assert.same((it => it).bind(null, 42)(), 42);
const regExpTest = RegExp.prototype.test.bind(/a/);
assert.true(regExpTest('a'));
const Date2017 = Date.bind(null, 2017);
const date = new Date2017(11);
assert.true(date instanceof Date);
assert.same(date.getFullYear(), 2017);
assert.same(date.getMonth(), 11);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.function.has-instance.js
|
JavaScript
|
QUnit.test('Function#@@hasInstance', assert => {
assert.true(Symbol.hasInstance in Function.prototype);
assert.nonEnumerable(Function.prototype, Symbol.hasInstance);
assert.true(Function[Symbol.hasInstance](() => { /* empty */ }));
assert.false(Function[Symbol.hasInstance]({}));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.function.name.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) {
QUnit.test('Function#name', assert => {
assert.true('name' in Function.prototype);
assert.nonEnumerable(Function.prototype, 'name');
function foo() { /* empty */ }
assert.same(foo.name, 'foo');
assert.same(function () { /* empty */ }.name, '');
if (Object.freeze) {
assert.same(Object.freeze(() => { /* empty */ }).name, '');
}
function bar() { /* empty */ }
bar.toString = function () {
throw new Error();
};
assert.notThrows(() => bar.name === 'bar', 'works with redefined `.toString`');
const baz = Object(() => { /* empty */ });
baz.toString = function () {
return '';
};
assert.same(baz.name, '');
assert.same(function /*
multi-line comment */() { /* empty */ }.name, '');
function /*
multi-line comment */
foobar() { /* empty */ }
assert.same(foobar.name, 'foobar');
function // simple-line comment
foobaz() { /* empty */ }
assert.same(foobaz.name, 'foobaz');
function // simple-line comment
/* multi-line comment */quux/*
multi-line comment
*/() { /* empty */ }
assert.same(quux.name, 'quux');
});
}
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.global-this.js
|
JavaScript
|
QUnit.test('globalThis', assert => {
assert.same(globalThis, Object(globalThis), 'is object');
assert.same(globalThis.Math, Math, 'contains globals');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.concat.js
|
JavaScript
|
import { createIterable, createIterator } from '../helpers/helpers.js';
const { from } = Array;
QUnit.test('Iterator.concat', assert => {
const { concat } = Iterator;
assert.isFunction(concat);
assert.arity(concat, 0);
assert.name(concat, 'concat');
assert.looksNative(concat);
assert.nonEnumerable(Iterator, 'concat');
let iterator = concat();
assert.isIterable(iterator, 'iterable, no args');
assert.isIterator(iterator, 'iterator, no args');
assert.true(iterator instanceof Iterator, 'iterator instance, no args');
assert.arrayEqual(from(iterator), [], 'proper values, no args');
iterator = concat([1, 2, 3]);
assert.isIterable(iterator, 'iterable, array');
assert.isIterator(iterator, 'iterator, array');
assert.true(iterator instanceof Iterator, 'iterator instance, array');
assert.arrayEqual(from(iterator), [1, 2, 3], 'proper values, array');
iterator = concat([]);
assert.isIterable(iterator, 'iterable, empty array');
assert.isIterator(iterator, 'iterator, empty array');
assert.true(iterator instanceof Iterator, 'iterator instance, empty array');
assert.arrayEqual(from(iterator), [], 'proper values, empty array');
iterator = concat(createIterable([1, 2, 3]));
assert.isIterable(iterator, 'iterable, custom iterable');
assert.isIterator(iterator, 'iterator, custom iterable');
assert.true(iterator instanceof Iterator, 'iterator instance, custom iterable');
assert.arrayEqual(from(iterator), [1, 2, 3], 'proper values, custom iterable');
iterator = concat([1, 2, 3], [], createIterable([4, 5, 6]), createIterable([]));
assert.isIterable(iterator, 'iterable, mixed');
assert.isIterator(iterator, 'iterator, mixed');
assert.true(iterator instanceof Iterator, 'iterator instance, mixed');
assert.arrayEqual(from(iterator), [1, 2, 3, 4, 5, 6], 'proper values, mixed');
iterator = concat(createIterable([1, 2, 3]));
iterator.next();
assert.deepEqual(iterator.return(), { done: true, value: undefined }, '.return with no active inner iterator result');
assert.deepEqual(iterator.next(), { done: true, value: undefined }, '.return with no active inner iterator result on closed iterator');
iterator = concat(createIterable([1, 2, 3]));
assert.deepEqual(iterator.next(), { done: false, value: 1 }, '.next with active inner iterator result');
assert.deepEqual(iterator.return(), { done: true, value: undefined }, '.return with active inner iterator result');
assert.deepEqual(iterator.next(), { done: true, value: undefined }, '.return with active inner iterator result on closed iterator');
let called = false;
iterator = concat(createIterable([1, 2, 3], {
return() {
called = true;
return {};
},
}));
iterator.next();
assert.deepEqual(iterator.return(), { done: true, value: undefined }, '.return with active inner iterator with return result');
assert.true(called, 'inner .return called');
// https://github.com/tc39/proposal-iterator-sequencing/issues/17
const oldIterResult = {
done: false,
value: 123,
};
const testIterator = {
next() {
return oldIterResult;
},
};
const iterable = {
[Symbol.iterator]() {
return testIterator;
},
};
iterator = concat(iterable);
const iterResult = iterator.next();
assert.same(iterResult.done, false);
assert.same(iterResult.value, 123);
// https://github.com/tc39/proposal-iterator-sequencing/pull/26
assert.notSame(iterResult, oldIterResult);
assert.throws(() => concat(createIterator([1, 2, 3])), TypeError, 'non-iterable iterator #1');
assert.throws(() => concat([], createIterator([1, 2, 3])), TypeError, 'non-iterable iterator #2');
assert.throws(() => concat(''), TypeError, 'iterable non-object argument #1');
assert.throws(() => concat([], ''), TypeError, 'iterable non-object argument #2');
assert.throws(() => concat(undefined), TypeError, 'non-iterable-object argument #1');
assert.throws(() => concat(null), TypeError, 'non-iterable-object argument #2');
assert.throws(() => concat(1), TypeError, 'non-iterable-object argument #3');
assert.throws(() => concat({}), TypeError, 'non-iterable-object argument #4');
assert.throws(() => concat([], undefined), TypeError, 'non-iterable-object argument #5');
assert.throws(() => concat([], null), TypeError, 'non-iterable-object argument #6');
assert.throws(() => concat([], 1), TypeError, 'non-iterable-object argument #7');
assert.throws(() => concat([], {}), TypeError, 'non-iterable-object argument #8');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.constructor.js
|
JavaScript
|
import { createIterator, nativeSubclass } from '../helpers/helpers.js';
const { getPrototypeOf } = Object;
QUnit.test('Iterator', assert => {
assert.isFunction(Iterator);
assert.arity(Iterator, 0);
assert.name(Iterator, 'Iterator');
assert.looksNative(Iterator);
const generator = (() => {
try {
return Function('return function*(){}()')();
} catch { /* empty */ }
})();
if (generator) {
const proto = getPrototypeOf(getPrototypeOf(getPrototypeOf(generator)));
if (proto !== Object.prototype && proto !== null) {
assert.true(generator instanceof Iterator, 'Generator');
}
}
assert.true(''[Symbol.iterator]() instanceof Iterator, 'String Iterator');
assert.true([].values() instanceof Iterator, 'Array Iterator');
assert.true(new Set().values() instanceof Iterator, 'Set Iterator');
assert.true('abc'.matchAll(/./g) instanceof Iterator, 'MatchAll Iterator');
assert.true(Iterator.from(createIterator([1, 2, 3])) instanceof Iterator, 'From Proxy');
assert.true([].values().drop(1) instanceof Iterator, 'Drop Proxy');
if (nativeSubclass) {
const Sub = nativeSubclass(Iterator);
assert.true(new Sub() instanceof Iterator, 'abstract constructor');
}
assert.throws(() => new Iterator(), 'direct constructor throws');
assert.throws(() => Iterator(), 'throws w/o `new`');
});
QUnit.test('Iterator#constructor', assert => {
assert.same(Iterator.prototype.constructor, Iterator, 'Iterator#constructor is Iterator');
});
QUnit.test('Iterator#@@toStringTag', assert => {
assert.same(Iterator.prototype[Symbol.toStringTag], 'Iterator', 'Iterator::@@toStringTag is `Iterator`');
assert.same(String(Iterator.from({
next: () => ({ done: Math.random() > 0.9, value: Math.random() * 10 | 0 }),
})), '[object Iterator]', 'correct stringification');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.dispose.js
|
JavaScript
|
const { create } = Object;
QUnit.test('Iterator#@@dispose', assert => {
const dispose = Iterator.prototype[Symbol.dispose];
assert.isFunction(dispose);
assert.arity(dispose, 0);
assert.looksNative(dispose);
assert.same(create(Iterator.prototype)[Symbol.dispose](), undefined);
let called = false;
const iterator2 = create(Iterator.prototype);
iterator2.return = function () {
called = true;
assert.same(this, iterator2);
return 7;
};
assert.same(iterator2[Symbol.dispose](), undefined);
assert.true(called);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.drop.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('Iterator#drop', assert => {
const { drop } = Iterator.prototype;
assert.isFunction(drop);
assert.arity(drop, 1);
assert.name(drop, 'drop');
assert.looksNative(drop);
assert.nonEnumerable(Iterator.prototype, 'drop');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 1).toArray(), [2, 3], 'basic functionality');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 1.5).toArray(), [2, 3], 'float');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 4).toArray(), [], 'big');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 0).toArray(), [1, 2, 3], 'zero');
if (STRICT) {
assert.throws(() => drop.call(undefined, 1), TypeError);
assert.throws(() => drop.call(null, 1), TypeError);
}
assert.throws(() => drop.call({}, 1).next(), TypeError);
assert.throws(() => drop.call([], 1).next(), TypeError);
assert.throws(() => drop.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => drop.call(it, NaN), RangeError, 'NaN');
assert.true(it.closed, 'drop closes iterator on validation error');
// https://issues.chromium.org/issues/336839115
assert.throws(() => drop.call({ next: null }, 0).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.every.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('Iterator#every', assert => {
const { every } = Iterator.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.looksNative(every);
assert.nonEnumerable(Iterator.prototype, 'every');
assert.true(every.call(createIterator([1, 2, 3]), it => typeof it == 'number'), 'basic functionality #1');
assert.false(every.call(createIterator([1, 2, 3]), it => it % 2), 'basic functionality #2');
every.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
if (STRICT) {
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call([], () => { /* empty */ }), TypeError);
assert.throws(() => every.call(createIterator([1]), undefined), TypeError);
assert.throws(() => every.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => every.call(it, {}), TypeError);
assert.true(it.closed, 'every closes iterator on validation error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.filter.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('Iterator#filter', assert => {
const { filter } = Iterator.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.looksNative(filter);
assert.nonEnumerable(Iterator.prototype, 'filter');
assert.arrayEqual(filter.call(createIterator([1, 2, 3]), it => it % 2).toArray(), [1, 3], 'basic functionality');
filter.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
if (STRICT) {
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => filter.call({}, () => { /* empty */ }).next(), TypeError);
assert.throws(() => filter.call([], () => { /* empty */ }).next(), TypeError);
assert.throws(() => filter.call(createIterator([1]), undefined), TypeError);
assert.throws(() => filter.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => filter.call(it, {}), TypeError);
assert.true(it.closed, 'filter closes iterator on validation error');
// https://issues.chromium.org/issues/336839115
assert.throws(() => filter.call({ next: null }, () => { /* empty */ }).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.find.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('Iterator#find', assert => {
const { find } = Iterator.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.looksNative(find);
assert.nonEnumerable(Iterator.prototype, 'find');
assert.same(find.call(createIterator([1, 2, 3]), it => !(it % 2)), 2, 'basic functionality');
find.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
if (STRICT) {
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call([], () => { /* empty */ }), TypeError);
assert.throws(() => find.call(createIterator([1]), undefined), TypeError);
assert.throws(() => find.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => find.call(it, {}), TypeError);
assert.true(it.closed, 'find closes iterator on validation error');
let returnCount = 0;
const it2 = createIterator([1, 2, 3], {
return() {
returnCount++;
throw new Error('close error');
},
});
assert.throws(() => find.call(it2, () => true), Error, 'iterator.return() throwing on stop');
assert.same(returnCount, 1, 'iterator.return() called exactly once when it throws');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.flat-map.js
|
JavaScript
|
import { createIterator, createIterable } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('Iterator#flatMap', assert => {
const { flatMap } = Iterator.prototype;
assert.isFunction(flatMap);
assert.arity(flatMap, 1);
assert.name(flatMap, 'flatMap');
assert.looksNative(flatMap);
assert.nonEnumerable(Iterator.prototype, 'flatMap');
assert.arrayEqual(
flatMap.call(createIterator([1, [], 2, createIterable([3, 4]), [5, 6]]), it => typeof it == 'number' ? [-it] : it).toArray(),
[-1, -2, 3, 4, 5, 6],
'basic functionality',
);
flatMap.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
return [arg];
}).toArray();
// Should not throw an error for an iterator without `return` method. Fixed in Safari 26.2
// https://bugs.webkit.org/show_bug.cgi?id=297532
assert.notThrows(() => {
const iter = flatMap.call(new Map([[4, 5]]).entries(), v => v);
iter.next();
iter.return();
}, 'iterator without `return` method');
if (STRICT) {
assert.throws(() => flatMap.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => flatMap.call({}, () => { /* empty */ }).next(), TypeError);
assert.throws(() => flatMap.call([], () => { /* empty */ }).next(), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), it => it).next(), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), undefined), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => flatMap.call(it, {}), TypeError);
assert.true(it.closed, 'flatMap closes iterator on validation error');
// https://issues.chromium.org/issues/336839115
assert.throws(() => flatMap.call({ next: null }, () => { /* empty */ }).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.for-each.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('Iterator#forEach', assert => {
const { forEach } = Iterator.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.name(forEach, 'forEach');
assert.looksNative(forEach);
assert.nonEnumerable(Iterator.prototype, 'forEach');
const array = [];
forEach.call(createIterator([1, 2, 3]), it => array.push(it));
assert.arrayEqual(array, [1, 2, 3], 'basic functionality');
forEach.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
if (STRICT) {
assert.throws(() => forEach.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => forEach.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call([], () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(createIterator([1]), undefined), TypeError);
assert.throws(() => forEach.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => forEach.call(it, {}), TypeError);
assert.true(it.closed, 'forEach closes iterator on validation error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.from.js
|
JavaScript
|
import { createIterable, createIterator } from '../helpers/helpers.js';
const { assign } = Object;
QUnit.test('Iterator.from', assert => {
const { from } = Iterator;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(Iterator, 'from');
assert.true(Iterator.from(createIterator([1, 2, 3])) instanceof Iterator, 'proxy, iterator');
assert.true(Iterator.from(createIterable([1, 2, 3])) instanceof Iterator, 'proxy, iterable');
assert.arrayEqual(Iterator.from(createIterable([1, 2, 3])).toArray(), [1, 2, 3], 'just a proxy');
assert.throws(() => from(undefined), TypeError);
assert.throws(() => from(null), TypeError);
assert.throws(() => from({}).next(), TypeError);
assert.throws(() => from(assign(new Iterator(), { next: 42 })).next(), TypeError);
// Should not throw when an underlying iterator's `return` method is null
// https://bugs.webkit.org/show_bug.cgi?id=288714
const iterator = createIterator([], { return: null });
const result = from(iterator).return('ignored');
assert.true(result.done, 'iterator with null next #1');
assert.strictEqual(result.value, undefined, 'iterator with null next #2');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.map.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('Iterator#map', assert => {
const { map } = Iterator.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.name(map, 'map');
assert.looksNative(map);
assert.nonEnumerable(Iterator.prototype, 'map');
assert.arrayEqual(map.call(createIterator([1, 2, 3]), it => it ** 2).toArray(), [1, 4, 9], 'basic functionality');
map.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
}).toArray();
if (STRICT) {
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => map.call({}, () => { /* empty */ }).next(), TypeError);
assert.throws(() => map.call([], () => { /* empty */ }).next(), TypeError);
assert.throws(() => map.call(createIterator([1]), undefined), TypeError);
assert.throws(() => map.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => map.call(it, {}), TypeError);
assert.true(it.closed, 'map closes iterator on validation error');
// https://issues.chromium.org/issues/336839115
assert.throws(() => map.call({ next: null }, () => { /* empty */ }).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.reduce.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('Iterator#reduce', assert => {
const { reduce } = Iterator.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.looksNative(reduce);
assert.nonEnumerable(Iterator.prototype, 'reduce');
assert.same(reduce.call(createIterator([1, 2, 3]), (a, b) => a + b, 1), 7, 'basic functionality');
assert.same(reduce.call(createIterator([1, 2, 3]), (a, b) => a + b), 6, 'basic functionality, no init');
reduce.call(createIterator([2]), function (a, b, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 3, 'arguments length');
assert.same(a, 1, 'argument 1');
assert.same(b, 2, 'argument 2');
assert.same(counter, 0, 'counter');
}, 1);
if (STRICT) {
assert.throws(() => reduce.call(undefined, (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call(null, (a, b) => a + b, 0), TypeError);
}
assert.throws(() => reduce.call({}, (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call([], (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call(createIterator([1]), undefined, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), null, 1), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => reduce.call(it, {}, 1), TypeError);
assert.true(it.closed, 'reduce closes iterator on validation error');
assert.notThrows(() => reduce.call(createIterator([]), () => false, undefined), 'fails on undefined initial parameter');
assert.same(reduce.call(createIterator([]), () => false, undefined), undefined, 'incorrect result on undefined initial parameter');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.some.js
|
JavaScript
|
import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('Iterator#some', assert => {
const { some } = Iterator.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.looksNative(some);
assert.nonEnumerable(Iterator.prototype, 'some');
assert.true(some.call(createIterator([1, 2, 3]), it => it % 2), 'basic functionality #1');
assert.false(some.call(createIterator([1, 2, 3]), it => typeof it == 'string'), 'basic functionality #2');
some.call(createIterator([1]), function (arg, counter) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(arg, 1, 'argument');
assert.same(counter, 0, 'counter');
});
if (STRICT) {
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
}
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call([], () => { /* empty */ }), TypeError);
assert.throws(() => some.call(createIterator([1]), undefined), TypeError);
assert.throws(() => some.call(createIterator([1]), null), TypeError);
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => some.call(it, {}), TypeError);
assert.true(it.closed, 'some closes iterator on validation error');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.take.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('Iterator#take', assert => {
const { take } = Iterator.prototype;
assert.isFunction(take);
assert.arity(take, 1);
assert.name(take, 'take');
assert.looksNative(take);
assert.nonEnumerable(Iterator.prototype, 'take');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 2).toArray(), [1, 2], 'basic functionality');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 1.5).toArray(), [1], 'float');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 4).toArray(), [1, 2, 3], 'big');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 0).toArray(), [], 'zero');
if (STRICT) {
assert.throws(() => take.call(undefined, 1), TypeError);
assert.throws(() => take.call(null, 1), TypeError);
}
assert.throws(() => take.call({}, 1).next(), TypeError);
assert.throws(() => take.call([], 1).next(), TypeError);
assert.throws(() => take.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
const it = createIterator([1], { return() { this.closed = true; } });
assert.throws(() => take.call(it, NaN), RangeError, 'NaN');
assert.true(it.closed, 'take closes iterator on validation error');
// https://issues.chromium.org/issues/336839115
assert.throws(() => take.call({ next: null }, 1).next(), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.iterator.to-array.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
import { createIterable, createIterator } from '../helpers/helpers.js';
QUnit.test('Iterator#toArray', assert => {
const { toArray } = Iterator.prototype;
assert.isFunction(toArray);
assert.arity(toArray, 0);
assert.name(toArray, 'toArray');
assert.looksNative(toArray);
assert.nonEnumerable(Iterator.prototype, 'toArray');
assert.arrayEqual([1, 2, 3].values().toArray(), [1, 2, 3]);
assert.arrayEqual(new Set([1, 2, 3]).values().toArray(), [1, 2, 3]);
assert.arrayEqual(Iterator.from('123').toArray(), ['1', '2', '3']);
assert.arrayEqual(Iterator.from(createIterable([1, 2, 3])).toArray(), [1, 2, 3]);
assert.arrayEqual(toArray.call(createIterator([1, 2, 3])), [1, 2, 3]);
if (STRICT) {
assert.throws(() => toArray.call(undefined), TypeError);
assert.throws(() => toArray.call(null), TypeError);
}
assert.throws(() => toArray.call({}), TypeError);
assert.throws(() => toArray.call([]), TypeError);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.json.is-raw-json.js
|
JavaScript
|
QUnit.test('JSON.rawJSON', assert => {
const { isRawJSON, rawJSON } = JSON;
const { freeze } = Object;
assert.isFunction(isRawJSON);
assert.arity(isRawJSON, 1);
assert.name(isRawJSON, 'isRawJSON');
assert.looksNative(isRawJSON);
assert.true(isRawJSON(rawJSON(1)), 'raw1');
assert.true(isRawJSON(rawJSON(null)), 'raw2');
assert.false(isRawJSON(freeze({ rawJSON: '123' })), 'fake');
assert.false(isRawJSON(undefined), 'undefined');
assert.false(isRawJSON(null), 'null');
assert.false(isRawJSON(1), 'number');
assert.false(isRawJSON('qwe'), 'string');
assert.false(isRawJSON(true), 'bool');
assert.false(isRawJSON(Symbol('JSON.isRawJSON test')), 'sym');
assert.false(isRawJSON({}), 'object');
assert.false(isRawJSON([]), 'array');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.json.parse.js
|
JavaScript
|
// Some tests adopted from Test262 project and governed by the BSD license.
// Copyright (c) 2012 Ecma International. All rights reserved.
/* eslint-disable unicorn/escape-case -- testing */
import { DESCRIPTORS, REDEFINABLE_PROTO } from '../helpers/constants.js';
QUnit.test('JSON.parse', assert => {
const { parse } = JSON;
const { defineProperty, hasOwn, keys } = Object;
assert.isFunction(parse);
assert.arity(parse, 2);
assert.name(parse, 'parse');
assert.looksNative(parse);
for (const [reviver, note] of [[undefined, 'without reviver'], [(key, value) => value, 'with reviver']]) {
assert.throws(() => parse('12\t\r\n 34', reviver), SyntaxError, `15.12.1.1-0-1 ${ note }`); // should produce a syntax error as whitespace results in two tokens
assert.throws(() => parse('\u000b1234', reviver), SyntaxError, `15.12.1.1-0-2 ${ note }`); // should produce a syntax error
assert.throws(() => parse('\u000c1234', reviver), SyntaxError, `15.12.1.1-0-3 ${ note }`); // should produce a syntax error
assert.throws(() => parse('\u00a01234', reviver), SyntaxError, `15.12.1.1-0-4 ${ note }`); // should produce a syntax error
assert.throws(() => parse('\u200b1234', reviver), SyntaxError, `15.12.1.1-0-5 ${ note }`); // should produce a syntax error
assert.throws(() => parse('\ufeff1234', reviver), SyntaxError, `15.12.1.1-0-6 ${ note }`); // should produce a syntax error
assert.throws(() => parse('\u2028\u20291234', reviver), SyntaxError, `15.12.1.1-0-8 ${ note }`); // should produce a syntax error
assert.notThrows(() => parse('\t\r \n{\t\r \n"property"\t\r \n:\t\r \n{\t\r \n}\t\r \n,\t\r \n"prop2"\t\r \n:\t\r \n' +
'[\t\r \ntrue\t\r \n,\t\r \nnull\t\r \n,123.456\t\r \n]\t\r \n}\t\r \n', reviver), SyntaxError, `15.12.1.1-0-9 ${ note }`); // should JSON parse without error
assert.same(parse('\t1234', reviver), 1234, `15.12.1.1-g1-1-1 ${ note }`); // '<TAB> should be ignored'
assert.throws(() => parse('12\t34', reviver), SyntaxError, `15.12.1.1-g1-1-2 ${ note }`); // <TAB> should produce a syntax error as whitespace results in two tokens
assert.same(parse('\r1234', reviver), 1234, `15.12.1.1-g1-2-1 ${ note }`); // '<CR> should be ignored'
assert.throws(() => parse('12\r34', reviver), SyntaxError, `15.12.1.1-g1-2-2 ${ note }`); // <CR> should produce a syntax error as whitespace results in two tokens
assert.same(parse('\n1234', reviver), 1234, `15.12.1.1-g1-3-1 ${ note }`); // '<LF> should be ignored'
assert.throws(() => parse('12\n34', reviver), SyntaxError, `15.12.1.1-g1-3-2 ${ note }`); // <LF> should produce a syntax error as whitespace results in two tokens
assert.same(parse(' 1234', reviver), 1234, `15.12.1.1-g1-4-1 ${ note }`); // '<SP> should be ignored'
assert.throws(() => parse('12 34', reviver), SyntaxError, `15.12.1.1-g1-4-2 ${ note }`); // <SP> should produce a syntax error as whitespace results in two tokens
assert.same(parse('"abc"', reviver), 'abc', `15.12.1.1-g2-1 ${ note }`);
assert.throws(() => parse("'abc'", reviver), SyntaxError, `15.12.1.1-g2-2 ${ note }`);
assert.throws(() => parse('\\u0022abc\\u0022', reviver), SyntaxError, `15.12.1.1-g2-3 ${ note }`);
assert.throws(() => parse('"abc\'', reviver), SyntaxError, `15.12.1.1-g2-4 ${ note }`);
assert.same(parse('""', reviver), '', `15.12.1.1-g2-5 ${ note }`);
// invalid string characters should produce a syntax error
assert.throws(() => parse('"\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007"', reviver), SyntaxError, `15.12.1.1-g4-1 ${ note }`);
assert.throws(() => parse('"\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f"', reviver), SyntaxError, `15.12.1.1-g4-2 ${ note }`);
assert.throws(() => parse('"\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017"', reviver), SyntaxError, `15.12.1.1-g4-3 ${ note }`);
assert.throws(() => parse('"\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f"', reviver), SyntaxError, `15.12.1.1-g4-4 ${ note }`);
assert.same(parse('"\\u0058"', reviver), 'X', `15.12.1.1-g5-1 ${ note }`);
assert.throws(() => parse('"\\u005"', reviver), SyntaxError, `15.12.1.1-g5-2 ${ note }`);
assert.throws(() => parse('"\\u0X50"', reviver), SyntaxError, `15.12.1.1-g5-3 ${ note }`);
assert.same(parse('"\\/"', reviver), '/', `15.12.1.1-g6-1 ${ note }`);
assert.same(parse('"\\\\"', reviver), '\\', `15.12.1.1-g6-2 ${ note }`);
assert.same(parse('"\\b"', reviver), '\b', `15.12.1.1-g6-3 ${ note }`);
assert.same(parse('"\\f"', reviver), '\f', `15.12.1.1-g6-4 ${ note }`);
assert.same(parse('"\\n"', reviver), '\n', `15.12.1.1-g6-5 ${ note }`);
assert.same(parse('"\\r"', reviver), '\r', `15.12.1.1-g6-6 ${ note }`);
assert.same(parse('"\\t"', reviver), '\t', `15.12.1.1-g6-7 ${ note }`);
const nullChars = [
'"\u0000"',
'"\u0001"',
'"\u0002"',
'"\u0003"',
'"\u0004"',
'"\u0005"',
'"\u0006"',
'"\u0007"',
'"\u0008"',
'"\u0009"',
'"\u000A"',
'"\u000B"',
'"\u000C"',
'"\u000D"',
'"\u000E"',
'"\u000F"',
'"\u0010"',
'"\u0011"',
'"\u0012"',
'"\u0013"',
'"\u0014"',
'"\u0015"',
'"\u0016"',
'"\u0017"',
'"\u0018"',
'"\u0019"',
'"\u001A"',
'"\u001B"',
'"\u001C"',
'"\u001D"',
'"\u001E"',
'"\u001F"',
];
for (let i = 0; i < nullChars.length; i++) {
assert.throws(() => parse(`{${ nullChars[i] } : "John" }`, reviver), SyntaxError, `15.12.2-2-1-${ i } ${ note }`);
assert.throws(() => parse(`{${ nullChars[i] }name : "John" }`, reviver), SyntaxError, `15.12.2-2-2-${ i } ${ note }`);
assert.throws(() => parse(`{name${ nullChars[i] } : "John" }`, reviver), SyntaxError, `15.12.2-2-3-${ i } ${ note }`);
assert.throws(() => parse(`{${ nullChars[i] }name${ nullChars[i] } : "John" }`, reviver), SyntaxError, `15.12.2-2-4-${ i } ${ note }`);
assert.throws(() => parse(`{na${ nullChars[i] }me : "John" }`, reviver), SyntaxError, `15.12.2-2-5-${ i } ${ note }`);
assert.throws(() => parse(`{ "name" : ${ nullChars[i] } }`, reviver), SyntaxError, `15.12.2-2-6-${ i } ${ note }`);
assert.throws(() => parse(`{ "name" : ${ nullChars[i] }John }`, reviver), SyntaxError, `15.12.2-2-7-${ i } ${ note }`);
assert.throws(() => parse(`{ "name" : John${ nullChars[i] } }`, reviver), SyntaxError, `15.12.2-2-8-${ i } ${ note }`);
assert.throws(() => parse(`{ "name" : ${ nullChars[i] }John${ nullChars[i] } }`, reviver), SyntaxError, `15.12.2-2-9-${ i } ${ note }`);
assert.throws(() => parse(`{ "name" : Jo${ nullChars[i] }hn }`, reviver), SyntaxError, `15.12.2-2-10-${ i } ${ note }`);
}
if (REDEFINABLE_PROTO) {
// eslint-disable-next-line no-proto -- testing
assert.same(parse('{ "__proto__": 1, "__proto__": 2 }', reviver).__proto__, 2, `duplicate proto ${ note }`);
}
assert.throws(() => parse('\u16801', reviver), SyntaxError, `15.12.1.1-0-7-1 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u180e1', reviver), SyntaxError, `15.12.1.1-0-7-2 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20001', reviver), SyntaxError, `15.12.1.1-0-7-3 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20011', reviver), SyntaxError, `15.12.1.1-0-7-4 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20021', reviver), SyntaxError, `15.12.1.1-0-7-5 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20031', reviver), SyntaxError, `15.12.1.1-0-7-6 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20041', reviver), SyntaxError, `15.12.1.1-0-7-7 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20051', reviver), SyntaxError, `15.12.1.1-0-7-8 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20061', reviver), SyntaxError, `15.12.1.1-0-7-9 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20071', reviver), SyntaxError, `15.12.1.1-0-7-10 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20081', reviver), SyntaxError, `15.12.1.1-0-7-11 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u20091', reviver), SyntaxError, `15.12.1.1-0-7-12 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u200a1', reviver), SyntaxError, `15.12.1.1-0-7-13 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u202f1', reviver), SyntaxError, `15.12.1.1-0-7-14 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u205f1', reviver), SyntaxError, `15.12.1.1-0-7-15 ${ note }`); // invalid whitespace
assert.throws(() => parse('\u30001', reviver), SyntaxError, `15.12.1.1-0-7-16 ${ note }`); // invalid whitespace
assert.same(parse('-0', reviver), -0, `negative-zero-1 ${ note }`);
assert.same(parse(' \n-0', reviver), -0, `negative-zero-2 ${ note }`);
assert.same(parse('-0 \t', reviver), -0, `negative-zero-3 ${ note }`);
assert.same(parse('\n\t -0\n ', reviver), -0, `negative-zero-4 ${ note }`);
assert.same(parse(-0, reviver), 0, `negative-zero-5 ${ note }`);
assert.throws(() => parse('1.', reviver), SyntaxError, `number-fraction-no-digits-1 ${ note }`);
assert.throws(() => parse('-0.', reviver), SyntaxError, `number-fraction-no-digits-2 ${ note }`);
assert.throws(() => parse('1.e5', reviver), SyntaxError, `number-fraction-no-digits-3 ${ note }`);
assert.throws(() => parse('[1.,2]', reviver), SyntaxError, `number-fraction-no-digits-4 ${ note }`);
assert.throws(() => parse('{', reviver), SyntaxError, `unterminated-object-1 ${ note }`);
assert.throws(() => parse('{"a":1,', reviver), SyntaxError, `unterminated-object-2 ${ note }`);
assert.throws(() => parse('[', reviver), SyntaxError, `unterminated-array-1 ${ note }`);
assert.throws(() => parse('[1,', reviver), SyntaxError, `unterminated-array-2 ${ note }`);
assert.throws(() => parse(undefined, reviver), SyntaxError, `undefined ${ note }`);
assert.throws(() => parse(Symbol('JSON.parse test'), reviver), TypeError, `symbol ${ note }`);
assert.same(parse(null, reviver), null, `null ${ note }`);
assert.same(parse(false, reviver), false, `false ${ note }`);
assert.same(parse(true, reviver), true, `true ${ note }`);
assert.same(parse(0, reviver), 0, `0 ${ note }`);
assert.same(parse(3.14, reviver), 3.14, `3.14 ${ note }`);
assert.same(parse({
toString() {
return '"string"';
},
valueOf() {
return '"default_or_number"';
},
}, reviver), 'string', `text-object ${ note }`);
assert.throws(() => parse({
toString: null,
valueOf() {
throw new EvalError('t262');
},
}, reviver), EvalError, `text-object-abrupt-1 ${ note }`);
assert.throws(() => parse({
toString() {
throw new EvalError('t262');
},
}, reviver), EvalError, `text-object-abrupt-2 ${ note }`);
}
// eslint-disable-next-line no-extend-native -- testing
Array.prototype[1] = 3;
const arr1 = parse('[1, 2]', function (key, value) {
if (key === '0') delete this[1];
return value;
});
delete Array.prototype[1];
assert.same(arr1[0], 1, 'reviver-array-get-prop-from-prototype-1');
assert.true(hasOwn(arr1, '1'), 'reviver-array-get-prop-from-prototype-2');
assert.same(arr1[1], 3, 'reviver-array-get-prop-from-prototype-3');
// eslint-disable-next-line no-extend-native -- testing
Object.prototype.b = 3;
const obj1 = parse('{"a": 1, "b": 2}', function (key, value) {
if (key === 'a') delete this.b;
return value;
});
delete Object.prototype.b;
assert.same(obj1.a, 1, 'reviver-object-get-prop-from-prototype-1');
assert.true(hasOwn(obj1, 'b'), 'reviver-object-get-prop-from-prototype-2');
assert.same(obj1.b, 3, 'reviver-object-get-prop-from-prototype-3');
if (DESCRIPTORS) {
const arr2 = parse('[1, 2]', function (key, value) {
if (key === '0') defineProperty(this, '1', { configurable: false });
if (key === '1') return 22;
return value;
});
assert.same(arr2[0], 1, 'reviver-array-non-configurable-prop-create-1');
assert.same(arr2[1], 2, 'reviver-array-non-configurable-prop-create-2');
const arr3 = parse('[1, 2]', function (key, value) {
if (key === '0') defineProperty(this, '1', { configurable: false });
if (key === '1') return;
return value;
});
assert.same(arr3[0], 1, 'reviver-array-non-configurable-prop-delete-1');
assert.true(hasOwn(arr3, '1'), 'reviver-array-non-configurable-prop-delete-2');
assert.same(arr3[1], 2, 'reviver-array-non-configurable-prop-delete-3');
const obj2 = parse('{"a": 1, "b": 2}', function (key, value) {
if (key === 'a') defineProperty(this, 'b', { configurable: false });
if (key === 'b') return 22;
return value;
});
assert.same(obj2.a, 1, 'reviver-object-non-configurable-prop-create-1');
assert.same(obj2.b, 2, 'reviver-object-non-configurable-prop-create-2');
const obj3 = parse('{"a": 1, "b": 2}', function (key, value) {
if (key === 'a') defineProperty(this, 'b', { configurable: false });
if (key === 'b') return;
return value;
});
assert.same(obj3.a, 1, 'reviver-object-non-configurable-prop-delete-1');
assert.true(hasOwn(obj3, 'b'), 'reviver-object-non-configurable-prop-delete-2');
assert.same(obj3.b, 2, 'reviver-object-non-configurable-prop-delete-3');
assert.throws(() => parse('[0,0]', function () {
defineProperty(this, '1', { get: () => { throw new EvalError('t262'); } });
}), EvalError, 'reviver-get-name-err');
}
assert.throws(() => parse('0', () => { throw new EvalError('t262'); }), EvalError, 'reviver-call-err');
// FF20- enumeration order issue
if (keys({ k: 1, 2: 3 })[0] === '2') {
const calls = [];
parse('{"p1":0,"p2":0,"p1":0,"2":0,"1":0}', (name, val) => {
calls.push(name);
return val;
});
// The empty string is the _rootName_ in JSON.parse
assert.arrayEqual(calls, ['1', '2', 'p1', 'p2', ''], 'reviver-call-order');
}
assert.throws(() => parse(), SyntaxError, 'no args');
});
QUnit.test('JSON.parse source access', assert => {
const { parse } = JSON;
const spy = (k, v, { source: $source }) => source = $source;
let source;
parse('1234', spy);
assert.same(source, '1234', '1234');
parse('"1234"', spy);
assert.same(source, '"1234"', '"1234"');
parse('null', spy);
assert.same(source, 'null', 'null');
parse('true', spy);
assert.same(source, 'true', 'true');
parse('false', spy);
assert.same(source, 'false', 'false');
parse('{}', spy);
assert.same(source, undefined, '{}');
parse('[]', spy);
assert.same(source, undefined, '[]');
parse('9007199254740993', spy);
assert.same(source, '9007199254740993', '9007199254740993');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.json.raw-json.js
|
JavaScript
|
import { FREEZING } from '../helpers/constants.js';
QUnit.test('JSON.rawJSON', assert => {
const { rawJSON, stringify } = JSON;
const { isFrozen, hasOwn } = Object;
assert.isFunction(rawJSON);
assert.arity(rawJSON, 1);
assert.name(rawJSON, 'rawJSON');
assert.looksNative(rawJSON);
const raw = rawJSON(1);
assert.true(hasOwn(raw, 'rawJSON'), 'own rawJSON');
assert.same(raw.rawJSON, '1', 'is string 1');
if (FREEZING) assert.true(isFrozen(raw), 'frozen');
assert.same(stringify(rawJSON('"qwe"')), '"qwe"');
assert.same(stringify(rawJSON('null')), 'null');
assert.same(stringify(rawJSON('true')), 'true');
assert.same(stringify(rawJSON('9007199254740993')), '9007199254740993');
assert.same(stringify({ key: rawJSON('9007199254740993') }), '{"key":9007199254740993}');
assert.same(stringify([rawJSON('9007199254740993')]), '[9007199254740993]');
assert.throws(() => rawJSON('"qwe'), SyntaxError, 'invalid 1');
assert.throws(() => rawJSON({}), SyntaxError, 'invalid 2');
assert.throws(() => rawJSON(''), SyntaxError, 'invalid 3');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.json.stringify.js
|
JavaScript
|
// Some tests adopted from Test262 project and governed by the BSD license.
// Copyright (c) 2012 Ecma International. All rights reserved.
/* eslint-disable es/no-bigint,unicorn/no-hex-escape -- testing */
import { DESCRIPTORS, GLOBAL } from '../helpers/constants.js';
if (GLOBAL.JSON?.stringify) {
QUnit.test('JSON.stringify', assert => {
const { stringify } = JSON;
const { defineProperty, keys, values } = Object;
assert.isFunction(stringify);
assert.arity(stringify, 3);
assert.name(stringify, 'stringify');
assert.looksNative(stringify);
assert.same(stringify({ a: 1, b: 2 }, []), '{}', 'replacer-array-empty-1');
assert.same(stringify({ a: 1, b: { c: 2 } }, []), '{}', 'replacer-array-empty-2');
assert.same(stringify([1, { a: 2 }], []), '[1,{}]', 'replacer-array-empty-3');
const num1 = new Number(10);
num1.toString = () => 'toString';
num1.valueOf = () => { throw new EvalError('should not be called'); };
assert.same(stringify({
10: 1,
toString: 2,
valueOf: 3,
}, [num1]), '{"toString":2}', 'replacer-array-number-object');
const obj1 = {
0: 0,
1: 1,
'-4': 2,
0.3: 3,
'-Infinity': 4,
NaN: 5,
};
assert.same(stringify(obj1, [
-0,
1,
-4,
0.3,
-Infinity,
NaN,
]), stringify(obj1), 'replacer-array-number');
const str1 = new String('str');
str1.toString = () => 'toString';
str1.valueOf = () => { throw new EvalError('should not be called'); };
assert.same(stringify({
str: 1,
toString: 2,
valueOf: 3,
}, [str1]), '{"toString":2}', 'replacer-array-string-object');
assert.same(stringify({ undefined: 1 }, [undefined]), '{}', 'replacer-array-undefined-1');
// eslint-disable-next-line no-sparse-arrays -- testing
assert.same(stringify({ key: 1, undefined: 2 }, [,,,]), '{}', 'replacer-array-undefined-2');
const sparse = Array(3);
sparse[1] = 'key';
assert.same(stringify({ undefined: 1, key: 2 }, sparse), '{"key":2}', 'replacer-array-undefined-3');
assert.throws(() => stringify({}, () => { throw new EvalError('should not be called'); }), EvalError, 'replacer-function-abrupt');
const calls = [];
const b1 = [1, 2];
const b2 = { c1: true, c2: false };
const a1 = {
b1,
b2: {
toJSON() { return b2; },
},
};
const obj2 = { a1, a2: 'a2' };
assert.same(stringify(obj2, function (key, value) {
if (key !== '') calls.push([this, key, value]);
return value;
}), stringify(obj2), 'replacer-function-arguments-1');
assert.arrayEqual(calls[0], [obj2, 'a1', a1], 'replacer-function-arguments-2');
assert.arrayEqual(calls[1], [a1, 'b1', b1], 'replacer-function-arguments-3');
assert.arrayEqual(calls[2], [b1, '0', 1], 'replacer-function-arguments-4');
assert.arrayEqual(calls[3], [b1, '1', 2], 'replacer-function-arguments-5');
assert.arrayEqual(calls[4], [a1, 'b2', b2], 'replacer-function-arguments-6');
assert.arrayEqual(calls[5], [b2, 'c1', true], 'replacer-function-arguments-7');
assert.arrayEqual(calls[6], [b2, 'c2', false], 'replacer-function-arguments-8');
assert.arrayEqual(calls[7], [obj2, 'a2', 'a2'], 'replacer-function-arguments-9');
const circular1 = [{}];
assert.throws(() => stringify(circular1, () => circular1), TypeError, 'replacer-function-array-circular');
const direct1 = { prop: {} };
assert.throws(() => stringify(direct1, () => direct1), TypeError, 'replacer-function-object-circular-1');
const indirect1 = { p1: { p2: {} } };
assert.throws(() => stringify(indirect1, (key, value) => key === 'p2' ? indirect1 : value), TypeError, 'replacer-function-object-circular-2');
assert.same(stringify(1, () => { /* empty */ }), undefined, 'replacer-function-result-undefined-1');
assert.same(stringify([1], () => { /* empty */ }), undefined, 'replacer-function-result-undefined-2');
assert.same(stringify({ prop: 1 }, () => { /* empty */ }), undefined, 'replacer-function-result-undefined-3');
assert.same(stringify([1], (key, value) => value === 1 ? undefined : value), '[null]', 'replacer-function-result-undefined-4');
assert.same(stringify({ prop: 1 }, (key, value) => value === 1 ? undefined : value), '{}', 'replacer-function-result-undefined-5');
assert.same(stringify({ a: { b: [1] } }, (key, value) => value === 1 ? undefined : value), '{"a":{"b":[null]}}', 'replacer-function-result-undefined-6');
assert.same(stringify(null, (key, value) => {
assert.same(value, null);
switch (key) {
case '': return { a1: null, a2: null };
case 'a1': return { b1: null, b2: null };
case 'a2': return 'a2';
case 'b1': return [null, null];
case 'b2': return { c1: null, c2: null };
case '0': return 1;
case '1': return 2;
case 'c1': return true;
case 'c2': return false;
} throw new EvalError('unreachable');
}), stringify({
a1: {
b1: [1, 2],
b2: {
c1: true,
c2: false,
},
},
a2: 'a2',
}), 'replacer-function-result');
assert.same(stringify({
toJSON() { return 'toJSON'; },
}, (_key, value) => `${ value }|replacer`), '"toJSON|replacer"', 'replacer-function-tojson-1');
assert.same(stringify({
toJSON() { return { calls: 'toJSON' }; },
}, (_key, value) => {
if (value && value.calls) value.calls += '|replacer';
return value;
}), '{"calls":"toJSON|replacer"}', 'replacer-function-tojson-2');
const obj4 = { key: [1] };
const json1 = '{"key":[1]}';
assert.same(stringify(obj4, {}), json1, 'replacer-wrong-type-1');
assert.same(stringify(obj4, new String('str')), json1, 'replacer-wrong-type-2');
assert.same(stringify(obj4, new Number(6.1)), json1, 'replacer-wrong-type-3');
assert.same(stringify(obj4, null), json1, 'replacer-wrong-type-4');
assert.same(stringify(obj4, ''), json1, 'replacer-wrong-type-5');
assert.same(stringify(obj4, 0), json1, 'replacer-wrong-type-6');
assert.same(stringify(obj4, Symbol('stringify replacer test')), json1, 'replacer-wrong-type-7');
assert.same(stringify(obj4, true), json1, 'replacer-wrong-type-8');
const obj5 = {
a1: {
b1: [1, 2, 3, 4],
b2: {
c1: 1,
c2: 2,
},
},
a2: 'a2',
};
assert.same(stringify(obj5, null, -1.99999), stringify(obj5, null, -1), 'space-number-float-1');
assert.same(stringify(obj5, null, new Number(5.11111)), stringify(obj5, null, 5), 'space-number-float-2');
assert.same(stringify(obj5, null, 6.99999), stringify(obj5, null, 6), 'space-number-float-3');
assert.same(stringify(obj5, null, new Number(1)), stringify(obj5, null, 1), 'space-number-object-1');
const num2 = new Number(1);
num2.toString = () => { throw new EvalError('should not be called'); };
num2.valueOf = () => 3;
assert.same(stringify(obj5, null, num2), stringify(obj5, null, 3), 'space-number-object-2');
const abrupt1 = new Number(4);
abrupt1.toString = () => { throw new EvalError('t262'); };
abrupt1.valueOf = () => { throw new EvalError('t262'); };
assert.throws(() => stringify(obj5, null, abrupt1), EvalError, 'space-number-object-3');
assert.same(stringify(obj5, null, new Number(-5)), stringify(obj5, null, 0), 'space-number-range-1');
assert.same(stringify(obj5, null, 10), stringify(obj5, null, 100), 'space-number-range-2');
assert.same(stringify(obj5, null, 0), stringify(obj5, null, ''), 'space-number-1');
assert.same(stringify(obj5, null, 4), stringify(obj5, null, ' '), 'space-number-2');
assert.same(stringify(obj5, null, new String('xxx')), stringify(obj5, null, 'xxx'), 'space-string-object-1');
const str2 = new String('xxx');
str2.toString = () => '---';
str2.valueOf = () => { throw new EvalError('should not be called'); };
assert.same(stringify(obj5, null, str2), stringify(obj5, null, '---'), 'space-string-object-2');
const abrupt2 = new String('xxx');
abrupt2.toString = () => { throw new EvalError('t262'); };
abrupt2.valueOf = () => { throw new EvalError('t262'); };
assert.throws(() => stringify(obj5, null, abrupt2), EvalError, 'space-string-object-3');
assert.same(stringify(obj5, null, '0123456789xxxxxxxxx'), stringify(obj5, null, '0123456789'), 'space-string-range');
assert.same(stringify(obj5, null, ''), stringify(obj5), 'space-string-1');
assert.same(stringify(obj5, null, ' '), `{
"a1": {
"b1": [
1,
2,
3,
4
],
"b2": {
"c1": 1,
"c2": 2
}
},
"a2": "a2"
}`, 'space-string-2');
assert.same(stringify(obj5), stringify(obj5, null, null), 'space-wrong-type-1');
assert.same(stringify(obj5), stringify(obj5, null, true), 'space-wrong-type-2');
assert.same(stringify(obj5), stringify(obj5, null, new Boolean(false)), 'space-wrong-type-3');
assert.same(stringify(obj5), stringify(obj5, null, Symbol('stringify space test')), 'space-wrong-type-4');
assert.same(stringify(obj5), stringify(obj5, null, {}), 'space-wrong-type-5');
const direct2 = [];
direct2.push(direct2);
assert.throws(() => stringify(direct2), TypeError, 'value-array-circular-1');
const indirect2 = [];
indirect2.push([[indirect2]]);
assert.throws(() => stringify(indirect2), TypeError, 'value-array-circular-2');
if (typeof BigInt == 'function') {
assert.same(stringify(BigInt(0), (k, v) => typeof v === 'bigint' ? 'bigint' : v), '"bigint"', 'value-bigint-replacer-1');
assert.same(stringify({ x: BigInt(0) }, (k, v) => typeof v === 'bigint' ? 'bigint' : v), '{"x":"bigint"}', 'value-bigint-replacer-2');
assert.throws(() => stringify(BigInt(0)), TypeError, 'value-bigint-1');
assert.throws(() => stringify(Object(BigInt(0))), TypeError, 'value-bigint-2');
assert.throws(() => stringify({ x: BigInt(0) }), TypeError, 'value-bigint-3');
}
assert.same(stringify(new Boolean(true)), 'true', 'value-boolean-object-1');
assert.same(stringify({
toJSON() {
return { key: new Boolean(false) };
},
}), '{"key":false}', 'value-boolean-object-2');
assert.same(stringify([1], (k, v) => v === 1 ? new Boolean(true) : v), '[true]', 'value-boolean-object-3');
assert.same(stringify(() => { /* empty */ }), undefined, 'value-function-1');
assert.same(stringify([() => { /* empty */ }]), '[null]', 'value-function-2');
assert.same(stringify({ key() { /* empty */ } }), '{}', 'value-function-3');
assert.same(stringify(-0), '0', 'value-number-negative-zero-1');
assert.same(stringify(['-0', 0, -0]), '["-0",0,0]', 'value-number-negative-zero-2');
assert.same(stringify({ key: -0 }), '{"key":0}', 'value-number-negative-zero-3');
assert.same(stringify(Infinity), 'null', 'value-number-non-finite-1');
assert.same(stringify({ key: -Infinity }), '{"key":null}', 'value-number-non-finite-2');
assert.same(stringify([NaN]), '[null]', 'value-number-non-finite-3');
assert.same(stringify(new Number(8.5)), '8.5', 'value-number-object-1');
assert.same(stringify(['str'], (key, value) => {
if (value === 'str') {
const num = new Number(42);
num.toString = () => { throw new EvalError('should not be called'); };
num.valueOf = () => 2;
return num;
} return value;
}), '[2]', 'value-number-object-2');
assert.throws(() => stringify({
key: {
toJSON() {
const num = new Number(3.14);
num.toString = () => { throw new EvalError('t262'); };
num.valueOf = () => { throw new EvalError('t262'); };
return num;
},
},
}), EvalError, 'value-number-object-3');
const direct3 = { prop: null };
direct3.prop = direct3;
assert.throws(() => stringify(direct3), TypeError, 'value-object-circular-1');
const indirect3 = { p1: { p2: {} } };
indirect3.p1.p2.p3 = indirect3;
assert.throws(() => stringify(indirect3), TypeError, 'value-object-circular-2');
assert.same(stringify(null), 'null', 'null');
assert.same(stringify(true), 'true', 'true');
assert.same(stringify(false), 'false', 'false');
assert.same(stringify('str'), '"str"', '"str"');
assert.same(stringify(123), '123', '123');
assert.same(stringify(undefined), undefined, 'undefined');
const charToJson = {
'"': '\\"',
'\\': '\\\\',
'\x00': '\\u0000',
'\x01': '\\u0001',
'\x02': '\\u0002',
'\x03': '\\u0003',
'\x04': '\\u0004',
'\x05': '\\u0005',
'\x06': '\\u0006',
'\x07': '\\u0007',
'\x08': '\\b',
'\x09': '\\t',
'\x0A': '\\n',
'\x0B': '\\u000b',
'\x0C': '\\f',
'\x0D': '\\r',
'\x0E': '\\u000e',
'\x0F': '\\u000f',
'\x10': '\\u0010',
'\x11': '\\u0011',
'\x12': '\\u0012',
'\x13': '\\u0013',
'\x14': '\\u0014',
'\x15': '\\u0015',
'\x16': '\\u0016',
'\x17': '\\u0017',
'\x18': '\\u0018',
'\x19': '\\u0019',
'\x1A': '\\u001a',
'\x1B': '\\u001b',
'\x1C': '\\u001c',
'\x1D': '\\u001d',
'\x1E': '\\u001e',
'\x1F': '\\u001f',
};
const chars = keys(charToJson).join('');
const charsReversed = keys(charToJson).reverse().join('');
const jsonChars = values(charToJson).join('');
const jsonCharsReversed = values(charToJson).reverse().join('');
const json = stringify({ [`name${ chars }${ charsReversed }`]: `${ charsReversed }${ chars }value` });
for (const chr in charToJson) {
const count = json.split(charToJson[chr]).length - 1;
assert.same(count, 4, `Every ASCII 0x${ chr.charCodeAt(0).toString(16) } serializes to ${ charToJson[chr] }`);
}
assert.same(
json,
`{"name${ jsonChars }${ jsonCharsReversed }":"${ jsonCharsReversed }${ jsonChars }value"}`,
'JSON.stringify(objectUsingControlCharacters)',
);
assert.same(stringify('\uD834'), '"\\ud834"', 'JSON.stringify("\\uD834")');
assert.same(stringify('\uDF06'), '"\\udf06"', 'JSON.stringify("\\uDF06")');
assert.same(stringify('\uD834\uDF06'), '"𝌆"', 'JSON.stringify("\\uD834\\uDF06")');
assert.same(stringify('\uD834\uD834\uDF06\uD834'), '"\\ud834𝌆\\ud834"', 'JSON.stringify("\\uD834\\uD834\\uDF06\\uD834")');
assert.same(stringify('\uD834\uD834\uDF06\uDF06'), '"\\ud834𝌆\\udf06"', 'JSON.stringify("\\uD834\\uD834\\uDF06\\uDF06")');
assert.same(stringify('\uDF06\uD834\uDF06\uD834'), '"\\udf06𝌆\\ud834"', 'JSON.stringify("\\uDF06\\uD834\\uDF06\\uD834")');
assert.same(stringify('\uDF06\uD834\uDF06\uDF06'), '"\\udf06𝌆\\udf06"', 'JSON.stringify("\\uDF06\\uD834\\uDF06\\uDF06")');
assert.same(stringify('\uDF06\uD834'), '"\\udf06\\ud834"', 'JSON.stringify("\\uDF06\\uD834")');
assert.same(stringify('\uD834\uDF06\uD834\uD834'), '"𝌆\\ud834\\ud834"', 'JSON.stringify("\\uD834\\uDF06\\uD834\\uD834")');
assert.same(stringify('\uD834\uDF06\uD834\uDF06'), '"𝌆𝌆"', 'JSON.stringify("\\uD834\\uDF06\\uD834\\uDF06")');
assert.same(stringify('\uDF06\uDF06\uD834\uD834'), '"\\udf06\\udf06\\ud834\\ud834"', 'JSON.stringify("\\uDF06\\uDF06\\uD834\\uD834")');
assert.same(stringify('\uDF06\uDF06\uD834\uDF06'), '"\\udf06\\udf06𝌆"', 'JSON.stringify("\\uDF06\\uDF06\\uD834\\uDF06")');
assert.same(stringify(new String('str')), '"str"', 'value-string-object-1');
assert.same(stringify({
key: {
toJSON() {
const str = new String('str');
str.toString = () => 'toString';
str.valueOf = () => { throw new EvalError('should not be called'); };
return str;
},
},
}), '{"key":"toString"}', 'value-string-object-2');
assert.throws(() => stringify([true], (key, value) => {
if (value === true) {
const str = new String('str');
str.toString = () => { throw new EvalError('t262'); };
str.valueOf = () => { throw new EvalError('t262'); };
return str;
} return value;
}), 'value-string-object-3');
assert.throws(() => stringify({
toJSON() { throw new EvalError('t262'); },
}), EvalError, 'value-tojson-abrupt-1');
let callCount = 0;
let $this, $key;
const obj6 = {
toJSON(key) {
callCount += 1;
$this = this;
$key = key;
},
};
assert.same(stringify(obj6), undefined, 'value-tojson-arguments-1');
assert.same(callCount, 1, 'value-tojson-arguments-2');
assert.same($this, obj6, 'value-tojson-arguments-3');
assert.same($key, '', 'value-tojson-arguments-4');
assert.same(stringify([1, obj6, 3]), '[1,null,3]', 'value-tojson-arguments-5');
assert.same(callCount, 2, 'value-tojson-arguments-6');
assert.same($this, obj6, 'value-tojson-arguments-7');
// some old implementations (like WebKit) could pass numbers as keys
// assert.same($key, '1', 'value-tojson-arguments-8');
assert.same(stringify({ key: obj6 }), '{}', 'value-tojson-arguments-9');
assert.same(callCount, 3, 'value-tojson-arguments-10');
assert.same($this, obj6, 'value-tojson-arguments-11');
assert.same($key, 'key', 'value-tojson-arguments-12');
const arr1 = [];
const circular2 = [arr1];
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- testing
arr1.toJSON = () => circular2;
assert.throws(() => stringify(circular2), TypeError, 'value-tojson-array-circular');
assert.same(stringify({ toJSON: null }), '{"toJSON":null}', 'value-tojson-not-function-1');
assert.same(stringify({ toJSON: false }), '{"toJSON":false}', 'value-tojson-not-function-2');
assert.same(stringify({ toJSON: [] }), '{"toJSON":[]}', 'value-tojson-not-function-3');
assert.same(stringify({ toJSON: /re/ }), '{"toJSON":{}}', 'value-tojson-not-function-4');
const obj7 = {};
const circular3 = { prop: obj7 };
obj7.toJSON = () => circular3;
assert.throws(() => stringify(circular3), TypeError, 'value-tojson-object-circular');
assert.same(stringify({ toJSON() { return [false]; } }), '[false]', 'value-tojson-result-1');
const arr2 = [true];
// eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- testing
arr2.toJSON = () => { /* empty */ };
assert.same(stringify(arr2), undefined, 'value-tojson-result-2');
const str3 = new String('str');
// eslint-disable-next-line es/no-nonstandard-string-prototype-properties -- testing
str3.toJSON = () => null;
assert.same(stringify({ key: str3 }), '{"key":null}', 'value-tojson-result-3');
const num3 = new Number(14);
// eslint-disable-next-line es/no-nonstandard-number-prototype-properties -- testing
num3.toJSON = () => ({ key: 7 });
assert.same(stringify([num3]), '[{"key":7}]', 'value-tojson-result-4');
if (DESCRIPTORS) {
// This getter will be triggered during enumeration, but the property it adds should not be enumerated.
/* IE issue
const o = defineProperty({
p1: 'p1',
p2: 'p2',
p3: 'p3',
}, 'add', {
enumerable: true,
get() {
o.extra = 'extra';
return 'add';
},
});
o.p4 = 'p4';
o[2] = '2';
o[0] = '0';
o[1] = '1';
delete o.p1;
delete o.p3;
o.p1 = 'p1';
assert.same(stringify(o), '{"0":"0","1":"1","2":"2","p2":"p2","add":"add","p4":"p4","p1":"p1"}', 'property-order');
*/
let getCalls = 0;
assert.same(stringify(defineProperty({}, 'key', {
enumerable: true,
get() {
getCalls += 1;
return true;
},
}), ['key', 'key']), '{"key":true}', 'replacer-array-duplicates-1');
assert.same(getCalls, 1, 'replacer-array-duplicates-2');
/* old WebKit bug - however, fixing of this is not in priority
const obj3 = defineProperty({}, 'a', {
enumerable: true,
get() {
delete this.b;
return 1;
},
});
obj3.b = 2;
assert.same(stringify(obj3, (key, value) => {
if (key === 'b') {
assert.same(value, undefined, 'replacer-function-object-deleted-property-1');
return '<replaced>';
} return value;
}), '{"a":1,"b":"<replaced>"}', 'replacer-function-object-deleted-property-2');
*/
assert.throws(() => stringify({ key: defineProperty(Array(1), '0', {
get() { throw new EvalError('t262'); },
}) }), EvalError, 'value-array-abrupt');
assert.throws(() => stringify(defineProperty({}, 'key', {
enumerable: true,
get() { throw new EvalError('t262'); },
})), EvalError, 'value-object-abrupt');
assert.throws(() => stringify(defineProperty({}, 'toJSON', {
get() { throw new EvalError('t262'); },
})), EvalError, 'value-tojson-abrupt-2');
}
});
QUnit.test('Symbols & JSON.stringify', assert => {
const { stringify } = JSON;
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 => {
const { stringify } = JSON;
assert.same(stringify({ foo: 'bar' }), '{"foo":"bar"}', 'basic');
assert.same(stringify('\uDEAD'), '"\\udead"', 'r1');
assert.same(stringify('\uDF06\uD834'), '"\\udf06\\ud834"', 'r2');
assert.same(stringify('\uDF06ab\uD834'), '"\\udf06ab\\ud834"', 'r3');
assert.same(stringify('𠮷'), '"𠮷"', 'r4');
assert.same(stringify('\uD834\uDF06'), '"𝌆"', 'r5');
assert.same(stringify('\uD834\uD834\uDF06'), '"\\ud834𝌆"', 'r6');
assert.same(stringify('\uD834\uDF06\uDF06'), '"𝌆\\udf06"', 'r7');
assert.same(stringify({ '𠮷': ['\uDF06\uD834'] }), '{"𠮷":["\\udf06\\ud834"]}', 'r8');
});
}
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.map.get-or-insert-computed.js
|
JavaScript
|
import { STRICT } from '../helpers/constants.js';
QUnit.test('Map#getOrInsertComputed', assert => {
const { getOrInsertComputed } = Map.prototype;
const { from } = Array;
assert.isFunction(getOrInsertComputed);
assert.arity(getOrInsertComputed, 2);
assert.name(getOrInsertComputed, 'getOrInsertComputed');
assert.looksNative(getOrInsertComputed);
assert.nonEnumerable(Map.prototype, 'getOrInsertComputed');
let map = new Map([['a', 2]]);
assert.same(map.getOrInsertComputed('a', () => 3), 2, 'result#1');
assert.deepEqual(from(map), [['a', 2]], 'map#1');
map = new Map([['a', 2]]);
assert.same(map.getOrInsertComputed('b', () => 3), 3, 'result#2');
assert.deepEqual(from(map), [['a', 2], ['b', 3]], 'map#2');
map = new Map([['a', 2]]);
map.getOrInsertComputed('a', () => assert.avoid());
map = new Map([['a', 2]]);
map.getOrInsertComputed('b', function (key) {
if (STRICT) assert.same(this, undefined, 'correct handler in callback');
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(key, 'b', 'correct key in callback');
});
map = new Map([['a', 2]]);
map.getOrInsertComputed(-0, key => assert.same(key, 0, 'CanonicalizeKeyedCollectionKey'));
assert.throws(() => new Map().getOrInsertComputed('a', {}), TypeError, 'non-callable#1');
assert.throws(() => new Map().getOrInsertComputed('a', 1), TypeError, 'non-callable#2');
assert.throws(() => new Map().getOrInsertComputed('a', null), TypeError, 'non-callable#3');
assert.throws(() => new Map().getOrInsertComputed('a', undefined), TypeError, 'non-callable#4');
assert.throws(() => new Map().getOrInsertComputed('a'), TypeError, 'non-callable#5');
assert.throws(() => getOrInsertComputed.call({}, 'a', () => 3), TypeError, 'non-generic#1');
assert.throws(() => getOrInsertComputed.call([], 'a', () => 3), TypeError, 'non-generic#2');
assert.throws(() => getOrInsertComputed.call(undefined, 'a', () => 3), TypeError, 'non-generic#3');
assert.throws(() => getOrInsertComputed.call(null, 'a', () => 3), TypeError, 'non-generic#4');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.map.get-or-insert.js
|
JavaScript
|
QUnit.test('Map#getOrInsert', assert => {
const { getOrInsert } = Map.prototype;
const { from } = Array;
assert.isFunction(getOrInsert);
assert.arity(getOrInsert, 2);
assert.name(getOrInsert, 'getOrInsert');
assert.looksNative(getOrInsert);
assert.nonEnumerable(Map.prototype, 'getOrInsert');
let map = new Map([['a', 2]]);
assert.same(map.getOrInsert('a', 3), 2, 'result#1');
assert.deepEqual(from(map), [['a', 2]], 'map#1');
map = new Map([['a', 2]]);
assert.same(map.getOrInsert('b', 3), 3, 'result#2');
assert.deepEqual(from(map), [['a', 2], ['b', 3]], 'map#2');
assert.throws(() => getOrInsert.call({}, 'a', 1), TypeError, 'non-generic#1');
assert.throws(() => getOrInsert.call([], 'a', 1), TypeError, 'non-generic#2');
assert.throws(() => getOrInsert.call(undefined, 'a', 1), TypeError, 'non-generic#3');
assert.throws(() => getOrInsert.call(null, 'a', 1), TypeError, 'non-generic#4');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.map.group-by.js
|
JavaScript
|
import { createIterable } from '../helpers/helpers.js';
QUnit.test('Map.groupBy', assert => {
const { groupBy } = Map;
const toArray = Array.from;
assert.isFunction(groupBy);
assert.arity(groupBy, 2);
assert.name(groupBy, 'groupBy');
assert.looksNative(groupBy);
assert.nonEnumerable(Map, 'groupBy');
assert.true(Map.groupBy([], it => it) instanceof Map);
assert.deepEqual(toArray(groupBy([], it => it)), []);
assert.deepEqual(toArray(groupBy([1, 2], it => it ** 2)), [[1, [1]], [4, [2]]]);
assert.deepEqual(toArray(groupBy([1, 2, 1], it => it ** 2)), [[1, [1, 1]], [4, [2]]]);
assert.deepEqual(toArray(groupBy(createIterable([1, 2]), it => it ** 2)), [[1, [1]], [4, [2]]]);
assert.deepEqual(toArray(groupBy('qwe', it => it)), [['q', ['q']], ['w', ['w']], ['e', ['e']]], 'iterable string');
const element = {};
groupBy([element], function (it, i) {
assert.same(arguments.length, 2);
assert.same(it, element);
assert.same(i, 0);
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.map.js
|
JavaScript
|
/* eslint-disable sonarjs/no-element-overwrite -- required for testing */
import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants.js';
import { createIterable, is, nativeSubclass } from '../helpers/helpers.js';
const Symbol = GLOBAL.Symbol || {};
const { getOwnPropertyDescriptor, keys, getOwnPropertyNames, getOwnPropertySymbols, freeze } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
QUnit.test('Map', assert => {
assert.isFunction(Map);
assert.arity(Map, 0);
assert.name(Map, 'Map');
assert.looksNative(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 [][Symbol.iterator].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');
}
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);
assert.arity(Map.prototype.clear, 0);
assert.name(Map.prototype.clear, 'clear');
assert.looksNative(Map.prototype.clear);
assert.nonEnumerable(Map.prototype, 'clear');
let map = new Map();
map.clear();
assert.same(map.size, 0);
map = new Map();
map.set(1, 2);
map.set(2, 3);
map.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();
map.set(1, 2);
map.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);
assert.arity(Map.prototype.delete, 1);
if (NATIVE) assert.name(Map.prototype.delete, 'delete');
assert.looksNative(Map.prototype.delete);
assert.nonEnumerable(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);
assert.arity(Map.prototype.forEach, 1);
assert.name(Map.prototype.forEach, 'forEach');
assert.looksNative(Map.prototype.forEach);
assert.nonEnumerable(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);
assert.name(Map.prototype.get, 'get');
assert.arity(Map.prototype.get, 1);
assert.looksNative(Map.prototype.get);
assert.nonEnumerable(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);
assert.name(Map.prototype.has, 'has');
assert.arity(Map.prototype.has, 1);
assert.looksNative(Map.prototype.has);
assert.nonEnumerable(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);
assert.name(Map.prototype.set, 'set');
assert.arity(Map.prototype.set, 2);
assert.looksNative(Map.prototype.set);
assert.nonEnumerable(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 => {
assert.nonEnumerable(Map.prototype, 'size');
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();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.nonEnumerable(iterator, 'next');
assert.nonEnumerable(iterator, Symbol.iterator);
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);
assert.name(Map.prototype.keys, 'keys');
assert.arity(Map.prototype.keys, 0);
assert.looksNative(Map.prototype.keys);
assert.nonEnumerable(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);
assert.name(Map.prototype.values, 'values');
assert.arity(Map.prototype.values, 0);
assert.looksNative(Map.prototype.values);
assert.nonEnumerable(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);
assert.name(Map.prototype.entries, 'entries');
assert.arity(Map.prototype.entries, 0);
assert.looksNative(Map.prototype.entries);
assert.nonEnumerable(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 => {
assert.isIterable(Map.prototype);
assert.name(Map.prototype.entries, 'entries');
assert.arity(Map.prototype.entries, 0);
assert.looksNative(Map.prototype[Symbol.iterator]);
assert.same(Map.prototype[Symbol.iterator], Map.prototype.entries);
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map[Symbol.iterator]();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], 'Map Iterator');
assert.same(String(iterator), '[object Map Iterator]');
assert.deepEqual(iterator.next(), {
value: ['a', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['s', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['d', 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.acosh.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.acosh', assert => {
const { acosh } = Math;
assert.isFunction(acosh);
assert.name(acosh, 'acosh');
assert.arity(acosh, 1);
assert.looksNative(acosh);
assert.nonEnumerable(Math, 'acosh');
assert.same(acosh(NaN), NaN);
assert.same(acosh(0.5), NaN);
assert.same(acosh(-1), NaN);
assert.same(acosh(-1e300), NaN);
assert.same(acosh(1), 0);
assert.same(acosh(Infinity), Infinity);
assert.closeTo(acosh(1234), 7.811163220849231, 1e-11);
assert.closeTo(acosh(8.88), 2.8737631531629235, 1e-11);
assert.closeTo(acosh(1e+160), 369.10676205960726, 1e-11);
assert.closeTo(acosh(Number.MAX_VALUE), 710.475860073944, 1e-11);
assert.closeTo(acosh(1 + Number.EPSILON), 2.1073424255447017e-8, 1e-11);
const checker = createConversionChecker(1234);
assert.closeTo(acosh(checker), 7.811163220849231, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.asinh.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.asinh', assert => {
const { asinh } = Math;
assert.isFunction(asinh);
assert.name(asinh, 'asinh');
assert.arity(asinh, 1);
assert.looksNative(asinh);
assert.nonEnumerable(Math, 'asinh');
assert.same(asinh(NaN), NaN);
assert.same(asinh(0), 0);
assert.same(asinh(-0), -0);
assert.same(asinh(Infinity), Infinity);
assert.same(asinh(-Infinity), -Infinity);
assert.closeTo(asinh(1234), 7.811163549201245, 1e-11);
assert.closeTo(asinh(9.99), 2.997227420191335, 1e-11);
assert.closeTo(asinh(1e150), 346.0809111296668, 1e-11);
assert.closeTo(asinh(1e7), 16.811242831518268, 1e-11);
assert.closeTo(asinh(-1e7), -16.811242831518268, 1e-11);
const checker = createConversionChecker(1234);
assert.closeTo(asinh(checker), 7.811163549201245, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.atanh.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.atanh', assert => {
const { atanh } = Math;
assert.isFunction(atanh);
assert.name(atanh, 'atanh');
assert.arity(atanh, 1);
assert.looksNative(atanh);
assert.nonEnumerable(Math, 'atanh');
assert.same(atanh(NaN), NaN);
assert.same(atanh(-2), NaN);
assert.same(atanh(-1.5), NaN);
assert.same(atanh(2), NaN);
assert.same(atanh(1.5), NaN);
assert.same(atanh(-1), -Infinity);
assert.same(atanh(1), Infinity);
assert.same(atanh(0), 0);
assert.same(atanh(-0), -0);
assert.same(atanh(-1e300), NaN);
assert.same(atanh(1e300), NaN);
assert.closeTo(atanh(0.5), 0.5493061443340549, 1e-11);
assert.closeTo(atanh(-0.5), -0.5493061443340549, 1e-11);
assert.closeTo(atanh(0.444), 0.47720201260109457, 1e-11);
assert.closeTo(atanh(1e-10), 1e-10, 1e-25, 'small value 1e-10');
assert.closeTo(atanh(1e-17), 1e-17, 1e-32, 'small value 1e-17');
assert.notSame(atanh(1e-20), 0, 'atanh(1e-20) should not be 0');
const checker = createConversionChecker(0.5);
assert.closeTo(atanh(checker), 0.5493061443340549, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.cbrt.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.cbrt', assert => {
const { cbrt } = Math;
assert.isFunction(cbrt);
assert.name(cbrt, 'cbrt');
assert.arity(cbrt, 1);
assert.looksNative(cbrt);
assert.nonEnumerable(Math, 'cbrt');
assert.same(cbrt(NaN), NaN);
assert.same(cbrt(0), 0);
assert.same(cbrt(-0), -0);
assert.same(cbrt(Infinity), Infinity);
assert.same(cbrt(-Infinity), -Infinity);
assert.same(cbrt(-8), -2);
assert.same(cbrt(8), 2);
assert.closeTo(cbrt(-1000), -10, 1e-11);
assert.closeTo(cbrt(1000), 10, 1e-11);
const checker = createConversionChecker(1000);
assert.closeTo(cbrt(checker), 10, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.clz32.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.clz32', assert => {
const { clz32 } = Math;
assert.isFunction(clz32);
assert.name(clz32, 'clz32');
assert.arity(clz32, 1);
assert.looksNative(clz32);
assert.nonEnumerable(Math, 'clz32');
assert.same(clz32(0), 32);
assert.same(clz32(1), 31);
assert.same(clz32(-1), 0);
assert.same(clz32(0.6), 32);
assert.same(clz32(2 ** 32 - 1), 0);
assert.same(clz32(2 ** 32), 32);
const checker = createConversionChecker(1);
assert.same(clz32(checker), 31, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.cosh.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.cosh', assert => {
const { cosh } = Math;
assert.isFunction(cosh);
assert.name(cosh, 'cosh');
assert.arity(cosh, 1);
assert.looksNative(cosh);
assert.nonEnumerable(Math, 'cosh');
assert.same(cosh(NaN), NaN);
assert.same(cosh(0), 1);
assert.same(cosh(-0), 1);
assert.same(cosh(Infinity), Infinity);
assert.same(cosh(-Infinity), Infinity);
assert.closeTo(cosh(12), 81377.395712574, 1e-9);
assert.closeTo(cosh(22), 1792456423.065796, 1e-5);
assert.closeTo(cosh(-10), 11013.232920103323, 1e-11);
assert.closeTo(cosh(-23), 4872401723.124452, 1e-5);
assert.closeTo(cosh(710), 1.1169973830808557e+308, 1e+295);
const checker = createConversionChecker(12);
assert.closeTo(cosh(checker), 81377.395712574, 1e-9, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.expm1.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.expm1', assert => {
const { expm1 } = Math;
assert.isFunction(expm1);
assert.name(expm1, 'expm1');
assert.arity(expm1, 1);
assert.looksNative(expm1);
assert.nonEnumerable(Math, 'expm1');
assert.same(expm1(NaN), NaN);
assert.same(expm1(0), 0);
assert.same(expm1(-0), -0);
assert.same(expm1(Infinity), Infinity);
assert.same(expm1(-Infinity), -1);
assert.closeTo(expm1(10), 22025.465794806718, 1e-11);
assert.closeTo(expm1(-10), -0.9999546000702375, 1e-11);
const checker = createConversionChecker(10);
assert.closeTo(expm1(checker), 22025.465794806718, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.f16round.js
|
JavaScript
|
// some asserts based on https://github.com/petamoriken/float16/blob/master/test/f16round.js
import { createConversionChecker } from '../helpers/helpers.js';
const { MAX_VALUE, MIN_VALUE } = Number;
QUnit.test('Math.f16round', assert => {
const { f16round } = Math;
assert.isFunction(f16round);
assert.name(f16round, 'f16round');
assert.arity(f16round, 1);
assert.looksNative(f16round);
assert.nonEnumerable(Math, 'f16round');
assert.same(f16round(), NaN);
assert.same(f16round(undefined), NaN);
assert.same(f16round(NaN), NaN);
assert.same(f16round(null), 0);
assert.same(f16round(0), 0);
assert.same(f16round(-0), -0);
assert.same(f16round(MIN_VALUE), 0);
assert.same(f16round(-MIN_VALUE), -0);
assert.same(f16round(Infinity), Infinity);
assert.same(f16round(-Infinity), -Infinity);
assert.same(f16round(MAX_VALUE), Infinity);
assert.same(f16round(-MAX_VALUE), -Infinity);
const MAX_FLOAT16 = 65504;
const MIN_FLOAT16 = 2 ** -24;
assert.same(f16round(MAX_FLOAT16), MAX_FLOAT16);
assert.same(f16round(-MAX_FLOAT16), -MAX_FLOAT16);
assert.same(f16round(MIN_FLOAT16), MIN_FLOAT16);
assert.same(f16round(-MIN_FLOAT16), -MIN_FLOAT16);
assert.same(f16round(MIN_FLOAT16 / 2), 0);
assert.same(f16round(-MIN_FLOAT16 / 2), -0);
assert.same(f16round(2.980232238769531911744490042422139897126953655970282852649688720703125e-8), MIN_FLOAT16);
assert.same(f16round(-2.980232238769531911744490042422139897126953655970282852649688720703125e-8), -MIN_FLOAT16);
assert.same(f16round(1.337), 1.3369140625);
assert.same(f16round(0.499994), 0.5);
assert.same(f16round(7.9999999), 8);
const checker = createConversionChecker(1.1);
assert.same(f16round(checker), 1.099609375, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.fround.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
const { MAX_VALUE, MIN_VALUE } = Number;
QUnit.test('Math.fround', assert => {
const { fround } = Math;
assert.isFunction(fround);
assert.name(fround, 'fround');
assert.arity(fround, 1);
assert.looksNative(fround);
assert.nonEnumerable(Math, 'fround');
assert.same(fround(), NaN);
assert.same(fround(undefined), NaN);
assert.same(fround(NaN), NaN);
assert.same(fround(null), 0);
assert.same(fround(0), 0);
assert.same(fround(-0), -0);
assert.same(fround(MIN_VALUE), 0);
assert.same(fround(-MIN_VALUE), -0);
assert.same(fround(Infinity), Infinity);
assert.same(fround(-Infinity), -Infinity);
assert.same(fround(MAX_VALUE), Infinity);
assert.same(fround(-MAX_VALUE), -Infinity);
assert.same(fround(3.4028235677973366e+38), Infinity);
assert.same(fround(3), 3);
assert.same(fround(-3), -3);
const maxFloat32 = 3.4028234663852886e+38;
const minFloat32 = 1.401298464324817e-45;
assert.same(fround(maxFloat32), maxFloat32);
assert.same(fround(-maxFloat32), -maxFloat32);
assert.same(fround(maxFloat32 + 2 ** 102), maxFloat32);
assert.same(fround(minFloat32), minFloat32);
assert.same(fround(-minFloat32), -minFloat32);
assert.same(fround(minFloat32 / 2), 0);
assert.same(fround(-minFloat32 / 2), -0);
assert.same(fround(minFloat32 / 2 + 2 ** -202), minFloat32);
assert.same(fround(-minFloat32 / 2 - 2 ** -202), -minFloat32);
const maxSubnormal32 = 1.1754942106924411e-38;
const minNormal32 = 1.1754943508222875e-38;
assert.same(fround(1.1754942807573642e-38), maxSubnormal32, 'fround(1.1754942807573642e-38)');
assert.same(fround(1.1754942807573643e-38), minNormal32, 'fround(1.1754942807573643e-38)');
assert.same(fround(1.1754942807573644e-38), minNormal32, 'fround(1.1754942807573644e-38)');
assert.same(fround(-1.1754942807573642e-38), -maxSubnormal32, 'fround(-1.1754942807573642e-38)');
assert.same(fround(-1.1754942807573643e-38), -minNormal32, 'fround(-1.1754942807573643e-38)');
assert.same(fround(-1.1754942807573644e-38), -minNormal32, 'fround(-1.1754942807573644e-38)');
const checker = createConversionChecker(1.1754942807573642e-38);
assert.same(fround(checker), maxSubnormal32, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.hypot.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.hypot', assert => {
const { hypot, sqrt } = Math;
assert.isFunction(hypot);
assert.name(hypot, 'hypot');
assert.arity(hypot, 2);
assert.looksNative(hypot);
assert.nonEnumerable(Math, 'hypot');
assert.same(hypot(), 0);
assert.same(hypot(1), 1);
assert.same(hypot('', 0), 0);
assert.same(hypot(0, ''), 0);
assert.same(hypot(Infinity, 0), Infinity, 'Infinity, 0');
assert.same(hypot(-Infinity, 0), Infinity, '-Infinity, 0');
assert.same(hypot(0, Infinity), Infinity, '0, Infinity');
assert.same(hypot(0, -Infinity), Infinity, '0, -Infinity');
assert.same(hypot(Infinity, NaN), Infinity, 'Infinity, NaN');
assert.same(hypot(NaN, -Infinity), Infinity, 'NaN, -Infinity');
assert.same(hypot(NaN, 0), NaN, 'NaN, 0');
assert.same(hypot(0, NaN), NaN, '0, NaN');
assert.same(hypot(0, -0), 0);
assert.same(hypot(0, 0), 0);
assert.same(hypot(-0, -0), 0);
assert.same(hypot(-0, 0), 0);
assert.same(hypot(0, 1), 1);
assert.same(hypot(0, -1), 1);
assert.same(hypot(-0, 1), 1);
assert.same(hypot(-0, -1), 1);
assert.same(hypot(0), 0);
assert.same(hypot(1), 1);
assert.same(hypot(2), 2);
assert.same(hypot(0, 0, 1), 1);
assert.same(hypot(0, 1, 0), 1);
assert.same(hypot(1, 0, 0), 1);
assert.same(hypot(2, 3, 4), sqrt(2 ** 2 + 3 ** 2 + 4 ** 2));
assert.same(hypot(2, 3, 4, 5), sqrt(2 ** 2 + 3 ** 2 + 4 ** 2 + 5 ** 2));
assert.closeTo(hypot(66, 66), 93.33809511662427, 1e-11);
assert.closeTo(hypot(0.1, 100), 100.0000499999875, 1e-11);
assert.same(hypot(1e+300, 1e+300), 1.4142135623730952e+300);
assert.same(Math.floor(hypot(1e-300, 1e-300) * 1e308), 141421356);
assert.same(hypot(1e+300, 1e+300, 2, 3), 1.4142135623730952e+300);
assert.same(hypot(-3, 4), 5);
assert.same(hypot(3, -4), 5);
const checker1 = createConversionChecker(2);
const checker2 = createConversionChecker(3);
const checker3 = createConversionChecker(4);
const checker4 = createConversionChecker(5);
assert.same(hypot(checker1, checker2, checker3, checker4), sqrt(2 ** 2 + 3 ** 2 + 4 ** 2 + 5 ** 2), 'object wrapper');
assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
assert.same(checker1.$toString, 0, 'checker1 toString calls');
assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
assert.same(checker2.$toString, 0, 'checker2 toString calls');
assert.same(checker3.$valueOf, 1, 'checker3 valueOf calls');
assert.same(checker3.$toString, 0, 'checker3 toString calls');
assert.same(checker4.$valueOf, 1, 'checker4 valueOf calls');
assert.same(checker4.$toString, 0, 'checker4 toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.imul.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.imul', assert => {
const { imul } = Math;
assert.isFunction(imul);
assert.name(imul, 'imul');
assert.arity(imul, 2);
assert.looksNative(imul);
assert.nonEnumerable(Math, 'imul');
assert.same(imul(0, 0), 0);
assert.same(imul(123, 456), 56088);
assert.same(imul(-123, 456), -56088);
assert.same(imul(123, -456), -56088);
assert.same(imul(19088743, 4275878552), 602016552);
assert.same(imul(false, 7), 0);
assert.same(imul(7, false), 0);
assert.same(imul(false, false), 0);
assert.same(imul(true, 7), 7);
assert.same(imul(7, true), 7);
assert.same(imul(true, true), 1);
assert.same(imul(undefined, 7), 0);
assert.same(imul(7, undefined), 0);
assert.same(imul(undefined, undefined), 0);
assert.same(imul('str', 7), 0);
assert.same(imul(7, 'str'), 0);
assert.same(imul({}, 7), 0);
assert.same(imul(7, {}), 0);
assert.same(imul([], 7), 0);
assert.same(imul(7, []), 0);
assert.same(imul(0xFFFFFFFF, 5), -5);
assert.same(imul(0xFFFFFFFE, 5), -10);
assert.same(imul(2, 4), 8);
assert.same(imul(-1, 8), -8);
assert.same(imul(-2, -2), 4);
assert.same(imul(-0, 7), 0);
assert.same(imul(7, -0), 0);
assert.same(imul(0.1, 7), 0);
assert.same(imul(7, 0.1), 0);
assert.same(imul(0.9, 7), 0);
assert.same(imul(7, 0.9), 0);
assert.same(imul(1.1, 7), 7);
assert.same(imul(7, 1.1), 7);
assert.same(imul(1.9, 7), 7);
assert.same(imul(7, 1.9), 7);
const checker1 = createConversionChecker(-123);
const checker2 = createConversionChecker(456);
assert.same(imul(checker1, checker2), -56088, 'object wrapper');
assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
assert.same(checker1.$toString, 0, 'checker1 toString calls');
assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
assert.same(checker2.$toString, 0, 'checker2 toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.log10.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.log10', assert => {
const { log10 } = Math;
assert.isFunction(log10);
assert.name(log10, 'log10');
assert.arity(log10, 1);
assert.looksNative(log10);
assert.nonEnumerable(Math, 'log10');
assert.same(log10(''), log10(0));
assert.same(log10(NaN), NaN);
assert.same(log10(-1), NaN);
assert.same(log10(0), -Infinity);
assert.same(log10(-0), -Infinity);
assert.same(log10(1), 0);
assert.same(log10(Infinity), Infinity);
assert.closeTo(log10(0.1), -1, 1e-11);
assert.closeTo(log10(0.5), -0.3010299956639812, 1e-11);
assert.closeTo(log10(1.5), 0.17609125905568124, 1e-11);
assert.closeTo(log10(5), 0.6989700043360189, 1e-11);
assert.closeTo(log10(50), 1.6989700043360187, 1e-11);
assert.closeTo(log10(1000), 3, 1e-11);
const checker = createConversionChecker(0.5);
assert.closeTo(log10(checker), -0.3010299956639812, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.log1p.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.log1p', assert => {
const { log1p } = Math;
assert.isFunction(log1p);
assert.name(log1p, 'log1p');
assert.arity(log1p, 1);
assert.looksNative(log1p);
assert.nonEnumerable(Math, 'log1p');
assert.same(log1p(''), log1p(0));
assert.same(log1p(NaN), NaN);
assert.same(log1p(-2), NaN);
assert.same(log1p(-1), -Infinity);
assert.same(log1p(0), 0);
assert.same(log1p(-0), -0);
assert.same(log1p(Infinity), Infinity);
assert.closeTo(log1p(5), 1.791759469228055, 1e-11);
assert.closeTo(log1p(50), 3.9318256327243257, 1e-11);
const checker = createConversionChecker(5);
assert.closeTo(log1p(checker), 1.791759469228055, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.log2.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.log2', assert => {
const { log2 } = Math;
assert.isFunction(log2);
assert.name(log2, 'log2');
assert.arity(log2, 1);
assert.looksNative(log2);
assert.nonEnumerable(Math, 'log2');
assert.same(log2(''), log2(0));
assert.same(log2(NaN), NaN);
assert.same(log2(-1), NaN);
assert.same(log2(0), -Infinity);
assert.same(log2(-0), -Infinity);
assert.same(log2(1), 0);
assert.same(log2(Infinity), Infinity);
assert.same(log2(0.5), -1);
assert.same(log2(32), 5);
assert.closeTo(log2(5), 2.321928094887362, 1e-11);
const checker = createConversionChecker(5);
assert.closeTo(log2(checker), 2.321928094887362, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.sign.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.sign', assert => {
const { sign } = Math;
assert.isFunction(sign);
assert.name(sign, 'sign');
assert.arity(sign, 1);
assert.looksNative(sign);
assert.nonEnumerable(Math, 'sign');
assert.same(sign(NaN), NaN);
assert.same(sign(), NaN);
assert.same(sign(-0), -0);
assert.same(sign(0), 0);
assert.same(sign(Infinity), 1);
assert.same(sign(-Infinity), -1);
assert.same(sign(13510798882111488), 1);
assert.same(sign(-13510798882111488), -1);
assert.same(sign(42.5), 1);
assert.same(sign(-42.5), -1);
const checker = createConversionChecker(-42.5);
assert.same(sign(checker), -1, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.sinh.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.sinh', assert => {
const { sinh } = Math;
assert.isFunction(sinh);
assert.name(sinh, 'sinh');
assert.arity(sinh, 1);
assert.looksNative(sinh);
assert.nonEnumerable(Math, 'sinh');
assert.same(sinh(NaN), NaN);
assert.same(sinh(0), 0);
assert.same(sinh(-0), -0);
assert.same(sinh(Infinity), Infinity);
assert.same(sinh(-Infinity), -Infinity);
assert.closeTo(sinh(-5), -74.20321057778875, 1e-11);
assert.closeTo(sinh(2), 3.6268604078470186, 1e-11);
assert.same(sinh(-2e-17), -2e-17);
const checker = createConversionChecker(-5);
assert.closeTo(sinh(checker), -74.20321057778875, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.sum-precise.js
|
JavaScript
|
/* eslint-disable @stylistic/max-len -- ok */
import { createIterable } from '../helpers/helpers.js';
QUnit.test('Math.sumPrecise', assert => {
const { sumPrecise } = Math;
assert.isFunction(sumPrecise);
assert.name(sumPrecise, 'sumPrecise');
assert.arity(sumPrecise, 1);
assert.looksNative(sumPrecise);
assert.nonEnumerable(Math, 'sumPrecise');
assert.same(sumPrecise([1, 2, 3]), 6, 'basic');
assert.same(sumPrecise(createIterable([1, 2, 3])), 6, 'custom iterable');
assert.throws(() => sumPrecise(undefined), TypeError, 'undefined');
assert.throws(() => sumPrecise(null), TypeError, 'null');
assert.throws(() => sumPrecise({ 0: 1 }), TypeError, 'non-iterable');
assert.throws(() => sumPrecise(1, 2), TypeError, 'non-iterable #2');
assert.throws(() => sumPrecise([1, '2']), TypeError, 'non-number elements');
// Adapted from https://github.com/tc39/test262
// Copyright (C) 2024 Kevin Gibbons. All rights reserved.
// This code is governed by the BSD license
assert.same(sumPrecise([NaN]), NaN, '[NaN]');
assert.same(sumPrecise([Infinity, -Infinity]), NaN, '[Infinity, -Infinity]');
assert.same(sumPrecise([-Infinity, Infinity]), NaN, '[-Infinity, Infinity]');
assert.same(sumPrecise([Infinity]), Infinity, '[Infinity]');
assert.same(sumPrecise([Infinity, Infinity]), Infinity, '[Infinity, Infinity]');
assert.same(sumPrecise([-Infinity]), -Infinity, '[-Infinity]');
assert.same(sumPrecise([-Infinity, -Infinity]), -Infinity, '[-Infinity, -Infinity]');
assert.same(sumPrecise([]), -0, '[]');
assert.same(sumPrecise([-0]), -0, '[-0]');
assert.same(sumPrecise([-0, -0]), -0, '[-0, -0]');
assert.same(sumPrecise([-0, 0]), 0, '[-0, 0]');
assert.same(sumPrecise([1e308]), 1e308, '[1e308]');
assert.same(sumPrecise([1e308, -1e308]), 0, '[1e308, -1e308]');
assert.same(sumPrecise([0.1]), 0.1, '[0.1]');
assert.same(sumPrecise([0.1, 0.1]), 0.2, '[0.1, 0.1]');
assert.same(sumPrecise([0.1, -0.1]), 0, '[0.1, -0.1]');
assert.same(sumPrecise([1e308, 1e308, 0.1, 0.1, 1e30, 0.1, -1e30, -1e308, -1e308]), 0.30000000000000004, '[1e308, 1e308, 0.1, 0.1, 1e30, 0.1, -1e30, -1e308, -1e308]');
assert.same(sumPrecise([1e30, 0.1, -1e30]), 0.1, '[1e30, 0.1, -1e30]');
assert.same(sumPrecise([8.98846567431158e+307, 8.988465674311579e+307, -Number.MAX_VALUE]), 9.9792015476736e+291, '[8.98846567431158e+307, 8.988465674311579e+307, -Number.MAX_VALUE]');
assert.same(sumPrecise([-5.630637621603525e+255, 9.565271205476345e+307, 2.9937604643020797e+292]), 9.565271205476347e+307, '[-5.630637621603525e+255, 9.565271205476345e+307, 2.9937604643020797e+292]');
assert.same(sumPrecise([6.739986666787661e+66, 2, -1.2689709186578243e-116, 1.7046015739467354e+308, -9.979201547673601e+291, 6.160926733208294e+307, -3.179557053031852e+234, -7.027282978772846e+307, -0.7500000000000001]), 1.61796594939028e+308, '[6.739986666787661e+66, 2, -1.2689709186578243e-116, 1.7046015739467354e+308, -9.979201547673601e+291, 6.160926733208294e+307, -3.179557053031852e+234, -7.027282978772846e+307, -0.7500000000000001]');
assert.same(sumPrecise([0.31150493246968836, -8.988465674311582e+307, 1.8315037361673755e-270, -15.999999999999996, 2.9999999999999996, 7.345200721499384e+164, -2.033582473639399, -8.98846567431158e+307, -3.5737295155405993e+292, 4.13894772383715e-124, -3.6111186457260667e-35, 2.387234887098013e+180, 7.645295562778372e-298, 3.395189016861822e-103, -2.6331611115768973e-149]), -Infinity, '[0.31150493246968836, -8.988465674311582e+307, 1.8315037361673755e-270, -15.999999999999996, 2.9999999999999996, 7.345200721499384e+164, -2.033582473639399, -8.98846567431158e+307, -3.5737295155405993e+292, 4.13894772383715e-124, -3.6111186457260667e-35, 2.387234887098013e+180, 7.645295562778372e-298, 3.395189016861822e-103, -2.6331611115768973e-149]');
assert.same(sumPrecise([-1.1442589134409902e+308, 9.593842098384855e+138, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]), -1.5936821971565685e+308, '[-1.1442589134409902e+308, 9.593842098384855e+138, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]');
assert.same(sumPrecise([-1.1442589134409902e+308, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]), -1.5936821971565687e+308, '[-1.1442589134409902e+308, 4.494232837155791e+307, -1.3482698511467367e+308, 4.494232837155792e+307]');
assert.same(sumPrecise([9.593842098384855e+138, -6.948356297254111e+307, -1.3482698511467367e+308, 4.494232837155792e+307]), -1.5936821971565685e+308, '[9.593842098384855e+138, -6.948356297254111e+307, -1.3482698511467367e+308, 4.494232837155792e+307]');
assert.same(sumPrecise([-2.534858246857893e+115, 8.988465674311579e+307, 8.98846567431158e+307]), Number.MAX_VALUE, '[-2.534858246857893e+115, 8.988465674311579e+307, 8.98846567431158e+307]');
assert.same(sumPrecise([1.3588124894186193e+308, 1.4803986201152006e+223, 6.741349255733684e+307]), Infinity, '[1.3588124894186193e+308, 1.4803986201152006e+223, 6.741349255733684e+307]');
assert.same(sumPrecise([6.741349255733684e+307, 1.7976931348623155e+308, -7.388327292663961e+41]), Infinity, '[6.741349255733684e+307, 1.7976931348623155e+308, -7.388327292663961e+41]');
assert.same(sumPrecise([-1.9807040628566093e+28, Number.MAX_VALUE, 9.9792015476736e+291]), Number.MAX_VALUE, '[-1.9807040628566093e+28, Number.MAX_VALUE, 9.9792015476736e+291]');
assert.same(sumPrecise([-1.0214557991173964e+61, Number.MAX_VALUE, 8.98846567431158e+307, -8.988465674311579e+307]), Number.MAX_VALUE, '[-1.0214557991173964e+61, Number.MAX_VALUE, 8.98846567431158e+307, -8.988465674311579e+307]');
assert.same(sumPrecise([Number.MAX_VALUE, 7.999999999999999, -1.908963895403937e-230, 1.6445950082320264e+292, 2.0734856707605806e+205]), Infinity, '[Number.MAX_VALUE, 7.999999999999999, -1.908963895403937e-230, 1.6445950082320264e+292, 2.0734856707605806e+205]');
assert.same(sumPrecise([6.197409167220438e-223, -9.979201547673601e+291, -Number.MAX_VALUE]), -Infinity, '[6.197409167220438e-223, -9.979201547673601e+291, -Number.MAX_VALUE]');
assert.same(sumPrecise([4.49423283715579e+307, 8.944251746776101e+307, -0.0002441406250000001, 1.1752060710043817e+308, 4.940846717201632e+292, -1.6836699406454528e+308]), 8.353845887521184e+307, '[4.49423283715579e+307, 8.944251746776101e+307, -0.0002441406250000001, 1.1752060710043817e+308, 4.940846717201632e+292, -1.6836699406454528e+308]');
assert.same(sumPrecise([8.988465674311579e+307, 7.999999999999998, 7.029158107234023e-308, -2.2303483759420562e-172, -Number.MAX_VALUE, -8.98846567431158e+307]), -Number.MAX_VALUE, '8.988465674311579e+307, 7.999999999999998, 7.029158107234023e-308, -2.2303483759420562e-172, -Number.MAX_VALUE, -8.98846567431158e+307]');
assert.same(sumPrecise([8.98846567431158e+307, 8.98846567431158e+307]), Infinity, '[8.98846567431158e+307, 8.98846567431158e+307]');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.tanh.js
|
JavaScript
|
import { NATIVE } from '../helpers/constants.js';
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.tanh', assert => {
const { tanh } = Math;
assert.isFunction(tanh);
assert.name(tanh, 'tanh');
assert.arity(tanh, 1);
assert.looksNative(tanh);
assert.nonEnumerable(Math, 'tanh');
assert.same(tanh(NaN), NaN);
assert.same(tanh(0), 0);
assert.same(tanh(-0), -0);
assert.same(tanh(Infinity), 1);
assert.same(tanh(90), 1);
assert.closeTo(tanh(10), 0.9999999958776927, 1e-11);
if (NATIVE) assert.same(tanh(710), 1);
const checker = createConversionChecker(10);
assert.closeTo(tanh(checker), 0.9999999958776927, 1e-11);
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.to-string-tag.js
|
JavaScript
|
QUnit.test('Math[@@toStringTag]', assert => {
assert.same(Math[Symbol.toStringTag], 'Math', 'Math[@@toStringTag] is `Math`');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.math.trunc.js
|
JavaScript
|
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.trunc', assert => {
const { trunc } = Math;
assert.isFunction(trunc);
assert.name(trunc, 'trunc');
assert.arity(trunc, 1);
assert.looksNative(trunc);
assert.nonEnumerable(Math, 'trunc');
assert.same(trunc(NaN), NaN, 'NaN -> NaN');
assert.same(trunc(-0), -0, '-0 -> -0');
assert.same(trunc(0), 0, '0 -> 0');
assert.same(trunc(Infinity), Infinity, 'Infinity -> Infinity');
assert.same(trunc(-Infinity), -Infinity, '-Infinity -> -Infinity');
assert.same(trunc(null), 0, 'null -> 0');
assert.same(trunc({}), NaN, '{} -> NaN');
assert.same(trunc([]), 0, '[] -> 0');
assert.same(trunc(1.01), 1, '1.01 -> 0');
assert.same(trunc(1.99), 1, '1.99 -> 0');
assert.same(trunc(-1), -1, '-1 -> -1');
assert.same(trunc(-1.99), -1, '-1.99 -> -1');
assert.same(trunc(-555.555), -555, '-555.555 -> -555');
assert.same(trunc(9007199254740992), 9007199254740992, '9007199254740992 -> 9007199254740992');
assert.same(trunc(-9007199254740992), -9007199254740992, '-9007199254740992 -> -9007199254740992');
const checker = createConversionChecker(-1.99);
assert.same(trunc(checker), -1, 'object wrapper');
assert.same(checker.$valueOf, 1, 'valueOf calls');
assert.same(checker.$toString, 0, 'toString calls');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.constructor.js
|
JavaScript
|
import { WHITESPACES } from '../helpers/constants.js';
import { nativeSubclass } from '../helpers/helpers.js';
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.arity(Number, 1);
assert.name(Number, 'Number');
assert.looksNative(Number);
assert.same(Number.prototype.constructor, Number);
assert.same(1.0.constructor, Number);
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(Object.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(Object.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);
if (nativeSubclass) {
const Subclass = nativeSubclass(Number);
assert.true(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.true(new Subclass() instanceof Number, 'correct subclassing with native classes #2');
assert.same(new Subclass(1).toFixed(2), '1.00', 'correct subclassing with native classes #3');
}
});
QUnit.test('Number constructor: binary', assert => {
const check = getCheck(assert);
check('0b1', 1);
check('0B1', 1);
check('0b12', NaN);
check('0b234', NaN);
check('0b1!', NaN);
check('+0b1', NaN);
check('-0b1', NaN);
check(' 0b1', 1);
check('0b1\n', 1);
check('\n 0b1\n ', 1);
check(' 0B1', 1);
check('0B1\n', 1);
check('\n 0B1\n ', 1);
check({
valueOf() {
return '0b11';
},
}, 3);
check({
toString() {
return '0b111';
},
}, 7);
check({
valueOf() {
return '0b101010';
},
}, 42);
check({
toString() {
return '0b101010';
},
}, 42);
check(`${ WHITESPACES }0b11`, 3);
check(`0b11${ WHITESPACES }`, 3);
check(`${ WHITESPACES }0b11${ WHITESPACES }`, 3);
check(`${ WHITESPACES }0B11`, 3);
check(`0B11${ WHITESPACES }`, 3);
check(`${ WHITESPACES }0B11${ WHITESPACES }`, 3);
});
QUnit.test('Number constructor: octal', assert => {
const check = getCheck(assert);
check('0o7', 7);
check('0O7', 7);
check('0o18', NaN);
check('0o89a', NaN);
check('0o1!', NaN);
check('+0o1', NaN);
check('-0o1', NaN);
check(' 0o1', 1);
check('0o1\n', 1);
check('\n 0o1\n ', 1);
check(' 0O1', 1);
check('0O1\n', 1);
check('\n 0O1\n ', 1);
check({
valueOf() {
return '0o77';
},
}, 63);
check({
toString() {
return '0o777';
},
}, 511);
check({
valueOf() {
return '0o12345';
},
}, 5349);
check({
toString() {
return '0o12345';
},
}, 5349);
check(`${ WHITESPACES }0o11`, 9);
check(`0o11${ WHITESPACES }`, 9);
check(`${ WHITESPACES }0o11${ WHITESPACES }`, 9);
check(`${ WHITESPACES }0O11`, 9);
check(`0O11${ WHITESPACES }`, 9);
check(`${ WHITESPACES }0O11${ WHITESPACES }`, 9);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.epsilon.js
|
JavaScript
|
QUnit.test('Number.EPSILON', assert => {
const { EPSILON } = Number;
assert.true('EPSILON' in Number, 'EPSILON in Number');
assert.nonEnumerable(Number, 'EPSILON');
assert.nonConfigurable(Number, 'EPSILON');
assert.nonWritable(Number, 'EPSILON');
// eslint-disable-next-line math/prefer-number-epsilon -- testing
assert.same(EPSILON, 2 ** -52, 'Is 2^-52');
assert.notSame(1, 1 + EPSILON, '1 is not 1 + EPSILON');
assert.same(1, 1 + EPSILON / 2, '1 is 1 + EPSILON / 2');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.is-finite.js
|
JavaScript
|
QUnit.test('Number.isFinite', assert => {
const { isFinite } = Number;
const { create } = Object;
assert.isFunction(isFinite);
assert.name(isFinite, 'isFinite');
assert.arity(isFinite, 1);
assert.looksNative(isFinite);
assert.nonEnumerable(Number, 'isFinite');
const finite = [
1,
0.1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
];
for (const value of finite) {
assert.true(isFinite(value), `isFinite ${ typeof value } ${ value }`);
}
const notFinite = [
NaN,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notFinite) {
assert.false(isFinite(value), `not isFinite ${ typeof value } ${ value }`);
}
assert.false(isFinite(create(null)), 'Number.isFinite(Object.create(null)) -> false');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.is-integer.js
|
JavaScript
|
QUnit.test('Number.isInteger', assert => {
const { isInteger } = Number;
const { create } = Object;
assert.isFunction(isInteger);
assert.name(isInteger, 'isInteger');
assert.arity(isInteger, 1);
assert.looksNative(isInteger);
assert.nonEnumerable(Number, 'isInteger');
const integers = [
1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
];
for (const value of integers) {
assert.true(isInteger(value), `isInteger ${ typeof value } ${ value }`);
}
const notIntegers = [
NaN,
0.1,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notIntegers) {
assert.false(isInteger(value), `not isInteger ${ typeof value } ${ value }`);
}
assert.false(isInteger(create(null)), 'Number.isInteger(Object.create(null)) -> false');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.is-nan.js
|
JavaScript
|
QUnit.test('Number.isNaN', assert => {
const { isNaN } = Number;
const { create } = Object;
assert.isFunction(isNaN);
assert.name(isNaN, 'isNaN');
assert.arity(isNaN, 1);
assert.looksNative(isNaN);
assert.nonEnumerable(Number, 'isNaN');
assert.true(isNaN(NaN), 'Number.isNaN NaN');
const notNaNs = [
1,
0.1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notNaNs) {
assert.false(isNaN(value), `not Number.isNaN ${ typeof value } ${ value }`);
}
assert.false(isNaN(create(null)), 'Number.isNaN(Object.create(null)) -> false');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.is-safe-integer.js
|
JavaScript
|
import { MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
QUnit.test('Number.isSafeInteger', assert => {
const { isSafeInteger } = Number;
const { create } = Object;
assert.isFunction(isSafeInteger);
assert.name(isSafeInteger, 'isSafeInteger');
assert.arity(isSafeInteger, 1);
assert.looksNative(isSafeInteger);
assert.nonEnumerable(Number, 'isSafeInteger');
const safeIntegers = [
1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
MAX_SAFE_INTEGER,
MIN_SAFE_INTEGER,
];
for (const value of safeIntegers) {
assert.true(isSafeInteger(value), `isSafeInteger ${ typeof value } ${ value }`);
}
const notSafeIntegers = [
MAX_SAFE_INTEGER + 1,
MIN_SAFE_INTEGER - 1,
NaN,
0.1,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notSafeIntegers) {
assert.false(isSafeInteger(value), `not isSafeInteger ${ typeof value } ${ value }`);
}
assert.false(isSafeInteger(create(null)), 'Number.isSafeInteger(Object.create(null)) -> false');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.max-safe-integer.js
|
JavaScript
|
QUnit.test('Number.MAX_SAFE_INTEGER', assert => {
assert.true('MAX_SAFE_INTEGER' in Number);
assert.nonEnumerable(Number, 'MAX_SAFE_INTEGER');
assert.nonConfigurable(Number, 'MAX_SAFE_INTEGER');
assert.nonWritable(Number, 'MAX_SAFE_INTEGER');
// eslint-disable-next-line math/prefer-number-max-safe-integer -- testing
assert.same(Number.MAX_SAFE_INTEGER, 2 ** 53 - 1, 'Is 2^53 - 1');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.min-safe-integer.js
|
JavaScript
|
QUnit.test('Number.MIN_SAFE_INTEGER', assert => {
assert.true('MIN_SAFE_INTEGER' in Number);
assert.nonEnumerable(Number, 'MIN_SAFE_INTEGER');
assert.nonConfigurable(Number, 'MIN_SAFE_INTEGER');
assert.nonWritable(Number, 'MIN_SAFE_INTEGER');
// eslint-disable-next-line math/prefer-number-min-safe-integer -- testing
assert.same(Number.MIN_SAFE_INTEGER, -(2 ** 53) + 1, 'Is -2^53 + 1');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.parse-float.js
|
JavaScript
|
import { GLOBAL, WHITESPACES } from '../helpers/constants.js';
QUnit.test('Number.parseFloat', assert => {
const { parseFloat } = Number;
assert.isFunction(parseFloat);
assert.name(parseFloat, 'parseFloat');
assert.arity(parseFloat, 1);
assert.looksNative(parseFloat);
assert.nonEnumerable(Number, 'parseFloat');
assert.same(parseFloat, GLOBAL.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);
if (typeof Symbol == 'function' && !Symbol.sham) {
const symbol = Symbol('Number.parseFloat test');
assert.throws(() => parseFloat(symbol), 'throws on symbol argument');
assert.throws(() => parseFloat(Object(symbol)), 'throws on boxed symbol argument');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.parse-int.js
|
JavaScript
|
/* eslint-disable prefer-numeric-literals -- required for testing */
import { GLOBAL, WHITESPACES } from '../helpers/constants.js';
QUnit.test('Number.parseInt', assert => {
const { parseInt } = Number;
assert.isFunction(parseInt);
assert.name(parseInt, 'parseInt');
assert.arity(parseInt, 2);
assert.looksNative(parseInt);
assert.nonEnumerable(Number, 'parseInt');
assert.same(parseInt, GLOBAL.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);
if (typeof Symbol == 'function' && !Symbol.sham) {
const symbol = Symbol('Number.parseInt test');
assert.throws(() => parseInt(symbol), 'throws on symbol argument');
assert.throws(() => parseInt(Object(symbol)), 'throws on boxed symbol argument');
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.to-exponential.js
|
JavaScript
|
QUnit.test('Number#toExponential', assert => {
const { toExponential } = Number.prototype;
assert.isFunction(toExponential);
assert.name(toExponential, 'toExponential');
assert.arity(toExponential, 1);
assert.looksNative(toExponential);
assert.nonEnumerable(Number.prototype, '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'); // Chakra Edge 14- / IE11- bug
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');
// somehow that randomly fails in FF16- on Linux
assert.same(toExponential.call(5, 19), '5.0000000000000000000e+0', '5, 19');
// 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');
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)');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.to-fixed.js
|
JavaScript
|
/* eslint-disable unicorn/require-number-to-fixed-digits-argument -- required for testing */
QUnit.test('Number#toFixed', assert => {
const { toFixed } = Number.prototype;
assert.isFunction(toFixed);
assert.name(toFixed, 'toFixed');
assert.arity(toFixed, 1);
assert.looksNative(toFixed);
assert.nonEnumerable(Number.prototype, 'toFixed');
assert.same(0.00008.toFixed(3), '0.000');
assert.same(0.9.toFixed(0), '1');
assert.same(1.255.toFixed(2), '1.25');
assert.same(1843654265.0774949.toFixed(5), '1843654265.07749');
assert.same(1000000000000000128.0.toFixed(0), '1000000000000000128');
assert.same(toFixed.call(1), '1');
assert.same(toFixed.call(1, 0), '1');
assert.same(toFixed.call(1, 1), '1.0');
assert.same(toFixed.call(1, 1.1), '1.0');
assert.same(toFixed.call(1, 0.9), '1');
assert.same(toFixed.call(1, '0'), '1');
assert.same(toFixed.call(1, '1'), '1.0');
assert.same(toFixed.call(1, '1.1'), '1.0');
assert.same(toFixed.call(1, '0.9'), '1');
assert.same(toFixed.call(1, NaN), '1');
assert.same(toFixed.call(1, 'some string'), '1');
assert.notThrows(() => toFixed.call(1, -0.1) === '1');
assert.same(new Number(1).toFixed(), '1');
assert.same(new Number(1).toFixed(0), '1');
assert.same(new Number(1).toFixed(1), '1.0');
assert.same(new Number(1).toFixed(1.1), '1.0');
assert.same(new Number(1).toFixed(0.9), '1');
assert.same(new Number(1).toFixed('0'), '1');
assert.same(new Number(1).toFixed('1'), '1.0');
assert.same(new Number(1).toFixed('1.1'), '1.0');
assert.same(new Number(1).toFixed('0.9'), '1');
assert.same(new Number(1).toFixed(NaN), '1');
assert.same(new Number(1).toFixed('some string'), '1');
assert.notThrows(() => new Number(1).toFixed(-0.1) === '1');
assert.same(NaN.toFixed(), 'NaN');
assert.same(NaN.toFixed(0), 'NaN');
assert.same(NaN.toFixed(1), 'NaN');
assert.same(NaN.toFixed(1.1), 'NaN');
assert.same(NaN.toFixed(0.9), 'NaN');
assert.same(NaN.toFixed('0'), 'NaN');
assert.same(NaN.toFixed('1'), 'NaN');
assert.same(NaN.toFixed('1.1'), 'NaN');
assert.same(NaN.toFixed('0.9'), 'NaN');
assert.same(NaN.toFixed(NaN), 'NaN');
assert.same(NaN.toFixed('some string'), 'NaN');
assert.notThrows(() => NaN.toFixed(-0.1) === 'NaN');
assert.same(new Number(1e21).toFixed(), String(1e21));
assert.same(new Number(1e21).toFixed(0), String(1e21));
assert.same(new Number(1e21).toFixed(1), String(1e21));
assert.same(new Number(1e21).toFixed(1.1), String(1e21));
assert.same(new Number(1e21).toFixed(0.9), String(1e21));
assert.same(new Number(1e21).toFixed('0'), String(1e21));
assert.same(new Number(1e21).toFixed('1'), String(1e21));
assert.same(new Number(1e21).toFixed('1.1'), String(1e21));
assert.same(new Number(1e21).toFixed('0.9'), String(1e21));
assert.same(new Number(1e21).toFixed(NaN), String(1e21));
assert.same(new Number(1e21).toFixed('some string'), String(1e21));
assert.notThrows(() => new Number(1e21).toFixed(-0.1) === String(1e21));
assert.throws(() => 1.0.toFixed(-101), RangeError, 'If f < 0 or f > 20 (100), throw a RangeError exception.');
assert.throws(() => 1.0.toFixed(101), RangeError, 'If f < 0 or f > 20 (100), throw a RangeError exception.');
assert.throws(() => NaN.toFixed(Infinity), RangeError, 'If f < 0 or f > 20 (100), throw a RangeError exception.');
assert.throws(() => toFixed.call({}, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed.call('123', 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed.call(false, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed.call(null, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed.call(undefined, 1), TypeError, '? thisNumberValue(this value)');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.number.to-precision.js
|
JavaScript
|
QUnit.test('Number#toPrecision', assert => {
const { toPrecision } = Number.prototype;
assert.isFunction(toPrecision);
assert.name(toPrecision, 'toPrecision');
assert.arity(toPrecision, 1);
assert.looksNative(toPrecision);
assert.nonEnumerable(Number.prototype, 'toPrecision');
assert.same(0.00008.toPrecision(3), '0.0000800', '0.00008.toPrecision(3)');
assert.same(1.255.toPrecision(2), '1.3', '1.255.toPrecision(2)');
assert.same(1843654265.0774949.toPrecision(13), '1843654265.077', '1843654265.0774949.toPrecision(13)');
assert.same(NaN.toPrecision(1), 'NaN', 'If x is NaN, return the String "NaN".');
assert.same(123.456.toPrecision(), '123.456', 'If precision is undefined, return ! ToString(x).');
assert.same(123.456.toPrecision(undefined), '123.456', 'If precision is undefined, return ! ToString(x).');
assert.throws(() => 0.9.toPrecision(0), RangeError, 'If p < 1 or p > 21, throw a RangeError exception.');
assert.throws(() => 0.9.toPrecision(101), RangeError, 'If p < 1 or p > 21, throw a RangeError exception.');
assert.throws(() => toPrecision.call({}, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision.call('123', 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision.call(false, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision.call(null, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision.call(undefined, 1), TypeError, '? thisNumberValue(this value)');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.assign.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Object.assign', assert => {
const { assign, keys, defineProperty } = Object;
assert.isFunction(assign);
assert.arity(assign, 2);
assert.name(assign, 'assign');
assert.looksNative(assign);
assert.nonEnumerable(Object, '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);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.create.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Object.create', assert => {
const { create, getPrototypeOf, getOwnPropertyNames } = Object;
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');
assert.looksNative(create);
assert.nonEnumerable(Object, 'create');
let object = { q: 1 };
assert.true({}.isPrototypeOf.call(object, create(object)));
assert.same(create(object).q, 1);
function F() {
return this.a = 1;
}
assert.true(create(new F()) instanceof F);
assert.same(F.prototype, getPrototypeOf(getPrototypeOf(create(new F()))));
assert.same(create(new F()).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(Object.create.sham, DESCRIPTORS ? undefined : true);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.define-getter.js
|
JavaScript
|
import { DESCRIPTORS, STRICT } from '../helpers/constants.js';
if (DESCRIPTORS) {
QUnit.test('Object#__defineGetter__', assert => {
const { __defineGetter__ } = Object.prototype;
assert.isFunction(__defineGetter__);
assert.arity(__defineGetter__, 2);
assert.name(__defineGetter__, '__defineGetter__');
assert.looksNative(__defineGetter__);
assert.nonEnumerable(Object.prototype, '__defineGetter__');
const object = {};
assert.same(object.__defineGetter__('key', () => 42), undefined, 'void');
assert.same(object.key, 42, 'works');
object.__defineSetter__('key', function () {
this.foo = 43;
});
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(() => __defineGetter__.call(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __defineGetter__.call(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.define-properties.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Object.defineProperties', assert => {
const { defineProperties } = Object;
assert.isFunction(defineProperties);
assert.arity(defineProperties, 2);
assert.name(defineProperties, 'defineProperties');
assert.looksNative(defineProperties);
assert.nonEnumerable(Object, '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(Object.defineProperties.sham, DESCRIPTORS ? undefined : true);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.define-property.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Object.defineProperty', assert => {
const { defineProperty, create } = Object;
assert.isFunction(defineProperty);
assert.arity(defineProperty, 3);
assert.name(defineProperty, 'defineProperty');
assert.looksNative(defineProperty);
assert.nonEnumerable(Object, '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(Object.defineProperty.sham, DESCRIPTORS ? undefined : true);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.define-setter.js
|
JavaScript
|
import { DESCRIPTORS, STRICT } from '../helpers/constants.js';
if (DESCRIPTORS) {
QUnit.test('Object#__defineSetter__', assert => {
const { __defineSetter__ } = Object.prototype;
assert.isFunction(__defineSetter__);
assert.arity(__defineSetter__, 2);
assert.name(__defineSetter__, '__defineSetter__');
assert.looksNative(__defineSetter__);
assert.nonEnumerable(Object.prototype, '__defineSetter__');
let object = {};
assert.same(object.__defineSetter__('key', function () {
this.foo = 43;
}), undefined, 'void');
object.key = 44;
assert.same(object.foo, 43, 'works');
object = {};
object.__defineSetter__('key', function () {
this.foo = 43;
});
object.__defineGetter__('key', () => 42);
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(() => __defineSetter__.call(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __defineSetter__.call(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.entries.js
|
JavaScript
|
QUnit.test('Object.entries', assert => {
const { entries, create, assign } = Object;
assert.isFunction(entries);
assert.arity(entries, 1);
assert.name(entries, 'entries');
assert.looksNative(entries);
assert.nonEnumerable(Object, '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 */ }
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.freeze.js
|
JavaScript
|
import { GLOBAL, NATIVE } from '../helpers/constants.js';
QUnit.test('Object.freeze', assert => {
const { freeze, isFrozen, keys, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
assert.isFunction(freeze);
assert.arity(freeze, 1);
assert.name(freeze, 'freeze');
assert.looksNative(freeze);
assert.nonEnumerable(Object, '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) }`);
}
if (NATIVE) assert.true(isFrozen(freeze({})));
const results = [];
for (const key in freeze({})) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(freeze({})), []);
assert.arrayEqual(getOwnPropertyNames(freeze({})), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(freeze({})), []);
if (ownKeys) assert.arrayEqual(ownKeys(freeze({})), []);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.from-entries.js
|
JavaScript
|
import { createIterable } from '../helpers/helpers.js';
QUnit.test('Object.fromEntries', assert => {
const { fromEntries } = Object;
assert.isFunction(fromEntries);
assert.arity(fromEntries, 1);
assert.name(fromEntries, 'fromEntries');
assert.looksNative(fromEntries);
assert.nonEnumerable(Object, '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);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.get-own-property-descriptor.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Object.getOwnPropertyDescriptor', assert => {
const { getOwnPropertyDescriptor } = Object;
assert.isFunction(getOwnPropertyDescriptor);
assert.arity(getOwnPropertyDescriptor, 2);
assert.name(getOwnPropertyDescriptor, 'getOwnPropertyDescriptor');
assert.looksNative(getOwnPropertyDescriptor);
assert.nonEnumerable(Object, '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(Object.getOwnPropertyDescriptor.sham, DESCRIPTORS ? undefined : true);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.get-own-property-descriptors.js
|
JavaScript
|
import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Object.getOwnPropertyDescriptors', assert => {
const { create, getOwnPropertyDescriptors } = Object;
assert.isFunction(getOwnPropertyDescriptors);
assert.arity(getOwnPropertyDescriptors, 1);
assert.name(getOwnPropertyDescriptors, 'getOwnPropertyDescriptors');
assert.looksNative(getOwnPropertyDescriptors);
assert.nonEnumerable(Object, 'getOwnPropertyDescriptors');
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(Object.getOwnPropertyDescriptors.sham, DESCRIPTORS ? undefined : true);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.get-own-property-names.js
|
JavaScript
|
import { includes } from '../helpers/helpers.js';
QUnit.test('Object.getOwnPropertyNames', assert => {
const { freeze, getOwnPropertyNames } = Object;
assert.isFunction(getOwnPropertyNames);
assert.arity(getOwnPropertyNames, 1);
assert.name(getOwnPropertyNames, 'getOwnPropertyNames');
assert.looksNative(getOwnPropertyNames);
assert.nonEnumerable(Object, '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');
}
*/
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.get-own-property-symbols.js
|
JavaScript
|
const {
getOwnPropertyNames,
getOwnPropertySymbols,
create,
} = Object;
QUnit.test('Object.getOwnPropertySymbols', assert => {
assert.isFunction(getOwnPropertySymbols);
assert.nonEnumerable(Object, 'getOwnPropertySymbols');
assert.same(getOwnPropertySymbols.length, 1, 'arity is 1');
assert.name(getOwnPropertySymbols, 'getOwnPropertySymbols');
assert.looksNative(getOwnPropertySymbols);
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 }`);
}
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.get-prototype-of.js
|
JavaScript
|
import { CORRECT_PROTOTYPE_GETTER } from '../helpers/constants.js';
QUnit.test('Object.getPrototypeOf', assert => {
const { create, getPrototypeOf } = Object;
assert.isFunction(getPrototypeOf);
assert.arity(getPrototypeOf, 1);
assert.name(getPrototypeOf, 'getPrototypeOf');
assert.looksNative(getPrototypeOf);
assert.nonEnumerable(Object, '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(Object.getPrototypeOf.sham, CORRECT_PROTOTYPE_GETTER ? undefined : true);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.group-by.js
|
JavaScript
|
import { createIterable } from '../helpers/helpers.js';
QUnit.test('Object.groupBy', assert => {
const { groupBy, getPrototypeOf, entries } = Object;
assert.isFunction(groupBy);
assert.arity(groupBy, 2);
assert.name(groupBy, 'groupBy');
assert.looksNative(groupBy);
assert.nonEnumerable(Object, 'groupBy');
assert.same(getPrototypeOf(groupBy([], it => it)), null);
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);
assert.same(it, element);
assert.same(i, 0);
});
const even = Symbol('even');
const odd = Symbol('odd');
const grouped = Object.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]);
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.has-own.js
|
JavaScript
|
QUnit.test('Object.hasOwn', assert => {
const { create, hasOwn } = Object;
assert.isFunction(hasOwn);
assert.arity(hasOwn, 2);
assert.name(hasOwn, 'hasOwn');
assert.looksNative(hasOwn);
assert.nonEnumerable(Object, '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');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.is-extensible.js
|
JavaScript
|
import { NATIVE } from '../helpers/constants.js';
QUnit.test('Object.isExtensible', assert => {
const { preventExtensions, isExtensible } = Object;
assert.isFunction(isExtensible);
assert.arity(isExtensible, 1);
assert.name(isExtensible, 'isExtensible');
assert.nonEnumerable(Object, 'isExtensible');
assert.looksNative(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 true on ${ value }`);
}
assert.true(isExtensible({}));
if (NATIVE) assert.false(isExtensible(preventExtensions({})));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.is-frozen.js
|
JavaScript
|
import { NATIVE } from '../helpers/constants.js';
QUnit.test('Object.isFrozen', assert => {
const { freeze, isFrozen } = Object;
assert.isFunction(isFrozen);
assert.arity(isFrozen, 1);
assert.name(isFrozen, 'isFrozen');
assert.looksNative(isFrozen);
assert.nonEnumerable(Object, '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({}));
if (NATIVE) assert.true(isFrozen(freeze({})));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.is-sealed.js
|
JavaScript
|
import { NATIVE } from '../helpers/constants.js';
QUnit.test('Object.isSealed', assert => {
const { seal, isSealed } = Object;
assert.isFunction(isSealed);
assert.arity(isSealed, 1);
assert.name(isSealed, 'isSealed');
assert.looksNative(isSealed);
assert.nonEnumerable(Object, '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({}));
if (NATIVE) assert.true(isSealed(seal({})));
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.is.js
|
JavaScript
|
QUnit.test('Object.is', assert => {
const { is } = Object;
assert.isFunction(is);
assert.arity(is, 2);
assert.name(is, 'is');
assert.looksNative(is);
assert.nonEnumerable(Object, 'is');
assert.true(is(1, 1), '1 is 1');
assert.true(is(NaN, NaN), '1 is 1');
assert.false(is(0, -0), '0 is not -0');
assert.false(is({}, {}), '{} is not {}');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.keys.js
|
JavaScript
|
import { includes } from '../helpers/helpers.js';
QUnit.test('Object.keys', assert => {
const { keys } = Object;
assert.isFunction(keys);
assert.arity(keys, 1);
assert.name(keys, 'keys');
assert.looksNative(keys);
assert.nonEnumerable(Object, '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');
});
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
| |
tests/unit-global/es.object.lookup-getter.js
|
JavaScript
|
import { DESCRIPTORS, STRICT } from '../helpers/constants.js';
if (DESCRIPTORS) {
QUnit.test('Object#__lookupGetter__', assert => {
const { __lookupGetter__ } = Object.prototype;
const { create } = Object;
assert.isFunction(__lookupGetter__);
assert.arity(__lookupGetter__, 1);
assert.name(__lookupGetter__, '__lookupGetter__');
assert.looksNative(__lookupGetter__);
assert.nonEnumerable(Object.prototype, '__lookupGetter__');
assert.same({}.__lookupGetter__('key'), undefined, 'empty object');
assert.same({ key: 42 }.__lookupGetter__('key'), undefined, 'data descriptor');
const object = {};
function setter() { /* empty */ }
object.__defineGetter__('key', setter);
assert.same(object.__lookupGetter__('key'), setter, 'own getter');
assert.same(create(object).__lookupGetter__('key'), setter, 'proto getter');
assert.same(create(object).__lookupGetter__('foo'), undefined, 'empty proto');
if (STRICT) {
assert.throws(() => __lookupGetter__.call(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __lookupGetter__.call(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
|
zloirock/core-js
| 25,418
|
Standard Library
|
JavaScript
|
zloirock
|
Denis Pushkarev
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.