diff options
Diffstat (limited to 'js/src/tests/test262/built-ins/Array/prototype/methods-called-as-functions.js')
-rw-r--r-- | js/src/tests/test262/built-ins/Array/prototype/methods-called-as-functions.js | 205 |
1 files changed, 205 insertions, 0 deletions
diff --git a/js/src/tests/test262/built-ins/Array/prototype/methods-called-as-functions.js b/js/src/tests/test262/built-ins/Array/prototype/methods-called-as-functions.js new file mode 100644 index 0000000000..7130ad549d --- /dev/null +++ b/js/src/tests/test262/built-ins/Array/prototype/methods-called-as-functions.js @@ -0,0 +1,205 @@ +// 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, Array.prototype.includes] +---*/ + +["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"); + +reportCompare(0, 0); |