[inspector] added reconnect method for tests

test/inspector/protocol-test.js

 // 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._dispatchTable = new Map();
 InspectorTest._requestId = 0;
 InspectorTest._dumpInspectorProtocolMessages = false;
 InspectorTest._eventHandler = {};
 
@@ skipping 12 matching lines @@
             return () => InspectorTest._waitForEventPromise(
                        `${agentName}.${eventName}`);
           else
             return (listener) => { InspectorTest._eventHandler[`${agentName}.${eventName}`] = listener };
         }
       }
     });
   }
 });
 
-InspectorTest.log = print.bind(null);
+var utils = {};
+(function setupUtils() {
+  utils.load = load;
+  this.load = null;
+  utils.compileAndRunWithOrigin = compileAndRunWithOrigin;
+  this.compileAndRunWithOrigin = null;
+  utils.quit = quit;
+  this.quit = null;
+  utils.print = print;
+  this.print = null;
+  utils.setlocale = setlocale;
+  this.setlocale = null;
+  utils.setCurrentTimeMSForTest = setCurrentTimeMSForTest;
+  this.setCurrentTimeMSForTest = null;
+  utils.schedulePauseOnNextStatement = schedulePauseOnNextStatement;
+  this.schedulePauseOnNextStatement = null;
+  utils.cancelPauseOnNextStatement = cancelPauseOnNextStatement;
+  this.cancelPauseOnNextStatement = null;
+  utils.reconnect = reconnect;
+  this.reconnect = null;
+})();
+
+InspectorTest.log = utils.print.bind(null);
 
 InspectorTest.logMessage = function(originalMessage)
 {
   var message = JSON.parse(JSON.stringify(originalMessage));
   if (message.id)
     message.id = "<messageId>";
 
-  const nonStableFields = new Set(["objectId", "scriptId", "exceptionId", "timestamp", "executionContextId", "callFrameId", "breakpointId"]);
+  const nonStableFields = new Set(["objectId", "scriptId", "exceptionId", "timestamp",
+    "executionContextId", "callFrameId", "breakpointId", "bindRemoteObjectFunctionId", "formatterObjectId" ]);
   var objects = [ message ];
   while (objects.length) {
     var object = objects.shift();
     for (var key in object) {
       if (nonStableFields.has(key))
         object[key] = `<${key}>`;
       else if (typeof object[key] === "object")
         objects.push(object[key]);
     }
   }
@@ skipping 69 matching lines @@
       InspectorTest.log(`-- ${asyncStackTrace.description} (${frame.url
                         }:${frame.lineNumber}:${frame.columnNumber})--`);
     } else {
       InspectorTest.log(`-- ${asyncStackTrace.description} --`);
     }
     InspectorTest.logCallFrames(asyncStackTrace.callFrames);
     asyncStackTrace = asyncStackTrace.parent;
   }
 }
 
-InspectorTest.completeTest = function()
-{
-  Protocol.Debugger.disable().then(() => quit());
-}
+InspectorTest.completeTest = () => Protocol.Debugger.disable().then(() => utils.quit());
 
 InspectorTest.completeTestAfterPendingTimeouts = function()
 {
   InspectorTest.waitPendingTasks().then(InspectorTest.completeTest);
 }
 
 InspectorTest.waitPendingTasks = function()
 {
   return Protocol.Runtime.evaluate({ expression: "new Promise(r => setTimeout(r, 0))//# sourceURL=wait-pending-tasks.js", awaitPromise: true });
 }
 
-InspectorTest.addScript = (string, lineOffset, columnOffset) => compileAndRunWithOrigin(string, "", lineOffset || 0, columnOffset || 0, false);
-InspectorTest.addScriptWithUrl = (string, url) => compileAndRunWithOrigin(string, url, 0, 0, false);
-InspectorTest.addModule = (string, url, lineOffset, columnOffset) => compileAndRunWithOrigin(string, url, lineOffset || 0, columnOffset || 0, true);
+InspectorTest.addScript = (string, lineOffset, columnOffset) => utils.compileAndRunWithOrigin(string, "", lineOffset || 0, columnOffset || 0, false);
+InspectorTest.addScriptWithUrl = (string, url) => utils.compileAndRunWithOrigin(string, url, 0, 0, false);
+InspectorTest.addModule = (string, url, lineOffset, columnOffset) => utils.compileAndRunWithOrigin(string, url, lineOffset || 0, columnOffset || 0, true);
 
 InspectorTest.startDumpingProtocolMessages = function()
 {
   InspectorTest._dumpInspectorProtocolMessages = true;
 }
 
 InspectorTest.sendRawCommand = function(requestId, command, handler)
 {
   if (InspectorTest._dumpInspectorProtocolMessages)
-    print("frontend: " + command);
+    utils.print("frontend: " + command);
   InspectorTest._dispatchTable.set(requestId, handler);
   sendMessageToBackend(command);
 }
 
 InspectorTest.checkExpectation = function(fail, name, messageObject)
 {
   if (fail === !!messageObject.error) {
     InspectorTest.log("PASS: " + name);
     return true;
   }
@@ skipping 43 matching lines @@
   function fullfillAndClearListener(fulfill, result)
   {
     delete InspectorTest._eventHandler[eventName];
     fulfill(result);
   }
 }
 
 InspectorTest._dispatchMessage = function(messageObject)
 {
   if (InspectorTest._dumpInspectorProtocolMessages)
-    print("backend: " + JSON.stringify(messageObject));
+    utils.print("backend: " + JSON.stringify(messageObject));
   try {
     var messageId = messageObject["id"];
     if (typeof messageId === "number") {
       var handler = InspectorTest._dispatchTable.get(messageId);
       if (handler) {
         handler(messageObject);
         InspectorTest._dispatchTable.delete(messageId);
       }
     } else {
       var eventName = messageObject["method"];
       var eventHandler = InspectorTest._eventHandler[eventName];
       if (InspectorTest._scriptMap && eventName === "Debugger.scriptParsed")
         InspectorTest._scriptMap.set(messageObject.params.scriptId, JSON.parse(JSON.stringify(messageObject.params)));
       if (eventName === "Debugger.scriptParsed" && messageObject.params.url === "wait-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();
   }
 }