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.object.lookup-setter.js | JavaScript | import { DESCRIPTORS, STRICT } from '../helpers/constants.js';
if (DESCRIPTORS) {
QUnit.test('Object#__lookupSetter__', assert => {
const { __lookupSetter__ } = Object.prototype;
const { create } = Object;
assert.isFunction(__lookupSetter__);
assert.arity(__lookupSetter__, 1);
assert.name(__looku... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.object.prevent-extensions.js | JavaScript | import { GLOBAL, NATIVE } from '../helpers/constants.js';
QUnit.test('Object.preventExtensions', assert => {
const { preventExtensions, keys, isExtensible, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
assert.isFunction(preventExtensions);
assert.arity(prevent... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.object.proto.js | JavaScript | /* eslint-disable no-proto -- required for testing */
import { DESCRIPTORS, PROTO } from '../helpers/constants.js';
if (PROTO && DESCRIPTORS) QUnit.test('Object.prototype.__proto__', assert => {
assert.true('__proto__' in Object.prototype, 'in Object.prototype');
const O = {};
assert.same(O.__proto__, Object.pro... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.object.seal.js | JavaScript | import { GLOBAL, NATIVE } from '../helpers/constants.js';
QUnit.test('Object.seal', assert => {
const { seal, isSealed, keys, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
assert.isFunction(seal);
assert.arity(seal, 1);
assert.name(seal, 'seal');
assert.lo... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.object.set-prototype-of.js | JavaScript | import { PROTO } from '../helpers/constants.js';
if (PROTO) QUnit.test('Object.setPrototypeOf', assert => {
const { setPrototypeOf } = Object;
assert.isFunction(setPrototypeOf);
assert.arity(setPrototypeOf, 2);
assert.name(setPrototypeOf, 'setPrototypeOf');
assert.looksNative(setPrototypeOf);
assert.nonEnu... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.object.to-string.js | JavaScript | import { GLOBAL, STRICT } from '../helpers/constants.js';
QUnit.test('Object#toString', assert => {
const { toString } = Object.prototype;
const Symbol = GLOBAL.Symbol || {};
assert.arity(toString, 0);
assert.name(toString, 'toString');
assert.looksNative(toString);
assert.nonEnumerable(Object.prototype, '... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.object.values.js | JavaScript | QUnit.test('Object.values', assert => {
const { values, create, assign } = Object;
assert.isFunction(values);
assert.arity(values, 1);
assert.name(values, 'values');
assert.looksNative(values);
assert.nonEnumerable(Object, 'values');
assert.deepEqual(values({ q: 1, w: 2, e: 3 }), [1, 2, 3]);
assert.deep... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.parse-float.js | JavaScript | import { WHITESPACES } from '../helpers/constants.js';
QUnit.test('parseFloat', assert => {
assert.isFunction(parseFloat);
assert.name(parseFloat, 'parseFloat');
assert.arity(parseFloat, 1);
assert.looksNative(parseFloat);
assert.same(parseFloat('0'), 0);
assert.same(parseFloat(' 0'), 0);
assert.same(par... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.parse-int.js | JavaScript | /* eslint-disable prefer-numeric-literals -- required for testing */
import { WHITESPACES } from '../helpers/constants.js';
/* eslint-disable radix -- required for testing */
QUnit.test('parseInt', assert => {
assert.isFunction(parseInt);
assert.name(parseInt, 'parseInt');
assert.arity(parseInt, 2);
assert.loo... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.promise.all-settled.js | JavaScript | import { createIterable } from '../helpers/helpers.js';
QUnit.test('Promise.allSettled', assert => {
assert.isFunction(Promise.allSettled);
assert.arity(Promise.allSettled, 1);
assert.looksNative(Promise.allSettled);
assert.nonEnumerable(Promise, 'allSettled');
assert.true(Promise.allSettled([1, 2, 3]) insta... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.promise.all.js | JavaScript | import { createIterable } from '../helpers/helpers.js';
QUnit.test('Promise.all', assert => {
const { all } = Promise;
assert.isFunction(all);
assert.arity(all, 1);
assert.name(all, 'all');
assert.looksNative(all);
assert.nonEnumerable(Promise, 'all');
assert.true(Promise.all([]) instanceof Promise, 'ret... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.promise.any.js | JavaScript | import { createIterable } from '../helpers/helpers.js';
QUnit.test('Promise.any', assert => {
assert.isFunction(Promise.any);
assert.arity(Promise.any, 1);
assert.looksNative(Promise.any);
assert.nonEnumerable(Promise, 'any');
assert.true(Promise.any([1, 2, 3]) instanceof Promise, 'returns a promise');
});
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.promise.catch.js | JavaScript | import { NATIVE } from '../helpers/constants.js';
QUnit.test('Promise#catch', assert => {
assert.isFunction(Promise.prototype.catch);
if (NATIVE) assert.arity(Promise.prototype.catch, 1);
if (NATIVE) assert.name(Promise.prototype.catch, 'catch');
assert.looksNative(Promise.prototype.catch);
assert.nonEnumera... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.promise.constructor.js | JavaScript | import { DESCRIPTORS, GLOBAL, NATIVE, PROTO, STRICT } from '../helpers/constants.js';
const Symbol = GLOBAL.Symbol || {};
const { setPrototypeOf, create } = Object;
QUnit.test('Promise', assert => {
assert.isFunction(Promise);
assert.arity(Promise, 1);
assert.name(Promise, 'Promise');
assert.looksNative(Promi... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.promise.finally.js | JavaScript | QUnit.test('Promise#finally', assert => {
assert.isFunction(Promise.prototype.finally);
assert.arity(Promise.prototype.finally, 1);
assert.looksNative(Promise.prototype.finally);
assert.nonEnumerable(Promise.prototype, 'finally');
assert.true(Promise.resolve(42).finally(() => { /* empty */ }) instanceof Promi... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.promise.race.js | JavaScript | import { createIterable } from '../helpers/helpers.js';
QUnit.test('Promise.race', assert => {
const { race } = Promise;
assert.isFunction(race);
assert.arity(race, 1);
assert.name(race, 'race');
assert.looksNative(race);
assert.nonEnumerable(Promise, 'race');
assert.true(Promise.race([]) instanceof Prom... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.promise.reject.js | JavaScript | import { NATIVE } from '../helpers/constants.js';
QUnit.test('Promise.reject', assert => {
const { reject } = Promise;
assert.isFunction(reject);
if (NATIVE) assert.arity(reject, 1);
assert.name(reject, 'reject');
assert.looksNative(reject);
assert.nonEnumerable(Promise, 'reject');
});
QUnit.test('Promise... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.promise.resolve.js | JavaScript | QUnit.test('Promise.resolve', assert => {
const { resolve } = Promise;
assert.isFunction(resolve);
assert.arity(resolve, 1);
assert.name(resolve, 'resolve');
assert.looksNative(resolve);
assert.nonEnumerable(Promise, 'resolve');
assert.true(Promise.resolve(42) instanceof Promise, 'returns a promise');
});... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.promise.try.js | JavaScript | import Promise from 'core-js-pure/es/promise';
QUnit.test('Promise.try', assert => {
assert.isFunction(Promise.try);
assert.arity(Promise.try, 1);
assert.looksNative(Promise.try);
assert.nonEnumerable(Promise, 'try');
assert.true(Promise.try(() => 42) instanceof Promise, 'returns a promise');
});
QUnit.test... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.promise.with-resolvers.js | JavaScript | const { getPrototypeOf } = Object;
QUnit.test('Promise.withResolvers', assert => {
const { withResolvers } = Promise;
assert.isFunction(withResolvers);
assert.arity(withResolvers, 0);
assert.name(withResolvers, 'withResolvers');
assert.nonEnumerable(Promise, 'withResolvers');
assert.looksNative(withResolve... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.apply.js | JavaScript | QUnit.test('Reflect.apply', assert => {
const { apply } = Reflect;
assert.isFunction(apply);
assert.arity(apply, 3);
assert.name(apply, 'apply');
assert.looksNative(apply);
assert.nonEnumerable(Reflect, 'apply');
assert.same(apply(Array.prototype.push, [1, 2], [3, 4, 5]), 5);
function f(a, b, c) {
r... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.construct.js | JavaScript | QUnit.test('Reflect.construct', assert => {
const { construct } = Reflect;
const { getPrototypeOf } = Object;
assert.isFunction(construct);
assert.arity(construct, 2);
assert.name(construct, 'construct');
assert.looksNative(construct);
assert.nonEnumerable(Reflect, 'construct');
function A(a, b, c) {
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.define-property.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Reflect.defineProperty', assert => {
const { defineProperty } = Reflect;
const { getOwnPropertyDescriptor, create } = Object;
assert.isFunction(defineProperty);
assert.arity(defineProperty, 3);
assert.name(defineProperty, 'defineProperty');
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.delete-property.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Reflect.deleteProperty', assert => {
const { deleteProperty } = Reflect;
const { defineProperty, keys } = Object;
assert.isFunction(deleteProperty);
assert.arity(deleteProperty, 2... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.get-own-property-descriptor.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Reflect.getOwnPropertyDescriptor', assert => {
const { getOwnPropertyDescriptor } = Reflect;
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.reflect.get-prototype-of.js | JavaScript | import { CORRECT_PROTOTYPE_GETTER } from '../helpers/constants.js';
QUnit.test('Reflect.getPrototypeOf', assert => {
const { getPrototypeOf } = Reflect;
assert.isFunction(getPrototypeOf);
assert.arity(getPrototypeOf, 1);
assert.name(getPrototypeOf, 'getPrototypeOf');
assert.looksNative(getPrototypeOf);
ass... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.get.js | JavaScript | import { DESCRIPTORS, NATIVE } from '../helpers/constants.js';
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Reflect.get', assert => {
const { defineProperty, create } = Object;
const { get } = Reflect;
assert.isFunction(get);
if (NATIVE) assert.arity(get, 2);
assert.name(get, ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.has.js | JavaScript | QUnit.test('Reflect.has', assert => {
const { has } = Reflect;
assert.isFunction(has);
assert.arity(has, 2);
assert.name(has, 'has');
assert.looksNative(has);
assert.nonEnumerable(Reflect, 'has');
const object = { qux: 987 };
assert.true(has(object, 'qux'));
assert.false(has(object, 'qwe'));
assert.... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.is-extensible.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Reflect.isExtensible', assert => {
const { isExtensible } = Reflect;
const { preventExtensions } = Object;
assert.isFunction(isExtensible);
assert.arity(isExtensible, 1);
assert.name(isExtensible, 'isExtensible');
assert.looksNative(isExten... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.own-keys.js | JavaScript | import { includes } from '../helpers/helpers.js';
QUnit.test('Reflect.ownKeys', assert => {
const { ownKeys } = Reflect;
const { defineProperty, create } = Object;
const symbol = Symbol('c');
assert.isFunction(ownKeys);
assert.arity(ownKeys, 1);
assert.name(ownKeys, 'ownKeys');
assert.looksNative(ownKeys... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.prevent-extensions.js | JavaScript | import { DESCRIPTORS, FREEZING } from '../helpers/constants.js';
QUnit.test('Reflect.preventExtensions', assert => {
const { preventExtensions } = Reflect;
const { isExtensible } = Object;
assert.isFunction(preventExtensions);
assert.arity(preventExtensions, 1);
assert.name(preventExtensions, 'preventExtensi... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.set-prototype-of.js | JavaScript | import { NATIVE, PROTO } from '../helpers/constants.js';
if (PROTO) QUnit.test('Reflect.setPrototypeOf', assert => {
const { setPrototypeOf } = Reflect;
assert.isFunction(setPrototypeOf);
if (NATIVE) assert.arity(setPrototypeOf, 2);
assert.name(setPrototypeOf, 'setPrototypeOf');
assert.looksNative(setPrototy... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.set.js | JavaScript | import { DESCRIPTORS, NATIVE } from '../helpers/constants.js';
import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Reflect.set', assert => {
const { set } = Reflect;
const { defineProperty, getOwnPropertyDescriptor, create, getPrototypeOf } = Object;
assert.isFunction(set);
if (NATIVE)... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.reflect.to-string-tag.js | JavaScript | QUnit.test('Reflect[@@toStringTag]', assert => {
assert.same(Reflect[Symbol.toStringTag], 'Reflect', 'Reflect[@@toStringTag] is `Reflect`');
});
| zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.regexp.constructor.js | JavaScript | /* eslint-disable prefer-regex-literals, regexp/no-invalid-regexp, regexp/sort-flags -- required for testing */
/* eslint-disable regexp/no-useless-assertions, regexp/no-useless-character-class, regexp/no-useless-flag -- required for testing */
import { DESCRIPTORS, GLOBAL } from '../helpers/constants.js';
import { nat... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.regexp.dot-all.js | JavaScript | /* eslint-disable prefer-regex-literals -- required for testing */
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) {
QUnit.test('RegExp#dotAll', assert => {
const re = RegExp('.', 's');
assert.true(re.dotAll, '.dotAll is true');
assert.same(re.flags, 's', '.flags contains s');
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.regexp.escape.js | JavaScript | /* eslint-disable @stylistic/max-len -- ok*/
QUnit.test('RegExp.escape', assert => {
const { escape } = RegExp;
assert.isFunction(escape);
assert.arity(escape, 1);
assert.name(escape, 'escape');
assert.looksNative(escape);
assert.nonEnumerable(RegExp, 'escape');
assert.same(escape('10$'), '\\x310\\$', '1... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.regexp.exec.js | JavaScript | /* eslint-disable prefer-regex-literals -- required for testing */
import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('RegExp#exec lastIndex updating', assert => {
let re = /b/;
assert.same(re.lastIndex, 0, '.lastIndex starts at 0 for non-global regexps');
re.exec('abc');
assert.same(re.lastInde... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.regexp.flags.js | JavaScript | /* eslint-disable prefer-regex-literals, regexp/sort-flags, regexp/no-useless-flag -- required for testing */
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) {
QUnit.test('RegExp#flags', assert => {
assert.nonEnumerable(RegExp.prototype, 'flags');
assert.same(/./g.flags, 'g', '/./g.fl... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.regexp.sticky.js | JavaScript | /* eslint-disable prefer-regex-literals -- required for testing */
import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) {
QUnit.test('RegExp#sticky', assert => {
const re = new RegExp('a', 'y');
assert.true(re.sticky, '.sticky is true');
assert.same(re.flags, 'y', '.flags contains y');... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.regexp.test.js | JavaScript |
QUnit.test('RegExp#test delegates to exec', assert => {
const exec = function (...args) {
execCalled = true;
return /./.exec.apply(this, args);
};
let execCalled = false;
let re = /[ac]/;
re.exec = exec;
assert.true(re.test('abc'), '#1');
assert.true(execCalled, '#2');
re = /a/;
// Not a fu... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.regexp.to-string.js | JavaScript | /* eslint-disable prefer-regex-literals, regexp/sort-flags, regexp/no-useless-flag -- required for testing */
import { STRICT } from '../helpers/constants.js';
QUnit.test('RegExp#toString', assert => {
const { toString } = RegExp.prototype;
assert.isFunction(toString);
assert.arity(toString, 0);
assert.name(to... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.set.difference.js | JavaScript | import { createIterable, createSetLike } from '../helpers/helpers.js';
QUnit.test('Set#difference', assert => {
const { difference } = Set.prototype;
const { from } = Array;
assert.isFunction(difference);
assert.arity(difference, 1);
assert.name(difference, 'difference');
assert.looksNative(difference);
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.set.intersection.js | JavaScript | import { createIterable, createSetLike } from '../helpers/helpers.js';
QUnit.test('Set#intersection', assert => {
const { intersection } = Set.prototype;
const { from } = Array;
assert.isFunction(intersection);
assert.arity(intersection, 1);
assert.name(intersection, 'intersection');
assert.looksNative(in... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.set.is-disjoint-from.js | JavaScript | import { createIterable, createSetLike } from '../helpers/helpers.js';
QUnit.test('Set#isDisjointFrom', assert => {
const { isDisjointFrom } = Set.prototype;
assert.isFunction(isDisjointFrom);
assert.arity(isDisjointFrom, 1);
assert.name(isDisjointFrom, 'isDisjointFrom');
assert.looksNative(isDisjointFrom);... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.set.is-subset-of.js | JavaScript | import { createIterable, createSetLike } from '../helpers/helpers.js';
QUnit.test('Set#isSubsetOf', assert => {
const { isSubsetOf } = Set.prototype;
assert.isFunction(isSubsetOf);
assert.arity(isSubsetOf, 1);
assert.name(isSubsetOf, 'isSubsetOf');
assert.looksNative(isSubsetOf);
assert.nonEnumerable(Set.... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.set.is-superset-of.js | JavaScript | import { createIterable, createSetLike } from '../helpers/helpers.js';
QUnit.test('Set#isSupersetOf', assert => {
const { isSupersetOf } = Set.prototype;
assert.isFunction(isSupersetOf);
assert.arity(isSupersetOf, 1);
assert.name(isSupersetOf, 'isSupersetOf');
assert.looksNative(isSupersetOf);
assert.nonE... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.set.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.set.symmetric-difference.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
import { createIterable, createSetLike } from '../helpers/helpers.js';
QUnit.test('Set#symmetricDifference', assert => {
const { symmetricDifference } = Set.prototype;
const { from } = Array;
const { defineProperty } = Object;
assert.isFunction(symmetricD... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.set.union.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
import { createIterable, createSetLike } from '../helpers/helpers.js';
QUnit.test('Set#union', assert => {
const { union } = Set.prototype;
const { from } = Array;
const { defineProperty } = Object;
assert.isFunction(union);
assert.arity(union, 1);
as... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.anchor.js | JavaScript | QUnit.test('String#anchor', assert => {
const { anchor } = String.prototype;
assert.isFunction(anchor);
assert.arity(anchor, 1);
assert.name(anchor, 'anchor');
assert.looksNative(anchor);
assert.nonEnumerable(String.prototype, 'anchor');
assert.same('a'.anchor('b'), '<a name="b">a</a>', 'lower case');
a... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.at-alternative.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('String#at', assert => {
const { at } = String.prototype;
assert.isFunction(at);
assert.arity(at, 1);
assert.name(at, 'at');
assert.looksNative(at);
assert.nonEnumerable(String.prototype, 'at');
assert.same('1', '123'.at(0));
assert.same('2',... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.big.js | JavaScript | QUnit.test('String#big', assert => {
const { big } = String.prototype;
assert.isFunction(big);
assert.arity(big, 0);
assert.name(big, 'big');
assert.looksNative(big);
assert.nonEnumerable(String.prototype, 'big');
assert.same('a'.big(), '<big>a</big>', 'lower case');
if (typeof Symbol == 'function' && ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.blink.js | JavaScript | QUnit.test('String#blink', assert => {
const { blink } = String.prototype;
assert.isFunction(blink);
assert.arity(blink, 0);
assert.name(blink, 'blink');
assert.looksNative(blink);
assert.nonEnumerable(String.prototype, 'blink');
assert.same('a'.blink(), '<blink>a</blink>', 'lower case');
if (typeof Sy... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.bold.js | JavaScript | QUnit.test('String#bold', assert => {
const { bold } = String.prototype;
assert.isFunction(bold);
assert.arity(bold, 0);
assert.name(bold, 'bold');
assert.looksNative(bold);
assert.nonEnumerable(String.prototype, 'bold');
assert.same('a'.bold(), '<b>a</b>', 'lower case');
if (typeof Symbol == 'function... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.code-point-at.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('String#codePointAt', assert => {
const { codePointAt } = String.prototype;
assert.isFunction(codePointAt);
assert.arity(codePointAt, 1);
assert.name(codePointAt, 'codePointAt');
assert.looksNative(codePointAt);
assert.nonEnumerable(String.protot... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.ends-with.js | JavaScript | import { GLOBAL, STRICT } from '../helpers/constants.js';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('String#endsWith', assert => {
const { endsWith } = String.prototype;
assert.isFunction(endsWith);
assert.arity(endsWith, 1);
assert.name(endsWith, 'endsWith');
assert.looksNative(endsWith);
assert.non... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.fixed.js | JavaScript | QUnit.test('String#fixed', assert => {
const { fixed } = String.prototype;
assert.isFunction(fixed);
assert.arity(fixed, 0);
assert.name(fixed, 'fixed');
assert.looksNative(fixed);
assert.nonEnumerable(String.prototype, 'fixed');
assert.same('a'.fixed(), '<tt>a</tt>', 'lower case');
if (typeof Symbol =... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.fontcolor.js | JavaScript | QUnit.test('String#fontcolor', assert => {
const { fontcolor } = String.prototype;
assert.isFunction(fontcolor);
assert.arity(fontcolor, 1);
assert.name(fontcolor, 'fontcolor');
assert.looksNative(fontcolor);
assert.nonEnumerable(String.prototype, 'fontcolor');
assert.same('a'.fontcolor('b'), '<font color... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.fontsize.js | JavaScript | QUnit.test('String#fontsize', assert => {
const { fontsize } = String.prototype;
assert.isFunction(fontsize);
assert.arity(fontsize, 1);
assert.name(fontsize, 'fontsize');
assert.looksNative(fontsize);
assert.nonEnumerable(String.prototype, 'fontsize');
assert.same('a'.fontsize('b'), '<font size="b">a</fo... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.from-code-point.js | JavaScript | /* eslint-disable prefer-spread -- required for testing */
QUnit.test('String.fromCodePoint', assert => {
const { fromCodePoint } = String;
assert.isFunction(fromCodePoint);
assert.arity(fromCodePoint, 1);
assert.name(fromCodePoint, 'fromCodePoint');
assert.looksNative(fromCodePoint);
assert.nonEnumerable(S... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.includes.js | JavaScript | import { GLOBAL, STRICT } from '../helpers/constants.js';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('String#includes', assert => {
const { includes } = String.prototype;
assert.isFunction(includes);
assert.arity(includes, 1);
assert.name(includes, 'includes');
assert.looksNative(includes);
assert.non... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.is-well-formed.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('String#isWellFormed', assert => {
const { isWellFormed } = String.prototype;
assert.isFunction(isWellFormed);
assert.arity(isWellFormed, 0);
assert.name(isWellFormed, 'isWellFormed');
assert.looksNative(isWellFormed);
assert.nonEnumerable(String... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.italics.js | JavaScript | QUnit.test('String#italics', assert => {
const { italics } = String.prototype;
assert.isFunction(italics);
assert.arity(italics, 0);
assert.name(italics, 'italics');
assert.looksNative(italics);
assert.nonEnumerable(String.prototype, 'italics');
assert.same('a'.italics(), '<i>a</i>', 'lower case');
if ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.iterator.js | JavaScript | import { GLOBAL } from '../helpers/constants.js';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('String#@@iterator', assert => {
assert.isIterable(String.prototype);
let iterator = 'qwe'[Symbol.iterator]();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.same(iterator[Symbol.toStringTag], ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.link.js | JavaScript | QUnit.test('String#link', assert => {
const { link } = String.prototype;
assert.isFunction(link);
assert.arity(link, 1);
assert.name(link, 'link');
assert.looksNative(link);
assert.nonEnumerable(String.prototype, 'link');
assert.same('a'.link('b'), '<a href="b">a</a>', 'lower case');
assert.same('a'.lin... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.match-all.js | JavaScript | import { DESCRIPTORS, STRICT } from '../helpers/constants.js';
QUnit.test('String#matchAll', assert => {
const { matchAll } = String.prototype;
const { assign } = Object;
assert.isFunction(matchAll);
assert.arity(matchAll, 1);
assert.name(matchAll, 'matchAll');
assert.looksNative(matchAll);
assert.nonEnu... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.match.js | JavaScript | // TODO: fix escaping in regexps
/* eslint-disable prefer-regex-literals, regexp/prefer-regexp-exec -- required for testing */
import { GLOBAL, NATIVE, STRICT } from '../helpers/constants.js';
import { patchRegExp$exec } from '../helpers/helpers.js';
const Symbol = GLOBAL.Symbol || {};
const run = assert => {
asser... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.pad-end.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('String#padEnd', assert => {
const { padEnd } = String.prototype;
assert.isFunction(padEnd);
assert.arity(padEnd, 1);
assert.name(padEnd, 'padEnd');
assert.looksNative(padEnd);
assert.nonEnumerable(String.prototype, 'padEnd');
assert.same('abc'... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.pad-start.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('String#padStart', assert => {
const { padStart } = String.prototype;
assert.isFunction(padStart);
assert.arity(padStart, 1);
assert.name(padStart, 'padStart');
assert.looksNative(padStart);
assert.nonEnumerable(String.prototype, 'padStart');
a... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.raw.js | JavaScript | QUnit.test('String.raw', assert => {
const { raw } = String;
assert.isFunction(raw);
assert.arity(raw, 1);
assert.name(raw, 'raw');
assert.looksNative(raw);
assert.nonEnumerable(String, 'raw');
assert.same(raw({ raw: ['Hi\\n', '!'] }, 'Bob'), 'Hi\\nBob!', 'raw is array');
assert.same(raw({ raw: 'test' }... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.repeat.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('String#repeat', assert => {
const { repeat } = String.prototype;
assert.isFunction(repeat);
assert.arity(repeat, 1);
assert.name(repeat, 'repeat');
assert.looksNative(repeat);
assert.nonEnumerable(String.prototype, 'repeat');
assert.same('qwe'... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.replace-all.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('String#replaceAll', assert => {
const { replaceAll } = String.prototype;
assert.isFunction(replaceAll);
assert.arity(replaceAll, 2);
assert.name(replaceAll, 'replaceAll');
assert.looksNative(replaceAll);
assert.nonEnumerable(String.prototype, 'r... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.replace.js | JavaScript | /* eslint-disable prefer-regex-literals, regexp/no-unused-capturing-group, sonarjs/slow-regex, unicorn/prefer-string-replace-all -- required for testing */
import { GLOBAL, NATIVE, STRICT } from '../helpers/constants.js';
import { patchRegExp$exec } from '../helpers/helpers.js';
const Symbol = GLOBAL.Symbol || {};
co... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.search.js | JavaScript | /* eslint-disable prefer-regex-literals -- required for testing */
import { GLOBAL, STRICT } from '../helpers/constants.js';
import { patchRegExp$exec } from '../helpers/helpers.js';
const Symbol = GLOBAL.Symbol || {};
const run = assert => {
assert.isFunction(''.search);
assert.arity(''.search, 1);
assert.name... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.small.js | JavaScript | QUnit.test('String#small', assert => {
const { small } = String.prototype;
assert.isFunction(small);
assert.arity(small, 0);
assert.name(small, 'small');
assert.looksNative(small);
assert.nonEnumerable(String.prototype, 'small');
assert.same('a'.small(), '<small>a</small>', 'lower case');
if (typeof Sy... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.split.js | JavaScript | /* eslint-disable prefer-regex-literals -- required for testing */
/* eslint-disable regexp/no-empty-group, regexp/no-empty-capturing-group -- required for testing */
/* eslint-disable regexp/optimal-lookaround-quantifier, regexp/no-lazy-ends -- required for testing */
import { GLOBAL, NATIVE, STRICT } from '../helpers... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.starts-with.js | JavaScript | import { GLOBAL, STRICT } from '../helpers/constants.js';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('String#startsWith', assert => {
const { startsWith } = String.prototype;
assert.isFunction(startsWith);
assert.arity(startsWith, 1);
assert.name(startsWith, 'startsWith');
assert.looksNative(startsWith)... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.strike.js | JavaScript | QUnit.test('String#strike', assert => {
const { strike } = String.prototype;
assert.isFunction(strike);
assert.arity(strike, 0);
assert.name(strike, 'strike');
assert.looksNative(strike);
assert.nonEnumerable(String.prototype, 'strike');
assert.same('a'.strike(), '<strike>a</strike>', 'lower case');
if... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.sub.js | JavaScript | QUnit.test('String#sub', assert => {
const { sub } = String.prototype;
assert.isFunction(sub);
assert.arity(sub, 0);
assert.name(sub, 'sub');
assert.looksNative(sub);
assert.nonEnumerable(String.prototype, 'sub');
assert.same('a'.sub(), '<sub>a</sub>', 'lower case');
if (typeof Symbol == 'function' && ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.substr.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('String#substr', assert => {
const { substr } = String.prototype;
assert.isFunction(substr);
assert.arity(substr, 2);
assert.name(substr, 'substr');
assert.looksNative(substr);
assert.nonEnumerable(String.prototype, 'substr');
assert.same('123... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.sup.js | JavaScript | QUnit.test('String#sup', assert => {
const { sup } = String.prototype;
assert.isFunction(sup);
assert.arity(sup, 0);
assert.name(sup, 'sup');
assert.looksNative(sup);
assert.nonEnumerable(String.prototype, 'sup');
assert.same('a'.sup(), '<sup>a</sup>', 'lower case');
if (typeof Symbol == 'function' && ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.to-well-formed.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('String#toWellFormed', assert => {
const { toWellFormed } = String.prototype;
assert.isFunction(toWellFormed);
assert.arity(toWellFormed, 0);
assert.name(toWellFormed, 'toWellFormed');
assert.looksNative(toWellFormed);
assert.nonEnumerable(String... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.trim-end.js | JavaScript | import { STRICT, WHITESPACES } from '../helpers/constants.js';
QUnit.test('String#trimEnd', assert => {
const { trimEnd, trimRight } = String.prototype;
assert.isFunction(trimEnd);
assert.arity(trimEnd, 0);
assert.name(trimEnd, 'trimEnd');
assert.looksNative(trimEnd);
assert.nonEnumerable(String.prototype,... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.trim-left.js | JavaScript | /* eslint-disable unicorn/prefer-string-trim-start-end -- required for testing */
import { STRICT, WHITESPACES } from '../helpers/constants.js';
QUnit.test('String#trimLeft', assert => {
const { trimLeft } = String.prototype;
assert.isFunction(trimLeft);
assert.arity(trimLeft, 0);
assert.name(trimLeft, 'trimSt... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.trim-right.js | JavaScript | /* eslint-disable unicorn/prefer-string-trim-start-end -- required for testing */
import { STRICT, WHITESPACES } from '../helpers/constants.js';
QUnit.test('String#trimRight', assert => {
const { trimRight } = String.prototype;
assert.isFunction(trimRight);
assert.arity(trimRight, 0);
assert.name(trimRight, 't... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.trim-start.js | JavaScript | import { STRICT, WHITESPACES } from '../helpers/constants.js';
QUnit.test('String#trimStart', assert => {
const { trimStart, trimLeft } = String.prototype;
assert.isFunction(trimStart);
assert.arity(trimStart, 0);
assert.name(trimStart, 'trimStart');
assert.looksNative(trimStart);
assert.nonEnumerable(Stri... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.string.trim.js | JavaScript | import { STRICT, WHITESPACES } from '../helpers/constants.js';
QUnit.test('String#trim', assert => {
const { trim } = String.prototype;
assert.isFunction(''.trim);
assert.arity(trim, 0);
assert.name(trim, 'trim');
assert.looksNative(trim);
assert.nonEnumerable(String.prototype, 'trim');
assert.same(' \n ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.suppressed-error.constructor.js | JavaScript | /* eslint-disable unicorn/throw-new-error -- testing */
QUnit.test('SuppressedError', assert => {
assert.isFunction(SuppressedError);
assert.arity(SuppressedError, 3);
assert.name(SuppressedError, 'SuppressedError');
assert.looksNative(SuppressedError);
assert.true(new SuppressedError() instanceof SuppressedE... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.symbol.async-dispose.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Symbol.asyncDispose', assert => {
assert.true('asyncDispose' in Symbol, 'Symbol.asyncDispose available');
assert.true(Object(Symbol.asyncDispose) instanceof Symbol, 'Symbol.asyncDispose is symbol');
// Node 20.4.0 add `Symbol.asyncDispose`, but w... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.symbol.async-iterator.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Symbol.asyncIterator', assert => {
assert.true('asyncIterator' in Symbol, 'Symbol.asyncIterator available');
assert.nonEnumerable(Symbol, 'asyncIterator');
assert.true(Object(Symbol.asyncIterator) instanceof Symbol, 'Symbol.asyncIterator is symbo... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.symbol.constructor.js | JavaScript | import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants.js';
const {
defineProperty,
defineProperties,
getOwnPropertyDescriptor,
getOwnPropertyNames,
getOwnPropertySymbols,
keys,
create,
} = Object;
const { ownKeys } = GLOBAL.Reflect || {};
QUnit.test('Symbol', assert => {
assert.isFunction(... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.symbol.description.js | JavaScript | /* eslint-disable symbol-description -- required for testing */
import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Symbol#description', assert => {
assert.same(Symbol('foo').description, 'foo');
assert.same(Symbol('').description, '');
assert.same(Symbol(')').description, ')');
assert.same(Symb... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.symbol.dispose.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Symbol.dispose', assert => {
assert.true('dispose' in Symbol, 'Symbol.dispose available');
assert.true(Object(Symbol.dispose) instanceof Symbol, 'Symbol.dispose is symbol');
// Node 20.4.0 add `Symbol.dispose`, but with incorrect descriptor
// ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.symbol.for.js | JavaScript | import { NATIVE } from '../helpers/constants.js';
QUnit.test('Symbol.for', assert => {
assert.isFunction(Symbol.for, 'Symbol.for is function');
assert.nonEnumerable(Symbol, 'for');
assert.arity(Symbol.for, 1, 'Symbol.for arity is 1');
if (NATIVE) assert.name(Symbol.for, 'for', 'Symbol.for.name is "for"');
as... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.symbol.key-for.js | JavaScript | QUnit.test('Symbol.keyFor', assert => {
assert.isFunction(Symbol.keyFor, 'Symbol.keyFor is function');
assert.nonEnumerable(Symbol, 'keyFor');
assert.arity(Symbol.keyFor, 1, 'Symbol.keyFor arity is 1');
assert.name(Symbol.keyFor, 'keyFor', 'Symbol.keyFor.name is "keyFor"');
assert.looksNative(Symbol.keyFor, '... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.at.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.indexOf', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.constructors.js | JavaScript | import { DESCRIPTORS, NATIVE, TYPED_ARRAYS } from '../helpers/constants.js';
import { createIterable } from '../helpers/helpers.js';
const { keys, getOwnPropertyDescriptor, getPrototypeOf, defineProperty, assign } = Object;
if (DESCRIPTORS) {
for (const { name, TypedArray, bytes } of TYPED_ARRAYS) {
QUnit.test(... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.copy-within.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.copyWithin', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.every.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.every', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { ev... | 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.