%TypedArray%.prototype.indexOf is coercing non-integers or non-floats to numbers...
[WebKit-https.git] / Source / JavaScriptCore / tests / stress / typedarray-functions-with-neutered.js
1 typedArrays = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
2
3 proto = Int8Array.prototype.__proto__;
4
5 function getGetter(prop) {
6     return Object.getOwnPropertyDescriptor(proto, prop).get;
7 }
8
9 function unit() { }
10
11
12 prototypeFunctions = [
13     { func:getGetter("length"), args:[], result:0 },
14     { func:getGetter("byteLength"), args:[], result:0 },
15     { func:getGetter("byteOffset"), args:[], result:0 },
16     { func:proto.copyWithin, args:[0, 1] },
17     { func:proto.entries, args:[] },
18     { func:proto.every, args:[unit] },
19     { func:proto.every, args:[1] },
20     { func:proto.filter, args:[unit] },
21     { func:proto.find, args:[] },
22     { func:proto.findIndex, args:[] },
23     { func:proto.forEach, args:[] },
24     { func:proto.indexOf, args:[] },
25     { func:proto.join, args:[] },
26     { func:proto.keys, args:[] },
27     { func:proto.lastIndexOf, args:[] },
28     { func:proto.map, args:[] },
29     { func:proto.reduce, args:[] },
30     { func:proto.reduceRight, args:[] },
31     { func:proto.reverse, args:[] },
32     { func:proto.set, args:[[]] },
33     { func:proto.set, args:[new Int32Array(1)] },
34     { func:proto.set, args:[new Int32Array(1)] },
35     { func:proto.set, args:[new Int32Array(1), -1], error:"RangeError: Offset should not be negative" },
36     { func:proto.slice, args:[] },
37     { func:proto.some, args:[] },
38     { func:proto.sort, args:[] },
39     { func:proto.subarray, args:[] },
40     { func:proto.toString, args:[] },
41     { func:proto.values, args:[] },
42 ];
43
44 arrays = typedArrays.map(function(constructor) {
45     let view = new constructor(10);
46     transferArrayBuffer(view.buffer);
47     return view;
48 });
49
50 function checkProtoFunc(testArgs) {
51     function throwsCorrectError(elem) {
52         try {
53             result = testArgs.func.call(...[elem, ...testArgs.args]);
54             if (testArgs.result !== undefined) {
55                 return result === testArgs.result;
56             }
57         } catch (e) {
58             if (testArgs.error)
59                 return e == testArgs.error;
60             return e == "TypeError: Underlying ArrayBuffer has been detached from the view";
61         }
62         return false;
63     }
64
65     if (!arrays.every(throwsCorrectError))
66         throw "bad" + testArgs.func.name;
67 }
68
69 function test() {
70     prototypeFunctions.forEach(checkProtoFunc);
71 }
72
73 for (var i = 0; i < 1000; i++)
74     test();
75
76 // Test that we handle neutering for any toInteger neutering the arraybuffer.
77 prototypeFunctions = [
78     { func:proto.copyWithin, args:["prim", "prim", "prim"] },
79     { func:proto.every, args:["func"] },
80     { func:proto.fill, args:["prim", "prim", "prim"] },
81     { func:proto.filter, args:["func"] },
82     { func:proto.find, args:["func"] },
83     { func:proto.findIndex, args:["func"] },
84     { func:proto.forEach, args:["func"] },
85     { func:proto.indexOf, args:["na", "prim"] },
86     { func:proto.includes, args:["na", "prim"] },
87     { func:proto.join, args:["prim"] },
88     { func:proto.lastIndexOf, args:["na", "prim"] },
89     { func:proto.map, args:["func"] },
90     { func:proto.reduce, args:["func"] },
91     { func:proto.reduceRight, args:["func"] },
92     { func:proto.set, args:["array", "prim"] },
93     { func:proto.slice, args:["prim", "prim"] },
94     { func:proto.some, args:["func"] },
95     { func:proto.sort, args:["func"] },
96     { func:proto.subarray, args:["prim", "prim"] },
97 ];
98
99 function defaultForArg(arg, argNum)
100 {
101     if (arg === "func")
102         return () => { return argNum; }
103     if (arg === "array")
104         return [1,2];
105
106     return argNum;
107 }
108
109 function callWithArgs(func, array, args, argNum) {
110     let failed = true;
111     try {
112         func.call(array, ...args);
113     } catch (e) {
114         if (e != "TypeError: Underlying ArrayBuffer has been detached from the view")
115             throw new Error(e);
116         failed = false;
117     }
118     if (failed)
119         throw new Error([func, argNum]);
120 }
121
122
123 function checkArgumentsForType(func, args, constructor) {
124     let defaultArgs = args.map(defaultForArg);
125
126     for (let argNum = 0; argNum < args.length; argNum++) {
127         let arg = args[argNum];
128         let callArgs = defaultArgs.slice();
129
130         if (arg === "na")
131             continue;
132
133         let array = new constructor(10);
134         if (arg === "func") {
135             callArgs[argNum] = () => {
136                 transferArrayBuffer(array.buffer);
137                 return func === array.every ? 1 : 0;
138             };
139             callWithArgs(func, array, callArgs, argNum);
140         } else if (arg === "prim") {
141             callArgs[argNum] = { [Symbol.toPrimitive]() {
142                 transferArrayBuffer(array.buffer);
143                 return argNum;
144             } };
145             callWithArgs(func, array, callArgs, argNum);
146         } else if (arg === "array") {
147             callArgs[argNum] = new Array(4);
148             callArgs[argNum].fill(2);
149             let desc = { get: () => {
150                 transferArrayBuffer(array.buffer);
151                 return 1;
152             } };
153             Object.defineProperty(callArgs[argNum], 1, desc);
154             callWithArgs(func, array, callArgs, argNum);
155         } else
156             throw new Error(arg);
157     }
158 }
159
160 function checkArguments({func, args}) {
161     for (constructor of typedArrays)
162         checkArgumentsForType(func, args, constructor);
163 }
164
165 function test2() {
166     prototypeFunctions.forEach(checkArguments);
167 }
168
169 test2();