diff --git a/harness/nans.js b/harness/nans.js
index e541dba02ba463159925876e426820c35acb43bd..3636a0b8c40538c36e271d42570ffdffab5a12fa 100644
--- a/harness/nans.js
+++ b/harness/nans.js
@@ -7,6 +7,15 @@ description: |
weak basis for assertions regarding the consistent canonicalization of NaN
values in Array buffers.
---*/
-var distinctNaNs = [
- 0/0, Infinity/Infinity, -(0/0), Math.pow(-1, 0.5), -Math.pow(-1, 0.5)
+
+var NaNs = [
+ () => NaN,
+ () => Number.NaN,
+ () => NaN * 0,
+ () => 0/0,
+ () => Infinity/Infinity,
+ () => -(0/0),
+ () => Math.pow(-1, 0.5),
+ () => -Math.pow(-1, 0.5),
+ () => Number("Not-a-Number"),
];
diff --git a/test/built-ins/Object/internals/DefineOwnProperty/nan-equivalence-define-own-property-reassign.js b/test/built-ins/Object/internals/DefineOwnProperty/nan-equivalence-define-own-property-reassign.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe1d3ba2a1f876ef40345f444c479a932ffaff32
--- /dev/null
+++ b/test/built-ins/Object/internals/DefineOwnProperty/nan-equivalence-define-own-property-reassign.js
@@ -0,0 +1,68 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc
+description: >
+ Replaces value field even if they pass in the SameValue algorithm, including
+ distinct NaN values
+info: |
+ This test does not compare the actual byte values, instead it simply checks that
+ the value is some valid NaN encoding.
+
+ ---
+
+ Previously, this test compared the "value" field using the SameValue
+ algorithm (thereby ignoring distinct NaN values)
+
+ ---
+
+ [[DefineOwnProperty]] (P, Desc)
+
+ Return ? OrdinaryDefineOwnProperty(O, P, Desc).
+
+ #sec-ordinarydefineownproperty
+ OrdinaryDefineOwnProperty ( O, P, Desc )
+
+ 1. Let current be ? O.[[GetOwnProperty]](P).
+ 2. Let extensible be O.[[Extensible]].
+ 3. Return ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc,
+ current).
+
+ #sec-validateandapplypropertydescriptor
+ ValidateAndApplyPropertyDescriptor ( O, P, extensible, Desc, current )
+
+ ...
+ 7. Else if IsDataDescriptor(current) and IsDataDescriptor(Desc) are both true,
+ then
+ a. If current.[[Configurable]] is false and current.[[Writable]] is false,
+ then
+ ...
+ ...
+ 9. If O is not undefined, then
+ a. For each field of Desc that is present, set the corresponding attribute
+ of the property named P of object O to the value of the field.
+ 10. Return true.
+
+ #sec-isnan-number
+
+ NOTE: A reliable way for ECMAScript code to test if a value X is a NaN is
+ an expression of the form X !== X. The result will be true if and only
+ if X is a NaN.
+includes: [nans.js]
+---*/
+
+var len = NaNs.length;
+
+for (var idx = 0; idx < len; ++idx) {
+ for (var jdx = 0; jdx < len; ++jdx) {
+ var a = {};
+
+ a.prop = NaNs[idx]();
+ a.prop = NaNs[jdx]();
+
+ assert(
+ a.prop !== a.prop,
+ `Object property value reassigned to NaN produced by (${NaNs[idx].toString()}) results in a valid NaN`
+ );
+ }
+}
diff --git a/test/built-ins/Object/internals/DefineOwnProperty/nan-equivalence-define-own-property-reconfigure.js b/test/built-ins/Object/internals/DefineOwnProperty/nan-equivalence-define-own-property-reconfigure.js
new file mode 100644
index 0000000000000000000000000000000000000000..7eb257bc167deab3cc9a33b5a862b3b0e4f888c7
--- /dev/null
+++ b/test/built-ins/Object/internals/DefineOwnProperty/nan-equivalence-define-own-property-reconfigure.js
@@ -0,0 +1,75 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc
+description: >
+ Replaces value field even if they pass in the SameValue algorithm, including
+ distinct NaN values
+info: |
+ This test does not compare the actual byte values, instead it simply checks that
+ the value is some valid NaN encoding.
+
+ ---
+
+ Previously, this method compared the "value" field using the SameValue
+ algorithm (thereby ignoring distinct NaN values)
+
+ ---
+
+ [[DefineOwnProperty]] (P, Desc)
+
+ Return ? OrdinaryDefineOwnProperty(O, P, Desc).
+
+ #sec-ordinarydefineownproperty
+ OrdinaryDefineOwnProperty ( O, P, Desc )
+
+ 1. Let current be ? O.[[GetOwnProperty]](P).
+ 2. Let extensible be O.[[Extensible]].
+ 3. Return ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc,
+ current).
+
+ #sec-validateandapplypropertydescriptor
+ ValidateAndApplyPropertyDescriptor ( O, P, extensible, Desc, current )
+
+ ...
+ 7. Else if IsDataDescriptor(current) and IsDataDescriptor(Desc) are both true,
+ then
+ a. If current.[[Configurable]] is false and current.[[Writable]] is false,
+ then
+ ...
+ ...
+ 9. If O is not undefined, then
+ a. For each field of Desc that is present, set the corresponding attribute
+ of the property named P of object O to the value of the field.
+ 10. Return true.
+
+ #sec-isnan-number
+
+ NOTE: A reliable way for ECMAScript code to test if a value X is a NaN is
+ an expression of the form X !== X. The result will be true if and only
+ if X is a NaN.
+includes: [nans.js]
+---*/
+
+var len = NaNs.length;
+
+for (var idx = 0; idx < len; ++idx) {
+ for (var jdx = 0; jdx < len; ++jdx) {
+ var a = {};
+ var b = {};
+
+ Object.defineProperty(a, "prop", {
+ value: NaNs[idx](),
+ configurable: true,
+ });
+
+ Object.defineProperty(a, "prop", {
+ value: NaNs[jdx](),
+ });
+
+ assert(
+ a.prop !== a.prop,
+ `Object property value reconfigured to NaN produced by (${NaNs[idx].toString()}) results in a valid NaN`
+ );
+ }
+}
diff --git a/test/built-ins/Object/internals/DefineOwnProperty/nan-equivalence.js b/test/built-ins/Object/internals/DefineOwnProperty/nan-equivalence.js
deleted file mode 100644
index d6f4455ad13850dc4396ffd9ca787578cae1b207..0000000000000000000000000000000000000000
--- a/test/built-ins/Object/internals/DefineOwnProperty/nan-equivalence.js
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (C) 2016 the V8 project authors. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-/*---
-esid: sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc
-es6id: 9.1.6
-description: >
- Replaces value field even if they pass in the SameValue algorithm, including
- distinct NaN values
-info: |
- Previously, this method compared the "value" field using the SameValue
- algorithm (thereby ignoring distinct NaN values)
-
- ---
-
- [[DefineOwnProperty]] (P, Desc)
-
- 1. Return ? OrdinaryDefineOwnProperty(O, P, Desc).
-
- 9.1.6.1 OrdinaryDefineOwnProperty
-
- 1. Let current be ? O.[[GetOwnProperty]](P).
- 2. Let extensible be O.[[Extensible]].
- 3. Return ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc,
- current).
-
- 9.1.6.3 ValidateAndApplyPropertyDescriptor
-
- [...]
- 7. Else if IsDataDescriptor(current) and IsDataDescriptor(Desc) are both true,
- then
- a. If current.[[Configurable]] is false and current.[[Writable]] is false,
- then
- [...]
- [...]
- 9. If O is not undefined, then
- a. For each field of Desc that is present, set the corresponding attribute
- of the property named P of object O to the value of the field.
- 10. Return true.
-features: [Float64Array, Uint8Array, Uint16Array]
-includes: [nans.js]
----*/
-
-var isLittleEndian = new Uint8Array(new Uint16Array([1]).buffer)[0] !== 0;
-
-var float = new Float64Array(1);
-var ints = new Uint8Array(float.buffer);
-var len = distinctNaNs.length;
-
-function byteValue(value) {
- float[0] = value;
-
- var hex = "0123456789ABCDEF";
- var s = "";
- for (var i = 0; i < 8; ++i) {
- var v = ints[isLittleEndian ? 7 - i : i];
- s += hex[(v >> 4) & 0xf] + hex[v & 0xf];
- }
- return s;
-}
-
-/**
- * Iterate over each pair of distinct NaN values (with replacement). If two or
- * more suitable NaN values cannot be identified, the semantics under test
- * cannot be verified and this test is expected to pass without evaluating any
- * assertions.
- */
-for (var idx = 0; idx < len; ++idx) {
- for (var jdx = 0; jdx < len; ++jdx) {
- // NB: Don't store the distinct NaN values as global variables, because
- // global variables are properties of the global object. And in this test
- // we want to ensure NaN-valued properties in objects are properly handled,
- // so storing NaN values in the (global) object defeats the purpose.
- if (byteValue(distinctNaNs[idx]) === byteValue(distinctNaNs[jdx])) {
- continue;
- }
-
- var subject = {};
- subject.prop = distinctNaNs[idx];
- subject.prop = distinctNaNs[jdx];
-
- assert.sameValue(
- byteValue(subject.prop),
- byteValue(distinctNaNs[jdx]),
- 'Property value was re-set'
- );
- }
-}
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/bit-precision.js b/test/built-ins/TypedArray/prototype/copyWithin/bit-precision.js
index 215f01f4a54581111a3560e965d1703c6582ff10..1aa660622b4e8b1a6951674ea5f5b4816e4d39f0 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/bit-precision.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/bit-precision.js
@@ -17,14 +17,14 @@ features: [TypedArray]
---*/
function body(FloatArray) {
- var subject = new FloatArray(distinctNaNs.length * 2);
+ var subject = new FloatArray(NaNs.length * 2);
- distinctNaNs.forEach(function(v, i) {
- subject[i] = v;
+ NaNs.forEach(function(v, i) {
+ subject[i] = v();
});
var originalBytes, copiedBytes;
- var length = distinctNaNs.length * FloatArray.BYTES_PER_ELEMENT;
+ var length = NaNs.length * FloatArray.BYTES_PER_ELEMENT;
originalBytes = new Uint8Array(
subject.buffer,
@@ -32,7 +32,7 @@ function body(FloatArray) {
length
);
- subject.copyWithin(distinctNaNs.length, 0);
+ subject.copyWithin(NaNs.length, 0);
copiedBytes = new Uint8Array(
subject.buffer,
length
diff --git a/test/built-ins/TypedArray/prototype/fill/fill-values-conversion-operations-consistent-nan.js b/test/built-ins/TypedArray/prototype/fill/fill-values-conversion-operations-consistent-nan.js
index 80e435b2e16794861d7c9682cad728666429867b..34e1f507bcbae774e605a86a9cef5449e9d80290 100644
--- a/test/built-ins/TypedArray/prototype/fill/fill-values-conversion-operations-consistent-nan.js
+++ b/test/built-ins/TypedArray/prototype/fill/fill-values-conversion-operations-consistent-nan.js
@@ -2,8 +2,14 @@
// This code is governed by the BSD license found in the LICENSE file.
/*---
esid: sec-%typedarray%.prototype.fill
-description: Consistent canonicalization of NaN values
+description: >
+ An implementation must always choose either the same encoding for each implementation distinguishable *NaN* value, or an implementation-defined canonical value.
info: |
+ This test does not compare the actual byte values, instead it simply checks that
+ the value is some valid NaN encoding.
+
+ ---
+
22.2.3.8 %TypedArray%.prototype.fill (value [ , start [ , end ] ] )
%TypedArray%.prototype.fill is a distinct function that implements the same
@@ -17,7 +23,8 @@ info: |
...
- 22.1.3.6 Array.prototype.fill (value [ , start [ , end ] ] )
+ #sec-array.prototype.fill
+ Array.prototype.fill (value [ , start [ , end ] ] )
...
7. Repeat, while k < final
@@ -25,46 +32,70 @@ info: |
b. Perform ? Set(O, Pk, value, true).
...
- 24.1.1.6 SetValueInBuffer ( arrayBuffer, byteIndex, type, value [ ,
+ #sec-setvalueinbuffer
+ SetValueInBuffer ( arrayBuffer, byteIndex, type, value [ ,
isLittleEndian ] )
- ...
- 8. If type is "Float32", then
+ 8. Let rawBytes be NumberToRawBytes(type, value, isLittleEndian).
+
+ #sec-numbertorawbytes
+ NumberToRawBytes( type, value, isLittleEndian )
+
+ 1. If type is "Float32", then
a. Set rawBytes to a List containing the 4 bytes that are the result
of converting value to IEEE 754-2008 binary32 format using “Round to
nearest, ties to even†rounding mode. If isLittleEndian is false, the
bytes are arranged in big endian order. Otherwise, the bytes are
arranged in little endian order. If value is NaN, rawValue may be set
to any implementation chosen IEEE 754-2008 binary64 format Not-a-Number
- encoding. An implementation must always choose the same encoding for
- each implementation distinguishable NaN value.
- 9. Else, if type is "Float64", then
- a. Set rawBytes to a List containing the 8 bytes that are the IEEE
- 754-2008 binary64 format encoding of value. If isLittleEndian is false,
- the bytes are arranged in big endian order. Otherwise, the bytes are
- arranged in little endian order. If value is NaN, rawValue may be set
- to any implementation chosen IEEE 754-2008 binary32 format Not-a-Number
- encoding. An implementation must always choose the same encoding for
- each implementation distinguishable NaN value.
+ encoding. An implementation must always choose either the same encoding
+ for each implementation distinguishable *NaN* value, or an
+ implementation-defined canonical value.
+ 2. Else, if type is "Float64", then
+ a. Set _rawBytes_ to a List containing the 8 bytes that are the IEEE
+ 754-2008 binary64 format encoding of _value_. If _isLittleEndian_ is
+ *false*, the bytes are arranged in big endian order. Otherwise,
+ the bytes are arranged in little endian order. If _value_ is *NaN*,
+ _rawValue_ may be set to any implementation chosen IEEE 754-2008
+ binary64 format Not-a-Number encoding. An implementation must
+ always choose either the same encoding for each implementation
+ distinguishable *NaN* value, or an implementation-defined
+ canonical value.
...
-includes: [nans.js, testTypedArray.js, compareArray.js]
+
+ #sec-isnan-number
+
+ NOTE: A reliable way for ECMAScript code to test if a value X is a NaN is
+ an expression of the form X !== X. The result will be true if and only
+ if X is a NaN.
+includes: [nans.js, testTypedArray.js]
features: [TypedArray]
---*/
-function body(FloatArray) {
- var sample = new FloatArray(3);
- var control, idx, someNaN, sampleBytes, controlBytes;
+testWithTypedArrayConstructors(function(FA) {
+ var precision = FA === Float32Array ? "single" : "double";
+ var samples = new FA(3);
+ var controls, idx, aNaN;
- for (idx = 0; idx < distinctNaNs.length; ++idx) {
- someNaN = distinctNaNs[idx];
- control = new FloatArray([someNaN, someNaN, someNaN]);
+ for (idx = 0; idx < NaNs.length; ++idx) {
+ aNaN = NaNs[idx]();
+ controls = new Float32Array([aNaN, aNaN, aNaN]);
- sample.fill(someNaN);
+ samples.fill(aNaN);
- sampleBytes = new Uint8Array(sample.buffer);
- controlBytes = new Uint8Array(control.buffer);
- assert(compareArray(sampleBytes, controlBytes), 'NaN value #' + idx);
- }
-}
+ for (var i = 0; i < samples.length; i++) {
+ var sample = samples[i];
+ var control = controls[i];
-testWithTypedArrayConstructors(body, [Float32Array, Float64Array]);
+ assert(
+ samples[i] !== samples[i],
+ `samples (${NaNs[idx].toString()}) produces a valid NaN (${precision} precision)`
+ );
+
+ assert(
+ controls[i] !== controls[i],
+ `controls (${NaNs[idx].toString()}) produces a valid NaN (${precision} precision)`
+ );
+ }
+ }
+}, [Float32Array, Float64Array]);
diff --git a/test/built-ins/TypedArray/prototype/map/return-new-typedarray-conversion-operation-consistent-nan.js b/test/built-ins/TypedArray/prototype/map/return-new-typedarray-conversion-operation-consistent-nan.js
index 15b63f79158aeaf28426c5a98d6c9e16a45a2fbf..7774273dc3b31ef8b97f820037c646c0cb43b111 100644
--- a/test/built-ins/TypedArray/prototype/map/return-new-typedarray-conversion-operation-consistent-nan.js
+++ b/test/built-ins/TypedArray/prototype/map/return-new-typedarray-conversion-operation-consistent-nan.js
@@ -45,12 +45,12 @@ features: [TypedArray]
---*/
function body(FloatArray) {
- var sample = new FloatArray(distinctNaNs);
+ var sample = new FloatArray(NaNs.map(n => n()));
var sampleBytes, resultBytes;
var i = 0;
var result = sample.map(function() {
- return distinctNaNs[i++];
+ return NaNs[i++];
});
sampleBytes = new Uint8Array(sample.buffer);
diff --git a/test/built-ins/TypedArray/prototype/set/bit-precision.js b/test/built-ins/TypedArray/prototype/set/bit-precision.js
index 0e9aac1c862724331c89b4a351a0c8afb31c5d15..569d9cdd795bb6de92add5fa6f36e635d06d20c6 100644
--- a/test/built-ins/TypedArray/prototype/set/bit-precision.js
+++ b/test/built-ins/TypedArray/prototype/set/bit-precision.js
@@ -19,9 +19,9 @@ includes: [nans.js, compareArray.js, testTypedArray.js]
features: [TypedArray]
---*/
-function body(FloatArray) {
- var source = new FloatArray(distinctNaNs);
- var target = new FloatArray(distinctNaNs.length);
+function body(FA) {
+ var source = new FA(NaNs.map(n => n()));
+ var target = new FA(NaNs.length);
var sourceBytes, targetBytes;
target.set(source);
diff --git a/test/built-ins/TypedArray/prototype/slice/bit-precision.js b/test/built-ins/TypedArray/prototype/slice/bit-precision.js
index 6f86ad033fb5aab29eb1fe61347722c4db527293..4698d460c69e11e94c106b076cb6b9fd485f91ac 100644
--- a/test/built-ins/TypedArray/prototype/slice/bit-precision.js
+++ b/test/built-ins/TypedArray/prototype/slice/bit-precision.js
@@ -25,7 +25,7 @@ features: [TypedArray]
---*/
function body(FloatArray) {
- var subject = new FloatArray(distinctNaNs);
+ var subject = new FloatArray(NaNs.map(n => n()));
var sliced, subjectBytes, slicedBytes;
sliced = subject.slice();
diff --git a/test/built-ins/TypedArrayConstructors/ctors/object-arg/conversion-operation-consistent-nan.js b/test/built-ins/TypedArrayConstructors/ctors/object-arg/conversion-operation-consistent-nan.js
index d01684942bd8f602ef0122c63c7571fa67bebb32..bb652e602ee1c39c9669f6538c87ddabc8af10ee 100644
--- a/test/built-ins/TypedArrayConstructors/ctors/object-arg/conversion-operation-consistent-nan.js
+++ b/test/built-ins/TypedArrayConstructors/ctors/object-arg/conversion-operation-consistent-nan.js
@@ -50,8 +50,8 @@ features: [TypedArray]
---*/
function body(FloatArray) {
- var first = new FloatArray(distinctNaNs);
- var second = new FloatArray(distinctNaNs);
+ var first = new FloatArray(NaNs.map(n => n()));
+ var second = new FloatArray(NaNs.map(n => n()));
var firstBytes = new Uint8Array(first.buffer);
var secondBytes = new Uint8Array(second.buffer);
diff --git a/test/built-ins/TypedArrayConstructors/internals/DefineOwnProperty/conversion-operation-consistent-nan.js b/test/built-ins/TypedArrayConstructors/internals/DefineOwnProperty/conversion-operation-consistent-nan.js
index c990ecd979f03200234d86fe479064a9a5e7e3a8..434b557e672c7e13544ec7c0f310146faa7caa55 100644
--- a/test/built-ins/TypedArrayConstructors/internals/DefineOwnProperty/conversion-operation-consistent-nan.js
+++ b/test/built-ins/TypedArrayConstructors/internals/DefineOwnProperty/conversion-operation-consistent-nan.js
@@ -4,7 +4,12 @@
esid: sec-integer-indexed-exotic-objects-defineownproperty-p-desc
description: Consistent canonicalization of NaN values
info: |
- 9.4.5.3 [[DefineOwnProperty]] ( P, Desc)
+ This test does not compare the actual byte values, instead it simply checks that
+ the value is some valid NaN encoding.
+
+ ---
+
+ [[DefineOwnProperty]] ( P, Desc)
...
3. If Type(P) is String, then
@@ -16,52 +21,78 @@ info: |
2. Return ? IntegerIndexedElementSet(O, intIndex, value).
...
- 9.4.5.9 IntegerIndexedElementSet ( O, index, value )
+ #sec-integerindexedelementset
+ IntegerIndexedElementSet ( O, index, value )
...
15. Perform SetValueInBuffer(buffer, indexedPosition, elementType, numValue).
...
- 24.1.1.6 SetValueInBuffer ( arrayBuffer, byteIndex, type, value [ ,
+ #sec-setvalueinbuffer
+ SetValueInBuffer ( arrayBuffer, byteIndex, type, value [ ,
isLittleEndian ] )
- ...
- 8. If type is "Float32", then
+ 8. Let rawBytes be NumberToRawBytes(type, value, isLittleEndian).
+
+ #sec-numbertorawbytes
+ NumberToRawBytes( type, value, isLittleEndian )
+
+ 1. If type is "Float32", then
a. Set rawBytes to a List containing the 4 bytes that are the result
of converting value to IEEE 754-2008 binary32 format using “Round to
nearest, ties to even†rounding mode. If isLittleEndian is false, the
bytes are arranged in big endian order. Otherwise, the bytes are
arranged in little endian order. If value is NaN, rawValue may be set
to any implementation chosen IEEE 754-2008 binary64 format Not-a-Number
- encoding. An implementation must always choose the same encoding for
- each implementation distinguishable NaN value.
- 9. Else, if type is "Float64", then
- a. Set rawBytes to a List containing the 8 bytes that are the IEEE
- 754-2008 binary64 format encoding of value. If isLittleEndian is false,
- the bytes are arranged in big endian order. Otherwise, the bytes are
- arranged in little endian order. If value is NaN, rawValue may be set
- to any implementation chosen IEEE 754-2008 binary32 format Not-a-Number
- encoding. An implementation must always choose the same encoding for
- each implementation distinguishable NaN value.
+ encoding. An implementation must always choose either the same encoding
+ for each implementation distinguishable *NaN* value, or an
+ implementation-defined canonical value.
+ 2. Else, if type is "Float64", then
+ a. Set _rawBytes_ to a List containing the 8 bytes that are the IEEE
+ 754-2008 binary64 format encoding of _value_. If _isLittleEndian_ is
+ *false*, the bytes are arranged in big endian order. Otherwise,
+ the bytes are arranged in little endian order. If _value_ is *NaN*,
+ _rawValue_ may be set to any implementation chosen IEEE 754-2008
+ binary64 format Not-a-Number encoding. An implementation must
+ always choose either the same encoding for each implementation
+ distinguishable *NaN* value, or an implementation-defined
+ canonical value.
...
-includes: [nans.js, testTypedArray.js, compareArray.js]
+
+ #sec-isnan-number
+
+ NOTE: A reliable way for ECMAScript code to test if a value X is a NaN is
+ an expression of the form X !== X. The result will be true if and only
+ if X is a NaN.
+includes: [nans.js, testTypedArray.js]
features: [TypedArray]
---*/
-function body(FloatArray) {
- var sample = new FloatArray(1);
- var control, idx, someNaN, sampleBytes, controlBytes;
+testWithTypedArrayConstructors(function(FA) {
+ var precision = FA === Float32Array ? "single" : "double";
+ var samples = new FA(1);
+ var controls, idx, aNaN;
+
+ for (idx = 0; idx < NaNs.length; ++idx) {
+ aNaN = NaNs[idx]();
+ controls = new FA([aNaN, aNaN, aNaN]);
+
+ Object.defineProperty(samples, "0", { value: aNaN });
- for (idx = 0; idx < distinctNaNs.length; ++idx) {
- someNaN = distinctNaNs[idx];
- control = new FloatArray([someNaN]);
+ for (var i = 0; i < samples.length; i++) {
+ var sample = samples[i];
+ var control = controls[i];
- Object.defineProperty(sample, '0', { value: someNaN });
+ assert(
+ samples[i] !== samples[i],
+ `samples (${NaNs[idx].toString()}) produces a valid NaN (${precision} precision)`
+ );
- sampleBytes = new Uint8Array(sample.buffer);
- controlBytes = new Uint8Array(control.buffer);
- assert(compareArray(sampleBytes, controlBytes));
+ assert(
+ controls[i] !== controls[i],
+ `controls (${NaNs[idx].toString()}) produces a valid NaN (${precision} precision)`
+ );
+ }
}
-}
+}, [Float32Array, Float64Array]);
-testWithTypedArrayConstructors(body, [Float32Array, Float64Array]);
diff --git a/test/built-ins/TypedArrayConstructors/internals/Set/conversion-operation-consistent-nan.js b/test/built-ins/TypedArrayConstructors/internals/Set/conversion-operation-consistent-nan.js
index 39a672a641afae41f37bad96f821473431acdfcc..6d9b1677a51bdfbae542a17c21cf7bd459a04e55 100644
--- a/test/built-ins/TypedArrayConstructors/internals/Set/conversion-operation-consistent-nan.js
+++ b/test/built-ins/TypedArrayConstructors/internals/Set/conversion-operation-consistent-nan.js
@@ -4,7 +4,12 @@
esid: sec-integer-indexed-exotic-objects-set-p-v-receiver
description: Consistent canonicalization of NaN values
info: |
- 9.4.5.5 [[Set]] ( P, V, Receiver)
+ This test does not compare the actual byte values, instead it simply checks that
+ the value is some valid NaN encoding.
+
+ ---
+
+ [[Set]] ( P, V, Receiver)
...
2. If Type(P) is String, then
@@ -13,52 +18,79 @@ info: |
i. Return ? IntegerIndexedElementSet(O, numericIndex, V).
...
- 9.4.5.9 IntegerIndexedElementSet ( O, index, value )
+ #sec-integerindexedelementset
+ IntegerIndexedElementSet ( O, index, value )
...
15. Perform SetValueInBuffer(buffer, indexedPosition, elementType, numValue).
...
- 24.1.1.6 SetValueInBuffer ( arrayBuffer, byteIndex, type, value [ ,
+ #sec-setvalueinbuffer
+ SetValueInBuffer ( arrayBuffer, byteIndex, type, value [ ,
isLittleEndian ] )
- ...
- 8. If type is "Float32", then
+ 8. Let rawBytes be NumberToRawBytes(type, value, isLittleEndian).
+
+ #sec-numbertorawbytes
+
+ NumberToRawBytes( type, value, isLittleEndian )
+
+ 1. If type is "Float32", then
a. Set rawBytes to a List containing the 4 bytes that are the result
of converting value to IEEE 754-2008 binary32 format using “Round to
nearest, ties to even†rounding mode. If isLittleEndian is false, the
bytes are arranged in big endian order. Otherwise, the bytes are
arranged in little endian order. If value is NaN, rawValue may be set
to any implementation chosen IEEE 754-2008 binary64 format Not-a-Number
- encoding. An implementation must always choose the same encoding for
- each implementation distinguishable NaN value.
- 9. Else, if type is "Float64", then
- a. Set rawBytes to a List containing the 8 bytes that are the IEEE
- 754-2008 binary64 format encoding of value. If isLittleEndian is false,
- the bytes are arranged in big endian order. Otherwise, the bytes are
- arranged in little endian order. If value is NaN, rawValue may be set
- to any implementation chosen IEEE 754-2008 binary32 format Not-a-Number
- encoding. An implementation must always choose the same encoding for
- each implementation distinguishable NaN value.
+ encoding. An implementation must always choose either the same encoding
+ for each implementation distinguishable *NaN* value, or an
+ implementation-defined canonical value.
+ 2. Else, if type is "Float64", then
+ a. Set _rawBytes_ to a List containing the 8 bytes that are the IEEE
+ 754-2008 binary64 format encoding of _value_. If _isLittleEndian_ is
+ *false*, the bytes are arranged in big endian order. Otherwise,
+ the bytes are arranged in little endian order. If _value_ is *NaN*,
+ _rawValue_ may be set to any implementation chosen IEEE 754-2008
+ binary64 format Not-a-Number encoding. An implementation must
+ always choose either the same encoding for each implementation
+ distinguishable *NaN* value, or an implementation-defined
+ canonical value.
...
-includes: [nans.js, testTypedArray.js, compareArray.js]
+
+ #sec-isnan-number
+
+ NOTE: A reliable way for ECMAScript code to test if a value X is a NaN is
+ an expression of the form X !== X. The result will be true if and only
+ if X is a NaN.
+includes: [nans.js, testTypedArray.js]
features: [TypedArray]
---*/
-function body(FloatArray) {
- var sample = new FloatArray(1);
- var control, idx, someNaN, sampleBytes, controlBytes;
+testWithTypedArrayConstructors(function(FA) {
+ var precision = FA === Float32Array ? "single" : "double";
+ var samples = new FA(1);
+ var controls, idx, aNaN;
+
+ for (idx = 0; idx < NaNs.length; ++idx) {
+ aNaN = NaNs[idx]();
+ controls = new FA([aNaN, aNaN, aNaN]);
+
+ samples[0] = aNaN;
- for (idx = 0; idx < distinctNaNs.length; ++idx) {
- someNaN = distinctNaNs[idx];
- control = new FloatArray([someNaN]);
+ for (var i = 0; i < samples.length; i++) {
+ var sample = samples[i];
+ var control = controls[i];
- sample[0] = someNaN;
+ assert(
+ samples[i] !== samples[i],
+ `samples (${NaNs[idx].toString()}) produces a valid NaN (${precision} precision)`
+ );
- sampleBytes = new Uint8Array(sample.buffer);
- controlBytes = new Uint8Array(control.buffer);
- assert(compareArray(sampleBytes, controlBytes), 'NaN value #' + idx);
+ assert(
+ controls[i] !== controls[i],
+ `controls (${NaNs[idx].toString()}) produces a valid NaN (${precision} precision)`
+ );
+ }
}
-}
+}, [Float32Array, Float64Array]);
-testWithTypedArrayConstructors(body, [Float32Array, Float64Array]);
diff --git a/test/built-ins/isNaN/return-true-nan.js b/test/built-ins/isNaN/return-true-nan.js
index 1942f1c81f22a4e5c037b999ffccfd2e9e637e05..d77e4cb5845b1deb1fc8016678ce68a43929773b 100644
--- a/test/built-ins/isNaN/return-true-nan.js
+++ b/test/built-ins/isNaN/return-true-nan.js
@@ -14,6 +14,6 @@ info: |
includes: [nans.js]
---*/
-distinctNaNs.forEach(function(v, i) {
- assert.sameValue(isNaN(v), true, "value on position: " + i);
+NaNs.forEach(function(v, i) {
+ assert.sameValue(isNaN(v()), true, "value on position: " + i);
});
diff --git a/test/harness/nans.js b/test/harness/nans.js
index b228838d05ee28e013aaf66669a99e5ae860e7f5..bd0d7b9bd7ebffb72f7ef3dcba3de3c1b0d7a496 100644
--- a/test/harness/nans.js
+++ b/test/harness/nans.js
@@ -2,17 +2,23 @@
// This code is governed by the BSD license found in the LICENSE file.
/*---
description: >
- Including nans.js will expose:
+ Including nans.js will expose:
- var distinctNaNs = [
- 0/0, Infinity/Infinity, -(0/0), Math.pow(-1, 0.5), -Math.pow(-1, 0.5)
- ];
+ var NaNs = [
+ () => NaN,
+ () => Number.NaN,
+ () => NaN * 0,
+ () => 0/0,
+ () => Infinity/Infinity,
+ () => -(0/0),
+ () => Math.pow(-1, 0.5),
+ () => -Math.pow(-1, 0.5),
+ () => Number("Not-a-Number"),
+ ];
includes: [nans.js]
---*/
-assert.sameValue(Number.isNaN(distinctNaNs[0]), true);
-assert.sameValue(Number.isNaN(distinctNaNs[1]), true);
-assert.sameValue(Number.isNaN(distinctNaNs[2]), true);
-assert.sameValue(Number.isNaN(distinctNaNs[3]), true);
-assert.sameValue(Number.isNaN(distinctNaNs[4]), true);
+for (var i = 0; i < NaNs.length; i++) {
+ assert.sameValue(Number.isNaN(NaNs[i]()), true, NaNs[i].toString());
+}