← Back to branch summary

~ubuntu-branches/ubuntu/trusty/mozjs24/trusty-proposed

« back to all changes in this revision

Viewing changes to js/src/jit-test/tests/ion/bug851792.js

  • Committer: Package Import Robot
  • Author(s): Tim Lunn
  • Date: 2014-02-11 21:55:34 UTC
  • Revision ID: package-import@ubuntu.com-20140211215534-m1zyq5aj59md3y07
Tags: upstream-24.2.0
Import upstream version 24.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
js/src/jit-test/tests/ion/bug851792.js
 
1
// Based on tests/ion/typed-arrays-1.js, but with string indexes
 
2
function testInt8() {
 
3
    var arr1 = new Int8Array(50);
 
4
    var arr2 = new Uint8Array(50);
 
5
    var arr3 = new Uint8ClampedArray(50);
 
6
 
 
7
    for (var i=0; i<arr1.length; i++) {
 
8
        arr1[i] = arr2[i] = arr3[i] = i * 8;
 
9
    }
 
10
    var res = 0;
 
11
    for (var i=0; i<arr1.length; i++) {
 
12
        res += arr1[i+""] + arr2[i+""] + arr3[i+""] + arr2["10".concat("")];
 
13
    }
 
14
    assertEq(res, 18334);
 
15
}
 
16
testInt8();
 
17
 
 
18
function testInt16() {
 
19
    var arr1 = new Int16Array(70);
 
20
    var arr2 = new Uint16Array(70);
 
21
 
 
22
    for (var i=0; i<arr1.length; i++) {
 
23
        arr1[i] = arr2[i] = i * 1000;
 
24
    }
 
25
    var res = 0;
 
26
    for (var i=0; i<arr1.length; i++) {
 
27
        res += arr1[i+""] + arr2[i+""] + arr2["1".concat("")] + arr1["3".concat("")];
 
28
    }
 
29
    assertEq(res, 2423024);
 
30
}
 
31
testInt16();
 
32
 
 
33
function testInt32() {
 
34
    var arr = new Int32Array(60);
 
35
    arr[0] = -50;
 
36
    for (var i=1; i<arr.length; i++) {
 
37
        arr[i] = arr[(i-1)+""] + arr["0".concat("")];
 
38
        ++arr[0];
 
39
    }
 
40
    assertEq(arr[(arr.length-1)+""], -1289);
 
41
}
 
42
testInt32();
 
43
 
 
44
function testUint32() {
 
45
    function sum(arr) {
 
46
        var res = 0;
 
47
        for (var i=0; i<arr.length; i++) {
 
48
            res += arr[i+""];
 
49
        }
 
50
        return res;
 
51
    }
 
52
    var arr = new Uint32Array(100);
 
53
    for (var i=0; i<arr.length; i++) {
 
54
        arr[i] = i;
 
55
    }
 
56
 
 
57
    // Compile sum() to read int32 values.
 
58
    assertEq(sum(arr), 4950);
 
59
 
 
60
    // Add a large uint32 so that the sum no longer fits in an
 
61
    // int32. sum() should be recompiled to return a double.
 
62
    arr[50] = 0xffffeeee;
 
63
    assertEq(sum(arr), 4294967826);
 
64
}
 
65
testUint32();
 
66
 
 
67
function testFloat() {
 
68
    var arr1 = new Float32Array(75);
 
69
    var arr2 = new Float64Array(75);
 
70
    arr1[0] = arr2[0] = Math.PI * 1234567.8;
 
71
 
 
72
    for (var i=1; i<75; i++) {
 
73
        arr1[i] = arr1[(i-1)+""] + arr1[0];
 
74
        arr2[i] = arr2[(i-1)+""] + arr2[0];
 
75
    }
 
76
    assertEq(arr1["74".concat("")] > 290888255, true);
 
77
    assertEq(arr1["74".concat("")] < 290888257, true);
 
78
 
 
79
    assertEq(arr2["74".concat("")] > 290888184, true);
 
80
    assertEq(arr2["74".concat("")] < 290888185, true);
 
81
}
 
82
testFloat();
 
83
 
 
84
function testCanonicalNaN() {
 
85
    // NaN values have to be canonicalized. Otherwise, malicious scripts could
 
86
    // construct arbitrary Value's (due to our NaN boxing Value representation).
 
87
    var buf = new ArrayBuffer(16);
 
88
    var uint32 = new Uint32Array(buf);
 
89
    var f64 = new Float64Array(buf);
 
90
    var f32 = new Float32Array(buf);
 
91
 
 
92
    // Evil: write a JSVAL_TYPE_OBJECT type tag...
 
93
    uint32[0] = 0xffffff87;
 
94
    uint32[1] = 0xffffff87;
 
95
 
 
96
    // Make sure this value is interpreted as a double.
 
97
    for (var i=0; i<3; i++) {
 
98
        assertEq(isNaN(f64["0".concat("")]), true);
 
99
        assertEq(isNaN(f32["0".concat("")]), true);
 
100
    }
 
101
}
 
102
testCanonicalNaN();
 
103
 
 
104
function testOutOfBounds() {
 
105
    var buf = new ArrayBuffer(16);
 
106
    var uint32 = new Uint32Array(buf);
 
107
 
 
108
    uint32[0] = 0;
 
109
    uint32[1] = 1;
 
110
 
 
111
    for (var i=0; i<3; i++) {
 
112
      assertEq(uint32["0".concat("")], 0);
 
113
      assertEq(uint32["1".concat("")], 1);
 
114
      assertEq(uint32["2".concat("")], 0);
 
115
      assertEq(uint32["17".concat("")], undefined);
 
116
    }
 
117
}
 
118
testOutOfBounds();
 
119
 
 
120
function testStrangeIndexes() {
 
121
    var buf = new ArrayBuffer(16);
 
122
    var uint32 = new Uint32Array(buf);
 
123
 
 
124
    uint32[0] = 0;
 
125
    uint32[1] = 1;
 
126
 
 
127
    indexes = ["0", "1", "2", "3", "17", "3.5", "NaN", "undefined", "null"];
 
128
    solutions = [0, 1, 0, 0, undefined, undefined, undefined, undefined, undefined];
 
129
 
 
130
    for (var i=0; i<indexes.length; i++) {
 
131
      assertEq(uint32[indexes[i]], solutions[i]);
 
132
    }
 
133
}
 
134
testStrangeIndexes();
 
135