vulcan 0.0.1 → 0.0.2

data/server/node_modules/connect-form/support/connect/test/vhost.test.js

@@ -0,0 +1,46 @@
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('connect'),
+    helpers = require('./helpers'),
+    assert = require('assert'),
+    http = require('http');
+
+module.exports = {
+    test: function(){
+        var server = helpers.run(
+            connect.vhost('foo.com', connect.createServer(
+                function(req, res){
+                    res.writeHead(200, {});
+                    res.end('from foo');
+                }
+            )),
+            connect.vhost('bar.com', connect.createServer(
+                function(req, res){
+                    res.writeHead(200, {});
+                    res.end('from bar');
+                }
+            ))
+        );
+
+        var req = server.request('GET', '/', { Host: 'foo.com' });
+        req.buffer = true;
+        req.addListener('response', function(res){
+            res.addListener('end', function(){
+                assert.equal('from foo', res.body);
+            });
+        });
+        req.end();
+
+        var req = server.request('GET', '/', { Host: 'bar.com' });
+        req.buffer = true;
+        req.addListener('response', function(res){
+            res.addListener('end', function(){
+                assert.equal('from bar', res.body);
+            });
+        });
+        req.end();
+    }
+}

data/server/node_modules/connect-form/support/expresso/History.md

@@ -0,0 +1,54 @@
+
+0.4.0 / 2010-07-09
+==================
+
+  * Added reporting source coverage (respects --boring for color haters)
+  * Added callback to assert.response(). Closes #12
+  * Fixed; putting exceptions to stderr. Closes #13
+
+0.3.1 / 2010-06-28
+==================
+
+  * Faster assert.response()
+
+0.3.0 / 2010-06-28
+==================
+
+  * Added -p, --port NUM flags
+  * Added assert.response(). Closes #11
+
+0.2.1 / 2010-06-25
+==================
+
+  * Fixed issue with reporting object assertions
+
+0.2.0 / 2010-06-21
+==================
+
+  * Added `make uninstall`
+  * Added better readdir() failure message
+  * Fixed `make install` for kiwi
+
+0.1.0 / 2010-06-15
+==================
+
+  * Added better usage docs via --help
+  * Added better conditional color support
+  * Added pre exit assertion support
+
+0.0.3 / 2010-06-02
+==================
+
+  * Added more room for filenames in test coverage
+  * Added boring output support via --boring (suppress colored output)
+  * Fixed async failure exit status
+
+0.0.2 / 2010-05-30
+==================
+
+  * Fixed exit status for CI support
+
+0.0.1 / 2010-05-30
+==================
+
+  * Initial release

data/server/node_modules/connect-form/support/expresso/Makefile

@@ -0,0 +1,30 @@
+
+BIN = bin/expresso
+PREFIX = /usr/local
+JSCOV = deps/jscoverage/node-jscoverage
+
+test: $(BIN)
+	@./$(BIN) -I lib --growl $(TEST_FLAGS) test/*.test.js
+
+test-cov:
+	@./$(BIN) -I lib --cov $(TEST_FLAGS) test/*.test.js
+
+install: install-jscov install-expresso
+
+uninstall:
+	rm -f $(PREFIX)/bin/expresso
+	rm -f $(PREFIX)/bin/node-jscoverage
+
+install-jscov: $(JSCOV)
+	install $(JSCOV) $(PREFIX)/bin
+
+install-expresso:
+	install $(BIN) $(PREFIX)/bin
+
+$(JSCOV):
+	cd deps/jscoverage && ./configure && make && mv jscoverage node-jscoverage
+
+clean:
+	@cd deps/jscoverage && git clean -fd
+
+.PHONY: test test-cov install uninstall install-expresso install-jscov clean

data/server/node_modules/connect-form/support/expresso/Readme.md

@@ -0,0 +1,208 @@
+
+# Expresso
+
+  TDD framework for [nodejs](http://nodejs.org).
+  
+  Expresso is an extremely fast Test Driven Development framework for nodejs. I
+  was frustrated with what was currently available, I wanted something
+  fast (_not executed serially_), with reasonable reporting,
+  drop-dead simple async support (_you dont have to do anything!_),
+  and _code coverage_.
+
+## Features
+
+  - intuitive async support
+  - intuitive test runner executable
+  - test coverage support and reporting
+  - uses the _assert_ module
+  - `assert.eql()` alias of `assert.deepEqual()`
+  - `assert.response()` http response utility
+  - `assert.includes()`
+  - `assert.isNull()`
+  - `assert.isUndefined()`
+  - `assert.isNotNull()`
+  - `assert.isNotUndefined()`
+  - `assert.match()`
+  - `assert.length()`
+  - light-weight
+
+## Installation
+
+To install both expresso _and_ node-jscoverage run:
+
+    $ make install
+
+To install expresso alone (no build required) run:
+
+    $ make install-expresso
+
+Install via [kiwi](http://github.com/visionmedia/kiwi):
+
+    $ kiwi install expresso
+
+Install via npm:
+
+	$ npm install expresso
+
+## Examples
+
+To define tests we simply export several functions:
+
+    module.exports = {
+      	'test String#length': function(assert){
+        	assert.equal(6, 'foobar');
+      	}
+    }
+
+Async example:
+
+    exports['test async] = function(assert, beforeExit){
+		var n = 0;
+      	setTimeout(function(){
+        	++n;
+        	assert.ok(true);
+      	}, 200);
+      	setTimeout(function(){
+        	++n;
+        	assert.ok(true);
+      	}, 200);
+		beforeExit(function(){
+			assert.equal(2, n, 'Ensure both timeouts are called');
+		});
+    }
+
+## Executable Usage
+
+To run a single test suite (file) run:
+
+    $ expresso test/a.test.js
+
+To run several suites we may simply append another:
+
+    $ expresso test/a.test.js test/b.test.js
+
+We can also pass a whitelist of tests to run within all suites:
+
+    $ expresso --only "foo()" --only "bar()"
+
+Or several with one call:
+
+    $ expresso --only "foo(), bar()"
+
+Globbing is of course possible as well:
+
+    $ expresso test/*
+
+When expresso is called without any files, _test/*_ is the default,
+so the following is equivalent to the command above:
+
+    $ expresso
+
+If you wish to unshift a path to `require.paths` before
+running tests, you may use the `-I` or `--include` flag.
+
+    $ expresso --include lib test/*
+
+The previous example is typically what I would recommend, since expresso
+supports test coverage via [node-jscoverage](http://github.com/visionmedia/expresso) (bundled with expresso),
+so you will need to expose an instrumented version of you library.
+
+To instrument your library, simply run [node-jscoverage](http://github.com/visionmedia/expresso),
+passing the _src_ and _dest_ directories:
+
+    $ node-jscoverage lib lib-cov
+
+Now we can run our tests again, using the _lib-cov_ directory that has been
+instrumented with coverage statements:
+
+    $ expresso -I lib-cov test/*
+
+The output will look similar to below, depending on your test coverage of course :)
+
+    Test Coverage
+    +--------------------------------+----------+------+------+--------+
+    | filename                       | coverage | LOC  | SLOC | missed |
+    +--------------------------------+----------+------+------+--------+
+    | a.js                           |    90.00 |   26 |   10 |      1 |
+    | b.js                           |   100.00 |   12 |    5 |      0 |
+    +--------------------------------+----------+------+------+--------+
+                                     |    93.33 |   38 |   15 |      1 |
+                                     +----------+------+------+--------+
+
+    bar.js:
+    
+      1 |   | 
+      2 | 1 | exports.bar = function(msg){
+      3 | 1 |     return msg || 'bar';
+      4 |   | };
+    
+    
+    foo.js:
+    
+       1 |   | 
+       2 | 1 | exports.foo = function(msg){
+       3 | 2 |     if (msg) {
+       4 | 0 |         return msg;
+       5 |   |     } else {
+       6 | 2 |         return generateFoo();
+       7 |   |     }
+       8 |   | };
+       9 |   | 
+      10 | 1 | function generateFoo() {
+      11 | 2 |     return 'foo';
+      12 |   | }
+      13 |   | 
+      14 | 1 | function Foo(msg){
+      15 | 0 |     this.msg = msg || 'foo';
+      16 |   | }
+
+To make this process easier expresso has the `-c` or `--cov` which essentiall
+does the same as the two commands above. The following two commands will
+run the same tests, however one will auto-instrument, and unshift _lib-cov_,
+and the other will run tests normally:
+
+    $ expresso -I lib test/*
+    $ expresso -I lib --cov test/*
+
+Currently coverage is bound to the _lib_ directory, however in the
+future `--cov` will most likely accept a path.
+
+## HTTP Server Response Assertions
+
+Expresso _0.3.0_ adds the `assert.response()` which accepts a
+`Server` instance, followed by the `request` options, `response`
+assertions, and final optional assertion `msg`. 
+
+The `Server` passed should __NOT__ be bound to a port, `assert.response()` will
+assign a dummy port ranging from `--port NUM` and up (defaults to 5000).
+
+    assert.response(server, {
+        url: '/',
+        method: 'GET'
+    },{
+        body: '{"name":"tj"}',
+        status: 200,
+        headers: {
+            'Content-Type': 'application/json; charset=utf8'
+        }
+    });
+    
+    assert.response(server, {
+        url: '/foo',
+        method: 'POST',
+        data: 'bar baz'
+    },{
+        body: '/foo bar baz',
+        status: 200
+    }, 'Test POST');
+
+
+    assert.response(server, {
+        url: '/'
+    }, function(res){
+        assert.ok(res.body.indexOf('tj') >= 0, 'Test assert.response() callback');
+    });
+
+Dropbox fails lots but here is an image with the colored output :)
+
+![node coverage](http://dl.dropbox.com/u/6396913/cov.png)

data/server/node_modules/connect-form/support/expresso/bin/expresso

@@ -0,0 +1,647 @@
+#!/usr/bin/env node
+
+/*!
+ * Expresso
+ * Copyright(c) TJ Holowaychuk <tj@vision-media.ca>
+ * (MIT Licensed)
+ */
+ 
+/**
+ * Module dependencies.
+ */
+
+var assert = require('assert'),
+    childProcess = require('child_process'),
+    http = require('http'),
+    path = require('path'),
+    sys = require('sys'),
+    cwd = process.cwd(),
+    fs = require('fs'),
+    defer;
+
+/**
+ * Expresso version.
+ */
+
+var version = '0.4.0';
+
+/**
+ * Failures hash.
+ */
+
+var failures = {};
+
+/**
+ * Failure count.
+ */
+
+var failed = 0;
+
+/**
+ * Whitelist of tests to run.
+ */
+ 
+var only = [];
+
+/**
+ * Boring output.
+ */
+ 
+var boring = false;
+
+/**
+ * Growl notifications.
+ */
+
+var growl = false;
+
+/**
+ * Server port.
+ */
+
+var port = 5555;
+
+/**
+ * Usage documentation.
+ */
+
+var usage = ''
+    + '[bold]{Usage}: expresso [options] <file ...>'
+    + '\n'
+    + '\n[bold]{Options}:'
+    + '\n  -g, --growl          Enable growl notifications'
+    + '\n  -c, --coverage       Generate and report test coverage'
+    + '\n  -r, --require PATH   Require the given module path'
+    + '\n  -o, --only TESTS     Execute only the comma sperated TESTS (can be set several times)'
+    + '\n  -I, --include PATH   Unshift the given path to require.paths'
+    + '\n  -p, --port NUM       Port number for test servers, starts at 5555'
+    + '\n  -b, --boring         Suppress ansi-escape colors'
+    + '\n  -v, --version        Output version number'
+    + '\n  -h, --help           Display help information'
+    + '\n';
+
+// Parse arguments
+
+var files = [],
+    args = process.argv.slice(2);
+
+while (args.length) {
+    var arg = args.shift();
+    switch (arg) {
+        case '-h':
+        case '--help':
+            print(usage + '\n');
+            process.exit(1);
+            break;
+        case '-v':
+        case '--version':
+            sys.puts(version);
+            process.exit(1);
+            break;
+        case '-i':
+        case '-I':
+        case '--include':
+            if (arg = args.shift()) {
+                require.paths.unshift(arg);
+            } else {
+                throw new Error('--include requires a path');
+            }
+            break;
+        case '-o':
+        case '--only':
+            if (arg = args.shift()) {
+                only = only.concat(arg.split(/ *, */));
+            } else {
+                throw new Error('--only requires comma-separated test names');
+            }
+            break;
+        case '-p':
+        case '--port':
+            if (arg = args.shift()) {
+                port = parseInt(arg, 10);
+            } else {
+                throw new Error('--port requires a number');
+            }
+            break;
+        case '-r':
+        case '--require':
+            if (arg = args.shift()) {
+                require(arg);
+            } else {
+                throw new Error('--require requires a path');
+            }
+            break;
+        case '-c':
+        case '--cov':
+        case '--coverage':
+            defer = true;
+            childProcess.exec('rm -fr lib-cov && node-jscoverage lib lib-cov', function(err){
+                if (err) throw err;
+                require.paths.unshift('lib-cov');
+                run(files);
+            })
+            break;
+        case '-b':
+        case '--boring':
+        	boring = true;
+        	break;
+        case '--g':
+        case '--growl':
+            growl = true;
+            break;
+        default:
+            if (/\.js$/.test(arg)) {
+                files.push(arg);
+            }
+            break;
+    }
+}
+
+/**
+ * Colorized sys.error().
+ *
+ * @param {String} str
+ */
+
+function print(str){
+    sys.error(colorize(str));
+}
+
+/**
+ * Colorize the given string using ansi-escape sequences.
+ * Disabled when --boring is set.
+ *
+ * @param {String} str
+ * @return {String}
+ */
+
+function colorize(str){
+    var colors = { bold: 1, red: 31, green: 32 };
+    return str.replace(/\[(\w+)\]\{([^]*?)\}/g, function(_, color, str){
+        return boring
+            ? str
+            : '\x1B[' + colors[color] + 'm' + str + '\x1B[0m';
+    });
+}
+
+// Alias deepEqual as eql for complex equality
+
+assert.eql = assert.deepEqual;
+
+/**
+ * Assert that `val` is null.
+ *
+ * @param {Mixed} val
+ * @param {String} msg
+ * @api public
+ */
+
+assert.isNull = function(val, msg) {
+    assert.strictEqual(null, val, msg);
+};
+
+/**
+ * Assert that `val` is not null.
+ *
+ * @param {Mixed} val
+ * @param {String} msg
+ * @api public
+ */
+
+assert.isNotNull = function(val, msg) {
+    assert.notStrictEqual(null, val, msg);
+};
+
+/**
+ * Assert that `val` is undefined.
+ *
+ * @param {Mixed} val
+ * @param {String} msg
+ * @api public
+ */
+
+assert.isUndefined = function(val, msg) {
+    assert.strictEqual(undefined, val, msg);
+};
+
+/**
+ * Assert that `val` is not undefined.
+ *
+ * @param {Mixed} val
+ * @param {String} msg
+ * @api public
+ */
+
+assert.isNotUndefined = function(val, msg) {
+    assert.notStrictEqual(undefined, val, msg);
+};
+
+/**
+ * Assert that `str` matches `regexp`.
+ *
+ * @param {String} str
+ * @param {RegExp} regexp
+ * @param {String} msg
+ * @api public
+ */
+
+assert.match = function(str, regexp, msg) {
+    msg = msg || sys.inspect(str) + ' does not match ' + sys.inspect(regexp);
+    assert.ok(regexp.test(str), msg);
+};
+
+/**
+ * Assert that `substr` is within `str`.
+ *
+ * @param {String} str
+ * @param {String} substr
+ * @param {String} msg
+ * @api public
+ */
+
+assert.includes = function(str, substr, msg) {
+    msg = msg || sys.inspect(str) + ' does not include ' + sys.inspect(substr);
+    assert.ok(str.indexOf(substr) >= 0, msg);
+};
+
+/**
+ * Assert length of `val` is `n`.
+ *
+ * @param {Number} n
+ * @param {Mixed} val
+ * @param {String} msg
+ * @api public
+ */
+
+assert.length = function(n, val, msg) {
+    msg = msg || sys.inspect(val) + ' has length of ' + val.length + ', expected ' + n;
+    assert.equal(n, val.length, msg);
+};
+
+/**
+ * Assert response from `server` with
+ * the given `req` object and `res` assertions object.
+ *
+ * @param {Server} server
+ * @param {Object} req
+ * @param {Object|Function} res
+ * @param {String} msg
+ * @api public
+ */
+
+assert.response = function(server, req, res, msg){
+    msg = msg || assert.testTitle;
+    msg += '. ';
+    server.__pending = server.__pending || 0;
+    server.__pending++;
+    if (!server.fd) {
+        server.listen(server.__port = port++);
+        server.client = http.createClient(server.__port);
+    }
+    var client = server.client,
+        method = req.method || 'GET',
+        status = res.status || res.statusCode,
+        data = req.data || req.body;
+    var request = client.request(method, req.url, req.headers);
+    if (data) request.write(data);
+    request.addListener('response', function(response){
+        response.body = '';
+        response.setEncoding('utf8');
+        response.addListener('data', function(chunk){ response.body += chunk; });
+        response.addListener('end', function(){
+            --server.__pending || server.close();
+
+            // Assertion callback
+            if (typeof res === 'function') {
+                return res(response);
+            }
+
+            // Assert response body
+            if (res.body !== undefined) {
+                assert.equal(
+                    response.body,
+                    res.body,
+                    msg + 'Invalid response body.\n'
+                        + '    Expected: ' + sys.inspect(res.body) + '\n'
+                        + '    Got: ' + sys.inspect(response.body)
+                );
+            }
+            
+            // Assert response status
+            if (typeof status === 'number') {
+                assert.equal(
+                    response.statusCode,
+                    status,
+                    msg + colorize('Invalid response status code.\n'
+                        + '    Expected: [green]{' + status + '}\n'
+                        + '    Got: [red]{' + response.statusCode + '}')
+                );
+            }
+
+            // Assert response headers
+            if (res.headers) {
+                var keys = Object.keys(res.headers);
+                for (var i = 0, len = keys.length; i < len; ++i) {
+                    var name = keys[i],
+                        actual = response.headers[name.toLowerCase()],
+                        expected = res.headers[name];
+                    assert.equal(
+                        actual,
+                        expected,
+                        msg + colorize('Invalid response header [bold]{' + name + '}.\n'
+                            + '    Expected: [green]{' + expected + '}\n'
+                            + '    Got: [red]{' + actual + '}')
+                    );
+                }
+            }
+        });
+    });
+    request.end();
+};
+
+/**
+ * Pad the given string to the maximum width provided.
+ *
+ * @param  {String} str
+ * @param  {Number} width
+ * @return {String}
+ * @api private
+ */
+
+function lpad(str, width) {
+    str = String(str);
+    var n = width - str.length;
+    if (n < 1) return str;
+    while (n--) str = ' ' + str;
+    return str;
+}
+
+/**
+ * Pad the given string to the maximum width provided.
+ *
+ * @param  {String} str
+ * @param  {Number} width
+ * @return {String}
+ * @api private
+ */
+
+function rpad(str, width) {
+    str = String(str);
+    var n = width - str.length;
+    if (n < 1) return str;
+    while (n--) str = str + ' ';
+    return str;
+}
+
+/**
+ * Report test coverage.
+ *
+ * @param  {Object} cov
+ * @api private
+ */
+
+function reportCoverage(cov) {
+    populateCoverage(cov);
+    // Stats
+    print('\n   [bold]{Test Coverage}\n');
+    var sep = '   +------------------------------------------+----------+------+------+--------+',
+        lastSep = '                                              +----------+------+------+--------+';
+    sys.puts(sep);
+    sys.puts('   | filename                                 | coverage | LOC  | SLOC | missed |');
+    sys.puts(sep);
+    for (var name in cov) {
+        var file = cov[name];
+        if (file instanceof Array) {
+            sys.print('   | ' + rpad(name, 40));
+            sys.print(' | ' + lpad(file.coverage.toFixed(2), 8));
+            sys.print(' | ' + lpad(file.LOC, 4));
+            sys.print(' | ' + lpad(file.SLOC, 4));
+            sys.print(' | ' + lpad(file.totalMisses, 6));
+            sys.print(' |\n');
+        }
+    }
+    sys.puts(sep);
+    sys.print('     ' + rpad('', 40));
+    sys.print(' | ' + lpad(cov.coverage.toFixed(2), 8));
+    sys.print(' | ' + lpad(cov.LOC, 4));
+    sys.print(' | ' + lpad(cov.SLOC, 4));
+    sys.print(' | ' + lpad(cov.totalMisses, 6));
+    sys.print(' |\n');
+    sys.puts(lastSep);
+    // Source
+    for (var name in cov) {
+        if (name.match(/\.js$/)) {
+            var file = cov[name];
+            print('\n   [bold]{' + name + '}:');
+            print(file.source);
+            sys.print('\n');
+        }
+    }
+}
+
+/**
+ * Populate code coverage data.
+ *
+ * @param  {Object} cov
+ * @api private
+ */
+
+function populateCoverage(cov) {
+    cov.LOC = 
+    cov.SLOC =
+    cov.totalFiles =
+    cov.totalHits =
+    cov.totalMisses = 
+    cov.coverage = 0;
+    for (var name in cov) {
+        var file = cov[name];
+        if (file instanceof Array) {
+            // Stats
+            ++cov.totalFiles;
+            cov.totalHits += file.totalHits = coverage(file, true);
+            cov.totalMisses += file.totalMisses = coverage(file, false);
+            file.totalLines = file.totalHits + file.totalMisses;
+            cov.SLOC += file.SLOC = file.totalLines;
+            cov.LOC += file.LOC = file.source.length;
+            file.coverage = (file.totalHits / file.totalLines) * 100;
+            // Source
+            var width = file.source.length.toString().length;
+            file.source = file.source.map(function(line, i){
+                ++i;
+                var hits = file[i] === 0 ? 0 : (file[i] || ' ');
+                if (!boring) {
+                    if (hits === 0) {
+                        hits = '\x1b[31m' + hits + '\x1b[0m';
+                        line = '\x1b[41m' + line + '\x1b[0m';
+                    } else {
+                        hits = '\x1b[32m' + hits + '\x1b[0m';
+                    }
+                }
+                return '\n     ' + lpad(i, width) + ' | ' + hits + ' | ' + line;
+            }).join('');
+        }
+    }
+    cov.coverage = (cov.totalHits / cov.SLOC) * 100;
+}
+
+/**
+ * Total coverage for the given file data.
+ *
+ * @param  {Array} data
+ * @return {Type}
+ * @api private
+ */
+
+function coverage(data, val) {
+    var n = 0;
+    for (var i = 0, len = data.length; i < len; ++i) {
+        if (data[i] !== undefined && data[i] == val) ++n;
+    }
+    return n;  
+}
+
+/**
+ * Run all test files.
+ *
+ * @param  {Array} files
+ * @api public
+ */
+
+function run(files, dir) {
+    if (files.length) {
+        files.forEach(function(file){
+            var title = path.basename(file),
+                file = path.join(cwd, dir, file),
+                mod = require(file.replace(/\.js$/, ''));
+            runSuite(title, mod);
+        });
+    } else {
+        fs.readdir('test', function(err, files){
+            if (err) {
+                print('\n   failed to load tests in [bold]{./test}\n');
+                ++failed;
+                process.exit(1);
+            }
+            run(files, 'test/');
+        });
+    }
+}
+
+/**
+ * Report global failures.
+ *
+ * @api private
+ */
+
+function reportFailures() {
+    for (var suite in failures) {
+        var n = 0;
+        print('\n   --- [bold]{' + suite + '} ' + Array(55).join('-') + '\n');
+        for (var test in failures[suite]) {
+            var err = failures[suite][test],
+                name = err.name,
+                stack = err.stack.replace(err.name, '');
+            if (test.indexOf('uncaught') === 0) {
+                test = '';
+            }
+            print('\n   ' + ++n + ') [bold]{' + test + '}: [red]{' + name + '}' + stack + '\n');
+        }
+    }
+}
+
+/**
+ * Run the given tests.
+ *
+ * @param  {String} title
+ * @param  {Object} tests
+ * @api private
+ */
+
+function runSuite(title, tests) {
+    var keys = only.length
+        ? only.slice(0)
+        : Object.keys(tests);
+    (function next(){
+        if (keys.length) {
+            var key,
+                test = tests[key = keys.shift()];
+            if (test) {
+                try {
+                    assert.testTitle = key;
+                    test(assert, function(fn){
+                        process.addListener('beforeExit', function(){
+                            try {
+                                fn();
+                            } catch (err) {
+                                ++failed;
+                                failures[title] = failures[title] || {};
+                                failures[title][key] = err;
+                            }
+                        });
+                    });
+                } catch (err) {
+                    ++failed;
+                    failures[title] = failures[title] || {};
+                    failures[title][key] = err;
+                }
+            }
+            next();
+        }
+    })();
+}
+
+/**
+ * Growl notify the given `msg`.
+ *
+ * @param {String} msg
+ */
+
+function notify(msg) {
+    if (growl) {
+        childProcess.exec('growlnotify -name Expresso -m "' + msg + '"');
+    }
+}
+
+// Prefix uncaughtException's with "uncaught"
+
+var uncaught = 0;
+process.addListener('uncaughtException', function(err){
+    ++failed;
+    failures['uncaught'] = failures['uncaught'] || {};
+    failures['uncaught']['uncaught ' + ++uncaught] = err;
+});
+
+// Report test coverage when available
+// and emit "beforeExit" event to perform
+// final assertions
+
+var orig = process.emit;
+process.emit = function(event){
+    if (event === 'exit') {
+        process.emit('beforeExit');
+        reportFailures();
+        if (failed) {
+            print('\n   [bold]{Failures}: [red]{' + failed + '}\n\n');
+            notify('Failures: ' + failed);
+        } else {
+            var quote = [
+                's`all good',
+                'eyyyy-ok',
+                'wahoo, your shit is not broken!',
+                'TATFT',
+                ':)'
+            ][Math.random() * 5 | 0];
+        	print('\n   [green]{100%} [bold]{' + quote + '}\n');
+        	notify('100% ' + quote);
+        }
+        if (typeof _$jscoverage === 'object') {
+            reportCoverage(_$jscoverage);
+        }
+        process.reallyExit(failed);
+    }
+    orig.apply(this, arguments);
+};
+
+// Run test files
+
+if (!defer) run(files);