summaryrefslogtreecommitdiffstats
path: root/js/src/jit-test/tests/debug/Frame-onPop-multiple-01.js
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /js/src/jit-test/tests/debug/Frame-onPop-multiple-01.js
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'js/src/jit-test/tests/debug/Frame-onPop-multiple-01.js')
-rw-r--r--js/src/jit-test/tests/debug/Frame-onPop-multiple-01.js127
1 files changed, 127 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/debug/Frame-onPop-multiple-01.js b/js/src/jit-test/tests/debug/Frame-onPop-multiple-01.js
new file mode 100644
index 000000000..87e23825f
--- /dev/null
+++ b/js/src/jit-test/tests/debug/Frame-onPop-multiple-01.js
@@ -0,0 +1,127 @@
+// Multiple debuggers all get their onPop handlers called, and see each others' effects.
+
+function completionsEqual(c1, c2) {
+ if (c1 && c2) {
+ if (c1.throw)
+ return c1.throw === c2.throw;
+ else
+ return c1.return === c2.return;
+ }
+ return c1 === c2;
+}
+
+function completionString(c) {
+ if (c == null)
+ return 'x';
+ if (c.return)
+ return 'r' + c.return;
+ if (c.throw)
+ return 't' + c.throw;
+ return '?';
+}
+
+var g = newGlobal(); // poor thing
+g.eval('function f() { debugger; return "1"; }');
+
+// We create a bunch of debuggers, but they all consult this global variable
+// for expectations and responses, so the order in which events get
+// reported to the debuggers doesn't matter.
+//
+// This list includes every pair of transitions, and is of minimal length.
+// As if opportunity cost were just some theoretical concern.
+var sequence = [{ expect: { return: '1' }, resume: { return: '2'} },
+ { expect: { return: '2' }, resume: { throw: '3'} },
+ { expect: { throw: '3' }, resume: { return: '4'} },
+ { expect: { return: '4' }, resume: null },
+ { expect: null, resume: { throw: '5'} },
+ { expect: { throw: '5' }, resume: { throw: '6'} },
+ { expect: { throw: '6' }, resume: null },
+ { expect: null, resume: null },
+ { expect: null, resume: { return: '7'} }];
+
+// A list of the debuggers' Debugger.Frame instances. When it's all over,
+// we test that they are all marked as no longer live.
+var frames = [];
+
+// We start off the test via Debugger.Frame.prototype.eval, so if we end
+// with a termination, we still catch it, instead of aborting the whole
+// test. (Debugger.Object.prototype.executeInGlobal would simplify this...)
+var dbg0 = new Debugger(g);
+dbg0.onEnterFrame = function handleOriginalEnter(frame) {
+ dbg0.log += '(';
+ dbg0.onEnterFrame = undefined;
+
+ assertEq(frame.live, true);
+ frames.push(frame);
+
+ var dbgs = [];
+ var log;
+
+ // Create a separate debugger to carry out each item in sequence.
+ for (s in sequence) {
+ // Each debugger's handlers close over a distinct 'dbg', but
+ // that's the only distinction between them. Otherwise, they're
+ // driven entirely by global data, so the order in which events are
+ // dispatched to them shouldn't matter.
+ let dbg = new Debugger(g);
+ dbgs.push(dbg);
+
+ dbg.onDebuggerStatement = function handleDebuggerStatement(f) {
+ log += 'd';
+ assertEq(f.live, true);
+ frames.push(f);
+ };
+
+ // First expect the 'eval'...
+ dbg.onEnterFrame = function handleEnterEval(f) {
+ log += 'e';
+ assertEq(f.type, 'eval');
+ assertEq(f.live, true);
+ frames.push(f);
+
+ // Then expect the call.
+ dbg.onEnterFrame = function handleEnterCall(f) {
+ log += '(';
+ assertEq(f.type, 'call');
+ assertEq(f.live, true);
+ frames.push(f);
+
+ // Don't expect any further frames.
+ dbg.onEnterFrame = function handleExtraEnter(f) {
+ log += 'z';
+ };
+
+ f.onPop = function handlePop(c) {
+ log += ')' + completionString(c);
+ assertEq(this.live, true);
+ frames.push(this);
+
+ // Check that this debugger is in the list, and then remove it.
+ var i = dbgs.indexOf(dbg);
+ assertEq(i != -1, true);
+ dbgs.splice(i,1);
+
+ // Check the frame's completion value against 'sequence'.
+ assertEq(completionsEqual(c, sequence[0].expect), true);
+
+ // Provide the next resumption value from 'sequence'.
+ return sequence.shift().resume;
+ };
+ };
+ };
+ }
+
+ log = '';
+ assertEq(completionsEqual(frame.eval('f()'), { return: '7' }), true);
+ assertEq(log, "eeeeeeeee(((((((((ddddddddd)r1)r2)t3)r4)x)t5)t6)x)x");
+
+ dbg0.log += '.';
+};
+
+dbg0.log = '';
+g.eval('eval');
+assertEq(dbg0.log, '(.');
+
+// Check that all Debugger.Frame instances we ran into are now marked as dead.
+for (var i = 0; i < frames.length; i++)
+ assertEq(frames[i].live, false);