Skip to content
Browse files

update to latest qunit, which includes a feature request of mine. woo.

  • Loading branch information...
1 parent 6cf0248 commit b16f0977695e55300bd36591d7892ef1d543ddac @paulirish paulirish committed Jul 19, 2012
Showing with 1,353 additions and 863 deletions.
  1. +1 −1 test/js/unit-caniuse.js
  2. +67 −67 test/js/unit.js
  3. +29 −23 test/qunit/qunit.css
  4. +1,256 −772 test/qunit/qunit.js
View
2 test/js/unit-caniuse.js
@@ -98,7 +98,7 @@ window.caniusecb = function(scriptdata) {
}
// where we actually do most our assertions
- equals(o.result, ciubool,
+ equal(o.result, ciubool,
o.browser + o.version + ': Caniuse result for ' + o.ciufeature +
' matches Modernizr\'s ' + (o.fp ? '*false positive*' : 'result') + ' for ' + o.feature
);
View
134 test/js/unit.js
@@ -39,10 +39,10 @@ test("globals set up", function() {
.replace(/,script\w+/,'') // placed by jQuery
.split(',');
- equals('', leakedGlobArr.pop(), 'retrieved my empty item from the end');
- equals('', leakedGlobArr.shift(), 'retrieved my empty item from the front');
+ equal('', leakedGlobArr.pop(), 'retrieved my empty item from the end');
+ equal('', leakedGlobArr.shift(), 'retrieved my empty item from the front');
- equals(leakedGlobArr.toString(), [].toString(), 'no global variables should leak (other than Modernizr and iepp)');
+ equal(leakedGlobArr.toString(), [].toString(), 'no global variables should leak (other than Modernizr and iepp)');
});
@@ -55,7 +55,7 @@ test("bind is implemented", function() {
};
a = a.bind({modernizr: 'just awsome'});
- equals("just awsome", a(), 'bind works as expected');
+ equal("just awsome", a(), 'bind works as expected');
// thank you webkit layoutTests
@@ -97,17 +97,17 @@ test("bind is implemented", function() {
// Objects that allow call but not construct can be bound, but should throw if used with new.
var abcAt = String.prototype.charAt.bind("abc");
- equals(abcAt(1), "b", 'Objects that allow call but not construct can be bound...');
+ equal(abcAt(1), "b", 'Objects that allow call but not construct can be bound...');
- equals(1, Function.bind.length, 'it exists');
+ equal(1, Function.bind.length, 'it exists');
});
test("document.documentElement is valid and correct",1, function() {
- equals(document.documentElement,document.getElementsByTagName('html')[0]);
+ equal(document.documentElement,document.getElementsByTagName('html')[0]);
});
@@ -167,8 +167,8 @@ test('html classes are looking good',function(){
// decrement for the properties that are private
for (var i = -1, len = TEST.privates.length; ++i < len; ){
var item = TEST.privates[i];
- equals(-1, TEST.inArray(item, classes), 'private Modernizr object '+ item +'should not have matching classes');
- equals(-1, TEST.inArray('no-' + item, classes), 'private Modernizr object no-'+item+' should not have matching classes');
+ equal(-1, TEST.inArray(item, classes), 'private Modernizr object '+ item +'should not have matching classes');
+ equal(-1, TEST.inArray('no-' + item, classes), 'private Modernizr object no-'+item+' should not have matching classes');
}
// decrement for the non-boolean objects
@@ -184,7 +184,7 @@ test('html classes are looking good',function(){
});
- //equals(classes,newprops,'equal number of classes and global object props');
+ //equal(classes,newprops,'equal number of classes and global object props');
if (classes.length !== newprops){
//window.console && console.log(classes, newprops);
@@ -200,26 +200,26 @@ test('html classes are looking good',function(){
if (aclass.indexOf('no-') === 0){
aclass = aclass.replace('no-','');
- equals(Modernizr[aclass], false,
+ equal(Modernizr[aclass], false,
aclass + ' is correctly false in the classes and object')
} else {
- equals(Modernizr[aclass], true,
+ equal(Modernizr[aclass], true,
aclass + ' is correctly true in the classes and object')
}
}
for (var i = 0, len = classes.length, aclass; i <len; i++){
- equals(classes[i],classes[i].toLowerCase(),'all classes are lowerCase.');
+ equal(classes[i],classes[i].toLowerCase(),'all classes are lowerCase.');
}
// Remove fake no-js classes before test.
var docElClass = document.documentElement.className;
$.each(['\\+no-js', 'no-js-', 'i-has-no-js'], function(i, fakeClass) {
docElClass = docElClass.replace(new RegExp('(^|\\s)' + fakeClass + '(\\s|$)', 'g'), '$1$2');
});
- equals(/[^\s]no-/.test(docElClass), false, 'whitespace between all classes.');
+ equal(/[^\s]no-/.test(docElClass), false, 'whitespace between all classes.');
})
@@ -242,7 +242,7 @@ test('Modernizr properties are looking good',function(){
'Modernizr.'+prop+' is a straight up boolean');
- equals(prop,prop.toLowerCase(),'all properties are lowerCase.')
+ equal(prop,prop.toLowerCase(),'all properties are lowerCase.')
}
}
})
@@ -257,13 +257,13 @@ test('Modernizr.audio and Modernizr.video',function(){
if (Modernizr[prop].toString() == 'true'){
ok(Modernizr[prop], 'Modernizr.'+prop+' is truthy.');
- equals(Modernizr[prop] == true,true, 'Modernizr.'+prop+' is == true')
- equals(typeof Modernizr[prop] === 'object',true,'Moderizr.'+prop+' is truly an object');
- equals(Modernizr[prop] !== true,true, 'Modernizr.'+prop+' is !== true')
+ equal(Modernizr[prop] == true,true, 'Modernizr.'+prop+' is == true')
+ equal(typeof Modernizr[prop] === 'object',true,'Moderizr.'+prop+' is truly an object');
+ equal(Modernizr[prop] !== true,true, 'Modernizr.'+prop+' is !== true')
} else {
- equals(Modernizr[prop] != true,true, 'Modernizr.'+prop+' is != true')
+ equal(Modernizr[prop] != true,true, 'Modernizr.'+prop+' is != true')
}
}
@@ -274,9 +274,9 @@ test('Modernizr.audio and Modernizr.video',function(){
test('Modernizr results match expected values',function(){
// i'm bringing over a few tests from inside Modernizr.js
- equals(!!document.createElement('canvas').getContext,Modernizr.canvas,'canvas test consistent');
+ equal(!!document.createElement('canvas').getContext,Modernizr.canvas,'canvas test consistent');
- equals(!!window.Worker,Modernizr.webworkers,'web workers test consistent')
+ equal(!!window.Worker,Modernizr.webworkers,'web workers test consistent')
});
@@ -311,16 +311,16 @@ test('Modernizr.addTest()',22,function(){
});
ok(docEl.className.indexOf(' testtrue') >= 0,'positive class added');
- equals(Modernizr.testtrue,true,'positive prop added');
+ equal(Modernizr.testtrue,true,'positive prop added');
ok(docEl.className.indexOf(' testtruthy') >= 0,'positive class added');
- equals(Modernizr.testtruthy,100,'truthy value is not casted to straight boolean');
+ equal(Modernizr.testtruthy,100,'truthy value is not casted to straight boolean');
ok(docEl.className.indexOf(' no-testfalse') >= 0,'negative class added');
- equals(Modernizr.testfalse,false,'negative prop added');
+ equal(Modernizr.testfalse,false,'negative prop added');
ok(docEl.className.indexOf(' no-testfalsy') >= 0,'negative class added');
- equals(Modernizr.testfalsy,undefined,'falsy value is not casted to straight boolean');
+ equal(Modernizr.testfalsy,undefined,'falsy value is not casted to straight boolean');
@@ -337,25 +337,25 @@ test('Modernizr.addTest()',22,function(){
Modernizr.addTest('testboolfalse', false);
ok(~docEl.className.indexOf(' no-testboolfalse'), 'Modernizr.addTest(feature, bool): negative class added');
- equals(Modernizr.testboolfalse, false, 'Modernizr.addTest(feature, bool): negative prop added');
+ equal(Modernizr.testboolfalse, false, 'Modernizr.addTest(feature, bool): negative prop added');
Modernizr.addTest('testbooltrue', true);
ok(~docEl.className.indexOf(' testbooltrue'), 'Modernizr.addTest(feature, bool): positive class added');
- equals(Modernizr.testbooltrue, true, 'Modernizr.addTest(feature, bool): positive prop added');
+ equal(Modernizr.testbooltrue, true, 'Modernizr.addTest(feature, bool): positive prop added');
Modernizr.addTest({'testobjboolfalse': false,
'testobjbooltrue' : true });
ok(~docEl.className.indexOf(' no-testobjboolfalse'), 'Modernizr.addTest({feature: bool}): negative class added');
- equals(Modernizr.testobjboolfalse, false, 'Modernizr.addTest({feature: bool}): negative prop added');
+ equal(Modernizr.testobjboolfalse, false, 'Modernizr.addTest({feature: bool}): negative prop added');
ok(~docEl.className.indexOf(' testobjbooltrue'), 'Modernizr.addTest({feature: bool}): positive class added');
- equals(Modernizr.testobjbooltrue, true, 'Modernizr.addTest({feature: bool}): positive prop added');
+ equal(Modernizr.testobjbooltrue, true, 'Modernizr.addTest({feature: bool}): positive prop added');
@@ -365,10 +365,10 @@ test('Modernizr.addTest()',22,function(){
ok(~docEl.className.indexOf(' no-testobjfnfalse'), 'Modernizr.addTest({feature: bool}): negative class added');
- equals(Modernizr.testobjfnfalse, false, 'Modernizr.addTest({feature: bool}): negative prop added');
+ equal(Modernizr.testobjfnfalse, false, 'Modernizr.addTest({feature: bool}): negative prop added');
ok(~docEl.className.indexOf(' testobjfntrue'), 'Modernizr.addTest({feature: bool}): positive class added');
- equals(Modernizr.testobjfntrue, true, 'Modernizr.addTest({feature: bool}): positive prop added');
+ equal(Modernizr.testobjfntrue, true, 'Modernizr.addTest({feature: bool}): positive prop added');
Modernizr
@@ -422,9 +422,9 @@ test('Modernizr.mq: media query testing',function(){
ok(Modernizr.mq,'Modernizr.mq() doesn\' freak out.');
- equals($.mobile.media('only screen'), Modernizr.mq('only screen'),'screen media query matches jQuery mobile\'s result');
+ equal($.mobile.media('only screen'), Modernizr.mq('only screen'),'screen media query matches jQuery mobile\'s result');
- equals(Modernizr.mq('only all'), Modernizr.mq('only all'), 'Cache hit matches');
+ equal(Modernizr.mq('only all'), Modernizr.mq('only all'), 'Cache hit matches');
});
@@ -437,12 +437,12 @@ test('Modernizr.hasEvent()',function(){
ok(typeof Modernizr.hasEvent == 'function','Modernizr.hasEvent() is a function');
- equals(Modernizr.hasEvent('click'), true,'click event is supported');
+ equal(Modernizr.hasEvent('click'), true,'click event is supported');
- equals(Modernizr.hasEvent('modernizrcustomevent'), false,'random event is definitely not supported');
+ equal(Modernizr.hasEvent('modernizrcustomevent'), false,'random event is definitely not supported');
/* works fine in webkit but not gecko
- equals( Modernizr.hasEvent('resize', window),
+ equal( Modernizr.hasEvent('resize', window),
!Modernizr.hasEvent('resize', document.createElement('div')),
'Resize is supported in window but not a div, typically...');
*/
@@ -455,37 +455,37 @@ test('Modernizr.hasEvent()',function(){
test('Modernizr.testStyles()',function(){
- equals(typeof Modernizr.testStyles, 'function','Modernizr.testStyles() is a function');
+ equal(typeof Modernizr.testStyles, 'function','Modernizr.testStyles() is a function');
var style = '#modernizr{ width: 9px; height: 4px; font-size: 0; color: papayawhip; }';
Modernizr.testStyles(style, function(elem, rule){
- equals(style, rule, 'rule passsed back matches what i gave it.')
- equals(elem.offsetWidth, 9, 'width was set through the style');
- equals(elem.offsetHeight, 4, 'height was set through the style');
- equals(elem.id, 'modernizr', 'element is indeed the modernizr element');
+ equal(style, rule, 'rule passsed back matches what i gave it.')
+ equal(elem.offsetWidth, 9, 'width was set through the style');
+ equal(elem.offsetHeight, 4, 'height was set through the style');
+ equal(elem.id, 'modernizr', 'element is indeed the modernizr element');
});
});
test('Modernizr._[properties]',function(){
- equals(6, Modernizr._prefixes.length, 'Modernizr._prefixes has 6 items');
+ equal(6, Modernizr._prefixes.length, 'Modernizr._prefixes has 6 items');
- equals(4, Modernizr._domPrefixes.length, 'Modernizr.domPrefixes has 4 items');
+ equal(4, Modernizr._domPrefixes.length, 'Modernizr.domPrefixes has 4 items');
});
test('Modernizr.testProp()',function(){
- equals(true, Modernizr.testProp('margin'), 'Everyone supports margin');
+ equal(true, Modernizr.testProp('margin'), 'Everyone supports margin');
- equals(false, Modernizr.testProp('happiness'), 'Nobody supports the happiness style. :(');
- equals(true, Modernizr.testProp('fontSize'), 'Everyone supports fontSize');
- equals(false, Modernizr.testProp('font-size'), 'Nobody supports font-size');
+ equal(false, Modernizr.testProp('happiness'), 'Nobody supports the happiness style. :(');
+ equal(true, Modernizr.testProp('fontSize'), 'Everyone supports fontSize');
+ equal(false, Modernizr.testProp('font-size'), 'Nobody supports font-size');
- equals('pointerEvents' in document.createElement('div').style,
+ equal('pointerEvents' in document.createElement('div').style,
Modernizr.testProp('pointerEvents'),
'results for `pointer-events` are consistent with a homegrown feature test');
@@ -495,15 +495,15 @@ test('Modernizr.testProp()',function(){
test('Modernizr.testAllProps()',function(){
- equals(true, Modernizr.testAllProps('margin'), 'Everyone supports margin');
+ equal(true, Modernizr.testAllProps('margin'), 'Everyone supports margin');
- equals(false, Modernizr.testAllProps('happiness'), 'Nobody supports the happiness style. :(');
- equals(true, Modernizr.testAllProps('fontSize'), 'Everyone supports fontSize');
- equals(false, Modernizr.testAllProps('font-size'), 'Nobody supports font-size');
+ equal(false, Modernizr.testAllProps('happiness'), 'Nobody supports the happiness style. :(');
+ equal(true, Modernizr.testAllProps('fontSize'), 'Everyone supports fontSize');
+ equal(false, Modernizr.testAllProps('font-size'), 'Nobody supports font-size');
- equals(Modernizr.csstransitions, Modernizr.testAllProps('transition'), 'Modernizr result matches API result: csstransitions');
+ equal(Modernizr.csstransitions, Modernizr.testAllProps('transition'), 'Modernizr result matches API result: csstransitions');
- equals(Modernizr.csscolumns, Modernizr.testAllProps('columnCount'), 'Modernizr result matches API result: csscolumns')
+ equal(Modernizr.csscolumns, Modernizr.testAllProps('columnCount'), 'Modernizr result matches API result: csscolumns')
});
@@ -552,7 +552,7 @@ test('Modernizr.prefixed() - css and DOM resolving', function(){
for (var i = -1, len = propArr.length; ++i < len; ){
var prop = propArr[i];
- equals(Modernizr.prefixed(prop), gimmePrefix(prop), 'results for ' + prop + ' match the homebaked prefix finder');
+ equal(Modernizr.prefixed(prop), gimmePrefix(prop), 'results for ' + prop + ' match the homebaked prefix finder');
}
for (var i = -1, len = domPropArr.length; ++i < len; ){
@@ -579,13 +579,13 @@ test('Modernizr.prefixed autobind', function(){
if (rAFName){
// rAF returns a function
- equals(
+ equal(
'function',
typeof Modernizr.prefixed('requestAnimationFrame', window),
"Modernizr.prefixed('requestAnimationFrame', window) returns a function")
// unless we false it to a string
- equals(
+ equal(
rAFName,
Modernizr.prefixed('requestAnimationFrame', window, false),
"Modernizr.prefixed('requestAnimationFrame', window, false) returns a string (the prop name)")
@@ -597,13 +597,13 @@ test('Modernizr.prefixed autobind', function(){
var fn = Modernizr.prefixed('matchesSelector', HTMLElement.prototype, document.body);
//returns function
- equals(
+ equal(
'function',
typeof fn,
"Modernizr.prefixed('matchesSelector', HTMLElement.prototype, document.body) returns a function");
// fn scoping
- equals(
+ equal(
true,
fn('body'),
"Modernizr.prefixed('matchesSelector', HTMLElement.prototype, document.body) is scoped to the body")
@@ -614,7 +614,7 @@ test('Modernizr.prefixed autobind', function(){
if (window.webkitNotifications){
// should be an object.
- equals(
+ equal(
'object',
typeof Modernizr.prefixed('Notifications', window),
"Modernizr.prefixed('Notifications') returns an object");
@@ -625,7 +625,7 @@ test('Modernizr.prefixed autobind', function(){
if (typeof document.webkitIsFullScreen !== 'undefined'){
// boolean
- equals(
+ equal(
'boolean',
typeof Modernizr.prefixed('isFullScreen', document),
"Modernizr.prefixed('isFullScreen') returns a boolean");
@@ -637,7 +637,7 @@ test('Modernizr.prefixed autobind', function(){
if (typeof document.mozFullScreen !== 'undefined'){
// boolean
- equals(
+ equal(
'boolean',
typeof Modernizr.prefixed('fullScreen', document),
"Modernizr.prefixed('fullScreen') returns a boolean");
@@ -648,30 +648,30 @@ test('Modernizr.prefixed autobind', function(){
if (document.body.style.WebkitAnimation){
// string
- equals(
+ equal(
'string',
typeof Modernizr.prefixed('animation', document.body.style),
"Modernizr.prefixed('animation', document.body.style) returns value of that, as a string");
- equals(
+ equal(
animationStyle.toLowerCase(),
Modernizr.prefixed('animation', document.body.style, false).toLowerCase(),
"Modernizr.prefixed('animation', document.body.style, false) returns the (case-normalized) name of the property: webkitanimation");
}
- equals(
+ equal(
false,
Modernizr.prefixed('doSomethingAmazing$#$', window),
"Modernizr.prefixed('doSomethingAmazing$#$', window) : Gobbledygook with prefixed(str,obj) returns false");
- equals(
+ equal(
false,
Modernizr.prefixed('doSomethingAmazing$#$', window, document.body),
"Modernizr.prefixed('doSomethingAmazing$#$', window) : Gobbledygook with prefixed(str,obj, scope) returns false");
- equals(
+ equal(
false,
Modernizr.prefixed('doSomethingAmazing$#$', window, false),
"Modernizr.prefixed('doSomethingAmazing$#$', window) : Gobbledygook with prefixed(str,obj, false) returns false");
View
52 test/qunit/qunit.css
@@ -1,9 +1,9 @@
/**
- * QUnit - A JavaScript Unit Testing Framework
+ * QUnit v1.9.0 - A JavaScript Unit Testing Framework
*
* http://docs.jquery.com/QUnit
*
- * Copyright (c) 2011 John Resig, Jörn Zaefferer
+ * Copyright (c) 2012 John Resig, Jörn Zaefferer
* Dual licensed under the MIT (MIT-LICENSE.txt)
* or GPL (GPL-LICENSE.txt) licenses.
*/
@@ -38,10 +38,10 @@
line-height: 1em;
font-weight: normal;
- border-radius: 15px 15px 0 0;
- -moz-border-radius: 15px 15px 0 0;
- -webkit-border-top-right-radius: 15px;
- -webkit-border-top-left-radius: 15px;
+ border-radius: 5px 5px 0 0;
+ -moz-border-radius: 5px 5px 0 0;
+ -webkit-border-top-right-radius: 5px;
+ -webkit-border-top-left-radius: 5px;
}
#qunit-header a {
@@ -54,6 +54,11 @@
color: #fff;
}
+#qunit-testrunner-toolbar label {
+ display: inline-block;
+ padding: 0 .5em 0 .1em;
+}
+
#qunit-banner {
height: 5px;
}
@@ -108,13 +113,9 @@
background-color: #fff;
- border-radius: 15px;
- -moz-border-radius: 15px;
- -webkit-border-radius: 15px;
-
- box-shadow: inset 0px 2px 13px #999;
- -moz-box-shadow: inset 0px 2px 13px #999;
- -webkit-box-shadow: inset 0px 2px 13px #999;
+ border-radius: 5px;
+ -moz-border-radius: 5px;
+ -webkit-border-radius: 5px;
}
#qunit-tests table {
@@ -157,8 +158,7 @@
#qunit-tests b.failed { color: #710909; }
#qunit-tests li li {
- margin: 0.5em;
- padding: 0.4em 0.5em 0.4em 0.5em;
+ padding: 5px;
background-color: #fff;
border-bottom: none;
list-style-position: inside;
@@ -167,9 +167,9 @@
/*** Passing Styles */
#qunit-tests li li.pass {
- color: #5E740B;
+ color: #3c510c;
background-color: #fff;
- border-left: 26px solid #C6E746;
+ border-left: 10px solid #C6E746;
}
#qunit-tests .pass { color: #528CE0; background-color: #D2E0E6; }
@@ -185,14 +185,15 @@
#qunit-tests li li.fail {
color: #710909;
background-color: #fff;
- border-left: 26px solid #EE5757;
+ border-left: 10px solid #EE5757;
+ white-space: pre;
}
#qunit-tests > li:last-child {
- border-radius: 0 0 15px 15px;
- -moz-border-radius: 0 0 15px 15px;
- -webkit-border-bottom-right-radius: 15px;
- -webkit-border-bottom-left-radius: 15px;
+ border-radius: 0 0 5px 5px;
+ -moz-border-radius: 0 0 5px 5px;
+ -webkit-border-bottom-right-radius: 5px;
+ -webkit-border-bottom-left-radius: 5px;
}
#qunit-tests .fail { color: #000000; background-color: #EE5757; }
@@ -215,11 +216,16 @@
border-bottom: 1px solid white;
}
+#qunit-testresult .module-name {
+ font-weight: bold;
+}
/** Fixture */
#qunit-fixture {
position: absolute;
top: -10000px;
left: -10000px;
-}
+ width: 1000px;
+ height: 1000px;
+}
View
2,028 test/qunit/qunit.js
@@ -1,145 +1,190 @@
/**
- * QUnit - A JavaScript Unit Testing Framework
+ * QUnit v1.9.0 - A JavaScript Unit Testing Framework
*
* http://docs.jquery.com/QUnit
*
- * Copyright (c) 2011 John Resig, Jörn Zaefferer
+ * Copyright (c) 2012 John Resig, Jörn Zaefferer
* Dual licensed under the MIT (MIT-LICENSE.txt)
* or GPL (GPL-LICENSE.txt) licenses.
*/
-(function(window) {
+(function( window ) {
-var defined = {
+var QUnit,
+ config,
+ onErrorFnPrev,
+ testId = 0,
+ fileName = (sourceFromStacktrace( 0 ) || "" ).replace(/(:\d+)+\)?/, "").replace(/.+\//, ""),
+ toString = Object.prototype.toString,
+ hasOwn = Object.prototype.hasOwnProperty,
+ defined = {
setTimeout: typeof window.setTimeout !== "undefined",
sessionStorage: (function() {
+ var x = "qunit-test-string";
try {
- return !!sessionStorage.getItem;
- } catch(e){
+ sessionStorage.setItem( x, x );
+ sessionStorage.removeItem( x );
+ return true;
+ } catch( e ) {
return false;
}
- })()
+ }())
};
-var testId = 0;
-
-var Test = function(name, testName, expected, testEnvironmentArg, async, callback) {
- this.name = name;
- this.testName = testName;
- this.expected = expected;
- this.testEnvironmentArg = testEnvironmentArg;
- this.async = async;
- this.callback = callback;
+function Test( settings ) {
+ extend( this, settings );
this.assertions = [];
-};
+ this.testNumber = ++Test.count;
+}
+
+Test.count = 0;
+
Test.prototype = {
init: function() {
- var tests = id("qunit-tests");
- if (tests) {
- var b = document.createElement("strong");
- b.innerHTML = "Running " + this.name;
- var li = document.createElement("li");
- li.appendChild( b );
- li.className = "running";
- li.id = this.id = "test-output" + testId++;
+ var a, b, li,
+ tests = id( "qunit-tests" );
+
+ if ( tests ) {
+ b = document.createElement( "strong" );
+ b.innerHTML = this.name;
+
+ // `a` initialized at top of scope
+ a = document.createElement( "a" );
+ a.innerHTML = "Rerun";
+ a.href = QUnit.url({ testNumber: this.testNumber });
+
+ li = document.createElement( "li" );
+ li.appendChild( b );
+ li.appendChild( a );
+ li.className = "running";
+ li.id = this.id = "qunit-test-output" + testId++;
+
tests.appendChild( li );
}
},
setup: function() {
- if (this.module != config.previousModule) {
+ if ( this.module !== config.previousModule ) {
if ( config.previousModule ) {
- QUnit.moduleDone( {
+ runLoggingCallbacks( "moduleDone", QUnit, {
name: config.previousModule,
failed: config.moduleStats.bad,
passed: config.moduleStats.all - config.moduleStats.bad,
total: config.moduleStats.all
- } );
+ });
}
config.previousModule = this.module;
config.moduleStats = { all: 0, bad: 0 };
- QUnit.moduleStart( {
+ runLoggingCallbacks( "moduleStart", QUnit, {
+ name: this.module
+ });
+ } else if ( config.autorun ) {
+ runLoggingCallbacks( "moduleStart", QUnit, {
name: this.module
- } );
+ });
}
config.current = this;
+
this.testEnvironment = extend({
setup: function() {},
teardown: function() {}
- }, this.moduleTestEnvironment);
- if (this.testEnvironmentArg) {
- extend(this.testEnvironment, this.testEnvironmentArg);
- }
+ }, this.moduleTestEnvironment );
- QUnit.testStart( {
- name: this.testName
- } );
+ runLoggingCallbacks( "testStart", QUnit, {
+ name: this.testName,
+ module: this.module
+ });
// allow utility functions to access the current test environment
// TODO why??
QUnit.current_testEnvironment = this.testEnvironment;
+ if ( !config.pollution ) {
+ saveGlobal();
+ }
+ if ( config.notrycatch ) {
+ this.testEnvironment.setup.call( this.testEnvironment );
+ return;
+ }
try {
- if ( !config.pollution ) {
- saveGlobal();
- }
-
- this.testEnvironment.setup.call(this.testEnvironment);
- } catch(e) {
- QUnit.ok( false, "Setup failed on " + this.testName + ": " + e.message );
+ this.testEnvironment.setup.call( this.testEnvironment );
+ } catch( e ) {
+ QUnit.pushFailure( "Setup failed on " + this.testName + ": " + e.message, extractStacktrace( e, 1 ) );
}
},
run: function() {
+ config.current = this;
+
+ var running = id( "qunit-testresult" );
+
+ if ( running ) {
+ running.innerHTML = "Running: <br/>" + this.name;
+ }
+
if ( this.async ) {
QUnit.stop();
}
if ( config.notrycatch ) {
- this.callback.call(this.testEnvironment);
+ this.callback.call( this.testEnvironment, QUnit.assert );
return;
}
+
try {
- this.callback.call(this.testEnvironment);
- } catch(e) {
- fail("Test " + this.testName + " died, exception and test follows", e, this.callback);
- QUnit.ok( false, "Died on test #" + (this.assertions.length + 1) + ": " + e.message + " - " + QUnit.jsDump.parse(e) );
+ this.callback.call( this.testEnvironment, QUnit.assert );
+ } catch( e ) {
+ QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + " " + this.stack + ": " + e.message, extractStacktrace( e, 0 ) );
// else next test will carry the responsibility
saveGlobal();
// Restart the tests if they're blocking
if ( config.blocking ) {
- start();
+ QUnit.start();
}
}
},
teardown: function() {
- try {
- this.testEnvironment.teardown.call(this.testEnvironment);
- checkPollution();
- } catch(e) {
- QUnit.ok( false, "Teardown failed on " + this.testName + ": " + e.message );
+ config.current = this;
+ if ( config.notrycatch ) {
+ this.testEnvironment.teardown.call( this.testEnvironment );
+ return;
+ } else {
+ try {
+ this.testEnvironment.teardown.call( this.testEnvironment );
+ } catch( e ) {
+ QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + e.message, extractStacktrace( e, 1 ) );
+ }
}
+ checkPollution();
},
finish: function() {
- if ( this.expected && this.expected != this.assertions.length ) {
- QUnit.ok( false, "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run" );
+ config.current = this;
+ if ( config.requireExpects && this.expected == null ) {
+ QUnit.pushFailure( "Expected number of assertions to be defined, but expect() was not called.", this.stack );
+ } else if ( this.expected != null && this.expected != this.assertions.length ) {
+ QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run", this.stack );
+ } else if ( this.expected == null && !this.assertions.length ) {
+ QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions.", this.stack );
}
- var good = 0, bad = 0,
- tests = id("qunit-tests");
+ var assertion, a, b, i, li, ol,
+ test = this,
+ good = 0,
+ bad = 0,
+ tests = id( "qunit-tests" );
config.stats.all += this.assertions.length;
config.moduleStats.all += this.assertions.length;
if ( tests ) {
- var ol = document.createElement("ol");
+ ol = document.createElement( "ol" );
- for ( var i = 0; i < this.assertions.length; i++ ) {
- var assertion = this.assertions[i];
+ for ( i = 0; i < this.assertions.length; i++ ) {
+ assertion = this.assertions[i];
- var li = document.createElement("li");
+ li = document.createElement( "li" );
li.className = assertion.result ? "pass" : "fail";
- li.innerHTML = assertion.message || (assertion.result ? "okay" : "failed");
+ li.innerHTML = assertion.message || ( assertion.result ? "okay" : "failed" );
ol.appendChild( li );
if ( assertion.result ) {
@@ -153,49 +198,48 @@ Test.prototype = {
// store result when possible
if ( QUnit.config.reorder && defined.sessionStorage ) {
- if (bad) {
- sessionStorage.setItem("qunit-" + this.module + "-" + this.testName, bad);
+ if ( bad ) {
+ sessionStorage.setItem( "qunit-test-" + this.module + "-" + this.testName, bad );
} else {
- sessionStorage.removeItem("qunit-" + this.module + "-" + this.testName);
+ sessionStorage.removeItem( "qunit-test-" + this.module + "-" + this.testName );
}
}
- if (bad == 0) {
+ if ( bad === 0 ) {
ol.style.display = "none";
}
- var b = document.createElement("strong");
+ // `b` initialized at top of scope
+ b = document.createElement( "strong" );
b.innerHTML = this.name + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + this.assertions.length + ")</b>";
- var a = document.createElement("a");
- a.innerHTML = "Rerun";
- a.href = QUnit.url({ filter: getText([b]).replace(/\([^)]+\)$/, "").replace(/(^\s*|\s*$)/g, "") });
-
addEvent(b, "click", function() {
var next = b.nextSibling.nextSibling,
display = next.style.display;
next.style.display = display === "none" ? "block" : "none";
});
- addEvent(b, "dblclick", function(e) {
+ addEvent(b, "dblclick", function( e ) {
var target = e && e.target ? e.target : window.event.srcElement;
if ( target.nodeName.toLowerCase() == "span" || target.nodeName.toLowerCase() == "b" ) {
target = target.parentNode;
}
if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
- window.location = QUnit.url({ filter: getText([target]).replace(/\([^)]+\)$/, "").replace(/(^\s*|\s*$)/g, "") });
+ window.location = QUnit.url({ testNumber: test.testNumber });
}
});
- var li = id(this.id);
+ // `li` initialized at top of scope
+ li = id( this.id );
li.className = bad ? "fail" : "pass";
li.removeChild( li.firstChild );
+ a = li.firstChild;
li.appendChild( b );
- li.appendChild( a );
+ li.appendChild ( a );
li.appendChild( ol );
} else {
- for ( var i = 0; i < this.assertions.length; i++ ) {
+ for ( i = 0; i < this.assertions.length; i++ ) {
if ( !this.assertions[i].result ) {
bad++;
config.stats.bad++;
@@ -204,22 +248,23 @@ Test.prototype = {
}
}
- try {
- QUnit.reset();
- } catch(e) {
- fail("reset() failed, following Test " + this.testName + ", exception and reset fn follows", e, QUnit.reset);
- }
-
- QUnit.testDone( {
+ runLoggingCallbacks( "testDone", QUnit, {
name: this.testName,
+ module: this.module,
failed: bad,
passed: this.assertions.length - bad,
total: this.assertions.length
- } );
+ });
+
+ QUnit.reset();
+
+ config.current = undefined;
},
queue: function() {
- var test = this;
+ var bad,
+ test = this;
+
synchronize(function() {
test.init();
});
@@ -238,263 +283,386 @@ Test.prototype = {
test.finish();
});
}
+
+ // `bad` initialized at top of scope
// defer when previous test run passed, if storage is available
- var bad = QUnit.config.reorder && defined.sessionStorage && +sessionStorage.getItem("qunit-" + this.module + "-" + this.testName);
- if (bad) {
+ bad = QUnit.config.reorder && defined.sessionStorage &&
+ +sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName );
+
+ if ( bad ) {
run();
} else {
- synchronize(run);
- };
+ synchronize( run, true );
+ }
}
-
};
-var QUnit = {
+// Root QUnit object.
+// `QUnit` initialized at top of scope
+QUnit = {
// call on start of module test to prepend name to all tests
- module: function(name, testEnvironment) {
+ module: function( name, testEnvironment ) {
config.currentModule = name;
config.currentModuleTestEnviroment = testEnvironment;
},
- asyncTest: function(testName, expected, callback) {
+ asyncTest: function( testName, expected, callback ) {
if ( arguments.length === 2 ) {
callback = expected;
- expected = 0;
+ expected = null;
}
- QUnit.test(testName, expected, callback, true);
+ QUnit.test( testName, expected, callback, true );
},
- test: function(testName, expected, callback, async) {
- var name = '<span class="test-name">' + testName + '</span>', testEnvironmentArg;
+ test: function( testName, expected, callback, async ) {
+ var test,
+ name = "<span class='test-name'>" + escapeInnerText( testName ) + "</span>";
if ( arguments.length === 2 ) {
callback = expected;
expected = null;
}
- // is 2nd argument a testEnvironment?
- if ( expected && typeof expected === 'object') {
- testEnvironmentArg = expected;
- expected = null;
- }
if ( config.currentModule ) {
- name = '<span class="module-name">' + config.currentModule + "</span>: " + name;
+ name = "<span class='module-name'>" + config.currentModule + "</span>: " + name;
}
- if ( !validTest(config.currentModule + ": " + testName) ) {
+ test = new Test({
+ name: name,
+ testName: testName,
+ expected: expected,
+ async: async,
+ callback: callback,
+ module: config.currentModule,
+ moduleTestEnvironment: config.currentModuleTestEnviroment,
+ stack: sourceFromStacktrace( 2 )
+ });
+
+ if ( !validTest( test ) ) {
return;
}
- var test = new Test(name, testName, expected, testEnvironmentArg, async, callback);
- test.module = config.currentModule;
- test.moduleTestEnvironment = config.currentModuleTestEnviroment;
test.queue();
},
- /**
- * Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through.
- */
- expect: function(asserts) {
+ // Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through.
+ expect: function( asserts ) {
config.current.expected = asserts;
},
+ start: function( count ) {
+ config.semaphore -= count || 1;
+ // don't start until equal number of stop-calls
+ if ( config.semaphore > 0 ) {
+ return;
+ }
+ // ignore if start is called more often then stop
+ if ( config.semaphore < 0 ) {
+ config.semaphore = 0;
+ }
+ // A slight delay, to avoid any current callbacks
+ if ( defined.setTimeout ) {
+ window.setTimeout(function() {
+ if ( config.semaphore > 0 ) {
+ return;
+ }
+ if ( config.timeout ) {
+ clearTimeout( config.timeout );
+ }
+
+ config.blocking = false;
+ process( true );
+ }, 13);
+ } else {
+ config.blocking = false;
+ process( true );
+ }
+ },
+
+ stop: function( count ) {
+ config.semaphore += count || 1;
+ config.blocking = true;
+
+ if ( config.testTimeout && defined.setTimeout ) {
+ clearTimeout( config.timeout );
+ config.timeout = window.setTimeout(function() {
+ QUnit.ok( false, "Test timed out" );
+ config.semaphore = 1;
+ QUnit.start();
+ }, config.testTimeout );
+ }
+ }
+};
+
+// Asssert helpers
+// All of these must call either QUnit.push() or manually do:
+// - runLoggingCallbacks( "log", .. );
+// - config.current.assertions.push({ .. });
+QUnit.assert = {
/**
- * Asserts true.
+ * Asserts rough true-ish result.
+ * @name ok
+ * @function
* @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
*/
- ok: function(a, msg) {
- a = !!a;
- var details = {
- result: a,
- message: msg
- };
- msg = escapeHtml(msg);
- QUnit.log(details);
+ ok: function( result, msg ) {
+ if ( !config.current ) {
+ throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) );
+ }
+ result = !!result;
+
+ var source,
+ details = {
+ result: result,
+ message: msg
+ };
+
+ msg = escapeInnerText( msg || (result ? "okay" : "failed" ) );
+ msg = "<span class='test-message'>" + msg + "</span>";
+
+ if ( !result ) {
+ source = sourceFromStacktrace( 2 );
+ if ( source ) {
+ details.source = source;
+ msg += "<table><tr class='test-source'><th>Source: </th><td><pre>" + escapeInnerText( source ) + "</pre></td></tr></table>";
+ }
+ }
+ runLoggingCallbacks( "log", QUnit, details );
config.current.assertions.push({
- result: a,
+ result: result,
message: msg
});
},
/**
- * Checks that the first two arguments are equal, with an optional message.
+ * Assert that the first two arguments are equal, with an optional message.
* Prints out both actual and expected values.
- *
- * Prefered to ok( actual == expected, message )
- *
- * @example equal( format("Received {0} bytes.", 2), "Received 2 bytes." );
- *
- * @param Object actual
- * @param Object expected
- * @param String message (optional)
+ * @name equal
+ * @function
+ * @example equal( format( "Received {0} bytes.", 2), "Received 2 bytes.", "format() replaces {0} with next argument" );
*/
- equal: function(actual, expected, message) {
- QUnit.push(expected == actual, actual, expected, message);
+ equal: function( actual, expected, message ) {
+ QUnit.push( expected == actual, actual, expected, message );
},
- notEqual: function(actual, expected, message) {
- QUnit.push(expected != actual, actual, expected, message);
+ /**
+ * @name notEqual
+ * @function
+ */
+ notEqual: function( actual, expected, message ) {
+ QUnit.push( expected != actual, actual, expected, message );
},
- deepEqual: function(actual, expected, message) {
- QUnit.push(QUnit.equiv(actual, expected), actual, expected, message);
+ /**
+ * @name deepEqual
+ * @function
+ */
+ deepEqual: function( actual, expected, message ) {
+ QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
},
- notDeepEqual: function(actual, expected, message) {
- QUnit.push(!QUnit.equiv(actual, expected), actual, expected, message);
+ /**
+ * @name notDeepEqual
+ * @function
+ */
+ notDeepEqual: function( actual, expected, message ) {
+ QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
},
- strictEqual: function(actual, expected, message) {
- QUnit.push(expected === actual, actual, expected, message);
+ /**
+ * @name strictEqual
+ * @function
+ */
+ strictEqual: function( actual, expected, message ) {
+ QUnit.push( expected === actual, actual, expected, message );
},
- notStrictEqual: function(actual, expected, message) {
- QUnit.push(expected !== actual, actual, expected, message);
+ /**
+ * @name notStrictEqual
+ * @function
+ */
+ notStrictEqual: function( actual, expected, message ) {
+ QUnit.push( expected !== actual, actual, expected, message );
},
- raises: function(block, expected, message) {
- var actual, ok = false;
+ throws: function( block, expected, message ) {
+ var actual,
+ ok = false;
- if (typeof expected === 'string') {
+ // 'expected' is optional
+ if ( typeof expected === "string" ) {
message = expected;
expected = null;
}
+ config.current.ignoreGlobalErrors = true;
try {
- block();
+ block.call( config.current.testEnvironment );
} catch (e) {
actual = e;
}
+ config.current.ignoreGlobalErrors = false;
- if (actual) {
+ if ( actual ) {
// we don't want to validate thrown error
- if (!expected) {
+ if ( !expected ) {
ok = true;
// expected is a regexp
- } else if (QUnit.objectType(expected) === "regexp") {
- ok = expected.test(actual);
+ } else if ( QUnit.objectType( expected ) === "regexp" ) {
+ ok = expected.test( actual );
// expected is a constructor
- } else if (actual instanceof expected) {
+ } else if ( actual instanceof expected ) {
ok = true;
// expected is a validation function which returns true is validation passed
- } else if (expected.call({}, actual) === true) {
+ } else if ( expected.call( {}, actual ) === true ) {
ok = true;
}
- }
-
- QUnit.ok(ok, message);
- },
-
- start: function() {
- config.semaphore--;
- if (config.semaphore > 0) {
- // don't start until equal number of stop-calls
- return;
- }
- if (config.semaphore < 0) {
- // ignore if start is called more often then stop
- config.semaphore = 0;
- }
- // A slight delay, to avoid any current callbacks
- if ( defined.setTimeout ) {
- window.setTimeout(function() {
- if ( config.timeout ) {
- clearTimeout(config.timeout);
- }
- config.blocking = false;
- process();
- }, 13);
+ QUnit.push( ok, actual, null, message );
} else {
- config.blocking = false;
- process();
+ QUnit.pushFailure( message, null, 'No exception was thrown.' );
}
- },
+ }
+};
- stop: function(timeout) {
- config.semaphore++;
- config.blocking = true;
+/**
+ * @deprecate since 1.8.0
+ * Kept assertion helpers in root for backwards compatibility
+ */
+extend( QUnit, QUnit.assert );
- if ( timeout && defined.setTimeout ) {
- clearTimeout(config.timeout);
- config.timeout = window.setTimeout(function() {
- QUnit.ok( false, "Test timed out" );
- QUnit.start();
- }, timeout);
- }
- }
+/**
+ * @deprecated since 1.9.0
+ * Kept global "raises()" for backwards compatibility
+ */
+QUnit.raises = QUnit.assert.throws;
+
+/**
+ * @deprecated since 1.0.0, replaced with error pushes since 1.3.0
+ * Kept to avoid TypeErrors for undefined methods.
+ */
+QUnit.equals = function() {
+ QUnit.push( false, false, false, "QUnit.equals has been deprecated since 2009 (e88049a0), use QUnit.equal instead" );
+};
+QUnit.same = function() {
+ QUnit.push( false, false, false, "QUnit.same has been deprecated since 2009 (e88049a0), use QUnit.deepEqual instead" );
};
-// Backwards compatibility, deprecated
-QUnit.equals = QUnit.equal;
-QUnit.same = QUnit.deepEqual;
+// We want access to the constructor's prototype
+(function() {
+ function F() {}
+ F.prototype = QUnit;
+ QUnit = new F();
+ // Make F QUnit's constructor so that we can add to the prototype later
+ QUnit.constructor = F;
+}());
-// Maintain internal state
-var config = {
+/**
+ * Config object: Maintain internal state
+ * Later exposed as QUnit.config
+ * `config` initialized at top of scope
+ */
+config = {
// The queue of tests to run
queue: [],
// block until document ready
blocking: true,
+ // when enabled, show only failing tests
+ // gets persisted through sessionStorage and can be changed in UI via checkbox
+ hidepassed: false,
+
// by default, run previously failed tests first
// very useful in combination with "Hide passed tests" checked
reorder: true,
- noglobals: false,
- notrycatch: false
+ // by default, modify document.title when suite is done
+ altertitle: true,
+
+ // when enabled, all tests must call expect()
+ requireExpects: false,
+
+ // add checkboxes that are persisted in the query-string
+ // when enabled, the id is set to `true` as a `QUnit.config` property
+ urlConfig: [
+ {
+ id: "noglobals",
+ label: "Check for Globals",
+ tooltip: "Enabling this will test if any test introduces new properties on the `window` object. Stored as query-strings."
+ },
+ {
+ id: "notrycatch",
+ label: "No try-catch",
+ tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging exceptions in IE reasonable. Stored as query-strings."
+ }
+ ],
+
+ // logging callback queues
+ begin: [],
+ done: [],
+ log: [],
+ testStart: [],
+ testDone: [],
+ moduleStart: [],
+ moduleDone: []
};
-// Load paramaters
+// Initialize more QUnit.config and QUnit.urlParams
(function() {
- var location = window.location || { search: "", protocol: "file:" },
+ var i,
+ location = window.location || { search: "", protocol: "file:" },
params = location.search.slice( 1 ).split( "&" ),
length = params.length,
urlParams = {},
current;
if ( params[ 0 ] ) {
- for ( var i = 0; i < length; i++ ) {
+ for ( i = 0; i < length; i++ ) {
current = params[ i ].split( "=" );
current[ 0 ] = decodeURIComponent( current[ 0 ] );
// allow just a key to turn on a flag, e.g., test.html?noglobals
current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;
urlParams[ current[ 0 ] ] = current[ 1 ];
- if ( current[ 0 ] in config ) {
- config[ current[ 0 ] ] = current[ 1 ];
- }
}
}
QUnit.urlParams = urlParams;
+
+ // String search anywhere in moduleName+testName
config.filter = urlParams.filter;
+ // Exact match of the module name
+ config.module = urlParams.module;
+
+ config.testNumber = parseInt( urlParams.testNumber, 10 ) || null;
+
// Figure out if we're running the tests from a server or not
- QUnit.isLocal = !!(location.protocol === 'file:');
-})();
+ QUnit.isLocal = location.protocol === "file:";
+}());
+
+// Export global variables, unless an 'exports' object exists,
+// in that case we assume we're in CommonJS (dealt with on the bottom of the script)
+if ( typeof exports === "undefined" ) {
+ extend( window, QUnit );
-// Expose the API as global variables, unless an 'exports'
-// object exists, in that case we assume we're in CommonJS
-if ( typeof exports === "undefined" || typeof require === "undefined" ) {
- extend(window, QUnit);
+ // Expose QUnit object
window.QUnit = QUnit;
-} else {
- extend(exports, QUnit);
- exports.QUnit = QUnit;
}
-// define these after exposing globals to keep them in these QUnit namespace only
-extend(QUnit, {
+// Extend QUnit object,
+// these after set here because they should not be exposed as global functions
+extend( QUnit, {
config: config,
// Initialize the configuration options
init: function() {
- extend(config, {
+ extend( config, {
stats: { all: 0, bad: 0 },
moduleStats: { all: 0, bad: 0 },
- started: +new Date,
+ started: +new Date(),
updateRate: 1000,
blocking: false,
autostart: true,
@@ -504,9 +672,21 @@ extend(QUnit, {
semaphore: 0
});
- var tests = id( "qunit-tests" ),
- banner = id( "qunit-banner" ),
- result = id( "qunit-testresult" );
+ var tests, banner, result,
+ qunit = id( "qunit" );
+
+ if ( qunit ) {
+ qunit.innerHTML =
+ "<h1 id='qunit-header'>" + escapeInnerText( document.title ) + "</h1>" +
+ "<h2 id='qunit-banner'></h2>" +
+ "<div id='qunit-testrunner-toolbar'></div>" +
+ "<h2 id='qunit-userAgent'></h2>" +
+ "<ol id='qunit-tests'></ol>";
+ }
+
+ tests = id( "qunit-tests" );
+ banner = id( "qunit-banner" );
+ result = id( "qunit-testresult" );
if ( tests ) {
tests.innerHTML = "";
@@ -525,43 +705,36 @@ extend(QUnit, {
result.id = "qunit-testresult";
result.className = "result";
tests.parentNode.insertBefore( result, tests );
- result.innerHTML = 'Running...<br/>&nbsp;';
+ result.innerHTML = "Running...<br/>&nbsp;";
}
},
- /**
- * Resets the test setup. Useful for tests that modify the DOM.
- *
- * If jQuery is available, uses jQuery's html(), otherwise just innerHTML.
- */
+ // Resets the test setup. Useful for tests that modify the DOM.
+ // If jQuery is available, uses jQuery's html(), otherwise just innerHTML.
reset: function() {
+ var fixture;
+
if ( window.jQuery ) {
jQuery( "#qunit-fixture" ).html( config.fixture );
} else {
- var main = id( 'qunit-fixture' );
- if ( main ) {
- main.innerHTML = config.fixture;
+ fixture = id( "qunit-fixture" );
+ if ( fixture ) {
+ fixture.innerHTML = config.fixture;
}
}
},
- /**
- * Trigger an event on an element.
- *
- * @example triggerEvent( document.body, "click" );
- *
- * @param DOMElement elem
- * @param String type
- */
+ // Trigger an event on an element.
+ // @example triggerEvent( document.body, "click" );
triggerEvent: function( elem, type, event ) {
if ( document.createEvent ) {
- event = document.createEvent("MouseEvents");
+ event = document.createEvent( "MouseEvents" );
event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,
0, 0, 0, 0, 0, false, false, false, false, 0, null);
- elem.dispatchEvent( event );
+ elem.dispatchEvent( event );
} else if ( elem.fireEvent ) {
- elem.fireEvent("on"+type);
+ elem.fireEvent( "on" + type );
}
},
@@ -571,340 +744,545 @@ extend(QUnit, {
},
objectType: function( obj ) {
- if (typeof obj === "undefined") {
+ if ( typeof obj === "undefined" ) {
return "undefined";
-
// consider: typeof null === object
}
- if (obj === null) {
+ if ( obj === null ) {
return "null";
}
- var type = Object.prototype.toString.call( obj )
- .match(/^\[object\s(.*)\]$/)[1] || '';
+ var type = toString.call( obj ).match(/^\[object\s(.*)\]$/)[1] || "";
- switch (type) {
- case 'Number':
- if (isNaN(obj)) {
- return "nan";
- } else {
- return "number";
- }
- case 'String':
- case 'Boolean':
- case 'Array':
- case 'Date':
- case 'RegExp':
- case 'Function':
- return type.toLowerCase();
+ switch ( type ) {
+ case "Number":
+ if ( isNaN(obj) ) {
+ return "nan";
+ }
+ return "number";
+ case "String":
+ case "Boolean":
+ case "Array":
+ case "Date":
+ case "RegExp":
+ case "Function":
+ return type.toLowerCase();
}
- if (typeof obj === "object") {
- return "object";
+ if ( typeof obj === "object" ) {
+ return "object";
}
return undefined;
},
- push: function(result, actual, expected, message) {
- var details = {
- result: result,
- message: message,
- actual: actual,
- expected: expected
- };
+ push: function( result, actual, expected, message ) {
+ if ( !config.current ) {
+ throw new Error( "assertion outside test context, was " + sourceFromStacktrace() );
+ }
+
+ var output, source,
+ details = {
+ result: result,
+ message: message,
+ actual: actual,
+ expected: expected
+ };
+
+ message = escapeInnerText( message ) || ( result ? "okay" : "failed" );
+ message = "<span class='test-message'>" + message + "</span>";
+ output = message;
+
+ if ( !result ) {
+ expected = escapeInnerText( QUnit.jsDump.parse(expected) );
+ actual = escapeInnerText( QUnit.jsDump.parse(actual) );
+ output += "<table><tr class='test-expected'><th>Expected: </th><td><pre>" + expected + "</pre></td></tr>";
+
+ if ( actual != expected ) {
+ output += "<tr class='test-actual'><th>Result: </th><td><pre>" + actual + "</pre></td></tr>";
+ output += "<tr class='test-diff'><th>Diff: </th><td><pre>" + QUnit.diff( expected, actual ) + "</pre></td></tr>";
+ }
+
+ source = sourceFromStacktrace();
- message = escapeHtml(message) || (result ? "okay" : "failed");
- message = '<span class="test-message">' + message + "</span>";
- expected = escapeHtml(QUnit.jsDump.parse(expected));
- actual = escapeHtml(QUnit.jsDump.parse(actual));
- var output = message + '<table><tr class="test-expected"><th>Expected: </th><td><pre>' + expected + '</pre></td></tr>';
- if (actual != expected) {
- output += '<tr class="test-actual"><th>Result: </th><td><pre>' + actual + '</pre></td></tr>';
- output += '<tr class="test-diff"><th>Diff: </th><td><pre>' + QUnit.diff(expected, actual) +'</pre></td></tr>';
- }
- if (!result) {
- var source = sourceFromStacktrace();
- if (source) {
+ if ( source ) {
details.source = source;
- output += '<tr class="test-source"><th>Source: </th><td><pre>' + source +'</pre></td></tr>';
+ output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeInnerText( source ) + "</pre></td></tr>";
}
+
+ output += "</table>";
}
- output += "</table>";
- QUnit.log(details);
+ runLoggingCallbacks( "log", QUnit, details );
config.current.assertions.push({
result: !!result,
message: output
});
},
+ pushFailure: function( message, source, actual ) {
+ if ( !config.current ) {
+ throw new Error( "pushFailure() assertion outside test context, was " + sourceFromStacktrace(2) );
+ }
+
+ var output,
+ details = {
+ result: false,
+ message: message
+ };
+
+ message = escapeInnerText( message ) || "error";
+ message = "<span class='test-message'>" + message + "</span>";
+ output = message;
+
+ output += "<table>";
+
+ if ( actual ) {
+ output += "<tr class='test-actual'><th>Result: </th><td><pre>" + escapeInnerText( actual ) + "</pre></td></tr>";
+ }
+
+ if ( source ) {
+ details.source = source;
+ output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeInnerText( source ) + "</pre></td></tr>";
+ }
+
+ output += "</table>";
+
+ runLoggingCallbacks( "log", QUnit, details );
+
+ config.current.assertions.push({
+ result: false,
+ message: output
+ });
+ },
+
url: function( params ) {
params = extend( extend( {}, QUnit.urlParams ), params );
- var querystring = "?",
- key;
+ var key,
+ querystring = "?";
+
for ( key in params ) {
+ if ( !hasOwn.call( params, key ) ) {
+ continue;
+ }
querystring += encodeURIComponent( key ) + "=" +
encodeURIComponent( params[ key ] ) + "&";
}
return window.location.pathname + querystring.slice( 0, -1 );
},
+ extend: extend,
+ id: id,
+ addEvent: addEvent
+ // load, equiv, jsDump, diff: Attached later
+});
+
+/**
+ * @deprecated: Created for backwards compatibility with test runner that set the hook function
+ * into QUnit.{hook}, instead of invoking it and passing the hook function.
+ * QUnit.constructor is set to the empty F() above so that we can add to it's prototype here.
+ * Doing this allows us to tell if the following methods have been overwritten on the actual
+ * QUnit object.
+ */
+extend( QUnit.constructor.prototype, {
+
// Logging callbacks; all receive a single argument with the listed properties
// run test/logs.html for any related changes
- begin: function() {},
+ begin: registerLoggingCallback( "begin" ),
+
// done: { failed, passed, total, runtime }
- done: function() {},
+ done: registerLoggingCallback( "done" ),
+
// log: { result, actual, expected, message }
- log: function() {},
+ log: registerLoggingCallback( "log" ),
+
// testStart: { name }
- testStart: function() {},
+ testStart: registerLoggingCallback( "testStart" ),
+
// testDone: { name, failed, passed, total }
- testDone: function() {},
+ testDone: registerLoggingCallback( "testDone" ),
+
// moduleStart: { name }
- moduleStart: function() {},
+ moduleStart: registerLoggingCallback( "moduleStart" ),
+
// moduleDone: { name, failed, passed, total }
- moduleDone: function() {}
+ moduleDone: registerLoggingCallback( "moduleDone" )
});
if ( typeof document === "undefined" || document.readyState === "complete" ) {
config.autorun = true;
}
-addEvent(window, "load", function() {
- QUnit.begin({});
+QUnit.load = function() {
+ runLoggingCallbacks( "begin", QUnit, {} );
// Initialize the config, saving the execution queue
- var oldconfig = extend({}, config);
+ var banner, filter, i, label, len, main, ol, toolbar, userAgent, val, urlConfigCheckboxes,
+ urlConfigHtml = "",
+ oldconfig = extend( {}, config );
+
QUnit.init();
extend(config, oldconfig);
config.blocking = false;
- var userAgent = id("qunit-userAgent");
+ len = config.urlConfig.length;
+
+ for ( i = 0; i < len; i++ ) {
+ val = config.urlConfig[i];
+ if ( typeof val === "string" ) {
+ val = {
+ id: val,
+ label: val,
+ tooltip: "[no tooltip available]"
+ };
+ }
+ config[ val.id ] = QUnit.urlParams[ val.id ];
+ urlConfigHtml += "<input id='qunit-urlconfig-" + val.id + "' name='" + val.id + "' type='checkbox'" + ( config[ val.id ] ? " checked='checked'" : "" ) + " title='" + val.tooltip + "'><label for='qunit-urlconfig-" + val.id + "' title='" + val.tooltip + "'>" + val.label + "</label>";
+ }
+
+ // `userAgent` initialized at top of scope
+ userAgent = id( "qunit-userAgent" );
if ( userAgent ) {
userAgent.innerHTML = navigator.userAgent;
}
- var banner = id("qunit-header");
+
+ // `banner` initialized at top of scope
+ banner = id( "qunit-header" );
if ( banner ) {
- banner.innerHTML = '<a href="' + QUnit.url({ filter: undefined }) + '"> ' + banner.innerHTML + '</a> ' +
- '<label><input name="noglobals" type="checkbox"' + ( config.noglobals ? ' checked="checked"' : '' ) + '>noglobals</label>' +
- '<label><input name="notrycatch" type="checkbox"' + ( config.notrycatch ? ' checked="checked"' : '' ) + '>notrycatch</label>';
- addEvent( banner, "change", function( event ) {
- var params = {};
- params[ event.target.name ] = event.target.checked ? true : undefined;
- window.location = QUnit.url( params );
- });
+ banner.innerHTML = "<a href='" + QUnit.url({ filter: undefined, module: undefined, testNumber: undefined }) + "'>" + banner.innerHTML + "</a> ";
}
- var toolbar = id("qunit-testrunner-toolbar");
+ // `toolbar` initialized at top of scope
+ toolbar = id( "qunit-testrunner-toolbar" );
if ( toolbar ) {
- var filter = document.createElement("input");
+ // `filter` initialized at top of scope
+ filter = document.createElement( "input" );
filter.type = "checkbox";
filter.id = "qunit-filter-pass";
+
addEvent( filter, "click", function() {
- var ol = document.getElementById("qunit-tests");
+ var tmp,
+ ol = document.getElementById( "qunit-tests" );
+
if ( filter.checked ) {
ol.className = ol.className + " hidepass";
} else {
- var tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";
- ol.className = tmp.replace(/ hidepass /, " ");
+ tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";
+ ol.className = tmp.replace( / hidepass /, " " );
}
if ( defined.sessionStorage ) {
if (filter.checked) {
- sessionStorage.setItem("qunit-filter-passed-tests", "true");
+ sessionStorage.setItem( "qunit-filter-passed-tests", "true" );
} else {
- sessionStorage.removeItem("qunit-filter-passed-tests");
+ sessionStorage.removeItem( "qunit-filter-passed-tests" );
}
}
});
- if ( defined.sessionStorage && sessionStorage.getItem("qunit-filter-passed-tests") ) {
+
+ if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem( "qunit-filter-passed-tests" ) ) {
filter.checked = true;
- var ol = document.getElementById("qunit-tests");
+ // `ol` initialized at top of scope
+ ol = document.getElementById( "qunit-tests" );
ol.className = ol.className + " hidepass";
}
toolbar.appendChild( filter );
- var label = document.createElement("label");
- label.setAttribute("for", "qunit-filter-pass");
+ // `label` initialized at top of scope
+ label = document.createElement( "label" );
+ label.setAttribute( "for", "qunit-filter-pass" );
+ label.setAttribute( "title", "Only show tests and assertons that fail. Stored in sessionStorage." );
label.innerHTML = "Hide passed tests";
toolbar.appendChild( label );
+
+ urlConfigCheckboxes = document.createElement( 'span' );
+ urlConfigCheckboxes.innerHTML = urlConfigHtml;
+ addEvent( urlConfigCheckboxes, "change", function( event ) {
+ var params = {};
+ params[ event.target.name ] = event.target.checked ? true : undefined;
+ window.location = QUnit.url( params );
+ });
+ toolbar.appendChild( urlConfigCheckboxes );
}
- var main = id('qunit-fixture');
+ // `main` initialized at top of scope
+ main = id( "qunit-fixture" );
if ( main ) {
config.fixture = main.innerHTML;
}
- if (config.autostart) {
+ if ( config.autostart ) {
QUnit.start();
}
-});
+};
+
+addEvent( window, "load", QUnit.load );
+
+// `onErrorFnPrev` initialized at top of scope
+// Preserve other handlers
+onErrorFnPrev = window.onerror;
+
+// Cover uncaught exceptions
+// Returning true will surpress the default browser handler,
+// returning false will let it run.
+window.onerror = function ( error, filePath, linerNr ) {
+ var ret = false;
+ if ( onErrorFnPrev ) {
+ ret = onErrorFnPrev( error, filePath, linerNr );
+ }
+
+ // Treat return value as window.onerror itself does,
+ // Only do our handling if not surpressed.
+ if ( ret !== true ) {
+ if ( QUnit.config.current ) {
+ if ( QUnit.config.current.ignoreGlobalErrors ) {
+ return true;
+ }
+ QUnit.pushFailure( error, filePath + ":" + linerNr );
+ } else {
+ QUnit.test( "global failure", function() {
+ QUnit.pushFailure( error, filePath + ":" + linerNr );
+ });
+ }
+ return false;
+ }
+
+ return ret;
+};
function done() {
config.autorun = true;
// Log the last module results
if ( config.currentModule ) {
- QUnit.moduleDone( {
+ runLoggingCallbacks( "moduleDone", QUnit, {
name: config.currentModule,
failed: config.moduleStats.bad,
passed: config.moduleStats.all - config.moduleStats.bad,
total: config.moduleStats.all
- } );
+ });
}
- var banner = id("qunit-banner"),
- tests = id("qunit-tests"),
- runtime = +new Date - config.started,
+ var i, key,
+ banner = id( "qunit-banner" ),
+ tests = id( "qunit-tests" ),
+ runtime = +new Date() - config.started,
passed = config.stats.all - config.stats.bad,
html = [
- 'Tests completed in ',
+ "Tests completed in ",
runtime,
- ' milliseconds.<br/>',
- '<span class="passed">',
+ " milliseconds.<br/>",
+ "<span class='passed'>",
passed,
- '</span> tests of <span class="total">',
+ "</span> tests of <span class='total'>",
config.stats.all,
- '</span> passed, <span class="failed">',
+ "</span> passed, <span class='failed'>",
config.stats.bad,
- '</span> failed.'
- ].join('');
+ "</span> failed."
+ ].join( "" );
if ( banner ) {
- banner.className = (config.stats.bad ? "qunit-fail" : "qunit-pass");
+ banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" );
}
if ( tests ) {
id( "qunit-testresult" ).innerHTML = html;
}
- if ( typeof document !== "undefined" && document.title ) {
+ if ( config.altertitle && typeof document !== "undefined" && document.title ) {
// show ✖ for good, ✔ for bad suite result in title
// use escape sequences in case file gets loaded with non-utf-8-charset
- document.title = (config.stats.bad ? "\u2716" : "\u2714") + " " + document.title;
+ document.title = [
+ ( config.stats.bad ? "\u2716" : "\u2714" ),
+ document.title.replace( /^[\u2714\u2716] /i, "" )
+ ].join( " " );
+ }
+
+ // clear own sessionStorage items if all tests passed
+ if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) {
+ // `key` & `i` initialized at top of scope
+ for ( i = 0; i < sessionStorage.length; i++ ) {
+ key = sessionStorage.key( i++ );
+ if ( key.indexOf( "qunit-test-" ) === 0 ) {
+ sessionStorage.removeItem( key );
+ }
+ }
}
- QUnit.done( {
+ runLoggingCallbacks( "done", QUnit, {
failed: config.stats.bad,
passed: passed,
total: config.stats.all,
runtime: runtime
- } );
+ });
}
-function validTest( name ) {
- var filter = config.filter,
- run = false;
+/** @return Boolean: true if this test should be ran */
+function validTest( test ) {
+ var include,
+ filter = config.filter && config.filter.toLowerCase(),
+ module = config.module && config.module.toLowerCase(),
+ fullName = (test.module + ": " + test.testName).toLowerCase();
+
+ if ( config.testNumber ) {
+ return test.testNumber === config.testNumber;
+ }
+
+ if ( module && ( !test.module || test.module.toLowerCase() !== module ) ) {
+ return false;
+ }
if ( !filter ) {
return true;
}
- var not = filter.charAt( 0 ) === "!";
- if ( not ) {
+ include = filter.charAt( 0 ) !== "!";
+ if ( !include ) {
filter = filter.slice( 1 );
}
- if ( name.indexOf( filter ) !== -1 ) {
- return !not;
- }
-
- if ( not ) {
- run = true;
+ // If the filter matches, we need to honour include
+ if ( fullName.indexOf( filter ) !== -1 ) {
+ return include;
}
- return run;
+ // Otherwise, do the opposite
+ return !include;
}
-// so far supports only Firefox, Chrome and Opera (buggy)
-// could be extended in the future to use something like https://github.com/csnover/TraceKit
-function sourceFromStacktrace() {
+// so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions)
+// Later Safari and IE10 are supposed to support error.stack as well
+// See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
+function extractStacktrace( e, offset ) {
+ offset = offset === undefined ? 3 : offset;
+
+ var stack, include, i, regex;
+
+ if ( e.stacktrace ) {
+ // Opera
+ return e.stacktrace.split( "\n" )[ offset + 3 ];
+ } else if ( e.stack ) {
+ // Firefox, Chrome
+ stack = e.stack.split( "\n" );
+ if (/^error$/i.test( stack[0] ) ) {
+ stack.shift();
+ }
+ if ( fileName ) {
+ include = [];
+ for ( i = offset; i < stack.length; i++ ) {
+ if ( stack[ i ].indexOf( fileName ) != -1 ) {
+ break;
+ }
+ include.push( stack[ i ] );
+ }
+ if ( include.length ) {
+ return include.join( "\n" );
+ }
+ }
+ return stack[ offset ];
+ } else if ( e.sourceURL ) {
+ // Safari, PhantomJS
+ // hopefully one day Safari provides actual stacktraces
+ // exclude useless self-reference for generated Error objects
+ if ( /qunit.js$/.test( e.sourceURL ) ) {
+ return;
+ }
+ // for actual exceptions, this is useful
+ return e.sourceURL + ":" + e.line;
+ }
+}
+function sourceFromStacktrace( offset ) {
try {