move test suite to mocha

package.json

@@ -30,7 +30,7 @@
     },
     "devDependencies": {
         "step": "0.0.4",
-        "expresso": "*"
+        "mocha": "~1.7"
     },
     "engines": {
         "node": ">= 0.6.13 && < 0.11.0"

test/affected.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test row changes and lastID'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var finished = false;
+describe('query properties', function() {
+    var db;
+    before(function(done) {
+        db = new sqlite3.Database(':memory:');
+        db.run("CREATE TABLE foo (id INT, txt TEXT)", done);
+    });
 
-    db.serialize(function() {
-        db.run("CREATE TABLE foo (id INT, txt TEXT)");
+    it('should return the correct lastID', function(done) {
         var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
         var j = 1;
         for (var i = 0; i < 1000; i++) {
@@ -20,15 +19,14 @@ exports['test row changes and lastID'] = function(beforeExit) {
                 assert.equal(j++, this.lastID);
             });
         }
+        db.wait(done);
+    });
 
+    it('should return the correct changes count', function(done) {
         db.run("UPDATE foo SET id = id + 1 WHERE id % 2 = 0", function(err) {
             if (err) throw err;
             assert.equal(500, this.changes);
-            finished = true;
+            done();
         });
     });
-
-    beforeExit(function() {
-        assert.ok(finished);
-    })
-}
+});

test/blob.test.js

-var sqlite3 = require('sqlite3'),
-    Step = require('step'),
+var sqlite3 = require('..'),
     fs = require('fs'),
-    assert = require('assert')
+    assert = require('assert'),
     Buffer = require('buffer').Buffer;
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
 // lots of elmo
 var elmo = fs.readFileSync(__dirname + '/support/elmo.png');
 
-exports['blob test'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
+describe('blob', function() {
+    var db;
+    before(function(done) {
+        db = new sqlite3.Database(':memory:');
+        db.run("CREATE TABLE elmos (id INT, image BLOB)", done);
+    });
+
     var total = 10;
     var inserted = 0;
     var retrieved = 0;
 
-    db.serialize(function() {
-        db.run('CREATE TABLE elmos (id INT, image BLOB)');
 
+    it('should insert blobs', function(done) {
         for (var i = 0; i < total; i++) {
             db.run('INSERT INTO elmos (id, image) VALUES (?, ?)', i, elmo, function(err) {
                 if (err) throw err;
                 inserted++;
             });
         }
+        db.wait(function() {
+            assert.equal(inserted, total);
+            done();
+        });
+    });
 
+    it('should retrieve the blobs', function(done) {
         db.all('SELECT id, image FROM elmos ORDER BY id', function(err, rows) {
             if (err) throw err;
             for (var i = 0; i < rows.length; i++) {
@@ -39,12 +46,9 @@ exports['blob test'] = function(beforeExit) {
 
                 retrieved++;
             }
-        });
-
-    });
 
-    beforeExit(function() {
-        assert.equal(inserted, total);
             assert.equal(retrieved, total);
-    })
-}
+            done();
+        });
+    });
+});

test/cache.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 var helper = require('./support/helper');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test caching Database objects while opening'] = function(beforeExit) {
+describe('cache', function() {
+    it('should cache Database objects while opening', function(done) {
         var filename = 'test/tmp/test_cache.db';
         helper.deleteFile(filename);
-    var opened1 = false, opened2 = false
+        var opened1 = false, opened2 = false;
         var db1 = new sqlite3.cached.Database(filename, function(err) {
             if (err) throw err;
             opened1 = true;
+            if (opened1 && opened2) done();
         });
         var db2 = new sqlite3.cached.Database(filename, function(err) {
             if (err) throw err;
             opened2 = true;
+            if (opened1 && opened2) done();
         });
         assert.equal(db1, db2);
-
-    beforeExit(function() {
-        assert.ok(opened1);
-        assert.ok(opened2);
     });
-};
 
-exports['test caching Database objects after it is open'] = function(beforeExit) {
+    it('should cache Database objects after they are open', function(done) {
         var filename = 'test/tmp/test_cache2.db';
         helper.deleteFile(filename);
-    var opened1 = false, opened2 = false
         var db1, db2;
         db1 = new sqlite3.cached.Database(filename, function(err) {
             if (err) throw err;
-        opened1 = true;
-        setTimeout(function() {
+            process.nextTick(function() {
                 db2 = new sqlite3.cached.Database(filename, function(err) {
-                opened2 = true;
-            });
-        }, 100);
-    });
+                    done();
 
-    beforeExit(function() {
+                });
                 assert.equal(db1, db2);
-        assert.ok(opened1);
-        assert.ok(opened2);
             });
-};
+        });
+    });
+});

test/constants.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test constants'] = function() {
+describe('constants', function() {
+    it('should have the right OPEN_* flags', function() {
         assert.ok(sqlite3.OPEN_READONLY === 1);
         assert.ok(sqlite3.OPEN_READWRITE === 2);
         assert.ok(sqlite3.OPEN_CREATE === 4);
+    });
 
+    it('should have the right error flags', function() {
         assert.ok(sqlite3.OK === 0);
         assert.ok(sqlite3.ERROR === 1);
         assert.ok(sqlite3.INTERNAL === 2);
@@ -35,4 +36,5 @@ exports['test constants'] = function() {
         assert.ok(sqlite3.FORMAT === 24);
         assert.ok(sqlite3.RANGE === 25);
         assert.ok(sqlite3.NOTADB === 26);
-};
+    });
\ No newline at end of file
+});

test/database_fail.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 
-exports['test Database() without new'] = function(beforeExit) {
+describe('error handling', function() {
+    var db;
+    before(function(done) {
+        db = new sqlite3.Database(':memory:', done);
+    });
+
+    it('throw when calling Database() without new', function() {
         assert.throws(function() {
             sqlite3.Database(':memory:');
         }, (/Use the new operator to create new Database objects/));
@@ -9,70 +15,48 @@ exports['test Database() without new'] = function(beforeExit) {
         assert.throws(function() {
             sqlite3.Statement();
         }, (/Use the new operator to create new Statement objects/));
-};
-
-exports['test Database#get prepare fail'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var completed = false;
+    });
 
+    it('should error when calling Database#get on a missing table', function(done) {
         db.get('SELECT id, txt FROM foo', function(err, row) {
             if (err) {
                 assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
                 assert.equal(err.errno, sqlite3.ERROR);
                 assert.equal(err.code, 'SQLITE_ERROR');
-            completed = true;
+                done();
+            } else {
+                done(new Error('Completed query without error, but expected error'));
             }
         });
-
-    beforeExit(function() {
-        assert.ok(completed);
     });
-};
-
-exports['test Database#all prepare fail'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var completed = false;
 
+    it('Database#all prepare fail', function(done) {
         db.all('SELECT id, txt FROM foo', function(err, row) {
             if (err) {
                 assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
                 assert.equal(err.errno, sqlite3.ERROR);
                 assert.equal(err.code, 'SQLITE_ERROR');
-            completed = true;
+                done();
+            } else {
+                done(new Error('Completed query without error, but expected error'));
             }
         });
-
-    beforeExit(function() {
-        assert.ok(completed);
     });
-};
-
-exports['test Database#run prepare fail'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var completed = false;
 
+    it('Database#run prepare fail', function(done) {
         db.run('SELECT id, txt FROM foo', function(err, row) {
             if (err) {
                 assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
                 assert.equal(err.errno, sqlite3.ERROR);
                 assert.equal(err.code, 'SQLITE_ERROR');
-            completed = true;
+                done();
+            } else {
+                done(new Error('Completed query without error, but expected error'));
             }
         });
-
-    beforeExit(function() {
-        assert.ok(completed);
     });
-};
-
-exports['test Database#each prepare fail'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var completed = false;
 
+    it('Database#each prepare fail', function(done) {
         db.each('SELECT id, txt FROM foo', function(err, row) {
             assert.ok(false, "this should not be called");
         }, function(err, num) {
@@ -80,99 +64,66 @@ exports['test Database#each prepare fail'] = function(beforeExit) {
                 assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
                 assert.equal(err.errno, sqlite3.ERROR);
                 assert.equal(err.code, 'SQLITE_ERROR');
-            completed = true;
+                done();
+            } else {
+                done(new Error('Completed query without error, but expected error'));
             }
         });
-
-    beforeExit(function() {
-        assert.ok(completed);
     });
-};
-
-exports['test Database#each prepare fail without completion handler'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var completed = false;
 
+    it('Database#each prepare fail without completion handler', function(done) {
         db.each('SELECT id, txt FROM foo', function(err, row) {
             if (err) {
                 assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
                 assert.equal(err.errno, sqlite3.ERROR);
                 assert.equal(err.code, 'SQLITE_ERROR');
-            completed = true;
-        }
-        else {
-            assert.ok(false, 'this should not be called')
+                done();
+            } else {
+                done(new Error('Completed query without error, but expected error'));
             }
         });
-
-    beforeExit(function() {
-        assert.ok(completed);
     });
-};
-
-exports['test Database#get prepare fail with param binding'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var completed = false;
 
+    it('Database#get prepare fail with param binding', function(done) {
         db.get('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
             if (err) {
                 assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
                 assert.equal(err.errno, sqlite3.ERROR);
                 assert.equal(err.code, 'SQLITE_ERROR');
-            completed = true;
+                done();
+            } else {
+                done(new Error('Completed query without error, but expected error'));
             }
         });
-
-    beforeExit(function() {
-        assert.ok(completed);
     });
-};
-
-exports['test Database#all prepare fail with param binding'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var completed = false;
 
+    it('Database#all prepare fail with param binding', function(done) {
         db.all('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
             if (err) {
                 assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
                 assert.equal(err.errno, sqlite3.ERROR);
                 assert.equal(err.code, 'SQLITE_ERROR');
-            completed = true;
+                done();
+            } else {
+                done(new Error('Completed query without error, but expected error'));
             }
         });
-
-    beforeExit(function() {
-        assert.ok(completed);
     });
-};
-
-exports['test Database#run prepare fail with param binding'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var completed = false;
 
+    it('Database#run prepare fail with param binding', function(done) {
         db.run('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
             if (err) {
                 assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
                 assert.equal(err.errno, sqlite3.ERROR);
                 assert.equal(err.code, 'SQLITE_ERROR');
-            completed = true;
+                done();
+            } else {
+                done(new Error('Completed query without error, but expected error'));
             }
         });
-
-    beforeExit(function() {
-        assert.ok(completed);
     });
-};
-
-exports['test Database#each prepare fail with param binding'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var completed = false;
 
+    it('Database#each prepare fail with param binding', function(done) {
         db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
             assert.ok(false, "this should not be called");
         }, function(err, num) {
@@ -180,33 +131,23 @@ exports['test Database#each prepare fail with param binding'] = function(beforeE
                 assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
                 assert.equal(err.errno, sqlite3.ERROR);
                 assert.equal(err.code, 'SQLITE_ERROR');
-            completed = true;
+                done();
+            } else {
+                done(new Error('Completed query without error, but expected error'));
             }
         });
-
-    beforeExit(function() {
-        assert.ok(completed);
     });
-};
-
-exports['test Database#each prepare fail with param binding without completion handler'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var completed = false;
 
+    it('Database#each prepare fail with param binding without completion handler', function(done) {
         db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
             if (err) {
                 assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
                 assert.equal(err.errno, sqlite3.ERROR);
                 assert.equal(err.code, 'SQLITE_ERROR');
-            completed = true;
-        }
-        else {
-            assert.ok(false, 'this should not be called')
+                done();
+            } else {
+                done(new Error('Completed query without error, but expected error'));
             }
         });
-
-    beforeExit(function() {
-        assert.ok(completed);
     });
-};
+});

test/each.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
-var util = require('util');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test Statement#each'] = function(beforeExit) {
-    var db = new sqlite3.Database('test/support/big.db', sqlite3.OPEN_READONLY);
+describe('each', function() {
+    var db;
+    before(function(done) {
+        db = new sqlite3.Database('test/support/big.db', sqlite3.OPEN_READONLY, done);
+    });
 
+    it('retrieve 100,000 rows with Statement#each', function(done) {
         var total = 100000;
         var retrieved = 0;
 
@@ -15,28 +16,23 @@ exports['test Statement#each'] = function(beforeExit) {
             retrieved++;
         });
 
-    beforeExit(function() {
+        db.wait(function() {
             assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
+            done();
+        });
     });
-};
-
-exports['test Statement#each with complete callback'] = function(beforeExit) {
-    var db = new sqlite3.Database('test/support/big.db', sqlite3.OPEN_READONLY);
 
+    it('Statement#each with complete callback', function(done) {
         var total = 10000;
         var retrieved = 0;
-    var completed = false;
 
         db.each('SELECT id, txt FROM foo LIMIT 0, ?', total, function(err, row) {
             if (err) throw err;
             retrieved++;
         }, function(err, num) {
             assert.equal(retrieved, num);
-        completed = true;
-    });
-
-    beforeExit(function() {
-        assert.ok(completed);
             assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
+            done();
+        });
     });
-};
+});

test/exec.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 var fs = require('fs');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
+describe('exec', function() {
+    var db;
+    before(function(done) {
+        db = new sqlite3.Database(':memory:', done);
+    });
 
-exports['test Database#exec'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-    var finished = false;
+    it('Database#exec', function(done) {
         var sql = fs.readFileSync('test/support/script.sql', 'utf8');
+        db.exec(sql, done);
+    });
 
-    db.exec(sql, function(err) {
-        if (err) throw err;
-
+    it('retrieve database structure', function(done) {
         db.all("SELECT type, name FROM sqlite_master ORDER BY type, name", function(err, rows) {
             if (err) throw err;
-
             assert.deepEqual(rows, [
                 { type: 'index', name: 'grid_key_lookup' },
                 { type: 'index', name: 'grid_utfgrid_lookup' },
@@ -32,12 +33,7 @@ exports['test Database#exec'] = function(beforeExit) {
                 { type: 'view', name: 'grids' },
                 { type: 'view', name: 'tiles' }
             ]);
-
-            finished = true;
+            done();
         });
     });
-
-    beforeExit(function() {
-        assert.ok(finished);
-    });
-};
+});

test/extension.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
-var exists = require('fs').existsSync || require('path').existsSync
-
-if (process.setMaxListeners) process.setMaxListeners(0);
+var exists = require('fs').existsSync || require('path').existsSync;
 
 var spatialite_ext = '/usr/local/lib/libspatialite.dylib';
 
-exports['test loadExtension'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-    var completed = false;
+describe('loadExtension', function(done) {
+    var db;
+    before(function(done) {
+        db = new sqlite3.Database(':memory:', done);
+    });
 
     if (exists(spatialite_ext)) {
-        db.loadExtension(spatialite_ext, function(err) {
-            if (err) throw err;
-            completed = true;
+        it('libspatialite', function(done) {
+            db.loadExtension(spatialite_ext, done);
         });
     } else {
-        completed = true;
+        it('libspatialite');
     }
-
-    beforeExit(function() {
-        assert.ok(completed);
-    });
-}
+});

test/fts-content.test.js

-/*jshint strict:true node:true es5:true onevar:true laxcomma:true laxbreak:true eqeqeq:true immed:true latedef:true*/
-(function () {
-  "use strict";
+var sqlite3 = require('..');
+var assert = require('assert');
 
-  var sqlite = require('sqlite3')
-    , assert = require('assert')
-    , db
-    ;
-
-  function readyForQuery() {
-    db.exec('CREATE VIRTUAL TABLE t1 USING fts4(content="", a, b, c);', function (err) {
-      assert.ok(!err);
+describe('fts', function() {
+    var db;
+    before(function(done) {
+        db = new sqlite3.Database(':memory:', done);
     });
-  }
 
-  db = new sqlite.Database(":memory:", readyForQuery);
-}());
+    it('should create a new fts4 table', function(done) {
+        db.exec('CREATE VIRTUAL TABLE t1 USING fts4(content="", a, b, c);', done);
+    });
+});

test/map.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test Database#map() with two columns'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
+describe('map', function() {
+    it('test Database#map() with two columns', function(done) {
         var count = 10;
         var inserted = 0;
-    var retrieved = false;
 
+        var db = new sqlite3.Database(':memory:');
         db.serialize(function() {
             db.run("CREATE TABLE foo (id INT, value TEXT)");
 
@@ -23,24 +20,19 @@ exports['test Database#map() with two columns'] = function(beforeExit) {
             stmt.finalize();
 
             db.map("SELECT * FROM foo", function(err, map) {
-           retrieved = true;
+                if (err) throw err;
                 assert.deepEqual(map, { 5: 'Value for 5', 6: 'Value for 6', 7: 'Value for 7', 8: 'Value for 8', 9: 'Value for 9' });
+                assert.equal(inserted, 5);
+                done();
             });
-
         });
-
-    beforeExit(function() {
-        assert.equal(inserted, 5);
-        assert.ok(retrieved);
     });
-};
 
-exports['test Database#map() with three columns'] = function(beforeExit) {
+    it('test Database#map() with three columns', function(done) {
         var db = new sqlite3.Database(':memory:');
 
         var count = 10;
         var inserted = 0;
-    var retrieved = false;
 
         db.serialize(function() {
             db.run("CREATE TABLE foo (id INT, value TEXT, other TEXT)");
@@ -55,7 +47,7 @@ exports['test Database#map() with three columns'] = function(beforeExit) {
             stmt.finalize();
 
             db.map("SELECT * FROM foo", function(err, map) {
-           retrieved = true;
+                if (err) throw err;
                 assert.deepEqual(map, {
                     5: { id: 5, value: 'Value for 5', other: null },
                     6: { id: 6, value: 'Value for 6', other: null },
@@ -63,12 +55,9 @@ exports['test Database#map() with three columns'] = function(beforeExit) {
                     8: { id: 8, value: 'Value for 8', other: null },
                     9: { id: 9, value: 'Value for 9', other: null }
                 });
+                assert.equal(inserted, 5);
+                done();
             });
-
         });
-
-    beforeExit(function() {
-        assert.equal(inserted, 5);
-        assert.ok(retrieved);
     });
-};
+});

test/named_columns.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test named columns'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var finished = false;
+describe('named columns', function() {
+    var db;
+    before(function(done) {
+        db = new sqlite3.Database(':memory:', done);
+    });
 
-    db.serialize(function() {
-        db.run("CREATE TABLE foo (txt TEXT, num INT)");
+    it('should create the table', function(done) {
+        db.run("CREATE TABLE foo (txt TEXT, num INT)", done);
+    });
 
+    it('should insert a value', function(done) {
         db.run("INSERT INTO foo VALUES($text, $id)", {
             $id: 1,
             $text: "Lorem Ipsum"
+        }, done);
     });
 
+    it('should retrieve the values', function(done) {
         db.get("SELECT txt, num FROM foo ORDER BY num", function(err, row) {
             if (err) throw err;
-
             assert.equal(row.txt, "Lorem Ipsum");
             assert.equal(row.num, 1);
-
-            finished = true;
-        });
-
+            done();
         });
-
-    beforeExit(function() {
-        assert.ok(finished);
     });
-};
+});
\ No newline at end of file

test/named_params.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test named parameters'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var finished = false;
+describe('named parameters', function() {
+    var db;
+    before(function(done) {
+        db = new sqlite3.Database(':memory:', done);
+    });
 
-    db.serialize(function() {
-        db.run("CREATE TABLE foo (txt TEXT, num INT)");
+    it('should create the table', function(done) {
+        db.run("CREATE TABLE foo (txt TEXT, num INT)", done);
+    });
 
+    it('should insert a value with $ placeholders', function(done) {
         db.run("INSERT INTO foo VALUES($text, $id)", {
             $id: 1,
             $text: "Lorem Ipsum"
+        }, done);
     });
 
+    it('should insert a value with : placeholders', function(done) {
         db.run("INSERT INTO foo VALUES(:text, :id)", {
-            ":id": 2,
-            ":text": "Dolor Sit Amet"
+            ':id': 2,
+            ':text': "Dolor Sit Amet"
+        }, done);
     });
 
+    it('should insert a value with @ placeholders', function(done) {
         db.run("INSERT INTO foo VALUES(@txt, @id)", {
             "@id": 3,
             "@txt": "Consectetur Adipiscing Elit"
+        }, done);
     });
 
-        db.run("INSERT INTO foo VALUES(@txt, @id)", [ 'Sed Do Eiusmod', 4 ]);
-        db.run("INSERT INTO foo VALUES(?2, ?4)", [ null, 'Tempor Incididunt', null, 5 ]);
+    it('should insert a value with @ placeholders using an array', function(done) {
+        db.run("INSERT INTO foo VALUES(@txt, @id)", [ 'Sed Do Eiusmod', 4 ], done);
+    });
 
+    it('should insert a value with indexed placeholders', function(done) {
+        db.run("INSERT INTO foo VALUES(?2, ?4)",
+            [ null, 'Tempor Incididunt', null, 5 ], done);
+    });
+
+    it('should insert a value with autoindexed placeholders', function(done) {
         db.run("INSERT INTO foo VALUES(?, ?)", {
             2: 6,
             1: "Ut Labore Et Dolore"
+        }, done);
     });
 
+    it('should retrieve all inserted values', function(done) {
         db.all("SELECT txt, num FROM foo ORDER BY num", function(err, rows) {
             if (err) throw err;
-
             assert.equal(rows[0].txt, "Lorem Ipsum");
             assert.equal(rows[0].num, 1);
             assert.equal(rows[1].txt, "Dolor Sit Amet");
@@ -49,12 +63,7 @@ exports['test named parameters'] = function(beforeExit) {
             assert.equal(rows[4].num, 5);
             assert.equal(rows[5].txt, "Ut Labore Et Dolore");
             assert.equal(rows[5].num, 6);
-
-            finished = true;
+            done();
         });
     });
-
-    beforeExit(function() {
-        assert.ok(finished);
-    });
-};
+});
\ No newline at end of file

test/null_error.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 var helper = require('./support/helper');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test SQLITE_OK error'] = function(beforeExit) {
-    var completed = false;
+describe('null error', function() {
     var filename = 'test/tmp/test_sqlite_ok_error.db';
+    var db;
+
+    before(function(done) {
         helper.deleteFile(filename);
-    var db = new sqlite3.Database(filename);
+        db = new sqlite3.Database(filename, done);
+    });
 
-    db.run("CREATE TABLE febp_data (leacode TEXT, leaname TEXT, state TEXT, postcode TEXT, fips TEXT, titleistim TEXT, ideastim TEXT, ideapool TEXT, ideapoolname TEXT, localebasis TEXT, localetype2 TEXT, version TEXT, leacount_2006 TEXT, ppexpend_2005 TEXT, ppexpend_2006 TEXT, ppexpend_2007 TEXT, ppexpend_2008 TEXT, ppexpendrank_2006 TEXT, ppexpendrank_2007 TEXT, ppexpendrank_2008 TEXT, rankppexpend_2005 TEXT, opbud_2004 TEXT, opbud_2006 TEXT, opbud_2007 TEXT, opbud_2008 TEXT, titlei_2004 TEXT, titlei_2006 TEXT, titlei_2007 TEXT, titlei_2008 TEXT, titlei_2009 TEXT, titlei_2010 TEXT, idea_2004 TEXT, idea_2005 TEXT, idea_2006 TEXT, idea_2007 TEXT, idea_2008 TEXT, idea_2009 TEXT, ideaest_2010 TEXT, impact_2007 TEXT, impact_2008 TEXT, impact_2009 TEXT, impact_2010 TEXT, fedrev_2006 TEXT, fedrev_2007 TEXT, fedrev_2008 TEXT, schonut_2006 TEXT, schonut_2007 TEXT, schomeal_2006 TEXT, schomeal_2007 TEXT, schoco_2006 TEXT, schocom_2007 TEXT, medicaid_2006 TEXT, medicaid_2007 TEXT, medicaid_2008 TEXT, cenpov_2004 TEXT, cenpov_2007 TEXT, cenpov_2008 TEXT, rankcenpov_2004 TEXT, rankcenpov_2007 TEXT, rankcenpov_2008 TEXT, enroll_2006 TEXT, enroll_2007 TEXT, enroll_2008 TEXT, white_2006 TEXT, white_2007 TEXT, white_2008 TEXT, afam_2006 TEXT, afam_2007 TEXT, afam_2008 TEXT, amin_2006 TEXT, amin_2007 TEXT, amin_2008 TEXT, asian_2006 TEXT, asian_2007 TEXT, asian_2008 TEXT, hisp_2006 TEXT, hisp_2007 TEXT, hisp_2008 TEXT, frpl_2006 TEXT, frpl_2007 TEXT, frpl_2008 TEXT, ell_2006 TEXT, ell_2007 TEXT, ell_2008 TEXT, sped_2006 TEXT, sped_2007 TEXT, sped_2008 TEXT, state4read_2005 TEXT, state4read_2006 TEXT, state4read_2007 TEXT, state4read_2008 TEXT, state4read_2009 TEXT, state4math_2005 TEXT, state4math_2006 TEXT, state4math_2007 TEXT, state4math_2008 TEXT, state4math_2009 TEXT, minor_2007 TEXT, minor_2008 TEXT, state8math_2006 TEXT, state8math_2007 TEXT, state8math_2008 TEXT, state8math_2009 TEXT, state8read_2006 TEXT, state8read_2007 TEXT, state8read_2008 TEXT, state8read_2009 TEXT, statehsmath_2006 TEXT, statehsmath_2007 TEXT, statehsmath_2008 TEXT, statehsmath_2009 TEXT, statehsread_2006 TEXT, statehsread_2007 TEXT, statehsread_2008 TEXT, statehsread_2009 TEXT)", function(err) {
-        if (err) throw err;
+    it('should create a table', function(done) {
+        db.run("CREATE TABLE febp_data (leacode TEXT, leaname TEXT, state TEXT, postcode TEXT, fips TEXT, titleistim TEXT, ideastim TEXT, ideapool TEXT, ideapoolname TEXT, localebasis TEXT, localetype2 TEXT, version TEXT, leacount_2006 TEXT, ppexpend_2005 TEXT, ppexpend_2006 TEXT, ppexpend_2007 TEXT, ppexpend_2008 TEXT, ppexpendrank_2006 TEXT, ppexpendrank_2007 TEXT, ppexpendrank_2008 TEXT, rankppexpend_2005 TEXT, opbud_2004 TEXT, opbud_2006 TEXT, opbud_2007 TEXT, opbud_2008 TEXT, titlei_2004 TEXT, titlei_2006 TEXT, titlei_2007 TEXT, titlei_2008 TEXT, titlei_2009 TEXT, titlei_2010 TEXT, idea_2004 TEXT, idea_2005 TEXT, idea_2006 TEXT, idea_2007 TEXT, idea_2008 TEXT, idea_2009 TEXT, ideaest_2010 TEXT, impact_2007 TEXT, impact_2008 TEXT, impact_2009 TEXT, impact_2010 TEXT, fedrev_2006 TEXT, fedrev_2007 TEXT, fedrev_2008 TEXT, schonut_2006 TEXT, schonut_2007 TEXT, schomeal_2006 TEXT, schomeal_2007 TEXT, schoco_2006 TEXT, schocom_2007 TEXT, medicaid_2006 TEXT, medicaid_2007 TEXT, medicaid_2008 TEXT, cenpov_2004 TEXT, cenpov_2007 TEXT, cenpov_2008 TEXT, rankcenpov_2004 TEXT, rankcenpov_2007 TEXT, rankcenpov_2008 TEXT, enroll_2006 TEXT, enroll_2007 TEXT, enroll_2008 TEXT, white_2006 TEXT, white_2007 TEXT, white_2008 TEXT, afam_2006 TEXT, afam_2007 TEXT, afam_2008 TEXT, amin_2006 TEXT, amin_2007 TEXT, amin_2008 TEXT, asian_2006 TEXT, asian_2007 TEXT, asian_2008 TEXT, hisp_2006 TEXT, hisp_2007 TEXT, hisp_2008 TEXT, frpl_2006 TEXT, frpl_2007 TEXT, frpl_2008 TEXT, ell_2006 TEXT, ell_2007 TEXT, ell_2008 TEXT, sped_2006 TEXT, sped_2007 TEXT, sped_2008 TEXT, state4read_2005 TEXT, state4read_2006 TEXT, state4read_2007 TEXT, state4read_2008 TEXT, state4read_2009 TEXT, state4math_2005 TEXT, state4math_2006 TEXT, state4math_2007 TEXT, state4math_2008 TEXT, state4math_2009 TEXT, minor_2007 TEXT, minor_2008 TEXT, state8math_2006 TEXT, state8math_2007 TEXT, state8math_2008 TEXT, state8math_2009 TEXT, state8read_2006 TEXT, state8read_2007 TEXT, state8read_2008 TEXT, state8read_2009 TEXT, statehsmath_2006 TEXT, statehsmath_2007 TEXT, statehsmath_2008 TEXT, statehsmath_2009 TEXT, statehsread_2006 TEXT, statehsread_2007 TEXT, statehsread_2008 TEXT, statehsread_2009 TEXT)", done);
+    });
+
+    it('should insert rows with lots of null values', function(done) {
         var stmt = db.prepare('INSERT INTO febp_data VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', function(err) {
             if (err) throw err;
 
@@ -21,15 +25,16 @@ exports['test SQLITE_OK error'] = function(beforeExit) {
 
             stmt.finalize(function(err) {
                 if (err) throw err;
-                completed = true;
+                done();
             });
         });
-
     });
 
-    beforeExit(function() {
-        assert.ok(completed);
+    it('should have created the database', function() {
         assert.fileExists(filename);
+    });
+
+    after(function() {
         helper.deleteFile(filename);
     });
-};
+});
\ No newline at end of file

test/open_close.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 var fs = require('fs');
 var helper = require('./support/helper');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['open and close non-existent database'] = function(beforeExit) {
-    var opened, closed;
-
+describe('open/close', function() {
+    describe('open and close non-existant database', function() {
+        before(function() {
             helper.deleteFile('test/tmp/test_create.db');
-    var db = new sqlite3.Database('test/tmp/test_create.db', function(err) {
-        if (err) throw err;
-        assert.ok(!opened);
-        assert.ok(!closed);
-        opened = true;
         });
 
-    db.close(function(err) {
-        if (err) throw err;
-        assert.ok(opened);
-        assert.ok(!closed);
-        closed = true;
+        var db;
+        it('should open the database', function(done) {
+            db = new sqlite3.Database('test/tmp/test_create.db', done);
+        });
+
+        it('should close the database', function(done) {
+            db.close(done);
         });
 
-    beforeExit(function() {
-        assert.ok(opened, 'Database not opened');
-        assert.ok(closed, 'Database not closed');
+        it('should have created the file', function() {
             assert.fileExists('test/tmp/test_create.db');
-        helper.deleteFile('test/tmp/test_create.db');
         });
-};
 
-exports['open inaccessible database'] = function(beforeExit) {
-    var notOpened;
+        after(function() {
+            helper.deleteFile('test/tmp/test_create.db');
+        });
+    });
 
+    it('should be unable to open an inaccessible database', function(done) {
+        // NOTE: test assumes that the user is not allowed to create new files
+        // in /usr/bin.
         var db = new sqlite3.Database('/usr/bin/test.db', function(err) {
             if (err && err.errno === sqlite3.CANTOPEN) {
-            notOpened = true;
+                done();
+            } else if (err) {
+                done(err);
+            } else {
+                done('Opened database that should be inaccessible');
             }
-        else if (err) throw err;
         });
-
-    beforeExit(function() {
-        assert.ok(notOpened, 'Database could be opened');
     });
-};
 
 
-exports['open non-existent database without create'] = function(beforeExit) {
-    var notOpened;
+    describe('creating database without create flag', function() {
+        before(function() {
+            helper.deleteFile('test/tmp/test_readonly.db');
+        });
 
-    helper.deleteFile('tmp/test_readonly.db');
-    var db = new sqlite3.Database('tmp/test_readonly.db', sqlite3.OPEN_READONLY,
-        function(err) {
+        it('should fail to open the database', function(done) {
+            new sqlite3.Database('tmp/test_readonly.db', sqlite3.OPEN_READONLY, function(err) {
                 if (err && err.errno === sqlite3.CANTOPEN) {
-                notOpened = true;
+                    done();
+                } else if (err) {
+                    done(err);
+                } else {
+                    done('Created database without create flag');
                 }
-            else if (err) throw err;
+            });
+        });
+
+        it('should not have created the file', function() {
+            assert.fileDoesNotExist('test/tmp/test_readonly.db');
         });
 
-    beforeExit(function() {
-        assert.ok(notOpened, 'Database could be opened');
-        assert.fileDoesNotExist('tmp/test_readonly.db');
+        after(function() {
+            helper.deleteFile('test/tmp/test_readonly.db');
+        });
     });
-};
 
-exports['open and close memory database queuing'] = function(beforeExit) {
-    var opened = 0, closed = 0, closeFailed = 0;
+    describe('open and close memory database queuing', function() {
+        var db;
+        it('should open the database', function(done) {
+            db = new sqlite3.Database(':memory:', done);
+        });
 
-    var db = new sqlite3.Database(':memory:', function openedCallback(err) {
-        if (err) throw err;
-        opened++;
+        it('should close the database', function(done) {
+            db.close(done);
         });
 
-    function closedCallback(err) {
-        if (closed > 0) {
+        it('shouldn\'t close the database again', function(done) {
+            db.close(function(err) {
                 assert.ok(err, 'No error object received on second close');
                 assert.ok(err.errno === sqlite3.MISUSE);
-            closeFailed++;
-        }
-        else if (err) throw err;
-        else closed++;
-    }
-
-    db.close(closedCallback);
-    db.close(closedCallback);
-
-    beforeExit(function() {
-        assert.equal(opened, 1, 'Database not opened');
-        assert.equal(closed, 1, 'Database not closed');
-        assert.equal(closeFailed, 1, 'Database could be closed again');
+                done();
+            });
+        });
     });
-};
 
-exports['test closing with open statements'] = function(beforeExit) {
+    describe('closing with unfinalized statements', function(done) {
         var completed = false;
         var completedSecond = false;
         var closed = false;
 
-    var db = new sqlite3.Database(':memory:');
+        var db;
+        before(function() {
+            db = new sqlite3.Database(':memory:', done);
+        });
 
-    db.serialize(function() {
-        db.run("CREATE TABLE foo (id INT, num INT)");
+        it('should create a table', function(done) {
+            db.run("CREATE TABLE foo (id INT, num INT)", done);
+        });
 
-        var stmt = db.prepare('INSERT INTO foo VALUES (?, ?)')
-        stmt.run(1, 2);
+        var stmt;
+        it('should prepare/run a statement', function(done) {
+            stmt = db.prepare('INSERT INTO foo VALUES (?, ?)');
+            stmt.run(1, 2, done);
+        });
 
+        it('should fail to close the database', function(done) {
             db.close(function(err) {
                 assert.ok(err.message,
                     "SQLITE_BUSY: unable to close due to unfinalised statements");
-            completed = true;
-            stmt.run(3, 4, function() {
-                completedSecond = true;
-                stmt.finalize();
-                db.close(function(err) {
-                    if (err) throw err;
-                    closed = true;
+                done();
             });
         });
+
+        it('should succeed to close the database after finalizing', function(done) {
+            stmt.run(3, 4, function() {
+                stmt.finalize();
+                db.close(done);
             });
         });
-
-    beforeExit(function() {
-        assert.ok(completed);
-        assert.ok(completedSecond);
-        assert.ok(closed);
     });
-};
+});

test/other_objects.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
+describe('data types', function() {
+    var db;
+    before(function(done) {
+        db = new sqlite3.Database(':memory:');
+        db.run("CREATE TABLE txt_table (txt TEXT)");
+        db.run("CREATE TABLE int_table (int INTEGER)");
+        db.run("CREATE TABLE flt_table (flt FLOAT)");
+        db.wait(done);
+    });
 
-exports['test Date() and RegExp() serialization'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
+    beforeEach(function(done) {
+        db.exec('DELETE FROM txt_table; DELETE FROM int_table; DELETE FROM flt_table;', done);
+    });
 
-    var retrieved = false;
+    it('should serialize Date()', function(done) {
         var date = new Date();
-
-    db.serialize(function() {
-        db.run("CREATE TABLE foo (txt TEXT, num FLOAT)");
-        db.run("INSERT INTO foo VALUES(?, ?)", (/^f\noo/), date);
-        db.get("SELECT txt, num FROM foo", function(err, row) {
+        db.run("INSERT INTO int_table VALUES(?)", date);
+        db.get("SELECT int FROM int_table", function(err, row) {
             if (err) throw err;
-            assert.equal(row.txt, '/^f\\noo/');
-            assert.equal(row.num, +date);
-            retrieved = true;
-        })
+            assert.equal(row.int, +date);
+            done();
         });
-
-    beforeExit(function() {
-        assert.ok(retrieved);
     });
-};
-
-exports['test large floats'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
 
-    var retrieved = false;
+    it('should serialize RegExp()', function(done) {
+        var regexp = /^f\noo/;
+        db.run("INSERT INTO txt_table VALUES(?)", regexp);
+        db.get("SELECT txt FROM txt_table", function(err, row) {
+            if (err) throw err;
+            assert.equal(row.txt, String(regexp));
+            done();
+        });
+    });
 
-    var numbers = [
+    [
         4294967296.249,
         Math.PI,
         3924729304762836.5,
@@ -42,39 +47,18 @@ exports['test large floats'] = function(beforeExit) {
         -9.293476892934982e+300,
         -2.3948728634826374e+83,
         -Infinity
-    ];
-
-    db.serialize(function() {
-        db.run("CREATE TABLE foo (id INT, num FLOAT)");
-
-        var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
-        for (var i = 0; i < numbers.length; i++) {
-            stmt.run(i, numbers[i]);
-        }
-        stmt.finalize();
-
-        db.all("SELECT num FROM foo ORDER BY id", function(err, rows) {
+    ].forEach(function(flt) {
+        it('should serialize float ' + flt, function(done) {
+            db.run("INSERT INTO flt_table VALUES(?)", flt);
+            db.get("SELECT flt FROM flt_table", function(err, row) {
                 if (err) throw err;
-
-            for (var i = 0; i < rows.length; i++) {
-                assert.equal(numbers[i], rows[i].num);
-            }
-
-            retrieved = true;
-        })
+                assert.equal(row.flt, flt);
+                done();
+            });
         });
-
-    beforeExit(function() {
-        assert.ok(retrieved);
     });
-};
-
-exports['test large integers'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
-
-    var retrieved = false;
 
-    var numbers = [
+    [
         4294967299,
         3924729304762836,
         new Date().valueOf(),
@@ -84,29 +68,14 @@ exports['test large integers'] = function(beforeExit) {
         -9.293476892934982e+300,
         -2.3948728634826374e+83,
         -Infinity
-    ];
-
-    db.serialize(function() {
-        db.run("CREATE TABLE foo (id INT, num INTEGER)");
-
-        var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
-        for (var i = 0; i < numbers.length; i++) {
-            stmt.run(i, numbers[i]);
-        }
-        stmt.finalize();
-
-        db.all("SELECT num FROM foo ORDER BY id", function(err, rows) {
+    ].forEach(function(integer) {
+        it('should serialize integer ' + integer, function(done) {
+            db.run("INSERT INTO int_table VALUES(?)", integer);
+            db.get("SELECT int AS integer FROM int_table", function(err, row) {
                 if (err) throw err;
-
-            for (var i = 0; i < rows.length; i++) {
-                assert.equal(numbers[i], rows[i].num);
-            }
-
-            retrieved = true;
-        })
+                assert.equal(row.integer, integer);
+                done();
+            });
         });
-
-    beforeExit(function() {
-        assert.ok(retrieved);
     });
-};
+});

test/parallel_insert.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
-var util = require('util');
 var helper = require('./support/helper');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test parallel inserts'] = function(beforeExit) {
-    var completed = false;
+describe('parallel', function() {
+    var db;
+    before(function(done) {
         helper.deleteFile('test/tmp/test_parallel_inserts.db');
-    var db = new sqlite3.Database('test/tmp/test_parallel_inserts.db');
+        db = new sqlite3.Database('test/tmp/test_parallel_inserts.db', done);
+    });
 
     var columns = [];
     for (var i = 0; i < 128; i++) {
         columns.push('id' + i);
     }
 
-    db.serialize(function() {
-        db.run("CREATE TABLE foo (" + columns + ")");
+    it('should create the table', function(done) {
+        db.run("CREATE TABLE foo (" + columns + ")", done);
     });
 
+    it('should insert in parallel', function(done) {
         for (var i = 0; i < 1000; i++) {
             for (var values = [], j = 0; j < columns.length; j++) {
                 values.push(i * j);
@@ -26,13 +26,18 @@ exports['test parallel inserts'] = function(beforeExit) {
             db.run("INSERT INTO foo VALUES (" + values + ")");
         }
 
-    db.close(function() {
-        completed = true;
+        db.wait(done);
+    });
+
+    it('should close the database', function(done) {
+        db.close(done);
     });
 
-    beforeExit(function() {
-        assert.ok(completed);
+    it('should verify that the database exists', function() {
         assert.fileExists('test/tmp/test_parallel_inserts.db');
+    });
+
+    after(function() {
         helper.deleteFile('test/tmp/test_parallel_inserts.db');
     });
-};
+});

test/profile.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
-var util = require('util');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test Database profiling'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
+describe('profiling', function() {
     var create = false;
     var select = false;
 
+    var db;
+    before(function(done) {
+        db = new sqlite3.Database(':memory:', done);
+
         db.on('profile', function(sql, nsecs) {
             assert.ok(typeof nsecs === "number");
             if (sql.match(/^SELECT/)) {
@@ -25,16 +25,32 @@ exports['test Database profiling'] = function(beforeExit) {
                 assert.ok(false);
             }
         });
+    });
 
-    db.serialize(function() {
-        db.run("CREATE TABLE foo (id int)");
-        db.run("SELECT * FROM foo");
+    it('should profile a create table', function(done) {
+        assert.ok(!create);
+        db.run("CREATE TABLE foo (id int)", function(err) {
+            if (err) throw err;
+            process.nextTick(function() {
+                assert.ok(create);
+                done();
+            });
+        });
     });
 
-    db.close();
 
-    beforeExit(function() {
-        assert.ok(create);
+    it('should profile a select', function(done) {
+        assert.ok(!select);
+        db.run("SELECT * FROM foo", function(err) {
+            if (err) throw err;
+            process.nextTick(function() {
                 assert.ok(select);
+                done();
+            });
+        });
+    });
+
+    after(function(done) {
+        db.close(done);
     });
-};
+});

test/rerun.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test running the same statement multiple times'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
+describe('rerunning statements', function() {
+    var db;
+    before(function(done) { db = new sqlite3.Database(':memory:', done); });
 
     var count = 10;
     var inserted = 0;
     var retrieved = 0;
 
-    db.serialize(function() {
-       db.run("CREATE TABLE foo (id int)");
+    it('should create the table', function(done) {
+        db.run("CREATE TABLE foo (id int)", done);
+    });
 
+    it('should insert repeatedly, reusing the same statement', function(done) {
         var stmt = db.prepare("INSERT INTO foo VALUES(?)");
         for (var i = 5; i < count; i++) {
             stmt.run(i, function(err) {
@@ -20,8 +21,10 @@ exports['test running the same statement multiple times'] = function(beforeExit)
                 inserted++;
             });
         }
-       stmt.finalize();
+        stmt.finalize(done);
+    });
 
+    it('should retrieve repeatedly, resuing the same statement', function(done) {
         var collected = [];
         var stmt = db.prepare("SELECT id FROM foo WHERE id = ?");
         for (var i = 0; i < count; i++) {
@@ -30,14 +33,18 @@ exports['test running the same statement multiple times'] = function(beforeExit)
                 if (row) collected.push(row);
             });
         }
-       stmt.finalize(function() {
+        stmt.finalize(function(err) {
+            if (err) throw err;
             retrieved += collected.length;
             assert.deepEqual(collected, [ { id: 5 }, { id: 6 }, { id: 7 }, { id: 8 }, { id: 9 } ]);
+            done();
         });
     });
 
-    beforeExit(function() {
+    it('should have inserted and retrieved the right amount', function() {
         assert.equal(inserted, 5);
         assert.equal(retrieved, 5);
     });
-};
+
+    after(function(done) { db.close(done); });
+});

test/scheduling.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test scheduling a query after the database was closed'] = function(beforeExit) {
-    var error = false;
+describe('scheduling', function() {
+    it('scheduling after the database was closed', function(done) {
         var db = new sqlite3.Database(':memory:');
         db.on('error', function(err) {
-        error = true;
             assert.equal(err.message, "SQLITE_MISUSE: Database handle is closed");
+            done();
         });
 
         db.close();
         db.run("CREATE TABLE foo (id int)");
-
-    beforeExit(function() {
-        assert.ok(error);
     });
-};
 
 
-exports['test scheduling a query with callback after the database was closed'] = function(beforeExit) {
-    var error = false;
-    var errorEvent = false;
+    it('scheduling a query with callback after the database was closed', function(done) {
         var db = new sqlite3.Database(':memory:');
         db.on('error', function(err) {
-        errorEvent = true;
+            assert.ok(false, 'Event was accidentally triggered');
         });
 
         db.close();
         db.run("CREATE TABLE foo (id int)", function(err) {
             assert.ok(err.message, "SQLITE_MISUSE: Database handle is closed");
-        error = true;
+            done();
         });
-
-    beforeExit(function() {
-        assert.ok(error);
-        assert.ok(!errorEvent);
     });
-};
 
-exports['test running a query after the database was closed'] = function(beforeExit) {
-    var error = false;
+    it('running a query after the database was closed', function(done) {
         var db = new sqlite3.Database(':memory:');
 
         var stmt = db.prepare("SELECT * FROM sqlite_master", function(err) {
             if (err) throw err;
             db.close(function(err) {
                 assert.ok(err);
-            error = true;
                 assert.equal(err.message, "SQLITE_BUSY: unable to close due to unfinalised statements");
-            stmt.run();
+
+                // Running a statement now should not fail.
+                stmt.run(done);
             });
         });
-
-    beforeExit(function() {
-        assert.ok(error);
     });
-};
+});

test/serialization.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
 
-exports['test serialize() and parallelize()'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
+describe('serialize() and parallelize()', function() {
+    var db;
+    before(function(done) { db = new sqlite3.Database(':memory:', done); });
 
     var inserted1 = 0;
     var inserted2 = 0;
@@ -12,26 +12,32 @@ exports['test serialize() and parallelize()'] = function(beforeExit) {
 
     var count = 1000;
 
+    it('should toggle', function(done) {
         db.serialize();
         db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)");
-    db.parallelize();
+        db.parallelize(done);
+    });
 
+    it('should insert rows', function() {
         var stmt1 = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
         var stmt2 = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
         for (var i = 0; i < count; i++) {
+            // Interleaved inserts with two statements.
             stmt1.run('String ' + i, i, i * Math.PI, function(err) {
                 if (err) throw err;
                 inserted1++;
-            // Might sometimes fail, but should work fine most of the time.
-            assert.ok(inserted2 >= Math.floor(0.75 * inserted1));
             });
             i++;
             stmt2.run('String ' + i, i, i * Math.PI, function(err) {
                 if (err) throw err;
                 inserted2++;
-            assert.ok(inserted1 >= Math.floor(0.75 * inserted2));
             });
         }
+        stmt1.finalize();
+        stmt2.finalize();
+    });
+
+    it('should have inserted all the rows after synchronizing with serialize()', function(done) {
         db.serialize();
         db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) {
             if (err) throw err;
@@ -42,21 +48,26 @@ exports['test serialize() and parallelize()'] = function(beforeExit) {
                 assert.equal(rows[i].blb, null);
                 retrieved++;
             }
-    });
 
-    beforeExit(function() {
             assert.equal(count, inserted1 + inserted2, "Didn't insert all rows");
             assert.equal(count, retrieved, "Didn't retrieve all rows");
+            done();
+        });
     });
-}
 
-exports['test serialize(fn)'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
+    after(function(done) { db.close(done); });
+});
+
+describe('serialize(fn)', function() {
+    var db;
+    before(function(done) { db = new sqlite3.Database(':memory:', done); });
 
     var inserted = 0;
     var retrieved = 0;
 
     var count = 1000;
+
+    it('should call the callback', function(done) {
         db.serialize(function() {
             db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)");
 
@@ -67,6 +78,7 @@ exports['test serialize(fn)'] = function(beforeExit) {
                     inserted++;
                 });
             }
+            stmt.finalize();
 
             db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) {
                 if (err) throw err;
@@ -77,11 +89,16 @@ exports['test serialize(fn)'] = function(beforeExit) {
                     assert.equal(rows[i].blb, null);
                     retrieved++;
                 }
+                done();
+            });
         });
     });
 
-    beforeExit(function() {
+
+    it('should have inserted and retrieved all rows', function() {
         assert.equal(count, inserted, "Didn't insert all rows");
         assert.equal(count, retrieved, "Didn't retrieve all rows");
     });
-}
+
+    after(function(done) { db.close(done); });
+});

test/trace.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
-var util = require('util');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
-exports['test Database tracing'] = function(beforeExit) {
+describe('tracing', function() {
+    it('Database tracing', function(done) {
         var db = new sqlite3.Database(':memory:');
         var create = false;
         var select = false;
@@ -30,15 +28,16 @@ exports['test Database tracing'] = function(beforeExit) {
             db.run("SELECT * FROM foo");
         });
 
-    db.close();
-
-    beforeExit(function() {
+        db.close(function(err) {
+            if (err) throw err;
             assert.ok(create);
             assert.ok(select);
+            done();
         });
-};
+    });
+
 
-exports['test disabling tracing #1'] = function(beforeExit) {
+    it('test disabling tracing #1', function(done) {
         var db = new sqlite3.Database(':memory:');
 
         db.on('trace', function(sql) {});
@@ -48,10 +47,11 @@ exports['test disabling tracing #1'] = function(beforeExit) {
         };
 
         db.run("CREATE TABLE foo (id int)");
-    db.close();
-};
+        db.close(done);
+    });
+
 
-exports['test disabling tracing #2'] = function(beforeExit) {
+    it('test disabling tracing #2', function(done) {
         var db = new sqlite3.Database(':memory:');
 
         var trace = function(sql) {};
@@ -62,5 +62,6 @@ exports['test disabling tracing #2'] = function(beforeExit) {
         };
 
         db.run("CREATE TABLE foo (id int)");
-    db.close();
-};
+        db.close(done);
+    });
+});

test/unicode.test.js

-var sqlite3 = require('sqlite3');
+var sqlite3 = require('..');
 var assert = require('assert');
 
-if (process.setMaxListeners) process.setMaxListeners(0);
-
 function randomString() {
     var str = '';
     for (var i = Math.random() * 300; i > 0; i--) {
         str += String.fromCharCode(Math.floor(Math.random() * 65536));
     }
     return str;
-};
+}
 
-exports['test unicode characters'] = function(beforeExit) {
-    var db = new sqlite3.Database(':memory:');
+describe('unicode', function() {
+    var db;
+    before(function(done) { db = new sqlite3.Database(':memory:', done); });
 
         // Generate random data.
     var data = [];
@@ -24,9 +23,11 @@ exports['test unicode characters'] = function(beforeExit) {
     var inserted = 0;
     var retrieved = 0;
 
-    db.serialize(function() {
-       db.run("CREATE TABLE foo (id int, txt text)");
+    it('should create the table', function(done) {
+        db.run("CREATE TABLE foo (id int, txt text)", done);
+    });
 
+    it('should insert all values', function(done) {
         var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
         for (var i = 0; i < data.length; i++) {
             stmt.run(i, data[i], function(err) {
@@ -34,8 +35,10 @@ exports['test unicode characters'] = function(beforeExit) {
                 inserted++;
             });
         }
-       stmt.finalize();
+        stmt.finalize(done);
+    });
 
+    it('should retrieve all values', function(done) {
         db.all("SELECT txt FROM foo ORDER BY id", function(err, rows) {
             if (err) throw err;
 
@@ -43,11 +46,14 @@ exports['test unicode characters'] = function(beforeExit) {
                 assert.equal(rows[i].txt, data[i]);
                 retrieved++;
             }
+            done();
         });
     });
 
-    beforeExit(function() {
+    it('should have inserted and retrieved the correct amount', function() {
         assert.equal(inserted, length);
         assert.equal(retrieved, length);
     });
-};
+
+    after(function(done) { db.close(done); });
+});