The Tor Browser: comparison testing/marionette/marionette-simpletest.js

comparison: testing/marionette/marionette-simpletest.js

testing/marionette/marionette-simpletest.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:795779b6f5ad
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this file,
+* You can obtain one at http://mozilla.org/MPL/2.0/. */
+/*
+* The Marionette object, passed to the script context.
+*/
+this.Marionette = function Marionette(scope, window, context, logObj, timeout,
+heartbeatCallback, testName) {
+this.scope = scope;
+this.window = window;
+this.tests = [];
+this.logObj = logObj;
+this.context = context;
+this.timeout = timeout;
+this.heartbeatCallback = heartbeatCallback;
+this.testName = testName;
+this.TEST_UNEXPECTED_FAIL = "TEST-UNEXPECTED-FAIL";
+this.TEST_PASS = "TEST-PASS";
+this.TEST_KNOWN_FAIL = "TEST-KNOWN-FAIL";
+}
+Marionette.prototype = {
+exports: ['ok', 'is', 'isnot', 'log', 'getLogs', 'generate_results', 'waitFor',
+'runEmulatorCmd', 'runEmulatorShell', 'TEST_PASS', 'TEST_KNOWN_FAIL',
+'TEST_UNEXPECTED_FAIL'],
+ok: function Marionette__ok(condition, name, passString, failString, diag) {
+this.heartbeatCallback();
+if (typeof(diag) == "undefined") {
+diag = this.repr(condition) + " was " + !!condition + ", expected true";
+}
+let test = {'result': !!condition, 'name': name, 'diag': diag};
+this.logResult(test,
+typeof(passString) == "undefined" ? this.TEST_PASS : passString,
+typeof(failString) == "undefined" ? this.TEST_UNEXPECTED_FAIL : failString);
+this.tests.push(test);
+},
+is: function Marionette__is(a, b, name, passString, failString) {
+this.heartbeatCallback();
+let pass = (a == b);
+let diag = pass ? this.repr(a) + " should equal " + this.repr(b)
+: "got " + this.repr(a) + ", expected " + this.repr(b);
+this.ok(pass, name, passString, failString, diag);
+},
+isnot: function Marionette__isnot (a, b, name, passString, failString) {
+this.heartbeatCallback();
+let pass = (a != b);
+let diag = pass ? this.repr(a) + " should not equal " + this.repr(b)
+: "didn't expect " + this.repr(a) + ", but got it";
+this.ok(pass, name, passString, failString, diag);
+},
+log: function Marionette__log(msg, level) {
+this.heartbeatCallback();
+dump("MARIONETTE LOG: " + (level ? level : "INFO") + ": " + msg + "\n");
+if (this.logObj != null) {
+this.logObj.log(msg, level);
+}
+},
+getLogs: function Marionette__getLogs() {
+this.heartbeatCallback();
+if (this.logObj != null) {
+this.logObj.getLogs();
+}
+},
+generate_results: function Marionette__generate_results() {
+this.heartbeatCallback();
+let passed = 0;
+let failed = 0;
+let failures = [];
+for (let i in this.tests) {
+if(this.tests[i].result) {
+passed++;
+}
+else {
+failed++;
+failures.push({'name': this.tests[i].name,
+'diag': this.tests[i].diag});
+}
+}
+// Reset state in case this object is reused for more tests.
+this.tests = [];
+return {"passed": passed, "failed": failed, "failures": failures};
+},
+logToFile: function Marionette__logToFile(file) {
+this.heartbeatCallback();
+//TODO
+},
+logResult: function Marionette__logResult(test, passString, failString) {
+this.heartbeatCallback();
+//TODO: dump to file
+let resultString = test.result ? passString : failString;
+let diagnostic = test.name + (test.diag ? " - " + test.diag : "");
+let msg = resultString + " | " + this.testName + " | " + diagnostic;
+dump("MARIONETTE TEST RESULT:" + msg + "\n");
+},
+repr: function Marionette__repr(o) {
+if (typeof(o) == "undefined") {
+return "undefined";
+} else if (o === null) {
+return "null";
+}
+try {
+if (typeof(o.__repr__) == 'function') {
+return o.__repr__();
+} else if (typeof(o.repr) == 'function' && o.repr != arguments.callee) {
+return o.repr();
+}
+} catch (e) {
+}
+try {
+if (typeof(o.NAME) == 'string' && (
+o.toString == Function.prototype.toString ||
+o.toString == Object.prototype.toString
+)) {
+return o.NAME;
+}
+} catch (e) {
+}
+let ostring;
+try {
+ostring = (o + "");
+} catch (e) {
+return "[" + typeof(o) + "]";
+}
+if (typeof(o) == "function") {
+o = ostring.replace(/^\s+/, "");
+let idx = o.indexOf("{");
+if (idx != -1) {
+o = o.substr(0, idx) + "{...}";
+}
+}
+return ostring;
+},
+waitFor: function test_waitFor(callback, test, timeout) {
+this.heartbeatCallback();
+if (test()) {
+callback();
+return;
+}
+var now = Date.now();
+var deadline = now + (typeof(timeout) == "undefined" ? this.timeout : timeout);
+if (deadline <= now) {
+dump("waitFor timeout: " + test.toString() + "\n");
+// the script will timeout here, so no need to raise a separate
+// timeout exception
+return;
+}
+this.window.setTimeout(this.waitFor.bind(this), 100, callback, test, deadline - now);
+},
+runEmulatorCmd: function runEmulatorCmd(cmd, callback) {
+this.heartbeatCallback();
+this.scope.runEmulatorCmd(cmd, callback);
+},
+runEmulatorShell: function runEmulatorShell(args, callback) {
+this.heartbeatCallback();
+this.scope.runEmulatorShell(args, callback);
+},
+};