diff --git a/harness/typeCoercion.js b/harness/typeCoercion.js
index ed03805d7cfd02612e0bbdf55b1bf7bcd8cdc243..26599d21677a1841fe0f2473cc26d3436d3b30ab 100644
--- a/harness/typeCoercion.js
+++ b/harness/typeCoercion.js
@@ -323,6 +323,24 @@ function testNotCoercibleToString(test) {
testNotCoercibleToPrimitive("string", test);
}
+function testCoercibleToBooleanTrue(test) {
+ test(true);
+ test(1);
+ test("string");
+ test(Symbol("1"));
+ test({});
+}
+
+function testCoercibleToBooleanFalse(test) {
+ test(undefined);
+ test(null);
+ test(false);
+ test(0);
+ test(-0);
+ test(NaN);
+ test("");
+}
+
function testCoercibleToBigIntZero(test) {
function testPrimitiveValue(value) {
test(value);
diff --git a/test/built-ins/DataView/prototype/getBigInt64/detached-buffer-after-toindex-byteoffset.js b/test/built-ins/DataView/prototype/getBigInt64/detached-buffer-after-toindex-byteoffset.js
new file mode 100644
index 0000000000000000000000000000000000000000..163513c7704ed3e123881baa9e7b5a3a0fa2c214
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/detached-buffer-after-toindex-byteoffset.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Detached buffer is only checked after ToIndex(requestIndex)
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 4. Let getIndex be ? ToIndex(requestIndex).
+ ...
+ 6. Let buffer be view.[[ViewedArrayBuffer]].
+ 7. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
+ ...
+includes: [detachArrayBuffer.js]
+features: [DataView, ArrayBuffer, BigInt, arrow-function]
+---*/
+
+var buffer = new ArrayBuffer(8);
+var sample = new DataView(buffer, 0);
+
+$DETACHBUFFER(buffer);
+
+assert.throws(RangeError, () => sample.getBigInt64(Infinity),
+ "DataView access at index Infinity should throw");
+
+assert.throws(RangeError, () => sample.getBigInt64(-1),
+ "DataView access at index -1 should throw");
diff --git a/test/built-ins/DataView/prototype/getBigInt64/detached-buffer-before-outofrange-byteoffset.js b/test/built-ins/DataView/prototype/getBigInt64/detached-buffer-before-outofrange-byteoffset.js
new file mode 100644
index 0000000000000000000000000000000000000000..e2aae643596371193b4da0608fb27140dac6ecc4
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/detached-buffer-before-outofrange-byteoffset.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Detached buffer is checked before out of range byteOffset's value
+info: |
+ 24.2.4.8 DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 6. Let buffer be view.[[ViewedArrayBuffer]].
+ 7. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
+ ...
+ 11. If getIndex + elementSize > viewSize, throw a RangeError exception.
+ ...
+includes: [detachArrayBuffer.js]
+features: [DataView, ArrayBuffer, BigInt, arrow-function]
+---*/
+
+var sample;
+var buffer = new ArrayBuffer(12);
+
+sample = new DataView(buffer, 0);
+
+$DETACHBUFFER(buffer);
+
+assert.throws(TypeError, () => sample.getBigInt64(13),
+ "detached DataView access should throw");
diff --git a/test/built-ins/DataView/prototype/getBigInt64/detached-buffer.js b/test/built-ins/DataView/prototype/getBigInt64/detached-buffer.js
new file mode 100644
index 0000000000000000000000000000000000000000..ed1b5a8c643e23e651ca3165fbeb6db69195ab12
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/detached-buffer.js
@@ -0,0 +1,30 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Throws a TypeError if buffer is detached
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 8. Let buffer be the value of view's [[ViewedArrayBuffer]] internal slot.
+ 9. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
+ ...
+includes: [detachArrayBuffer.js]
+features: [DataView, ArrayBuffer, BigInt, arrow-function]
+---*/
+
+var buffer = new ArrayBuffer(1);
+var sample = new DataView(buffer, 0);
+
+$DETACHBUFFER(buffer);
+assert.throws(TypeError, () => sample.getBigInt64(0),
+ "detached DataView access should throw");
diff --git a/test/built-ins/DataView/prototype/getBigInt64/index-is-out-of-range.js b/test/built-ins/DataView/prototype/getBigInt64/index-is-out-of-range.js
new file mode 100644
index 0000000000000000000000000000000000000000..57e75e8e95121bb8b46c7648bb03756b7947f57b
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/index-is-out-of-range.js
@@ -0,0 +1,75 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Throws a RangeError if getIndex + elementSize > viewSize
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 10. Let viewOffset be the value of view's [[ByteOffset]] internal slot.
+ 11. Let viewSize be the value of view's [[ByteLength]] internal slot.
+ 12. Let elementSize be the Number value of the Element Size value specified in
+ Table 50 for Element Type type.
+ 13. If getIndex + elementSize > viewSize, throw a RangeError exception.
+ ...
+features: [DataView, ArrayBuffer, BigInt, arrow-function]
+---*/
+
+var sample;
+var buffer = new ArrayBuffer(12);
+
+sample = new DataView(buffer, 0);
+
+assert.throws(RangeError, () => sample.getBigInt64(Infinity),
+ "DataView access at index Infinity should throw");
+
+assert.throws(RangeError, () => sample.getBigInt64(13), "13 + 8 > 12");
+
+assert.throws(RangeError, () => sample.getBigInt64(12), "12 + 8 > 12");
+
+assert.throws(RangeError, () => sample.getBigInt64(11), "11 + 8 > 12");
+
+assert.throws(RangeError, () => sample.getBigInt64(10), "10 + 8 > 12");
+
+assert.throws(RangeError, () => sample.getBigInt64(9), "9 + 8 > 12");
+
+assert.throws(RangeError, () => sample.getBigInt64(8), "8 + 8 > 12");
+
+assert.throws(RangeError, () => sample.getBigInt64(7), "7 + 8 > 12");
+
+assert.throws(RangeError, () => sample.getBigInt64(6), "6 + 8 > 12");
+
+assert.throws(RangeError, () => sample.getBigInt64(5), "5 + 8 > 12");
+
+sample = new DataView(buffer, 8);
+assert.throws(RangeError, () => sample.getBigInt64(1),
+ "1 + 8 > 4 (offset)");
+
+sample = new DataView(buffer, 9);
+assert.throws(RangeError, () => sample.getBigInt64(0),
+ "0 + 8 > 3 (offset)");
+
+sample = new DataView(buffer, 0, 8);
+assert.throws(RangeError, () => sample.getBigInt64(1),
+ "1 + 8 > 8 (length)");
+
+sample = new DataView(buffer, 0, 7);
+assert.throws(RangeError, () => sample.getBigInt64(0),
+ "0 + 8 > 7 (length)");
+
+sample = new DataView(buffer, 4, 8);
+assert.throws(RangeError, () => sample.getBigInt64(1),
+ "1 + 8 > 8 (offset+length)");
+
+sample = new DataView(buffer, 4, 7);
+assert.throws(RangeError, () => sample.getBigInt64(0),
+ "0 + 8 > 7 (offset+length)");
diff --git a/test/built-ins/DataView/prototype/getBigInt64/length.js b/test/built-ins/DataView/prototype/getBigInt64/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..91e07c8345eca33e14c63a55e1e5bbe2399e2124
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/length.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: DataView.prototype.getBigInt64.length property descriptor
+info: >
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 17 ECMAScript Standard Built-in Objects
+
+ Every built-in function object, including constructors, has a length
+ property whose value is an integer. Unless otherwise specified, this
+ value is equal to the largest number of named arguments shown in the
+ subclause headings for the function description. Optional parameters
+ (which are indicated with brackets: [ ]) or rest parameters (which
+ are shown using the form «...name») are not included in the default
+ argument count.
+
+ Unless otherwise specified, the length property of a built-in
+ function object has the attributes { [[Writable]]: false,
+ [[Enumerable]]: false, [[Configurable]]: true }.
+includes: [propertyHelper.js]
+features: [DataView, ArrayBuffer, BigInt]
+---*/
+
+verifyProperty(DataView.prototype.getBigInt64, "length", {
+ value: 1,
+ writable: false,
+ enumerable: false,
+ configurable: true
+});
diff --git a/test/built-ins/DataView/prototype/getBigInt64/name.js b/test/built-ins/DataView/prototype/getBigInt64/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..800dfaed3523e691525b75b3e287dda7c1dcfa67
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/name.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: DataView.prototype.getBigInt64.name property descriptor
+info: >
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 17 ECMAScript Standard Built-in Objects
+
+ Every built-in function object, including constructors, that is not
+ identified as an anonymous function has a name property whose value
+ is a String. Unless otherwise specified, this value is the name that
+ is given to the function in this specification. For functions that
+ are specified as properties of objects, the name value is the
+ property name string used to access the function. [...]
+
+ Unless otherwise specified, the name property of a built-in function
+ object, if it exists, has the attributes { [[Writable]]: false,
+ [[Enumerable]]: false, [[Configurable]]: true }.
+includes: [propertyHelper.js]
+features: [DataView, ArrayBuffer, BigInt]
+---*/
+
+verifyProperty(DataView.prototype.getBigInt64, "name", {
+ value: "getBigInt64",
+ writable: false,
+ enumerable: false,
+ configurable: true
+});
diff --git a/test/built-ins/DataView/prototype/getBigInt64/negative-byteoffset-throws.js b/test/built-ins/DataView/prototype/getBigInt64/negative-byteoffset-throws.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb466a69d18661a0374042fc0f38ce0b9eb0b8f5
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/negative-byteoffset-throws.js
@@ -0,0 +1,30 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Throws a RangeError if getIndex < 0
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 4. Let getIndex be ? ToIndex(requestIndex).
+ ...
+features: [DataView, ArrayBuffer, BigInt, arrow-function]
+---*/
+
+var buffer = new ArrayBuffer(12);
+var sample = new DataView(buffer, 0);
+
+assert.throws(RangeError, () => sample.getBigInt64(-1),
+ "DataView access at index -1 should throw");
+
+assert.throws(RangeError, () => sample.getBigInt64(-Infinity),
+ "DataView access at index -Infinity should throw");
diff --git a/test/built-ins/DataView/prototype/getBigInt64/return-abrupt-from-tonumber-byteoffset-symbol.js b/test/built-ins/DataView/prototype/getBigInt64/return-abrupt-from-tonumber-byteoffset-symbol.js
new file mode 100644
index 0000000000000000000000000000000000000000..b0aaa8f4870f56963721b3caae09e3b6850b5c9e
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/return-abrupt-from-tonumber-byteoffset-symbol.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Return abrupt from ToNumber(symbol byteOffset)
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 4. Let getIndex be ? ToNumber(requestIndex).
+ ...
+features: [DataView, ArrayBuffer, Symbol, BigInt, arrow-function]
+---*/
+
+var buffer = new ArrayBuffer(1);
+var sample = new DataView(buffer, 0);
+
+var s = Symbol("1");
+
+assert.throws(TypeError, () => sample.getBigInt64(s));
diff --git a/test/built-ins/DataView/prototype/getBigInt64/return-abrupt-from-tonumber-byteoffset.js b/test/built-ins/DataView/prototype/getBigInt64/return-abrupt-from-tonumber-byteoffset.js
new file mode 100644
index 0000000000000000000000000000000000000000..51a723d82ed9fd93378b605d87106f7b951fdbf7
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/return-abrupt-from-tonumber-byteoffset.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Return abrupt from ToNumber(byteOffset)
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 4. Let getIndex be ? ToNumber(requestIndex).
+ ...
+features: [DataView, ArrayBuffer, BigInt, arrow-function]
+---*/
+
+var buffer = new ArrayBuffer(1);
+var sample = new DataView(buffer, 0);
+
+var bo1 = { valueOf() { throw new Test262Error(); } };
+var bo2 = { toString() { throw new Test262Error(); } };
+
+assert.throws(Test262Error, () => sample.getBigInt64(bo1), "valueOf");
+
+assert.throws(Test262Error, () => sample.getBigInt64(bo2), "toString");
diff --git a/test/built-ins/DataView/prototype/getBigInt64/return-value-clean-arraybuffer.js b/test/built-ins/DataView/prototype/getBigInt64/return-value-clean-arraybuffer.js
new file mode 100644
index 0000000000000000000000000000000000000000..ceb13110417173da595835fc818e6dbda38f5476
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/return-value-clean-arraybuffer.js
@@ -0,0 +1,48 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Return value from Buffer using a clean ArrayBuffer
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 12. Let bufferIndex be getIndex + viewOffset.
+ 13. Return GetValueFromBuffer(buffer, bufferIndex, type, false,
+ "Unordered", isLittleEndian).
+
+ 24.1.1.6 GetValueFromBuffer ( arrayBuffer, byteIndex, type,
+ isTypedArray, order [ , isLittleEndian ] )
+
+ ...
+ 9. Return RawBytesToNumber(type, rawValue, isLittleEndian).
+
+ 24.1.1.5 RawBytesToNumber( type, rawBytes, isLittleEndian )
+
+ ...
+ 2. If isLittleEndian is false, reverse the order of the elements of rawBytes.
+ ...
+features: [DataView, ArrayBuffer, BigInt]
+---*/
+
+var buffer = new ArrayBuffer(12);
+var sample = new DataView(buffer, 0);
+
+assert.sameValue(sample.getBigInt64(0, true), 0n, "sample.getBigInt64(0, true)");
+assert.sameValue(sample.getBigInt64(1, true), 0n, "sample.getBigInt64(1, true)");
+assert.sameValue(sample.getBigInt64(2, true), 0n, "sample.getBigInt64(2, true)");
+assert.sameValue(sample.getBigInt64(3, true), 0n, "sample.getBigInt64(3, true)");
+assert.sameValue(sample.getBigInt64(4, true), 0n, "sample.getBigInt64(4, true)");
+assert.sameValue(sample.getBigInt64(0, false), 0n, "sample.getBigInt64(0, false)");
+assert.sameValue(sample.getBigInt64(1, false), 0n, "sample.getBigInt64(1, false)");
+assert.sameValue(sample.getBigInt64(2, false), 0n, "sample.getBigInt64(2, false)");
+assert.sameValue(sample.getBigInt64(3, false), 0n, "sample.getBigInt64(3, false)");
+assert.sameValue(sample.getBigInt64(4, false), 0n, "sample.getBigInt64(4, false)");
diff --git a/test/built-ins/DataView/prototype/getBigInt64/return-values-custom-offset.js b/test/built-ins/DataView/prototype/getBigInt64/return-values-custom-offset.js
new file mode 100644
index 0000000000000000000000000000000000000000..daa5790ae903a15603ebbafe9623de0de4301c5f
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/return-values-custom-offset.js
@@ -0,0 +1,68 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Return values from Buffer using a custom offset
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 12. Let bufferIndex be getIndex + viewOffset.
+ 13. Return GetValueFromBuffer(buffer, bufferIndex, type, false,
+ "Unordered", isLittleEndian).
+
+ 24.1.1.6 GetValueFromBuffer ( arrayBuffer, byteIndex, type,
+ isTypedArray, order [ , isLittleEndian ] )
+
+ ...
+ 9. Return RawBytesToNumber(type, rawValue, isLittleEndian).
+
+ 24.1.1.5 RawBytesToNumber( type, rawBytes, isLittleEndian )
+
+ ...
+ 2. If isLittleEndian is false, reverse the order of the elements of rawBytes.
+ ...
+features: [DataView, ArrayBuffer, DataView.prototype.setUint8, BigInt]
+---*/
+
+var buffer = new ArrayBuffer(16);
+var sample = new DataView(buffer, 0);
+
+sample.setUint8(0, 0x27);
+sample.setUint8(1, 0x02);
+sample.setUint8(2, 0x06);
+sample.setUint8(3, 0x02);
+sample.setUint8(4, 0x80);
+sample.setUint8(5, 0x00);
+sample.setUint8(6, 0x80);
+sample.setUint8(7, 0x01);
+sample.setUint8(8, 0x7f);
+sample.setUint8(9, 0x00);
+sample.setUint8(10, 0x01);
+sample.setUint8(11, 0x02);
+sample.setUint8(12, 0x80);
+sample.setUint8(13, 0x7f);
+sample.setUint8(14, 0xff);
+sample.setUint8(15, 0x80);
+
+sample = new DataView(buffer, 4);
+
+assert.sameValue(sample.getBigInt64(0, false), -0x7fff7ffe80fffefen, "0, false");
+assert.sameValue(sample.getBigInt64(1, false), 0x80017f00010280n, "1, false");
+assert.sameValue(sample.getBigInt64(2, false), -0x7ffe80fffefd7f81n, "2, false");
+assert.sameValue(sample.getBigInt64(3, false), 0x17f000102807fffn, "3, false");
+assert.sameValue(sample.getBigInt64(4, false), 0x7f000102807fff80n, "4, false");
+
+assert.sameValue(sample.getBigInt64(0, true), 0x201007f01800080n, "0, true");
+assert.sameValue(sample.getBigInt64(1, true), -0x7ffdfeff80fe8000n, "1, true");
+assert.sameValue(sample.getBigInt64(2, true), 0x7f800201007f0180n, "2, true");
+assert.sameValue(sample.getBigInt64(3, true), -0x807ffdfeff80ffn, "3, true");
+assert.sameValue(sample.getBigInt64(4, true), -0x7f00807ffdfeff81n, "4, true");
diff --git a/test/built-ins/DataView/prototype/getBigInt64/return-values.js b/test/built-ins/DataView/prototype/getBigInt64/return-values.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9b6fdd836c741b2b77b65b2caca8e018a1b17f3
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/return-values.js
@@ -0,0 +1,69 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Return values from Buffer
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 14. Let bufferIndex be getIndex + viewOffset.
+ 15. Return GetValueFromBuffer(buffer, bufferIndex, type, isLittleEndian).
+ ...
+
+ 24.1.1.6 GetValueFromBuffer ( arrayBuffer, byteIndex, type [ , isLittleEndian
+ ] )
+
+ ...
+ 8. If isLittleEndian is false, reverse the order of the elements of rawValue.
+ ...
+features: [DataView, ArrayBuffer, DataView.prototype.setUint8, BigInt]
+---*/
+
+var buffer = new ArrayBuffer(16);
+var sample = new DataView(buffer, 0);
+
+sample.setUint8(0, 0x27);
+sample.setUint8(1, 0x02);
+sample.setUint8(2, 0x06);
+sample.setUint8(3, 0x02);
+sample.setUint8(4, 0x80);
+sample.setUint8(5, 0x00);
+sample.setUint8(6, 0x80);
+sample.setUint8(7, 0x01);
+sample.setUint8(8, 0x7f);
+sample.setUint8(9, 0x00);
+sample.setUint8(10, 0x01);
+sample.setUint8(11, 0x02);
+sample.setUint8(12, 0x80);
+sample.setUint8(13, 0x7f);
+sample.setUint8(14, 0xff);
+sample.setUint8(15, 0x80);
+
+assert.sameValue(sample.getBigInt64(0, false), 0x2702060280008001n, "0, false");
+assert.sameValue(sample.getBigInt64(1, false), 0x20602800080017fn, "1, false");
+assert.sameValue(sample.getBigInt64(2, false), 0x602800080017f00n, "2, false");
+assert.sameValue(sample.getBigInt64(3, false), 0x2800080017f0001n, "3, false");
+assert.sameValue(sample.getBigInt64(4, false), -0x7fff7ffe80fffefen, "4, false");
+assert.sameValue(sample.getBigInt64(5, false), 0x80017f00010280n, "5, false");
+assert.sameValue(sample.getBigInt64(6, false), -0x7ffe80fffefd7f81n, "6, false");
+assert.sameValue(sample.getBigInt64(7, false), 0x17f000102807fffn, "7, false");
+assert.sameValue(sample.getBigInt64(8, false), 0x7f000102807fff80n, "8, false");
+
+assert.sameValue(sample.getBigInt64(0, true), 0x180008002060227n, "0, true");
+assert.sameValue(sample.getBigInt64(1, true), 0x7f01800080020602n, "1, true");
+assert.sameValue(sample.getBigInt64(2, true), 0x7f018000800206n, "2, true");
+assert.sameValue(sample.getBigInt64(3, true), 0x1007f0180008002n, "3, true");
+assert.sameValue(sample.getBigInt64(4, true), 0x201007f01800080n, "4, true");
+assert.sameValue(sample.getBigInt64(5, true), -0x7ffdfeff80fe8000n, "5, true");
+assert.sameValue(sample.getBigInt64(6, true), 0x7f800201007f0180n, "6, true");
+assert.sameValue(sample.getBigInt64(7, true), -0x807ffdfeff80ffn, "7, true");
+assert.sameValue(sample.getBigInt64(8, true), -0x7f00807ffdfeff81n, "8, true");
diff --git a/test/built-ins/DataView/prototype/getBigInt64/this-has-no-dataview-internal.js b/test/built-ins/DataView/prototype/getBigInt64/this-has-no-dataview-internal.js
new file mode 100644
index 0000000000000000000000000000000000000000..b55215f6444dcfc8b3ff9e20daacfe0b3aec658b
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/this-has-no-dataview-internal.js
@@ -0,0 +1,34 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Throws a TypeError if this does not have a [[DataView]] internal slot
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ 1. If Type(view) is not Object, throw a TypeError exception.
+ 2. If view does not have a [[DataView]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [DataView, ArrayBuffer, Int8Array, BigInt, arrow-function]
+---*/
+
+var getBigInt64 = DataView.prototype.getBigInt64;
+
+assert.throws(TypeError, () => getBigInt64.call({}), "{}");
+
+assert.throws(TypeError, () => getBigInt64.call([]), "[]");
+
+var ab = new ArrayBuffer(1);
+assert.throws(TypeError, () => getBigInt64.call(ab), "ArrayBuffer");
+
+var ta = new Int8Array();
+assert.throws(TypeError, () => getBigInt64.call(ta), "TypedArray");
diff --git a/test/built-ins/DataView/prototype/getBigInt64/this-is-not-object.js b/test/built-ins/DataView/prototype/getBigInt64/this-is-not-object.js
new file mode 100644
index 0000000000000000000000000000000000000000..1dad1108dd90453901f77ad1f9591b28e49d71cd
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/this-is-not-object.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: Throws a TypeError if this is not Object
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ 1. If Type(view) is not Object, throw a TypeError exception.
+ ...
+features: [DataView, ArrayBuffer, Symbol, BigInt, arrow-function]
+---*/
+
+var getBigInt64 = DataView.prototype.getBigInt64;
+
+assert.throws(TypeError, () => getBigInt64.call(undefined),
+ "undefined");
+
+assert.throws(TypeError, () => getBigInt64.call(null), "null");
+
+assert.throws(TypeError, () => getBigInt64.call(1), "1");
+
+assert.throws(TypeError, () => getBigInt64.call("string"), "string");
+
+assert.throws(TypeError, () => getBigInt64.call(true), "true");
+
+assert.throws(TypeError, () => getBigInt64.call(false), "false");
+
+var s = Symbol("1");
+assert.throws(TypeError, () => getBigInt64.call(s), "symbol");
diff --git a/test/built-ins/DataView/prototype/getBigInt64/to-boolean-littleendian.js b/test/built-ins/DataView/prototype/getBigInt64/to-boolean-littleendian.js
new file mode 100644
index 0000000000000000000000000000000000000000..a84e42e1c509c29682d63c9f18a6e3b9dc8b8960
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/to-boolean-littleendian.js
@@ -0,0 +1,53 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ Boolean littleEndian argument coerced in ToBoolean
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 5. Set isLittleEndian to ToBoolean(isLittleEndian).
+ ...
+ 12. Let bufferIndex be getIndex + viewOffset.
+ 13. Return GetValueFromBuffer(buffer, bufferIndex, type, false,
+ "Unordered", isLittleEndian).
+
+ 24.1.1.6 GetValueFromBuffer ( arrayBuffer, byteIndex, type,
+ isTypedArray, order [ , isLittleEndian ] )
+
+ ...
+ 9. Return RawBytesToNumber(type, rawValue, isLittleEndian).
+
+ 24.1.1.5 RawBytesToNumber( type, rawBytes, isLittleEndian )
+
+ ...
+ 2. If isLittleEndian is false, reverse the order of the elements of rawBytes.
+ ...
+includes: [typeCoercion.js]
+features: [DataView, ArrayBuffer, DataView.prototype.setUint8, BigInt, Symbol, Symbol.toPrimitive]
+---*/
+
+var buffer = new ArrayBuffer(8);
+var sample = new DataView(buffer, 0);
+
+sample.setUint8(7, 0xff);
+
+// False
+assert.sameValue(sample.getBigInt64(0), 0xffn, "no argument");
+testCoercibleToBooleanFalse(function (x) {
+ assert.sameValue(sample.getBigInt64(0, x), 0xffn);
+});
+
+// True
+testCoercibleToBooleanTrue(function (x) {
+ assert.sameValue(sample.getBigInt64(0, x), -0x100000000000000n);
+});
diff --git a/test/built-ins/DataView/prototype/getBigInt64/toindex-byteoffset.js b/test/built-ins/DataView/prototype/getBigInt64/toindex-byteoffset.js
new file mode 100644
index 0000000000000000000000000000000000000000..11b5cd93152a0075473da42fce6a251c28fb05a9
--- /dev/null
+++ b/test/built-ins/DataView/prototype/getBigInt64/toindex-byteoffset.js
@@ -0,0 +1,54 @@
+// Copyright (C) 2017 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-dataview.prototype.getbigint64
+description: >
+ ToIndex conversions on byteOffset
+info: |
+ DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] )
+
+ 1. Let v be the this value.
+ 2. If littleEndian is not present, let littleEndian be undefined.
+ 3. Return ? GetViewValue(v, byteOffset, littleEndian, "Int64").
+
+ 24.3.1.1 GetViewValue ( view, requestIndex, isLittleEndian, type )
+
+ ...
+ 4. Let getIndex be ? ToIndex(requestIndex).
+ ...
+includes: [typeCoercion.js]
+features: [DataView, ArrayBuffer, DataView.prototype.setUint8, BigInt, Symbol, Symbol.toPrimitive]
+---*/
+
+var buffer = new ArrayBuffer(12);
+var sample = new DataView(buffer, 0);
+
+sample.setUint8(0, 0x27);
+sample.setUint8(1, 0x02);
+sample.setUint8(2, 0x06);
+sample.setUint8(3, 0x02);
+sample.setUint8(4, 0x80);
+sample.setUint8(5, 0x00);
+sample.setUint8(6, 0x80);
+sample.setUint8(7, 0x01);
+sample.setUint8(8, 0x7f);
+sample.setUint8(9, 0x00);
+sample.setUint8(10, 0x01);
+sample.setUint8(11, 0x02);
+
+testCoercibleToIndexZero(function (x) {
+ assert.sameValue(sample.getBigInt64(x), 0x2702060280008001n);
+});
+
+testCoercibleToIndexOne(function (x) {
+ assert.sameValue(sample.getBigInt64(x), 0x20602800080017fn);
+});
+
+testCoercibleToIndexFromIndex(2, function (x) {
+ assert.sameValue(sample.getBigInt64(x), 0x602800080017F00n);
+});
+
+testCoercibleToIndexFromIndex(3, function (x) {
+ assert.sameValue(sample.getBigInt64(x), 0x2800080017F0001n);
+});