@depup/fakeredis 2.0.0-depup.0

package/test.js

@@ -0,0 +1,1025 @@
+"use strict";
+
+var fake        = require("./main"),
+
+    OK          = "OK",
+    PONG        = "PONG",
+
+    BAD_ARGS    = "wrong number of arguments",
+    BAD_TYPE    = "Operation against a key holding the wrong kind of value",
+    BAD_INT     = "value is not an integer or out of range",
+    BAD_FLOAT   = "value is not a valid float",
+    BAD_SYNTAX  = "syntax error",
+    BAD_INDEX   = "index out of range",
+    BAD_DB      = "invalid DB index",
+    BAD_SETEX   = "invalid expire time in SETEX",
+    BAD_SORT    = "One or more scores can't be converted into double";
+
+
+// So lets go.
+
+process.stdout.write('testing fakeredis ...\n\n');
+
+
+// Keys and strings.
+
+(function () {
+    var redis  = fake.createClient("stuff"),
+        redis2 = fake.createClient("stuff");
+
+    redis.AUTH("password", test("AUTH", null, "OK"));
+
+    redis.SET("hello", "world", test("SET", null, OK));
+    redis.GET("hello", test("SET / GET", null, "world"));
+
+    redis.SET("what", "who");
+    redis.GETSET("what", "where", test("GETSET", null, "who"));
+    redis.MGET("hello", "nonex", "what", test("MGET", null, [ "world", null, "where" ]));
+    redis.DEL("hello", "nonex", "what", test("DEL count", null, 2));
+    redis.GET("hello", test("SET / DEL / GET", null, null));
+
+    redis.SET("hello", "vmvl");
+    redis.GETBIT("hello", 7, test("GETBIT", null, 0));
+    redis.GETBIT("hello", 14, test("GETBIT", null, 0));
+    redis.GETBIT("hello", 21, test("GETBIT", null, 1));
+    redis.SETBIT("hello", 7, 1, test("SETBIT", null, 0));
+    redis.SETBIT("hello", 14, 1, test("SETBIT", null, 0));
+    redis.SETBIT("hello", 21, 0, test("GETBIT", null, 1));
+    redis.GETBIT("hello", 7, test("GETBIT", null, 1));
+    redis.GETBIT("hello", 14, test("GETBIT", null, 1));
+    redis.GETBIT("hello", 21, test("GETBIT", null, 0));
+
+    redis.STRLEN("hello", test("STRLEN", null, 4));
+    redis.SETBIT("hello", 33, 1);
+    redis.SETBIT("hello", 34, 1);
+    redis.SETBIT("hello", 37, 1);
+    redis.STRLEN("hello", test("SETBIT refits buffer", null, 5));
+    redis.GET("hello", test("SETBIT char from bits", null, "world"));
+
+    redis.SETRANGE("hi", 0, "Hello World", test("SETRANGE upsert", null, 11));
+    redis.GET("hi", test("SETRANGE", null, "Hello World"));
+    redis.GETRANGE("hi", -5, -1, test("GETRANGE negneg", null, "World"));
+    redis.SETRANGE("hi", 6, "Redis", test("SETRANGE offset", null, 11));
+    redis.GET("hi", test("SETRANGE", null, "Hello Redis"));
+
+    redis.EXPIRE("hello", 15);
+    redis.DECR("hello", test("SET / DECR", BAD_INT, null));
+    redis.TTL("hello", test("EXPIRE / TTL", null, 15));
+    redis.PERSIST("hello");
+    redis.send_command("pttl", [ "hello" ], test("PERSIST / PTTL", null, -1));
+    redis.send_command("pexpireat", [ "hello", Date.now () + 250 ]);
+    redis.MSETNX("somekey", "someval", "hello", "non-world", test("MSETNX is safe", null, 0));
+    redis.GET("hello", test("GET expiring", null, "world"));
+    redis.APPEND("hello", " of mine", test("APPEND upset", null,("world of mine" ).length));
+    redis.INCR("hello", test("INCR upset", BAD_INT, null));
+    redis.DECRBY("nonx", 5, test("DECR nonexist", null, -5));
+
+    redis.SETEX("nonx", 0, "hello", test("SETEX fail", BAD_SETEX, null));
+    redis.SETNX("nonx", "dont!", test("SETNX fail", null, 0));
+    redis.SET("nonx", "hello", "EX", 0, test("SET with EX fail", BAD_INT, null));
+    redis.SET("nonx", "hello", "PX", 0, test("SET with PX fail", BAD_INT, null));
+    redis.SET("nonx", "dont!", "NX", test("SET with NX fail", null, null));
+    redis.MSET("nonx", "do", test("MSET", null, OK));
+    redis.send_command("psetex", [ "nonx", 1000, "disappear" ], test("PSETEX", null, OK));
+    redis.GET("nonx", test("PSETEX set", null, "disappear"));
+    redis.TTL("nonx", test("PSETEX expire", null, 1));
+    redis.GETSET("nonx", "stay");
+    redis.TTL("nonx", test("GETSET persists", null, -1));
+    redis.DEL("nonx");
+
+    redis.SET("flop", "dont!", "XX", test("SET with XX fail", null, null));
+
+    redis.BITCOUNT(test("BITCOUNT missing key parameter", BAD_ARGS, null));
+    redis.BITCOUNT("absentKey", test("BITCOUNT absent key", null, 0));
+    redis.SET("bitCountKey", "foobar");
+    redis.BITCOUNT("bitCountKey", test("BITCOUNT of valid key", null, 26));
+    redis.BITCOUNT("bitCountKey", 0, -1, test("BITCOUNT using explicit range", null, 26));
+    redis.BITCOUNT("bitCountKey", 0, 0, test("BITCOUNT of first character", null, 4));
+    redis.BITCOUNT("bitCountKey", -1, -1, test("BITCOUNT of last character", null, 4));
+    redis.BITCOUNT("bitCountKey", 0, 3, test("BITCOUNT of substring", null, 19));
+
+    // Sets.
+
+    redis.SADD("hello", "kuku", "buku", test("SADD typerror", BAD_TYPE, null));
+    redis.SADD("myset", [ "ala", "bala" ], test("SADD multiarg", null, 2));
+    redis.SADD("myset", "niza", "bala", test("SADD delta", null, 1));
+    redis.SCARD("hello", test("SCARD typerror", BAD_TYPE, null));
+    redis.SCARD("myset", test("SCARD", null, 3));
+    redis.SADD("set2", 1, 2, 3, 4, 5);
+    redis.SADD("set3", "xxx", "zzz", "yyy");
+    redis.SUNIONSTORE("output", [ "nonex1", "myset", "set2", "set3", "nonex2" ], test("SUNIONSTORE", null, 11));
+    redis.SISMEMBER("output", "xxx", test("SISMEMBER union 3 sets", null, 1));
+    redis.SINTER("myset", "output", test("SINTER", null, [ "ala", "bala", "niza" ]));
+    redis.SINTER("myset", "outputs", test("SINTER nonex empty 1", null, []));
+    redis.SINTER("outputs", "myset", test("SINTER nonex empty 2", null, []));
+    redis.SADD("set3", "ala", 3, 4, "kukukuku");
+    redis.SDIFFSTORE("output", "output", "set3", test("SDIFFSTORE", null, 5));
+    redis.SMEMBERS("output", test("SMEMBERS", null, [ "1", "2", "5", "bala", "niza" ]));
+    redis.SISMEMBER("output", "bala", test("SISMEMBER yes", null, 1));
+    redis.SISMEMBER("output", "what", test("SISMEMBER no", null, 0));
+    redis.SISMEMBER("nonex", "what", test("SISMEMBER nonex", null, 0));
+    redis.SISMEMBER("hello", "what", test("SISMEMBER bad", BAD_TYPE, null));
+
+    redis.SADD("otherset", "whatever");
+    redis.SINTERSTORE("nothing", "otherset", "output", test("SINTERSTORE empty out", null, 0));
+    redis.TYPE("nothing", test("SINTERSTORE empty out / TYPE", null, "none"));
+
+    redis.DEL("set3");
+    redis.SPOP("set3", test("SPOP nothing", null, null));
+    redis.SINTER("output", function (err, members) {
+        redis.SPOP("output", function (err, member) {
+            member = member ? member.toString() : "!?@#?!@?#";
+
+            var expected = members
+                .map(function (entry) { return entry.toString(); })
+                .filter(function (entry) { return entry !== member; });
+
+            redis2.SDIFF("output", test("SPOP(client 2 )", null, expected));
+        });
+    });
+
+
+    // Sorted sets.
+
+    redis.ZADD("myzset", [ 1, "one", 2, "two", 3, "three" ], test("ZADD", null, 3));
+    redis.ZCARD("myzset", test("ZCARD", null, 3));
+    redis.ZCARD("whatwhat", test("ZCARD nonex", null, 0));
+    redis.ZCARD("myset", test("ZCARD bad", BAD_TYPE, null));
+    redis.ZRANGE("myzset", 1, -1, test("ZRANGE pos neg", null, [ "two", "three" ]));
+    redis.ZRANGE("myzset", 0, 1, test("ZRANGE pos pos", null, [ "one", "two" ]));
+    redis.ZRANGE("myzset", 1, -2, test("ZRANGE pos=neg", null, [ "two" ]));
+    redis.ZRANGE("myzset", -1, 1, test("ZRANGE null", null, []));
+    redis.ZRANGE("myzset", "-inf", "+inf", test("ZRANGE int", BAD_INT, null));
+    redis.ZREVRANGEBYSCORE("myzset", "+inf", "-inf", test("ZREVRANGEBYSCORE all", null, [ "three", "two", "one" ]));
+    redis.ZREVRANGEBYSCORE("myzset", 2, 1, test("ZREVRANGEBYSCORE incl", null, [ "two", "one" ]));
+    redis.ZREVRANGEBYSCORE("myzset", 2, "(1", test("ZREVRANGEBYSCORE soso", null, [ "two" ]));
+    redis.ZREVRANGEBYSCORE("myzset", "(2", "(1", test("ZREVRANGEBYSCORE excl", null, []));
+    redis.ZADD("myzset", 1.5, "one.five");
+    redis.ZRANGEBYSCORE("myzset", "-inf", "+inf", "WITHSCORES", "LIMIT", 1, 2, test("ZREVRANGEBYSCORE limit", null, [ "one.five", "1.5", "two", "2" ]));
+
+    // Negative offset behaves differently here and in SORT
+
+    redis.ZRANGEBYSCORE("myzset", "-inf", "+inf", "WITHSCORES", "LIMIT", -1, 2, test("ZREVRANGEBYSCORE limit +negoffset", null, []));
+    redis.ZRANGEBYSCORE("myzset", "-inf", "+inf", "WITHSCORES", "LIMIT", 1, -11, test("ZREVRANGEBYSCORE limit +negcount", null, [ "one.five", "1.5", "two", "2", "three", "3" ]));
+
+    redis.ZCOUNT("myzset", "(1", 2, test("ZCOUNT", null, 2));
+    redis.SET("wrong", "indeed");
+    redis.ZREMRANGEBYRANK("wrong", 0, -1, test("ZREMRANGEBYRANK badkey", BAD_TYPE, null));
+    redis.ZREMRANGEBYSCORE("myzset", "(1", "2", test("ZREMRANGEBYSCORE", null, 2));
+    redis.ZRANGE("myzset", "0", "-1", test("ZREMRANGEBYSCORE / ZRANGE", null, [ "one", "three" ]));
+    redis.ZADD("myzset", 1.9, "goner1", 2.1, "goner2");
+    redis.ZREMRANGEBYRANK("myzset", 1, 2, test("ZREMRANGEBYRANK", null, 2));
+    redis.ZRANGE("myzset", "0", "-1", test("ZREMRANGEBYRANK / ZRANGE", null, [ "one", "three" ]));
+    redis.ZADD("myzset", "2", "one", test("ZADD not adding", null, 0));
+    redis.ZADD("myzset", "", "one", test("ZADD bad score", BAD_FLOAT, null));
+    redis.ZADD("myzset", "2", "two");
+    redis.ZINCRBY("myzset", 2, "one", test("ZINCRBY", null, 4));
+    redis.ZREVRANGE("myzset", 0, -1, "WITHSCORES", test("ZREVRANGE", null, [ "one", "4", "three", "3", "two", "2" ]));
+    redis.ZSCORE("myzset", "three", test("ZSCORE", null, 3));
+    redis.ZADD("myzset", 1.5, "one.five");
+    redis.ZRANK("myzset", "three", test("ZRANK", null, 2));
+    redis.ZREVRANK("myzset", "three", test("ZREVRANK", null, 1));
+
+    redis.ZADD("zset1", 1, "one", 2, "two");
+    redis.ZADD("zset2", 1, "one", 2, "two", 3, "three");
+    redis.ZINTERSTORE("out", 2, "zset1", "zset2", "weights", 2, 3, test("ZINTERSTORE no aggregate", null, 2));
+    redis.ZRANGE("out", 0, -1, "WITHSCORES", test("ZINTERSTORE / ZRANGE", null, [ "one", "5", "two", "10" ]));
+
+    redis.ZUNIONSTORE(
+        "out", /* 4, */ "nonex", "zset1", "zset2", "out", "weights", 10, 1, 2, 0.5, "aggregate", "max",
+        test("ZUNIONSTORE missing keycount", BAD_INT, null)
+    );
+    redis.ZUNIONSTORE(
+        "out", 4, "nonex", "zset1", "zset2", "out", "weights", 10, 1, 2, /* .5, */ "aggregate", "max",
+        test("ZUNIONSTORE bad weight count (less)", BAD_FLOAT, null)
+    );
+    redis.ZUNIONSTORE(
+        "out", 4, "nonex", "zset1", "zset2", "out", "weights", 10, 1, 2, 0.5, 10, "aggregate", "max",
+        test("ZUNIONSTORE bad weight count (more)", BAD_ARGS, null)
+    );
+    redis.ZUNIONSTORE(
+        "out", 4, "nonex", "zset1", "zset2", "out", "weights", 10, 1, 2, 0.5, "aggregate", /* "max", */
+        test("ZUNIONSTORE missing aggregate", BAD_ARGS, null)
+    );
+    redis.ZUNIONSTORE(
+        "out", 4, "nonex", "zset1", "zset2", "out", /* "weights", */ 10, 1, 2, 0.5, "aggregate", "max",
+        test("ZUNIONSTORE missing weight keyword", BAD_ARGS, null)
+    );
+
+    redis.ZUNIONSTORE(
+        "out2", 2, "zset1", "zset2",
+        test("ZUNIONSTORE naked", null, 3 )
+    );
+    redis.ZRANGE("out2", 0, -1, "WITHSCORES", test("ZUNIONSTORE naked / ZRANGE", null, [ "one", "2", "three", "3", "two", "4" ]));
+
+    redis.ZUNIONSTORE(
+        "out2", 2, "zset1", "zset2", "aggregate", "min",
+        test("ZUNIONSTORE with aggregate", null, 3 )
+    );
+    redis.ZRANGE("out2", 0, -1, "WITHSCORES", test("ZUNIONSTORE with aggregate / ZRANGE", null, [ "one", "1", "two", "2", "three", "3" ]));
+
+    redis.ZUNIONSTORE(
+        "out", 4, "nonex", "zset1", "zset2", "out", "weights", 10, 1, 2, 0.5, "aggregate", "max",
+        test("ZUNIONSTORE with weights + aggregate", null, 3 )
+    );
+    redis.ZRANGE("out", 0, -1, "WITHSCORES", test("ZUNIONSTORE / ZRANGE", null, [ "one", "2.5", "two", "5", "three", "6" ]));
+
+    redis.KEYS("*z?et*", test("KEYS with ? and *", null, [ "myzset", "zset1", "zset2" ]));
+    redis.KEYS("my[sz]*et", test("KEYS with [] and *", null, [ "myset", "myzset" ]));
+    redis.KEYS("my[sz]{2}et", test("REGEXP escaping", null, []));
+    redis.TYPE("myset", test("TYPE", null, "set"));
+
+    redis.EXPIRE("out", 60);
+    redis.RENAME("out", "outandabout", test("RENAME", null, OK));
+    redis.ZADD("outandabout", 0, "zero", test("ZADD zero", null, 1));
+    redis.TTL("outandabout", test("RENAME / ZADD / TTL", null, 60));
+    redis.EXISTS("out", test("EXISTS no", null, 0));
+    redis.EXISTS("outandabout", test("EXISTS yes", null, 1));
+
+    redis.ZADD("lexi", 1, "AAA", 1, "BBB", 1, "ZZZ", 1, "XXX", 1, "YYY", 2, "FFF");
+    redis.ZRANGE("lexi", 0, -1, test("lexicographic zset member sort", null, [ "AAA", "BBB", "XXX", "YYY", "ZZZ", "FFF" ]));
+    redis.ZREVRANGE("lexi", 0, -1, test("lexicographic zset member sort", null, [ "FFF", "ZZZ", "YYY", "XXX", "BBB", "AAA" ]));
+
+    redis.ZADD("otherzset", 100, "whatever");
+    redis.ZINTERSTORE("nothing", 2, "lexi", "otherzset", test("ZINTERSTORE empty out", null, 0));
+    redis.TYPE("nothing", test("ZINTERSTORE empty out / TYPE", null, "none"));
+
+    redis.SADD("newset", "v1", "v2");
+    redis.ZADD("newzset", 1, "v1", 2, "v2", 3, "v3");
+    redis.ZINTERSTORE("out", 2, "newzset", "newset");
+    redis.ZRANGE("out", 0, -1, test("ZINTERSTORE with sets", null, ["v1", "v2"]));
+    // switch set and zset key order
+    redis.ZINTERSTORE("out2", 2, "newset", "newzset");
+    redis.ZRANGE("out2", 0, -1, test("ZINTERSTORE with sets", null, ["v1", "v2"]));
+    redis.ZREVRANGE("out2", 0, -1, "withscores", test("ZINTERSTORE with sets withscores", null, ["v2", "3", "v1", "2"]));
+    redis.ZUNIONSTORE("out3", 2, "newset", "newzset");
+    redis.ZRANGE("out3", 0, -1, "withscores", test("ZUNIONSTORE with sets withscores", null, ["v1", "2", "v2", "3", "v3", "3"]));
+
+    // Hashes.
+
+    redis.HGETALL("nonex", test("HGETALL nonex", null, null));
+
+    redis.HMSET("h", { "f1" : "v1", "field-3" : "3" }, test("HMSET {} ok", null, OK));
+    redis.HMSET("h", "f2", "v2", "field-4", 4, test("HMSET ... ok", null, OK));
+
+    redis.HSETNX("h", "f1", "V1", test("HSETNX safe", null, 0));
+    redis.HSETNX("h", "F1", "V1", test("HSETNX", null, 1));
+    redis.HGETALL("h", test("HGETALL", null, { "F1": "V1", "f1": "v1", "f2": "v2", "field-3": "3", "field-4": "4" }));
+
+    redis.getKeyspace("*h", test("getKeyspace() with pattern", null, [ "h", "-1", "hash", [ "F1", "V1", "f1", "v1", "f2", "v2", "field-3", "3", "field-4", "4" ] ]));
+
+    redis.HKEYS("h", test("HKEYS", null, [ "F1", "f1", "f2", "field-3", "field-4" ]));
+    redis.send_command("HINCRBYFLOAT", [ "h", "f1", 3.5 ], test("HINCRBYFLOAT fail", BAD_FLOAT, null));
+    redis.HINCRBY("h", "field-3", 3, test("HINCRBYFLOAT success", null, 6));
+    redis.HVALS("h", test("HVALS", null, [ "4", "6", "V1", "v1", "v2" ]));
+    redis.HMGET("h", "F1", "f1", "f2", test("HMGET", null, [ "V1", "v1", "v2" ]));
+    redis.HGETALL("h", function (err, data) {
+        redis.multi()
+            .HGETALL("h", test("HGETALL multi/exec sugar", err, data))
+                .exec(test("HGETALL multi/exec replies sugar", err, [ data ]));
+
+        redis.HDEL("h", "field-3", "F1", "F2", test("HDEL", null, 2));
+        redis.TYPE("h", test("TYPE hash", null, "hash"));
+        redis.HDEL("h", "field-4", "f1", "f2");
+        redis.TYPE("h", test("TYPE none", null, "none"));
+    });
+
+    redis.HDEL('hnonex', 'moot', test("HDEL nonex", null, 0));
+    redis.HSET('w00t', 'field', 'value', function () {
+        redis.HDEL('w00t', 'moot', test("HDEL nonex field", null, 0));
+    });
+
+
+    // Lists, non-blocking.
+
+    redis.LPUSH("list", [ "one", "two", "three" ], test("LPUSH", null, 3));
+    redis.LPOP("list", test("RPOP", null, "three"));
+    redis.LRANGE("list", 0, -1, test("LRANGE all posneg", null, [ "two", "one" ]));
+    redis.LSET("list", 1, "what", test("LSET", null, OK));
+    redis.LSET("list", 4, "what", test("LSET out of range", BAD_INDEX, null));
+    redis.LTRIM("list", 1, -1, test("LTRIM posneg", null, OK));
+    redis.RPOPLPUSH("nonexl", "newlist", test("RPOPLPUSH nonex", null, null));
+    redis.TYPE("newlist", test("RPOPLPUSH nonex safe", null, "none"));
+    redis.RPOPLPUSH("list", "newlist", test("RPOPLPUSH", null, "what"));
+    redis.LPUSHX("nonex", "where", "why", test("LPUSHX nonex", null, 0));
+    redis.RPUSHX("newlist", "where", "why", test("RPUSHX", null, 3));
+    redis.RPUSH("list3", "one", "two", "three", test("RPUSH", null, 3));
+    redis.LTRIM("list3", -3, -1, test("LTRIM negneg", null, OK));
+    redis.LLEN("list3", test("LLEN", null, 3));
+    redis.LINDEX("list3", 2, test("LINDEX posyes", null, "three"));
+    redis.LINDEX("list3", -3, test("LINDEX negyes", null, "one"));
+    redis.LINDEX("list3", 3, test("LINDEX negno", null, null));
+    redis.LINDEX("list3", -4, test("LINDEX negno", null, null));
+    redis.LINDEX("nonex", 0, test("LINDEX badkey", null, null));
+    redis.LINDEX("hello", 0, test("LINDEX badkey", BAD_TYPE, null));
+    redis.LRANGE("list3", -3, 2, test("LRANGE all negpos", null, [ "one", "two", "three" ]));
+    redis.LRANGE("list3", -5, 0, test("LRANGE lo2lo", null, [ "one" ]));
+    redis.LRANGE("list3", 2, 10, test("LRANGE hi2hi", null, [ "three" ]));
+    redis.LPUSH("list3", "three", "what", "what");
+    redis.LREM("list3", 1, "one", test("LREM left", null, 1));
+    redis.LREM("list3", -1, "three", test("LREM right", null, 1));
+    redis.LREM("list3", -2, "what", test("LREM 2right", null, 2));
+
+    redis.getKeyspace("*list*", test("lists outcome", null, [ "list3", "-1", "list", [ "three", "two" ], "newlist", "-1", "list", [ "what", "where", "why" ] ]));
+
+    redis.LREM("lnonex", 1, "what", test("LREM nonex", null, 0));
+
+    redis.LPUSH("lremlist", "a", "b", "b", "a", "b", "b", test("LPUSH", null, 6));
+    redis.LREM("lremlist", 0, "a", test("LREM 0", null, 2));
+    redis.LLEN("lremlist", test("LLEN", null, 4));
+    redis.LREM("lremlist", 0, "b", test("LREM 0", null, 4));
+    redis.LLEN("lremlist", test("LLEN empty", null, 0));
+
+
+    // Blocking list commands !
+
+    redis.BLPOP("BL-a", "BL-b", "BL-c", 0, test("BLPOP", null, [ "BL-a", "AAA" ]));
+
+    redis2.LPUSH("BL-a", "AAA", test("LPUSH + BLPOP", null, 1));
+    redis2.BRPOP("BL-b", "BL-c", 0, test("BRPOP", null, [ "BL-b", "BB3" ]));
+
+    redis.RPUSH("BL-b", "BB1", "BB2", "BB3", test("RPUSH + BRPOP", null, 3));
+    redis.BLPOP("BL-a", "BL-c", 0, test("BLPOP", null, [ "BL-c", "CC1" ]));
+
+    redis2.RPUSH("BL-c", "CC1", "CC2", "CC3", test("RPUSH + BLPOP", null, 3));
+
+    redis.getKeyspace("BL-?", test("blocking lists outcome", null, [ "BL-b", "-1", "list", [ "BB1", "BB2" ], "BL-c", "-1", "list", [ "CC2", "CC3" ] ]));
+
+
+    // Misc stuff.
+
+    redis.ECHO("hello world!", test("ECHO", null, "hello world!"));
+    redis.PING(test("PING", null, "PONG"));
+
+    redis.SAVE(test("SAVE", null, "OK"));
+    redis.BGSAVE(test("BGSAVE", null, "OK"));
+    redis.BGREWRITEAOF(test("BGREWRITEAOF", null, "OK"));
+
+
+    // Expiry and flush.
+
+    setTimeout(
+        function () {
+            redis.GET("hello", test("GET expired", null, null));
+
+            // redis.pretty ();
+
+            redis.FLUSHDB ();
+            redis.GETSET("hello", "world", test("GETSET null", null, null));
+            redis.getKeyspace(test("getKeyspace() flushed, nopat", null, [ "hello", "-1", "string", "world" ]));
+        },
+        1000
+    );
+} ());
+
+
+// Transactions.
+
+(function () {
+    var multi,
+        redis  = fake.createClient("transactions-1"),
+        redis2 = fake.createClient("transactions-1");
+
+    redis.SET("abc", "dfg");
+    redis.SET("what", "who");
+    redis.WATCH("why", "what", "abc");
+    multi = redis.MULTI();
+    redis.GET("abc", function () {
+        redis2.SET("abc", "dfgdfg", function () {
+            multi.SET("abc", "dfggfd", test("SET discarded", null, null));
+            multi.exec ();
+
+            redis.GET("abc", test("invalidated transaction", null, "dfgdfg"));
+        });
+    });
+} ());
+
+(function () {
+    var multi,
+        redis  = fake.createClient("transactions-1"),
+        redis2 = fake.createClient("transactions-1");
+
+    redis.SET("abc", "dfg");
+    redis.SET("what", "who");
+    redis.WATCH("why", "what", "abc");
+    multi = redis.MULTI();
+    redis.GET("abc", function () {
+        redis2.SET("abc", "dfgdfg", function () {
+            multi.SET("abc", "dfggfd", test("SET discarded", null, null));
+            multi.exec ();
+
+            redis.GET("abc", test("invalidated transaction", null, "dfgdfg"));
+        });
+    });
+} ());
+
+(function () {
+    var multi,
+        redis  = fake.createClient("transactions-2"),
+        redis2 = fake.createClient("transactions-2");
+
+    redis.SET("abc", "dfg");
+    redis.SET("what", "who");
+    redis.WATCH("why", "what", "abc");
+    multi = redis.MULTI();
+    redis.GET("abc", function () {
+        redis2.SET("abc", "dfgdfg", function () {
+            redis.UNWATCH ();
+            multi.SET("abc", "dfggfd", test("SET discarded", null, OK));
+            multi.STRLEN("abc", test("STRLEN", null, 6));
+            multi.exec ();
+
+            redis.GET("abc", test("unwatched succeeds", null, "dfggfd"));
+        });
+    });
+} ());
+
+(function () {
+    var multi,
+        redis = fake.createClient("transactions-3");
+
+    redis.WATCH("abc");
+    redis.GET("abc");
+    multi = redis.MULTI();
+    multi.SET("abc", "dfgdfg");
+    multi.exec(test("WATCH NONEX EXEC succeeds", null, ['OK']));
+    redis.GET("abc", test("WATCH NONEX GET succeeds", null, "dfgdfg"));
+} ());
+
+(function () {
+    var multi,
+        redis = fake.createClient("transactions-4");
+
+    redis.SET("fail-a", "hello");
+    multi = redis.MULTI();
+    multi.SADD("fail-a", "woot", test("EXEC reply error", BAD_TYPE));
+    multi.exec();
+} ());
+
+(function () {
+    var client = fake.createClient(), set_size = 1000;
+
+    client.sadd("bigset", "a member");
+    client.sadd("bigset", "another member");
+
+    while (set_size > 0) {
+        client.sadd("bigset", "member " + set_size);
+        set_size -= 1;
+    }
+
+    client.multi()
+        .scard("bigset")
+        .sadd("set2","m1","m2")
+        .keys("*")
+        .smembers("set2")
+        .srem("set2","m3","m2","m1")
+        .dbsize(test("DBSIZE", null, 1))
+        .exec(test("multi chain with an individual callback", null, [ 1002, 2, [ "bigset", "set2" ], [ "m1", "m2" ], 2, 1 ]));
+} ());
+
+
+// Pub / Sub.
+
+(function () {
+    var pub  = fake.createClient("pubsub-1"),
+        sub1 = fake.createClient("pubsub-1"),
+        sub2 = fake.createClient("pubsub-1"),
+        sub3 = fake.createClient("pubsub-1"),
+
+        data = [ 0, [], [], [] ],
+        tcb1 = test("PUBSUB basics", null, [ 4, [ 'my.ch-alpha', 'my.ch-beta', 'my.ch-omega' ], [ 'my.ch-alpha', 'my.ch-beta' ], [ 'my.ch-alpha', 'my.ch-beta', 'what-what', 'my.ch-omega' ] ]),
+
+        ord  = [],
+        tcb2 = test("PUBSUB normal / sequence", null, [ 1, '*ch', 'pun', 1 ]),
+
+        thr  = test("Pubsub mode", null, true),
+        pun  = test("PUNSUBSCRIBE", null, "*ch");
+
+    sub2.SADD("testset", "testmem", function (err, data) {
+        ord.push(data);
+    });
+
+    sub1.SUBSCRIBE("my.ch");
+    sub2.PSUBSCRIBE("*ch");
+    sub3.PSUBSCRIBE("my.*", "what");
+
+    try {
+        sub3.PUBLISH('fail', 'fail');
+        thr(null, false);
+    }
+    catch (e) {
+        thr(null, true);
+    }
+
+    sub1.on('message', function (channel, message) {
+        data[1].push(channel + '-' + message);
+
+        if (message === 'alpha')
+            pub.PUBLISH('my.ch', 'beta', test('PUB2', null, 3));
+    });
+
+    sub2.on('pmessage', function (pattern, channel, message) {
+        data[2].push(channel + '-' + message);
+
+        if (message === 'beta') {
+            pub.PUBLISH('ignore', 'ignored', test('PUB3 ignored', null, 0));
+            pub.PUBLISH('what', 'what', test('PUB3 delivered', null, 1));
+            sub2.PUNSUBSCRIBE('hello', 'world', '*ch');
+        }
+    });
+
+    sub2.on('punsubscribe', function (pattern) {
+        pun(null, pattern);
+
+        ord.push('pun');
+
+        sub2.SREM('testset', 'testmem', function (err, data) {
+            ord.push(data);
+        });
+
+        sub2.PUBLISH('hello', 'world', test('PUB4 ignored', null, 0));
+        sub2.PUBLISH('my.ch', 'omega', test('PUB5 unsubed', null, 2));
+    });
+
+    sub3.on('pmessage', function (pattern, channel, message) {
+        data [ 3 ].push(channel + '-' + message);
+    });
+
+    var start = function (ch) {
+        data [ 0 ] ++;
+        if (data [ 0 ] === 4) {
+            pub.PUBLISH('my.ch', 'alpha', test('PUB1', null, 3));
+        }
+
+        if (ch === '*ch')
+            ord.push(ch);
+    };
+
+    sub1.on('subscribe', start);
+    sub2.on('psubscribe', start);
+    sub3.on('psubscribe', start);
+
+    // Test the state a bit later.
+
+    setTimeout(
+        function () {
+            tcb1(null, data);
+            tcb2(null, ord);
+        },
+        1000
+    );
+} ());
+
+(function () {
+    var pub  = fake.createClient("pubsub-2"),
+        sub1 = fake.createClient("pubsub-2"),
+        sub2 = fake.createClient("pubsub-2"),
+
+        un1  = [],
+        tcb1 = test("PUBSUB UNSUBSCRIBE from all", null, [ "one", 3, "two", 2, "three", 1 ]),
+
+        un2  = [],
+        tcb2 = test("PUBSUB PUNSUBSCRIBE from all", null, [ "on?", 3, "tw?", 2, "thre?", 1 ]),
+
+        good = [],
+        tcb3 = test("subscribed correctly", null, [ "A", "B", "C", "A", "B", "C" ]),
+
+        bad  = [],
+        tcb4 = test("unsubscribed correctly", null, []),
+
+        msg  = [ 'A', 'B', 'C' ],
+
+        x    = 0,
+        y    = 0,
+        tcb5 = test("sub / unsub counters", null, [ 8, 6 ]);
+
+
+    sub1.SUBSCRIBE('one');
+    sub1.SUBSCRIBE('two', 'three');
+    sub2.PSUBSCRIBE('on?');
+    sub2.PSUBSCRIBE('tw?', 'thre?');
+
+    sub1.PSUBSCRIBE('t?st');
+    sub2.SUBSCRIBE('test');
+
+    sub1.on('message', function (pat, channel, message) {
+        bad.push(message);
+    });
+    sub2.on('pmessage', function (channel, message) {
+        bad.push(message);
+    });
+
+    sub1.on('pmessage', function (pat, channel, message) {
+        good.push(message);
+    });
+    sub2.on('message', function (channel, message) {
+        good.push(message);
+    });
+
+
+    sub1.on('subscribe', function () {
+        start ();
+    });
+    sub1.on('psubscribe', function () {
+        start ();
+    });
+    sub2.on('subscribe', function () {
+        start ();
+    });
+    sub2.on('psubscribe', function () {
+        start ();
+    });
+
+    function start() {
+        x ++;
+        if (x < 8)
+            return;
+
+        sub1.UNSUBSCRIBE ();
+        sub2.PUNSUBSCRIBE ();
+    }
+
+
+    sub1.on('unsubscribe', function (channel, count) {
+        un1.push(channel, count);
+        end ();
+    });
+
+    sub2.on('punsubscribe', function (pattern, count) {
+        un2.push(pattern, count);
+        end ();
+    });
+
+    function end() {
+        y ++;
+        if (y < 4 )
+            return;
+
+        pub.PUBLISH('test', msg.shift());
+        if (y === 4 )
+            pub.PUBLISH('three', 'ignored', test("PUB ignored", null, 0));
+    }
+
+
+    // Test the state a bit later.
+
+    setTimeout(
+        function () {
+            tcb1(null, un1);
+            tcb2(null, un2);
+            tcb3(null, good);
+            tcb4(null, bad);
+            tcb5(null, [ x, y ]);
+        },
+        1000
+    );
+} ());
+
+
+// More blocking list stuff.
+
+(function () {
+    fake.createClient().BLPOP("list", "mylist", "BL-a", 1, test("BLPOP timeout", null, null));
+    fake.createClient().BRPOP("list", "mylist", "BL-a", 1, test("BRPOP timeout", null, null));
+    fake.createClient().BRPOPLPUSH("list", "mylist", "BL-a", 1, test("BRPOPLPUSH timeout", null, null));
+} ());
+
+
+// Connection state changes and other weirdness.
+
+(function () {
+    var redis1 = fake.createClient("weird"),
+        redis2 = fake.createClient("weird"),
+        redis3 = fake.createClient("weird");
+
+
+    redis1.multi()
+        .SET("hello", "world" )
+        .BLPOP("nonex", 0, test("BLPOP in transaction", null, null))
+        .LPUSH("step-1", "", test("LPUSH empty string", null, 1))
+            .exec ();
+
+    redis1.BRPOP("step-3", 0, test("BRPOPLPUSH step 3, chain worked.", null, [ "step-3", "" ]));
+
+    redis1.MULTI()
+        .get("hello", test("GET transblocktrans", null, "redis"))
+        .blpop("nonex", 0, test("BLPOP in postblock transaction", null, null))
+        .publish("hello", "world", test("PUBLISH in postblock transaction", null, 1))
+            .exec ();
+
+    redis2.BRPOPLPUSH("step-2", "step-3", 0, test("BRPOPLPUSH step 2", null, ""));
+    redis2.SET("hello", "redis");
+
+    redis3.BRPOPLPUSH("step-1", "step-2", 0, test("BRPOPLPUSH step 1", null, ""));
+    redis3.SUBSCRIBE("hello");
+
+
+    redis3.on('message', function (channel, message) {
+        if (channel === 'hello' && message === 'world')
+            redis3.UNSUBSCRIBE ();
+    });
+
+    redis3.on('unsubscribe', function (channel) {
+        if (channel === 'hello')
+            redis3.LPUSH("end-message", "Hello World!");
+    });
+
+
+    redis1.BLPOP("end-message", 0, test("Multi + Blocking + Pubsub, end result", null, [ "end-message", "Hello World!" ]));
+} ());
+
+
+// Sort.
+
+(function () {
+    var redis = fake.createClient(),
+        result;
+
+    // Simple num and alpha sort.
+
+    redis.LPUSH("list", "2", "11", 3, 1);
+    redis.SORT("list", test("SORT num", null, [ "1", "2", "3", "11" ]));
+    redis.DEL("list");
+
+    redis.LPUSH("list", "2", "a", "11", 3, 1, "A", "-", "_", ".", "~", "*");
+    redis.SORT("list", test("SORT scorefail", BAD_SORT, null));
+    redis.SORT("list", "alpha", test("SORT alpha", null, [ "*", "-", ".", "1", "11", "2", "3", "A", "_", "a", "~" ]));
+    redis.DEL("list");
+
+    // By clause.
+
+    redis.LPUSH("list", 11, 22, "hello", "abra", "opa");
+    redis.SET("w11w", -1);
+    redis.SET("w22w", 1);
+    redis.SORT("list", "by", "w*w", test("SORT num by +MVs, str*", null, [ "11", "abra", "hello", "opa", "22" ]));
+    redis.DEL("list", "w11w", "w22w");
+
+    // Test BY and GET clauses.
+
+    redis.LPUSH("list", 11, 22, 33, 44, 55);
+    redis.SADD ("set",  11, 22, 33, 44, 55);
+    redis.ZADD ("zset", 0, 11, 0, 22, 0, 33, 0, 44, 0, 55);
+
+    redis.HMSET("o11", "name", "tuti", "age", 25);
+    redis.HMSET("o22", "name", "ivo", "age", 26);
+    redis.HMSET("o33", "name", "lino", "age", 27);
+    redis.HMSET("o44", "name", "mina", "age", 20);
+    redis.HMSET("o55", "name", "kemi", "age", 18);
+
+    result = [ "55", "kemi", "44", "mina", "11", "tuti", "22", "ivo", "33", "lino" ];
+
+    redis.SORT("list", "by", "o*->age", "get", "#", "get", "o*->name", test("SORT list by+get, h*->f", null, result));
+    redis.SORT("set",  "by", "o*->age", "get", "#", "get", "o*->name", test("SORT set by+get, h*->f",  null, result));
+    redis.SORT("zset", "by", "o*->age", "get", "#", "get", "o*->name", test("SORT zset by+get, h*->f", null, result));
+
+    redis.SORT("zset", "by", "o*->age", "get", "#", "get", "o*->name", "store", "storekey", test("SORT zset by+get, h*->f, STORE", null, result.length));
+    redis.LRANGE("storekey", 0, -1, test("SORT zset by+get, h*->f, STORE / LRANGE", null, result));
+
+    // Negative offset behaves differently here and in ZRANGEBYSCORE
+
+    redis.SORT("list", "by", "o*->age", "limit", 0, 2, "get", "#", "get", "o*->name", test("SORT limit", null, result.slice(0, 4 )));
+    redis.SORT("list", "by", "o*->age", "limit", 2, 4, "get", "#", "get", "o*->name", test("SORT limit +offset", null, result.slice(4 )));
+    redis.SORT("list", "by", "o*->age", "limit", 2, -10, "get", "#", "get", "o*->name", test("SORT limit +negcount", null, result.slice(4 )));
+    redis.SORT("list", "by", "o*->age", "limit", -2, 2, "get", "#", "get", "o*->name", test("SORT limit +negoffset+negcount", null, result.slice(0, 4 )));
+
+    redis.HSET("o11", "age", "not-a-number");
+    redis.SORT("list", "by", "o*->age", "get", "#", "get", "o*->name", test("SORT by+scorefail", BAD_SORT, null));
+
+    // Edge cases.
+
+    redis.SORT("nonex", test("SORT nonex", null, []));
+    redis.SORT("nonex", "by", "o*->age", test("SORT nonex+by", null, []));
+    redis.SORT("nonex", "by", "o*->age", "get", "#", "get", "o*->name", test("SORT nonex+by+get", null, []));
+    redis.SET("hello", "world");
+    redis.SORT("hello", test("SORT bad type", BAD_TYPE, null));
+} ());
+
+
+// Keyspace dump.
+
+(function () {
+    var redis = fake.createClient();
+
+    redis.SET("hello", "redis");
+    redis.SET("mykey", "some string");
+    redis.SADD("myset", "m3", "m2", "m1");
+    redis.ZADD("myzset", 10, "zm1", 5, "zm2", -5, "zm3");
+    redis.HMSET("myhash", "field1", "value1", "field2", "value2");
+    redis.LPUSH("mylist", "e1", "e2", "e3");
+
+    redis.getKeyspace("my*", test(
+        "keyspace dump, all types", null,
+        [
+            "myhash", "-1", "hash", [ "field1", "value1", "field2", "value2" ],
+            "mykey",  "-1", "string", "some string",
+            "mylist", "-1", "list", [ "e3", "e2", "e1" ],
+            "myset",  "-1", "set",  [ "m1", "m2", "m3" ],
+            "myzset", "-1", "zset", [ "zm3", "-5", "zm2", "5", "zm1", "10" ]
+        ]
+   ));
+
+    //
+    redis.end();
+} ());
+
+
+// Select.
+
+(function () {
+    var redis1 = fake.createClient("select-test");
+    var redis2 = fake.createClient("select-test");
+    var redis3 = fake.createClient("select-test");
+
+    var finish = test("SELECT, cross-database pubsub", null, "Hey you!");
+
+    redis2.SUBSCRIBE("PASS");
+    redis2.on('message', function (channel, message) {
+        finish(null, message);
+    });
+
+    redis1.SET("A", "Hola");
+    redis1.SELECT(1, test("SELECT 1", null, OK));
+
+    redis1.GET("A", test("SELECT, keyspace isolation", null, null));
+    redis1.SET("A", "Hello", function () {
+
+        redis3.GET("A", test("SELECT, connection selection isolation", null, "Hola"));
+        redis3.SET("A", "Hola!!!", function () {
+
+            redis1.SELECT(0, test("SELECT 0", null, OK));
+            redis1.GET("A", test("SELECT, keyspace switching", null, "Hola!!!"));
+
+            redis1.SELECT(-1, test("SELECT BAD_DB neg", BAD_DB, null));
+            redis1.SELECT("X", test("SELECT BAD_DB X", BAD_DB, null));
+            redis1.SELECT(111.4, test("SELECT BAD_DB float", BAD_DB, null));
+
+            redis1.SELECT(2000, test("SELECT 2000", null, OK));
+            redis1.PUBLISH("PASS", "Hey you!");
+        });
+    });
+} ());
+
+
+// Select with blocking.
+
+(function () {
+    var redis1 = fake.createClient("select-test2");
+    var redis2 = fake.createClient("select-test2");
+    var redis3 = fake.createClient("select-test2");
+
+    redis1.BLPOP("list", "other", 1, test("SELECT 0 + BLPOP", null, ["list", "hello list in 0"]));
+
+    redis2.SELECT(1);
+    redis2.BRPOP("other", "list", 1, test("SELECT 1 + BRPOP", null, ["list", "hello list in 1"]));
+
+    redis3.SELECT(2);
+    redis3.LPUSH("list", "wrong!");
+    redis3.SELECT(1);
+    redis3.LPUSH("list", "hello list in 1");
+    redis3.SELECT(0);
+    redis3.RPUSH("list", "hello list in 0");
+} ());
+
+
+// Buffers.
+
+(function () {
+    var redis = fake.createClient(null, null, { return_buffers: true });
+
+    function randBuf() {
+        var n = Math.ceil(Math.random() * 1024);
+        var buf = new Buffer(n);
+        while (n --)
+            buf[n] = Math.round(Math.random() * 256);
+
+        return buf;
+    }
+
+    var k1 = randBuf();
+    var v1 = randBuf();
+
+    redis.SET(k1, v1, test("SET bufbuf", null, new Buffer(OK)));
+    redis.GET(k1, test("GET bufbuf", null, v1));
+} ());
+
+
+// Scan & co.
+
+(function () {
+    var redis = fake.createClient();
+
+    redis.SADD('myset', 'what', 'woo', 'woot', 'www');
+    redis.ZADD('myzset', 1, 'what', 4, 'woo', 3, 'woot', 2, 'www');
+    redis.HMSET('myhash', 'key1', 'val1', 'key2', 'val2');
+
+    redis.SCAN(0, test('SCAN 0 all', null, ['0', ['myset', 'myzset', 'myhash']]));
+    redis.SCAN(0, 'COUNT', 2, test('SCAN 0 COUNT 2', null, ['2', ['myset', 'myzset']]));
+    redis.SCAN(2, 'COUNT', 2, test('SCAN COUNT 2 rest', null, ['0', ['myhash']]));
+    redis.SCAN(0, 'MATCH', '*z*', test('SCAN MATCH 1', null, ['0', ['myzset']]));
+    redis.SCAN(0, 'MATCH', 'none', test('SCAN MATCH none', null, ['0', []]));
+    redis.SCAN(0, 'MATCH', '*set', 'COUNT', 1, test('SCAN MATCH COUNT', null, ['1', ['myset']]));
+    redis.SCAN(0, 'MATCH', '*zset', 'COUNT', 1, test('SCAN MATCH COUNT empty', null, ['1', []]));
+    redis.SCAN(1, 'MATCH', '*zset', 'COUNT', 1, test('SCAN MATCH COUNT mid', null, ['2', ['myzset']]));
+    redis.SCAN(0, 'MATCH', '*set', 'COUNT', 0, test('SCAN MATCH COUNT 0', null, ['0', []]));
+
+    redis.SSCAN('myset', 0, test('SSCAN 0 all', null, ['0', ['what', 'woo', 'woot', 'www']]));
+    redis.SSCAN('myset', 0, 'COUNT', 2, test('SSCAN 0 COUNT 2', null, ['2', ['what', 'woo']]));
+    redis.SSCAN('myset', 2, 'COUNT', 2, test('SSCAN COUNT 2 rest', null, ['0', ['woot', 'www']]));
+    redis.SSCAN('myset', 0, 'MATCH', '*o', test('SSCAN MATCH 1', null, ['0', ['woo']]));
+
+    redis.HSCAN('myhash', 0, test('HSCAN', null, ['0', ['key1', 'val1', 'key2', 'val2']]));
+    redis.HSCAN('myhash', 0, 'MATCH', '*y2', test('HSCAN MATCH', null, ['0', ['key2', 'val2']]));
+
+    redis.ZSCAN('myzset', 0, test('ZSCAN', null, ['0', ['what', '1', 'www', '2', 'woot', '3', 'woo', '4']]));
+    redis.ZSCAN('myzset', 0, 'MATCH', 'wo*', test('ZSCAN MATCH', null, ['0', ['woot', '3', 'woo', '4']]));
+
+} ());
+
+
+// Test shorthand.
+
+var TEST_COUNT, numErrors, numOk;
+
+function areEqualBuffers(b1, b2) {
+    if (!Buffer.isBuffer(b1))
+        return false;
+    if (!Buffer.isBuffer(b2))
+        return false;
+
+    if (b1.length !== b2.length)
+        return false;
+
+    var n = b1.length;
+    while (n--)
+        if (b1[n] !== b2[n])
+            return false;
+
+    return true;
+}
+
+function test(name, xErr, xData) {
+    var timeout,
+        c = (TEST_COUNT = (TEST_COUNT || 0) + 1);
+
+    xErr = JSON.stringify(xErr);
+    if (!Buffer.isBuffer(xData))
+        xData = JSON.stringify(xData);
+
+    timeout = setTimeout(
+        function () {
+            numErrors = (numErrors || 0 ) + 1;
+            process.stdout.write('\x1B[1;31m\n  ✗ #' + c + ' ' + name + '\x1B[0m:\n\tDidn\'t call back.\n\txErr = ' + xErr + '\t\txData = ' + xData + '\n\n');
+        },
+        5000
+    );
+
+    return function (err, data) {
+        clearTimeout(timeout);
+        if (err)
+            err = err.message;
+
+        err = JSON.stringify(err);
+        if (!Buffer.isBuffer(data))
+            data = JSON.stringify(data);
+
+        if (err === xErr && (Buffer.isBuffer(xData) ? areEqualBuffers(data, xData) : data === xData)) {
+            numOk = (numOk || 0) + 1;
+            process.stdout.write('\x1B[1;32m  ✓ #' + c + ' ' + name + '\x1B[0m\n');
+        }
+
+        else {
+            numErrors = (numErrors || 0 ) + 1;
+            process.stdout.write('\x1B[1;31m\n  ✗ #' + c + ' ' + name + '\x1B[0m:\n\terr  = ' + err + '\t\tdata  = ' + data + '\n\txErr = ' + xErr + '\t\txData = ' + xData + '\n\n');
+        }
+    };
+}
+
+
+// Suite self-validate and known test count check.
+
+function countTests() {
+
+    // Counts the number of tests in tests.js.
+    // -1 because this matches the function defition too.
+    var tests = require('fs').readFileSync('./test.js', 'utf8');
+    return tests.match(/[^a-z0-9_$]test\s*\(/g).length - 1;
+}
+
+var NUM_TESTS = countTests();
+if (NUM_TESTS !== 286)
+    throw new Error("Test count is off: " + NUM_TESTS);
+
+process.on('exit', function () {
+    if (TEST_COUNT > NUM_TESTS)
+        throw new Error("Update NUM_TESTS when adding stuff to the test suite.");
+
+    if (!numErrors && numOk === TEST_COUNT && numOk === NUM_TESTS) {
+        process.stdout.write('\n\x1B[1;32m  ✓ All good (' + numOk + ').\x1B[0m\n');
+        process.exit(0);
+    }
+
+    else {
+        process.stdout.write('\x1B[1;31m\n  ✗ ' + numErrors + ' broken.\x1B[0m\n');
+        process.exit(1);
+    }
+});