├── .gitignore
├── docs
    ├── layout
    │   ├── foot.html
    │   └── head.html
    ├── index.md
    ├── index.html
    └── api.html
├── .gitmodules
├── test
    ├── match
    │   └── test.js
    ├── async.test.js
    ├── bar.test.js
    ├── .invalid.test.js
    ├── foo.test.js
    ├── earlyexit
    │   └── forever.test.js
    ├── serial
    │   ├── teardown.test.js
    │   ├── async.test.js
    │   └── http.test.js
    ├── this.test.js
    ├── earlyexit.test.js
    ├── match.test.js
    ├── local-assert.test.js
    ├── assert.test.js
    └── http.test.js
├── package.json
├── Makefile
├── Readme.md
├── History.md
└── bin
    └── expresso


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | lib-cov
3 | node_modules/
4 | 


--------------------------------------------------------------------------------
/docs/layout/foot.html:
--------------------------------------------------------------------------------
1 | 		</div>
2 | 	</body>
3 | </html>


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "deps/jscoverage"]
2 | 	path = deps/jscoverage
3 | 	url = git://github.com/visionmedia/node-jscoverage.git
4 | 


--------------------------------------------------------------------------------
/test/match/test.js:
--------------------------------------------------------------------------------
 1 | var assert = require('assert'); 
 2 | 
 3 | module.exports = {
 4 |   'this test will pass': function() {
 5 |     assert.ok(true);
 6 |   },
 7 |   'this test will fail': function() {
 8 |     assert.ok(false);
 9 |   },
10 | }


--------------------------------------------------------------------------------
/test/async.test.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * Module dependencies.
 4 |  */
 5 | 
 6 | var assert = require('assert');
 7 | 
 8 | setTimeout(function(){
 9 |     exports['test async exports'] = function(){
10 |         assert.ok('wahoo');
11 |     };
12 | }, 100);


--------------------------------------------------------------------------------
/test/bar.test.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * Module dependencies.
 4 |  */
 5 | 
 6 | var assert = require('assert')
 7 |   , bar = require('bar');
 8 | 
 9 | module.exports = {
10 |     'bar()': function(){
11 |         assert.equal('bar', bar.bar());
12 |     }
13 | };


--------------------------------------------------------------------------------
/test/.invalid.test.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * This file should never run because it begins with a .
 3 |  */
 4 | 
 5 | var assert = require('assert');
 6 | 
 7 | exports['failure'] = function() {
 8 |     assert.ok(false, "Don't run files beginning with a dot");
 9 | };
10 | 


--------------------------------------------------------------------------------
/test/foo.test.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * Module dependencies.
 4 |  */
 5 | 
 6 | var assert = require('assert')
 7 |   , foo = require('foo');
 8 | 
 9 | module.exports = {
10 |     'foo()': function(){
11 |         assert.equal('foo', foo.foo());
12 |         assert.equal('foo', foo.foo());
13 |     }
14 | };


--------------------------------------------------------------------------------
/test/earlyexit/forever.test.js:
--------------------------------------------------------------------------------
1 | var http = require('http');
2 | var assert = require('assert');
3 | var server = http.createServer(function(req, res) { /* Never send a response */ });
4 | 
5 | exports['assert.response'] = function() {
6 |     // This will keep running for a while because the server never returns.
7 |     assert.response(server, { url: '/' }, { status: 200 });
8 | };
9 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | { "name": "expresso",
 2 |   "version": "0.9.2",
 3 |   "description": "TDD framework, light-weight, fast, CI-friendly",
 4 |   "author": "TJ Holowaychuk <tj@vision-media.ca>",
 5 |   "repository": "git://github.com/visionmedia/expresso",
 6 |   "bin": {
 7 |     "expresso": "./bin/expresso",
 8 |     "node-jscoverage": "./deps/jscoverage/node-jscoverage"
 9 |   },
10 |   "scripts": {
11 |     "preinstall": "make deps/jscoverage/node-jscoverage"
12 |   }
13 | }


--------------------------------------------------------------------------------
/test/serial/teardown.test.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * Module dependencies.
 4 |  */
 5 | 
 6 | var assert = require('assert');
 7 | 
 8 | var a = 0;
 9 | 
10 | module.exports = {
11 |   teardown : function (done) {
12 |     a--;
13 |     done();
14 |   },
15 |   test1 : function(done) {
16 |     a++;
17 |     assert.strictEqual(1, a);
18 |     done();
19 |   },
20 |   test2 : function (done) {
21 |     a++;
22 |     assert.strictEqual(1, a);
23 |     done();
24 |   }
25 | };
26 | 


--------------------------------------------------------------------------------
/test/this.test.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * This.
 3 |  */
 4 | 
 5 | module.exports = {
 6 |     'test this': function(beforeExit, assert) {
 7 |         assert.equal(this.suite, 'this.test.js');
 8 |         assert.equal(this.title, 'test this');
 9 |         assert.ok(this.assert);
10 | 
11 |         var exiting = false;
12 |         this.on('exit', function() {
13 |             exiting = true;
14 |         });
15 | 
16 |         beforeExit(function() {
17 |             assert.ok(exiting);
18 |         });
19 |     }
20 | };


--------------------------------------------------------------------------------
/test/earlyexit.test.js:
--------------------------------------------------------------------------------
 1 | var assert = require('assert');
 2 | var spawn = require('child_process').spawn;
 3 | 
 4 | exports['early exit'] = function(beforeExit) {
 5 |     var completed = false;
 6 | 
 7 |     var proc = spawn('bin/expresso', ['test/earlyexit/forever.test.js', '--port', '23444']);
 8 |     proc.on('exit', function(code) {
 9 |         completed = true;
10 |         assert.equal(1, code, "assert.response didn't report an error while still running");
11 |     });
12 | 
13 |     setTimeout(function() {
14 |         proc.kill('SIGINT');
15 |     }, 1000);
16 | 
17 |     // Also kill the child if it still exists.
18 |     beforeExit(function() {
19 |         proc.kill();
20 |         assert.ok(completed);
21 |     });
22 | };


--------------------------------------------------------------------------------
/test/serial/async.test.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var assert = require('assert')
 3 |   , setup = 0
 4 |   , order = [];
 5 | 
 6 | module.exports = {
 7 |     setup: function(done){
 8 |         ++setup;
 9 |         done();
10 |     },
11 | 
12 |     a: function(done){
13 |         assert.equal(1, setup);
14 |         order.push('a');
15 |         setTimeout(function(){
16 |             done();
17 |         }, 500);
18 |     },
19 |     
20 |     b: function(done){
21 |         assert.equal(2, setup);
22 |         order.push('b');
23 |         setTimeout(function(){
24 |             done();
25 |         }, 200);
26 |     },
27 |     
28 |     c: function(done){
29 |         assert.equal(3, setup);
30 |         order.push('c');
31 |         setTimeout(function(){
32 |             done();
33 |         }, 1000);
34 |     },
35 | 
36 |     d: function(){
37 |         assert.eql(order, ['a', 'b', 'c']);
38 |     }
39 | };


--------------------------------------------------------------------------------
/test/match.test.js:
--------------------------------------------------------------------------------
 1 | var assert = require('assert');
 2 | var spawn = require('child_process').spawn;
 3 | 
 4 | module.exports = {
 5 |   'will run only matched tests': function() {
 6 |     var proc = spawn('bin/expresso', ['-m', 'p..s', 'test/match/test.js']);
 7 |     proc.on('exit', function(code) {
 8 |         completed = true;
 9 |         assert.equal(0, code, 'failing test was not filtered out');
10 |     });
11 |     setTimeout(function() {
12 |         proc.kill('SIGINT');
13 |     }, 1000);
14 |   },
15 |   'will run tests matched in a subsequent expression': function() {
16 |     var proc = spawn('bin/expresso', ['-m', 'nothing', '--match', 'p..s', 'test/match/test.js']);
17 |     proc.on('exit', function(code) {
18 |         completed = true;
19 |         assert.equal(0, code, 'failing test was not filtered out');
20 |     });
21 |     setTimeout(function() {
22 |         proc.kill('SIGINT');
23 |     }, 1000);
24 |   },
25 | };


--------------------------------------------------------------------------------
/test/local-assert.test.js:
--------------------------------------------------------------------------------
 1 | var assert = require('assert');
 2 | 
 3 | // Using a localized version of assert.
 4 | exports['first'] = function(beforeExit, assert) {
 5 |     process.nextTick(function() {
 6 |         assert.equal(assert._test.suite, 'local-assert.test.js');
 7 |         assert.equal(assert._test.title, 'first');
 8 |         try {
 9 |            var error = false;
10 |            assert.ok(false);
11 |         } catch (err) {
12 |            assert.equal(err._test, assert._test);
13 |            error = true;
14 |         }
15 |         assert.ok(error);
16 |     });
17 | };
18 | 
19 | // Using the broken global version of assert.
20 | exports['second'] = function(beforeExit) {
21 |     process.nextTick(function() {
22 |         assert.notEqual(assert._test.suite, 'local-assert.test.js');
23 |         assert.notEqual(assert._test.title, 'third');
24 |     });
25 | };
26 | 
27 | // Overwrite the testTitle in assert.
28 | exports['third'] = function() {};
29 | 


--------------------------------------------------------------------------------
/docs/layout/head.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>Expresso - TDD Framework For Node</title>
 4 | 		<style>
 5 | 			body {
 6 | 				font: 13px/1.4 "Helvetica", "Lucida Grande", Arial, sans-serif;
 7 | 				text-align: center;
 8 | 			}
 9 | 			#ribbon {
10 | 				position: absolute;
11 | 				top: 0;
12 | 				right: 0;
13 | 				z-index: 10;
14 | 			}
15 | 			#wrapper {
16 | 			  margin: 0 auto;
17 | 				padding: 50px 80px;
18 | 				width: 700px;
19 | 				text-align: left;
20 | 			}
21 | 			h1, h2, h3 {
22 | 				margin: 25px 0 15px 0;
23 | 			}
24 | 			h1 {
25 | 			  font-size: 35px;
26 | 			}
27 | 			pre {
28 | 				margin: 0 5px;
29 | 				padding: 15px;
30 | 				border: 1px solid #eee;
31 | 			}
32 | 			a {
33 | 			  color: #00aaff;
34 | 			}
35 | 		</style>
36 | 	</head>
37 | 	<body>
38 | 		<a href="http://github.com/visionmedia/expresso">
39 | 			<img alt="Fork me on GitHub" id="ribbon" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" />
40 | 		</a>
41 | 		<div id="wrapper">
42 | 			<h1>Expresso 0.9.0</h1>
43 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | 
 2 | PREFIX ?= /usr/local
 3 | BIN = bin/expresso
 4 | JSCOV = deps/jscoverage/node-jscoverage
 5 | DOCS = docs/index.md
 6 | HTMLDOCS = $(DOCS:.md=.html)
 7 | 
 8 | test: $(BIN)
 9 | 	@./$(BIN) --growl $(TEST_FLAGS)
10 | 
11 | test-cov:
12 | 	@./$(BIN) -I lib --cov $(TEST_FLAGS)
13 | 
14 | test-serial:
15 | 	@./$(BIN) --serial $(TEST_FLAGS) test/serial/*.test.js
16 | 
17 | install: install-jscov install-expresso
18 | 
19 | uninstall:
20 | 	rm -f $(PREFIX)/bin/expresso
21 | 	rm -f $(PREFIX)/bin/node-jscoverage
22 | 
23 | install-jscov: $(JSCOV)
24 | 	install $(JSCOV) $(PREFIX)/bin
25 | 
26 | install-expresso:
27 | 	install $(BIN) $(PREFIX)/bin
28 | 
29 | $(JSCOV):
30 | 	cd deps/jscoverage && ./configure && make && mv jscoverage node-jscoverage
31 | 
32 | clean:
33 | 	@cd deps/jscoverage && git clean -fd
34 | 
35 | docs: docs/api.html $(HTMLDOCS)
36 | 
37 | %.html: %.md
38 | 	@echo "... $< > $@"
39 | 	@ronn --html $< \
40 | 		| cat docs/layout/head.html - docs/layout/foot.html \
41 | 		> $@
42 | 
43 | docs/api.html: bin/expresso
44 | 	dox \
45 | 		--title "Expresso" \
46 | 		--ribbon "http://github.com/visionmedia/expresso" \
47 | 		--desc "Insanely fast TDD framework for [node](http://nodejs.org) featuring code coverage reporting." \
48 | 		$< > $@
49 | 
50 | docclean:
51 | 	rm -f docs/*.html
52 | 
53 | .PHONY: test test-cov install uninstall install-expresso install-jscov clean docs docclean


--------------------------------------------------------------------------------
/test/serial/http.test.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * Module dependencies.
 4 |  */
 5 | 
 6 | var assert = require('assert')
 7 |   , http = require('http');
 8 | 
 9 | var server = http.createServer(function(req, res){
10 |     if (req.method === 'GET') {
11 |         if (req.url === '/delay') {
12 |             setTimeout(function(){
13 |                 res.writeHead(200, {});
14 |                 res.end('delayed');
15 |             }, 200);
16 |         } else {
17 |             var body = JSON.stringify({ name: 'tj' });
18 |             res.writeHead(200, {
19 |                 'Content-Type': 'application/json; charset=utf8',
20 |                 'Content-Length': body.length
21 |             });
22 |             res.end(body);
23 |         }
24 |     } else {
25 |         var body = '';
26 |         req.setEncoding('utf8');
27 |         req.addListener('data', function(chunk){ body += chunk });
28 |         req.addListener('end', function(){
29 |             res.writeHead(200, {});
30 |             res.end(req.url + ' ' + body);
31 |         });
32 |     }
33 | });
34 | 
35 | module.exports = {
36 |     'test assert.response()': function(done){
37 |         assert.response(server, {
38 |             url: '/',
39 |             method: 'GET'
40 |         },{
41 |             body: '{"name":"tj"}',
42 |             status: 200,
43 |             headers: {
44 |                 'Content-Type': 'application/json; charset=utf8'
45 |             }
46 |         }, done);
47 |     }
48 | };


--------------------------------------------------------------------------------
/test/assert.test.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * Module dependencies.
 4 |  */
 5 | 
 6 | var assert = require('assert');
 7 | 
 8 | module.exports = {
 9 |     'assert.eql()': function(){
10 |         assert.equal(assert.deepEqual, assert.eql);
11 |     },
12 |     
13 |     'assert.type()': function(){
14 |         assert.type('foobar', 'string');
15 |         assert.type(2, 'number');
16 |         assert.throws(function(){
17 |             assert.type([1,2,3], 'string');
18 |         });
19 |     },
20 |     
21 |     'assert.includes()': function(){
22 |         assert.includes('some random string', 'dom');
23 |         assert.throws(function(){
24 |            assert.include('some random string', 'foobar');
25 |         });
26 |     
27 |         assert.includes(['foo', 'bar'], 'bar');
28 |         assert.includes(['foo', 'bar'], 'foo');
29 |         assert.includes([1,2,3], 3);
30 |         assert.includes([1,2,3], 2);
31 |         assert.includes([1,2,3], 1);
32 |         assert.throws(function(){
33 |             assert.includes(['foo', 'bar'], 'baz');
34 |         });
35 |         
36 |         assert.throws(function(){
37 |             assert.includes({ wrong: 'type' }, 'foo');
38 |         });
39 |     },
40 |     
41 |     'assert.isNull()': function(){
42 |         assert.isNull(null);
43 |         assert.throws(function(){
44 |             assert.isNull(undefined);
45 |         });
46 |         assert.throws(function(){
47 |             assert.isNull(false);
48 |         });
49 |     },
50 |     
51 |     'assert.isUndefined()': function(){
52 |         assert.isUndefined(undefined);
53 |         assert.throws(function(){
54 |             assert.isUndefined(null);
55 |         });
56 |         assert.throws(function(){
57 |             assert.isUndefined(false);
58 |         });
59 |     },
60 |     
61 |     'assert.isNotNull()': function(){
62 |         assert.isNotNull(false);
63 |         assert.isNotNull(undefined);
64 |         assert.throws(function(){
65 |             assert.isNotNull(null);
66 |         });
67 |     },
68 |     
69 |     'assert.isDefined()': function(){
70 |         assert.isDefined(false);
71 |         assert.isDefined(null);
72 |         assert.throws(function(){
73 |             assert.isDefined(undefined);
74 |         });
75 |     },
76 |     
77 |     'assert.match()': function(){
78 |         assert.match('foobar', /foo(bar)?/);
79 |         assert.throws(function(){
80 |             assert.match('something', /rawr/);
81 |         });
82 |     }
83 | };


--------------------------------------------------------------------------------
/Readme.md:
--------------------------------------------------------------------------------
 1 | # Expresso
 2 | 
 3 |   TDD framework for [nodejs](http://nodejs.org). This module is
 4 |   no longer maintained by me, if you wish to maintain it let me know,
 5 |   otherwise use [Mocha](https://github.com/mochajs/mocha).
 6 |   
 7 | ## Features
 8 | 
 9 |   - light-weight
10 |   - intuitive async support
11 |   - intuitive test runner executable
12 |   - test coverage support and reporting
13 |   - uses the _assert_ module
14 |   - `assert.eql()` alias of `assert.deepEqual()`
15 |   - `assert.response()` http response utility
16 |   - `assert.includes()`
17 |   - `assert.type()`
18 |   - `assert.isNull()`
19 |   - `assert.isUndefined()`
20 |   - `assert.isNotNull()`
21 |   - `assert.isDefined()`
22 |   - `assert.match()`
23 |   - `assert.length()`
24 | 
25 | ## Installation
26 | 
27 | To install both expresso _and_ node-jscoverage run:
28 | 
29 |     $ make install
30 | 
31 | To install expresso alone (no build required) run:
32 | 
33 |     $ make install-expresso
34 | 
35 | Install via npm:
36 | 
37 |     $ npm install expresso
38 | 
39 | ## Usage
40 | 
41 | Create a directory named `test` in your project and place JavaScript files in it. Each JavaScript file can export multiple tests of this format:
42 | 
43 | ```js
44 | exports['test String#length'] = function(beforeExit, assert) {
45 |     assert.equal(6, 'foobar'.length);
46 | };
47 | ```
48 | 
49 | To run tests, type `expresso`.
50 | 
51 | For more information, [see the manual](http://visionmedia.github.com/expresso/).
52 | 
53 | ## License
54 | 
55 | (The MIT License)
56 | 
57 | Copyright (c) 2010 TJ Holowaychuk &lt;tj@vision-media.ca&gt;
58 | 
59 | Permission is hereby granted, free of charge, to any person obtaining
60 | a copy of this software and associated documentation files (the
61 | 'Software'), to deal in the Software without restriction, including
62 | without limitation the rights to use, copy, modify, merge, publish,
63 | distribute, sublicense, and/or sell copies of the Software, and to
64 | permit persons to whom the Software is furnished to do so, subject to
65 | the following conditions:
66 | 
67 | The above copyright notice and this permission notice shall be
68 | included in all copies or substantial portions of the Software.
69 | 
70 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
71 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
72 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
73 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
74 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
75 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
76 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
77 | 


--------------------------------------------------------------------------------
/test/http.test.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /**
  3 |  * Module dependencies.
  4 |  */
  5 | 
  6 | var assert = require('assert')
  7 |   , http = require('http');
  8 | 
  9 | var server = http.createServer(function(req, res){
 10 |   if (req.method === 'GET') {
 11 |     if (req.url === '/delay') {
 12 |       setTimeout(function(){
 13 |         res.writeHead(200, {});
 14 |         res.end('delayed');
 15 |       }, 200);
 16 |     } else {
 17 |       var body = JSON.stringify({ name: 'tj' });
 18 |       res.writeHead(200, {
 19 |         'Content-Type': 'application/json; charset=utf8',
 20 |         'Content-Length': body.length
 21 |       });
 22 |       res.end(body);
 23 |     }
 24 |   } else {
 25 |     var body = '';
 26 |     req.setEncoding('utf8');
 27 |     req.on('data', function(chunk){ body += chunk });
 28 |     req.on('end', function(){
 29 |       res.writeHead(200, {});
 30 |       res.end(req.url + ' ' + body);
 31 |     });
 32 |   }
 33 | });
 34 | 
 35 | var delayedServer = http.createServer(function(req, res){
 36 |   res.writeHead(200);
 37 |   res.end('it worked');
 38 | });
 39 | 
 40 | var oldListen = delayedServer.listen;
 41 | delayedServer.listen = function(){
 42 |   var args = arguments;
 43 |   setTimeout(function(){
 44 |     oldListen.apply(delayedServer, args);
 45 |   }, 100);
 46 | };
 47 | 
 48 | var runningServer = http.createServer(function(req, res){
 49 |   res.writeHead(200);
 50 |   res.end('it worked');
 51 | });
 52 | 
 53 | runningServer.listen(5554);
 54 | 
 55 | module.exports = {
 56 |   'test assert.response(req, res, fn)': function(beforeExit){
 57 |     var calls = 0;
 58 | 
 59 |     assert.response(server, {
 60 |       url: '/',
 61 |       method: 'GET'
 62 |     },{
 63 |       body: '{"name":"tj"}',
 64 |       status: 200,
 65 |       headers: {
 66 |         'Content-Type': 'application/json; charset=utf8'
 67 |       }
 68 |     }, function(res){
 69 |       ++calls;
 70 |       assert.ok(res);
 71 |     });
 72 |     
 73 |     beforeExit(function(){
 74 |       assert.equal(1, calls);
 75 |     })
 76 |   },
 77 | 
 78 |   'test assert.response(req, fn)': function(beforeExit){
 79 |     var calls = 0;
 80 | 
 81 |     assert.response(server, {
 82 |       url: '/foo'
 83 |     }, function(res){
 84 |       ++calls;
 85 |       assert.ok(res.body.indexOf('tj') >= 0, 'Test assert.response() callback');
 86 |     });
 87 | 
 88 |     beforeExit(function(){
 89 |       assert.equal(1, calls);
 90 |     });
 91 |   },
 92 |   
 93 |   'test assert.response() delay': function(beforeExit){
 94 |     var calls = 0;
 95 | 
 96 |     assert.response(server,
 97 |       { url: '/delay', timeout: 1500 },
 98 |       { body: 'delayed' },
 99 |       function(){
100 |         ++calls;
101 |       });
102 | 
103 |     beforeExit(function(){
104 |       assert.equal(1, calls);
105 |     });
106 |   },
107 | 
108 |   'test assert.response() regexp': function(beforeExit){
109 |     var calls = 0;
110 | 
111 |     assert.response(server,
112 |       { url: '/foo', method: 'POST', data: 'foobar' },
113 |       { body: /^\/foo foo(bar)?/ },
114 |       function(){
115 |         ++calls;
116 |       });
117 |     
118 |     beforeExit(function(){
119 |       assert.equal(1, calls);
120 |     });
121 |   },
122 |   
123 |   'test assert.response() regexp headers': function(beforeExit){
124 |     var calls = 0;
125 | 
126 |     assert.response(server,
127 |       { url: '/' },
128 |       { body: '{"name":"tj"}', headers: { 'Content-Type': /^application\/json/ } },
129 |       function(){
130 |         ++calls;
131 |       });
132 |     
133 |     beforeExit(function(){
134 |       assert.equal(1, calls);
135 |     });
136 |   },
137 | 
138 |   // [!] if this test doesn't pass, an uncaught ECONNREFUSED will display
139 |   'test assert.response() with deferred listen()': function(beforeExit){
140 |     var calls = 0;
141 | 
142 |     assert.response(delayedServer,
143 |       { url: '/' },
144 |       { body: 'it worked' },
145 |       function(){
146 |         ++calls;
147 |       });
148 | 
149 |     beforeExit(function(){
150 |       assert.equal(1, calls);
151 |     });
152 |   },
153 | 
154 |   'test assert.response() with already running server': function(beforeExit){
155 |       var calls = 0;
156 | 
157 |       assert.response(runningServer,
158 |         { url: '/' },
159 |         { body: 'it worked' },
160 |         function(){
161 |           ++calls;
162 |         });
163 | 
164 |       beforeExit(function(){
165 |         assert.equal(1, calls);
166 |       });
167 |     }
168 | };
169 | 


--------------------------------------------------------------------------------
/History.md:
--------------------------------------------------------------------------------
  1 | 
  2 | 0.9.2 / 2011-10-12 
  3 | ==================
  4 | 
  5 |   * Fixed serial support
  6 | 
  7 | 0.9.1 / 2011-10-12 
  8 | ==================
  9 | 
 10 |   * Added 0.5.x support
 11 |   * Added regex based test name filtering argument
 12 |   * Removed "sys" module related calls
 13 | 
 14 | 0.8.1 / 2011-07-07 
 15 | ==================
 16 | 
 17 |   * Revert "Changed: explicitly exit on failure"
 18 |   * acquire port number from servers that are already running and wait until server started up
 19 | 
 20 | 0.8.0 / 2011-07-05 
 21 | ==================
 22 | 
 23 |   * Changed: explicitly exit on failure
 24 | 
 25 | 0.7.9 / 2011-06-22 
 26 | ==================
 27 | 
 28 |   * Fixed; increase maxListeners to prevent reaching the limit
 29 | 
 30 | 0.7.8 / 2011-06-22 
 31 | ==================
 32 | 
 33 |   * Added `--json [file]` flag to output JSON test coverage reports
 34 | 
 35 | 0.7.7 / 2011-05-24 
 36 | ==================
 37 | 
 38 |   * Moved to new http request API. Fixing Connection Refused error [Renault John Lecoultre]
 39 |   * Added encoding option to request function. Defaults to utf8 as before. [nateps]
 40 | 
 41 | 0.7.6 / 2011-04-20 
 42 | ==================
 43 | 
 44 |   * Added teardown for serial tests. Sync tests no longer require parameter. [Raevel]
 45 | 
 46 | 0.7.5 / 2011-03-31 
 47 | ==================
 48 | 
 49 |   * Fixed; removed some ansi-escape sequences in --boring mode [Norbert Schultz]
 50 | 
 51 | 0.7.4 / 2011-03-27 
 52 | ==================
 53 | 
 54 |   * Added coffee-script support (wahoo...)
 55 | 
 56 | 0.7.3 / 2011-03-02 
 57 | ==================
 58 | 
 59 |   * Fixed server listening check. Closes #62. [Andrew Stone]
 60 | 
 61 | 0.7.2 / 2010-12-29 
 62 | ==================
 63 | 
 64 |   * Fixed problem with `listen()` sometimes firing on the same tick [guillermo]
 65 | 
 66 | 0.7.1 / 2010-12-28 
 67 | ==================
 68 | 
 69 |   * Fixed `assert.request()` client logic into an issue() function, fired upon the `listen()` callback if the server doesn't have an assigned fd. [guillermo]
 70 |   * Removed `--watch`
 71 | 
 72 | 0.7.0 / 2010-11-19 
 73 | ==================
 74 | 
 75 |   * Removed `assert` from test function signature
 76 |     Just use `require('assert')` :) this will make integration
 77 |     with libraries like [should](http://github.com/visionmedia/should) cleaner.
 78 | 
 79 | 0.6.4 / 2010-11-02 
 80 | ==================
 81 | 
 82 |   * Added regexp support to `assert.response()` headers
 83 |   * Removed `waitForExit` code, causing issues
 84 | 
 85 | 0.6.3 / 2010-11-02 
 86 | ==================
 87 | 
 88 |   * Added `assert.response()` body RegExp support
 89 |   * Fixed issue with _--serial_ not executing files sequentially. Closes #42
 90 |   * Fixed hang when modules use `setInterval` - monitor running tests & force the process to quit after all have completed + timeout [Steve Mason]
 91 | 
 92 | 0.6.2 / 2010-09-17 
 93 | ==================
 94 | 
 95 |   * Added _node-jsocoverage_ to package.json (aka will respect npm's binroot)
 96 |   * Added _-t, --timeout_ MS option, defaulting to 2000 ms
 97 |   * Added _-s, --serial_
 98 |   * __PREFIX__ clobberable
 99 |   * Fixed `assert.response()` for latest node
100 |   * Fixed cov reporting from exploding on empty files
101 | 
102 | 0.6.2 / 2010-08-03
103 | ==================
104 | 
105 |   * Added `assert.type()`
106 |   * Renamed `assert.isNotUndefined()` to `assert.isDefined()`
107 |   * Fixed `assert.includes()` param ordering
108 | 
109 | 0.6.0 / 2010-07-31
110 | ==================
111 | 
112 |   * Added _docs/api.html_
113 |   * Added -w, --watch
114 |   * Added `Array` support to `assert.includes()`
115 |   * Added; outputting exceptions immediately. Closes #19
116 |   * Fixed `assert.includes()` param ordering
117 |   * Fixed `assert.length()` param ordering
118 |   * Fixed jscoverage links
119 | 
120 | 0.5.0 / 2010-07-16
121 | ==================
122 | 
123 |   * Added support for async exports
124 |   * Added timeout support to `assert.response()`. Closes #3
125 |   * Added 4th arg callback support to `assert.response()`
126 |   * Added `assert.length()`
127 |   * Added `assert.match()`
128 |   * Added `assert.isUndefined()`
129 |   * Added `assert.isNull()`
130 |   * Added `assert.includes()`
131 |   * Added growlnotify support via -g, --growl
132 |   * Added -o, --only TESTS. Ex: --only "test foo()" --only "test foo(), test bar()"
133 |   * Removed profanity
134 | 
135 | 0.4.0 / 2010-07-09
136 | ==================
137 | 
138 |   * Added reporting source coverage (respects --boring for color haters)
139 |   * Added callback to assert.response(). Closes #12
140 |   * Fixed; putting exceptions to stderr. Closes #13
141 | 
142 | 0.3.1 / 2010-06-28
143 | ==================
144 | 
145 |   * Faster assert.response()
146 | 
147 | 0.3.0 / 2010-06-28
148 | ==================
149 | 
150 |   * Added -p, --port NUM flags
151 |   * Added assert.response(). Closes #11
152 | 
153 | 0.2.1 / 2010-06-25
154 | ==================
155 | 
156 |   * Fixed issue with reporting object assertions
157 | 
158 | 0.2.0 / 2010-06-21
159 | ==================
160 | 
161 |   * Added `make uninstall`
162 |   * Added better readdir() failure message
163 |   * Fixed `make install` for kiwi
164 | 
165 | 0.1.0 / 2010-06-15
166 | ==================
167 | 
168 |   * Added better usage docs via --help
169 |   * Added better conditional color support
170 |   * Added pre exit assertion support
171 | 
172 | 0.0.3 / 2010-06-02
173 | ==================
174 | 
175 |   * Added more room for filenames in test coverage
176 |   * Added boring output support via --boring (suppress colored output)
177 |   * Fixed async failure exit status
178 | 
179 | 0.0.2 / 2010-05-30
180 | ==================
181 | 
182 |   * Fixed exit status for CI support
183 | 
184 | 0.0.1 / 2010-05-30
185 | ==================
186 | 
187 |   * Initial release


--------------------------------------------------------------------------------
/docs/index.md:
--------------------------------------------------------------------------------
  1 | 
  2 | [Expresso](http://github.com/visionmedia/expresso) is a JavaScript [TDD](http://en.wikipedia.org/wiki/Test-driven_development) framework written for [nodejs](http://nodejs.org). Expresso is extremely fast, and is packed with features such as additional assertion methods, code coverage reporting, CI support, and more.
  3 | 
  4 | ## Features
  5 | 
  6 | - light-weight
  7 | - intuitive async support
  8 | - intuitive test runner executable
  9 | - test coverage support and reporting via [node-jscoverage](http://github.com/visionmedia/node-jscoverage)
 10 | - uses and extends the core `assert` module
 11 | - `assert.eql()` alias of `assert.deepEqual()`
 12 | - `assert.response()` http response utility
 13 | - `assert.includes()`
 14 | - `assert.isNull()`
 15 | - `assert.isUndefined()`
 16 | - `assert.isNotNull()`
 17 | - `assert.isDefined()`
 18 | - `assert.match()`
 19 | - `assert.length()`
 20 | 
 21 | ## Installation
 22 | 
 23 | To install both expresso _and_ node-jscoverage run
 24 | the command below, which will first compile node-jscoverage:
 25 | 
 26 |     $ make install
 27 | 
 28 | To install expresso alone without coverage reporting run:
 29 | 
 30 |     $ make install-expresso
 31 | 
 32 | Install via npm:
 33 | 
 34 |     $ npm install expresso
 35 | 
 36 | ## Examples
 37 | 
 38 | To define tests we simply export several functions:
 39 | 
 40 |     exports['test String#length'] = function(){
 41 |         assert.equal(6, 'foobar'.length);
 42 |     };
 43 | 
 44 | Alternatively for large numbers of tests you may want to
 45 | export your own object containing the tests, however this
 46 | is essentially the as above:
 47 | 
 48 |     module.exports = {
 49 |         'test String#length': function(beforeExit, assert) {
 50 |           assert.equal(6, 'foobar'.length);
 51 |         }
 52 |     };
 53 | 
 54 | If you prefer not to use quoted keys:
 55 | 
 56 |     exports.testsStringLength = function(beforeExit, assert) {
 57 |         assert.equal(6, 'foobar'.length);
 58 |     };
 59 | 
 60 | The argument passed to each callback is `beforeExit` and `assert`.
 61 | The context ("`this`") of each test function is a _Test_ object. You can pass a function to `beforeExit` to make sure the assertions are run before the tests exit. This is can be used to verify that tests have indeed been run. `beforeExit` is a shortcut for listening to the `exit` event on `this`. The second parameter `assert` is the `assert` object localized to that test. It makes sure that assertions in asynchronous callbacks are associated with the correct test.
 62 | 
 63 |     exports.testAsync = function(beforeExit, assert) {
 64 |         var n = 0;
 65 |         setTimeout(function() {
 66 |             ++n;
 67 |             assert.ok(true);
 68 |         }, 200);
 69 |         setTimeout(function() {
 70 |             ++n;
 71 |             assert.ok(true);
 72 |         }, 200);
 73 | 
 74 |         // When the tests are finished, the exit event is emitted.
 75 |         this.on('exit', function() {
 76 |             assert.equal(2, n, 'Ensure both timeouts are called');
 77 |         });
 78 | 
 79 |         // Alternatively, you can use the beforeExit shortcut.
 80 |         beforeExit(function() {
 81 |             assert.equal(2, n, 'Ensure both timeouts are called');
 82 |         });
 83 |     };
 84 | 
 85 | ## Assert Utilities
 86 | 
 87 | ### assert.isNull(val[, msg])
 88 | 
 89 | Asserts that the given `val` is `null`.
 90 | 
 91 |     assert.isNull(null);
 92 | 
 93 | ### assert.isNotNull(val[, msg])
 94 | 
 95 | Asserts that the given `val` is not `null`.
 96 | 
 97 |     assert.isNotNull(undefined);
 98 |     assert.isNotNull(false);
 99 | 
100 | ### assert.isUndefined(val[, msg])
101 | 
102 | Asserts that the given `val` is `undefined`.
103 | 
104 |     assert.isUndefined(undefined);
105 | 
106 | ### assert.isDefined(val[, msg])
107 | 
108 | Asserts that the given `val` is not `undefined`.
109 | 
110 |     assert.isDefined(null);
111 |     assert.isDefined(false);
112 | 
113 | ### assert.match(str, regexp[, msg])
114 | 
115 | Asserts that the given `str` matches `regexp`.
116 | 
117 |     assert.match('foobar', /^foo(bar)?/);
118 |     assert.match('foo', /^foo(bar)?/);
119 | 
120 | ### assert.length(val, n[, msg])
121 | 
122 | Assert that the given `val` has a length of `n`.
123 | 
124 |     assert.length([1,2,3], 3);
125 |     assert.length('foo', 3);
126 | 
127 | ### assert.type(obj, type[, msg])
128 | 
129 | Assert that the given `obj` is typeof `type`.
130 | 
131 |     assert.type(3, 'number');
132 | 
133 | ### assert.eql(a, b[, msg])
134 | 
135 | Assert that object `b` is equal to object `a`. This is an
136 | alias for the core `assert.deepEqual()` method which does complex
137 | comparisons, opposed to `assert.equal()` which uses `==`.
138 | 
139 |     assert.eql('foo', 'foo');
140 |     assert.eql([1,2], [1,2]);
141 |     assert.eql({ foo: 'bar' }, { foo: 'bar' });
142 | 
143 | ### assert.includes(obj, val[, msg])
144 | 
145 | Assert that `obj` is within `val`. This method supports `Array`s
146 | and `Strings`s.
147 | 
148 |     assert.includes([1,2,3], 3);
149 |     assert.includes('foobar', 'foo');
150 |     assert.includes('foobar', 'bar');
151 | 
152 | ### assert.response(server, req, res|fn[, msg|fn])
153 | 
154 | Performs assertions on the given `server`, which should _not_ call
155 | `listen()`, as this is handled internally by expresso and the server
156 | is killed after all responses have completed. This method works with
157 | any `http.Server` instance, so _Connect_ and _Express_ servers will work
158 | as well.
159 | 
160 | The **`req`** object may contain:
161 | 
162 | - `url`: request url
163 | - `timeout`: timeout in milliseconds
164 | - `method`: HTTP method
165 | - `data`: request body
166 | - `headers`: headers object
167 | 
168 | The **`res`** object may be a callback function which
169 | receives the response for assertions, or an object
170 | which is then used to perform several assertions
171 | on the response with the following properties:
172 | 
173 | - `body`: assert response body (regexp or string)
174 | - `status`: assert response status code
175 | - `header`: assert that all given headers match (unspecified are ignored, use a regexp or string)
176 | 
177 | When providing `res` you may then also pass a callback function
178 | as the fourth argument for additional assertions.
179 | 
180 | Below are some examples:
181 | 
182 |     assert.response(server, {
183 |         url: '/', timeout: 500
184 |     }, {
185 |         body: 'foobar'
186 |     });
187 | 
188 |     assert.response(server, {
189 |         url: '/',
190 |         method: 'GET'
191 |     }, {
192 |         body: '{"name":"tj"}',
193 |         status: 200,
194 |         headers: {
195 |             'Content-Type': 'application/json; charset=utf8',
196 |             'X-Foo': 'bar'
197 |         }
198 |     });
199 | 
200 |     assert.response(server, {
201 |         url: '/foo',
202 |         method: 'POST',
203 |         data: 'bar baz'
204 |     }, {
205 |         body: '/foo bar baz',
206 |         status: 200
207 |     }, 'Test POST');
208 | 
209 |     assert.response(server, {
210 |         url: '/foo',
211 |         method: 'POST',
212 |         data: 'bar baz'
213 |     }, {
214 |         body: '/foo bar baz',
215 |         status: 200
216 |     }, function(res){
217 |         // All done, do some more tests if needed
218 |     });
219 | 
220 |     assert.response(server, {
221 |         url: '/'
222 |     }, function(res){
223 |         assert.ok(res.body.indexOf('tj') >= 0, 'Test assert.response() callback');
224 |     });
225 | 
226 | This function will fail when it receives no response or when the timeout (default is 30 seconds) expires.
227 | 
228 | 
229 | ## expresso(1)
230 | 
231 | To run a single test suite (file) run:
232 | 
233 |     $ expresso test/a.test.js
234 | 
235 | To run several suites we may simply append another:
236 | 
237 |     $ expresso test/a.test.js test/b.test.js
238 | 
239 | We can also pass a whitelist of tests to run within all suites:
240 | 
241 |     $ expresso --only "foo()" --only "bar()"
242 | 
243 | Or several with one call:
244 | 
245 |     $ expresso --only "foo(), bar()"
246 | 
247 | Globbing is of course possible as well:
248 | 
249 |     $ expresso test/*
250 | 
251 | When expresso is called without any files, _test/*_ is the default,
252 | so the following is equivalent to the command above:
253 | 
254 |     $ expresso
255 | 
256 | If you wish to unshift a path to `require.paths` before
257 | running tests, you may use the `-I` or `--include` flag.
258 | 
259 |     $ expresso --include lib test/*
260 | 
261 | The previous example is typically what I would recommend, since expresso
262 | supports test coverage via [node-jscoverage](http://github.com/visionmedia/node-jscoverage) (bundled with expresso),
263 | so you will need to expose an instrumented version of you library.
264 | 
265 | To instrument your library, simply run [node-jscoverage](http://github.com/visionmedia/node-jscoverage),
266 | passing the _src_ and _dest_ directories:
267 | 
268 |     $ node-jscoverage lib lib-cov
269 | 
270 | Now we can run our tests again, using the _lib-cov_ directory that has been
271 | instrumented with coverage statements:
272 | 
273 |     $ expresso -I lib-cov test/*
274 | 
275 | The output will look similar to below, depending on your test coverage of course :)
276 | 
277 | ![node coverage](http://dl.dropbox.com/u/6396913/cov.png)
278 | 
279 | To make this process easier expresso has the `-c` or `--cov` which essentially
280 | does the same as the two commands above. The following two commands will
281 | run the same tests, however one will auto-instrument, and unshift `lib-cov`,
282 | and the other will run tests normally:
283 | 
284 |     $ expresso -I lib test/*
285 |     $ expresso -I lib --cov test/*
286 | 
287 | Currently coverage is bound to the `lib` directory, however in the
288 | future `--cov` will most likely accept a path.
289 | 
290 | If you would like code coverage reports suitable for automated parsing, pass the `--json [output file]` option:
291 | 
292 |     $ expresso -I lib test/*
293 |     $ expresso -I lib --cov --json coverage.json test/*
294 | 
295 | You should then see the json coverage details in the file you specified:
296 | 
297 |     {
298 |         "LOC": 20,
299 |         "SLOC": 7,
300 |         "coverage": "71.43",
301 |         "files": {
302 |             "bar.js": {
303 |                 "LOC": 4,
304 |                 "SLOC": 2,
305 |                 "coverage": "100.00",
306 |                 "totalMisses": 0
307 |             },
308 |             "foo.js": {
309 |                 "LOC": 16,
310 |                 "SLOC": 5,
311 |                 "coverage": "60.00",
312 |                 "totalMisses": 2
313 |             }
314 |         },
315 |         "totalMisses": 2
316 |     }
317 | 
318 | ## Async Exports
319 | 
320 | Sometimes it is useful to postpone running of tests until a callback or event has fired, currently the `exports.foo = function() {};` syntax is supported for this:
321 | 
322 |     setTimeout(function() {
323 |         exports['test async exports'] = function(){
324 |             assert.ok('wahoo');
325 |         };
326 |     }, 100);
327 | 
328 | Note that you only have one "shot" at exporting. You have to export all of your test functions in the same loop as the first one. That means you can't progressively add more test functions to the `exports` object.
329 | 


--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 | 	<head>
  3 | 		<title>Expresso - TDD Framework For Node</title>
  4 | 		<style>
  5 | 			body {
  6 | 				font: 13px/1.4 "Helvetica", "Lucida Grande", Arial, sans-serif;
  7 | 				text-align: center;
  8 | 			}
  9 | 			#ribbon {
 10 | 				position: absolute;
 11 | 				top: 0;
 12 | 				right: 0;
 13 | 				z-index: 10;
 14 | 			}
 15 | 			#wrapper {
 16 | 			  margin: 0 auto;
 17 | 				padding: 50px 80px;
 18 | 				width: 700px;
 19 | 				text-align: left;
 20 | 			}
 21 | 			h1, h2, h3 {
 22 | 				margin: 25px 0 15px 0;
 23 | 			}
 24 | 			h1 {
 25 | 			  font-size: 35px;
 26 | 			}
 27 | 			pre {
 28 | 				margin: 0 5px;
 29 | 				padding: 15px;
 30 | 				border: 1px solid #eee;
 31 | 			}
 32 | 			a {
 33 | 			  color: #00aaff;
 34 | 			}
 35 | 		</style>
 36 | 	</head>
 37 | 	<body>
 38 | 		<a href="http://github.com/visionmedia/expresso">
 39 | 			<img alt="Fork me on GitHub" id="ribbon" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" />
 40 | 		</a>
 41 | 		<div id="wrapper">
 42 | 			<h1>Expresso 0.9.0</h1>
 43 | <html><p><a href="http://github.com/visionmedia/expresso">Expresso</a> is a JavaScript <a href="http://en.wikipedia.org/wiki/Test-driven_development">TDD</a> framework written for <a href="http://nodejs.org">nodejs</a>. Expresso is extremely fast, and is packed with features such as additional assertion methods, code coverage reporting, CI support, and more.</p><h2 id="Features">Features</h2><ul><li>light-weight</li><li>intuitive async support</li><li>intuitive test runner executable</li><li>test coverage support and reporting via <a href="http://github.com/visionmedia/node-jscoverage">node-jscoverage</a></li><li>uses and extends the core <code>assert</code> module</li><li><code>assert.eql()</code> alias of <code>assert.deepEqual()</code></li><li><code>assert.response()</code> http response utility</li><li><code>assert.includes()</code></li><li><code>assert.isNull()</code></li><li><code>assert.isUndefined()</code></li><li><code>assert.isNotNull()</code></li><li><code>assert.isDefined()</code></li><li><code>assert.match()</code></li><li><code>assert.length()</code></li></ul><h2 id="Installation">Installation</h2><p>To install both expresso <em>and</em> node-jscoverage run
 44 | the command below, which will first compile node-jscoverage:</p><pre><code>$ make install</code></pre><p>To install expresso alone without coverage reporting run:</p><pre><code>$ make install-expresso</code></pre><p>Install via npm:</p><pre><code>$ npm install expresso</code></pre><h2 id="Examples">Examples</h2><p>To define tests we simply export several functions:</p><pre><code>exports['test String#length'] = function(){
 45 |     assert.equal(6, 'foobar'.length);
 46 | };</code></pre><p>Alternatively for large numbers of tests you may want to
 47 | export your own object containing the tests, however this
 48 | is essentially the as above:</p><pre><code>module.exports = {
 49 |     'test String#length': function(beforeExit, assert) {
 50 |       assert.equal(6, 'foobar'.length);
 51 |     }
 52 | };</code></pre><p>If you prefer not to use quoted keys:</p><pre><code>exports.testsStringLength = function(beforeExit, assert) {
 53 |     assert.equal(6, 'foobar'.length);
 54 | };</code></pre><p>The argument passed to each callback is <code>beforeExit</code> and <code>assert</code>.
 55 | The context ("<code>this</code>") of each test function is a <em>Test</em> object. You can pass a function to <code>beforeExit</code> to make sure the assertions are run before the tests exit. This is can be used to verify that tests have indeed been run. <code>beforeExit</code> is a shortcut for listening to the <code>exit</code> event on <code>this</code>. The second parameter <code>assert</code> is the <code>assert</code> object localized to that test. It makes sure that assertions in asynchronous callbacks are associated with the correct test.</p><pre><code>exports.testAsync = function(beforeExit, assert) {
 56 |     var n = 0;
 57 |     setTimeout(function() {
 58 |         ++n;
 59 |         assert.ok(true);
 60 |     }, 200);
 61 |     setTimeout(function() {
 62 |         ++n;
 63 |         assert.ok(true);
 64 |     }, 200);
 65 | 
 66 |     // When the tests are finished, the exit event is emitted.
 67 |     this.on('exit', function() {
 68 |         assert.equal(2, n, 'Ensure both timeouts are called');
 69 |     });
 70 | 
 71 |     // Alternatively, you can use the beforeExit shortcut.
 72 |     beforeExit(function() {
 73 |         assert.equal(2, n, 'Ensure both timeouts are called');
 74 |     });
 75 | };</code></pre><h2 id="Assert-Utilities">Assert Utilities</h2><h3 id="assert-isNull-val-msg">assert.isNull(val[, msg])</h3><p>Asserts that the given <code>val</code> is <code>null</code>.</p><pre><code>assert.isNull(null);</code></pre><h3 id="assert-isNotNull-val-msg">assert.isNotNull(val[, msg])</h3><p>Asserts that the given <code>val</code> is not <code>null</code>.</p><pre><code>assert.isNotNull(undefined);
 76 | assert.isNotNull(false);</code></pre><h3 id="assert-isUndefined-val-msg">assert.isUndefined(val[, msg])</h3><p>Asserts that the given <code>val</code> is <code>undefined</code>.</p><pre><code>assert.isUndefined(undefined);</code></pre><h3 id="assert-isDefined-val-msg">assert.isDefined(val[, msg])</h3><p>Asserts that the given <code>val</code> is not <code>undefined</code>.</p><pre><code>assert.isDefined(null);
 77 | assert.isDefined(false);</code></pre><h3 id="assert-match-str-regexp-msg">assert.match(str, regexp[, msg])</h3><p>Asserts that the given <code>str</code> matches <code>regexp</code>.</p><pre><code>assert.match('foobar', /^foo(bar)?/);
 78 | assert.match('foo', /^foo(bar)?/);</code></pre><h3 id="assert-length-val-n-msg">assert.length(val, n[, msg])</h3><p>Assert that the given <code>val</code> has a length of <code>n</code>.</p><pre><code>assert.length([1,2,3], 3);
 79 | assert.length('foo', 3);</code></pre><h3 id="assert-type-obj-type-msg">assert.type(obj, type[, msg])</h3><p>Assert that the given <code>obj</code> is typeof <code>type</code>.</p><pre><code>assert.type(3, 'number');</code></pre><h3 id="assert-eql-a-b-msg">assert.eql(a, b[, msg])</h3><p>Assert that object <code>b</code> is equal to object <code>a</code>. This is an
 80 | alias for the core <code>assert.deepEqual()</code> method which does complex
 81 | comparisons, opposed to <code>assert.equal()</code> which uses <code>==</code>.</p><pre><code>assert.eql('foo', 'foo');
 82 | assert.eql([1,2], [1,2]);
 83 | assert.eql({ foo: 'bar' }, { foo: 'bar' });</code></pre><h3 id="assert-includes-obj-val-msg">assert.includes(obj, val[, msg])</h3><p>Assert that <code>obj</code> is within <code>val</code>. This method supports <code>Array</code>s
 84 | and <code>Strings</code>s.</p><pre><code>assert.includes([1,2,3], 3);
 85 | assert.includes('foobar', 'foo');
 86 | assert.includes('foobar', 'bar');</code></pre><h3 id="assert-response-server-req-res-fn-msg-fn">assert.response(server, req, res|fn[, msg|fn])</h3><p>Performs assertions on the given <code>server</code>, which should <em>not</em> call
 87 | <code>listen()</code>, as this is handled internally by expresso and the server
 88 | is killed after all responses have completed. This method works with
 89 | any <code>http.Server</code> instance, so <em>Connect</em> and <em>Express</em> servers will work
 90 | as well.</p><p>The <strong><code>req</code></strong> object may contain:</p><ul><li><code>url</code>: request url</li><li><code>timeout</code>: timeout in milliseconds</li><li><code>method</code>: HTTP method</li><li><code>data</code>: request body</li><li><code>headers</code>: headers object</li></ul><p>The <strong><code>res</code></strong> object may be a callback function which
 91 | receives the response for assertions, or an object
 92 | which is then used to perform several assertions
 93 | on the response with the following properties:</p><ul><li><code>body</code>: assert response body (regexp or string)</li><li><code>status</code>: assert response status code</li><li><code>header</code>: assert that all given headers match (unspecified are ignored, use a regexp or string)</li></ul><p>When providing <code>res</code> you may then also pass a callback function
 94 | as the fourth argument for additional assertions.</p><p>Below are some examples:</p><pre><code>assert.response(server, {
 95 |     url: '/', timeout: 500
 96 | }, {
 97 |     body: 'foobar'
 98 | });
 99 | 
100 | assert.response(server, {
101 |     url: '/',
102 |     method: 'GET'
103 | }, {
104 |     body: '{"name":"tj"}',
105 |     status: 200,
106 |     headers: {
107 |         'Content-Type': 'application/json; charset=utf8',
108 |         'X-Foo': 'bar'
109 |     }
110 | });
111 | 
112 | assert.response(server, {
113 |     url: '/foo',
114 |     method: 'POST',
115 |     data: 'bar baz'
116 | }, {
117 |     body: '/foo bar baz',
118 |     status: 200
119 | }, 'Test POST');
120 | 
121 | assert.response(server, {
122 |     url: '/foo',
123 |     method: 'POST',
124 |     data: 'bar baz'
125 | }, {
126 |     body: '/foo bar baz',
127 |     status: 200
128 | }, function(res){
129 |     // All done, do some more tests if needed
130 | });
131 | 
132 | assert.response(server, {
133 |     url: '/'
134 | }, function(res){
135 |     assert.ok(res.body.indexOf('tj') &gt;= 0, 'Test assert.response() callback');
136 | });</code></pre><p>This function will fail when it receives no response or when the timeout (default is 30 seconds) expires.</p><h2 id="expresso-1">expresso(1)</h2><p>To run a single test suite (file) run:</p><pre><code>$ expresso test/a.test.js</code></pre><p>To run several suites we may simply append another:</p><pre><code>$ expresso test/a.test.js test/b.test.js</code></pre><p>We can also pass a whitelist of tests to run within all suites:</p><pre><code>$ expresso --only "foo()" --only "bar()"</code></pre><p>Or several with one call:</p><pre><code>$ expresso --only "foo(), bar()"</code></pre><p>Globbing is of course possible as well:</p><pre><code>$ expresso test/*</code></pre><p>When expresso is called without any files, <em>test/*</em> is the default,
137 | so the following is equivalent to the command above:</p><pre><code>$ expresso</code></pre><p>If you wish to unshift a path to <code>require.paths</code> before
138 | running tests, you may use the <code>-I</code> or <code>--include</code> flag.</p><pre><code>$ expresso --include lib test/*</code></pre><p>The previous example is typically what I would recommend, since expresso
139 | supports test coverage via <a href="http://github.com/visionmedia/node-jscoverage">node-jscoverage</a> (bundled with expresso),
140 | so you will need to expose an instrumented version of you library.</p><p>To instrument your library, simply run <a href="http://github.com/visionmedia/node-jscoverage">node-jscoverage</a>,
141 | passing the <em>src</em> and <em>dest</em> directories:</p><pre><code>$ node-jscoverage lib lib-cov</code></pre><p>Now we can run our tests again, using the <em>lib-cov</em> directory that has been
142 | instrumented with coverage statements:</p><pre><code>$ expresso -I lib-cov test/*</code></pre><p>The output will look similar to below, depending on your test coverage of course :)</p><p><img alt="node coverage" src="http://dl.dropbox.com/u/6396913/cov.png" /></p><p>To make this process easier expresso has the <code>-c</code> or <code>--cov</code> which essentially
143 | does the same as the two commands above. The following two commands will
144 | run the same tests, however one will auto-instrument, and unshift <code>lib-cov</code>,
145 | and the other will run tests normally:</p><pre><code>$ expresso -I lib test/*
146 | $ expresso -I lib --cov test/*</code></pre><p>Currently coverage is bound to the <code>lib</code> directory, however in the
147 | future <code>--cov</code> will most likely accept a path.</p><p>If you would like code coverage reports suitable for automated parsing, pass the <code>--json [output file]</code> option:</p><pre><code>$ expresso -I lib test/*
148 | $ expresso -I lib --cov --json coverage.json test/*</code></pre><p>You should then see the json coverage details in the file you specified:</p><pre><code>{
149 |     "LOC": 20,
150 |     "SLOC": 7,
151 |     "coverage": "71.43",
152 |     "files": {
153 |         "bar.js": {
154 |             "LOC": 4,
155 |             "SLOC": 2,
156 |             "coverage": "100.00",
157 |             "totalMisses": 0
158 |         },
159 |         "foo.js": {
160 |             "LOC": 16,
161 |             "SLOC": 5,
162 |             "coverage": "60.00",
163 |             "totalMisses": 2
164 |         }
165 |     },
166 |     "totalMisses": 2
167 | }</code></pre><h2 id="Async-Exports">Async Exports</h2><p>Sometimes it is useful to postpone running of tests until a callback or event has fired, currently the <code>exports.foo = function() {};</code> syntax is supported for this:</p><pre><code>setTimeout(function() {
168 |     exports['test async exports'] = function(){
169 |         assert.ok('wahoo');
170 |     };
171 | }, 100);</code></pre><p>Note that you only have one "shot" at exporting. You have to export all of your test functions in the same loop as the first one. That means you can't progressively add more test functions to the <code>exports</code> object.</p></html>
172 | 		</div>
173 | 	</body>
174 | </html>


--------------------------------------------------------------------------------
/bin/expresso:
--------------------------------------------------------------------------------
   1 | #!/usr/bin/env node
   2 | 
   3 | /*
   4 |  * Expresso
   5 |  * Copyright(c) TJ Holowaychuk <tj@vision-media.ca>
   6 |  * (MIT Licensed)
   7 |  */
   8 | 
   9 | /**
  10 |  * Module dependencies.
  11 |  */
  12 | 
  13 | var assert = require('assert'),
  14 |     childProcess = require('child_process'),
  15 |     http = require('http'),
  16 |     path = require('path'),
  17 |     util = require('util'),
  18 |     cwd = process.cwd(),
  19 |     fs = require('fs'),
  20 |     defer;
  21 | 
  22 | /**
  23 |  * Set the node env to test if it hasn't already been set
  24 |  */
  25 | 
  26 | if( !process.env.NODE_ENV ) process.env.NODE_ENV = 'test';
  27 | 
  28 | /**
  29 |  * Setup the regex which is used to match test files.
  30 |  * Adjust it to include coffeescript files if CS is available
  31 |  */
  32 | var file_matcher = /\.js$/;
  33 | try {
  34 |   require('coffee-script');
  35 |   file_matcher = /\.(js|coffee)$/;
  36 | } catch (e) {}
  37 | 
  38 | /**
  39 |  * Expresso version.
  40 |  */
  41 | 
  42 | var version = '0.9.2';
  43 | 
  44 | /**
  45 |  * Failure count.
  46 |  */
  47 | 
  48 | var failures = 0;
  49 | 
  50 | /**
  51 |  * Indicates whether all test files have been loaded.
  52 |  */
  53 | 
  54 | var suites = 0;
  55 | var suitesRun = 0;
  56 | 
  57 | /**
  58 |  * Number of tests executed.
  59 |  */
  60 | 
  61 | var testcount = 0;
  62 | 
  63 | /**
  64 |  * Whitelist of tests to run.
  65 |  */
  66 | 
  67 | var only = [];
  68 | 
  69 | /**
  70 |  * Regex expression filtering tests to run.
  71 |  */
  72 | 
  73 | var match = '';
  74 | 
  75 | /**
  76 |  * Boring output.
  77 |  */
  78 | 
  79 | var boring = false;
  80 | 
  81 | /**
  82 |  * Growl notifications.
  83 |  */
  84 | 
  85 | var growl = false;
  86 | 
  87 | /**
  88 |  * Server port.
  89 |  */
  90 | 
  91 | var port = 5555;
  92 | 
  93 | /**
  94 |  * Execute serially.
  95 |  */
  96 | 
  97 | var serial = false;
  98 | 
  99 | /**
 100 |  * Default timeout.
 101 |  */
 102 | 
 103 | var timeout = 2000;
 104 | 
 105 | /**
 106 |  * Quiet output.
 107 |  */
 108 | 
 109 | var quiet = false;
 110 | 
 111 | /**
 112 |  * JSON code coverage report
 113 |  */
 114 | var jsonCoverage = false;
 115 | var jsonFile;
 116 | 
 117 | /**
 118 |  * Usage documentation.
 119 |  */
 120 | 
 121 | var usage = ''
 122 |     + '[bold]{Usage}: expresso [options] <file ...>'
 123 |     + '\n'
 124 |     + '\n[bold]{Options}:'
 125 |     + '\n  -g, --growl          Enable growl notifications'
 126 |     //+ '\n  -c, --coverage       Generate and report test coverage'
 127 |     + '\n  -j, --json PATH      Used in conjunction with --coverage, ouput JSON coverage to PATH'
 128 |     + '\n  -q, --quiet          Suppress coverage report if 100%'
 129 |     + '\n  -t, --timeout MS     Timeout in milliseconds, defaults to 2000'
 130 |     + '\n  -r, --require PATH   Require the given module path'
 131 |     + '\n  -o, --only TESTS     Execute only the comma sperated TESTS (can be set several times)'
 132 |     + '\n  -m, --match EXP      Execute only tests matching a given regular expression (can be set several times)'
 133 |     + '\n  -p, --port NUM       Port number for test servers, starts at 5555'
 134 |     + '\n  -s, --serial         Execute tests serially'
 135 |     + '\n  -b, --boring         Suppress ansi-escape colors'
 136 |     + '\n  -v, --version        Output version number'
 137 |     + '\n  -h, --help           Display help information'
 138 |     + '\n';
 139 | 
 140 | // Parse arguments
 141 | 
 142 | var files = [],
 143 |     args = process.argv.slice(2);
 144 | 
 145 | while (args.length) {
 146 |     var arg = args.shift();
 147 |     switch (arg) {
 148 |         case '-h':
 149 |         case '--help':
 150 |             print(usage + '\n');
 151 |             process.exit(1);
 152 |             break;
 153 |         case '-v':
 154 |         case '--version':
 155 |             console.log(version);
 156 |             process.exit(1);
 157 |             break;
 158 |         case '-o':
 159 |         case '--only':
 160 |             if (arg = args.shift()) {
 161 |                 only = only.concat(arg.split(/ *, */));
 162 |             } else {
 163 |                 throw new Error('--only requires comma-separated test names');
 164 |             }
 165 |             break;
 166 |         case '-m':
 167 |         case '--match':
 168 |             if (arg = args.shift()) {
 169 |                 match += (match.length > 0 ? '|' : '') + arg;
 170 |             } else {
 171 |                 throw new Error('--match requires argument');
 172 |             }
 173 |             break;
 174 |         case '-p':
 175 |         case '--port':
 176 |             if (arg = args.shift()) {
 177 |                 port = parseInt(arg, 10);
 178 |             } else {
 179 |                 throw new Error('--port requires a number');
 180 |             }
 181 |             break;
 182 |         case '-r':
 183 |         case '--require':
 184 |             if (arg = args.shift()) {
 185 |                 require(arg);
 186 |             } else {
 187 |                 throw new Error('--require requires a path');
 188 |             }
 189 |             break;
 190 |         case '-t':
 191 |         case '--timeout':
 192 |           if (arg = args.shift()) {
 193 |             timeout = parseInt(arg, 10);
 194 |           } else {
 195 |             throw new Error('--timeout requires an argument');
 196 |           }
 197 |           break;
 198 |         // case '-c':
 199 |         // case '--cov':
 200 |         // case '--coverage':
 201 |         //     defer = true;
 202 |         //     childProcess.exec('rm -fr lib-cov && node-jscoverage lib lib-cov', function(err){
 203 |         //         if (err) throw err;
 204 |         //         require.paths.unshift('lib-cov');
 205 |         //         run(files);
 206 |         //     })
 207 |         //     break;
 208 |         case '-q':
 209 |         case '--quiet':
 210 |             quiet = true;
 211 |             break;
 212 |         case '-b':
 213 |         case '--boring':
 214 |             boring = true;
 215 |             break;
 216 |         case '-g':
 217 |         case '--growl':
 218 |             growl = true;
 219 |             break;
 220 |         case '-s':
 221 |         case '--serial':
 222 |             serial = true;
 223 |             break;
 224 |         case '-j':
 225 |         case '--json':
 226 |             jsonCoverage = true;
 227 |             if (arg = args.shift()) {
 228 |                 jsonFile = path.normalize(arg);
 229 |             } else {
 230 |                 throw new Error('--json requires file to write to');
 231 |             }
 232 |             break;
 233 |         default:
 234 |             if (file_matcher.test(arg)) {
 235 |                 files.push(arg);
 236 |             }
 237 |             break;
 238 |     }
 239 | }
 240 | 
 241 | /**
 242 |  * Colorized console.error().
 243 |  *
 244 |  * @param {String} str
 245 |  */
 246 | 
 247 | function print(str){
 248 |     console.error(colorize(str));
 249 | }
 250 | 
 251 | /**
 252 |  * Colorize the given string using ansi-escape sequences.
 253 |  * Disabled when --boring is set.
 254 |  *
 255 |  * @param {String} str
 256 |  * @return {String}
 257 |  */
 258 | 
 259 | function colorize(str) {
 260 |     var colors = { bold: 1, red: 31, green: 32, yellow: 33 };
 261 |     return str.replace(/\[(\w+)\]\{([^]*?)\}/g, function(_, color, str) {
 262 |         return boring
 263 |             ? str
 264 |             : '\x1B[' + colors[color] + 'm' + str + '\x1B[0m';
 265 |     });
 266 | }
 267 | 
 268 | // Alias deepEqual as eql for complex equality
 269 | 
 270 | assert.eql = assert.deepEqual;
 271 | 
 272 | /**
 273 |  * Assert that `val` is null.
 274 |  *
 275 |  * @param {Mixed} val
 276 |  * @param {String} msg
 277 |  */
 278 | 
 279 | assert.isNull = function(val, msg) {
 280 |     assert.strictEqual(null, val, msg);
 281 | };
 282 | 
 283 | /**
 284 |  * Assert that `val` is not null.
 285 |  *
 286 |  * @param {Mixed} val
 287 |  * @param {String} msg
 288 |  */
 289 | 
 290 | assert.isNotNull = function(val, msg) {
 291 |     assert.notStrictEqual(null, val, msg);
 292 | };
 293 | 
 294 | /**
 295 |  * Assert that `val` is undefined.
 296 |  *
 297 |  * @param {Mixed} val
 298 |  * @param {String} msg
 299 |  */
 300 | 
 301 | assert.isUndefined = function(val, msg) {
 302 |     assert.strictEqual(undefined, val, msg);
 303 | };
 304 | 
 305 | /**
 306 |  * Assert that `val` is not undefined.
 307 |  *
 308 |  * @param {Mixed} val
 309 |  * @param {String} msg
 310 |  */
 311 | 
 312 | assert.isDefined = function(val, msg) {
 313 |     assert.notStrictEqual(undefined, val, msg);
 314 | };
 315 | 
 316 | /**
 317 |  * Assert that `obj` is `type`.
 318 |  *
 319 |  * @param {Mixed} obj
 320 |  * @param {String} type
 321 |  * @api public
 322 |  */
 323 | 
 324 | assert.type = function(obj, type, msg) {
 325 |     var real = typeof obj;
 326 |     msg = msg || 'typeof ' + util.inspect(obj) + ' is ' + real + ', expected ' + type;
 327 |     assert.ok(type === real, msg);
 328 | };
 329 | 
 330 | /**
 331 |  * Assert that `str` matches `regexp`.
 332 |  *
 333 |  * @param {String} str
 334 |  * @param {RegExp} regexp
 335 |  * @param {String} msg
 336 |  */
 337 | 
 338 | assert.match = function(str, regexp, msg) {
 339 |     msg = msg || util.inspect(str) + ' does not match ' + util.inspect(regexp);
 340 |     assert.ok(regexp.test(str), msg);
 341 | };
 342 | 
 343 | /**
 344 |  * Assert that `val` is within `obj`.
 345 |  *
 346 |  * Examples:
 347 |  *
 348 |  *    assert.includes('foobar', 'bar');
 349 |  *    assert.includes(['foo', 'bar'], 'foo');
 350 |  *
 351 |  * @param {String|Array} obj
 352 |  * @param {Mixed} val
 353 |  * @param {String} msg
 354 |  */
 355 | 
 356 | assert.includes = function(obj, val, msg) {
 357 |     msg = msg || util.inspect(obj) + ' does not include ' + util.inspect(val);
 358 |     assert.ok(obj.indexOf(val) >= 0, msg);
 359 | };
 360 | 
 361 | /**
 362 |  * Assert length of `val` is `n`.
 363 |  *
 364 |  * @param {Mixed} val
 365 |  * @param {Number} n
 366 |  * @param {String} msg
 367 |  */
 368 | 
 369 | assert.length = function(val, n, msg) {
 370 |     msg = msg || util.inspect(val) + ' has length of ' + val.length + ', expected ' + n;
 371 |     assert.equal(n, val.length, msg);
 372 | };
 373 | 
 374 | /**
 375 |  * Assert response from `server` with
 376 |  * the given `req` object and `res` assertions object.
 377 |  *
 378 |  * @param {Server} server
 379 |  * @param {Object} req
 380 |  * @param {Object|Function} res
 381 |  * @param {String} msg
 382 |  */
 383 | assert.response = function(server, req, res, msg) {
 384 |     var test = assert._test;
 385 | 
 386 |     // Callback as third or fourth arg
 387 |     var callback = typeof res === 'function'
 388 |         ? res
 389 |         : typeof msg === 'function'
 390 |             ? msg
 391 |             : function() {};
 392 | 
 393 |     // Default messate to test title
 394 |     if (typeof msg === 'function') msg = null;
 395 |     msg = msg || test.title;
 396 |     msg += '. ';
 397 | 
 398 |     // Add a unique token for this call to assert.response(). We'll move it to
 399 |     // succeeded/failed when done
 400 |     var token = new Error('Response not completed: ' + msg);
 401 |     test._pending.push(token);
 402 | 
 403 |     function check() {
 404 |         try {
 405 |             server.__port = server.address().port;
 406 |             server.__listening = true;
 407 |         } catch (err) {
 408 |             process.nextTick(check);
 409 |             return;
 410 |         }
 411 |         if (server.__deferred) {
 412 |             server.__deferred.forEach(function(fn) { fn(); });
 413 |             server.__deferred = null;
 414 |         }
 415 |     }
 416 | 
 417 |     // Pending responses
 418 |     server.setMaxListeners(99999);
 419 |     server.__pending = server.__pending || 0;
 420 |     server.__pending++;
 421 | 
 422 |     // Check that the server is ready or defer
 423 |     if (!server.fd) {
 424 |         server.__deferred = server.__deferred || [];
 425 |         server.listen(server.__port = port++, '127.0.0.1', check);
 426 |     } else if (!server.__port) {
 427 |         server.__deferred = server.__deferred || [];
 428 |         process.nextTick(check);
 429 |     }
 430 | 
 431 |     // The socket was created but is not yet listening, so keep deferring
 432 |     if (!server.__listening) {
 433 |         server.__deferred.push(issue);
 434 |         return;
 435 |     } else {
 436 |         issue();
 437 |     }
 438 | 
 439 |     function issue() {
 440 |         // Issue request
 441 |         var timer,
 442 |             method = req.method || 'GET',
 443 |             status = res.status || res.statusCode,
 444 |             data = req.data || req.body,
 445 |             requestTimeout = req.timeout || 0,
 446 |             encoding = req.encoding || 'utf8';
 447 | 
 448 |         var request = http.request({
 449 |             host: '127.0.0.1',
 450 |             port: server.__port,
 451 |             path: req.url,
 452 |             method: method,
 453 |             headers: req.headers
 454 |         });
 455 | 
 456 |         var check = function() {
 457 |             if (--server.__pending === 0) {
 458 |                 server.close();
 459 |                 server.__listening = false;
 460 |             }
 461 |         };
 462 | 
 463 |         // Timeout
 464 |         if (requestTimeout) {
 465 |             timer = setTimeout(function() {
 466 |                 check();
 467 |                 delete req.timeout;
 468 |                 test.failure(new Error(msg + 'Request timed out after ' + requestTimeout + 'ms.'));
 469 |             }, requestTimeout);
 470 |         }
 471 | 
 472 |         if (data) request.write(data);
 473 | 
 474 |         request.on('response', function(response) {
 475 |             response.body = '';
 476 |             response.setEncoding(encoding);
 477 |             response.on('data', function(chunk) { response.body += chunk; });
 478 |             response.on('end', function() {
 479 |                 if (timer) clearTimeout(timer);
 480 |                 try {
 481 |                     // Assert response body
 482 |                     if (res.body !== undefined) {
 483 |                         var eql = res.body instanceof RegExp
 484 |                           ? res.body.test(response.body)
 485 |                           : res.body === response.body;
 486 |                         assert.ok(
 487 |                             eql,
 488 |                             msg + 'Invalid response body.\n'
 489 |                                 + '    Expected: ' + util.inspect(res.body) + '\n'
 490 |                                 + '    Got: ' + util.inspect(response.body)
 491 |                         );
 492 |                     }
 493 | 
 494 |                     // Assert response status
 495 |                     if (typeof status === 'number') {
 496 |                         assert.equal(
 497 |                             response.statusCode,
 498 |                             status,
 499 |                             msg + colorize('Invalid response status code.\n'
 500 |                                 + '    Expected: [green]{' + status + '}\n'
 501 |                                 + '    Got: [red]{' + response.statusCode + '}')
 502 |                         );
 503 |                     }
 504 | 
 505 |                     // Assert response headers
 506 |                     if (res.headers) {
 507 |                         var keys = Object.keys(res.headers);
 508 |                         for (var i = 0, len = keys.length; i < len; ++i) {
 509 |                             var name = keys[i],
 510 |                                 actual = response.headers[name.toLowerCase()],
 511 |                                 expected = res.headers[name],
 512 |                                 eql = expected instanceof RegExp
 513 |                                   ? expected.test(actual)
 514 |                                   : expected == actual;
 515 |                             assert.ok(
 516 |                                 eql,
 517 |                                 msg + colorize('Invalid response header [bold]{' + name + '}.\n'
 518 |                                     + '    Expected: [green]{' + expected + '}\n'
 519 |                                     + '    Got: [red]{' + actual + '}')
 520 |                             );
 521 |                         }
 522 |                     }
 523 | 
 524 |                     // Callback
 525 |                     callback(response);
 526 | 
 527 |                     // Add this to the succeeded bin.
 528 |                     test.success(msg);
 529 |                 } catch (err) {
 530 |                     test.failure(err);
 531 |                     test.callback();
 532 |                 } finally {
 533 |                     // Remove our token.
 534 |                     var idx = test._pending.indexOf(token);
 535 |                     if (idx >= 0) {
 536 |                         test._pending.splice(idx, 1);
 537 |                     } else {
 538 |                         // Someone else took our token. This is an error.
 539 |                         test.failure(new Error('Request succeeded, but token vanished: ' + msg));
 540 |                     }
 541 | 
 542 |                     // Potentially shut down the server.
 543 |                     check();
 544 |                 }
 545 |             });
 546 |         });
 547 | 
 548 |         request.end();
 549 |       }
 550 | };
 551 | 
 552 | /**
 553 |  * Custom assert module that tacks on the current test to every error
 554 |  */
 555 | var customAssert = { __proto__: assert };
 556 | Object.keys(assert).forEach(function (method) {
 557 |    customAssert[method] = function () {
 558 |       try {
 559 |          return assert[method].apply(assert, arguments);
 560 |       } catch (err) {
 561 |          // 'this' is this assert object from the test
 562 |          if (this._test) {
 563 |             err._test = this._test;
 564 |          }
 565 |          throw err;
 566 |       }
 567 |    };
 568 | });
 569 | 
 570 | /**
 571 |  * Pad the given string to the maximum width provided.
 572 |  *
 573 |  * @param  {String} str
 574 |  * @param  {Number} width
 575 |  * @return {String}
 576 |  */
 577 | 
 578 | function lpad(str, width) {
 579 |     str = String(str);
 580 |     var n = width - str.length;
 581 |     if (n < 1) return str;
 582 |     while (n--) str = ' ' + str;
 583 |     return str;
 584 | }
 585 | 
 586 | /**
 587 |  * Pad the given string to the maximum width provided.
 588 |  *
 589 |  * @param  {String} str
 590 |  * @param  {Number} width
 591 |  * @return {String}
 592 |  */
 593 | 
 594 | function rpad(str, width) {
 595 |     str = String(str);
 596 |     var n = width - str.length;
 597 |     if (n < 1) return str;
 598 |     while (n--) str = str + ' ';
 599 |     return str;
 600 | }
 601 | 
 602 | /**
 603 |  * Report test coverage in tabular format
 604 |  *
 605 |  * @param  {Object} cov
 606 |  */
 607 | 
 608 | function reportCoverageTable(cov) {
 609 |     // Stats
 610 |     print('\n   [bold]{Test Coverage}\n');
 611 |     var sep = '   +------------------------------------------+----------+------+------+--------+',
 612 |         lastSep = '                                              +----------+------+------+--------+';
 613 |     console.log(sep);
 614 |     console.log('   | filename                                 | coverage | LOC  | SLOC | missed |');
 615 |     console.log(sep);
 616 |     for (var name in cov) {
 617 |         var file = cov[name];
 618 |         if (Array.isArray(file)) {
 619 |             process.stdout.write('   | ' + rpad(name, 40));
 620 |             process.stdout.write(' | ' + lpad(file.coverage.toFixed(2), 8));
 621 |             process.stdout.write(' | ' + lpad(file.LOC, 4));
 622 |             process.stdout.write(' | ' + lpad(file.SLOC, 4));
 623 |             process.stdout.write(' | ' + lpad(file.totalMisses, 6));
 624 |             process.stdout.write(' |\n');
 625 |         }
 626 |     }
 627 |     console.log(sep);
 628 |     process.stdout.write('     ' + rpad('', 40));
 629 |     process.stdout.write(' | ' + lpad(cov.coverage.toFixed(2), 8));
 630 |     process.stdout.write(' | ' + lpad(cov.LOC, 4));
 631 |     process.stdout.write(' | ' + lpad(cov.SLOC, 4));
 632 |     process.stdout.write(' | ' + lpad(cov.totalMisses, 6));
 633 |     process.stdout.write(' |\n');
 634 |     console.log(lastSep);
 635 |     // Source
 636 |     for (var name in cov) {
 637 |         if (name.match(file_matcher)) {
 638 |             var file = cov[name];
 639 |             if ((file.coverage < 100) || !quiet) {
 640 |                print('\n   [bold]{' + name + '}:');
 641 |                print(file.source);
 642 |                process.stdout.write('\n');
 643 |             }
 644 |         }
 645 |     }
 646 | }
 647 | 
 648 | /**
 649 |  * Report test coverage in raw json format
 650 |  *
 651 |  * @param {Object} cov
 652 |  */
 653 | 
 654 | function reportCoverageJson(cov) {
 655 |     var report = {
 656 |         "coverage" : cov.coverage.toFixed(2),
 657 |         "LOC" : cov.LOC,
 658 |         "SLOC" : cov.SLOC,
 659 |         "totalMisses" : cov.totalMisses,
 660 |         "files" : {}
 661 |     };
 662 | 
 663 |     for (var name in cov) {
 664 |         var file = cov[name];
 665 |         if (Array.isArray(file)) {
 666 |             report.files[name] = {
 667 |                 "coverage" : file.coverage.toFixed(2),
 668 |                 "LOC" : file.LOC,
 669 |                 "SLOC" : file.SLOC,
 670 |                 "totalMisses" : file.totalMisses
 671 |             };
 672 |         }
 673 |     }
 674 | 
 675 |     fs.writeFileSync(jsonFile, JSON.stringify(report), "utf8");
 676 | }
 677 | 
 678 | /**
 679 |  * Populate code coverage data.
 680 |  *
 681 |  * @param  {Object} cov
 682 |  */
 683 | 
 684 | function populateCoverage(cov) {
 685 |     cov.LOC =
 686 |     cov.SLOC =
 687 |     cov.totalFiles =
 688 |     cov.totalHits =
 689 |     cov.totalMisses =
 690 |     cov.coverage = 0;
 691 |     for (var name in cov) {
 692 |         var file = cov[name];
 693 |         if (Array.isArray(file)) {
 694 |             // Stats
 695 |             ++cov.totalFiles;
 696 |             cov.totalHits += file.totalHits = coverage(file, true);
 697 |             cov.totalMisses += file.totalMisses = coverage(file, false);
 698 |             file.totalLines = file.totalHits + file.totalMisses;
 699 |             cov.SLOC += file.SLOC = file.totalLines;
 700 |             if (!file.source) file.source = [];
 701 |             cov.LOC += file.LOC = file.source.length;
 702 |             file.coverage = (file.totalHits / file.totalLines) * 100;
 703 |             // Source
 704 |             var width = file.source.length.toString().length;
 705 |             file.source = file.source.map(function(line, i) {
 706 |                 ++i;
 707 |                 var hits = file[i] === 0 ? 0 : (file[i] || ' ');
 708 |                 if (!boring) {
 709 |                     if (hits === 0) {
 710 |                         hits = '\x1b[31m' + hits + '\x1b[0m';
 711 |                         line = '\x1b[41m' + line + '\x1b[0m';
 712 |                     } else {
 713 |                         hits = '\x1b[32m' + hits + '\x1b[0m';
 714 |                     }
 715 |                 }
 716 |                 return '\n     ' + lpad(i, width) + ' | ' + hits + ' | ' + line;
 717 |             }).join('');
 718 |         }
 719 |     }
 720 |     cov.coverage = (cov.totalHits / cov.SLOC) * 100;
 721 | }
 722 | 
 723 | /**
 724 |  * Total coverage for the given file data.
 725 |  *
 726 |  * @param  {Array} data
 727 |  * @return {Type}
 728 |  */
 729 | 
 730 | function coverage(data, val) {
 731 |     var n = 0;
 732 |     for (var i = 0, len = data.length; i < len; ++i) {
 733 |         if (data[i] !== undefined && data[i] == val) ++n;
 734 |     }
 735 |     return n;
 736 | }
 737 | 
 738 | /**
 739 |  * Test if all files have 100% coverage
 740 |  *
 741 |  * @param  {Object} cov
 742 |  * @return {Boolean}
 743 |  */
 744 | 
 745 | function hasFullCoverage(cov) {
 746 |   for (var name in cov) {
 747 |     var file = cov[name];
 748 |     if (file instanceof Array) {
 749 |       if (file.coverage !== 100) {
 750 |           return false;
 751 |       }
 752 |     }
 753 |   }
 754 |   return true;
 755 | }
 756 | 
 757 | /**
 758 |  * Run the given test `files`, or try _test/*_.
 759 |  *
 760 |  * @param  {Array} files
 761 |  */
 762 | 
 763 | function run(files) {
 764 |     cursor(false);
 765 |     if (!files.length) {
 766 |         try {
 767 |             files = fs.readdirSync('test').map(function(file) {
 768 |                 return 'test/' + file;
 769 |             }).filter(function(file) {
 770 |                 return !(/(^\.)|(\/\.)/.test(file));
 771 |             });
 772 |         } catch (err) {
 773 |             print('\n  failed to load tests in [bold]{./test}\n');
 774 |             ++failures;
 775 |             process.exit(1);
 776 |         }
 777 |     }
 778 |     runFiles(files);
 779 | }
 780 | 
 781 | /**
 782 |  * Show the cursor when `show` is true, otherwise hide it.
 783 |  *
 784 |  * @param {Boolean} show
 785 |  */
 786 | 
 787 | function cursor(show) {
 788 |     if (boring) return;
 789 |     if (show) {
 790 |         process.stdout.write('\x1b[?25h');
 791 |     } else {
 792 |         process.stdout.write('\x1b[?25l');
 793 |     }
 794 | }
 795 | 
 796 | /**
 797 |  * Run the given test `files`.
 798 |  *
 799 |  * @param {Array} files
 800 |  */
 801 | 
 802 | function runFiles(files) {
 803 |     files = files.filter(function(file) {
 804 |         return file.match(file_matcher);
 805 |     });
 806 |     suites = files.length;
 807 | 
 808 |     if (serial) {
 809 |         (function next() {
 810 |             if (files.length) {
 811 |                 runFile(files.shift(), next);
 812 |             }
 813 |         })();
 814 |     } else {
 815 |         files.forEach(runFile);
 816 |     }
 817 | }
 818 | 
 819 | /**
 820 |  * Run tests for the given `file`, callback `fn()` when finished.
 821 |  *
 822 |  * @param {String} file
 823 |  * @param {Function} fn
 824 |  */
 825 | 
 826 | function runFile(file, fn) {
 827 |     var title = path.basename(file),
 828 |         file = path.join(cwd, file),
 829 |         mod = require(file.replace(file_matcher,''));
 830 |     (function check() {
 831 |        var len = Object.keys(mod).length;
 832 |        if (len) {
 833 |            runSuite(title, mod, fn);
 834 |            suitesRun++;
 835 |        } else {
 836 |            setTimeout(check, 20);
 837 |        }
 838 |     })();
 839 | }
 840 | 
 841 | /**
 842 |  * Run the given tests, callback `fn()` when finished.
 843 |  *
 844 |  * @param  {String} title
 845 |  * @param  {Object} tests
 846 |  * @param  {Function} fn
 847 |  */
 848 | 
 849 | var dots = 0;
 850 | function runSuite(title, tests, callback) {
 851 |     // Keys
 852 |     var keys = only.length
 853 |         ? only.slice(0)
 854 |         : Object.keys(tests);
 855 |     
 856 |     // Regular expression test filter
 857 |     var filter = new RegExp('(?:' + (match.length == 0 ? '.' : match) + ')');
 858 |     
 859 |     // Setup
 860 |     var setup = tests.setup || function(fn, assert) { fn(); };
 861 |     var teardown = tests.teardown || function(fn, assert) { fn(); };
 862 | 
 863 |     process.setMaxListeners(10 + process.listeners('beforeExit').length  + keys.length);
 864 | 
 865 |     // Iterate tests
 866 |     (function next() {
 867 |         if (keys.length) {
 868 |             var key,
 869 |                 fn = tests[key = keys.shift()];
 870 |             
 871 |             // Filter
 872 |             if (filter.test(key) === false) return next();
 873 |             
 874 |             // Non-tests
 875 |             if (key === 'setup' || key === 'teardown') return next();
 876 | 
 877 |             // Run test
 878 |             if (fn) {
 879 |                 var test = new Test({
 880 |                     fn: fn,
 881 |                     suite: title,
 882 |                     title: key,
 883 |                     setup: setup,
 884 |                     teardown: teardown
 885 |                 })
 886 |                 test.run(next);
 887 |             } else {
 888 |                 // @TODO: Add warning message that there's no test.
 889 |                 next();
 890 |             }
 891 |         } else if (serial) {
 892 |             callback();
 893 |         }
 894 |     })();
 895 | }
 896 | 
 897 | require('util').inherits(Test, require('events').EventEmitter);
 898 | function Test(options) {
 899 |     for (var key in options) {
 900 |         this[key] = options[key];
 901 |     }
 902 |     this._succeeded = [];
 903 |     this._failed = [];
 904 |     this._pending = [];
 905 |     this._beforeExit = [];
 906 |     this.assert = { __proto__: customAssert, _test: this };
 907 | 
 908 |     var test = this;
 909 |     process.on('beforeExit', function() {
 910 |         try {
 911 |             test.emit('exit');
 912 |         } catch (err) {
 913 |             test.failure(err);
 914 |         }
 915 |         test.report();
 916 |     });
 917 | }
 918 | 
 919 | Test.prototype.success = function(err) {
 920 |     this._succeeded.push(err);
 921 | };
 922 | 
 923 | Test.prototype.failure = function(err) {
 924 |     this._failed.push(err);
 925 |     this.error(err);
 926 | };
 927 | 
 928 | Test.prototype.report = function() {
 929 |     for (var i = 0; i < this._pending.length; i++) {
 930 |         this.error(this._pending[i]);
 931 |     }
 932 | };
 933 | 
 934 | Test.prototype.run = function(callback) {
 935 |     try {
 936 |         ++testcount;
 937 |         assert._test = this;
 938 | 
 939 |         if (serial) {
 940 |             this.runSerial(callback);
 941 |         } else {
 942 |             // @TODO: find a way to run setup/tearDown.
 943 |             this.runParallel();
 944 |             callback();
 945 |         }
 946 |     } catch (err) {
 947 |         this.failure(err);
 948 |         this.report();
 949 |     }
 950 | };
 951 | 
 952 | Test.prototype.runSerial = function(callback) {
 953 |     serialTest = this;
 954 | 
 955 |     var test = this;
 956 |     process.stdout.write('.');
 957 |     if (++dots % 25 === 0) console.log();
 958 |     test.setup(function() {
 959 |         if (test.fn.length < 1) {
 960 |             test.fn();
 961 |             test.teardown(callback);
 962 |         } else {
 963 |             var id = setTimeout(function() {
 964 |                 throw new Error("'" + test.title + "' timed out");
 965 |             }, timeout);
 966 |             test.callback = function() {
 967 |                 clearTimeout(id);
 968 |                 test.teardown(callback);
 969 |                 process.nextTick(function() {
 970 |                     test.report();
 971 |                 });
 972 |             };
 973 |             test.fn(test.callback);
 974 |         }
 975 |     });
 976 | };
 977 | 
 978 | Test.prototype.runParallel = function() {
 979 |     var test = this;
 980 |     test.fn(function(fn) {
 981 |         test.on('exit', function() {
 982 |             fn(test.assert);
 983 |         });
 984 |     }, test.assert);
 985 | };
 986 | 
 987 | /**
 988 |  * Report `err` for the given `test` and `suite`.
 989 |  *
 990 |  * @param {String} suite
 991 |  * @param {String} test
 992 |  * @param {Error} err
 993 |  */
 994 | Test.prototype.error = function(err) {
 995 |     if (!err._reported) {
 996 |         ++failures;
 997 |         var test = err._test || this;
 998 |         var name = err.name,
 999 |             stack = err.stack ? err.stack.replace(err.name, '') : '',
1000 |             label = test.suite + ' ' + test.title;
1001 |         print('\n   [bold]{' + label + '}: [red]{' + name + '}' + stack + '\n');
1002 |         err._reported = true;
1003 |     }
1004 | }
1005 | 
1006 | /**
1007 | * Report exceptions.
1008 |  */
1009 | 
1010 | function report() {
1011 |     cursor(true);
1012 |     process.emit('beforeExit');
1013 |     if (suitesRun < suites) {
1014 |         print('\n   [bold]{Failure}: [red]{Only ' + suitesRun + ' of ' + suites + ' suites have been started}\n\n');
1015 |     }
1016 |     else if (failures) {
1017 |         print('\n   [bold]{Failures}: [red]{' + failures + '}\n\n');
1018 |         notify('Failures: ' + failures);
1019 |     } else {
1020 |         if (serial) print('');
1021 |         print('\n   [green]{100%} ' + testcount + ' tests\n');
1022 |         notify('100% ok');
1023 |     }
1024 |     if (typeof _$jscoverage === 'object') {
1025 |         populateCoverage(_$jscoverage);
1026 |         if (!hasFullCoverage(_$jscoverage) || !quiet) {
1027 |             (jsonCoverage ? reportCoverageJson(_$jscoverage) : reportCoverageTable(_$jscoverage));
1028 |         }
1029 |     }
1030 | }
1031 | 
1032 | /**
1033 |  * Growl notify the given `msg`.
1034 |  *
1035 |  * @param {String} msg
1036 |  */
1037 | 
1038 | function notify(msg) {
1039 |     if (growl) {
1040 |         childProcess.exec('growlnotify -name Expresso -m "' + msg + '"');
1041 |     }
1042 | }
1043 | 
1044 | // Report uncaught exceptions
1045 | var unknownTest = new Test({
1046 |     suite: 'uncaught',
1047 |     test: 'uncaught'
1048 | });
1049 | var serialTest;
1050 | 
1051 | process.on('uncaughtException', function(err) {
1052 |     if (!serial) {
1053 |         unknownTest.error(err);
1054 |     } else {
1055 |         serialTest.failure(err);
1056 |         serialTest.callback();
1057 |     }
1058 | });
1059 | 
1060 | // Show cursor
1061 | 
1062 | ['INT', 'TERM', 'QUIT'].forEach(function(sig) {
1063 |     process.on('SIG' + sig, function() {
1064 |         cursor(true);
1065 |         process.exit(1);
1066 |     });
1067 | });
1068 | 
1069 | // Report test coverage when available
1070 | // and emit "beforeExit" event to perform
1071 | // final assertions
1072 | 
1073 | var orig = process.emit;
1074 | process.emit = function(event) {
1075 |     if (event === 'exit') {
1076 |         report();
1077 |         process.reallyExit(failures);
1078 |     }
1079 |     orig.apply(this, arguments);
1080 | };
1081 | 
1082 | // Run test files
1083 | 
1084 | if (!defer) run(files);
1085 | 


--------------------------------------------------------------------------------
/docs/api.html:
--------------------------------------------------------------------------------
   1 | <a href="http://github.com/visionmedia/expresso"><img alt="Fork me on GitHub" id="ribbon" src="http://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png"></a><html>
   2 | 	<head>
   3 | 		<title>Expresso</title>
   4 | 		<script src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>
   5 | 		<style>body {
   6 |     margin: 0;
   7 |     padding: 0;
   8 |     font: 14px/1.5 'Palatino Linotype', 'Book Antiqua', Palatino, FreeSerif, serif;
   9 |     color: #252519;
  10 | }
  11 | a {
  12 |     color: #252519;
  13 | }
  14 | a:hover {
  15 |     text-decoration: underline;
  16 |     color: #19469D;
  17 | }
  18 | p {
  19 |     margin: 12px 0;
  20 | }
  21 | h1, h2, h3 {
  22 |     margin: 0;
  23 |     padding: 0;
  24 | }
  25 | table#source {
  26 |     width: 100%;
  27 |     border-collapse: collapse;
  28 | }
  29 | table#source td:first-child {
  30 |     padding: 30px 40px 30px 40px;
  31 |     vertical-align: top;
  32 | }
  33 | table#source td:first-child,
  34 | table#source td:first-child pre {
  35 |     width: 450px;
  36 | }
  37 | table#source td:last-child {
  38 |     padding: 30px 0 30px 40px;
  39 |     border-left: 1px solid #E5E5EE;
  40 |     background: #F5F5FF;
  41 | }
  42 | table#source tr {
  43 |     border-bottom: 1px solid #E5E5EE;
  44 | }
  45 | table#source tr.filename {
  46 |     padding-top: 40px;
  47 |     border-top: 1px solid #E5E5EE;
  48 | }
  49 | table#source tr.filename td:first-child {
  50 |     text-transform: capitalize;
  51 | }
  52 | table#source tr.filename td:last-child {
  53 |     font-size: 12px;
  54 | }
  55 | table#source tr.filename h2 {
  56 |     margin: 0;
  57 |     padding: 0;
  58 |     cursor: pointer;
  59 | }
  60 | table#source tr.code h1,
  61 | table#source tr.code h2,
  62 | table#source tr.code h3 {
  63 |     margin-top: 30px;
  64 |     font-family: "Lucida Grande", "Helvetica Nueue", Arial, sans-serif;
  65 |     font-size: 18px;
  66 | }
  67 | table#source tr.code h2 {
  68 |     font-size: 16px;
  69 | }
  70 | table#source tr.code h3 {
  71 |     font-size: 14px;
  72 | }
  73 | table#source tr.code ul {
  74 |     margin: 15px 0 15px 35px;
  75 |     padding: 0;
  76 | }
  77 | table#source tr.code ul li {
  78 |     margin: 0;
  79 |     padding: 1px 0;
  80 | }
  81 | table#source tr.code ul li p {
  82 |     margin: 0;
  83 |     padding: 0;
  84 | }
  85 | table#source tr.code td:first-child pre {
  86 |     padding: 20px;
  87 | }
  88 | #ribbon {
  89 |     position: fixed;
  90 |     top: 0;
  91 |     right: 0;
  92 | }
  93 | code .string { color: #219161; }
  94 | code .regexp { color: #219161; }
  95 | code .keyword { color: #954121; }
  96 | code .number { color: #19469D; }
  97 | code .comment { color: #bbb; }
  98 | code .this { color: #19469D; }</style>
  99 | 		<script>
 100 | 			$(function(){
 101 | 				$('tr.code').hide();
 102 | 				$('tr.filename').toggle(function(){
 103 | 					$(this).nextUntil('.filename').fadeIn();
 104 | 				}, function(){
 105 | 					$(this).nextUntil('.filename').fadeOut();
 106 | 				});
 107 | 			});
 108 | 		</script>
 109 | 	</head>
 110 | 	<body>
 111 | <table id="source"><tbody><tr><td><h1>Expresso</h1><p>Insanely fast TDD framework for <a href="http://nodejs.org">node</a> featuring code coverage reporting.</p></td><td></td></tr><tr class="filename"><td><h2 id="bin/expresso"><a href="#">expresso</a></h2></td><td>bin/expresso</td></tr><tr class="code">
 112 | <td class="docs">
 113 | <h1>!/usr/bin/env node</h1>
 114 | </td>
 115 | <td class="code">
 116 | <pre><code>
 117 |  * <span class="class">Expresso</span>
 118 |  * <span class="class">Copyright</span>(<span class="variable">c</span>) <span class="class">TJ</span> <span class="class">Holowaychuk</span> &<span class="variable">lt</span>;<span class="variable">tj</span>@<span class="variable">vision</span>-<span class="variable">media</span>.<span class="variable">ca</span>&<span class="variable">gt</span>;
 119 |  * (<span class="class">MIT</span> <span class="class">Licensed</span>)
 120 |  </code></pre>
 121 | </td>
 122 | </tr>
 123 | <tr class="code">
 124 | <td class="docs">
 125 | <p>Module dependencies.
 126 |  </p>
 127 | </td>
 128 | <td class="code">
 129 | <pre><code><span class="keyword">var</span> <span class="variable">assert</span> = <span class="variable">require</span>(<span class="string">'assert'</span>),
 130 |     <span class="variable">childProcess</span> = <span class="variable">require</span>(<span class="string">'child_process'</span>),
 131 |     <span class="variable">http</span> = <span class="variable">require</span>(<span class="string">'http'</span>),
 132 |     <span class="variable">path</span> = <span class="variable">require</span>(<span class="string">'path'</span>),
 133 |     <span class="variable">sys</span> = <span class="variable">require</span>(<span class="string">'sys'</span>),
 134 |     <span class="variable">cwd</span> = <span class="variable">process</span>.<span class="variable">cwd</span>(),
 135 |     <span class="variable">fs</span> = <span class="variable">require</span>(<span class="string">'fs'</span>),
 136 |     <span class="variable">defer</span>;</code></pre>
 137 | </td>
 138 | </tr>
 139 | <tr class="code">
 140 | <td class="docs">
 141 | <p>Set the node env to test if it hasn't already been set
 142 |  </p>
 143 | </td>
 144 | <td class="code">
 145 | <pre><code><span class="keyword">if</span>( !<span class="variable">process</span>.<span class="variable">env</span>.<span class="class">NODE_ENV</span> ) <span class="variable">process</span>.<span class="variable">env</span>.<span class="class">NODE_ENV</span> = <span class="string">'test'</span>;</code></pre>
 146 | </td>
 147 | </tr>
 148 | <tr class="code">
 149 | <td class="docs">
 150 | <p>Setup the regex which is used to match test files.
 151 | Adjust it to include coffeescript files if CS is available
 152 |  </p>
 153 | </td>
 154 | <td class="code">
 155 | <pre><code><span class="keyword">var</span> <span class="variable">file_matcher</span> = <span class="regexp">/\.js$/</span>;
 156 | <span class="keyword">try</span> {
 157 |   <span class="variable">require</span>(<span class="string">'coffee-script'</span>);
 158 |   <span class="variable">file_matcher</span> = <span class="regexp">/\.(js|coffee)$/</span>;
 159 | } <span class="keyword">catch</span> (<span class="variable">e</span>) {}</code></pre>
 160 | </td>
 161 | </tr>
 162 | <tr class="code">
 163 | <td class="docs">
 164 | <p>Expresso version.
 165 |  </p>
 166 | </td>
 167 | <td class="code">
 168 | <pre><code><span class="keyword">var</span> <span class="variable">version</span> = <span class="string">'0.8.1'</span>;</code></pre>
 169 | </td>
 170 | </tr>
 171 | <tr class="code">
 172 | <td class="docs">
 173 | <p>Failure count.
 174 |  </p>
 175 | </td>
 176 | <td class="code">
 177 | <pre><code><span class="keyword">var</span> <span class="variable">failures</span> = <span class="number integer">0</span>;</code></pre>
 178 | </td>
 179 | </tr>
 180 | <tr class="code">
 181 | <td class="docs">
 182 | <p>Indicates whether all test files have been loaded.
 183 |  </p>
 184 | </td>
 185 | <td class="code">
 186 | <pre><code><span class="keyword">var</span> <span class="variable">suites</span> = <span class="number integer">0</span>;
 187 | <span class="keyword">var</span> <span class="variable">suitesRun</span> = <span class="number integer">0</span>;</code></pre>
 188 | </td>
 189 | </tr>
 190 | <tr class="code">
 191 | <td class="docs">
 192 | <p>Number of tests executed.
 193 |  </p>
 194 | </td>
 195 | <td class="code">
 196 | <pre><code><span class="keyword">var</span> <span class="variable">testcount</span> = <span class="number integer">0</span>;</code></pre>
 197 | </td>
 198 | </tr>
 199 | <tr class="code">
 200 | <td class="docs">
 201 | <p>Whitelist of tests to run.
 202 |  </p>
 203 | </td>
 204 | <td class="code">
 205 | <pre><code><span class="keyword">var</span> <span class="variable">only</span> = [];</code></pre>
 206 | </td>
 207 | </tr>
 208 | <tr class="code">
 209 | <td class="docs">
 210 | <p>Boring output.
 211 |  </p>
 212 | </td>
 213 | <td class="code">
 214 | <pre><code><span class="keyword">var</span> <span class="variable">boring</span> = <span class="variable">false</span>;</code></pre>
 215 | </td>
 216 | </tr>
 217 | <tr class="code">
 218 | <td class="docs">
 219 | <p>Growl notifications.
 220 |  </p>
 221 | </td>
 222 | <td class="code">
 223 | <pre><code><span class="keyword">var</span> <span class="variable">growl</span> = <span class="variable">false</span>;</code></pre>
 224 | </td>
 225 | </tr>
 226 | <tr class="code">
 227 | <td class="docs">
 228 | <p>Server port.
 229 |  </p>
 230 | </td>
 231 | <td class="code">
 232 | <pre><code><span class="keyword">var</span> <span class="variable">port</span> = <span class="number integer">5555</span>;</code></pre>
 233 | </td>
 234 | </tr>
 235 | <tr class="code">
 236 | <td class="docs">
 237 | <p>Execute serially.
 238 |  </p>
 239 | </td>
 240 | <td class="code">
 241 | <pre><code><span class="keyword">var</span> <span class="variable">serial</span> = <span class="variable">false</span>;</code></pre>
 242 | </td>
 243 | </tr>
 244 | <tr class="code">
 245 | <td class="docs">
 246 | <p>Default timeout.
 247 |  </p>
 248 | </td>
 249 | <td class="code">
 250 | <pre><code><span class="keyword">var</span> <span class="variable">timeout</span> = <span class="number integer">2000</span>;</code></pre>
 251 | </td>
 252 | </tr>
 253 | <tr class="code">
 254 | <td class="docs">
 255 | <p>Quiet output.
 256 |  </p>
 257 | </td>
 258 | <td class="code">
 259 | <pre><code><span class="keyword">var</span> <span class="variable">quiet</span> = <span class="variable">false</span>;</code></pre>
 260 | </td>
 261 | </tr>
 262 | <tr class="code">
 263 | <td class="docs">
 264 | <p>JSON code coverage report
 265 |  </p>
 266 | </td>
 267 | <td class="code">
 268 | <pre><code><span class="keyword">var</span> <span class="variable">jsonCoverage</span> = <span class="variable">false</span>;
 269 | <span class="keyword">var</span> <span class="variable">jsonFile</span>;</code></pre>
 270 | </td>
 271 | </tr>
 272 | <tr class="code">
 273 | <td class="docs">
 274 | <p>Usage documentation.
 275 |  </p>
 276 | </td>
 277 | <td class="code">
 278 | <pre><code><span class="keyword">var</span> <span class="variable">usage</span> = <span class="string">''</span>
 279 |     + <span class="string">'[bold]{Usage}: expresso [options] &lt;file ...&gt;'</span>
 280 |     + <span class="string">'\n'</span>
 281 |     + <span class="string">'\n[bold]{Options}:'</span>
 282 |     + <span class="string">'\n  -g, --growl          Enable growl notifications'</span>
 283 |     + <span class="string">'\n  -c, --coverage       Generate and report test coverage'</span>
 284 |     + <span class="string">'\n  -j, --json PATH      Used in conjunction with --coverage, ouput JSON coverage to PATH'</span>
 285 |     + <span class="string">'\n  -q, --quiet          Suppress coverage report if 100%'</span>
 286 |     + <span class="string">'\n  -t, --timeout MS     Timeout in milliseconds, defaults to 2000'</span>
 287 |     + <span class="string">'\n  -r, --require PATH   Require the given module path'</span>
 288 |     + <span class="string">'\n  -o, --only TESTS     Execute only the comma sperated TESTS (can be set several times)'</span>
 289 |     + <span class="string">'\n  -I, --include PATH   Unshift the given path to require.paths'</span>
 290 |     + <span class="string">'\n  -p, --port NUM       Port number for test servers, starts at 5555'</span>
 291 |     + <span class="string">'\n  -s, --serial         Execute tests serially'</span>
 292 |     + <span class="string">'\n  -b, --boring         Suppress ansi-escape colors'</span>
 293 |     + <span class="string">'\n  -v, --version        Output version number'</span>
 294 |     + <span class="string">'\n  -h, --help           Display help information'</span>
 295 |     + <span class="string">'\n'</span>;
 296 | 
 297 | <span class="comment">// Parse arguments</span>
 298 | 
 299 | <span class="keyword">var</span> <span class="variable">files</span> = [],
 300 |     <span class="variable">args</span> = <span class="variable">process</span>.<span class="variable">argv</span>.<span class="variable">slice</span>(<span class="number integer">2</span>);
 301 | 
 302 | <span class="keyword">while</span> (<span class="variable">args</span>.<span class="variable">length</span>) {
 303 |     <span class="keyword">var</span> <span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>();
 304 |     <span class="keyword">switch</span> (<span class="variable">arg</span>) {
 305 |         <span class="keyword">case</span> <span class="string">'-h'</span>:
 306 |         <span class="keyword">case</span> <span class="string">'--help'</span>:
 307 |             <span class="variable">print</span>(<span class="variable">usage</span> + <span class="string">'\n'</span>);
 308 |             <span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
 309 |             <span class="keyword">break</span>;
 310 |         <span class="keyword">case</span> <span class="string">'-v'</span>:
 311 |         <span class="keyword">case</span> <span class="string">'--version'</span>:
 312 |             <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">version</span>);
 313 |             <span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
 314 |             <span class="keyword">break</span>;
 315 |         <span class="keyword">case</span> <span class="string">'-i'</span>:
 316 |         <span class="keyword">case</span> <span class="string">'-I'</span>:
 317 |         <span class="keyword">case</span> <span class="string">'--include'</span>:
 318 |             <span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
 319 |                 <span class="variable">require</span>.<span class="variable">paths</span>.<span class="variable">unshift</span>(<span class="variable">arg</span>);
 320 |             } <span class="keyword">else</span> {
 321 |                 <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--include requires a path'</span>);
 322 |             }
 323 |             <span class="keyword">break</span>;
 324 |         <span class="keyword">case</span> <span class="string">'-o'</span>:
 325 |         <span class="keyword">case</span> <span class="string">'--only'</span>:
 326 |             <span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
 327 |                 <span class="variable">only</span> = <span class="variable">only</span>.<span class="variable">concat</span>(<span class="variable">arg</span>.<span class="variable">split</span>(<span class="regexp">/ *, */</span>));
 328 |             } <span class="keyword">else</span> {
 329 |                 <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--only requires comma-separated test names'</span>);
 330 |             }
 331 |             <span class="keyword">break</span>;
 332 |         <span class="keyword">case</span> <span class="string">'-p'</span>:
 333 |         <span class="keyword">case</span> <span class="string">'--port'</span>:
 334 |             <span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
 335 |                 <span class="variable">port</span> = <span class="variable">parseInt</span>(<span class="variable">arg</span>, <span class="number integer">10</span>);
 336 |             } <span class="keyword">else</span> {
 337 |                 <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--port requires a number'</span>);
 338 |             }
 339 |             <span class="keyword">break</span>;
 340 |         <span class="keyword">case</span> <span class="string">'-r'</span>:
 341 |         <span class="keyword">case</span> <span class="string">'--require'</span>:
 342 |             <span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
 343 |                 <span class="variable">require</span>(<span class="variable">arg</span>);
 344 |             } <span class="keyword">else</span> {
 345 |                 <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--require requires a path'</span>);
 346 |             }
 347 |             <span class="keyword">break</span>;
 348 |         <span class="keyword">case</span> <span class="string">'-t'</span>:
 349 |         <span class="keyword">case</span> <span class="string">'--timeout'</span>:
 350 |           <span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
 351 |             <span class="variable">timeout</span> = <span class="variable">parseInt</span>(<span class="variable">arg</span>, <span class="number integer">10</span>);
 352 |           } <span class="keyword">else</span> {
 353 |             <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--timeout requires an argument'</span>);
 354 |           }
 355 |           <span class="keyword">break</span>;
 356 |         <span class="keyword">case</span> <span class="string">'-c'</span>:
 357 |         <span class="keyword">case</span> <span class="string">'--cov'</span>:
 358 |         <span class="keyword">case</span> <span class="string">'--coverage'</span>:
 359 |             <span class="variable">defer</span> = <span class="variable">true</span>;
 360 |             <span class="variable">childProcess</span>.<span class="variable">exec</span>(<span class="string">'rm -fr lib-cov &amp;&amp; node-jscoverage lib lib-cov'</span>, <span class="keyword">function</span>(<span class="variable">err</span>) {
 361 |                 <span class="keyword">if</span> (<span class="variable">err</span>) <span class="keyword">throw</span> <span class="variable">err</span>;
 362 |                 <span class="variable">require</span>.<span class="variable">paths</span>.<span class="variable">unshift</span>(<span class="string">'lib-cov'</span>);
 363 |                 <span class="variable">run</span>(<span class="variable">files</span>);
 364 |             });
 365 |             <span class="keyword">break</span>;
 366 |         <span class="keyword">case</span> <span class="string">'-q'</span>:
 367 |         <span class="keyword">case</span> <span class="string">'--quiet'</span>:
 368 |             <span class="variable">quiet</span> = <span class="variable">true</span>;
 369 |             <span class="keyword">break</span>;
 370 |         <span class="keyword">case</span> <span class="string">'-b'</span>:
 371 |         <span class="keyword">case</span> <span class="string">'--boring'</span>:
 372 |             <span class="variable">boring</span> = <span class="variable">true</span>;
 373 |             <span class="keyword">break</span>;
 374 |         <span class="keyword">case</span> <span class="string">'-g'</span>:
 375 |         <span class="keyword">case</span> <span class="string">'--growl'</span>:
 376 |             <span class="variable">growl</span> = <span class="variable">true</span>;
 377 |             <span class="keyword">break</span>;
 378 |         <span class="keyword">case</span> <span class="string">'-s'</span>:
 379 |         <span class="keyword">case</span> <span class="string">'--serial'</span>:
 380 |             <span class="variable">serial</span> = <span class="variable">true</span>;
 381 |             <span class="keyword">break</span>;
 382 |         <span class="keyword">case</span> <span class="string">'-j'</span>:
 383 |         <span class="keyword">case</span> <span class="string">'--json'</span>:
 384 |             <span class="variable">jsonCoverage</span> = <span class="variable">true</span>;
 385 |             <span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
 386 |                 <span class="variable">jsonFile</span> = <span class="variable">path</span>.<span class="variable">normalize</span>(<span class="variable">arg</span>);
 387 |             } <span class="keyword">else</span> {
 388 |                 <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--json requires file to write to'</span>);
 389 |             }
 390 |             <span class="keyword">break</span>;
 391 |         <span class="keyword">default</span>:
 392 |             <span class="keyword">if</span> (<span class="variable">file_matcher</span>.<span class="variable">test</span>(<span class="variable">arg</span>)) {
 393 |                 <span class="variable">files</span>.<span class="variable">push</span>(<span class="variable">arg</span>);
 394 |             }
 395 |             <span class="keyword">break</span>;
 396 |     }
 397 | }</code></pre>
 398 | </td>
 399 | </tr>
 400 | <tr class="code">
 401 | <td class="docs">
 402 | <p>Colorized sys.error().</p>
 403 | 
 404 | <h2></h2>
 405 | 
 406 | <ul><li><p><strong>param</strong>: <em>String</em>  str</p></li></ul>
 407 | </td>
 408 | <td class="code">
 409 | <pre><code><span class="keyword">function</span> <span class="variable">print</span>(<span class="variable">str</span>) {
 410 |     <span class="variable">sys</span>.<span class="variable">error</span>(<span class="variable">colorize</span>(<span class="variable">str</span>));
 411 | }</code></pre>
 412 | </td>
 413 | </tr>
 414 | <tr class="code">
 415 | <td class="docs">
 416 | <p>Colorize the given string using ansi-escape sequences.
 417 | Disabled when --boring is set.</p>
 418 | 
 419 | <h2></h2>
 420 | 
 421 | <ul><li><p><strong>param</strong>: <em>String</em>  str</p></li><li><p><strong>return</strong>: <em>String</em> </p></li></ul>
 422 | </td>
 423 | <td class="code">
 424 | <pre><code><span class="keyword">function</span> <span class="variable">colorize</span>(<span class="variable">str</span>) {
 425 |     <span class="keyword">var</span> <span class="variable">colors</span> = { <span class="variable">bold</span>: <span class="number integer">1</span>, <span class="variable">red</span>: <span class="number integer">31</span>, <span class="variable">green</span>: <span class="number integer">32</span>, <span class="variable">yellow</span>: <span class="number integer">33</span> };
 426 |     <span class="keyword">return</span> <span class="variable">str</span>.<span class="variable">replace</span>(<span class="regexp">/\[(\w+)\]\{([^]*?)\}/g</span>, <span class="keyword">function</span>(<span class="variable">_</span>, <span class="variable">color</span>, <span class="variable">str</span>) {
 427 |         <span class="keyword">return</span> <span class="variable">boring</span>
 428 |             ? <span class="variable">str</span>
 429 |             : <span class="string">'\x1B['</span> + <span class="variable">colors</span>[<span class="variable">color</span>] + <span class="string">'m'</span> + <span class="variable">str</span> + <span class="string">'\x1B[0m'</span>;
 430 |     });
 431 | }
 432 | 
 433 | <span class="comment">// Alias deepEqual as eql for complex equality</span>
 434 | 
 435 | <span class="variable">assert</span>.<span class="variable">eql</span> = <span class="variable">assert</span>.<span class="variable">deepEqual</span>;</code></pre>
 436 | </td>
 437 | </tr>
 438 | <tr class="code">
 439 | <td class="docs">
 440 | <p>Assert that <code>val</code> is null.</p>
 441 | 
 442 | <h2></h2>
 443 | 
 444 | <ul><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
 445 | </td>
 446 | <td class="code">
 447 | <pre><code><span class="variable">assert</span>.<span class="variable">isNull</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
 448 |     <span class="variable">assert</span>.<span class="variable">strictEqual</span>(<span class="keyword">null</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
 449 | };</code></pre>
 450 | </td>
 451 | </tr>
 452 | <tr class="code">
 453 | <td class="docs">
 454 | <p>Assert that <code>val</code> is not null.</p>
 455 | 
 456 | <h2></h2>
 457 | 
 458 | <ul><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
 459 | </td>
 460 | <td class="code">
 461 | <pre><code><span class="variable">assert</span>.<span class="variable">isNotNull</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
 462 |     <span class="variable">assert</span>.<span class="variable">notStrictEqual</span>(<span class="keyword">null</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
 463 | };</code></pre>
 464 | </td>
 465 | </tr>
 466 | <tr class="code">
 467 | <td class="docs">
 468 | <p>Assert that <code>val</code> is undefined.</p>
 469 | 
 470 | <h2></h2>
 471 | 
 472 | <ul><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
 473 | </td>
 474 | <td class="code">
 475 | <pre><code><span class="variable">assert</span>.<span class="variable">isUndefined</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
 476 |     <span class="variable">assert</span>.<span class="variable">strictEqual</span>(<span class="variable">undefined</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
 477 | };</code></pre>
 478 | </td>
 479 | </tr>
 480 | <tr class="code">
 481 | <td class="docs">
 482 | <p>Assert that <code>val</code> is not undefined.</p>
 483 | 
 484 | <h2></h2>
 485 | 
 486 | <ul><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
 487 | </td>
 488 | <td class="code">
 489 | <pre><code><span class="variable">assert</span>.<span class="variable">isDefined</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
 490 |     <span class="variable">assert</span>.<span class="variable">notStrictEqual</span>(<span class="variable">undefined</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
 491 | };</code></pre>
 492 | </td>
 493 | </tr>
 494 | <tr class="code">
 495 | <td class="docs">
 496 | <p>Assert that <code>obj</code> is <code>type</code>.</p>
 497 | 
 498 | <h2></h2>
 499 | 
 500 | <ul><li><p><strong>param</strong>: <em>Mixed</em>  obj</p></li><li><p><strong>param</strong>: <em>String</em>  type</p></li><li><p><strong>api</strong>: <em>public</em></p></li></ul>
 501 | </td>
 502 | <td class="code">
 503 | <pre><code><span class="variable">assert</span>.<span class="variable">type</span> = <span class="keyword">function</span>(<span class="variable">obj</span>, <span class="variable">type</span>, <span class="variable">msg</span>) {
 504 |     <span class="keyword">var</span> <span class="variable">real</span> = <span class="keyword">typeof</span> <span class="variable">obj</span>;
 505 |     <span class="variable">msg</span> = <span class="variable">msg</span> || <span class="string">'typeof '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">obj</span>) + <span class="string">' is '</span> + <span class="variable">real</span> + <span class="string">', expected '</span> + <span class="variable">type</span>;
 506 |     <span class="variable">assert</span>.<span class="variable">ok</span>(<span class="variable">type</span> === <span class="variable">real</span>, <span class="variable">msg</span>);
 507 | };</code></pre>
 508 | </td>
 509 | </tr>
 510 | <tr class="code">
 511 | <td class="docs">
 512 | <p>Assert that <code>str</code> matches <code>regexp</code>.</p>
 513 | 
 514 | <h2></h2>
 515 | 
 516 | <ul><li><p><strong>param</strong>: <em>String</em>  str</p></li><li><p><strong>param</strong>: <em>RegExp</em>  regexp</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
 517 | </td>
 518 | <td class="code">
 519 | <pre><code><span class="variable">assert</span>.<span class="variable">match</span> = <span class="keyword">function</span>(<span class="variable">str</span>, <span class="variable">regexp</span>, <span class="variable">msg</span>) {
 520 |     <span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">str</span>) + <span class="string">' does not match '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">regexp</span>);
 521 |     <span class="variable">assert</span>.<span class="variable">ok</span>(<span class="variable">regexp</span>.<span class="variable">test</span>(<span class="variable">str</span>), <span class="variable">msg</span>);
 522 | };</code></pre>
 523 | </td>
 524 | </tr>
 525 | <tr class="code">
 526 | <td class="docs">
 527 | <p>Assert that <code>val</code> is within <code>obj</code>.</p>
 528 | 
 529 | <h2>Examples</h2>
 530 | 
 531 | <p>   assert.includes('foobar', 'bar');
 532 |    assert.includes(['foo', 'bar'], 'foo');</p>
 533 | 
 534 | <h2></h2>
 535 | 
 536 | <ul><li><p><strong>param</strong>: <em>String | Array</em>  obj</p></li><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
 537 | </td>
 538 | <td class="code">
 539 | <pre><code><span class="variable">assert</span>.<span class="variable">includes</span> = <span class="keyword">function</span>(<span class="variable">obj</span>, <span class="variable">val</span>, <span class="variable">msg</span>) {
 540 |     <span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">obj</span>) + <span class="string">' does not include '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">val</span>);
 541 |     <span class="variable">assert</span>.<span class="variable">ok</span>(<span class="variable">obj</span>.<span class="variable">indexOf</span>(<span class="variable">val</span>) &<span class="variable">gt</span>;= <span class="number integer">0</span>, <span class="variable">msg</span>);
 542 | };</code></pre>
 543 | </td>
 544 | </tr>
 545 | <tr class="code">
 546 | <td class="docs">
 547 | <p>Assert length of <code>val</code> is <code>n</code>.</p>
 548 | 
 549 | <h2></h2>
 550 | 
 551 | <ul><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>Number</em>  n</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
 552 | </td>
 553 | <td class="code">
 554 | <pre><code><span class="variable">assert</span>.<span class="variable">length</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">n</span>, <span class="variable">msg</span>) {
 555 |     <span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">val</span>) + <span class="string">' has length of '</span> + <span class="variable">val</span>.<span class="variable">length</span> + <span class="string">', expected '</span> + <span class="variable">n</span>;
 556 |     <span class="variable">assert</span>.<span class="variable">equal</span>(<span class="variable">n</span>, <span class="variable">val</span>.<span class="variable">length</span>, <span class="variable">msg</span>);
 557 | };</code></pre>
 558 | </td>
 559 | </tr>
 560 | <tr class="code">
 561 | <td class="docs">
 562 | <p>Assert response from <code>server</code> with
 563 | the given <code>req</code> object and <code>res</code> assertions object.</p>
 564 | 
 565 | <h2></h2>
 566 | 
 567 | <ul><li><p><strong>param</strong>: <em>Server</em>  server</p></li><li><p><strong>param</strong>: <em>Object</em>  req</p></li><li><p><strong>param</strong>: <em>Object | Function</em>  res</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
 568 | </td>
 569 | <td class="code">
 570 | <pre><code><span class="variable">assert</span>.<span class="variable">response</span> = <span class="keyword">function</span>(<span class="variable">server</span>, <span class="variable">req</span>, <span class="variable">res</span>, <span class="variable">msg</span>) {
 571 |     <span class="keyword">var</span> <span class="variable">test</span> = <span class="variable">assert</span>.<span class="variable">_test</span>;
 572 | 
 573 |     <span class="comment">// Callback as third or fourth arg</span>
 574 |     <span class="keyword">var</span> <span class="variable">callback</span> = <span class="keyword">typeof</span> <span class="variable">res</span> === <span class="string">'function'</span>
 575 |         ? <span class="variable">res</span>
 576 |         : <span class="keyword">typeof</span> <span class="variable">msg</span> === <span class="string">'function'</span>
 577 |             ? <span class="variable">msg</span>
 578 |             : <span class="keyword">function</span>() {};
 579 | 
 580 |     <span class="comment">// Default messate to test title</span>
 581 |     <span class="keyword">if</span> (<span class="keyword">typeof</span> <span class="variable">msg</span> === <span class="string">'function'</span>) <span class="variable">msg</span> = <span class="keyword">null</span>;
 582 |     <span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">test</span>.<span class="variable">title</span>;
 583 |     <span class="variable">msg</span> += <span class="string">'. '</span>;
 584 | 
 585 |     <span class="comment">// Add a unique token for this call to assert.response(). We'll move it to</span>
 586 |     <span class="comment">// succeeded/failed when done</span>
 587 |     <span class="keyword">var</span> <span class="variable">token</span> = <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'Response not completed: '</span> + <span class="variable">msg</span>);
 588 |     <span class="variable">test</span>.<span class="variable">_pending</span>.<span class="variable">push</span>(<span class="variable">token</span>);
 589 | 
 590 |     <span class="keyword">function</span> <span class="variable">check</span>() {
 591 |         <span class="keyword">try</span> {
 592 |             <span class="variable">server</span>.<span class="variable">__port</span> = <span class="variable">server</span>.<span class="variable">address</span>().<span class="variable">port</span>;
 593 |             <span class="variable">server</span>.<span class="variable">__listening</span> = <span class="variable">true</span>;
 594 |         } <span class="keyword">catch</span> (<span class="variable">err</span>) {
 595 |             <span class="variable">process</span>.<span class="variable">nextTick</span>(<span class="variable">check</span>);
 596 |             <span class="keyword">return</span>;
 597 |         }
 598 |         <span class="keyword">if</span> (<span class="variable">server</span>.<span class="variable">__deferred</span>) {
 599 |             <span class="variable">server</span>.<span class="variable">__deferred</span>.<span class="variable">forEach</span>(<span class="keyword">function</span>(<span class="variable">fn</span>) { <span class="variable">fn</span>(); });
 600 |             <span class="variable">server</span>.<span class="variable">__deferred</span> = <span class="keyword">null</span>;
 601 |         }
 602 |     }
 603 | 
 604 |     <span class="comment">// Pending responses</span>
 605 |     <span class="variable">server</span>.<span class="variable">__pending</span> = <span class="variable">server</span>.<span class="variable">__pending</span> || <span class="number integer">0</span>;
 606 |     <span class="variable">server</span>.<span class="variable">__pending</span>++;
 607 | 
 608 |     <span class="comment">// Check that the server is ready or defer</span>
 609 |     <span class="keyword">if</span> (!<span class="variable">server</span>.<span class="variable">fd</span>) {
 610 |         <span class="variable">server</span>.<span class="variable">__deferred</span> = <span class="variable">server</span>.<span class="variable">__deferred</span> || [];
 611 |         <span class="variable">server</span>.<span class="variable">listen</span>(<span class="variable">server</span>.<span class="variable">__port</span> = <span class="variable">port</span>++, <span class="string">'127.0.0.1'</span>, <span class="variable">check</span>);
 612 |     } <span class="keyword">else</span> <span class="keyword">if</span> (!<span class="variable">server</span>.<span class="variable">__port</span>) {
 613 |         <span class="variable">server</span>.<span class="variable">__deferred</span> = <span class="variable">server</span>.<span class="variable">__deferred</span> || [];
 614 |         <span class="variable">process</span>.<span class="variable">nextTick</span>(<span class="variable">check</span>);
 615 |     }
 616 | 
 617 |     <span class="comment">// The socket was created but is not yet listening, so keep deferring</span>
 618 |     <span class="keyword">if</span> (!<span class="variable">server</span>.<span class="variable">__listening</span>) {
 619 |         <span class="variable">server</span>.<span class="variable">__deferred</span>.<span class="variable">push</span>(<span class="variable">issue</span>);
 620 |         <span class="keyword">return</span>;
 621 |     } <span class="keyword">else</span> {
 622 |         <span class="variable">issue</span>();
 623 |     }
 624 | 
 625 |     <span class="keyword">function</span> <span class="variable">issue</span>() {
 626 |         <span class="comment">// Issue request</span>
 627 |         <span class="keyword">var</span> <span class="variable">timer</span>,
 628 |             <span class="variable">method</span> = <span class="variable">req</span>.<span class="variable">method</span> || <span class="string">'GET'</span>,
 629 |             <span class="variable">status</span> = <span class="variable">res</span>.<span class="variable">status</span> || <span class="variable">res</span>.<span class="variable">statusCode</span>,
 630 |             <span class="variable">data</span> = <span class="variable">req</span>.<span class="variable">data</span> || <span class="variable">req</span>.<span class="variable">body</span>,
 631 |             <span class="variable">requestTimeout</span> = <span class="variable">req</span>.<span class="variable">timeout</span> || <span class="number integer">0</span>,
 632 |             <span class="variable">encoding</span> = <span class="variable">req</span>.<span class="variable">encoding</span> || <span class="string">'utf8'</span>;
 633 | 
 634 |         <span class="keyword">var</span> <span class="variable">request</span> = <span class="variable">http</span>.<span class="variable">request</span>({
 635 |             <span class="variable">host</span>: <span class="string">'127.0.0.1'</span>,
 636 |             <span class="variable">port</span>: <span class="variable">server</span>.<span class="variable">__port</span>,
 637 |             <span class="variable">path</span>: <span class="variable">req</span>.<span class="variable">url</span>,
 638 |             <span class="variable">method</span>: <span class="variable">method</span>,
 639 |             <span class="variable">headers</span>: <span class="variable">req</span>.<span class="variable">headers</span>
 640 |         });
 641 | 
 642 |         <span class="keyword">var</span> <span class="variable">check</span> = <span class="keyword">function</span>() {
 643 |             <span class="keyword">if</span> (--<span class="variable">server</span>.<span class="variable">__pending</span> === <span class="number integer">0</span>) {
 644 |                 <span class="variable">server</span>.<span class="variable">close</span>();
 645 |                 <span class="variable">server</span>.<span class="variable">__listening</span> = <span class="variable">false</span>;
 646 |             }
 647 |         };
 648 | 
 649 |         <span class="comment">// Timeout</span>
 650 |         <span class="keyword">if</span> (<span class="variable">requestTimeout</span>) {
 651 |             <span class="variable">timer</span> = <span class="variable">setTimeout</span>(<span class="keyword">function</span>() {
 652 |                 <span class="variable">check</span>();
 653 |                 <span class="keyword">delete</span> <span class="variable">req</span>.<span class="variable">timeout</span>;
 654 |                 <span class="variable">test</span>.<span class="variable">failure</span>(<span class="keyword">new</span> <span class="class">Error</span>(<span class="variable">msg</span> + <span class="string">'Request timed out after '</span> + <span class="variable">requestTimeout</span> + <span class="string">'ms.'</span>));
 655 |             }, <span class="variable">requestTimeout</span>);
 656 |         }
 657 | 
 658 |         <span class="keyword">if</span> (<span class="variable">data</span>) <span class="variable">request</span>.<span class="variable">write</span>(<span class="variable">data</span>);
 659 | 
 660 |         <span class="variable">request</span>.<span class="variable">on</span>(<span class="string">'response'</span>, <span class="keyword">function</span>(<span class="variable">response</span>) {
 661 |             <span class="variable">response</span>.<span class="variable">body</span> = <span class="string">''</span>;
 662 |             <span class="variable">response</span>.<span class="variable">setEncoding</span>(<span class="variable">encoding</span>);
 663 |             <span class="variable">response</span>.<span class="variable">on</span>(<span class="string">'data'</span>, <span class="keyword">function</span>(<span class="variable">chunk</span>) { <span class="variable">response</span>.<span class="variable">body</span> += <span class="variable">chunk</span>; });
 664 |             <span class="variable">response</span>.<span class="variable">on</span>(<span class="string">'end'</span>, <span class="keyword">function</span>() {
 665 |                 <span class="keyword">if</span> (<span class="variable">timer</span>) <span class="variable">clearTimeout</span>(<span class="variable">timer</span>);
 666 |                 <span class="keyword">try</span> {
 667 |                     <span class="comment">// Assert response body</span>
 668 |                     <span class="keyword">if</span> (<span class="variable">res</span>.<span class="variable">body</span> !== <span class="variable">undefined</span>) {
 669 |                         <span class="keyword">var</span> <span class="variable">eql</span> = <span class="variable">res</span>.<span class="variable">body</span> <span class="variable">instanceof</span> <span class="class">RegExp</span>
 670 |                           ? <span class="variable">res</span>.<span class="variable">body</span>.<span class="variable">test</span>(<span class="variable">response</span>.<span class="variable">body</span>)
 671 |                           : <span class="variable">res</span>.<span class="variable">body</span> === <span class="variable">response</span>.<span class="variable">body</span>;
 672 |                         <span class="variable">assert</span>.<span class="variable">ok</span>(
 673 |                             <span class="variable">eql</span>,
 674 |                             <span class="variable">msg</span> + <span class="string">'Invalid response body.\n'</span>
 675 |                                 + <span class="string">'    Expected: '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">res</span>.<span class="variable">body</span>) + <span class="string">'\n'</span>
 676 |                                 + <span class="string">'    Got: '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">response</span>.<span class="variable">body</span>)
 677 |                         );
 678 |                     }
 679 | 
 680 |                     <span class="comment">// Assert response status</span>
 681 |                     <span class="keyword">if</span> (<span class="keyword">typeof</span> <span class="variable">status</span> === <span class="string">'number'</span>) {
 682 |                         <span class="variable">assert</span>.<span class="variable">equal</span>(
 683 |                             <span class="variable">response</span>.<span class="variable">statusCode</span>,
 684 |                             <span class="variable">status</span>,
 685 |                             <span class="variable">msg</span> + <span class="variable">colorize</span>(<span class="string">'Invalid response status code.\n'</span>
 686 |                                 + <span class="string">'    Expected: [green]{'</span> + <span class="variable">status</span> + <span class="string">'}\n'</span>
 687 |                                 + <span class="string">'    Got: [red]{'</span> + <span class="variable">response</span>.<span class="variable">statusCode</span> + <span class="string">'}'</span>)
 688 |                         );
 689 |                     }
 690 | 
 691 |                     <span class="comment">// Assert response headers</span>
 692 |                     <span class="keyword">if</span> (<span class="variable">res</span>.<span class="variable">headers</span>) {
 693 |                         <span class="keyword">var</span> <span class="variable">keys</span> = <span class="class">Object</span>.<span class="variable">keys</span>(<span class="variable">res</span>.<span class="variable">headers</span>);
 694 |                         <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">i</span> = <span class="number integer">0</span>, <span class="variable">len</span> = <span class="variable">keys</span>.<span class="variable">length</span>; <span class="variable">i</span> &<span class="variable">lt</span>; <span class="variable">len</span>; ++<span class="variable">i</span>) {
 695 |                             <span class="keyword">var</span> <span class="variable">name</span> = <span class="variable">keys</span>[<span class="variable">i</span>],
 696 |                                 <span class="variable">actual</span> = <span class="variable">response</span>.<span class="variable">headers</span>[<span class="variable">name</span>.<span class="variable">toLowerCase</span>()],
 697 |                                 <span class="variable">expected</span> = <span class="variable">res</span>.<span class="variable">headers</span>[<span class="variable">name</span>],
 698 |                                 <span class="variable">eql</span> = <span class="variable">expected</span> <span class="variable">instanceof</span> <span class="class">RegExp</span>
 699 |                                   ? <span class="variable">expected</span>.<span class="variable">test</span>(<span class="variable">actual</span>)
 700 |                                   : <span class="variable">expected</span> == <span class="variable">actual</span>;
 701 |                             <span class="variable">assert</span>.<span class="variable">ok</span>(
 702 |                                 <span class="variable">eql</span>,
 703 |                                 <span class="variable">msg</span> + <span class="variable">colorize</span>(<span class="string">'Invalid response header [bold]{'</span> + <span class="variable">name</span> + <span class="string">'}.\n'</span>
 704 |                                     + <span class="string">'    Expected: [green]{'</span> + <span class="variable">expected</span> + <span class="string">'}\n'</span>
 705 |                                     + <span class="string">'    Got: [red]{'</span> + <span class="variable">actual</span> + <span class="string">'}'</span>)
 706 |                             );
 707 |                         }
 708 |                     }
 709 | 
 710 |                     <span class="comment">// Callback</span>
 711 |                     <span class="variable">callback</span>(<span class="variable">response</span>);
 712 | 
 713 |                     <span class="comment">// Add this to the succeeded bin.</span>
 714 |                     <span class="variable">test</span>.<span class="variable">success</span>(<span class="variable">msg</span>);
 715 |                 } <span class="keyword">catch</span> (<span class="variable">err</span>) {
 716 |                     <span class="variable">test</span>.<span class="variable">failure</span>(<span class="variable">err</span>);
 717 |                     <span class="variable">test</span>.<span class="variable">callback</span>();
 718 |                 } <span class="keyword">finally</span> {
 719 |                     <span class="comment">// Remove our token.</span>
 720 |                     <span class="keyword">var</span> <span class="variable">idx</span> = <span class="variable">test</span>.<span class="variable">_pending</span>.<span class="variable">indexOf</span>(<span class="variable">token</span>);
 721 |                     <span class="keyword">if</span> (<span class="variable">idx</span> &<span class="variable">gt</span>;= <span class="number integer">0</span>) {
 722 |                         <span class="variable">test</span>.<span class="variable">_pending</span>.<span class="variable">splice</span>(<span class="variable">idx</span>, <span class="number integer">1</span>);
 723 |                     } <span class="keyword">else</span> {
 724 |                         <span class="comment">// Someone else took our token. This is an error.</span>
 725 |                         <span class="variable">test</span>.<span class="variable">failure</span>(<span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'Request succeeded, but token vanished: '</span> + <span class="variable">msg</span>));
 726 |                     }
 727 | 
 728 |                     <span class="comment">// Potentially shut down the server.</span>
 729 |                     <span class="variable">check</span>();
 730 |                 }
 731 |             });
 732 |         });
 733 | 
 734 |         <span class="variable">request</span>.<span class="variable">end</span>();
 735 |       }
 736 | };</code></pre>
 737 | </td>
 738 | </tr>
 739 | <tr class="code">
 740 | <td class="docs">
 741 | <p>Pad the given string to the maximum width provided.</p>
 742 | 
 743 | <h2></h2>
 744 | 
 745 | <ul><li><p><strong>param</strong>: <em>String</em>  str</p></li><li><p><strong>param</strong>: <em>Number</em>  width</p></li><li><p><strong>return</strong>: <em>String</em> </p></li></ul>
 746 | </td>
 747 | <td class="code">
 748 | <pre><code><span class="keyword">function</span> <span class="variable">lpad</span>(<span class="variable">str</span>, <span class="variable">width</span>) {
 749 |     <span class="variable">str</span> = <span class="class">String</span>(<span class="variable">str</span>);
 750 |     <span class="keyword">var</span> <span class="variable">n</span> = <span class="variable">width</span> - <span class="variable">str</span>.<span class="variable">length</span>;
 751 |     <span class="keyword">if</span> (<span class="variable">n</span> &<span class="variable">lt</span>; <span class="number integer">1</span>) <span class="keyword">return</span> <span class="variable">str</span>;
 752 |     <span class="keyword">while</span> (<span class="variable">n</span>--) <span class="variable">str</span> = <span class="string">' '</span> + <span class="variable">str</span>;
 753 |     <span class="keyword">return</span> <span class="variable">str</span>;
 754 | }</code></pre>
 755 | </td>
 756 | </tr>
 757 | <tr class="code">
 758 | <td class="docs">
 759 | <p>Pad the given string to the maximum width provided.</p>
 760 | 
 761 | <h2></h2>
 762 | 
 763 | <ul><li><p><strong>param</strong>: <em>String</em>  str</p></li><li><p><strong>param</strong>: <em>Number</em>  width</p></li><li><p><strong>return</strong>: <em>String</em> </p></li></ul>
 764 | </td>
 765 | <td class="code">
 766 | <pre><code><span class="keyword">function</span> <span class="variable">rpad</span>(<span class="variable">str</span>, <span class="variable">width</span>) {
 767 |     <span class="variable">str</span> = <span class="class">String</span>(<span class="variable">str</span>);
 768 |     <span class="keyword">var</span> <span class="variable">n</span> = <span class="variable">width</span> - <span class="variable">str</span>.<span class="variable">length</span>;
 769 |     <span class="keyword">if</span> (<span class="variable">n</span> &<span class="variable">lt</span>; <span class="number integer">1</span>) <span class="keyword">return</span> <span class="variable">str</span>;
 770 |     <span class="keyword">while</span> (<span class="variable">n</span>--) <span class="variable">str</span> = <span class="variable">str</span> + <span class="string">' '</span>;
 771 |     <span class="keyword">return</span> <span class="variable">str</span>;
 772 | }</code></pre>
 773 | </td>
 774 | </tr>
 775 | <tr class="code">
 776 | <td class="docs">
 777 | <p>Report test coverage in tabular format</p>
 778 | 
 779 | <h2></h2>
 780 | 
 781 | <ul><li><p><strong>param</strong>: <em>Object</em>  cov</p></li></ul>
 782 | </td>
 783 | <td class="code">
 784 | <pre><code><span class="keyword">function</span> <span class="variable">reportCoverageTable</span>(<span class="variable">cov</span>) {
 785 |     <span class="comment">// Stats</span>
 786 |     <span class="variable">print</span>(<span class="string">'\n   [bold]{Test Coverage}\n'</span>);
 787 |     <span class="keyword">var</span> <span class="variable">sep</span> = <span class="string">'   +------------------------------------------+----------+------+------+--------+'</span>,
 788 |         <span class="variable">lastSep</span> = <span class="string">'                                              +----------+------+------+--------+'</span>;
 789 |     <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">sep</span>);
 790 |     <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="string">'   | filename                                 | coverage | LOC  | SLOC | missed |'</span>);
 791 |     <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">sep</span>);
 792 |     <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">name</span> <span class="keyword">in</span> <span class="variable">cov</span>) {
 793 |         <span class="keyword">var</span> <span class="variable">file</span> = <span class="variable">cov</span>[<span class="variable">name</span>];
 794 |         <span class="keyword">if</span> (<span class="class">Array</span>.<span class="variable">isArray</span>(<span class="variable">file</span>)) {
 795 |             <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'   | '</span> + <span class="variable">rpad</span>(<span class="variable">name</span>, <span class="number integer">40</span>));
 796 |             <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="variable">coverage</span>.<span class="variable">toFixed</span>(<span class="number integer">2</span>), <span class="number integer">8</span>));
 797 |             <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="class">LOC</span>, <span class="number integer">4</span>));
 798 |             <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="class">SLOC</span>, <span class="number integer">4</span>));
 799 |             <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="variable">totalMisses</span>, <span class="number integer">6</span>));
 800 |             <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' |\n'</span>);
 801 |         }
 802 |     }
 803 |     <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">sep</span>);
 804 |     <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'     '</span> + <span class="variable">rpad</span>(<span class="string">''</span>, <span class="number integer">40</span>));
 805 |     <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="variable">coverage</span>.<span class="variable">toFixed</span>(<span class="number integer">2</span>), <span class="number integer">8</span>));
 806 |     <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="class">LOC</span>, <span class="number integer">4</span>));
 807 |     <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="class">SLOC</span>, <span class="number integer">4</span>));
 808 |     <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="variable">totalMisses</span>, <span class="number integer">6</span>));
 809 |     <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' |\n'</span>);
 810 |     <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">lastSep</span>);
 811 |     <span class="comment">// Source</span>
 812 |     <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">name</span> <span class="keyword">in</span> <span class="variable">cov</span>) {
 813 |         <span class="keyword">if</span> (<span class="variable">name</span>.<span class="variable">match</span>(<span class="variable">file_matcher</span>)) {
 814 |             <span class="keyword">var</span> <span class="variable">file</span> = <span class="variable">cov</span>[<span class="variable">name</span>];
 815 |             <span class="keyword">if</span> ((<span class="variable">file</span>.<span class="variable">coverage</span> &<span class="variable">lt</span>; <span class="number integer">100</span>) || !<span class="variable">quiet</span>) {
 816 |                <span class="variable">print</span>(<span class="string">'\n   [bold]{'</span> + <span class="variable">name</span> + <span class="string">'}:'</span>);
 817 |                <span class="variable">print</span>(<span class="variable">file</span>.<span class="variable">source</span>);
 818 |                <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'\n'</span>);
 819 |             }
 820 |         }
 821 |     }
 822 | }</code></pre>
 823 | </td>
 824 | </tr>
 825 | <tr class="code">
 826 | <td class="docs">
 827 | <p>Report test coverage in raw json format</p>
 828 | 
 829 | <h2></h2>
 830 | 
 831 | <ul><li><p><strong>param</strong>: <em>Object</em>  cov</p></li></ul>
 832 | </td>
 833 | <td class="code">
 834 | <pre><code><span class="keyword">function</span> <span class="variable">reportCoverageJson</span>(<span class="variable">cov</span>) {
 835 |     <span class="keyword">var</span> <span class="variable">report</span> = {
 836 |         &<span class="variable">quot</span>;<span class="variable">coverage</span>&<span class="variable">quot</span>; : <span class="variable">cov</span>.<span class="variable">coverage</span>.<span class="variable">toFixed</span>(<span class="number integer">2</span>),
 837 |         &<span class="variable">quot</span>;<span class="class">LOC</span>&<span class="variable">quot</span>; : <span class="variable">cov</span>.<span class="class">LOC</span>,
 838 |         &<span class="variable">quot</span>;<span class="class">SLOC</span>&<span class="variable">quot</span>; : <span class="variable">cov</span>.<span class="class">SLOC</span>,
 839 |         &<span class="variable">quot</span>;<span class="variable">totalMisses</span>&<span class="variable">quot</span>; : <span class="variable">cov</span>.<span class="variable">totalMisses</span>,
 840 |         &<span class="variable">quot</span>;<span class="variable">files</span>&<span class="variable">quot</span>; : {}
 841 |     };
 842 | 
 843 |     <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">name</span> <span class="keyword">in</span> <span class="variable">cov</span>) {
 844 |         <span class="keyword">var</span> <span class="variable">file</span> = <span class="variable">cov</span>[<span class="variable">name</span>];
 845 |         <span class="keyword">if</span> (<span class="class">Array</span>.<span class="variable">isArray</span>(<span class="variable">file</span>)) {
 846 |             <span class="variable">report</span>.<span class="variable">files</span>[<span class="variable">name</span>] = {
 847 |                 &<span class="variable">quot</span>;<span class="variable">coverage</span>&<span class="variable">quot</span>; : <span class="variable">file</span>.<span class="variable">coverage</span>.<span class="variable">toFixed</span>(<span class="number integer">2</span>),
 848 |                 &<span class="variable">quot</span>;<span class="class">LOC</span>&<span class="variable">quot</span>; : <span class="variable">file</span>.<span class="class">LOC</span>,
 849 |                 &<span class="variable">quot</span>;<span class="class">SLOC</span>&<span class="variable">quot</span>; : <span class="variable">file</span>.<span class="class">SLOC</span>,
 850 |                 &<span class="variable">quot</span>;<span class="variable">totalMisses</span>&<span class="variable">quot</span>; : <span class="variable">file</span>.<span class="variable">totalMisses</span>
 851 |             };
 852 |         }
 853 |     }
 854 | 
 855 |     <span class="variable">fs</span>.<span class="variable">writeFileSync</span>(<span class="variable">jsonFile</span>, <span class="class">JSON</span>.<span class="variable">stringify</span>(<span class="variable">report</span>), &<span class="variable">quot</span>;<span class="variable">utf8</span>&<span class="variable">quot</span>;);
 856 | }</code></pre>
 857 | </td>
 858 | </tr>
 859 | <tr class="code">
 860 | <td class="docs">
 861 | <p>Populate code coverage data.</p>
 862 | 
 863 | <h2></h2>
 864 | 
 865 | <ul><li><p><strong>param</strong>: <em>Object</em>  cov</p></li></ul>
 866 | </td>
 867 | <td class="code">
 868 | <pre><code><span class="keyword">function</span> <span class="variable">populateCoverage</span>(<span class="variable">cov</span>) {
 869 |     <span class="variable">cov</span>.<span class="class">LOC</span> =
 870 |     <span class="variable">cov</span>.<span class="class">SLOC</span> =
 871 |     <span class="variable">cov</span>.<span class="variable">totalFiles</span> =
 872 |     <span class="variable">cov</span>.<span class="variable">totalHits</span> =
 873 |     <span class="variable">cov</span>.<span class="variable">totalMisses</span> =
 874 |     <span class="variable">cov</span>.<span class="variable">coverage</span> = <span class="number integer">0</span>;
 875 |     <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">name</span> <span class="keyword">in</span> <span class="variable">cov</span>) {
 876 |         <span class="keyword">var</span> <span class="variable">file</span> = <span class="variable">cov</span>[<span class="variable">name</span>];
 877 |         <span class="keyword">if</span> (<span class="class">Array</span>.<span class="variable">isArray</span>(<span class="variable">file</span>)) {
 878 |             <span class="comment">// Stats</span>
 879 |             ++<span class="variable">cov</span>.<span class="variable">totalFiles</span>;
 880 |             <span class="variable">cov</span>.<span class="variable">totalHits</span> += <span class="variable">file</span>.<span class="variable">totalHits</span> = <span class="variable">coverage</span>(<span class="variable">file</span>, <span class="variable">true</span>);
 881 |             <span class="variable">cov</span>.<span class="variable">totalMisses</span> += <span class="variable">file</span>.<span class="variable">totalMisses</span> = <span class="variable">coverage</span>(<span class="variable">file</span>, <span class="variable">false</span>);
 882 |             <span class="variable">file</span>.<span class="variable">totalLines</span> = <span class="variable">file</span>.<span class="variable">totalHits</span> + <span class="variable">file</span>.<span class="variable">totalMisses</span>;
 883 |             <span class="variable">cov</span>.<span class="class">SLOC</span> += <span class="variable">file</span>.<span class="class">SLOC</span> = <span class="variable">file</span>.<span class="variable">totalLines</span>;
 884 |             <span class="keyword">if</span> (!<span class="variable">file</span>.<span class="variable">source</span>) <span class="variable">file</span>.<span class="variable">source</span> = [];
 885 |             <span class="variable">cov</span>.<span class="class">LOC</span> += <span class="variable">file</span>.<span class="class">LOC</span> = <span class="variable">file</span>.<span class="variable">source</span>.<span class="variable">length</span>;
 886 |             <span class="variable">file</span>.<span class="variable">coverage</span> = (<span class="variable">file</span>.<span class="variable">totalHits</span> / <span class="variable">file</span>.<span class="variable">totalLines</span>) * <span class="number integer">100</span>;
 887 |             <span class="comment">// Source</span>
 888 |             <span class="keyword">var</span> <span class="variable">width</span> = <span class="variable">file</span>.<span class="variable">source</span>.<span class="variable">length</span>.<span class="variable">toString</span>().<span class="variable">length</span>;
 889 |             <span class="variable">file</span>.<span class="variable">source</span> = <span class="variable">file</span>.<span class="variable">source</span>.<span class="variable">map</span>(<span class="keyword">function</span>(<span class="variable">line</span>, <span class="variable">i</span>) {
 890 |                 ++<span class="variable">i</span>;
 891 |                 <span class="keyword">var</span> <span class="variable">hits</span> = <span class="variable">file</span>[<span class="variable">i</span>] === <span class="number integer">0</span> ? <span class="number integer">0</span> : (<span class="variable">file</span>[<span class="variable">i</span>] || <span class="string">' '</span>);
 892 |                 <span class="keyword">if</span> (!<span class="variable">boring</span>) {
 893 |                     <span class="keyword">if</span> (<span class="variable">hits</span> === <span class="number integer">0</span>) {
 894 |                         <span class="variable">hits</span> = <span class="string">'\x1b[31m'</span> + <span class="variable">hits</span> + <span class="string">'\x1b[0m'</span>;
 895 |                         <span class="variable">line</span> = <span class="string">'\x1b[41m'</span> + <span class="variable">line</span> + <span class="string">'\x1b[0m'</span>;
 896 |                     } <span class="keyword">else</span> {
 897 |                         <span class="variable">hits</span> = <span class="string">'\x1b[32m'</span> + <span class="variable">hits</span> + <span class="string">'\x1b[0m'</span>;
 898 |                     }
 899 |                 }
 900 |                 <span class="keyword">return</span> <span class="string">'\n     '</span> + <span class="variable">lpad</span>(<span class="variable">i</span>, <span class="variable">width</span>) + <span class="string">' | '</span> + <span class="variable">hits</span> + <span class="string">' | '</span> + <span class="variable">line</span>;
 901 |             }).<span class="variable">join</span>(<span class="string">''</span>);
 902 |         }
 903 |     }
 904 |     <span class="variable">cov</span>.<span class="variable">coverage</span> = (<span class="variable">cov</span>.<span class="variable">totalHits</span> / <span class="variable">cov</span>.<span class="class">SLOC</span>) * <span class="number integer">100</span>;
 905 | }</code></pre>
 906 | </td>
 907 | </tr>
 908 | <tr class="code">
 909 | <td class="docs">
 910 | <p>Total coverage for the given file data.</p>
 911 | 
 912 | <h2></h2>
 913 | 
 914 | <ul><li><p><strong>param</strong>: <em>Array</em>  data</p></li><li><p><strong>return</strong>: <em>Type</em> </p></li></ul>
 915 | </td>
 916 | <td class="code">
 917 | <pre><code><span class="keyword">function</span> <span class="variable">coverage</span>(<span class="variable">data</span>, <span class="variable">val</span>) {
 918 |     <span class="keyword">var</span> <span class="variable">n</span> = <span class="number integer">0</span>;
 919 |     <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">i</span> = <span class="number integer">0</span>, <span class="variable">len</span> = <span class="variable">data</span>.<span class="variable">length</span>; <span class="variable">i</span> &<span class="variable">lt</span>; <span class="variable">len</span>; ++<span class="variable">i</span>) {
 920 |         <span class="keyword">if</span> (<span class="variable">data</span>[<span class="variable">i</span>] !== <span class="variable">undefined</span> &<span class="variable">amp</span>;&<span class="variable">amp</span>; <span class="variable">data</span>[<span class="variable">i</span>] == <span class="variable">val</span>) ++<span class="variable">n</span>;
 921 |     }
 922 |     <span class="keyword">return</span> <span class="variable">n</span>;
 923 | }</code></pre>
 924 | </td>
 925 | </tr>
 926 | <tr class="code">
 927 | <td class="docs">
 928 | <p>Test if all files have 100% coverage</p>
 929 | 
 930 | <h2></h2>
 931 | 
 932 | <ul><li><p><strong>param</strong>: <em>Object</em>  cov</p></li><li><p><strong>return</strong>: <em>Boolean</em> </p></li></ul>
 933 | </td>
 934 | <td class="code">
 935 | <pre><code><span class="keyword">function</span> <span class="variable">hasFullCoverage</span>(<span class="variable">cov</span>) {
 936 |   <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">name</span> <span class="keyword">in</span> <span class="variable">cov</span>) {
 937 |     <span class="keyword">var</span> <span class="variable">file</span> = <span class="variable">cov</span>[<span class="variable">name</span>];
 938 |     <span class="keyword">if</span> (<span class="variable">file</span> <span class="variable">instanceof</span> <span class="class">Array</span>) {
 939 |       <span class="keyword">if</span> (<span class="variable">file</span>.<span class="variable">coverage</span> !== <span class="number integer">100</span>) {
 940 |           <span class="keyword">return</span> <span class="variable">false</span>;
 941 |       }
 942 |     }
 943 |   }
 944 |   <span class="keyword">return</span> <span class="variable">true</span>;
 945 | }</code></pre>
 946 | </td>
 947 | </tr>
 948 | <tr class="code">
 949 | <td class="docs">
 950 | <p>Run the given test <code>files</code>, or try <em>test/*</em>.</p>
 951 | 
 952 | <h2></h2>
 953 | 
 954 | <ul><li><p><strong>param</strong>: <em>Array</em>  files</p></li></ul>
 955 | </td>
 956 | <td class="code">
 957 | <pre><code><span class="keyword">function</span> <span class="variable">run</span>(<span class="variable">files</span>) {
 958 |     <span class="variable">cursor</span>(<span class="variable">false</span>);
 959 |     <span class="keyword">if</span> (!<span class="variable">files</span>.<span class="variable">length</span>) {
 960 |         <span class="keyword">try</span> {
 961 |             <span class="variable">files</span> = <span class="variable">fs</span>.<span class="variable">readdirSync</span>(<span class="string">'test'</span>).<span class="variable">map</span>(<span class="keyword">function</span>(<span class="variable">file</span>) {
 962 |                 <span class="keyword">return</span> <span class="string">'test/'</span> + <span class="variable">file</span>;
 963 |             }).<span class="variable">filter</span>(<span class="keyword">function</span>(<span class="variable">file</span>) {
 964 |                 <span class="keyword">return</span> !(<span class="regexp">/(^\.)|(\/</span>\.)/.<span class="variable">test</span>(<span class="variable">file</span>));
 965 |             });
 966 |         } <span class="keyword">catch</span> (<span class="variable">err</span>) {
 967 |             <span class="variable">print</span>(<span class="string">'\n  failed to load tests in [bold]{./test}\n'</span>);
 968 |             ++<span class="variable">failures</span>;
 969 |             <span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
 970 |         }
 971 |     }
 972 |     <span class="variable">runFiles</span>(<span class="variable">files</span>);
 973 | }</code></pre>
 974 | </td>
 975 | </tr>
 976 | <tr class="code">
 977 | <td class="docs">
 978 | <p>Show the cursor when <code>show</code> is true, otherwise hide it.</p>
 979 | 
 980 | <h2></h2>
 981 | 
 982 | <ul><li><p><strong>param</strong>: <em>Boolean</em>  show</p></li></ul>
 983 | </td>
 984 | <td class="code">
 985 | <pre><code><span class="keyword">function</span> <span class="variable">cursor</span>(<span class="variable">show</span>) {
 986 |     <span class="keyword">if</span> (<span class="variable">boring</span>) <span class="keyword">return</span>;
 987 |     <span class="keyword">if</span> (<span class="variable">show</span>) {
 988 |         <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'\x1b[?25h'</span>);
 989 |     } <span class="keyword">else</span> {
 990 |         <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'\x1b[?25l'</span>);
 991 |     }
 992 | }</code></pre>
 993 | </td>
 994 | </tr>
 995 | <tr class="code">
 996 | <td class="docs">
 997 | <p>Run the given test <code>files</code>.</p>
 998 | 
 999 | <h2></h2>
1000 | 
1001 | <ul><li><p><strong>param</strong>: <em>Array</em>  files</p></li></ul>
1002 | </td>
1003 | <td class="code">
1004 | <pre><code><span class="keyword">function</span> <span class="variable">runFiles</span>(<span class="variable">files</span>) {
1005 |     <span class="variable">files</span> = <span class="variable">files</span>.<span class="variable">filter</span>(<span class="keyword">function</span>(<span class="variable">file</span>) {
1006 |         <span class="keyword">return</span> <span class="variable">file</span>.<span class="variable">match</span>(<span class="variable">file_matcher</span>);
1007 |     });
1008 |     <span class="variable">suites</span> = <span class="variable">files</span>.<span class="variable">length</span>;
1009 | 
1010 |     <span class="keyword">if</span> (<span class="variable">serial</span>) {
1011 |         (<span class="keyword">function</span> <span class="variable">next</span>() {
1012 |             <span class="keyword">if</span> (<span class="variable">files</span>.<span class="variable">length</span>) {
1013 |                 <span class="variable">runFile</span>(<span class="variable">files</span>.<span class="variable">shift</span>(), <span class="variable">next</span>);
1014 |             }
1015 |         })();
1016 |     } <span class="keyword">else</span> {
1017 |         <span class="variable">files</span>.<span class="variable">forEach</span>(<span class="variable">runFile</span>);
1018 |     }
1019 | }</code></pre>
1020 | </td>
1021 | </tr>
1022 | <tr class="code">
1023 | <td class="docs">
1024 | <p>Run tests for the given <code>file</code>, callback <code>fn()</code> when finished.</p>
1025 | 
1026 | <h2></h2>
1027 | 
1028 | <ul><li><p><strong>param</strong>: <em>String</em>  file</p></li><li><p><strong>param</strong>: <em>Function</em>  fn</p></li></ul>
1029 | </td>
1030 | <td class="code">
1031 | <pre><code><span class="keyword">function</span> <span class="variable">runFile</span>(<span class="variable">file</span>, <span class="variable">fn</span>) {
1032 |     <span class="keyword">var</span> <span class="variable">title</span> = <span class="variable">path</span>.<span class="variable">basename</span>(<span class="variable">file</span>),
1033 |         <span class="variable">file</span> = <span class="variable">path</span>.<span class="variable">join</span>(<span class="variable">cwd</span>, <span class="variable">file</span>),
1034 |         <span class="variable">mod</span> = <span class="variable">require</span>(<span class="variable">file</span>.<span class="variable">replace</span>(<span class="variable">file_matcher</span>,<span class="string">''</span>));
1035 |     (<span class="keyword">function</span> <span class="variable">check</span>() {
1036 |        <span class="keyword">var</span> <span class="variable">len</span> = <span class="class">Object</span>.<span class="variable">keys</span>(<span class="variable">mod</span>).<span class="variable">length</span>;
1037 |        <span class="keyword">if</span> (<span class="variable">len</span>) {
1038 |            <span class="variable">runSuite</span>(<span class="variable">title</span>, <span class="variable">mod</span>, <span class="variable">fn</span>);
1039 |            <span class="variable">suitesRun</span>++;
1040 |        } <span class="keyword">else</span> {
1041 |            <span class="variable">setTimeout</span>(<span class="variable">check</span>, <span class="number integer">20</span>);
1042 |        }
1043 |     })();
1044 | }</code></pre>
1045 | </td>
1046 | </tr>
1047 | <tr class="code">
1048 | <td class="docs">
1049 | <p>Run the given tests, callback <code>fn()</code> when finished.</p>
1050 | 
1051 | <h2></h2>
1052 | 
1053 | <ul><li><p><strong>param</strong>: <em>String</em>  title</p></li><li><p><strong>param</strong>: <em>Object</em>  tests</p></li><li><p><strong>param</strong>: <em>Function</em>  fn</p></li></ul>
1054 | </td>
1055 | <td class="code">
1056 | <pre><code><span class="keyword">var</span> <span class="variable">dots</span> = <span class="number integer">0</span>;
1057 | <span class="keyword">function</span> <span class="variable">runSuite</span>(<span class="variable">title</span>, <span class="variable">tests</span>, <span class="variable">callback</span>) {
1058 |     <span class="comment">// Keys</span>
1059 |     <span class="keyword">var</span> <span class="variable">keys</span> = <span class="variable">only</span>.<span class="variable">length</span>
1060 |         ? <span class="variable">only</span>.<span class="variable">slice</span>(<span class="number integer">0</span>)
1061 |         : <span class="class">Object</span>.<span class="variable">keys</span>(<span class="variable">tests</span>);
1062 | 
1063 |     <span class="comment">// Setup</span>
1064 |     <span class="keyword">var</span> <span class="variable">setup</span> = <span class="variable">tests</span>.<span class="variable">setup</span> || <span class="keyword">function</span>(<span class="variable">fn</span>, <span class="variable">assert</span>) { <span class="variable">fn</span>(); };
1065 |     <span class="keyword">var</span> <span class="variable">teardown</span> = <span class="variable">tests</span>.<span class="variable">teardown</span> || <span class="keyword">function</span>(<span class="variable">fn</span>, <span class="variable">assert</span>) { <span class="variable">fn</span>(); };
1066 | 
1067 |     <span class="variable">process</span>.<span class="variable">setMaxListeners</span>(<span class="number integer">10</span> + <span class="variable">process</span>.<span class="variable">listeners</span>(<span class="string">'beforeExit'</span>).<span class="variable">length</span>  + <span class="variable">keys</span>.<span class="variable">length</span>);
1068 | 
1069 |     <span class="comment">// Iterate tests</span>
1070 |     (<span class="keyword">function</span> <span class="variable">next</span>() {
1071 |         <span class="keyword">if</span> (<span class="variable">keys</span>.<span class="variable">length</span>) {
1072 |             <span class="keyword">var</span> <span class="variable">key</span>,
1073 |                 <span class="variable">fn</span> = <span class="variable">tests</span>[<span class="variable">key</span> = <span class="variable">keys</span>.<span class="variable">shift</span>()];
1074 |             <span class="comment">// Non-tests</span>
1075 |             <span class="keyword">if</span> (<span class="variable">key</span> === <span class="string">'setup'</span> || <span class="variable">key</span> === <span class="string">'teardown'</span>) <span class="keyword">return</span> <span class="variable">next</span>();
1076 | 
1077 |             <span class="comment">// Run test</span>
1078 |             <span class="keyword">if</span> (<span class="variable">fn</span>) {
1079 |                 <span class="keyword">var</span> <span class="variable">test</span> = <span class="keyword">new</span> <span class="class">Test</span>({
1080 |                     <span class="variable">fn</span>: <span class="variable">fn</span>,
1081 |                     <span class="variable">suite</span>: <span class="variable">title</span>,
1082 |                     <span class="variable">title</span>: <span class="variable">key</span>,
1083 |                     <span class="variable">setup</span>: <span class="variable">setup</span>,
1084 |                     <span class="variable">teardown</span>: <span class="variable">teardown</span>
1085 |                 })
1086 |                 <span class="variable">test</span>.<span class="variable">run</span>(<span class="variable">next</span>);
1087 |             } <span class="keyword">else</span> {
1088 |                 <span class="comment">// @TODO: Add warning message that there's no test.</span>
1089 |                 <span class="variable">next</span>();
1090 |             }
1091 |         } <span class="keyword">else</span> <span class="keyword">if</span> (<span class="variable">serial</span>) {
1092 |             <span class="variable">callback</span>();
1093 |         }
1094 |     })();
1095 | }
1096 | 
1097 | <span class="variable">require</span>(<span class="string">'util'</span>).<span class="variable">inherits</span>(<span class="class">Test</span>, <span class="variable">require</span>(<span class="string">'events'</span>).<span class="class">EventEmitter</span>);
1098 | <span class="keyword">function</span> <span class="class">Test</span>(<span class="variable">options</span>) {
1099 |     <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">key</span> <span class="keyword">in</span> <span class="variable">options</span>) {
1100 |         <span class="this">this</span>[<span class="variable">key</span>] = <span class="variable">options</span>[<span class="variable">key</span>];
1101 |     }
1102 |     <span class="this">this</span>.<span class="variable">_succeeded</span> = [];
1103 |     <span class="this">this</span>.<span class="variable">_failed</span> = [];
1104 |     <span class="this">this</span>.<span class="variable">_pending</span> = [];
1105 |     <span class="this">this</span>.<span class="variable">_beforeExit</span> = [];
1106 |     <span class="this">this</span>.<span class="variable">assert</span> = { <span class="variable">__proto__</span>: <span class="variable">assert</span>, <span class="variable">_test</span>: <span class="this">this</span> };
1107 | 
1108 |     <span class="keyword">var</span> <span class="variable">test</span> = <span class="this">this</span>;
1109 |     <span class="variable">process</span>.<span class="variable">on</span>(<span class="string">'beforeExit'</span>, <span class="keyword">function</span>() {
1110 |         <span class="keyword">try</span> {
1111 |             <span class="variable">test</span>.<span class="variable">emit</span>(<span class="string">'exit'</span>);
1112 |         } <span class="keyword">catch</span> (<span class="variable">err</span>) {
1113 |             <span class="variable">test</span>.<span class="variable">failure</span>(<span class="variable">err</span>);
1114 |         }
1115 |         <span class="variable">test</span>.<span class="variable">report</span>();
1116 |     });
1117 | }
1118 | 
1119 | <span class="class">Test</span>.<span class="variable">prototype</span>.<span class="variable">success</span> = <span class="keyword">function</span>(<span class="variable">err</span>) {
1120 |     <span class="this">this</span>.<span class="variable">_succeeded</span>.<span class="variable">push</span>(<span class="variable">err</span>);
1121 | };
1122 | 
1123 | <span class="class">Test</span>.<span class="variable">prototype</span>.<span class="variable">failure</span> = <span class="keyword">function</span>(<span class="variable">err</span>) {
1124 |     <span class="this">this</span>.<span class="variable">_failed</span>.<span class="variable">push</span>(<span class="variable">err</span>);
1125 |     <span class="this">this</span>.<span class="variable">error</span>(<span class="variable">err</span>);
1126 | };
1127 | 
1128 | <span class="class">Test</span>.<span class="variable">prototype</span>.<span class="variable">report</span> = <span class="keyword">function</span>() {
1129 |     <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">i</span> = <span class="number integer">0</span>; <span class="variable">i</span> &<span class="variable">lt</span>; <span class="this">this</span>.<span class="variable">_pending</span>.<span class="variable">length</span>; <span class="variable">i</span>++) {
1130 |         <span class="this">this</span>.<span class="variable">error</span>(<span class="this">this</span>.<span class="variable">_pending</span>[<span class="variable">i</span>]);
1131 |     }
1132 | };
1133 | 
1134 | <span class="class">Test</span>.<span class="variable">prototype</span>.<span class="variable">run</span> = <span class="keyword">function</span>(<span class="variable">callback</span>) {
1135 |     <span class="keyword">try</span> {
1136 |         ++<span class="variable">testcount</span>;
1137 |         <span class="variable">assert</span>.<span class="variable">_test</span> = <span class="this">this</span>;
1138 | 
1139 |         <span class="keyword">if</span> (<span class="variable">serial</span>) {
1140 |             <span class="this">this</span>.<span class="variable">runSerial</span>(<span class="variable">callback</span>);
1141 |         } <span class="keyword">else</span> {
1142 |             <span class="comment">// @TODO: find a way to run setup/tearDown.</span>
1143 |             <span class="this">this</span>.<span class="variable">runParallel</span>();
1144 |             <span class="variable">callback</span>();
1145 |         }
1146 |     } <span class="keyword">catch</span> (<span class="variable">err</span>) {
1147 |         <span class="this">this</span>.<span class="variable">failure</span>(<span class="variable">err</span>);
1148 |         <span class="this">this</span>.<span class="variable">report</span>();
1149 |     }
1150 | };
1151 | 
1152 | <span class="class">Test</span>.<span class="variable">prototype</span>.<span class="variable">runSerial</span> = <span class="keyword">function</span>(<span class="variable">callback</span>) {
1153 |     <span class="keyword">var</span> <span class="variable">test</span> = <span class="this">this</span>;
1154 |     <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'.'</span>);
1155 |     <span class="keyword">if</span> (++<span class="variable">dots</span> % <span class="number integer">25</span> === <span class="number integer">0</span>) <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'\n'</span>);
1156 |     <span class="variable">test</span>.<span class="variable">setup</span>(<span class="keyword">function</span>() {
1157 |         <span class="keyword">if</span> (<span class="variable">test</span>.<span class="variable">fn</span>.<span class="variable">length</span> &<span class="variable">lt</span>; <span class="number integer">1</span>) {
1158 |             <span class="variable">test</span>.<span class="variable">fn</span>();
1159 |             <span class="variable">test</span>.<span class="variable">teardown</span>(<span class="variable">callback</span>);
1160 |         } <span class="keyword">else</span> {
1161 |             <span class="keyword">var</span> <span class="variable">id</span> = <span class="variable">setTimeout</span>(<span class="keyword">function</span>() {
1162 |                 <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(&<span class="variable">quot</span>;<span class="string">'&quot; + key + &quot;'</span> <span class="variable">timed</span> <span class="variable">out</span>&<span class="variable">quot</span>;);
1163 |             }, <span class="variable">timeout</span>);
1164 |             <span class="variable">test</span>.<span class="variable">callback</span> = <span class="keyword">function</span>() {
1165 |                 <span class="variable">clearTimeout</span>(<span class="variable">id</span>);
1166 |                 <span class="variable">test</span>.<span class="variable">teardown</span>(<span class="variable">callback</span>);
1167 |                 <span class="variable">process</span>.<span class="variable">nextTick</span>(<span class="keyword">function</span>() {
1168 |                     <span class="variable">test</span>.<span class="variable">report</span>();
1169 |                 });
1170 |             };
1171 |             <span class="variable">test</span>.<span class="variable">fn</span>(<span class="variable">test</span>.<span class="variable">callback</span>);
1172 |         }
1173 |     });
1174 | };
1175 | 
1176 | <span class="class">Test</span>.<span class="variable">prototype</span>.<span class="variable">runParallel</span> = <span class="keyword">function</span>() {
1177 |     <span class="keyword">var</span> <span class="variable">test</span> = <span class="this">this</span>;
1178 |     <span class="variable">test</span>.<span class="variable">fn</span>(<span class="keyword">function</span>(<span class="variable">fn</span>) {
1179 |         <span class="variable">test</span>.<span class="variable">on</span>(<span class="string">'exit'</span>, <span class="keyword">function</span>() {
1180 |             <span class="variable">fn</span>(<span class="variable">test</span>.<span class="variable">assert</span>);
1181 |         });
1182 |     }, <span class="variable">test</span>.<span class="variable">assert</span>);
1183 | };</code></pre>
1184 | </td>
1185 | </tr>
1186 | <tr class="code">
1187 | <td class="docs">
1188 | <p>Report <code>err</code> for the given <code>test</code> and <code>suite</code>.</p>
1189 | 
1190 | <h2></h2>
1191 | 
1192 | <ul><li><p><strong>param</strong>: <em>String</em>  suite</p></li><li><p><strong>param</strong>: <em>String</em>  test</p></li><li><p><strong>param</strong>: <em>Error</em>  err</p></li></ul>
1193 | </td>
1194 | <td class="code">
1195 | <pre><code><span class="class">Test</span>.<span class="variable">prototype</span>.<span class="variable">error</span> = <span class="keyword">function</span>(<span class="variable">err</span>) {
1196 |     <span class="keyword">if</span> (!<span class="variable">err</span>.<span class="variable">_reported</span>) {
1197 |         ++<span class="variable">failures</span>;
1198 |         <span class="keyword">var</span> <span class="variable">name</span> = <span class="variable">err</span>.<span class="variable">name</span>,
1199 |             <span class="variable">stack</span> = <span class="variable">err</span>.<span class="variable">stack</span> ? <span class="variable">err</span>.<span class="variable">stack</span>.<span class="variable">replace</span>(<span class="variable">err</span>.<span class="variable">name</span>, <span class="string">''</span>) : <span class="string">''</span>,
1200 |             <span class="keyword">label</span> = <span class="this">this</span>.<span class="variable">title</span> === <span class="string">'uncaught'</span>
1201 |                 ? <span class="this">this</span>.<span class="variable">title</span>
1202 |                 : <span class="this">this</span>.<span class="variable">suite</span> + <span class="string">' '</span> + <span class="this">this</span>.<span class="variable">title</span>;
1203 |         <span class="variable">print</span>(<span class="string">'\n   [bold]{'</span> + <span class="keyword">label</span> + <span class="string">'}: [red]{'</span> + <span class="variable">name</span> + <span class="string">'}'</span> + <span class="variable">stack</span> + <span class="string">'\n'</span>);
1204 |         <span class="variable">err</span>.<span class="variable">_reported</span> = <span class="variable">true</span>;
1205 |     }
1206 | }</code></pre>
1207 | </td>
1208 | </tr>
1209 | <tr class="code">
1210 | <td class="docs">
1211 | <p>Report exceptions.
1212 |  </p>
1213 | </td>
1214 | <td class="code">
1215 | <pre><code><span class="keyword">function</span> <span class="variable">report</span>() {
1216 |     <span class="variable">cursor</span>(<span class="variable">true</span>);
1217 |     <span class="variable">process</span>.<span class="variable">emit</span>(<span class="string">'beforeExit'</span>);
1218 |     <span class="keyword">if</span> (<span class="variable">suitesRun</span> &<span class="variable">lt</span>; <span class="variable">suites</span>) {
1219 |         <span class="variable">print</span>(<span class="string">'\n   [bold]{Failure}: [red]{Only '</span> + <span class="variable">suitesRun</span> + <span class="string">' of '</span> + <span class="variable">suites</span> + <span class="string">' suites have been started}\n\n'</span>);
1220 |     }
1221 |     <span class="keyword">else</span> <span class="keyword">if</span> (<span class="variable">failures</span>) {
1222 |         <span class="variable">print</span>(<span class="string">'\n   [bold]{Failures}: [red]{'</span> + <span class="variable">failures</span> + <span class="string">'}\n\n'</span>);
1223 |         <span class="variable">notify</span>(<span class="string">'Failures: '</span> + <span class="variable">failures</span>);
1224 |     } <span class="keyword">else</span> {
1225 |         <span class="keyword">if</span> (<span class="variable">serial</span>) <span class="variable">print</span>(<span class="string">''</span>);
1226 |         <span class="variable">print</span>(<span class="string">'\n   [green]{100%} '</span> + <span class="variable">testcount</span> + <span class="string">' tests\n'</span>);
1227 |         <span class="variable">notify</span>(<span class="string">'100% ok'</span>);
1228 |     }
1229 |     <span class="keyword">if</span> (<span class="keyword">typeof</span> <span class="variable">_</span>$<span class="variable">jscoverage</span> === <span class="string">'object'</span>) {
1230 |         <span class="variable">populateCoverage</span>(<span class="variable">_</span>$<span class="variable">jscoverage</span>);
1231 |         <span class="keyword">if</span> (!<span class="variable">hasFullCoverage</span>(<span class="variable">_</span>$<span class="variable">jscoverage</span>) || !<span class="variable">quiet</span>) {
1232 |             (<span class="variable">jsonCoverage</span> ? <span class="variable">reportCoverageJson</span>(<span class="variable">_</span>$<span class="variable">jscoverage</span>) : <span class="variable">reportCoverageTable</span>(<span class="variable">_</span>$<span class="variable">jscoverage</span>));
1233 |         }
1234 |     }
1235 | }</code></pre>
1236 | </td>
1237 | </tr>
1238 | <tr class="code">
1239 | <td class="docs">
1240 | <p>Growl notify the given <code>msg</code>.</p>
1241 | 
1242 | <h2></h2>
1243 | 
1244 | <ul><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
1245 | </td>
1246 | <td class="code">
1247 | <pre><code><span class="keyword">function</span> <span class="variable">notify</span>(<span class="variable">msg</span>) {
1248 |     <span class="keyword">if</span> (<span class="variable">growl</span>) {
1249 |         <span class="variable">childProcess</span>.<span class="variable">exec</span>(<span class="string">'growlnotify -name Expresso -m &quot;'</span> + <span class="variable">msg</span> + <span class="string">'&quot;'</span>);
1250 |     }
1251 | }
1252 | 
1253 | <span class="comment">// Report uncaught exceptions</span>
1254 | <span class="keyword">var</span> <span class="variable">unknownTest</span> = <span class="keyword">new</span> <span class="class">Test</span>({
1255 |     <span class="variable">suite</span>: <span class="string">'uncaught'</span>,
1256 |     <span class="variable">test</span>: <span class="string">'uncaught'</span>
1257 | });
1258 | 
1259 | <span class="variable">process</span>.<span class="variable">on</span>(<span class="string">'uncaughtException'</span>, <span class="keyword">function</span>(<span class="variable">err</span>) {
1260 |     <span class="variable">unknownTest</span>.<span class="variable">error</span>(<span class="variable">err</span>);
1261 | });
1262 | 
1263 | <span class="comment">// Show cursor</span>
1264 | 
1265 | [<span class="string">'INT'</span>, <span class="string">'TERM'</span>, <span class="string">'QUIT'</span>].<span class="variable">forEach</span>(<span class="keyword">function</span>(<span class="variable">sig</span>) {
1266 |     <span class="variable">process</span>.<span class="variable">on</span>(<span class="string">'SIG'</span> + <span class="variable">sig</span>, <span class="keyword">function</span>() {
1267 |         <span class="variable">cursor</span>(<span class="variable">true</span>);
1268 |         <span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
1269 |     });
1270 | });
1271 | 
1272 | <span class="comment">// Report test coverage when available</span>
1273 | <span class="comment">// and emit &quot;beforeExit&quot; event to perform</span>
1274 | <span class="comment">// final assertions</span>
1275 | 
1276 | <span class="keyword">var</span> <span class="variable">orig</span> = <span class="variable">process</span>.<span class="variable">emit</span>;
1277 | <span class="variable">process</span>.<span class="variable">emit</span> = <span class="keyword">function</span>(<span class="variable">event</span>) {
1278 |     <span class="keyword">if</span> (<span class="variable">event</span> === <span class="string">'exit'</span>) {
1279 |         <span class="variable">report</span>();
1280 |         <span class="variable">process</span>.<span class="variable">reallyExit</span>(<span class="variable">failures</span>);
1281 |     }
1282 |     <span class="variable">orig</span>.<span class="variable">apply</span>(<span class="this">this</span>, <span class="variable">arguments</span>);
1283 | };
1284 | 
1285 | <span class="comment">// Run test files</span>
1286 | 
1287 | <span class="keyword">if</span> (!<span class="variable">defer</span>) <span class="variable">run</span>(<span class="variable">files</span>);
1288 | </code></pre>
1289 | </td>
1290 | </tr>	</body>
1291 | </html></tbody></table>


--------------------------------------------------------------------------------