diff --git a/when/when-tests.ts b/when/when-tests.ts
index 9e949dad99..61b688a035 100644
--- a/when/when-tests.ts
+++ b/when/when-tests.ts
@@ -41,51 +41,51 @@ promise = when.attempt(() => 1);
 promise = when.attempt((a: number) => a + a, 1);
 promise = when.attempt((a: number) => a + a, when(1));
 
-promise = when.attempt((a: number, b: number) => a + b, 1, 2);
-promise = when.attempt((a: number, b: number) => a + b, 1, when(2));
-promise = when.attempt((a: number, b: number) => a + b, when(1), 2);
-promise = when.attempt((a: number, b: number) => a + b, when(1), when(2));
+promise = when.attempt((a: number, b: string) => a, 1, '2');
+promise = when.attempt((a: number, b: string) => a, 1, when('2'));
+promise = when.attempt((a: number, b: string) => a, when(1), '2');
+promise = when.attempt((a: number, b: string) => a, when(1), when('2'));
 
-promise = when.attempt((a: number, b: number, c: number) => a + b + c, 1, 2, 3);
-promise = when.attempt((a: number, b: number, c: number) => a + b + c, 1, when(2), 3);
-promise = when.attempt((a: number, b: number, c: number) => a + b + c, when(1), 2, 3);
-promise = when.attempt((a: number, b: number, c: number) => a + b + c, when(1), when(2), 3);
-promise = when.attempt((a: number, b: number, c: number) => a + b + c, 1, 2, when(3));
-promise = when.attempt((a: number, b: number, c: number) => a + b + c, 1, when(2), when(3));
-promise = when.attempt((a: number, b: number, c: number) => a + b + c, when(1), 2, when(3));
-promise = when.attempt((a: number, b: number, c: number) => a + b + c, when(1), when(2), when(3));
+promise = when.attempt((a: number, b: string, c: boolean) => a, 1, '2', true);
+promise = when.attempt((a: number, b: string, c: boolean) => a, 1, when('2'), true);
+promise = when.attempt((a: number, b: string, c: boolean) => a, when(1), '2', true);
+promise = when.attempt((a: number, b: string, c: boolean) => a, when(1), when('2'), true);
+promise = when.attempt((a: number, b: string, c: boolean) => a, 1, '2', when(true));
+promise = when.attempt((a: number, b: string, c: boolean) => a, 1, when('2'), when(true));
+promise = when.attempt((a: number, b: string, c: boolean) => a, when(1), '2', when(true));
+promise = when.attempt((a: number, b: string, c: boolean) => a, when(1), when('2'), when(true));
 
-promise = when.attempt((a: number, b: number, c: number, d: number, e: number) => a + b + c + d + e, when(1), when(2), when(3), when(4), when(5));
+promise = when.attempt((a: number, b: string, c: boolean, d: number, e: string) => a, when(1), when('2'), when(true), when(4), when('5'));
 
 /* when.lift(f) */
 
-var liftedFunc0 = when.lift(() => 2);
-var liftedFunc1 = when.lift((a: number) => a + a);
-var liftedFunc2 = when.lift((a: number, b: number) => a + b);
-var liftedFunc3 = when.lift((a: number, b: number, c: number) => a + b + c);
+var liftedFunc0 = when.lift(() => 0);
+var liftedFunc1 = when.lift((a: number) => a);
+var liftedFunc2 = when.lift((a: number, b: string) => a);
+var liftedFunc3 = when.lift((a: number, b: string, c: boolean) => a);
 
-var liftedFunc5 = when.lift((a: number, b: number, c: number, d: number, e: number) => a + b + c + d + e);
+var liftedFunc5 = when.lift((a: number, b: string, c: boolean, d: number, e: string) => a);
 
 promise = liftedFunc0();
 
 promise = liftedFunc1(1);
 promise = liftedFunc1(when(1));
 
-promise = liftedFunc2(1, 2);
-promise = liftedFunc2(when(1), 2);
-promise = liftedFunc2(1, when(2));
-promise = liftedFunc2(when(1), when(2));
+promise = liftedFunc2(1, '2');
+promise = liftedFunc2(when(1), '2');
+promise = liftedFunc2(1, when('2'));
+promise = liftedFunc2(when(1), when('2'));
 
-promise = liftedFunc3(1, 2, 3);
-promise = liftedFunc3(when(1), 2, 3);
-promise = liftedFunc3(1, when(2), 3);
-promise = liftedFunc3(when(1), when(2), 3);
-promise = liftedFunc3(1, 2, when(3));
-promise = liftedFunc3(when(1), 2, when(3));
-promise = liftedFunc3(1, when(2), when(3));
-promise = liftedFunc3(when(1), when(2), when(3));
+promise = liftedFunc3(1, '2', true);
+promise = liftedFunc3(when(1), '2', true);
+promise = liftedFunc3(1, when('2'), true);
+promise = liftedFunc3(when(1), when('2'), true);
+promise = liftedFunc3(1, '2', when(true));
+promise = liftedFunc3(when(1), '2', when(true));
+promise = liftedFunc3(1, when('2'), when(true));
+promise = liftedFunc3(when(1), when('2'), when(true));
 
-promise = liftedFunc5(when(1), when(2), when(3), when(4), when(5));
+promise = liftedFunc5(when(1), when('2'), when(true), when(4), when('5'));
 
 /* when.join(...promises) */
 
@@ -133,16 +133,16 @@ promise = when(1).then((val: number) => when(val + val), (err: any) => 2);
 /* promise.spread(onFulfilledArray) */
 
 // TODO: Work out how to do this...
-// promise = when([1, 2, 3]).spread((a: number, b: number) => a + b);
-// promise = when([1, 2, 3]).spread((a: number, b: number) => when(a + b));
+// promise = when([1, '2', true]).spread((a: number, b: string, c: boolean) => a);
+// promise = when([1, '2', true]).spread((a: number, b: string, c: boolean) => when(a));
 
 /* promise.fold(combine, promise2) */
 
-promise = when(1).fold((a: number, b: number) => a + b, 2);
-promise = when(1).fold((a: number, b: number) => a + b, when(2));
+promise = when(1).fold((a: number, b: string) => a, '2');
+promise = when(1).fold((a: number, b: string) => a, when('2'));
 
-promise = when(1).fold((a: number, b: number) => when(a + b), 2);
-promise = when(1).fold((a: number, b: number) => when(a + b), when(2));
+promise = when(1).fold((a: number, b: string) => when(a), '2');
+promise = when(1).fold((a: number, b: string) => when(a), when('2'));
 
 /* promise.catch(onRejected) */
 
@@ -218,10 +218,10 @@ import nodefn = require('when/node');
 
 var nodeFn0 = (callback: (err: any, result: number) => void) => callback(null, 0);
 var nodeFn1 = (a: number, callback: (err: any, result: number) => void) => callback(null, a);
-var nodeFn2 = (a: number, b: number, callback: (err: any, result: number) => void) => callback(null, a + b);
-var nodeFn3 = (a: number, b: number, c: number, callback: (err: any, result: number) => void) => callback(null, a + b + c);
+var nodeFn2 = (a: number, b: string, callback: (err: any, result: number) => void) => callback(null, a);
+var nodeFn3 = (a: number, b: string, c: boolean, callback: (err: any, result: number) => void) => callback(null, a);
 
-var nodeFn5 = (a: number, b: number, c: number, d: number, e: number, callback: (err: any, result: number) => void) => callback(null, a + b + c + d + e);
+var nodeFn5 = (a: number, b: string, c: boolean, d: number, e: string, callback: (err: any, result: number) => void) => callback(null, a);
 
 var liftedNodeFunc0 = nodefn.lift(nodeFn0);
 var liftedNodeFunc1 = nodefn.lift(nodeFn1);
@@ -235,21 +235,21 @@ promise = liftedNodeFunc0();
 promise = liftedNodeFunc1(1);
 promise = liftedNodeFunc1(when(1));
 
-promise = liftedNodeFunc2(1, 2);
-promise = liftedNodeFunc2(when(1), 2);
-promise = liftedNodeFunc2(1, when(2));
-promise = liftedNodeFunc2(when(1), when(2));
+promise = liftedNodeFunc2(1, '2');
+promise = liftedNodeFunc2(when(1), '2');
+promise = liftedNodeFunc2(1, when('2'));
+promise = liftedNodeFunc2(when(1), when('2'));
 
-promise = liftedNodeFunc3(1, 2, 3);
-promise = liftedNodeFunc3(when(1), 2, 3);
-promise = liftedNodeFunc3(1, when(2), 3);
-promise = liftedNodeFunc3(when(1), when(2), 3);
-promise = liftedNodeFunc3(1, 2, when(3));
-promise = liftedNodeFunc3(when(1), 2, when(3));
-promise = liftedNodeFunc3(1, when(2), when(3));
-promise = liftedNodeFunc3(when(1), when(2), when(3));
+promise = liftedNodeFunc3(1, '2', true);
+promise = liftedNodeFunc3(when(1), '2', true);
+promise = liftedNodeFunc3(1, when('2'), true);
+promise = liftedNodeFunc3(when(1), when('2'), true);
+promise = liftedNodeFunc3(1, '2', when(true));
+promise = liftedNodeFunc3(when(1), '2', when(true));
+promise = liftedNodeFunc3(1, when('2'), when(true));
+promise = liftedNodeFunc3(when(1), when('2'), when(true));
 
-promise = liftedNodeFunc5(when(1), when(2), when(3), when(4), when(5));
+promise = liftedNodeFunc5(when(1), when('2'), when(true), when(4), when('5'));
 
 example = function() {
 	var resolveAddress = nodefn.lift(dns.resolve);
@@ -314,21 +314,21 @@ promise = nodefn.call(nodeFn0);
 promise = nodefn.call(nodeFn1, 1);
 promise = nodefn.call(nodeFn1, when(1));
 
-promise = nodefn.call(nodeFn2, 1, 2);
-promise = nodefn.call(nodeFn2, 1, when(2));
-promise = nodefn.call(nodeFn2, when(1), 2);
-promise = nodefn.call(nodeFn2, when(1), when(2));
+promise = nodefn.call(nodeFn2, 1, '2');
+promise = nodefn.call(nodeFn2, 1, when('2'));
+promise = nodefn.call(nodeFn2, when(1), '2');
+promise = nodefn.call(nodeFn2, when(1), when('2'));
 
-promise = nodefn.call(nodeFn3, 1, 2, 3);
-promise = nodefn.call(nodeFn3, 1, when(2), 3);
-promise = nodefn.call(nodeFn3, when(1), 2, 3);
-promise = nodefn.call(nodeFn3, when(1), when(2), 3);
-promise = nodefn.call(nodeFn3, 1, 2, when(3));
-promise = nodefn.call(nodeFn3, 1, when(2), when(3));
-promise = nodefn.call(nodeFn3, when(1), 2, when(3));
-promise = nodefn.call(nodeFn3, when(1), when(2), when(3));
+promise = nodefn.call(nodeFn3, 1, '2', true);
+promise = nodefn.call(nodeFn3, 1, when('2'), true);
+promise = nodefn.call(nodeFn3, when(1), '2', true);
+promise = nodefn.call(nodeFn3, when(1), when('2'), true);
+promise = nodefn.call(nodeFn3, 1, '2', when(true));
+promise = nodefn.call(nodeFn3, 1, when('2'), when(true));
+promise = nodefn.call(nodeFn3, when(1), '2', when(true));
+promise = nodefn.call(nodeFn3, when(1), when('2'), when(true));
 
-promise = nodefn.call(nodeFn5, when(1), when(2), when(3), when(4), when(5));
+promise = nodefn.call(nodeFn5, when(1), when('2'), when(true), when(4), when('5'));
 
 example = function () {
 	var loadPasswd = nodefn.call(fs.readFile, '/etc/passwd');
@@ -340,7 +340,7 @@ example = function () {
 
 /* node.apply */
 
-promise = nodefn.apply(nodeFn2, [1, 2]);
+promise = nodefn.apply(nodeFn2, [1, '2']);
 
 example = function () {
 	var loadPasswd = nodefn.apply(fs.readFile, ['/etc/passwd']);
@@ -375,7 +375,7 @@ example = function () {
 
 example = function () {
 	when.promise((resolve, reject) =>
-			nodeFn2(1, 2, nodefn.createCallback({ resolve: resolve, reject: reject })))
+			nodeFn2(1, '2', nodefn.createCallback({ resolve: resolve, reject: reject })))
 		.then(
 			(value: number) => console.log(value),
 			(err: any) => console.error(err));