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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
// Copyright 2017 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.
Debug = debug.Debug
var exception = null;
let a = 1;
var object = { property : 2,
get getter() { return 3; }
};
var string0 = new String("string");
var string1 = { toString() { return "x"; } };
var string2 = { toString() { print("x"); return "x"; } };
var array = [4, 5];
var error = new Error();
function simple_return(x) { return x; }
function set_a() { a = 2; }
function get_a() { return a; }
var bound = get_a.bind(0);
function return_arg0() { return return_arg0.arguments[0]; }
function return_caller_name() { return return_caller_name.caller.name; }
var global_eval = eval;
function listener(event, exec_state, event_data, data) {
if (event != Debug.DebugEvent.Break) return;
try {
function success(expectation, source) {
assertEquals(expectation,
exec_state.frame(0).evaluate(source, true).value());
}
function fail(source) {
assertThrows(() => exec_state.frame(0).evaluate(source, true),
EvalError);
}
// Simple test.
success(3, "1 + 2");
// Dymanic load.
success(array, "array");
// Context load.
success(1, "a");
// Global and named property load.
success(2, "object.property");
// Load via read-only getter.
success(3, "object.getter");
// Implicit call to read-only toString.
success("xy", "string1 + 'y'");
// Keyed property load.
success(5, "array[1]");
// Call to read-only function.
success(1, "get_a()");
success(1, "bound()");
success({}, "new get_a()");
// Call to read-only function within try-catch.
success(1, "try { get_a() } catch (e) {}");
// Call to C++ built-in.
success(Math.sin(2), "Math.sin(2)");
// Call to whitelisted get accessors.
success(3, "'abc'.length");
success(2, "array.length");
success(1, "'x'.length");
success(0, "set_a.length");
success("set_a", "set_a.name");
success(0, "bound.length");
success("bound get_a", "bound.name");
success(1, "return_arg0(1)");
success("f", "(function f() { return return_caller_name() })()");
// Non-evaluated call.
// Constructed literals.
success([1], "[1]");
success({x: 1}, "({x: 1})");
success([1], "[a]");
success({x: 1}, "({x: a})");
// Test that template literal evaluation fails.
fail("simple_return`1`");
// Test that non-read-only code fails.
fail("exception = 1");
// Test that calling a non-read-only function fails.
fail("set_a()");
fail("new set_a()");
// Test that implicit call to a non-read-only function fails.
fail("string2 + 'y'");
// Test that try-catch does not catch the EvalError.
fail("try { set_a() } catch (e) {}");
// Test that call to set accessor fails.
fail("array.length = 4");
fail("set_a.name = 'set_b'");
fail("set_a.length = 1");
fail("bound.name = 'bound'");
fail("bound.length = 1");
fail("set_a.prototype = null");
// Test that call to non-whitelisted get accessor fails.
fail("error.stack");
// Call to set accessors with receiver check.
success(1, "[].length = 1");
success(1, "'x'.length = 1");
fail("string0.length = 1");
success(1, "(new String('abc')).length = 1");
success("g", "(function(){}).name = 'g'");
success(1, "(function(){}).length = 1");
success("g", "get_a.bind(0).name = 'g'");
success(1, "get_a.bind(0).length = 1");
success(null, "(function(){}).prototype = null");
success(true, "(new Error()).stack.length > 1");
success("a", "(new Error()).stack = 'a'");
// Eval is not allowed.
fail("eval('Math.sin(1)')");
fail("eval('exception = 1')");
fail("global_eval('1')");
success(1, "(() => { var a = 1; return a++; })()")
} catch (e) {
exception = e;
print(e, e.stack);
};
};
// Add the debug event listener.
Debug.setListener(listener);
function f() {
debugger;
};
f();
assertNull(exception);
assertEquals(1, a);
|
