diff --git a/test/built-ins/Atomics/wait/bad-range.js b/test/built-ins/Atomics/wait/bad-range.js
index 07373b8055778fc14080cc3e02626385b14da924..13df39122edec5cf336b9aa59e9f613bc9c7e495 100644
--- a/test/built-ins/Atomics/wait/bad-range.js
+++ b/test/built-ins/Atomics/wait/bad-range.js
@@ -15,7 +15,7 @@ includes: [testAtomics.js]
 features: [ArrayBuffer, arrow-function, Atomics, DataView, for-of, let, SharedArrayBuffer, TypedArray]
 ---*/
 
-var i32a = new Int32Array(
+const i32a = new Int32Array(
   new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
 );
 
diff --git a/test/built-ins/Atomics/wait/non-shared-bufferdata-throws.js b/test/built-ins/Atomics/wait/non-shared-bufferdata-throws.js
index 4e11f0728728da7747868ed558f539ee136de142..5056a28edbc3b7a6414292e3fd43e47caa42f9b4 100644
--- a/test/built-ins/Atomics/wait/non-shared-bufferdata-throws.js
+++ b/test/built-ins/Atomics/wait/non-shared-bufferdata-throws.js
@@ -16,7 +16,7 @@ features: [ArrayBuffer, Atomics, TypedArray]
 ---*/
 
 const i32a = new Int32Array(
-  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+  new ArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
 );
 
 const poisoned = {
diff --git a/test/built-ins/Atomics/wake/bad-range.js b/test/built-ins/Atomics/wake/bad-range.js
index 247550a7c1165bb66ba4caa0fa9dd2a766e5f367..cfd55750ab2b0ee24829b4d4ccc0c7e281de938b 100644
--- a/test/built-ins/Atomics/wake/bad-range.js
+++ b/test/built-ins/Atomics/wake/bad-range.js
@@ -15,14 +15,12 @@ includes: [testAtomics.js, testTypedArray.js]
 features: [ArrayBuffer, arrow-function, Atomics, DataView, for-of, let, SharedArrayBuffer, TypedArray]
 ---*/
 
-var sab = new SharedArrayBuffer(8);
-var views = [Int32Array];
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
 
-testWithTypedArrayConstructors(function(TA) {
-  let view = new TA(sab);
-  testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
-    assert.throws(RangeError, function() {
-      Atomics.wake(view, IdxGen(view), 0);
-    }, '`Atomics.wake(view, IdxGen(view), 0)` throws RangeError'); // Even with waking zero
-  });
-}, views);
+testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
+  assert.throws(RangeError, function() {
+    Atomics.wake(i32a, IdxGen(i32a), 0);
+  }, 'Atomics.wake(i32a, IdxGen(i32a), 0) throws RangeError');
+});
diff --git a/test/built-ins/Atomics/wake/bigint/bad-range.js b/test/built-ins/Atomics/wake/bigint/bad-range.js
index e35b19ba84b64549e3aea0e1747472148449cb50..26d12c627868c5cfbbe6b1c8e9ffd72b15354048 100644
--- a/test/built-ins/Atomics/wake/bigint/bad-range.js
+++ b/test/built-ins/Atomics/wake/bigint/bad-range.js
@@ -15,11 +15,12 @@ includes: [testAtomics.js]
 features: [ArrayBuffer, arrow-function, Atomics, BigInt, DataView, for-of, let, SharedArrayBuffer, TypedArray]
 ---*/
 
-var sab = new SharedArrayBuffer(8);
-let i64a = new BigInt64Array(sab);
+const i64a = new BigInt64Array(
+  new SharedArrayBuffer(BigInt64Array.BYTES_PER_ELEMENT)
+);
 
 testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
   assert.throws(RangeError, function() {
-    Atomics.wake(view, IdxGen(i64a), 0);
-  }, '`Atomics.wake(view, IdxGen(i64a), 0)` throws RangeError');
+    Atomics.wake(i64a, IdxGen(i64a), 0);
+  }, '`Atomics.wake(i64a, IdxGen(i64a), 0)` throws RangeError');
 });
diff --git a/test/built-ins/Atomics/wake/bigint/non-bigint64-typedarray-throws.js b/test/built-ins/Atomics/wake/bigint/non-bigint64-typedarray-throws.js
index b056597318f56daa1011585b8008c4ced3df5c4e..719bfa730eec188a6cb6a6e632b1f242f7278352 100644
--- a/test/built-ins/Atomics/wake/bigint/non-bigint64-typedarray-throws.js
+++ b/test/built-ins/Atomics/wake/bigint/non-bigint64-typedarray-throws.js
@@ -15,12 +15,20 @@ info: |
 features: [Atomics, BigInt, TypedArray]
 ---*/
 
-var poisoned = {
+const i64a = new BigUint64Array(
+  new SharedArrayBuffer(BigUint64Array.BYTES_PER_ELEMENT)
+);
+
+const poisoned = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
   }
 };
 
 assert.throws(TypeError, function() {
-  Atomics.wake(new BigUint64Array(), poisoned, poisoned);
-}, '`Atomics.wake(new BigUint64Array(), poisoned, poisoned)` throws TypeError');
+  Atomics.wait(i64a, 0, 0);
+}, 'BigUint64Array');
+
+assert.throws(TypeError, function() {
+  Atomics.wait(i64a, poisoned, poisoned);
+}, 'BigUint64Array');
diff --git a/test/built-ins/Atomics/wake/bigint/non-shared-bufferdata-throws.js b/test/built-ins/Atomics/wake/bigint/non-shared-bufferdata-throws.js
index 30cfc76bcc49873ae259323d2e41a05891ff459c..e1c1b391f98d3656b98f2087c3a6a9884a1a12db 100644
--- a/test/built-ins/Atomics/wake/bigint/non-shared-bufferdata-throws.js
+++ b/test/built-ins/Atomics/wake/bigint/non-shared-bufferdata-throws.js
@@ -14,9 +14,11 @@ info: |
           4.If bufferData is a Data Block, return false.
 features: [ArrayBuffer, Atomics, BigInt, TypedArray]
 ---*/
+const i64a = new BigInt64Array(
+  new ArrayBuffer(BigInt64Array.BYTES_PER_ELEMENT)
+);
 
-var i64a = new BigInt64Array(new ArrayBuffer(4));
-var poisoned = {
+const poisoned = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
   }
@@ -24,8 +26,8 @@ var poisoned = {
 
 assert.throws(TypeError, function() {
   Atomics.wake(i64a, 0, 0);
-}, '`Atomics.wake(i64a, 0, 0)` throws TypeError');
+}, 'Atomics.wake(i64a, 0, 0) on ArrayBuffer throws TypeError');
 
 assert.throws(TypeError, function() {
   Atomics.wake(i64a, poisoned, poisoned);
-}, '`Atomics.wake(i64a, poisoned, poisoned)` throws TypeError');
+}, 'Atomics.wake(i64a, poisoned, poisoned) on ArrayBuffer throws TypeError');
diff --git a/test/built-ins/Atomics/wake/bigint/null-bufferdata-throws.js b/test/built-ins/Atomics/wake/bigint/null-bufferdata-throws.js
index d237accfa697cc0b29bd55d325afc920d94fc97b..e596a901aad501bb733aaf4789206c74fb0e8f94 100644
--- a/test/built-ins/Atomics/wake/bigint/null-bufferdata-throws.js
+++ b/test/built-ins/Atomics/wake/bigint/null-bufferdata-throws.js
@@ -16,16 +16,21 @@ includes: [detachArrayBuffer.js]
 features: [ArrayBuffer, Atomics, BigInt, TypedArray]
 ---*/
 
-var i64a = new BigInt64Array(new ArrayBuffer(1024));
-var poisoned = {
+const i64a = new BigInt64Array(
+  new SharedArrayBuffer(BigInt64Array.BYTES_PER_ELEMENT)
+);
+const poisoned = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
   }
 };
 
-// Detaching a non-shared ArrayBuffer sets the [[ArrayBufferData]] value to null
-$DETACHBUFFER(i64a.buffer);
+try {
+  $DETACHBUFFER(i64a.buffer); // Detaching a non-shared ArrayBuffer sets the [[ArrayBufferData]] value to null
+} catch (error) {
+  $ERROR(`An unexpected error occurred when detaching ArrayBuffer: ${error.message}`);
+}
 
 assert.throws(TypeError, function() {
   Atomics.wake(i64a, poisoned, poisoned);
-}, '`Atomics.wake(i64a, poisoned, poisoned)` throws TypeError');
+}, 'Atomics.wake(i64a, poisoned, poisoned) on detached buffer throwes TypeError');
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 9fa496496145c5b4309bcabdc989ca7abd6cc377..679be97e7f396152cbb0f12cb44eedee145744a8 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
@@ -28,13 +28,13 @@ for (var i = 0; i < NUMAGENT; i++) {
 }
 
 $262.agent.start(`
-$262.agent.receiveBroadcast(function(sab) {
-  const i64a = new BigInt64Array(sab);
-  Atomics.add(i64a, ${RUNNING}, 1);
-  // This will always time out.
-  $262.agent.report("B " + Atomics.wait(i64a, ${DUMMY}, 0, 10));
-  $262.agent.leaving();
-});
+  $262.agent.receiveBroadcast(function(sab) {
+    const i64a = new BigInt64Array(sab);
+    Atomics.add(i64a, ${RUNNING}, 1);
+    // This will always time out.
+    $262.agent.report("B " + Atomics.wait(i64a, ${DUMMY}, 0, 10));
+    $262.agent.leaving();
+  });
 `);
 
 const i64a = new BigInt64Array(
@@ -63,7 +63,7 @@ for (var i = 0; i < NUMAGENT + 1; i++) {
 rs.sort();
 
 for (var i = 0; i < NUMAGENT; i++) {
-  assert.sameValue(rs[i], "A ok", 'The value of rs[i] is "A ok"');
+  assert.sameValue(rs[i], 'A ok', 'The value of rs[i] is "A ok"');
 }
-assert.sameValue(rs[NUMAGENT], "B timed-out", 'The value of rs[NUMAGENT] is "B timed-out"');
+assert.sameValue(rs[NUMAGENT], 'B timed-out', 'The value of rs[NUMAGENT] is "B timed-out"');
 
diff --git a/test/built-ins/Atomics/wake/count-boundary-cases.js b/test/built-ins/Atomics/wake/count-boundary-cases.js
index 1ffb865ef3c21ab666285e5fe3d63c820a1ae8bc..3faffa2f44e536857308b161cbdac55cba93aa91 100644
--- a/test/built-ins/Atomics/wake/count-boundary-cases.js
+++ b/test/built-ins/Atomics/wake/count-boundary-cases.js
@@ -25,24 +25,37 @@ info: |
 features: [Atomics, SharedArrayBuffer, TypedArray]
 ---*/
 
-var sab = new SharedArrayBuffer(4);
-var view = new Int32Array(sab);
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
 
-assert.sameValue(Atomics.wake(view, 0, -3), 0, 'Atomics.wake(view, 0, -3) returns 0');
 assert.sameValue(
-  Atomics.wake(view, 0, Number.POSITIVE_INFINITY),
+  Atomics.wake(i32a, 0, -3),
+  0,
+  'Atomics.wake(i32a, 0, -3) returns 0'
+);
+assert.sameValue(
+  Atomics.wake(i32a, 0, Number.POSITIVE_INFINITY),
+  0,
+  'Atomics.wake(i32a, 0, Number.POSITIVE_INFINITY) returns 0'
+);
+assert.sameValue(
+  Atomics.wake(i32a, 0, undefined),
+  0,
+  'Atomics.wake(i32a, 0, undefined) returns 0'
+);
+assert.sameValue(
+  Atomics.wake(i32a, 0, '33'),
   0,
-  'Atomics.wake(view, 0, Number.POSITIVE_INFINITY) returns 0'
+  'Atomics.wake(i32a, 0, "33") returns 0'
 );
 assert.sameValue(
-  Atomics.wake(view, 0, undefined),
+  Atomics.wake(i32a, 0, { valueOf: 8 }),
   0,
-  'Atomics.wake(view, 0, undefined) returns 0'
+  'Atomics.wake(i32a, 0, {valueOf: 8}) returns 0'
 );
-assert.sameValue(Atomics.wake(view, 0, "33"), 0, 'Atomics.wake(view, 0, "33") returns 0');
 assert.sameValue(
-  Atomics.wake(view, 0, { valueOf: 8 }),
+  Atomics.wake(i32a, 0),
   0,
-  'Atomics.wake(view, 0, {valueOf: 8}) returns 0'
+  'Atomics.wake(i32a, 0) returns 0'
 );
-assert.sameValue(Atomics.wake(view, 0), 0, 'Atomics.wake(view, 0) returns 0');
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 9a3ed079fd6af7b269420747869bb43523220f86..7038e41e4bc9104d8432072b0f8516a713a3e23a 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
@@ -16,16 +16,8 @@ includes: [atomicsHelper.js]
 features: [Atomics, SharedArrayBuffer, TypedArray]
 ---*/
 
-var NUMAGENT = 4; // Total number of agents started
-var WAKEUP = 0; // Index all agents are waiting on
-
-function getReport() {
-  var r;
-  while ((r = $262.agent.getReport()) == null) {
-    $262.agent.sleep(10);
-  }
-  return r;
-}
+const NUMAGENT = 4; // Total number of agents started
+const WAKEUP = 0; // Index all agents are waiting on
 
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
@@ -64,7 +56,7 @@ const i32a = new Int32Array(
 );
 
 $262.agent.broadcast(i32a.buffer);
-$262.agent.sleep(20);
+$262.agent.sleep(100);
 
 assert.sameValue(
   Atomics.wake(i32a, WAKEUP /*, count missing */),
@@ -72,13 +64,13 @@ assert.sameValue(
   'Atomics.wake(i32a, WAKEUP /*, count missing */) equals the value of `NUMAGENT` (4)'
 );
 
-var sortedReports = [];
+const sortedReports = [];
 for (var i = 0; i < NUMAGENT; i++) {
   sortedReports.push(getReport());
 }
 sortedReports.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(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"');
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 0d8b569b50472fb8f3527a6b09c2dabd9ba7e86a..837bcfa84fa23e5e7441a6a09c0e6b1e911e9855 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
@@ -33,7 +33,6 @@ $262.agent.start(`
   });
 `);
 
-
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     const i32a = new Int32Array(sab);
@@ -42,7 +41,6 @@ $262.agent.start(`
   });
 `);
 
-
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     const i32a = new Int32Array(sab);
@@ -65,13 +63,13 @@ assert.sameValue(
   'Atomics.wake(i32a, WAKEUP, undefined) equals the value of `NUMAGENT` (4)'
 );
 
-var sortedReports = [];
+const sortedReports = [];
 for (var i = 0; i < NUMAGENT; i++) {
   sortedReports.push(getReport());
 }
 sortedReports.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(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"');
diff --git a/test/built-ins/Atomics/wake/count-from-nans.js b/test/built-ins/Atomics/wake/count-from-nans.js
index fc425cee64e0eab57e2242b8df1a3becb5f9f6c9..c71f739f7bcec296fdf6b276dca8917c23744ccf 100644
--- a/test/built-ins/Atomics/wake/count-from-nans.js
+++ b/test/built-ins/Atomics/wake/count-from-nans.js
@@ -20,13 +20,14 @@ info: |
   2. If number is NaN, return +0.
   ...
 
+includes: [nans.js, atomicsHelper.js]
 features: [Atomics, SharedArrayBuffer, TypedArray]
-includes: [nans.js]
 ---*/
 
-var sab = new SharedArrayBuffer(4);
-var view = new Int32Array(sab);
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
 
 NaNs.forEach(nan => {
-  assert.sameValue(Atomics.wake(view, 0, nan), 0, 'Atomics.wake(view, 0, nan) returns 0');
+  assert.sameValue(Atomics.wake(i32a, 0, nan), 0, 'Atomics.wake(i32a, 0, nan) returns 0');
 });
diff --git a/test/built-ins/Atomics/wake/count-symbol-throws.js b/test/built-ins/Atomics/wake/count-symbol-throws.js
index 585434c58f9c5881acdc5468fcae673791948d9f..c2c93c331050d507dce91b2f5fea010a8089e2ad 100644
--- a/test/built-ins/Atomics/wake/count-symbol-throws.js
+++ b/test/built-ins/Atomics/wake/count-symbol-throws.js
@@ -17,9 +17,10 @@ info: |
 features: [Atomics, SharedArrayBuffer, TypedArray]
 ---*/
 
-var sab = new SharedArrayBuffer(4);
-var view = new Int32Array(sab);
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
 
 assert.throws(TypeError, function() {
-  Atomics.wake(view, 0, Symbol());
-}, '`Atomics.wake(view, 0, Symbol())` throws TypeError');
+  Atomics.wake(i32a, 0, Symbol());
+}, '`Atomics.wake(i32a, 0, Symbol())` throws TypeError');
diff --git a/test/built-ins/Atomics/wake/count-tointeger-throws-then-wake-throws.js b/test/built-ins/Atomics/wake/count-tointeger-throws-then-wake-throws.js
index 77967165004c98e5280c2f46b9f7472548964787..dff76e0709ba446b3ba700f3f9a49a52abb1634a 100644
--- a/test/built-ins/Atomics/wake/count-tointeger-throws-then-wake-throws.js
+++ b/test/built-ins/Atomics/wake/count-tointeger-throws-then-wake-throws.js
@@ -17,14 +17,16 @@ info: |
 features: [Atomics, SharedArrayBuffer, TypedArray]
 ---*/
 
-var sab = new SharedArrayBuffer(4);
-var view = new Int32Array(sab);
-var poisoned = {
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
+
+const poisoned = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
   }
 };
 
 assert.throws(Test262Error, function() {
-  Atomics.wake(view, 0, poisoned);
-}, '`Atomics.wake(view, 0, poisoned)` throws Test262Error');
+  Atomics.wake(i32a, 0, poisoned);
+}, '`Atomics.wake(i32a, 0, poisoned)` throws Test262Error');
diff --git a/test/built-ins/Atomics/wake/negative-count.js b/test/built-ins/Atomics/wake/negative-count.js
index df172ff2e1a985b23318d0e3e99606ea9aaff306..2c3c1abbb294d69d5531fa1a3e7c10ac5d564a78 100644
--- a/test/built-ins/Atomics/wake/negative-count.js
+++ b/test/built-ins/Atomics/wake/negative-count.js
@@ -11,7 +11,7 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
-    var i32a = new Int32Array(sab);
+    const i32a = new Int32Array(sab);
     $262.agent.report(Atomics.wait(i32a, 0, 0, 1000)); // Timeout after 1 second
     $262.agent.leaving();
   });
diff --git a/test/built-ins/Atomics/wake/negative-index-throws.js b/test/built-ins/Atomics/wake/negative-index-throws.js
index 68637f66346b5b93d67aa50e1d0a878b53dd0ca5..50d7a345c16180ac6a83a81f92e851f50a7adfd7 100644
--- a/test/built-ins/Atomics/wake/negative-index-throws.js
+++ b/test/built-ins/Atomics/wake/negative-index-throws.js
@@ -16,9 +16,11 @@ info: |
 features: [Atomics, SharedArrayBuffer, TypedArray]
 ---*/
 
-var sab = new SharedArrayBuffer(1024);
-var i32a = new Int32Array(sab);
-var poisoned = {
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
+
+const poisoned = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
   }
diff --git a/test/built-ins/Atomics/wake/non-int32-typedarray-throws.js b/test/built-ins/Atomics/wake/non-int32-typedarray-throws.js
index 60f6103068cd0064d595a94089db498185497220..2ca5c7d46fca1aa54827ab24ed1c4c45bdb1d73e 100644
--- a/test/built-ins/Atomics/wake/non-int32-typedarray-throws.js
+++ b/test/built-ins/Atomics/wake/non-int32-typedarray-throws.js
@@ -15,40 +15,64 @@ info: |
 features: [Atomics, Float32Array, Float64Array, Int8Array, TypedArray, Uint16Array, Uint8Array, Uint8ClampedArray]
 ---*/
 
-var poisoned = {
+const poisoned = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
   }
 };
 
 assert.throws(TypeError, function() {
-  Atomics.wake(new Float64Array(), poisoned, poisoned);
-}, '`Atomics.wake(new Float64Array(), poisoned, poisoned)` throws TypeError');
+  const view = new Float64Array(
+    new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT)
+  );
+  Atomics.wake(view, poisoned, poisoned);
+}, '`Atomics.wake(view), poisoned, poisoned)` throws TypeError');
 
 assert.throws(TypeError, function() {
-  Atomics.wake(new Float32Array(), poisoned, poisoned);
-}, '`Atomics.wake(new Float32Array(), poisoned, poisoned)` throws TypeError');
+  const view = new Float32Array(
+    new SharedArrayBuffer(Float32Array.BYTES_PER_ELEMENT)
+  );
+  Atomics.wake(view, poisoned, poisoned);
+}, '`Atomics.wake(view), poisoned, poisoned)` throws TypeError');
 
 assert.throws(TypeError, function() {
-  Atomics.wake(new Int16Array(), poisoned, poisoned);
-}, '`Atomics.wake(new Int16Array(), poisoned, poisoned)` throws TypeError');
+  const view = new Int16Array(
+    new SharedArrayBuffer(Int16Array.BYTES_PER_ELEMENT)
+  );
+  Atomics.wake(view, poisoned, poisoned);
+}, '`Atomics.wake(view), poisoned, poisoned)` throws TypeError');
 
 assert.throws(TypeError, function() {
-  Atomics.wake(new Int8Array(), poisoned, poisoned);
-}, '`Atomics.wake(new Int8Array(), poisoned, poisoned)` throws TypeError');
+  const view = new Int8Array(
+    new SharedArrayBuffer(Int8Array.BYTES_PER_ELEMENT)
+  );
+  Atomics.wake(view, poisoned, poisoned);
+}, '`Atomics.wake(view), poisoned, poisoned)` throws TypeError');
 
 assert.throws(TypeError, function() {
+  const view = new Uint32Array(
+    new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT)
+  );
   Atomics.wake(new Uint32Array(),  poisoned, poisoned);
-}, '`Atomics.wake(new Uint32Array(), poisoned, poisoned)` throws TypeError');
+}, '`Atomics.wake(view), poisoned, poisoned)` throws TypeError');
 
 assert.throws(TypeError, function() {
-  Atomics.wake(new Uint16Array(), poisoned, poisoned);
-}, '`Atomics.wake(new Uint16Array(), poisoned, poisoned)` throws TypeError');
+  const view = new Uint16Array(
+    new SharedArrayBuffer(Uint16Array.BYTES_PER_ELEMENT)
+  );
+  Atomics.wake(view, poisoned, poisoned);
+}, '`Atomics.wake(view), poisoned, poisoned)` throws TypeError');
 
 assert.throws(TypeError, function() {
-  Atomics.wait(new Uint8Array(), poisoned, poisoned);
-}, '`Atomics.wait(new Uint8Array(), poisoned, poisoned)` throws TypeError');
+  const view = new Uint8Array(
+    new SharedArrayBuffer(Uint8Array.BYTES_PER_ELEMENT)
+  );
+  Atomics.wake(view, poisoned, poisoned);
+}, '`Atomics.wait(view), poisoned, poisoned)` throws TypeError');
 
 assert.throws(TypeError, function() {
-  Atomics.wake(new Uint8ClampedArray(), poisoned, poisoned);
-}, '`Atomics.wake(new Uint8ClampedArray(), poisoned, poisoned)` throws TypeError');
+  const view = new Uint8ClampedArray(
+    new SharedArrayBuffer(Uint8ClampedArray.BYTES_PER_ELEMENT)
+  );
+  Atomics.wake(view, poisoned, poisoned);
+}, '`Atomics.wake(view), poisoned, poisoned)` throws TypeError');
diff --git a/test/built-ins/Atomics/wake/non-shared-bufferdata-throws.js b/test/built-ins/Atomics/wake/non-shared-bufferdata-throws.js
index b31d39aa4dbd4d1072e6f4a4826c6a40938d778f..ddfd3ce87b014f0315b36e08fb440a8f515fa39d 100644
--- a/test/built-ins/Atomics/wake/non-shared-bufferdata-throws.js
+++ b/test/built-ins/Atomics/wake/non-shared-bufferdata-throws.js
@@ -15,8 +15,11 @@ info: |
 features: [ArrayBuffer, Atomics, TypedArray]
 ---*/
 
-var i32a = new Int32Array(new ArrayBuffer(4));
-var poisoned = {
+const i32a = new Int32Array(
+  new ArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
+
+const poisoned = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
   }
diff --git a/test/built-ins/Atomics/wake/non-shared-bufferdatate-non-shared-int-views.js b/test/built-ins/Atomics/wake/non-shared-bufferdatate-non-shared-int-views.js
new file mode 100644
index 0000000000000000000000000000000000000000..289530bb21e77c065c4cccaaeb4ab10505c8143a
--- /dev/null
+++ b/test/built-ins/Atomics/wake/non-shared-bufferdatate-non-shared-int-views.js
@@ -0,0 +1,42 @@
+// Copyright (C) 2017 Mozilla Corporation.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-atomics.wake
+description: >
+  Test Atomics.wake on non-shared integer TypedArrays
+includes: [testTypedArray.js]
+features: [ArrayBuffer, Atomics, TypedArray]
+---*/
+
+const nonsab = new ArrayBuffer(16);
+
+const poisoned = {
+  valueOf: function() {
+    throw new Test262Error('should not evaluate this code');
+  }
+};
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Int16Array(nonsab), poisoned, poisoned);
+}, 'Atomics.wake(new Int16Array(nonsab)) throws TypeError');
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Int8Array(nonsab), poisoned, poisoned);
+}, 'Atomics.wake(new Int8Array(nonsab)) throws TypeError');
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Uint32Array(nonsab),  poisoned, poisoned);
+}, 'Atomics.wake(new Uint32Array(nonsab)) throws TypeError');
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Uint16Array(nonsab), poisoned, poisoned);
+}, 'Atomics.wake(new Uint16Array(nonsab)) throws TypeError');
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Uint8Array(nonsab), poisoned, poisoned);
+}, 'Atomics.wake(new Uint8Array(nonsab)) throws TypeError');
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Uint8ClampedArray(nonsab), poisoned, poisoned);
+}, 'Atomics.wake(new Uint8ClampedArray(nonsab)) throws TypeError');
diff --git a/test/built-ins/Atomics/wake/non-shared-int-views.js b/test/built-ins/Atomics/wake/non-shared-int-views.js
new file mode 100644
index 0000000000000000000000000000000000000000..64e69bd3b990fb9915b9392189343f8908a9838f
--- /dev/null
+++ b/test/built-ins/Atomics/wake/non-shared-int-views.js
@@ -0,0 +1,42 @@
+// Copyright (C) 2017 Mozilla Corporation.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-atomics.wake
+description: >
+  Test Atomics.wake on non-shared integer TypedArrays
+includes: [testTypedArray.js]
+features: [Atomics, SharedArrayBuffer, TypedArray]
+---*/
+
+const sab = new SharedArrayBuffer(16);
+
+const poisoned = {
+  valueOf: function() {
+    throw new Test262Error('should not evaluate this code');
+  }
+};
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Int16Array(sab), poisoned, poisoned);
+}, 'Atomics.wake(new Int16Array(sab)) throws TypeError');
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Int8Array(sab), poisoned, poisoned);
+}, 'Atomics.wake(new Int8Array(sab)) throws TypeError');
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Uint32Array(sab),  poisoned, poisoned);
+}, 'Atomics.wake(new Uint32Array(sab)) throws TypeError');
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Uint16Array(sab), poisoned, poisoned);
+}, 'Atomics.wake(new Uint16Array(sab)) throws TypeError');
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Uint8Array(sab), poisoned, poisoned);
+}, 'Atomics.wake(new Uint8Array(sab)) throws TypeError');
+
+assert.throws(TypeError, function() {
+  Atomics.wake(new Uint8ClampedArray(sab), poisoned, poisoned);
+}, 'Atomics.wake(new Uint8ClampedArray(sab)) throws TypeError');
diff --git a/test/built-ins/Atomics/wake/non-views.js b/test/built-ins/Atomics/wake/non-views.js
index 032a4891620c0d3fd06f66ad768ec5c1f720f8df..5ee2b79e6756f8d363b3ddac0016d87e9f962749 100644
--- a/test/built-ins/Atomics/wake/non-views.js
+++ b/test/built-ins/Atomics/wake/non-views.js
@@ -9,8 +9,8 @@ includes: [testAtomics.js]
 features: [ArrayBuffer, arrow-function, Atomics, DataView, for-of, let, SharedArrayBuffer]
 ---*/
 
-testWithAtomicsNonViewValues(function(view) {
+testWithAtomicsNonViewValues(function(nonView) {
   assert.throws(TypeError, function() {
-    Atomics.wake(view, 0, 0);
-  }, '`Atomics.wake(view, 0, 0)` throws TypeError'); // Even with count == 0
+    Atomics.wake(nonView, 0, 0);
+  }, '`Atomics.wake(nonView, 0, 0)` throws TypeError'); // Even with count == 0
 });
diff --git a/test/built-ins/Atomics/wake/nonshared-int-views.js b/test/built-ins/Atomics/wake/nonshared-int-views.js
deleted file mode 100644
index ca3f198c6ae16ea35d1d5e7845a87af7883d9510..0000000000000000000000000000000000000000
--- a/test/built-ins/Atomics/wake/nonshared-int-views.js
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (C) 2017 Mozilla Corporation.  All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-
-/*---
-esid: sec-atomics.wake
-description: >
-  Test Atomics.wake on non-shared integer TypedArrays
-includes: [testTypedArray.js]
-features: [ArrayBuffer, Atomics, TypedArray]
----*/
-
-var buffer = new ArrayBuffer(16);
-var views = intArrayConstructors.slice();
-
-testWithTypedArrayConstructors(function(TA) {
-  // Should fail even if waking zero waiters
-  assert.throws(TypeError, function() {
-    Atomics.wake(new TA(buffer), 0, 0);
-  }, '`Atomics.wake(new TA(buffer), 0, 0)` throws TypeError');
-}, views);
diff --git a/test/built-ins/Atomics/wake/not-a-typedarray-throws.js b/test/built-ins/Atomics/wake/not-a-typedarray-throws.js
index 2e0203e290b6158445580ace17d6fe95de23385f..2f2fe55dda4eb23812dc9235dce9303bfb418ce0 100644
--- a/test/built-ins/Atomics/wake/not-a-typedarray-throws.js
+++ b/test/built-ins/Atomics/wake/not-a-typedarray-throws.js
@@ -14,7 +14,7 @@ info: |
 features: [Atomics]
 ---*/
 
-var poisoned = {
+const poisoned = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
   }
diff --git a/test/built-ins/Atomics/wake/not-an-object-throws.js b/test/built-ins/Atomics/wake/not-an-object-throws.js
index cf8cc3e5d6c525cb020e51dec7020de082130422..ce868dc2cd7c88f34249e7227550206f6725c52e 100644
--- a/test/built-ins/Atomics/wake/not-an-object-throws.js
+++ b/test/built-ins/Atomics/wake/not-an-object-throws.js
@@ -13,7 +13,7 @@ info: |
 features: [Atomics, Symbol]
 ---*/
 
-var poisoned = {
+const poisoned = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
   }
diff --git a/test/built-ins/Atomics/wake/null-bufferdata-throws.js b/test/built-ins/Atomics/wake/null-bufferdata-throws.js
index 4d2300fd98cf0c0ebbce1a6b82ef948ee8406a56..ac4413488b72b55b012f17e2fcb794ec42656a28 100644
--- a/test/built-ins/Atomics/wake/null-bufferdata-throws.js
+++ b/test/built-ins/Atomics/wake/null-bufferdata-throws.js
@@ -16,15 +16,22 @@ includes: [detachArrayBuffer.js]
 features: [ArrayBuffer, Atomics, TypedArray]
 ---*/
 
-var i32a = new Int32Array(new ArrayBuffer(1024));
-var poisoned = {
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
+
+const poisoned = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
   }
 };
 
-$DETACHBUFFER(i32a.buffer); // Detaching a non-shared ArrayBuffer sets the [[ArrayBufferData]] value to null
+try {
+  $DETACHBUFFER(i32a.buffer); // Detaching a non-shared ArrayBuffer sets the [[ArrayBufferData]] value to null
+} catch (error) {
+  $ERROR(`An unexpected error occurred when detaching ArrayBuffer: ${error.message}`);
+}
 
 assert.throws(TypeError, function() {
   Atomics.wake(i32a, poisoned, poisoned);
-}, '`Atomics.wake(i32a, poisoned, poisoned)` throws TypeError');
+}, 'Atomics.wake(i32a, poisoned, poisoned) on detached buffer throwes TypeError');
diff --git a/test/built-ins/Atomics/wake/out-of-range-index-throws.js b/test/built-ins/Atomics/wake/out-of-range-index-throws.js
index bbc9f08387d334ad8e876f5774d9b2f4610fbeb5..6100ad14c894d29fbc5e1d35dc7cd1be18aaa93c 100644
--- a/test/built-ins/Atomics/wake/out-of-range-index-throws.js
+++ b/test/built-ins/Atomics/wake/out-of-range-index-throws.js
@@ -16,7 +16,10 @@ description: >
 features: [Atomics, SharedArrayBuffer, TypedArray]
 ---*/
 
-var i32a = new Int32Array(new SharedArrayBuffer(4));
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
+
 var poisoned = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
diff --git a/test/built-ins/Atomics/wake/symbol-for-index-throws.js b/test/built-ins/Atomics/wake/symbol-for-index-throws.js
index 723753f685546a43e14759cc263c62118b46e45e..2d446e8eef54e07dce9654c5e1b21f34edb5c0fb 100644
--- a/test/built-ins/Atomics/wake/symbol-for-index-throws.js
+++ b/test/built-ins/Atomics/wake/symbol-for-index-throws.js
@@ -28,16 +28,17 @@ info: |
 features: [Atomics, SharedArrayBuffer, Symbol, Symbol.toPrimitive, TypedArray]
 ---*/
 
-var buffer = new SharedArrayBuffer(1024);
-var i32a = new Int32Array(buffer);
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
 
-var poisonedValueOf = {
+const poisonedValueOf = {
   valueOf: function() {
     throw new Test262Error('should not evaluate this code');
   }
 };
 
-var poisonedToPrimitive = {
+const poisonedToPrimitive = {
   [Symbol.toPrimitive]: function() {
     throw new Test262Error("passing a poisoned object using @@ToPrimitive");
   }
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 3faf97b4dd00a30366e0a1df13a972ef51bb4e7f..93cc8e34417ea4cd2e1633f0616c33b6537dafc1 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
@@ -39,7 +39,7 @@ $262.agent.start(`
 `);
 
 const i32a = new Int32Array(
-  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
 );
 
 $262.agent.broadcast(i32a.buffer);
@@ -51,7 +51,7 @@ assert.sameValue(
   1,
   'Atomics.wake(i32a, undefined, 1) returns 1'
 );
-assert.sameValue(getReport(), "ok", 'getReport() returns "ok"');
+assert.sameValue(getReport(), 'ok', 'getReport() returns "ok"');
 
 
 // wake again at index 0
@@ -60,4 +60,4 @@ assert.sameValue(
   1,
   'Atomics.wake(i32a) returns 1'
 );
-assert.sameValue(getReport(), "ok", 'getReport() returns "ok"');
+assert.sameValue(getReport(), 'ok', '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 f319ef5f8f66d7a9a447bd84974ebb7cdd78357e..e094e8526fc78efaebbd91852ae9e18e92dc6d60 100644
--- a/test/built-ins/Atomics/wake/wake-all-on-loc.js
+++ b/test/built-ins/Atomics/wake/wake-all-on-loc.js
@@ -20,7 +20,7 @@ const NUMAGENT = 3;
 for (var i=0; i < NUMAGENT; i++) {
   $262.agent.start(`
     $262.agent.receiveBroadcast(function(sab) {
-      var i32a = new Int32Array(sab);
+      const i32a = new Int32Array(sab);
       Atomics.add(i32a, ${RUNNING}, 1);
       $262.agent.report("A " + Atomics.wait(i32a, ${WAKEUP}, 0));
       $262.agent.leaving();
@@ -30,7 +30,7 @@ for (var i=0; i < NUMAGENT; i++) {
 
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
-    var i32a = new Int32Array(sab);
+    const i32a = new Int32Array(sab);
     Atomics.add(i32a, ${RUNNING}, 1);
     // This will always time out.
     $262.agent.report("B " + Atomics.wait(i32a, ${DUMMY}, 0, 10));
diff --git a/test/built-ins/Atomics/wake/wake-all.js b/test/built-ins/Atomics/wake/wake-all.js
index ca6ebbacfdb38081cafca42ba0ffcc8bdc28785c..1d6a3de1ddf405c8c4e43ffa8fa1fa09593bbfc5 100644
--- a/test/built-ins/Atomics/wake/wake-all.js
+++ b/test/built-ins/Atomics/wake/wake-all.js
@@ -15,10 +15,10 @@ const RUNNING = 2;                // Accounting of live agents
 const NUMELEM = 3;
 const NUMAGENT = 3;
 
-for (var i=0; i < NUMAGENT; i++) {
+for (var i = 0; i < NUMAGENT; i++) {
   $262.agent.start(`
     $262.agent.receiveBroadcast(function(sab) {
-      var i32a = new Int32Array(sab);
+      const i32a = new Int32Array(sab);
       Atomics.add(i32a, ${RUNNING}, 1);
       $262.agent.report("A " + Atomics.wait(i32a, ${WAKEUP}, 0));
       $262.agent.leaving();
@@ -28,7 +28,7 @@ for (var i=0; i < NUMAGENT; i++) {
 
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
-    var i32a = new Int32Array(sab);
+    const i32a = new Int32Array(sab);
     Atomics.add(i32a, ${RUNNING}, 1);
     // This will always time out.
     $262.agent.report("B " + Atomics.wait(i32a, ${DUMMY}, 0, 10));
@@ -36,7 +36,10 @@ $262.agent.start(`
   });
 `);
 
-var i32a = new Int32Array(new SharedArrayBuffer(NUMELEM * Int32Array.BYTES_PER_ELEMENT));
+const i32a = new Int32Array(
+  new SharedArrayBuffer(NUMELEM * Int32Array.BYTES_PER_ELEMENT)
+);
+
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
@@ -60,6 +63,6 @@ for (var i = 0; i < NUMAGENT + 1; i++) {
 rs.sort();
 
 for (var i = 0; i < NUMAGENT; i++) {
-  assert.sameValue(rs[i], "A ok", 'The value of rs[i] is "A ok"');
+  assert.sameValue(rs[i], 'A ok', 'The value of rs[i] is "A ok"');
 }
-assert.sameValue(rs[NUMAGENT], "B timed-out", 'The value of rs[NUMAGENT] is "B timed-out"');
+assert.sameValue(rs[NUMAGENT], 'B timed-out', 'The value of rs[NUMAGENT] is "B timed-out"');
diff --git a/test/built-ins/Atomics/wake/wake-in-order.js b/test/built-ins/Atomics/wake/wake-in-order.js
index 36174a310e96a626f102b8812d3641f0e3468ea9..07675d49f48940a5ec23dd6ef673307fe1f2c8b7 100644
--- a/test/built-ins/Atomics/wake/wake-in-order.js
+++ b/test/built-ins/Atomics/wake/wake-in-order.js
@@ -22,7 +22,7 @@ const NUMELEM = RUNNING + 1;
 for (var i = 0; i < NUMAGENT; i++) {
   $262.agent.start(`
     $262.agent.receiveBroadcast(function(sab) {
-      var i32a = new Int32Array(sab);
+      const i32a = new Int32Array(sab);
       Atomics.add(i32a, ${RUNNING}, 1);
       while (Atomics.load(i32a, ${SPIN + i}) === 0)
           /* nothing */ ;
@@ -35,6 +35,7 @@ for (var i = 0; i < NUMAGENT; i++) {
 const i32a = new Int32Array(
   new SharedArrayBuffer(NUMELEM * Int32Array.BYTES_PER_ELEMENT)
 );
+
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
@@ -53,5 +54,5 @@ for (var i = 0; i < NUMAGENT; i++) {
 // Wake them up one at a time and check the order is 0 1 2
 for (var i = 0; i < NUMAGENT; i++) {
   assert.sameValue(Atomics.wake(i32a, WAKEUP, 1), 1, 'Atomics.wake(i32a, WAKEUP, 1) returns 1');
-  assert.sameValue(getReport(), i + "ok", 'getReport() returns i + "ok"');
+  assert.sameValue(getReport(), i + 'ok', 'getReport() returns i + "ok"');
 }
diff --git a/test/built-ins/Atomics/wake/wake-nan.js b/test/built-ins/Atomics/wake/wake-nan.js
index 3625ef5c8f6e9093c22e16289decc50a588aead9..ddb4166384acf4f02c77202fe37278e51fbacc55 100644
--- a/test/built-ins/Atomics/wake/wake-nan.js
+++ b/test/built-ins/Atomics/wake/wake-nan.js
@@ -24,4 +24,4 @@ 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, NaN), 0, 'Atomics.wake(i32a, 0, NaN) returns 0'); // Don't actually wake it
-assert.sameValue(getReport(), "timed-out", 'getReport() returns "timed-out"');
+assert.sameValue(getReport(), 'timed-out', '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 49fea9399e44701174544d93373ac6fbd74c0ebb..11b74ce861ff24f6e26d36ae5c4e2b0f5976e41c 100644
--- a/test/built-ins/Atomics/wake/wake-one.js
+++ b/test/built-ins/Atomics/wake/wake-one.js
@@ -18,7 +18,7 @@ const WAKECOUNT = 1;
 for (var i = 0; i < NUMAGENT; i++ ) {
   $262.agent.start(`
     $262.agent.receiveBroadcast(function(sab) {
-      var i32a = new Int32Array(sab);
+      const i32a = new Int32Array(sab);
       Atomics.add(i32a, ${RUNNING}, 1);
       // Waiters that are not woken will time out eventually.
       $262.agent.report(Atomics.wait(i32a, ${WAKEUP}, 0, 2000));
@@ -30,6 +30,7 @@ for (var i = 0; i < NUMAGENT; i++ ) {
 const i32a = new Int32Array(
   new SharedArrayBuffer(NUMELEM * Int32Array.BYTES_PER_ELEMENT)
 );
+
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
diff --git a/test/built-ins/Atomics/wake/wake-rewake-noop.js b/test/built-ins/Atomics/wake/wake-rewake-noop.js
index 3f5e6cbc0fefbfa4f1dd606c2c50a4d260f7cde6..7d4c8e3f1abbfcea01a9df05c74f7ec20527c627 100644
--- a/test/built-ins/Atomics/wake/wake-rewake-noop.js
+++ b/test/built-ins/Atomics/wake/wake-rewake-noop.js
@@ -11,15 +11,15 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
-    var i32a = new Int32Array(sab);
+    const i32a = new Int32Array(sab);
     Atomics.add(i32a, 1, 1);
     $262.agent.report(Atomics.wait(i32a, 0, 0, 2000));
     $262.agent.leaving();
   });
 `);
 
-var i32a = new Int32Array(
-  new SharedArrayBuffer(2 * Int32Array.BYTES_PER_ELEMENT)
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
 );
 
 $262.agent.broadcast(i32a.buffer);
diff --git a/test/built-ins/Atomics/wake/wake-two.js b/test/built-ins/Atomics/wake/wake-two.js
index a8544684d34c3727fcaa1fdceb161ad2e1ddcdba..6a9b790165f6a5eeeb979b4e8ee85b29fc70bfb6 100644
--- a/test/built-ins/Atomics/wake/wake-two.js
+++ b/test/built-ins/Atomics/wake/wake-two.js
@@ -16,10 +16,10 @@ var RUNNING = 1;                // Accounting of live agents here
 var NUMELEM = 2;
 var WAKECOUNT = 2;
 
-for ( var i=0 ; i < NUMAGENT ; i++ ) {
+for (var i = 0; i < NUMAGENT; i++ ) {
   $262.agent.start(`
     $262.agent.receiveBroadcast(function(sab) {
-      var i32a = new Int32Array(sab);
+      const i32a = new Int32Array(sab);
       Atomics.add(i32a, ${RUNNING}, 1);
       // Waiters that are not woken will time out eventually.
       $262.agent.report(Atomics.wait(i32a, ${WAKEUP}, 0, 2000));
@@ -28,9 +28,10 @@ for ( var i=0 ; i < NUMAGENT ; i++ ) {
   `);
 }
 
-var i32a = new Int32Array(
-  new SharedArrayBuffer(NUMELEM * Int32Array.BYTES_PER_ELEMENT)
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
 );
+
 $262.agent.broadcast(i32a.buffer);
 
 // Wait for agents to be running.
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 55357c68876eda0edf039fe60967e28115988bcd..83ebc27f34b445684aec3bfaf25fc99418e6658e 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
@@ -18,9 +18,10 @@ $262.agent.start(`
   });
 `);
 
-var i32a = new Int32Array(
-  new SharedArrayBuffer(2 * Int32Array.BYTES_PER_ELEMENT)
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
 );
+
 $262.agent.broadcast(i32a.buffer);
 
 waitUntil(i32a, 1, 1);
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 b9e68f6225057d7089faa052c6e7813b447e2046..e967a85eeaf69ff3250e256f920b285a0715e4d1 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
@@ -6,7 +6,7 @@ esid: sec-atomics.wake
 description: >
   Test that Atomics.wake wakes zero waiters if there are no agents that match
   its arguments waiting.
-includes: [testAtomics.js]
+includes: [atomicsHelper.js]
 features: [Atomics, SharedArrayBuffer, TypedArray]
 ---*/
 
@@ -19,20 +19,13 @@ $262.agent.start(`
   });
 `);
 
-var i32a = new Int32Array(new SharedArrayBuffer(2 * Int32Array.BYTES_PER_ELEMENT));
+const i32a = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
+
 $262.agent.broadcast(i32a.buffer);
 
 waitUntil(i32a, 1, 1);
 
 // There are ZERO matching agents...
 assert.sameValue(Atomics.wake(i32a, 1, 1), 0, 'Atomics.wake(i32a, 1, 1) returns 0');
-
-function waitUntil(i32a, index, numberOfAgentsExpected) {
-  var i = 0;
-  while (Atomics.load(i32a, index) !== numberOfAgentsExpected && i < 15) {
-    $262.agent.sleep(10);
-    i++;
-  }
-  const numberOfAgentsReady = Atomics.load(i32a, index);
-  assert.sameValue(numberOfAgentsReady, numberOfAgentsExpected, `'numberOfAgentsReady' equals the value of numberOfAgentsExpected (${numberOfAgentsExpected})`);
-}
diff --git a/test/built-ins/Atomics/wake/wake-zero.js b/test/built-ins/Atomics/wake/wake-zero.js
index 7e6d85bf04ddf3d40348be3d9c89cd0d942ac86b..f4c6066496fcb0166441f2e9fab4aefe68281059 100644
--- a/test/built-ins/Atomics/wake/wake-zero.js
+++ b/test/built-ins/Atomics/wake/wake-zero.js
@@ -18,7 +18,7 @@ var WAKECOUNT = 0;
 for (var i = 0; i < NUMAGENT; i++) {
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
-    var i32a = new Int32Array(sab);
+    const i32a = new Int32Array(sab);
     Atomics.add(i32a, ${RUNNING}, 1);
     // Waiters that are not woken will time out eventually.
     $262.agent.report(Atomics.wait(i32a, ${WAKEUP}, 0, 200));
@@ -33,7 +33,6 @@ const i32a = new Int32Array(
 
 $262.agent.broadcast(i32a.buffer);
 
-
 // Wait for agents to be running.
 waitUntil(i32a, RUNNING, NUMAGENT);