.config/coc/extensions/node_modules/coc-prettier/node_modules/get-intrinsic/test/GetIntrinsic.js

   1 'use strict';
   2
   3 var GetIntrinsic = require('../');
   4
   5 var test = require('tape');
   6 var forEach = require('foreach');
   7 var debug = require('object-inspect');
   8 var generatorFns = require('make-generator-function')();
   9 var asyncFns = require('make-async-function').list();
  10 var asyncGenFns = require('make-async-generator-function')();
  11
  12 var callBound = require('call-bind/callBound');
  13 var v = require('es-value-fixtures');
  14 var $gOPD = require('es-abstract/helpers/getOwnPropertyDescriptor');
  15 var defineProperty = require('es-abstract/test/helpers/defineProperty');
  16
  17 var $isProto = callBound('%Object.prototype.isPrototypeOf%');
  18
  19 test('export', function (t) {
  20         t.equal(typeof GetIntrinsic, 'function', 'it is a function');
  21         t.equal(GetIntrinsic.length, 2, 'function has length of 2');
  22
  23         t.end();
  24 });
  25
  26 test('throws', function (t) {
  27         t['throws'](
  28                 function () { GetIntrinsic('not an intrinsic'); },
  29                 SyntaxError,
  30                 'nonexistent intrinsic throws a syntax error'
  31         );
  32
  33         t['throws'](
  34                 function () { GetIntrinsic(''); },
  35                 TypeError,
  36                 'empty string intrinsic throws a type error'
  37         );
  38
  39         t['throws'](
  40                 function () { GetIntrinsic('.'); },
  41                 SyntaxError,
  42                 '"just a dot" intrinsic throws a syntax error'
  43         );
  44
  45         t['throws'](
  46                 function () { GetIntrinsic('%String'); },
  47                 SyntaxError,
  48                 'Leading % without trailing % throws a syntax error'
  49         );
  50
  51         t['throws'](
  52                 function () { GetIntrinsic('String%'); },
  53                 SyntaxError,
  54                 'Trailing % without leading % throws a syntax error'
  55         );
  56
  57         t['throws'](
  58                 function () { GetIntrinsic("String['prototype]"); },
  59                 SyntaxError,
  60                 'Dynamic property access is disallowed for intrinsics (unterminated string)'
  61         );
  62
  63         t['throws'](
  64                 function () { GetIntrinsic('%Proxy.prototype.undefined%'); },
  65                 TypeError,
  66                 "Throws when middle part doesn't exist (%Proxy.prototype.undefined%)"
  67         );
  68
  69         forEach(v.nonStrings, function (nonString) {
  70                 t['throws'](
  71                         function () { GetIntrinsic(nonString); },
  72                         TypeError,
  73                         debug(nonString) + ' is not a String'
  74                 );
  75         });
  76
  77         forEach(v.nonBooleans, function (nonBoolean) {
  78                 t['throws'](
  79                         function () { GetIntrinsic('%', nonBoolean); },
  80                         TypeError,
  81                         debug(nonBoolean) + ' is not a Boolean'
  82                 );
  83         });
  84
  85         forEach([
  86                 'toString',
  87                 'propertyIsEnumerable',
  88                 'hasOwnProperty'
  89         ], function (objectProtoMember) {
  90                 t['throws'](
  91                         function () { GetIntrinsic(objectProtoMember); },
  92                         SyntaxError,
  93                         debug(objectProtoMember) + ' is not an intrinsic'
  94                 );
  95         });
  96
  97         t.end();
  98 });
  99
 100 test('base intrinsics', function (t) {
 101         t.equal(GetIntrinsic('%Object%'), Object, '%Object% yields Object');
 102         t.equal(GetIntrinsic('Object'), Object, 'Object yields Object');
 103         t.equal(GetIntrinsic('%Array%'), Array, '%Array% yields Array');
 104         t.equal(GetIntrinsic('Array'), Array, 'Array yields Array');
 105
 106         t.end();
 107 });
 108
 109 test('dotted paths', function (t) {
 110         t.equal(GetIntrinsic('%Object.prototype.toString%'), Object.prototype.toString, '%Object.prototype.toString% yields Object.prototype.toString');
 111         t.equal(GetIntrinsic('Object.prototype.toString'), Object.prototype.toString, 'Object.prototype.toString yields Object.prototype.toString');
 112         t.equal(GetIntrinsic('%Array.prototype.push%'), Array.prototype.push, '%Array.prototype.push% yields Array.prototype.push');
 113         t.equal(GetIntrinsic('Array.prototype.push'), Array.prototype.push, 'Array.prototype.push yields Array.prototype.push');
 114
 115         test('underscore paths are aliases for dotted paths', { skip: !Object.isFrozen || Object.isFrozen(Object.prototype) }, function (st) {
 116                 var original = GetIntrinsic('%ObjProto_toString%');
 117
 118                 forEach([
 119                         '%Object.prototype.toString%',
 120                         'Object.prototype.toString',
 121                         '%ObjectPrototype.toString%',
 122                         'ObjectPrototype.toString',
 123                         '%ObjProto_toString%',
 124                         'ObjProto_toString'
 125                 ], function (name) {
 126                         defineProperty(Object.prototype, 'toString', {
 127                                 value: function toString() {
 128                                         return original.apply(this, arguments);
 129                                 }
 130                         });
 131                         st.equal(GetIntrinsic(name), original, name + ' yields original Object.prototype.toString');
 132                 });
 133
 134                 defineProperty(Object.prototype, 'toString', { value: original });
 135                 st.end();
 136         });
 137
 138         test('dotted paths cache', { skip: !Object.isFrozen || Object.isFrozen(Object.prototype) }, function (st) {
 139                 var original = GetIntrinsic('%Object.prototype.propertyIsEnumerable%');
 140
 141                 forEach([
 142                         '%Object.prototype.propertyIsEnumerable%',
 143                         'Object.prototype.propertyIsEnumerable',
 144                         '%ObjectPrototype.propertyIsEnumerable%',
 145                         'ObjectPrototype.propertyIsEnumerable'
 146                 ], function (name) {
 147                         // eslint-disable-next-line no-extend-native
 148                         Object.prototype.propertyIsEnumerable = function propertyIsEnumerable() {
 149                                 return original.apply(this, arguments);
 150                         };
 151                         st.equal(GetIntrinsic(name), original, name + ' yields cached Object.prototype.propertyIsEnumerable');
 152                 });
 153
 154                 // eslint-disable-next-line no-extend-native
 155                 Object.prototype.propertyIsEnumerable = original;
 156                 st.end();
 157         });
 158
 159         test('dotted path reports correct error', function (st) {
 160                 st['throws'](function () {
 161                         GetIntrinsic('%NonExistentIntrinsic.prototype.property%');
 162                 }, /%NonExistentIntrinsic%/, 'The base intrinsic of %NonExistentIntrinsic.prototype.property% is %NonExistentIntrinsic%');
 163
 164                 st['throws'](function () {
 165                         GetIntrinsic('%NonExistentIntrinsicPrototype.property%');
 166                 }, /%NonExistentIntrinsicPrototype%/, 'The base intrinsic of %NonExistentIntrinsicPrototype.property% is %NonExistentIntrinsicPrototype%');
 167
 168                 st.end();
 169         });
 170
 171         t.end();
 172 });
 173
 174 test('accessors', { skip: !$gOPD || typeof Map !== 'function' }, function (t) {
 175         var actual = $gOPD(Map.prototype, 'size');
 176         t.ok(actual, 'Map.prototype.size has a descriptor');
 177         t.equal(typeof actual.get, 'function', 'Map.prototype.size has a getter function');
 178         t.equal(GetIntrinsic('%Map.prototype.size%'), actual.get, '%Map.prototype.size% yields the getter for it');
 179         t.equal(GetIntrinsic('Map.prototype.size'), actual.get, 'Map.prototype.size yields the getter for it');
 180
 181         t.end();
 182 });
 183
 184 test('generator functions', { skip: !generatorFns.length }, function (t) {
 185         var $GeneratorFunction = GetIntrinsic('%GeneratorFunction%');
 186         var $GeneratorFunctionPrototype = GetIntrinsic('%Generator%');
 187         var $GeneratorPrototype = GetIntrinsic('%GeneratorPrototype%');
 188
 189         forEach(generatorFns, function (genFn) {
 190                 var fnName = genFn.name;
 191                 fnName = fnName ? "'" + fnName + "'" : 'genFn';
 192
 193                 t.ok(genFn instanceof $GeneratorFunction, fnName + ' instanceof %GeneratorFunction%');
 194                 t.ok($isProto($GeneratorFunctionPrototype, genFn), '%Generator% is prototype of ' + fnName);
 195                 t.ok($isProto($GeneratorPrototype, genFn.prototype), '%GeneratorPrototype% is prototype of ' + fnName + '.prototype');
 196         });
 197
 198         t.end();
 199 });
 200
 201 test('async functions', { skip: !asyncFns.length }, function (t) {
 202         var $AsyncFunction = GetIntrinsic('%AsyncFunction%');
 203         var $AsyncFunctionPrototype = GetIntrinsic('%AsyncFunctionPrototype%');
 204
 205         forEach(asyncFns, function (asyncFn) {
 206                 var fnName = asyncFn.name;
 207                 fnName = fnName ? "'" + fnName + "'" : 'asyncFn';
 208
 209                 t.ok(asyncFn instanceof $AsyncFunction, fnName + ' instanceof %AsyncFunction%');
 210                 t.ok($isProto($AsyncFunctionPrototype, asyncFn), '%AsyncFunctionPrototype% is prototype of ' + fnName);
 211         });
 212
 213         t.end();
 214 });
 215
 216 test('async generator functions', { skip: asyncGenFns.length === 0 }, function (t) {
 217         var $AsyncGeneratorFunction = GetIntrinsic('%AsyncGeneratorFunction%');
 218         var $AsyncGeneratorFunctionPrototype = GetIntrinsic('%AsyncGenerator%');
 219         var $AsyncGeneratorPrototype = GetIntrinsic('%AsyncGeneratorPrototype%');
 220
 221         forEach(asyncGenFns, function (asyncGenFn) {
 222                 var fnName = asyncGenFn.name;
 223                 fnName = fnName ? "'" + fnName + "'" : 'asyncGenFn';
 224
 225                 t.ok(asyncGenFn instanceof $AsyncGeneratorFunction, fnName + ' instanceof %AsyncGeneratorFunction%');
 226                 t.ok($isProto($AsyncGeneratorFunctionPrototype, asyncGenFn), '%AsyncGenerator% is prototype of ' + fnName);
 227                 t.ok($isProto($AsyncGeneratorPrototype, asyncGenFn.prototype), '%AsyncGeneratorPrototype% is prototype of ' + fnName + '.prototype');
 228         });
 229
 230         t.end();
 231 });
 232
 233 test('%ThrowTypeError%', function (t) {
 234         var $ThrowTypeError = GetIntrinsic('%ThrowTypeError%');
 235
 236         t.equal(typeof $ThrowTypeError, 'function', 'is a function');
 237         t['throws'](
 238                 $ThrowTypeError,
 239                 TypeError,
 240                 '%ThrowTypeError% throws a TypeError'
 241         );
 242
 243         t.end();
 244 });
 245
 246 test('allowMissing', { skip: asyncGenFns.length > 0 }, function (t) {
 247         t['throws'](
 248                 function () { GetIntrinsic('%AsyncGeneratorPrototype%'); },
 249                 TypeError,
 250                 'throws when missing'
 251         );
 252
 253         t.equal(
 254                 GetIntrinsic('%AsyncGeneratorPrototype%', true),
 255                 undefined,
 256                 'does not throw when allowMissing'
 257         );
 258
 259         t.end();
 260 });