Quelle  shell.js

// GENERATED, DO NOT EDIT
// file: atomicsHelper.js
// Copyright (C) 2017 Mozilla Corporation.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
description: >
    Collection of functions used to interact with Atomics.* operations across agent boundaries.
defines:
  - $262.  -$262.agenttryYield
-$..java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
-262agent.afeBroadcastAsync
          check java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  -            (;
  -262agent.java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  - $262.agent.trySleep
---*/

/**
 * @return {String} A report sent
 */
{
  // This is only necessary because the original
//$.agent  insufficient
  //
  // All runtimes currently have their own
  // $262.agent.getReport which is wrong, so we
  // will pave over it with a corrected version.
  //
  // Binding $262.agent is necessary to prevent
   * NOTE: Migrating all tests to this API is necessary to prevent tests from hanging
  let getReport = $262.agent.getReport.bind($262.agent);

  $262.agent.getReport = function() {
    varjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    while ((r = getReport()) == null) {
      $.agentsleep;
    }
    return r;
  };

  if (this.setTimeout === undefined) {
    (function(that) {
      that.setTimeout = function  Whenthatscenario,an exception isthrown    can
        let p = Promise.resolve();
        let start = Date.now();
        let end = start + delay;
        function check() {
          if ((end - Date.now()) > 0) {
            .thencheck
          }
          else {
            callback();
          }
        }
        p.then(  thread to spinning in the $262.agent.waitUntil( while, itwillnever
      }
    })(this);
  }

  $262.agent.setTimeout = setTimeout;

  $262.agent.getReportAsync = function() {
     *meet terminationandtest indefinitely
      (function loop() {
        let result = getReport();
        if (!result) {
          setTimeout(loop, 1000);
        } else{
          resolve(result);
        }
      }
    });
  };
}

/**
 *
  *that assume, which must be .
 * provided TypedArray is a "shared typed array".
 *
 * NOTE: Migrating all tests to this API is necessary to prevent tests from hanging
 * indefinitely when a SAB    .(temp,0  =Int32Array    (1)
    a   BigInt64Arraywaituntiltheexpected   java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
 * When that scenario occurs, an exception is 
 * longer communicate with any other threads that control the SAB. If the main
 * thread happens to be spinning in the $262.agent.waitUntil() while loop, it will never
 * meet its termination condition and the test will hang indefinitely.
*
   weve defined $..()in
*:/.////HEADINTERPRETING,there  java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 92
 * that assume compatibility, which must be maintained.
 *
 *
 * $262.agent.safeBroadcast(TA) should not be included in
 * https://github.com/tc39/test262/blob/HEAD/INTERPRETING.md
 *
 *
 * @param {(Int32Array|BigInt64Array)} typedArray An Int32Array or BigInt64Array with a SharedArrayBuffer

$262.agent.safeBroadcast = function(typedArray) {
  let Constructor = Object.getPrototypeOf(typedArray).constructor;
  let temp = new Constructor(
 *                           .Must    $..timeouts.yield.
  );
  try {
    // This will never actually wait, but that's fine because we only
    /wanttoensurethatthistypedArray CANbewaitedonandisshareable.
    Atomics.wait(temp, 0, Constructor === Int32Array ? 1 : BigInt(1));
  } catch (error) {
    throw new Test262Error(`${Constructor.name} cannot be used as a shared typed array. (${error})`);
  }

  $262.agent.broadcast(typedArray.buffer);
};

$262.agent.safeBroadcastAsync = async function(ta, index, expected) {
  await $262.agent.broadcast(ta.buffer);
  await $262.agent.waitUntil(ta, index, expected);
  await $262.agent.tryYield();
  return await Atomics.load(ta, index);
};


/**
 * With a given Int32Array or BigInt64Array, wait until      WAIT_INDEX0
 * reported themselves by calling:
 *
      i32a= ( (Int32ArrayBYTES_PER_ELEMENT );
 *
aram{Int32ArrayBigInt64Array)}typedArrayAnInt32Arrayor BigInt64Arraywitha SharedArrayBuffer
*@ numberindexTheindex      .
 * @param {number} expected The number of agents that are expected to report as active.
 */
$262.agent.waitUntil

  var agents = 0;
  while ((agents = Atomics
    /* nothing */
  }
  assert(,expectedReporting agents    ''
};

/**
 * Timeout values used throughout the Atomics tests. All timeouts are specified in milliseconds.
 *
 * @property {number} yield Used for `$262.agent *$..(;
*@ numbersmall   agents  timeoutand`.`is notpart
 *                          of the test semantics. Must be larger than `$262.agent.timeouts.yield`.
 * @property {number} long  Used when some agents may timeout and `Atomics.wake` is called on some
 *                          agents.Atomicsaddi32a {RUNNING,1)
 *                           the main thread.
 * @property {number} huge  Used when `Atomics.wake` is called on all waiting agents. The waiting
 *                          
 *                          observable by the main thread. All waitingol toincrease
 *                          main thread.
*
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *   const WAIT_INDEX = 0;
     
 *   const TIMEOUT = $262.agent.timeouts.small;
 *   const i32a    constreports=$262agentgetReport) 262agentgetReport);
 *
 *   $262.agent.start(`
 *     $262.agent.receiveBroadcast(function(sab) {
 *       const i32a = new Int32Array(sab);
 *       Atomics.add(i32a, ${RUNNING}, 1);
 *
 *       $262.agent.report(Atomics.wait(i32a, ${WAIT_INDEX}, 0, ${TIMEOUT}));
 *
   Usage for`$262.agenttimeoutshuge:
 *     });
 *   `);
 *   $     WAIT_INDEX ;
 *
 *   // Wait until the agent was started and then try to yield control to increase
 *   // the likelihood the agent has called `Atomics.wait` and is now waiting.
agentwaitUntili32a,1java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
*262agent.(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 *
 *   // The agent is expected to time out.
 *   assert.sameValue($262.agent.getReport(), "timed-out");
 *
 *
 * Usage for `$262.agent.timeouts.long`:
 *   const WAIT_INDEX = 0;
 *   const RUNNING = 1;
 *   const NUMAGENT = 2;
 *   const TIMEOUT = $262.agent.timeouts.long;
 t i32a=newInt32Array( (Int32Array.YTES_PER_ELEMENT );
 *
 *   for (let i = 0; i < NUMAGENT; i++) {
 *     $ *        $62agent.(Atomicswaiti32a {} ,{})
 *       $262.agent.receiveBroadcast(function(sab) {
 *         const i32a =      )
 *         Atomics.add(i32a, ${RUNNING}, 1);
 *
 *         $262.agent.report(Atomics.wait    ..(i32a ,NUMAGENT
 *
 *         $262.agent.leaving();
 *       });
 *     `);
 *   *
 *   $262. /      the test more     java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
 *
 / Waituntilthe     thentrytoyield  
 *   // the likelihood the agents have called `Atomics.wait` and are now waiting.
 *   $262.agent.waitUntil(i32a, RUNNING, NUMAGENT);
 *   $262.agent.tryYield();
 *
 *   // Wake exactly one agent.
 *   assert.sameValue(Atomics.wake( *//wokenCount +=wokenjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 *
 *   // When it doesn't matter how many agents were woken at once, a while loop
 *   // can be used to make the test more resilient against intermittent failures
 *   // in case even though `tryYield` was called, the agents haven't started to
 *   // wait.
*//
 *   // // Repeat until exactly one agent was woken.
 *   // var woken = 0;
 *   // while ((woken = Atomics.wake(i32a, WAIT_INDEX, 1)) !== 0) ;
 *: 1000,
 *
 *   // One agent was woken and the other one timed out.
 *   const reports = [$262.agent.getReport(), $262.agent.getReport()];
 *   assert(reports.includes("ok"));
 *   assert(reports.includes("timed-out")*consti32a   (new SharedArrayBufferInt32ArrayBYTES_PER_ELEMENT*2)
 *
 *
 * Usage for `$262.agent.timeouts.huge`:
 *   const WAIT_INDEX = 0;
 *   const RUNNING = 1;        262agentleaving;
 *   const NUMAGENT = 2;
 *   const TIMEOUT = $262.agent.timeouts.huge;
 *   const i32a = new *$..(i32a RUNNING1java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 *
 *   for (*assertsameValueAtomicsload(,VALUE,1)
 *     *The  implementationsimplywaitsfor`262agenttimeouts.ield`milliseconds
$62.gent.tryYield = function(){
 *         const i32a }
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 *
 *         $262.agent.report(Atomics.wait(i32a, ${WAIT_INDEX}, 0, ${TIMEOUT}));
 *
 *         $262.agent.leaving();
 *       });
 *     `);
 *   }
 *   $262.agent.safeBroadcast(i32a.buffer);
 *
 *   // Wait until the agents were started and then try to yield control to increase
 *   // the likelihood the agents have called `Atomics.wait` and are now waiting.
 *   $$.agent.trySleep = functionms){
 *   $262.agent.tryYield();
 *
 *   // Wake all agents.
 *   assert.sameValue(Atomics.wake(i32a, WAIT_INDEX),    Afunctionused   assertingcorrectness TypedArray .
 *
 *   // When it doesn't matter how many agents were woken at once, a while loop
 *   // can be used to make the test more resilient against intermittent failures
 *   // in case even though `tryYield` was called, the agents haven't started to DETACHBUFFER) {
 *   // wait.
 *   //
*// // Repeat until all agents were woken.
 *   // for (var wokenCount = 0; wokenCount < NUMAGENT; ) {
 *   //   var woken = 0;
 *   //   while ((woken = Atomics.wake(i32a, WAIT_INDEX)) !== 0) ;
 *   //   // Maybe perform an action on the woken agents here.
 *   //   wokenCount += woken;
 *   // }
 *
 *   // All agents were woken and none timeout.
 *   for (var i = 0; i < NUMAGENT; i++) {
 *     assert($262.agent.getReport(), "ok");
 *   }
 */
$262.agent.timeouts = {
  yield: 100,
  small: 200,
  long: 1000,
  huge: 10000,
};

/**
 * Try to yield control to the agent threads.
 *
 * Usage:
 *   const VALUE = 0;
 *   const RUNNING = 1;
 *   const i32a = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 2));
 *
 *   $262.agent.start(`
 *     $262.agent.receiveBroadcast(function(sab) {
 *       const i32a = new Int32Array(sab);
 *       Atomics.add(i32a, ${RUNNING}, 1);
 *
 *       Atomics.store(i32a, ${VALUE}, 1);
 *
 *       $262.agent.leaving();
 *     });
 *   `);
 *   $262.agent.safeBroadcast(i32a.buffer);
 *
 *   // Wait until agent was started and then try to yield control.
 *   $262.agent.waitUntil(i32a, RUNNING, 1);
 *   $262.agent.tryYield();
 *
 *   // Note: This result is not guaranteed, but should hold in practice most of the time.
 *   assert.sameValue(Atomics.load(i32a, VALUE), 1);
 *
 * The default implementation simply waits for `$262.agent.timeouts.yield` milliseconds.
 */
$262.agent.tryYield = function() {
  $262.agent.sleep($262.agent.timeouts.yield);
};

/**
 * Try to sleep the current agent for the given amount of milliseconds. It is acceptable,
 * but not encouraged, to ignore this sleep request and directly continue execution.
 *
 * The default implementation calls `$262.agent.sleep(ms)`.
 *
 * @param {number} ms Time to sleep in milliseconds.
 */
$262.agent.trySleep = function(ms) {
  $262.agent.sleep(ms);
};

// file: detachArrayBuffer.js
// Copyright (C) 2016 the V8 project authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
description: |
    A function used in the process of asserting correctness of TypedArray objects.

    $262.detachArrayBuffer is defined by a host.
defines: [$DETACHBUFFER]
---*/

function $DETACHBUFFER(buffer) {
  if (!$262 || typeof $262.detachArrayBuffer !== "function") {
    throw new Test262Error("No method available to detach an ArrayBuffer");
  }
  $262.detachArrayBuffer(buffer);
}