The Tor Browser: comparison dom/imptests/testharnessreport.js

comparison: dom/imptests/testharnessreport.js

dom/imptests/testharnessreport.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:637aeb877ece
+/* 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/. */
+var W3CTest = {
+/**
+* Dictionary mapping a test URL to either the string "all", which means that
+* all tests in this file are expected to fail, or a dictionary mapping test
+* names to either the boolean |true|, or the string "debug". The former
+* means that this test is expected to fail in all builds, and the latter
+* that it is only expected to fail in debug builds.
+*/
+"expectedFailures": {},
+/**
+* If set to true, we will dump the test failures to the console.
+*/
+"dumpFailures": false,
+/**
+* If dumpFailures is true, this holds a structure like necessary for
+* expectedFailures, for ease of updating the expectations.
+*/
+"failures": {},
+/**
+* List of test results, needed by TestRunner to update the UI.
+*/
+"tests": [],
+/**
+* Number of unlogged passes, to stop buildbot from truncating the log.
+* We will print a message every MAX_COLLAPSED_MESSAGES passes.
+*/
+"collapsedMessages": 0,
+"MAX_COLLAPSED_MESSAGES": 100,
+/**
+* Reference to the TestRunner object in the parent frame.
+*/
+"runner": parent === this ? null : parent.TestRunner || parent.wrappedJSObject.TestRunner,
+/**
+* Prefixes for the error logging. Indexed first by int(todo) and second by
+* int(result).
+*/
+"prefixes": [
+["TEST-UNEXPECTED-FAIL", "TEST-PASS"],
+["TEST-KNOWN-FAIL", "TEST-UNEXPECTED-PASS"]
+],
+/**
+* Prefix of the path to parent of the the failures directory.
+*/
+"pathprefix": "/tests/dom/imptests/",
+/**
+* Returns the URL of the current test, relative to the root W3C tests
+* directory. Used as a key into the expectedFailures dictionary.
+*/
+"getPath": function() {
+var url = this.getURL();
+if (!url.startsWith(this.pathprefix)) {
+return "";
+}
+return url.substring(this.pathprefix.length);
+},
+/**
+* Returns the root-relative URL of the current test.
+*/
+"getURL": function() {
+return this.runner ? this.runner.currentTestURL : location.pathname;
+},
+/**
+* Report the results in the tests array.
+*/
+"reportResults": function() {
+var element = function element(aLocalName) {
+var xhtmlNS = "http://www.w3.org/1999/xhtml";
+return document.createElementNS(xhtmlNS, aLocalName);
+};
+var stylesheet = element("link");
+stylesheet.setAttribute("rel", "stylesheet");
+stylesheet.setAttribute("href", "/resources/testharness.css");
+var heads = document.getElementsByTagName("head");
+if (heads.length) {
+heads[0].appendChild(stylesheet);
+}
+var log = document.getElementById("log");
+if (!log) {
+return;
+}
+var section = log.appendChild(element("section"));
+section.id = "summary";
+section.appendChild(element("h2")).textContent = "Details";
+var table = section.appendChild(element("table"));
+table.id = "results";
+var tr = table.appendChild(element("thead")).appendChild(element("tr"));
+for (var header of ["Result", "Test Name", "Message"]) {
+tr.appendChild(element("th")).textContent = header;
+}
+var statuses = [
+["Unexpected Fail", "Pass"],
+["Known Fail", "Unexpected Pass"]
+];
+var tbody = table.appendChild(element("tbody"));
+for (var test of this.tests) {
+tr = tbody.appendChild(element("tr"));
+tr.className = (test.result === !test.todo ? "pass" : "fail");
+tr.appendChild(element("td")).textContent =
+statuses[+test.todo][+test.result];
+tr.appendChild(element("td")).textContent = test.name;
+tr.appendChild(element("td")).textContent = test.message;
+}
+},
+/**
+* Returns a printable message based on aTest's 'name' and 'message'
+* properties.
+*/
+"formatTestMessage": function(aTest) {
+return aTest.name + (aTest.message ? ": " + aTest.message : "");
+},
+/**
+* Lets the test runner know about a test result.
+*/
+"_log": function(test) {
+var url = this.getURL();
+var msg = this.prefixes[+test.todo][+test.result] + " | ";
+if (url) {
+msg += url;
+}
+msg += " | " + this.formatTestMessage(test);
+if (this.runner) {
+this.runner[(test.result === !test.todo) ? "log" : "error"](msg);
+} else {
+dump(msg + "\n");
+}
+},
+/**
+* Logs a message about collapsed messages (if any), and resets the counter.
+*/
+"_logCollapsedMessages": function() {
+if (this.collapsedMessages) {
+this._log({
+"name": document.title,
+"result": true,
+"todo": false,
+"message": "Elided " + this.collapsedMessages + " passes or known failures."
+});
+}
+this.collapsedMessages = 0;
+},
+/**
+* Maybe logs a result, eliding up to MAX_COLLAPSED_MESSAGES consecutive
+* passes.
+*/
+"_maybeLog": function(test) {
+var success = (test.result === !test.todo);
+if (success && ++this.collapsedMessages < this.MAX_COLLAPSED_MESSAGES) {
+return;
+}
+this._logCollapsedMessages();
+this._log(test);
+},
+/**
+* Reports a test result. The argument is an object with the following
+* properties:
+*
+* o message (string): message to be reported
+* o result (boolean): whether this test failed
+* o todo (boolean): whether this test is expected to fail
+*/
+"report": function(test) {
+this.tests.push(test);
+this._maybeLog(test);
+},
+/**
+* Returns true if this test is expected to fail, and false otherwise.
+*/
+"_todo": function(test) {
+if (this.expectedFailures === "all") {
+return true;
+}
+var value = this.expectedFailures[test.name];
+return value === true || (value === "debug" && !!SpecialPowers.isDebugBuild);
+},
+/**
+* Callback function for testharness.js. Called when one test in a file
+* finishes.
+*/
+"result": function(test) {
+var url = this.getPath();
+this.report({
+"name": test.name,
+"message": test.message || "",
+"result": test.status === test.PASS,
+"todo": this._todo(test)
+});
+if (this.dumpFailures && test.status !== test.PASS) {
+this.failures[test.name] = true;
+}
+},
+/**
+* Callback function for testharness.js. Called when the entire test file
+* finishes.
+*/
+"finish": function(tests, status) {
+var url = this.getPath();
+this.report({
+"name": "Finished test",
+"message": "Status: " + status.status,
+"result": status.status === status.OK,
+"todo":
+url in this.expectedFailures &&
+this.expectedFailures[url] === "error"
+});
+this._logCollapsedMessages();
+if (this.dumpFailures) {
+dump("@@@ @@@ Failures\n");
+dump(url + "@@@" + JSON.stringify(this.failures) + "\n");
+}
+if (this.runner) {
+this.runner.testFinished(this.tests.map(function(aTest) {
+return {
+"message": this.formatTestMessage(aTest),
+"result": aTest.result,
+"todo": aTest.todo
+};
+}, this));
+} else {
+this.reportResults();
+}
+},
+/**
+* Log an unexpected failure. Intended to be used from harness code, not
+* from tests.
+*/
+"logFailure": function(aTestName, aMessage) {
+this.report({
+"name": aTestName,
+"message": aMessage,
+"result": false,
+"todo": false
+});
+},
+/**
+* Timeout the current test. Intended to be used from harness code, not
+* from tests.
+*/
+"timeout": function() {
+this.logFailure("Timeout", "Test runner timed us out.");
+timeout();
+}
+};
+(function() {
+try {
+var path = W3CTest.getPath();
+if (path) {
+// Get expected fails.  If there aren't any, there will be a 404, which is
+// fine.  Anything else is unexpected.
+var url = W3CTest.pathprefix + "failures/" + path + ".json";
+var request = new XMLHttpRequest();
+request.open("GET", url, false);
+request.send();
+if (request.status === 200) {
+W3CTest.expectedFailures = JSON.parse(request.responseText);
+} else if (request.status !== 404) {
+W3CTest.logFailure("Fetching failures file", "Request status was " + request.status);
+}
+}
+add_result_callback(W3CTest.result.bind(W3CTest));
+add_completion_callback(W3CTest.finish.bind(W3CTest));
+setup({
+"output": false,
+"explicit_timeout": true
+});
+} catch (e) {
+W3CTest.logFailure("Harness setup", "Unexpected exception: " + e);
+}
+})();