2016-10-02 19:41:17 +00:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
InspectorTest = {};
|
|
|
|
InspectorTest._dumpInspectorProtocolMessages = false;
|
2017-03-22 18:07:12 +00:00
|
|
|
InspectorTest._commandsForLogging = new Set();
|
2017-05-19 00:35:45 +00:00
|
|
|
InspectorTest._sessions = new Set();
|
2016-10-03 23:32:52 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
InspectorTest.log = utils.print.bind(utils);
|
|
|
|
InspectorTest.quitImmediately = utils.quit.bind(utils);
|
|
|
|
|
|
|
|
InspectorTest.logProtocolCommandCalls = function(command) {
|
|
|
|
InspectorTest._commandsForLogging.add(command);
|
2017-05-18 23:11:20 +00:00
|
|
|
}
|
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
InspectorTest.completeTest = function() {
|
|
|
|
var promises = [];
|
|
|
|
for (var session of InspectorTest._sessions)
|
|
|
|
promises.push(session.Protocol.Debugger.disable());
|
|
|
|
Promise.all(promises).then(() => utils.quit());
|
2017-05-18 23:11:20 +00:00
|
|
|
}
|
2016-10-02 19:41:17 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
InspectorTest.waitForPendingTasks = function() {
|
|
|
|
var promises = [];
|
|
|
|
for (var session of InspectorTest._sessions)
|
|
|
|
promises.push(session.Protocol.Runtime.evaluate({ expression: "new Promise(r => setTimeout(r, 0))//# sourceURL=wait-for-pending-tasks.js", awaitPromise: true }));
|
|
|
|
return Promise.all(promises);
|
|
|
|
}
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
InspectorTest.startDumpingProtocolMessages = function() {
|
|
|
|
InspectorTest._dumpInspectorProtocolMessages = true;
|
|
|
|
}
|
2016-10-02 19:41:17 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
InspectorTest.logMessage = function(originalMessage) {
|
2016-11-04 19:59:11 +00:00
|
|
|
var message = JSON.parse(JSON.stringify(originalMessage));
|
2016-10-03 23:32:52 +00:00
|
|
|
if (message.id)
|
|
|
|
message.id = "<messageId>";
|
2016-10-02 19:41:17 +00:00
|
|
|
|
2017-02-28 20:22:24 +00:00
|
|
|
const nonStableFields = new Set(["objectId", "scriptId", "exceptionId", "timestamp",
|
|
|
|
"executionContextId", "callFrameId", "breakpointId", "bindRemoteObjectFunctionId", "formatterObjectId" ]);
|
2016-10-03 23:32:52 +00:00
|
|
|
var objects = [ message ];
|
|
|
|
while (objects.length) {
|
|
|
|
var object = objects.shift();
|
|
|
|
for (var key in object) {
|
|
|
|
if (nonStableFields.has(key))
|
|
|
|
object[key] = `<${key}>`;
|
2017-03-29 21:40:07 +00:00
|
|
|
else if (typeof object[key] === "string" && object[key].match(/\d+:\d+:\d+:debug/))
|
|
|
|
object[key] = object[key].replace(/\d+/, '<scriptId>');
|
2016-10-03 23:32:52 +00:00
|
|
|
else if (typeof object[key] === "object")
|
|
|
|
objects.push(object[key]);
|
2016-10-02 19:41:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-03 23:32:52 +00:00
|
|
|
InspectorTest.logObject(message);
|
2016-11-04 19:59:11 +00:00
|
|
|
return originalMessage;
|
2016-10-03 23:32:52 +00:00
|
|
|
}
|
2016-10-02 19:41:17 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
InspectorTest.logObject = function(object, title) {
|
2016-10-02 19:41:17 +00:00
|
|
|
var lines = [];
|
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
function dumpValue(value, prefix, prefixWithName) {
|
2016-10-02 19:41:17 +00:00
|
|
|
if (typeof value === "object" && value !== null) {
|
|
|
|
if (value instanceof Array)
|
|
|
|
dumpItems(value, prefix, prefixWithName);
|
|
|
|
else
|
|
|
|
dumpProperties(value, prefix, prefixWithName);
|
|
|
|
} else {
|
|
|
|
lines.push(prefixWithName + String(value).replace(/\n/g, " "));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
function dumpProperties(object, prefix, firstLinePrefix) {
|
2016-10-02 19:41:17 +00:00
|
|
|
prefix = prefix || "";
|
|
|
|
firstLinePrefix = firstLinePrefix || prefix;
|
|
|
|
lines.push(firstLinePrefix + "{");
|
|
|
|
|
|
|
|
var propertyNames = Object.keys(object);
|
|
|
|
propertyNames.sort();
|
|
|
|
for (var i = 0; i < propertyNames.length; ++i) {
|
|
|
|
var name = propertyNames[i];
|
|
|
|
if (!object.hasOwnProperty(name))
|
|
|
|
continue;
|
|
|
|
var prefixWithName = " " + prefix + name + " : ";
|
|
|
|
dumpValue(object[name], " " + prefix, prefixWithName);
|
|
|
|
}
|
|
|
|
lines.push(prefix + "}");
|
|
|
|
}
|
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
function dumpItems(object, prefix, firstLinePrefix) {
|
2016-10-02 19:41:17 +00:00
|
|
|
prefix = prefix || "";
|
|
|
|
firstLinePrefix = firstLinePrefix || prefix;
|
|
|
|
lines.push(firstLinePrefix + "[");
|
|
|
|
for (var i = 0; i < object.length; ++i)
|
|
|
|
dumpValue(object[i], " " + prefix, " " + prefix + "[" + i + "] : ");
|
|
|
|
lines.push(prefix + "]");
|
|
|
|
}
|
|
|
|
|
2016-10-28 06:47:58 +00:00
|
|
|
dumpValue(object, "", title || "");
|
2016-10-02 19:41:17 +00:00
|
|
|
InspectorTest.log(lines.join("\n"));
|
|
|
|
}
|
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
InspectorTest.ContextGroup = class {
|
|
|
|
constructor() {
|
|
|
|
this.id = utils.createContextGroup();
|
2016-12-13 19:40:14 +00:00
|
|
|
}
|
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
schedulePauseOnNextStatement(reason, details) {
|
|
|
|
utils.schedulePauseOnNextStatement(this.id, reason, details);
|
2017-02-27 18:58:55 +00:00
|
|
|
}
|
2017-05-19 00:35:45 +00:00
|
|
|
|
|
|
|
cancelPauseOnNextStatement() {
|
|
|
|
utils.cancelPauseOnNextStatement(this.id);
|
2017-02-27 18:58:55 +00:00
|
|
|
}
|
2017-05-19 00:35:45 +00:00
|
|
|
|
|
|
|
addScript(string, lineOffset, columnOffset, url) {
|
|
|
|
utils.compileAndRunWithOrigin(this.id, string, url || '', lineOffset || 0, columnOffset || 0, false);
|
2017-02-27 18:58:55 +00:00
|
|
|
}
|
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
addModule(string, url, lineOffset, columnOffset) {
|
|
|
|
utils.compileAndRunWithOrigin(this.id, string, url, lineOffset || 0, columnOffset || 0, true);
|
|
|
|
}
|
2017-03-03 12:38:41 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
loadScript(fileName) {
|
|
|
|
this.addScript(utils.read(fileName));
|
|
|
|
}
|
|
|
|
|
|
|
|
connect() {
|
|
|
|
return new InspectorTest.Session(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
setupInjectedScriptEnvironment(debug) {
|
|
|
|
let scriptSource = '';
|
|
|
|
// First define all getters on Object.prototype.
|
|
|
|
let injectedScriptSource = utils.read('src/inspector/injected-script-source.js');
|
|
|
|
let getterRegex = /\.[a-zA-Z0-9]+/g;
|
|
|
|
let match;
|
|
|
|
let getters = new Set();
|
|
|
|
while (match = getterRegex.exec(injectedScriptSource)) {
|
|
|
|
getters.add(match[0].substr(1));
|
|
|
|
}
|
|
|
|
scriptSource += `(function installSettersAndGetters() {
|
|
|
|
let defineProperty = Object.defineProperty;
|
|
|
|
let ObjectPrototype = Object.prototype;\n`;
|
|
|
|
scriptSource += Array.from(getters).map(getter => `
|
|
|
|
defineProperty(ObjectPrototype, '${getter}', {
|
|
|
|
set() { debugger; throw 42; }, get() { debugger; throw 42; },
|
|
|
|
__proto__: null
|
|
|
|
});
|
|
|
|
`).join('\n') + '})();';
|
|
|
|
this.addScript(scriptSource);
|
|
|
|
|
|
|
|
if (debug) {
|
|
|
|
InspectorTest.log('WARNING: setupInjectedScriptEnvironment with debug flag for debugging only and should not be landed.');
|
|
|
|
InspectorTest.log('WARNING: run test with --expose-inspector-scripts flag to get more details.');
|
|
|
|
InspectorTest.log('WARNING: you can additionally comment rjsmin in xxd.py to get unminified injected-script-source.js.');
|
|
|
|
var session = InspectorTest._sessions.next().vale;
|
|
|
|
session.setupScriptMap();
|
|
|
|
sesison.Protocol.Debugger.enable();
|
|
|
|
session.Protocol.Debugger.onPaused(message => {
|
|
|
|
let callFrames = message.params.callFrames;
|
|
|
|
session.logSourceLocations(callFrames.map(frame => frame.location));
|
|
|
|
})
|
2017-01-26 09:32:37 +00:00
|
|
|
}
|
|
|
|
}
|
2017-05-19 00:35:45 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
InspectorTest.Session = class {
|
|
|
|
constructor(contextGroup) {
|
|
|
|
this.contextGroup = contextGroup;
|
|
|
|
this._dispatchTable = new Map();
|
|
|
|
this._eventHandlers = new Map();
|
|
|
|
this._requestId = 0;
|
|
|
|
this.Protocol = this._setupProtocol();
|
|
|
|
InspectorTest._sessions.add(this);
|
|
|
|
this.id = utils.connectSession(contextGroup.id, '', this._dispatchMessage.bind(this));
|
|
|
|
}
|
2017-01-26 09:32:37 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
disconnect() {
|
|
|
|
InspectorTest._sessions.delete(this);
|
|
|
|
utils.disconnectSession(this.id);
|
|
|
|
}
|
2016-10-02 19:41:17 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
reconnect() {
|
|
|
|
var state = utils.disconnectSession(this.id);
|
|
|
|
this.id = utils.connectSession(this.contextGroup.id, state, this._dispatchMessage.bind(this));
|
|
|
|
}
|
2017-06-05 17:37:25 +00:00
|
|
|
|
|
|
|
async addInspectedObject(serializable) {
|
|
|
|
return this.Protocol.Runtime.evaluate({expression: `inspector.addInspectedObject(${this.id}, ${JSON.stringify(serializable)})`});
|
|
|
|
}
|
2016-10-03 21:10:40 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
sendRawCommand(requestId, command, handler) {
|
|
|
|
if (InspectorTest._dumpInspectorProtocolMessages)
|
|
|
|
utils.print("frontend: " + command);
|
|
|
|
this._dispatchTable.set(requestId, handler);
|
|
|
|
utils.sendMessageToBackend(this.id, command);
|
|
|
|
}
|
2017-01-31 00:19:41 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
setupScriptMap() {
|
|
|
|
if (this._scriptMap)
|
|
|
|
return;
|
|
|
|
this._scriptMap = new Map();
|
|
|
|
}
|
2016-10-03 23:32:52 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
logCallFrames(callFrames) {
|
|
|
|
for (var frame of callFrames) {
|
|
|
|
var functionName = frame.functionName || '(anonymous)';
|
|
|
|
var url = frame.url ? frame.url : this._scriptMap.get(frame.location.scriptId).url;
|
|
|
|
var lineNumber = frame.location ? frame.location.lineNumber : frame.lineNumber;
|
|
|
|
var columnNumber = frame.location ? frame.location.columnNumber : frame.columnNumber;
|
|
|
|
InspectorTest.log(`${functionName} (${url}:${lineNumber}:${columnNumber})`);
|
|
|
|
}
|
2016-10-02 19:41:17 +00:00
|
|
|
}
|
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
logSourceLocation(location) {
|
|
|
|
var scriptId = location.scriptId;
|
|
|
|
if (!this._scriptMap || !this._scriptMap.has(scriptId)) {
|
|
|
|
InspectorTest.log("setupScriptMap should be called before Protocol.Debugger.enable.");
|
|
|
|
InspectorTest.completeTest();
|
|
|
|
}
|
|
|
|
var script = this._scriptMap.get(scriptId);
|
|
|
|
if (!script.scriptSource) {
|
|
|
|
return this.Protocol.Debugger.getScriptSource({ scriptId })
|
|
|
|
.then(message => script.scriptSource = message.result.scriptSource)
|
|
|
|
.then(dumpSourceWithLocation);
|
|
|
|
}
|
|
|
|
return Promise.resolve().then(dumpSourceWithLocation);
|
|
|
|
|
|
|
|
function dumpSourceWithLocation() {
|
|
|
|
var lines = script.scriptSource.split('\n');
|
|
|
|
var line = lines[location.lineNumber];
|
|
|
|
line = line.slice(0, location.columnNumber) + '#' + (line.slice(location.columnNumber) || '');
|
|
|
|
lines[location.lineNumber] = line;
|
|
|
|
lines = lines.filter(line => line.indexOf('//# sourceURL=') === -1);
|
|
|
|
InspectorTest.log(lines.slice(Math.max(location.lineNumber - 1, 0), location.lineNumber + 2).join('\n'));
|
|
|
|
InspectorTest.log('');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
logSourceLocations(locations) {
|
|
|
|
if (locations.length == 0) return Promise.resolve();
|
|
|
|
return this.logSourceLocation(locations[0]).then(() => this.logSourceLocations(locations.splice(1)));
|
|
|
|
}
|
|
|
|
|
2017-06-07 12:26:44 +00:00
|
|
|
async logBreakLocations(inputLocations) {
|
|
|
|
let locations = inputLocations.slice();
|
[inspector] moved var initialization break location before init expression (reland)
This CL improves break locations for expressions like 'var a = <expr>'. Without CL we use <expr> position as break location for initialization statement, with this CL we use position of first character after '=' as position.
Benefits (see test for details):
- only one break in expressions which includes mix of property lookup and calls, e.g. var p = Promise.resolve().then(x => x * 2),
- removed redundant break location for expressions like: let { x, y } = { x: 1, y: 2}.
TBR=dgozman@chromium.org,rmcilroy@chromium.org,machenbach@chromium.org,marja@chromium.org,kozyatinskiy@chromium.org,devtools-reviews@chromium.org,v8-reviews@googlegroups.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: v8:5909
Change-Id: Ie84fa79afeed09e28cf8478ba610a0cfbfdfc294
Reviewed-on: https://chromium-review.googlesource.com/518116
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45598}
2017-05-30 12:25:55 +00:00
|
|
|
let scriptId = locations[0].scriptId;
|
|
|
|
let script = this._scriptMap.get(scriptId);
|
|
|
|
if (!script.scriptSource) {
|
|
|
|
let message = await this.Protocol.Debugger.getScriptSource({scriptId});
|
|
|
|
script.scriptSource = message.result.scriptSource;
|
|
|
|
}
|
|
|
|
let lines = script.scriptSource.split('\n');
|
|
|
|
locations = locations.sort((loc1, loc2) => {
|
|
|
|
if (loc2.lineNumber !== loc1.lineNumber) return loc2.lineNumber - loc1.lineNumber;
|
|
|
|
return loc2.columnNumber - loc1.columnNumber;
|
|
|
|
});
|
|
|
|
for (let location of locations) {
|
|
|
|
let line = lines[location.lineNumber];
|
|
|
|
line = line.slice(0, location.columnNumber) + locationMark(location.type) + line.slice(location.columnNumber);
|
|
|
|
lines[location.lineNumber] = line;
|
|
|
|
}
|
|
|
|
lines = lines.filter(line => line.indexOf('//# sourceURL=') === -1);
|
|
|
|
InspectorTest.log(lines.join('\n') + '\n');
|
2017-06-07 12:26:44 +00:00
|
|
|
return inputLocations;
|
[inspector] moved var initialization break location before init expression (reland)
This CL improves break locations for expressions like 'var a = <expr>'. Without CL we use <expr> position as break location for initialization statement, with this CL we use position of first character after '=' as position.
Benefits (see test for details):
- only one break in expressions which includes mix of property lookup and calls, e.g. var p = Promise.resolve().then(x => x * 2),
- removed redundant break location for expressions like: let { x, y } = { x: 1, y: 2}.
TBR=dgozman@chromium.org,rmcilroy@chromium.org,machenbach@chromium.org,marja@chromium.org,kozyatinskiy@chromium.org,devtools-reviews@chromium.org,v8-reviews@googlegroups.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: v8:5909
Change-Id: Ie84fa79afeed09e28cf8478ba610a0cfbfdfc294
Reviewed-on: https://chromium-review.googlesource.com/518116
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45598}
2017-05-30 12:25:55 +00:00
|
|
|
|
|
|
|
function locationMark(type) {
|
|
|
|
if (type === 'return') return '|R|';
|
|
|
|
if (type === 'call') return '|C|';
|
|
|
|
if (type === 'debuggerStatement') return '|D|';
|
|
|
|
return '|_|';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
logAsyncStackTrace(asyncStackTrace) {
|
|
|
|
while (asyncStackTrace) {
|
|
|
|
if (asyncStackTrace.promiseCreationFrame) {
|
|
|
|
var frame = asyncStackTrace.promiseCreationFrame;
|
|
|
|
InspectorTest.log(`-- ${asyncStackTrace.description} (${frame.url}:${frame.lineNumber}:${frame.columnNumber})--`);
|
|
|
|
} else {
|
|
|
|
InspectorTest.log(`-- ${asyncStackTrace.description} --`);
|
|
|
|
}
|
|
|
|
this.logCallFrames(asyncStackTrace.callFrames);
|
|
|
|
asyncStackTrace = asyncStackTrace.parent;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
_sendCommandPromise(method, params) {
|
|
|
|
if (InspectorTest._commandsForLogging.has(method))
|
|
|
|
utils.print(method + ' called');
|
|
|
|
var requestId = ++this._requestId;
|
|
|
|
var messageObject = { "id": requestId, "method": method, "params": params };
|
|
|
|
return new Promise(fulfill => this.sendRawCommand(requestId, JSON.stringify(messageObject), fulfill));
|
|
|
|
}
|
|
|
|
|
|
|
|
_setupProtocol() {
|
|
|
|
return new Proxy({}, { get: (target, agentName, receiver) => new Proxy({}, {
|
|
|
|
get: (target, methodName, receiver) => {
|
|
|
|
const eventPattern = /^on(ce)?([A-Z][A-Za-z0-9]+)/;
|
|
|
|
var match = eventPattern.exec(methodName);
|
|
|
|
if (!match)
|
|
|
|
return args => this._sendCommandPromise(`${agentName}.${methodName}`, args || {});
|
|
|
|
var eventName = match[2];
|
|
|
|
eventName = eventName.charAt(0).toLowerCase() + eventName.slice(1);
|
|
|
|
if (match[1])
|
|
|
|
return () => this._waitForEventPromise(`${agentName}.${eventName}`);
|
|
|
|
return listener => this._eventHandlers.set(`${agentName}.${eventName}`, listener);
|
|
|
|
}
|
|
|
|
})});
|
|
|
|
}
|
|
|
|
|
|
|
|
_dispatchMessage(messageString) {
|
|
|
|
var messageObject = JSON.parse(messageString);
|
|
|
|
if (InspectorTest._dumpInspectorProtocolMessages)
|
|
|
|
utils.print("backend: " + JSON.stringify(messageObject));
|
|
|
|
try {
|
|
|
|
var messageId = messageObject["id"];
|
|
|
|
if (typeof messageId === "number") {
|
|
|
|
var handler = this._dispatchTable.get(messageId);
|
|
|
|
if (handler) {
|
|
|
|
handler(messageObject);
|
|
|
|
this._dispatchTable.delete(messageId);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
var eventName = messageObject["method"];
|
|
|
|
var eventHandler = this._eventHandlers.get(eventName);
|
|
|
|
if (this._scriptMap && eventName === "Debugger.scriptParsed")
|
|
|
|
this._scriptMap.set(messageObject.params.scriptId, JSON.parse(JSON.stringify(messageObject.params)));
|
|
|
|
if (eventName === "Debugger.scriptParsed" && messageObject.params.url === "wait-for-pending-tasks.js")
|
|
|
|
return;
|
|
|
|
if (eventHandler)
|
|
|
|
eventHandler(messageObject);
|
|
|
|
}
|
|
|
|
} catch (e) {
|
|
|
|
InspectorTest.log("Exception when dispatching message: " + e + "\n" + e.stack + "\n message = " + JSON.stringify(messageObject, null, 2));
|
|
|
|
InspectorTest.completeTest();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
_waitForEventPromise(eventName) {
|
|
|
|
return new Promise(fulfill => {
|
|
|
|
this._eventHandlers.set(eventName, result => {
|
|
|
|
delete this._eventHandlers.delete(eventName);
|
|
|
|
fulfill(result);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
};
|
2016-12-13 19:40:14 +00:00
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
InspectorTest.runTestSuite = function(testSuite) {
|
|
|
|
function nextTest() {
|
2016-10-02 19:41:17 +00:00
|
|
|
if (!testSuite.length) {
|
|
|
|
InspectorTest.completeTest();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
var fun = testSuite.shift();
|
|
|
|
InspectorTest.log("\nRunning test: " + fun.name);
|
|
|
|
fun(nextTest);
|
|
|
|
}
|
|
|
|
nextTest();
|
|
|
|
}
|
2016-10-03 23:32:52 +00:00
|
|
|
|
2017-03-06 16:28:21 +00:00
|
|
|
InspectorTest.runAsyncTestSuite = async function(testSuite) {
|
|
|
|
for (var test of testSuite) {
|
|
|
|
InspectorTest.log("\nRunning test: " + test.name);
|
2017-05-18 23:11:20 +00:00
|
|
|
try {
|
|
|
|
await test();
|
|
|
|
} catch (e) {
|
|
|
|
utils.print(e.stack);
|
|
|
|
}
|
2017-03-06 16:28:21 +00:00
|
|
|
}
|
|
|
|
InspectorTest.completeTest();
|
|
|
|
}
|
|
|
|
|
2017-05-19 00:35:45 +00:00
|
|
|
InspectorTest.start = function(description) {
|
|
|
|
try {
|
|
|
|
InspectorTest.log(description);
|
|
|
|
var contextGroup = new InspectorTest.ContextGroup();
|
|
|
|
var session = contextGroup.connect();
|
|
|
|
return { session: session, contextGroup: contextGroup, Protocol: session.Protocol };
|
|
|
|
} catch (e) {
|
|
|
|
utils.print(e.stack);
|
2016-10-03 23:32:52 +00:00
|
|
|
}
|
|
|
|
}
|