QUnit源码阅读（2）：test基本执行流程

// 直接上代码

//step 1: write a simple test as the following.
test("hello test", function() {
ok(1 == "1", "Passed!");
});

//step 2: 调用test函数
QUnit = {
//...
test : function(testName, expected, callback, async) {
//...

//初始化test,
test = new Test({
name : name,
testName : testName,
expected : expected,
async : async,
callback : callback, //回调函数， very important
module : config.currentModule,
moduleTestEnvironment : config.currentModuleTestEnvironment,
stack : sourceFromStacktrace(2)
});

if (!validTest(test)) {
return;
}

test.queue();
},
//...
}

//step 3: 调用test.queue函数，在config.queue中存入test.init和queue的内置函数run。
Test.prototype = {
//...
queue : function() {
var bad, test = this;

synchronize(function() {
test.init();
});
function run() {
// each of these can by async
synchronize(function() {
test.setup();
});
synchronize(function() {
test.run();
});
synchronize(function() {
test.teardown();
});
synchronize(function() {
test.finish();
});
}

// `bad` initialized at top of scope
// defer when previous test run passed, if storage is available
bad = QUnit.config.reorder && defined.sessionStorage && +sessionStorage.getItem("qunit-test-" + this.module + "-" + this.testName);

if (bad) {
run();
} else {
synchronize(run, true);
}
}
//...
}

//step 4.1 - 4.2 在config.queue中存入callback函数
function synchronize(callback, last) {
config.queue.push(callback);

if (config.autorun && !config.blocking) {
process(last);
}
}

//step 5 调用Qunit.start函数
QUnit.load = function() {
runLoggingCallbacks("begin", QUnit, {});
//I do not care, right now

//...
QUnit.init();

//...
if (config.autostart) {
QUnit.start();
}
};

//step 6， 调用 process(true)
QUnit = {

//...
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);
//13ms后调用,即step 7
} else {
config.blocking = false;
process(true);
}
},
//...
}

//step 7: 调用 process(true)
(function() {
if (config.semaphore > 0) {
return;
}
if (config.timeout) {
clearTimeout(config.timeout);
}

config.blocking = false;
process(true);
//ref step 8
})()
//step 8, 循环泵，整个test框架的调用驱动函数,将config.queue[]中的回调依次拿出来run
//Attention： 利用函数window.setTimeout及next函数来不断循环的技巧☆☆☆
function process(last) {
function next() {
process(last);
}

var start = new Date().getTime();
config.depth = config.depth ? config.depth + 1 : 1;

while (config.queue.length && !config.blocking) {
if (!defined.setTimeout || config.updateRate <= 0 || ((new Date().getTime() - start ) < config.updateRate )) {
config.queue.shift()();
//Attention, this is very important.
} else {
window.setTimeout(next, 13);
//Or, 13ms 之后再次调用process(true).
break;
}
}
config.depth--;
if (last && !config.blocking && !config.queue.length && config.depth === 0) {
done();
}
}

//step 9， 调用init函数
Test.prototype = {
//...
init : function() {
//...
},
//...
}

//step 10. 调用run函数， 在 config.queue中放置更多的函数test.setup, run, teardown, finish
Test.prototype = {
//...
queue : function() {
//...
function run() {
// each of these can by async
synchronize(function() {
test.setup();
});
synchronize(function() {
test.run();
});
synchronize(function() {
test.teardown();
});
synchronize(function() {
test.finish();
});
}

//...
}
};

//step 11. 调用test.setup, run, teardown, finish
Test.prototype = {
//...
setup : function() {
//...
},

run : function() {
config.current = this;

var running = id("qunit-testresult");

if (running) {
running.innerHTML = "Running: <br/>" + this.name;
}

if (this.async) {
QUnit.stop();
}

//this.callback 将会调用我们在 step1中写的匿名函数function() { ok(1 == "1", "Passed!");})
//this.callback 的初始化请参考step2
if (config.notrycatch) {
this.callback.call(this.testEnvironment, QUnit.assert);
return;
}

try {
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) {
QUnit.start();
}
}
},

teardown : function() {
//...
},

finish : function() {
//...
},
};

//step 12: 调用 我们的测试函数
(function() {
ok(1 == "1", "Passed!");
});

//step 13: ok函数
QUnit.assert = {
/**
* Asserts rough true-ish result.
* @name ok
* @function
* @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
*/
ok : function(result, msg) {
//...
result = !!result;
//...
},
//...
equal : function(actual, expected, message) {
QUnit.push(expected == actual, actual, expected, message);
},
}

extend( QUnit, {
//...
push: function( result, actual, expected, message ) {
//...
message = escapeInnerText( message ) || ( result ? "okay" : "failed" );
//...
},
//...
});