← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libv8/trusty

« back to all changes in this revision

Viewing changes to test/mjsunit/unbox-double-arrays.js

  • Committer: Package Import Robot
  • Author(s): Jérémy Lal
  • Date: 2012-02-20 14:08:17 UTC
  • mfrom: (15.1.24 sid)
  • Revision ID: package-import@ubuntu.com-20120220140817-bsvmeoa4sxsj5hbz
Tags: 3.7.12.22-3
Fix mipsel build, allow test debug-step-3 to fail (non-crucial)

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/mjsunit/unbox-double-arrays.js
77
77
    assertEquals(value_6, a[6]);
78
78
    assertEquals(value_6, a[computed_6()]); // Test non-constant key
79
79
    assertEquals(value_7, a[7]);
80
 
    assertEquals(undefined, a[large_array_size-1]);
81
 
    assertEquals(undefined, a[-1]);
82
80
    assertEquals(large_array_size, a.length);
83
81
    assertTrue(%HasFastDoubleElements(a));
84
82
  }
89
87
    assertEquals(value_6, a[6]);
90
88
    assertEquals(value_6, a[computed_6()]); // Test non-constant key
91
89
    assertEquals(value_7, a[7]);
92
 
    assertEquals(undefined, a[large_array_size-1]);
93
 
    assertEquals(undefined, a[-1]);
94
90
    assertEquals(large_array_size, a.length);
95
91
    assertTrue(%HasFastDoubleElements(a));
96
92
  }
101
97
    assertEquals(value_6, a[6]);
102
98
    assertEquals(value_6, a[computed_6()]); // Test non-constant key
103
99
    assertEquals(value_7, a[7]);
104
 
    assertEquals(undefined, a[large_array_size-1]);
105
 
    assertEquals(undefined, a[-1]);
106
100
    assertEquals(large_array_size, a.length);
107
101
    assertTrue(%HasFastDoubleElements(a));
108
102
  }
113
107
    assertEquals(value_6, a[6]);
114
108
    assertEquals(value_6, a[computed_6()]); // Test non-constant key
115
109
    assertEquals(value_7, a[7]);
116
 
    assertEquals(undefined, a[large_array_size-1]);
117
 
    assertEquals(undefined, a[-1]);
118
110
    assertEquals(large_array_size, a.length);
119
111
    assertTrue(%HasFastDoubleElements(a));
120
112
  }
121
113
 
122
114
  function test_various_loads5(a, value_5, value_6, value_7) {
123
115
    assertTrue(%HasFastDoubleElements(a));
124
 
    assertEquals(value_5, a[5]);
125
 
    assertEquals(value_6, a[6]);
126
 
    assertEquals(value_6, a[computed_6()]); // Test non-constant key
 
116
    if (value_5 != undefined) {
 
117
      assertEquals(value_5, a[5]);
 
118
    };
 
119
    if (value_6 != undefined) {
 
120
      assertEquals(value_6, a[6]);
 
121
      assertEquals(value_6, a[computed_6()]); // Test non-constant key
 
122
    }
127
123
    assertEquals(value_7, a[7]);
128
 
    assertEquals(undefined, a[large_array_size-1]);
129
 
    assertEquals(undefined, a[-1]);
130
124
    assertEquals(large_array_size, a.length);
131
125
    assertTrue(%HasFastDoubleElements(a));
132
126
  }
137
131
    assertEquals(value_6, a[6]);
138
132
    assertEquals(value_6, a[computed_6()]); // Test non-constant key
139
133
    assertEquals(value_7, a[7]);
140
 
    assertEquals(undefined, a[large_array_size-1]);
141
 
    assertEquals(undefined, a[-1]);
 
134
    assertEquals(large_array_size, a.length);
 
135
    assertTrue(%HasFastDoubleElements(a));
 
136
  }
 
137
 
 
138
  function test_various_loads7(a, value_5, value_6, value_7) {
 
139
    assertTrue(%HasFastDoubleElements(a));
 
140
    assertEquals(value_5, a[5]);
 
141
    assertEquals(value_6, a[6]);
 
142
    assertEquals(value_6, a[computed_6()]); // Test non-constant key
 
143
    assertEquals(value_7, a[7]);
142
144
    assertEquals(large_array_size, a.length);
143
145
    assertTrue(%HasFastDoubleElements(a));
144
146
  }
248
250
                      expected_array_value(7));
249
251
 
250
252
  // Make sure Crankshaft code handles the hole correctly (bailout)
 
253
  var large_array = new allocator(large_array_size);
 
254
  force_to_fast_double_array(large_array);
251
255
  test_various_stores(large_array,
252
256
                      expected_array_value(5),
253
257
                      expected_array_value(6),
273
277
                      undefined,
274
278
                      expected_array_value(7));
275
279
 
 
280
  %DeoptimizeFunction(test_various_loads6);
 
281
  gc();
 
282
 
276
283
  // Test stores for non-NaN.
 
284
  var large_array = new allocator(large_array_size);
 
285
  force_to_fast_double_array(large_array);
277
286
  %OptimizeFunctionOnNextCall(test_various_stores);
278
287
  test_various_stores(large_array,
279
288
                      expected_array_value(5),
285
294
                      expected_array_value(6),
286
295
                      expected_array_value(7));
287
296
 
288
 
  test_various_loads6(large_array,
 
297
  test_various_loads7(large_array,
 
298
                      expected_array_value(5),
 
299
                      expected_array_value(6),
 
300
                      expected_array_value(7));
 
301
 
 
302
  test_various_loads7(large_array,
 
303
                      expected_array_value(5),
 
304
                      expected_array_value(6),
 
305
                      expected_array_value(7));
 
306
 
 
307
  %OptimizeFunctionOnNextCall(test_various_loads7);
 
308
 
 
309
  test_various_loads7(large_array,
289
310
                      expected_array_value(5),
290
311
                      expected_array_value(6),
291
312
                      expected_array_value(7));
301
322
                      -NaN,
302
323
                      expected_array_value(7));
303
324
 
304
 
  test_various_loads6(large_array,
 
325
  test_various_loads7(large_array,
305
326
                      NaN,
306
327
                      -NaN,
307
328
                      expected_array_value(7));
317
338
                      -Infinity,
318
339
                      expected_array_value(7));
319
340
 
320
 
  test_various_loads6(large_array,
 
341
  test_various_loads7(large_array,
321
342
                      Infinity,
322
343
                      -Infinity,
323
344
                      expected_array_value(7));
434
455
large_array3[4] = -Infinity;
435
456
 
436
457
function call_apply() {
437
 
  assertTrue(%HasFastDoubleElements(large_array3));
438
458
  called_by_apply.apply({}, large_array3);
439
459
}
440
460
 
449
469
function test_for_in() {
450
470
  // Due to previous tests, keys 0..25 and 95 should be present.
451
471
  next_expected = 0;
452
 
  assertTrue(%HasFastDoubleElements(large_array3));
453
472
  for (x in large_array3) {
454
473
    assertTrue(next_expected++ == x);
455
474
    if (next_expected == 25) {