Google Git
Sign in
webkit / WebKit / 823b24db02cef0fb4f6c41ebda26693fab222517 / . / Source / JavaScriptCore / tests / stress / proxy-call.js
blob: b3b5eff841154e9b1d5781ce08b9fe5f48735841 [file] [log] [blame]
sbarati@apple.com62d6d112016-02-19 22:56:31 +0000[diff] [blame]1function assert(b) {
2 if (!b)
3 throw new Error("Bad assertion");
4}
5
6{
7 let target = function foo(...args) {
8 assert(args[0] === 10);
9 assert(args[1] === 20);
10 return "foo";
11 }
12 let handler = {
13 apply: function(theTarget, thisArg, argArray) {
14 assert(theTarget === target);
15 assert(argArray[0] === 10);
16 assert(argArray[1] === 20);
17 return theTarget.apply(thisArg, argArray);
18 }
19 };
20 let proxy = new Proxy(target, handler);
21 for (let i = 0; i < 500; i++) {
22 assert(proxy(10, 20) === "foo");
23 }
24}
25
26{
27 let target = function foo() { }
28 let error = null;
29 let handler = {
30 get apply() {
31 error = new Error();
32 throw error;
33 }
34 };
35 let proxy = new Proxy(target, handler);
36 for (let i = 0; i < 500; i++) {
37 let threw = false;
38 try {
39 proxy(10, 20);
40 } catch(e) {
41 assert(e === error);
42 threw = true;
43 }
44 assert(threw);
45 }
46}
47
48{
49 let called = false;
50 let globalThis = this;
51 let target = function foo() {
52 assert(this === globalThis);
53 called = true;
54 }
55 let handler = {
56 apply: null
57 };
58
59 let proxy = new Proxy(target, handler);
60 for (let i = 0; i < 500; i++) {
61 proxy();
62 assert(called);
63 called = false;
64 }
65}
66
67{
68 let called = false;
69 let globalThis = this;
70 let target = function foo() {
71 assert(this === globalThis);
72 called = true;
73 }
74 let handler = {
75 apply: undefined
76 };
77
78 let proxy = new Proxy(target, handler);
79 for (let i = 0; i < 500; i++) {
80 proxy();
81 assert(called);
82 called = false;
83 }
84}
85
86{
87 let called = false;
88 let thisValue = {};
89 let target = function foo(x, y, z) {
90 assert(this === thisValue);
91 assert(x === 20);
92 assert(y === 45);
93 assert(z === "foo");
94 called = true;
95 }
96
97 let handler = {
98 apply: undefined
99 };
100
101 let proxy = new Proxy(target, handler);
102 for (let i = 0; i < 500; i++) {
103 proxy.call(thisValue, 20, 45, "foo");
104 assert(called);
105 called = false;
106 proxy.apply(thisValue, [20, 45, "foo"]);
107 assert(called);
108 called = false;
109 }
110}
111
112{
113 let called = false;
114 let thisValue = {};
115 let target = function foo(x, y, z) {
116 assert(this === thisValue);
117 assert(x === 20);
118 assert(y === 45);
119 assert(z === "foo");
120 called = true;
121 return this;
122 }
123
124 let handler = {
125 apply: function(theTarget, thisArg, argArray) {
126 assert(theTarget === target);
127 assert(argArray[0] === 20);
128 assert(argArray[1] === 45);
129 assert(argArray[2] === "foo");
130 assert(thisArg === thisValue);
131 return theTarget.apply(thisArg, argArray);
132 }
133 };
134
135 let proxy = new Proxy(target, handler);
136 for (let i = 0; i < 500; i++) {
137 assert(proxy.call(thisValue, 20, 45, "foo") === thisValue);
138 assert(called);
139 called = false;
140 assert(proxy.apply(thisValue, [20, 45, "foo"]) === thisValue);
141 assert(called);
142 called = false;
143 }
144}
145
146{
147 let called = false;
148 let target = Error;
149
150 let handler = {
151 apply: function(theTarget, thisArg, argArray) {
152 called = true;
153 assert(theTarget === Error);
154 return theTarget.apply(thisArg, argArray);
155 }
156 };
157
158 let proxy = new Proxy(target, handler);
159 for (let i = 0; i < 500; i++) {
160 let error = proxy();
161 assert(!!error.stack);
162 called = false;
163 }
164}
165
166{
167 let called = false;
168 let self = this;
169 let target = (x) => {
170 called = true;
171 assert(this === self);
172 return x;
173 };
174
175 let handler = { };
176
177 let proxy = new Proxy(target, handler);
178 for (let i = 0; i < 500; i++) {
179 let result = proxy(i);
180 assert(result === i);
181 called = false;
182 }
183}
184
185{
186 let called = false;
187 let self = this;
188 let target = (x) => {
189 assert(this === self);
190 return x;
191 };
192
193 let handler = {
194 apply: function(theTarget, thisArg, argArray) {
195 called = true;
196 assert(theTarget === target);
197 return theTarget.apply(thisArg, argArray);
198 }
199 };
200
201 let proxy = new Proxy(target, handler);
202 for (let i = 0; i < 500; i++) {
203 let result = proxy(i);
204 assert(result === i);
205 called = false;
206 }
207}
208
209{
210 let called = false;
211 let self = this;
212 let target = (x) => {
213 assert(this === self);
214 return x;
215 };
216
217 let handler = {
218 apply: function(theTarget, thisArg, argArray) {
219 called = true;
220 assert(theTarget === target);
221 return theTarget.apply(null, argArray);
222 }
223 };
224
225 let proxy = new Proxy(target, handler);
226 for (let i = 0; i < 500; i++) {
227 let result = proxy(i);
228 assert(called);
229 assert(result === i);
230 called = false;
231 }
232}
233
234{
235 let called = false;
236 let target = (x) => { };
237 let error = null;
238
239 let handler = {
240 apply: function(theTarget, thisArg, argArray) {
241 error = new Error();
242 throw error;
243 }
244 };
245
246 let proxy = new Proxy(target, handler);
247 for (let i = 0; i < 500; i++) {
248 let threw = false;
249 try {
250 proxy();
251 } catch(e) {
252 assert(e === error);
253 threw = true;
254 }
255 assert(threw);
256 }
257}
258
259{
260 let called = false;
261 let error = null;
262 let target = (x) => {
263 error = new Error();
264 throw error;
265 };
266
267 let handler = {
268 apply: function(theTarget, thisArg, argArray) {
269 assert(theTarget === target);
270 return theTarget.apply(null, argArray);
271 }
272 };
273
274 let proxy = new Proxy(target, handler);
275 for (let i = 0; i < 500; i++) {
276 let threw = false;
277 try {
278 proxy();
279 } catch(e) {
280 assert(e === error);
281 threw = true;
282 }
283 assert(threw);
284 }
285}
286
287{
288 let called = false;
289 let error = null;
290 let target = new Proxy((x) => x, {});
291
292 let handler = {
293 apply: function(theTarget, thisArg, argArray) {
294 assert(theTarget === target);
295 called = true;
296 return theTarget.apply(null, argArray);
297 }
298 };
299
300 let proxy = new Proxy(target, handler);
301 for (let i = 0; i < 500; i++) {
302 assert(proxy(i) === i);
303 assert(called);
304 called = false;
305 }
306}
307
308{
309 let target = (x) => x;
310 let handler = {
311 apply: function(theTarget, thisArg, argArray) {
312 return theTarget.apply(thisArg, argArray);
313 }
314 };
315 let proxy = new Proxy(target, handler);
316 for (let i = 0; i < 500; i++) {
317 assert(typeof proxy === "function");
318 }
319}
320
321{
322 let target = function() { }
323 let handler = {
324 apply: function(theTarget, thisArg, argArray) {
325 return theTarget.apply(thisArg, argArray);
326 }
327 };
328 let proxy = new Proxy(target, handler);
329 for (let i = 0; i < 500; i++) {
330 assert(typeof proxy === "function");
331 }
332}
333
334{
335 let target = Error;
336 let handler = {
337 apply: function(theTarget, thisArg, argArray) {
338 return theTarget.apply(thisArg, argArray);
339 }
340 };
341 let proxy = new Proxy(target, handler);
342 for (let i = 0; i < 500; i++) {
343 assert(typeof proxy === "function");
344 }
345}
346
347{
348 let target = (function foo() { }).bind({});
349 let handler = {
350 apply: function(theTarget, thisArg, argArray) {
351 return theTarget.apply(thisArg, argArray);
352 }
353 };
354 let proxy = new Proxy(target, handler);
355 for (let i = 0; i < 500; i++) {
356 assert(typeof proxy === "function");
357 }
358}
359
360{
361 let target = function() { };
362 let handler = {};
363 let proxy = new Proxy(target, handler);
364 for (let i = 0; i < 500; i++) {
365 assert(typeof proxy === "function");
366 }
367}
368
369{
370 let target = {};
371 let handler = {};
372 let proxy = new Proxy(target, handler);
373 for (let i = 0; i < 500; i++) {
374 assert(typeof proxy === "object");
375 }
376}
377
378{
379 let target = [];
380 let handler = {};
381 let proxy = new Proxy(target, handler);
382 for (let i = 0; i < 500; i++) {
383 assert(typeof proxy === "object");
384 }
385}
386
387{
388 let target = new String("foo");
389 let handler = {};
390 let proxy = new Proxy(target, handler);
391 for (let i = 0; i < 500; i++) {
392 assert(typeof proxy === "object");
393 }
394}