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
|
// Copyright 2016 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.
var Debug = debug.Debug;
var LiveEdit = Debug.LiveEdit;
unique_id = 0;
var AsyncFunction = (async function(){}).constructor;
function assertPromiseValue(value, promise) {
promise.then(resolve => {
went = true;
if (resolve !== value) {
print(`expected ${value} found ${resolve}`);
quit(1);
}
}, reject => {
print(`rejected ${reject}`);
quit(1);
});
}
function MakeAsyncFunction() {
// Prevents eval script caching.
unique_id++;
return AsyncFunction('callback',
"/* " + unique_id + "*/\n" +
"await callback();\n" +
"return 'Cat';\n");
}
function MakeFunction() {
// Prevents eval script caching.
unique_id++;
return Function('callback',
"/* " + unique_id + "*/\n" +
"callback();\n" +
"return 'Cat';\n");
}
// First, try MakeGenerator with no perturbations.
(function(){
var asyncfn = MakeAsyncFunction();
function callback() {};
var promise = asyncfn(callback);
assertPromiseValue('Cat', promise);
})();
function patch(fun, from, to) {
function debug() {
var log = new Array();
var script = Debug.findScript(fun);
var pos = script.source.indexOf(from);
print(`pos ${pos}`);
try {
LiveEdit.TestApi.ApplySingleChunkPatch(script, pos, from.length, to,
log);
} finally {
print("Change log: " + JSON.stringify(log) + "\n");
}
}
%ExecuteInDebugContext(debug);
}
// Try to edit a MakeAsyncFunction while it's running, then again while it's
// stopped.
(function(){
var asyncfn = MakeAsyncFunction();
var patch_attempted = false;
function attempt_patch() {
assertFalse(patch_attempted);
patch_attempted = true;
assertThrows(function() { patch(asyncfn, "'Cat'", "'Capybara'") },
LiveEdit.Failure);
};
var promise = asyncfn(attempt_patch);
// Patch should not succeed because there is a live async function activation
// on the stack.
assertPromiseValue("Cat", promise);
assertTrue(patch_attempted);
%RunMicrotasks();
// At this point one iterator is live, but closed, so the patch will succeed.
patch(asyncfn, "'Cat'", "'Capybara'");
promise = asyncfn(function(){});
// Patch successful.
assertPromiseValue("Capybara", promise);
// Patching will fail however when an async function is suspended.
var resolve;
promise = asyncfn(function(){return new Promise(function(r){resolve = r})});
assertThrows(function() { patch(asyncfn, "'Capybara'", "'Tapir'") },
LiveEdit.Failure);
resolve();
assertPromiseValue("Capybara", promise);
// Try to patch functions with activations inside and outside async
// function activations. We should succeed in the former case, but not in the
// latter.
var fun_outside = MakeFunction();
var fun_inside = MakeFunction();
var fun_patch_attempted = false;
var fun_patch_restarted = false;
function attempt_fun_patches() {
if (fun_patch_attempted) {
assertFalse(fun_patch_restarted);
fun_patch_restarted = true;
return;
}
fun_patch_attempted = true;
// Patching outside an async function activation must fail.
assertThrows(function() { patch(fun_outside, "'Cat'", "'Cobra'") },
LiveEdit.Failure);
// Patching inside an async function activation may succeed.
patch(fun_inside, "'Cat'", "'Koala'");
}
promise = asyncfn(function() { return fun_inside(attempt_fun_patches) });
assertEquals('Cat',
fun_outside(function () {
assertPromiseValue('Capybara', promise);
assertTrue(fun_patch_restarted);
assertTrue(fun_inside.toString().includes("'Koala'"));
}));
})();
%RunMicrotasks();
|
