Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

29 files changed, 1325 insertions, 0 deletions

diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/browser.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/browser.js
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/detached-buffer.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/detached-buffer.js
new file mode 100644
index 0000000000..524f6858e2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/detached-buffer.js
@@ -0,0 +1,67 @@
+// 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-%typedarray%.prototype.subarray
+description: Throws a TypeError creating a new instance with a detached buffer
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  7. Let relativeBegin be ? ToInteger(begin).
+  ...
+  9. If end is undefined, let relativeEnd be srcLength; else, let relativeEnd be
+  ? ToInteger(end).
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  4. Return ? TypedArrayCreate(constructor, argumentList).
+
+  22.2.4.6 TypedArrayCreate ( constructor, argumentList )
+
+  1. Let newTypedArray be ? Construct(constructor, argumentList).
+  ...
+
+  22.2.4.5 TypedArray ( buffer [ , byteOffset [ , length ] ] )
+
+  ...
+  11. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
+  ...
+includes: [testBigIntTypedArray.js, detachArrayBuffer.js]
+features: [BigInt, TypedArray]
+---*/
+
+var begin, end;
+
+var o1 = {
+  valueOf: function() {
+    begin = true;
+    return 0;
+  }
+};
+
+var o2 = {
+  valueOf: function() {
+    end = true;
+    return 2;
+  }
+};
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA(2);
+  begin = false;
+  end = false;
+
+  $DETACHBUFFER(sample.buffer);
+  assert.throws(TypeError, function() {
+    sample.subarray(o1, o2);
+  });
+
+  assert(begin, "observable ToInteger(begin)");
+  assert(end, "observable ToInteger(end)");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/infinity.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/infinity.js
new file mode 100644
index 0000000000..cb1838bc27
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/infinity.js
@@ -0,0 +1,33 @@
+// 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-%typedarray%.prototype.subarray
+description: Infinity values on begin and end
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+includes: [testBigIntTypedArray.js, compareArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+
+  assert(
+    compareArray(sample.subarray(-Infinity), [40n, 41n, 42n, 43n]),
+    "begin == -Infinity"
+  );
+  assert(
+    compareArray(sample.subarray(Infinity), []),
+    "being == Infinity"
+  );
+  assert(
+    compareArray(sample.subarray(0, -Infinity), []),
+    "end == -Infinity"
+  );
+  assert(
+    compareArray(sample.subarray(0, Infinity), [40n, 41n, 42n, 43n]),
+    "end == Infinity"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/minus-zero.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/minus-zero.js
new file mode 100644
index 0000000000..efdf9cca16
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/minus-zero.js
@@ -0,0 +1,33 @@
+// 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-%typedarray%.prototype.subarray
+description: -0 values on begin and end
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+includes: [testBigIntTypedArray.js, compareArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+
+  assert(
+    compareArray(sample.subarray(-0), [40n, 41n, 42n, 43n]),
+    "begin == -0"
+  );
+  assert(
+    compareArray(sample.subarray(-0, 4), [40n, 41n, 42n, 43n]),
+    "being == -0, end == length"
+  );
+  assert(
+    compareArray(sample.subarray(0, -0), []),
+    "being == 0, end == -0"
+  );
+  assert(
+    compareArray(sample.subarray(-0, -0), []),
+    "being == -0, end == -0"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/result-does-not-copy-ordinary-properties.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/result-does-not-copy-ordinary-properties.js
new file mode 100644
index 0000000000..9be1b784d2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/result-does-not-copy-ordinary-properties.js
@@ -0,0 +1,29 @@
+// 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-%typedarray%.prototype.subarray
+description: Subarray result does not import own property
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([41n, 42n, 43n, 44n]);
+  var result;
+
+  sample.foo = 42;
+
+  result = sample.subarray(0);
+  assert.sameValue(
+    result.hasOwnProperty("foo"),
+    false,
+    "does not import own property"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/result-is-new-instance-from-same-ctor.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/result-is-new-instance-from-same-ctor.js
new file mode 100644
index 0000000000..4cefa6fd29
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/result-is-new-instance-from-same-ctor.js
@@ -0,0 +1,33 @@
+// 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-%typedarray%.prototype.subarray
+description: Returns a new instance from the same constructor
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+includes: [testBigIntTypedArray.js, compareArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+  var result = sample.subarray(1);
+
+  assert.sameValue(
+    Object.getPrototypeOf(result),
+    Object.getPrototypeOf(sample),
+    "prototype"
+  );
+  assert.sameValue(result.constructor, sample.constructor, "constructor");
+  assert(result instanceof TA, "instanceof");
+
+  assert(
+    compareArray(sample, [40n, 41n, 42n, 43n]),
+    "original sample remains the same"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/result-is-new-instance-with-shared-buffer.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/result-is-new-instance-with-shared-buffer.js
new file mode 100644
index 0000000000..3b8ea3c331
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/result-is-new-instance-with-shared-buffer.js
@@ -0,0 +1,37 @@
+// 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-%typedarray%.prototype.subarray
+description: Returns a new instance sharing the same buffer
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+includes: [testBigIntTypedArray.js, compareArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+  var buffer = sample.buffer;
+  var result = sample.subarray(1);
+
+  assert.notSameValue(result, sample, "returns a new instance");
+  assert.sameValue(result.buffer, sample.buffer, "shared buffer");
+  assert.sameValue(sample.buffer, buffer, "original buffer is preserved");
+
+  sample[1] = 100n;
+  assert(
+    compareArray(result, [100n, 42n, 43n]),
+    "changes on the original sample values affect the new instance"
+  );
+
+  result[1] = 111n;
+  assert(
+    compareArray(sample, [40n, 100n, 111n, 43n]),
+    "changes on the new instance values affect the original sample"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/results-with-different-length.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/results-with-different-length.js
new file mode 100644
index 0000000000..f4153da597
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/results-with-different-length.js
@@ -0,0 +1,60 @@
+// 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-%typedarray%.prototype.subarray
+description: Subarray may return a new instance with a smaller length
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+includes: [testBigIntTypedArray.js, compareArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+
+  function testRes(result, expected, msg) {
+    assert(compareArray(result, expected), msg + ", result: [" + result + "]");
+  }
+
+  testRes(sample.subarray(1), [41n, 42n, 43n], "begin == 1");
+  testRes(sample.subarray(2), [42n, 43n], "begin == 2");
+  testRes(sample.subarray(3), [43n], "begin == 3");
+
+  testRes(sample.subarray(1, 4), [41n, 42n, 43n], "begin == 1, end == length");
+  testRes(sample.subarray(2, 4), [42n, 43n], "begin == 2, end == length");
+  testRes(sample.subarray(3, 4), [43n], "begin == 3, end == length");
+
+  testRes(sample.subarray(0, 1), [40n], "begin == 0, end == 1");
+  testRes(sample.subarray(0, 2), [40n, 41n], "begin == 0, end == 2");
+  testRes(sample.subarray(0, 3), [40n, 41n, 42n], "begin == 0, end == 3");
+
+  testRes(sample.subarray(-1), [43n], "begin == -1");
+  testRes(sample.subarray(-2), [42n, 43n], "begin == -2");
+  testRes(sample.subarray(-3), [41n, 42n, 43n], "begin == -3");
+
+  testRes(sample.subarray(-1, 4), [43n], "begin == -1, end == length");
+  testRes(sample.subarray(-2, 4), [42n, 43n], "begin == -2, end == length");
+  testRes(sample.subarray(-3, 4), [41n, 42n, 43n], "begin == -3, end == length");
+
+  testRes(sample.subarray(0, -1), [40n, 41n, 42n], "begin == 0, end == -1");
+  testRes(sample.subarray(0, -2), [40n, 41n], "begin == 0, end == -2");
+  testRes(sample.subarray(0, -3), [40n], "begin == 0, end == -3");
+
+  testRes(sample.subarray(-0, -1), [40n, 41n, 42n], "begin == -0, end == -1");
+  testRes(sample.subarray(-0, -2), [40n, 41n], "begin == -0, end == -2");
+  testRes(sample.subarray(-0, -3), [40n], "begin == -0, end == -3");
+
+  testRes(sample.subarray(-2, -1), [42n], "length == 4, begin == -2, end == -1");
+  testRes(sample.subarray(1, -1), [41n, 42n], "length == 4, begin == 1, end == -1");
+  testRes(sample.subarray(1, -2), [41n], "length == 4, begin == 1, end == -2");
+  testRes(sample.subarray(2, -1), [42n], "length == 4, begin == 2, end == -1");
+
+  testRes(sample.subarray(-1, 5), [43n], "begin == -1, end > length");
+  testRes(sample.subarray(-2, 4), [42n, 43n], "begin == -2, end > length");
+  testRes(sample.subarray(-3, 4), [41n, 42n, 43n], "begin == -3, end > length");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/results-with-empty-length.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/results-with-empty-length.js
new file mode 100644
index 0000000000..33a3728bf9
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/results-with-empty-length.js
@@ -0,0 +1,59 @@
+// 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-%typedarray%.prototype.subarray
+description: Subarray may return a new empty instance
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+
+  function testRes(result, msg) {
+    assert.sameValue(result.length, 0, msg);
+    assert.sameValue(
+      result.hasOwnProperty(0),
+      false,
+      msg + " & result.hasOwnProperty(0) === false"
+    );
+  }
+
+  testRes(sample.subarray(4), "begin == length");
+  testRes(sample.subarray(5), "begin > length");
+
+  testRes(sample.subarray(4, 4), "begin == length, end == length");
+  testRes(sample.subarray(5, 4), "begin > length, end == length");
+
+  testRes(sample.subarray(4, 4), "begin == length, end > length");
+  testRes(sample.subarray(5, 4), "begin > length, end > length");
+
+  testRes(sample.subarray(0, 0), "begin == 0, end == 0");
+  testRes(sample.subarray(-0, -0), "begin == -0, end == -0");
+  testRes(sample.subarray(1, 0), "begin > 0, end == 0");
+  testRes(sample.subarray(-1, 0), "being < 0, end == 0");
+
+  testRes(sample.subarray(2, 1), "begin > 0, begin < length, begin > end, end > 0");
+  testRes(sample.subarray(2, 2), "begin > 0, begin < length, begin == end");
+
+  testRes(sample.subarray(2, -2), "begin > 0, begin < length, end == -2");
+
+  testRes(sample.subarray(-1, -1), "length = 4, begin == -1, end == -1");
+  testRes(sample.subarray(-1, -2), "length = 4, begin == -1, end == -2");
+  testRes(sample.subarray(-2, -2), "length = 4, begin == -2, end == -2");
+
+  testRes(sample.subarray(0, -4), "begin == 0, end == -length");
+  testRes(sample.subarray(-4, -4), "begin == -length, end == -length");
+  testRes(sample.subarray(-5, -4), "begin < -length, end == -length");
+
+  testRes(sample.subarray(0, -5), "begin == 0, end < -length");
+  testRes(sample.subarray(-4, -5), "begin == -length, end < -length");
+  testRes(sample.subarray(-5, -5), "begin < -length, end < -length");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/results-with-same-length.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/results-with-same-length.js
new file mode 100644
index 0000000000..a74e0c3be6
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/results-with-same-length.js
@@ -0,0 +1,39 @@
+// 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-%typedarray%.prototype.subarray
+description: Subarray may return a new instance with the same length
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+
+  function testRes(result, msg) {
+    assert.sameValue(result.length, 4, msg);
+    assert.sameValue(result[0], 40n, msg + " & result[0] === 40");
+    assert.sameValue(result[1], 41n, msg + " & result[1] === 41");
+    assert.sameValue(result[2], 42n, msg + " & result[2] === 42");
+    assert.sameValue(result[3], 43n, msg + " & result[3] === 43");
+  }
+
+  testRes(sample.subarray(0), "begin == 0");
+  testRes(sample.subarray(-4), "begin == -srcLength");
+  testRes(sample.subarray(-5), "begin < -srcLength");
+
+  testRes(sample.subarray(0, 4), "begin == 0, end == srcLength");
+  testRes(sample.subarray(-4, 4), "begin == -srcLength, end == srcLength");
+  testRes(sample.subarray(-5, 4), "begin < -srcLength, end == srcLength");
+
+  testRes(sample.subarray(0, 5), "begin == 0, end > srcLength");
+  testRes(sample.subarray(-4, 5), "begin == -srcLength, end > srcLength");
+  testRes(sample.subarray(-5, 5), "begin < -srcLength, end > srcLength");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-begin-symbol.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-begin-symbol.js
new file mode 100644
index 0000000000..83233be119
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-begin-symbol.js
@@ -0,0 +1,26 @@
+// 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-%typedarray%.prototype.subarray
+description: Return abrupt from ToInteger(begin), begin is symbol
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  7. Let relativeBegin be ? ToInteger(begin).
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, Symbol, TypedArray]
+---*/
+
+var s = Symbol("1");
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA();
+
+  assert.throws(TypeError, function() {
+    sample.subarray(s);
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-begin.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-begin.js
new file mode 100644
index 0000000000..0b5d84df83
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-begin.js
@@ -0,0 +1,40 @@
+// 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-%typedarray%.prototype.subarray
+description: Return abrupt from ToInteger(begin)
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  7. Let relativeBegin be ? ToInteger(begin).
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+var o1 = {
+  valueOf: function() {
+    throw new Test262Error();
+  }
+};
+
+var o2 = {
+  toString: function() {
+    throw new Test262Error();
+  }
+};
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA();
+
+  assert.throws(Test262Error, function() {
+    sample.subarray(o1);
+  });
+
+  assert.throws(Test262Error, function() {
+    sample.subarray(o2);
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-end-symbol.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-end-symbol.js
new file mode 100644
index 0000000000..c68e1fbcb6
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-end-symbol.js
@@ -0,0 +1,27 @@
+// 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-%typedarray%.prototype.subarray
+description: Return abrupt from ToInteger(end), end is symbol
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  9. If end is undefined, let relativeEnd be srcLength; else, let relativeEnd
+  be ? ToInteger(end).
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, Symbol, TypedArray]
+---*/
+
+var s = Symbol("1");
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA();
+
+  assert.throws(TypeError, function() {
+    sample.subarray(0, s);
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-end.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-end.js
new file mode 100644
index 0000000000..02ba53cd48
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-end.js
@@ -0,0 +1,41 @@
+// 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-%typedarray%.prototype.subarray
+description: Return abrupt from ToInteger(end)
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  9. If end is undefined, let relativeEnd be srcLength; else, let relativeEnd
+  be ? ToInteger(end).
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+var o1 = {
+  valueOf: function() {
+    throw new Test262Error();
+  }
+};
+
+var o2 = {
+  toString: function() {
+    throw new Test262Error();
+  }
+};
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA();
+
+  assert.throws(Test262Error, function() {
+    sample.subarray(0, o1);
+  });
+
+  assert.throws(Test262Error, function() {
+    sample.subarray(0, o2);
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/shell.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/shell.js
new file mode 100644
index 0000000000..90ee9c114d
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/shell.js
@@ -0,0 +1,42 @@
+// GENERATED, DO NOT EDIT
+// file: testBigIntTypedArray.js
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    Collection of functions used to assert the correctness of BigInt TypedArray objects.
+defines:
+  - TypedArray
+  - testWithBigIntTypedArrayConstructors
+---*/
+
+/**
+ * The %TypedArray% intrinsic constructor function.
+ */
+var TypedArray = Object.getPrototypeOf(Int8Array);
+
+/**
+ * Calls the provided function for every typed array constructor.
+ *
+ * @param {typedArrayConstructorCallback} f - the function to call for each typed array constructor.
+ * @param {Array} selected - An optional Array with filtered typed arrays
+ */
+function testWithBigIntTypedArrayConstructors(f, selected) {
+  /**
+   * Array containing every BigInt typed array constructor.
+   */
+  var constructors = selected || [
+    BigInt64Array,
+    BigUint64Array
+  ];
+
+  for (var i = 0; i < constructors.length; ++i) {
+    var constructor = constructors[i];
+    try {
+      f(constructor);
+    } catch (e) {
+      e.message += " (Testing with " + constructor.name + ".)";
+      throw e;
+    }
+  }
+}
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-abrupt.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-abrupt.js
new file mode 100644
index 0000000000..fadaf446a4
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-abrupt.js
@@ -0,0 +1,42 @@
+// 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-%typedarray%.prototype.subarray
+description: Return abrupt from SpeciesConstructor's get Constructor
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  ...
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  1. Assert: Type(O) is Object.
+  2. Let C be ? Get(O, "constructor").
+  3. If C is undefined, return defaultConstructor.
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+
+  Object.defineProperty(sample, "constructor", {
+    get: function() {
+      throw new Test262Error();
+    }
+  });
+
+  assert.throws(Test262Error, function() {
+    sample.subarray(0);
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-inherited.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-inherited.js
new file mode 100644
index 0000000000..68d4865a46
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-inherited.js
@@ -0,0 +1,63 @@
+// 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-%typedarray%.prototype.subarray
+description: get inherited constructor on SpeciesConstructor
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  ...
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  1. Assert: Type(O) is Object.
+  2. Let C be ? Get(O, "constructor").
+  3. If C is undefined, return defaultConstructor.
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+  var calls = 0;
+  var result;
+
+  Object.defineProperty(TA.prototype, "constructor", {
+    get: function() {
+      calls++;
+    }
+  });
+
+  result = sample.subarray(0);
+
+  assert.sameValue(calls, 1, "called custom ctor get accessor once");
+
+  assert.sameValue(
+    Object.getPrototypeOf(result),
+    Object.getPrototypeOf(sample),
+    "use defaultCtor on an undefined return - getPrototypeOf check"
+  );
+  assert.sameValue(
+    result.constructor,
+    undefined,
+    "used defaultCtor but still checks the inherited .constructor"
+  );
+
+  calls = 6;
+  result.constructor;
+  assert.sameValue(
+    calls,
+    7,
+    "result.constructor triggers the inherited accessor property"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-returns-throws.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-returns-throws.js
new file mode 100644
index 0000000000..07fec8bb54
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-returns-throws.js
@@ -0,0 +1,64 @@
+// 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-%typedarray%.prototype.subarray
+description: >
+  Throws if O.constructor returns a non-Object and non-undefined value
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  ...
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  1. Assert: Type(O) is Object.
+  2. Let C be ? Get(O, "constructor").
+  3. If C is undefined, return defaultConstructor.
+  4. If Type(C) is not Object, throw a TypeError exception.
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, Symbol, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+
+  sample.constructor = 42;
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "42");
+
+  sample.constructor = "1";
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "string");
+
+  sample.constructor = null;
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "null");
+
+  sample.constructor = NaN;
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "NaN");
+
+  sample.constructor = false;
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "false");
+
+  sample.constructor = Symbol("1");
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "symbol");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor.js
new file mode 100644
index 0000000000..3b1687fd77
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor.js
@@ -0,0 +1,55 @@
+// 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-%typedarray%.prototype.subarray
+description: get constructor on SpeciesConstructor
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  ...
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  1. Assert: Type(O) is Object.
+  2. Let C be ? Get(O, "constructor").
+  3. If C is undefined, return defaultConstructor.
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+  var calls = 0;
+  var result;
+
+  Object.defineProperty(sample, "constructor", {
+    get: function() {
+      calls++;
+    }
+  });
+
+  result = sample.subarray(0);
+
+  assert.sameValue(calls, 1, "called custom ctor get accessor once");
+
+  assert.sameValue(
+    Object.getPrototypeOf(result),
+    Object.getPrototypeOf(sample),
+    "use defaultCtor on an undefined return - getPrototypeOf check"
+  );
+  assert.sameValue(
+    result.constructor,
+    TA,
+    "use defaultCtor on an undefined return - .constructor check"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-abrupt.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-abrupt.js
new file mode 100644
index 0000000000..94a903d30e
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-abrupt.js
@@ -0,0 +1,46 @@
+// 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-%typedarray%.prototype.subarray
+description: >
+  Returns abrupt from get @@species on found constructor
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  ...
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  1. Assert: Type(O) is Object.
+  2. Let C be ? Get(O, "constructor").
+  ...
+  5. Let S be ? Get(C, @@species).
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, Symbol.species, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA(2);
+
+  sample.constructor = {};
+
+  Object.defineProperty(sample.constructor, Symbol.species, {
+    get: function() {
+      throw new Test262Error();
+    }
+  });
+
+  assert.throws(Test262Error, function() {
+    sample.subarray(0);
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-invocation.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-invocation.js
new file mode 100644
index 0000000000..5afae1123e
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-invocation.js
@@ -0,0 +1,63 @@
+// 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-%typedarray%.prototype.subarray
+description: >
+  Verify arguments on custom @@species construct call
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  4. Return ? TypedArrayCreate(constructor, argumentList).
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  ...
+  5. Let S be ? Get(C, @@species).
+  ...
+  7. If IsConstructor(S) is true, return S.
+  ...
+
+  22.2.4.6 TypedArrayCreate ( constructor, argumentList )
+
+  1. Let newTypedArray be ? Construct(constructor, argumentList).
+  2. Perform ? ValidateTypedArray(newTypedArray).
+  3. If argumentList is a List of a single Number, then
+    ...
+  4. Return newTypedArray.
+includes: [testBigIntTypedArray.js]
+features: [BigInt, Symbol.species, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n]);
+  var expectedOffset = TA.BYTES_PER_ELEMENT;
+  var result, ctorThis;
+
+  sample.constructor = {};
+  sample.constructor[Symbol.species] = function(buffer, offset, length) {
+    result = arguments;
+    ctorThis = this;
+    return new TA(buffer, offset, length);
+  };
+
+  sample.subarray(1);
+
+  assert.sameValue(result.length, 3, "called with 3 arguments");
+  assert.sameValue(result[0], sample.buffer, "[0] is sample.buffer");
+  assert.sameValue(result[1], expectedOffset, "[1] is the byte offset pos");
+  assert.sameValue(result[2], 2, "[2] is expected length");
+
+  assert(
+    ctorThis instanceof sample.constructor[Symbol.species],
+    "`this` value in the @@species fn is an instance of the function itself"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-returns-another-instance.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-returns-another-instance.js
new file mode 100644
index 0000000000..5ac5a191ce
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-returns-another-instance.js
@@ -0,0 +1,54 @@
+// 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-%typedarray%.prototype.subarray
+description: >
+  Custom @@species constructor may return a totally different TypedArray
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  4. Return ? TypedArrayCreate(constructor, argumentList).
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  ...
+  5. Let S be ? Get(C, @@species).
+  ...
+  7. If IsConstructor(S) is true, return S.
+  ...
+
+  22.2.4.6 TypedArrayCreate ( constructor, argumentList )
+
+  1. Let newTypedArray be ? Construct(constructor, argumentList).
+  2. Perform ? ValidateTypedArray(newTypedArray).
+  3. If argumentList is a List of a single Number, then
+    ...
+  4. Return newTypedArray.
+includes: [testBigIntTypedArray.js, compareArray.js]
+features: [BigInt, Symbol.species, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n]);
+  var other = new BigInt64Array([1n, 0n, 1n]);
+  var result;
+
+  sample.constructor = {};
+  sample.constructor[Symbol.species] = function() {
+    return other;
+  };
+
+  result = sample.subarray(0, 0);
+
+  assert.sameValue(result, other, "returned another typedarray");
+  assert(compareArray(result, [1n, 0n, 1n]), "the returned object is preserved");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-throws.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-throws.js
new file mode 100644
index 0000000000..4350b76916
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-throws.js
@@ -0,0 +1,48 @@
+// 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-%typedarray%.prototype.subarray
+description: >
+  Custom @@species constructor throws if it does not return a compatible object
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  4. Return ? TypedArrayCreate(constructor, argumentList).
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  ...
+  5. Let S be ? Get(C, @@species).
+  ...
+  7. If IsConstructor(S) is true, return S.
+  ...
+
+  22.2.4.6 TypedArrayCreate ( constructor, argumentList )
+
+  1. Let newTypedArray be ? Construct(constructor, argumentList).
+  2. Perform ? ValidateTypedArray(newTypedArray).
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, Symbol.species, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA(2);
+  var ctor = function() {};
+
+  sample.constructor = {};
+  sample.constructor[Symbol.species] = ctor;
+
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor.js
new file mode 100644
index 0000000000..22f9502ae5
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor.js
@@ -0,0 +1,55 @@
+// 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-%typedarray%.prototype.subarray
+description: >
+  Use custom @@species constructor if available
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  4. Return ? TypedArrayCreate(constructor, argumentList).
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  ...
+  5. Let S be ? Get(C, @@species).
+  ...
+  7. If IsConstructor(S) is true, return S.
+  ...
+
+  22.2.4.6 TypedArrayCreate ( constructor, argumentList )
+
+  1. Let newTypedArray be ? Construct(constructor, argumentList).
+  2. Perform ? ValidateTypedArray(newTypedArray).
+  3. If argumentList is a List of a single Number, then
+    ...
+  4. Return newTypedArray.
+includes: [testBigIntTypedArray.js, compareArray.js]
+features: [BigInt, Symbol.species, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n]);
+  var calls = 0;
+  var result;
+
+  sample.constructor = {};
+  sample.constructor[Symbol.species] = function(buffer, offset, length) {
+    calls++;
+    return new TA(buffer, offset, length);
+  };
+
+  result = sample.subarray(1);
+
+  assert.sameValue(calls, 1, "ctor called once");
+  assert(compareArray(result, [41n, 42n]), "expected subarray");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-returns-throws.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-returns-throws.js
new file mode 100644
index 0000000000..d568d39110
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-returns-throws.js
@@ -0,0 +1,67 @@
+// 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-%typedarray%.prototype.subarray
+description: >
+  Throws if returned @@species is not a constructor, null or undefined.
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  ...
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  ...
+  5. Let S be ? Get(C, @@species).
+  6. If S is either undefined or null, return defaultConstructor.
+  7. If IsConstructor(S) is true, return S.
+  8. Throw a TypeError exception.
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, Symbol.species, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA(2);
+
+  sample.constructor = {};
+
+  sample.constructor[Symbol.species] = 0;
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "0");
+
+  sample.constructor[Symbol.species] = "string";
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "string");
+
+  sample.constructor[Symbol.species] = {};
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "{}");
+
+  sample.constructor[Symbol.species] = NaN;
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "NaN");
+
+  sample.constructor[Symbol.species] = false;
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "false");
+
+  sample.constructor[Symbol.species] = true;
+  assert.throws(TypeError, function() {
+    sample.subarray(0);
+  }, "true");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-use-default-ctor.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-use-default-ctor.js
new file mode 100644
index 0000000000..e22fea84ad
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-use-default-ctor.js
@@ -0,0 +1,55 @@
+// 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-%typedarray%.prototype.subarray
+description: >
+  Use defaultConstructor if @@species is either undefined or null
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  ...
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  ...
+  5. Let S be ? Get(C, @@species).
+  6. If S is either undefined or null, return defaultConstructor.
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, Symbol.species, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA(2);
+  var result;
+
+  sample.constructor = {};
+
+  result = sample.subarray(0);
+
+  assert.sameValue(
+    Object.getPrototypeOf(result),
+    Object.getPrototypeOf(sample),
+    "undefined @@species - prototype check "
+  );
+  assert.sameValue(result.constructor, TA, "undefined @@species - ctor check");
+
+  sample.constructor[Symbol.species] = null;
+  result = sample.subarray(0);
+
+  assert.sameValue(
+    Object.getPrototypeOf(result),
+    Object.getPrototypeOf(sample),
+    "null @@species - prototype check "
+  );
+  assert.sameValue(result.constructor, TA, "null @@species - ctor check");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species.js
new file mode 100644
index 0000000000..358a88f259
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species.js
@@ -0,0 +1,47 @@
+// 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-%typedarray%.prototype.subarray
+description: >
+  get @@species from found constructor
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  17. Return ? TypedArraySpeciesCreate(O, argumentsList).
+
+  22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
+
+  ...
+  3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
+  ...
+
+  7.3.20 SpeciesConstructor ( O, defaultConstructor )
+
+  1. Assert: Type(O) is Object.
+  2. Let C be ? Get(O, "constructor").
+  ...
+  5. Let S be ? Get(C, @@species).
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, Symbol.species, TypedArray]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA(2);
+  var calls = 0;
+
+  sample.constructor = {};
+
+  Object.defineProperty(sample.constructor, Symbol.species, {
+    get: function() {
+      calls++;
+    }
+  });
+
+  sample.subarray(0);
+
+  assert.sameValue(calls, 1);
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/tointeger-begin.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/tointeger-begin.js
new file mode 100644
index 0000000000..4fcce8b780
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/tointeger-begin.js
@@ -0,0 +1,50 @@
+// 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-%typedarray%.prototype.subarray
+description: ToInteger(begin)
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  7. Let relativeBegin be ? ToInteger(begin).
+  ...
+includes: [testBigIntTypedArray.js, compareArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+var obj = {
+  valueOf: function() {
+    return 2;
+  }
+};
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+
+  assert(compareArray(sample.subarray(false), [40n, 41n, 42n, 43n]), "false");
+  assert(compareArray(sample.subarray(true), [41n, 42n, 43n]), "true");
+
+  assert(compareArray(sample.subarray(NaN), [40n, 41n, 42n, 43n]), "NaN");
+  assert(compareArray(sample.subarray(null), [40n, 41n, 42n, 43n]), "null");
+  assert(compareArray(sample.subarray(undefined), [40n, 41n, 42n, 43n]), "undefined");
+
+  assert(compareArray(sample.subarray(1.1), [41n, 42n, 43n]), "1.1");
+  assert(compareArray(sample.subarray(1.5), [41n, 42n, 43n]), "1.5");
+  assert(compareArray(sample.subarray(0.6), [40n, 41n, 42n, 43n]), "0.6");
+
+  assert(compareArray(sample.subarray(-1.5), [43n]), "-1.5");
+  assert(compareArray(sample.subarray(-1.1), [43n]), "-1.1");
+  assert(compareArray(sample.subarray(-0.6), [40n, 41n, 42n, 43n]), "-0.6");
+
+  assert(compareArray(sample.subarray("3"), [43n]), "string");
+  assert(
+    compareArray(
+      sample.subarray(obj),
+      [42n, 43n]
+    ),
+    "object"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/tointeger-end.js b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/tointeger-end.js
new file mode 100644
index 0000000000..2e3a74b14a
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/subarray/BigInt/tointeger-end.js
@@ -0,0 +1,50 @@
+// 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-%typedarray%.prototype.subarray
+description: ToInteger(end)
+info: |
+  22.2.3.27 %TypedArray%.prototype.subarray( begin , end )
+
+  ...
+  9. If end is undefined, let relativeEnd be srcLength; else, let relativeEnd be
+  ? ToInteger(end).
+  ...
+includes: [testBigIntTypedArray.js, compareArray.js]
+features: [BigInt, TypedArray]
+---*/
+
+var obj = {
+  valueOf: function() {
+    return 2;
+  }
+};
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([40n, 41n, 42n, 43n]);
+
+  assert(compareArray(sample.subarray(0, false), []), "false");
+  assert(compareArray(sample.subarray(0, true), [40n]), "true");
+
+  assert(compareArray(sample.subarray(0, NaN), []), "NaN");
+  assert(compareArray(sample.subarray(0, null), []), "null");
+  assert(compareArray(sample.subarray(0, undefined), [40n, 41n, 42n, 43n]), "undefined");
+
+  assert(compareArray(sample.subarray(0, 0.6), []), "0.6");
+  assert(compareArray(sample.subarray(0, 1.1), [40n]), "1.1");
+  assert(compareArray(sample.subarray(0, 1.5), [40n]), "1.5");
+  assert(compareArray(sample.subarray(0, -0.6), []), "-0.6");
+  assert(compareArray(sample.subarray(0, -1.1), [40n, 41n, 42n]), "-1.1");
+  assert(compareArray(sample.subarray(0, -1.5), [40n, 41n, 42n]), "-1.5");
+
+  assert(compareArray(sample.subarray(0, "3"), [40n, 41n, 42n]), "string");
+  assert(
+    compareArray(
+      sample.subarray(0, obj),
+      [40n, 41n]
+    ),
+    "object"
+  );
+});
+
+reportCompare(0, 0);