/* 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 EXPORTED_SYMBOLS = ['Assert', 'Expect']; var Cu = Components.utils; Cu.import("resource://gre/modules/Services.jsm"); var broker = {}; Cu.import('resource://mozmill/driver/msgbroker.js', broker); var errors = {}; Cu.import('resource://mozmill/modules/errors.js', errors); var stack = {}; Cu.import('resource://mozmill/modules/stack.js', stack); /** * @name assertions * @namespace Defines expect and assert methods to be used for assertions. */ /** * The Assert class implements fatal assertions, and can be used in cases * when a failing test has to directly abort the current test function. All * remaining tasks will not be performed. * */ var Assert = function () {} Assert.prototype = { // The following deepEquals implementation is from Narwhal under this license: // http://wiki.commonjs.org/wiki/Unit_Testing/1.0 // // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8! // // Originally from narwhal.js (http://narwhaljs.org) // Copyright (c) 2009 Thomas Robinson <280north.com> // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the 'Software'), to // deal in the Software without restriction, including without limitation the // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or // sell copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. _deepEqual: function (actual, expected) { // 7.1. All identical values are equivalent, as determined by ===. if (actual === expected) { return true; // 7.2. If the expected value is a Date object, the actual value is // equivalent if it is also a Date object that refers to the same time. } else if (actual instanceof Date && expected instanceof Date) { return actual.getTime() === expected.getTime(); // 7.3. Other pairs that do not both pass typeof value == 'object', // equivalence is determined by ==. } else if (typeof actual != 'object' && typeof expected != 'object') { return actual == expected; // 7.4. For all other Object pairs, including Array objects, equivalence is // determined by having the same number of owned properties (as verified // with Object.prototype.hasOwnProperty.call), the same set of keys // (although not necessarily the same order), equivalent values for every // corresponding key, and an identical 'prototype' property. Note: this // accounts for both named and indexed properties on Arrays. } else { return this._objEquiv(actual, expected); } }, _objEquiv: function (a, b) { if (a == null || a == undefined || b == null || b == undefined) return false; // an identical 'prototype' property. if (a.prototype !== b.prototype) return false; function isArguments(object) { return Object.prototype.toString.call(object) == '[object Arguments]'; } //~~~I've managed to break Object.keys through screwy arguments passing. // Converting to array solves the problem. if (isArguments(a)) { if (!isArguments(b)) { return false; } a = pSlice.call(a); b = pSlice.call(b); return _deepEqual(a, b); } try { var ka = Object.keys(a), kb = Object.keys(b), key, i; } catch (e) {//happens when one is a string literal and the other isn't return false; } // having the same number of owned properties (keys incorporates // hasOwnProperty) if (ka.length != kb.length) return false; //the same set of keys (although not necessarily the same order), ka.sort(); kb.sort(); //~~~cheap key test for (i = ka.length - 1; i >= 0; i--) { if (ka[i] != kb[i]) return false; } //equivalent values for every corresponding key, and //~~~possibly expensive deep test for (i = ka.length - 1; i >= 0; i--) { key = ka[i]; if (!this._deepEqual(a[key], b[key])) return false; } return true; }, _expectedException : function Assert__expectedException(actual, expected) { if (!actual || !expected) { return false; } if (expected instanceof RegExp) { return expected.test(actual); } else if (actual instanceof expected) { return true; } else if (expected.call({}, actual) === true) { return true; } else if (actual.name === expected.name) { return true; } return false; }, /** * Log a test as failing by throwing an AssertionException. * * @param {object} aResult * Test result details used for reporting. *
*
fileName
*
Name of the file in which the assertion failed.
*
functionName
*
Function in which the assertion failed.
*
lineNumber
*
Line number of the file in which the assertion failed.
*
message
*
Message why the assertion failed.
*
* @throws {errors.AssertionError} * */ _logFail: function Assert__logFail(aResult) { throw new errors.AssertionError(aResult.message, aResult.fileName, aResult.lineNumber, aResult.functionName, aResult.name); }, /** * Log a test as passing by adding a pass frame. * * @param {object} aResult * Test result details used for reporting. *
*
fileName
*
Name of the file in which the assertion failed.
*
functionName
*
Function in which the assertion failed.
*
lineNumber
*
Line number of the file in which the assertion failed.
*
message
*
Message why the assertion failed.
*
*/ _logPass: function Assert__logPass(aResult) { broker.pass({pass: aResult}); }, /** * Test the condition and mark test as passed or failed * * @param {boolean} aCondition * Condition to test. * @param {string} aMessage * Message to show for the test result * @param {string} aDiagnosis * Diagnose message to show for the test result * @throws {errors.AssertionError} * * @returns {boolean} Result of the test. */ _test: function Assert__test(aCondition, aMessage, aDiagnosis) { let diagnosis = aDiagnosis || ""; let message = aMessage || ""; if (diagnosis) message = aMessage ? message + " - " + diagnosis : diagnosis; // Build result data let frame = stack.findCallerFrame(Components.stack); let result = { 'fileName' : frame.filename.replace(/(.*)-> /, ""), 'functionName' : frame.name, 'lineNumber' : frame.lineNumber, 'message' : message }; // Log test result if (aCondition) { this._logPass(result); } else { result.stack = Components.stack; this._logFail(result); } return aCondition; }, /** * Perform an always passing test * * @param {string} aMessage * Message to show for the test result. * @returns {boolean} Always returns true. */ pass: function Assert_pass(aMessage) { return this._test(true, aMessage, undefined); }, /** * Perform an always failing test * * @param {string} aMessage * Message to show for the test result. * @throws {errors.AssertionError} * * @returns {boolean} Always returns false. */ fail: function Assert_fail(aMessage) { return this._test(false, aMessage, undefined); }, /** * Test if the value pass * * @param {boolean|string|number|object} aValue * Value to test. * @param {string} aMessage * Message to show for the test result. * @throws {errors.AssertionError} * * @returns {boolean} Result of the test. */ ok: function Assert_ok(aValue, aMessage) { let condition = !!aValue; let diagnosis = "got '" + aValue + "'"; return this._test(condition, aMessage, diagnosis); }, /** * Test if both specified values are identical. * * @param {boolean|string|number|object} aValue * Value to test. * @param {boolean|string|number|object} aExpected * Value to strictly compare with. * @param {string} aMessage * Message to show for the test result * @throws {errors.AssertionError} * * @returns {boolean} Result of the test. */ equal: function Assert_equal(aValue, aExpected, aMessage) { let condition = (aValue === aExpected); let diagnosis = "'" + aValue + "' should equal '" + aExpected + "'"; return this._test(condition, aMessage, diagnosis); }, /** * Test if both specified values are not identical. * * @param {boolean|string|number|object} aValue * Value to test. * @param {boolean|string|number|object} aExpected * Value to strictly compare with. * @param {string} aMessage * Message to show for the test result * @throws {errors.AssertionError} * * @returns {boolean} Result of the test. */ notEqual: function Assert_notEqual(aValue, aExpected, aMessage) { let condition = (aValue !== aExpected); let diagnosis = "'" + aValue + "' should not equal '" + aExpected + "'"; return this._test(condition, aMessage, diagnosis); }, /** * Test if an object equals another object * * @param {object} aValue * The object to test. * @param {object} aExpected * The object to strictly compare with. * @param {string} aMessage * Message to show for the test result * @throws {errors.AssertionError} * * @returns {boolean} Result of the test. */ deepEqual: function equal(aValue, aExpected, aMessage) { let condition = this._deepEqual(aValue, aExpected); try { var aValueString = JSON.stringify(aValue); } catch (e) { var aValueString = String(aValue); } try { var aExpectedString = JSON.stringify(aExpected); } catch (e) { var aExpectedString = String(aExpected); } let diagnosis = "'" + aValueString + "' should equal '" + aExpectedString + "'"; return this._test(condition, aMessage, diagnosis); }, /** * Test if an object does not equal another object * * @param {object} aValue * The object to test. * @param {object} aExpected * The object to strictly compare with. * @param {string} aMessage * Message to show for the test result * @throws {errors.AssertionError} * * @returns {boolean} Result of the test. */ notDeepEqual: function notEqual(aValue, aExpected, aMessage) { let condition = !this._deepEqual(aValue, aExpected); try { var aValueString = JSON.stringify(aValue); } catch (e) { var aValueString = String(aValue); } try { var aExpectedString = JSON.stringify(aExpected); } catch (e) { var aExpectedString = String(aExpected); } let diagnosis = "'" + aValueString + "' should not equal '" + aExpectedString + "'"; return this._test(condition, aMessage, diagnosis); }, /** * Test if the regular expression matches the string. * * @param {string} aString * String to test. * @param {RegEx} aRegex * Regular expression to use for testing that a match exists. * @param {string} aMessage * Message to show for the test result * @throws {errors.AssertionError} * * @returns {boolean} Result of the test. */ match: function Assert_match(aString, aRegex, aMessage) { // XXX Bug 634948 // Regex objects are transformed to strings when evaluated in a sandbox // For now lets re-create the regex from its string representation let pattern = flags = ""; try { let matches = aRegex.toString().match(/\/(.*)\/(.*)/); pattern = matches[1]; flags = matches[2]; } catch (e) { } let regex = new RegExp(pattern, flags); let condition = (aString.match(regex) !== null); let diagnosis = "'" + regex + "' matches for '" + aString + "'"; return this._test(condition, aMessage, diagnosis); }, /** * Test if the regular expression does not match the string. * * @param {string} aString * String to test. * @param {RegEx} aRegex * Regular expression to use for testing that a match does not exist. * @param {string} aMessage * Message to show for the test result * @throws {errors.AssertionError} * * @returns {boolean} Result of the test. */ notMatch: function Assert_notMatch(aString, aRegex, aMessage) { // XXX Bug 634948 // Regex objects are transformed to strings when evaluated in a sandbox // For now lets re-create the regex from its string representation let pattern = flags = ""; try { let matches = aRegex.toString().match(/\/(.*)\/(.*)/); pattern = matches[1]; flags = matches[2]; } catch (e) { } let regex = new RegExp(pattern, flags); let condition = (aString.match(regex) === null); let diagnosis = "'" + regex + "' doesn't match for '" + aString + "'"; return this._test(condition, aMessage, diagnosis); }, /** * Test if a code block throws an exception. * * @param {string} block * function to call to test for exception * @param {RegEx} error * the expected error class * @param {string} message * message to present if assertion fails * @throws {errors.AssertionError} * * @returns {boolean} Result of the test. */ throws : function Assert_throws(block, /*optional*/error, /*optional*/message) { return this._throws.apply(this, [true].concat(Array.prototype.slice.call(arguments))); }, /** * Test if a code block doesn't throw an exception. * * @param {string} block * function to call to test for exception * @param {RegEx} error * the expected error class * @param {string} message * message to present if assertion fails * @throws {errors.AssertionError} * * @returns {boolean} Result of the test. */ doesNotThrow : function Assert_doesNotThrow(block, /*optional*/error, /*optional*/message) { return this._throws.apply(this, [false].concat(Array.prototype.slice.call(arguments))); }, /* Tests whether a code block throws the expected exception class. helper for throws() and doesNotThrow() adapted from node.js's assert._throws() https://github.com/joyent/node/blob/master/lib/assert.js */ _throws : function Assert__throws(shouldThrow, block, expected, message) { var actual; if (typeof expected === 'string') { message = expected; expected = null; } try { block(); } catch (e) { actual = e; } message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + (message ? ' ' + message : '.'); if (shouldThrow && !actual) { return this._test(false, message, 'Missing expected exception'); } if (!shouldThrow && this._expectedException(actual, expected)) { return this._test(false, message, 'Got unwanted exception'); } if ((shouldThrow && actual && expected && !this._expectedException(actual, expected)) || (!shouldThrow && actual)) { throw actual; } return this._test(true, message); }, /** * Test if the string contains the pattern. * * @param {String} aString String to test. * @param {String} aPattern Pattern to look for in the string * @param {String} aMessage Message to show for the test result * @throws {errors.AssertionError} * * @returns {Boolean} Result of the test. */ contain: function Assert_contain(aString, aPattern, aMessage) { let condition = (aString.indexOf(aPattern) !== -1); let diagnosis = "'" + aString + "' should contain '" + aPattern + "'"; return this._test(condition, aMessage, diagnosis); }, /** * Test if the string does not contain the pattern. * * @param {String} aString String to test. * @param {String} aPattern Pattern to look for in the string * @param {String} aMessage Message to show for the test result * @throws {errors.AssertionError} * * @returns {Boolean} Result of the test. */ notContain: function Assert_notContain(aString, aPattern, aMessage) { let condition = (aString.indexOf(aPattern) === -1); let diagnosis = "'" + aString + "' should not contain '" + aPattern + "'"; return this._test(condition, aMessage, diagnosis); }, /** * Waits for the callback evaluates to true * * @param {Function} aCallback * Callback for evaluation * @param {String} aMessage * Message to show for result * @param {Number} aTimeout * Timeout in waiting for evaluation * @param {Number} aInterval * Interval between evaluation attempts * @param {Object} aThisObject * this object * @throws {errors.AssertionError} * * @returns {Boolean} Result of the test. */ waitFor: function Assert_waitFor(aCallback, aMessage, aTimeout, aInterval, aThisObject) { var timeout = aTimeout || 5000; var interval = aInterval || 100; var self = { timeIsUp: false, result: aCallback.call(aThisObject) }; var deadline = Date.now() + timeout; function wait() { if (self.result !== true) { self.result = aCallback.call(aThisObject); self.timeIsUp = Date.now() > deadline; } } var hwindow = Services.appShell.hiddenDOMWindow; var timeoutInterval = hwindow.setInterval(wait, interval); var thread = Services.tm.currentThread; while (self.result !== true && !self.timeIsUp) { thread.processNextEvent(true); let type = typeof(self.result); if (type !== 'boolean') throw TypeError("waitFor() callback has to return a boolean" + " instead of '" + type + "'"); } hwindow.clearInterval(timeoutInterval); if (self.result !== true && self.timeIsUp) { aMessage = aMessage || arguments.callee.name + ": Timeout exceeded for '" + aCallback + "'"; throw new errors.TimeoutError(aMessage); } broker.pass({'function':'assert.waitFor()'}); return true; } } /* non-fatal assertions */ var Expect = function () {} Expect.prototype = new Assert(); /** * Log a test as failing by adding a fail frame. * * @param {object} aResult * Test result details used for reporting. *
*
fileName
*
Name of the file in which the assertion failed.
*
functionName
*
Function in which the assertion failed.
*
lineNumber
*
Line number of the file in which the assertion failed.
*
message
*
Message why the assertion failed.
*
*/ Expect.prototype._logFail = function Expect__logFail(aResult) { broker.fail({fail: aResult}); } /** * Waits for the callback evaluates to true * * @param {Function} aCallback * Callback for evaluation * @param {String} aMessage * Message to show for result * @param {Number} aTimeout * Timeout in waiting for evaluation * @param {Number} aInterval * Interval between evaluation attempts * @param {Object} aThisObject * this object */ Expect.prototype.waitFor = function Expect_waitFor(aCallback, aMessage, aTimeout, aInterval, aThisObject) { let condition = true; let message = aMessage; try { Assert.prototype.waitFor.apply(this, arguments); } catch (ex) { if (!(ex instanceof errors.AssertionError)) { throw ex; } message = ex.message; condition = false; } return this._test(condition, message); }