[ARM,MIPS] Skip slow tests
[WebKit-https.git] / JSTests / stress / dataview-jit-set.js
1 "use strict";
2
3 function assert(b) {
4     if (!b)
5         throw new Error;
6 }
7
8 function readHex(dv, bytes) {
9     function isLittleEndian() { 
10         let b = new ArrayBuffer(4);
11         let dv = new DataView(b);
12         dv.setInt32(0, 0x00112233, true);
13         return dv.getUint8(0) === 0x33;
14     }
15     let str = "";
16     function readByte(i) {
17         let b = dv.getUint8(i).toString(16);
18         if (b.length === 1)
19             b = "0" + b;
20         else
21             assert(b.length === 2)
22         return b;
23     }
24     if (isLittleEndian()) {
25         for (let i = bytes; i--;)
26             str = str + readByte(i);
27     } else {
28         for (let i = 0; i < bytes; ++i)
29             str = str + readByte(i);
30     }
31
32     return "0x" + str;
33 }
34
35 {
36     let b = new ArrayBuffer(4);
37     let dv = new DataView(b);
38     dv.setInt32(0, 0x00112233, true);
39     assert(readHex(dv, 4) === "0x00112233");
40 }
41
42 function test() {
43     function storeLittleEndian(dv, index, value) {
44         dv.setInt16(index, value, true);
45     }
46     noInline(storeLittleEndian);
47
48     function storeBigEndian(dv, index, value) {
49         dv.setInt16(index, value, false);
50     }
51     noInline(storeBigEndian);
52
53     function store(dv, index, value, littleEndian) {
54         dv.setInt16(index, value, littleEndian);
55     }
56     noInline(store);
57
58     let buffer = new ArrayBuffer(2);
59     let arr = new Uint16Array(buffer);
60     let dv = new DataView(buffer);
61
62     for (let i = 0; i < 10000; ++i) {
63         storeLittleEndian(dv, 0, 0xfaba);
64         assert(arr[0] === 0xfaba);
65
66         store(dv, 0, 0xabcd, true);
67         assert(arr[0] === 0xabcd);
68
69         store(dv, 0, 0xbadbeef, true);
70         assert(arr[0] === 0xbeef);
71
72         storeLittleEndian(dv, 0, 0xbb4db33f, true);
73         assert(arr[0] === 0xb33f);
74
75         storeBigEndian(dv, 0, 0xfada);
76         assert(arr[0] === 0xdafa);
77
78         storeBigEndian(dv, 0, 0x12ab);
79         assert(arr[0] === 0xab12);
80
81         store(dv, 0, 0x1234, false);
82         assert(arr[0] === 0x3412);
83
84         store(dv, 0, 0x0102, false);
85         assert(arr[0] === 0x0201);
86
87         store(dv, 0, -1, false);
88         assert(arr[0] === 0xffff);
89
90         store(dv, 0, -2, false);
91         assert(arr[0] === 0xfeff);
92
93         storeBigEndian(dv, 0, -1);
94         assert(arr[0] === 0xffff);
95
96         storeBigEndian(dv, 0, -2);
97         assert(arr[0] === 0xfeff);
98
99         storeBigEndian(dv, 0, -2147483648); 
100         assert(arr[0] === 0x0000);
101
102         storeLittleEndian(dv, 0, -2147483648); 
103         assert(arr[0] === 0x0000);
104
105         storeLittleEndian(dv, 0, -2147478988); 
106         assert(arr[0] === 0x1234);
107
108         storeBigEndian(dv, 0, -2147478988); 
109         assert(arr[0] === 0x3412);
110     }
111 }
112 test();
113
114 function test2() {
115     function storeLittleEndian(dv, index, value) {
116         dv.setUint16(index, value, true);
117     }
118     noInline(storeLittleEndian);
119
120     function storeBigEndian(dv, index, value) {
121         dv.setUint16(index, value, false);
122     }
123     noInline(storeBigEndian);
124
125     function store(dv, index, value, littleEndian) {
126         dv.setUint16(index, value, littleEndian);
127     }
128     noInline(store);
129
130     let buffer = new ArrayBuffer(2);
131     let arr = new Uint16Array(buffer);
132     let dv = new DataView(buffer);
133
134     for (let i = 0; i < 10000; ++i) {
135         storeLittleEndian(dv, 0, 0xfaba);
136         assert(arr[0] === 0xfaba);
137
138         store(dv, 0, 0xabcd, true);
139         assert(arr[0] === 0xabcd);
140
141         store(dv, 0, 0xbadbeef, true);
142         assert(arr[0] === 0xbeef);
143
144         storeLittleEndian(dv, 0, 0xbb4db33f, true);
145         assert(arr[0] === 0xb33f);
146
147         storeBigEndian(dv, 0, 0xfada);
148         assert(arr[0] === 0xdafa);
149
150         storeBigEndian(dv, 0, 0x12ab);
151         assert(arr[0] === 0xab12);
152
153         store(dv, 0, 0x1234, false);
154         assert(arr[0] === 0x3412);
155
156         store(dv, 0, 0x0102, false);
157         assert(arr[0] === 0x0201);
158
159         store(dv, 0, -1, false);
160         assert(arr[0] === 0xffff);
161
162         store(dv, 0, -2, false);
163         assert(arr[0] === 0xfeff);
164
165         storeBigEndian(dv, 0, -1);
166         assert(arr[0] === 0xffff);
167
168         storeBigEndian(dv, 0, -2);
169         assert(arr[0] === 0xfeff);
170
171         storeBigEndian(dv, 0, -2147483648); 
172         assert(arr[0] === 0x0000);
173
174         storeLittleEndian(dv, 0, -2147483648); 
175         assert(arr[0] === 0x0000);
176
177         storeLittleEndian(dv, 0, -2147478988); 
178         assert(arr[0] === 0x1234);
179
180         storeBigEndian(dv, 0, -2147478988); 
181         assert(arr[0] === 0x3412);
182     }
183 }
184 test2();
185
186 function test3() {
187     function storeLittleEndian(dv, index, value) {
188         dv.setUint32(index, value, true);
189     }
190     noInline(storeLittleEndian);
191
192     function storeBigEndian(dv, index, value) {
193         dv.setUint32(index, value, false);
194     }
195     noInline(storeBigEndian);
196
197     function store(dv, index, value, littleEndian) {
198         dv.setUint32(index, value, littleEndian);
199     }
200     noInline(store);
201
202     let buffer = new ArrayBuffer(4);
203     let arr = new Uint32Array(buffer);
204     let arr2 = new Int32Array(buffer);
205     let dv = new DataView(buffer);
206
207     for (let i = 0; i < 10000; ++i) {
208         storeLittleEndian(dv, 0, 0xffffffff);
209         assert(arr[0] === 0xffffffff);
210         assert(arr2[0] === -1);
211
212         storeLittleEndian(dv, 0, 0xffaabbcc);
213         assert(arr[0] === 0xffaabbcc);
214
215         storeBigEndian(dv, 0, 0x12345678);
216         assert(arr[0] === 0x78563412);
217
218         storeBigEndian(dv, 0, 0xffaabbcc);
219         assert(arr[0] === 0xccbbaaff);
220
221         store(dv, 0, 0xfaeadaca, false);
222         assert(arr[0] === 0xcadaeafa);
223
224         store(dv, 0, 0xcadaeafa, false);
225         assert(arr2[0] === -85271862);
226
227         store(dv, 0, 0x12345678, false);
228         assert(arr[0] === 0x78563412);
229
230         storeBigEndian(dv, 0, 0xbeeffeeb);
231         assert(arr2[0] === -335614018);
232     }
233 }
234 test3();
235
236 function test4() {
237     function storeLittleEndian(dv, index, value) {
238         dv.setInt32(index, value, true);
239     }
240     noInline(storeLittleEndian);
241
242     function storeBigEndian(dv, index, value) {
243         dv.setInt32(index, value, false);
244     }
245     noInline(storeBigEndian);
246
247     function store(dv, index, value, littleEndian) {
248         dv.setInt32(index, value, littleEndian);
249     }
250     noInline(store);
251
252     let buffer = new ArrayBuffer(4);
253     let arr = new Uint32Array(buffer);
254     let arr2 = new Int32Array(buffer);
255     let dv = new DataView(buffer);
256
257     for (let i = 0; i < 10000; ++i) {
258         storeLittleEndian(dv, 0, 0xffffffff);
259         assert(arr[0] === 0xffffffff);
260         assert(arr2[0] === -1);
261
262         storeLittleEndian(dv, 0, 0xffaabbcc);
263         assert(arr[0] === 0xffaabbcc);
264
265         storeBigEndian(dv, 0, 0x12345678);
266         assert(arr[0] === 0x78563412);
267
268         storeBigEndian(dv, 0, 0xffaabbcc);
269         assert(arr[0] === 0xccbbaaff);
270
271         store(dv, 0, 0xfaeadaca, false);
272         assert(arr[0] === 0xcadaeafa);
273
274         store(dv, 0, 0xcadaeafa, false);
275         assert(arr2[0] === -85271862);
276
277         store(dv, 0, 0x12345678, false);
278         assert(arr[0] === 0x78563412);
279
280         storeBigEndian(dv, 0, 0xbeeffeeb);
281         assert(arr2[0] === -335614018);
282     }
283 }
284 test4();
285
286 function test5() {
287     function storeLittleEndian(dv, index, value) {
288         dv.setFloat32(index, value, true);
289     }
290     noInline(storeLittleEndian);
291
292     function storeBigEndian(dv, index, value) {
293         dv.setFloat32(index, value, false);
294     }
295     noInline(storeBigEndian);
296
297     function store(dv, index, value, littleEndian) {
298         dv.setFloat32(index, value, littleEndian);
299     }
300     noInline(store);
301
302     let buffer = new ArrayBuffer(4);
303     let arr = new Float32Array(buffer);
304     let bits = new Uint32Array(buffer);
305     let dv = new DataView(buffer);
306
307     for (let i = 0; i < 10000; ++i) {
308         storeLittleEndian(dv, 0, 1.5);
309         assert(arr[0] === 1.5);
310
311         storeLittleEndian(dv, 0, 12912.124123215122);
312         assert(arr[0] === 12912.1240234375);
313         assert(bits[0] === 0x4649c07f);
314
315         storeLittleEndian(dv, 0, NaN);
316         assert(isNaN(arr[0]));
317
318         storeLittleEndian(dv, 0, 2.3879393e-38);
319         assert(arr[0] === 2.387939260590663e-38);
320         assert(bits[0] === 0x01020304);
321
322         storeBigEndian(dv, 0, 2.3879393e-38);
323         assert(arr[0] === 1.539989614439558e-36);
324         assert(bits[0] === 0x04030201);
325     }
326 }
327 test5();
328
329 function test6() {
330     function storeLittleEndian(dv, index, value) {
331         dv.setFloat64(index, value, true);
332     }
333     noInline(storeLittleEndian);
334
335     function storeBigEndian(dv, index, value) {
336         dv.setFloat64(index, value, false);
337     }
338     noInline(storeBigEndian);
339
340     function store(dv, index, value, littleEndian) {
341         dv.setFloat64(index, value, littleEndian);
342     }
343     noInline(store);
344
345     let buffer = new ArrayBuffer(8);
346     let arr = new Float64Array(buffer);
347     let dv = new DataView(buffer);
348
349     for (let i = 0; i < 10000; ++i) {
350         storeLittleEndian(dv, 0, NaN);
351         assert(isNaN(arr[0]));
352
353         storeLittleEndian(dv, 0, -2.5075187084135162e+284);
354         assert(arr[0] === -2.5075187084135162e+284);
355         assert(readHex(dv, 8) === "0xfafafafafafafafa");
356
357         store(dv, 0, 124.553, true);
358         assert(readHex(dv, 8) === "0x405f23645a1cac08");
359
360         store(dv, 0, Infinity, true);
361         assert(readHex(dv, 8) === "0x7ff0000000000000");
362
363         store(dv, 0, Infinity, false);
364         assert(readHex(dv, 8) === "0x000000000000f07f");
365
366         store(dv, 0, -Infinity, true);
367         assert(readHex(dv, 8) === "0xfff0000000000000");
368
369         storeBigEndian(dv, 0, -2.5075187084135162e+284);
370         assert(arr[0] === -2.5075187084135162e+284);
371         assert(readHex(dv, 8) === "0xfafafafafafafafa");
372
373         storeBigEndian(dv, 0, 124.553);
374         assert(readHex(dv, 8) === "0x08ac1c5a64235f40");
375     }
376 }
377 test6();
378
379 function test7() {
380     function store(dv, index, value) {
381         dv.setInt8(index, value);
382     }
383     noInline(store);
384
385     let buffer = new ArrayBuffer(1);
386     let arr = new Uint8Array(buffer);
387     let arr2 = new Int8Array(buffer);
388     let dv = new DataView(buffer);
389
390     for (let i = 0; i < 10000; ++i) {
391         store(dv, 0, 0xff);
392         assert(arr[0] === 0xff);
393         assert(arr2[0] === -1);
394
395         store(dv, 0, 0xff00);
396         assert(arr[0] === 0);
397         assert(arr2[0] === 0);
398
399         store(dv, 0, -1);
400         assert(arr[0] === 0xff);
401         assert(arr2[0] === -1);
402
403         store(dv, 0, 0x0badbeef);
404         assert(arr[0] === 0xef);
405         assert(arr2[0] === -17);
406     }
407 }
408 test7();
409
410 function test8() {
411     function store(dv, index, value) {
412         dv.setInt8(index, value);
413     }
414     noInline(store);
415
416     let buffer = new ArrayBuffer(1);
417     let arr = new Uint8Array(buffer);
418     let arr2 = new Int8Array(buffer);
419     let dv = new DataView(buffer);
420
421     for (let i = 0; i < 10000; ++i) {
422         store(dv, 0, 0xff);
423         assert(arr[0] === 0xff);
424         assert(arr2[0] === -1);
425
426         store(dv, 0, 0xff00);
427         assert(arr[0] === 0);
428         assert(arr2[0] === 0);
429
430         store(dv, 0, -1);
431         assert(arr[0] === 0xff);
432         assert(arr2[0] === -1);
433
434         store(dv, 0, 0x0badbeef);
435         assert(arr[0] === 0xef);
436         assert(arr2[0] === -17);
437     }
438 }
439 test8();