diff --git a/Gruntfile.js b/Gruntfile.js
index 2358ec0e..14274ba5 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -42,21 +42,11 @@ module.exports = function(grunt) {
       },
       unittests: {
         files: {
-          'test/lib/test-bundle.js': []
+          'test/lib/unittests-bundle.js': []
         },
         options: {
           debug: true,
-          alias: './test/test-all.js:unittests',
-          external: [ 'openpgp', 'keyring' ]
-        }
-      },
-      ci_tests: {
-        files: {
-          'test/lib/ci-tests-bundle.js': []
-        },
-        options: {
-          debug: true,
-          alias: './test/ci-tests-all.js:ci-tests',
+          alias: './test/unittests.js:unittests',
           external: [ 'openpgp', 'keyring' ]
         }
       }
@@ -120,7 +110,7 @@ module.exports = function(grunt) {
         expand: true,
         flatten: true,
         cwd: 'node_modules/',
-        src: ['mocha/mocha.css', 'mocha/mocha.js', 'chai/chai.js', 'sinon/pkg/sinon.js'],
+        src: ['mocha/mocha.css', 'mocha/mocha.js', 'chai/chai.js'],
         dest: 'test/lib/'
       }
     }
@@ -147,10 +137,11 @@ module.exports = function(grunt) {
   // Alias the `mocha_phantomjs` task to run `mocha-phantomjs`
   grunt.registerTask('mocha_phantomjs', 'mocha-phantomjs', function () {
     var done = this.async();
-    require('child_process').exec('node_modules/mocha-phantomjs/bin/mocha-phantomjs ./test/ci-tests.html', function (err, stdout) {
-      grunt.log.write(stdout);
+    var mocha = require('child_process').exec('node_modules/mocha-phantomjs/bin/mocha-phantomjs ./test/unittests.html', function (err) {
       done(err);
     });
+    mocha.stdout.pipe(process.stdout);
+    mocha.stderr.pipe(process.stderr);
   });
 
   // Test/Dev tasks
diff --git a/Makefile b/Makefile
index fc8a6605..e1646bc2 100644
--- a/Makefile
+++ b/Makefile
@@ -2,11 +2,10 @@ default: help
 
 help:
 	@echo "update         - get latest sources"
-	@echo "minify         - makes JavaScript download and run faster"
+	@echo "bundle         - makes JavaScript download and run faster"
 	@echo "lint           - checks JavaScript files for style issues"
 	@echo "test           - runs JavaScript unit tests"
 	@echo "example        - creates a simple example"
-	@echo "ext-chr-gmail  - creates the Google Chrome / Google Mail extension"
 	@echo "documentation  - generates documentation. Requires jsdoc (3.2) in PATH"
 
 update: update-me update-deps
@@ -17,34 +16,20 @@ update-me:
 update-deps:
 	@git submodule foreach git pull
 
+bundle:
+	@grunt
+
+lint:
+	@grunt jshint
+
+test:
+	@npm test
+
 example:
 	@mkdir -p build
 	@rm -f build/openpgpjs-0.x.zip
 	@zip -j build/openpgpjs-0.x.zip resources/example.* resources/openpgp.min.js resources/jquery.min.js
 	@echo "Have a look at build/openpgpjs-0.x.zip"
 
-ext-chr-gmail:
-	@./scripts/create_extension.sh
-
-lint:
-	@echo See http://code.google.com/closure/utilities/
-	@./scripts/lint.sh
-
-bundle:
-	@browserify -d -r ./src/:openpgp > ./resources/openpgp.js
-	@browserify -r ./src/:openpgp > ./resources/openpgp_nodebug.js
-	@browserify -d -x openpgp -r ./src/keyring/:keyring > ./resources/keyring.js
-	@browserify -x openpgp -r ./src/keyring/:keyring > ./resources/keyring_nodebug.js
-
-bundle-test:
-	@browserify -d -x openpgp -x keyring -r ./test/test-all.js:unittests > ./test/lib/test-bundle.js
-
-bundle-ci-test:
-	@browserify -d -x openpgp -x keyring -r ./test/ci-tests-all.js:ci-tests > ./test/lib/ci-tests-bundle.js
-
-test:
-	@echo to be implemented
-	@echo Open test/index.html instead
-
 documentation:
-	@jsdoc src -r -d doc
+	@grunt jsdoc
diff --git a/package.json b/package.json
index 556d3ca1..e4b5c2d5 100644
--- a/package.json
+++ b/package.json
@@ -17,7 +17,6 @@
     "mocha-phantomjs": "~3.1.6",
     "phantomjs": "~1.9.2-5",
     "chai": "~1.8.1",
-    "sinon": "~1.7.3",
     "grunt-contrib-copy": "~0.4.1",
     "grunt-browserify": "~1.2.11",
     "grunt-contrib-uglify": "*",
diff --git a/test/ci-quick.js b/test/ci-quick.js
deleted file mode 100644
index bcc64ffe..00000000
--- a/test/ci-quick.js
+++ /dev/null
@@ -1,237 +0,0 @@
-var openpgp = require('openpgp');
-
-'use strict';
-
-var expect = chai.expect;
-
-describe('Openpgp integration tests', function() {
-    var user = 'test@t-online.de',
-        passphrase = 'asdf',
-        keySize = 512,
-        keyId = 'F6F60E9B42CDFF4C',
-        pubkey = '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' +
-            'Version: OpenPGP.js v.1.20131011\n' +
-            'Comment: http://openpgpjs.org\n' +
-            '\n' +
-            'xk0EUlhMvAEB/2MZtCUOAYvyLFjDp3OBMGn3Ev8FwjzyPbIF0JUw+L7y2XR5\n' +
-            'RVGvbK88unV3cU/1tOYdNsXI6pSp/Ztjyv7vbBUAEQEAAc0pV2hpdGVvdXQg\n' +
-            'VXNlciA8d2hpdGVvdXQudGVzdEB0LW9ubGluZS5kZT7CXAQQAQgAEAUCUlhM\n' +
-            'vQkQ9vYOm0LN/0wAAAW4Af9C+kYW1AvNWmivdtr0M0iYCUjM9DNOQH1fcvXq\n' +
-            'IiN602mWrkd8jcEzLsW5IUNzVPLhrFIuKyBDTpLnC07Loce1\n' +
-            '=6XMW\n' +
-            '-----END PGP PUBLIC KEY BLOCK-----',
-        privkey = '-----BEGIN PGP PRIVATE KEY BLOCK-----\n' +
-            'Version: OpenPGP.js v.1.20131011\n' +
-            'Comment: http://openpgpjs.org\n' +
-            '\n' +
-            'xcBeBFJYTLwBAf9jGbQlDgGL8ixYw6dzgTBp9xL/BcI88j2yBdCVMPi+8tl0\n' +
-            'eUVRr2yvPLp1d3FP9bTmHTbFyOqUqf2bY8r+72wVABEBAAH+AwMIhNB4ivtv\n' +
-            'Y2xg6VeMcjjHxZayESHACV+nQx5Tx6ev6xzIF1Qh72fNPDppLhFSFOuTTMsU\n' +
-            'kTN4c+BVYt29spH+cA1jcDAxQ2ULrNAXo+hheOqhpedTs8aCbcLFkJAS16hk\n' +
-            'YSk4OnJgp/z24rVju1SHRSFbgundPzmNgXeX9e8IkviGhhQ11Wc5YwVkx03t\n' +
-            'Z3MdDMF0jyhopbPIoBdyJB0dhvBh98w3JmwpYh9wjUA9MBHD1tvHpRmSZ3BM\n' +
-            'UCmATn2ZLWBRWiYqFbgDnL1GM80pV2hpdGVvdXQgVXNlciA8d2hpdGVvdXQu\n' +
-            'dGVzdEB0LW9ubGluZS5kZT7CXAQQAQgAEAUCUlhMvQkQ9vYOm0LN/0wAAAW4\n' +
-            'Af9C+kYW1AvNWmivdtr0M0iYCUjM9DNOQH1fcvXqIiN602mWrkd8jcEzLsW5\n' +
-            'IUNzVPLhrFIuKyBDTpLnC07Loce1\n' +
-            '=ULta\n' +
-            '-----END PGP PRIVATE KEY BLOCK-----';
-       var keyringClass = require('keyring');
-       var keyring = new keyringClass();
-
-    describe('Generate key pair', function() {
-        it('should work', function(done) {
-            // generate keypair (keytype 1=RSA)
-            var errMsg, err;
-            var keys = null;
-
-            try {
-                var userId = 'Whiteout User <' + user + '>';
-                var keys = openpgp.generateKeyPair(1, keySize, userId, passphrase);
-                var keyId = openpgp.util.hexstrdump(keys.key.getKeyPacket().getKeyId()).toUpperCase();
-                expect(keyId).to.exist;
-                expect(keys.privateKeyArmored).to.exist;
-                expect(keys.publicKeyArmored).to.exist;
-            } catch (e) {
-                errMsg = 'Keygeneration failed!';
-                err = e;
-            }
-
-            expect(err).to.not.exist;
-            done();
-        });
-    });
-
-    describe('Keyring', function() {
-        describe('Import key pair', function() {
-            it('should work', function(done) {
-                // clear any keypair already in the keychain
-                keyring.clear();
-                keyring.importKey(privkey);
-                keyring.importKey(pubkey);
-                done();
-            });
-        });
-        describe('Retrieve keys', function() {
-            it('getPublicKeyForAddress() - unknown address', function(done) {
-                var key = keyring.getPublicKeyForAddress('nobody@example.com');
-                expect(key).to.be.empty;
-                done();
-            });
-            it('getPublicKeyForAddress() - valid address', function(done) {
-                var key = keyring.getPublicKeyForAddress(user);
-                expect(key).to.exist;
-                done();
-            });
-            it('getPrivateKeyForAddress() - unknown address', function(done) {
-                var key = keyring.getPrivateKeyForAddress('nobody@example.com');
-                expect(key).to.be.empty;
-                done();
-            });
-            it('getPrivateKeyForAddress() - valid address', function(done) {
-                var key = keyring.getPrivateKeyForAddress(user);
-                expect(key).to.exist;
-                done();
-            });
-            it('getKeysForKeyId() - unknown id', function(done) {
-                var keys = keyring.getKeysForKeyId('000102030405060708');
-                expect(keys).to.be.empty;
-                done();
-            });
-            it('getKeysForKeyId() - valid id', function(done) {
-                var keys = keyring.getKeysForKeyId(keyId.toLowerCase());
-                expect(keys).to.exist.and.have.length(1);
-                done();
-            });
-        });
-    });
-
-    describe('Encryption', function() {
-        var message = 'asdfs\n\nThursday, Nov 21, 2013 7:38 PM asdf@example.com wrote:\n' +
-                            '> asdf\n' +
-                            '> \n' +
-                            '> Thursday, Nov 21, 2013 7:32 PM asdf@example.com wrote:\n' +
-                            '> > secret 3',
-            ciphertext;
-
-        describe('Encrypt and Sign', function() {
-            it('should work', function(done) {
-                var signkey = openpgp.key.readArmored(privkey).keys[0];
-                expect(signkey).to.exist;
-                var encryptkey = openpgp.key.readArmored(pubkey).keys[0];
-                expect(encryptkey).to.exist;
-                expect(signkey.decrypt(passphrase)).to.be.true;
-                ciphertext = openpgp.signAndEncryptMessage([encryptkey], signkey, message);
-                expect(ciphertext).to.exist;
-                done();
-            });
-        });
-
-        describe('Decrypt and Verify', function() {
-            it('should work', function(done) {
-                var decryptkey = openpgp.key.readArmored(privkey).keys[0];
-                expect(decryptkey, 'decryptkey').to.exist;
-                var verifykey = openpgp.key.readArmored(pubkey).keys[0];
-                expect(verifykey, 'verifykey').to.exist;
-                var pgpmsg = openpgp.message.readArmored(ciphertext);
-                expect(pgpmsg, 'pgpmsg').to.exist;
-                var keyids = pgpmsg.getEncryptionKeyIds();
-                expect(keyids, 'keyids').to.exist;
-                expect(decryptkey.decryptKeyPacket(keyids, passphrase), 'decryptKeyPacket()').to.be.true;
-                var result = openpgp.decryptAndVerifyMessage(decryptkey, [verifykey], pgpmsg);
-                expect(result, 'decryptAndVerifyMessage() result').to.exist;
-                expect(result.text, 'decryptAndVerifyMessage() result.text').to.exist.and.equal(message);
-                expect(result.signatures, 'decryptAndVerifyMessage() result.signatures').to.exist.and.not.be.empty;
-                expect(result.signatures[0].valid, 'decryptAndVerifyMessage() result.signatures[0].valid').to.be.true;
-                done();
-            });
-        });
-    });
-
-    describe('Verify clearsign from gpg', function() {
-        describe('Verify V3 signature', function() {
-            var v3_clearsign_msg = '-----BEGIN PGP SIGNED MESSAGE-----\r\n' +
-                'Hash: SHA1\r\n' +
-                '\r\n' +
-                'This is a test message.\r\n' +
-                '\r\n' +
-                'This paragraph is separated form the next by a line of dashes.\r\n' +
-                '\r\n' +
-                '- --------------------------------------------------------------------------\r\n' +
-                '\r\n' +
-                'The next paragraph has a number of blank lines between this one and it.\r\n' +
-                '\r\n' +
-                '\r\n' +
-                '\r\n' +
-                '\r\n' +
-                '\r\n' +
-                '\r\n' +
-                'This is the last paragraph.\r\n' +
-                '\r\n' +
-                '- --\r\n' +
-                '\r\n' +
-                'Joe Test\r\n' +
-                '-----BEGIN PGP SIGNATURE-----\r\n' +
-                'Version: GnuPG v1.4.15 (GNU/Linux)\r\n' +
-                '\r\n' +
-                'iQBVAwUBUp/7GPb2DptCzf9MAQKviQH6A6Pqa63kxWI+atMiaSXz5uifgsBoiOof\r\n' +
-                'E3/oVTIGyGTgB7KnwZiFkDMFrUNREJVSQGt6+4nxje8gARcuYpMnWw==\r\n' +
-                '=lOCC\r\n' +
-                '-----END PGP SIGNATURE-----\r\n';
-            it('should work', function(done) {
-                var cleartext = openpgp.cleartext.readArmored(v3_clearsign_msg);
-                expect(cleartext).to.exist;
-                var verifykey = openpgp.key.readArmored(pubkey).keys[0];
-                expect(verifykey, 'verifykey').to.exist;
-                var result = cleartext.verify([verifykey])
-                expect(result, 'verify() result').to.exist.and.not.be.empty;
-                expect(result[0].keyid, 'verify() result[0].keyid').to.exist;
-                expect(result[0].valid, 'verify() result[0].valid').to.be.true;
-                done();
-            });
-        });
-
-        describe('Verify V4 signature', function() {
-            var v4_clearsign_msg = '-----BEGIN PGP SIGNED MESSAGE-----\r\n' +
-                'Hash: SHA1\r\n' +
-                '\r\n' +
-                'This is a test message.\r\n' +
-                '\r\n' +
-                'This paragraph is separated form the next by a line of dashes.\r\n' +
-                '\r\n' +
-                '- --------------------------------------------------------------------------\r\n' +
-                '\r\n' +
-                'The next paragraph has a number of blank lines between this one and it.\r\n' +
-                '\r\n' +
-                '\r\n' +
-                '\r\n' +
-                '\r\n' +
-                '\r\n' +
-                '\r\n' +
-                'This is the last paragraph.\r\n' +
-                '\r\n' +
-                '- --\r\n' +
-                '\r\n' +
-                'Joe Test\r\n' +
-                '-----BEGIN PGP SIGNATURE-----\r\n' +
-                'Version: GnuPG v1.4.15 (GNU/Linux)\r\n' +
-                '\r\n' +
-                'iFwEAQECAAYFAlKf5LcACgkQ9vYOm0LN/0ybVwH8CItdDh4kWKVcyUx3Q3hWZnWd\r\n' +
-                'zP9CUbIa9uToIPABjV3GOTDM3ZgiP0/SE6Al5vG8hlx+/u2piVojoLovk/4LnA==\r\n' +
-                '=i6ew\r\n' +
-                '-----END PGP SIGNATURE-----\r\n';
-
-            it('should work', function(done) {
-                var cleartext = openpgp.cleartext.readArmored(v4_clearsign_msg);
-                expect(cleartext).to.exist;
-                var verifykey = openpgp.key.readArmored(pubkey).keys[0];
-                expect(verifykey, 'verifykey').to.exist;
-                var result = cleartext.verify([verifykey])
-                expect(result, 'verify() result').to.exist.and.not.be.empty;
-                expect(result[0].keyid, 'verify() result[0].keyid').to.exist;
-                expect(result[0].valid, 'verify() result[0].valid').to.be.true;
-                done();
-            });
-        });
-    });
-});
diff --git a/test/ci-tests-all.js b/test/ci-tests-all.js
deleted file mode 100644
index 50546202..00000000
--- a/test/ci-tests-all.js
+++ /dev/null
@@ -1 +0,0 @@
-require('./ci-quick.js');
diff --git a/test/crypto/cipher/aes.js b/test/crypto/cipher/aes.js
index f1089fe7..62166a7b 100644
--- a/test/crypto/cipher/aes.js
+++ b/test/crypto/cipher/aes.js
@@ -1,11 +1,10 @@
-var unit = require('../../unit.js');
+'use strict';
 
-unit.register("AES Rijndael cipher test with test vectors from ecb_tbl.txt", function() {
-  var openpgp = require('openpgp');
-  var util = openpgp.util;
-
-  var result = new Array();
+var openpgp = require('openpgp'),
+  util = openpgp.util,
+  expect = chai.expect;
 
+describe('AES Rijndael cipher test with test vectors from ecb_tbl.txt', function() {
   function test_aes(input, key, output) {
     var aes = new openpgp.crypto.cipher.aes128(util.bin2str(key));
 
@@ -62,60 +61,33 @@ unit.register("AES Rijndael cipher test with test vectors from ecb_tbl.txt", fun
               [[0x08,0x09,0x0A,0x0B,0x0D,0x0E,0x0F,0x10,0x12,0x13,0x14,0x15,0x17,0x18,0x19,0x1A,0x1C,0x1D,0x1E,0x1F,0x21,0x22,0x23,0x24,0x26,0x27,0x28,0x29,0x2B,0x2C,0x2D,0x2E],[0x06,0x9A,0x00,0x7F,0xC7,0x6A,0x45,0x9F,0x98,0xBA,0xF9,0x17,0xFE,0xDF,0x95,0x21],[0x08,0x0E,0x95,0x17,0xEB,0x16,0x77,0x71,0x9A,0xCF,0x72,0x80,0x86,0x04,0x0A,0xE3]],
               [[0x30,0x31,0x32,0x33,0x35,0x36,0x37,0x38,0x3A,0x3B,0x3C,0x3D,0x3F,0x40,0x41,0x42,0x44,0x45,0x46,0x47,0x49,0x4A,0x4B,0x4C,0x4E,0x4F,0x50,0x51,0x53,0x54,0x55,0x56],[0x72,0x61,0x65,0xC1,0x72,0x3F,0xBC,0xF6,0xC0,0x26,0xD7,0xD0,0x0B,0x09,0x10,0x27],[0x7C,0x17,0x00,0x21,0x1A,0x39,0x91,0xFC,0x0E,0xCD,0xED,0x0A,0xB3,0xE5,0x76,0xB0]]];
 
-  var res = true;
-  var j = 0;
-  for (var i = 0; i < testvectors128.length; i++) {
-    var res2 = test_aes(testvectors128[i][1],testvectors128[i][0],testvectors128[i][2]);
-    res &= res2;
-    if (!res2) {
-      result[j] = new unit.result("Testing 128 bit key vector with block "+
-        util.hexidump(testvectors128[i][1])+
-        " and key "+util.hexidump(testvectors128[i][0])+
-        " should be "+util.hexidump(testvectors128[i][2]),
-        false);
-      j++;
+  it('128 bit key', function (done) {
+    for (var i = 0; i < testvectors128.length; i++) {
+      var res = test_aes(testvectors128[i][1],testvectors128[i][0],testvectors128[i][2]);
+      expect(res, 'block ' + util.hexidump(testvectors128[i][1]) +
+                  ' and key '+util.hexidump(testvectors128[i][0]) +
+                  ' should be '+util.hexidump(testvectors128[i][2])).to.be.true;
     }
-  }
-  if (res) {
-    result[j] = new unit.result("128 bit key test vectors completed.",true)
-    j++;
-  }
-  
-  res = true;
-  for (var i = 0; i < testvectors192.length; i++) {
-    var res2 = test_aes(testvectors192[i][1],testvectors192[i][0],testvectors192[i][2]);
-    res &= res2;
-    if (!res2) {
-      result[j] = new unit.result("Testing 192 bit key vector with block "+
-        util.hexidump(testvectors192[i][1])+
-        " and key "+util.hexidump(testvectors192[i][0])+
-        " should be "+util.hexidump(testvectors192[i][2]),
-        false);
-      j++;
-    }
-  }
-  if (res) {
-    result[j] = new unit.result("192 bit key test vectors completed.",true)
-    j++;
-  }
+    done();
+  });
 
-  res = true;
-  for (var i = 0; i < testvectors256.length; i++) {
-    var res2 = test_aes(testvectors256[i][1],testvectors256[i][0],testvectors256[i][2]);
-    res &= res2;
-    if (!res2) {
-      result[j] = new unit.result("Testing 256 bit key vector with block "+
-        util.hexidump(testvectors256[i][1])+
-        " and key "+util.hexidump(testvectors256[i][0])+
-        " should be "+util.hexidump(testvectors256[i][2]),
-        false);
-      j++;
+  it('192 bit key', function (done) {
+    for (var i = 0; i < testvectors192.length; i++) {
+      var res = test_aes(testvectors192[i][1],testvectors192[i][0],testvectors192[i][2]);
+      expect(res, 'block ' + util.hexidump(testvectors192[i][1]) +
+                  ' and key ' + util.hexidump(testvectors192[i][0])+
+                  ' should be ' + util.hexidump(testvectors192[i][2])).to.be.true;
     }
-  }
-  if (res) {
-    result[j] = new unit.result("256 bit key test vectors completed.", true)
-    j++;
-  }
+    done();
+  });
 
-  return result;
+  it('256 bit key', function (done) {
+    for (var i = 0; i < testvectors256.length; i++) {
+      var res = test_aes(testvectors256[i][1],testvectors256[i][0],testvectors256[i][2]);
+      expect(res, 'block ' + util.hexidump(testvectors256[i][1]) +
+                  ' and key ' + util.hexidump(testvectors256[i][0]) +
+                  ' should be ' + util.hexidump(testvectors256[i][2]));
+    }
+    done();
+  });
 });
diff --git a/test/crypto/cipher/blowfish.js b/test/crypto/cipher/blowfish.js
index 93621767..806e33cd 100644
--- a/test/crypto/cipher/blowfish.js
+++ b/test/crypto/cipher/blowfish.js
@@ -1,17 +1,18 @@
-var unit = require('../../unit.js');
+'use strict';
 
-unit.register("Blowfish cipher test with test vectors from http://www.schneier.com/code/vectors.txt", function() {
-  var openpgp = require('openpgp'),
-    util = openpgp.util,
-    BFencrypt = openpgp.crypto.cipher.blowfish;
+var openpgp = require('openpgp'),
+  util = openpgp.util,
+  BFencrypt = openpgp.crypto.cipher.blowfish,
+  expect = chai.expect;
 
-  var result = [];
+it('Blowfish cipher test with test vectors from http://www.schneier.com/code/vectors.txt', function(done) {
   function test_bf(input, key, output) {
     var blowfish = new openpgp.crypto.cipher.blowfish(util.bin2str(key));
     var result = util.bin2str(blowfish.encrypt(input));
 
     return (util.hexstrdump(result) == util.hexstrdump(util.bin2str(output)));
   }
+
   var testvectors = [[[0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00],[0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00],[0x4E,0xF9,0x97,0x45,0x61,0x98,0xDD,0x78]],
                      [[0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF],[0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF],[0x51,0x86,0x6F,0xD5,0xB8,0x5E,0xCB,0x8A]],
                      [[0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00],[0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x01],[0x7D,0x85,0x6F,0x9A,0x61,0x30,0x63,0xF2]],
@@ -47,21 +48,11 @@ unit.register("Blowfish cipher test with test vectors from http://www.schneier.c
                      [[0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF],[0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00],[0x24,0x59,0x46,0x88,0x57,0x54,0x36,0x9A]],
                      [[0xFE,0xDC,0xBA,0x98,0x76,0x54,0x32,0x10],[0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF],[0x6B,0x5C,0x5A,0x9C,0x5D,0x9E,0x0A,0x5A]]];
 
-  var res = true;
-  var j = 0;
   for (var i = 0; i < testvectors.length; i++) {
-    var res2 = test_bf(testvectors[i][1],testvectors[i][0],testvectors[i][2]);
-    res &= res2;
-    if (!res2) {
-      result[j] = new unit.result("Testing vector "+i+" with block "+
-        util.hexidump(testvectors[i][0])+
-        " and key "+util.hexidump(testvectors[i][1])+
-        " should be "+util.hexidump(testvectors[i][2]), false);
-      j++;
-    }
+    var res = test_bf(testvectors[i][1],testvectors[i][0],testvectors[i][2]);
+    expect(res, 'vector '+ i + '" with block ' + util.hexidump(testvectors[i][0])+
+                ' and key ' + util.hexidump(testvectors[i][1]) +
+                ' should be ' + util.hexidump(testvectors[i][2]), false);
   }
-  if (res) {
-    result[j] = new unit.result("34 test vectors completed ", true);
-  }
-  return result;
+  done();
 });
diff --git a/test/crypto/cipher/cast5.js b/test/crypto/cipher/cast5.js
index 98828d7a..c1fc7344 100644
--- a/test/crypto/cipher/cast5.js
+++ b/test/crypto/cipher/cast5.js
@@ -1,10 +1,10 @@
-var unit = require('../../unit.js');
+'use strict';
 
-unit.register("CAST-128 cipher test with test vectors from RFC2144", function() {
-	var openpgp = require('openpgp'),
-		util = openpgp.util;
+var openpgp = require('openpgp'),
+  util = openpgp.util,
+  expect = chai.expect;
 
-	var result = [];
+it('CAST-128 cipher test with test vectors from RFC2144', function (done) {
 	function test_cast(input, key, output) {
 		var cast5 = new openpgp.crypto.cipher.cast5(util.bin2str(key));
 		var result = util.bin2str(cast5.encrypt(input));
@@ -15,11 +15,10 @@ unit.register("CAST-128 cipher test with test vectors from RFC2144", function()
 	var testvectors = [[[0x01,0x23,0x45,0x67,0x12,0x34,0x56,0x78,0x23,0x45,0x67,0x89,0x34,0x56,0x78,0x9A],[0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF],[0x23,0x8B,0x4F,0xE5,0x84,0x7E,0x44,0xB2]]];
 
 	for (var i = 0; i < testvectors.length; i++) {
-		result[i] = new unit.result("Testing vector with block "+
-				util.hexidump(testvectors[i][0])+
-				" and key "+util.hexidump(testvectors[i][1])+
-				" should be "+util.hexidump(testvectors[i][2]),
-			test_cast(testvectors[i][1],testvectors[i][0],testvectors[i][2]));
+    var res = test_cast(testvectors[i][1],testvectors[i][0],testvectors[i][2]);
+		expect(res, 'vector with block ' + util.hexidump(testvectors[i][0]) +
+                ' and key ' + util.hexidump(testvectors[i][1]) +
+                ' should be ' + util.hexidump(testvectors[i][2])).to.be.true;
 	}
-	return result;
+  done();
 });
diff --git a/test/crypto/cipher/des.js b/test/crypto/cipher/des.js
index 5a3ea465..d002fe0b 100644
--- a/test/crypto/cipher/des.js
+++ b/test/crypto/cipher/des.js
@@ -1,10 +1,10 @@
-var unit = require('../../unit.js');
+'use strict';
 
-unit.register("TripleDES (EDE) cipher test with test vectors from http://csrc.nist.gov/publications/nistpubs/800-20/800-20.pdf", function() {
-  var openpgp = require('openpgp'),
-    util = openpgp.util;
+var openpgp = require('openpgp'),
+  util = openpgp.util,
+  expect = chai.expect;
 
-  var result = [];
+describe('TripleDES (EDE) cipher test with test vectors from http://csrc.nist.gov/publications/nistpubs/800-20/800-20.pdf', function() {
   var key = util.bin2str([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]);
   var testvectors = [[[0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00],[0x95,0xF8,0xA5,0xE5,0xDD,0x31,0xD9,0x00]],
                      [[0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00],[0xDD,0x7F,0x12,0x1C,0xA5,0x01,0x56,0x19]],
@@ -71,38 +71,21 @@ unit.register("TripleDES (EDE) cipher test with test vectors from http://csrc.ni
                      [[0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02],[0x06,0xE7,0xEA,0x22,0xCE,0x92,0x70,0x8F]],
                      [[0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01],[0x16,0x6B,0x40,0xB4,0x4A,0xBA,0x4B,0xD6]]];
 
-  var res = true;
-  var j = 0;
-  for (var i = 0; i < testvectors.length; i++) {
-    var des = new openpgp.crypto.cipher.des(key);
+  it('3DES EDE test vectors', function (done) {
+    for (var i = 0; i < testvectors.length; i++) {
+      var des = new openpgp.crypto.cipher.des(key);
 
-    var encr = util.bin2str(des.encrypt(testvectors[i][0], key));
-    var res2 = encr == util.bin2str(testvectors[i][1]);
+      var encr = util.bin2str(des.encrypt(testvectors[i][0], key));
 
-    res &= res2;
-
-    if (!res2) {
-    result[j] = new unit.result("Testing vector with block " +
-        util.hexidump(testvectors[i][0]) +
-        " and key " + util.hexstrdump(key) +
-        " should be " + util.hexidump(testvectors[i][1]) + " != " +
-        util.hexidump(encr),
-      false);
-    j++;
+      expect(encr, 'vector with block ' + util.hexidump(testvectors[i][0]) +
+                   ' and key ' + util.hexstrdump(key) +
+                   ' should be ' + util.hexidump(testvectors[i][1]) +
+                   ' != ' + util.hexidump(encr)).to.be.equal(util.bin2str(testvectors[i][1]));
     }
-  }
-  if (res) {
-    result[j] = new unit.result("All 3DES EDE test vectors completed", true);
-  }
-  return result;
-});
+    done();
+  });
 
-
-unit.register("DES encrypt/decrypt padding tests", function () {
-    var openpgp = require('openpgp'),
-      util = openpgp.util;
-
-    var result = [];
+  it('DES encrypt/decrypt padding tests', function (done) {
     var key = util.bin2str([0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF]);
     var testvectors = new Array();
     testvectors[0] = [[[0x01], [0x24, 0xC7, 0x4A, 0x9A, 0x79, 0x75, 0x4B, 0xC7]],
@@ -132,34 +115,27 @@ unit.register("DES encrypt/decrypt padding tests", function () {
 
     var des = new openpgp.crypto.cipher.originalDes(key);
 
-    var res = true;
-    var j = 0;
-
     for (var padding = 0; padding < 3; padding++) {
-        var thisVectorSet = testvectors[padding];
+      var thisVectorSet = testvectors[padding];
 
-        for (var i = 0; i < thisVectorSet.length; i++) {
-            var encrypted = des.encrypt(thisVectorSet[i][0], padding);
-            var decrypted = des.decrypt(encrypted, padding);
+      for (var i = 0; i < thisVectorSet.length; i++) {
+        var encrypted = des.encrypt(thisVectorSet[i][0], padding);
+        var decrypted = des.decrypt(encrypted, padding);
 
-            var res2 = (util.bin2str(encrypted) == util.bin2str(thisVectorSet[i][1]));
-            var res3 = (util.bin2str(decrypted) == util.bin2str(thisVectorSet[i][0]));
-            res &= res2;
-            res &= res3;
-            if (!res2 || !res3) {
-                result[j] = new unit.result(
-                    "Testing vector with block [" +
-                        util.hexidump(thisVectorSet[i][0]) +
-                        "] and key [" + util.hexstrdump(key) +
-                        "] and padding [" + padding +
-                        "] should be " + util.hexidump(thisVectorSet[i][1]) + " - Actually [ENC:" + util.hexidump(encrypted) + ", DEC:" + util.hexidump(decrypted) + "]",
-                    false);
-                j++;
-            }
-        }
+        expect(util.bin2str(encrypted), 'vector with block [' + util.hexidump(thisVectorSet[i][0]) +
+          '] and key [' + util.hexstrdump(key) +
+          '] and padding [' + padding +
+          '] should be ' + util.hexidump(thisVectorSet[i][1]) +
+          ' - Actually [' + util.hexidump(encrypted) +
+          ']').to.equal(util.bin2str(thisVectorSet[i][1]));
+        expect(util.bin2str(decrypted), 'vector with block [' + util.hexidump(thisVectorSet[i][0]) +
+          '] and key [' + util.hexstrdump(key) +
+          '] and padding [' + padding +
+          '] should be ' + util.hexidump(thisVectorSet[i][0]) +
+          ' - Actually [' + util.hexidump(decrypted) +
+          ']').to.equal(util.bin2str(thisVectorSet[i][0]));
+      }
     }
-    if (res) {
-        result[j] = new unit.result("All DES test vectors completed", true);
-    }
-    return result;
+    done();
+  });
 });
diff --git a/test/crypto/cipher/index.js b/test/crypto/cipher/index.js
new file mode 100644
index 00000000..6737cca1
--- /dev/null
+++ b/test/crypto/cipher/index.js
@@ -0,0 +1,7 @@
+describe('Cipher', function () {
+  require('./aes.js');
+  require('./blowfish.js');
+  require('./cast5.js');
+  require('./des.js');
+  require('./twofish.js');
+});
diff --git a/test/crypto/cipher/twofish.js b/test/crypto/cipher/twofish.js
index ccbad52b..3b1dfd8f 100644
--- a/test/crypto/cipher/twofish.js
+++ b/test/crypto/cipher/twofish.js
@@ -1,17 +1,16 @@
-var unit = require('../../unit.js');
+'use strict';
 
-unit.register("Twofish test with test vectors from http://www.schneier.com/code/ecb_ival.txt", function() {
-  var openpgp = require('openpgp'),
-    util = openpgp.util;
+var openpgp = require('openpgp'),
+  util = openpgp.util,
+  expect = chai.expect;
 
+it('Twofish with test vectors from http://www.schneier.com/code/ecb_ival.txt', function(done) {
   function TFencrypt(block, key) {
     var tf = new openpgp.crypto.cipher.twofish(key);
 
     return tf.encrypt(block);
   }
 
-
-  var result = [];
   var start = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
   var start_short = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
   var testvectors = [[0x57,0xFF,0x73,0x9D,0x4D,0xC9,0x2C,0x1B,0xD7,0xFC,0x01,0x70,0x0C,0xC8,0x21,0x6F],
@@ -26,43 +25,41 @@ unit.register("Twofish test with test vectors from http://www.schneier.com/code/
             [0x43,0xD5,0xCE,0xC3,0x27,0xB2,0x4A,0xB9,0x0A,0xD3,0x4A,0x79,0xD0,0x46,0x91,0x51]];
   testvectors[47] =  [0x43,0x10,0x58,0xF4,0xDB,0xC7,0xF7,0x34,0xDA,0x4F,0x02,0xF0,0x4C,0xC4,0xF4,0x59];
   testvectors[48] =  [0x37,0xFE,0x26,0xFF,0x1C,0xF6,0x61,0x75,0xF5,0xDD,0xF4,0xC3,0x3B,0x97,0xA2,0x05];
-  var res = true;
-  var j = 0;
+
   for (var i = 0; i < 49; i++) {
-    var res2 = false;
-    var blk, key, ct;
+    var res, exp, blk, key, ct;
     if (i === 0) {
       blk = start_short;
       key = util.bin2str(start);
       ct = testvectors[0];
-      res2 = (util.bin2str(TFencrypt(blk,key)) == util.bin2str(ct));
+      res = util.bin2str(TFencrypt(blk,key));
+      exp = util.bin2str(ct);
     } else if (i === 1) {
       blk = testvectors[0];
       key = util.bin2str(start);
       ct = testvectors[1];
-      res2 = (util.bin2str(TFencrypt(blk,key)) == util.bin2str(ct));
+      res = util.bin2str(TFencrypt(blk,key));
+      exp = util.bin2str(ct);
     } else if (i === 2) {
       blk = testvectors[i-1];
       key = util.bin2str(testvectors[i-2].concat(start_short));
       ct = testvectors[i];
-      res2 = (util.bin2str(TFencrypt(blk,key)) == util.bin2str(ct));
+      res = util.bin2str(TFencrypt(blk,key));
+      exp = util.bin2str(ct);
     } else if (i < 10 || i > 46) {
       blk = testvectors[i-1];
       key = util.bin2str(testvectors[i-2].concat(testvectors[i-3]));
       ct = testvectors[i];
-      res2 = (util.bin2str(TFencrypt(blk,key)) == util.bin2str(ct));
+      res = util.bin2str(TFencrypt(blk,key));
+      exp = util.bin2str(ct);
     } else {
       testvectors[i] = TFencrypt(testvectors[i-1],util.bin2str(testvectors[i-2].concat(testvectors[i-3])));
-      res2 = true;
-    }
-    res &= res2;
-    if (!res2) {
-      result[j] = new unit.result("Testing vector with block "+util.hexidump(blk)+" with key "+ util.hexstrdump(key) +" should be "+util.hexidump(ct)+" but is "+util.hexidump(TFencrypt(blk,key)), false);
-      j++;
+      continue;
     }
+    expect(res, 'vector with block ' + util.hexidump(blk) +
+                ' with key ' + util.hexstrdump(key) +
+                ' should be ' + util.hexidump(ct) +
+                ' but is ' + util.hexidump(TFencrypt(blk,key))).to.equal(exp);
   }
-  if (res) {
-    result[j] = new unit.result("49 test vectors completed", true);
-  }
-  return result;
+  done();
 });
diff --git a/test/crypto/crypto.js b/test/crypto/crypto.js
index 9d65e5e7..df455dc6 100644
--- a/test/crypto/crypto.js
+++ b/test/crypto/crypto.js
@@ -1,191 +1,191 @@
-var unit = require('../unit.js');
+var openpgp = require('openpgp');
 
-unit.register("Functional testing of openpgp.crypto.* methods", function() {
-	var openpgp = require('openpgp');
+'use strict';
+
+var expect = chai.expect;
+
+describe('API functional testing', function() {
   var util = openpgp.util;
-  var result = [];
   var RSApubMPIstrs = [
-              util.bin2str([0x08,0x00,0xac,0x15,0xb3,0xd6,0xd2,0x0f,0xf0,0x7a,0xdd,0x21,0xb7,
-                            0xbf,0x61,0xfa,0xca,0x93,0x86,0xc8,0x55,0x5a,0x4b,0xa6,0xa4,0x1a,
-                            0x60,0xa2,0x3a,0x37,0x06,0x08,0xd8,0x15,0x8e,0x85,0x45,0xaa,0xb7,
-                            0x1d,0x7b,0x0b,0x73,0x94,0x55,0x0c,0x5c,0xec,0xc0,0x22,0x4b,0xa1,
-                            0x64,0x20,0x7d,0x4d,0xa8,0x96,0x1a,0x64,0x38,0x93,0xcd,0xec,0x73,
-                            0x5d,0xf9,0x89,0x88,0x24,0x3d,0x48,0xff,0x3b,0x87,0x62,0xd0,0x84,
-                            0xea,0xff,0x39,0xb5,0x27,0x70,0xea,0x4a,0xb2,0x2e,0x9d,0xf1,0x7c,
-                            0x23,0xec,0xf4,0x5e,0xea,0x61,0x3d,0xe5,0xd8,0x0d,0xf9,0x59,0x6d,
-                            0x28,0x00,0xeb,0xcb,0xc9,0x55,0x00,0x72,0x30,0x1f,0x65,0x9d,0xd6,
-                            0x17,0x58,0x5f,0xa6,0x4a,0xa0,0xdd,0xe1,0x76,0xf2,0xef,0x21,0x9f,
-                            0x84,0xfc,0xaa,0x5b,0x52,0x6e,0xc1,0xa2,0xb9,0xbd,0xb9,0xf4,0x9e,
-                            0x49,0x92,0xf2,0xaf,0x57,0x86,0xf2,0xef,0x70,0xbf,0x51,0x40,0xfd,
-                            0xbf,0x56,0x51,0xe8,0x2c,0xa2,0x4f,0xf8,0xa4,0xd7,0x36,0x18,0x85,
-                            0xce,0x09,0x0d,0xbc,0x8d,0x65,0x5e,0x8a,0x1d,0x98,0xb0,0x4d,0x9d,
-                            0xc1,0xcf,0x82,0xe1,0xb7,0x43,0x5d,0x5a,0x72,0xcd,0x55,0xd2,0xff,
-                            0xb1,0xb4,0x78,0xbf,0xa1,0x7d,0xac,0xd9,0x1b,0xc4,0xfa,0x39,0x34,
-                            0x92,0x09,0xf9,0x08,0x2a,0x6b,0x9d,0x14,0x56,0x12,0x4c,0xe9,0xa6,
-                            0x29,0xc1,0xf3,0xa9,0x0b,0xfc,0x31,0x75,0x58,0x74,0x2a,0x88,0xaf,
-                            0xee,0xc9,0xa4,0xcd,0x15,0xdc,0x1b,0x8d,0x64,0xc1,0x36,0x17,0xc4,
-                            0x8d,0x5e,0x99,0x7a,0x5b,0x9f,0x39,0xd0,0x00,0x6e,0xf9]),
-              util.bin2str([0x00,0x11,0x01,0x00,0x01])];
+    util.bin2str([0x08,0x00,0xac,0x15,0xb3,0xd6,0xd2,0x0f,0xf0,0x7a,0xdd,0x21,0xb7,
+                  0xbf,0x61,0xfa,0xca,0x93,0x86,0xc8,0x55,0x5a,0x4b,0xa6,0xa4,0x1a,
+                  0x60,0xa2,0x3a,0x37,0x06,0x08,0xd8,0x15,0x8e,0x85,0x45,0xaa,0xb7,
+                  0x1d,0x7b,0x0b,0x73,0x94,0x55,0x0c,0x5c,0xec,0xc0,0x22,0x4b,0xa1,
+                  0x64,0x20,0x7d,0x4d,0xa8,0x96,0x1a,0x64,0x38,0x93,0xcd,0xec,0x73,
+                  0x5d,0xf9,0x89,0x88,0x24,0x3d,0x48,0xff,0x3b,0x87,0x62,0xd0,0x84,
+                  0xea,0xff,0x39,0xb5,0x27,0x70,0xea,0x4a,0xb2,0x2e,0x9d,0xf1,0x7c,
+                  0x23,0xec,0xf4,0x5e,0xea,0x61,0x3d,0xe5,0xd8,0x0d,0xf9,0x59,0x6d,
+                  0x28,0x00,0xeb,0xcb,0xc9,0x55,0x00,0x72,0x30,0x1f,0x65,0x9d,0xd6,
+                  0x17,0x58,0x5f,0xa6,0x4a,0xa0,0xdd,0xe1,0x76,0xf2,0xef,0x21,0x9f,
+                  0x84,0xfc,0xaa,0x5b,0x52,0x6e,0xc1,0xa2,0xb9,0xbd,0xb9,0xf4,0x9e,
+                  0x49,0x92,0xf2,0xaf,0x57,0x86,0xf2,0xef,0x70,0xbf,0x51,0x40,0xfd,
+                  0xbf,0x56,0x51,0xe8,0x2c,0xa2,0x4f,0xf8,0xa4,0xd7,0x36,0x18,0x85,
+                  0xce,0x09,0x0d,0xbc,0x8d,0x65,0x5e,0x8a,0x1d,0x98,0xb0,0x4d,0x9d,
+                  0xc1,0xcf,0x82,0xe1,0xb7,0x43,0x5d,0x5a,0x72,0xcd,0x55,0xd2,0xff,
+                  0xb1,0xb4,0x78,0xbf,0xa1,0x7d,0xac,0xd9,0x1b,0xc4,0xfa,0x39,0x34,
+                  0x92,0x09,0xf9,0x08,0x2a,0x6b,0x9d,0x14,0x56,0x12,0x4c,0xe9,0xa6,
+                  0x29,0xc1,0xf3,0xa9,0x0b,0xfc,0x31,0x75,0x58,0x74,0x2a,0x88,0xaf,
+                  0xee,0xc9,0xa4,0xcd,0x15,0xdc,0x1b,0x8d,0x64,0xc1,0x36,0x17,0xc4,
+                  0x8d,0x5e,0x99,0x7a,0x5b,0x9f,0x39,0xd0,0x00,0x6e,0xf9]),
+    util.bin2str([0x00,0x11,0x01,0x00,0x01])];
   var RSAsecMPIstrs = [
-              util.bin2str([0x07,0xfe,0x23,0xff,0xce,0x45,0x6c,0x60,0x65,0x40,0x6e,0xae,0x35,
-                            0x10,0x56,0x60,0xee,0xab,0xfa,0x10,0x42,0xba,0xc7,0x04,0xaf,0x63,
-                            0xcd,0x3f,0x62,0xca,0x4b,0xfa,0xe1,0xa9,0x70,0xcd,0x34,0x8b,0xc8,
-                            0x0e,0xe4,0xc4,0xba,0x83,0x17,0x5f,0xa4,0xb8,0xea,0x60,0xc2,0x4d,
-                            0x9a,0xf2,0xa9,0x03,0xeb,0xf6,0xaa,0xc2,0xb8,0x8b,0x43,0x12,0xe9,
-                            0xf7,0x88,0xd2,0x5a,0xa6,0xaa,0x23,0x71,0x31,0x74,0xdb,0x19,0x20,
-                            0x15,0x41,0x1b,0x43,0x68,0x62,0xd8,0xc0,0x93,0x91,0xe8,0xfc,0xb1,
-                            0xa9,0x9a,0x52,0x6c,0xe0,0xbf,0x43,0x01,0xa8,0x37,0x14,0x28,0xbf,
-                            0x0b,0x15,0x56,0x3e,0xa5,0x79,0xa0,0xc4,0x42,0x88,0xee,0xeb,0x1b,
-                            0xf4,0x7a,0x4a,0x58,0x31,0x58,0x81,0xd2,0x3e,0xde,0x07,0x64,0x92,
-                            0xf0,0x60,0xd3,0x9a,0x29,0xca,0xc6,0x67,0x75,0x07,0xca,0x92,0x39,
-                            0x56,0xf6,0x11,0x84,0xba,0x6d,0x4b,0xe6,0x6f,0x66,0xc2,0x17,0xeb,
-                            0x46,0x69,0x1c,0xbb,0xdf,0xc0,0x38,0x00,0xd6,0x01,0xe6,0x70,0x9d,
-                            0x4b,0x9b,0x70,0xed,0x5c,0xb8,0xcf,0xe8,0x68,0x71,0xbe,0x24,0x6d,
-                            0xb1,0xa3,0x13,0xcc,0xf1,0xbc,0x67,0xdc,0xe0,0x69,0x09,0x82,0x3c,
-                            0x3b,0x0f,0x14,0x98,0x48,0x30,0xb2,0x70,0xc6,0x9e,0xfa,0x46,0x8f,
-                            0xf1,0xc0,0x65,0x8e,0xc6,0xae,0xdc,0x47,0x91,0x13,0x1e,0xd6,0x4a,
-                            0xf2,0xad,0xda,0xc2,0xc7,0x39,0x78,0x99,0xde,0x57,0x14,0x45,0x7f,
-                            0x32,0x38,0xa3,0x44,0x0f,0xe7,0x39,0x4c,0x6f,0x0f,0x32,0x7e,0xf1,
-                            0x5c,0x84,0x97,0xdd,0xa0,0x0c,0x87,0x66,0x7d,0x75,0x79]),
-              util.bin2str([0x04,0x00,0xc2,0xbc,0x71,0xf7,0x41,0x4a,0x09,0x66,0x70,0x02,0x68,
-                            0x8b,0xeb,0xe2,0x34,0xd1,0x12,0x83,0x93,0x75,0xe9,0x71,0x32,0xe2,
-                            0xed,0x18,0x6f,0x8e,0x3a,0xff,0x22,0x70,0x28,0x01,0xbf,0x4a,0x39,
-                            0x41,0xbb,0x3c,0x4a,0xbc,0xb8,0x13,0xfc,0x14,0xf6,0x71,0xa1,0x44,
-                            0x1c,0x02,0xa1,0x73,0x81,0xcc,0xa0,0x35,0x02,0x3e,0x97,0xb5,0xc4,
-                            0x94,0x33,0xf1,0xd1,0xdf,0x14,0x3f,0xfb,0x8f,0xb9,0x75,0x70,0xdc,
-                            0x74,0x3f,0x07,0x35,0x8f,0x53,0xaa,0xb2,0xd6,0x88,0x51,0x71,0x4e,
-                            0x01,0x24,0xec,0x7d,0xca,0xf6,0xa2,0xb3,0xbb,0xad,0x2e,0x60,0xfb,
-                            0x1c,0xee,0x49,0xd0,0x4e,0x5c,0xe3,0x1f,0x88,0x48,0xe4,0x68,0x14,
-                            0x3d,0x71,0xba,0xd7,0x4d,0x35,0x10,0x86,0x37,0x62,0xe0,0xa5,0x0b]),
-              util.bin2str([0x04,0x00,0xe2,0x38,0xf9,0xc8,0x3c,0xd1,0xcf,0x62,0x93,0xc3,0x77,
-                            0x76,0x97,0x44,0xe8,0xc8,0xca,0x93,0x9a,0xef,0xf0,0x63,0x76,0x25,
-                            0x3b,0x1c,0x46,0xff,0x90,0x13,0x91,0x15,0x97,0x7e,0x88,0x95,0xd4,
-                            0x7f,0x2f,0x52,0x6e,0x0d,0x55,0x55,0x2e,0xf1,0x58,0x5c,0x7e,0x56,
-                            0xd4,0x48,0xaa,0xdb,0x8c,0x44,0x4d,0x84,0x69,0x33,0x87,0x07,0xb2,
-                            0x7e,0xf5,0xa0,0x60,0xfb,0x73,0x59,0x46,0x29,0xcb,0x1e,0x3f,0x7c,
-                            0x2f,0xa6,0x53,0xe3,0x8c,0xef,0xd5,0xeb,0xbb,0xc8,0x9a,0x8e,0x66,
-                            0x4a,0x47,0x2f,0xe1,0xba,0x5e,0x32,0xd4,0x52,0x04,0x88,0x9d,0x63,
-                            0x3e,0xba,0x71,0x2d,0xf7,0x61,0xd5,0xfc,0x26,0xbf,0xd8,0x60,0x92,
-                            0x7b,0x94,0xf8,0x6f,0x3d,0x97,0x0b,0x0c,0x52,0x8c,0xb3,0xb6,0x8b]),
-              util.bin2str([0x04,0x00,0xb7,0xc5,0x4d,0x6e,0x2f,0xdd,0xef,0xec,0x07,0x70,0xa2,
-                            0x7c,0x1c,0x9d,0x8e,0x66,0x60,0x7c,0x61,0x1e,0x45,0xe9,0xdc,0x82,
-                            0x2f,0xc5,0x7e,0x1a,0xc6,0xd0,0x92,0xc5,0x22,0x9b,0x9a,0xfb,0x73,
-                            0x95,0x99,0xf2,0x7c,0xdb,0x2a,0x93,0x7b,0x5a,0x29,0x73,0x24,0x16,
-                            0x41,0x49,0xb5,0xf2,0x5f,0xbe,0xe7,0x64,0x4d,0xda,0x52,0x9e,0xc1,
-                            0x41,0x40,0x5e,0x03,0x92,0x8d,0x39,0x95,0x1f,0x68,0x9f,0x00,0x2e,
-                            0x0c,0x6f,0xcf,0xd9,0x6d,0x68,0xf7,0x00,0x4f,0x0e,0xc8,0x0b,0xfa,
-                            0x51,0xe0,0x22,0xf0,0xff,0xa7,0x42,0xd4,0xde,0x0b,0x47,0x8f,0x2b,
-                            0xf5,0x4d,0x04,0x32,0x91,0x89,0x4b,0x0e,0x05,0x8d,0x70,0xf9,0xbb,
-                            0xe7,0xd6,0x76,0xea,0x0e,0x1a,0x90,0x30,0xf5,0x98,0x01,0xc5,0x73])];
+    util.bin2str([0x07,0xfe,0x23,0xff,0xce,0x45,0x6c,0x60,0x65,0x40,0x6e,0xae,0x35,
+                  0x10,0x56,0x60,0xee,0xab,0xfa,0x10,0x42,0xba,0xc7,0x04,0xaf,0x63,
+                  0xcd,0x3f,0x62,0xca,0x4b,0xfa,0xe1,0xa9,0x70,0xcd,0x34,0x8b,0xc8,
+                  0x0e,0xe4,0xc4,0xba,0x83,0x17,0x5f,0xa4,0xb8,0xea,0x60,0xc2,0x4d,
+                  0x9a,0xf2,0xa9,0x03,0xeb,0xf6,0xaa,0xc2,0xb8,0x8b,0x43,0x12,0xe9,
+                  0xf7,0x88,0xd2,0x5a,0xa6,0xaa,0x23,0x71,0x31,0x74,0xdb,0x19,0x20,
+                  0x15,0x41,0x1b,0x43,0x68,0x62,0xd8,0xc0,0x93,0x91,0xe8,0xfc,0xb1,
+                  0xa9,0x9a,0x52,0x6c,0xe0,0xbf,0x43,0x01,0xa8,0x37,0x14,0x28,0xbf,
+                  0x0b,0x15,0x56,0x3e,0xa5,0x79,0xa0,0xc4,0x42,0x88,0xee,0xeb,0x1b,
+                  0xf4,0x7a,0x4a,0x58,0x31,0x58,0x81,0xd2,0x3e,0xde,0x07,0x64,0x92,
+                  0xf0,0x60,0xd3,0x9a,0x29,0xca,0xc6,0x67,0x75,0x07,0xca,0x92,0x39,
+                  0x56,0xf6,0x11,0x84,0xba,0x6d,0x4b,0xe6,0x6f,0x66,0xc2,0x17,0xeb,
+                  0x46,0x69,0x1c,0xbb,0xdf,0xc0,0x38,0x00,0xd6,0x01,0xe6,0x70,0x9d,
+                  0x4b,0x9b,0x70,0xed,0x5c,0xb8,0xcf,0xe8,0x68,0x71,0xbe,0x24,0x6d,
+                  0xb1,0xa3,0x13,0xcc,0xf1,0xbc,0x67,0xdc,0xe0,0x69,0x09,0x82,0x3c,
+                  0x3b,0x0f,0x14,0x98,0x48,0x30,0xb2,0x70,0xc6,0x9e,0xfa,0x46,0x8f,
+                  0xf1,0xc0,0x65,0x8e,0xc6,0xae,0xdc,0x47,0x91,0x13,0x1e,0xd6,0x4a,
+                  0xf2,0xad,0xda,0xc2,0xc7,0x39,0x78,0x99,0xde,0x57,0x14,0x45,0x7f,
+                  0x32,0x38,0xa3,0x44,0x0f,0xe7,0x39,0x4c,0x6f,0x0f,0x32,0x7e,0xf1,
+                  0x5c,0x84,0x97,0xdd,0xa0,0x0c,0x87,0x66,0x7d,0x75,0x79]),
+    util.bin2str([0x04,0x00,0xc2,0xbc,0x71,0xf7,0x41,0x4a,0x09,0x66,0x70,0x02,0x68,
+                  0x8b,0xeb,0xe2,0x34,0xd1,0x12,0x83,0x93,0x75,0xe9,0x71,0x32,0xe2,
+                  0xed,0x18,0x6f,0x8e,0x3a,0xff,0x22,0x70,0x28,0x01,0xbf,0x4a,0x39,
+                  0x41,0xbb,0x3c,0x4a,0xbc,0xb8,0x13,0xfc,0x14,0xf6,0x71,0xa1,0x44,
+                  0x1c,0x02,0xa1,0x73,0x81,0xcc,0xa0,0x35,0x02,0x3e,0x97,0xb5,0xc4,
+                  0x94,0x33,0xf1,0xd1,0xdf,0x14,0x3f,0xfb,0x8f,0xb9,0x75,0x70,0xdc,
+                  0x74,0x3f,0x07,0x35,0x8f,0x53,0xaa,0xb2,0xd6,0x88,0x51,0x71,0x4e,
+                  0x01,0x24,0xec,0x7d,0xca,0xf6,0xa2,0xb3,0xbb,0xad,0x2e,0x60,0xfb,
+                  0x1c,0xee,0x49,0xd0,0x4e,0x5c,0xe3,0x1f,0x88,0x48,0xe4,0x68,0x14,
+                  0x3d,0x71,0xba,0xd7,0x4d,0x35,0x10,0x86,0x37,0x62,0xe0,0xa5,0x0b]),
+    util.bin2str([0x04,0x00,0xe2,0x38,0xf9,0xc8,0x3c,0xd1,0xcf,0x62,0x93,0xc3,0x77,
+                  0x76,0x97,0x44,0xe8,0xc8,0xca,0x93,0x9a,0xef,0xf0,0x63,0x76,0x25,
+                  0x3b,0x1c,0x46,0xff,0x90,0x13,0x91,0x15,0x97,0x7e,0x88,0x95,0xd4,
+                  0x7f,0x2f,0x52,0x6e,0x0d,0x55,0x55,0x2e,0xf1,0x58,0x5c,0x7e,0x56,
+                  0xd4,0x48,0xaa,0xdb,0x8c,0x44,0x4d,0x84,0x69,0x33,0x87,0x07,0xb2,
+                  0x7e,0xf5,0xa0,0x60,0xfb,0x73,0x59,0x46,0x29,0xcb,0x1e,0x3f,0x7c,
+                  0x2f,0xa6,0x53,0xe3,0x8c,0xef,0xd5,0xeb,0xbb,0xc8,0x9a,0x8e,0x66,
+                  0x4a,0x47,0x2f,0xe1,0xba,0x5e,0x32,0xd4,0x52,0x04,0x88,0x9d,0x63,
+                  0x3e,0xba,0x71,0x2d,0xf7,0x61,0xd5,0xfc,0x26,0xbf,0xd8,0x60,0x92,
+                  0x7b,0x94,0xf8,0x6f,0x3d,0x97,0x0b,0x0c,0x52,0x8c,0xb3,0xb6,0x8b]),
+    util.bin2str([0x04,0x00,0xb7,0xc5,0x4d,0x6e,0x2f,0xdd,0xef,0xec,0x07,0x70,0xa2,
+                  0x7c,0x1c,0x9d,0x8e,0x66,0x60,0x7c,0x61,0x1e,0x45,0xe9,0xdc,0x82,
+                  0x2f,0xc5,0x7e,0x1a,0xc6,0xd0,0x92,0xc5,0x22,0x9b,0x9a,0xfb,0x73,
+                  0x95,0x99,0xf2,0x7c,0xdb,0x2a,0x93,0x7b,0x5a,0x29,0x73,0x24,0x16,
+                  0x41,0x49,0xb5,0xf2,0x5f,0xbe,0xe7,0x64,0x4d,0xda,0x52,0x9e,0xc1,
+                  0x41,0x40,0x5e,0x03,0x92,0x8d,0x39,0x95,0x1f,0x68,0x9f,0x00,0x2e,
+                  0x0c,0x6f,0xcf,0xd9,0x6d,0x68,0xf7,0x00,0x4f,0x0e,0xc8,0x0b,0xfa,
+                  0x51,0xe0,0x22,0xf0,0xff,0xa7,0x42,0xd4,0xde,0x0b,0x47,0x8f,0x2b,
+                  0xf5,0x4d,0x04,0x32,0x91,0x89,0x4b,0x0e,0x05,0x8d,0x70,0xf9,0xbb,
+                  0xe7,0xd6,0x76,0xea,0x0e,0x1a,0x90,0x30,0xf5,0x98,0x01,0xc5,0x73])];
   
   var DSApubMPIstrs = [
-          util.bin2str([0x08,0x00,0xa8,0x85,0x5c,0x28,0x05,0x94,0x03,0xbe,0x07,0x6c,0x13,0x3e,0x65,
-                        0xfb,0xb5,0xe1,0x99,0x7c,0xfa,0x84,0xe3,0xac,0x47,0xa5,0xc4,0x46,0xd8,0x5f,
-                        0x44,0xe9,0xc1,0x6b,0x69,0xf7,0x10,0x76,0x49,0xa7,0x25,0x85,0xf4,0x1b,0xed,
-                        0xc6,0x60,0xc4,0x5b,0xaa,0xd4,0x87,0xd6,0x8f,0x92,0x56,0x7d,0x55,0x3f,0x45,
-                        0xae,0x12,0x73,0xda,0x29,0x8c,0xba,0x32,0xcc,0xd7,0xa4,0xd0,0x24,0xb0,0x7c,
-                        0xd8,0x0c,0x3a,0x91,0x6f,0x98,0x40,0x9c,0x9a,0xa8,0xcc,0x28,0x27,0x95,0x0b,
-                        0xe1,0x5b,0xb9,0x3b,0x1c,0x1c,0xd2,0xec,0xab,0x07,0x25,0x8d,0x7a,0x2a,0x2b,
-                        0x16,0x14,0xe8,0xda,0x71,0xd2,0xab,0xba,0x85,0x14,0x0d,0xc5,0xe0,0x88,0xeb,
-                        0xa5,0xe2,0xd5,0x48,0x3d,0x74,0x0c,0x41,0xeb,0xfd,0xb6,0x4e,0xf9,0x2c,0x82,
-                        0x17,0xdd,0x64,0x1e,0x19,0x39,0xa3,0x7f,0xf9,0x00,0xcd,0x9b,0xda,0x2e,0xbd,
-                        0x71,0x12,0xdf,0x0d,0x7c,0x0a,0x6b,0x2d,0x21,0x3b,0x9c,0x66,0x93,0x4a,0x1e,
-                        0x90,0x79,0xd3,0x5a,0x5b,0xe5,0xb9,0x94,0x1b,0xe6,0x47,0x99,0x06,0x98,0xd8,
-                        0x2a,0xe5,0xe2,0xa6,0x95,0x6a,0x07,0xc8,0xac,0x7c,0xe9,0xfc,0xa2,0x6a,0x16,
-                        0x2c,0x94,0x98,0xbd,0x91,0x0a,0x7c,0x7c,0x2c,0xb9,0x7e,0xa2,0x51,0x8b,0x45,
-                        0x1d,0x46,0x34,0xa8,0x52,0x2b,0xdd,0xd9,0xa8,0xbc,0x46,0x78,0x66,0xe1,0x72,
-                        0x11,0xf1,0xcb,0x1a,0xb6,0x4e,0x05,0x54,0xf7,0xe9,0xbe,0x4c,0x25,0x59,0x08,
-                        0x9f,0xf8,0xea,0x25,0x97,0x33,0xd6,0xc9,0x0f,0x59,0x0e,0xfd,0x9f,0xdc,0xe2,
-                        0xc0,0xcf,0x2f]),
-      util.bin2str([0x01,0x00,0xe1,0x72,0x2c,0xd0,0xbb,0x1a,0x4f,0xb6,0xb6,0x95,0x77,0x71,0x2e,
-                    0x01,0x48,0x3e,0x35,0x54,0x64,0x2b,0xed,0x40,0x5f,0x65,0x0c,0x57,0x28,0x5f,
-                    0xfd,0xfd,0xff,0xd7]),
-      util.bin2str([0x07,0xff,0x5d,0x9f,0xc4,0xb5,0x63,0x25,0x9d,0x72,0x88,0xe5,0x53,0x46,0x98,
-                    0xe3,0xe9,0x62,0xcb,0x0c,0xa1,0xb7,0x75,0x9f,0x18,0x41,0x94,0x32,0x28,0x29,
-                    0x6d,0x69,0xe0,0x3f,0x7d,0x7b,0x2b,0x06,0x5a,0x33,0x5c,0xd4,0x36,0x31,0x09,
-                    0x54,0x85,0x9d,0xb8,0x20,0xfe,0xda,0xfc,0xcd,0x1f,0xb1,0x2c,0x15,0x08,0x9d,
-                    0x32,0x53,0x2f,0xc1,0x42,0x22,0x69,0xff,0x67,0x2e,0x39,0x97,0x50,0x66,0x39,
-                    0xda,0xcf,0xfd,0x64,0x6f,0x91,0x05,0x64,0x37,0xc5,0x07,0x24,0xaa,0x40,0xa0,
-                    0x75,0x82,0x1d,0x97,0x96,0x12,0xf1,0xbd,0x9e,0x09,0x26,0x3c,0x97,0x5d,0x57,
-                    0xb8,0x5c,0x7d,0x89,0x03,0x82,0xcd,0x40,0xe5,0x03,0xe6,0x4a,0xfb,0xbc,0xd2,
-                    0xef,0x7a,0x89,0x02,0x08,0xc8,0x52,0xfa,0x97,0x74,0x66,0x32,0xae,0xa6,0x52,
-                    0x4b,0xef,0x5f,0xce,0x91,0x23,0x3f,0xab,0x9d,0x62,0x21,0xef,0x48,0x6d,0x07,
-                    0x5a,0xba,0xdf,0x00,0x91,0x54,0xea,0x5c,0xfa,0x4b,0x16,0x28,0x1a,0xce,0x48,
-                    0xb7,0x5c,0x50,0xa5,0x59,0xa4,0xb4,0xaf,0x1f,0xeb,0x8d,0x58,0x3f,0x0a,0xa5,
-                    0x97,0x2b,0x51,0x56,0xe8,0x88,0xf6,0x07,0xbc,0xdf,0xfa,0x2b,0x7b,0x88,0xe0,
-                    0x46,0xc8,0x7a,0x3e,0xd8,0x80,0xdb,0x4d,0x87,0x61,0x4f,0x64,0xcd,0xeb,0xe8,
-                    0x0d,0x86,0x16,0xcc,0xdd,0x6c,0x76,0x66,0xc1,0x73,0xb7,0x08,0x98,0x89,0x2f,
-                    0x67,0x69,0xd1,0xfc,0x97,0x4d,0xa2,0xce,0xad,0xbb,0x6f,0xab,0xa5,0xd6,0x18,
-                    0xb3,0x1a,0x96,0x02,0xbc,0x31,0x42,0xa2,0xad,0x77,0xe8,0xe2,0x4c,0x99,0xf9,
-                    0xdd,0xbe,0xcd]),
-      util.bin2str([0x07,0xff,0x5d,0xfe,0x9c,0x98,0xef,0x3a,0xa6,0x49,0xf0,0x10,0x67,0x79,0x2a,
-                    0x9d,0x79,0x43,0x06,0xa4,0xa8,0x6b,0x1a,0x6d,0x1f,0x77,0x6e,0x00,0x31,0xb9,
-                    0xed,0xc9,0x66,0xff,0xf1,0x21,0x32,0xfa,0x62,0x43,0xcd,0x97,0xd3,0x3d,0xaf,
-                    0xb4,0x29,0x29,0x26,0x4e,0x1c,0xa0,0xad,0x1c,0x07,0x28,0x3f,0xe5,0x43,0x10,
-                    0xba,0xb4,0x08,0xe0,0xdc,0xa2,0xc3,0x5b,0x1f,0xbd,0x94,0xc7,0x43,0xe5,0xf2,
-                    0x17,0x30,0x54,0x7f,0x14,0xbe,0xf4,0xbd,0x91,0x3b,0xe4,0x36,0xa4,0x50,0x5b,
-                    0x37,0x89,0x5e,0xcc,0xc7,0x74,0x54,0x32,0x20,0x09,0x63,0x98,0xb7,0xd9,0xaf,
-                    0x7f,0xb0,0x6c,0x27,0x43,0xfe,0x52,0xe6,0x1a,0x88,0x59,0x25,0xfc,0xeb,0x43,
-                    0x50,0xc7,0x65,0x43,0xc1,0x86,0x73,0x58,0x53,0x3a,0xcf,0x7a,0xa3,0x1d,0x56,
-                    0xc8,0x4a,0x80,0x70,0xb7,0xbf,0xf2,0xa3,0xec,0xe8,0x77,0x05,0x33,0x09,0x9d,
-                    0xaa,0xca,0xa0,0xe1,0x64,0x64,0x6f,0x76,0x99,0x41,0x75,0x78,0x90,0xf6,0xe7,
-                    0x23,0xe6,0xec,0x50,0xe5,0x99,0xa8,0x3e,0x1a,0x4b,0xc9,0x88,0x58,0x66,0xae,
-                    0x1a,0x53,0x5e,0xe4,0xb7,0x86,0xcf,0xa6,0xe5,0xad,0xb4,0x80,0xa0,0xf1,0x0d,
-                    0x96,0xb8,0x41,0xd0,0x07,0x9a,0x21,0x8d,0x50,0x7f,0x4f,0x73,0x13,0xa2,0xe2,
-                    0x02,0x07,0xc3,0xa3,0x0f,0x09,0x18,0x7f,0xf7,0x6b,0x90,0x70,0xc0,0xf9,0x0c,
-                    0x67,0x8d,0x9d,0x14,0xb6,0x9d,0x32,0x82,0xd0,0xb5,0xc6,0x57,0xf0,0x91,0xd9,
-                    0xc3,0x26,0xae,0x9f,0xa9,0x67,0x49,0x96,0x5c,0x07,0x3e,0x47,0x5c,0xed,0x60,
-                    0x07,0xac,0x6a])];
-  var DSAsecMPIstrs = [util.bin2str([0x01,0x00,0x9b,0x58,0xa8,0xf4,0x04,0xb1,0xd5,0x14,0x09,0xe1,
-                           0xe1,0xa1,0x8a,0x0b,0xa3,0xc3,0xa3,0x66,0xaa,0x27,0x99,0x50,
-                           0x1c,0x4d,0xba,0x24,0xee,0xdf,0xdf,0xb8,0x8e,0x8e])];
+    util.bin2str([0x08,0x00,0xa8,0x85,0x5c,0x28,0x05,0x94,0x03,0xbe,0x07,0x6c,0x13,0x3e,0x65,
+                  0xfb,0xb5,0xe1,0x99,0x7c,0xfa,0x84,0xe3,0xac,0x47,0xa5,0xc4,0x46,0xd8,0x5f,
+                  0x44,0xe9,0xc1,0x6b,0x69,0xf7,0x10,0x76,0x49,0xa7,0x25,0x85,0xf4,0x1b,0xed,
+                  0xc6,0x60,0xc4,0x5b,0xaa,0xd4,0x87,0xd6,0x8f,0x92,0x56,0x7d,0x55,0x3f,0x45,
+                  0xae,0x12,0x73,0xda,0x29,0x8c,0xba,0x32,0xcc,0xd7,0xa4,0xd0,0x24,0xb0,0x7c,
+                  0xd8,0x0c,0x3a,0x91,0x6f,0x98,0x40,0x9c,0x9a,0xa8,0xcc,0x28,0x27,0x95,0x0b,
+                  0xe1,0x5b,0xb9,0x3b,0x1c,0x1c,0xd2,0xec,0xab,0x07,0x25,0x8d,0x7a,0x2a,0x2b,
+                  0x16,0x14,0xe8,0xda,0x71,0xd2,0xab,0xba,0x85,0x14,0x0d,0xc5,0xe0,0x88,0xeb,
+                  0xa5,0xe2,0xd5,0x48,0x3d,0x74,0x0c,0x41,0xeb,0xfd,0xb6,0x4e,0xf9,0x2c,0x82,
+                  0x17,0xdd,0x64,0x1e,0x19,0x39,0xa3,0x7f,0xf9,0x00,0xcd,0x9b,0xda,0x2e,0xbd,
+                  0x71,0x12,0xdf,0x0d,0x7c,0x0a,0x6b,0x2d,0x21,0x3b,0x9c,0x66,0x93,0x4a,0x1e,
+                  0x90,0x79,0xd3,0x5a,0x5b,0xe5,0xb9,0x94,0x1b,0xe6,0x47,0x99,0x06,0x98,0xd8,
+                  0x2a,0xe5,0xe2,0xa6,0x95,0x6a,0x07,0xc8,0xac,0x7c,0xe9,0xfc,0xa2,0x6a,0x16,
+                  0x2c,0x94,0x98,0xbd,0x91,0x0a,0x7c,0x7c,0x2c,0xb9,0x7e,0xa2,0x51,0x8b,0x45,
+                  0x1d,0x46,0x34,0xa8,0x52,0x2b,0xdd,0xd9,0xa8,0xbc,0x46,0x78,0x66,0xe1,0x72,
+                  0x11,0xf1,0xcb,0x1a,0xb6,0x4e,0x05,0x54,0xf7,0xe9,0xbe,0x4c,0x25,0x59,0x08,
+                  0x9f,0xf8,0xea,0x25,0x97,0x33,0xd6,0xc9,0x0f,0x59,0x0e,0xfd,0x9f,0xdc,0xe2,
+                  0xc0,0xcf,0x2f]),
+    util.bin2str([0x01,0x00,0xe1,0x72,0x2c,0xd0,0xbb,0x1a,0x4f,0xb6,0xb6,0x95,0x77,0x71,0x2e,
+                  0x01,0x48,0x3e,0x35,0x54,0x64,0x2b,0xed,0x40,0x5f,0x65,0x0c,0x57,0x28,0x5f,
+                  0xfd,0xfd,0xff,0xd7]),
+    util.bin2str([0x07,0xff,0x5d,0x9f,0xc4,0xb5,0x63,0x25,0x9d,0x72,0x88,0xe5,0x53,0x46,0x98,
+                  0xe3,0xe9,0x62,0xcb,0x0c,0xa1,0xb7,0x75,0x9f,0x18,0x41,0x94,0x32,0x28,0x29,
+                  0x6d,0x69,0xe0,0x3f,0x7d,0x7b,0x2b,0x06,0x5a,0x33,0x5c,0xd4,0x36,0x31,0x09,
+                  0x54,0x85,0x9d,0xb8,0x20,0xfe,0xda,0xfc,0xcd,0x1f,0xb1,0x2c,0x15,0x08,0x9d,
+                  0x32,0x53,0x2f,0xc1,0x42,0x22,0x69,0xff,0x67,0x2e,0x39,0x97,0x50,0x66,0x39,
+                  0xda,0xcf,0xfd,0x64,0x6f,0x91,0x05,0x64,0x37,0xc5,0x07,0x24,0xaa,0x40,0xa0,
+                  0x75,0x82,0x1d,0x97,0x96,0x12,0xf1,0xbd,0x9e,0x09,0x26,0x3c,0x97,0x5d,0x57,
+                  0xb8,0x5c,0x7d,0x89,0x03,0x82,0xcd,0x40,0xe5,0x03,0xe6,0x4a,0xfb,0xbc,0xd2,
+                  0xef,0x7a,0x89,0x02,0x08,0xc8,0x52,0xfa,0x97,0x74,0x66,0x32,0xae,0xa6,0x52,
+                  0x4b,0xef,0x5f,0xce,0x91,0x23,0x3f,0xab,0x9d,0x62,0x21,0xef,0x48,0x6d,0x07,
+                  0x5a,0xba,0xdf,0x00,0x91,0x54,0xea,0x5c,0xfa,0x4b,0x16,0x28,0x1a,0xce,0x48,
+                  0xb7,0x5c,0x50,0xa5,0x59,0xa4,0xb4,0xaf,0x1f,0xeb,0x8d,0x58,0x3f,0x0a,0xa5,
+                  0x97,0x2b,0x51,0x56,0xe8,0x88,0xf6,0x07,0xbc,0xdf,0xfa,0x2b,0x7b,0x88,0xe0,
+                  0x46,0xc8,0x7a,0x3e,0xd8,0x80,0xdb,0x4d,0x87,0x61,0x4f,0x64,0xcd,0xeb,0xe8,
+                  0x0d,0x86,0x16,0xcc,0xdd,0x6c,0x76,0x66,0xc1,0x73,0xb7,0x08,0x98,0x89,0x2f,
+                  0x67,0x69,0xd1,0xfc,0x97,0x4d,0xa2,0xce,0xad,0xbb,0x6f,0xab,0xa5,0xd6,0x18,
+                  0xb3,0x1a,0x96,0x02,0xbc,0x31,0x42,0xa2,0xad,0x77,0xe8,0xe2,0x4c,0x99,0xf9,
+                  0xdd,0xbe,0xcd]),
+    util.bin2str([0x07,0xff,0x5d,0xfe,0x9c,0x98,0xef,0x3a,0xa6,0x49,0xf0,0x10,0x67,0x79,0x2a,
+                  0x9d,0x79,0x43,0x06,0xa4,0xa8,0x6b,0x1a,0x6d,0x1f,0x77,0x6e,0x00,0x31,0xb9,
+                  0xed,0xc9,0x66,0xff,0xf1,0x21,0x32,0xfa,0x62,0x43,0xcd,0x97,0xd3,0x3d,0xaf,
+                  0xb4,0x29,0x29,0x26,0x4e,0x1c,0xa0,0xad,0x1c,0x07,0x28,0x3f,0xe5,0x43,0x10,
+                  0xba,0xb4,0x08,0xe0,0xdc,0xa2,0xc3,0x5b,0x1f,0xbd,0x94,0xc7,0x43,0xe5,0xf2,
+                  0x17,0x30,0x54,0x7f,0x14,0xbe,0xf4,0xbd,0x91,0x3b,0xe4,0x36,0xa4,0x50,0x5b,
+                  0x37,0x89,0x5e,0xcc,0xc7,0x74,0x54,0x32,0x20,0x09,0x63,0x98,0xb7,0xd9,0xaf,
+                  0x7f,0xb0,0x6c,0x27,0x43,0xfe,0x52,0xe6,0x1a,0x88,0x59,0x25,0xfc,0xeb,0x43,
+                  0x50,0xc7,0x65,0x43,0xc1,0x86,0x73,0x58,0x53,0x3a,0xcf,0x7a,0xa3,0x1d,0x56,
+                  0xc8,0x4a,0x80,0x70,0xb7,0xbf,0xf2,0xa3,0xec,0xe8,0x77,0x05,0x33,0x09,0x9d,
+                  0xaa,0xca,0xa0,0xe1,0x64,0x64,0x6f,0x76,0x99,0x41,0x75,0x78,0x90,0xf6,0xe7,
+                  0x23,0xe6,0xec,0x50,0xe5,0x99,0xa8,0x3e,0x1a,0x4b,0xc9,0x88,0x58,0x66,0xae,
+                  0x1a,0x53,0x5e,0xe4,0xb7,0x86,0xcf,0xa6,0xe5,0xad,0xb4,0x80,0xa0,0xf1,0x0d,
+                  0x96,0xb8,0x41,0xd0,0x07,0x9a,0x21,0x8d,0x50,0x7f,0x4f,0x73,0x13,0xa2,0xe2,
+                  0x02,0x07,0xc3,0xa3,0x0f,0x09,0x18,0x7f,0xf7,0x6b,0x90,0x70,0xc0,0xf9,0x0c,
+                  0x67,0x8d,0x9d,0x14,0xb6,0x9d,0x32,0x82,0xd0,0xb5,0xc6,0x57,0xf0,0x91,0xd9,
+                  0xc3,0x26,0xae,0x9f,0xa9,0x67,0x49,0x96,0x5c,0x07,0x3e,0x47,0x5c,0xed,0x60,
+                  0x07,0xac,0x6a])];
+  var DSAsecMPIstrs = [
+    util.bin2str([0x01,0x00,0x9b,0x58,0xa8,0xf4,0x04,0xb1,0xd5,0x14,0x09,0xe1,0xe1,0xa1,0x8a,
+                  0x0b,0xa3,0xc3,0xa3,0x66,0xaa,0x27,0x99,0x50,0x1c,0x4d,0xba,0x24,0xee,0xdf,
+                  0xdf,0xb8,0x8e,0x8e])];
             
-  var ElgamalpubMPIstrs = 
-          [util.bin2str([0x08,0x00,0xea,0xcc,0xbe,0xe2,0xe4,0x5a,0x51,0x18,0x93,0xa1,0x12,0x2f,
-                     0x00,0x99,0x42,0xd8,0x5c,0x1c,0x2f,0xb6,0x3c,0xd9,0x94,0x61,0xb4,0x55,
-                     0x8d,0x4e,0x73,0xe6,0x69,0xbc,0x1d,0x33,0xe3,0x2d,0x91,0x23,0x69,0x95,
-                     0x98,0xd7,0x18,0x5a,0xaf,0xa7,0x93,0xc6,0x05,0x93,0x3a,0xc7,0xea,0xd0,
-                     0xb1,0xa9,0xc7,0xab,0x41,0x89,0xc8,0x38,0x99,0xdc,0x1a,0x57,0x35,0x1a,
-                     0x27,0x62,0x40,0x71,0x9f,0x36,0x1c,0x6d,0x18,0x1c,0x93,0xf7,0xba,0x35,
-                     0x06,0xed,0x30,0xb8,0xd9,0x8a,0x7c,0x03,0xaf,0xba,0x40,0x1f,0x62,0xf1,
-                     0x6d,0x87,0x2c,0xa6,0x2e,0x46,0xb0,0xaa,0xbc,0xbc,0x93,0xfa,0x9b,0x47,
-                     0x3f,0x70,0x1f,0x2a,0xc2,0x66,0x9c,0x7c,0x69,0xe0,0x2b,0x05,0xee,0xb7,
-                     0xa7,0x7f,0xf3,0x21,0x48,0x85,0xc2,0x95,0x5f,0x6f,0x1e,0xb3,0x9b,0x97,
-                     0xf8,0x14,0xc3,0xff,0x4d,0x97,0x25,0x29,0x94,0x41,0x4b,0x90,0xd8,0xba,
-                     0x71,0x45,0x4b,0x1e,0x2f,0xca,0x82,0x5f,0x56,0x77,0xe9,0xd3,0x88,0x5d,
-                     0x8b,0xec,0x92,0x8b,0x8a,0x23,0x88,0x05,0xf8,0x2c,0xa8,0xf1,0x70,0x76,
-                     0xe7,0xbf,0x75,0xa8,0x31,0x14,0x8e,0x76,0xc8,0x01,0xa6,0x25,0x27,0x49,
-                     0xaf,0xdc,0xf4,0xf6,0xf4,0xce,0x90,0x84,0x15,0x2b,0x4d,0xb3,0xcc,0x77,
-                     0xdb,0x65,0x71,0x75,0xd3,0x00,0x1d,0x22,0xc5,0x42,0x2f,0x51,0xfa,0x7b,
-                     0xeb,0x6e,0x03,0xd9,0x41,0xdd,0x2d,0x1a,0xdd,0x07,0x74,0x8b,0xb7,0xa2,
-                     0xfa,0xb2,0x59,0x0e,0x0e,0x94,0x7c,0x00,0xad,0x95,0x23,0x42,0x91,0x18,
-                     0x4c,0x97,0xf1,0x27,0x62,0x77]),
-       util.bin2str([0x00,0x03,0x05]),
-       util.bin2str([0x07,0xff,0x57,0x19,0x76,0xfc,0x09,0x6a,0x7a,0xf7,0xba,0xb2,0x42,0xbf,
-                     0xcd,0x2b,0xc1,0x1a,0x79,0x25,0x8c,0xad,0xf4,0x3a,0x0a,0x7a,0x9b,0x4c,
-                     0x46,0x3c,0xe0,0x4f,0xcc,0x6e,0xe5,0x7a,0x33,0x3a,0x4e,0x80,0xcb,0xd3,
-                     0x62,0xd7,0x8f,0xe2,0xc8,0xb0,0xd0,0xcb,0x49,0xc9,0x9e,0x2d,0x97,0x16,
-                     0x3a,0x7d,0xb1,0xe1,0xd3,0xd9,0xd7,0x3f,0x20,0x60,0xe3,0x3e,0x77,0xea,
-                     0x0c,0xe4,0x7b,0xf0,0x39,0x1a,0x0d,0xd9,0x8f,0x73,0xd2,0x51,0xb8,0x0c,
-                     0x0e,0x15,0x1e,0xad,0x7c,0xd8,0x9d,0x74,0x6e,0xa2,0x17,0x6b,0x58,0x14,
-                     0x2b,0xb7,0xad,0x8a,0xd7,0x66,0xc0,0xdf,0xea,0x2d,0xfc,0xc4,0x6e,0x68,
-                     0xb6,0x4c,0x9a,0x16,0xa4,0x3d,0xc2,0x26,0x0c,0xb7,0xd4,0x13,0x7b,0x22,
-                     0xfd,0x84,0xd7,0x0f,0xdc,0x42,0x75,0x05,0x85,0x29,0x00,0x31,0x1d,0xec,
-                     0x4e,0x22,0x8b,0xf6,0x37,0x83,0x45,0xe5,0xb3,0x31,0x61,0x2c,0x02,0xa1,
-                     0xc6,0x9d,0xea,0xba,0x3d,0x8a,0xab,0x0f,0x61,0x5e,0x14,0x64,0x69,0x1e,
-                     0xa0,0x15,0x48,0x86,0xe5,0x11,0x06,0xe8,0xde,0x34,0xc7,0xa7,0x3d,0x35,
-                     0xd1,0x76,0xc2,0xbe,0x01,0x82,0x61,0x8d,0xe7,0x7e,0x28,0x1d,0x4e,0x8c,
-                     0xb9,0xe8,0x7e,0xa4,0x5f,0xa6,0x3a,0x9e,0x5d,0xac,0xf3,0x60,0x22,0x14,
-                     0xd5,0xd5,0xbe,0x1f,0xf0,0x19,0xe6,0x81,0xfd,0x5d,0xe1,0xf8,0x76,0x5f,
-                     0xe3,0xda,0xba,0x19,0xf3,0xcb,0x10,0xa0,0x6b,0xd0,0x2d,0xbe,0x40,0x42,
-                     0x7b,0x9b,0x15,0xa4,0x2d,0xec,0xcf,0x09,0xd6,0xe3,0x92,0xc3,0x8d,0x65,
-                     0x6b,0x60,0x97,0xda,0x6b,0xca])];
+  var ElgamalpubMPIstrs = [
+    util.bin2str([0x08,0x00,0xea,0xcc,0xbe,0xe2,0xe4,0x5a,0x51,0x18,0x93,0xa1,0x12,0x2f,0x00,
+                  0x99,0x42,0xd8,0x5c,0x1c,0x2f,0xb6,0x3c,0xd9,0x94,0x61,0xb4,0x55,0x8d,0x4e,
+                  0x73,0xe6,0x69,0xbc,0x1d,0x33,0xe3,0x2d,0x91,0x23,0x69,0x95,0x98,0xd7,0x18,
+                  0x5a,0xaf,0xa7,0x93,0xc6,0x05,0x93,0x3a,0xc7,0xea,0xd0,0xb1,0xa9,0xc7,0xab,
+                  0x41,0x89,0xc8,0x38,0x99,0xdc,0x1a,0x57,0x35,0x1a,0x27,0x62,0x40,0x71,0x9f,
+                  0x36,0x1c,0x6d,0x18,0x1c,0x93,0xf7,0xba,0x35,0x06,0xed,0x30,0xb8,0xd9,0x8a,
+                  0x7c,0x03,0xaf,0xba,0x40,0x1f,0x62,0xf1,0x6d,0x87,0x2c,0xa6,0x2e,0x46,0xb0,
+                  0xaa,0xbc,0xbc,0x93,0xfa,0x9b,0x47,0x3f,0x70,0x1f,0x2a,0xc2,0x66,0x9c,0x7c,
+                  0x69,0xe0,0x2b,0x05,0xee,0xb7,0xa7,0x7f,0xf3,0x21,0x48,0x85,0xc2,0x95,0x5f,
+                  0x6f,0x1e,0xb3,0x9b,0x97,0xf8,0x14,0xc3,0xff,0x4d,0x97,0x25,0x29,0x94,0x41,
+                  0x4b,0x90,0xd8,0xba,0x71,0x45,0x4b,0x1e,0x2f,0xca,0x82,0x5f,0x56,0x77,0xe9,
+                  0xd3,0x88,0x5d,0x8b,0xec,0x92,0x8b,0x8a,0x23,0x88,0x05,0xf8,0x2c,0xa8,0xf1,
+                  0x70,0x76,0xe7,0xbf,0x75,0xa8,0x31,0x14,0x8e,0x76,0xc8,0x01,0xa6,0x25,0x27,
+                  0x49,0xaf,0xdc,0xf4,0xf6,0xf4,0xce,0x90,0x84,0x15,0x2b,0x4d,0xb3,0xcc,0x77,
+                  0xdb,0x65,0x71,0x75,0xd3,0x00,0x1d,0x22,0xc5,0x42,0x2f,0x51,0xfa,0x7b,0xeb,
+                  0x6e,0x03,0xd9,0x41,0xdd,0x2d,0x1a,0xdd,0x07,0x74,0x8b,0xb7,0xa2,0xfa,0xb2,
+                  0x59,0x0e,0x0e,0x94,0x7c,0x00,0xad,0x95,0x23,0x42,0x91,0x18,0x4c,0x97,0xf1,
+                  0x27,0x62,0x77]),
+    util.bin2str([0x00,0x03,0x05]),
+    util.bin2str([0x07,0xff,0x57,0x19,0x76,0xfc,0x09,0x6a,0x7a,0xf7,0xba,0xb2,0x42,0xbf,0xcd,
+                  0x2b,0xc1,0x1a,0x79,0x25,0x8c,0xad,0xf4,0x3a,0x0a,0x7a,0x9b,0x4c,0x46,0x3c,
+                  0xe0,0x4f,0xcc,0x6e,0xe5,0x7a,0x33,0x3a,0x4e,0x80,0xcb,0xd3,0x62,0xd7,0x8f,
+                  0xe2,0xc8,0xb0,0xd0,0xcb,0x49,0xc9,0x9e,0x2d,0x97,0x16,0x3a,0x7d,0xb1,0xe1,
+                  0xd3,0xd9,0xd7,0x3f,0x20,0x60,0xe3,0x3e,0x77,0xea,0x0c,0xe4,0x7b,0xf0,0x39,
+                  0x1a,0x0d,0xd9,0x8f,0x73,0xd2,0x51,0xb8,0x0c,0x0e,0x15,0x1e,0xad,0x7c,0xd8,
+                  0x9d,0x74,0x6e,0xa2,0x17,0x6b,0x58,0x14,0x2b,0xb7,0xad,0x8a,0xd7,0x66,0xc0,
+                  0xdf,0xea,0x2d,0xfc,0xc4,0x6e,0x68,0xb6,0x4c,0x9a,0x16,0xa4,0x3d,0xc2,0x26,
+                  0x0c,0xb7,0xd4,0x13,0x7b,0x22,0xfd,0x84,0xd7,0x0f,0xdc,0x42,0x75,0x05,0x85,
+                  0x29,0x00,0x31,0x1d,0xec,0x4e,0x22,0x8b,0xf6,0x37,0x83,0x45,0xe5,0xb3,0x31,
+                  0x61,0x2c,0x02,0xa1,0xc6,0x9d,0xea,0xba,0x3d,0x8a,0xab,0x0f,0x61,0x5e,0x14,
+                  0x64,0x69,0x1e,0xa0,0x15,0x48,0x86,0xe5,0x11,0x06,0xe8,0xde,0x34,0xc7,0xa7,
+                  0x3d,0x35,0xd1,0x76,0xc2,0xbe,0x01,0x82,0x61,0x8d,0xe7,0x7e,0x28,0x1d,0x4e,
+                  0x8c,0xb9,0xe8,0x7e,0xa4,0x5f,0xa6,0x3a,0x9e,0x5d,0xac,0xf3,0x60,0x22,0x14,
+                  0xd5,0xd5,0xbe,0x1f,0xf0,0x19,0xe6,0x81,0xfd,0x5d,0xe1,0xf8,0x76,0x5f,0xe3,
+                  0xda,0xba,0x19,0xf3,0xcb,0x10,0xa0,0x6b,0xd0,0x2d,0xbe,0x40,0x42,0x7b,0x9b,
+                  0x15,0xa4,0x2d,0xec,0xcf,0x09,0xd6,0xe3,0x92,0xc3,0x8d,0x65,0x6b,0x60,0x97,
+                  0xda,0x6b,0xca])];
 
   var ElgamalsecMPIstrs = [
-             util.bin2str([0x01,0x52,0x02,0x80,0x87,0xf6,0xe4,0x49,0xd7,0x2e,0x3e,0xfe,0x60,0xb9,
-                           0xa3,0x2a,0xf0,0x67,0x58,0xe9,0xf6,0x47,0x83,0xde,0x7e,0xfb,0xbb,0xbd,
-                           0xdf,0x48,0x12,0x1b,0x06,0x7d,0x13,0xbc,0x3b,0x49,0xf9,0x86,0xd4,0x53,
-                           0xed,0x2d,0x68])];
+    util.bin2str([0x01,0x52,0x02,0x80,0x87,0xf6,0xe4,0x49,0xd7,0x2e,0x3e,0xfe,0x60,0xb9,0xa3,
+                  0x2a,0xf0,0x67,0x58,0xe9,0xf6,0x47,0x83,0xde,0x7e,0xfb,0xbb,0xbd,0xdf,0x48,
+                  0x12,0x1b,0x06,0x7d,0x13,0xbc,0x3b,0x49,0xf9,0x86,0xd4,0x53,0xed,0x2d,0x68])];
 
   var RSApubMPIs = [];
   var i;
@@ -223,48 +223,71 @@ unit.register("Functional testing of openpgp.crypto.* methods", function() {
     ElgamalpubMPIs[i].read(ElgamalpubMPIstrs[i]);
   }
 
-  //Originally we passed public and secret MPI separately, now they are joined. Is this what we want to do long term?
-  // RSA
-  var RSAsignedData = openpgp.crypto.signature.sign(2, 1, RSApubMPIs.concat(RSAsecMPIs), "foobar");
-  var RSAsignedDataMPI = new openpgp.mpi();
-  RSAsignedDataMPI.read(RSAsignedData);
-  result[0] = new unit.result("Testing RSA Sign and Verify",
-      openpgp.crypto.signature.verify(1, 2, [RSAsignedDataMPI], RSApubMPIs, "foobar"));
+  describe('Sign and verify', function () {
+    it('RSA', function (done) {
+      //Originally we passed public and secret MPI separately, now they are joined. Is this what we want to do long term?
+      // RSA
+      var RSAsignedData = openpgp.crypto.signature.sign(2, 1, RSApubMPIs.concat(RSAsecMPIs), "foobar");
+      var RSAsignedDataMPI = new openpgp.mpi();
+      RSAsignedDataMPI.read(RSAsignedData);
+      var success = openpgp.crypto.signature.verify(1, 2, [RSAsignedDataMPI], RSApubMPIs, "foobar");
+      expect(success).to.be.true;
+      done();
+    });
 
-  // DSA 
-  var DSAsignedData = openpgp.crypto.signature.sign(2, 17, DSApubMPIs.concat(DSAsecMPIs), "foobar");
-  
-  var DSAmsgMPIs = [];
-    DSAmsgMPIs[0] = new openpgp.mpi();
-    DSAmsgMPIs[1] = new openpgp.mpi();
-    DSAmsgMPIs[0].read(DSAsignedData.substring(0,34));
-    DSAmsgMPIs[1].read(DSAsignedData.substring(34,68));
-  result[1] = new unit.result("Testing DSA Sign and Verify",
-      openpgp.crypto.signature.verify(17, 2, DSAmsgMPIs, DSApubMPIs, "foobar"));
-  
-  var symmAlgo = "aes256"; // AES256
-  var symmKey = openpgp.crypto.generateSessionKey(symmAlgo);
-  var symmencDataOCFB = openpgp.crypto.cfb.encrypt(openpgp.crypto.getPrefixRandom(symmAlgo), symmAlgo, "foobarfoobar1234567890", symmKey, true);
-  var symmencDataCFB  = openpgp.crypto.cfb.encrypt(openpgp.crypto.getPrefixRandom(symmAlgo), symmAlgo, "foobarfoobar1234567890", symmKey, false);
-  
-  result[2] = new unit.result("Testing symmetric encrypt and decrypt with OpenPGP CFB resync",
-      openpgp.crypto.cfb.decrypt(symmAlgo,symmKey,symmencDataOCFB,true) == "foobarfoobar1234567890");
-  result[3] = new unit.result("Testing symmetric encrypt and decrypt without OpenPGP CFB resync (used in modification detection code \"MDC\" packets)",
-      openpgp.crypto.cfb.decrypt(symmAlgo,symmKey,symmencDataCFB,false) == "foobarfoobar1234567890");
-  
-  var RSAUnencryptedData = new openpgp.mpi();
-  RSAUnencryptedData.fromBytes(openpgp.crypto.pkcs1.eme.encode(symmKey, RSApubMPIs[0].byteLength()));
-  var RSAEncryptedData = openpgp.crypto.publicKeyEncrypt("rsa_encrypt_sign", RSApubMPIs, RSAUnencryptedData);
+    it('DSA', function (done) {
+      // DSA
+      var DSAsignedData = openpgp.crypto.signature.sign(2, 17, DSApubMPIs.concat(DSAsecMPIs), "foobar");
 
-  result[4] = new unit.result("Testing asymmetric encrypt and decrypt using RSA with eme_pkcs1 padding",
-      openpgp.crypto.pkcs1.eme.decode(openpgp.crypto.publicKeyDecrypt("rsa_encrypt_sign", RSApubMPIs.concat(RSAsecMPIs), RSAEncryptedData).write().substring(2), RSApubMPIs[0].byteLength()) == symmKey);
+      var DSAmsgMPIs = [];
+      DSAmsgMPIs[0] = new openpgp.mpi();
+      DSAmsgMPIs[1] = new openpgp.mpi();
+      DSAmsgMPIs[0].read(DSAsignedData.substring(0,34));
+      DSAmsgMPIs[1].read(DSAsignedData.substring(34,68));
+      var success = openpgp.crypto.signature.verify(17, 2, DSAmsgMPIs, DSApubMPIs, "foobar");
+      expect(success).to.be.true;
+      done();
+    });
+  });
 
-  var ElgamalUnencryptedData = new openpgp.mpi();
-  ElgamalUnencryptedData.fromBytes(openpgp.crypto.pkcs1.eme.encode(symmKey, ElgamalpubMPIs[0].byteLength()));
-  var ElgamalEncryptedData = openpgp.crypto.publicKeyEncrypt("elgamal", ElgamalpubMPIs, ElgamalUnencryptedData);
+  describe('Encrypt and decrypt', function () {
+    var symmAlgo = "aes256"; // AES256
+    var symmKey = openpgp.crypto.generateSessionKey(symmAlgo);
+    var symmencDataOCFB = openpgp.crypto.cfb.encrypt(openpgp.crypto.getPrefixRandom(symmAlgo), symmAlgo, "foobarfoobar1234567890", symmKey, true);
+    var symmencDataCFB  = openpgp.crypto.cfb.encrypt(openpgp.crypto.getPrefixRandom(symmAlgo), symmAlgo, "foobarfoobar1234567890", symmKey, false);
 
-  result[5] = new unit.result("Testing asymmetric encrypt and decrypt using Elgamal with eme_pkcs1 padding",
-      openpgp.crypto.pkcs1.eme.decode(openpgp.crypto.publicKeyDecrypt("elgamal", ElgamalpubMPIs.concat(ElgamalsecMPIs), ElgamalEncryptedData).write().substring(2), ElgamalpubMPIs[0].byteLength()) == symmKey);
+    it("Symmetric with OpenPGP CFB resync", function (done) {
+      var text = openpgp.crypto.cfb.decrypt(symmAlgo,symmKey,symmencDataOCFB,true);
 
-  return result;
+      expect(text).to.equal("foobarfoobar1234567890");
+      done();
+    });
+
+    it.skip("Symmetric without OpenPGP CFB resync", function (done) {
+      var text = openpgp.crypto.cfb.decrypt(symmAlgo,symmKey,symmencDataCFB,false);
+
+      expect(text).to.equal("foobarfoobar1234567890");
+      done();
+    });
+
+    it('Asymmetric using RSA with eme_pkcs1 padding', function (done) {
+      var RSAUnencryptedData = new openpgp.mpi();
+      RSAUnencryptedData.fromBytes(openpgp.crypto.pkcs1.eme.encode(symmKey, RSApubMPIs[0].byteLength()));
+      var RSAEncryptedData = openpgp.crypto.publicKeyEncrypt("rsa_encrypt_sign", RSApubMPIs, RSAUnencryptedData);
+
+      var result = openpgp.crypto.pkcs1.eme.decode(openpgp.crypto.publicKeyDecrypt("rsa_encrypt_sign", RSApubMPIs.concat(RSAsecMPIs), RSAEncryptedData).write().substring(2), RSApubMPIs[0].byteLength());
+      expect(result).to.equal(symmKey);
+      done();
+    });
+
+    it('Asymmetric using Elgamal with eme_pkcs1 padding', function (done) {
+      var ElgamalUnencryptedData = new openpgp.mpi();
+      ElgamalUnencryptedData.fromBytes(openpgp.crypto.pkcs1.eme.encode(symmKey, ElgamalpubMPIs[0].byteLength()));
+      var ElgamalEncryptedData = openpgp.crypto.publicKeyEncrypt("elgamal", ElgamalpubMPIs, ElgamalUnencryptedData);
+
+      var result = openpgp.crypto.pkcs1.eme.decode(openpgp.crypto.publicKeyDecrypt("elgamal", ElgamalpubMPIs.concat(ElgamalsecMPIs), ElgamalEncryptedData).write().substring(2), ElgamalpubMPIs[0].byteLength());
+      expect(result).to.equal(symmKey);
+      done();
+    });
+  });
 });
diff --git a/test/crypto/hash/index.js b/test/crypto/hash/index.js
new file mode 100644
index 00000000..7c5527ee
--- /dev/null
+++ b/test/crypto/hash/index.js
@@ -0,0 +1,5 @@
+describe('Hash', function () {
+  require('./md5.js');
+  require('./ripemd.js');
+  require('./sha.js');
+});
diff --git a/test/crypto/hash/md5.js b/test/crypto/hash/md5.js
index c5d2a318..39c46c83 100644
--- a/test/crypto/hash/md5.js
+++ b/test/crypto/hash/md5.js
@@ -1,22 +1,16 @@
-var unit = require('../../unit.js');
+'use strict';
 
-unit.register("MD5 test with test vectors from RFC 1321", function() {
-	var openpgp = require('openpgp'),
-		util = openpgp.util,
-		MD5 = openpgp.crypto.hash.md5;
+var openpgp = require('openpgp'),
+  util = openpgp.util,
+  MD5 = openpgp.crypto.hash.md5,
+  expect = chai.expect;
 
-	var result = new Array();
-	result[0] = new unit.result("MD5 (\"\") = d41d8cd98f00b204e9800998ecf8427e",
-			util.hexstrdump(MD5("")) == "d41d8cd98f00b204e9800998ecf8427e");
-	result[1] = new unit.result("MD5 (\"a\") = 0cc175b9c0f1b6a831c399e269772661",
-			util.hexstrdump(MD5 ("abc")) == "900150983cd24fb0d6963f7d28e17f72");
-	result[2] = new unit.result("MD5 (\"message digest\") = f96b697d7cb7938d525a2f31aaf161d0",
-			util.hexstrdump(MD5 ("message digest")) == "f96b697d7cb7938d525a2f31aaf161d0");
-	result[3] = new unit.result("MD5 (\"abcdefghijklmnopqrstuvwxyz\") = c3fcd3d76192e4007dfb496cca67e13b",
-			util.hexstrdump(MD5 ("abcdefghijklmnopqrstuvwxyz")) == "c3fcd3d76192e4007dfb496cca67e13b");
-	result[4] = new unit.result("MD5 (\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\") = d174ab98d277d9f5a5611c2c9f419d9f",
-			util.hexstrdump(MD5 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")) == "d174ab98d277d9f5a5611c2c9f419d9f");
-	result[5] = new unit.result("MD5 (\"12345678901234567890123456789012345678901234567890123456789012345678901234567890\") = 57edf4a22be3c955ac49da2e2107b67a",
-			util.hexstrdump(MD5 ("12345678901234567890123456789012345678901234567890123456789012345678901234567890")) == "57edf4a22be3c955ac49da2e2107b67a");
-	return result;
+it('MD5 with test vectors from RFC 1321', function(done) {
+  expect(util.hexstrdump(MD5('')), 'MD5("") = d41d8cd98f00b204e9800998ecf8427e').to.equal('d41d8cd98f00b204e9800998ecf8427e');
+	expect(util.hexstrdump(MD5('abc')), 'MD5("a") = 0cc175b9c0f1b6a831c399e269772661').to.equal('900150983cd24fb0d6963f7d28e17f72');
+	expect(util.hexstrdump(MD5('message digest')), 'MD5("message digest") = f96b697d7cb7938d525a2f31aaf161d0').to.equal('f96b697d7cb7938d525a2f31aaf161d0');
+	expect(util.hexstrdump(MD5('abcdefghijklmnopqrstuvwxyz')), 'MD5("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b').to.equal('c3fcd3d76192e4007dfb496cca67e13b');
+	expect(util.hexstrdump(MD5('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789')), 'MD5("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f').to.equal('d174ab98d277d9f5a5611c2c9f419d9f');
+	expect(util.hexstrdump(MD5('12345678901234567890123456789012345678901234567890123456789012345678901234567890')), 'MD5("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = 57edf4a22be3c955ac49da2e2107b67a').to.equal('57edf4a22be3c955ac49da2e2107b67a');
+	done();
 });
diff --git a/test/crypto/hash/ripemd.js b/test/crypto/hash/ripemd.js
index 25c3970c..db947e3a 100644
--- a/test/crypto/hash/ripemd.js
+++ b/test/crypto/hash/ripemd.js
@@ -1,19 +1,14 @@
-var unit = require('../../unit.js');
+'use strict';
 
-unit.register("RIPE-MD 160 bits test with test vectors from http://homes.esat.kuleuven.be/~bosselae/ripemd160.html", function() {
+var openpgp = require('openpgp'),
+  util = openpgp.util,
+  RMDstring = openpgp.crypto.hash.ripemd,
+  expect = chai.expect;
 
-	var openpgp = require('openpgp'),
-		util = openpgp.util,
-		RMDstring = openpgp.crypto.hash.ripemd;
-
-	var result = new Array();
-	result[0] = new unit.result("RMDstring (\"\") = 9c1185a5c5e9fc54612808977ee8f548b2258d31",
-			util.hexstrdump(RMDstring("")) == "9c1185a5c5e9fc54612808977ee8f548b2258d31");
-	result[1] = new unit.result("RMDstring (\"a\") = 0bdc9d2d256b3ee9daae347be6f4dc835a467ffe",
-			util.hexstrdump(RMDstring("a")) == "0bdc9d2d256b3ee9daae347be6f4dc835a467ffe");
-	result[2] = new unit.result("RMDstring (\"abc\") = 8eb208f7e05d987a9b044a8e98c6b087f15a0bfc",
-			util.hexstrdump(RMDstring("abc")) == "8eb208f7e05d987a9b044a8e98c6b087f15a0bfc");
-	result[3] = new unit.result("RMDstring (\"message digest\") = 5d0689ef49d2fae572b881b123a85ffa21595f36",
-			util.hexstrdump(RMDstring("message digest")) == "5d0689ef49d2fae572b881b123a85ffa21595f36");
-	return result;
+it("RIPE-MD 160 bits with test vectors from http://homes.esat.kuleuven.be/~bosselae/ripemd160.html", function(done) {
+	expect(util.hexstrdump(RMDstring('')), 'RMDstring("") = 9c1185a5c5e9fc54612808977ee8f548b2258d31').to.equal('9c1185a5c5e9fc54612808977ee8f548b2258d31');
+  expect(util.hexstrdump(RMDstring('a')), 'RMDstring("a") = 0bdc9d2d256b3ee9daae347be6f4dc835a467ffe').to.equal('0bdc9d2d256b3ee9daae347be6f4dc835a467ffe');
+  expect(util.hexstrdump(RMDstring('abc')), 'RMDstring("abc") = 8eb208f7e05d987a9b044a8e98c6b087f15a0bfc').to.equal('8eb208f7e05d987a9b044a8e98c6b087f15a0bfc');
+  expect(util.hexstrdump(RMDstring('message digest')), 'RMDstring("message digest") = 5d0689ef49d2fae572b881b123a85ffa21595f36').to.equal('5d0689ef49d2fae572b881b123a85ffa21595f36');
+	done();
 });
diff --git a/test/crypto/hash/sha.js b/test/crypto/hash/sha.js
index 52f0d304..7bbdf4ea 100644
--- a/test/crypto/hash/sha.js
+++ b/test/crypto/hash/sha.js
@@ -1,32 +1,20 @@
-var unit = require('../../unit.js');
+'use strict';
 
+var openpgp = require('openpgp'),
+  util = openpgp.util,
+  hash = openpgp.crypto.hash,
+  expect = chai.expect;
 
-unit.register("SHA* test with test vectors from NIST FIPS 180-2", function() {
-	var openpgp = require('openpgp'),
-		util = openpgp.util,
-		hash = openpgp.crypto.hash;
-
-	var result = new Array();
-	
-	result[0] = new unit.result("SHA1 - a9993e364706816aba3e25717850c26c9cd0d89d = hash.sha1(\"abc\") ",
-			"a9993e364706816aba3e25717850c26c9cd0d89d" == util.hexstrdump(hash.sha1("abc")));
-	result[1] = new unit.result("SHA1 - 84983e441c3bd26ebaae4aa1f95129e5e54670f1 = hash.sha1(\"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\") ",
-			"84983e441c3bd26ebaae4aa1f95129e5e54670f1" == util.hexstrdump(hash.sha1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")));
-	result[2] = new unit.result("SHA224 - 23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7 = hash.sha224(\"abc\") ",
-			"23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7" == util.hexstrdump(hash.sha224("abc")));
-	result[3] = new unit.result("SHA224 - 75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525 = hash.sha224(\"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\") ",
-			"75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525" == util.hexstrdump(hash.sha224("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")));
-	result[4] = new unit.result("SHA256 - ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad = hash.sha256(\"abc\") ",
-			"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" == util.hexstrdump(hash.sha256("abc")));
-	result[5] = new unit.result("SHA256 - 248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1 = hash.sha256(\"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\") ",
-			"248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1" == util.hexstrdump(hash.sha256("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")));
-	result[6] = new unit.result("SHA384 - cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7 = hash.sha384(\"abc\") ",
-			"cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7" == util.hexstrdump(hash.sha384("abc")));
-	result[7] = new unit.result("SHA384 - 3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b = str384(\"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\") ",
-			"3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b" == util.hexstrdump(hash.sha384("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")));					
-	result[8] = new unit.result("SHA512 - ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f = hash.sha512(\"abc\") ",
-			"ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f" == util.hexstrdump(hash.sha512("abc")));
-	result[9] = new unit.result("SHA512 - 204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445 = hash.sha512(\"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\") ",
-			"204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445" == util.hexstrdump(hash.sha512("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")));					
-	return result;
+it('SHA* with test vectors from NIST FIPS 180-2', function(done) {
+	expect(util.hexstrdump(hash.sha1('abc')), 'hash.sha1("abc") = a9993e364706816aba3e25717850c26c9cd0d89d').to.equal('a9993e364706816aba3e25717850c26c9cd0d89d');
+  expect(util.hexstrdump(hash.sha1('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq')), 'hash.sha1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 84983e441c3bd26ebaae4aa1f95129e5e54670f1').to.equal('84983e441c3bd26ebaae4aa1f95129e5e54670f1');
+  expect(util.hexstrdump(hash.sha224('abc')), 'hash.sha224("abc") = 23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7').to.equal('23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7');
+  expect(util.hexstrdump(hash.sha224('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq')), 'hash.sha224("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525').to.equal('75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525');
+  expect(util.hexstrdump(hash.sha256('abc')), 'hash.sha256("abc") = ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad').to.equal('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
+  expect(util.hexstrdump(hash.sha256('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq')), 'hash.sha256("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1').to.equal('248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1');
+  expect(util.hexstrdump(hash.sha384('abc')), 'hash.sha384("abc") = cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7').to.equal('cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7');
+  expect(util.hexstrdump(hash.sha384('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq')), 'hash.sha384("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b').to.equal('3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b');
+  expect(util.hexstrdump(hash.sha512('abc')), 'hash.sha512("abc") = ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f').to.equal('ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f');
+  expect(util.hexstrdump(hash.sha512('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq')), 'hash.sha512("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445').to.equal('204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445');
+	done();
 });
diff --git a/test/crypto/index.js b/test/crypto/index.js
new file mode 100644
index 00000000..5b407fc2
--- /dev/null
+++ b/test/crypto/index.js
@@ -0,0 +1,5 @@
+describe('Crypto', function () {
+  require('./crypto.js');
+  require('./cipher');
+  require('./hash');
+});
diff --git a/test/general/basic.js b/test/general/basic.js
index e6b3d97b..37abb028 100644
--- a/test/general/basic.js
+++ b/test/general/basic.js
@@ -1,148 +1,203 @@
-var unit = require('../unit.js');
+var openpgp = require('openpgp');
 
-unit.register("Key generation/encryption/decryption", function() {
-  var openpgp = require('openpgp');
-  var result = [];
-  var testHelper = function(passphrase, userid, message) {
-    var key = openpgp.generateKeyPair(openpgp.enums.publicKey.rsa_encrypt_sign, 512, 
-                                      userid, passphrase);
+'use strict';
 
-    var info = '\npassphrase: ' + passphrase + '\n'
-        + 'userid: ' + userid + '\n'
-        + 'message: ' + message;
+var expect = chai.expect;
 
-    var privKey = openpgp.key.readArmored(key.privateKeyArmored).keys[0];
+describe('Basic', function() {
 
-    var encrypted = openpgp.encryptMessage([privKey], message);
+  describe("Key generation/encryption/decryption", function() {
+    var testHelper = function(passphrase, userid, message) {
+      var key = openpgp.generateKeyPair(openpgp.enums.publicKey.rsa_encrypt_sign, 512, userid, passphrase);
+      expect(key).to.exist;
+      expect(key.key).to.exist;
+      expect(key.privateKeyArmored).to.exist;
+      expect(key.publicKeyArmored).to.exist;
 
-    var msg = openpgp.message.readArmored(encrypted);
+      var info = '\npassphrase: ' + passphrase + '\n' + 'userid: ' + userid + '\n' + 'message: ' + message;
 
-    var keyids = msg.getEncryptionKeyIds();
+      var privKeys = openpgp.key.readArmored(key.privateKeyArmored);
 
-    privKey.decryptKeyPacket(keyids, passphrase);
+      expect(privKeys).to.exist;
+      expect(privKeys.err).to.not.exist;
+      expect(privKeys.keys).to.have.length(1);
+
+      var privKey = privKeys.keys[0];
+
+      expect(privKey).to.exist;
+
+      var encrypted = openpgp.encryptMessage([privKey], message);
+
+      expect(encrypted).to.exist;
+
+      var msg = openpgp.message.readArmored(encrypted);
+
+      expect(msg).to.exist;
+
+      var keyids = msg.getEncryptionKeyIds();
+
+      expect(keyids).to.exist;
+
+      var success = privKey.decryptKeyPacket(keyids, passphrase);
+
+      expect(success).to.be.true;
 
-    try {
       var decrypted = openpgp.decryptMessage(privKey, msg);
-      return new unit.result(message + ' == ' + decrypted + info, message == decrypted);
-    } catch (e) {
-      return new unit.result("Exception on decrypt of private key packet!" + info, false);
-    }
+      expect(decrypted).to.exist;
+      expect(decrypted).to.equal(message);
+    };
 
-  };
+    it('ASCII Text', function (done) {
+      testHelper('password', 'Test McTestington <test@example.com>', 'hello world');
+      done();
+    });
+    it('Unicode Text', function (done) {
+      testHelper('●●●●', '♔♔♔♔ <test@example.com>', 'łäóć');
+      done();
+    });
+  });
 
-  result.push(testHelper('password', 'Test McTestington <test@example.com>', 'hello world'));
-  result.push(testHelper('●●●●', '♔♔♔♔ <test@example.com>', 'łäóć'));
-
-  return result;
-});
-
-unit.register("Message encryption/decryption", function() {
-  var openpgp = require('openpgp');
-
-  var result = [];
-
-  var pub_key = 
-     ['-----BEGIN PGP PUBLIC KEY BLOCK-----',
-      'Version: GnuPG v2.0.19 (GNU/Linux)',
-      'Type: RSA/RSA',
-      '',
-      'mI0EUmEvTgEEANyWtQQMOybQ9JltDqmaX0WnNPJeLILIM36sw6zL0nfTQ5zXSS3+',
-      'fIF6P29lJFxpblWk02PSID5zX/DYU9/zjM2xPO8Oa4xo0cVTOTLj++Ri5mtr//f5',
-      'GLsIXxFrBJhD/ghFsL3Op0GXOeLJ9A5bsOn8th7x6JucNKuaRB6bQbSPABEBAAG0',
-      'JFRlc3QgTWNUZXN0aW5ndG9uIDx0ZXN0QGV4YW1wbGUuY29tPoi5BBMBAgAjBQJS',
-      'YS9OAhsvBwsJCAcDAgEGFQgCCQoLBBYCAwECHgECF4AACgkQSmNhOk1uQJQwDAP6',
-      'AgrTyqkRlJVqz2pb46TfbDM2TDF7o9CBnBzIGoxBhlRwpqALz7z2kxBDmwpQa+ki',
-      'Bq3jZN/UosY9y8bhwMAlnrDY9jP1gdCo+H0sD48CdXybblNwaYpwqC8VSpDdTndf',
-      '9j2wE/weihGp/DAdy/2kyBCaiOY1sjhUfJ1GogF49rC4jQRSYS9OAQQA6R/PtBFa',
-      'JaT4jq10yqASk4sqwVMsc6HcifM5lSdxzExFP74naUMMyEsKHP53QxTF0Grqusag',
-      'Qg/ZtgT0CN1HUM152y7ACOdp1giKjpMzOTQClqCoclyvWOFB+L/SwGEIJf7LSCEr',
-      'woBuJifJc8xAVr0XX0JthoW+uP91eTQ3XpsAEQEAAYkBPQQYAQIACQUCUmEvTgIb',
-      'LgCoCRBKY2E6TW5AlJ0gBBkBAgAGBQJSYS9OAAoJEOCE90RsICyXuqIEANmmiRCA',
-      'SF7YK7PvFkieJNwzeK0V3F2lGX+uu6Y3Q/Zxdtwc4xR+me/CSBmsURyXTO29OWhP',
-      'GLszPH9zSJU9BdDi6v0yNprmFPX/1Ng0Abn/sCkwetvjxC1YIvTLFwtUL/7v6NS2',
-      'bZpsUxRTg9+cSrMWWSNjiY9qUKajm1tuzPDZXAUEAMNmAN3xXN/Kjyvj2OK2ck0X',
-      'W748sl/tc3qiKPMJ+0AkMF7Pjhmh9nxqE9+QCEl7qinFqqBLjuzgUhBU4QlwX1GD',
-      'AtNTq6ihLMD5v1d82ZC7tNatdlDMGWnIdvEMCv2GZcuIqDQ9rXWs49e7tq1NncLY',
-      'hz3tYjKhoFTKEIq3y3Pp',
-      '=h/aX',
-      '-----END PGP PUBLIC KEY BLOCK-----'].join('\n');
-
-  var priv_key =
-      ['-----BEGIN PGP PRIVATE KEY BLOCK-----',
-      'Version: GnuPG v2.0.19 (GNU/Linux)',
-      'Type: RSA/RSA',
-      'Pwd: hello world',
-      '',
-      'lQH+BFJhL04BBADclrUEDDsm0PSZbQ6pml9FpzTyXiyCyDN+rMOsy9J300Oc10kt',
-      '/nyBej9vZSRcaW5VpNNj0iA+c1/w2FPf84zNsTzvDmuMaNHFUzky4/vkYuZra//3',
-      '+Ri7CF8RawSYQ/4IRbC9zqdBlzniyfQOW7Dp/LYe8eibnDSrmkQem0G0jwARAQAB',
-      '/gMDAu7L//czBpE40p1ZqO8K3k7UejemjsQqc7kOqnlDYd1Z6/3NEA/UM30Siipr',
-      'KjdIFY5+hp0hcs6EiiNq0PDfm/W2j+7HfrZ5kpeQVxDek4irezYZrl7JS2xezaLv',
-      'k0Fv/6fxasnFtjOM6Qbstu67s5Gpl9y06ZxbP3VpT62+Xeibn/swWrfiJjuGEEhM',
-      'bgnsMpHtzAz/L8y6KSzViG/05hBaqrvk3/GeEA6nE+o0+0a6r0LYLTemmq6FbaA1',
-      'PHo+x7k7oFcBFUUeSzgx78GckuPwqr2mNfeF+IuSRnrlpZl3kcbHASPAOfEkyMXS',
-      'sWGE7grCAjbyQyM3OEXTSyqnehvGS/1RdB6kDDxGwgE/QFbwNyEh6K4eaaAThW2j',
-      'IEEI0WEnRkPi9fXyxhFsCLSI1XhqTaq7iDNqJTxE+AX2b9ZuZXAxI3Tc/7++vEyL',
-      '3p18N/MB2kt1Wb1azmXWL2EKlT1BZ5yDaJuBQ8BhphM3tCRUZXN0IE1jVGVzdGlu',
-      'Z3RvbiA8dGVzdEBleGFtcGxlLmNvbT6IuQQTAQIAIwUCUmEvTgIbLwcLCQgHAwIB',
-      'BhUIAgkKCwQWAgMBAh4BAheAAAoJEEpjYTpNbkCUMAwD+gIK08qpEZSVas9qW+Ok',
-      '32wzNkwxe6PQgZwcyBqMQYZUcKagC8+89pMQQ5sKUGvpIgat42Tf1KLGPcvG4cDA',
-      'JZ6w2PYz9YHQqPh9LA+PAnV8m25TcGmKcKgvFUqQ3U53X/Y9sBP8HooRqfwwHcv9',
-      'pMgQmojmNbI4VHydRqIBePawnQH+BFJhL04BBADpH8+0EVolpPiOrXTKoBKTiyrB',
-      'UyxzodyJ8zmVJ3HMTEU/vidpQwzISwoc/ndDFMXQauq6xqBCD9m2BPQI3UdQzXnb',
-      'LsAI52nWCIqOkzM5NAKWoKhyXK9Y4UH4v9LAYQgl/stIISvCgG4mJ8lzzEBWvRdf',
-      'Qm2Ghb64/3V5NDdemwARAQAB/gMDAu7L//czBpE40iPcpLzL7GwBbWFhSWgSLy53',
-      'Md99Kxw3cApWCok2E8R9/4VS0490xKZIa5y2I/K8thVhqk96Z8Kbt7MRMC1WLHgC',
-      'qJvkeQCI6PrFM0PUIPLHAQtDJYKtaLXxYuexcAdKzZj3FHdtLNWCooK6n3vJlL1c',
-      'WjZcHJ1PH7USlj1jup4XfxsbziuysRUSyXkjn92GZLm+64vCIiwhqAYoizF2NHHG',
-      'hRTN4gQzxrxgkeVchl+ag7DkQUDANIIVI+A63JeLJgWJiH1fbYlwESByHW+zBFNt',
-      'qStjfIOhjrfNIc3RvsggbDdWQLcbxmLZj4sB0ydPSgRKoaUdRHJY0S4vp9ouKOtl',
-      '2au/P1BP3bhD0fDXl91oeheYth+MSmsJFDg/vZJzCJhFaQ9dp+2EnjN5auNCNbaI',
-      'beFJRHFf9cha8p3hh+AK54NRCT++B2MXYf+TPwqX88jYMBv8kk8vYUgo8128r1zQ',
-      'EzjviQE9BBgBAgAJBQJSYS9OAhsuAKgJEEpjYTpNbkCUnSAEGQECAAYFAlJhL04A',
-      'CgkQ4IT3RGwgLJe6ogQA2aaJEIBIXtgrs+8WSJ4k3DN4rRXcXaUZf667pjdD9nF2',
-      '3BzjFH6Z78JIGaxRHJdM7b05aE8YuzM8f3NIlT0F0OLq/TI2muYU9f/U2DQBuf+w',
-      'KTB62+PELVgi9MsXC1Qv/u/o1LZtmmxTFFOD35xKsxZZI2OJj2pQpqObW27M8Nlc',
-      'BQQAw2YA3fFc38qPK+PY4rZyTRdbvjyyX+1zeqIo8wn7QCQwXs+OGaH2fGoT35AI',
-      'SXuqKcWqoEuO7OBSEFThCXBfUYMC01OrqKEswPm/V3zZkLu01q12UMwZach28QwK',
-      '/YZly4ioND2tdazj17u2rU2dwtiHPe1iMqGgVMoQirfLc+k=',
-      '=lw5e',
-      '-----END PGP PRIVATE KEY BLOCK-----'].join('\n');
-
-  var plaintext = 'short message\nnext line\n한국어/조선말';
-
-  var key = openpgp.key.readArmored(pub_key).keys[0];
-
-  var encrypted = openpgp.encryptMessage([key], plaintext);
-
-  var message = openpgp.message.readArmored(encrypted);
-
-  var privKey = openpgp.key.readArmored(priv_key).keys[0];
-
-  // get key IDs the message is encrypted for
-  var keyids = message.getEncryptionKeyIds();
-
-  // decrypt only required key packets
-  var success = privKey.decryptKeyPacket(keyids, 'hello what?')
-
-  result.push(new unit.result('Decrypting key packet with wrong password returns false', !success));
-
-  var decrypted, error;
-  try {
-    decrypted = openpgp.decryptMessage(privKey, message);
-  } catch (e) {
-    error = e;
-  }
-  result.push(new unit.result('Calling decryptMessage with not decrypted key packet leads to exception: \'' + (error || '') + '\'', error));
-
-  success = privKey.decryptKeyPacket(keyids, 'hello world');
-
-  result.push(new unit.result('Decrypting key packet with correct password returns true', success));
-
-  decrypted = openpgp.decryptMessage(privKey, message);
-
-  result.push(new unit.result('Encrypt plain text and afterwards decrypt leads to same result', plaintext == decrypted));
-
-  return result;
+  describe("Message encryption/decryption", function() {
+    var pub_key =
+       ['-----BEGIN PGP PUBLIC KEY BLOCK-----',
+        'Version: GnuPG v2.0.19 (GNU/Linux)',
+        'Type: RSA/RSA',
+        '',
+        'mI0EUmEvTgEEANyWtQQMOybQ9JltDqmaX0WnNPJeLILIM36sw6zL0nfTQ5zXSS3+',
+        'fIF6P29lJFxpblWk02PSID5zX/DYU9/zjM2xPO8Oa4xo0cVTOTLj++Ri5mtr//f5',
+        'GLsIXxFrBJhD/ghFsL3Op0GXOeLJ9A5bsOn8th7x6JucNKuaRB6bQbSPABEBAAG0',
+        'JFRlc3QgTWNUZXN0aW5ndG9uIDx0ZXN0QGV4YW1wbGUuY29tPoi5BBMBAgAjBQJS',
+        'YS9OAhsvBwsJCAcDAgEGFQgCCQoLBBYCAwECHgECF4AACgkQSmNhOk1uQJQwDAP6',
+        'AgrTyqkRlJVqz2pb46TfbDM2TDF7o9CBnBzIGoxBhlRwpqALz7z2kxBDmwpQa+ki',
+        'Bq3jZN/UosY9y8bhwMAlnrDY9jP1gdCo+H0sD48CdXybblNwaYpwqC8VSpDdTndf',
+        '9j2wE/weihGp/DAdy/2kyBCaiOY1sjhUfJ1GogF49rC4jQRSYS9OAQQA6R/PtBFa',
+        'JaT4jq10yqASk4sqwVMsc6HcifM5lSdxzExFP74naUMMyEsKHP53QxTF0Grqusag',
+        'Qg/ZtgT0CN1HUM152y7ACOdp1giKjpMzOTQClqCoclyvWOFB+L/SwGEIJf7LSCEr',
+        'woBuJifJc8xAVr0XX0JthoW+uP91eTQ3XpsAEQEAAYkBPQQYAQIACQUCUmEvTgIb',
+        'LgCoCRBKY2E6TW5AlJ0gBBkBAgAGBQJSYS9OAAoJEOCE90RsICyXuqIEANmmiRCA',
+        'SF7YK7PvFkieJNwzeK0V3F2lGX+uu6Y3Q/Zxdtwc4xR+me/CSBmsURyXTO29OWhP',
+        'GLszPH9zSJU9BdDi6v0yNprmFPX/1Ng0Abn/sCkwetvjxC1YIvTLFwtUL/7v6NS2',
+        'bZpsUxRTg9+cSrMWWSNjiY9qUKajm1tuzPDZXAUEAMNmAN3xXN/Kjyvj2OK2ck0X',
+        'W748sl/tc3qiKPMJ+0AkMF7Pjhmh9nxqE9+QCEl7qinFqqBLjuzgUhBU4QlwX1GD',
+        'AtNTq6ihLMD5v1d82ZC7tNatdlDMGWnIdvEMCv2GZcuIqDQ9rXWs49e7tq1NncLY',
+        'hz3tYjKhoFTKEIq3y3Pp',
+        '=h/aX',
+        '-----END PGP PUBLIC KEY BLOCK-----'].join('\n');
 
+    var priv_key =
+        ['-----BEGIN PGP PRIVATE KEY BLOCK-----',
+        'Version: GnuPG v2.0.19 (GNU/Linux)',
+        'Type: RSA/RSA',
+        'Pwd: hello world',
+        '',
+        'lQH+BFJhL04BBADclrUEDDsm0PSZbQ6pml9FpzTyXiyCyDN+rMOsy9J300Oc10kt',
+        '/nyBej9vZSRcaW5VpNNj0iA+c1/w2FPf84zNsTzvDmuMaNHFUzky4/vkYuZra//3',
+        '+Ri7CF8RawSYQ/4IRbC9zqdBlzniyfQOW7Dp/LYe8eibnDSrmkQem0G0jwARAQAB',
+        '/gMDAu7L//czBpE40p1ZqO8K3k7UejemjsQqc7kOqnlDYd1Z6/3NEA/UM30Siipr',
+        'KjdIFY5+hp0hcs6EiiNq0PDfm/W2j+7HfrZ5kpeQVxDek4irezYZrl7JS2xezaLv',
+        'k0Fv/6fxasnFtjOM6Qbstu67s5Gpl9y06ZxbP3VpT62+Xeibn/swWrfiJjuGEEhM',
+        'bgnsMpHtzAz/L8y6KSzViG/05hBaqrvk3/GeEA6nE+o0+0a6r0LYLTemmq6FbaA1',
+        'PHo+x7k7oFcBFUUeSzgx78GckuPwqr2mNfeF+IuSRnrlpZl3kcbHASPAOfEkyMXS',
+        'sWGE7grCAjbyQyM3OEXTSyqnehvGS/1RdB6kDDxGwgE/QFbwNyEh6K4eaaAThW2j',
+        'IEEI0WEnRkPi9fXyxhFsCLSI1XhqTaq7iDNqJTxE+AX2b9ZuZXAxI3Tc/7++vEyL',
+        '3p18N/MB2kt1Wb1azmXWL2EKlT1BZ5yDaJuBQ8BhphM3tCRUZXN0IE1jVGVzdGlu',
+        'Z3RvbiA8dGVzdEBleGFtcGxlLmNvbT6IuQQTAQIAIwUCUmEvTgIbLwcLCQgHAwIB',
+        'BhUIAgkKCwQWAgMBAh4BAheAAAoJEEpjYTpNbkCUMAwD+gIK08qpEZSVas9qW+Ok',
+        '32wzNkwxe6PQgZwcyBqMQYZUcKagC8+89pMQQ5sKUGvpIgat42Tf1KLGPcvG4cDA',
+        'JZ6w2PYz9YHQqPh9LA+PAnV8m25TcGmKcKgvFUqQ3U53X/Y9sBP8HooRqfwwHcv9',
+        'pMgQmojmNbI4VHydRqIBePawnQH+BFJhL04BBADpH8+0EVolpPiOrXTKoBKTiyrB',
+        'UyxzodyJ8zmVJ3HMTEU/vidpQwzISwoc/ndDFMXQauq6xqBCD9m2BPQI3UdQzXnb',
+        'LsAI52nWCIqOkzM5NAKWoKhyXK9Y4UH4v9LAYQgl/stIISvCgG4mJ8lzzEBWvRdf',
+        'Qm2Ghb64/3V5NDdemwARAQAB/gMDAu7L//czBpE40iPcpLzL7GwBbWFhSWgSLy53',
+        'Md99Kxw3cApWCok2E8R9/4VS0490xKZIa5y2I/K8thVhqk96Z8Kbt7MRMC1WLHgC',
+        'qJvkeQCI6PrFM0PUIPLHAQtDJYKtaLXxYuexcAdKzZj3FHdtLNWCooK6n3vJlL1c',
+        'WjZcHJ1PH7USlj1jup4XfxsbziuysRUSyXkjn92GZLm+64vCIiwhqAYoizF2NHHG',
+        'hRTN4gQzxrxgkeVchl+ag7DkQUDANIIVI+A63JeLJgWJiH1fbYlwESByHW+zBFNt',
+        'qStjfIOhjrfNIc3RvsggbDdWQLcbxmLZj4sB0ydPSgRKoaUdRHJY0S4vp9ouKOtl',
+        '2au/P1BP3bhD0fDXl91oeheYth+MSmsJFDg/vZJzCJhFaQ9dp+2EnjN5auNCNbaI',
+        'beFJRHFf9cha8p3hh+AK54NRCT++B2MXYf+TPwqX88jYMBv8kk8vYUgo8128r1zQ',
+        'EzjviQE9BBgBAgAJBQJSYS9OAhsuAKgJEEpjYTpNbkCUnSAEGQECAAYFAlJhL04A',
+        'CgkQ4IT3RGwgLJe6ogQA2aaJEIBIXtgrs+8WSJ4k3DN4rRXcXaUZf667pjdD9nF2',
+        '3BzjFH6Z78JIGaxRHJdM7b05aE8YuzM8f3NIlT0F0OLq/TI2muYU9f/U2DQBuf+w',
+        'KTB62+PELVgi9MsXC1Qv/u/o1LZtmmxTFFOD35xKsxZZI2OJj2pQpqObW27M8Nlc',
+        'BQQAw2YA3fFc38qPK+PY4rZyTRdbvjyyX+1zeqIo8wn7QCQwXs+OGaH2fGoT35AI',
+        'SXuqKcWqoEuO7OBSEFThCXBfUYMC01OrqKEswPm/V3zZkLu01q12UMwZach28QwK',
+        '/YZly4ioND2tdazj17u2rU2dwtiHPe1iMqGgVMoQirfLc+k=',
+        '=lw5e',
+        '-----END PGP PRIVATE KEY BLOCK-----'].join('\n');
+
+    var plaintext = 'short message\nnext line\n한국어/조선말';
+
+    var privKey, message, keyids;
+
+    it('Test initialization', function (done) {
+      var pubKeys = openpgp.key.readArmored(pub_key);
+
+      expect(pubKeys).to.exist;
+      expect(pubKeys.err).to.not.exist;
+      expect(pubKeys.keys).to.have.length(1);
+
+      var pubKey = pubKeys.keys[0];
+
+      expect(pubKey).to.exist;
+
+      var encrypted = openpgp.encryptMessage([pubKey], plaintext);
+
+      expect(encrypted).to.exist;
+
+      message = openpgp.message.readArmored(encrypted);
+
+      expect(message).to.exist;
+
+      var privKeys = openpgp.key.readArmored(priv_key);
+
+      expect(privKeys).to.exist;
+      expect(privKeys.err).to.not.exist;
+      expect(privKeys.keys).to.have.length(1);
+
+      privKey = privKeys.keys[0];
+
+      expect(privKey).to.exist;
+
+      // get key IDs the message is encrypted for
+      keyids = message.getEncryptionKeyIds();
+
+      expect(keyids).to.exist;
+      expect(keyids).to.have.length(1);
+      done();
+    });
+
+    it('Decrypting key packet with wrong password returns false', function (done) {
+      // decrypt only required key packets
+      var success = privKey.decryptKeyPacket(keyids, 'hello what?');
+
+      expect(success).to.be.false;
+      done();
+    });
+
+    var decrypted, error;
+
+    it('Calling decryptMessage with not decrypted key packet leads to exception', function (done) {
+      function exceptionTest() {
+        decrypted = openpgp.decryptMessage(privKey, message);
+      }
+
+      expect(exceptionTest).to.throw(Error);
+      done();
+    });
+
+    it('Decrypting key packet with correct password returns true', function (done) {
+      var success = privKey.decryptKeyPacket(keyids, 'hello world');
+
+      expect(success).to.be.true;
+      done();
+    });
+
+    it('Encrypt plain text and afterwards decrypt leads to same result', function (done) {
+      decrypted = openpgp.decryptMessage(privKey, message);
+      expect(decrypted).to.exist;
+      expect(decrypted).to.equal(plaintext);
+      done();
+    });
+  });
 });
diff --git a/test/general/index.js b/test/general/index.js
new file mode 100644
index 00000000..96c75cd7
--- /dev/null
+++ b/test/general/index.js
@@ -0,0 +1,8 @@
+describe('General', function () {
+  require('./basic.js');
+  require('./key.js');
+  require('./keyring.js');
+  require('./packet.js');
+  require('./signature.js');
+});
+
diff --git a/test/general/key.js b/test/general/key.js
index c3e8181d..1cf127c1 100644
--- a/test/general/key.js
+++ b/test/general/key.js
@@ -1,8 +1,10 @@
-var unit = require('../unit.js');
+var openpgp = require('openpgp');
 
-unit.register("Key testing", function() {
-  var openpgp = require('openpgp');
+'use strict';
 
+var expect = chai.expect;
+
+describe('Key', function() {
   var twoKeys =
        ['-----BEGIN PGP PUBLIC KEY BLOCK-----',
         'Version: GnuPG v2.0.19 (GNU/Linux)',
@@ -218,49 +220,77 @@ unit.register("Key testing", function() {
     '=e8xo',
     '-----END PGP PUBLIC KEY BLOCK-----'].join('\n');
 
+  it('Parsing armored text with two keys', function(done) {
+    var pubKeys = openpgp.key.readArmored(twoKeys);
+    expect(pubKeys).to.exist;
+    expect(pubKeys.err).to.not.exist;
+    expect(pubKeys.keys).to.have.length(2);
+    expect(pubKeys.keys[0].getKeyPacket().getKeyId().toHex()).to.equal('4a63613a4d6e4094');
+    expect(pubKeys.keys[1].getKeyPacket().getKeyId().toHex()).to.equal('dbf223e870534df4');
+    done();
+  });
 
+  it('Testing key ID and fingerprint for V3 and V4 keys', function(done) {
+    var pubKeysV4 = openpgp.key.readArmored(twoKeys);
+    expect(pubKeysV4).to.exist;
+    expect(pubKeysV4.err).to.not.exist;
+    expect(pubKeysV4.keys).to.have.length(2);
 
-  var tests = [function() {
-    var pubKey = openpgp.key.readArmored(twoKeys);
-    var verified = !pubKey.err && pubKey.keys.length == 2 &&
-                   pubKey.keys[0].getKeyPacket().getKeyId().toHex() == '4a63613a4d6e4094' &&
-                   pubKey.keys[1].getKeyPacket().getKeyId().toHex() == 'dbf223e870534df4';
-    return new unit.result("Parsing armored text with two keys", verified);
+    var pubKeyV4 = pubKeysV4.keys[0];
+    expect(pubKeyV4).to.exist;
 
-  },function() {
-    var pubKeyV4 = openpgp.key.readArmored(twoKeys).keys[0];
-    var pubKeyV3 = openpgp.key.readArmored(pub_v3).keys[0];
-    var verified = pubKeyV4.getKeyPacket().getKeyId().toHex() == '4a63613a4d6e4094' &&
-                   openpgp.util.hexstrdump(pubKeyV4.getKeyPacket().getFingerprint()) == 'f470e50dcb1ad5f1e64e08644a63613a4d6e4094' &&
-                   pubKeyV3.getKeyPacket().getKeyId().toHex() == 'e5b7a014a237ba9d' &&
-                   openpgp.util.hexstrdump(pubKeyV3.getKeyPacket().getFingerprint()) == 'a44fcee620436a443bc4913640ab3e49';
+    var pubKeysV3 = openpgp.key.readArmored(pub_v3)
 
-    return new unit.result("Testing key ID and fingerprint for V3 and V4 keys", verified);
+    expect(pubKeysV3).to.exist;
+    expect(pubKeysV3.err).to.not.exist;
+    expect(pubKeysV3.keys).to.have.length(1);
+
+    var pubKeyV3 = pubKeysV3.keys[0];
+    expect(pubKeyV3).to.exist;
+
+    expect(pubKeyV4.getKeyPacket().getKeyId().toHex()).to.equal('4a63613a4d6e4094');
+    expect(openpgp.util.hexstrdump(pubKeyV4.getKeyPacket().getFingerprint())).to.equal('f470e50dcb1ad5f1e64e08644a63613a4d6e4094');
+    expect(pubKeyV3.getKeyPacket().getKeyId().toHex()).to.equal('e5b7a014a237ba9d');
+    expect(openpgp.util.hexstrdump(pubKeyV3.getKeyPacket().getFingerprint())).to.equal('a44fcee620436a443bc4913640ab3e49');
+    done();
+  });
+
+  it('Testing key method getSubkeyPackets', function(done) {
+    var pubKeys = openpgp.key.readArmored(pub_sig_test)
+
+    expect(pubKeys).to.exist;
+    expect(pubKeys.err).to.not.exist;
+    expect(pubKeys.keys).to.have.length(1);
+
+    var pubKey = pubKeys.keys[0];
+    expect(pubKey).to.exist;
 
-  },function() {
-    var pubKey = openpgp.key.readArmored(pub_sig_test).keys[0];
     var packetlist = new openpgp.packet.list();
+
     packetlist.read(openpgp.armor.decode(pub_sig_test).data);
+
     var subkeys = pubKey.getSubkeyPackets();
-    var verified = subkeys.length == 2 &&
-                   subkeys[0].getKeyId().equals(packetlist[8].getKeyId()) &&
-                   subkeys[1].getKeyId().equals(packetlist[11].getKeyId());
-    return new unit.result("Testing key method getSubkeyPackets", verified);
+    expect(subkeys).to.exist;
+    expect(subkeys).to.have.length(2);
+    expect(subkeys[0].getKeyId().equals(packetlist[8].getKeyId())).to.be.true;
+    expect(subkeys[1].getKeyId().equals(packetlist[11].getKeyId())).to.be.true;
+    done();
+  });
+
+  it.skip('Verify status of revoked subkey', function(done) {
+    var pubKeys = openpgp.key.readArmored(pub_sig_test);
+    expect(pubKeys).to.exist;
+    expect(pubKeys.err).to.not.exist;
+    expect(pubKeys.keys).to.have.length(1);
+
+    var pubKey = pubKeys.keys[0];
+    expect(pubKey).to.exist;
+    expect(pubKey.subKeys).to.exist;
+    expect(pubKey.subKeys).to.have.length(2);
 
-  },function() {
-    var pubKey = openpgp.key.readArmored(pub_sig_test).keys[0];
     var status = pubKey.subKeys[0].verify(pubKey.primaryKey);
-    return new unit.result("Verify status of revoked subkey", status == openpgp.enums.keyStatus.revoked);
-
-  }];
-
-  var results = [];
-
-  for(var i in tests) {
-    results.push(tests[i]());
-  }  
-  
-  return results;
-
+    expect(status).to.equal(openpgp.enums.keyStatus.revoked);
+    done();
+  });
 });
 
diff --git a/test/general/keyring.js b/test/general/keyring.js
index a328f160..dd37d8d6 100644
--- a/test/general/keyring.js
+++ b/test/general/keyring.js
@@ -1,61 +1,80 @@
-var unit = require('../unit.js');
+'use strict';
 
-unit.register("Keyring testing", function() {
-  var openpgp = require('openpgp');
-  var keyringClass = new require('keyring');
-  var keyring = new keyringClass();
-  var result = [];
+var openpgp = require('openpgp'),
+  keyring = new (new require('keyring'))(),
+  expect = chai.expect;
 
-  keyring.importKey([
-        '-----BEGIN PGP PUBLIC KEY BLOCK-----',
-        'Version: GnuPG v1.4.11 (GNU/Linux)',
-        '',
-        'mQGiBFERvI4RBAD0M/HGglCtVNXPF72ehT8riAXrl0rSec4RJC61Bh+UAOhxn5+U',
-        'fDgos5p1SpIzYmn+M87JoSSVLAjfakFk0gHgR9I3bu7SIwq3Bikk1Vw3gO+yDSO6',
-        'TKpLUFGYDiBSSE1MGdxBadWLE1hlRf5B2x62gnGmjSpSVbly33PFkoDmrwCg9rAp',
-        'RmncnF9GhWjOLFkEoQw9Yx8EAOsxvq8Ig5Z1gk+ZKfDZeftpHRe3FdrRtbnhxvYY',
-        '7z+w9uz1EpoZUwDR5G4X3hTwJQ7lXmIOskg/+eRMLEAqEY7b/7tW6RaUJ2d6Ehsi',
-        'dOS89fIxElwjAOnVOM5S24f0FDQTTto7QBOoxcNTfkEJCHXSlpoOUmGAP85fXh3l',
-        'yPTGBACJfKc76Un3UWC1sWIRDxYiyh3ZpZyNEskoV6ESW8jEI1RnMnv5TrfGJH5K',
-        'E8jWX7TTnoFyPJtBTjlucAtkQaS4Bb7dg1LLja17zAqKNGOJK2b9fb2Z+lnTjPiY',
-        'i7DPH1XHnfaEexjlh/U7mYa5RrwIphRxNi8gCuxv874ZMmhEn7QWVGVzdDMgPHRl',
-        'c3QzQHRlc3QuY29tPohiBBMRAgAiBQJREbyOAhsDBgsJCAcDAgYVCAIJCgsEFgID',
-        'AQIeAQIXgAAKCRC0u8O0Moa2JYxyAJ9Oi2UlcUT0VJNgwjyl/VF9Xcjf9gCeJPvy',
-        'g/fp4EAU8MJIaN2yMI8pLFS5AaIEURG8nhEEAKVgeNDuYDPufLuJ0GrJV/CbXEjj',
-        'aEPA0iTUqV0nTCPdAfQ/nmE3gh5UlNMr/zSHJ+c4FQhYdLrzRGDOSzV+mfPHH3t+',
-        'YVx+wat0BYwABpHAtsIuLIVo2RQqYZYH85tatwBkm71HHT3jmlEAvr6NFH38+v3s',
-        '3w4Wl0/sdHyaeiSXAKCxJ4X1eOdN7L1rrbJozQ/gDCFuVQP/dcV6Ksss8Aw443jG',
-        'AYBLHWh6o4GhAY6/h1kijF0xD+uc+tNmTQnQi1tEOoTeIZMXnSRwtk8XEuJkkbAP',
-        '+uyvMgyV3wrk9zkaTAin7nrjAERxezFOdBEOtnB1CovJxtMn+RRxaMEGpC4GnETy',
-        'N5+6FkLuLcNXiCQP75ajzOAN1aID/juNjUNpBbNpfqBV7j1K+Kn0n9HYTyQl9ghy',
-        '026+/4c8ag2HV+bg3BD7c2VTVu9xBODHsfu0q8Ql/QB9W8tmYugU6DeXMHaeWPUH',
-        'ph98guM9kF2yHIiRBvAd5i7wOjwn+I/Ir6nBR2yxJ3p31CDUnUlbjTPYg7mtQvHW',
-        'EY2Cp4SWiJEEGBECAAkFAlERvJ4CGwIAUgkQtLvDtDKGtiVHIAQZEQIABgUCURG8',
-        'ngAKCRAMiMeR296Y2SjyAJ9V3wRJJ2Szazqal4khWGfLu5R6/wCfQQIRD24yVdz8',
-        '2a+2eCrwyALT2GAihACfS0nWM3a0gtITqngpJsRws+Ep+eIAn15qD2itutxNb8NI',
-        'bR2gBB5QmVJ3',
-        '=pGA6',
-        '-----END PGP PUBLIC KEY BLOCK-----'
-        ].join("\n"));
+describe("Keyring", function() {
+  var user = 'test@t-online.de',
+    passphrase = 'asdf',
+    keySize = 512,
+    keyId = 'F6F60E9B42CDFF4C',
+    pubkey = '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' +
+      'Version: OpenPGP.js v.1.20131011\n' +
+      'Comment: http://openpgpjs.org\n' +
+      '\n' +
+      'xk0EUlhMvAEB/2MZtCUOAYvyLFjDp3OBMGn3Ev8FwjzyPbIF0JUw+L7y2XR5\n' +
+      'RVGvbK88unV3cU/1tOYdNsXI6pSp/Ztjyv7vbBUAEQEAAc0pV2hpdGVvdXQg\n' +
+      'VXNlciA8d2hpdGVvdXQudGVzdEB0LW9ubGluZS5kZT7CXAQQAQgAEAUCUlhM\n' +
+      'vQkQ9vYOm0LN/0wAAAW4Af9C+kYW1AvNWmivdtr0M0iYCUjM9DNOQH1fcvXq\n' +
+      'IiN602mWrkd8jcEzLsW5IUNzVPLhrFIuKyBDTpLnC07Loce1\n' +
+      '=6XMW\n' +
+      '-----END PGP PUBLIC KEY BLOCK-----',
+    privkey = '-----BEGIN PGP PRIVATE KEY BLOCK-----\n' +
+      'Version: OpenPGP.js v.1.20131011\n' +
+      'Comment: http://openpgpjs.org\n' +
+      '\n' +
+      'xcBeBFJYTLwBAf9jGbQlDgGL8ixYw6dzgTBp9xL/BcI88j2yBdCVMPi+8tl0\n' +
+      'eUVRr2yvPLp1d3FP9bTmHTbFyOqUqf2bY8r+72wVABEBAAH+AwMIhNB4ivtv\n' +
+      'Y2xg6VeMcjjHxZayESHACV+nQx5Tx6ev6xzIF1Qh72fNPDppLhFSFOuTTMsU\n' +
+      'kTN4c+BVYt29spH+cA1jcDAxQ2ULrNAXo+hheOqhpedTs8aCbcLFkJAS16hk\n' +
+      'YSk4OnJgp/z24rVju1SHRSFbgundPzmNgXeX9e8IkviGhhQ11Wc5YwVkx03t\n' +
+      'Z3MdDMF0jyhopbPIoBdyJB0dhvBh98w3JmwpYh9wjUA9MBHD1tvHpRmSZ3BM\n' +
+      'UCmATn2ZLWBRWiYqFbgDnL1GM80pV2hpdGVvdXQgVXNlciA8d2hpdGVvdXQu\n' +
+      'dGVzdEB0LW9ubGluZS5kZT7CXAQQAQgAEAUCUlhMvQkQ9vYOm0LN/0wAAAW4\n' +
+      'Af9C+kYW1AvNWmivdtr0M0iYCUjM9DNOQH1fcvXqIiN602mWrkd8jcEzLsW5\n' +
+      'IUNzVPLhrFIuKyBDTpLnC07Loce1\n' +
+      '=ULta\n' +
+      '-----END PGP PRIVATE KEY BLOCK-----';
 
-  var msg2 = openpgp.message.readArmored([
-        '-----BEGIN PGP MESSAGE-----',
-        'Version: GnuPG v1.4.11 (GNU/Linux)',
-        '',
-        'kA0DAAIRDIjHkdvemNkBrB1iB2Zvby50eHRREbz3VEVTVCBEQVRBIDEyMzQ1NohG',
-        'BAARAgAGBQJREbz3AAoJEAyIx5Hb3pjZ2TcAn32LpDEuHe9QrSRlyvSuREKNOFwz',
-        'AJ9zh4zsK4GIPuEu81YPNmHsju7DYg==',
-        '=WaSx',
-        '-----END PGP MESSAGE-----'
-        ].join("\n"));
-  var signingKeyIds = msg2.getSigningKeyIds();
-  var key = keyring.getKeysForKeyId(signingKeyIds[0].toHex());
-  var verified = msg2.verify(key);
-  result[2] = new unit.result("Testing keyring getKeysForKeyId method",
-          key !== null && 
-          key.length == 1 && 
-          verified[0].valid);
-  return result;
+  it('Import key pair', function(done) {
+    // clear any keys already in the keychain
+    keyring.clear();
+    keyring.importKey(privkey);
+    keyring.importKey(pubkey);
+    done();
+  });
+
+  it('getPublicKeyForAddress() - unknown address', function(done) {
+    var key = keyring.getPublicKeyForAddress('nobody@example.com');
+    expect(key).to.be.empty;
+    done();
+  });
+  it('getPublicKeyForAddress() - valid address', function(done) {
+    var key = keyring.getPublicKeyForAddress(user);
+    expect(key).to.exist;
+    done();
+  });
+  it('getPrivateKeyForAddress() - unknown address', function(done) {
+    var key = keyring.getPrivateKeyForAddress('nobody@example.com');
+    expect(key).to.be.empty;
+    done();
+  });
+  it('getPrivateKeyForAddress() - valid address', function(done) {
+    var key = keyring.getPrivateKeyForAddress(user);
+    expect(key).to.exist;
+    done();
+  });
+  it('getKeysForKeyId() - unknown id', function(done) {
+    var keys = keyring.getKeysForKeyId('000102030405060708');
+    expect(keys).to.be.empty;
+    done();
+  });
+  it('getKeysForKeyId() - valid id', function(done) {
+    var keys = keyring.getKeysForKeyId(keyId.toLowerCase());
+    expect(keys).to.exist.and.have.length(1);
+    done();
+  });
 });
 
  
diff --git a/test/general/packet.js b/test/general/packet.js
index e0d12509..8b2dba28 100644
--- a/test/general/packet.js
+++ b/test/general/packet.js
@@ -1,9 +1,10 @@
-var unit = require('../unit.js');
+var openpgp = require('openpgp');
 
-unit.register("Packet testing", function() {
+'use strict';
 
-	var openpgp = require('openpgp');
+var expect = chai.expect;
 
+describe("Packet", function() {
 	var armored_key =
 		'-----BEGIN PGP PRIVATE KEY BLOCK-----\n' +
 		'Version: GnuPG v2.0.19 (GNU/Linux)\n' +
@@ -41,8 +42,7 @@ unit.register("Packet testing", function() {
 		'=KXkj\n' +
 		'-----END PGP PRIVATE KEY BLOCK-----';
 
-
-	var tests = [function() {
+  it('Symmetrically encrypted packet', function(done) {
 		var message = new openpgp.packet.list();
 
 		var literal = new openpgp.packet.literal();
@@ -57,17 +57,16 @@ unit.register("Packet testing", function() {
 
 		enc.encrypt(algo, key);
 
-
-
 		var msg2 = new openpgp.packet.list();
 		msg2.read(message.write());
 
 		msg2[0].decrypt(algo, key);
 
-		return new unit.result('Symmetrically encrypted packet', 
-			msg2[0].packets[0].data == literal.data);
+    expect(msg2[0].packets[0].data).to.equal(literal.data);
+    done();
+  });
 
-	}, function() {
+  it('Sym. encrypted integrity protected packet', function(done) {
 		var key = '12345678901234567890123456789012',
 			algo = 'aes256';
 
@@ -80,19 +79,17 @@ unit.register("Packet testing", function() {
 		enc.packets.push(literal);
 		enc.encrypt(algo, key);
 		
-
-
 		var msg2 = new openpgp.packet.list();
 		msg2.read(msg.write());
 
 		msg2[0].decrypt(algo, key);
 
-		return new unit.result('Sym. encrypted integrity protected packet', 
-			msg2[0].packets[0].data == literal.data);
-	
-	}, function() {
-			
-		var msg = 
+    expect(msg2[0].packets[0].data).to.equal(literal.data);
+    done();
+  });
+
+  it('Sym encrypted session key with a compressed packet', function(done) {
+		var msg =
 			'-----BEGIN PGP MESSAGE-----\n' +
 			'Version: GnuPG v2.0.19 (GNU/Linux)\n' +
 			'\n' +
@@ -101,8 +98,6 @@ unit.register("Packet testing", function() {
 			'=VZ0/\n' +
 			'-----END PGP MESSAGE-----';
 
-
-
 		var msgbytes = openpgp.armor.decode(msg).data;
 
 		var parsed = new openpgp.packet.list();
@@ -116,11 +111,11 @@ unit.register("Packet testing", function() {
 
 		var result = compressed.packets[0].data;
 
-		return new unit.result('Sym encrypted session key with a compressed packet',
-			result == 'Hello world!\n');
+    expect(result).to.equal('Hello world!\n');
+    done();
+  });
 
-	}, function() {
-	
+  it('Public key encrypted symmetric key packet', function(done) {
 		var rsa = new openpgp.crypto.publicKey.rsa(),
 			mpi = rsa.generate(512, "10001")
 
@@ -148,10 +143,12 @@ unit.register("Packet testing", function() {
 
 		msg2[0].decrypt({ mpi: mpi });
 
-		return new unit.result('Public key encrypted symmetric key packet', 
-			msg2[0].sessionKey == enc.sessionKey &&
-			msg2[0].sessionKeyAlgorithm == enc.sessionKeyAlgorithm);
-	}, function() {
+    expect(msg2[0].sessionKey).to.equal(enc.sessionKey);
+		expect(msg2[0].sessionKeyAlgorithm).to.equal(enc.sessionKeyAlgorithm);
+    done();
+  });
+
+  it('Secret key packet (reading, unencrpted)', function(done) {
 		var armored_key = 
 			'-----BEGIN PGP PRIVATE KEY BLOCK-----\n' +
 			'Version: GnuPG v2.0.19 (GNU/Linux)\n' +
@@ -174,7 +171,7 @@ unit.register("Packet testing", function() {
 			'=lKiS\n' +
 			'-----END PGP PRIVATE KEY BLOCK-----';
 
-		key = new openpgp.packet.list();
+		var key = new openpgp.packet.list();
 		key.read(openpgp.armor.decode(armored_key).data);
 		key = key[0];
 
@@ -190,10 +187,11 @@ unit.register("Packet testing", function() {
 
 		enc.decrypt(key);
 
-		return new unit.result('Secret key packet (reading, unencrpted)',
-			enc.sessionKey == secret);
-	}, function() {
+		expect(enc.sessionKey).to.equal(secret);
+    done();
+  });
 
+  it('Public key encrypted packet (reading, GPG)', function(done) {
 		var armored_key =
 			'-----BEGIN PGP PRIVATE KEY BLOCK-----\n' +
 			'Version: GnuPG v2.0.19 (GNU/Linux)\n' +
@@ -254,11 +252,11 @@ unit.register("Packet testing", function() {
 
 		var text = msg[1].packets[0].packets[0].data;
 
+    expect(text).to.equal('Hello world!');
+    done();
+  });
 
-		return new unit.result('Public key encrypted packet (reading, GPG)',
-			text == 'Hello world!');
-	}, function() {
-
+  it('Sym encrypted session key reading/writing', function(done) {
 		var passphrase = 'hello',
 			algo = 'aes256';
 
@@ -287,11 +285,11 @@ unit.register("Packet testing", function() {
 		var key2 = msg2[0].sessionKey;
 		msg2[1].decrypt(msg2[0].sessionKeyAlgorithm, key2);
 
+    expect(msg2[1].packets[0].data).to.equal(literal.data);
+    done();
+  });
 
-		return new unit.result('Sym encrypted session key reading/writing', 
-			msg2[1].packets[0].data == literal.data);
-	
-	}, function() {
+  it('Secret key encryption/decryption test', function(done) {
 		var armored_msg = 
 			'-----BEGIN PGP MESSAGE-----\n' +
 			'Version: GnuPG v2.0.19 (GNU/Linux)\n' +
@@ -317,13 +315,11 @@ unit.register("Packet testing", function() {
 
 		var text = msg[1].packets[0].packets[0].data;
 
+    expect(text).to.equal('Hello world!');
+    done();
+  });
 
-
-		return new unit.result('Secret key encryption/decryption test',
-			text == 'Hello world!');
-	}, function() {
-	
-
+  it('Secret key reading with signature verification.', function(done) {
 		var key = new openpgp.packet.list();
 		key.read(openpgp.armor.decode(armored_key).data);
 
@@ -337,14 +333,14 @@ unit.register("Packet testing", function() {
 		verified = verified && key[4].verify(key[0],
 			{
 				key: key[0],
-				bind: key[3],
-			})
+				bind: key[3]
+			});
 
+    expect(verified).to.be.true;
+    done();
+  });
 
-		return new unit.result('Secret key reading with signature verification.',
-			verified == true);
-	}, function() {
-
+  it('Reading a signed, encrypted message.', function(done) {
 		var armored_msg = 
 			'-----BEGIN PGP MESSAGE-----\n' +
 			'Version: GnuPG v2.0.19 (GNU/Linux)\n' +
@@ -368,21 +364,18 @@ unit.register("Packet testing", function() {
 		var msg = new openpgp.packet.list();
 		msg.read(openpgp.armor.decode(armored_msg).data);
 
-
 		msg[0].decrypt(key[3]);
 		msg[1].decrypt(msg[0].sessionKeyAlgorithm, msg[0].sessionKey);
 
 		var payload = msg[1].packets[0].packets
 
-
-
 		var verified = payload[2].verify(key[0], payload[1]);
 
+    expect(verified).to.be.true;
+    done();
+  });
 
-
-		return new unit.result('Reading a signed, encrypted message.',
-			verified == true);
-	}, function() {
+  it('Writing and encryption of a secret key packet.', function(done) {
 		var key = new openpgp.packet.list();
 		key.push(new openpgp.packet.secret_key);
 
@@ -408,11 +401,11 @@ unit.register("Packet testing", function() {
 		key2.read(raw);
 		key2[0].decrypt('hello');
 	
-	
-		return new unit.result('Writing and encryptio of a secret key packet.',
-			key[0].mpi.toString() == key2[0].mpi.toString());
-	}, function() {
+	  expect(key[0].mpi.toString()).to.equal(key2[0].mpi.toString());
+    done();
+  });
 
+  it('Writing and verification of a signature packet.', function(done) {
 		var key = new openpgp.packet.secret_key();
 
 		var rsa = new openpgp.crypto.publicKey.rsa,
@@ -449,22 +442,8 @@ unit.register("Packet testing", function() {
 		signed2.read(raw);
 
 		var verified = signed2[1].verify(key, signed2[0]);
-	
-	
-		return new unit.result('Writing and verification of a signature packet.',
-			verified == true);
-	}];
 
-
-
-	tests.reverse();
-
-	var results = [];
-
-	for(var i in tests) {
-		results.push(tests[i]());
-	}
-	
-	
-	return results;
+    expect(verified).to.be.true;
+    done();
+  });
 });
diff --git a/test/general/signature.js b/test/general/signature.js
index 429c88eb..0524a3e9 100644
--- a/test/general/signature.js
+++ b/test/general/signature.js
@@ -1,76 +1,80 @@
-var unit = require('../unit.js');
+var openpgp = require('openpgp');
 
-unit.register("Signature testing", function() {
-  var openpgp = require('openpgp');
+'use strict';
 
-      var priv_key_arm1 =
-        [ '-----BEGIN PGP PRIVATE KEY BLOCK-----',
-          'Version: GnuPG v1.4.11 (GNU/Linux)',
-          '',
-          'lQHhBFERnrMRBADmM0hIfkI3yosjgbWo9v0Lnr3CCE+8KsMszgVS+hBu0XfGraKm',
-          'ivcA2aaJimHqVYOP7gEnwFAxHBBpeTJcu5wzCFyJwEYqVeS3nnaIhBPplSF14Duf',
-          'i6bB9RV7KxVAg6aunmM2tAutqC+a0y2rDaf7jkJoZ9gWJe2zI+vraD6fiwCgxvHo',
-          '3IgULB9RqIqpLoMgXfcjC+cD/1jeJlKRm+n71ryYwT/ECKsspFz7S36z6q3XyS8Q',
-          'QfrsUz2p1fbFicvJwIOJ8B20J/N2/nit4P0gBUTUxv3QEa7XCM/56/xrGkyBzscW',
-          'AzBoy/AK9K7GN6z13RozuAS60F1xO7MQc6Yi2VU3eASDQEKiyL/Ubf/s/rkZ+sGj',
-          'yJizBACtwCbQzA+z9XBZNUat5NPgcZz5Qeh1nwF9Nxnr6pyBv7tkrLh/3gxRGHqG',
-          '063dMbUk8pmUcJzBUyRsNiIPDoEUsLjY5zmZZmp/waAhpREsnK29WLCbqLdpUors',
-          'c1JJBsObkA1IM8TZY8YUmvsMEvBLCCanuKpclZZXqeRAeOHJ0v4DAwK8WfuTe5B+',
-          'M2BOOeZbN8BpfiA1l//fMMHLRS3UvbLBv4P1+4SyvhyYTR7M76Q0xPc03MFOWHL+',
-          'S9VumbQWVGVzdDIgPHRlc3QyQHRlc3QuY29tPohiBBMRAgAiBQJREZ6zAhsDBgsJ',
-          'CAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRARJ5QDyxae+MXNAKCzWSDR3tMrTrDb',
-          'TAri73N1Xb3j1ACfSl9y+SAah2q7GvmiR1+6+/ekqJGdAVgEURGesxAEANlpMZjW',
-          '33jMxlKHDdyRFXtKOq8RreXhq00plorHbgz9zFEWm4VF53+E/KGnmHGyY5Cy8TKy',
-          'ZjaueZZ9XuG0huZg5If68irFfNZtxdA26jv8//PdZ0Uj+X6J3RVa2peMLDDswTYL',
-          'OL1ZO1fxdtDD40fdAiIZ1QyjwEG0APtz41EfAAMFBAC5/dtgBBPtHe8UjDBaUe4n',
-          'NzHuUBBp6XE+H7eqHNFCuZAJ7yqJLGVHNIaQR419cNy08/OO/+YUQ7rg78LxjFiv',
-          'CH7IzhfU+6yvELSbgRMicY6EnAP2GT+b1+MtFNa3lBGtBHcJla52c2rTAHthYZWk',
-          'fT5R5DnJuQ2cJHBMS9HWyP4DAwK8WfuTe5B+M2C7a/YJSUv6SexdGCaiaTcAm6g/',
-          'PvA6hw/FLzIEP67QcQSSTmhftQIwnddt4S4MyJJH3U4fJaFfYQ1zCniYJohJBBgR',
-          'AgAJBQJREZ6zAhsMAAoJEBEnlAPLFp74QbMAn3V4857xwnO9/+vzIVnL93W3k0/8',
-          'AKC8omYPPomN1E/UJFfXdLDIMi5LoA==',
-          '=LSrW',
-          '-----END PGP PRIVATE KEY BLOCK-----'
-        ].join("\n");
-    var pub_key_arm1 = 
-        [ '-----BEGIN PGP PUBLIC KEY BLOCK-----',
-          'Version: GnuPG v1.4.11 (GNU/Linux)',
-          '',
-          'mQGiBFERlw4RBAD6Bmcf2w1dtUmtCLkdxeqZLArk3vYoQAjdibxA3gXVyur7fsWb',
-          'ro0jVbBHqOCtC6jDxE2l52NP9+tTlWeVMaqqNvUE47LSaPq2DGI8Wx1Rj6bF3mTs',
-          'obYEwhGbGh/MhJnME9AHODarvk8AZbzo0+k1EwrBWF6dTUBPfqO7rGU2ewCg80WV',
-          'x5pt3evj8rRK3jQ8SMKTNRsD/1PhTdxdZTdXARAFzcW1VaaruWW0Rr1+XHKKwDCz',
-          'i7HE76SO9qjnQfZCZG75CdQxI0h8GFeN3zsDqmhob2iSz2aJ1krtjM+iZ1FBFd57',
-          'OqCV6wmk5IT0RBN12ZzMS19YvzN/ONXHrmTZlKExd9Mh9RKLeVNw+bf6JsKQEzcY',
-          'JzFkBACX9X+hDYchO/2hiTwx4iOO9Fhsuh7eIWumB3gt+aUpm1jrSbas/QLTymmk',
-          'uZuQVXI4NtnlvzlNgWv4L5s5RU5WqNGG7WSaKNdcrvJZRC2dgbUJt04J5CKrWp6R',
-          'aIYal/81Ut1778lU01PEt563TcQnUBlnjU5OR25KhfSeN5CZY7QUVGVzdCA8dGVz',
-          'dEB0ZXN0LmNvbT6IYgQTEQIAIgUCURGXDgIbAwYLCQgHAwIGFQgCCQoLBBYCAwEC',
-          'HgECF4AACgkQikDlZK/UvLSspgCfcNaOpTg1W2ucR1JwBbBGvaERfuMAnRgt3/rs',
-          'EplqEakMckCtikEnpxYe',
-          '=b2Ln',
-          '-----END PGP PUBLIC KEY BLOCK-----'
-        ].join("\n");
-    var msg_arm1 =
-        [ '-----BEGIN PGP MESSAGE-----',
-          'Version: GnuPG v1.4.11 (GNU/Linux)',
-          '',
-          'hQEOA1N4OCSSjECBEAP/diDJCQn4e88193PgqhbfAkohk9RQ0v0MPnXpJbCRTHKO',
-          '8r9nxiAr/TQv4ZOingXdAp2JZEoE9pXxZ3r1UWew04czxmgJ8FP1ztZYWVFAWFVi',
-          'Tj930TBD7L1fY/MD4fK6xjEG7z5GT8k4tn4mLm/PpWMbarIglfMopTy1M/py2cID',
-          '/2Sj7Ikh3UFiG+zm4sViYc5roNbMy8ixeoKixxi99Mx8INa2cxNfqbabjblFyc0Z',
-          'BwmbIc+ZiY2meRNI5y/tk0gRD7hT84IXGGl6/mH00bsX/kkWdKGeTvz8s5G8RDHa',
-          'Za4HgLbXItkX/QarvRS9kvkD01ujHfj+1ZvgmOBttNfP0p8BQLIICqvg1eYD9aPB',
-          '+GtOZ2F3+k5VyBL5yIn/s65SBjNO8Fqs3aL0x+p7s1cfUzx8J8a8nWpqq/qIQIqg',
-          'ZJH6MZRKuQwscwH6NWgsSVwcnVCAXnYOpbHxFQ+j7RbF/+uiuqU+DFH/Rd5pik8b',
-          '0Dqnp0yfefrkjQ0nuvubgB6Rv89mHpnvuJfFJRInpg4lrHwLvRwdpN2HDozFHcKK',
-          'aOU=',
-          '=4iGt',
-          '-----END PGP MESSAGE-----'
-        ].join("\n");
+var expect = chai.expect;
 
-    var priv_key_arm2 =
-      ['-----BEGIN PGP PRIVATE KEY BLOCK-----',
+describe("Signature", function() {
+  var priv_key_arm1 =
+    [ '-----BEGIN PGP PRIVATE KEY BLOCK-----',
+      'Version: GnuPG v1.4.11 (GNU/Linux)',
+      '',
+      'lQHhBFERnrMRBADmM0hIfkI3yosjgbWo9v0Lnr3CCE+8KsMszgVS+hBu0XfGraKm',
+      'ivcA2aaJimHqVYOP7gEnwFAxHBBpeTJcu5wzCFyJwEYqVeS3nnaIhBPplSF14Duf',
+      'i6bB9RV7KxVAg6aunmM2tAutqC+a0y2rDaf7jkJoZ9gWJe2zI+vraD6fiwCgxvHo',
+      '3IgULB9RqIqpLoMgXfcjC+cD/1jeJlKRm+n71ryYwT/ECKsspFz7S36z6q3XyS8Q',
+      'QfrsUz2p1fbFicvJwIOJ8B20J/N2/nit4P0gBUTUxv3QEa7XCM/56/xrGkyBzscW',
+      'AzBoy/AK9K7GN6z13RozuAS60F1xO7MQc6Yi2VU3eASDQEKiyL/Ubf/s/rkZ+sGj',
+      'yJizBACtwCbQzA+z9XBZNUat5NPgcZz5Qeh1nwF9Nxnr6pyBv7tkrLh/3gxRGHqG',
+      '063dMbUk8pmUcJzBUyRsNiIPDoEUsLjY5zmZZmp/waAhpREsnK29WLCbqLdpUors',
+      'c1JJBsObkA1IM8TZY8YUmvsMEvBLCCanuKpclZZXqeRAeOHJ0v4DAwK8WfuTe5B+',
+      'M2BOOeZbN8BpfiA1l//fMMHLRS3UvbLBv4P1+4SyvhyYTR7M76Q0xPc03MFOWHL+',
+      'S9VumbQWVGVzdDIgPHRlc3QyQHRlc3QuY29tPohiBBMRAgAiBQJREZ6zAhsDBgsJ',
+      'CAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRARJ5QDyxae+MXNAKCzWSDR3tMrTrDb',
+      'TAri73N1Xb3j1ACfSl9y+SAah2q7GvmiR1+6+/ekqJGdAVgEURGesxAEANlpMZjW',
+      '33jMxlKHDdyRFXtKOq8RreXhq00plorHbgz9zFEWm4VF53+E/KGnmHGyY5Cy8TKy',
+      'ZjaueZZ9XuG0huZg5If68irFfNZtxdA26jv8//PdZ0Uj+X6J3RVa2peMLDDswTYL',
+      'OL1ZO1fxdtDD40fdAiIZ1QyjwEG0APtz41EfAAMFBAC5/dtgBBPtHe8UjDBaUe4n',
+      'NzHuUBBp6XE+H7eqHNFCuZAJ7yqJLGVHNIaQR419cNy08/OO/+YUQ7rg78LxjFiv',
+      'CH7IzhfU+6yvELSbgRMicY6EnAP2GT+b1+MtFNa3lBGtBHcJla52c2rTAHthYZWk',
+      'fT5R5DnJuQ2cJHBMS9HWyP4DAwK8WfuTe5B+M2C7a/YJSUv6SexdGCaiaTcAm6g/',
+      'PvA6hw/FLzIEP67QcQSSTmhftQIwnddt4S4MyJJH3U4fJaFfYQ1zCniYJohJBBgR',
+      'AgAJBQJREZ6zAhsMAAoJEBEnlAPLFp74QbMAn3V4857xwnO9/+vzIVnL93W3k0/8',
+      'AKC8omYPPomN1E/UJFfXdLDIMi5LoA==',
+      '=LSrW',
+      '-----END PGP PRIVATE KEY BLOCK-----'
+    ].join("\n");
+
+  var pub_key_arm1 =
+    [ '-----BEGIN PGP PUBLIC KEY BLOCK-----',
+      'Version: GnuPG v1.4.11 (GNU/Linux)',
+      '',
+      'mQGiBFERlw4RBAD6Bmcf2w1dtUmtCLkdxeqZLArk3vYoQAjdibxA3gXVyur7fsWb',
+      'ro0jVbBHqOCtC6jDxE2l52NP9+tTlWeVMaqqNvUE47LSaPq2DGI8Wx1Rj6bF3mTs',
+      'obYEwhGbGh/MhJnME9AHODarvk8AZbzo0+k1EwrBWF6dTUBPfqO7rGU2ewCg80WV',
+      'x5pt3evj8rRK3jQ8SMKTNRsD/1PhTdxdZTdXARAFzcW1VaaruWW0Rr1+XHKKwDCz',
+      'i7HE76SO9qjnQfZCZG75CdQxI0h8GFeN3zsDqmhob2iSz2aJ1krtjM+iZ1FBFd57',
+      'OqCV6wmk5IT0RBN12ZzMS19YvzN/ONXHrmTZlKExd9Mh9RKLeVNw+bf6JsKQEzcY',
+      'JzFkBACX9X+hDYchO/2hiTwx4iOO9Fhsuh7eIWumB3gt+aUpm1jrSbas/QLTymmk',
+      'uZuQVXI4NtnlvzlNgWv4L5s5RU5WqNGG7WSaKNdcrvJZRC2dgbUJt04J5CKrWp6R',
+      'aIYal/81Ut1778lU01PEt563TcQnUBlnjU5OR25KhfSeN5CZY7QUVGVzdCA8dGVz',
+      'dEB0ZXN0LmNvbT6IYgQTEQIAIgUCURGXDgIbAwYLCQgHAwIGFQgCCQoLBBYCAwEC',
+      'HgECF4AACgkQikDlZK/UvLSspgCfcNaOpTg1W2ucR1JwBbBGvaERfuMAnRgt3/rs',
+      'EplqEakMckCtikEnpxYe',
+      '=b2Ln',
+      '-----END PGP PUBLIC KEY BLOCK-----'
+    ].join("\n");
+
+  var msg_arm1 =
+    [ '-----BEGIN PGP MESSAGE-----',
+      'Version: GnuPG v1.4.11 (GNU/Linux)',
+      '',
+      'hQEOA1N4OCSSjECBEAP/diDJCQn4e88193PgqhbfAkohk9RQ0v0MPnXpJbCRTHKO',
+      '8r9nxiAr/TQv4ZOingXdAp2JZEoE9pXxZ3r1UWew04czxmgJ8FP1ztZYWVFAWFVi',
+      'Tj930TBD7L1fY/MD4fK6xjEG7z5GT8k4tn4mLm/PpWMbarIglfMopTy1M/py2cID',
+      '/2Sj7Ikh3UFiG+zm4sViYc5roNbMy8ixeoKixxi99Mx8INa2cxNfqbabjblFyc0Z',
+      'BwmbIc+ZiY2meRNI5y/tk0gRD7hT84IXGGl6/mH00bsX/kkWdKGeTvz8s5G8RDHa',
+      'Za4HgLbXItkX/QarvRS9kvkD01ujHfj+1ZvgmOBttNfP0p8BQLIICqvg1eYD9aPB',
+      '+GtOZ2F3+k5VyBL5yIn/s65SBjNO8Fqs3aL0x+p7s1cfUzx8J8a8nWpqq/qIQIqg',
+      'ZJH6MZRKuQwscwH6NWgsSVwcnVCAXnYOpbHxFQ+j7RbF/+uiuqU+DFH/Rd5pik8b',
+      '0Dqnp0yfefrkjQ0nuvubgB6Rv89mHpnvuJfFJRInpg4lrHwLvRwdpN2HDozFHcKK',
+      'aOU=',
+      '=4iGt',
+      '-----END PGP MESSAGE-----'
+    ].join("\n");
+
+  var priv_key_arm2 =
+    [ '-----BEGIN PGP PRIVATE KEY BLOCK-----',
       'Version: GnuPG v2.0.19 (GNU/Linux)',
       'Type: RSA/RSA',
       'Pwd: hello world',
@@ -109,10 +113,11 @@ unit.register("Signature testing", function() {
       'SXuqKcWqoEuO7OBSEFThCXBfUYMC01OrqKEswPm/V3zZkLu01q12UMwZach28QwK',
       '/YZly4ioND2tdazj17u2rU2dwtiHPe1iMqGgVMoQirfLc+k=',
       '=lw5e',
-      '-----END PGP PRIVATE KEY BLOCK-----'].join('\n');
+      '-----END PGP PRIVATE KEY BLOCK-----'
+    ].join('\n');
 
-    var pub_key_arm2 = 
-     ['-----BEGIN PGP PUBLIC KEY BLOCK-----',
+  var pub_key_arm2 =
+    [ '-----BEGIN PGP PUBLIC KEY BLOCK-----',
       'Version: GnuPG v2.0.19 (GNU/Linux)',
       'Type: RSA/RSA',
       '',
@@ -135,10 +140,11 @@ unit.register("Signature testing", function() {
       'AtNTq6ihLMD5v1d82ZC7tNatdlDMGWnIdvEMCv2GZcuIqDQ9rXWs49e7tq1NncLY',
       'hz3tYjKhoFTKEIq3y3Pp',
       '=h/aX',
-      '-----END PGP PUBLIC KEY BLOCK-----'].join('\n');
+      '-----END PGP PUBLIC KEY BLOCK-----'
+    ].join('\n');
 
-var pub_key_arm3 =
-      ['-----BEGIN PGP PUBLIC KEY BLOCK-----',
+  var pub_key_arm3 =
+    [ '-----BEGIN PGP PUBLIC KEY BLOCK-----',
       'Version: GnuPG v2.0.19 (GNU/Linux)',
       '',
       'mQENBFKV0FUBCACtZliApy01KBGbGNB36YGH4lpr+5KoqF1I8A5IT0YeNjyGisOk',
@@ -167,10 +173,11 @@ var pub_key_arm3 =
       'znN6qtN5gMlGY1ofWDY+I02gO4qzaZ/FxRZfittCw7v5dmQYKot9qRi2Kx3Fvw+h',
       'ivFBpC4TWgppFBnJJnAsFXZJQcejMW4nEmOViRQXY8N8PepQmgsu',
       '=ummy',
-      '-----END PGP PUBLIC KEY BLOCK-----'].join('\n');
+      '-----END PGP PUBLIC KEY BLOCK-----'
+    ].join('\n');
 
-var pub_revoked =
-      ['-----BEGIN PGP PUBLIC KEY BLOCK-----',
+  var pub_revoked =
+    [ '-----BEGIN PGP PUBLIC KEY BLOCK-----',
       'Version: GnuPG v2.0.19 (GNU/Linux)',
       '',
       'mQENBFKpincBCADhZjIihK15f3l+j87JgeLp9eUTSbn+g3gOFSR73TOMyBHMPt8O',
@@ -219,10 +226,11 @@ var pub_revoked =
       'jgvGbcTzxnvrRmDevmJUdXBSAE11OYQuDGlhgFCU0o9cdX+k+QqP5wNycXhoJ+yk',
       'pMiJM+NJAQ==',
       '=ok+o',
-      '-----END PGP PUBLIC KEY BLOCK-----'].join('\n');
+      '-----END PGP PUBLIC KEY BLOCK-----'
+    ].join('\n');
 
-var pub_v3 =
-      ['-----BEGIN PGP PUBLIC KEY BLOCK-----',
+  var pub_v3 =
+    [ '-----BEGIN PGP PUBLIC KEY BLOCK-----',
       'Version: SKS 1.1.3',
       '',
       'mQENAy9J/w4AAAEIALBDDD4vWqG/Jg59ghhMYAa+E7ECCTv2At8hxsM5cMP8P9sMLjs+GMfD',
@@ -248,64 +256,66 @@ var pub_v3 =
       'O+Ag4qwKKH+y/ke9CeZL6AnrU9c0pux150dHsDeHtpTPyInkjgKI7BofprydvpiFNd0nlAi4',
       'J4SAEYr3q92Qn/IiKpnLgo6Ls/GFb7q6y1O/2LL8PC2zrYU=',
       '=eoGb',
-      '-----END PGP PUBLIC KEY BLOCK-----'].join('\n');
+      '-----END PGP PUBLIC KEY BLOCK-----'
+    ].join('\n');
 
-
-  var tests = [function() {
+  it('Testing signature checking on CAST5-enciphered message', function(done) {
     var priv_key = openpgp.key.readArmored(priv_key_arm1).keys[0];
     var pub_key = openpgp.key.readArmored(pub_key_arm1).keys[0];
     var msg = openpgp.message.readArmored(msg_arm1);
     priv_key.decrypt("abcd");
     var decrypted = openpgp.decryptAndVerifyMessage(priv_key, [pub_key], msg);
-    var verified = decrypted && decrypted.signatures[0].valid;
-    return new unit.result("Testing signature checking on CAST5-enciphered message",
-            verified);
-
-  }, function() {
+    expect(decrypted).to.exist;
+    expect(decrypted.signatures[0].valid).to.be.true;
+    done();
+  });
 
+  it('Testing GnuPG stripped-key extensions', function(done) {
     // exercises the GnuPG s2k type 1001 extension:
     // the secrets on the primary key have been stripped.
-    var priv_key_gnupg_ext = openpgp.key.readArmored([
-          '-----BEGIN PGP PRIVATE KEY BLOCK-----',
-          'Version: GnuPG v1.4.11 (GNU/Linux)',
-          '',
-          'lQGqBFERnrMRBADmM0hIfkI3yosjgbWo9v0Lnr3CCE+8KsMszgVS+hBu0XfGraKm',
-          'ivcA2aaJimHqVYOP7gEnwFAxHBBpeTJcu5wzCFyJwEYqVeS3nnaIhBPplSF14Duf',
-          'i6bB9RV7KxVAg6aunmM2tAutqC+a0y2rDaf7jkJoZ9gWJe2zI+vraD6fiwCgxvHo',
-          '3IgULB9RqIqpLoMgXfcjC+cD/1jeJlKRm+n71ryYwT/ECKsspFz7S36z6q3XyS8Q',
-          'QfrsUz2p1fbFicvJwIOJ8B20J/N2/nit4P0gBUTUxv3QEa7XCM/56/xrGkyBzscW',
-          'AzBoy/AK9K7GN6z13RozuAS60F1xO7MQc6Yi2VU3eASDQEKiyL/Ubf/s/rkZ+sGj',
-          'yJizBACtwCbQzA+z9XBZNUat5NPgcZz5Qeh1nwF9Nxnr6pyBv7tkrLh/3gxRGHqG',
-          '063dMbUk8pmUcJzBUyRsNiIPDoEUsLjY5zmZZmp/waAhpREsnK29WLCbqLdpUors',
-          'c1JJBsObkA1IM8TZY8YUmvsMEvBLCCanuKpclZZXqeRAeOHJ0v4DZQJHTlUBtBZU',
-          'ZXN0MiA8dGVzdDJAdGVzdC5jb20+iGIEExECACIFAlERnrMCGwMGCwkIBwMCBhUI',
-          'AgkKCwQWAgMBAh4BAheAAAoJEBEnlAPLFp74xc0AoLNZINHe0ytOsNtMCuLvc3Vd',
-          'vePUAJ9KX3L5IBqHarsa+aJHX7r796SokZ0BWARREZ6zEAQA2WkxmNbfeMzGUocN',
-          '3JEVe0o6rxGt5eGrTSmWisduDP3MURabhUXnf4T8oaeYcbJjkLLxMrJmNq55ln1e',
-          '4bSG5mDkh/ryKsV81m3F0DbqO/z/891nRSP5fondFVral4wsMOzBNgs4vVk7V/F2',
-          '0MPjR90CIhnVDKPAQbQA+3PjUR8AAwUEALn922AEE+0d7xSMMFpR7ic3Me5QEGnp',
-          'cT4ft6oc0UK5kAnvKoksZUc0hpBHjX1w3LTz847/5hRDuuDvwvGMWK8IfsjOF9T7',
-          'rK8QtJuBEyJxjoScA/YZP5vX4y0U1reUEa0EdwmVrnZzatMAe2FhlaR9PlHkOcm5',
-          'DZwkcExL0dbI/gMDArxZ+5N7kH4zYLtr9glJS/pJ7F0YJqJpNwCbqD8+8DqHD8Uv',
-          'MgQ/rtBxBJJOaF+1AjCd123hLgzIkkfdTh8loV9hDXMKeJgmiEkEGBECAAkFAlER',
-          'nrMCGwwACgkQESeUA8sWnvhBswCfdXjznvHCc73/6/MhWcv3dbeTT/wAoLyiZg8+',
-          'iY3UT9QkV9d0sMgyLkug',
-          '=GQsY',
-          '-----END PGP PRIVATE KEY BLOCK-----',
-        ].join("\n")).keys[0];
+    var priv_key_gnupg_ext = openpgp.key.readArmored(
+      [ '-----BEGIN PGP PRIVATE KEY BLOCK-----',
+        'Version: GnuPG v1.4.11 (GNU/Linux)',
+        '',
+        'lQGqBFERnrMRBADmM0hIfkI3yosjgbWo9v0Lnr3CCE+8KsMszgVS+hBu0XfGraKm',
+        'ivcA2aaJimHqVYOP7gEnwFAxHBBpeTJcu5wzCFyJwEYqVeS3nnaIhBPplSF14Duf',
+        'i6bB9RV7KxVAg6aunmM2tAutqC+a0y2rDaf7jkJoZ9gWJe2zI+vraD6fiwCgxvHo',
+        '3IgULB9RqIqpLoMgXfcjC+cD/1jeJlKRm+n71ryYwT/ECKsspFz7S36z6q3XyS8Q',
+        'QfrsUz2p1fbFicvJwIOJ8B20J/N2/nit4P0gBUTUxv3QEa7XCM/56/xrGkyBzscW',
+        'AzBoy/AK9K7GN6z13RozuAS60F1xO7MQc6Yi2VU3eASDQEKiyL/Ubf/s/rkZ+sGj',
+        'yJizBACtwCbQzA+z9XBZNUat5NPgcZz5Qeh1nwF9Nxnr6pyBv7tkrLh/3gxRGHqG',
+        '063dMbUk8pmUcJzBUyRsNiIPDoEUsLjY5zmZZmp/waAhpREsnK29WLCbqLdpUors',
+        'c1JJBsObkA1IM8TZY8YUmvsMEvBLCCanuKpclZZXqeRAeOHJ0v4DZQJHTlUBtBZU',
+        'ZXN0MiA8dGVzdDJAdGVzdC5jb20+iGIEExECACIFAlERnrMCGwMGCwkIBwMCBhUI',
+        'AgkKCwQWAgMBAh4BAheAAAoJEBEnlAPLFp74xc0AoLNZINHe0ytOsNtMCuLvc3Vd',
+        'vePUAJ9KX3L5IBqHarsa+aJHX7r796SokZ0BWARREZ6zEAQA2WkxmNbfeMzGUocN',
+        '3JEVe0o6rxGt5eGrTSmWisduDP3MURabhUXnf4T8oaeYcbJjkLLxMrJmNq55ln1e',
+        '4bSG5mDkh/ryKsV81m3F0DbqO/z/891nRSP5fondFVral4wsMOzBNgs4vVk7V/F2',
+        '0MPjR90CIhnVDKPAQbQA+3PjUR8AAwUEALn922AEE+0d7xSMMFpR7ic3Me5QEGnp',
+        'cT4ft6oc0UK5kAnvKoksZUc0hpBHjX1w3LTz847/5hRDuuDvwvGMWK8IfsjOF9T7',
+        'rK8QtJuBEyJxjoScA/YZP5vX4y0U1reUEa0EdwmVrnZzatMAe2FhlaR9PlHkOcm5',
+        'DZwkcExL0dbI/gMDArxZ+5N7kH4zYLtr9glJS/pJ7F0YJqJpNwCbqD8+8DqHD8Uv',
+        'MgQ/rtBxBJJOaF+1AjCd123hLgzIkkfdTh8loV9hDXMKeJgmiEkEGBECAAkFAlER',
+        'nrMCGwwACgkQESeUA8sWnvhBswCfdXjznvHCc73/6/MhWcv3dbeTT/wAoLyiZg8+',
+        'iY3UT9QkV9d0sMgyLkug',
+        '=GQsY',
+        '-----END PGP PRIVATE KEY BLOCK-----'
+      ].join("\n")).keys[0];
     var pub_key = openpgp.key.readArmored(pub_key_arm1).keys[0];
     var msg = openpgp.message.readArmored(msg_arm1);
 
     priv_key_gnupg_ext.subKeys[0].subKey.decrypt("abcd");
     msg = msg.decrypt(priv_key_gnupg_ext);
     var verified = msg.verify([pub_key]);
-    return new unit.result("Testing GnuPG stripped-key extensions",
-            verified[0].valid);
-
-  }, function() {
+    expect(verified).to.exist;
+    expect(verified).to.have.length(1);
+    expect(verified[0].valid).to.be.true;
+    done();
+  });
 
+  it('Verify V4 signature. Hash: SHA1. PK: RSA. Signature Type: 0x00 (binary document)', function(done) {
     var signedArmor = 
-       ['-----BEGIN PGP MESSAGE-----',
+      [ '-----BEGIN PGP MESSAGE-----',
         'Version: GnuPG v2.0.19 (GNU/Linux)',
         '',
         'owGbwMvMwMT4oOW7S46CznTGNeZJLCWpFSVBU3ZGF2fkF5Uo5KYWFyemp3LlAUUV',
@@ -314,16 +324,21 @@ var pub_v3 =
         'cw6U57n3/Z4X0pEZ68C5/o/6NpPICD7fuEOz3936raZ6wXGzueY8pfPnVjY0ajAc',
         'PtJzvvqj+ubYaT1sK9wWhd9lL3/V+9Zuua9QjOWC22buchsCroh8fLoZAA==',
         '=VH8F',
-        '-----END PGP MESSAGE-----'].join('\n');
+        '-----END PGP MESSAGE-----'
+      ].join('\n');
 
     var sMsg = openpgp.message.readArmored(signedArmor);
     var pub_key = openpgp.key.readArmored(pub_key_arm2).keys[0];
     var verified = sMsg.verify([pub_key]);
-    return new unit.result("Verify V4 signature. Hash: SHA1. PK: RSA. Signature Type: 0x00 (binary document)", verified[0].valid);
-  }, function() {
+    expect(verified).to.exist;
+    expect(verified).to.have.length(1);
+    expect(verified[0].valid).to.be.true;
+    done();
+  });
 
+  it('Verify V3 signature. Hash: MD5. PK: RSA. Signature Type: 0x01 (text document)', function(done) {
     var signedArmor = 
-       ['-----BEGIN PGP MESSAGE-----',
+      [ '-----BEGIN PGP MESSAGE-----',
         'Version: GnuPG v2.0.19 (GNU/Linux)',
         '',
         'owGbwMvMyMj4oOW7S46CznTG09YlLCWpFSVBU47xFGfkF5Uo5KYWFyemp/Jy5QGF',
@@ -332,16 +347,21 @@ var pub_v3 =
         'aPJyvm9TTpobW/O+P1n2THLS4UCvWt12Oa2lJ04GLwk/bDF1u+8ZpfPCpsxLVzcs',
         'ZGtbq/f23XxV/jkL47hr3s3Ic4yoZTW4oZO27GYf37TPp9L3VboCAA==',
         '=pa6B',
-        '-----END PGP MESSAGE-----'].join('\n');
+        '-----END PGP MESSAGE-----'
+      ].join('\n');
 
     var sMsg = openpgp.message.readArmored(signedArmor);
     var pub_key = openpgp.key.readArmored(pub_key_arm2).keys[0];
     var verified = sMsg.verify([pub_key]);
-    return new unit.result("Verify V3 signature. Hash: MD5. PK: RSA. Signature Type: 0x01 (text document)", verified[0].valid);
-  }, function() {
+    expect(verified).to.exist;
+    expect(verified).to.have.length(1);
+    expect(verified[0].valid).to.be.true;
+    done();
+  });
 
+  it('Verify signature of signed and encrypted message from GPG2 with openpgp.decryptAndVerifyMessage', function(done) {
     var msg_armor = 
-       ['-----BEGIN PGP MESSAGE-----',
+      [ '-----BEGIN PGP MESSAGE-----',
         'Version: GnuPG v2.0.19 (GNU/Linux)',
         '',
         'hIwD4IT3RGwgLJcBBADEBdm+GEW7IV1K/Bykg0nB0WYO08ai7/8/+Y/O9xu6RiU0',
@@ -354,7 +374,8 @@ var pub_v3 =
         'ifxyV4zia9RvaCUY8vXGM+gQJ3NNXx2LkZA3kWUEyxFVL1Vl/XUQY0M6U+uccSk4',
         'eMXm6eyEWDcj0lBRckqKoKo1w/uan11jPuHsnRz6jO9DsuKEz79UDgI=',
         '=cFi7',
-        '-----END PGP MESSAGE-----'].join('\n');
+        '-----END PGP MESSAGE-----'
+      ].join('\n');
 
     var plaintext = 'short message\nnext line\n한국어/조선말';
     var esMsg = openpgp.message.readArmored(msg_armor);
@@ -365,27 +386,32 @@ var pub_v3 =
     privKey.decryptKeyPacket(keyids, 'hello world');
 
     var decrypted = openpgp.decryptAndVerifyMessage(privKey, [pubKey], esMsg);
-    var verified = decrypted.text == plaintext && decrypted.signatures[0].valid;
 
-    return new unit.result("Verify signature of signed and encrypted message from GPG2 with openpgp.decryptAndVerifyMessage", verified);
-  }, function() {
+    expect(decrypted).to.exist;
+    expect(decrypted.text).to.equal(plaintext);
+    expect(decrypted.signatures).to.have.length(1);
+    expect(decrypted.signatures[0].valid).to.be.true;
+    done();
+  });
 
+  it('Verify signature of signed and encrypted message from PGP 10.3.0 with openpgp.decryptAndVerifyMessage', function(done) {
     var msg_armor = 
-      ['-----BEGIN PGP MESSAGE-----',
-      'Version: Encryption Desktop 10.3.0 (Build 9307)',
-      'Charset: utf-8',
-      '',
-      'qANQR1DBjAPghPdEbCAslwED/2S4oNvCjO5TdLUMMUuVOQc8fi6c5XIBu7Y09fEX',
-      'Jm/UrkDHVgmPojLGBDF0CYENNZOVrNfpahY7A3r4HPzGucBzCO1uxuUIKjhtNAAM',
-      'mjD939ernjooOZrM6xDuRaX8adG0LSxpNaVJGxXd/EdlmKDJbYDI6aJ5INrUxzAR',
-      'DAqw0sBSAXgRWgiH6IIiAo5y5WFEDEN9sGStaEQT2wd32kX73M4iZuMt/GM2agiB',
-      'sWb7yLcNHiJ/3OnTfDg9+T543kFq9FlwFbwqygO/wm9e/kgMBq0ZsFOfV+GRtXep',
-      '3qNbJsmzGvdqiUHb/+hkdE191jaSVcO/zaMW4N0Vc1IwIEhZ8I9+9bKwusdVhHT5',
-      'MySnhIogv+0Ilag/aY+UiCt+Zcie69T7Eix48fC/VVW5w3INf1T2CMmDm5ZLZFRN',
-      'oyqzb9Vsgu1gS7SCb6qTbnbV9PlSyU4wJB6siX8hz/U0urokT5se3uYRjiV0KbkA',
-      'zl1/r/wCrmwX4Gl9VN9+33cQgYZAlJLsRw8N82GhbVweZS8qwv24GQ==',
-      '=nx90',
-      '-----END PGP MESSAGE-----'].join('\n');
+      [ '-----BEGIN PGP MESSAGE-----',
+        'Version: Encryption Desktop 10.3.0 (Build 9307)',
+        'Charset: utf-8',
+        '',
+        'qANQR1DBjAPghPdEbCAslwED/2S4oNvCjO5TdLUMMUuVOQc8fi6c5XIBu7Y09fEX',
+        'Jm/UrkDHVgmPojLGBDF0CYENNZOVrNfpahY7A3r4HPzGucBzCO1uxuUIKjhtNAAM',
+        'mjD939ernjooOZrM6xDuRaX8adG0LSxpNaVJGxXd/EdlmKDJbYDI6aJ5INrUxzAR',
+        'DAqw0sBSAXgRWgiH6IIiAo5y5WFEDEN9sGStaEQT2wd32kX73M4iZuMt/GM2agiB',
+        'sWb7yLcNHiJ/3OnTfDg9+T543kFq9FlwFbwqygO/wm9e/kgMBq0ZsFOfV+GRtXep',
+        '3qNbJsmzGvdqiUHb/+hkdE191jaSVcO/zaMW4N0Vc1IwIEhZ8I9+9bKwusdVhHT5',
+        'MySnhIogv+0Ilag/aY+UiCt+Zcie69T7Eix48fC/VVW5w3INf1T2CMmDm5ZLZFRN',
+        'oyqzb9Vsgu1gS7SCb6qTbnbV9PlSyU4wJB6siX8hz/U0urokT5se3uYRjiV0KbkA',
+        'zl1/r/wCrmwX4Gl9VN9+33cQgYZAlJLsRw8N82GhbVweZS8qwv24GQ==',
+        '=nx90',
+        '-----END PGP MESSAGE-----'
+      ].join('\n');
 
     var plaintext = 'short message\nnext line\n한국어/조선말\n\n';
     var esMsg = openpgp.message.readArmored(msg_armor);
@@ -396,28 +422,33 @@ var pub_v3 =
     privKey.decryptKeyPacket(keyids, 'hello world');
 
     var decrypted = openpgp.decryptAndVerifyMessage(privKey, [pubKey], esMsg);
-    var verified = decrypted.text == plaintext && decrypted.signatures[0].valid;
 
-    return new unit.result("Verify signature of signed and encrypted message from PGP 10.3.0 with openpgp.decryptAndVerifyMessage", verified);
-  }, function() {
+    expect(decrypted).to.exist;
+    expect(decrypted.text).to.equal(plaintext);
+    expect(decrypted.signatures).to.have.length(1);
+    expect(decrypted.signatures[0].valid).to.be.true;
+    done();
+  });
 
+  it('Verify signed message with two one pass signatures', function(done) {
     var msg_armor = 
-     ['-----BEGIN PGP MESSAGE-----',
-      'Version: GnuPG v2.0.19 (GNU/Linux)',
-      '',
-      'owGbwMvMwMF4+5Pyi4Jg3y8ME8DcBy3fXXIUdKYzrjFNYilJrSgJmsXDXJyRX1Si',
-      'kJtaXJyYnsqVBxRVyMnMS+V6O3XOq61r30zbov9m4YY3LQteL5/QMYeFgZGDgY2V',
-      'CaSRgYtTAGZiYxYLwySbQk07ptZel6gmjrKyBWsyWdkOG3oscLBdIpXXfDdb6fNv',
-      '8ULN5L1ed+xNo79P2dBotWud6vn7e9dtLJ7o12PunnvEz8gyyvP4/As/los0xsnZ',
-      'H+8ublrhvGtLxJUZuUKZO6QdHq2Nepuw8OrfiMXPBDQXXpV2q11Ze+rD3lndgv/C',
-      'bJQNOhll0J0H839jFvt/16m20h/ZmDoWqJywapnypjdIjcXr+7rJFess40yenV7Q',
-      '2LSu/EX6Aq29x+dv+GPUMfuhTNE3viWWUR4PD6T7XfmdViUwmSf8fkRNUn/t3a2n',
-      'cq46Xr36seCor/OLp0atSZwHrjx2SU5zPLheZn+zw/0d1/YZnD7AEeP9s/Cuycyv',
-      'CZ5HZNKufvB8fsh+dfdSXW0GfqkPfxk36Vw8ufpjaoZDyt2nxxg/6D4KS3UvZzv3',
-      'axdLZ9yd0OJNZv4P501If24W4vTGz6nI7Ser8Yd2PiOvE5MWMT0wLZQ+zPX1sv0/',
-      's8PvkyWmVM0O0fB/ZSHovHNNPffDg/rWhzOmXQ9/7vTn477F+aWm5sYzJ75/BQA=',
-      '=+L0S',
-      '-----END PGP MESSAGE-----'].join('\n');
+      [ '-----BEGIN PGP MESSAGE-----',
+        'Version: GnuPG v2.0.19 (GNU/Linux)',
+        '',
+        'owGbwMvMwMF4+5Pyi4Jg3y8ME8DcBy3fXXIUdKYzrjFNYilJrSgJmsXDXJyRX1Si',
+        'kJtaXJyYnsqVBxRVyMnMS+V6O3XOq61r30zbov9m4YY3LQteL5/QMYeFgZGDgY2V',
+        'CaSRgYtTAGZiYxYLwySbQk07ptZel6gmjrKyBWsyWdkOG3oscLBdIpXXfDdb6fNv',
+        '8ULN5L1ed+xNo79P2dBotWud6vn7e9dtLJ7o12PunnvEz8gyyvP4/As/los0xsnZ',
+        'H+8ublrhvGtLxJUZuUKZO6QdHq2Nepuw8OrfiMXPBDQXXpV2q11Ze+rD3lndgv/C',
+        'bJQNOhll0J0H839jFvt/16m20h/ZmDoWqJywapnypjdIjcXr+7rJFess40yenV7Q',
+        '2LSu/EX6Aq29x+dv+GPUMfuhTNE3viWWUR4PD6T7XfmdViUwmSf8fkRNUn/t3a2n',
+        'cq46Xr36seCor/OLp0atSZwHrjx2SU5zPLheZn+zw/0d1/YZnD7AEeP9s/Cuycyv',
+        'CZ5HZNKufvB8fsh+dfdSXW0GfqkPfxk36Vw8ufpjaoZDyt2nxxg/6D4KS3UvZzv3',
+        'axdLZ9yd0OJNZv4P501If24W4vTGz6nI7Ser8Yd2PiOvE5MWMT0wLZQ+zPX1sv0/',
+        's8PvkyWmVM0O0fB/ZSHovHNNPffDg/rWhzOmXQ9/7vTn477F+aWm5sYzJ75/BQA=',
+        '=+L0S',
+        '-----END PGP MESSAGE-----'
+      ].join('\n');
 
     var plaintext = 'short message\nnext line\n한국어/조선말';
     var sMsg = openpgp.message.readArmored(msg_armor);
@@ -426,39 +457,44 @@ var pub_v3 =
 
     var keyids = sMsg.getSigningKeyIds();
 
-    var verified = pubKey2.getPublicKeyPacket(keyids) !== null && pubKey3.getPublicKeyPacket(keyids) !== null;
+    expect(pubKey2.getPublicKeyPacket(keyids)).to.exist;
+    expect(pubKey3.getPublicKeyPacket(keyids)).to.exist;
 
-    verified = verified && sMsg.getText() == plaintext;
+    expect(sMsg.getText()).to.equal(plaintext);
 
     var verifiedSig = sMsg.verify([pubKey2, pubKey3]);
-    
-    verified = verified && verifiedSig[0].valid && verifiedSig[1].valid;
 
-    return new unit.result("Verify signed message with two one pass signatures", verified);
-  }, function() {
+    expect(verifiedSig).to.exist;
+    expect(verifiedSig).to.have.length(2);
+    expect(verifiedSig[0].valid).to.be.true;
+    expect(verifiedSig[1].valid).to.be.true;
+    done();
+  });
 
+  it('Verify cleartext signed message with two signatures with openpgp.verifyClearSignedMessage', function(done) {
     var msg_armor = 
-     ['-----BEGIN PGP SIGNED MESSAGE-----',
-      'Hash: SHA256',
-      '',
-      'short message',
-      'next line',
-      '한국어/조선말',
-      '-----BEGIN PGP SIGNATURE-----',
-      'Version: GnuPG v2.0.19 (GNU/Linux)',
-      '',
-      'iJwEAQEIAAYFAlKcju8ACgkQ4IT3RGwgLJci6gP/dCmIraUa6AGpJxzGfK+jYpjl',
-      'G0KunFyGmyPxeJVnPi2bBp3EPIbiayQ71CcDe9DKpF046tora07AA9eo+/YbvJ9P',
-      'PWeScw3oj/ejsmKQoDBGzyDMFUphevnhgc5lENjovJqmiu6FKjNmADTxcZ/qFTOq',
-      '44EWTgdW3IqXFkNpKjeJARwEAQEIAAYFAlKcju8ACgkQ2/Ij6HBTTfQi6gf9HxhE',
-      'ycLDhQ8iyC090TaYwsDytScU2vOMiI5rJCy2tfDV0pfn+UekYGMnKxZTpwtmno1j',
-      'mVOlieENszz5IcehS5TYwk4lmRFjoba+Z8qwPEYhYxP29GMbmRIsH811sQHFTigo',
-      'LI2t4pSSSUpAiXd9y6KtvkWcGGn8IfkNHCEHPh1ov28QvH0+ByIiKYK5N6ZB8hEo',
-      '0uMYhKQPVJdPCvMkAxQCRPw84EvmxuJ0HMCeSB9tHQXpz5un2m8D9yiGpBQPnqlW',
-      'vCCq7fgaUz8ksxvQ9bSwv0iIIbbBdTP7Z8y2c1Oof6NDl7irH+QCeNT7IIGs8Smn',
-      'BEzv/FqkQAhjy3Krxg==',
-      '=3Pkl',
-      '-----END PGP SIGNATURE-----'].join('\n');
+      [ '-----BEGIN PGP SIGNED MESSAGE-----',
+        'Hash: SHA256',
+        '',
+        'short message',
+        'next line',
+        '한국어/조선말',
+        '-----BEGIN PGP SIGNATURE-----',
+        'Version: GnuPG v2.0.19 (GNU/Linux)',
+        '',
+        'iJwEAQEIAAYFAlKcju8ACgkQ4IT3RGwgLJci6gP/dCmIraUa6AGpJxzGfK+jYpjl',
+        'G0KunFyGmyPxeJVnPi2bBp3EPIbiayQ71CcDe9DKpF046tora07AA9eo+/YbvJ9P',
+        'PWeScw3oj/ejsmKQoDBGzyDMFUphevnhgc5lENjovJqmiu6FKjNmADTxcZ/qFTOq',
+        '44EWTgdW3IqXFkNpKjeJARwEAQEIAAYFAlKcju8ACgkQ2/Ij6HBTTfQi6gf9HxhE',
+        'ycLDhQ8iyC090TaYwsDytScU2vOMiI5rJCy2tfDV0pfn+UekYGMnKxZTpwtmno1j',
+        'mVOlieENszz5IcehS5TYwk4lmRFjoba+Z8qwPEYhYxP29GMbmRIsH811sQHFTigo',
+        'LI2t4pSSSUpAiXd9y6KtvkWcGGn8IfkNHCEHPh1ov28QvH0+ByIiKYK5N6ZB8hEo',
+        '0uMYhKQPVJdPCvMkAxQCRPw84EvmxuJ0HMCeSB9tHQXpz5un2m8D9yiGpBQPnqlW',
+        'vCCq7fgaUz8ksxvQ9bSwv0iIIbbBdTP7Z8y2c1Oof6NDl7irH+QCeNT7IIGs8Smn',
+        'BEzv/FqkQAhjy3Krxg==',
+        '=3Pkl',
+        '-----END PGP SIGNATURE-----'
+      ].join('\n');
 
     var plaintext = 'short message\nnext line\n한국어/조선말';
     var csMsg = openpgp.cleartext.readArmored(msg_armor);
@@ -467,17 +503,20 @@ var pub_v3 =
 
     var keyids = csMsg.getSigningKeyIds();
 
-    var verified = pubKey2.getPublicKeyPacket(keyids) !== null && pubKey3.getPublicKeyPacket(keyids) !== null;
+    expect(pubKey2.getPublicKeyPacket(keyids)).to.exist;
+    expect(pubKey3.getPublicKeyPacket(keyids)).to.exist;
 
     var cleartextSig = openpgp.verifyClearSignedMessage([pubKey2, pubKey3], csMsg);
 
-    verified = verified && cleartextSig.text == plaintext;
-
-    verified = verified && cleartextSig.signatures[0].valid && cleartextSig.signatures[1].valid;
-
-    return new unit.result("Verify cleartext signed message with two signatures with openpgp.verifyClearSignedMessage", verified);
-  }, function() {
+    expect(cleartextSig).to.exist;
+    expect(cleartextSig.text).to.equal(plaintext);
+    expect(cleartextSig.signatures).to.have.length(2);
+    expect(cleartextSig.signatures[0].valid).to.be.true;
+    expect(cleartextSig.signatures[1].valid).to.be.true;
+    done();
+  });
 
+  it('Sign text with openpgp.signClearMessage and verify with openpgp.verifyClearSignedMessage leads to same cleartext and valid signatures', function(done) {
     var plaintext = 'short message\nnext line\n한국어/조선말';
     var pubKey = openpgp.key.readArmored(pub_key_arm2).keys[0];
     var privKey = openpgp.key.readArmored(priv_key_arm2).keys[0];
@@ -489,48 +528,46 @@ var pub_v3 =
     
     var cleartextSig = openpgp.verifyClearSignedMessage([pubKey], csMsg);
 
-    var verified = cleartextSig.text == plaintext.replace(/\r/g,'');
-
-    verified = verified && cleartextSig.signatures[0].valid;
-
-    return new unit.result("Sign text with openpgp.signClearMessage and verify with openpgp.verifyClearSignedMessage leads to same cleartext and valid signatures", verified);
-  }, function() {
+    expect(cleartextSig).to.exist;
+    expect(cleartextSig.text).to.equal(plaintext.replace(/\r/g,''));
+    expect(cleartextSig.signatures).to.have.length(1);
+    expect(cleartextSig.signatures[0].valid).to.be.true;
+    done();
+  });
 
+  it('Verify primary key revocation signature', function(done) {
     var pubKey = openpgp.key.readArmored(pub_revoked).keys[0];
 
     var verified = pubKey.revocationSignature.verify(pubKey.primaryKey, {key: pubKey.primaryKey});
 
-    return new unit.result("Verify primary key revocation signature", verified);
-  }, function() {
+    expect(verified).to.be.true;
+    done();
+  });
 
+  it.skip('Verify subkey revocation signature', function(done) {
     var pubKey = openpgp.key.readArmored(pub_revoked).keys[0];
 
     var verified = pubKey.subKeys[0].revocationSignature.verify(pubKey.primaryKey, {key: pubKey.subKeys[0].subKey});
 
-    return new unit.result("Verify subkey revocation signature", verified);
-  }, function() {
+    expect(verified).to.be.true;
+    done();
+  });
 
+  it('Verify key expiration date', function(done) {
     var pubKey = openpgp.key.readArmored(pub_revoked).keys[0];
 
-    var verified = !pubKey.users[0].selfCertifications[0].keyNeverExpires && 
-                    pubKey.users[0].selfCertifications[0].keyExpirationTime == 5*365*24*60*60;
-
-    return new unit.result("Verify key expiration date", verified);
-  }, function() {
+    expect(pubKey).to.exist;
+    expect(pubKey.users[0].selfCertifications[0].keyNeverExpires).to.be.false;
+    expect(pubKey.users[0].selfCertifications[0].keyExpirationTime).to.equal(5*365*24*60*60);
+    done();
+  });
 
+  it('Verify V3 certification signature', function(done) {
     var pubKey = openpgp.key.readArmored(pub_v3).keys[0];
 
     var verified = pubKey.users[0].selfCertifications[0].verify(pubKey.primaryKey, {key: pubKey.primaryKey, userid: pubKey.users[0].userId});
 
-    return new unit.result("Verify V3 certification signature", verified);
-  }];
-
-  var results = [];
-
-  for(var i in tests) {
-    results.push(tests[i]());
-  }  
-  
-  return results;
-
+    expect(verified).to.be.true;
+    done();
+  });
 });
diff --git a/test/index.html b/test/index.html
deleted file mode 100644
index 1fedc06a..00000000
--- a/test/index.html
+++ /dev/null
@@ -1,121 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<meta charset="utf-8">
-
-<!-- unit test -->
-<title>OpenPGP.js testpage</title>
-
-<style>
-* {
-	font-family: monospace;
-}
-
-#debug, #testoutput {
-	border: 1px dotted #aaa;
-	background-color: #eee;
-	margin: 5px;
-	padding: 5px;
-}
-
-.successful {
-	background-color: #afa;
-}
-.failed {
-	background-color: #faa;
-}
-
-#unittests {
-	width: 98%;
-	max-width: 99%;
-	table-layout: fixed;
-	word-wrap: break-word;
-	white-space: pre;
-}
-
-
-#unittests tbody tr th {
-	background-color: #eee;
-	border: 1px dotted #aaa;
-}
-
-#unittests tbody tr td {
-	padding: 2px;
-	border: 1px solid #ccc;
-}
-
-.unittesttitle {
-	font-weight: bold;
-	vertical-align: top;
-}
-
-.unittestrow {
-	border-top: 1px solid #aaa;
-}
-
-
-</style>
-<script src="../resources/openpgp.js"></script>
-<script src="../resources/keyring.js"></script>
-<script src="lib/test-bundle.js"></script>
-<script type="text/javascript">
-
-var test = require('unittests');
-
-function unit_tests() {
-	var table = document.getElementById('unittests');
-
-	var single_test = function() {
-		var result = test.run();
-
-		var html = '<tr class="unittestrow"><td rowspan="' +
-			result.tests.length + '" class="unittesttitle">' + result.title + '</td>';
-
-
-		for (var i in result.tests) {
-			html += (i != 0 ?
-					'<tr>' : '')
-				+ '<td>' + result.tests[i].description
-				+ '</td><td ' + (result.tests[i].result ? 
-					'class="successful">PASSED</td>' : 
-					'class="failed">FAILED</td>') 
-				+ '</tr>';
-		}
-
-		table.innerHTML += html;
-
-		if(test.tests.length > 0) {
-			setTimeout(single_test, 100);
-		}
-	}
-
-	single_test();
-}
-
-</script>
-</head>
-<body>
-	<a href="index.html">Unit Tests</a> | 
-	<a href="parser.html">Parser</a> | 
-	<a href="encryption.html">Encryption / Decryption</a> | 
-	<a href="coverage.html">Coverage</a>
-
-<h1>Unit tests</h1>
-
-<table id="unittests">
-	<colgroup>
-		<col style="width: 20%;">
-		<col>
-		<col style="width: 5%;">
-	</colgroup>
-	<tr><th>Test</th><th>Description</th><th>Result</th></tr>
-</table>
-
-<br>
-<button type="submit" onmousedown="unit_tests();">Run unit tests</button>
-
-<!-- src/util/util.js print_debug() writes to  -->
-<h2>Messages</h2>
-<div id="debug"></div>
-</body>
-</html>
diff --git a/test/test-all.js b/test/test-all.js
deleted file mode 100644
index 7b22068a..00000000
--- a/test/test-all.js
+++ /dev/null
@@ -1,20 +0,0 @@
-
-module.exports = require('./unit.js');
-
-require('./crypto/hash/sha.js');
-require('./crypto/hash/md5.js');
-require('./crypto/hash/ripemd.js');
-
-require('./crypto/cipher/aes.js');
-require('./crypto/cipher/blowfish.js');
-require('./crypto/cipher/cast5.js');
-require('./crypto/cipher/des.js');
-require('./crypto/cipher/twofish.js');
-
-require('./crypto/crypto.js');
-
-require('./general/basic.js');
-require('./general/key.js');
-require('./general/keyring.js');
-require('./general/packet.js');
-require('./general/signature.js');
diff --git a/test/test.js b/test/test.js
deleted file mode 100644
index 9c937381..00000000
--- a/test/test.js
+++ /dev/null
@@ -1,6 +0,0 @@
-
-module.exports = require('./unit.js');
-
-require('./test-all.js');
-
-module.exports.run_all();
diff --git a/test/unit.js b/test/unit.js
deleted file mode 100644
index 081a3fc5..00000000
--- a/test/unit.js
+++ /dev/null
@@ -1,48 +0,0 @@
-
-module.exports = {
-	tests: [],
-	register: function(str_title, func_runtest) {
-		this.tests.push({ title: str_title, run: func_runtest });
-	},
-	
-	run: function() {
-		var test = this.tests.shift();
-
-		var result = {
-			title: test.title
-		};
-
-
-		result.tests = test.run();
-
-		return result;
-	},
-
-	run_all: function() {
-		var passed = true;
-
-		while(this.tests.length > 0) {
-			var result = this.run();
-
-			console.log('Test: ' + result.title);
-
-			for(var i in result.tests) {
-
-				var res = result.tests[i].result ?
-					'SUCCESS' : 'FAILED';
-
-				console.log(result.tests[i].description + ' ' + res);
-
-				passed = passed && result.tests[i].result;
-			}				
-		}
-
-		if(!passed) process.exit(1);
-	},
-		
-	result: function(str_description, boolean_result) {
-		this.description = str_description;
-		this.result = boolean_result;
-	}
-}
-
diff --git a/test/ci-tests.html b/test/unittests.html
similarity index 77%
rename from test/ci-tests.html
rename to test/unittests.html
index 23ea9f7d..cd8d94ed 100644
--- a/test/ci-tests.html
+++ b/test/unittests.html
@@ -2,7 +2,7 @@
 <html>
   <head>
     <meta charset="utf-8">
-    <title>OpenPGPJS Continuous Integration Tests</title>
+    <title>OpenPGPJS Unit Tests</title>
     <link rel="stylesheet" href="lib/mocha.css" />
 
   </head>
@@ -13,14 +13,13 @@
     <script src="../resources/openpgp.js"></script>
     <script src="../resources/keyring.js"></script>
     <script src="lib/chai.js"></script>
-    <script src="lib/sinon.js"></script>
     <script src="lib/mocha.js"></script>
     <script>
         mocha.setup('bdd');
     </script>
-    <script src="lib/ci-tests-bundle.js"></script>
+    <script src="lib/unittests-bundle.js"></script>
     <script>
-        require('ci-tests');
+        require('unittests');
         if (window.mochaPhantomJS) {
           mochaPhantomJS.run();
         } else {
diff --git a/test/unittests.js b/test/unittests.js
new file mode 100644
index 00000000..4b66c6de
--- /dev/null
+++ b/test/unittests.js
@@ -0,0 +1,4 @@
+describe('Unit Tests', function () {
+  require('./general');
+  require('./crypto');
+});