diff --git a/harness/atomicsHelper.js b/harness/atomicsHelper.js
index df5141743cc8d7210da47226382be44fbeea3f72..e6e7d9ca10859515178a594df00a3584b7821b74 100644
--- a/harness/atomicsHelper.js
+++ b/harness/atomicsHelper.js
@@ -5,25 +5,35 @@ description: >
     Collection of functions used to interact with Atomics.* operations across agent boundaries.
 ---*/
 
-var helper = helper || {};
-
 /**
  * The amount of slack allowed for testing time-related Atomics methods (i.e. wait and wake).
  * The absolute value of the difference of the observed time and the expected time must
  * be epsilon-close.
  */
-var $ATOMICS_MAX_TIME_EPSILON = 100;
+$262.agent.MAX_TIME_EPSILON = 100;
 
 /**
- *
  * @return {String} A report sent from an agent.
  */
-function getReport() {
-  var r;
-  while ((r = $262.agent.getReport()) == null) {
-    $262.agent.sleep(10);
-  }
-  return r;
+{
+  // This is only necessary because the original
+  // $262.agent.getReport API was 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
+  // breaking SpiderMonkey's $262.agent.getReport
+  let getReport = $262.agent.getReport.bind($262.agent);
+
+  $262.agent.getReport = function() {
+    var r;
+    while ((r = getReport()) == null) {
+      $262.agent.sleep(1);
+    }
+    return r;
+  };
 }
 /**
  * With a given Int32Array, wait until the expected number of agents have reported themselves by
@@ -35,14 +45,10 @@ function getReport() {
  * @param {Number} index    The index of which all agents will report.
  * @param {Number} expected The number of agents that are expected to report as active.
  */
-function waitUntil(i32a, index, expected) {
+$262.agent.waitUntil = function(i32a, index, expected) {
   let agents = 0;
   while ((agents = Atomics.load(i32a, index)) !== expected) {
     /* nothing */
   }
-  assert.sameValue(agents, expected, `'agents' equals the value of 'expected' (${expected})`);
-}
-
-
-helper.getReport = getReport;
-helper.waitUntil = waitUntil;
+  assert.sameValue(agents, expected, `Reporting number of 'agents' equals the value of 'expected' (${expected})`);
+};
diff --git a/test/built-ins/Atomics/isLockFree/expected-return-value.js b/test/built-ins/Atomics/isLockFree/expected-return-value.js
index a057543a8a059d9789a8b3ffd977677825c74ff3..cd5795c7849eba2dff3eb62eecc4afc2d0137a59 100644
--- a/test/built-ins/Atomics/isLockFree/expected-return-value.js
+++ b/test/built-ins/Atomics/isLockFree/expected-return-value.js
@@ -32,7 +32,7 @@ var isLockFree8;
   assert.sameValue(
     Atomics.isLockFree(1),
     isLockFree1,
-    'Atomics.isLockFree(1) equals the value of `isLockFree1` (Atomics.isLockFree(1))'
+    'Atomics.isLockFree(1) equals the value of `isLockFree1` (1)'
   );
 };
 {
@@ -47,7 +47,7 @@ var isLockFree8;
   assert.sameValue(
     Atomics.isLockFree(2),
     isLockFree2,
-    'Atomics.isLockFree(2) equals the value of `isLockFree2` (Atomics.isLockFree(2))'
+    'Atomics.isLockFree(2) equals the value of `isLockFree2` (2)'
   );
 };
 {
@@ -71,7 +71,7 @@ var isLockFree8;
   assert.sameValue(
     Atomics.isLockFree(8),
     isLockFree8,
-    'Atomics.isLockFree(8) equals the value of `isLockFree8` (Atomics.isLockFree(8))'
+    'Atomics.isLockFree(8) equals the value of `isLockFree8` (8)'
   );
 };
 
@@ -86,17 +86,17 @@ var isLockFree8;
 assert.sameValue(
   Atomics.isLockFree(1),
   isLockFree1,
-  'Later call to Atomics.isLockFree(1) equals the value of `isLockFree1` (Atomics.isLockFree(1))'
+  'Later call to Atomics.isLockFree(1) equals the value of `isLockFree1` (1)'
 );
 assert.sameValue(
   Atomics.isLockFree(2),
   isLockFree2,
-  'Later call to Atomics.isLockFree(2) equals the value of `isLockFree2` (Atomics.isLockFree(2))'
+  'Later call to Atomics.isLockFree(2) equals the value of `isLockFree2` (2)'
 );
 assert.sameValue(
   Atomics.isLockFree(8),
   isLockFree8,
-  'Later call to Atomics.isLockFree(8) equals the value of `isLockFree8` (Atomics.isLockFree(8))'
+  'Later call to Atomics.isLockFree(8) equals the value of `isLockFree8` (8)'
 );
 
 // Duplicates behavior created by loop from above
diff --git a/test/built-ins/Atomics/wait/bigint/false-for-timeout-agent.js b/test/built-ins/Atomics/wait/bigint/false-for-timeout-agent.js
index 3b21c4c540f7bca345810d9431bb8346d5e31450..9ed38e8987f0b1ae231d8b417305f72fc1e95001 100644
--- a/test/built-ins/Atomics/wait/bigint/false-for-timeout-agent.js
+++ b/test/built-ins/Atomics/wait/bigint/false-for-timeout-agent.js
@@ -47,18 +47,18 @@ const i64a = new BigInt64Array(
 $262.agent.broadcast(i64a.buffer);
 $262.agent.sleep(100);
 
-assert.sameValue(getReport(), 'timed-out');
-assert.sameValue(getReport(), 'timed-out');
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= 0,
   `${lapse} should be greater than, or equal to 0`
 );
 assert(
-  lapse <= $ATOMICS_MAX_TIME_EPSILON,
-  `${lapse} should be less than ${$ATOMICS_MAX_TIME_EPSILON}`
+  lapse <= $262.agent.MAX_TIME_EPSILON,
+  `${lapse} should be less than ${$262.agent.MAX_TIME_EPSILON}`
 );
 assert.sameValue(Atomics.wake(i64a, 0), 0);
 
diff --git a/test/built-ins/Atomics/wait/bigint/good-views.js b/test/built-ins/Atomics/wait/bigint/good-views.js
index f478ab396a5759ec4d43d50b235a4538edffe9d4..0c1bbc0ca89f37be43d6890cf85f18906c20addd 100644
--- a/test/built-ins/Atomics/wait/bigint/good-views.js
+++ b/test/built-ins/Atomics/wait/bigint/good-views.js
@@ -44,10 +44,6 @@ $262.agent.start(`
   $262.agent.leaving();
 `);
 
-assert.sameValue(getReport(), "A timed-out");
-assert.sameValue(getReport(), "B not-equal"); // Even with zero timeout
-
-var r;
-while ((r = getReport()) != "done") {
-  assert.sameValue(r, "C not-equal");
-}
+assert.sameValue($262.agent.getReport(), 'A timed-out');
+assert.sameValue($262.agent.getReport(), 'B not-equal');
+assert.sameValue($262.agent.getReport(), 'C not-equal');
diff --git a/test/built-ins/Atomics/wait/bigint/nan-for-timeout.js b/test/built-ins/Atomics/wait/bigint/nan-for-timeout.js
index 9963ad7c5ed0980672331e655a6872e09fdbae60..21723c9becc65d8d39725e2230dc24f423b09e05 100644
--- a/test/built-ins/Atomics/wait/bigint/nan-for-timeout.js
+++ b/test/built-ins/Atomics/wait/bigint/nan-for-timeout.js
@@ -32,4 +32,4 @@ const i64a = new BigInt64Array(
 $262.agent.broadcast(i64a.buffer);
 $262.agent.sleep(100);
 assert.sameValue(Atomics.wake(i64a, 0), 1);
-assert.sameValue(getReport(), 'ok');
+assert.sameValue($262.agent.getReport(), 'ok');
diff --git a/test/built-ins/Atomics/wait/bigint/negative-timeout-agent.js b/test/built-ins/Atomics/wait/bigint/negative-timeout-agent.js
index 2e8ef99b29ff0b6cc1eff9732ca6b2ccf87a07ea..d828c990c9950bd7919b426e62fac775ced0d91e 100644
--- a/test/built-ins/Atomics/wait/bigint/negative-timeout-agent.js
+++ b/test/built-ins/Atomics/wait/bigint/negative-timeout-agent.js
@@ -23,5 +23,5 @@ const i64a = new BigInt64Array(
 
 $262.agent.broadcast(i64a.buffer);
 $262.agent.sleep(10);
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i64a, 0), 0);
diff --git a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-no-operation.js b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-no-operation.js
index 5c6cd8407c20bd5659a334fa23f99371e7c4b460..cb91b6da4e8cd94544feb1af5d4345f0c36ce200 100644
--- a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-no-operation.js
+++ b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-no-operation.js
@@ -37,10 +37,10 @@ $262.agent.sleep(10);
 
 // NO OPERATION OCCURS HERE!
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i64a, 0), 0);
diff --git a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-add.js b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-add.js
index a849a0dfbd53e23b579c2fb971f0247a19dfa8c5..2cc3ddae5fa6dca1eb17c2f76e41d6e8258349d8 100644
--- a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-add.js
+++ b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-add.js
@@ -30,12 +30,12 @@ $262.agent.sleep(10);
 
 Atomics.add(i64a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i64a, 0), 0);
 
 
diff --git a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-and.js b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-and.js
index 65ac7b19ad2bee6531edafa3a948e8b3e4d98e0b..2d92ce6f43a4d4ef980405fb2230f9c057c17ac8 100644
--- a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-and.js
+++ b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-and.js
@@ -29,12 +29,12 @@ $262.agent.sleep(10);
 
 Atomics.and(i64a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i64a, 0), 0);
 
 
diff --git a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-compareExchange.js b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-compareExchange.js
index 8a65b0805c3714d0ea389dc6baf45d0a7151b006..b6faecf4778bd141eb82c81a173dae7e474c6da8 100644
--- a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-compareExchange.js
+++ b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-compareExchange.js
@@ -29,10 +29,10 @@ $262.agent.sleep(10);
 
 Atomics.compareExchange(i64a, 0, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i64a, 0), 0);
diff --git a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-exchange.js b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-exchange.js
index 24e70acdc1cd2c20d5214a6a7c501850d744efba..23b63d38fc83eabe9f81adcfaa92521f9cb139aa 100644
--- a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-exchange.js
+++ b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-exchange.js
@@ -29,11 +29,11 @@ $262.agent.sleep(10);
 
 Atomics.exchange(i64a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i64a, 0), 0);
 
diff --git a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-or.js b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-or.js
index ae0d560e2ad7bcc312b25e721eeff8b6451c6c6c..352642bfa5e975b39f5352b517a12e89076a8fe1 100644
--- a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-or.js
+++ b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-or.js
@@ -29,12 +29,12 @@ $262.agent.sleep(10);
 
 Atomics.or(i64a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i64a, 0), 0);
 
 
diff --git a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-store.js b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-store.js
index 6e25fe7a3d926ef8a57b838d5c7f1fc3327e494a..7f955ac2c090c9023ad926c96af45dce59f7454a 100644
--- a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-store.js
+++ b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-store.js
@@ -29,11 +29,11 @@ $262.agent.sleep(10);
 
 Atomics.store(i64a, 0, 0x111111);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i64a, 0), 0);
 
diff --git a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-sub.js b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-sub.js
index b291f9d2be8c439fc9d529ad6fa2ac25bbb82ff6..68bcdea9a3b8692870fa702d5a9acdd5e411cdd6 100644
--- a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-sub.js
+++ b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-sub.js
@@ -29,10 +29,10 @@ $262.agent.sleep(10);
 
 Atomics.sub(i64a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i64a, 0), 0);
diff --git a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-xor.js b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-xor.js
index 5bb9c7da9483881823d2a774628c364339122c8a..b06ac9565cf9b14eda2826696432f13d0cd5653c 100644
--- a/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-xor.js
+++ b/test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-xor.js
@@ -29,12 +29,12 @@ $262.agent.sleep(10);
 
 Atomics.xor(i64a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i64a, 0), 0);
 
 
diff --git a/test/built-ins/Atomics/wait/bigint/value-not-equal.js b/test/built-ins/Atomics/wait/bigint/value-not-equal.js
index 351e6782879761609bd8c11494bf0215ece47226..c67f82808081df47b87e9125f6259942233cfe4e 100644
--- a/test/built-ins/Atomics/wait/bigint/value-not-equal.js
+++ b/test/built-ins/Atomics/wait/bigint/value-not-equal.js
@@ -37,6 +37,6 @@ const i64a = new BigInt64Array(
 $262.agent.broadcast(i64a.buffer);
 $262.agent.sleep(100);
 
-assert.sameValue(getReport(), value.toString());
-assert.sameValue(getReport(), 'not-equal');
+assert.sameValue($262.agent.getReport(), value.toString());
+assert.sameValue($262.agent.getReport(), 'not-equal');
 
diff --git a/test/built-ins/Atomics/wait/bigint/waiterlist-block-indexedposition-wake.js b/test/built-ins/Atomics/wait/bigint/waiterlist-block-indexedposition-wake.js
index ee128c52d99ac3ec1fb7c54d19070956b4e4f358..b141a4ff4580485e956d6e79ef0e1bbc0fa229ae 100644
--- a/test/built-ins/Atomics/wait/bigint/waiterlist-block-indexedposition-wake.js
+++ b/test/built-ins/Atomics/wait/bigint/waiterlist-block-indexedposition-wake.js
@@ -60,8 +60,8 @@ assert.sameValue(Atomics.wake(i64a, 5), 0, 'Atomics.wake(i64a, 5) returns 0');
 
 // Wake index 7, wakes 1
 assert.sameValue(Atomics.wake(i64a, 7), 1, 'Atomics.wake(i64a, 7) returns 1');
-assert.sameValue(getReport(), 'ok', 'getReport() returns "ok"');
+assert.sameValue($262.agent.getReport(), 'ok', '$262.agent.getReport() returns "ok"');
 
 // Wake index 0, wakes 1
 assert.sameValue(Atomics.wake(i64a, 0), 1, 'Atomics.wake(i64a, 0) returns 1');
-assert.sameValue(getReport(), 'ok', 'getReport() returns "ok"');
+assert.sameValue($262.agent.getReport(), 'ok', '$262.agent.getReport() returns "ok"');
diff --git a/test/built-ins/Atomics/wait/bigint/waiterlist-order-of-operations-is-fifo.js b/test/built-ins/Atomics/wait/bigint/waiterlist-order-of-operations-is-fifo.js
index 3cf805064048c196ff74efee88d345bbc39b4c2a..95a554b72d2b946d19bb4d814bd9624ec6854af0 100644
--- a/test/built-ins/Atomics/wait/bigint/waiterlist-order-of-operations-is-fifo.js
+++ b/test/built-ins/Atomics/wait/bigint/waiterlist-order-of-operations-is-fifo.js
@@ -61,17 +61,17 @@ $262.agent.broadcast(i64a.buffer);
 $262.agent.sleep(100);
 
 // Agents may be started in any order...
-const started = [getReport(), getReport(), getReport()];
+const started = [$262.agent.getReport(), $262.agent.getReport(), $262.agent.getReport()];
 
 // Agents must wake in the order they waited
 assert.sameValue(Atomics.wake(i64a, 1, 1), 1);
-assert.sameValue(getReport(), 'ok');
-assert.sameValue(getReport(), started[0]);
+assert.sameValue($262.agent.getReport(), 'ok');
+assert.sameValue($262.agent.getReport(), started[0]);
 
 assert.sameValue(Atomics.wake(i64a, 2, 1), 1);
-assert.sameValue(getReport(), 'ok');
-assert.sameValue(getReport(), started[1]);
+assert.sameValue($262.agent.getReport(), 'ok');
+assert.sameValue($262.agent.getReport(), started[1]);
 
 assert.sameValue(Atomics.wake(i64a, 3, 1), 1);
-assert.sameValue(getReport(), 'ok');
-assert.sameValue(getReport(), started[2]);
+assert.sameValue($262.agent.getReport(), 'ok');
+assert.sameValue($262.agent.getReport(), started[2]);
diff --git a/test/built-ins/Atomics/wait/bigint/was-woken-before-timeout.js b/test/built-ins/Atomics/wait/bigint/was-woken-before-timeout.js
index c21b75cd4a15c9a935a200e72a2e28afdb73eb0b..d9084dcdf57b9c55f4bcde603a8580aff1446001 100644
--- a/test/built-ins/Atomics/wait/bigint/was-woken-before-timeout.js
+++ b/test/built-ins/Atomics/wait/bigint/was-woken-before-timeout.js
@@ -45,12 +45,12 @@ $262.agent.sleep(sleeping);
 
 assert.sameValue(Atomics.wake(i64a, 0), 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 
 assert(
   sleeping + lapse < timeout,
   `${sleeping + lapse} should be less than ${timeout}`
 );
-assert.sameValue(getReport(), 'ok');
+assert.sameValue($262.agent.getReport(), 'ok');
 
 
diff --git a/test/built-ins/Atomics/wait/false-for-timeout-agent.js b/test/built-ins/Atomics/wait/false-for-timeout-agent.js
index 616b095b77df59882661f2d27980d6ae3180caa6..1bdda0a50e4c761c8f4dd6dfdd85a8ea84dd46f0 100644
--- a/test/built-ins/Atomics/wait/false-for-timeout-agent.js
+++ b/test/built-ins/Atomics/wait/false-for-timeout-agent.js
@@ -47,15 +47,15 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(100);
 
-assert.sameValue(getReport(), 'timed-out');
-assert.sameValue(getReport(), 'timed-out');
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 
-var lapse = getReport();
+var lapse = $262.agent.getReport();
 
 assert(lapse >= 0, 'timeout should be a min of 0ms');
 
-assert(lapse <= $ATOMICS_MAX_TIME_EPSILON, `timeout should be a max of ${$ATOMICS_MAX_TIME_EPSILON}`);
+assert(lapse <= $262.agent.MAX_TIME_EPSILON, `timeout should be a max of ${$262.agent.MAX_TIME_EPSILON}`);
 
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
diff --git a/test/built-ins/Atomics/wait/good-views.js b/test/built-ins/Atomics/wait/good-views.js
index 9b6b253de8c232c32f3eb38c56e4f0c4bfc7b899..536293c23e86808acf494ad1dd47723c07cce6a6 100644
--- a/test/built-ins/Atomics/wait/good-views.js
+++ b/test/built-ins/Atomics/wait/good-views.js
@@ -44,10 +44,6 @@ $262.agent.start(`
   $262.agent.leaving();
 `);
 
-assert.sameValue(getReport(), 'A timed-out');
-assert.sameValue(getReport(), 'B not-equal'); // Even with zero timeout
-
-var r;
-while ((r = getReport()) != "done") {
-  assert.sameValue(r, "C not-equal");
-}
+assert.sameValue($262.agent.getReport(), 'A timed-out');
+assert.sameValue($262.agent.getReport(), 'B not-equal');
+assert.sameValue($262.agent.getReport(), 'C not-equal');
diff --git a/test/built-ins/Atomics/wait/nan-for-timeout.js b/test/built-ins/Atomics/wait/nan-for-timeout.js
index d5075813b8f033d35b16413e6e3f0d0a9223f76c..7ae886c772358c664714e224026a92e18a9bf4c3 100644
--- a/test/built-ins/Atomics/wait/nan-for-timeout.js
+++ b/test/built-ins/Atomics/wait/nan-for-timeout.js
@@ -33,4 +33,4 @@ $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(500); // Ample time
 
 assert.sameValue(Atomics.wake(i32a, 0), 1);
-assert.sameValue(getReport(), "ok");
+assert.sameValue($262.agent.getReport(), "ok");
diff --git a/test/built-ins/Atomics/wait/negative-timeout-agent.js b/test/built-ins/Atomics/wait/negative-timeout-agent.js
index a4557714c850cc2d510d92d4c5595dc7a382e5e8..4b93eeb05faef5738b3979455fe21e5f910e41f0 100644
--- a/test/built-ins/Atomics/wait/negative-timeout-agent.js
+++ b/test/built-ins/Atomics/wait/negative-timeout-agent.js
@@ -24,5 +24,5 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(100);
 
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i32a, 0), 0);
diff --git a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-add.js b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-add.js
index d98e92ec7686e9cb0ebeabdbe14ddeb06189771c..4ed4cc2b37bd02d4a8eecaa61278fa64092f2f03 100644
--- a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-add.js
+++ b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-add.js
@@ -30,12 +30,12 @@ $262.agent.sleep(10);
 
 Atomics.add(i32a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
 
diff --git a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-and.js b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-and.js
index 29c2bf2a2b5d95a13be1ae57296dec07bdc9f613..66f6bc7c03dd717cb12212007a9f8faaf633fa8d 100644
--- a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-and.js
+++ b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-and.js
@@ -30,12 +30,12 @@ $262.agent.sleep(10);
 
 Atomics.and(i32a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
 
diff --git a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-compareExchange.js b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-compareExchange.js
index 31d9cd74c0d2772ae02074fb591e12c834e1b1fd..fdb8bd04feaeb688ca0900330f554fe7ea5733e4 100644
--- a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-compareExchange.js
+++ b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-compareExchange.js
@@ -30,10 +30,10 @@ $262.agent.sleep(10);
 
 Atomics.compareExchange(i32a, 0, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i32a, 0), 0);
diff --git a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-exchange.js b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-exchange.js
index aeb16b37bc035b49f658517e623f69106d42b1b0..6976bcdfccba73891c3e80ff0d038e623ab5b2aa 100644
--- a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-exchange.js
+++ b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-exchange.js
@@ -30,11 +30,11 @@ $262.agent.sleep(10);
 
 Atomics.exchange(i32a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
diff --git a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-or.js b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-or.js
index a365f2effdb659f8f5ed0da0cb47709b340112d4..847706e762b6a19878851fb5320ccc6cdd4a626b 100644
--- a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-or.js
+++ b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-or.js
@@ -30,12 +30,12 @@ $262.agent.sleep(10);
 
 Atomics.or(i32a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
 
diff --git a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-store.js b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-store.js
index 0ce28339a811753f90f6286d10b442f2747af1b5..e2e918fab4c50556c7bd705addafcd2267b3dd48 100644
--- a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-store.js
+++ b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-store.js
@@ -30,11 +30,11 @@ $262.agent.sleep(10);
 
 Atomics.store(i32a, 0, 0x111111);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
diff --git a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-sub.js b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-sub.js
index 081f9a428e84678da03d2b5f7fbd2ac80f007832..196d3d260466c0e5088d153c963dc49e7591f26e 100644
--- a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-sub.js
+++ b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-sub.js
@@ -30,10 +30,10 @@ $262.agent.sleep(10);
 
 Atomics.sub(i32a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i32a, 0), 0);
diff --git a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-xor.js b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-xor.js
index a96e43346741ac55233bce551076a4a7a32bc41e..83c7c97af92d05d7a89c7fd20a53f0facf983e26 100644
--- a/test/built-ins/Atomics/wait/no-spurious-wakeup-on-xor.js
+++ b/test/built-ins/Atomics/wait/no-spurious-wakeup-on-xor.js
@@ -30,12 +30,12 @@ $262.agent.sleep(10);
 
 Atomics.xor(i32a, 0, 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 assert(
   lapse >= TIMEOUT,
   `${lapse} should be at least ${TIMEOUT}`
 );
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
 
diff --git a/test/built-ins/Atomics/wait/null-for-timeout-agent.js b/test/built-ins/Atomics/wait/null-for-timeout-agent.js
index 599d95091eaf1b273ac84be8031590db0df5b7ce..6ba9a4f5b753fa171141e86fdc0c710da53840ec 100644
--- a/test/built-ins/Atomics/wait/null-for-timeout-agent.js
+++ b/test/built-ins/Atomics/wait/null-for-timeout-agent.js
@@ -47,15 +47,15 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(150);
 
-assert.sameValue(getReport(), 'timed-out');
-assert.sameValue(getReport(), 'timed-out');
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 
 assert(lapse >= 0, 'timeout should be a min of 0ms');
 
-assert(lapse <= $ATOMICS_MAX_TIME_EPSILON, 'timeout should be a max of $ATOMICS_MAX_TIME_EPSILON');
+assert(lapse <= $262.agent.MAX_TIME_EPSILON, 'timeout should be a max of $262.agent.MAX_TIME_EPSILON');
 
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
diff --git a/test/built-ins/Atomics/wait/object-for-timeout-agent.js b/test/built-ins/Atomics/wait/object-for-timeout-agent.js
index 4f5f2e9913c6dc801f911403940026eb036d522d..6446096693df08841fc4e33992b7ecf169574b6d 100644
--- a/test/built-ins/Atomics/wait/object-for-timeout-agent.js
+++ b/test/built-ins/Atomics/wait/object-for-timeout-agent.js
@@ -52,15 +52,15 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(150);
 
-assert.sameValue(getReport(), 'timed-out');
-assert.sameValue(getReport(), 'timed-out');
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 
-var lapse = getReport();
+const lapse = $262.agent.getReport();
 
 assert(lapse >= 0, 'timeout should be a min of 0ms');
 
-assert(lapse <= $ATOMICS_MAX_TIME_EPSILON, 'timeout should be a max of $$ATOMICS_MAX_TIME_EPSILON');
+assert(lapse <= $262.agent.MAX_TIME_EPSILON, 'timeout should be a max of $$262.agent.MAX_TIME_EPSILON');
 
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
diff --git a/test/built-ins/Atomics/wait/poisoned-object-for-timeout-throws-agent.js b/test/built-ins/Atomics/wait/poisoned-object-for-timeout-throws-agent.js
index 5ec9f809459218f32f239778b29d9f8aff9d5efb..6642ccfe3addc744ae0e0b294ef85136257bc3b5 100644
--- a/test/built-ins/Atomics/wait/poisoned-object-for-timeout-throws-agent.js
+++ b/test/built-ins/Atomics/wait/poisoned-object-for-timeout-throws-agent.js
@@ -54,14 +54,14 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(150);
 
-assert.sameValue(getReport(), 'poisonedValueOf');
-assert.sameValue(getReport(), 'poisonedToPrimitive');
+assert.sameValue($262.agent.getReport(), 'poisonedValueOf');
+assert.sameValue($262.agent.getReport(), 'poisonedToPrimitive');
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 
 assert(lapse >= 0, 'timeout should be a min of 0ms');
 
-assert(lapse <= $ATOMICS_MAX_TIME_EPSILON, 'timeout should be a max of $$ATOMICS_MAX_TIME_EPSILON');
+assert(lapse <= $262.agent.MAX_TIME_EPSILON, 'timeout should be a max of $$262.agent.MAX_TIME_EPSILON');
 
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
diff --git a/test/built-ins/Atomics/wait/symbol-for-index-throws-agent.js b/test/built-ins/Atomics/wait/symbol-for-index-throws-agent.js
index c4bc9e7cf54b908697385d6a9d48a3d77a719c6f..7065e97a852c75e0db13043db8c6f01a888e0a9b 100644
--- a/test/built-ins/Atomics/wait/symbol-for-index-throws-agent.js
+++ b/test/built-ins/Atomics/wait/symbol-for-index-throws-agent.js
@@ -67,13 +67,13 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(150);
 
-assert.sameValue(getReport(), 'Symbol("1")');
-assert.sameValue(getReport(), 'Symbol("2")');
+assert.sameValue($262.agent.getReport(), 'Symbol("1")');
+assert.sameValue($262.agent.getReport(), 'Symbol("2")');
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 
 assert(lapse >= 0, 'timeout should be a min of 0ms');
-assert(lapse <= $ATOMICS_MAX_TIME_EPSILON, 'timeout should be a max of $$ATOMICS_MAX_TIME_EPSILON');
+assert(lapse <= $262.agent.MAX_TIME_EPSILON, 'timeout should be a max of $$262.agent.MAX_TIME_EPSILON');
 
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
diff --git a/test/built-ins/Atomics/wait/symbol-for-timeout-throws-agent.js b/test/built-ins/Atomics/wait/symbol-for-timeout-throws-agent.js
index b730a5baba1efc940775e9521ad5633d289f4252..a0b33165588562fa6ff4af1b653f96d3c50ec7e0 100644
--- a/test/built-ins/Atomics/wait/symbol-for-timeout-throws-agent.js
+++ b/test/built-ins/Atomics/wait/symbol-for-timeout-throws-agent.js
@@ -41,12 +41,12 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(150);
 
-assert.sameValue(getReport(), 'Symbol("1")');
-assert.sameValue(getReport(), 'Symbol("2")');
+assert.sameValue($262.agent.getReport(), 'Symbol("1")');
+assert.sameValue($262.agent.getReport(), 'Symbol("2")');
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 
 assert(lapse >= 0, 'timeout should be a min of 0ms');
-assert(lapse <= $ATOMICS_MAX_TIME_EPSILON, 'timeout should be a max of $$ATOMICS_MAX_TIME_EPSILON');
+assert(lapse <= $262.agent.MAX_TIME_EPSILON, 'timeout should be a max of $$262.agent.MAX_TIME_EPSILON');
 
 assert.sameValue(Atomics.wake(i32a, 0), 0);
diff --git a/test/built-ins/Atomics/wait/symbol-for-value-throws-agent.js b/test/built-ins/Atomics/wait/symbol-for-value-throws-agent.js
index 2457900778b0346a6a2eb7c3cf3a612ddad83c2e..6a2faa17db3920cfc185f391c9026d2f07ed5ff8 100644
--- a/test/built-ins/Atomics/wait/symbol-for-value-throws-agent.js
+++ b/test/built-ins/Atomics/wait/symbol-for-value-throws-agent.js
@@ -58,12 +58,12 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(150);
 
-assert.sameValue(getReport(), 'Symbol("1")');
-assert.sameValue(getReport(), 'Symbol("2")');
+assert.sameValue($262.agent.getReport(), 'Symbol("1")');
+assert.sameValue($262.agent.getReport(), 'Symbol("2")');
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 
 assert(lapse >= 0, 'timeout should be a min of 0ms');
-assert(lapse <= $ATOMICS_MAX_TIME_EPSILON, 'timeout should be a max of $$ATOMICS_MAX_TIME_EPSILON');
+assert(lapse <= $262.agent.MAX_TIME_EPSILON, 'timeout should be a max of $$262.agent.MAX_TIME_EPSILON');
 
 assert.sameValue(Atomics.wake(i32a, 0), 0);
diff --git a/test/built-ins/Atomics/wait/true-for-timeout-agent.js b/test/built-ins/Atomics/wait/true-for-timeout-agent.js
index 0b8df771bdb0f0818cd61a60f88570f71d06d3e6..be3adbb63917c88cde79df4b73a5cd5f07214015 100644
--- a/test/built-ins/Atomics/wait/true-for-timeout-agent.js
+++ b/test/built-ins/Atomics/wait/true-for-timeout-agent.js
@@ -47,15 +47,15 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(150);
 
-assert.sameValue(getReport(), 'timed-out');
-assert.sameValue(getReport(), 'timed-out');
-assert.sameValue(getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
+assert.sameValue($262.agent.getReport(), 'timed-out');
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 
 assert(lapse >= 0, 'timeout should be a min of 0ms');
 
-assert(lapse <= $ATOMICS_MAX_TIME_EPSILON, 'timeout should be a max of $$ATOMICS_MAX_TIME_EPSILON');
+assert(lapse <= $262.agent.MAX_TIME_EPSILON, 'timeout should be a max of $$262.agent.MAX_TIME_EPSILON');
 
 assert.sameValue(Atomics.wake(i32a, 0), 0);
 
diff --git a/test/built-ins/Atomics/wait/undefined-for-timeout.js b/test/built-ins/Atomics/wait/undefined-for-timeout.js
index 2ab278457292fd081152ec3f61d7710f31be277f..fd38c69ab386e8a68753a962de620843464ff643 100644
--- a/test/built-ins/Atomics/wait/undefined-for-timeout.js
+++ b/test/built-ins/Atomics/wait/undefined-for-timeout.js
@@ -17,14 +17,17 @@ includes: [atomicsHelper.js]
 features: [Atomics, SharedArrayBuffer, TypedArray]
 ---*/
 
-const NUMAGENT = 2; // Total number of agents started
-const WAKEUP = 0; // Index all agents are waiting on
-const WAKECOUNT = 2; // Total number of agents to wake up
+const WAIT_INDEX = 0; // Index all agents are waiting on
+const RUNNING = 1;
+const NUMAGENT = 2;   // Total number of agents started
+const WAKECOUNT = 2;  // Total number of agents to wake up
 
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     var i32a = new Int32Array(sab);
-    $262.agent.report("A " + Atomics.wait(i32a, 0, 0, undefined));  // undefined => NaN => +Infinity
+    // undefined => NaN => +Infinity
+    Atomics.add(i32a, ${RUNNING}, 1);
+    $262.agent.report("A " + Atomics.wait(i32a, 0, 0, undefined));
     $262.agent.leaving();
   });
 `);
@@ -32,7 +35,9 @@ $262.agent.start(`
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     var i32a = new Int32Array(sab);
-    $262.agent.report("B " + Atomics.wait(i32a, 0, 0));  // undefined timeout arg => NaN => +Infinity
+    // undefined timeout arg => NaN => +Infinity
+    Atomics.add(i32a, ${RUNNING}, 1);
+    $262.agent.report("B " + Atomics.wait(i32a, 0, 0));
     $262.agent.leaving();
   });
 `);
@@ -42,18 +47,15 @@ const i32a = new Int32Array(
 );
 
 $262.agent.broadcast(i32a.buffer);
-$262.agent.sleep(500); // Ample time
+$262.agent.waitUntil(i32a, RUNNING, NUMAGENT);
 
-// No Reports made before wait
-assert.sameValue(getReport(), null);
+assert.sameValue(Atomics.wake(i32a, WAIT_INDEX, WAKECOUNT), WAKECOUNT);
 
-assert.sameValue(Atomics.wake(i32a, WAKEUP, WAKECOUNT), WAKECOUNT);
-
-const sortedReports = [];
+const reports = [];
 for (var i = 0; i < NUMAGENT; i++) {
-  sortedReports.push(getReport());
+  reports.push($262.agent.getReport());
 }
-sortedReports.sort();
+reports.sort();
 
-assert.sameValue(sortedReports[0], 'A ok');
-assert.sameValue(sortedReports[1], 'B ok');
+assert.sameValue(reports[0], 'A ok');
+assert.sameValue(reports[1], 'B ok');
diff --git a/test/built-ins/Atomics/wait/undefined-index-defaults-to-zero.js b/test/built-ins/Atomics/wait/undefined-index-defaults-to-zero.js
index f3f722c7fa00d34be692680311d67f87f9e94b85..6a01b06d9f9c892a9b0224d741385536f6f8bdfb 100644
--- a/test/built-ins/Atomics/wait/undefined-index-defaults-to-zero.js
+++ b/test/built-ins/Atomics/wait/undefined-index-defaults-to-zero.js
@@ -39,4 +39,4 @@ $262.agent.sleep(150);
 
 assert.sameValue(Atomics.wake(i32a, 0), 1); // wake at index 0
 assert.sameValue(Atomics.wake(i32a, 0), 0); // wake again at index 0, and 0 agents should be woken
-assert.sameValue(getReport(), 'ok');
+assert.sameValue($262.agent.getReport(), 'ok');
diff --git a/test/built-ins/Atomics/wait/value-not-equal.js b/test/built-ins/Atomics/wait/value-not-equal.js
index 82dde2224e6e914acaa7f85519c3d0034996da29..8111ba45e58e0669bfcd8170858b377dd25f2c32 100644
--- a/test/built-ins/Atomics/wait/value-not-equal.js
+++ b/test/built-ins/Atomics/wait/value-not-equal.js
@@ -36,6 +36,6 @@ const i32a = new Int32Array(
 
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(100);
-assert.sameValue(getReport(), value.toString());
-assert.sameValue(getReport(), 'not-equal');
+assert.sameValue($262.agent.getReport(), value.toString());
+assert.sameValue($262.agent.getReport(), 'not-equal');
 
diff --git a/test/built-ins/Atomics/wait/wait-index-value-not-equal.js b/test/built-ins/Atomics/wait/wait-index-value-not-equal.js
index 16f427246933008d990383fe11ea50cbda3df13b..19c6c90a7098312383bebae12a5d2e20bec86bd1 100644
--- a/test/built-ins/Atomics/wait/wait-index-value-not-equal.js
+++ b/test/built-ins/Atomics/wait/wait-index-value-not-equal.js
@@ -33,6 +33,6 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(100);
 
-assert.sameValue(getReport(), 'not-equal');
-assert.sameValue(getReport(), 'not-equal');
+assert.sameValue($262.agent.getReport(), 'not-equal');
+assert.sameValue($262.agent.getReport(), 'not-equal');
 assert.sameValue(Atomics.wake(i32a, 0), 0);
diff --git a/test/built-ins/Atomics/wait/waiterlist-block-indexedposition-wake.js b/test/built-ins/Atomics/wait/waiterlist-block-indexedposition-wake.js
index c25fb386cc7f0cbcdc25496df99ec445d5232d76..0d3f0acf0076fce131a9b420de8b869057771f37 100644
--- a/test/built-ins/Atomics/wait/waiterlist-block-indexedposition-wake.js
+++ b/test/built-ins/Atomics/wait/waiterlist-block-indexedposition-wake.js
@@ -56,8 +56,8 @@ assert.sameValue(Atomics.wake(i32a, 3), 0, 'Atomics.wake(i32a, 3) returns 0');
 
 // Wake index 2, wakes 1
 assert.sameValue(Atomics.wake(i32a, 2), 1, 'Atomics.wake(i32a, 2) returns 1');
-assert.sameValue(getReport(), 'ok', 'getReport() returns "ok"');
+assert.sameValue($262.agent.getReport(), 'ok', '$262.agent.getReport() returns "ok"');
 
 // Wake index 0, wakes 1
 assert.sameValue(Atomics.wake(i32a, 0), 1, 'Atomics.wake(i32a, 0) returns 1');
-assert.sameValue(getReport(), 'ok', 'getReport() returns "ok"');
+assert.sameValue($262.agent.getReport(), 'ok', '$262.agent.getReport() returns "ok"');
diff --git a/test/built-ins/Atomics/wait/waiterlist-order-of-operations-is-fifo.js b/test/built-ins/Atomics/wait/waiterlist-order-of-operations-is-fifo.js
index bbd670bd09e8ac88ff217784dd26fe771f1f4add..418dd921be2a3a4a6eb31e84402af5dee235d068 100644
--- a/test/built-ins/Atomics/wait/waiterlist-order-of-operations-is-fifo.js
+++ b/test/built-ins/Atomics/wait/waiterlist-order-of-operations-is-fifo.js
@@ -62,17 +62,17 @@ $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(100);
 
 // Agents may be started in any order...
-const started = [getReport(), getReport(), getReport()];
+const started = [$262.agent.getReport(), $262.agent.getReport(), $262.agent.getReport()];
 
 // Agents must wake in the order they waited
 assert.sameValue(Atomics.wake(i32a, 1, 1), 1);
-assert.sameValue(getReport(), 'ok');
-assert.sameValue(getReport(), started[0]);
+assert.sameValue($262.agent.getReport(), 'ok');
+assert.sameValue($262.agent.getReport(), started[0]);
 
 assert.sameValue(Atomics.wake(i32a, 2, 1), 1);
-assert.sameValue(getReport(), 'ok');
-assert.sameValue(getReport(), started[1]);
+assert.sameValue($262.agent.getReport(), 'ok');
+assert.sameValue($262.agent.getReport(), started[1]);
 
 assert.sameValue(Atomics.wake(i32a, 3, 1), 1);
-assert.sameValue(getReport(), 'ok');
-assert.sameValue(getReport(), started[2]);
+assert.sameValue($262.agent.getReport(), 'ok');
+assert.sameValue($262.agent.getReport(), started[2]);
diff --git a/test/built-ins/Atomics/wait/was-woken-before-timeout.js b/test/built-ins/Atomics/wait/was-woken-before-timeout.js
index cd9c31bdb825abe7ad75af6ff07655ac3e7dbec3..ba5c9ee4dc535771f0dae002ae7bb7cf8cbab6df 100644
--- a/test/built-ins/Atomics/wait/was-woken-before-timeout.js
+++ b/test/built-ins/Atomics/wait/was-woken-before-timeout.js
@@ -45,12 +45,12 @@ $262.agent.sleep(sleeping);
 
 assert.sameValue(Atomics.wake(i32a, 0), 1);
 
-const lapse = getReport();
+const lapse = $262.agent.getReport();
 
 assert(
   sleeping + lapse < timeout,
   `${sleeping + lapse} should be less than ${timeout}`
 );
-assert.sameValue(getReport(), 'ok');
+assert.sameValue($262.agent.getReport(), 'ok');
 
 
diff --git a/test/built-ins/Atomics/wake/bigint/wake-all-on-loc.js b/test/built-ins/Atomics/wake/bigint/wake-all-on-loc.js
index a6efe4057547e054bf29c059741674d270a42653..8e6568779cd1002daabe780aa5fd976a9254687d 100644
--- a/test/built-ins/Atomics/wake/bigint/wake-all-on-loc.js
+++ b/test/built-ins/Atomics/wake/bigint/wake-all-on-loc.js
@@ -43,7 +43,7 @@ const i64a = new BigInt64Array(
 $262.agent.broadcast(i64a.buffer);
 
 // Wait for agents to be running.
-waitUntil(i64a, RUNNING, BUFFER_SIZE);
+$262.agent.waitUntil(i64a, RUNNING, BUFFER_SIZE);
 
 // Then wait some more to give the agents a fair chance to wait.  If we don't,
 // we risk sending the wakeup before agents are sleeping, and we hang.
@@ -56,14 +56,14 @@ assert.sameValue(
   'Atomics.wake(i64a, WAIT_INDEX) equals the value of `NUMAGENT` (3)'
 );
 
-var rs = [];
+var reports = [];
 for (var i = 0; i < NUMAGENT + 1; i++) {
-  rs.push(getReport());
+  reports.push($262.agent.getReport());
 }
-rs.sort();
+reports.sort();
 
 for (var i = 0; i < NUMAGENT; i++) {
-  assert.sameValue(rs[i], 'A ok', 'The value of rs[i] is "A ok"');
+  assert.sameValue(reports[i], 'A ok', 'The value of reports[i] is "A ok"');
 }
-assert.sameValue(rs[NUMAGENT], 'B timed-out', 'The value of rs[NUMAGENT] is "B timed-out"');
+assert.sameValue(reports[NUMAGENT], 'B timed-out', 'The value of reports[NUMAGENT] is "B timed-out"');
 
diff --git a/test/built-ins/Atomics/wake/count-defaults-to-infinity-missing.js b/test/built-ins/Atomics/wake/count-defaults-to-infinity-missing.js
index 8db6dee17e6bdce17bc23c53baf72392f1730c78..45ca1827349e4ff2f31bfbcdbe1e1aa6231a185e 100644
--- a/test/built-ins/Atomics/wake/count-defaults-to-infinity-missing.js
+++ b/test/built-ins/Atomics/wake/count-defaults-to-infinity-missing.js
@@ -64,7 +64,7 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
-waitUntil(i32a, RUNNING, NUMAGENT);
+$262.agent.waitUntil(i32a, RUNNING, NUMAGENT);
 
 assert.sameValue(
   Atomics.wake(i32a, WAIT_INDEX /*, count missing */),
@@ -72,13 +72,13 @@ assert.sameValue(
   'Atomics.wake(i32a, WAIT_INDEX /*, count missing */) equals the value of `NUMAGENT` (4)'
 );
 
-const sortedReports = [];
+const reports = [];
 for (var i = 0; i < NUMAGENT; i++) {
-  sortedReports.push(getReport());
+  reports.push($262.agent.getReport());
 }
-sortedReports.sort();
+reports.sort();
 
-assert.sameValue(sortedReports[0], 'A ok', 'The value of sortedReports[0] is "A ok"');
-assert.sameValue(sortedReports[1], 'B ok', 'The value of sortedReports[1] is "B ok"');
-assert.sameValue(sortedReports[2], 'C ok', 'The value of sortedReports[2] is "C ok"');
-assert.sameValue(sortedReports[3], 'D ok', 'The value of sortedReports[3] is "D ok"');
+assert.sameValue(reports[0], 'A ok', 'The value of reports[0] is "A ok"');
+assert.sameValue(reports[1], 'B ok', 'The value of reports[1] is "B ok"');
+assert.sameValue(reports[2], 'C ok', 'The value of reports[2] is "C ok"');
+assert.sameValue(reports[3], 'D ok', 'The value of reports[3] is "D ok"');
diff --git a/test/built-ins/Atomics/wake/count-defaults-to-infinity-undefined.js b/test/built-ins/Atomics/wake/count-defaults-to-infinity-undefined.js
index cd1e1455a253c22e05f2bfa7fa3a197ac688bae6..74c91ca992c32aff13fc4bfa47dc152c772f1169 100644
--- a/test/built-ins/Atomics/wake/count-defaults-to-infinity-undefined.js
+++ b/test/built-ins/Atomics/wake/count-defaults-to-infinity-undefined.js
@@ -62,7 +62,7 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
-waitUntil(i32a, RUNNING, NUMAGENT);
+$262.agent.waitUntil(i32a, RUNNING, NUMAGENT);
 
 assert.sameValue(
   Atomics.wake(i32a, WAIT_INDEX, undefined),
@@ -70,13 +70,13 @@ assert.sameValue(
   'Atomics.wake(i32a, WAIT_INDEX, undefined) equals the value of `NUMAGENT` (4)'
 );
 
-const sortedReports = [];
+const reports = [];
 for (var i = 0; i < NUMAGENT; i++) {
-  sortedReports.push(getReport());
+  reports.push($262.agent.getReport());
 }
-sortedReports.sort();
+reports.sort();
 
-assert.sameValue(sortedReports[0], 'A ok', 'The value of sortedReports[0] is "A ok"');
-assert.sameValue(sortedReports[1], 'B ok', 'The value of sortedReports[1] is "B ok"');
-assert.sameValue(sortedReports[2], 'C ok', 'The value of sortedReports[2] is "C ok"');
-assert.sameValue(sortedReports[3], 'D ok', 'The value of sortedReports[3] is "D ok"');
+assert.sameValue(reports[0], 'A ok', 'The value of reports[0] is "A ok"');
+assert.sameValue(reports[1], 'B ok', 'The value of reports[1] is "B ok"');
+assert.sameValue(reports[2], 'C ok', 'The value of reports[2] is "C ok"');
+assert.sameValue(reports[3], 'D ok', 'The value of reports[3] is "D ok"');
diff --git a/test/built-ins/Atomics/wake/negative-count.js b/test/built-ins/Atomics/wake/negative-count.js
index 8d8803669a1e6e5230540a2c35cda1e5ab84c218..74cf6861c684bcb5b56572a6a12cc82baa4a1e88 100644
--- a/test/built-ins/Atomics/wake/negative-count.js
+++ b/test/built-ins/Atomics/wake/negative-count.js
@@ -24,5 +24,5 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(500); // Give the agent a chance to wait
 assert.sameValue(Atomics.wake(i32a, 0, -1), 0, 'Atomics.wake(i32a, 0, -1) returns 0'); // Don't actually wake it
-assert.sameValue(getReport(), 'timed-out', 'getReport() returns "timed-out"');
+assert.sameValue($262.agent.getReport(), 'timed-out', '$262.agent.getReport() returns "timed-out"');
 
diff --git a/test/built-ins/Atomics/wake/undefined-index-defaults-to-zero.js b/test/built-ins/Atomics/wake/undefined-index-defaults-to-zero.js
index 51e9ea8d86a6e7259748f6bdf2f0b3358e9a963d..917c48c72b3300c4382eb2ac8b69365e5c16b6bf 100644
--- a/test/built-ins/Atomics/wake/undefined-index-defaults-to-zero.js
+++ b/test/built-ins/Atomics/wake/undefined-index-defaults-to-zero.js
@@ -51,7 +51,7 @@ assert.sameValue(
   1,
   'Atomics.wake(i32a, undefined, 1) returns 1'
 );
-assert.sameValue(getReport(), 'ok', 'getReport() returns "ok"');
+assert.sameValue($262.agent.getReport(), 'ok', '$262.agent.getReport() returns "ok"');
 
 
 // wake again at index 0, default => 0
@@ -60,4 +60,4 @@ assert.sameValue(
   1,
   'Atomics.wake(i32a /*, default values used */) returns 1'
 );
-assert.sameValue(getReport(), 'ok', 'getReport() returns "ok"');
+assert.sameValue($262.agent.getReport(), 'ok', '$262.agent.getReport() returns "ok"');
diff --git a/test/built-ins/Atomics/wake/wake-all-on-loc.js b/test/built-ins/Atomics/wake/wake-all-on-loc.js
index cda0d96a9452c5fd7783b6c95d342cbd2d765405..56136e4639f501277381abc01ca33363e494ad48 100644
--- a/test/built-ins/Atomics/wake/wake-all-on-loc.js
+++ b/test/built-ins/Atomics/wake/wake-all-on-loc.js
@@ -44,7 +44,7 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
-waitUntil(i32a, RUNNING, BUFFER_SIZE);
+$262.agent.waitUntil(i32a, RUNNING, BUFFER_SIZE);
 
 // Then wait some more to give the agents a fair chance to wait.  If we don't,
 // we risk sending the wakeup before agents are sleeping, and we hang.
@@ -57,13 +57,13 @@ assert.sameValue(
   'Atomics.wake(i32a, WAIT_INDEX) equals the value of `NUMAGENT` (3)'
 );
 
-const rs = [];
+const reports = [];
 for (var i = 0; i < NUMAGENT + 1; i++) {
-  rs.push(getReport());
+  reports.push($262.agent.getReport());
 }
-rs.sort();
+reports.sort();
 
 for (var i = 0; i < NUMAGENT; i++) {
-  assert.sameValue(rs[i], "A ok", 'The value of rs[i] is "A ok"');
+  assert.sameValue(reports[i], "A ok", 'The value of reports[i] is "A ok"');
 }
-assert.sameValue(rs[NUMAGENT], "B timed-out", 'The value of rs[NUMAGENT] is "B timed-out"');
+assert.sameValue(reports[NUMAGENT], "B timed-out", 'The value of reports[NUMAGENT] is "B timed-out"');
diff --git a/test/built-ins/Atomics/wake/wake-all.js b/test/built-ins/Atomics/wake/wake-all.js
index 0da7909479ffe42e2633f222fce5956a59515b07..c2f88accfa3876d78f41576e6fb37e4fb4e14d7b 100644
--- a/test/built-ins/Atomics/wake/wake-all.js
+++ b/test/built-ins/Atomics/wake/wake-all.js
@@ -43,7 +43,7 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
-waitUntil(i32a, RUNNING, NUMAGENT + 1);
+$262.agent.waitUntil(i32a, RUNNING, NUMAGENT + 1);
 
 // Then wait some more to give the agents a fair chance to wait.  If we don't,
 // we risk sending the wakeup before agents are sleeping, and we hang.
@@ -56,13 +56,13 @@ assert.sameValue(
   'Atomics.wake(i32a, WAIT_INDEX) equals the value of `NUMAGENT` (3)'
 );
 
-const rs = [];
+const reports = [];
 for (var i = 0; i < NUMAGENT + 1; i++) {
-  rs.push(getReport());
+  reports.push($262.agent.getReport());
 }
-rs.sort();
+reports.sort();
 
 for (var i = 0; i < NUMAGENT; i++) {
-  assert.sameValue(rs[i], 'A ok', 'The value of rs[i] is "A ok"');
+  assert.sameValue(reports[i], 'A ok', 'The value of reports[i] is "A ok"');
 }
-assert.sameValue(rs[NUMAGENT], 'B timed-out', 'The value of rs[NUMAGENT] is "B timed-out"');
+assert.sameValue(reports[NUMAGENT], 'B timed-out', 'The value of reports[NUMAGENT] is "B timed-out"');
diff --git a/test/built-ins/Atomics/wake/wake-in-order-one-time.js b/test/built-ins/Atomics/wake/wake-in-order-one-time.js
index 1ab2223be2a817352663004d028b26e8758ddec1..59d11b52327f0d388a18569b8d96c1af46aaac4e 100644
--- a/test/built-ins/Atomics/wake/wake-in-order-one-time.js
+++ b/test/built-ins/Atomics/wake/wake-in-order-one-time.js
@@ -42,7 +42,7 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
-waitUntil(i32a, RUNNING, NUMAGENT);
+$262.agent.waitUntil(i32a, RUNNING, NUMAGENT);
 
 // Sleep to allow the agents a fair chance to wait. If we don't,
 // we risk sending the wakeup before agents are sleeping, and we hang.
@@ -50,13 +50,13 @@ $262.agent.sleep(50);
 
 var waiterlist = [];
 assert.sameValue(Atomics.store(i32a, SPIN + 0, 1), 1);
-waiterlist.push(getReport());
+waiterlist.push($262.agent.getReport());
 
 assert.sameValue(Atomics.store(i32a, SPIN + 1, 1), 1);
-waiterlist.push(getReport());
+waiterlist.push($262.agent.getReport());
 
 assert.sameValue(Atomics.store(i32a, SPIN + 2, 1), 1);
-waiterlist.push(getReport());
+waiterlist.push($262.agent.getReport());
 
 var notified = [];
 assert.sameValue(
@@ -64,21 +64,21 @@ assert.sameValue(
   1,
   `Notification #0: on WAIT_INDEX (0) of i32a must notify 1 waiter.`
 );
-notified.push(getReport());
+notified.push($262.agent.getReport());
 
 assert.sameValue(
   Atomics.wake(i32a, WAIT_INDEX, 1),
   1,
   `Notification #1: on WAIT_INDEX (0) of i32a must notify 1 waiter.`
 );
-notified.push(getReport());
+notified.push($262.agent.getReport());
 
 assert.sameValue(
   Atomics.wake(i32a, WAIT_INDEX, 1),
   1,
   `Notification #2: on WAIT_INDEX (0) of i32a must notify 1 waiter.`
 );
-notified.push(getReport());
+notified.push($262.agent.getReport());
 
 assert.sameValue(
   notified.join(''),
diff --git a/test/built-ins/Atomics/wake/wake-in-order.js b/test/built-ins/Atomics/wake/wake-in-order.js
index 25df57db54f8c67a9c5203d5aeb4631e0844899e..3a2700ff35a4013c3b1d558a9921210a85ef53f0 100644
--- a/test/built-ins/Atomics/wake/wake-in-order.js
+++ b/test/built-ins/Atomics/wake/wake-in-order.js
@@ -43,7 +43,7 @@ for (var attempt = 0; attempt < 10; attempt++) {
   $262.agent.broadcast(i32a.buffer);
 
   // Wait for agents to be running.
-  waitUntil(i32a, RUNNING, NUMAGENT);
+  $262.agent.waitUntil(i32a, RUNNING, NUMAGENT);
 
   // Sleep to allow the agents a fair chance to wait. If we don't,
   // we risk sending the wakeup before agents are sleeping, and we hang.
@@ -51,13 +51,13 @@ for (var attempt = 0; attempt < 10; attempt++) {
 
   var waiterlist = [];
   assert.sameValue(Atomics.store(i32a, SPIN + 0, 1), 1);
-  waiterlist.push(getReport());
+  waiterlist.push($262.agent.getReport());
 
   assert.sameValue(Atomics.store(i32a, SPIN + 1, 1), 1);
-  waiterlist.push(getReport());
+  waiterlist.push($262.agent.getReport());
 
   assert.sameValue(Atomics.store(i32a, SPIN + 2, 1), 1);
-  waiterlist.push(getReport());
+  waiterlist.push($262.agent.getReport());
 
   var notified = [];
   assert.sameValue(
@@ -65,21 +65,21 @@ for (var attempt = 0; attempt < 10; attempt++) {
     1,
     `Attempt #${attempt}, Notification #0: on WAIT_INDEX (0) of i32a must notify 1 waiter.`
   );
-  notified.push(getReport());
+  notified.push($262.agent.getReport());
 
   assert.sameValue(
     Atomics.wake(i32a, WAIT_INDEX, 1),
     1,
     `Attempt #${attempt}, Notification #1: on WAIT_INDEX (0) of i32a must notify 1 waiter.`
   );
-  notified.push(getReport());
+  notified.push($262.agent.getReport());
 
   assert.sameValue(
     Atomics.wake(i32a, WAIT_INDEX, 1),
     1,
     `Attempt #${attempt}, Notification #2: on WAIT_INDEX (0) of i32a must notify 1 waiter.`
   );
-  notified.push(getReport());
+  notified.push($262.agent.getReport());
 
   assert.sameValue(
     notified.join(''),
diff --git a/test/built-ins/Atomics/wake/wake-nan.js b/test/built-ins/Atomics/wake/wake-nan.js
index 972853e1ef459f746ee5510df4655b3883c8316d..e4a047156538f8fa7a4772d05e4bf431a9640510 100644
--- a/test/built-ins/Atomics/wake/wake-nan.js
+++ b/test/built-ins/Atomics/wake/wake-nan.js
@@ -27,4 +27,4 @@ assert.sameValue(Atomics.wake(i32a, 0, NaN), 0, 'Atomics.wake(i32a, 0, NaN) retu
 
 // Sleep past the timeout
 $262.agent.sleep(300);
-assert.sameValue(getReport(), 'timed-out', 'getReport() returns "timed-out"');
+assert.sameValue($262.agent.getReport(), 'timed-out', '$262.agent.getReport() returns "timed-out"');
diff --git a/test/built-ins/Atomics/wake/wake-one.js b/test/built-ins/Atomics/wake/wake-one.js
index a4fba0293016d0ee3776d12077529c712c67c0b2..bbf3507bfb784aafa65391edffad8a4d60e953d3 100644
--- a/test/built-ins/Atomics/wake/wake-one.js
+++ b/test/built-ins/Atomics/wake/wake-one.js
@@ -34,7 +34,7 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
-waitUntil(i32a, RUNNING, NUMAGENT);
+$262.agent.waitUntil(i32a, RUNNING, NUMAGENT);
 
 // Then wait some more to give the agents a fair chance to wait.  If we don't,
 // we risk sending the wakeup before agents are sleeping, and we hang.
@@ -50,15 +50,15 @@ assert.sameValue(
 );
 
 // Collect and check results
-const rs = [];
+const reports = [];
 for (var i = 0; i < NUMAGENT; i++) {
-  rs.push(getReport());
+  reports.push($262.agent.getReport());
 }
-rs.sort();
+reports.sort();
 
 for (var i = 0; i < WAKECOUNT; i++) {
-  assert.sameValue(rs[i], 'ok', 'The value of rs[i] is "ok"');
+  assert.sameValue(reports[i], 'ok', 'The value of reports[i] is "ok"');
 }
 for (var i = WAKECOUNT; i < NUMAGENT; i++) {
-  assert.sameValue(rs[i], 'timed-out', 'The value of rs[i] is "timed-out"');
+  assert.sameValue(reports[i], 'timed-out', 'The value of reports[i] is "timed-out"');
 }
diff --git a/test/built-ins/Atomics/wake/wake-rewake-noop.js b/test/built-ins/Atomics/wake/wake-rewake-noop.js
index 456ad7a64db97f28304264e7759959682d2b48a9..086b2ea73601cad46ae3fc2f5d3271158d546bca 100644
--- a/test/built-ins/Atomics/wake/wake-rewake-noop.js
+++ b/test/built-ins/Atomics/wake/wake-rewake-noop.js
@@ -24,11 +24,11 @@ const i32a = new Int32Array(
 
 $262.agent.broadcast(i32a.buffer);
 
-waitUntil(i32a, 1, 1);
+$262.agent.waitUntil(i32a, 1, 1);
 
 assert.sameValue(Atomics.wake(i32a, 0, 1), 1, 'Atomics.wake(i32a, 0, 1) returns 1');
 
-assert.sameValue(getReport(), 'ok', 'The value of `report` is "ok"');
+assert.sameValue($262.agent.getReport(), 'ok', 'The value of `report` is "ok"');
 
 // Already awake, this should be a noop
 assert.sameValue(Atomics.wake(i32a, 0, 1), 0, 'Atomics.wake(i32a, 0, 1) returns 0');
diff --git a/test/built-ins/Atomics/wake/wake-two.js b/test/built-ins/Atomics/wake/wake-two.js
index 5cc398816fd73367b203f201f7da7651512c045d..7a05ba188d71c2c9f16ba8396d429c26ac5de215 100644
--- a/test/built-ins/Atomics/wake/wake-two.js
+++ b/test/built-ins/Atomics/wake/wake-two.js
@@ -35,7 +35,7 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
-waitUntil(i32a, RUNNING, NUMAGENT);
+$262.agent.waitUntil(i32a, RUNNING, NUMAGENT);
 
 // Then wait some more to give the agents a fair chance to wait.  If we don't,
 // we risk sending the wakeup before agents are sleeping, and we hang.
@@ -54,16 +54,16 @@ assert.sameValue(
 $262.agent.sleep(300);
 
 // Collect and check results
-var rs = [];
+var reports = [];
 for (var i = 0; i < NUMAGENT; i++) {
-  rs.push(getReport());
+  reports.push($262.agent.getReport());
 }
-rs.sort();
+reports.sort();
 
 for (var i = 0; i < WAKECOUNT; i++) {
-  assert.sameValue(rs[i], 'ok', 'The value of rs[i] is "ok"');
+  assert.sameValue(reports[i], 'ok', 'The value of reports[i] is "ok"');
 }
 for (var i = WAKECOUNT; i < NUMAGENT; i++) {
-  assert.sameValue(rs[i], 'timed-out', 'The value of rs[i] is "timed-out"');
+  assert.sameValue(reports[i], 'timed-out', 'The value of reports[i] is "timed-out"');
 }
 
diff --git a/test/built-ins/Atomics/wake/wake-with-no-agents-waiting.js b/test/built-ins/Atomics/wake/wake-with-no-agents-waiting.js
index abd003e89fe21a6a1286b4d94e4a90d013dd30aa..2c7eb375802033a2eecf1169f6cceea966f056f3 100644
--- a/test/built-ins/Atomics/wake/wake-with-no-agents-waiting.js
+++ b/test/built-ins/Atomics/wake/wake-with-no-agents-waiting.js
@@ -9,11 +9,13 @@ includes: [atomicsHelper.js]
 features: [Atomics, SharedArrayBuffer, TypedArray]
 ---*/
 
+const RUNNING = 1;
 
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     const i32a = new Int32Array(sab);
-    Atomics.add(i32a, 1, 1);
+    Atomics.add(i32a, ${RUNNING}, 1);
+    // THIS WILL NEVER WAIT.
     $262.agent.leaving();
   });
 `);
@@ -23,8 +25,7 @@ const i32a = new Int32Array(
 );
 
 $262.agent.broadcast(i32a.buffer);
-
-waitUntil(i32a, 1, 1);
+$262.agent.waitUntil(i32a, RUNNING, 1);
 
 // There are ZERO agents waiting to wake...
 assert.sameValue(Atomics.wake(i32a, 0, 1), 0, 'Atomics.wake(i32a, 0, 1) returns 0');
diff --git a/test/built-ins/Atomics/wake/wake-with-no-matching-agents-waiting.js b/test/built-ins/Atomics/wake/wake-with-no-matching-agents-waiting.js
index 4ce6cfe3f71419471b6b647df05ad35a9471463a..3182f965e6741881b976cbc98a7837752dbbeb6a 100644
--- a/test/built-ins/Atomics/wake/wake-with-no-matching-agents-waiting.js
+++ b/test/built-ins/Atomics/wake/wake-with-no-matching-agents-waiting.js
@@ -4,17 +4,18 @@
 /*---
 esid: sec-atomics.wake
 description: >
-  Test that Atomics.wake wakes zero waiters if there are no agents that match
-  its arguments waiting.
+  Test that Atomics.wake wakes zero waiters if there are no waiters
+  at the index specified.
 includes: [atomicsHelper.js]
 features: [Atomics, SharedArrayBuffer, TypedArray]
 ---*/
 
+const RUNNING = 1;
 
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     const i32a = new Int32Array(sab);
-    Atomics.add(i32a, 1, 1);
+    Atomics.add(i32a, ${RUNNING}, 1);
     $262.agent.leaving();
   });
 `);
@@ -24,8 +25,7 @@ const i32a = new Int32Array(
 );
 
 $262.agent.broadcast(i32a.buffer);
+$262.agent.waitUntil(i32a, RUNNING, 1);
 
-waitUntil(i32a, 1, 1);
-
-// There are ZERO matching agents...
+// There are ZERO matching agents waiting on index 1
 assert.sameValue(Atomics.wake(i32a, 1, 1), 0, 'Atomics.wake(i32a, 1, 1) returns 0');
diff --git a/test/built-ins/Atomics/wake/wake-zero.js b/test/built-ins/Atomics/wake/wake-zero.js
index b9725e3a00bd23076dfa748657d178474e497ab7..df226e98ed1fed6710e177e9692e840e3db0782b 100644
--- a/test/built-ins/Atomics/wake/wake-zero.js
+++ b/test/built-ins/Atomics/wake/wake-zero.js
@@ -34,7 +34,7 @@ const i32a = new Int32Array(
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
-waitUntil(i32a, RUNNING, NUMAGENT);
+$262.agent.waitUntil(i32a, RUNNING, NUMAGENT);
 
 // There's a slight risk we'll fail to wake the desired count, if the preceding
 // sleep() took much longer than anticipated and workers have started timing
@@ -49,5 +49,5 @@ assert.sameValue(
 $262.agent.sleep(300);
 
 for (var i = 0; i < NUMAGENT; i++) {
-  assert.sameValue(getReport(), 'timed-out', `Report #${i}: must equal "timed-out"`);
+  assert.sameValue($262.agent.getReport(), 'timed-out', `Report #${i}: must equal "timed-out"`);
 }