Atomics: house keeping.

test/built-ins/Atomics/add/bad-range.js

@@ -15,6 +15,10 @@ var views = intArrayConstructors.slice();
 testWithTypedArrayConstructors(function(TA) {
   let view = new TA(buffer);
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
-    assert.throws(RangeError, () => Atomics.add(view, IdxGen(view), 10));
+    assert.throws(
+      RangeError,
+      () => Atomics.add(view, IdxGen(view), 10),
+      'Atomics.add(view, IdxGen(view), 10) throws RangeError'
+    );
   });
 }, views);

test/built-ins/Atomics/add/bigint/bad-range.js

@@ -14,6 +14,10 @@ var buffer = new SharedArrayBuffer(8);
 testWithBigIntTypedArrayConstructors(function(TA) {
   let view = new TA(buffer);
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
-    assert.throws(RangeError, () => Atomics.add(view, IdxGen(view), 10));
+    assert.throws(
+      RangeError,
+      () => Atomics.add(view, IdxGen(view), 10),
+      'Atomics.add(view, IdxGen(view), 10) throws RangeError'
+    );
   });
 });

test/built-ins/Atomics/add/bigint/good-views.js

@@ -19,27 +19,27 @@ testWithBigIntTypedArrayConstructors(function(TA) {
 
   // Add positive number
   view[8] = 0;
-  assert.sameValue(Atomics.add(view, 8, 10), 0);
+  assert.sameValue(Atomics.add(view, 8, 10), 0, 'Atomics.add(view, 8, 10) returns 0');
-  assert.sameValue(view[8], 10);
+  assert.sameValue(view[8], 10, 'The value of view[8] is 10');
 
   // Add negative number
-  assert.sameValue(Atomics.add(view, 8, -5), 10);
+  assert.sameValue(Atomics.add(view, 8, -5), 10, 'Atomics.add(view, 8, -5) returns 10');
-  assert.sameValue(view[8], 5);
+  assert.sameValue(view[8], 5, 'The value of view[8] is 5');
 
   view[3] = -5;
   control[0] = -5;
   assert.sameValue(Atomics.add(view, 3, 0), control[0],
-    "Result is negative and subject to coercion");
+    'Atomics.add(view, 3, 0) equals the value of control[0] (-5)');
 
   control[0] = 12345;
   view[3] = 12345;
   assert.sameValue(Atomics.add(view, 3, 0), control[0],
-    "Result is subject to chopping");
+    'Atomics.add(view, 3, 0) equals the value of control[0] (12345)');
 
   control[0] = 123456789;
   view[3] = 123456789;
   assert.sameValue(Atomics.add(view, 3, 0), control[0],
-    "Result is subject to chopping");
+    'Atomics.add(view, 3, 0) equals the value of control[0] (123456789)');
 
   // In-bounds boundary cases for indexing
   testWithAtomicsInBoundsIndices(function(IdxGen) {
@@ -48,6 +48,6 @@ testWithBigIntTypedArrayConstructors(function(TA) {
     // Atomics.store() computes an index from Idx in the same way as other
     // Atomics operations, not quite like view[Idx].
     Atomics.store(view, Idx, 37);
-    assert.sameValue(Atomics.add(view, Idx, 0), 37);
+    assert.sameValue(Atomics.add(view, Idx, 0), 37, 'Atomics.add(view, Idx, 0) returns 37');
   });
 });

test/built-ins/Atomics/add/bigint/nonshared-int-views.js

@@ -12,5 +12,9 @@ features: [ArrayBuffer, arrow-function, Atomics, BigInt, TypedArray]
 var ab = new ArrayBuffer(16);
 
 testWithBigIntTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, () => Atomics.add(new TA(ab), 0, 0));
+  assert.throws(
+    TypeError,
+    () => Atomics.add(new TA(ab), 0, 0),
+    'Atomics.add(new TA(ab), 0, 0) throws TypeError'
+  );
 });

test/built-ins/Atomics/add/descriptor.js

@@ -8,6 +8,8 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-verifyWritable(Atomics, "add");
+verifyProperty(Atomics, 'add', {
-verifyNotEnumerable(Atomics, "add");
+  enumerable: false,
-verifyConfigurable(Atomics, "add");
+  writable: true,
+  configurable: true,
+});

test/built-ins/Atomics/add/expected-return-value.js

@@ -29,7 +29,7 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 
 var buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
 var i32a = new Int32Array(buffer);
-var value = 0b00000001000000001000000010000001;
+var newValue = 0b00000001000000001000000010000001;
 
-assert.sameValue(Atomics.add(i32a, 0, value), 0);
+assert.sameValue(Atomics.add(i32a, 0, newValue), 0, 'Atomics.add(i32a, 0, newValue) returns 0');
-assert.sameValue(i32a[0], value);
+assert.sameValue(i32a[0], newValue, 'The value of i32a[0] equals the value of newValue (0b00000001000000001000000010000001)');

test/built-ins/Atomics/add/good-views.js

@@ -20,27 +20,27 @@ testWithTypedArrayConstructors(function(TA) {
 
   // Add positive number
   view[8] = 0;
-  assert.sameValue(Atomics.add(view, 8, 10), 0);
+  assert.sameValue(Atomics.add(view, 8, 10), 0, 'Atomics.add(view, 8, 10) returns 0');
-  assert.sameValue(view[8], 10);
+  assert.sameValue(view[8], 10, 'The value of view[8] is 10');
 
   // Add negative number
-  assert.sameValue(Atomics.add(view, 8, -5), 10);
+  assert.sameValue(Atomics.add(view, 8, -5), 10, 'Atomics.add(view, 8, -5) returns 10');
-  assert.sameValue(view[8], 5);
+  assert.sameValue(view[8], 5, 'The value of view[8] is 5');
 
   view[3] = -5;
   control[0] = -5;
   assert.sameValue(Atomics.add(view, 3, 0), control[0],
-    "Result is negative and subject to coercion");
+    'Atomics.add(view, 3, 0) equals the value of control[0] (-5)');
 
   control[0] = 12345;
   view[3] = 12345;
   assert.sameValue(Atomics.add(view, 3, 0), control[0],
-    "Result is subject to chopping");
+    'Atomics.add(view, 3, 0) equals the value of control[0] (12345)');
 
   control[0] = 123456789;
   view[3] = 123456789;
   assert.sameValue(Atomics.add(view, 3, 0), control[0],
-    "Result is subject to chopping");
+    'Atomics.add(view, 3, 0) equals the value of control[0] (123456789)');
 
   // In-bounds boundary cases for indexing
   testWithAtomicsInBoundsIndices(function(IdxGen) {
@@ -49,6 +49,6 @@ testWithTypedArrayConstructors(function(TA) {
     // Atomics.store() computes an index from Idx in the same way as other
     // Atomics operations, not quite like view[Idx].
     Atomics.store(view, Idx, 37);
-    assert.sameValue(Atomics.add(view, Idx, 0), 37);
+    assert.sameValue(Atomics.add(view, Idx, 0), 37, 'Atomics.add(view, Idx, 0) returns 37');
   });
 }, views);

test/built-ins/Atomics/add/length.js

@@ -24,8 +24,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.add.length, 3);
+verifyProperty(Atomics.add, 'length', {
-
+  value: 3,
-verifyNotEnumerable(Atomics.add, "length");
+  enumerable: false,
-verifyNotWritable(Atomics.add, "length");
+  writable: false,
-verifyConfigurable(Atomics.add, "length");
+  configurable: true,
+});

test/built-ins/Atomics/add/name.js

@@ -10,8 +10,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.add.name, "add");
+verifyProperty(Atomics.add, 'name', {
-
+  value: 'add',
-verifyNotEnumerable(Atomics.add, "name");
+  enumerable: false,
-verifyNotWritable(Atomics.add, "name");
+  writable: false,
-verifyConfigurable(Atomics.add, "name");
+  configurable: true,
+});

test/built-ins/Atomics/add/non-views.js

@@ -10,5 +10,9 @@ features: [ArrayBuffer, arrow-function, Atomics, DataView, for-of, let, SharedAr
 ---*/
 
 testWithAtomicsNonViewValues(function(view) {
-  assert.throws(TypeError, (() => Atomics.add(view, 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.add(view, 0, 0),
+    'Atomics.add(view, 0, 0) throws TypeError'
+  );
 });

test/built-ins/Atomics/add/nonshared-int-views.js

@@ -13,5 +13,9 @@ var ab = new ArrayBuffer(16);
 var views = intArrayConstructors.slice();
 
 testWithTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, (() => Atomics.add(new TA(ab), 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.add(new TA(ab), 0, 0),
+    'Atomics.add(new TA(ab), 0, 0) throws TypeError'
+  );
 }, views);

test/built-ins/Atomics/add/shared-nonint-views.js

@@ -12,5 +12,9 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 var buffer = new SharedArrayBuffer(1024);
 
 testWithTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, (() => Atomics.add(new TA(buffer), 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.add(new TA(buffer), 0, 0),
+    'Atomics.add(new TA(buffer), 0, 0) throws TypeError'
+  );
 }, floatArrayConstructors);

test/built-ins/Atomics/and/bad-range.js

@@ -15,6 +15,10 @@ var views = intArrayConstructors.slice();
 testWithTypedArrayConstructors(function(TA) {
   let view = new TA(buffer);
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
-    assert.throws(RangeError, () => Atomics.and(view, IdxGen(view), 10));
+    assert.throws(
+      RangeError,
+      () => Atomics.and(view, IdxGen(view), 10),
+      'Atomics.and(view, IdxGen(view), 10) throws RangeError'
+    );
   });
 }, views);

test/built-ins/Atomics/and/bigint/bad-range.js

@@ -14,6 +14,10 @@ var buffer = new SharedArrayBuffer(8);
 testWithBigIntTypedArrayConstructors(function(TA) {
   let view = new TA(buffer);
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
-    assert.throws(RangeError, () => Atomics.and(view, IdxGen(view), 10));
+    assert.throws(
+      RangeError,
+      () => Atomics.and(view, IdxGen(view), 10),
+      'Atomics.and(view, IdxGen(view), 10) throws RangeError'
+    );
   });
 });

test/built-ins/Atomics/and/bigint/good-views.js

@@ -20,33 +20,41 @@ testWithBigIntTypedArrayConstructors(function(TA) {
   view[8] = 0x33333333;
   control[0] = 0x33333333;
   assert.sameValue(Atomics.and(view, 8, 0x55555555), control[0],
-    "Result is subject to chopping");
+    'Atomics.and(view, 8, 0x55555555) equals the value of control[0] (0x33333333)');
 
   control[0] = 0x11111111;
-  assert.sameValue(view[8], control[0]);
+  assert.sameValue(
+    view[8],
+    control[0],
+    'The value of view[8] equals the value of control[0] (0x11111111)'
+  );
   assert.sameValue(Atomics.and(view, 8, 0xF0F0F0F0), control[0],
-    "Result is subject to chopping");
+    'Atomics.and(view, 8, 0xF0F0F0F0) equals the value of control[0] (0x11111111)');
 
   control[0] = 0x10101010;
-  assert.sameValue(view[8], control[0]);
+  assert.sameValue(
+    view[8],
+    control[0],
+    'The value of view[8] equals the value of control[0] (0x10101010)'
+  );
 
   view[3] = -5;
   control[0] = -5;
   assert.sameValue(Atomics.and(view, 3, 0), control[0],
-    "Result is negative and subject to coercion");
+    'Atomics.and(view, 3, 0) equals the value of control[0] (-5)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
   control[0] = 12345;
   view[3] = 12345;
   assert.sameValue(Atomics.and(view, 3, 0), control[0],
-    "Result is subjective to chopping");
+    'Atomics.and(view, 3, 0) equals the value of control[0] (12345)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
   control[0] = 123456789;
   view[3] = 123456789;
   assert.sameValue(Atomics.and(view, 3, 0), control[0],
-    "Result is subjective to chopping");
+    'Atomics.and(view, 3, 0) equals the value of control[0] (123456789)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
   // In-bounds boundary cases for indexing
   testWithAtomicsInBoundsIndices(function(IdxGen) {
@@ -55,6 +63,6 @@ testWithBigIntTypedArrayConstructors(function(TA) {
     // Atomics.store() computes an index from Idx in the same way as other
     // Atomics operations, not quite like view[Idx].
     Atomics.store(view, Idx, 37);
-    assert.sameValue(Atomics.and(view, Idx, 0), 37);
+    assert.sameValue(Atomics.and(view, Idx, 0), 37, 'Atomics.and(view, Idx, 0) returns 37');
   });
 });

test/built-ins/Atomics/and/bigint/nonshared-int-views.js

@@ -12,5 +12,9 @@ features: [ArrayBuffer, arrow-function, Atomics, BigInt, TypedArray]
 var buffer = new ArrayBuffer(16);
 
 testWithBigIntTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, () => Atomics.and(new TA(buffer), 0, 0));
+  assert.throws(
+    TypeError,
+    () => Atomics.and(new TA(buffer), 0, 0),
+    'Atomics.and(new TA(buffer), 0, 0) throws TypeError'
+  );
 });

test/built-ins/Atomics/and/descriptor.js

@@ -8,6 +8,8 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-verifyWritable(Atomics, "and");
+verifyProperty(Atomics, 'and', {
-verifyNotEnumerable(Atomics, "and");
+  enumerable: false,
-verifyConfigurable(Atomics, "and");
+  writable: true,
+  configurable: true,
+});

test/built-ins/Atomics/and/expected-return-value.js

@@ -34,5 +34,9 @@ var other = 0b00000001111111111000000011111111;
 
 i32a[0] = value;
 
-assert.sameValue(Atomics.and(i32a, 0, value), value);
+assert.sameValue(
-assert.sameValue(i32a[0], value & other);
+  Atomics.and(i32a, 0, value),
+  value,
+  'Atomics.and(i32a, 0, value) equals the value of value (0b00000001000000001000000010000001)'
+);
+assert.sameValue(i32a[0], value & other, 'The value of i32a[0] is value & other');

test/built-ins/Atomics/and/good-views.js

@@ -21,33 +21,41 @@ testWithTypedArrayConstructors(function(TA) {
   view[8] = 0x33333333;
   control[0] = 0x33333333;
   assert.sameValue(Atomics.and(view, 8, 0x55555555), control[0],
-    "Result is subject to chopping");
+    'Atomics.and(view, 8, 0x55555555) equals the value of control[0] (0x33333333)');
 
   control[0] = 0x11111111;
-  assert.sameValue(view[8], control[0]);
+  assert.sameValue(
+    view[8],
+    control[0],
+    'The value of view[8] equals the value of control[0] (0x11111111)'
+  );
   assert.sameValue(Atomics.and(view, 8, 0xF0F0F0F0), control[0],
-    "Result is subject to chopping");
+    'Atomics.and(view, 8, 0xF0F0F0F0) equals the value of control[0] (0x11111111)');
 
   control[0] = 0x10101010;
-  assert.sameValue(view[8], control[0]);
+  assert.sameValue(
+    view[8],
+    control[0],
+    'The value of view[8] equals the value of control[0] (0x10101010)'
+  );
 
   view[3] = -5;
   control[0] = -5;
   assert.sameValue(Atomics.and(view, 3, 0), control[0],
-    "Result is negative and subject to coercion");
+    'Atomics.and(view, 3, 0) equals the value of control[0] (-5)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
   control[0] = 12345;
   view[3] = 12345;
   assert.sameValue(Atomics.and(view, 3, 0), control[0],
-    "Result is subjective to chopping");
+    'Atomics.and(view, 3, 0) equals the value of control[0] (12345)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
   control[0] = 123456789;
   view[3] = 123456789;
   assert.sameValue(Atomics.and(view, 3, 0), control[0],
-    "Result is subjective to chopping");
+    'Atomics.and(view, 3, 0) equals the value of control[0] (123456789)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
   // In-bounds boundary cases for indexing
   testWithAtomicsInBoundsIndices(function(IdxGen) {
@@ -56,6 +64,6 @@ testWithTypedArrayConstructors(function(TA) {
     // Atomics.store() computes an index from Idx in the same way as other
     // Atomics operations, not quite like view[Idx].
     Atomics.store(view, Idx, 37);
-    assert.sameValue(Atomics.and(view, Idx, 0), 37);
+    assert.sameValue(Atomics.and(view, Idx, 0), 37, 'Atomics.and(view, Idx, 0) returns 37');
   });
 }, views);

test/built-ins/Atomics/and/length.js

@@ -24,8 +24,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.and.length, 3);
+verifyProperty(Atomics.and, 'length', {
-
+  value: 3,
-verifyNotEnumerable(Atomics.and, "length");
+  enumerable: false,
-verifyNotWritable(Atomics.and, "length");
+  writable: false,
-verifyConfigurable(Atomics.and, "length");
+  configurable: true,
+});

test/built-ins/Atomics/and/name.js

@@ -10,8 +10,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.and.name, "and");
+verifyProperty(Atomics.and, 'name', {
-
+  value: 'and',
-verifyNotEnumerable(Atomics.and, "name");
+  enumerable: false,
-verifyNotWritable(Atomics.and, "name");
+  writable: false,
-verifyConfigurable(Atomics.and, "name");
+  configurable: true,
+});

test/built-ins/Atomics/and/non-views.js

@@ -10,5 +10,9 @@ features: [ArrayBuffer, arrow-function, Atomics, DataView, for-of, let, SharedAr
 ---*/
 
 testWithAtomicsNonViewValues(function(view) {
-  assert.throws(TypeError, (() => Atomics.and(view, 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.and(view, 0, 0),
+    'Atomics.and(view, 0, 0) throws TypeError'
+  );
 });

test/built-ins/Atomics/and/nonshared-int-views.js

@@ -13,5 +13,9 @@ var buffer = new ArrayBuffer(16);
 var views = intArrayConstructors.slice();
 
 testWithTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, (() => Atomics.and(new TA(buffer), 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.and(new TA(buffer), 0, 0),
+    'Atomics.and(new TA(buffer), 0, 0) throws TypeError'
+  );
 }, views);

test/built-ins/Atomics/and/shared-nonint-views.js

@@ -12,5 +12,9 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 var buffer = new SharedArrayBuffer(1024);
 
 testWithTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, (() => Atomics.and(new TA(buffer), 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.and(new TA(buffer), 0, 0),
+    'Atomics.and(new TA(buffer), 0, 0) throws TypeError'
+  );
 }, floatArrayConstructors);

test/built-ins/Atomics/compareExchange/bad-range.js

@@ -15,6 +15,10 @@ var views = intArrayConstructors.slice();
 testWithTypedArrayConstructors(function(TA) {
   let view = new TA(buffer);
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
-    assert.throws(RangeError, () => Atomics.compareExchange(view, IdxGen(view), 10, 0));
+    assert.throws(
+      RangeError,
+      () => Atomics.compareExchange(view, IdxGen(view), 10, 0),
+      'Atomics.compareExchange(view, IdxGen(view), 10, 0) throws RangeError'
+    );
   });
 }, views);

test/built-ins/Atomics/compareExchange/bigint/bad-range.js

@@ -14,6 +14,10 @@ var buffer = new SharedArrayBuffer(8);
 testWithBigIntTypedArrayConstructors(function(TA) {
   let view = new TA(buffer);
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
-    assert.throws(RangeError, () => Atomics.compareExchange(view, IdxGen(view), 10, 0));
+    assert.throws(
+      RangeError,
+      () => Atomics.compareExchange(view, IdxGen(view), 10, 0),
+      'Atomics.compareExchange(view, IdxGen(view), 10, 0) throws RangeError'
+    );
   });
 });

test/built-ins/Atomics/compareExchange/bigint/good-views.js

@@ -19,39 +19,43 @@ testWithBigIntTypedArrayConstructors(function(TA) {
 
   // Performs the exchange
   view[8] = 0;
-  assert.sameValue(Atomics.compareExchange(view, 8, 0, 10), 0);
+  assert.sameValue(
-  assert.sameValue(view[8], 10);
+    Atomics.compareExchange(view, 8, 0, 10),
+    0,
+    'Atomics.compareExchange(view, 8, 0, 10) returns 0'
+  );
+  assert.sameValue(view[8], 10, 'The value of view[8] is 10');
 
   view[8] = 0;
   assert.sameValue(Atomics.compareExchange(view, 8, 1, 10), 0,
-    "Does not perform the exchange");
+    'Atomics.compareExchange(view, 8, 1, 10) returns 0');
-  assert.sameValue(view[8], 0);
+  assert.sameValue(view[8], 0, 'The value of view[8] is 0');
 
   view[8] = 0;
   assert.sameValue(Atomics.compareExchange(view, 8, 0, -5), 0,
-    "Performs the exchange, coercing the value being stored");
+    'Atomics.compareExchange(view, 8, 0, -5) returns 0');
   control[0] = -5;
-  assert.sameValue(view[8], control[0]);
+  assert.sameValue(view[8], control[0], 'The value of view[8] equals the value of control[0] (-5)');
 
 
   view[3] = -5;
   control[0] = -5;
   assert.sameValue(Atomics.compareExchange(view, 3, -5, 0), control[0],
-    "Performs the exchange, coercing the value being tested");
+    'Atomics.compareExchange(view, 3, -5, 0) equals the value of control[0] (-5)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
 
   control[0] = 12345;
   view[3] = 12345;
   assert.sameValue(Atomics.compareExchange(view, 3, 12345, 0), control[0],
-    "Performs the exchange, chopping the value being tested");
+    'Atomics.compareExchange(view, 3, 12345, 0) equals the value of control[0] (12345)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
   control[0] = 123456789;
   view[3] = 123456789;
   assert.sameValue(Atomics.compareExchange(view, 3, 123456789, 0), control[0],
-    "Performs the exchange, chopping the value being tested");
+    'Atomics.compareExchange(view, 3, 123456789, 0) equals the value of control[0] (123456789)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
   // In-bounds boundary cases for indexing
   testWithAtomicsInBoundsIndices(function(IdxGen) {
@@ -60,6 +64,10 @@ testWithBigIntTypedArrayConstructors(function(TA) {
     // Atomics.store() computes an index from Idx in the same way as other
     // Atomics operations, not quite like view[Idx].
     Atomics.store(view, Idx, 37);
-    assert.sameValue(Atomics.compareExchange(view, Idx, 37, 0), 37);
+    assert.sameValue(
+      Atomics.compareExchange(view, Idx, 37, 0),
+      37,
+      'Atomics.compareExchange(view, Idx, 37, 0) returns 37'
+    );
   });
 });

test/built-ins/Atomics/compareExchange/bigint/nonshared-int-views.js

@@ -12,5 +12,9 @@ features: [ArrayBuffer, arrow-function, Atomics, BigInt, TypedArray]
 var buffer = new ArrayBuffer(16);
 
 testWithBigIntTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, (() => Atomics.compareExchange(new TA(buffer), 0, 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.compareExchange(new TA(buffer), 0, 0, 0),
+    'Atomics.compareExchange(new TA(buffer), 0, 0, 0) throws TypeError'
+  );
 });

test/built-ins/Atomics/compareExchange/descriptor.js

@@ -8,6 +8,8 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-verifyWritable(Atomics, "compareExchange");
+verifyProperty(Atomics, 'compareExchange', {
-verifyNotEnumerable(Atomics, "compareExchange");
+  enumerable: false,
-verifyConfigurable(Atomics, "compareExchange");
+  writable: true,
+  configurable: true,
+});

test/built-ins/Atomics/compareExchange/expected-return-value.js

@@ -28,9 +28,13 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 
 var buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
 var i32a = new Int32Array(buffer);
-var value = 0b00000001000000001000000010000001;
+var update = 0b00000001000000001000000010000001;
 
-i32a[0] = value;
+i32a[0] = update;
 
-assert.sameValue(Atomics.compareExchange(i32a, 0, value, 0), value);
+assert.sameValue(
-assert.sameValue(i32a[0], 0);
+  Atomics.compareExchange(i32a, 0, update, 0),
+  update,
+  'Atomics.compareExchange(i32a, 0, update, 0) equals the value of update (0b00000001000000001000000010000001)'
+);
+assert.sameValue(i32a[0], 0, 'The value of i32a[0] is 0');

test/built-ins/Atomics/compareExchange/good-views.js

@@ -20,39 +20,43 @@ testWithTypedArrayConstructors(function(TA) {
 
   // Performs the exchange
   view[8] = 0;
-  assert.sameValue(Atomics.compareExchange(view, 8, 0, 10), 0);
+  assert.sameValue(
-  assert.sameValue(view[8], 10);
+    Atomics.compareExchange(view, 8, 0, 10),
+    0,
+    'Atomics.compareExchange(view, 8, 0, 10) returns 0'
+  );
+  assert.sameValue(view[8], 10, 'The value of view[8] is 10');
 
   view[8] = 0;
   assert.sameValue(Atomics.compareExchange(view, 8, 1, 10), 0,
-    "Does not perform the exchange");
+    'Atomics.compareExchange(view, 8, 1, 10) returns 0');
-  assert.sameValue(view[8], 0);
+  assert.sameValue(view[8], 0, 'The value of view[8] is 0');
 
   view[8] = 0;
   assert.sameValue(Atomics.compareExchange(view, 8, 0, -5), 0,
-    "Performs the exchange, coercing the value being stored");
+    'Atomics.compareExchange(view, 8, 0, -5) returns 0');
   control[0] = -5;
-  assert.sameValue(view[8], control[0]);
+  assert.sameValue(view[8], control[0], 'The value of view[8] equals the value of control[0] (-5)');
 
 
   view[3] = -5;
   control[0] = -5;
   assert.sameValue(Atomics.compareExchange(view, 3, -5, 0), control[0],
-    "Performs the exchange, coercing the value being tested");
+    'Atomics.compareExchange(view, 3, -5, 0) equals the value of control[0] (-5)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
 
   control[0] = 12345;
   view[3] = 12345;
   assert.sameValue(Atomics.compareExchange(view, 3, 12345, 0), control[0],
-    "Performs the exchange, chopping the value being tested");
+    'Atomics.compareExchange(view, 3, 12345, 0) equals the value of control[0] (12345)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
   control[0] = 123456789;
   view[3] = 123456789;
   assert.sameValue(Atomics.compareExchange(view, 3, 123456789, 0), control[0],
-    "Performs the exchange, chopping the value being tested");
+    'Atomics.compareExchange(view, 3, 123456789, 0) equals the value of control[0] (123456789)');
-  assert.sameValue(view[3], 0);
+  assert.sameValue(view[3], 0, 'The value of view[3] is 0');
 
   // In-bounds boundary cases for indexing
   testWithAtomicsInBoundsIndices(function(IdxGen) {
@@ -61,6 +65,10 @@ testWithTypedArrayConstructors(function(TA) {
     // Atomics.store() computes an index from Idx in the same way as other
     // Atomics operations, not quite like view[Idx].
     Atomics.store(view, Idx, 37);
-    assert.sameValue(Atomics.compareExchange(view, Idx, 37, 0), 37);
+    assert.sameValue(
+      Atomics.compareExchange(view, Idx, 37, 0),
+      37,
+      'Atomics.compareExchange(view, Idx, 37, 0) returns 37'
+    );
   });
 }, views);

test/built-ins/Atomics/compareExchange/length.js

@@ -24,8 +24,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.compareExchange.length, 4);
+verifyProperty(Atomics.compareExchange, 'length', {
-
+  value: 4,
-verifyNotEnumerable(Atomics.compareExchange, "length");
+  enumerable: false,
-verifyNotWritable(Atomics.compareExchange, "length");
+  writable: false,
-verifyConfigurable(Atomics.compareExchange, "length");
+  configurable: true,
+});

test/built-ins/Atomics/compareExchange/name.js

@@ -10,8 +10,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.compareExchange.name, "compareExchange");
+verifyProperty(Atomics.compareExchange, 'name', {
-
+  value: 'compareExchange',
-verifyNotEnumerable(Atomics.compareExchange, "name");
+  enumerable: false,
-verifyNotWritable(Atomics.compareExchange, "name");
+  writable: false,
-verifyConfigurable(Atomics.compareExchange, "name");
+  configurable: true,
+});

test/built-ins/Atomics/compareExchange/non-views.js

@@ -10,5 +10,9 @@ features: [ArrayBuffer, arrow-function, Atomics, DataView, for-of, let, SharedAr
 ---*/
 
 testWithAtomicsNonViewValues(function(view) {
-  assert.throws(TypeError, (() => Atomics.compareExchange(view, 0, 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.compareExchange(view, 0, 0, 0),
+    'Atomics.compareExchange(view, 0, 0, 0) throws TypeError'
+  );
 });

test/built-ins/Atomics/compareExchange/nonshared-int-views.js

@@ -13,5 +13,9 @@ var buffer = new ArrayBuffer(16);
 var views = intArrayConstructors.slice();
 
 testWithTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, (() => Atomics.compareExchange(new TA(buffer), 0, 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.compareExchange(new TA(buffer), 0, 0, 0),
+    'Atomics.compareExchange(new TA(buffer), 0, 0, 0) throws TypeError'
+  );
 }, views);

test/built-ins/Atomics/compareExchange/shared-nonint-views.js

@@ -12,5 +12,9 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 var buffer = new SharedArrayBuffer(1024);
 
 testWithTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, (() => Atomics.compareExchange(new TA(buffer), 0, 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.compareExchange(new TA(buffer), 0, 0, 0),
+    'Atomics.compareExchange(new TA(buffer), 0, 0, 0) throws TypeError'
+  );
 }, floatArrayConstructors);

test/built-ins/Atomics/exchange/bad-range.js

@@ -15,6 +15,10 @@ var views = intArrayConstructors.slice();
 testWithTypedArrayConstructors(function(TA) {
   let view = new TA(buffer);
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
-    assert.throws(RangeError, () => Atomics.exchange(view, IdxGen(view), 10, 0));
+    assert.throws(
+      RangeError,
+      () => Atomics.exchange(view, IdxGen(view), 10, 0),
+      'Atomics.exchange(view, IdxGen(view), 10, 0) throws RangeError'
+    );
   });
 }, views);

test/built-ins/Atomics/exchange/bigint/bad-range.js

@@ -14,6 +14,10 @@ var buffer = new SharedArrayBuffer(8);
 testWithBigIntTypedArrayConstructors(function(TA) {
   let view = new TA(buffer);
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
-    assert.throws(RangeError, () => Atomics.exchange(view, IdxGen(view), 10, 0));
+    assert.throws(
+      RangeError,
+      () => Atomics.exchange(view, IdxGen(view), 10, 0),
+      'Atomics.exchange(view, IdxGen(view), 10, 0) throws RangeError'
+    );
   });
 });

test/built-ins/Atomics/exchange/bigint/good-views.js

@@ -19,28 +19,28 @@ testWithBigIntTypedArrayConstructors(function(TA) {
 
   view[8] = 0;
   assert.sameValue(Atomics.exchange(view, 8, 10), 0,
-    "Exchange returns the value previously in the array");
+    'Atomics.exchange(view, 8, 10) returns 0');
-  assert.sameValue(view[8], 10);
+  assert.sameValue(view[8], 10, 'The value of view[8] is 10');
 
   assert.sameValue(Atomics.exchange(view, 8, -5), 10,
-    "Exchange returns the value previously in the array");
+    'Atomics.exchange(view, 8, -5) returns 10');
   control[0] = -5;
-  assert.sameValue(view[8], control[0]);
+  assert.sameValue(view[8], control[0], 'The value of view[8] equals the value of control[0] (-5)');
 
   view[3] = -5;
   control[0] = -5;
   assert.sameValue(Atomics.exchange(view, 3, 0), control[0],
-    "Result is subject to coercion");
+    'Atomics.exchange(view, 3, 0) equals the value of control[0] (-5)');
 
   control[0] = 12345;
   view[3] = 12345;
   assert.sameValue(Atomics.exchange(view, 3, 0), control[0],
-    "Result is subject to chopping");
+    'Atomics.exchange(view, 3, 0) equals the value of control[0] (12345)');
 
   control[0] = 123456789;
   view[3] = 123456789;
   assert.sameValue(Atomics.exchange(view, 3, 0), control[0],
-    "Result is subject to chopping");
+    'Atomics.exchange(view, 3, 0) equals the value of control[0] (123456789)');
 
   // In-bounds boundary cases for indexing
   testWithAtomicsInBoundsIndices(function(IdxGen) {
@@ -49,6 +49,6 @@ testWithBigIntTypedArrayConstructors(function(TA) {
     // Atomics.store() computes an index from Idx in the same way as other
     // Atomics operations, not quite like view[Idx].
     Atomics.store(view, Idx, 37);
-    assert.sameValue(Atomics.exchange(view, Idx, 0), 37);
+    assert.sameValue(Atomics.exchange(view, Idx, 0), 37, 'Atomics.exchange(view, Idx, 0) returns 37');
   });
 });

test/built-ins/Atomics/exchange/bigint/nonshared-int-views.js

@@ -12,5 +12,9 @@ features: [ArrayBuffer, arrow-function, Atomics, BigInt, TypedArray]
 var buffer = new ArrayBuffer(16);
 
 testWithBigIntTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, (() => Atomics.exchange(new TA(buffer), 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.exchange(new TA(buffer), 0, 0),
+    'Atomics.exchange(new TA(buffer), 0, 0) throws TypeError'
+  );
 });

test/built-ins/Atomics/exchange/descriptor.js

@@ -8,6 +8,8 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-verifyWritable(Atomics, "exchange");
+verifyProperty(Atomics, 'exchange', {
-verifyNotEnumerable(Atomics, "exchange");
+  enumerable: false,
-verifyConfigurable(Atomics, "exchange");
+  writable: true,
+  configurable: true,
+});

test/built-ins/Atomics/exchange/expected-return-value.js

@@ -29,7 +29,15 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 
 var buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
 var i32a = new Int32Array(buffer);
-var value = 0b00000001000000001000000010000001;
+var update = 0b00000001000000001000000010000001;
 
-assert.sameValue(Atomics.exchange(i32a, 0, value), 0);
+assert.sameValue(
-assert.sameValue(i32a[0], value);
+  Atomics.exchange(i32a, 0, update),
+  0,
+  'Atomics.exchange(i32a, 0, update) returns 0'
+);
+assert.sameValue(
+  i32a[0],
+  update,
+  'The value of i32a[0] equals the value of update (0b00000001000000001000000010000001)'
+);

test/built-ins/Atomics/exchange/good-views.js

@@ -20,28 +20,28 @@ testWithTypedArrayConstructors(function(TA) {
 
   view[8] = 0;
   assert.sameValue(Atomics.exchange(view, 8, 10), 0,
-    "Exchange returns the value previously in the array");
+    'Atomics.exchange(view, 8, 10) returns 0');
-  assert.sameValue(view[8], 10);
+  assert.sameValue(view[8], 10, 'The value of view[8] is 10');
 
   assert.sameValue(Atomics.exchange(view, 8, -5), 10,
-    "Exchange returns the value previously in the array");
+    'Atomics.exchange(view, 8, -5) returns 10');
   control[0] = -5;
-  assert.sameValue(view[8], control[0]);
+  assert.sameValue(view[8], control[0], 'The value of view[8] equals the value of control[0] (-5)');
 
   view[3] = -5;
   control[0] = -5;
   assert.sameValue(Atomics.exchange(view, 3, 0), control[0],
-    "Result is subject to coercion");
+    'Atomics.exchange(view, 3, 0) equals the value of control[0] (-5)');
 
   control[0] = 12345;
   view[3] = 12345;
   assert.sameValue(Atomics.exchange(view, 3, 0), control[0],
-    "Result is subject to chopping");
+    'Atomics.exchange(view, 3, 0) equals the value of control[0] (12345)');
 
   control[0] = 123456789;
   view[3] = 123456789;
   assert.sameValue(Atomics.exchange(view, 3, 0), control[0],
-    "Result is subject to chopping");
+    'Atomics.exchange(view, 3, 0) equals the value of control[0] (123456789)');
 
   // In-bounds boundary cases for indexing
   testWithAtomicsInBoundsIndices(function(IdxGen) {
@@ -50,6 +50,6 @@ testWithTypedArrayConstructors(function(TA) {
     // Atomics.store() computes an index from Idx in the same way as other
     // Atomics operations, not quite like view[Idx].
     Atomics.store(view, Idx, 37);
-    assert.sameValue(Atomics.exchange(view, Idx, 0), 37);
+    assert.sameValue(Atomics.exchange(view, Idx, 0), 37, 'Atomics.exchange(view, Idx, 0) returns 37');
   });
 }, views);

test/built-ins/Atomics/exchange/length.js

@@ -24,8 +24,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.exchange.length, 3);
+verifyProperty(Atomics.exchange, 'length', {
-
+  value: 3,
-verifyNotEnumerable(Atomics.exchange, "length");
+  enumerable: false,
-verifyNotWritable(Atomics.exchange, "length");
+  writable: false,
-verifyConfigurable(Atomics.exchange, "length");
+  configurable: true,
+});

test/built-ins/Atomics/exchange/name.js

@@ -10,8 +10,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.exchange.name, "exchange");
+verifyProperty(Atomics.exchange, 'name', {
-
+  value: 'exchange',
-verifyNotEnumerable(Atomics.exchange, "name");
+  enumerable: false,
-verifyNotWritable(Atomics.exchange, "name");
+  writable: false,
-verifyConfigurable(Atomics.exchange, "name");
+  configurable: true,
+});

test/built-ins/Atomics/exchange/non-views.js

@@ -10,5 +10,9 @@ features: [ArrayBuffer, arrow-function, Atomics, DataView, for-of, let, SharedAr
 ---*/
 
 testWithAtomicsNonViewValues(function(view) {
-  assert.throws(TypeError, (() => Atomics.exchange(view, 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.exchange(view, 0, 0),
+    'Atomics.exchange(view, 0, 0) throws TypeError'
+  );
 });

test/built-ins/Atomics/exchange/nonshared-int-views.js

@@ -13,5 +13,9 @@ var buffer = new ArrayBuffer(16);
 var views = intArrayConstructors.slice();
 
 testWithTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, (() => Atomics.exchange(new TA(buffer), 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.exchange(new TA(buffer), 0, 0),
+    'Atomics.exchange(new TA(buffer), 0, 0) throws TypeError'
+  );
 }, views);

test/built-ins/Atomics/exchange/shared-nonint-views.js

@@ -12,5 +12,9 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 var buffer = new SharedArrayBuffer(1024);
 
 testWithTypedArrayConstructors(function(TA) {
-  assert.throws(TypeError, (() => Atomics.exchange(new TA(buffer), 0, 0)));
+  assert.throws(
+    TypeError,
+    () => Atomics.exchange(new TA(buffer), 0, 0),
+    'Atomics.exchange(new TA(buffer), 0, 0) throws TypeError'
+  );
 }, floatArrayConstructors);

test/built-ins/Atomics/isLockFree/bigint/corner-cases.js

@@ -9,20 +9,64 @@ features: [arrow-function, Atomics]
 includes: [testAtomics.js, testBigIntTypedArray.js]
 ---*/
 
-assert.sameValue(Atomics.isLockFree(hide(3, Number.NaN)), false);
+assert.sameValue(
-assert.sameValue(Atomics.isLockFree(hide(3, -1)), false);
+  Atomics.isLockFree(hide(3, Number.NaN)),
-assert.sameValue(Atomics.isLockFree(hide(3, 3.14)), false);
+  false,
-assert.sameValue(Atomics.isLockFree(hide(3, 0)), false);
+  'Atomics.isLockFree(hide(3, Number.NaN)) returns false'
+);
+assert.sameValue(
+  Atomics.isLockFree(hide(3, -1)),
+  false,
+  'Atomics.isLockFree(hide(3, -1)) returns false'
+);
+assert.sameValue(
+  Atomics.isLockFree(hide(3, 3.14)),
+  false,
+  'Atomics.isLockFree(hide(3, 3.14)) returns false'
+);
+assert.sameValue(
+  Atomics.isLockFree(hide(3, 0)),
+  false,
+  'Atomics.isLockFree(hide(3, 0)) returns false'
+);
 
-assert.sameValue(Atomics.isLockFree('1'), Atomics.isLockFree(1));
+assert.sameValue(
-assert.sameValue(Atomics.isLockFree('3'), Atomics.isLockFree(3));
+  Atomics.isLockFree('1'),
+  Atomics.isLockFree(1),
+  'Atomics.isLockFree(\'1\') returns Atomics.isLockFree(1)'
+);
+assert.sameValue(
+  Atomics.isLockFree('3'),
+  Atomics.isLockFree(3),
+  'Atomics.isLockFree(\'3\') returns Atomics.isLockFree(3)'
+);
 
-assert.sameValue(Atomics.isLockFree(true), Atomics.isLockFree(1));
+assert.sameValue(
+  Atomics.isLockFree(true),
+  Atomics.isLockFree(1),
+  'Atomics.isLockFree(true) returns Atomics.isLockFree(1)'
+);
 
-assert.sameValue(Atomics.isLockFree(1), Atomics.isLockFree({valueOf: () => 1}));
+assert.sameValue(
-assert.sameValue(Atomics.isLockFree(3), Atomics.isLockFree({valueOf: () => 3}));
+  Atomics.isLockFree(1),
-assert.sameValue(Atomics.isLockFree(1), Atomics.isLockFree({toString: () => '1'}));
+  Atomics.isLockFree({valueOf: () => 1}),
-assert.sameValue(Atomics.isLockFree(3), Atomics.isLockFree({toString: () => '3'}));
+  'Atomics.isLockFree(1) returns Atomics.isLockFree({valueOf: () => 1})'
+);
+assert.sameValue(
+  Atomics.isLockFree(3),
+  Atomics.isLockFree({valueOf: () => 3}),
+  'Atomics.isLockFree(3) returns Atomics.isLockFree({valueOf: () => 3})'
+);
+assert.sameValue(
+  Atomics.isLockFree(1),
+  Atomics.isLockFree({toString: () => '1'}),
+  'Atomics.isLockFree(1) returns Atomics.isLockFree({toString: () => \'1\'})'
+);
+assert.sameValue(
+  Atomics.isLockFree(3),
+  Atomics.isLockFree({toString: () => '3'}),
+  'Atomics.isLockFree(3) returns Atomics.isLockFree({toString: () => \'3\'})'
+);
 
 function hide(k, x) {
   if (k) {

test/built-ins/Atomics/isLockFree/bigint/expected-return-value.js

@@ -23,7 +23,13 @@ includes: [testBigIntTypedArray.js]
 ---*/
 
 testWithBigIntTypedArrayConstructors(function(TA) {
-  assert.sameValue(Atomics.isLockFree(TA.BYTES_PER_ELEMENT), true);
+  var observed = Atomics.isLockFree(TA.BYTES_PER_ELEMENT);
+
+  assert.sameValue(
+    Atomics.isLockFree(TA.BYTES_PER_ELEMENT),
+    observed,
+    'Atomics.isLockFree(TA.BYTES_PER_ELEMENT) equals the value of `observed` (Atomics.isLockFree(TA.BYTES_PER_ELEMENT))'
+  );
 });
 
 

test/built-ins/Atomics/isLockFree/bigint/value.js

@@ -1,46 +0,0 @@
-// Copyright (C) 2018 Rick Waldron. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-
-/*---
-esid: sec-atomics.islockfree
-description: >
-  Test isLockFree on nonnegative integer arguments
-features: [Atomics, computed-property-names]
-includes: [testAtomics.js, testBigIntTypedArray.js]
----*/
-
-var sizes   = [    1,     2,     3,     4,     5,     6,     7,  8,
-                   9,    10,    11,    12];
-var answers = [   {},    {}, false,  true, false, false, false, false,
-               false, false, false, false];
-
-var saved = {};
-
-// This should defeat most optimizations.
-
-for (var i = 0; i < sizes.length; i++) {
-  var v = Atomics.isLockFree(sizes[i]);
-  var a = answers[i];
-  assert.sameValue(typeof v, 'boolean');
-  if (typeof a == 'boolean') {
-    assert.sameValue(v, a);
-  } else {
-    saved[sizes[i]] = v;
-  }
-}
-
-// This ought to be optimizable.  Make sure the answers are the same
-// as for the unoptimized case.
-
-assert.sameValue(Atomics.isLockFree(1), saved[1]);
-assert.sameValue(Atomics.isLockFree(2), saved[2]);
-assert.sameValue(Atomics.isLockFree(3), false);
-assert.sameValue(Atomics.isLockFree(4), true);
-assert.sameValue(Atomics.isLockFree(5), false);
-assert.sameValue(Atomics.isLockFree(6), false);
-assert.sameValue(Atomics.isLockFree(7), false);
-assert.sameValue(Atomics.isLockFree(8), false);
-assert.sameValue(Atomics.isLockFree(9), false);
-assert.sameValue(Atomics.isLockFree(10), false);
-assert.sameValue(Atomics.isLockFree(11), false);
-assert.sameValue(Atomics.isLockFree(12), false);

test/built-ins/Atomics/isLockFree/corner-cases.js

@@ -8,20 +8,64 @@ description: >
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.isLockFree(hide(3, Number.NaN)), false);
+assert.sameValue(
-assert.sameValue(Atomics.isLockFree(hide(3, -1)), false);
+  Atomics.isLockFree(hide(3, Number.NaN)),
-assert.sameValue(Atomics.isLockFree(hide(3, 3.14)), false);
+  false,
-assert.sameValue(Atomics.isLockFree(hide(3, 0)), false);
+  'Atomics.isLockFree(hide(3, Number.NaN)) returns false'
+);
+assert.sameValue(
+  Atomics.isLockFree(hide(3, -1)),
+  false,
+  'Atomics.isLockFree(hide(3, -1)) returns false'
+);
+assert.sameValue(
+  Atomics.isLockFree(hide(3, 3.14)),
+  false,
+  'Atomics.isLockFree(hide(3, 3.14)) returns false'
+);
+assert.sameValue(
+  Atomics.isLockFree(hide(3, 0)),
+  false,
+  'Atomics.isLockFree(hide(3, 0)) returns false'
+);
 
-assert.sameValue(Atomics.isLockFree('1'), Atomics.isLockFree(1));
+assert.sameValue(
-assert.sameValue(Atomics.isLockFree('3'), Atomics.isLockFree(3));
+  Atomics.isLockFree('1'),
+  Atomics.isLockFree(1),
+  'Atomics.isLockFree("1") returns Atomics.isLockFree(1)'
+);
+assert.sameValue(
+  Atomics.isLockFree('3'),
+  Atomics.isLockFree(3),
+  'Atomics.isLockFree("3") returns Atomics.isLockFree(3)'
+);
 
-assert.sameValue(Atomics.isLockFree(true), Atomics.isLockFree(1));
+assert.sameValue(
+  Atomics.isLockFree(true),
+  Atomics.isLockFree(1),
+  'Atomics.isLockFree(true) returns Atomics.isLockFree(1)'
+);
 
-assert.sameValue(Atomics.isLockFree(1), Atomics.isLockFree({valueOf: () => 1}));
+assert.sameValue(
-assert.sameValue(Atomics.isLockFree(3), Atomics.isLockFree({valueOf: () => 3}));
+  Atomics.isLockFree(1),
-assert.sameValue(Atomics.isLockFree(1), Atomics.isLockFree({toString: () => '1'}));
+  Atomics.isLockFree({valueOf: () => 1}),
-assert.sameValue(Atomics.isLockFree(3), Atomics.isLockFree({toString: () => '3'}));
+  'Atomics.isLockFree(1) returns Atomics.isLockFree({valueOf: () => 1})'
+);
+assert.sameValue(
+  Atomics.isLockFree(3),
+  Atomics.isLockFree({valueOf: () => 3}),
+  'Atomics.isLockFree(3) returns Atomics.isLockFree({valueOf: () => 3})'
+);
+assert.sameValue(
+  Atomics.isLockFree(1),
+  Atomics.isLockFree({toString: () => '1'}),
+  'Atomics.isLockFree(1) returns Atomics.isLockFree({toString: () => "1"})'
+);
+assert.sameValue(
+  Atomics.isLockFree(3),
+  Atomics.isLockFree({toString: () => '3'}),
+  'Atomics.isLockFree(3) returns Atomics.isLockFree({toString: () => "3"})'
+);
 
 function hide(k, x) {
   if (k) {

test/built-ins/Atomics/isLockFree/descriptor.js

@@ -8,6 +8,8 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-verifyWritable(Atomics, "add");
+verifyProperty(Atomics, 'add', {
-verifyNotEnumerable(Atomics, "add");
+  enumerable: false,
-verifyConfigurable(Atomics, "add");
+  writable: true,
+  configurable: true,
+});

test/built-ins/Atomics/isLockFree/expected-return-value.js

@@ -1,30 +1,111 @@
-// Copyright (C) 2018 Rick Waldron.  All rights reserved.
+// Copyright (C) 2017 Mozilla Corporation.  All rights reserved.
 // This code is governed by the BSD license found in the LICENSE file.
 
 /*---
-esid: sec-atomics.isLockFree
+esid: sec-atomics.islockfree
 description: >
-  Atomics.isLockFree returns a boolean that indicates whether
-  operations on datum of size will be performed without the agent
-  acquiring a lock outside of size bytes.
-info: |
   Atomics.isLockFree( size )
-
+    Let n be ? ToInteger(size).
-  1. Let n be ? ToInteger(size).
+    Let AR be the Agent Record of the surrounding agent.
-  2. Let AR be the Agent Record of the surrounding agent.
+    If n equals 1, return AR.[[IsLockFree1]].
-  3. If n equals 1, return AR.[[IsLockFree1]].
+    If n equals 2, return AR.[[IsLockFree2]].
-  4. If n equals 2, return AR.[[IsLockFree2]].
+    If n equals 4, return true.
-  5. If n equals 4, return true.
+    If n equals 8, return AR.[[IsLockFree8]].
-  6. Return false.
+    Return false.
-
+features: [Atomics]
-features: [Atomics, SharedArrayBuffer, TypedArray]
-includes: [testTypedArray.js]
 ---*/
 
-var views = intArrayConstructors.slice();
+// These are the only counts that we care about tracking.
+var isLockFree1;
+var isLockFree2;
+var isLockFree8;
 
-testWithTypedArrayConstructors(function(TA) {
+{
-  assert.sameValue(Atomics.isLockFree(TA.BYTES_PER_ELEMENT), true);
+  isLockFree1 = Atomics.isLockFree(1);
-}, views);
+  //
+  // If n equals 1, return AR.[[IsLockFree1]].
+  //
+  assert.sameValue(typeof isLockFree1, 'boolean', 'The value of `typeof isLockFree1` is "boolean"');
+  // Once the values of [[Signifier]], [[IsLockFree1]], [[IsLockFree2]],
+  // and [[IsLockFree8]] have been observed by any agent in the agent
+  // cluster they cannot change.
+  assert.sameValue(
+    Atomics.isLockFree(1),
+    isLockFree1,
+    'Atomics.isLockFree(1) equals the value of `isLockFree1` (Atomics.isLockFree(1))'
+  );
+};
+{
+  isLockFree2 = Atomics.isLockFree(2);
+  //
+  // If n equals 2, return AR.[[IsLockFree2]].
+  //
+  assert.sameValue(typeof isLockFree2, 'boolean', 'The value of `typeof isLockFree2` is "boolean"');
+  // Once the values of [[Signifier]], [[IsLockFree1]], [[IsLockFree2]],
+  // and [[IsLockFree8]] have been observed by any agent in the agent
+  // cluster they cannot change.
+  assert.sameValue(
+    Atomics.isLockFree(2),
+    isLockFree2,
+    'Atomics.isLockFree(2) equals the value of `isLockFree2` (Atomics.isLockFree(2))'
+  );
+};
+{
+  let isLockFree4 = Atomics.isLockFree(4);
+  //
+  // If n equals 4, return true.
+  //
+  assert.sameValue(typeof isLockFree4, 'boolean', 'The value of `typeof isLockFree` is "boolean"');
+  assert.sameValue(isLockFree4, true, 'The value of `isLockFree` is true');
+};
 
+{
+  let isLockFree8 = Atomics.isLockFree(8);
+  //
+  // If n equals 8, return AR.[[IsLockFree8]].
+  //
+  assert.sameValue(typeof isLockFree8, 'boolean', 'The value of `typeof isLockFree8` is "boolean"');
+  // Once the values of [[Signifier]], [[IsLockFree1]], [[IsLockFree2]],
+  // and [[IsLockFree8]] have been observed by any agent in the agent
+  // cluster they cannot change.
+  assert.sameValue(
+    Atomics.isLockFree(8),
+    isLockFree8,
+    'Atomics.isLockFree(8) equals the value of `isLockFree8` (Atomics.isLockFree(8))'
+  );
+};
 
+{
+  for (let i = 0; i < 12; i++) {
+    if (![1, 2, 4, 8].includes(i)) {
+      assert.sameValue(Atomics.isLockFree(i), false);
+    }
+  }
+};
+
+assert.sameValue(
+  Atomics.isLockFree(1),
+  isLockFree1,
+  'Later call to Atomics.isLockFree(1) equals the value of `isLockFree1` (Atomics.isLockFree(1))'
+);
+assert.sameValue(
+  Atomics.isLockFree(2),
+  isLockFree2,
+  'Later call to Atomics.isLockFree(2) equals the value of `isLockFree2` (Atomics.isLockFree(2))'
+);
+assert.sameValue(
+  Atomics.isLockFree(8),
+  isLockFree8,
+  'Later call to Atomics.isLockFree(8) equals the value of `isLockFree8` (Atomics.isLockFree(8))'
+);
+
+// Duplicates behavior created by loop from above
+assert.sameValue(Atomics.isLockFree(3), false, 'Atomics.isLockFree(3) returns false');
+assert.sameValue(Atomics.isLockFree(4), true, 'Atomics.isLockFree(4) returns true');
+assert.sameValue(Atomics.isLockFree(5), false, 'Atomics.isLockFree(5) returns false');
+assert.sameValue(Atomics.isLockFree(6), false, 'Atomics.isLockFree(6) returns false');
+assert.sameValue(Atomics.isLockFree(7), false, 'Atomics.isLockFree(7) returns false');
+assert.sameValue(Atomics.isLockFree(9), false, 'Atomics.isLockFree(9) returns false');
+assert.sameValue(Atomics.isLockFree(10), false, 'Atomics.isLockFree(10) returns false');
+assert.sameValue(Atomics.isLockFree(11), false, 'Atomics.isLockFree(11) returns false');
+assert.sameValue(Atomics.isLockFree(12), false, 'Atomics.isLockFree(12) returns false');

test/built-ins/Atomics/isLockFree/length.js

@@ -24,8 +24,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.isLockFree.length, 1);
+verifyProperty(Atomics.isLockFree, 'length', {
-
+  value: 1,
-verifyNotEnumerable(Atomics.isLockFree, "length");
+  enumerable: false,
-verifyNotWritable(Atomics.isLockFree, "length");
+  writable: false,
-verifyConfigurable(Atomics.isLockFree, "length");
+  configurable: true,
+});

test/built-ins/Atomics/isLockFree/name.js

@@ -10,8 +10,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.isLockFree.name, "isLockFree");
+verifyProperty(Atomics.isLockFree, 'name', {
-
+  value: 'isLockFree',
-verifyNotEnumerable(Atomics.isLockFree, "name");
+  enumerable: false,
-verifyNotWritable(Atomics.isLockFree, "name");
+  writable: false,
-verifyConfigurable(Atomics.isLockFree, "name");
+  configurable: true,
+});

test/built-ins/Atomics/isLockFree/value.js

@@ -1,45 +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.islockfree
-description: >
-  Test isLockFree on nonnegative integer arguments
-features: [Atomics]
----*/
-
-var sizes   = [    1,     2,     3,     4,     5,     6,     7,  8,
-                   9,    10,    11,    12];
-var answers = [   {},    {}, false,  true, false, false, false, false,
-               false, false, false, false];
-
-var saved = {};
-
-// This should defeat most optimizations.
-
-for (var i = 0; i < sizes.length; i++) {
-  var v = Atomics.isLockFree(sizes[i]);
-  var a = answers[i];
-  assert.sameValue(typeof v, 'boolean');
-  if (typeof a == 'boolean') {
-    assert.sameValue(v, a);
-  } else {
-    saved[sizes[i]] = v;
-  }
-}
-
-// This ought to be optimizable.  Make sure the answers are the same
-// as for the unoptimized case.
-
-assert.sameValue(Atomics.isLockFree(1), saved[1]);
-assert.sameValue(Atomics.isLockFree(2), saved[2]);
-assert.sameValue(Atomics.isLockFree(3), false);
-assert.sameValue(Atomics.isLockFree(4), true);
-assert.sameValue(Atomics.isLockFree(5), false);
-assert.sameValue(Atomics.isLockFree(6), false);
-assert.sameValue(Atomics.isLockFree(7), false);
-assert.sameValue(Atomics.isLockFree(8), false);
-assert.sameValue(Atomics.isLockFree(9), false);
-assert.sameValue(Atomics.isLockFree(10), false);
-assert.sameValue(Atomics.isLockFree(11), false);
-assert.sameValue(Atomics.isLockFree(12), false);

test/built-ins/Atomics/load/descriptor.js

@@ -8,6 +8,8 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-verifyWritable(Atomics, "load");
+verifyProperty(Atomics, 'load', {
-verifyNotEnumerable(Atomics, "load");
+  enumerable: false,
-verifyConfigurable(Atomics, "load");
+  writable: true,
+  configurable: true,
+});

test/built-ins/Atomics/load/expected-return-value.js

@@ -30,11 +30,11 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 
 var buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
 var i32a = new Int32Array(buffer);
-var value = 0b00000001000000001000000010000001;
+var update = 0b00000001000000001000000010000001;
 
 assert.sameValue(Atomics.load(i32a, 0), 0);
 
-i32a[0] = value;
+i32a[0] = update;
 
-assert.sameValue(Atomics.load(i32a, 0), value);
+assert.sameValue(Atomics.load(i32a, 0), update);
 

test/built-ins/Atomics/load/length.js

@@ -24,8 +24,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.load.length, 2);
+verifyProperty(Atomics.load, 'length', {
-
+  value: 2,
-verifyNotEnumerable(Atomics.load, "length");
+  enumerable: false,
-verifyNotWritable(Atomics.load, "length");
+  writable: false,
-verifyConfigurable(Atomics.load, "length");
+  configurable: true,
+});

test/built-ins/Atomics/load/name.js

@@ -10,8 +10,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.load.name, "load");
+verifyProperty(Atomics.load, 'name', {
-
+  value: 'load',
-verifyNotEnumerable(Atomics.load, "name");
+  enumerable: false,
-verifyNotWritable(Atomics.load, "name");
+  writable: false,
-verifyConfigurable(Atomics.load, "name");
+  configurable: true,
+});

test/built-ins/Atomics/or/descriptor.js

@@ -7,7 +7,8 @@ description: Testing descriptor property of Atomics.or
 includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
-
+verifyProperty(Atomics, 'or', {
-verifyWritable(Atomics, "or");
+  enumerable: false,
-verifyNotEnumerable(Atomics, "or");
+  writable: true,
-verifyConfigurable(Atomics, "or");
+  configurable: true,
+});

test/built-ins/Atomics/or/expected-return-value.js

@@ -29,7 +29,7 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 
 var buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
 var i32a = new Int32Array(buffer);
-var value = 0b00000001000000001000000010000001;
+var update = 0b00000001000000001000000010000001;
 
-assert.sameValue(Atomics.or(i32a, 0, value), 0);
+assert.sameValue(Atomics.or(i32a, 0, update), 0);
-assert.sameValue(i32a[0], 0 | value);
+assert.sameValue(i32a[0], 0 | update);

test/built-ins/Atomics/or/length.js

@@ -24,8 +24,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.or.length, 3);
+verifyProperty(Atomics.or, 'length', {
-
+  value: 3,
-verifyNotEnumerable(Atomics.or, "length");
+  enumerable: false,
-verifyNotWritable(Atomics.or, "length");
+  writable: false,
-verifyConfigurable(Atomics.or, "length");
+  configurable: true,
+});

test/built-ins/Atomics/or/name.js

@@ -10,8 +10,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.or.name, "or");
+verifyProperty(Atomics.or, 'name', {
-
+  value: 'or',
-verifyNotEnumerable(Atomics.or, "name");
+  enumerable: false,
-verifyNotWritable(Atomics.or, "name");
+  writable: false,
-verifyConfigurable(Atomics.or, "name");
+  configurable: true,
+});

test/built-ins/Atomics/store/descriptor.js

@@ -7,7 +7,8 @@ description: Testing descriptor property of Atomics.store
 includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
-
+verifyProperty(Atomics, 'store', {
-verifyWritable(Atomics, "store");
+  enumerable: false,
-verifyNotEnumerable(Atomics, "store");
+  writable: true,
-verifyConfigurable(Atomics, "store");
+  configurable: true,
+});

test/built-ins/Atomics/store/expected-return-value.js

@@ -20,7 +20,7 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 
 var buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
 var i32a = new Int32Array(buffer);
-var expect = 0b00000001000000001000000010000001;
+var update = 0b00000001000000001000000010000001;
 
-assert.sameValue(Atomics.store(i32a, 0, expect), expect);
+assert.sameValue(Atomics.store(i32a, 0, update), update);
-assert.sameValue(i32a[0], expect);
+assert.sameValue(i32a[0], update);

test/built-ins/Atomics/store/length.js

@@ -24,8 +24,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.store.length, 3);
+verifyProperty(Atomics.store, 'length', {
-
+  value: 3,
-verifyNotEnumerable(Atomics.store, "length");
+  enumerable: false,
-verifyNotWritable(Atomics.store, "length");
+  writable: false,
-verifyConfigurable(Atomics.store, "length");
+  configurable: true,
+});

test/built-ins/Atomics/store/name.js

@@ -10,8 +10,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.store.name, "store");
+verifyProperty(Atomics.store, 'name', {
-
+  value: 'store',
-verifyNotEnumerable(Atomics.store, "name");
+  enumerable: false,
-verifyNotWritable(Atomics.store, "name");
+  writable: false,
-verifyConfigurable(Atomics.store, "name");
+  configurable: true,
+});

test/built-ins/Atomics/sub/descriptor.js

@@ -8,6 +8,8 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-verifyWritable(Atomics, "sub");
+verifyProperty(Atomics, 'sub', {
-verifyNotEnumerable(Atomics, "sub");
+  enumerable: false,
-verifyConfigurable(Atomics, "sub");
+  writable: true,
+  configurable: true,
+});

test/built-ins/Atomics/sub/expected-return-value.js

@@ -29,9 +29,9 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 
 var buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
 var i32a = new Int32Array(buffer);
-var value = 0b00000001000000001000000010000001;
+var update = 0b00000001000000001000000010000001;
 
-i32a[0] = value;
+i32a[0] = update;
 
-assert.sameValue(Atomics.sub(i32a, 0, value), value);
+assert.sameValue(Atomics.sub(i32a, 0, update), update);
 assert.sameValue(i32a[0], 0);

test/built-ins/Atomics/sub/length.js

@@ -24,8 +24,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.sub.length, 3);
+verifyProperty(Atomics.sub, 'length', {
-
+  value: 3,
-verifyNotEnumerable(Atomics.sub, "length");
+  enumerable: false,
-verifyNotWritable(Atomics.sub, "length");
+  writable: false,
-verifyConfigurable(Atomics.sub, "length");
+  configurable: true,
+});

test/built-ins/Atomics/sub/name.js

@@ -10,8 +10,10 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.sub.name, "sub");
+verifyProperty(Atomics.sub, 'name', {
+  value: 'sub',
+  enumerable: false,
+  writable: false,
+  configurable: true,
+});
 
-verifyNotEnumerable(Atomics.sub, "name");
-verifyNotWritable(Atomics.sub, "name");
-verifyConfigurable(Atomics.sub, "name");

test/built-ins/Atomics/wait/bigint/did-timeout.js

@@ -26,9 +26,9 @@ function getReport() {
 $262.agent.start(`
 $262.agent.receiveBroadcast(function(sab, id) {
   var ia = new BigInt64Array(sab);
-  var then = Date.now();
+  var then = $262.agent.monotonicNow();
   $262.agent.report(Atomics.wait(ia, 0, 0, 500)); // Timeout 500ms
-  $262.agent.report(Date.now() - then);           // Actual time can be more than 500ms
+  $262.agent.report($262.agent.monotonicNow() - then);           // Actual time can be more than 500ms
   $262.agent.leaving();
 });
 `);

test/built-ins/Atomics/wait/bigint/false-for-timeout-agent.js

@@ -38,11 +38,11 @@ var toPrimitive = {
 
 $262.agent.receiveBroadcast(function(sab) {
   var i64a = new BigInt64Array(sab);
-  var start = Date.now();
+  var start = $262.agent.monotonicNow();
   $262.agent.report(Atomics.wait(i64a, 0, 0, false));
   $262.agent.report(Atomics.wait(i64a, 0, 0, valueOf));
   $262.agent.report(Atomics.wait(i64a, 0, 0, toPrimitive));
-  $262.agent.report(Date.now() - start);
+  $262.agent.report($262.agent.monotonicNow() - start);
   $262.agent.leaving();
 });
 `);

test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-store-padded-time.js

@@ -13,9 +13,9 @@ features: [Atomics, BigInt, SharedArrayBuffer, TypedArray]
 $262.agent.start(`
 $262.agent.receiveBroadcast(function(sab, id) {
   var ia = new BigInt64Array(sab);
-  var then = Date.now();
+  var then = $262.agent.monotonicNow();
   Atomics.wait(ia, 0, 0);
-  var diff = Date.now() - then;        // Should be about 1000 ms but can be more
+  var diff = $262.agent.monotonicNow() - then;        // Should be about 1000 ms but can be more
   $262.agent.report(diff);
   $262.agent.leaving();
 })

test/built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-store.js

@@ -23,10 +23,10 @@ const i64a = new BigInt64Array(
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     var i64a = new BigInt64Array(sab);
-    var before = Date.now();
+    var before = $262.agent.monotonicNow();
     $262.agent.report("ready");
     Atomics.wait(i64a, 0, 0, ${TWO_SECOND_TIMEOUT});
-    $262.agent.report(Date.now() - before);
+    $262.agent.report($262.agent.monotonicNow() - before);
     $262.agent.leaving();
   });
 `);

test/built-ins/Atomics/wait/descriptor.js

@@ -8,6 +8,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-verifyWritable(Atomics, "wait");
+verifyProperty(Atomics, 'wait', {
-verifyNotEnumerable(Atomics, "wait");
+  enumerable: false,
-verifyConfigurable(Atomics, "wait");
+  writable: true,
+  configurable: true,
+});
+

test/built-ins/Atomics/wait/did-timeout.js

@@ -27,9 +27,9 @@ function getReport() {
 $262.agent.start(`
 $262.agent.receiveBroadcast(function(sab, id) {
   var i32a = new Int32Array(sab);
-  var then = Date.now();
+  var before = $262.agent.monotonicNow();
   $262.agent.report(Atomics.wait(i32a, 0, 0, 500)); // Timeout 500ms
-  $262.agent.report(Date.now() - then);           // Actual time can be more than 500ms
+  $262.agent.report($262.agent.monotonicNow() - before); // Actual time can be more than 500ms
   $262.agent.leaving();
 })
 `);

test/built-ins/Atomics/wait/false-for-timeout-agent.js

@@ -40,11 +40,11 @@ var toPrimitive = {
 
 $262.agent.receiveBroadcast(function(sab) {
   var i32a = new Int32Array(sab);
-  var start = Date.now();
+  var before = $262.agent.monotonicNow();
   $262.agent.report(Atomics.wait(i32a, 0, 0, false));
   $262.agent.report(Atomics.wait(i32a, 0, 0, valueOf));
   $262.agent.report(Atomics.wait(i32a, 0, 0, toPrimitive));
-  $262.agent.report(Date.now() - start);
+  $262.agent.report($262.agent.monotonicNow() - before);
   $262.agent.leaving();
 })
 `);

test/built-ins/Atomics/wait/length.js

@@ -24,8 +24,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.wait.length, 4);
+verifyProperty(Atomics.wait, 'length', {
-
+  value: 4,
-verifyNotEnumerable(Atomics.wait, "length");
+  enumerable: false,
-verifyNotWritable(Atomics.wait, "length");
+  writable: false,
-verifyConfigurable(Atomics.wait, "length");
+  configurable: true,
+});

test/built-ins/Atomics/wait/name.js

@@ -10,8 +10,9 @@ includes: [propertyHelper.js]
 features: [Atomics]
 ---*/
 
-assert.sameValue(Atomics.wait.name, "wait");
+verifyProperty(Atomics.wait, 'name', {
-
+  value: 'wait',
-verifyNotEnumerable(Atomics.wait, "name");
+  enumerable: false,
-verifyNotWritable(Atomics.wait, "name");
+  writable: false,
-verifyConfigurable(Atomics.wait, "name");
+  configurable: true,
+});

test/built-ins/Atomics/wait/no-spurious-wakeup-on-add.js

@@ -23,10 +23,10 @@ const i32a = new Int32Array(
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     var i32a = new Int32Array(sab);
-    var before = Date.now();
+    var before = $262.agent.monotonicNow();
     $262.agent.report("ready");
     Atomics.wait(i32a, 0, 0, ${TWO_SECOND_TIMEOUT});
-    $262.agent.report(Date.now() - before);
+    $262.agent.report($262.agent.monotonicNow() - before);
     $262.agent.leaving();
   });
 `);

test/built-ins/Atomics/wait/no-spurious-wakeup-on-and.js

@@ -23,10 +23,10 @@ const i32a = new Int32Array(
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     var i32a = new Int32Array(sab);
-    var before = Date.now();
+    var before = $262.agent.monotonicNow();
     $262.agent.report("ready");
     Atomics.wait(i32a, 0, 0, ${TWO_SECOND_TIMEOUT});
-    $262.agent.report(Date.now() - before);
+    $262.agent.report($262.agent.monotonicNow() - before);
     $262.agent.leaving();
   });
 `);

test/built-ins/Atomics/wait/no-spurious-wakeup-on-compareExchange.js

@@ -23,10 +23,10 @@ const i32a = new Int32Array(
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     var i32a = new Int32Array(sab);
-    var before = Date.now();
+    var before = $262.agent.monotonicNow();
     $262.agent.report("ready");
     Atomics.wait(i32a, 0, 0, ${TWO_SECOND_TIMEOUT});
-    $262.agent.report(Date.now() - before);
+    $262.agent.report($262.agent.monotonicNow() - before);
     $262.agent.leaving();
   });
 `);

test/built-ins/Atomics/wait/no-spurious-wakeup-on-exchange.js

@@ -23,10 +23,10 @@ const i32a = new Int32Array(
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     var i32a = new Int32Array(sab);
-    var before = Date.now();
+    var before = $262.agent.monotonicNow();
     $262.agent.report("ready");
     Atomics.wait(i32a, 0, 0, ${TWO_SECOND_TIMEOUT});
-    $262.agent.report(Date.now() - before);
+    $262.agent.report($262.agent.monotonicNow() - before);
     $262.agent.leaving();
   });
 `);

test/built-ins/Atomics/wait/no-spurious-wakeup-on-or.js

@@ -23,10 +23,10 @@ const i32a = new Int32Array(
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     var i32a = new Int32Array(sab);
-    var before = Date.now();
+    var before = $262.agent.monotonicNow();
     $262.agent.report("ready");
     Atomics.wait(i32a, 0, 0, ${TWO_SECOND_TIMEOUT});
-    $262.agent.report(Date.now() - before);
+    $262.agent.report($262.agent.monotonicNow() - before);
     $262.agent.leaving();
   });
 `);

test/built-ins/Atomics/wait/no-spurious-wakeup-on-store-padded-time.js

@@ -13,9 +13,9 @@ features: [Atomics, SharedArrayBuffer, TypedArray]
 $262.agent.start(`
 $262.agent.receiveBroadcast(function(sab, id) {
   var i32a = new Int32Array(sab);
-  var then = Date.now();
+  var then = $262.agent.monotonicNow();
   Atomics.wait(i32a, 0, 0);
-  var diff = Date.now() - then;        // Should be about 1000 ms but can be more
+  var diff = $262.agent.monotonicNow() - then;        // Should be about 1000 ms but can be more
   $262.agent.report(diff);
   $262.agent.leaving();
 })

test/built-ins/Atomics/wait/no-spurious-wakeup-on-store.js

@@ -23,10 +23,10 @@ const i32a = new Int32Array(
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     var i32a = new Int32Array(sab);
-    var before = Date.now();
+    var before = $262.agent.monotonicNow();
     $262.agent.report("ready");
     Atomics.wait(i32a, 0, 0, ${TWO_SECOND_TIMEOUT});
-    $262.agent.report(Date.now() - before);
+    $262.agent.report($262.agent.monotonicNow() - before);
     $262.agent.leaving();
   });
 `);

test/built-ins/Atomics/wait/no-spurious-wakeup-on-sub.js

@@ -23,10 +23,10 @@ const i32a = new Int32Array(
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     var i32a = new Int32Array(sab);
-    var before = Date.now();
+    var before = $262.agent.monotonicNow();
     $262.agent.report("ready");
     Atomics.wait(i32a, 0, 0, ${TWO_SECOND_TIMEOUT});
-    $262.agent.report(Date.now() - before);
+    $262.agent.report($262.agent.monotonicNow() - before);
     $262.agent.leaving();
   });
 `);

test/built-ins/Atomics/wait/no-spurious-wakeup-on-xor.js

@@ -23,10 +23,10 @@ const i32a = new Int32Array(
 $262.agent.start(`
   $262.agent.receiveBroadcast(function(sab) {
     var i32a = new Int32Array(sab);
-    var before = Date.now();
+    var before = $262.agent.monotonicNow();
     $262.agent.report("ready");
     Atomics.wait(i32a, 0, 0, ${TWO_SECOND_TIMEOUT});
-    $262.agent.report(Date.now() - before);
+    $262.agent.report($262.agent.monotonicNow() - before);
     $262.agent.leaving();
   });
 `);

test/built-ins/Atomics/wait/null-for-timeout-agent.js

@@ -40,11 +40,11 @@ var toPrimitive = {
 
 $262.agent.receiveBroadcast(function(sab) {
   var i32a = new Int32Array(sab);
-  var start = Date.now();
+  var before = $262.agent.monotonicNow();
   $262.agent.report(Atomics.wait(i32a, 0, 0, null));
   $262.agent.report(Atomics.wait(i32a, 0, 0, valueOf));
   $262.agent.report(Atomics.wait(i32a, 0, 0, toPrimitive));
-  $262.agent.report(Date.now() - start);
+  $262.agent.report($262.agent.monotonicNow() - before);
   $262.agent.leaving();
 })
 `);

test/built-ins/Atomics/wait/object-for-timeout-agent.js

@@ -47,11 +47,11 @@ var toPrimitive = {
 
 $262.agent.receiveBroadcast(function(sab) {
   var i32a = new Int32Array(sab);
-  var start = Date.now();
+  var start = $262.agent.monotonicNow();
   $262.agent.report(Atomics.wait(i32a, 0, 0, valueOf));
   $262.agent.report(Atomics.wait(i32a, 0, 0, toString));
   $262.agent.report(Atomics.wait(i32a, 0, 0, toPrimitive));
-  $262.agent.report(Date.now() - start);
+  $262.agent.report($262.agent.monotonicNow() - start);
   $262.agent.leaving();
 })
 `);

test/built-ins/Atomics/wait/poisoned-object-for-timeout-throws-agent.js

@@ -40,7 +40,7 @@ var poisonedToPrimitive = {
 
 $262.agent.receiveBroadcast(function(sab) {
   var i32a = new Int32Array(sab);
-  var start = Date.now();
+  var start = $262.agent.monotonicNow();
   try {
     Atomics.wait(i32a, 0, 0, poisonedValueOf);
   } catch (error) {
@@ -51,7 +51,7 @@ $262.agent.receiveBroadcast(function(sab) {
   } catch (error) {
     $262.agent.report("poisonedToPrimitive");
   }
-  $262.agent.report(Date.now() - start);
+  $262.agent.report($262.agent.monotonicNow() - start);
   $262.agent.leaving();
 });
 `);

test/built-ins/Atomics/wait/symbol-for-index-throws-agent.js

@@ -53,7 +53,7 @@ var poisonedToPrimitive = {
 
 $262.agent.receiveBroadcast(function(sab) {
   var i32a = new Int32Array(sab);
-  var start = Date.now();
+  var start = $262.agent.monotonicNow();
   try {
     Atomics.wait(i32a, Symbol("1"), poisonedValueOf, poisonedValueOf);
   } catch (error) {
@@ -64,7 +64,7 @@ $262.agent.receiveBroadcast(function(sab) {
   } catch (error) {
     $262.agent.report('Symbol("2")');
   }
-  $262.agent.report(Date.now() - start);
+  $262.agent.report($262.agent.monotonicNow() - start);
   $262.agent.leaving();
 });
 `);

test/built-ins/Atomics/wait/symbol-for-timeout-throws-agent.js

@@ -26,7 +26,7 @@ function getReport() {
 $262.agent.start(`
 $262.agent.receiveBroadcast(function(sab) {
   var i32a = new Int32Array(sab);
-  var start = Date.now();
+  var start = $262.agent.monotonicNow();
   try {
     Atomics.wait(i32a, 0, 0, Symbol("1"));
   } catch (error) {
@@ -37,7 +37,7 @@ $262.agent.receiveBroadcast(function(sab) {
   } catch (error) {
     $262.agent.report('Symbol("2")');
   }
-  $262.agent.report(Date.now() - start);
+  $262.agent.report($262.agent.monotonicNow() - start);
   $262.agent.leaving();
 });
 `);

test/built-ins/Atomics/wait/symbol-for-value-throws-agent.js

@@ -43,7 +43,7 @@ var poisonedToPrimitive = {
 
 $262.agent.receiveBroadcast(function(sab) {
   var i32a = new Int32Array(sab);
-  var start = Date.now();
+  var start = $262.agent.monotonicNow();
   try {
     Atomics.wait(i32a, 0, Symbol("1"), poisonedValueOf);
   } catch (error) {
@@ -54,7 +54,7 @@ $262.agent.receiveBroadcast(function(sab) {
   } catch (error) {
     $262.agent.report('Symbol("2")');
   }
-  $262.agent.report(Date.now() - start);
+  $262.agent.report($262.agent.monotonicNow() - start);
   $262.agent.leaving();
 });
 `);

test/built-ins/Atomics/wait/true-for-timeout-agent.js

@@ -40,11 +40,11 @@ var toPrimitive = {
 
 $262.agent.receiveBroadcast(function(sab) {
   var i32a = new Int32Array(sab);
-  var start = Date.now();
+  var start = $262.agent.monotonicNow();
   $262.agent.report(Atomics.wait(i32a, 0, 0, true));
   $262.agent.report(Atomics.wait(i32a, 0, 0, valueOf));
   $262.agent.report(Atomics.wait(i32a, 0, 0, toPrimitive));
-  $262.agent.report(Date.now() - start);
+  $262.agent.report($262.agent.monotonicNow() - start);
   $262.agent.leaving();
 })
 `);

test/built-ins/Atomics/wait/waiterlist-order-of-operations-is-fifo.js

@@ -70,7 +70,7 @@ var i32a = new Int32Array(new SharedArrayBuffer(4));
 
 $262.agent.broadcast(i32a.buffer);
 
-var orderWhichAgentsWereStarted = getReport() + getReport() + getReport(); // can be started in any order
+var orderAgentsStarted = getReport() + getReport() + getReport(); // can be started in any order
 
 assert.sameValue(Atomics.wake(i32a, 0, 1), 1);
 
@@ -84,4 +84,4 @@ assert.sameValue(Atomics.wake(i32a, 0, 1), 1);
 
 orderAgentsWereWoken += getReport();
 
-assert.sameValue(orderWhichAgentsWereStarted, orderAgentsWereWoken);  // agents should wake in the same order as they were started FIFO
+assert.sameValue(orderAgentsStarted, orderAgentsWereWoken);  // agents should wake in the same order as they were started FIFO

test/built-ins/Atomics/wait/was-woken.js

@@ -18,15 +18,15 @@ function getReport() {
 
 $262.agent.start(`
 $262.agent.receiveBroadcast(function(sab, id) {
-  var ia = new Int32Array(sab);
+  var i32a = new Int32Array(sab);
-  $262.agent.report(Atomics.wait(ia, 0, 0)); // No timeout => Infinity
+  $262.agent.report(Atomics.wait(i32a, 0, 0)); // No timeout => Infinity
   $262.agent.leaving();
 });
 `);
 
-var ia = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+var i32a = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
 
-$262.agent.broadcast(ia.buffer);
+$262.agent.broadcast(i32a.buffer);
 $262.agent.sleep(500); // Give the agent a chance to wait
-Atomics.wake(ia, 0);
+Atomics.wake(i32a, 0);
 assert.sameValue(getReport(), "ok");