<\/code>, QUnit will handle the reset for us. Finally, we include a tests.js file that represents the file containing the tests. My advice is to use files to store tests when working with real projects. In the live demo I created for this tutorial, I used JSBin and certainly did not allow uploading of files. So in the demo, you'll see that I've inlined the test code. Now that you understand what it means to tag each section, open the index.html page in your browser to see what happens. If all goes well, you should see a live demo interface as shown below, which is also provided as JSBin: QUnit example. At this stage, the only part of this interface that is relevant to us is the part that shows the time QUnit spends processing tests, the number of assertions defined, and the number of tests passed and failed. The above demonstration shows that we do not define any tests. Let's solve this problem. <\/p>\n

How to create tests using QUnit<\/strong><\/p>\n

QUnit provides two ways to create new tests: QUnit.test()<\/code> and QUnit.asyncTest()<\/code>. The first one is used to test code running synchronously, while the second one is used to test asynchronous code. In this section, I will describe how to create tests for synchronous code. The signature of the QUnit.test()<\/code> method is as follows: <\/p>\n

QUnit.test(name, testFunction)<\/pre>\n
The first parameter name<\/code> is a string that helps us identify the created tests. The second parameter testFunction<\/code> is a function that contains the assertions the framework will execute. The framework passes a parameter to this function that exposes all QUnit's assertion methods. Convert this description to code, we can update the tests.js file with the following code: <\/p>\n
QUnit.test('我的第一個測試', function(assert) {\n   \/\/ 斷言在這里...\n});<\/pre>\n
This code creates a new test identified by the string \"My First Test\" and a function with an empty body. Adding tests without any assertions is of no use. To solve this problem, we must learn the assertion methods available in QUnit. <\/p>\n
QUnit's assertion method<\/strong><\/p>\n
Assertions are at the heart of software testing. They allow us to verify that our code works as expected. In QUnit, we have many ways to verify these expectations. They can be accessed in tests by parameters of functions passed to the QUnit.test()<\/code> method (in our previous example, assert<\/code>). The following list summarizes the available methods, as well as their functions and signatures: <\/p>
\n
deepEqual(value, expected[, message])<\/code>: A recursive strict comparison that works for all JavaScript types. If value<\/code> and expected<\/code> are the same in terms of properties and values, and have the same prototype, the assertion is passed; <\/li>\n
equal(value, expected[, message])<\/code>: The value<\/code> equals expected<\/code> parameter provided using non-strict comparison (==) verification. <\/li>\n
notDeepEqual(value, expected[, message])<\/code>: Same as deepEqual()<\/code>, but tests inequality; <\/li>\n
notEqual(value, expected[, message])<\/code>: Same as equal()<\/code>, but tests inequality; <\/li>\n
propEqual(value, expected[, message])<\/code>: Strict comparison of the properties and values ??of an object. If all attributes and values ??are the same, the assertion passes; <\/li>\n
strictEqual(value, expected[, message])<\/code>: Use strict comparison (===) verification to provide the value<\/code> parameter equal to the expected<\/code>; <\/li>\n
notPropEqual(value, expected[, message])<\/code>: Same as propEqual()<\/code>, but tests inequality; <\/li>\n
notStrictEqual(value, expected[, message])<\/code>: Same as strictEqual()<\/code>, but tests inequality; <\/li>\n
ok(value[, message])<\/code>: If the first parameter is a true value, the assertion passes; <\/li>\n
throws(function[, expected][, message])<\/code>: Test whether the callback throws an exception and optionally compare the thrown errors; <\/li>\n<\/ul>\n
The parameters accepted by these methods are as follows: <\/p>\n
\n
value<\/code>: The value returned by a function, method, or the value stored in a variable that must be verified; <\/li>\n
expected<\/code>: The value to be tested. For the throws()<\/code> method, this can be Error 對象（實例）、Error 函數(shù)（構(gòu)造函數(shù)）、與字符串表示匹配（或部分匹配）的正則表達(dá)式或必須返回 true 以通過斷言檢查的回調(diào)函數(shù)<\/q><\/code>; <\/li>\n
message<\/code>: an optional string describing the assertion; <\/li>\n
function<\/code>: The function to be executed should return an Error; <\/li>\n<\/ul>\n
Now that you have understood the methods and parameters available, it's time to check out some code. Instead of writing multiple tests for a single function, I try to reproduce a more realistic example. Anyway, the tests I will show you should not be considered a complete test suite, but they should give you a specific idea of ??where to start. In order to write the mentioned tests, we need to define some code to test. In this case, I will define an object literal like this: <\/p>
\n\n\n  \n