ff1d32c19794b69066df91fac1a40c708312d03f
[WebKit-https.git] / LayoutTests / http / tests / inspector-protocol / resources / InspectorTest.js
1 /*
2  * Copyright (C) 2012 Samsung Electronics. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25 InspectorFrontendAPI = {};
26
27 InspectorTest = {};
28 InspectorTest._dispatchTable = [];
29 InspectorTest._requestId = -1;
30 InspectorTest.eventHandler = {};
31
32 /**
33  * @param {string} method
34  * @param {object} params
35  * @param {function({object} messageObject)=} handler
36  */
37 InspectorTest.sendCommand = function(method, params, handler)
38 {
39     this._dispatchTable[++this._requestId] = handler;
40
41     var messageObject = { "method": method,
42                           "params": params,
43                           "id": this._requestId };
44
45     InspectorFrontendHost.sendMessageToBackend(JSON.stringify(messageObject));
46
47     return this._requestId;
48 }
49
50 /**
51  * @param {object} messageObject
52  */
53 InspectorFrontendAPI.dispatchMessageAsync = function(messageObject)
54 {
55     var messageId = messageObject["id"];
56     if (typeof messageId === "number") {
57         var handler = InspectorTest._dispatchTable[messageId];
58         if (handler && typeof handler === "function")
59             handler(messageObject);
60     } else {
61         var eventName = messageObject["method"];
62         var eventHandler = InspectorTest.eventHandler[eventName];
63         if (eventHandler)
64             eventHandler(messageObject);
65         else if (InspectorTest.defaultEventHandler)
66             InspectorTest.defaultEventHandler(messageObject);
67     }
68 }
69
70 /**
71 * Registers an event handler for messages coming from the InspectorBackend.
72 * If multiple callbacks are registered for the same event, it will chain the execution.
73 * @param {string} event name
74 * @param {function} handler to be executed
75 * @param {boolean} execute the handler before all other handlers
76 */
77 InspectorTest.addEventListener = function(eventName, callback, capture)
78 {
79     if (!InspectorTest.eventHandler[eventName]) {
80         InspectorTest.eventHandler[eventName] = callback;
81         return;
82     }
83     var firstHandler = InspectorTest.eventHandler[eventName];
84     var secondHandler = callback;
85     if (capture) {
86         // Swap firstHandler with the new callback, so that we execute the callback first.
87         [firstHandler, secondHandler] = [secondHandler, firstHandler];
88     }
89     InspectorTest.eventHandler[eventName] = function(messageObject)
90     {
91         firstHandler(messageObject);
92         secondHandler(messageObject);
93     };
94 }
95
96 /**
97 * Logs message to document.
98 * @param {string} message
99 */
100 InspectorTest.log = function(message)
101 {
102     this.sendCommand("Runtime.evaluate", { "expression": "log(" + JSON.stringify(message) + ")" } );
103 }
104
105 /**
106 * Logs an assert message to document.
107 * @param {boolean} condition
108 * @param {string} message
109 */
110 InspectorTest.assert = function(condition, message)
111 {
112     var status = condition ? "PASS" : "FAIL";
113     this.sendCommand("Runtime.evaluate", { "expression": "log(" + JSON.stringify(status + ": " + message) + ")" } );
114 }
115
116 /**
117 * Logs message directly to process stdout via alert function (hopefully followed by flush call).
118 * This message should survive process crash or kill by timeout.
119 * @param {string} message
120 */
121 InspectorTest.debugLog = function(message)
122 {
123     this.sendCommand("Runtime.evaluate", { "expression": "debugLog(" + JSON.stringify(message) + ")" } );
124 }
125
126 InspectorTest.completeTest = function()
127 {
128     this.sendCommand("Runtime.evaluate", { "expression": "closeTest();"} );
129 }
130
131 InspectorTest.checkForError = function(responseObject)
132 {
133     if (responseObject.error) {
134         InspectorTest.log("PROTOCOL ERROR: " + JSON.stringify(responseObject.error));
135         InspectorTest.completeTest();
136         throw "PROTOCOL ERROR";
137     }
138 }
139
140 /**
141  * @param {string} scriptName
142  */
143 InspectorTest.importScript = function(scriptName)
144 {
145     var xhr = new XMLHttpRequest();
146     xhr.open("GET", scriptName, false);
147     xhr.send(null);
148     if (xhr.status !== 0 && xhr.status !== 200)
149         throw new Error("Invalid script URL: " + scriptName);
150     var script = "try { " + xhr.responseText + "} catch (e) { alert(" + JSON.stringify("Error in: " + scriptName) + "); throw e; }";
151     window.eval(script);
152 }
153
154 InspectorTest.importInspectorScripts = function()
155 {
156     // Catch any errors and finish the test early.
157     console.error = window.onerror = function()
158     {
159         console.log(Array.prototype.join.call(arguments, ', '));
160         InspectorTest.completeTest();
161     };
162
163     console.assert = function(assertion, message)
164     {
165         if (assertion)
166             return;
167         console.log("ASSERT:" + message);
168         InspectorTest.completeTest();
169     };
170
171     // Note: This function overwrites the InspectorFrontendAPI, so there's currently no
172     // way to intercept the messages from the backend.
173
174     var inspectorScripts = [
175         "Utilities",
176         "WebInspector",
177         "Object",
178         "InspectorBackend",
179         "InspectorFrontendAPI",
180         "InspectorFrontendHostStub",
181         "InspectorJSBackendCommands",
182         "InspectorWebBackendCommands",
183         "URLUtilities",
184         "MessageDispatcher",
185         "Setting",
186         "PageObserver",
187         "DOMObserver",
188         "CSSObserver",
189         "FrameResourceManager",
190         "RuntimeManager",
191         "Frame",
192         "Revision",
193         "SourceCodeRevision",
194         "SourceCode",
195         "Resource",
196         "ResourceCollection",
197         "DOMTreeManager",
198         "DOMNode",
199         "ContentFlow",
200         "DOMTree",
201         "DOMUtilities",
202         "ExecutionContext",
203         "ExecutionContextList",
204         "CSSStyleManager",
205         "Color",
206         "RuntimeObserver",
207         "RuntimeManager"
208     ];
209     for (var i = 0; i < inspectorScripts.length; ++i)
210         InspectorTest.importScript("../../../../../Source/WebInspectorUI/UserInterface/" + inspectorScripts[i] + ".js");
211
212     // The initialization should be in sync with WebInspector.loaded in Main.js.
213     // FIXME: As soon as we can support all the observers and managers we should remove UI related tasks
214     // from WebInspector.loaded, so that it can be used from the LayoutTests.
215
216     InspectorBackend.registerPageDispatcher(new WebInspector.PageObserver);
217     InspectorBackend.registerDOMDispatcher(new WebInspector.DOMObserver);
218     InspectorBackend.registerCSSDispatcher(new WebInspector.CSSObserver);
219     if (InspectorBackend.registerRuntimeDispatcher)
220         InspectorBackend.registerRuntimeDispatcher(new WebInspector.RuntimeObserver);
221
222     WebInspector.frameResourceManager = new WebInspector.FrameResourceManager;
223     WebInspector.domTreeManager = new WebInspector.DOMTreeManager;
224     WebInspector.cssStyleManager = new WebInspector.CSSStyleManager;
225     WebInspector.runtimeManager = new WebInspector.RuntimeManager;
226
227     InspectorFrontendHost.loaded();
228 }
229
230
231 window.addEventListener("message", function(event) {
232     try {
233         eval(event.data);
234     } catch (e) {
235         alert(e.stack);
236         InspectorTest.completeTest();
237         throw e;
238     }
239 });