diff --git a/tape/tape-tests.ts b/tape/tape-tests.ts
index 2c4e4ec1bb..85bb19a6ec 100644
--- a/tape/tape-tests.ts
+++ b/tape/tape-tests.ts
@@ -4,21 +4,16 @@
 
 import tape = require('tape');
 
-var x: any;
-var value: any;
-var err: any;
-var a: any;
-var b: any;
-var err: any;
-var num: number;
 var name: string;
-var msg: string;
-var rs: NodeJS.ReadableStream;
-
 var cb: tape.TestCase;
+var opts: tape.TestOptions;
 var t: tape.Test;
 
+tape(cb);
 tape(name, cb);
+tape(opts, cb);
+tape(name, opts, cb);
+
 tape(name, (test: tape.Test) => {
 	t = test;
 });
@@ -26,29 +21,51 @@ tape(name, (test: tape.Test) => {
 tape.skip(name, cb);
 tape.only(name, cb);
 
-rs = tape.createStream();
-rs = tape.createStream(x);
 
-var tx = tape.createHarness();
-tx(name, cb);
-tape.skip(name, cb);
-tape.only(name, cb);
+var sopts: tape.StreamOptions;
+var rs: NodeJS.ReadableStream;
+rs = tape.createStream();
+rs = tape.createStream(sopts);
+
+
+var htest: typeof tape;
+htest = tape.createHarness();
+
 
 tape(name, (test: tape.Test) => {
 
+	var num: number;
+	var ms: number;
+	var value: any;
+	var actual: any;
+	var expected: any;
+	var err: any;
+	var fn = function() {};
+	var msg: string;
+
+	var exceptionExpected: RegExp | (() => void);
+
 	test.plan(num);
 	test.end();
+	test.end(err);
 
 	test.fail(msg);
 	test.pass(msg);
+	test.timeoutAfter(ms);
 	test.skip(msg);
 
+	test.ok(value);
 	test.ok(value, msg);
+	test.true(value);
 	test.true(value, msg);
+	test.assert(value);
 	test.assert(value, msg);
 
+	test.notOk(value);
 	test.notOk(value, msg);
+	test.false(value);
 	test.false(value, msg);
+	test.notok(value);
 	test.notok(value, msg);
 
 	test.error(err, msg);
@@ -56,51 +73,91 @@ tape(name, (test: tape.Test) => {
 	test.ifErr(err, msg);
 	test.iferror(err, msg);
 
-	test.equal(a, b, msg);
-	test.equals(a, b, msg);
-	test.isEqual(a, b, msg);
-	test.is(a, b, msg);
-	test.strictEqual(a, b, msg);
-	test.strictEquals(a, b, msg);
+	test.equal(actual, expected);
+	test.equal(actual, expected, msg);
+	test.equals(actual, expected);
+	test.equals(actual, expected, msg);
+	test.isEqual(actual, expected);
+	test.isEqual(actual, expected, msg);
+	test.is(actual, expected);
+	test.is(actual, expected, msg);
+	test.strictEqual(actual, expected);
+	test.strictEqual(actual, expected, msg);
+	test.strictEquals(actual, expected);
+	test.strictEquals(actual, expected, msg);
 
-	test.notEqual(a, b, msg);
-	test.notEquals(a, b, msg);
-	test.notStrictEqual(a, b, msg);
-	test.notStrictEquals(a, b, msg);
-	test.isNotEqual(a, b, msg);
-	test.isNot(a, b, msg);
-	test.not(a, b, msg);
-	test.doesNotEqual(a, b, msg);
-	test.notEqual(a, b, msg);
-	test.isInequal(a, b, msg);
+	test.notEqual(actual, expected);
+	test.notEqual(actual, expected, msg);
+	test.notEquals(actual, expected);
+	test.notEquals(actual, expected, msg);
+	test.notStrictEqual(actual, expected);
+	test.notStrictEqual(actual, expected, msg);
+	test.notStrictEquals(actual, expected);
+	test.notStrictEquals(actual, expected, msg);
+	test.isNotEqual(actual, expected);
+	test.isNotEqual(actual, expected, msg);
+	test.isNot(actual, expected);
+	test.isNot(actual, expected, msg);
+	test.not(actual, expected);
+	test.not(actual, expected, msg);
+	test.doesNotEqual(actual, expected);
+	test.doesNotEqual(actual, expected, msg);
+	test.isInequal(actual, expected);
+	test.isInequal(actual, expected, msg);
 
-	test.deepEqual(a, b, msg);
-	test.deepEquals(a, b, msg);
-	test.isEquivalent(a, b, msg);
-	test.same(a, b, msg);
+	test.deepEqual(actual, expected);
+	test.deepEqual(actual, expected, msg);
+	test.deepEquals(actual, expected);
+	test.deepEquals(actual, expected, msg);
+	test.isEquivalent(actual, expected);
+	test.isEquivalent(actual, expected, msg);
+	test.same(actual, expected);
+	test.same(actual, expected, msg);
 
-	test.notDeepEqual(a, b, msg);
-	test.notEquivalent(a, b, msg);
-	test.notDeeply(a, b, msg);
-	test.notSame(a, b, msg);
-	test.isNotDeepEqual(a, b, msg);
-	test.isNotDeeply(a, b, msg);
-	test.isNotEquivalent(a, b, msg);
-	test.isInequivalent(a, b, msg);
+	test.notDeepEqual(actual, expected);
+	test.notDeepEqual(actual, expected, msg);
+	test.notEquivalent(actual, expected);
+	test.notEquivalent(actual, expected, msg);
+	test.notDeeply(actual, expected);
+	test.notDeeply(actual, expected, msg);
+	test.notSame(actual, expected);
+	test.notSame(actual, expected, msg);
+	test.isNotDeepEqual(actual, expected);
+	test.isNotDeepEqual(actual, expected, msg);
+	test.isNotDeeply(actual, expected);
+	test.isNotDeeply(actual, expected, msg);
+	test.isNotEquivalent(actual, expected);
+	test.isNotEquivalent(actual, expected, msg);
+	test.isInequivalent(actual, expected);
+	test.isInequivalent(actual, expected, msg);
 
-	test.deepLooseEqual(a, b, msg);
-	test.looseEqual(a, b, msg);
-	test.looseEquals(a, b, msg);
+	test.deepLooseEqual(actual, expected);
+	test.deepLooseEqual(actual, expected, msg);
+	test.looseEqual(actual, expected);
+	test.looseEqual(actual, expected, msg);
+	test.looseEquals(actual, expected);
+	test.looseEquals(actual, expected, msg);
 
-	test.notDeepLooseEqual(a, b, msg);
-	test.notLooseEqual(a, b, msg);
-	test.notLooseEquals(a, b, msg);
+	test.notDeepLooseEqual(actual, expected);
+	test.notDeepLooseEqual(actual, expected, msg);
+	test.notLooseEqual(actual, expected);
+	test.notLooseEqual(actual, expected, msg);
+	test.notLooseEquals(actual, expected);
+	test.notLooseEquals(actual, expected, msg);
 
-	test.throws(() => {
+	test.throws(fn);
+	test.throws(fn, msg);
+	test.throws(fn, exceptionExpected);
+	test.throws(fn, exceptionExpected, msg);
 
-	}, value, msg);
+	test.doesNotThrow(fn);
+	test.doesNotThrow(fn, msg);
+	test.doesNotThrow(fn, exceptionExpected);
+	test.doesNotThrow(fn, exceptionExpected, msg);
 
-	test.doesNotThrow(() => {
+	test.test(name, (st) => {
+		t = st;
+	});
 
-	}, value, msg);
+	test.comment(msg);
 });