js/src/tests/test262/prs/3994/shell.js

   1 // GENERATED, DO NOT EDIT
   2 // file: assert.js
   3 // Copyright (C) 2017 Ecma International.  All rights reserved.
   4 // This code is governed by the BSD license found in the LICENSE file.
   5 /*---
   6 description: |
   7     Collection of assertion functions used throughout test262
   8 defines: [assert]
   9 ---*/
  10
  11
  12 function assert(mustBeTrue, message) {
  13   if (mustBeTrue === true) {
  14     return;
  15   }
  16
  17   if (message === undefined) {
  18     message = 'Expected true but got ' + assert._toString(mustBeTrue);
  19   }
  20   throw new Test262Error(message);
  21 }
  22
  23 assert._isSameValue = function (a, b) {
  24   if (a === b) {
  25     // Handle +/-0 vs. -/+0
  26     return a !== 0 || 1 / a === 1 / b;
  27   }
  28
  29   // Handle NaN vs. NaN
  30   return a !== a && b !== b;
  31 };
  32
  33 assert.sameValue = function (actual, expected, message) {
  34   try {
  35     if (assert._isSameValue(actual, expected)) {
  36       return;
  37     }
  38   } catch (error) {
  39     throw new Test262Error(message + ' (_isSameValue operation threw) ' + error);
  40     return;
  41   }
  42
  43   if (message === undefined) {
  44     message = '';
  45   } else {
  46     message += ' ';
  47   }
  48
  49   message += 'Expected SameValue(«' + assert._toString(actual) + '», «' + assert._toString(expected) + '») to be true';
  50
  51   throw new Test262Error(message);
  52 };
  53
  54 assert.notSameValue = function (actual, unexpected, message) {
  55   if (!assert._isSameValue(actual, unexpected)) {
  56     return;
  57   }
  58
  59   if (message === undefined) {
  60     message = '';
  61   } else {
  62     message += ' ';
  63   }
  64
  65   message += 'Expected SameValue(«' + assert._toString(actual) + '», «' + assert._toString(unexpected) + '») to be false';
  66
  67   throw new Test262Error(message);
  68 };
  69
  70 assert.throws = function (expectedErrorConstructor, func, message) {
  71   var expectedName, actualName;
  72   if (typeof func !== "function") {
  73     throw new Test262Error('assert.throws requires two arguments: the error constructor ' +
  74       'and a function to run');
  75     return;
  76   }
  77   if (message === undefined) {
  78     message = '';
  79   } else {
  80     message += ' ';
  81   }
  82
  83   try {
  84     func();
  85   } catch (thrown) {
  86     if (typeof thrown !== 'object' || thrown === null) {
  87       message += 'Thrown value was not an object!';
  88       throw new Test262Error(message);
  89     } else if (thrown.constructor !== expectedErrorConstructor) {
  90       expectedName = expectedErrorConstructor.name;
  91       actualName = thrown.constructor.name;
  92       if (expectedName === actualName) {
  93         message += 'Expected a ' + expectedName + ' but got a different error constructor with the same name';
  94       } else {
  95         message += 'Expected a ' + expectedName + ' but got a ' + actualName;
  96       }
  97       throw new Test262Error(message);
  98     }
  99     return;
 100   }
 101
 102   message += 'Expected a ' + expectedErrorConstructor.name + ' to be thrown but no exception was thrown at all';
 103   throw new Test262Error(message);
 104 };
 105
 106 assert._toString = function (value) {
 107   try {
 108     if (value === 0 && 1 / value === -Infinity) {
 109       return '-0';
 110     }
 111
 112     return String(value);
 113   } catch (err) {
 114     if (err.name === 'TypeError') {
 115       return Object.prototype.toString.call(value);
 116     }
 117
 118     throw err;
 119   }
 120 };
 121
 122 // file: compareArray.js
 123 // Copyright (C) 2017 Ecma International.  All rights reserved.
 124 // This code is governed by the BSD license found in the LICENSE file.
 125 /*---
 126 description: |
 127     Compare the contents of two arrays
 128 defines: [compareArray]
 129 ---*/
 130
 131 function compareArray(a, b) {
 132   if (b.length !== a.length) {
 133     return false;
 134   }
 135
 136   for (var i = 0; i < a.length; i++) {
 137     if (!compareArray.isSameValue(b[i], a[i])) {
 138       return false;
 139     }
 140   }
 141   return true;
 142 }
 143
 144 compareArray.isSameValue = function(a, b) {
 145   if (a === 0 && b === 0) return 1 / a === 1 / b;
 146   if (a !== a && b !== b) return true;
 147
 148   return a === b;
 149 };
 150
 151 compareArray.format = function(arrayLike) {
 152   return `[${[].map.call(arrayLike, String).join(', ')}]`;
 153 };
 154
 155 assert.compareArray = function(actual, expected, message) {
 156   message  = message === undefined ? '' : message;
 157
 158   if (typeof message === 'symbol') {
 159     message = message.toString();
 160   }
 161
 162   assert(actual != null, `First argument shouldn't be nullish. ${message}`);
 163   assert(expected != null, `Second argument shouldn't be nullish. ${message}`);
 164   var format = compareArray.format;
 165   var result = compareArray(actual, expected);
 166
 167   // The following prevents actual and expected from being iterated and evaluated
 168   // more than once unless absolutely necessary.
 169   if (!result) {
 170     assert(false, `Expected ${format(actual)} and ${format(expected)} to have the same contents. ${message}`);
 171   }
 172 };
 173
 174 // file: propertyHelper.js
 175 // Copyright (C) 2017 Ecma International.  All rights reserved.
 176 // This code is governed by the BSD license found in the LICENSE file.
 177 /*---
 178 description: |
 179     Collection of functions used to safely verify the correctness of
 180     property descriptors.
 181 defines:
 182   - verifyProperty
 183   - verifyEqualTo # deprecated
 184   - verifyWritable # deprecated
 185   - verifyNotWritable # deprecated
 186   - verifyEnumerable # deprecated
 187   - verifyNotEnumerable # deprecated
 188   - verifyConfigurable # deprecated
 189   - verifyNotConfigurable # deprecated
 190 ---*/
 191
 192 // @ts-check
 193
 194 /**
 195  * @param {object} obj
 196  * @param {string|symbol} name
 197  * @param {PropertyDescriptor|undefined} desc
 198  * @param {object} [options]
 199  * @param {boolean} [options.restore]
 200  */
 201 function verifyProperty(obj, name, desc, options) {
 202   assert(
 203     arguments.length > 2,
 204     'verifyProperty should receive at least 3 arguments: obj, name, and descriptor'
 205   );
 206
 207   var originalDesc = Object.getOwnPropertyDescriptor(obj, name);
 208   var nameStr = String(name);
 209
 210   // Allows checking for undefined descriptor if it's explicitly given.
 211   if (desc === undefined) {
 212     assert.sameValue(
 213       originalDesc,
 214       undefined,
 215       "obj['" + nameStr + "'] descriptor should be undefined"
 216     );
 217
 218     // desc and originalDesc are both undefined, problem solved;
 219     return true;
 220   }
 221
 222   assert(
 223     Object.prototype.hasOwnProperty.call(obj, name),
 224     "obj should have an own property " + nameStr
 225   );
 226
 227   assert.notSameValue(
 228     desc,
 229     null,
 230     "The desc argument should be an object or undefined, null"
 231   );
 232
 233   assert.sameValue(
 234     typeof desc,
 235     "object",
 236     "The desc argument should be an object or undefined, " + String(desc)
 237   );
 238
 239   var names = Object.getOwnPropertyNames(desc);
 240   for (var i = 0; i < names.length; i++) {
 241     assert(
 242       names[i] === "value" ||
 243         names[i] === "writable" ||
 244         names[i] === "enumerable" ||
 245         names[i] === "configurable" ||
 246         names[i] === "get" ||
 247         names[i] === "set",
 248       "Invalid descriptor field: " + names[i],
 249     );
 250   }
 251
 252   var failures = [];
 253
 254   if (Object.prototype.hasOwnProperty.call(desc, 'value')) {
 255     if (!isSameValue(desc.value, originalDesc.value)) {
 256       failures.push("descriptor value should be " + desc.value);
 257     }
 258     if (!isSameValue(desc.value, obj[name])) {
 259       failures.push("object value should be " + desc.value);
 260     }
 261   }
 262
 263   if (Object.prototype.hasOwnProperty.call(desc, 'enumerable')) {
 264     if (desc.enumerable !== originalDesc.enumerable ||
 265         desc.enumerable !== isEnumerable(obj, name)) {
 266       failures.push('descriptor should ' + (desc.enumerable ? '' : 'not ') + 'be enumerable');
 267     }
 268   }
 269
 270   if (Object.prototype.hasOwnProperty.call(desc, 'writable')) {
 271     if (desc.writable !== originalDesc.writable ||
 272         desc.writable !== isWritable(obj, name)) {
 273       failures.push('descriptor should ' + (desc.writable ? '' : 'not ') + 'be writable');
 274     }
 275   }
 276
 277   if (Object.prototype.hasOwnProperty.call(desc, 'configurable')) {
 278     if (desc.configurable !== originalDesc.configurable ||
 279         desc.configurable !== isConfigurable(obj, name)) {
 280       failures.push('descriptor should ' + (desc.configurable ? '' : 'not ') + 'be configurable');
 281     }
 282   }
 283
 284   assert(!failures.length, failures.join('; '));
 285
 286   if (options && options.restore) {
 287     Object.defineProperty(obj, name, originalDesc);
 288   }
 289
 290   return true;
 291 }
 292
 293 function isConfigurable(obj, name) {
 294   var hasOwnProperty = Object.prototype.hasOwnProperty;
 295   try {
 296     delete obj[name];
 297   } catch (e) {
 298     if (!(e instanceof TypeError)) {
 299       throw new Test262Error("Expected TypeError, got " + e);
 300     }
 301   }
 302   return !hasOwnProperty.call(obj, name);
 303 }
 304
 305 function isEnumerable(obj, name) {
 306   var stringCheck = false;
 307
 308   if (typeof name === "string") {
 309     for (var x in obj) {
 310       if (x === name) {
 311         stringCheck = true;
 312         break;
 313       }
 314     }
 315   } else {
 316     // skip it if name is not string, works for Symbol names.
 317     stringCheck = true;
 318   }
 319
 320   return stringCheck &&
 321     Object.prototype.hasOwnProperty.call(obj, name) &&
 322     Object.prototype.propertyIsEnumerable.call(obj, name);
 323 }
 324
 325 function isSameValue(a, b) {
 326   if (a === 0 && b === 0) return 1 / a === 1 / b;
 327   if (a !== a && b !== b) return true;
 328
 329   return a === b;
 330 }
 331
 332 var __isArray = Array.isArray;
 333 function isWritable(obj, name, verifyProp, value) {
 334   var unlikelyValue = __isArray(obj) && name === "length" ?
 335     Math.pow(2, 32) - 1 :
 336     "unlikelyValue";
 337   var newValue = value || unlikelyValue;
 338   var hadValue = Object.prototype.hasOwnProperty.call(obj, name);
 339   var oldValue = obj[name];
 340   var writeSucceeded;
 341
 342   try {
 343     obj[name] = newValue;
 344   } catch (e) {
 345     if (!(e instanceof TypeError)) {
 346       throw new Test262Error("Expected TypeError, got " + e);
 347     }
 348   }
 349
 350   writeSucceeded = isSameValue(obj[verifyProp || name], newValue);
 351
 352   // Revert the change only if it was successful (in other cases, reverting
 353   // is unnecessary and may trigger exceptions for certain property
 354   // configurations)
 355   if (writeSucceeded) {
 356     if (hadValue) {
 357       obj[name] = oldValue;
 358     } else {
 359       delete obj[name];
 360     }
 361   }
 362
 363   return writeSucceeded;
 364 }
 365
 366 /**
 367  * Deprecated; please use `verifyProperty` in new tests.
 368  */
 369 function verifyEqualTo(obj, name, value) {
 370   if (!isSameValue(obj[name], value)) {
 371     throw new Test262Error("Expected obj[" + String(name) + "] to equal " + value +
 372            ", actually " + obj[name]);
 373   }
 374 }
 375
 376 /**
 377  * Deprecated; please use `verifyProperty` in new tests.
 378  */
 379 function verifyWritable(obj, name, verifyProp, value) {
 380   if (!verifyProp) {
 381     assert(Object.getOwnPropertyDescriptor(obj, name).writable,
 382          "Expected obj[" + String(name) + "] to have writable:true.");
 383   }
 384   if (!isWritable(obj, name, verifyProp, value)) {
 385     throw new Test262Error("Expected obj[" + String(name) + "] to be writable, but was not.");
 386   }
 387 }
 388
 389 /**
 390  * Deprecated; please use `verifyProperty` in new tests.
 391  */
 392 function verifyNotWritable(obj, name, verifyProp, value) {
 393   if (!verifyProp) {
 394     assert(!Object.getOwnPropertyDescriptor(obj, name).writable,
 395          "Expected obj[" + String(name) + "] to have writable:false.");
 396   }
 397   if (isWritable(obj, name, verifyProp)) {
 398     throw new Test262Error("Expected obj[" + String(name) + "] NOT to be writable, but was.");
 399   }
 400 }
 401
 402 /**
 403  * Deprecated; please use `verifyProperty` in new tests.
 404  */
 405 function verifyEnumerable(obj, name) {
 406   assert(Object.getOwnPropertyDescriptor(obj, name).enumerable,
 407        "Expected obj[" + String(name) + "] to have enumerable:true.");
 408   if (!isEnumerable(obj, name)) {
 409     throw new Test262Error("Expected obj[" + String(name) + "] to be enumerable, but was not.");
 410   }
 411 }
 412
 413 /**
 414  * Deprecated; please use `verifyProperty` in new tests.
 415  */
 416 function verifyNotEnumerable(obj, name) {
 417   assert(!Object.getOwnPropertyDescriptor(obj, name).enumerable,
 418        "Expected obj[" + String(name) + "] to have enumerable:false.");
 419   if (isEnumerable(obj, name)) {
 420     throw new Test262Error("Expected obj[" + String(name) + "] NOT to be enumerable, but was.");
 421   }
 422 }
 423
 424 /**
 425  * Deprecated; please use `verifyProperty` in new tests.
 426  */
 427 function verifyConfigurable(obj, name) {
 428   assert(Object.getOwnPropertyDescriptor(obj, name).configurable,
 429        "Expected obj[" + String(name) + "] to have configurable:true.");
 430   if (!isConfigurable(obj, name)) {
 431     throw new Test262Error("Expected obj[" + String(name) + "] to be configurable, but was not.");
 432   }
 433 }
 434
 435 /**
 436  * Deprecated; please use `verifyProperty` in new tests.
 437  */
 438 function verifyNotConfigurable(obj, name) {
 439   assert(!Object.getOwnPropertyDescriptor(obj, name).configurable,
 440        "Expected obj[" + String(name) + "] to have configurable:false.");
 441   if (isConfigurable(obj, name)) {
 442     throw new Test262Error("Expected obj[" + String(name) + "] NOT to be configurable, but was.");
 443   }
 444 }
 445
 446 // file: sta.js
 447 // Copyright (c) 2012 Ecma International.  All rights reserved.
 448 // This code is governed by the BSD license found in the LICENSE file.
 449 /*---
 450 description: |
 451     Provides both:
 452
 453     - An error class to avoid false positives when testing for thrown exceptions
 454     - A function to explicitly throw an exception using the Test262Error class
 455 defines: [Test262Error, $DONOTEVALUATE]
 456 ---*/
 457
 458
 459 function Test262Error(message) {
 460   this.message = message || "";
 461 }
 462
 463 Test262Error.prototype.toString = function () {
 464   return "Test262Error: " + this.message;
 465 };
 466
 467 Test262Error.thrower = function (message) {
 468   throw new Test262Error(message);
 469 };
 470
 471 function $DONOTEVALUATE() {
 472   throw "Test262: This statement should not be evaluated.";
 473 }
 474
 475 // file: test262-host.js
 476 // This Source Code Form is subject to the terms of the Mozilla Public
 477 // License, v. 2.0. If a copy of the MPL was not distributed with this
 478 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 479
 480 // https://github.com/tc39/test262/blob/main/INTERPRETING.md#host-defined-functions
 481 ;(function createHostObject(global) {
 482     "use strict";
 483
 484     // Save built-in functions and constructors.
 485     var FunctionToString = global.Function.prototype.toString;
 486     var ReflectApply = global.Reflect.apply;
 487     var Atomics = global.Atomics;
 488     var Error = global.Error;
 489     var SharedArrayBuffer = global.SharedArrayBuffer;
 490     var Int32Array = global.Int32Array;
 491
 492     // Save built-in shell functions.
 493     var NewGlobal = global.newGlobal;
 494     var setSharedArrayBuffer = global.setSharedArrayBuffer;
 495     var getSharedArrayBuffer = global.getSharedArrayBuffer;
 496     var evalInWorker = global.evalInWorker;
 497     var monotonicNow = global.monotonicNow;
 498     var gc = global.gc;
 499     var clearKeptObjects = global.clearKeptObjects;
 500
 501     var hasCreateIsHTMLDDA = "createIsHTMLDDA" in global;
 502     var hasThreads = ("helperThreadCount" in global ? global.helperThreadCount() > 0 : true);
 503     var hasMailbox = typeof setSharedArrayBuffer === "function" && typeof getSharedArrayBuffer === "function";
 504     var hasEvalInWorker = typeof evalInWorker === "function";
 505
 506     if (!hasCreateIsHTMLDDA && !("document" in global && "all" in global.document))
 507         throw new Error("no [[IsHTMLDDA]] object available for testing");
 508
 509     var IsHTMLDDA = hasCreateIsHTMLDDA
 510                     ? global.createIsHTMLDDA()
 511                     : global.document.all;
 512
 513     // The $262.agent framework is not appropriate for browsers yet, and some
 514     // test cases can't work in browsers (they block the main thread).
 515
 516     var shellCode = hasMailbox && hasEvalInWorker;
 517     var sabTestable = Atomics && SharedArrayBuffer && hasThreads && shellCode;
 518
 519     global.$262 = {
 520         __proto__: null,
 521         createRealm() {
 522             var newGlobalObject = NewGlobal();
 523             var createHostObjectFn = ReflectApply(FunctionToString, createHostObject, []);
 524             newGlobalObject.Function(`${createHostObjectFn} createHostObject(this);`)();
 525             return newGlobalObject.$262;
 526         },
 527         detachArrayBuffer: global.detachArrayBuffer,
 528         evalScript: global.evaluateScript || global.evaluate,
 529         global,
 530         IsHTMLDDA,
 531         gc() {
 532             gc();
 533         },
 534         clearKeptObjects() {
 535             clearKeptObjects();
 536         },
 537         agent: (function () {
 538
 539             // SpiderMonkey complication: With run-time argument --no-threads
 540             // our test runner will not properly filter test cases that can't be
 541             // run because agents can't be started, and so we do a little
 542             // filtering here: We will quietly succeed and exit if an agent test
 543             // should not have been run because threads cannot be started.
 544             //
 545             // Firefox complication: The test cases that use $262.agent can't
 546             // currently work in the browser, so for now we rely on them not
 547             // being run at all.
 548
 549             if (!sabTestable) {
 550                 let {reportCompare, quit} = global;
 551
 552                 function notAvailable() {
 553                     // See comment above.
 554                     if (!hasThreads && shellCode) {
 555                         reportCompare(0, 0);
 556                         quit(0);
 557                     }
 558                     throw new Error("Agents not available");
 559                 }
 560
 561                 return {
 562                     start(script) { notAvailable() },
 563                     broadcast(sab, id) { notAvailable() },
 564                     getReport() { notAvailable() },
 565                     sleep(s) { notAvailable() },
 566                     monotonicNow,
 567                 }
 568             }
 569
 570             // The SpiderMonkey implementation uses a designated shared buffer _ia
 571             // for coordination, and spinlocks for everything except sleeping.
 572
 573             var _MSG_LOC = 0;           // Low bit set: broadcast available; High bits: seq #
 574             var _ID_LOC = 1;            // ID sent with broadcast
 575             var _ACK_LOC = 2;           // Worker increments this to ack that broadcast was received
 576             var _RDY_LOC = 3;           // Worker increments this to ack that worker is up and running
 577             var _LOCKTXT_LOC = 4;       // Writer lock for the text buffer: 0=open, 1=closed
 578             var _NUMTXT_LOC = 5;        // Count of messages in text buffer
 579             var _NEXT_LOC = 6;          // First free location in the buffer
 580             var _SLEEP_LOC = 7;         // Used for sleeping
 581
 582             var _FIRST = 10;            // First location of first message
 583
 584             var _ia = new Int32Array(new SharedArrayBuffer(65536));
 585             _ia[_NEXT_LOC] = _FIRST;
 586
 587             var _worker_prefix =
 588 // BEGIN WORKER PREFIX
 589 `if (typeof $262 === 'undefined')
 590     $262 = {};
 591 $262.agent = (function (global) {
 592     var ReflectApply = global.Reflect.apply;
 593     var StringCharCodeAt = global.String.prototype.charCodeAt;
 594     var {
 595         add: Atomics_add,
 596         compareExchange: Atomics_compareExchange,
 597         load: Atomics_load,
 598         store: Atomics_store,
 599         wait: Atomics_wait,
 600     } = global.Atomics;
 601
 602     var {getSharedArrayBuffer} = global;
 603
 604     var _ia = new Int32Array(getSharedArrayBuffer());
 605     var agent = {
 606         receiveBroadcast(receiver) {
 607             var k;
 608             while (((k = Atomics_load(_ia, ${_MSG_LOC})) & 1) === 0)
 609                 ;
 610             var received_sab = getSharedArrayBuffer();
 611             var received_id = Atomics_load(_ia, ${_ID_LOC});
 612             Atomics_add(_ia, ${_ACK_LOC}, 1);
 613             while (Atomics_load(_ia, ${_MSG_LOC}) === k)
 614                 ;
 615             receiver(received_sab, received_id);
 616         },
 617
 618         report(msg) {
 619             while (Atomics_compareExchange(_ia, ${_LOCKTXT_LOC}, 0, 1) === 1)
 620                 ;
 621             msg = "" + msg;
 622             var i = _ia[${_NEXT_LOC}];
 623             _ia[i++] = msg.length;
 624             for ( let j=0 ; j < msg.length ; j++ )
 625                 _ia[i++] = ReflectApply(StringCharCodeAt, msg, [j]);
 626             _ia[${_NEXT_LOC}] = i;
 627             Atomics_add(_ia, ${_NUMTXT_LOC}, 1);
 628             Atomics_store(_ia, ${_LOCKTXT_LOC}, 0);
 629         },
 630
 631         sleep(s) {
 632             Atomics_wait(_ia, ${_SLEEP_LOC}, 0, s);
 633         },
 634
 635         leaving() {},
 636
 637         monotonicNow: global.monotonicNow,
 638     };
 639     Atomics_add(_ia, ${_RDY_LOC}, 1);
 640     return agent;
 641 })(this);`;
 642 // END WORKER PREFIX
 643
 644             var _numWorkers = 0;
 645             var _numReports = 0;
 646             var _reportPtr = _FIRST;
 647             var {
 648                 add: Atomics_add,
 649                 load: Atomics_load,
 650                 store: Atomics_store,
 651                 wait: Atomics_wait,
 652             } = Atomics;
 653             var StringFromCharCode = global.String.fromCharCode;
 654
 655             return {
 656                 start(script) {
 657                     setSharedArrayBuffer(_ia.buffer);
 658                     var oldrdy = Atomics_load(_ia, _RDY_LOC);
 659                     evalInWorker(_worker_prefix + script);
 660                     while (Atomics_load(_ia, _RDY_LOC) === oldrdy)
 661                         ;
 662                     _numWorkers++;
 663                 },
 664
 665                 broadcast(sab, id) {
 666                     setSharedArrayBuffer(sab);
 667                     Atomics_store(_ia, _ID_LOC, id);
 668                     Atomics_store(_ia, _ACK_LOC, 0);
 669                     Atomics_add(_ia, _MSG_LOC, 1);
 670                     while (Atomics_load(_ia, _ACK_LOC) < _numWorkers)
 671                         ;
 672                     Atomics_add(_ia, _MSG_LOC, 1);
 673                 },
 674
 675                 getReport() {
 676                     if (_numReports === Atomics_load(_ia, _NUMTXT_LOC))
 677                         return null;
 678                     var s = "";
 679                     var i = _reportPtr;
 680                     var len = _ia[i++];
 681                     for ( let j=0 ; j < len ; j++ )
 682                         s += StringFromCharCode(_ia[i++]);
 683                     _reportPtr = i;
 684                     _numReports++;
 685                     return s;
 686                 },
 687
 688                 sleep(s) {
 689                     Atomics_wait(_ia, _SLEEP_LOC, 0, s);
 690                 },
 691
 692                 monotonicNow,
 693             };
 694         })()
 695     };
 696 })(this);
 697
 698 var $mozAsyncTestDone = false;
 699 function $DONE(failure) {
 700     // This function is generally called from within a Promise handler, so any
 701     // exception thrown by this method will be swallowed and most likely
 702     // ignored by the Promise machinery.
 703     if ($mozAsyncTestDone) {
 704         reportFailure("$DONE() already called");
 705         return;
 706     }
 707     $mozAsyncTestDone = true;
 708
 709     if (failure)
 710         reportFailure(failure);
 711     else
 712         reportCompare(0, 0);
 713
 714     if (typeof jsTestDriverEnd === "function") {
 715         gDelayTestDriverEnd = false;
 716         jsTestDriverEnd();
 717     }
 718 }
 719
 720 // Some tests in test262 leave promise rejections unhandled.
 721 if ("ignoreUnhandledRejections" in this) {
 722   ignoreUnhandledRejections();
 723 }