1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
// Files: tools/clusterfuzz/v8_mock.js
// Test foozzie mocks for differential fuzzing.
// Deterministic Math.random.
assertEquals(0.7098480789645691, Math.random());
assertEquals(0.9742682568175951, Math.random());
assertEquals(0.20008059867222983, Math.random());
// Deterministic date.
assertEquals(1477662728698, Date.now());
assertEquals(1477662728701, Date.now());
assertEquals(1477662728705, new Date().getTime());
assertEquals(710, new Date.prototype.constructor().getUTCMilliseconds());
// Deterministic arguments in constructor keep working.
assertEquals(819134640000,
new Date('December 17, 1995 03:24:00 GMT+1000').getTime());
// Dummy performance methods.
assertEquals(1.2, performance.now());
assertEquals([], performance.measureMemory());
// Worker messages follow a predefined deterministic pattern.
const worker = new Worker(``, {type: 'string'});
assertEquals(0, worker.getMessage());
assertEquals(-1, worker.getMessage());
// NaN patterns in typed arrays are mocked out. Test that we get no
// difference between unoptimized and optimized code.
function testSameOptimized(pattern, create_fun) {
const expected = new Uint32Array(pattern);
%PrepareFunctionForOptimization(create_fun);
assertEquals(expected, create_fun());
%OptimizeFunctionOnNextCall(create_fun);
assertEquals(expected, create_fun());
}
function testArrayType(arrayType, pattern) {
// Test passing NaNs to constructor with array.
let create = function() {
return new Uint32Array(new arrayType([-NaN]).buffer);
};
testSameOptimized(pattern, create);
// Test passing NaNs to constructor with iterator.
create = function() {
const iter = function*(){ yield* [-NaN]; }();
return new Uint32Array(new arrayType(iter).buffer);
};
testSameOptimized(pattern, create);
// Test setting NaN property.
create = function() {
const arr = new arrayType(1);
arr[0] = -NaN;
return new Uint32Array(arr.buffer);
};
// Test passing NaN using set.
testSameOptimized(pattern, create);
create = function() {
const arr = new arrayType(1);
arr.set([-NaN], 0);
return new Uint32Array(arr.buffer);
};
testSameOptimized(pattern, create);
}
var isBigEndian = new Uint8Array(new Uint16Array([0xABCD]).buffer)[0] === 0xAB;
testArrayType(Float32Array, [1065353216]);
if (isBigEndian){
testArrayType(Float64Array, [1072693248, 0]);
}
else {
testArrayType(Float64Array, [0, 1072693248]);
}
// Realm.eval is just eval.
assertEquals(1477662728716, Realm.eval(Realm.create(), `Date.now()`));
// Test suppressions when Math.pow is optimized.
function callPow(v) {
return Math.pow(v, -0.5);
}
%PrepareFunctionForOptimization(callPow);
const unoptimized = callPow(6996);
%OptimizeFunctionOnNextCall(callPow);
assertEquals(unoptimized, callPow(6996));
|
