[inspector] added inspector protocol test runner

test/inspector-protocol/protocol-test.js

Index: test/inspector-protocol/protocol-test.js
diff --git a/test/inspector-protocol/protocol-test.js b/test/inspector-protocol/protocol-test.js
new file mode 100644
index 0000000000000000000000000000000000000000..8df10d46e2a5f2f38e21c61f10b0633cdc589142
--- /dev/null
+++ b/test/inspector-protocol/protocol-test.js
@@ -0,0 +1,209 @@
+// 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 = [];
+InspectorTest._requestId = -1;
+InspectorTest._dumpInspectorProtocolMessages = false;
+InspectorTest.eventHandler = {};
+
+InspectorTest.startDumpingProtocolMessages = function()
+{
+    InspectorTest._dumpInspectorProtocolMessages = true;
+}
+
+InspectorTest.sendCommand = function(method, params, handler)
+{
+    this._dispatchTable[++this._requestId] = handler;
+    var messageObject = { "id": this._requestId, "method": method, "params": params };
+    if (InspectorTest._dumpInspectorProtocolMessages)
+        print("frontend: " + JSON.stringify(messageObject));
+    sendMessageToBackend(JSON.stringify(messageObject));
+    return this._requestId;
+}
+
+InspectorTest.sendCommandOrDie = function(command, properties, callback)
+{
+    InspectorTest.sendCommand(command, properties || {}, commandCallback);
+    function commandCallback(msg)
+    {
+        if (msg.error) {
+            InspectorTest.log("ERROR: " + msg.error.message);
+            InspectorTest.completeTest();
+            return;
+        }
+        if (callback)
+            callback(msg.result);
+    }
+}
+
+InspectorTest.sendCommandPromise = function(method, params)
+{
+    var callback;
+    var promise = new Promise(fulfill => callback = fulfill);
+    InspectorTest.sendCommand(method, params, callback);
+    return promise;
+}
+
+InspectorTest.waitForEventPromise = function(eventName)
+{
+    return new Promise(fulfill => InspectorTest.eventHandler[eventName] = fullfillAndClearListener.bind(null, fulfill));
+
+    function fullfillAndClearListener(fulfill, result)
+    {
+        fulfill(result);
+        delete InspectorTest.eventHandler[eventName];
+    }
+}
+
+InspectorTest.runTestSuite = function(testSuite)
+{
+    function nextTest()
+    {
+        if (!testSuite.length) {
+            InspectorTest.completeTest();
+            return;
+        }
+        var fun = testSuite.shift();
+        InspectorTest.log("\nRunning test: " + fun.name);
+        fun(nextTest);
+    }
+
+    nextTest();
+}
+
+/**
+ * @param {string} command
+ * @param {function({object} messageObject)=} handler
+ */
+InspectorTest.sendRawCommand = function(command, handler)
+{
+    this._dispatchTable[++this._requestId] = handler;
+    sendMessageToBackend(command);
+    return this._requestId;
+}
+
+/**
+ * @param {string|!Object} messageOrObject
+ */
+dispatchMessage = function(messageOrObject)
+{
+    var messageObject = (typeof messageOrObject === "string" ? JSON.parse(messageOrObject) : messageOrObject);
+    if (InspectorTest._dumpInspectorProtocolMessages)
+        print("backend: " + JSON.stringify(messageObject));
+    var messageId = messageObject["id"];
+    try {
+        if (typeof messageId === "number") {
+            var handler = InspectorTest._dispatchTable[messageId];
+            if (handler && typeof handler === "function") {
+                handler(messageObject);
+            }
+        } else {
+            var eventName = messageObject["method"];
+            var eventHandler = InspectorTest.eventHandler[eventName];
+            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();
+    }
+}
+
+/**
+* Logs message to document.
+* @param {string} message
+*/
+InspectorTest.log = function(message)
+{
+    print(message);
+}
+
+/**
+* Formats and logs object.
+* @param {Object} object
+* @param {string=} title
+*/
+InspectorTest.logObject = function(object, title)
+{
+    var lines = [];
+
+    function dumpValue(value, prefix, prefixWithName)
+    {
+        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, " "));
+        }
+    }
+
+    function dumpProperties(object, prefix, firstLinePrefix)
+    {
+        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 + "}");
+    }
+
+    function dumpItems(object, prefix, firstLinePrefix)
+    {
+        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 + "]");
+    }
+
+    dumpValue(object, "", title);
+    InspectorTest.log(lines.join("\n"));
+}
+
+InspectorTest.completeTest = function()
+{
+    quit();
+}
+
+/**
+ * Evaluates string in page.
+ * @param {string} message
+ * @param {!function} callback
+ */
+InspectorTest.evaluateInPage = function(string, callback)
+{
+    this.sendCommand("Runtime.evaluate", { "expression": string }, function(message) {
+        if (message.error)
+            InspectorTest.log("Error while executing '" + string + "': " + message.error.message);
+        else if (callback)
+            callback(message.result.result.value);
+    });
+};
+
+InspectorTest.checkExpectation = function(fail, name, messageObject)
+{
+    if (fail === !!messageObject.error) {
+        InspectorTest.log("PASS: " + name);
+        return true;
+    }
+
+    InspectorTest.log("FAIL: " + name + ": " + JSON.stringify(messageObject));
+    InspectorTest.completeTest();
+    return false;
+}
+InspectorTest.expectedSuccess = InspectorTest.checkExpectation.bind(null, false);
+InspectorTest.expectedError = InspectorTest.checkExpectation.bind(null, true);