Debian Codegraph @

js/src/tests/test/expected/import/files/local/smTempBranch/shell.js

raw
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 }