1 /*

     2  * Copyright (C) 2010 Google Inc. 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 are

     6  * met:

     7  *

     8  *     * Redistributions of source code must retain the above copyright

     9  * notice, this list of conditions and the following disclaimer.

    10  *     * Redistributions in binary form must reproduce the above

    11  * copyright notice, this list of conditions and the following disclaimer

    12  * in the documentation and/or other materials provided with the

    13  * distribution.

    14  *     * Neither the name of Google Inc. nor the names of its

    15  * contributors may be used to endorse or promote products derived from

    16  * this software without specific prior written permission.

    17  *

    18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

    19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

    20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

    21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

    22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

    23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

    24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

    25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

    26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    29  */

    30 

    31 

    32 /**

    33  * @fileoverview This file contains small testing framework along with the

    34  * test suite for the frontend. These tests are a part of the continues build

    35  * and are executed by the devtools_sanity_unittest.cc as a part of the

    36  * Interactive UI Test suite.

    37  * FIXME: change field naming style to use trailing underscore.

    38  */

    39 

    40 if (window.domAutomationController) {

    41 

    42 var ___interactiveUiTestsMode = true;

    43 

    44 /**

    45  * Test suite for interactive UI tests.

    46  * @constructor

    47  */

    48 TestSuite = function()

    49 {

    50     this.controlTaken_ = false;

    51     this.timerId_ = -1;

    52 };

    53 

    54 

    55 /**

    56  * Reports test failure.

    57  * @param {string} message Failure description.

    58  */

    59 TestSuite.prototype.fail = function(message)

    60 {

    61     if (this.controlTaken_)

    62         this.reportFailure_(message);

    63     else

    64         throw message;

    65 };

    66 

    67 

    68 /**

    69  * Equals assertion tests that expected === actual.

    70  * @param {Object} expected Expected object.

    71  * @param {Object} actual Actual object.

    72  * @param {string} opt_message User message to print if the test fails.

    73  */

    74 TestSuite.prototype.assertEquals = function(expected, actual, opt_message)

    75 {

    76     if (expected !== actual) {

    77         var message = "Expected: '" + expected + "', but was '" + actual + "'";

    78         if (opt_message)

    79             message = opt_message + "(" + message + ")";

    80         this.fail(message);

    81     }

    82 };

    83 

    84 

    85 /**

    86  * True assertion tests that value == true.

    87  * @param {Object} value Actual object.

    88  * @param {string} opt_message User message to print if the test fails.

    89  */

    90 TestSuite.prototype.assertTrue = function(value, opt_message)

    91 {

    92     this.assertEquals(true, !!value, opt_message);

    93 };

    94 

    95 

    96 /**

    97  * Contains assertion tests that string contains substring.

    98  * @param {string} string Outer.

    99  * @param {string} substring Inner.

   100  */

   101 TestSuite.prototype.assertContains = function(string, substring)

   102 {

   103     if (string.indexOf(substring) === -1)

   104         this.fail("Expected to: '" + string + "' to contain '" + substring + "'");

   105 };

   106 

   107 

   108 /**

   109  * Takes control over execution.

   110  */

   111 TestSuite.prototype.takeControl = function()

   112 {

   113     this.controlTaken_ = true;

   114     // Set up guard timer.

   115     var self = this;

   116     this.timerId_ = setTimeout(function() {

   117         self.reportFailure_("Timeout exceeded: 20 sec");

   118     }, 20000);

   119 };

   120 

   121 

   122 /**

   123  * Releases control over execution.

   124  */

   125 TestSuite.prototype.releaseControl = function()

   126 {

   127     if (this.timerId_ !== -1) {

   128         clearTimeout(this.timerId_);

   129         this.timerId_ = -1;

   130     }

   131     this.reportOk_();

   132 };

   133 

   134 

   135 /**

   136  * Async tests use this one to report that they are completed.

   137  */

   138 TestSuite.prototype.reportOk_ = function()

   139 {

   140     window.domAutomationController.send("[OK]");

   141 };

   142 

   143 

   144 /**

   145  * Async tests use this one to report failures.

   146  */

   147 TestSuite.prototype.reportFailure_ = function(error)

   148 {

   149     if (this.timerId_ !== -1) {

   150         clearTimeout(this.timerId_);

   151         this.timerId_ = -1;

   152     }

   153     window.domAutomationController.send("[FAILED] " + error);

   154 };

   155 

   156 

   157 /**

   158  * Runs all global functions starting with "test" as unit tests.

   159  */

   160 TestSuite.prototype.runTest = function(testName)

   161 {

   162     try {

   163         this[testName]();

   164         if (!this.controlTaken_)

   165             this.reportOk_();

   166     } catch (e) {

   167         this.reportFailure_(e);

   168     }

   169 };

   170 

   171 

   172 /**

   173  * @param {string} panelName Name of the panel to show.

   174  */

   175 TestSuite.prototype.showPanel = function(panelName)

   176 {

   177     // Open Scripts panel.

   178     var toolbar = document.getElementById("toolbar");

   179     var button = toolbar.getElementsByClassName(panelName)[0];

   180     button.click();

   181     this.assertEquals(WebInspector.panels[panelName], WebInspector.currentPanel);

   182 };

   183 

   184 

   185 /**

   186  * Overrides the method with specified name until it's called first time.

   187  * @param {Object} receiver An object whose method to override.

   188  * @param {string} methodName Name of the method to override.

   189  * @param {Function} override A function that should be called right after the

   190  *     overriden method returns.

   191  * @param {boolean} opt_sticky Whether restore original method after first run

   192  *     or not.

   193  */

   194 TestSuite.prototype.addSniffer = function(receiver, methodName, override, opt_sticky)

   195 {

   196     var orig = receiver[methodName];

   197     if (typeof orig !== "function")

   198         this.fail("Cannot find method to override: " + methodName);

   199     var test = this;

   200     receiver[methodName] = function(var_args) {

   201         try {

   202             var result = orig.apply(this, arguments);

   203         } finally {

   204             if (!opt_sticky)

   205                 receiver[methodName] = orig;

   206         }

   207         // In case of exception the override won't be called.

   208         try {

   209             override.apply(this, arguments);

   210         } catch (e) {

   211             test.fail("Exception in overriden method '" + methodName + "': " + e);

   212         }

   213         return result;

   214     };

   215 };

   216 

   217 

   218 // UI Tests

   219 

   220 

   221 /**

   222  * Tests that the real injected host is present in the context.

   223  */

   224 TestSuite.prototype.testHostIsPresent = function()

   225 {

   226     this.assertTrue(typeof InspectorFrontendHost === "object" && !InspectorFrontendHost.isStub);

   227 };

   228 

   229 

   230 /**

   231  * Tests elements tree has an "HTML" root.

   232  */

   233 TestSuite.prototype.testElementsTreeRoot = function()

   234 {

   235     var doc = WebInspector.domAgent.document;

   236     this.assertEquals("HTML", doc.documentElement.nodeName);

   237     this.assertTrue(doc.documentElement.hasChildNodes());

   238 };

   239 

   240 

   241 /**

   242  * Tests that main resource is present in the system and that it is

   243  * the only resource.

   244  */

   245 TestSuite.prototype.testMainResource = function()

   246 {

   247     var tokens = [];

   248     var resources = WebInspector.resources;

   249     for (var id in resources)

   250         tokens.push(resources[id].lastPathComponent);

   251     this.assertEquals("simple_page.html", tokens.join(","));

   252 };

   253 

   254 

   255 /**

   256  * Tests that resources tab is enabled when corresponding item is selected.

   257  */

   258 TestSuite.prototype.testEnableResourcesTab = function()

   259 {

   260     this.showPanel("resources");

   261 

   262     var test = this;

   263     this.addSniffer(WebInspector, "updateResource",

   264         function(identifier, payload) {

   265             test.assertEquals("simple_page.html", payload.lastPathComponent);

   266             WebInspector.panels.resources.refresh();

   267             WebInspector.panels.resources.revealAndSelectItem(WebInspector.resources[identifier]);

   268 

   269             test.releaseControl();

   270         });

   271 

   272     // Following call should lead to reload that we capture in the

   273     // addResource override.

   274     WebInspector.panels.resources._enableResourceTracking();

   275 

   276     // We now have some time to report results to controller.

   277     this.takeControl();

   278 };

   279 

   280 

   281 /**

   282  * Tests that correct content length is reported for resources.

   283  */

   284 TestSuite.prototype.testResourceContentLength = function()

   285 {

   286     this.showPanel("resources");

   287     var test = this;

   288 

   289     var png = false;

   290     var html = false;

   291     this.addSniffer(WebInspector, "updateResource",

   292         function(identifier, payload) {

   293             if (!payload.didLengthChange)

   294                 return;

   295             var resource = WebInspector.resources[identifier];

   296             if (!resource || !resource.url)

   297                 return;

   298             if (resource.url.search("image.html") !== -1) {

   299               var expectedLength = 87;

   300               test.assertTrue(

   301                   resource.resourceSize <= expectedLength,

   302                   "image.html content length is greater thatn expected.");

   303               if (expectedLength === resource.resourceSize)

   304                   html = true;

   305             } else if (resource.url.search("image.png") !== -1) {

   306               var expectedLength = 257796;

   307               test.assertTrue(

   308                   resource.resourceSize <= expectedLength,

   309                   "image.png content length is greater than expected.");

   310               if (expectedLength === resource.resourceSize)

   311                   png = true;

   312             }

   313             if (html && png) {

   314               // Wait 1 second before releasing control to check that the content

   315               // lengths are not updated anymore.

   316               setTimeout(function() {

   317                   test.releaseControl();

   318               }, 1000);

   319             }

   320         }, true);

   321 

   322     // Make sure resource tracking is on.

   323     WebInspector.panels.resources._enableResourceTracking();

   324     // Reload inspected page to update all resources.

   325     test.evaluateInConsole_(

   326         "window.location.reload(true);",

   327          function(resultText) {

   328              test.assertEquals("undefined", resultText, "Unexpected result of reload().");

   329          });

   330 

   331     // We now have some time to report results to controller.

   332     this.takeControl();

   333 };

   334 

   335 

   336 /**

   337  * Tests resource headers.

   338  */

   339 TestSuite.prototype.testResourceHeaders = function()

   340 {

   341     this.showPanel("resources");

   342 

   343     var test = this;

   344 

   345     var responseOk = false;

   346     var timingOk = false;

   347 

   348     this.addSniffer(WebInspector, "updateResource",

   349         function(identifier, payload) {

   350             var resource = this.resources[identifier];

   351             if (!resource || resource.mainResource) {

   352                 // We are only interested in secondary resources in this test.

   353                 return;

   354             }

   355 

   356             var requestHeaders = JSON.stringify(resource.requestHeaders);

   357             test.assertContains(requestHeaders, "Accept");

   358 

   359             if (payload.didResponseChange) {

   360                 var responseHeaders = JSON.stringify(resource.responseHeaders);

   361                 test.assertContains(responseHeaders, "Content-type");

   362                 test.assertContains(responseHeaders, "Content-Length");

   363                 test.assertTrue(typeof resource.responseReceivedTime !== "undefined");

   364                 responseOk = true;

   365             }

   366 

   367             if (payload.didTimingChange) {

   368                 test.assertTrue(typeof resource.startTime !== "undefined");

   369                 timingOk = true;

   370             }

   371 

   372             if (payload.didCompletionChange) {

   373                 test.assertTrue(responseOk);

   374                 test.assertTrue(timingOk);

   375                 test.assertTrue(typeof resource.endTime !== "undefined");

   376                 test.releaseControl();

   377             }

   378         }, true);

   379 

   380     WebInspector.panels.resources._enableResourceTracking();

   381     this.takeControl();

   382 };

   383 

   384 

   385 /**

   386  * Tests the mime type of a cached (HTTP 304) resource.

   387  */

   388 TestSuite.prototype.testCachedResourceMimeType = function()

   389 {

   390     this.showPanel("resources");

   391 

   392     var test = this;

   393     var hasReloaded = false;

   394 

   395     this.addSniffer(WebInspector, "updateResource",

   396         function(identifier, payload) {

   397             var resource = this.resources[identifier];

   398             if (!resource || resource.mainResource) {

   399                 // We are only interested in secondary resources in this test.

   400                 return;

   401             }

   402 

   403             if (payload.didResponseChange) {

   404                 // Test server uses a default mime type for JavaScript files.

   405                 test.assertEquals("text/html", payload.mimeType);

   406                 if (!hasReloaded) {

   407                     hasReloaded = true;

   408                     // Reload inspected page to update all resources.

   409                     test.evaluateInConsole_("window.location.reload(true);", function() {});

   410                 } else

   411                     test.releaseControl();

   412             }

   413 

   414         }, true);

   415 

   416     WebInspector.panels.resources._enableResourceTracking();

   417     this.takeControl();

   418 };

   419 

   420 

   421 /**

   422  * Tests that profiler works.

   423  */

   424 TestSuite.prototype.testProfilerTab = function()

   425 {

   426     this.showPanel("profiles");

   427 

   428     var panel = WebInspector.panels.profiles;

   429     var test = this;

   430 

   431     function findDisplayedNode() {

   432         var node = panel.visibleView.profileDataGridTree.children[0];

   433         if (!node) {

   434             // Profile hadn't been queried yet, re-schedule.

   435             window.setTimeout(findDisplayedNode, 100);

   436             return;

   437         }

   438 

   439         // Iterate over displayed functions and search for a function

   440         // that is called "fib" or "eternal_fib". If found, this will mean

   441         // that we actually have profiled page's code.

   442         while (node) {

   443             if (node.functionName.indexOf("fib") !== -1)

   444                 test.releaseControl();

   445             node = node.traverseNextNode(true, null, true);

   446         }

   447 

   448         test.fail();

   449     }

   450 

   451     function findVisibleView() {

   452         if (!panel.visibleView) {

   453             setTimeout(findVisibleView, 0);

   454             return;

   455         }

   456         setTimeout(findDisplayedNode, 0);

   457     }

   458 

   459     findVisibleView();

   460     this.takeControl();

   461 };

   462 

   463 

   464 /**

   465  * Tests that heap profiler works.

   466  */

   467 TestSuite.prototype.testHeapProfiler = function()

   468 {

   469     this.showPanel("profiles");

   470 

   471     var panel = WebInspector.panels.profiles;

   472     var test = this;

   473 

   474     function findDisplayedNode() {

   475         var node = panel.visibleView.dataGrid.children[0];

   476         if (!node) {

   477             // Profile hadn't been queried yet, re-schedule.

   478             window.setTimeout(findDisplayedNode, 100);

   479             return;

   480         }

   481 

   482         // Iterate over displayed functions and find node called "A"

   483         // If found, this will mean that we actually have taken heap snapshot.

   484         while (node) {

   485             if (node.constructorName.indexOf("A") !== -1) {

   486                 test.releaseControl();

   487                 return;

   488             }

   489             node = node.traverseNextNode(false, null, true);

   490         }

   491 

   492         test.fail();

   493     }

   494 

   495     function findVisibleView() {

   496         if (!panel.visibleView) {

   497             setTimeout(findVisibleView, 0);

   498             return;

   499         }

   500         setTimeout(findDisplayedNode, 0);

   501     }

   502 

   503     WebInspector.HeapSnapshotProfileType.prototype.buttonClicked();

   504     findVisibleView();

   505     this.takeControl();

   506 };

   507 

   508 

   509 /**

   510  * Tests that scripts tab can be open and populated with inspected scripts.

   511  */

   512 TestSuite.prototype.testShowScriptsTab = function()

   513 {

   514     this.showPanel("scripts");

   515     var test = this;

   516     // There should be at least main page script.

   517     this._waitUntilScriptsAreParsed(["debugger_test_page.html"],

   518         function() {

   519             test.releaseControl();

   520         });

   521     // Wait until all scripts are added to the debugger.

   522     this.takeControl();

   523 };

   524 

   525 

   526 /**

   527  * Tests that scripts tab is populated with inspected scripts even if it

   528  * hadn't been shown by the moment inspected paged refreshed.

   529  * @see http://crbug.com/26312

   530  */

   531 TestSuite.prototype.testScriptsTabIsPopulatedOnInspectedPageRefresh = function()

   532 {

   533     var test = this;

   534     this.assertEquals(WebInspector.panels.elements, WebInspector.currentPanel, "Elements panel should be current one.");

   535 

   536     this.addSniffer(WebInspector.panels.scripts, "reset", waitUntilScriptIsParsed);

   537 

   538     // Reload inspected page. It will reset the debugger agent.

   539     test.evaluateInConsole_(

   540         "window.location.reload(true);",

   541         function(resultText) {});

   542 

   543     function waitUntilScriptIsParsed() {

   544         test.showPanel("scripts");

   545         test._waitUntilScriptsAreParsed(["debugger_test_page.html"],

   546             function() {

   547                 test.releaseControl();

   548             });

   549     }

   550 

   551     // Wait until all scripts are added to the debugger.

   552     this.takeControl();

   553 };

   554 

   555 

   556 /**

   557  * Tests that scripts list contains content scripts.

   558  */

   559 TestSuite.prototype.testContentScriptIsPresent = function()

   560 {

   561     this.showPanel("scripts");

   562     var test = this;

   563 

   564     test._waitUntilScriptsAreParsed(

   565         ["page_with_content_script.html", "simple_content_script.js"],

   566         function() {

   567           test.releaseControl();

   568         });

   569 

   570     // Wait until all scripts are added to the debugger.

   571     this.takeControl();

   572 };

   573 

   574 

   575 /**

   576  * Tests that scripts are not duplicaed on Scripts tab switch.

   577  */

   578 TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch = function()

   579 {

   580     var test = this;

   581 

   582     // There should be two scripts: one for the main page and another

   583     // one which is source of console API(see

   584     // InjectedScript._ensureCommandLineAPIInstalled).

   585     var expectedScriptsCount = 2;

   586     var parsedScripts = [];

   587 

   588     this.showPanel("scripts");

   589 

   590 

   591     function switchToElementsTab() {

   592         test.showPanel("elements");

   593         setTimeout(switchToScriptsTab, 0);

   594     }

   595 

   596     function switchToScriptsTab() {

   597         test.showPanel("scripts");

   598         setTimeout(checkScriptsPanel, 0);

   599     }

   600 

   601     function checkScriptsPanel() {

   602         test.assertTrue(!!WebInspector.panels.scripts.visibleView, "No visible script view.");

   603         test.assertTrue(test._scriptsAreParsed(["debugger_test_page.html"]), "Some scripts are missing.");

   604         checkNoDuplicates();

   605         test.releaseControl();

   606     }

   607 

   608     function checkNoDuplicates() {

   609         var scriptSelect = document.getElementById("scripts-files");

   610         var options = scriptSelect.options;

   611         for (var i = 0; i < options.length; i++) {

   612             var scriptName = options[i].text;

   613             for (var j = i + 1; j < options.length; j++)

   614                 test.assertTrue(scriptName !== options[j].text, "Found script duplicates: " + test.optionsToString_(options));

   615         }

   616     }

   617 

   618     test._waitUntilScriptsAreParsed(

   619         ["debugger_test_page.html"],

   620         function() {

   621             checkNoDuplicates();

   622             setTimeout(switchToElementsTab, 0);

   623         });

   624 

   625 

   626     // Wait until all scripts are added to the debugger.

   627     this.takeControl();

   628 };

   629 

   630 

   631 /**

   632  * Tests that a breakpoint can be set.

   633  */

   634 TestSuite.prototype.testSetBreakpoint = function()

   635 {

   636     var test = this;

   637     this.showPanel("scripts");

   638 

   639     var breakpointLine = 16

   640 

   641     this._waitUntilScriptsAreParsed(["debugger_test_page.html"],

   642         function() {

   643           test.showMainPageScriptSource_(

   644               "debugger_test_page.html",

   645               function(view, url) {

   646                 view._addBreakpoint(breakpointLine);

   647 

   648                 test.evaluateInConsole_(

   649                     'setTimeout("calculate()" , 0)',

   650                     function(resultText) {

   651                       test.assertTrue(!isNaN(resultText), "Failed to get timer id: " + resultText);

   652                     });

   653               });

   654         });

   655 

   656     this._waitForScriptPause(

   657         {

   658             functionsOnStack: ["calculate", ""],

   659             lineNumber: breakpointLine,

   660             lineText: "  result = fib(lastVal++);"

   661         },

   662         function() {

   663             test.releaseControl();

   664         });

   665 

   666     this.takeControl();

   667 };

   668 

   669 

   670 /**

   671  * Tests that pause on exception works.

   672  */

   673 TestSuite.prototype.testPauseOnException = function()

   674 {

   675     this.showPanel("scripts");

   676     var test = this;

   677 

   678     InspectorBackend.setPauseOnExceptionsState(WebInspector.ScriptsPanel.PauseOnExceptionsState.PauseOnUncaughtExceptions);

   679 

   680     this._executeCodeWhenScriptsAreParsed("handleClick()", ["pause_on_exception.html"]);

   681 

   682     this._waitForScriptPause(

   683         {

   684             functionsOnStack: ["throwAnException", "handleClick", ""],

   685             lineNumber: 6,

   686             lineText: "  return unknown_var;"

   687         },

   688         function() {

   689             test.releaseControl();

   690         });

   691 

   692     this.takeControl();

   693 };

   694 

   695 

   696 // Tests that debugger works correctly if pause event occurs when DevTools

   697 // frontend is being loaded.

   698 TestSuite.prototype.testPauseWhenLoadingDevTools = function()

   699 {

   700     this.showPanel("scripts");

   701     var test = this;

   702 

   703     var expectations = {

   704             functionsOnStack: ["callDebugger"],

   705             lineNumber: 8,

   706             lineText: "  debugger;"

   707         };

   708 

   709 

   710     // Script execution can already be paused.

   711     if (WebInspector.currentPanel.paused) {

   712         var callFrame = WebInspector.currentPanel.sidebarPanes.callstack.selectedCallFrame;

   713         this.assertEquals(expectations.functionsOnStack[0], callFrame.functionName);

   714         var callbackInvoked = false;

   715         this._checkSourceFrameWhenLoaded(expectations, function() {

   716                 callbackInvoked = true;

   717                 if (test.controlTaken_)

   718                     test.releaseControl();

   719             });

   720         if (!callbackInvoked) {

   721             test.takeControl();

   722         }

   723         return;

   724     }

   725 

   726     this._waitForScriptPause(

   727         {

   728             functionsOnStack: ["callDebugger"],

   729             lineNumber: 8,

   730             lineText: "  debugger;"

   731         },

   732         function() {

   733             test.releaseControl();

   734         });

   735     this.takeControl();

   736 };

   737 

   738 

   739 // Tests that pressing "Pause" will pause script execution if the script

   740 // is already running.

   741 TestSuite.prototype.testPauseWhenScriptIsRunning = function()

   742 {

   743     this.showPanel("scripts");

   744     var test = this;

   745 

   746     test.evaluateInConsole_(

   747         'setTimeout("handleClick()" , 0)',

   748         function(resultText) {

   749           test.assertTrue(!isNaN(resultText), "Failed to get timer id: " + resultText);

   750           testScriptPauseAfterDelay();

   751         });

   752 

   753     // Wait for some time to make sure that inspected page is running the

   754     // infinite loop.

   755     function testScriptPauseAfterDelay() {

   756         setTimeout(testScriptPause, 300);

   757     }

   758 

   759     function testScriptPause() {

   760         // The script should be in infinite loop. Click "Pause" button to

   761         // pause it and wait for the result.

   762         WebInspector.panels.scripts.pauseButton.click();

   763 

   764         test._waitForScriptPause(

   765             {

   766                 functionsOnStack: ["handleClick", ""],

   767                 lineNumber: 5,

   768                 lineText: "  while(true) {"

   769             },

   770             function() {

   771                 test.releaseControl();

   772             });

   773     }

   774 

   775     this.takeControl();

   776 };

   777 

   778 

   779 /**

   780  * Serializes options collection to string.

   781  * @param {HTMLOptionsCollection} options

   782  * @return {string}

   783  */

   784 TestSuite.prototype.optionsToString_ = function(options)

   785 {

   786     var names = [];

   787     for (var i = 0; i < options.length; i++)

   788         names.push('"' + options[i].text + '"');

   789     return names.join(",");

   790 };

   791 

   792 

   793 /**

   794  * Ensures that main HTML resource is selected in Scripts panel and that its

   795  * source frame is setup. Invokes the callback when the condition is satisfied.

   796  * @param {HTMLOptionsCollection} options

   797  * @param {function(WebInspector.SourceView,string)} callback

   798  */

   799 TestSuite.prototype.showMainPageScriptSource_ = function(scriptName, callback)

   800 {

   801     var test = this;

   802 

   803     var scriptSelect = document.getElementById("scripts-files");

   804     var options = scriptSelect.options;

   805 

   806     test.assertTrue(options.length, "Scripts list is empty");

   807 

   808     // Select page's script if it's not current option.

   809     var scriptResource;

   810     if (options[scriptSelect.selectedIndex].text === scriptName)

   811         scriptResource = options[scriptSelect.selectedIndex].representedObject;

   812     else {

   813         var pageScriptIndex = -1;

   814         for (var i = 0; i < options.length; i++) {

   815             if (options[i].text === scriptName) {

   816                 pageScriptIndex = i;

   817                 break;

   818             }

   819         }

   820         test.assertTrue(-1 !== pageScriptIndex, "Script with url " + scriptName + " not found among " + test.optionsToString_(options));

   821         scriptResource = options[pageScriptIndex].representedObject;

   822 

   823         // Current panel is "Scripts".

   824         WebInspector.currentPanel._showScriptOrResource(scriptResource);

   825         test.assertEquals(pageScriptIndex, scriptSelect.selectedIndex, "Unexpected selected option index.");

   826     }

   827 

   828     test.assertTrue(scriptResource instanceof WebInspector.Resource,

   829                     "Unexpected resource class.");

   830     test.assertTrue(!!scriptResource.url, "Resource URL is null.");

   831     test.assertTrue(scriptResource.url.search(scriptName + "$") !== -1, "Main HTML resource should be selected.");

   832 

   833     var scriptsPanel = WebInspector.panels.scripts;

   834 

   835     var view = scriptsPanel.visibleView;

   836     test.assertTrue(view instanceof WebInspector.SourceView);

   837 

   838     if (!view.sourceFrame._loaded) {

   839         test.addSniffer(view, "_sourceFrameSetupFinished", function(event) {

   840             callback(view, scriptResource.url);

   841         });

   842     } else

   843         callback(view, scriptResource.url);

   844 };

   845 

   846 

   847 /*

   848  * Evaluates the code in the console as if user typed it manually and invokes

   849  * the callback when the result message is received and added to the console.

   850  * @param {string} code

   851  * @param {function(string)} callback

   852  */

   853 TestSuite.prototype.evaluateInConsole_ = function(code, callback)

   854 {

   855     WebInspector.showConsole();

   856     WebInspector.console.prompt.text = code;

   857     WebInspector.console.promptElement.dispatchEvent( TestSuite.createKeyEvent("Enter"));

   858 

   859     this.addSniffer(WebInspector.ConsoleView.prototype, "addMessage",

   860         function(commandResult) {

   861             callback(commandResult.toMessageElement().textContent);

   862         });

   863 };

   864 

   865 

   866 /**

   867  * Tests eval on call frame.

   868  */

   869 TestSuite.prototype.testEvalOnCallFrame = function()

   870 {

   871     this.showPanel("scripts");

   872 

   873     var breakpointLine = 16;

   874 

   875     var test = this;

   876     this._waitUntilScriptsAreParsed(["debugger_test_page.html"],

   877         function() {

   878           test.showMainPageScriptSource_(

   879               "debugger_test_page.html",

   880               function(view, url) {

   881                   view._addBreakpoint(breakpointLine);

   882 

   883                   // Since breakpoints are ignored in evals' calculate() function is

   884                   // execute after zero-timeout so that the breakpoint is hit.

   885                   test.evaluateInConsole_(

   886                       'setTimeout("calculate(123)" , 0)',

   887                       function(resultText) {

   888                           test.assertTrue(!isNaN(resultText), "Failed to get timer id: " + resultText);

   889                           waitForBreakpointHit();

   890                       });

   891               });

   892         });

   893 

   894     function waitForBreakpointHit() {

   895       test.addSniffer(WebInspector,

   896           "pausedScript",

   897           function(callFrames) {

   898             test.assertEquals(2, callFrames.length, "Unexpected stack depth on the breakpoint. " + JSON.stringify(callFrames, null, 4));

   899             test.assertEquals("calculate", callFrames[0].functionName, "Unexpected top frame function.");

   900             // Evaluate "e+1" where "e" is an argument of "calculate" function.

   901             test.evaluateInConsole_(

   902                 "e+1",

   903                 function(resultText) {

   904                     test.assertEquals("124", resultText, 'Unexpected "e+1" value.');

   905                     test.releaseControl();

   906                 });

   907           });

   908     }

   909 

   910     this.takeControl();

   911 };

   912 

   913 

   914 /**

   915  * Tests that console auto completion works when script execution is paused.

   916  */

   917 TestSuite.prototype.testCompletionOnPause = function()

   918 {

   919     this.showPanel("scripts");

   920     var test = this;

   921     this._executeCodeWhenScriptsAreParsed("handleClick()", ["completion_on_pause.html"]);

   922 

   923     this._waitForScriptPause(

   924         {

   925             functionsOnStack: ["innerFunction", "handleClick", ""],

   926             lineNumber: 9,

   927             lineText: "    debugger;"

   928         },

   929         showConsole);

   930 

   931     function showConsole() {

   932         if (WebInspector.currentFocusElement === WebInspector.console.promptElement)

   933             testLocalsCompletion();

   934         else {

   935             test.addSniffer(WebInspector.console, "afterShow", testLocalsCompletion);

   936             WebInspector.showConsole();

   937         }

   938     }

   939 

   940     function testLocalsCompletion() {

   941         checkCompletions("th", ["parameter1", "closureLocal", "p", "createClosureLocal"], testThisCompletion);

   942     }

   943 

   944     function testThisCompletion() {

   945         checkCompletions("this.", ["field1", "field2", "m"], testFieldCompletion);

   946     }

   947 

   948     function testFieldCompletion() {

   949         checkCompletions("this.field1.", ["id", "name"], function() { test.releaseControl(); });

   950     }

   951 

   952     function checkCompletions(expression, expectedProperties, callback) {

   953         test.addSniffer(WebInspector.console, "_reportCompletions",

   954             function(bestMatchOnly, completionsReadyCallback, dotNotation, bracketNotation, prefix, result, isException) {

   955                 test.assertTrue(!isException, "Exception while collecting completions");

   956                 for (var i = 0; i < expectedProperties.length; i++) {

   957                     var name = expectedProperties[i];

   958                     test.assertTrue(result[name], "Name " + name + " not found among the completions: " + JSON.stringify(result));

   959                 }

   960                 setTimeout(callback, 0);

   961             });

   962       WebInspector.console.prompt.text = expression;

   963       WebInspector.console.prompt.autoCompleteSoon();

   964     }

   965 

   966     this.takeControl();

   967 };

   968 

   969 

   970 /**

   971  * Tests that inspected page doesn't hang on reload if it contains a syntax

   972  * error and DevTools window is open.

   973  */

   974 TestSuite.prototype.testAutoContinueOnSyntaxError = function()

   975 {

   976     // TODO(yurys): provide an implementation that works with ScriptDebugServer.

   977 };

   978 

   979 

   980 /**

   981  * Checks current execution line against expectations.

   982  * @param {WebInspector.SourceFrame} sourceFrame

   983  * @param {number} lineNumber Expected line number

   984  * @param {string} lineContent Expected line text

   985  */

   986 TestSuite.prototype._checkExecutionLine = function(sourceFrame, lineNumber, lineContent)

   987 {

   988     this.assertEquals(lineNumber, sourceFrame.executionLine, "Unexpected execution line number.");

   989     this.assertEquals(lineContent, sourceFrame._textModel.line(lineNumber - 1), "Unexpected execution line text.");

   990 }

   991 

   992 

   993 /**

   994  * Checks that all expected scripts are present in the scripts list

   995  * in the Scripts panel.

   996  * @param {Array.<string>} expected Regular expressions describing

   997  *     expected script names.

   998  * @return {boolean} Whether all the scripts are in "scripts-files" select

   999  *     box

  1000  */

  1001 TestSuite.prototype._scriptsAreParsed = function(expected)

  1002 {

  1003     var scriptSelect = document.getElementById("scripts-files");

  1004     var options = scriptSelect.options;

  1005 

  1006     // Check that at least all the expected scripts are present.

  1007     var missing = expected.slice(0);

  1008     for (var i = 0 ; i < options.length; i++) {

  1009         for (var j = 0; j < missing.length; j++) {

  1010             if (options[i].text.search(missing[j]) !== -1) {

  1011                 missing.splice(j, 1);

  1012                 break;

  1013             }

  1014         }

  1015     }

  1016     return missing.length === 0;

  1017 };

  1018 

  1019 

  1020 /**

  1021  * Waits for script pause, checks expectations, and invokes the callback.

  1022  * @param {Object} expectations  Dictionary of expectations

  1023  * @param {function():void} callback

  1024  */

  1025 TestSuite.prototype._waitForScriptPause = function(expectations, callback)

  1026 {

  1027     var test = this;

  1028     // Wait until script is paused.

  1029     test.addSniffer(

  1030         WebInspector,

  1031         "pausedScript",

  1032         function(callFrames) {

  1033             var functionsOnStack = [];

  1034             for (var i = 0; i < callFrames.length; i++)

  1035                 functionsOnStack.push(callFrames[i].functionName);

  1036 

  1037             test.assertEquals(expectations.functionsOnStack.join(","), functionsOnStack.join(","), "Unexpected stack.");

  1038 

  1039             // Check that execution line where the script is paused is

  1040             // expected one.

  1041             test._checkSourceFrameWhenLoaded(expectations, callback);

  1042         });

  1043 };

  1044 

  1045 

  1046 /**

  1047  * Waits for current source frame to load, checks expectations, and invokes

  1048  * the callback.

  1049  * @param {Object} expectations  Dictionary of expectations

  1050  * @param {function():void} callback

  1051  */

  1052 TestSuite.prototype._checkSourceFrameWhenLoaded = function(expectations, callback)

  1053 {

  1054     var test = this;

  1055 

  1056     var frame = WebInspector.currentPanel.visibleView.sourceFrame;

  1057     if (frame._loaded)

  1058         checkExecLine();

  1059     else {

  1060         setTimeout(function() {

  1061             test._checkSourceFrameWhenLoaded(expectations, callback);

  1062         }, 100);

  1063     }

  1064     function checkExecLine() {

  1065         test._checkExecutionLine(frame, expectations.lineNumber, expectations.lineText);

  1066         callback();

  1067     }

  1068 };

  1069 

  1070 

  1071 /**

  1072  * Performs sequence of steps.

  1073  * @param {Array.<Object|Function>} Array [expectations1,action1,expectations2,

  1074  *     action2,...,actionN].

  1075  */

  1076 TestSuite.prototype._performSteps = function(actions)

  1077 {

  1078     var test = this;

  1079     var i = 0;

  1080     function doNextAction() {

  1081         if (i > 0)

  1082             actions[i++]();

  1083         if (i < actions.length - 1)

  1084             test._waitForScriptPause(actions[i++], doNextAction);

  1085     }

  1086     doNextAction();

  1087 };

  1088 

  1089 

  1090 /**

  1091  * Waits until all the scripts are parsed and asynchronously executes the code

  1092  * in the inspected page.

  1093  */

  1094 TestSuite.prototype._executeCodeWhenScriptsAreParsed = function(code, expectedScripts)

  1095 {

  1096     var test = this;

  1097 

  1098     function executeFunctionInInspectedPage() {

  1099         // Since breakpoints are ignored in evals' calculate() function is

  1100         // execute after zero-timeout so that the breakpoint is hit.

  1101         test.evaluateInConsole_(

  1102             'setTimeout("' + code + '" , 0)',

  1103             function(resultText) {

  1104                 test.assertTrue(!isNaN(resultText), "Failed to get timer id: " + resultText + ". Code: " + code);

  1105             });

  1106     }

  1107 

  1108     test._waitUntilScriptsAreParsed(expectedScripts, executeFunctionInInspectedPage);

  1109 };

  1110 

  1111 

  1112 /**

  1113  * Waits until all the scripts are parsed and invokes the callback.

  1114  */

  1115 TestSuite.prototype._waitUntilScriptsAreParsed = function(expectedScripts, callback)

  1116 {

  1117     var test = this;

  1118 

  1119     function waitForAllScripts() {

  1120         if (test._scriptsAreParsed(expectedScripts))

  1121             callback();

  1122         else

  1123             test.addSniffer(WebInspector, "parsedScriptSource", waitForAllScripts);

  1124     }

  1125 

  1126     waitForAllScripts();

  1127 };

  1128 

  1129 

  1130 /**

  1131  * Waits until all debugger scripts are parsed and executes "a()" in the

  1132  * inspected page.

  1133  */

  1134 TestSuite.prototype._executeFunctionForStepTest = function()

  1135 {