From 9857b124c06e8848d2294ca10c3c27a6e807d625 Mon Sep 17 00:00:00 2001
From: Alexey Shvayka <shvaikalesh@gmail.com>
Date: Sat, 5 Sep 2020 01:16:17 +0300
Subject: [PATCH] Test Array.prototype methods called as top-level functions

---
 .../prototype/methods-called-as-functions.js  | 203 ++++++++++++++++++
 1 file changed, 203 insertions(+)
 create mode 100644 test/built-ins/Array/prototype/methods-called-as-functions.js

diff --git a/test/built-ins/Array/prototype/methods-called-as-functions.js b/test/built-ins/Array/prototype/methods-called-as-functions.js
new file mode 100644
index 0000000000..6d04e33905
--- /dev/null
+++ b/test/built-ins/Array/prototype/methods-called-as-functions.js
@@ -0,0 +1,203 @@
+// Copyright (C) 2020 Alexey Shvayka. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-properties-of-the-array-prototype-object
+description: >
+    Array.prototype methods resolve `this` value using strict mode semantics,
+    throwing TypeError if called as top-level function.
+info: |
+    Array.prototype.concat ( ...items )
+
+    1. Let O be ? ToObject(this value).
+
+    ToObject ( argument )
+
+    Argument Type: Undefined
+    Result: Throw a TypeError exception.
+features: [Symbol, Symbol.isConcatSpreadable, Symbol.iterator, Symbol.species, Array.prototype.flat, Array.prototype.flatMap]
+---*/
+
+["constructor", "length", "0", Symbol.isConcatSpreadable, Symbol.species].forEach(function(key) {
+    Object.defineProperty(this, key, {
+        get: function() {
+            throw new Test262Error(String(key) + " lookup should not be performed");
+        },
+    });
+}, this);
+
+function callback() {
+    throw new Test262Error("callback should not be called");
+}
+
+var index = {
+    get valueOf() {
+        throw new Test262Error("index should not be coerced to number");
+    },
+};
+
+var separator = {
+    get toString() {
+        throw new Test262Error("separator should not be coerced to string");
+    },
+};
+
+var concat = Array.prototype.concat;
+assert.throws(TypeError, function() {
+    concat();
+}, "concat");
+
+var copyWithin = Array.prototype.copyWithin;
+assert.throws(TypeError, function() {
+    copyWithin(index, index);
+}, "copyWithin");
+
+var entries = Array.prototype.entries;
+assert.throws(TypeError, function() {
+    entries();
+}, "entries");
+
+var every = Array.prototype.every;
+assert.throws(TypeError, function() {
+    every(callback);
+}, "every");
+
+var fill = Array.prototype.fill;
+assert.throws(TypeError, function() {
+    fill(0);
+}, "fill");
+
+var filter = Array.prototype.filter;
+assert.throws(TypeError, function() {
+    filter(callback);
+}, "filter");
+
+var find = Array.prototype.find;
+assert.throws(TypeError, function() {
+    find(callback);
+}, "find");
+
+var findIndex = Array.prototype.findIndex;
+assert.throws(TypeError, function() {
+    findIndex(callback);
+}, "findIndex");
+
+var flat = Array.prototype.flat;
+assert.throws(TypeError, function() {
+    flat(index);
+}, "flat");
+
+var flatMap = Array.prototype.flatMap;
+assert.throws(TypeError, function() {
+    flatMap(callback);
+}, "flatMap");
+
+var forEach = Array.prototype.forEach;
+assert.throws(TypeError, function() {
+    forEach(callback);
+}, "forEach");
+
+var includes = Array.prototype.includes;
+assert.throws(TypeError, function() {
+    includes(0, index);
+}, "includes");
+
+var indexOf = Array.prototype.indexOf;
+assert.throws(TypeError, function() {
+    indexOf(0, index);
+}, "indexOf");
+
+var join = Array.prototype.join;
+assert.throws(TypeError, function() {
+    join(separator);
+}, "join");
+
+var keys = Array.prototype.keys;
+assert.throws(TypeError, function() {
+    keys();
+}, "keys");
+
+var lastIndexOf = Array.prototype.lastIndexOf;
+assert.throws(TypeError, function() {
+    lastIndexOf(0, index);
+}, "lastIndexOf");
+
+var map = Array.prototype.map;
+assert.throws(TypeError, function() {
+    map(callback);
+}, "map");
+
+var pop = Array.prototype.pop;
+assert.throws(TypeError, function() {
+    pop();
+}, "pop");
+
+var push = Array.prototype.push;
+assert.throws(TypeError, function() {
+    push();
+}, "push");
+
+var reduce = Array.prototype.reduce;
+assert.throws(TypeError, function() {
+    reduce(callback, 0);
+}, "reduce");
+
+var reduceRight = Array.prototype.reduceRight;
+assert.throws(TypeError, function() {
+    reduceRight(callback, 0);
+}, "reduceRight");
+
+var reverse = Array.prototype.reverse;
+assert.throws(TypeError, function() {
+    reverse();
+}, "reverse");
+
+var shift = Array.prototype.shift;
+assert.throws(TypeError, function() {
+    shift();
+}, "shift");
+
+var slice = Array.prototype.slice;
+assert.throws(TypeError, function() {
+    slice(index, index);
+}, "slice");
+
+var some = Array.prototype.some;
+assert.throws(TypeError, function() {
+    some(callback);
+}, "some");
+
+var sort = Array.prototype.sort;
+assert.throws(TypeError, function() {
+    sort(callback);
+}, "sort");
+
+var splice = Array.prototype.splice;
+assert.throws(TypeError, function() {
+    splice(index, index);
+}, "splice");
+
+var toLocaleString = Array.prototype.toLocaleString;
+assert.throws(TypeError, function() {
+    toLocaleString();
+}, "toLocaleString");
+
+var toString = Array.prototype.toString;
+assert.throws(TypeError, function() {
+    toString();
+}, "toString");
+
+var unshift = Array.prototype.unshift;
+assert.throws(TypeError, function() {
+    unshift();
+}, "unshift");
+
+var values = Array.prototype.values;
+assert.throws(TypeError, function() {
+    values();
+}, "values");
+
+var iterator = Array.prototype[Symbol.iterator];
+assert.throws(TypeError, function() {
+    iterator();
+}, "Symbol.iterator");