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,... | 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(() =... | 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]()... | 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
i... | 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(setFlo... | 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.getFul... | 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.get... | 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');
// asser... | 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).toISOStrin... | 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(), ... | 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... | 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... | 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);
... | 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('err... | 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');
asse... | 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' && ... | 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);
ass... | 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 () { /* ... | 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(Iterat... | 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 {
r... | 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 ... | 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(I... | 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);
as... | 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... | 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.no... | 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');
ass... | 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(... | 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')... | 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.nonEnumer... | 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... | 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.no... | 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(I... | 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.looksNati... | 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... | 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 }... | 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)... | 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.s... | 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');
a... | 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 = ... | 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');
... | 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, ... | 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);
asse... | 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);
asse... | 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);
asse... | 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(c... | 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.... | 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(c... | 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);
asse... | 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(f16ro... | 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,... | 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);
ass... | 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(im... | 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));
... | 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));
... | 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.sam... | 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(s... | 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(s... | 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);
ass... | 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... | 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 ->... | 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 ... | 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 -- tes... | 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,
... | 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,
... | 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 = [
... | 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.loo... | 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 -- ... | 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 -- ... | 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, 'parseFlo... | 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.looksNat... | 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... | 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... | 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.toPrecis... | 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... | 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 = getProtot... | 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__');... | 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);
asse... | 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.non... | 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__');... | 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',... | 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');... | 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, 'fromEntr... | 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')... | 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, 'getOwnPropert... | 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(getO... | 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(getOwnPro... | 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);... | 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');... | 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'));
a... | 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... | 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 primiti... | 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 primitive... | 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');
asse... | 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() {... | 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(__looku... | 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.