testing/mochitest/browser-test.js

   1 if (Cc === undefined) {
   2   var Cc = Components.classes;
   3   var Ci = Components.interfaces;
   4 }
   5 window.addEventListener("load", testOnLoad, false);
   6
   7 function testOnLoad() {
   8   window.removeEventListener("load", testOnLoad, false);
   9
  10   // Make sure to launch the test harness for the first opened window only
  11   var prefs = Cc["@mozilla.org/preferences-service;1"].
  12               getService(Ci.nsIPrefBranch);
  13   if (prefs.prefHasUserValue("testing.browserTestHarness.running"))
  14     return;
  15
  16   prefs.setBoolPref("testing.browserTestHarness.running", true);
  17
  18   var ww = Cc["@mozilla.org/embedcomp/window-watcher;1"].
  19            getService(Ci.nsIWindowWatcher);
  20   var sstring = Cc["@mozilla.org/supports-string;1"].
  21                 createInstance(Ci.nsISupportsString);
  22   sstring.data = location.search;
  23   ww.openWindow(window, "chrome://mochikit/content/browser-harness.xul", "browserTest",
  24                 "chrome,centerscreen,dialog,resizable,titlebar,toolbar=no,width=800,height=600", sstring);
  25 }
  26
  27 function Tester(aTests, aCallback) {
  28   this.tests = aTests;
  29   this.callback = aCallback;
  30 }
  31 Tester.prototype = {
  32   checker: null,
  33   currentTestIndex: -1,
  34   get currentTest() {
  35     return this.tests[this.currentTestIndex];
  36   },
  37   get done() {
  38     return this.currentTestIndex == this.tests.length - 1;
  39   },
  40   step: function Tester_step() {
  41     this.currentTestIndex++;
  42   },
  43
  44   start: function Tester_start() {
  45     this.execTest();
  46   },
  47
  48   finish: function Tester_finish() {
  49     // Tests complete, notify the callback and return
  50     this.callback(this.tests);
  51     this.callback = null;
  52     this.tests = null;
  53   },
  54
  55   execTest: function Tester_execTest() {
  56     if (this.done) {
  57       this.finish();
  58       return;
  59     }
  60
  61     // Move to the next test (or first test).
  62     this.step();
  63
  64     // Load the tests into a testscope
  65     this.currentTest.scope = new testScope(this.currentTest.tests);
  66
  67     var scriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
  68                        getService(Ci.mozIJSSubScriptLoader);
  69     try {
  70       scriptLoader.loadSubScript(this.currentTest.path, this.currentTest.scope);
  71
  72       // Run the test
  73       this.currentTest.scope.test();
  74     } catch (ex) {
  75       this.currentTest.tests.push(new testResult(false, "Exception thrown", ex, false));
  76       this.currentTest.scope.done = true;
  77     }
  78
  79     // If the test ran synchronously, move to the next test,
  80     // otherwise start a poller to monitor it's progress.
  81     if (this.currentTest.scope.done) {
  82       this.execTest();
  83     } else {
  84       var self = this;
  85       this.checker = new resultPoller(this.currentTest, function () { self.execTest(); });
  86       this.checker.start();
  87     }
  88   }
  89 };
  90
  91 function testResult(aCondition, aName, aDiag, aIsTodo) {
  92   aName = aName || "";
  93
  94   this.pass = !!aCondition;
  95   this.todo = aIsTodo;
  96   this.msg = aName;
  97   if (this.pass) {
  98     if (aIsTodo)
  99       this.result = "TEST-KNOWN-FAIL";
 100     else
 101       this.result = "TEST-PASS";
 102   } else {
 103     if (aDiag)
 104       this.msg += " - " + aDiag;
 105     if (aIsTodo)
 106       this.result = "TEST-UNEXPECTED-PASS";
 107     else
 108       this.result = "TEST-UNEXPECTED-FAIL";
 109   }
 110 }
 111
 112 function testScope(aTests) {
 113   var scriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
 114                      getService(Ci.mozIJSSubScriptLoader);
 115   scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/EventUtils.js", this.EventUtils);
 116
 117   this.tests = aTests;
 118
 119   var self = this;
 120   this.ok = function test_ok(condition, name, diag) {
 121     self.tests.push(new testResult(condition, name, diag, false));
 122   };
 123   this.is = function test_is(a, b, name) {
 124     self.ok(a == b, name, "Got " + a + ", expected " + b);
 125   };
 126   this.isnot = function test_isnot(a, b, name) {
 127     self.ok(a != b, name, "Didn't expect " + a + ", but got it");
 128   };
 129   this.todo = function test_todo(condition, name, diag) {
 130     self.tests.push(new testResult(!condition, name, diag, true));
 131   };
 132   this.todo_is = function test_todo_is(a, b, name) {
 133     self.todo(a == b, name, "Got " + a + ", expected " + b);
 134   };
 135   this.todo_isnot = function test_todo_isnot(a, b, name) {
 136     self.todo(a != b, name, "Didn't expect " + a + ", but got it");
 137   };
 138
 139   this.executeSoon = function test_executeSoon(func) {
 140     let tm = Cc["@mozilla.org/thread-manager;1"].getService(Ci.nsIThreadManager);
 141
 142     tm.mainThread.dispatch({
 143       run: function() {
 144         func();
 145       }
 146     }, Ci.nsIThread.DISPATCH_NORMAL);
 147   };
 148
 149   this.waitForExplicitFinish = function test_WFEF() {
 150     self.done = false;
 151   };
 152   this.finish = function test_finish() {
 153     self.done = true;
 154   };
 155 }
 156 testScope.prototype = {
 157   done: true,
 158
 159   EventUtils: {}
 160 };
 161
 162 // Check whether the test has completed every 3 seconds
 163 const CHECK_INTERVAL = 3000;
 164 // Test timeout (seconds)
 165 const TIMEOUT_SECONDS = 30;
 166
 167 const MAX_LOOP_COUNT = (TIMEOUT_SECONDS * 1000) / CHECK_INTERVAL;
 168
 169 function resultPoller(aTest, aCallback) {
 170   this.test = aTest;
 171   this.callback = aCallback;
 172 }
 173 resultPoller.prototype = {
 174   loopCount: 0,
 175   interval: 0,
 176
 177   start: function resultPoller_start() {
 178     var self = this;
 179     function checkDone() {
 180       self.loopCount++;
 181
 182       if (self.loopCount > MAX_LOOP_COUNT) {
 183         self.test.tests.push(new testResult(false, "Timed out", "", false));
 184         self.test.scope.done = true;
 185       }
 186
 187       if (self.test.scope.done) {
 188         clearInterval(self.interval);
 189
 190         // Notify the callback
 191         self.callback();
 192         self.callback = null;
 193         self.test = null;
 194       }
 195     }
 196     this.interval = setInterval(checkDone, CHECK_INTERVAL);
 197   }
 198 };