switch to vuepress

14 files changed, 7435 insertions, 0 deletions

diff --git a/node_modules/tapable/lib/__tests__/AsyncParallelHooks.js b/node_modules/tapable/lib/__tests__/AsyncParallelHooks.js
new file mode 100644
index 00000000..c762fad3
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/AsyncParallelHooks.js
@@ -0,0 +1,37 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const HookTester = require("./HookTester");
+const AsyncParallelHook = require("../AsyncParallelHook");
+const AsyncParallelBailHook = require("../AsyncParallelBailHook");
+
+describe("AsyncParallelHook", () => {
+	it(
+		"should have to correct behavior",
+		async () => {
+			const tester = new HookTester(args => new AsyncParallelHook(args));
+
+			const result = await tester.run();
+
+			expect(result).toMatchSnapshot();
+		},
+		15000
+	);
+});
+
+describe("AsyncParallelBailHook", () => {
+	it(
+		"should have to correct behavior",
+		async () => {
+			const tester = new HookTester(args => new AsyncParallelBailHook(args));
+
+			const result = await tester.run();
+
+			expect(result).toMatchSnapshot();
+		},
+		15000
+	);
+});
diff --git a/node_modules/tapable/lib/__tests__/AsyncSeriesHooks.js b/node_modules/tapable/lib/__tests__/AsyncSeriesHooks.js
new file mode 100644
index 00000000..6fa3ed72
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/AsyncSeriesHooks.js
@@ -0,0 +1,51 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const HookTester = require("./HookTester");
+const AsyncSeriesHook = require("../AsyncSeriesHook");
+const AsyncSeriesBailHook = require("../AsyncSeriesBailHook");
+const AsyncSeriesWaterfallHook = require("../AsyncSeriesWaterfallHook");
+const AsyncSeriesLoopHook = require("../AsyncSeriesLoopHook");
+
+describe("AsyncSeriesHook", () => {
+	it("should have to correct behavior", async () => {
+		const tester = new HookTester(args => new AsyncSeriesHook(args));
+
+		const result = await tester.run();
+
+		expect(result).toMatchSnapshot();
+	});
+});
+
+describe("AsyncSeriesBailHook", () => {
+	it("should have to correct behavior", async () => {
+		const tester = new HookTester(args => new AsyncSeriesBailHook(args));
+
+		const result = await tester.run();
+
+		expect(result).toMatchSnapshot();
+	});
+});
+
+describe("AsyncSeriesWaterfallHook", () => {
+	it("should have to correct behavior", async () => {
+		const tester = new HookTester(args => new AsyncSeriesWaterfallHook(args));
+
+		const result = await tester.run();
+
+		expect(result).toMatchSnapshot();
+	});
+});
+
+describe("AsyncSeriesLoopHook", () => {
+	it("should have to correct behavior", async () => {
+		const tester = new HookTester(args => new AsyncSeriesLoopHook(args));
+
+		const result = await tester.runForLoop();
+
+		expect(result).toMatchSnapshot();
+	});
+});
diff --git a/node_modules/tapable/lib/__tests__/Hook.js b/node_modules/tapable/lib/__tests__/Hook.js
new file mode 100644
index 00000000..71a73d5d
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/Hook.js
@@ -0,0 +1,70 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const SyncHook = require("../SyncHook");
+
+describe("Hook", () => {
+	it("should allow to insert hooks before others and in stages", () => {
+		const hook = new SyncHook();
+
+		const calls = [];
+		hook.tap("A", () => calls.push("A"));
+		hook.tap(
+			{
+				name: "B",
+				before: "A"
+			},
+			() => calls.push("B")
+		);
+
+		calls.length = 0;
+		hook.call();
+		expect(calls).toEqual(["B", "A"]);
+
+		hook.tap(
+			{
+				name: "C",
+				before: ["A", "B"]
+			},
+			() => calls.push("C")
+		);
+
+		calls.length = 0;
+		hook.call();
+		expect(calls).toEqual(["C", "B", "A"]);
+
+		hook.tap(
+			{
+				name: "D",
+				before: "B"
+			},
+			() => calls.push("D")
+		);
+
+		calls.length = 0;
+		hook.call();
+		expect(calls).toEqual(["C", "D", "B", "A"]);
+
+		hook.tap(
+			{
+				name: "E",
+				stage: -5
+			},
+			() => calls.push("E")
+		);
+		hook.tap(
+			{
+				name: "F",
+				stage: -3
+			},
+			() => calls.push("F")
+		);
+
+		calls.length = 0;
+		hook.call();
+		expect(calls).toEqual(["E", "F", "C", "D", "B", "A"]);
+	});
+});
diff --git a/node_modules/tapable/lib/__tests__/HookCodeFactory.js b/node_modules/tapable/lib/__tests__/HookCodeFactory.js
new file mode 100644
index 00000000..759d1511
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/HookCodeFactory.js
@@ -0,0 +1,252 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const HookCodeFactory = require("../HookCodeFactory");
+
+const expectNoSyntaxError = code => {
+	new Function("a, b, c", code);
+};
+
+describe("HookCodeFactory", () => {
+	describe("callTap", () => {
+		const factoryConfigurations = {
+			"no args, no intercept": {
+				args: [],
+				taps: [
+					{
+						type: "sync"
+					},
+					{
+						type: "async"
+					},
+					{
+						type: "promise"
+					}
+				],
+				interceptors: []
+			},
+			"with args, no intercept": {
+				args: ["a", "b", "c"],
+				taps: [
+					{
+						type: "sync"
+					},
+					{
+						type: "async"
+					},
+					{
+						type: "promise"
+					}
+				],
+				interceptors: []
+			},
+			"with args, with intercept": {
+				args: ["a", "b", "c"],
+				taps: [
+					{
+						type: "sync"
+					},
+					{
+						type: "async"
+					},
+					{
+						type: "promise"
+					}
+				],
+				interceptors: [
+					{
+						call: () => {},
+						tap: () => {}
+					},
+					{
+						tap: () => {}
+					},
+					{
+						call: () => {}
+					}
+				]
+			}
+		};
+		for (const configurationName in factoryConfigurations) {
+			describe(`(${configurationName})`, () => {
+				let factory;
+				beforeEach(() => {
+					factory = new HookCodeFactory();
+					factory.init(factoryConfigurations[configurationName]);
+				});
+				it("sync without onResult", () => {
+					const code = factory.callTap(0, {
+						onError: err => `onError(${err});\n`,
+						onDone: () => "onDone();\n"
+					});
+					expect(code).toMatchSnapshot();
+					expectNoSyntaxError(code);
+				});
+				it("sync with onResult", () => {
+					const code = factory.callTap(0, {
+						onError: err => `onError(${err});\n`,
+						onResult: result => `onResult(${result});\n`
+					});
+					expect(code).toMatchSnapshot();
+					expectNoSyntaxError(code);
+				});
+				it("async without onResult", () => {
+					const code = factory.callTap(1, {
+						onError: err => `onError(${err});\n`,
+						onDone: () => "onDone();\n"
+					});
+					expect(code).toMatchSnapshot();
+					expectNoSyntaxError(code);
+				});
+				it("async with onResult", () => {
+					const code = factory.callTap(1, {
+						onError: err => `onError(${err});\n`,
+						onResult: result => `onResult(${result});\n`
+					});
+					expect(code).toMatchSnapshot();
+					expectNoSyntaxError(code);
+				});
+				it("promise without onResult", () => {
+					const code = factory.callTap(2, {
+						onError: err => `onError(${err});\n`,
+						onDone: () => "onDone();\n"
+					});
+					expect(code).toMatchSnapshot();
+					expectNoSyntaxError(code);
+				});
+				it("promise with onResult", () => {
+					const code = factory.callTap(2, {
+						onError: err => `onError(${err});\n`,
+						onResult: result => `onResult(${result});\n`
+					});
+					expect(code).toMatchSnapshot();
+					expectNoSyntaxError(code);
+				});
+			});
+		}
+	});
+	describe("taps", () => {
+		const factoryConfigurations = {
+			none: {
+				args: ["a", "b", "c"],
+				taps: [],
+				interceptors: []
+			},
+			"single sync": {
+				args: ["a", "b", "c"],
+				taps: [
+					{
+						type: "sync"
+					}
+				],
+				interceptors: []
+			},
+			"multiple sync": {
+				args: ["a", "b", "c"],
+				taps: [
+					{
+						type: "sync"
+					},
+					{
+						type: "sync"
+					},
+					{
+						type: "sync"
+					}
+				],
+				interceptors: []
+			},
+			"single async": {
+				args: ["a", "b", "c"],
+				taps: [
+					{
+						type: "async"
+					}
+				],
+				interceptors: []
+			},
+			"single promise": {
+				args: ["a", "b", "c"],
+				taps: [
+					{
+						type: "promise"
+					}
+				],
+				interceptors: []
+			},
+			mixed: {
+				args: ["a", "b", "c"],
+				taps: [
+					{
+						type: "sync"
+					},
+					{
+						type: "async"
+					},
+					{
+						type: "promise"
+					}
+				],
+				interceptors: []
+			},
+			mixed2: {
+				args: ["a", "b", "c"],
+				taps: [
+					{
+						type: "async"
+					},
+					{
+						type: "promise"
+					},
+					{
+						type: "sync"
+					}
+				],
+				interceptors: []
+			}
+		};
+		for (const configurationName in factoryConfigurations) {
+			describe(`(${configurationName})`, () => {
+				let factory;
+				beforeEach(() => {
+					factory = new HookCodeFactory();
+					factory.init(factoryConfigurations[configurationName]);
+				});
+				it("callTapsSeries", () => {
+					const code = factory.callTapsSeries({
+						onError: (i, err) => `onError(${i}, ${err});\n`,
+						onResult: (i, result, next, doneBreak) =>
+							`onResult(${i}, ${result}, () => {\n${next()}}, () => {\n${doneBreak()}});\n`,
+						onDone: () => "onDone();\n",
+						rethrowIfPossible: true
+					});
+					expect(code).toMatchSnapshot();
+					expectNoSyntaxError(code);
+				});
+				it("callTapsParallel", () => {
+					const code = factory.callTapsParallel({
+						onError: (i, err) => `onError(${i}, ${err});\n`,
+						onResult: (i, result, done, doneBreak) =>
+							`onResult(${i}, ${result}, () => {\n${done()}}, () => {\n${doneBreak()}});\n`,
+						onDone: () => "onDone();\n",
+						rethrowIfPossible: true
+					});
+					expect(code).toMatchSnapshot();
+					expectNoSyntaxError(code);
+				});
+				it("callTapsLooping", () => {
+					const code = factory.callTapsLooping({
+						onError: (i, err) => `onError(${i}, ${err});\n`,
+						onDone: () => "onDone();\n",
+						rethrowIfPossible: true
+					});
+					expect(code).toMatchSnapshot();
+					expectNoSyntaxError(code);
+				});
+			});
+		}
+	});
+});
diff --git a/node_modules/tapable/lib/__tests__/HookTester.js b/node_modules/tapable/lib/__tests__/HookTester.js
new file mode 100644
index 00000000..ae5659f7
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/HookTester.js
@@ -0,0 +1,1203 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+require("babel-polyfill");
+
+describe("HookTester", () => {
+	it("should run", () => {});
+});
+
+process.on("unhandledRejection", err => console.error(err.stack));
+
+class HookTester {
+	constructor(hookCreator, sync) {
+		this.hookCreator = hookCreator;
+		this.sync = sync;
+	}
+
+	async run(syncOnly) {
+		const result = {
+			sync: {},
+			async: {},
+			intercept: {}
+		};
+
+		if (syncOnly) {
+			await this.runSync(result.sync, "call");
+		} else {
+			await this.runAsync(result.async, "callAsync");
+			await this.runAsync(result.async, "promise");
+
+			await this.runIntercept(result.intercept, "callAsync");
+			await this.runIntercept(result.intercept, "promise");
+		}
+
+		await this.runSync(result.sync, "callAsync");
+		await this.runSync(result.sync, "promise");
+
+		return result;
+	}
+
+	async runForLoop(syncOnly) {
+		const result = {
+			sync: {},
+			async: {}
+		};
+
+		if (syncOnly) {
+			await this.runForLoopSync(result.sync, "call");
+		} else {
+			await this.runForLoopAsync(result.async, "callAsync");
+			await this.runForLoopAsync(result.async, "promise");
+		}
+
+		await this.runForLoopSync(result.sync, "callAsync");
+		await this.runForLoopSync(result.sync, "promise");
+
+		return result;
+	}
+
+	async runForLoopAsync(result, method) {
+		{
+			const hook = this.createHook([], `${method}BrokenPromise`);
+			hook.tapPromise("promise", () => "this is not a promise");
+			result[`${method}BrokenPromise`] = await this.gainResult(cb =>
+				hook[method](cb)
+			);
+		}
+		{
+			const hook = this.createHook([], `${method}SinglePromise`);
+			hook.tapPromise("promise", () => {
+				result[`${method}SinglePromiseCalled`] =
+					(result[`${method}SinglePromiseCalled`] || 0) + 1;
+				if (result[`${method}SinglePromiseCalled`] < 42)
+					return Promise.resolve().then(() => true);
+				return Promise.resolve().then(() => {});
+			});
+			result[`${method}SinglePromise`] = await this.gainResult(cb =>
+				hook[method](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${method}MultiplePromise`);
+			hook.tapPromise("promise1", () => {
+				result[`${method}MultiplePromiseCalled1`] =
+					(result[`${method}MultiplePromiseCalled1`] || 0) + 1;
+				if (result[`${method}MultiplePromiseCalled1`] < 42)
+					return Promise.resolve().then(() => true);
+				return Promise.resolve().then(() => {});
+			});
+			hook.tapPromise("promise2", () => {
+				result[`${method}MultiplePromiseCalled2`] =
+					(result[`${method}MultiplePromiseCalled2`] || 0) + 1;
+				if (result[`${method}MultiplePromiseCalled2`] < 42)
+					return Promise.resolve().then(() => true);
+				return Promise.resolve().then(() => {});
+			});
+			result[`${method}MultiplePromise`] = await this.gainResult(cb =>
+				hook[method](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${method}SingleAsync`);
+			hook.tapAsync("async", callback => {
+				result[`${method}SingleAsyncCalled`] =
+					(result[`${method}SingleAsyncCalled`] || 0) + 1;
+				if (result[`${method}SingleAsyncCalled`] < 42)
+					return Promise.resolve().then(() => callback(null, true));
+				return Promise.resolve().then(() => callback());
+			});
+			result[`${method}SingleAsync`] = await this.gainResult(cb =>
+				hook[method](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${method}MultipleAsync`);
+			hook.tapAsync("async1", callback => {
+				result[`${method}MultipleAsyncCalled1`] =
+					(result[`${method}MultipleAsyncCalled1`] || 0) + 1;
+				if (result[`${method}MultipleAsyncCalled1`] < 42)
+					return Promise.resolve().then(() => callback(null, true));
+				return Promise.resolve().then(() => callback());
+			});
+			hook.tapAsync("async2", callback => {
+				result[`${method}MultipleAsyncCalled2`] =
+					(result[`${method}MultipleAsyncCalled2`] || 0) + 1;
+				if (result[`${method}MultipleAsyncCalled2`] < 42)
+					return Promise.resolve().then(() => callback(null, true));
+				return Promise.resolve().then(() => callback());
+			});
+			result[`${method}MultipleAsync`] = await this.gainResult(cb =>
+				hook[method](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${method}Mixed`);
+			hook.tapAsync("async1", callback => {
+				result[`${method}MixedCalled1`] =
+					(result[`${method}MixedCalled1`] || 0) + 1;
+				if (result[`${method}MixedCalled1`] < 42)
+					return Promise.resolve().then(() => callback(null, true));
+				return Promise.resolve().then(() => callback());
+			});
+			hook.tap("sync2", () => {
+				result[`${method}MixedCalled2`] =
+					(result[`${method}MixedCalled2`] || 0) + 1;
+				if (result[`${method}MixedCalled2`] < 42) return true;
+			});
+			hook.tapPromise("promise3", () => {
+				result[`${method}MixedCalled3`] =
+					(result[`${method}MixedCalled3`] || 0) + 1;
+				if (result[`${method}MixedCalled3`] < 42)
+					return Promise.resolve().then(() => true);
+				return Promise.resolve().then(() => {});
+			});
+			result[`${method}Mixed`] = await this.gainResult(cb => hook[method](cb));
+		}
+	}
+
+	async runForLoopSync(result, method) {
+		{
+			const hook = this.createHook([], `${method}None`);
+			result[`${method}None`] = await this.gainResult(cb => hook[method](cb));
+		}
+
+		{
+			const hook = this.createHook(["arg"], `${method}NoneWithArg`);
+			result[`${method}NoneWithArg`] = await this.gainResult(cb =>
+				hook[method](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${method}SingleSync`);
+			hook.tap("sync", () => {
+				result[`${method}SingleSyncCalled`] =
+					(result[`${method}SingleSyncCalled`] || 0) + 1;
+				if (result[`${method}SingleSyncCalled`] < 42) return true;
+			});
+			result[`${method}SingleSync`] = await this.gainResult(cb =>
+				hook[method](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${method}MultipleSync`);
+			hook.tap("sync1", () => {
+				result[`${method}MultipleSyncCalled1`] =
+					(result[`${method}MultipleSyncCalled1`] || 0) + 1;
+				if (result[`${method}MultipleSyncCalled1`] < 42) return true;
+			});
+			hook.tap("sync2", () => {
+				result[`${method}MultipleSyncCalled2`] =
+					(result[`${method}MultipleSyncCalled2`] || 0) + 1;
+				if (result[`${method}MultipleSyncCalled2`] < 42) return true;
+			});
+			result[`${method}MultipleSync`] = await this.gainResult(cb =>
+				hook[method](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${method}InterceptedSync`);
+			hook.tap("sync1", () => {
+				result[`${method}InterceptedSyncCalled1`] =
+					(result[`${method}InterceptedSyncCalled1`] || 0) + 1;
+				if (result[`${method}InterceptedSyncCalled1`] < 42) return true;
+			});
+			hook.tap("sync2", () => {
+				result[`${method}InterceptedSyncCalled2`] =
+					(result[`${method}InterceptedSyncCalled2`] || 0) + 1;
+				if (result[`${method}InterceptedSyncCalled2`] < 42) return true;
+			});
+			hook.intercept({
+				call: a =>
+					(result[`${method}InterceptedSyncCalledCall`] =
+						(result[`${method}InterceptedSyncCalledCall`] || 0) + 1),
+				loop: a =>
+					(result[`${method}InterceptedSyncCalledLoop`] =
+						(result[`${method}InterceptedSyncCalledLoop`] || 0) + 1),
+				tap: tap => {
+					result[`${method}InterceptedSyncCalledTap`] =
+						(result[`${method}InterceptedSyncCalledTap`] || 0) + 1;
+				}
+			});
+			result[`${method}InterceptedSync`] = await this.gainResult(cb =>
+				hook[method](cb)
+			);
+		}
+	}
+
+	async runSync(result, method) {
+		{
+			const hook = this.createHook([], `${method}None`);
+			result[`${method}None`] = await this.gainResult(cb => hook[method](cb));
+		}
+
+		{
+			const hook = this.createHook(["arg"], `${method}NoneWithArg`);
+			result[`${method}NoneWithArg`] = await this.gainResult(cb =>
+				hook[method](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${method}SingleSync`);
+			hook.tap("sync", () => {
+				result[`${method}SingleSyncCalled`] = true;
+				return 42;
+			});
+			result[`${method}SingleSync`] = await this.gainResult(cb =>
+				hook[method](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["myArg"], `${method}SingleSyncWithArg`);
+			hook.tap("sync", nr => {
+				result[`${method}SingleSyncWithArgCalled`] = nr;
+				return nr;
+			});
+			result[`${method}SingleSyncWithArg`] = await this.gainResult(cb =>
+				hook[method](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${method}MultipleSync`);
+			hook.tap("sync1", () => {
+				result[`${method}MultipleSyncCalled1`] = true;
+				return 42;
+			});
+			hook.tap("sync2", () => {
+				result[`${method}MultipleSyncCalled2`] = true;
+				return 43;
+			});
+			result[`${method}MultipleSync`] = await this.gainResult(cb =>
+				hook[method](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["a"], `${method}MultipleSyncWithArg`);
+			hook.tap("sync1", a => {
+				result[`${method}MultipleSyncWithArgCalled1`] = a;
+				return 42 + a;
+			});
+			hook.tap("sync2", a => {
+				result[`${method}MultipleSyncWithArgCalled2`] = a;
+				return 43 + a;
+			});
+			result[`${method}MultipleSyncWithArg`] = await this.gainResult(cb =>
+				hook[method](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["a"],
+				`${method}MultipleSyncWithArgNoReturn`
+			);
+			hook.tap("sync1", a => {
+				result[`${method}MultipleSyncWithArgNoReturnCalled1`] = a;
+			});
+			hook.tap("sync2", a => {
+				result[`${method}MultipleSyncWithArgNoReturnCalled2`] = a;
+			});
+			result[`${method}MultipleSyncWithArgNoReturn`] = await this.gainResult(
+				cb => hook[method](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["a"],
+				`${method}MultipleSyncWithArgFirstReturn`
+			);
+			hook.tap("sync1", a => {
+				result[`${method}MultipleSyncWithArgFirstReturnCalled1`] = a;
+				return 42 + a;
+			});
+			hook.tap("sync2", a => {
+				result[`${method}MultipleSyncWithArgFirstReturnCalled2`] = a;
+			});
+			result[`${method}MultipleSyncWithArgFirstReturn`] = await this.gainResult(
+				cb => hook[method](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["a"],
+				`${method}MultipleSyncWithArgLastReturn`
+			);
+			hook.tap("sync1", a => {
+				result[`${method}MultipleSyncWithArgLastReturnCalled1`] = a;
+			});
+			hook.tap("sync2", a => {
+				result[`${method}MultipleSyncWithArgLastReturnCalled2`] = a;
+				return 43 + a;
+			});
+			result[`${method}MultipleSyncWithArgLastReturn`] = await this.gainResult(
+				cb => hook[method](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["a", "b", "c"],
+				`${method}MultipleSyncWithArgs`
+			);
+			hook.tap("sync1", (a, b, c) => {
+				result[`${method}MultipleSyncWithArgsCalled1`] = [a, b, c];
+				return a + b + c;
+			});
+			hook.tap("sync2", (a, b, c) => {
+				result[`${method}MultipleSyncWithArgsCalled2`] = [a, b, c];
+				return a + b + c + 1;
+			});
+			result[`${method}MultipleSyncWithArgs`] = await this.gainResult(cb =>
+				hook[method](42, 43, 44, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${method}MultipleSyncError`);
+			hook.tap("sync1", () => {
+				result[`${method}MultipleSyncErrorCalled1`] = true;
+			});
+			hook.tap("sync2", () => {
+				result[`${method}MultipleSyncErrorCalled2`] = true;
+				throw new Error("Error in sync2");
+			});
+			hook.tap("sync3", () => {
+				result[`${method}MultipleSyncErrorCalled3`] = true;
+			});
+			result[`${method}MultipleSyncError`] = await this.gainResult(cb =>
+				hook[method](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["a", "b", "c"], `${method}Intercepted`);
+			hook.intercept({
+				call: (a, b, c) => {
+					result[`${method}InterceptedCall1`] = [a, b, c];
+				},
+				tap: tap => {
+					result[`${method}InterceptedTap1`] = Object.assign({}, tap, {
+						fn: tap.fn.length
+					});
+				}
+			});
+			hook.intercept({
+				call: (a, b, c) => {
+					result[`${method}InterceptedCall2`] = [a, b, c];
+				},
+				tap: tap => {
+					if (!result[`${method}InterceptedTap2`])
+						result[`${method}InterceptedTap2`] = Object.assign({}, tap, {
+							fn: tap.fn.length
+						});
+				}
+			});
+			hook.tap("sync1", (a, b, c) => a + b + c);
+			hook.tap("sync2", (a, b) => a + b + 1);
+			result[`${method}Intercepted`] = await this.gainResult(cb =>
+				hook[method](1, 2, 3, cb)
+			);
+		}
+	}
+
+	async runAsync(result, type) {
+		{
+			const hook = this.createHook([], `${type}None`);
+			result[`${type}None`] = await this.gainResult(cb => hook[type](cb));
+		}
+
+		{
+			const hook = this.createHook(["arg"], `${type}NoneWithArg`);
+			result[`${type}NoneWithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${type}SingleSync`);
+			hook.tap("sync", () => {
+				result[`${type}SingleSyncCalled1`] = true;
+				return 42;
+			});
+			result[`${type}SingleSync`] = await this.gainResult(cb => hook[type](cb));
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}SingleSyncWithArg`);
+			hook.tap("sync", arg => {
+				result[`${type}SingleSyncWithArgCalled1`] = arg;
+				return arg + 1;
+			});
+			result[`${type}SingleSyncWithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}SingleSyncWithArgNoReturn`);
+			hook.tap("sync", arg => {
+				result[`${type}SingleSyncWithArgNoReturnCalled1`] = arg;
+			});
+			result[`${type}SingleSyncWithArgNoReturn`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${type}MultipleSync`);
+			hook.tap("sync1", () => {
+				result[`${type}MultipleSyncCalled1`] = true;
+				return 42;
+			});
+			hook.tap("sync2", () => {
+				result[`${type}MultipleSyncCalled2`] = true;
+				return 43;
+			});
+			result[`${type}MultipleSync`] = await this.gainResult(cb =>
+				hook[type](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${type}MultipleSyncLastReturn`);
+			hook.tap("sync1", () => {
+				result[`${type}MultipleSyncLastReturnCalled1`] = true;
+			});
+			hook.tap("sync2", () => {
+				result[`${type}MultipleSyncLastReturnCalled2`] = true;
+				return 43;
+			});
+			result[`${type}MultipleSyncLastReturn`] = await this.gainResult(cb =>
+				hook[type](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${type}MultipleSyncNoReturn`);
+			hook.tap("sync1", () => {
+				result[`${type}MultipleSyncNoReturnCalled1`] = true;
+			});
+			hook.tap("sync2", () => {
+				result[`${type}MultipleSyncNoReturnCalled2`] = true;
+			});
+			result[`${type}MultipleSyncNoReturn`] = await this.gainResult(cb =>
+				hook[type](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["arg"], `${type}MultipleSyncWithArg`);
+			hook.tap("sync1", arg => {
+				result[`${type}MultipleSyncWithArgCalled1`] = arg;
+				return arg + 1;
+			});
+			hook.tap("sync2", arg => {
+				result[`${type}MultipleSyncWithArgCalled2`] = arg;
+				return arg + 2;
+			});
+			result[`${type}MultipleSyncWithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["arg"],
+				`${type}MultipleSyncWithArgNoReturn`
+			);
+			hook.tap("sync1", arg => {
+				result[`${type}MultipleSyncWithArgNoReturnCalled1`] = arg;
+			});
+			hook.tap("sync2", arg => {
+				result[`${type}MultipleSyncWithArgNoReturnCalled2`] = arg;
+			});
+			result[`${type}MultipleSyncWithArgNoReturn`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["arg"],
+				`${type}MultipleSyncWithArgLastReturn`
+			);
+			hook.tap("sync1", arg => {
+				result[`${type}MultipleSyncWithArgLastReturnCalled1`] = arg;
+			});
+			hook.tap("sync2", arg => {
+				result[`${type}MultipleSyncWithArgLastReturnCalled2`] = arg;
+				return arg + 2;
+			});
+			result[`${type}MultipleSyncWithArgLastReturn`] = await this.gainResult(
+				cb => hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["arg"],
+				`${type}MultipleSyncWithArgFirstReturn`
+			);
+			hook.tap("sync1", arg => {
+				result[`${type}MultipleSyncWithArgFirstReturnCalled1`] = arg;
+				return arg + 1;
+			});
+			hook.tap("sync2", arg => {
+				result[`${type}MultipleSyncWithArgFirstReturnCalled2`] = arg;
+			});
+			result[`${type}MultipleSyncWithArgFirstReturn`] = await this.gainResult(
+				cb => hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}SingleAsyncWithArg`);
+			hook.tapAsync("async", (arg, callback) => {
+				result[`${type}SingleAsyncWithArgCalled1`] = arg;
+				callback(null, arg);
+			});
+			result[`${type}SingleAsyncWithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}MultipleAsyncWithArg`);
+			hook.tapAsync("async1", (arg, callback) => {
+				result[`${type}MultipleAsyncWithArgCalled1`] = arg;
+				callback(null, arg + 1);
+			});
+			hook.tapAsync("async2", (arg, callback) => {
+				result[`${type}MultipleAsyncWithArgCalled2`] = arg;
+				callback(null, arg + 2);
+			});
+			result[`${type}MultipleAsyncWithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["x"],
+				`${type}MultipleAsyncWithArgNoReturn`
+			);
+			hook.tapAsync("async1", (arg, callback) => {
+				result[`${type}MultipleAsyncWithArgNoReturnCalled1`] = arg;
+				callback();
+			});
+			hook.tapAsync("async2", (arg, callback) => {
+				result[`${type}MultipleAsyncWithArgNoReturnCalled2`] = arg;
+				callback();
+			});
+			result[`${type}MultipleAsyncWithArgNoReturn`] = await this.gainResult(
+				cb => hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["x"],
+				`${type}MultipleAsyncWithArgFirstReturn`
+			);
+			hook.tapAsync("async1", (arg, callback) => {
+				result[`${type}MultipleAsyncWithArgFirstReturnCalled1`] = arg;
+				callback(null, arg + 1);
+			});
+			hook.tapAsync("async2", (arg, callback) => {
+				result[`${type}MultipleAsyncWithArgFirstReturnCalled2`] = arg;
+				callback();
+			});
+			result[`${type}MultipleAsyncWithArgFirstReturn`] = await this.gainResult(
+				cb => hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["x"],
+				`${type}MultipleAsyncWithArgLastReturn`
+			);
+			hook.tapAsync("async1", (arg, callback) => {
+				result[`${type}MultipleAsyncWithArgLastReturnCalled1`] = arg;
+				callback();
+			});
+			hook.tapAsync("async2", (arg, callback) => {
+				result[`${type}MultipleAsyncWithArgLastReturnCalled2`] = arg;
+				callback(null, arg + 2);
+			});
+			result[`${type}MultipleAsyncWithArgLastReturn`] = await this.gainResult(
+				cb => hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}SinglePromiseWithArg`);
+			hook.tapPromise("promise", arg => {
+				result[`${type}SinglePromiseWithArgCalled1`] = arg;
+				return Promise.resolve(arg + 1);
+			});
+			result[`${type}SinglePromiseWithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}MultiplePromiseWithArg`);
+			hook.tapPromise("promise1", arg => {
+				result[`${type}MultiplePromiseWithArgCalled1`] = arg;
+				return Promise.resolve(arg + 1);
+			});
+			hook.tapPromise("promise2", arg => {
+				result[`${type}MultiplePromiseWithArgCalled2`] = arg;
+				return Promise.resolve(arg + 2);
+			});
+			result[`${type}MultiplePromiseWithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["x"],
+				`${type}MultiplePromiseWithArgNoReturn`
+			);
+			hook.tapPromise("promise1", arg => {
+				result[`${type}MultiplePromiseWithArgNoReturnCalled1`] = arg;
+				return Promise.resolve();
+			});
+			hook.tapPromise("promise2", arg => {
+				result[`${type}MultiplePromiseWithArgNoReturnCalled2`] = arg;
+				return Promise.resolve();
+			});
+			result[`${type}MultiplePromiseWithArgNoReturn`] = await this.gainResult(
+				cb => hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["x"],
+				`${type}MultiplePromiseWithArgFirstReturn`
+			);
+			hook.tapPromise("promise1", arg => {
+				result[`${type}MultiplePromiseWithArgFirstReturnCalled1`] = arg;
+				return Promise.resolve(arg + 1);
+			});
+			hook.tapPromise("promise2", arg => {
+				result[`${type}MultiplePromiseWithArgFirstReturnCalled2`] = arg;
+				return Promise.resolve();
+			});
+			result[
+				`${type}MultiplePromiseWithArgFirstReturn`
+			] = await this.gainResult(cb => hook[type](42, cb));
+		}
+
+		{
+			const hook = this.createHook(
+				["x"],
+				`${type}MultiplePromiseWithArgLastReturn`
+			);
+			hook.tapPromise("promise1", arg => {
+				result[`${type}MultiplePromiseWithArgLastReturnCalled1`] = arg;
+				return Promise.resolve();
+			});
+			hook.tapPromise("promise2", arg => {
+				result[`${type}MultiplePromiseWithArgLastReturnCalled2`] = arg;
+				return Promise.resolve(arg + 2);
+			});
+			result[`${type}MultiplePromiseWithArgLastReturn`] = await this.gainResult(
+				cb => hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}MultipleMixed1WithArg`);
+			hook.tapAsync("async", (arg, callback) => {
+				result[`${type}MultipleMixed1WithArgCalled1`] = arg;
+				callback(null, arg + 1);
+			});
+			hook.tapPromise("promise", arg => {
+				result[`${type}MultipleMixed1WithArgCalled2`] = arg;
+				return Promise.resolve(arg + 2);
+			});
+			hook.tap("sync", arg => {
+				result[`${type}MultipleMixed1WithArgCalled3`] = arg;
+				return arg + 3;
+			});
+			result[`${type}MultipleMixed1WithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}MultipleMixed2WithArg`);
+			hook.tapAsync("async", (arg, callback) => {
+				result[`${type}MultipleMixed2WithArgCalled1`] = arg;
+				setTimeout(() => callback(null, arg + 1), 100);
+			});
+			hook.tapPromise("promise", arg => {
+				result[`${type}MultipleMixed2WithArgCalled2`] = arg;
+				return Promise.resolve(arg + 2);
+			});
+			result[`${type}MultipleMixed2WithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}MultipleMixed3WithArg`);
+			hook.tapAsync("async1", (arg, callback) => {
+				result[`${type}MultipleMixed3WithArgCalled1`] = arg;
+				callback(null, arg + 1);
+			});
+			hook.tapPromise("promise", arg => {
+				result[`${type}MultipleMixed3WithArgCalled2`] = arg;
+				return Promise.resolve(arg + 2);
+			});
+			hook.tapAsync("async2", (arg, callback) => {
+				result[`${type}MultipleMixed3WithArgCalled3`] = arg;
+				setTimeout(() => callback(null, arg + 3), 100);
+			});
+			result[`${type}MultipleMixed3WithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${type}MultipleSyncError`);
+			hook.tap("sync1", () => {
+				result[`${type}MultipleSyncErrorCalled1`] = true;
+			});
+			hook.tap("sync2", () => {
+				throw new Error("Error in sync2");
+			});
+			hook.tap("sync3", () => {
+				result[`${type}MultipleSyncErrorCalled3`] = true;
+			});
+			result[`${type}MultipleSyncError`] = await this.gainResult(cb =>
+				hook[type](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${type}MultipleAsyncError`);
+			hook.tapAsync("async1", callback => {
+				result[`${type}MultipleAsyncErrorCalled1`] = true;
+				callback();
+			});
+			hook.tapAsync("async2", callback => {
+				callback(new Error("Error in async2"));
+			});
+			hook.tapAsync("async3", callback => {
+				result[`${type}MultipleAsyncErrorCalled3`] = true;
+				callback();
+			});
+			result[`${type}MultipleAsyncError`] = await this.gainResult(cb =>
+				hook[type](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${type}MultipleAsyncLateError`);
+			hook.tapAsync("async1", callback => {
+				result[`${type}MultipleAsyncLateErrorCalled1`] = true;
+				callback();
+			});
+			hook.tapAsync("async2", callback => {
+				setTimeout(() => callback(new Error("Error in async2")), 100);
+			});
+			hook.tapAsync("async3", callback => {
+				result[`${type}MultipleAsyncLateErrorCalled3`] = true;
+				callback();
+			});
+			result[`${type}MultipleAsyncLateError`] = await this.gainResult(cb =>
+				hook[type](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				[],
+				`${type}MultipleAsyncLateErrorEarlyResult1`
+			);
+			hook.tapAsync("async1", callback => {
+				result[`${type}MultipleAsyncLateErrorEarlyResult1Called1`] = true;
+				callback();
+			});
+			hook.tapAsync("async2", callback => {
+				setTimeout(() => callback(new Error("Error in async2")), 100);
+			});
+			hook.tapAsync("async3", callback => {
+				result[`${type}MultipleAsyncLateErrorEarlyResult1Called3`] = true;
+				callback(null, 7);
+			});
+			result[
+				`${type}MultipleAsyncLateErrorEarlyResult1`
+			] = await this.gainResult(cb => hook[type](cb));
+		}
+
+		{
+			const hook = this.createHook(
+				[],
+				`${type}MultipleAsyncLateErrorEarlyResult2`
+			);
+			hook.tapAsync("async1", callback => {
+				result[`${type}MultipleAsyncLateErrorEarlyResult2Called1`] = true;
+				setTimeout(() => callback(null, 42), 200);
+			});
+			hook.tapAsync("async2", callback => {
+				setTimeout(() => callback(new Error("Error in async2")), 100);
+			});
+			hook.tapAsync("async3", callback => {
+				result[`${type}MultipleAsyncLateErrorEarlyResult2Called3`] = true;
+				callback(null, 7);
+			});
+			result[
+				`${type}MultipleAsyncLateErrorEarlyResult2`
+			] = await this.gainResult(cb => hook[type](cb));
+		}
+
+		{
+			const hook = this.createHook([], `${type}MultipleAsyncEarlyError`);
+			hook.tapAsync("async1", callback => {
+				result[`${type}MultipleAsyncEarlyErrorCalled1`] = true;
+				setTimeout(() => callback(), 100);
+			});
+			hook.tapAsync("async2", callback => {
+				callback(new Error("Error in async2"));
+			});
+			hook.tapAsync("async3", callback => {
+				result[`${type}MultipleAsyncEarlyErrorCalled3`] = true;
+				setTimeout(() => callback(), 100);
+			});
+			result[`${type}MultipleAsyncEarlyError`] = await this.gainResult(cb =>
+				hook[type](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${type}MultiplePromiseError`);
+			hook.tapPromise("promise1", () => {
+				result[`${type}MultiplePromiseErrorCalled1`] = true;
+				return Promise.resolve();
+			});
+			hook.tapPromise("promise2", () => {
+				return Promise.resolve().then(() => {
+					throw new Error("Error in async2");
+				});
+			});
+			hook.tapPromise("promise3", () => {
+				result[`${type}MultiplePromiseErrorCalled3`] = true;
+				return Promise.resolve();
+			});
+			result[`${type}MultiplePromiseError`] = await this.gainResult(cb =>
+				hook[type](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${type}MultiplePromiseLateError`);
+			hook.tapPromise("promise1", () => {
+				result[`${type}MultiplePromiseLateErrorCalled1`] = true;
+				return Promise.resolve();
+			});
+			hook.tapPromise("promise2", () => {
+				return new Promise((resolve, reject) => {
+					setTimeout(() => reject(new Error("Error in async2")), 100);
+				});
+			});
+			hook.tapPromise("promise3", () => {
+				result[`${type}MultiplePromiseLateErrorCalled3`] = true;
+				return Promise.resolve();
+			});
+			result[`${type}MultiplePromiseLateError`] = await this.gainResult(cb =>
+				hook[type](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${type}MultiplePromiseEarlyError`);
+			hook.tapPromise("promise1", () => {
+				result[`${type}MultiplePromiseEarlyErrorCalled1`] = true;
+				return new Promise(resolve => setTimeout(() => resolve(), 100));
+			});
+			hook.tapPromise("promise2", () => {
+				return Promise.resolve().then(() => {
+					throw new Error("Error in async2");
+				});
+			});
+			hook.tapPromise("promise3", () => {
+				result[`${type}MultiplePromiseEarlyErrorCalled3`] = true;
+				return new Promise(resolve => setTimeout(() => resolve(), 100));
+			});
+			result[`${type}MultiplePromiseEarlyError`] = await this.gainResult(cb =>
+				hook[type](cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}MultipleMixedError1WithArg`);
+			hook.tapAsync("async", (arg, callback) => {
+				result[`${type}MultipleMixedError1WithArgCalled1`] = arg;
+				callback(null, arg);
+			});
+			hook.tapPromise("promise", arg => {
+				result[`${type}MultipleMixedError1WithArgCalled2`] = arg;
+				return Promise.resolve(arg + 1);
+			});
+			hook.tap("sync", arg => {
+				result[`${type}MultipleMixedError1WithArgCalled3`] = arg;
+				throw new Error("Error in sync");
+			});
+			result[`${type}MultipleMixedError1WithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}MultipleMixedError2WithArg`);
+			hook.tapAsync("async", (arg, callback) => {
+				result[`${type}MultipleMixedError2WithArgCalled1`] = arg;
+				callback(null, arg);
+			});
+			hook.tapPromise("promise", arg => {
+				result[`${type}MultipleMixedError2WithArgCalled2`] = arg;
+				return Promise.resolve().then(() => {
+					throw new Error("Error in promise");
+				});
+			});
+			hook.tap("sync", arg => {
+				result[`${type}MultipleMixedError2WithArgCalled3`] = arg;
+				return arg + 2;
+			});
+			result[`${type}MultipleMixedError2WithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(["x"], `${type}MultipleMixedError3WithArg`);
+			hook.tapAsync("async", (arg, callback) => {
+				result[`${type}MultipleMixedError3WithArgCalled1`] = arg;
+				callback(new Error("Error in async"));
+			});
+			hook.tapPromise("promise", arg => {
+				result[`${type}MultipleMixedError3WithArgCalled2`] = arg;
+				return Promise.resolve(arg + 1);
+			});
+			hook.tap("sync", arg => {
+				result[`${type}MultipleMixedError3WithArgCalled3`] = arg;
+				return arg + 2;
+			});
+			result[`${type}MultipleMixedError3WithArg`] = await this.gainResult(cb =>
+				hook[type](42, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook([], `${type}MultipleMixedLateError`);
+			hook.tapAsync("async", callback => {
+				result[`${type}MultipleMixedLateErrorCalled1`] = true;
+				setTimeout(() => callback(new Error("Error in async")), 100);
+			});
+			hook.tapPromise("promise", () => {
+				result[`${type}MultipleMixedLateErrorCalled2`] = true;
+				return Promise.resolve(42);
+			});
+			hook.tap("sync", () => {
+				result[`${type}MultipleMixedLateErrorCalled3`] = true;
+				return 43;
+			});
+			result[`${type}MultipleMixedLateError`] = await this.gainResult(cb =>
+				hook[type](cb)
+			);
+		}
+	}
+
+	async runIntercept(result, type) {
+		{
+			const hook = this.createHook(["a", "b", "c"], `${type}Intercepted`);
+			hook.intercept({
+				call: (a, b, c) => {
+					result[`${type}InterceptedCall1`] = [a, b, c];
+				},
+				tap: tap => {
+					result[`${type}InterceptedTap1`] = Object.assign({}, tap, {
+						fn: tap.fn.length
+					});
+				}
+			});
+			hook.intercept({
+				call: (a, b, c) => {
+					result[`${type}InterceptedCall2`] = [a, b, c];
+				},
+				tap: tap => {
+					if (!result[`${type}InterceptedTap2`])
+						result[`${type}InterceptedTap2`] = Object.assign({}, tap, {
+							fn: tap.fn.length
+						});
+				}
+			});
+			hook.tap("sync", (a, b, c) => a + b + c);
+			hook.tapPromise("promise", (a, b) => Promise.resolve(a + b + 1));
+			result[`${type}Intercepted`] = await this.gainResult(cb =>
+				hook[type](1, 2, 3, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["a", "b", "c"],
+				`${type}ContextIntercepted`
+			);
+			hook.intercept({
+				call: (context, a, b, c) => {
+					context.number = 42;
+					result[`${type}ContextInterceptedCall1`] = [context, a, b, c];
+				},
+				loop: (context, a, b, c) => {
+					context.number2 = 88;
+					result[`${type}ContextInterceptedLoop1`] = [context, a, b, c];
+				},
+				tap: (context, tap) => {
+					result[`${type}ContextInterceptedTap1`] = context;
+				},
+				context: true
+			});
+			hook.intercept({
+				call: (a, b, c) => {
+					result[`${type}ContextInterceptedCall2`] = [a, b, c];
+				}
+			});
+			hook.tap(
+				{
+					name: "sync",
+					context: true
+				},
+				(context, a, b, c) => context.number + a + b + c
+			);
+			result[`${type}ContextIntercepted`] = await this.gainResult(cb =>
+				hook[type](1, 2, 3, cb)
+			);
+		}
+
+		{
+			const hook = this.createHook(
+				["a", "b", "c"],
+				`${type}UnusedContextIntercepted`
+			);
+			hook.intercept({
+				call: (context, a, b, c) => {
+					result[`${type}UnusedContextInterceptedCall1`] = [context, a, b, c];
+				},
+				tap: (context, tap) => {
+					result[`${type}UnusedContextInterceptedTap1`] = context;
+				},
+				context: true
+			});
+			hook.intercept({
+				call: (a, b, c) => {
+					result[`${type}UnusedContextInterceptedCall2`] = [a, b, c];
+				}
+			});
+			hook.tap("sync", (a, b, c) => a + b + c);
+			result[`${type}UnusedContextIntercepted`] = await this.gainResult(cb =>
+				hook[type](1, 2, 3, cb)
+			);
+		}
+	}
+
+	gainResult(fn) {
+		return Promise.race([
+			new Promise(resolve => {
+				try {
+					const ret = fn((err, result) => {
+						if (err) {
+							resolve({
+								type: "async",
+								error: err.message
+							});
+						} else {
+							resolve({
+								type: "async",
+								value: result
+							});
+						}
+					});
+					if (ret instanceof Promise) {
+						resolve(
+							ret.then(
+								res => ({
+									type: "promise",
+									value: res
+								}),
+								err => ({
+									type: "promise",
+									error: err.message
+								})
+							)
+						);
+					} else if (ret !== undefined) {
+						resolve({
+							type: "return",
+							value: ret
+						});
+					}
+				} catch (e) {
+					resolve({
+						error: e.message
+					});
+				}
+			}),
+			new Promise(resolve => {
+				setTimeout(
+					() =>
+						resolve({
+							type: "no result"
+						}),
+					1000
+				);
+			})
+		]);
+	}
+
+	createHook(args, name) {
+		try {
+			return this.hookCreator(args, name);
+		} catch (err) {
+			return {
+				tap: () => {},
+				tapPromise: () => {},
+				tapAsync: () => {},
+				intercept: () => {},
+				call: () => {
+					throw err;
+				},
+				callAsync: () => {
+					throw err;
+				},
+				promise: () => {
+					throw err;
+				}
+			};
+		}
+	}
+}
+
+module.exports = HookTester;
diff --git a/node_modules/tapable/lib/__tests__/MultiHook.js b/node_modules/tapable/lib/__tests__/MultiHook.js
new file mode 100644
index 00000000..e23f2e46
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/MultiHook.js
@@ -0,0 +1,76 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+require("babel-polyfill");
+
+const MultiHook = require("../MultiHook");
+
+describe("MultiHook", () => {
+	const redirectedMethods = ["tap", "tapAsync", "tapPromise"];
+	for (const name of redirectedMethods) {
+		it(`should redirect ${name}`, () => {
+			const calls = [];
+			const fakeHook = {
+				[name]: (options, fn) => {
+					calls.push({ options, fn });
+				}
+			};
+			new MultiHook([fakeHook, fakeHook])[name]("options", "fn");
+			expect(calls).toEqual([
+				{ options: "options", fn: "fn" },
+				{ options: "options", fn: "fn" }
+			]);
+		});
+	}
+	it("should redirect intercept", () => {
+		const calls = [];
+		const fakeHook = {
+			intercept: interceptor => {
+				calls.push(interceptor);
+			}
+		};
+		new MultiHook([fakeHook, fakeHook]).intercept("interceptor");
+		expect(calls).toEqual(["interceptor", "interceptor"]);
+	});
+	it("should redirect withOptions", () => {
+		const calls = [];
+		const fakeHook = {
+			withOptions: options => {
+				calls.push(options);
+				return {
+					tap: (options, fn) => {
+						calls.push({ options, fn });
+					}
+				};
+			}
+		};
+		const newHook = new MultiHook([fakeHook, fakeHook]).withOptions("options");
+		newHook.tap("options", "fn");
+		expect(calls).toEqual([
+			"options",
+			"options",
+			{ options: "options", fn: "fn" },
+			{ options: "options", fn: "fn" }
+		]);
+	});
+	it("should redirect isUsed", () => {
+		const calls = [];
+		const fakeHook1 = {
+			isUsed: () => {
+				return true;
+			}
+		};
+		const fakeHook2 = {
+			isUsed: () => {
+				return false;
+			}
+		};
+		expect(new MultiHook([fakeHook1, fakeHook1]).isUsed()).toEqual(true);
+		expect(new MultiHook([fakeHook1, fakeHook2]).isUsed()).toEqual(true);
+		expect(new MultiHook([fakeHook2, fakeHook1]).isUsed()).toEqual(true);
+		expect(new MultiHook([fakeHook2, fakeHook2]).isUsed()).toEqual(false);
+	});
+});
diff --git a/node_modules/tapable/lib/__tests__/SyncBailHook.js b/node_modules/tapable/lib/__tests__/SyncBailHook.js
new file mode 100644
index 00000000..420b0102
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/SyncBailHook.js
@@ -0,0 +1,73 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+require("babel-polyfill");
+
+const SyncBailHook = require("../SyncBailHook");
+
+describe("SyncBailHook", () => {
+	it("should allow to create sync bail hooks", async () => {
+		const h1 = new SyncBailHook(["a"]);
+		const h2 = new SyncBailHook(["a", "b"]);
+		const h3 = new SyncBailHook(["a"]);
+
+		let r = h1.call(1);
+		expect(r).toEqual(undefined);
+
+		h1.tap("A", a => undefined);
+		h2.tap("A", (a, b) => [a, b]);
+
+		expect(h1.call(1)).toEqual(undefined);
+		expect(await h1.promise(1)).toEqual(undefined);
+		expect(await pify(cb => h1.callAsync(1, cb))).toEqual(undefined);
+		expect(h2.call(1, 2)).toEqual([1, 2]);
+		expect(await h2.promise(1, 2)).toEqual([1, 2]);
+		expect(await pify(cb => h2.callAsync(1, 2, cb))).toEqual([1, 2]);
+
+		h1.tap("B", a => "ok" + a);
+		h2.tap("B", (a, b) => "wrong");
+
+		expect(h1.call(10)).toEqual("ok10");
+		expect(await h1.promise(10)).toEqual("ok10");
+		expect(await pify(cb => h1.callAsync(10, cb))).toEqual("ok10");
+		expect(h2.call(10, 20)).toEqual([10, 20]);
+		expect(await h2.promise(10, 20)).toEqual([10, 20]);
+		expect(await pify(cb => h2.callAsync(10, 20, cb))).toEqual([10, 20]);
+	});
+
+	it("should allow to intercept calls", () => {
+		const hook = new SyncBailHook(["x"]);
+
+		const mockCall = jest.fn();
+		const mockTap = jest.fn(x => x);
+
+		hook.intercept({
+			call: mockCall,
+			tap: mockTap
+		});
+
+		hook.call(5);
+
+		expect(mockCall).toHaveBeenLastCalledWith(5);
+		expect(mockTap).not.toHaveBeenCalled();
+
+		hook.tap("test", () => 10);
+
+		hook.call(7);
+
+		expect(mockCall).toHaveBeenLastCalledWith(7);
+		expect(mockTap).toHaveBeenCalled();
+	});
+});
+
+function pify(fn) {
+	return new Promise((resolve, reject) => {
+		fn((err, result) => {
+			if (err) reject(err);
+			else resolve(result);
+		});
+	});
+}
diff --git a/node_modules/tapable/lib/__tests__/SyncHook.js b/node_modules/tapable/lib/__tests__/SyncHook.js
new file mode 100644
index 00000000..99b2f2c8
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/SyncHook.js
@@ -0,0 +1,104 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+require("babel-polyfill");
+
+const SyncHook = require("../SyncHook");
+
+describe("SyncHook", () => {
+	it("should allow to create sync hooks", async () => {
+		const h0 = new SyncHook();
+		const h1 = new SyncHook(["test"]);
+		const h2 = new SyncHook(["test", "arg2"]);
+		const h3 = new SyncHook(["test", "arg2", "arg3"]);
+
+		h0.call();
+		await h0.promise();
+		await new Promise(resolve => h0.callAsync(resolve));
+
+		const mock0 = jest.fn();
+		h0.tap("A", mock0);
+
+		h0.call();
+
+		expect(mock0).toHaveBeenLastCalledWith();
+
+		const mock1 = jest.fn();
+		h0.tap("B", mock1);
+
+		h0.call();
+
+		expect(mock1).toHaveBeenLastCalledWith();
+
+		const mock2 = jest.fn();
+		const mock3 = jest.fn();
+		const mock4 = jest.fn();
+		const mock5 = jest.fn();
+
+		h1.tap("C", mock2);
+		h2.tap("D", mock3);
+		h3.tap("E", mock4);
+		h3.tap("F", mock5);
+
+		h1.call("1");
+		h2.call("1", 2);
+		h3.call("1", 2, 3);
+
+		expect(mock2).toHaveBeenLastCalledWith("1");
+		expect(mock3).toHaveBeenLastCalledWith("1", 2);
+		expect(mock4).toHaveBeenLastCalledWith("1", 2, 3);
+		expect(mock5).toHaveBeenLastCalledWith("1", 2, 3);
+
+		await new Promise(resolve => h1.callAsync("a", resolve));
+		await h2.promise("a", "b");
+		await new Promise(resolve => h3.callAsync("a", "b", "c", resolve));
+
+		expect(mock2).toHaveBeenLastCalledWith("a");
+		expect(mock3).toHaveBeenLastCalledWith("a", "b");
+		expect(mock4).toHaveBeenLastCalledWith("a", "b", "c");
+		expect(mock5).toHaveBeenLastCalledWith("a", "b", "c");
+
+		await h3.promise("x", "y");
+
+		expect(mock4).toHaveBeenLastCalledWith("x", "y", undefined);
+		expect(mock5).toHaveBeenLastCalledWith("x", "y", undefined);
+	});
+
+	it("should allow to intercept calls", () => {
+		const hook = new SyncHook(["arg1", "arg2"]);
+
+		const mockCall = jest.fn();
+		const mock0 = jest.fn();
+		const mockRegister = jest.fn(x => ({
+			name: "huh",
+			type: "sync",
+			fn: mock0
+		}));
+
+		const mock1 = jest.fn();
+		hook.tap("Test1", mock1);
+
+		hook.intercept({
+			call: mockCall,
+			register: mockRegister
+		});
+
+		const mock2 = jest.fn();
+		hook.tap("Test2", mock2);
+
+		hook.call(1, 2);
+
+		expect(mockCall).toHaveBeenLastCalledWith(1, 2);
+		expect(mockRegister).toHaveBeenLastCalledWith({
+			type: "sync",
+			name: "Test2",
+			fn: mock2
+		});
+		expect(mock1).not.toHaveBeenLastCalledWith(1, 2);
+		expect(mock2).not.toHaveBeenLastCalledWith(1, 2);
+		expect(mock0).toHaveBeenLastCalledWith(1, 2);
+	});
+});
diff --git a/node_modules/tapable/lib/__tests__/SyncHooks.js b/node_modules/tapable/lib/__tests__/SyncHooks.js
new file mode 100644
index 00000000..a5d04b4e
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/SyncHooks.js
@@ -0,0 +1,67 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const HookTester = require("./HookTester");
+const SyncHook = require("../SyncHook");
+const SyncBailHook = require("../SyncBailHook");
+const SyncWaterfallHook = require("../SyncWaterfallHook");
+const SyncLoopHook = require("../SyncLoopHook");
+
+describe("SyncHook", () => {
+	it(
+		"should have to correct behavior",
+		async () => {
+			const tester = new HookTester(args => new SyncHook(args));
+
+			const result = await tester.run(true);
+
+			expect(result).toMatchSnapshot();
+		},
+		15000
+	);
+});
+
+describe("SyncBailHook", () => {
+	it(
+		"should have to correct behavior",
+		async () => {
+			const tester = new HookTester(args => new SyncBailHook(args));
+
+			const result = await tester.run(true);
+
+			expect(result).toMatchSnapshot();
+		},
+		15000
+	);
+});
+
+describe("SyncWaterfallHook", () => {
+	it(
+		"should have to correct behavior",
+		async () => {
+			const tester = new HookTester(args => new SyncWaterfallHook(args));
+
+			const result = await tester.run(true);
+
+			expect(result).toMatchSnapshot();
+		},
+		15000
+	);
+});
+
+describe("SyncLoopHook", () => {
+	it(
+		"should have to correct behavior",
+		async () => {
+			const tester = new HookTester(args => new SyncLoopHook(args));
+
+			const result = await tester.runForLoop(true);
+
+			expect(result).toMatchSnapshot();
+		},
+		15000
+	);
+});
diff --git a/node_modules/tapable/lib/__tests__/Tapable.js b/node_modules/tapable/lib/__tests__/Tapable.js
new file mode 100644
index 00000000..65f61f9a
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/Tapable.js
@@ -0,0 +1,63 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Tapable = require("../Tapable");
+const SyncHook = require("../SyncHook");
+const HookMap = require("../HookMap");
+
+describe("Tapable", () => {
+	it("should use same name or camelCase hook by default", () => {
+		const t = new Tapable();
+		t.hooks = {
+			myHook: new SyncHook()
+		};
+		let called = 0;
+		t.plugin("my-hook", () => called++);
+		t.hooks.myHook.call();
+		t.plugin("myHook", () => (called += 10));
+		t.hooks.myHook.call();
+		expect(called).toEqual(12);
+	});
+
+	it("should throw on unknown hook", () => {
+		const t = new Tapable();
+		t.hooks = {
+			myHook: new SyncHook()
+		};
+		expect(() => {
+			t.plugin("some-hook", () => {});
+		}).toThrow(/some-hook/);
+		t.hooks.myHook.call();
+	});
+
+	it("should use custom mapping", () => {
+		const t = new Tapable();
+		t.hooks = {
+			myHook: new SyncHook(),
+			hookMap: new HookMap(name => new SyncHook())
+		};
+		let called = 0;
+		t._pluginCompat.tap("hookMap custom mapping", options => {
+			const match = /^hookMap (.+)$/.exec(options.name);
+			if (match) {
+				t.hooks.hookMap.tap(
+					match[1],
+					options.fn.name || "unnamed compat plugin",
+					options.fn
+				);
+				return true;
+			}
+		});
+		t.plugin("my-hook", () => called++);
+		t.plugin("hookMap test", () => (called += 10));
+		t.hooks.myHook.call();
+		expect(called).toEqual(1);
+		t.hooks.hookMap.for("test").call();
+		expect(called).toEqual(11);
+		t.hooks.hookMap.for("other").call();
+		expect(called).toEqual(11);
+	});
+});
diff --git a/node_modules/tapable/lib/__tests__/__snapshots__/AsyncParallelHooks.js.snap b/node_modules/tapable/lib/__tests__/__snapshots__/AsyncParallelHooks.js.snap
new file mode 100644
index 00000000..94a88b19
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/__snapshots__/AsyncParallelHooks.js.snap
@@ -0,0 +1,1469 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP

+

+exports[`AsyncParallelBailHook should have to correct behavior 1`] = `

+Object {

+  "async": Object {

+    "callAsyncMultipleAsyncEarlyError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultipleAsyncEarlyErrorCalled1": true,

+    "callAsyncMultipleAsyncError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultipleAsyncErrorCalled1": true,

+    "callAsyncMultipleAsyncLateError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultipleAsyncLateErrorCalled1": true,

+    "callAsyncMultipleAsyncLateErrorCalled3": true,

+    "callAsyncMultipleAsyncLateErrorEarlyResult1": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultipleAsyncLateErrorEarlyResult1Called1": true,

+    "callAsyncMultipleAsyncLateErrorEarlyResult1Called3": true,

+    "callAsyncMultipleAsyncLateErrorEarlyResult2": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncMultipleAsyncLateErrorEarlyResult2Called1": true,

+    "callAsyncMultipleAsyncLateErrorEarlyResult2Called3": true,

+    "callAsyncMultipleAsyncWithArg": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncMultipleAsyncWithArgCalled1": 42,

+    "callAsyncMultipleAsyncWithArgFirstReturn": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncMultipleAsyncWithArgFirstReturnCalled1": 42,

+    "callAsyncMultipleAsyncWithArgLastReturn": Object {

+      "type": "async",

+      "value": 44,

+    },

+    "callAsyncMultipleAsyncWithArgLastReturnCalled1": 42,

+    "callAsyncMultipleAsyncWithArgLastReturnCalled2": 42,

+    "callAsyncMultipleAsyncWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleAsyncWithArgNoReturnCalled1": 42,

+    "callAsyncMultipleAsyncWithArgNoReturnCalled2": 42,

+    "callAsyncMultipleMixed1WithArg": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncMultipleMixed1WithArgCalled1": 42,

+    "callAsyncMultipleMixed2WithArg": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncMultipleMixed2WithArgCalled1": 42,

+    "callAsyncMultipleMixed2WithArgCalled2": 42,

+    "callAsyncMultipleMixed3WithArg": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncMultipleMixed3WithArgCalled1": 42,

+    "callAsyncMultipleMixedError1WithArg": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncMultipleMixedError1WithArgCalled1": 42,

+    "callAsyncMultipleMixedError2WithArg": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncMultipleMixedError2WithArgCalled1": 42,

+    "callAsyncMultipleMixedError3WithArg": Object {

+      "error": "Error in async",

+      "type": "async",

+    },

+    "callAsyncMultipleMixedError3WithArgCalled1": 42,

+    "callAsyncMultipleMixedLateError": Object {

+      "error": "Error in async",

+      "type": "async",

+    },

+    "callAsyncMultipleMixedLateErrorCalled1": true,

+    "callAsyncMultipleMixedLateErrorCalled2": true,

+    "callAsyncMultipleMixedLateErrorCalled3": true,

+    "callAsyncMultiplePromiseEarlyError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultiplePromiseEarlyErrorCalled1": true,

+    "callAsyncMultiplePromiseEarlyErrorCalled3": true,

+    "callAsyncMultiplePromiseError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultiplePromiseErrorCalled1": true,

+    "callAsyncMultiplePromiseErrorCalled3": true,

+    "callAsyncMultiplePromiseLateError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultiplePromiseLateErrorCalled1": true,

+    "callAsyncMultiplePromiseLateErrorCalled3": true,

+    "callAsyncMultiplePromiseWithArg": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncMultiplePromiseWithArgCalled1": 42,

+    "callAsyncMultiplePromiseWithArgCalled2": 42,

+    "callAsyncMultiplePromiseWithArgFirstReturn": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncMultiplePromiseWithArgFirstReturnCalled1": 42,

+    "callAsyncMultiplePromiseWithArgFirstReturnCalled2": 42,

+    "callAsyncMultiplePromiseWithArgLastReturn": Object {

+      "type": "async",

+      "value": 44,

+    },

+    "callAsyncMultiplePromiseWithArgLastReturnCalled1": 42,

+    "callAsyncMultiplePromiseWithArgLastReturnCalled2": 42,

+    "callAsyncMultiplePromiseWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultiplePromiseWithArgNoReturnCalled1": 42,

+    "callAsyncMultiplePromiseWithArgNoReturnCalled2": 42,

+    "callAsyncMultipleSync": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncMultipleSyncCalled1": true,

+    "callAsyncMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "async",

+    },

+    "callAsyncMultipleSyncErrorCalled1": true,

+    "callAsyncMultipleSyncLastReturn": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncMultipleSyncLastReturnCalled1": true,

+    "callAsyncMultipleSyncLastReturnCalled2": true,

+    "callAsyncMultipleSyncNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncNoReturnCalled1": true,

+    "callAsyncMultipleSyncNoReturnCalled2": true,

+    "callAsyncMultipleSyncWithArg": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncMultipleSyncWithArgCalled1": 42,

+    "callAsyncMultipleSyncWithArgFirstReturn": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgLastReturn": Object {

+      "type": "async",

+      "value": 44,

+    },

+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,

+    "callAsyncNone": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncNoneWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleAsyncWithArg": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncSingleAsyncWithArgCalled1": 42,

+    "callAsyncSinglePromiseWithArg": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncSinglePromiseWithArgCalled1": 42,

+    "callAsyncSingleSync": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncSingleSyncCalled1": true,

+    "callAsyncSingleSyncWithArg": Object {

+      "type": "async",

+      "value": 43,

+    },

+    "callAsyncSingleSyncWithArgCalled1": 42,

+    "callAsyncSingleSyncWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSyncWithArgNoReturnCalled1": 42,

+    "promiseMultipleAsyncEarlyError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultipleAsyncEarlyErrorCalled1": true,

+    "promiseMultipleAsyncError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultipleAsyncErrorCalled1": true,

+    "promiseMultipleAsyncLateError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultipleAsyncLateErrorCalled1": true,

+    "promiseMultipleAsyncLateErrorCalled3": true,

+    "promiseMultipleAsyncLateErrorEarlyResult1": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultipleAsyncLateErrorEarlyResult1Called1": true,

+    "promiseMultipleAsyncLateErrorEarlyResult1Called3": true,

+    "promiseMultipleAsyncLateErrorEarlyResult2": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseMultipleAsyncLateErrorEarlyResult2Called1": true,

+    "promiseMultipleAsyncLateErrorEarlyResult2Called3": true,

+    "promiseMultipleAsyncWithArg": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseMultipleAsyncWithArgCalled1": 42,

+    "promiseMultipleAsyncWithArgFirstReturn": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseMultipleAsyncWithArgFirstReturnCalled1": 42,

+    "promiseMultipleAsyncWithArgLastReturn": Object {

+      "type": "promise",

+      "value": 44,

+    },

+    "promiseMultipleAsyncWithArgLastReturnCalled1": 42,

+    "promiseMultipleAsyncWithArgLastReturnCalled2": 42,

+    "promiseMultipleAsyncWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleAsyncWithArgNoReturnCalled1": 42,

+    "promiseMultipleAsyncWithArgNoReturnCalled2": 42,

+    "promiseMultipleMixed1WithArg": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseMultipleMixed1WithArgCalled1": 42,

+    "promiseMultipleMixed2WithArg": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseMultipleMixed2WithArgCalled1": 42,

+    "promiseMultipleMixed2WithArgCalled2": 42,

+    "promiseMultipleMixed3WithArg": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseMultipleMixed3WithArgCalled1": 42,

+    "promiseMultipleMixedError1WithArg": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseMultipleMixedError1WithArgCalled1": 42,

+    "promiseMultipleMixedError2WithArg": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseMultipleMixedError2WithArgCalled1": 42,

+    "promiseMultipleMixedError3WithArg": Object {

+      "error": "Error in async",

+      "type": "promise",

+    },

+    "promiseMultipleMixedError3WithArgCalled1": 42,

+    "promiseMultipleMixedLateError": Object {

+      "error": "Error in async",

+      "type": "promise",

+    },

+    "promiseMultipleMixedLateErrorCalled1": true,

+    "promiseMultipleMixedLateErrorCalled2": true,

+    "promiseMultipleMixedLateErrorCalled3": true,

+    "promiseMultiplePromiseEarlyError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultiplePromiseEarlyErrorCalled1": true,

+    "promiseMultiplePromiseEarlyErrorCalled3": true,

+    "promiseMultiplePromiseError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultiplePromiseErrorCalled1": true,

+    "promiseMultiplePromiseErrorCalled3": true,

+    "promiseMultiplePromiseLateError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultiplePromiseLateErrorCalled1": true,

+    "promiseMultiplePromiseLateErrorCalled3": true,

+    "promiseMultiplePromiseWithArg": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseMultiplePromiseWithArgCalled1": 42,

+    "promiseMultiplePromiseWithArgCalled2": 42,

+    "promiseMultiplePromiseWithArgFirstReturn": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseMultiplePromiseWithArgFirstReturnCalled1": 42,

+    "promiseMultiplePromiseWithArgFirstReturnCalled2": 42,

+    "promiseMultiplePromiseWithArgLastReturn": Object {

+      "type": "promise",

+      "value": 44,

+    },

+    "promiseMultiplePromiseWithArgLastReturnCalled1": 42,

+    "promiseMultiplePromiseWithArgLastReturnCalled2": 42,

+    "promiseMultiplePromiseWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultiplePromiseWithArgNoReturnCalled1": 42,

+    "promiseMultiplePromiseWithArgNoReturnCalled2": 42,

+    "promiseMultipleSync": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseMultipleSyncCalled1": true,

+    "promiseMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "promise",

+    },

+    "promiseMultipleSyncErrorCalled1": true,

+    "promiseMultipleSyncLastReturn": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseMultipleSyncLastReturnCalled1": true,

+    "promiseMultipleSyncLastReturnCalled2": true,

+    "promiseMultipleSyncNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncNoReturnCalled1": true,

+    "promiseMultipleSyncNoReturnCalled2": true,

+    "promiseMultipleSyncWithArg": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseMultipleSyncWithArgCalled1": 42,

+    "promiseMultipleSyncWithArgFirstReturn": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,

+    "promiseMultipleSyncWithArgLastReturn": Object {

+      "type": "promise",

+      "value": 44,

+    },

+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,

+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,

+    "promiseMultipleSyncWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,

+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,

+    "promiseNone": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseNoneWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleAsyncWithArg": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseSingleAsyncWithArgCalled1": 42,

+    "promiseSinglePromiseWithArg": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseSinglePromiseWithArgCalled1": 42,

+    "promiseSingleSync": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseSingleSyncCalled1": true,

+    "promiseSingleSyncWithArg": Object {

+      "type": "promise",

+      "value": 43,

+    },

+    "promiseSingleSyncWithArgCalled1": 42,

+    "promiseSingleSyncWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSyncWithArgNoReturnCalled1": 42,

+  },

+  "intercept": Object {

+    "callAsyncContextIntercepted": Object {

+      "type": "async",

+      "value": 48,

+    },

+    "callAsyncContextInterceptedCall1": Array [

+      Object {

+        "number": 42,

+      },

+      1,

+      2,

+      3,

+    ],

+    "callAsyncContextInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncContextInterceptedTap1": Object {

+      "number": 42,

+    },

+    "callAsyncIntercepted": Object {

+      "type": "async",

+      "value": 6,

+    },

+    "callAsyncInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedTap1": Object {

+      "fn": 3,

+      "name": "sync",

+      "type": "sync",

+    },

+    "callAsyncInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync",

+      "type": "sync",

+    },

+    "callAsyncUnusedContextIntercepted": Object {

+      "type": "async",

+      "value": 6,

+    },

+    "callAsyncUnusedContextInterceptedCall1": Array [

+      undefined,

+      1,

+      2,

+      3,

+    ],

+    "callAsyncUnusedContextInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncUnusedContextInterceptedTap1": undefined,

+    "promiseContextIntercepted": Object {

+      "type": "promise",

+      "value": 48,

+    },

+    "promiseContextInterceptedCall1": Array [

+      Object {

+        "number": 42,

+      },

+      1,

+      2,

+      3,

+    ],

+    "promiseContextInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseContextInterceptedTap1": Object {

+      "number": 42,

+    },

+    "promiseIntercepted": Object {

+      "type": "promise",

+      "value": 6,

+    },

+    "promiseInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedTap1": Object {

+      "fn": 3,

+      "name": "sync",

+      "type": "sync",

+    },

+    "promiseInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync",

+      "type": "sync",

+    },

+    "promiseUnusedContextIntercepted": Object {

+      "type": "promise",

+      "value": 6,

+    },

+    "promiseUnusedContextInterceptedCall1": Array [

+      undefined,

+      1,

+      2,

+      3,

+    ],

+    "promiseUnusedContextInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseUnusedContextInterceptedTap1": undefined,

+  },

+  "sync": Object {

+    "callAsyncIntercepted": Object {

+      "type": "async",

+      "value": 6,

+    },

+    "callAsyncInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedTap1": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "callAsyncInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "callAsyncMultipleSync": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncMultipleSyncCalled1": true,

+    "callAsyncMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "async",

+    },

+    "callAsyncMultipleSyncErrorCalled1": true,

+    "callAsyncMultipleSyncErrorCalled2": true,

+    "callAsyncMultipleSyncWithArg": Object {

+      "type": "async",

+      "value": 84,

+    },

+    "callAsyncMultipleSyncWithArgCalled1": 42,

+    "callAsyncMultipleSyncWithArgFirstReturn": Object {

+      "type": "async",

+      "value": 84,

+    },

+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgLastReturn": Object {

+      "type": "async",

+      "value": 85,

+    },

+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgs": Object {

+      "type": "async",

+      "value": 129,

+    },

+    "callAsyncMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "callAsyncNone": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncNoneWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSync": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncSingleSyncCalled": true,

+    "callAsyncSingleSyncWithArg": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncSingleSyncWithArgCalled": 42,

+    "promiseIntercepted": Object {

+      "type": "promise",

+      "value": 6,

+    },

+    "promiseInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedTap1": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "promiseInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "promiseMultipleSync": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseMultipleSyncCalled1": true,

+    "promiseMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "promise",

+    },

+    "promiseMultipleSyncErrorCalled1": true,

+    "promiseMultipleSyncErrorCalled2": true,

+    "promiseMultipleSyncWithArg": Object {

+      "type": "promise",

+      "value": 84,

+    },

+    "promiseMultipleSyncWithArgCalled1": 42,

+    "promiseMultipleSyncWithArgFirstReturn": Object {

+      "type": "promise",

+      "value": 84,

+    },

+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,

+    "promiseMultipleSyncWithArgLastReturn": Object {

+      "type": "promise",

+      "value": 85,

+    },

+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,

+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,

+    "promiseMultipleSyncWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,

+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,

+    "promiseMultipleSyncWithArgs": Object {

+      "type": "promise",

+      "value": 129,

+    },

+    "promiseMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "promiseNone": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseNoneWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSync": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseSingleSyncCalled": true,

+    "promiseSingleSyncWithArg": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseSingleSyncWithArgCalled": 42,

+  },

+}

+`;

+

+exports[`AsyncParallelHook should have to correct behavior 1`] = `

+Object {

+  "async": Object {

+    "callAsyncMultipleAsyncEarlyError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultipleAsyncEarlyErrorCalled1": true,

+    "callAsyncMultipleAsyncError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultipleAsyncErrorCalled1": true,

+    "callAsyncMultipleAsyncLateError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultipleAsyncLateErrorCalled1": true,

+    "callAsyncMultipleAsyncLateErrorCalled3": true,

+    "callAsyncMultipleAsyncLateErrorEarlyResult1": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultipleAsyncLateErrorEarlyResult1Called1": true,

+    "callAsyncMultipleAsyncLateErrorEarlyResult1Called3": true,

+    "callAsyncMultipleAsyncLateErrorEarlyResult2": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultipleAsyncLateErrorEarlyResult2Called1": true,

+    "callAsyncMultipleAsyncLateErrorEarlyResult2Called3": true,

+    "callAsyncMultipleAsyncWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleAsyncWithArgCalled1": 42,

+    "callAsyncMultipleAsyncWithArgCalled2": 42,

+    "callAsyncMultipleAsyncWithArgFirstReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleAsyncWithArgFirstReturnCalled1": 42,

+    "callAsyncMultipleAsyncWithArgFirstReturnCalled2": 42,

+    "callAsyncMultipleAsyncWithArgLastReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleAsyncWithArgLastReturnCalled1": 42,

+    "callAsyncMultipleAsyncWithArgLastReturnCalled2": 42,

+    "callAsyncMultipleAsyncWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleAsyncWithArgNoReturnCalled1": 42,

+    "callAsyncMultipleAsyncWithArgNoReturnCalled2": 42,

+    "callAsyncMultipleMixed1WithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleMixed1WithArgCalled1": 42,

+    "callAsyncMultipleMixed1WithArgCalled2": 42,

+    "callAsyncMultipleMixed1WithArgCalled3": 42,

+    "callAsyncMultipleMixed2WithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleMixed2WithArgCalled1": 42,

+    "callAsyncMultipleMixed2WithArgCalled2": 42,

+    "callAsyncMultipleMixed3WithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleMixed3WithArgCalled1": 42,

+    "callAsyncMultipleMixed3WithArgCalled2": 42,

+    "callAsyncMultipleMixed3WithArgCalled3": 42,

+    "callAsyncMultipleMixedError1WithArg": Object {

+      "error": "Error in sync",

+      "type": "async",

+    },

+    "callAsyncMultipleMixedError1WithArgCalled1": 42,

+    "callAsyncMultipleMixedError1WithArgCalled2": 42,

+    "callAsyncMultipleMixedError1WithArgCalled3": 42,

+    "callAsyncMultipleMixedError2WithArg": Object {

+      "error": "Error in promise",

+      "type": "async",

+    },

+    "callAsyncMultipleMixedError2WithArgCalled1": 42,

+    "callAsyncMultipleMixedError2WithArgCalled2": 42,

+    "callAsyncMultipleMixedError2WithArgCalled3": 42,

+    "callAsyncMultipleMixedError3WithArg": Object {

+      "error": "Error in async",

+      "type": "async",

+    },

+    "callAsyncMultipleMixedError3WithArgCalled1": 42,

+    "callAsyncMultipleMixedLateError": Object {

+      "error": "Error in async",

+      "type": "async",

+    },

+    "callAsyncMultipleMixedLateErrorCalled1": true,

+    "callAsyncMultipleMixedLateErrorCalled2": true,

+    "callAsyncMultipleMixedLateErrorCalled3": true,

+    "callAsyncMultiplePromiseEarlyError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultiplePromiseEarlyErrorCalled1": true,

+    "callAsyncMultiplePromiseEarlyErrorCalled3": true,

+    "callAsyncMultiplePromiseError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultiplePromiseErrorCalled1": true,

+    "callAsyncMultiplePromiseErrorCalled3": true,

+    "callAsyncMultiplePromiseLateError": Object {

+      "error": "Error in async2",

+      "type": "async",

+    },

+    "callAsyncMultiplePromiseLateErrorCalled1": true,

+    "callAsyncMultiplePromiseLateErrorCalled3": true,

+    "callAsyncMultiplePromiseWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultiplePromiseWithArgCalled1": 42,

+    "callAsyncMultiplePromiseWithArgCalled2": 42,

+    "callAsyncMultiplePromiseWithArgFirstReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultiplePromiseWithArgFirstReturnCalled1": 42,

+    "callAsyncMultiplePromiseWithArgFirstReturnCalled2": 42,

+    "callAsyncMultiplePromiseWithArgLastReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultiplePromiseWithArgLastReturnCalled1": 42,

+    "callAsyncMultiplePromiseWithArgLastReturnCalled2": 42,

+    "callAsyncMultiplePromiseWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultiplePromiseWithArgNoReturnCalled1": 42,

+    "callAsyncMultiplePromiseWithArgNoReturnCalled2": 42,

+    "callAsyncMultipleSync": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncCalled1": true,

+    "callAsyncMultipleSyncCalled2": true,

+    "callAsyncMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "async",

+    },

+    "callAsyncMultipleSyncErrorCalled1": true,

+    "callAsyncMultipleSyncLastReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncLastReturnCalled1": true,

+    "callAsyncMultipleSyncLastReturnCalled2": true,

+    "callAsyncMultipleSyncNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncNoReturnCalled1": true,

+    "callAsyncMultipleSyncNoReturnCalled2": true,

+    "callAsyncMultipleSyncWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgCalled1": 42,

+    "callAsyncMultipleSyncWithArgCalled2": 42,

+    "callAsyncMultipleSyncWithArgFirstReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgFirstReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgLastReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,

+    "callAsyncNone": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncNoneWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleAsyncWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleAsyncWithArgCalled1": 42,

+    "callAsyncSinglePromiseWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSinglePromiseWithArgCalled1": 42,

+    "callAsyncSingleSync": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSyncCalled1": true,

+    "callAsyncSingleSyncWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSyncWithArgCalled1": 42,

+    "callAsyncSingleSyncWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSyncWithArgNoReturnCalled1": 42,

+    "promiseMultipleAsyncEarlyError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultipleAsyncEarlyErrorCalled1": true,

+    "promiseMultipleAsyncError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultipleAsyncErrorCalled1": true,

+    "promiseMultipleAsyncLateError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultipleAsyncLateErrorCalled1": true,

+    "promiseMultipleAsyncLateErrorCalled3": true,

+    "promiseMultipleAsyncLateErrorEarlyResult1": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultipleAsyncLateErrorEarlyResult1Called1": true,

+    "promiseMultipleAsyncLateErrorEarlyResult1Called3": true,

+    "promiseMultipleAsyncLateErrorEarlyResult2": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultipleAsyncLateErrorEarlyResult2Called1": true,

+    "promiseMultipleAsyncLateErrorEarlyResult2Called3": true,

+    "promiseMultipleAsyncWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleAsyncWithArgCalled1": 42,

+    "promiseMultipleAsyncWithArgCalled2": 42,

+    "promiseMultipleAsyncWithArgFirstReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleAsyncWithArgFirstReturnCalled1": 42,

+    "promiseMultipleAsyncWithArgFirstReturnCalled2": 42,

+    "promiseMultipleAsyncWithArgLastReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleAsyncWithArgLastReturnCalled1": 42,

+    "promiseMultipleAsyncWithArgLastReturnCalled2": 42,

+    "promiseMultipleAsyncWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleAsyncWithArgNoReturnCalled1": 42,

+    "promiseMultipleAsyncWithArgNoReturnCalled2": 42,

+    "promiseMultipleMixed1WithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleMixed1WithArgCalled1": 42,

+    "promiseMultipleMixed1WithArgCalled2": 42,

+    "promiseMultipleMixed1WithArgCalled3": 42,

+    "promiseMultipleMixed2WithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleMixed2WithArgCalled1": 42,

+    "promiseMultipleMixed2WithArgCalled2": 42,

+    "promiseMultipleMixed3WithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleMixed3WithArgCalled1": 42,

+    "promiseMultipleMixed3WithArgCalled2": 42,

+    "promiseMultipleMixed3WithArgCalled3": 42,

+    "promiseMultipleMixedError1WithArg": Object {

+      "error": "Error in sync",

+      "type": "promise",

+    },

+    "promiseMultipleMixedError1WithArgCalled1": 42,

+    "promiseMultipleMixedError1WithArgCalled2": 42,

+    "promiseMultipleMixedError1WithArgCalled3": 42,

+    "promiseMultipleMixedError2WithArg": Object {

+      "error": "Error in promise",

+      "type": "promise",

+    },

+    "promiseMultipleMixedError2WithArgCalled1": 42,

+    "promiseMultipleMixedError2WithArgCalled2": 42,

+    "promiseMultipleMixedError2WithArgCalled3": 42,

+    "promiseMultipleMixedError3WithArg": Object {

+      "error": "Error in async",

+      "type": "promise",

+    },

+    "promiseMultipleMixedError3WithArgCalled1": 42,

+    "promiseMultipleMixedLateError": Object {

+      "error": "Error in async",

+      "type": "promise",

+    },

+    "promiseMultipleMixedLateErrorCalled1": true,

+    "promiseMultipleMixedLateErrorCalled2": true,

+    "promiseMultipleMixedLateErrorCalled3": true,

+    "promiseMultiplePromiseEarlyError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultiplePromiseEarlyErrorCalled1": true,

+    "promiseMultiplePromiseEarlyErrorCalled3": true,

+    "promiseMultiplePromiseError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultiplePromiseErrorCalled1": true,

+    "promiseMultiplePromiseErrorCalled3": true,

+    "promiseMultiplePromiseLateError": Object {

+      "error": "Error in async2",

+      "type": "promise",

+    },

+    "promiseMultiplePromiseLateErrorCalled1": true,

+    "promiseMultiplePromiseLateErrorCalled3": true,

+    "promiseMultiplePromiseWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultiplePromiseWithArgCalled1": 42,

+    "promiseMultiplePromiseWithArgCalled2": 42,

+    "promiseMultiplePromiseWithArgFirstReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultiplePromiseWithArgFirstReturnCalled1": 42,

+    "promiseMultiplePromiseWithArgFirstReturnCalled2": 42,

+    "promiseMultiplePromiseWithArgLastReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultiplePromiseWithArgLastReturnCalled1": 42,

+    "promiseMultiplePromiseWithArgLastReturnCalled2": 42,

+    "promiseMultiplePromiseWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultiplePromiseWithArgNoReturnCalled1": 42,

+    "promiseMultiplePromiseWithArgNoReturnCalled2": 42,

+    "promiseMultipleSync": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncCalled1": true,

+    "promiseMultipleSyncCalled2": true,

+    "promiseMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "promise",

+    },

+    "promiseMultipleSyncErrorCalled1": true,

+    "promiseMultipleSyncLastReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncLastReturnCalled1": true,

+    "promiseMultipleSyncLastReturnCalled2": true,

+    "promiseMultipleSyncNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncNoReturnCalled1": true,

+    "promiseMultipleSyncNoReturnCalled2": true,

+    "promiseMultipleSyncWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgCalled1": 42,

+    "promiseMultipleSyncWithArgCalled2": 42,

+    "promiseMultipleSyncWithArgFirstReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,

+    "promiseMultipleSyncWithArgFirstReturnCalled2": 42,

+    "promiseMultipleSyncWithArgLastReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,

+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,

+    "promiseMultipleSyncWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,

+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,

+    "promiseNone": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseNoneWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleAsyncWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleAsyncWithArgCalled1": 42,

+    "promiseSinglePromiseWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSinglePromiseWithArgCalled1": 42,

+    "promiseSingleSync": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSyncCalled1": true,

+    "promiseSingleSyncWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSyncWithArgCalled1": 42,

+    "promiseSingleSyncWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSyncWithArgNoReturnCalled1": 42,

+  },

+  "intercept": Object {

+    "callAsyncContextIntercepted": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncContextInterceptedCall1": Array [

+      Object {

+        "number": 42,

+      },

+      1,

+      2,

+      3,

+    ],

+    "callAsyncContextInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncContextInterceptedTap1": Object {

+      "number": 42,

+    },

+    "callAsyncIntercepted": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedTap1": Object {

+      "fn": 2,

+      "name": "promise",

+      "type": "promise",

+    },

+    "callAsyncInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync",

+      "type": "sync",

+    },

+    "callAsyncUnusedContextIntercepted": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncUnusedContextInterceptedCall1": Array [

+      undefined,

+      1,

+      2,

+      3,

+    ],

+    "callAsyncUnusedContextInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncUnusedContextInterceptedTap1": undefined,

+    "promiseContextIntercepted": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseContextInterceptedCall1": Array [

+      Object {

+        "number": 42,

+      },

+      1,

+      2,

+      3,

+    ],

+    "promiseContextInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseContextInterceptedTap1": Object {

+      "number": 42,

+    },

+    "promiseIntercepted": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedTap1": Object {

+      "fn": 2,

+      "name": "promise",

+      "type": "promise",

+    },

+    "promiseInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync",

+      "type": "sync",

+    },

+    "promiseUnusedContextIntercepted": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseUnusedContextInterceptedCall1": Array [

+      undefined,

+      1,

+      2,

+      3,

+    ],

+    "promiseUnusedContextInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseUnusedContextInterceptedTap1": undefined,

+  },

+  "sync": Object {

+    "callAsyncIntercepted": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedTap1": Object {

+      "fn": 2,

+      "name": "sync2",

+      "type": "sync",

+    },

+    "callAsyncInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "callAsyncMultipleSync": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncCalled1": true,

+    "callAsyncMultipleSyncCalled2": true,

+    "callAsyncMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "async",

+    },

+    "callAsyncMultipleSyncErrorCalled1": true,

+    "callAsyncMultipleSyncErrorCalled2": true,

+    "callAsyncMultipleSyncWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgCalled1": 42,

+    "callAsyncMultipleSyncWithArgCalled2": 42,

+    "callAsyncMultipleSyncWithArgFirstReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgFirstReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgLastReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgs": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "callAsyncMultipleSyncWithArgsCalled2": Array [

+      42,

+      43,

+      44,

+    ],

+    "callAsyncNone": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncNoneWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSync": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSyncCalled": true,

+    "callAsyncSingleSyncWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSyncWithArgCalled": 42,

+    "promiseIntercepted": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedTap1": Object {

+      "fn": 2,

+      "name": "sync2",

+      "type": "sync",

+    },

+    "promiseInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "promiseMultipleSync": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncCalled1": true,

+    "promiseMultipleSyncCalled2": true,

+    "promiseMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "promise",

+    },

+    "promiseMultipleSyncErrorCalled1": true,

+    "promiseMultipleSyncErrorCalled2": true,

+    "promiseMultipleSyncWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgCalled1": 42,

+    "promiseMultipleSyncWithArgCalled2": 42,

+    "promiseMultipleSyncWithArgFirstReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,

+    "promiseMultipleSyncWithArgFirstReturnCalled2": 42,

+    "promiseMultipleSyncWithArgLastReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,

+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,

+    "promiseMultipleSyncWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,

+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,

+    "promiseMultipleSyncWithArgs": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "promiseMultipleSyncWithArgsCalled2": Array [

+      42,

+      43,

+      44,

+    ],

+    "promiseNone": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseNoneWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSync": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSyncCalled": true,

+    "promiseSingleSyncWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSyncWithArgCalled": 42,

+  },

+}

+`;

diff --git a/node_modules/tapable/lib/__tests__/__snapshots__/AsyncSeriesHooks.js.snap b/node_modules/tapable/lib/__tests__/__snapshots__/AsyncSeriesHooks.js.snap
new file mode 100644
index 00000000..5004020e
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/__snapshots__/AsyncSeriesHooks.js.snap
@@ -0,0 +1,2214 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`AsyncSeriesBailHook should have to correct behavior 1`] = `
+Object {
+  "async": Object {
+    "callAsyncMultipleAsyncEarlyError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultipleAsyncEarlyErrorCalled1": true,
+    "callAsyncMultipleAsyncError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultipleAsyncErrorCalled1": true,
+    "callAsyncMultipleAsyncLateError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultipleAsyncLateErrorCalled1": true,
+    "callAsyncMultipleAsyncLateErrorEarlyResult1": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultipleAsyncLateErrorEarlyResult1Called1": true,
+    "callAsyncMultipleAsyncLateErrorEarlyResult2": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncMultipleAsyncLateErrorEarlyResult2Called1": true,
+    "callAsyncMultipleAsyncWithArg": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultipleAsyncWithArgCalled1": 42,
+    "callAsyncMultipleAsyncWithArgFirstReturn": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultipleAsyncWithArgFirstReturnCalled1": 42,
+    "callAsyncMultipleAsyncWithArgLastReturn": Object {
+      "type": "async",
+      "value": 44,
+    },
+    "callAsyncMultipleAsyncWithArgLastReturnCalled1": 42,
+    "callAsyncMultipleAsyncWithArgLastReturnCalled2": 42,
+    "callAsyncMultipleAsyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleAsyncWithArgNoReturnCalled1": 42,
+    "callAsyncMultipleAsyncWithArgNoReturnCalled2": 42,
+    "callAsyncMultipleMixed1WithArg": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultipleMixed1WithArgCalled1": 42,
+    "callAsyncMultipleMixed2WithArg": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultipleMixed2WithArgCalled1": 42,
+    "callAsyncMultipleMixed3WithArg": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultipleMixed3WithArgCalled1": 42,
+    "callAsyncMultipleMixedError1WithArg": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncMultipleMixedError1WithArgCalled1": 42,
+    "callAsyncMultipleMixedError2WithArg": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncMultipleMixedError2WithArgCalled1": 42,
+    "callAsyncMultipleMixedError3WithArg": Object {
+      "error": "Error in async",
+      "type": "async",
+    },
+    "callAsyncMultipleMixedError3WithArgCalled1": 42,
+    "callAsyncMultipleMixedLateError": Object {
+      "error": "Error in async",
+      "type": "async",
+    },
+    "callAsyncMultipleMixedLateErrorCalled1": true,
+    "callAsyncMultiplePromiseEarlyError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultiplePromiseEarlyErrorCalled1": true,
+    "callAsyncMultiplePromiseError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultiplePromiseErrorCalled1": true,
+    "callAsyncMultiplePromiseLateError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultiplePromiseLateErrorCalled1": true,
+    "callAsyncMultiplePromiseWithArg": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultiplePromiseWithArgCalled1": 42,
+    "callAsyncMultiplePromiseWithArgFirstReturn": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultiplePromiseWithArgFirstReturnCalled1": 42,
+    "callAsyncMultiplePromiseWithArgLastReturn": Object {
+      "type": "async",
+      "value": 44,
+    },
+    "callAsyncMultiplePromiseWithArgLastReturnCalled1": 42,
+    "callAsyncMultiplePromiseWithArgLastReturnCalled2": 42,
+    "callAsyncMultiplePromiseWithArgNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultiplePromiseWithArgNoReturnCalled1": 42,
+    "callAsyncMultiplePromiseWithArgNoReturnCalled2": 42,
+    "callAsyncMultipleSync": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncMultipleSyncCalled1": true,
+    "callAsyncMultipleSyncError": Object {
+      "error": "Error in sync2",
+      "type": "async",
+    },
+    "callAsyncMultipleSyncErrorCalled1": true,
+    "callAsyncMultipleSyncLastReturn": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultipleSyncLastReturnCalled1": true,
+    "callAsyncMultipleSyncLastReturnCalled2": true,
+    "callAsyncMultipleSyncNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncNoReturnCalled1": true,
+    "callAsyncMultipleSyncNoReturnCalled2": true,
+    "callAsyncMultipleSyncWithArg": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultipleSyncWithArgCalled1": 42,
+    "callAsyncMultipleSyncWithArgFirstReturn": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgLastReturn": Object {
+      "type": "async",
+      "value": 44,
+    },
+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,
+    "callAsyncMultipleSyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,
+    "callAsyncNone": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncNoneWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleAsyncWithArg": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncSingleAsyncWithArgCalled1": 42,
+    "callAsyncSinglePromiseWithArg": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncSinglePromiseWithArgCalled1": 42,
+    "callAsyncSingleSync": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncSingleSyncCalled1": true,
+    "callAsyncSingleSyncWithArg": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncSingleSyncWithArgCalled1": 42,
+    "callAsyncSingleSyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleSyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleAsyncEarlyError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultipleAsyncEarlyErrorCalled1": true,
+    "promiseMultipleAsyncError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultipleAsyncErrorCalled1": true,
+    "promiseMultipleAsyncLateError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultipleAsyncLateErrorCalled1": true,
+    "promiseMultipleAsyncLateErrorEarlyResult1": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultipleAsyncLateErrorEarlyResult1Called1": true,
+    "promiseMultipleAsyncLateErrorEarlyResult2": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseMultipleAsyncLateErrorEarlyResult2Called1": true,
+    "promiseMultipleAsyncWithArg": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultipleAsyncWithArgCalled1": 42,
+    "promiseMultipleAsyncWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultipleAsyncWithArgFirstReturnCalled1": 42,
+    "promiseMultipleAsyncWithArgLastReturn": Object {
+      "type": "promise",
+      "value": 44,
+    },
+    "promiseMultipleAsyncWithArgLastReturnCalled1": 42,
+    "promiseMultipleAsyncWithArgLastReturnCalled2": 42,
+    "promiseMultipleAsyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleAsyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleAsyncWithArgNoReturnCalled2": 42,
+    "promiseMultipleMixed1WithArg": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultipleMixed1WithArgCalled1": 42,
+    "promiseMultipleMixed2WithArg": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultipleMixed2WithArgCalled1": 42,
+    "promiseMultipleMixed3WithArg": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultipleMixed3WithArgCalled1": 42,
+    "promiseMultipleMixedError1WithArg": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseMultipleMixedError1WithArgCalled1": 42,
+    "promiseMultipleMixedError2WithArg": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseMultipleMixedError2WithArgCalled1": 42,
+    "promiseMultipleMixedError3WithArg": Object {
+      "error": "Error in async",
+      "type": "promise",
+    },
+    "promiseMultipleMixedError3WithArgCalled1": 42,
+    "promiseMultipleMixedLateError": Object {
+      "error": "Error in async",
+      "type": "promise",
+    },
+    "promiseMultipleMixedLateErrorCalled1": true,
+    "promiseMultiplePromiseEarlyError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultiplePromiseEarlyErrorCalled1": true,
+    "promiseMultiplePromiseError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultiplePromiseErrorCalled1": true,
+    "promiseMultiplePromiseLateError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultiplePromiseLateErrorCalled1": true,
+    "promiseMultiplePromiseWithArg": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultiplePromiseWithArgCalled1": 42,
+    "promiseMultiplePromiseWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultiplePromiseWithArgFirstReturnCalled1": 42,
+    "promiseMultiplePromiseWithArgLastReturn": Object {
+      "type": "promise",
+      "value": 44,
+    },
+    "promiseMultiplePromiseWithArgLastReturnCalled1": 42,
+    "promiseMultiplePromiseWithArgLastReturnCalled2": 42,
+    "promiseMultiplePromiseWithArgNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultiplePromiseWithArgNoReturnCalled1": 42,
+    "promiseMultiplePromiseWithArgNoReturnCalled2": 42,
+    "promiseMultipleSync": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseMultipleSyncCalled1": true,
+    "promiseMultipleSyncError": Object {
+      "error": "Error in sync2",
+      "type": "promise",
+    },
+    "promiseMultipleSyncErrorCalled1": true,
+    "promiseMultipleSyncLastReturn": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultipleSyncLastReturnCalled1": true,
+    "promiseMultipleSyncLastReturnCalled2": true,
+    "promiseMultipleSyncNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncNoReturnCalled1": true,
+    "promiseMultipleSyncNoReturnCalled2": true,
+    "promiseMultipleSyncWithArg": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultipleSyncWithArgCalled1": 42,
+    "promiseMultipleSyncWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,
+    "promiseMultipleSyncWithArgLastReturn": Object {
+      "type": "promise",
+      "value": 44,
+    },
+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,
+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,
+    "promiseMultipleSyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,
+    "promiseNone": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseNoneWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleAsyncWithArg": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseSingleAsyncWithArgCalled1": 42,
+    "promiseSinglePromiseWithArg": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseSinglePromiseWithArgCalled1": 42,
+    "promiseSingleSync": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseSingleSyncCalled1": true,
+    "promiseSingleSyncWithArg": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseSingleSyncWithArgCalled1": 42,
+    "promiseSingleSyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleSyncWithArgNoReturnCalled1": 42,
+  },
+  "intercept": Object {
+    "callAsyncContextIntercepted": Object {
+      "type": "async",
+      "value": 48,
+    },
+    "callAsyncContextInterceptedCall1": Array [
+      Object {
+        "number": 42,
+      },
+      1,
+      2,
+      3,
+    ],
+    "callAsyncContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncContextInterceptedTap1": Object {
+      "number": 42,
+    },
+    "callAsyncIntercepted": Object {
+      "type": "async",
+      "value": 6,
+    },
+    "callAsyncInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedTap1": Object {
+      "fn": 3,
+      "name": "sync",
+      "type": "sync",
+    },
+    "callAsyncInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync",
+      "type": "sync",
+    },
+    "callAsyncUnusedContextIntercepted": Object {
+      "type": "async",
+      "value": 6,
+    },
+    "callAsyncUnusedContextInterceptedCall1": Array [
+      undefined,
+      1,
+      2,
+      3,
+    ],
+    "callAsyncUnusedContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncUnusedContextInterceptedTap1": undefined,
+    "promiseContextIntercepted": Object {
+      "type": "promise",
+      "value": 48,
+    },
+    "promiseContextInterceptedCall1": Array [
+      Object {
+        "number": 42,
+      },
+      1,
+      2,
+      3,
+    ],
+    "promiseContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseContextInterceptedTap1": Object {
+      "number": 42,
+    },
+    "promiseIntercepted": Object {
+      "type": "promise",
+      "value": 6,
+    },
+    "promiseInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedTap1": Object {
+      "fn": 3,
+      "name": "sync",
+      "type": "sync",
+    },
+    "promiseInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync",
+      "type": "sync",
+    },
+    "promiseUnusedContextIntercepted": Object {
+      "type": "promise",
+      "value": 6,
+    },
+    "promiseUnusedContextInterceptedCall1": Array [
+      undefined,
+      1,
+      2,
+      3,
+    ],
+    "promiseUnusedContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseUnusedContextInterceptedTap1": undefined,
+  },
+  "sync": Object {
+    "callAsyncIntercepted": Object {
+      "type": "async",
+      "value": 6,
+    },
+    "callAsyncInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedTap1": Object {
+      "fn": 3,
+      "name": "sync1",
+      "type": "sync",
+    },
+    "callAsyncInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync1",
+      "type": "sync",
+    },
+    "callAsyncMultipleSync": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncMultipleSyncCalled1": true,
+    "callAsyncMultipleSyncError": Object {
+      "error": "Error in sync2",
+      "type": "async",
+    },
+    "callAsyncMultipleSyncErrorCalled1": true,
+    "callAsyncMultipleSyncErrorCalled2": true,
+    "callAsyncMultipleSyncWithArg": Object {
+      "type": "async",
+      "value": 84,
+    },
+    "callAsyncMultipleSyncWithArgCalled1": 42,
+    "callAsyncMultipleSyncWithArgFirstReturn": Object {
+      "type": "async",
+      "value": 84,
+    },
+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgLastReturn": Object {
+      "type": "async",
+      "value": 85,
+    },
+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,
+    "callAsyncMultipleSyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,
+    "callAsyncMultipleSyncWithArgs": Object {
+      "type": "async",
+      "value": 129,
+    },
+    "callAsyncMultipleSyncWithArgsCalled1": Array [
+      42,
+      43,
+      44,
+    ],
+    "callAsyncNone": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncNoneWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleSync": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncSingleSyncCalled": true,
+    "callAsyncSingleSyncWithArg": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncSingleSyncWithArgCalled": 42,
+    "promiseIntercepted": Object {
+      "type": "promise",
+      "value": 6,
+    },
+    "promiseInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedTap1": Object {
+      "fn": 3,
+      "name": "sync1",
+      "type": "sync",
+    },
+    "promiseInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync1",
+      "type": "sync",
+    },
+    "promiseMultipleSync": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseMultipleSyncCalled1": true,
+    "promiseMultipleSyncError": Object {
+      "error": "Error in sync2",
+      "type": "promise",
+    },
+    "promiseMultipleSyncErrorCalled1": true,
+    "promiseMultipleSyncErrorCalled2": true,
+    "promiseMultipleSyncWithArg": Object {
+      "type": "promise",
+      "value": 84,
+    },
+    "promiseMultipleSyncWithArgCalled1": 42,
+    "promiseMultipleSyncWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": 84,
+    },
+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,
+    "promiseMultipleSyncWithArgLastReturn": Object {
+      "type": "promise",
+      "value": 85,
+    },
+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,
+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,
+    "promiseMultipleSyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,
+    "promiseMultipleSyncWithArgs": Object {
+      "type": "promise",
+      "value": 129,
+    },
+    "promiseMultipleSyncWithArgsCalled1": Array [
+      42,
+      43,
+      44,
+    ],
+    "promiseNone": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseNoneWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleSync": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseSingleSyncCalled": true,
+    "promiseSingleSyncWithArg": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseSingleSyncWithArgCalled": 42,
+  },
+}
+`;
+
+exports[`AsyncSeriesHook should have to correct behavior 1`] = `
+Object {
+  "async": Object {
+    "callAsyncMultipleAsyncEarlyError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultipleAsyncEarlyErrorCalled1": true,
+    "callAsyncMultipleAsyncError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultipleAsyncErrorCalled1": true,
+    "callAsyncMultipleAsyncLateError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultipleAsyncLateErrorCalled1": true,
+    "callAsyncMultipleAsyncLateErrorEarlyResult1": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultipleAsyncLateErrorEarlyResult1Called1": true,
+    "callAsyncMultipleAsyncLateErrorEarlyResult2": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultipleAsyncLateErrorEarlyResult2Called1": true,
+    "callAsyncMultipleAsyncWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleAsyncWithArgCalled1": 42,
+    "callAsyncMultipleAsyncWithArgCalled2": 42,
+    "callAsyncMultipleAsyncWithArgFirstReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleAsyncWithArgFirstReturnCalled1": 42,
+    "callAsyncMultipleAsyncWithArgFirstReturnCalled2": 42,
+    "callAsyncMultipleAsyncWithArgLastReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleAsyncWithArgLastReturnCalled1": 42,
+    "callAsyncMultipleAsyncWithArgLastReturnCalled2": 42,
+    "callAsyncMultipleAsyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleAsyncWithArgNoReturnCalled1": 42,
+    "callAsyncMultipleAsyncWithArgNoReturnCalled2": 42,
+    "callAsyncMultipleMixed1WithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleMixed1WithArgCalled1": 42,
+    "callAsyncMultipleMixed1WithArgCalled2": 42,
+    "callAsyncMultipleMixed1WithArgCalled3": 42,
+    "callAsyncMultipleMixed2WithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleMixed2WithArgCalled1": 42,
+    "callAsyncMultipleMixed2WithArgCalled2": 42,
+    "callAsyncMultipleMixed3WithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleMixed3WithArgCalled1": 42,
+    "callAsyncMultipleMixed3WithArgCalled2": 42,
+    "callAsyncMultipleMixed3WithArgCalled3": 42,
+    "callAsyncMultipleMixedError1WithArg": Object {
+      "error": "Error in sync",
+      "type": "async",
+    },
+    "callAsyncMultipleMixedError1WithArgCalled1": 42,
+    "callAsyncMultipleMixedError1WithArgCalled2": 42,
+    "callAsyncMultipleMixedError1WithArgCalled3": 42,
+    "callAsyncMultipleMixedError2WithArg": Object {
+      "error": "Error in promise",
+      "type": "async",
+    },
+    "callAsyncMultipleMixedError2WithArgCalled1": 42,
+    "callAsyncMultipleMixedError2WithArgCalled2": 42,
+    "callAsyncMultipleMixedError3WithArg": Object {
+      "error": "Error in async",
+      "type": "async",
+    },
+    "callAsyncMultipleMixedError3WithArgCalled1": 42,
+    "callAsyncMultipleMixedLateError": Object {
+      "error": "Error in async",
+      "type": "async",
+    },
+    "callAsyncMultipleMixedLateErrorCalled1": true,
+    "callAsyncMultiplePromiseEarlyError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultiplePromiseEarlyErrorCalled1": true,
+    "callAsyncMultiplePromiseError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultiplePromiseErrorCalled1": true,
+    "callAsyncMultiplePromiseLateError": Object {
+      "error": "Error in async2",
+      "type": "async",
+    },
+    "callAsyncMultiplePromiseLateErrorCalled1": true,
+    "callAsyncMultiplePromiseWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultiplePromiseWithArgCalled1": 42,
+    "callAsyncMultiplePromiseWithArgCalled2": 42,
+    "callAsyncMultiplePromiseWithArgFirstReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultiplePromiseWithArgFirstReturnCalled1": 42,
+    "callAsyncMultiplePromiseWithArgFirstReturnCalled2": 42,
+    "callAsyncMultiplePromiseWithArgLastReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultiplePromiseWithArgLastReturnCalled1": 42,
+    "callAsyncMultiplePromiseWithArgLastReturnCalled2": 42,
+    "callAsyncMultiplePromiseWithArgNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultiplePromiseWithArgNoReturnCalled1": 42,
+    "callAsyncMultiplePromiseWithArgNoReturnCalled2": 42,
+    "callAsyncMultipleSync": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncCalled1": true,
+    "callAsyncMultipleSyncCalled2": true,
+    "callAsyncMultipleSyncError": Object {
+      "error": "Error in sync2",
+      "type": "async",
+    },
+    "callAsyncMultipleSyncErrorCalled1": true,
+    "callAsyncMultipleSyncLastReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncLastReturnCalled1": true,
+    "callAsyncMultipleSyncLastReturnCalled2": true,
+    "callAsyncMultipleSyncNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncNoReturnCalled1": true,
+    "callAsyncMultipleSyncNoReturnCalled2": true,
+    "callAsyncMultipleSyncWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncWithArgCalled1": 42,
+    "callAsyncMultipleSyncWithArgCalled2": 42,
+    "callAsyncMultipleSyncWithArgFirstReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgFirstReturnCalled2": 42,
+    "callAsyncMultipleSyncWithArgLastReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,
+    "callAsyncMultipleSyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,
+    "callAsyncNone": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncNoneWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleAsyncWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleAsyncWithArgCalled1": 42,
+    "callAsyncSinglePromiseWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSinglePromiseWithArgCalled1": 42,
+    "callAsyncSingleSync": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleSyncCalled1": true,
+    "callAsyncSingleSyncWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleSyncWithArgCalled1": 42,
+    "callAsyncSingleSyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleSyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleAsyncEarlyError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultipleAsyncEarlyErrorCalled1": true,
+    "promiseMultipleAsyncError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultipleAsyncErrorCalled1": true,
+    "promiseMultipleAsyncLateError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultipleAsyncLateErrorCalled1": true,
+    "promiseMultipleAsyncLateErrorEarlyResult1": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultipleAsyncLateErrorEarlyResult1Called1": true,
+    "promiseMultipleAsyncLateErrorEarlyResult2": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultipleAsyncLateErrorEarlyResult2Called1": true,
+    "promiseMultipleAsyncWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleAsyncWithArgCalled1": 42,
+    "promiseMultipleAsyncWithArgCalled2": 42,
+    "promiseMultipleAsyncWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleAsyncWithArgFirstReturnCalled1": 42,
+    "promiseMultipleAsyncWithArgFirstReturnCalled2": 42,
+    "promiseMultipleAsyncWithArgLastReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleAsyncWithArgLastReturnCalled1": 42,
+    "promiseMultipleAsyncWithArgLastReturnCalled2": 42,
+    "promiseMultipleAsyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleAsyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleAsyncWithArgNoReturnCalled2": 42,
+    "promiseMultipleMixed1WithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleMixed1WithArgCalled1": 42,
+    "promiseMultipleMixed1WithArgCalled2": 42,
+    "promiseMultipleMixed1WithArgCalled3": 42,
+    "promiseMultipleMixed2WithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleMixed2WithArgCalled1": 42,
+    "promiseMultipleMixed2WithArgCalled2": 42,
+    "promiseMultipleMixed3WithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleMixed3WithArgCalled1": 42,
+    "promiseMultipleMixed3WithArgCalled2": 42,
+    "promiseMultipleMixed3WithArgCalled3": 42,
+    "promiseMultipleMixedError1WithArg": Object {
+      "error": "Error in sync",
+      "type": "promise",
+    },
+    "promiseMultipleMixedError1WithArgCalled1": 42,
+    "promiseMultipleMixedError1WithArgCalled2": 42,
+    "promiseMultipleMixedError1WithArgCalled3": 42,
+    "promiseMultipleMixedError2WithArg": Object {
+      "error": "Error in promise",
+      "type": "promise",
+    },
+    "promiseMultipleMixedError2WithArgCalled1": 42,
+    "promiseMultipleMixedError2WithArgCalled2": 42,
+    "promiseMultipleMixedError3WithArg": Object {
+      "error": "Error in async",
+      "type": "promise",
+    },
+    "promiseMultipleMixedError3WithArgCalled1": 42,
+    "promiseMultipleMixedLateError": Object {
+      "error": "Error in async",
+      "type": "promise",
+    },
+    "promiseMultipleMixedLateErrorCalled1": true,
+    "promiseMultiplePromiseEarlyError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultiplePromiseEarlyErrorCalled1": true,
+    "promiseMultiplePromiseError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultiplePromiseErrorCalled1": true,
+    "promiseMultiplePromiseLateError": Object {
+      "error": "Error in async2",
+      "type": "promise",
+    },
+    "promiseMultiplePromiseLateErrorCalled1": true,
+    "promiseMultiplePromiseWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultiplePromiseWithArgCalled1": 42,
+    "promiseMultiplePromiseWithArgCalled2": 42,
+    "promiseMultiplePromiseWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultiplePromiseWithArgFirstReturnCalled1": 42,
+    "promiseMultiplePromiseWithArgFirstReturnCalled2": 42,
+    "promiseMultiplePromiseWithArgLastReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultiplePromiseWithArgLastReturnCalled1": 42,
+    "promiseMultiplePromiseWithArgLastReturnCalled2": 42,
+    "promiseMultiplePromiseWithArgNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultiplePromiseWithArgNoReturnCalled1": 42,
+    "promiseMultiplePromiseWithArgNoReturnCalled2": 42,
+    "promiseMultipleSync": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncCalled1": true,
+    "promiseMultipleSyncCalled2": true,
+    "promiseMultipleSyncError": Object {
+      "error": "Error in sync2",
+      "type": "promise",
+    },
+    "promiseMultipleSyncErrorCalled1": true,
+    "promiseMultipleSyncLastReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncLastReturnCalled1": true,
+    "promiseMultipleSyncLastReturnCalled2": true,
+    "promiseMultipleSyncNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncNoReturnCalled1": true,
+    "promiseMultipleSyncNoReturnCalled2": true,
+    "promiseMultipleSyncWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncWithArgCalled1": 42,
+    "promiseMultipleSyncWithArgCalled2": 42,
+    "promiseMultipleSyncWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,
+    "promiseMultipleSyncWithArgFirstReturnCalled2": 42,
+    "promiseMultipleSyncWithArgLastReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,
+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,
+    "promiseMultipleSyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,
+    "promiseNone": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseNoneWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleAsyncWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleAsyncWithArgCalled1": 42,
+    "promiseSinglePromiseWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSinglePromiseWithArgCalled1": 42,
+    "promiseSingleSync": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleSyncCalled1": true,
+    "promiseSingleSyncWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleSyncWithArgCalled1": 42,
+    "promiseSingleSyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleSyncWithArgNoReturnCalled1": 42,
+  },
+  "intercept": Object {
+    "callAsyncContextIntercepted": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncContextInterceptedCall1": Array [
+      Object {
+        "number": 42,
+      },
+      1,
+      2,
+      3,
+    ],
+    "callAsyncContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncContextInterceptedTap1": Object {
+      "number": 42,
+    },
+    "callAsyncIntercepted": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedTap1": Object {
+      "fn": 2,
+      "name": "promise",
+      "type": "promise",
+    },
+    "callAsyncInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync",
+      "type": "sync",
+    },
+    "callAsyncUnusedContextIntercepted": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncUnusedContextInterceptedCall1": Array [
+      undefined,
+      1,
+      2,
+      3,
+    ],
+    "callAsyncUnusedContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncUnusedContextInterceptedTap1": undefined,
+    "promiseContextIntercepted": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseContextInterceptedCall1": Array [
+      Object {
+        "number": 42,
+      },
+      1,
+      2,
+      3,
+    ],
+    "promiseContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseContextInterceptedTap1": Object {
+      "number": 42,
+    },
+    "promiseIntercepted": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedTap1": Object {
+      "fn": 2,
+      "name": "promise",
+      "type": "promise",
+    },
+    "promiseInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync",
+      "type": "sync",
+    },
+    "promiseUnusedContextIntercepted": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseUnusedContextInterceptedCall1": Array [
+      undefined,
+      1,
+      2,
+      3,
+    ],
+    "promiseUnusedContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseUnusedContextInterceptedTap1": undefined,
+  },
+  "sync": Object {
+    "callAsyncIntercepted": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedTap1": Object {
+      "fn": 2,
+      "name": "sync2",
+      "type": "sync",
+    },
+    "callAsyncInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync1",
+      "type": "sync",
+    },
+    "callAsyncMultipleSync": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncCalled1": true,
+    "callAsyncMultipleSyncCalled2": true,
+    "callAsyncMultipleSyncError": Object {
+      "error": "Error in sync2",
+      "type": "async",
+    },
+    "callAsyncMultipleSyncErrorCalled1": true,
+    "callAsyncMultipleSyncErrorCalled2": true,
+    "callAsyncMultipleSyncWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncWithArgCalled1": 42,
+    "callAsyncMultipleSyncWithArgCalled2": 42,
+    "callAsyncMultipleSyncWithArgFirstReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgFirstReturnCalled2": 42,
+    "callAsyncMultipleSyncWithArgLastReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,
+    "callAsyncMultipleSyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,
+    "callAsyncMultipleSyncWithArgs": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncWithArgsCalled1": Array [
+      42,
+      43,
+      44,
+    ],
+    "callAsyncMultipleSyncWithArgsCalled2": Array [
+      42,
+      43,
+      44,
+    ],
+    "callAsyncNone": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncNoneWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleSync": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleSyncCalled": true,
+    "callAsyncSingleSyncWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleSyncWithArgCalled": 42,
+    "promiseIntercepted": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedTap1": Object {
+      "fn": 2,
+      "name": "sync2",
+      "type": "sync",
+    },
+    "promiseInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync1",
+      "type": "sync",
+    },
+    "promiseMultipleSync": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncCalled1": true,
+    "promiseMultipleSyncCalled2": true,
+    "promiseMultipleSyncError": Object {
+      "error": "Error in sync2",
+      "type": "promise",
+    },
+    "promiseMultipleSyncErrorCalled1": true,
+    "promiseMultipleSyncErrorCalled2": true,
+    "promiseMultipleSyncWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncWithArgCalled1": 42,
+    "promiseMultipleSyncWithArgCalled2": 42,
+    "promiseMultipleSyncWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,
+    "promiseMultipleSyncWithArgFirstReturnCalled2": 42,
+    "promiseMultipleSyncWithArgLastReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,
+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,
+    "promiseMultipleSyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,
+    "promiseMultipleSyncWithArgs": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncWithArgsCalled1": Array [
+      42,
+      43,
+      44,
+    ],
+    "promiseMultipleSyncWithArgsCalled2": Array [
+      42,
+      43,
+      44,
+    ],
+    "promiseNone": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseNoneWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleSync": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleSyncCalled": true,
+    "promiseSingleSyncWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleSyncWithArgCalled": 42,
+  },
+}
+`;
+
+exports[`AsyncSeriesLoopHook should have to correct behavior 1`] = `
+Object {
+  "async": Object {
+    "callAsyncBrokenPromise": Object {
+      "error": "Tap function (tapPromise) did not return promise (returned this is not a promise)",
+    },
+    "callAsyncMixed": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMixedCalled1": 124,
+    "callAsyncMixedCalled2": 83,
+    "callAsyncMixedCalled3": 42,
+    "callAsyncMultipleAsync": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleAsyncCalled1": 83,
+    "callAsyncMultipleAsyncCalled2": 42,
+    "callAsyncMultiplePromise": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultiplePromiseCalled1": 83,
+    "callAsyncMultiplePromiseCalled2": 42,
+    "callAsyncSingleAsync": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleAsyncCalled": 42,
+    "callAsyncSinglePromise": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSinglePromiseCalled": 42,
+    "promiseBrokenPromise": Object {
+      "error": "Tap function (tapPromise) did not return promise (returned this is not a promise)",
+      "type": "promise",
+    },
+    "promiseMixed": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMixedCalled1": 124,
+    "promiseMixedCalled2": 83,
+    "promiseMixedCalled3": 42,
+    "promiseMultipleAsync": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleAsyncCalled1": 83,
+    "promiseMultipleAsyncCalled2": 42,
+    "promiseMultiplePromise": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultiplePromiseCalled1": 83,
+    "promiseMultiplePromiseCalled2": 42,
+    "promiseSingleAsync": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleAsyncCalled": 42,
+    "promiseSinglePromise": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSinglePromiseCalled": 42,
+  },
+  "sync": Object {
+    "callAsyncInterceptedSync": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncInterceptedSyncCalled1": 83,
+    "callAsyncInterceptedSyncCalled2": 42,
+    "callAsyncInterceptedSyncCalledCall": 1,
+    "callAsyncInterceptedSyncCalledLoop": 83,
+    "callAsyncInterceptedSyncCalledTap": 125,
+    "callAsyncMultipleSync": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncMultipleSyncCalled1": 83,
+    "callAsyncMultipleSyncCalled2": 42,
+    "callAsyncNone": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncNoneWithArg": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleSync": Object {
+      "type": "async",
+      "value": undefined,
+    },
+    "callAsyncSingleSyncCalled": 42,
+    "promiseInterceptedSync": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseInterceptedSyncCalled1": 83,
+    "promiseInterceptedSyncCalled2": 42,
+    "promiseInterceptedSyncCalledCall": 1,
+    "promiseInterceptedSyncCalledLoop": 83,
+    "promiseInterceptedSyncCalledTap": 125,
+    "promiseMultipleSync": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseMultipleSyncCalled1": 83,
+    "promiseMultipleSyncCalled2": 42,
+    "promiseNone": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseNoneWithArg": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleSync": Object {
+      "type": "promise",
+      "value": undefined,
+    },
+    "promiseSingleSyncCalled": 42,
+  },
+}
+`;
+
+exports[`AsyncSeriesWaterfallHook should have to correct behavior 1`] = `
+Object {
+  "async": Object {
+    "callAsyncMultipleAsyncEarlyError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultipleAsyncError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultipleAsyncLateError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultipleAsyncLateErrorEarlyResult1": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultipleAsyncLateErrorEarlyResult2": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultipleAsyncWithArg": Object {
+      "type": "async",
+      "value": 45,
+    },
+    "callAsyncMultipleAsyncWithArgCalled1": 42,
+    "callAsyncMultipleAsyncWithArgCalled2": 43,
+    "callAsyncMultipleAsyncWithArgFirstReturn": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultipleAsyncWithArgFirstReturnCalled1": 42,
+    "callAsyncMultipleAsyncWithArgFirstReturnCalled2": 43,
+    "callAsyncMultipleAsyncWithArgLastReturn": Object {
+      "type": "async",
+      "value": 44,
+    },
+    "callAsyncMultipleAsyncWithArgLastReturnCalled1": 42,
+    "callAsyncMultipleAsyncWithArgLastReturnCalled2": 42,
+    "callAsyncMultipleAsyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncMultipleAsyncWithArgNoReturnCalled1": 42,
+    "callAsyncMultipleAsyncWithArgNoReturnCalled2": 42,
+    "callAsyncMultipleMixed1WithArg": Object {
+      "type": "async",
+      "value": 48,
+    },
+    "callAsyncMultipleMixed1WithArgCalled1": 42,
+    "callAsyncMultipleMixed1WithArgCalled2": 43,
+    "callAsyncMultipleMixed1WithArgCalled3": 45,
+    "callAsyncMultipleMixed2WithArg": Object {
+      "type": "async",
+      "value": 45,
+    },
+    "callAsyncMultipleMixed2WithArgCalled1": 42,
+    "callAsyncMultipleMixed2WithArgCalled2": 43,
+    "callAsyncMultipleMixed3WithArg": Object {
+      "type": "async",
+      "value": 48,
+    },
+    "callAsyncMultipleMixed3WithArgCalled1": 42,
+    "callAsyncMultipleMixed3WithArgCalled2": 43,
+    "callAsyncMultipleMixed3WithArgCalled3": 45,
+    "callAsyncMultipleMixedError1WithArg": Object {
+      "error": "Error in sync",
+      "type": "async",
+    },
+    "callAsyncMultipleMixedError1WithArgCalled1": 42,
+    "callAsyncMultipleMixedError1WithArgCalled2": 42,
+    "callAsyncMultipleMixedError1WithArgCalled3": 43,
+    "callAsyncMultipleMixedError2WithArg": Object {
+      "error": "Error in promise",
+      "type": "async",
+    },
+    "callAsyncMultipleMixedError2WithArgCalled1": 42,
+    "callAsyncMultipleMixedError2WithArgCalled2": 42,
+    "callAsyncMultipleMixedError3WithArg": Object {
+      "error": "Error in async",
+      "type": "async",
+    },
+    "callAsyncMultipleMixedError3WithArgCalled1": 42,
+    "callAsyncMultipleMixedLateError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultiplePromiseEarlyError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultiplePromiseError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultiplePromiseLateError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultiplePromiseWithArg": Object {
+      "type": "async",
+      "value": 45,
+    },
+    "callAsyncMultiplePromiseWithArgCalled1": 42,
+    "callAsyncMultiplePromiseWithArgCalled2": 43,
+    "callAsyncMultiplePromiseWithArgFirstReturn": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultiplePromiseWithArgFirstReturnCalled1": 42,
+    "callAsyncMultiplePromiseWithArgFirstReturnCalled2": 43,
+    "callAsyncMultiplePromiseWithArgLastReturn": Object {
+      "type": "async",
+      "value": 44,
+    },
+    "callAsyncMultiplePromiseWithArgLastReturnCalled1": 42,
+    "callAsyncMultiplePromiseWithArgLastReturnCalled2": 42,
+    "callAsyncMultiplePromiseWithArgNoReturn": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncMultiplePromiseWithArgNoReturnCalled1": 42,
+    "callAsyncMultiplePromiseWithArgNoReturnCalled2": 42,
+    "callAsyncMultipleSync": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultipleSyncError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultipleSyncLastReturn": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultipleSyncNoReturn": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultipleSyncWithArg": Object {
+      "type": "async",
+      "value": 45,
+    },
+    "callAsyncMultipleSyncWithArgCalled1": 42,
+    "callAsyncMultipleSyncWithArgCalled2": 43,
+    "callAsyncMultipleSyncWithArgFirstReturn": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgFirstReturnCalled2": 43,
+    "callAsyncMultipleSyncWithArgLastReturn": Object {
+      "type": "async",
+      "value": 44,
+    },
+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,
+    "callAsyncMultipleSyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,
+    "callAsyncNone": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncNoneWithArg": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncSingleAsyncWithArg": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncSingleAsyncWithArgCalled1": 42,
+    "callAsyncSinglePromiseWithArg": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncSinglePromiseWithArgCalled1": 42,
+    "callAsyncSingleSync": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncSingleSyncWithArg": Object {
+      "type": "async",
+      "value": 43,
+    },
+    "callAsyncSingleSyncWithArgCalled1": 42,
+    "callAsyncSingleSyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncSingleSyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleAsyncEarlyError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultipleAsyncError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultipleAsyncLateError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultipleAsyncLateErrorEarlyResult1": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultipleAsyncLateErrorEarlyResult2": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultipleAsyncWithArg": Object {
+      "type": "promise",
+      "value": 45,
+    },
+    "promiseMultipleAsyncWithArgCalled1": 42,
+    "promiseMultipleAsyncWithArgCalled2": 43,
+    "promiseMultipleAsyncWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultipleAsyncWithArgFirstReturnCalled1": 42,
+    "promiseMultipleAsyncWithArgFirstReturnCalled2": 43,
+    "promiseMultipleAsyncWithArgLastReturn": Object {
+      "type": "promise",
+      "value": 44,
+    },
+    "promiseMultipleAsyncWithArgLastReturnCalled1": 42,
+    "promiseMultipleAsyncWithArgLastReturnCalled2": 42,
+    "promiseMultipleAsyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseMultipleAsyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleAsyncWithArgNoReturnCalled2": 42,
+    "promiseMultipleMixed1WithArg": Object {
+      "type": "promise",
+      "value": 48,
+    },
+    "promiseMultipleMixed1WithArgCalled1": 42,
+    "promiseMultipleMixed1WithArgCalled2": 43,
+    "promiseMultipleMixed1WithArgCalled3": 45,
+    "promiseMultipleMixed2WithArg": Object {
+      "type": "promise",
+      "value": 45,
+    },
+    "promiseMultipleMixed2WithArgCalled1": 42,
+    "promiseMultipleMixed2WithArgCalled2": 43,
+    "promiseMultipleMixed3WithArg": Object {
+      "type": "promise",
+      "value": 48,
+    },
+    "promiseMultipleMixed3WithArgCalled1": 42,
+    "promiseMultipleMixed3WithArgCalled2": 43,
+    "promiseMultipleMixed3WithArgCalled3": 45,
+    "promiseMultipleMixedError1WithArg": Object {
+      "error": "Error in sync",
+      "type": "promise",
+    },
+    "promiseMultipleMixedError1WithArgCalled1": 42,
+    "promiseMultipleMixedError1WithArgCalled2": 42,
+    "promiseMultipleMixedError1WithArgCalled3": 43,
+    "promiseMultipleMixedError2WithArg": Object {
+      "error": "Error in promise",
+      "type": "promise",
+    },
+    "promiseMultipleMixedError2WithArgCalled1": 42,
+    "promiseMultipleMixedError2WithArgCalled2": 42,
+    "promiseMultipleMixedError3WithArg": Object {
+      "error": "Error in async",
+      "type": "promise",
+    },
+    "promiseMultipleMixedError3WithArgCalled1": 42,
+    "promiseMultipleMixedLateError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultiplePromiseEarlyError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultiplePromiseError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultiplePromiseLateError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultiplePromiseWithArg": Object {
+      "type": "promise",
+      "value": 45,
+    },
+    "promiseMultiplePromiseWithArgCalled1": 42,
+    "promiseMultiplePromiseWithArgCalled2": 43,
+    "promiseMultiplePromiseWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultiplePromiseWithArgFirstReturnCalled1": 42,
+    "promiseMultiplePromiseWithArgFirstReturnCalled2": 43,
+    "promiseMultiplePromiseWithArgLastReturn": Object {
+      "type": "promise",
+      "value": 44,
+    },
+    "promiseMultiplePromiseWithArgLastReturnCalled1": 42,
+    "promiseMultiplePromiseWithArgLastReturnCalled2": 42,
+    "promiseMultiplePromiseWithArgNoReturn": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseMultiplePromiseWithArgNoReturnCalled1": 42,
+    "promiseMultiplePromiseWithArgNoReturnCalled2": 42,
+    "promiseMultipleSync": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultipleSyncError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultipleSyncLastReturn": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultipleSyncNoReturn": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultipleSyncWithArg": Object {
+      "type": "promise",
+      "value": 45,
+    },
+    "promiseMultipleSyncWithArgCalled1": 42,
+    "promiseMultipleSyncWithArgCalled2": 43,
+    "promiseMultipleSyncWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,
+    "promiseMultipleSyncWithArgFirstReturnCalled2": 43,
+    "promiseMultipleSyncWithArgLastReturn": Object {
+      "type": "promise",
+      "value": 44,
+    },
+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,
+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,
+    "promiseMultipleSyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,
+    "promiseNone": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseNoneWithArg": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseSingleAsyncWithArg": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseSingleAsyncWithArgCalled1": 42,
+    "promiseSinglePromiseWithArg": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseSinglePromiseWithArgCalled1": 42,
+    "promiseSingleSync": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseSingleSyncWithArg": Object {
+      "type": "promise",
+      "value": 43,
+    },
+    "promiseSingleSyncWithArgCalled1": 42,
+    "promiseSingleSyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseSingleSyncWithArgNoReturnCalled1": 42,
+  },
+  "intercept": Object {
+    "callAsyncContextIntercepted": Object {
+      "type": "async",
+      "value": 48,
+    },
+    "callAsyncContextInterceptedCall1": Array [
+      Object {
+        "number": 42,
+      },
+      1,
+      2,
+      3,
+    ],
+    "callAsyncContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncContextInterceptedTap1": Object {
+      "number": 42,
+    },
+    "callAsyncIntercepted": Object {
+      "type": "async",
+      "value": 9,
+    },
+    "callAsyncInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedTap1": Object {
+      "fn": 2,
+      "name": "promise",
+      "type": "promise",
+    },
+    "callAsyncInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync",
+      "type": "sync",
+    },
+    "callAsyncUnusedContextIntercepted": Object {
+      "type": "async",
+      "value": 6,
+    },
+    "callAsyncUnusedContextInterceptedCall1": Array [
+      undefined,
+      1,
+      2,
+      3,
+    ],
+    "callAsyncUnusedContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncUnusedContextInterceptedTap1": undefined,
+    "promiseContextIntercepted": Object {
+      "type": "promise",
+      "value": 48,
+    },
+    "promiseContextInterceptedCall1": Array [
+      Object {
+        "number": 42,
+      },
+      1,
+      2,
+      3,
+    ],
+    "promiseContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseContextInterceptedTap1": Object {
+      "number": 42,
+    },
+    "promiseIntercepted": Object {
+      "type": "promise",
+      "value": 9,
+    },
+    "promiseInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedTap1": Object {
+      "fn": 2,
+      "name": "promise",
+      "type": "promise",
+    },
+    "promiseInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync",
+      "type": "sync",
+    },
+    "promiseUnusedContextIntercepted": Object {
+      "type": "promise",
+      "value": 6,
+    },
+    "promiseUnusedContextInterceptedCall1": Array [
+      undefined,
+      1,
+      2,
+      3,
+    ],
+    "promiseUnusedContextInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseUnusedContextInterceptedTap1": undefined,
+  },
+  "sync": Object {
+    "callAsyncIntercepted": Object {
+      "type": "async",
+      "value": 9,
+    },
+    "callAsyncInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "callAsyncInterceptedTap1": Object {
+      "fn": 2,
+      "name": "sync2",
+      "type": "sync",
+    },
+    "callAsyncInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync1",
+      "type": "sync",
+    },
+    "callAsyncMultipleSync": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultipleSyncError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncMultipleSyncWithArg": Object {
+      "type": "async",
+      "value": 127,
+    },
+    "callAsyncMultipleSyncWithArgCalled1": 42,
+    "callAsyncMultipleSyncWithArgCalled2": 84,
+    "callAsyncMultipleSyncWithArgFirstReturn": Object {
+      "type": "async",
+      "value": 84,
+    },
+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgFirstReturnCalled2": 84,
+    "callAsyncMultipleSyncWithArgLastReturn": Object {
+      "type": "async",
+      "value": 85,
+    },
+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,
+    "callAsyncMultipleSyncWithArgNoReturn": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,
+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,
+    "callAsyncMultipleSyncWithArgs": Object {
+      "type": "async",
+      "value": 217,
+    },
+    "callAsyncMultipleSyncWithArgsCalled1": Array [
+      42,
+      43,
+      44,
+    ],
+    "callAsyncMultipleSyncWithArgsCalled2": Array [
+      129,
+      43,
+      44,
+    ],
+    "callAsyncNone": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncNoneWithArg": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncSingleSync": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "callAsyncSingleSyncWithArg": Object {
+      "type": "async",
+      "value": 42,
+    },
+    "callAsyncSingleSyncWithArgCalled": 42,
+    "promiseIntercepted": Object {
+      "type": "promise",
+      "value": 9,
+    },
+    "promiseInterceptedCall1": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedCall2": Array [
+      1,
+      2,
+      3,
+    ],
+    "promiseInterceptedTap1": Object {
+      "fn": 2,
+      "name": "sync2",
+      "type": "sync",
+    },
+    "promiseInterceptedTap2": Object {
+      "fn": 3,
+      "name": "sync1",
+      "type": "sync",
+    },
+    "promiseMultipleSync": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultipleSyncError": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseMultipleSyncWithArg": Object {
+      "type": "promise",
+      "value": 127,
+    },
+    "promiseMultipleSyncWithArgCalled1": 42,
+    "promiseMultipleSyncWithArgCalled2": 84,
+    "promiseMultipleSyncWithArgFirstReturn": Object {
+      "type": "promise",
+      "value": 84,
+    },
+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,
+    "promiseMultipleSyncWithArgFirstReturnCalled2": 84,
+    "promiseMultipleSyncWithArgLastReturn": Object {
+      "type": "promise",
+      "value": 85,
+    },
+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,
+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,
+    "promiseMultipleSyncWithArgNoReturn": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,
+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,
+    "promiseMultipleSyncWithArgs": Object {
+      "type": "promise",
+      "value": 217,
+    },
+    "promiseMultipleSyncWithArgsCalled1": Array [
+      42,
+      43,
+      44,
+    ],
+    "promiseMultipleSyncWithArgsCalled2": Array [
+      129,
+      43,
+      44,
+    ],
+    "promiseNone": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseNoneWithArg": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseSingleSync": Object {
+      "error": "Waterfall hooks must have at least one argument",
+    },
+    "promiseSingleSyncWithArg": Object {
+      "type": "promise",
+      "value": 42,
+    },
+    "promiseSingleSyncWithArgCalled": 42,
+  },
+}
+`;
diff --git a/node_modules/tapable/lib/__tests__/__snapshots__/HookCodeFactory.js.snap b/node_modules/tapable/lib/__tests__/__snapshots__/HookCodeFactory.js.snap
new file mode 100644
index 00000000..a070a9a5
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/__snapshots__/HookCodeFactory.js.snap
@@ -0,0 +1,880 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`HookCodeFactory callTap (no args, no intercept) async with onResult 1`] = `
+"var _fn1 = _x[1];
+_fn1((_err1, _result1) => {
+if(_err1) {
+onError(_err1);
+} else {
+onResult(_result1);
+}
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (no args, no intercept) async without onResult 1`] = `
+"var _fn1 = _x[1];
+_fn1(_err1 => {
+if(_err1) {
+onError(_err1);
+} else {
+onDone();
+}
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (no args, no intercept) promise with onResult 1`] = `
+"var _fn2 = _x[2];
+var _hasResult2 = false;
+var _promise2 = _fn2();
+if (!_promise2 || !_promise2.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise2 + ')');
+_promise2.then(_result2 => {
+_hasResult2 = true;
+onResult(_result2);
+}, _err2 => {
+if(_hasResult2) throw _err2;
+onError(_err2);
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (no args, no intercept) promise without onResult 1`] = `
+"var _fn2 = _x[2];
+var _hasResult2 = false;
+var _promise2 = _fn2();
+if (!_promise2 || !_promise2.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise2 + ')');
+_promise2.then(_result2 => {
+_hasResult2 = true;
+onDone();
+}, _err2 => {
+if(_hasResult2) throw _err2;
+onError(_err2);
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (no args, no intercept) sync with onResult 1`] = `
+"var _fn0 = _x[0];
+var _hasError0 = false;
+try {
+var _result0 = _fn0();
+} catch(_err) {
+_hasError0 = true;
+onError(_err);
+}
+if(!_hasError0) {
+onResult(_result0);
+}
+"
+`;
+
+exports[`HookCodeFactory callTap (no args, no intercept) sync without onResult 1`] = `
+"var _fn0 = _x[0];
+var _hasError0 = false;
+try {
+_fn0();
+} catch(_err) {
+_hasError0 = true;
+onError(_err);
+}
+if(!_hasError0) {
+onDone();
+}
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, no intercept) async with onResult 1`] = `
+"var _fn1 = _x[1];
+_fn1(a, b, c, (_err1, _result1) => {
+if(_err1) {
+onError(_err1);
+} else {
+onResult(_result1);
+}
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, no intercept) async without onResult 1`] = `
+"var _fn1 = _x[1];
+_fn1(a, b, c, _err1 => {
+if(_err1) {
+onError(_err1);
+} else {
+onDone();
+}
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, no intercept) promise with onResult 1`] = `
+"var _fn2 = _x[2];
+var _hasResult2 = false;
+var _promise2 = _fn2(a, b, c);
+if (!_promise2 || !_promise2.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise2 + ')');
+_promise2.then(_result2 => {
+_hasResult2 = true;
+onResult(_result2);
+}, _err2 => {
+if(_hasResult2) throw _err2;
+onError(_err2);
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, no intercept) promise without onResult 1`] = `
+"var _fn2 = _x[2];
+var _hasResult2 = false;
+var _promise2 = _fn2(a, b, c);
+if (!_promise2 || !_promise2.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise2 + ')');
+_promise2.then(_result2 => {
+_hasResult2 = true;
+onDone();
+}, _err2 => {
+if(_hasResult2) throw _err2;
+onError(_err2);
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, no intercept) sync with onResult 1`] = `
+"var _fn0 = _x[0];
+var _hasError0 = false;
+try {
+var _result0 = _fn0(a, b, c);
+} catch(_err) {
+_hasError0 = true;
+onError(_err);
+}
+if(!_hasError0) {
+onResult(_result0);
+}
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, no intercept) sync without onResult 1`] = `
+"var _fn0 = _x[0];
+var _hasError0 = false;
+try {
+_fn0(a, b, c);
+} catch(_err) {
+_hasError0 = true;
+onError(_err);
+}
+if(!_hasError0) {
+onDone();
+}
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, with intercept) async with onResult 1`] = `
+"var _tap1 = _taps[1];
+_interceptors[0].tap(_tap1);
+_interceptors[1].tap(_tap1);
+var _fn1 = _x[1];
+_fn1(a, b, c, (_err1, _result1) => {
+if(_err1) {
+onError(_err1);
+} else {
+onResult(_result1);
+}
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, with intercept) async without onResult 1`] = `
+"var _tap1 = _taps[1];
+_interceptors[0].tap(_tap1);
+_interceptors[1].tap(_tap1);
+var _fn1 = _x[1];
+_fn1(a, b, c, _err1 => {
+if(_err1) {
+onError(_err1);
+} else {
+onDone();
+}
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, with intercept) promise with onResult 1`] = `
+"var _tap2 = _taps[2];
+_interceptors[0].tap(_tap2);
+_interceptors[1].tap(_tap2);
+var _fn2 = _x[2];
+var _hasResult2 = false;
+var _promise2 = _fn2(a, b, c);
+if (!_promise2 || !_promise2.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise2 + ')');
+_promise2.then(_result2 => {
+_hasResult2 = true;
+onResult(_result2);
+}, _err2 => {
+if(_hasResult2) throw _err2;
+onError(_err2);
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, with intercept) promise without onResult 1`] = `
+"var _tap2 = _taps[2];
+_interceptors[0].tap(_tap2);
+_interceptors[1].tap(_tap2);
+var _fn2 = _x[2];
+var _hasResult2 = false;
+var _promise2 = _fn2(a, b, c);
+if (!_promise2 || !_promise2.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise2 + ')');
+_promise2.then(_result2 => {
+_hasResult2 = true;
+onDone();
+}, _err2 => {
+if(_hasResult2) throw _err2;
+onError(_err2);
+});
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, with intercept) sync with onResult 1`] = `
+"var _tap0 = _taps[0];
+_interceptors[0].tap(_tap0);
+_interceptors[1].tap(_tap0);
+var _fn0 = _x[0];
+var _hasError0 = false;
+try {
+var _result0 = _fn0(a, b, c);
+} catch(_err) {
+_hasError0 = true;
+onError(_err);
+}
+if(!_hasError0) {
+onResult(_result0);
+}
+"
+`;
+
+exports[`HookCodeFactory callTap (with args, with intercept) sync without onResult 1`] = `
+"var _tap0 = _taps[0];
+_interceptors[0].tap(_tap0);
+_interceptors[1].tap(_tap0);
+var _fn0 = _x[0];
+var _hasError0 = false;
+try {
+_fn0(a, b, c);
+} catch(_err) {
+_hasError0 = true;
+onError(_err);
+}
+if(!_hasError0) {
+onDone();
+}
+"
+`;
+
+exports[`HookCodeFactory taps (mixed) callTapsLooping 1`] = `
+"var _looper = () => {
+var _loopAsync = false;
+var _loop;
+do {
+_loop = false;
+var _fn0 = _x[0];
+var _hasError0 = false;
+try {
+var _result0 = _fn0(a, b, c);
+} catch(_err) {
+_hasError0 = true;
+onError(0, _err);
+}
+if(!_hasError0) {
+if(_result0 !== undefined) {
+_loop = true;
+if(_loopAsync) _looper();
+} else {
+var _fn1 = _x[1];
+_fn1(a, b, c, (_err1, _result1) => {
+if(_err1) {
+onError(1, _err1);
+} else {
+if(_result1 !== undefined) {
+_loop = true;
+if(_loopAsync) _looper();
+} else {
+var _fn2 = _x[2];
+var _hasResult2 = false;
+var _promise2 = _fn2(a, b, c);
+if (!_promise2 || !_promise2.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise2 + ')');
+_promise2.then(_result2 => {
+_hasResult2 = true;
+if(_result2 !== undefined) {
+_loop = true;
+if(_loopAsync) _looper();
+} else {
+if(!_loop) {
+onDone();
+}
+}
+}, _err2 => {
+if(_hasResult2) throw _err2;
+onError(2, _err2);
+});
+}
+}
+});
+}
+}
+} while(_loop);
+_loopAsync = true;
+};
+_looper();
+"
+`;
+
+exports[`HookCodeFactory taps (mixed) callTapsParallel 1`] = `
+"do {
+var _counter = 3;
+var _done = () => {
+onDone();
+};
+if(_counter <= 0) break;
+var _fn0 = _x[0];
+var _result0 = _fn0(a, b, c);
+if(_counter > 0) {
+onResult(0, _result0, () => {
+if(--_counter === 0) _done();
+}, () => {
+_counter = 0;
+_done();
+});
+}
+if(_counter <= 0) break;
+var _fn1 = _x[1];
+_fn1(a, b, c, (_err1, _result1) => {
+if(_err1) {
+if(_counter > 0) {
+onError(1, _err1);
+}
+} else {
+if(_counter > 0) {
+onResult(1, _result1, () => {
+if(--_counter === 0) _done();
+}, () => {
+_counter = 0;
+_done();
+});
+}
+}
+});
+if(_counter <= 0) break;
+var _fn2 = _x[2];
+var _hasResult2 = false;
+var _promise2 = _fn2(a, b, c);
+if (!_promise2 || !_promise2.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise2 + ')');
+_promise2.then(_result2 => {
+_hasResult2 = true;
+if(_counter > 0) {
+onResult(2, _result2, () => {
+if(--_counter === 0) _done();
+}, () => {
+_counter = 0;
+_done();
+});
+}
+}, _err2 => {
+if(_hasResult2) throw _err2;
+if(_counter > 0) {
+onError(2, _err2);
+}
+});
+} while(false);
+"
+`;
+
+exports[`HookCodeFactory taps (mixed) callTapsSeries 1`] = `
+"var _fn0 = _x[0];
+var _result0 = _fn0(a, b, c);
+onResult(0, _result0, () => {
+var _fn1 = _x[1];
+_fn1(a, b, c, (_err1, _result1) => {
+if(_err1) {
+onError(1, _err1);
+} else {
+onResult(1, _result1, () => {
+var _fn2 = _x[2];
+var _hasResult2 = false;
+var _promise2 = _fn2(a, b, c);
+if (!_promise2 || !_promise2.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise2 + ')');
+_promise2.then(_result2 => {
+_hasResult2 = true;
+onResult(2, _result2, () => {
+onDone();
+}, () => {
+onDone();
+});
+}, _err2 => {
+if(_hasResult2) throw _err2;
+onError(2, _err2);
+});
+}, () => {
+onDone();
+});
+}
+});
+}, () => {
+onDone();
+});
+"
+`;
+
+exports[`HookCodeFactory taps (mixed2) callTapsLooping 1`] = `
+"var _looper = () => {
+var _loopAsync = false;
+var _loop;
+do {
+_loop = false;
+var _fn0 = _x[0];
+_fn0(a, b, c, (_err0, _result0) => {
+if(_err0) {
+onError(0, _err0);
+} else {
+if(_result0 !== undefined) {
+_loop = true;
+if(_loopAsync) _looper();
+} else {
+var _fn1 = _x[1];
+var _hasResult1 = false;
+var _promise1 = _fn1(a, b, c);
+if (!_promise1 || !_promise1.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise1 + ')');
+_promise1.then(_result1 => {
+_hasResult1 = true;
+if(_result1 !== undefined) {
+_loop = true;
+if(_loopAsync) _looper();
+} else {
+var _fn2 = _x[2];
+var _hasError2 = false;
+try {
+var _result2 = _fn2(a, b, c);
+} catch(_err) {
+_hasError2 = true;
+onError(2, _err);
+}
+if(!_hasError2) {
+if(_result2 !== undefined) {
+_loop = true;
+if(_loopAsync) _looper();
+} else {
+if(!_loop) {
+onDone();
+}
+}
+}
+}
+}, _err1 => {
+if(_hasResult1) throw _err1;
+onError(1, _err1);
+});
+}
+}
+});
+} while(_loop);
+_loopAsync = true;
+};
+_looper();
+"
+`;
+
+exports[`HookCodeFactory taps (mixed2) callTapsParallel 1`] = `
+"do {
+var _counter = 3;
+var _done = () => {
+onDone();
+};
+if(_counter <= 0) break;
+var _fn0 = _x[0];
+_fn0(a, b, c, (_err0, _result0) => {
+if(_err0) {
+if(_counter > 0) {
+onError(0, _err0);
+}
+} else {
+if(_counter > 0) {
+onResult(0, _result0, () => {
+if(--_counter === 0) _done();
+}, () => {
+_counter = 0;
+_done();
+});
+}
+}
+});
+if(_counter <= 0) break;
+var _fn1 = _x[1];
+var _hasResult1 = false;
+var _promise1 = _fn1(a, b, c);
+if (!_promise1 || !_promise1.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise1 + ')');
+_promise1.then(_result1 => {
+_hasResult1 = true;
+if(_counter > 0) {
+onResult(1, _result1, () => {
+if(--_counter === 0) _done();
+}, () => {
+_counter = 0;
+_done();
+});
+}
+}, _err1 => {
+if(_hasResult1) throw _err1;
+if(_counter > 0) {
+onError(1, _err1);
+}
+});
+if(_counter <= 0) break;
+var _fn2 = _x[2];
+var _result2 = _fn2(a, b, c);
+if(_counter > 0) {
+onResult(2, _result2, () => {
+if(--_counter === 0) _done();
+}, () => {
+_counter = 0;
+_done();
+});
+}
+} while(false);
+"
+`;
+
+exports[`HookCodeFactory taps (mixed2) callTapsSeries 1`] = `
+"var _fn0 = _x[0];
+_fn0(a, b, c, (_err0, _result0) => {
+if(_err0) {
+onError(0, _err0);
+} else {
+onResult(0, _result0, () => {
+var _fn1 = _x[1];
+var _hasResult1 = false;
+var _promise1 = _fn1(a, b, c);
+if (!_promise1 || !_promise1.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise1 + ')');
+_promise1.then(_result1 => {
+_hasResult1 = true;
+onResult(1, _result1, () => {
+var _fn2 = _x[2];
+var _hasError2 = false;
+try {
+var _result2 = _fn2(a, b, c);
+} catch(_err) {
+_hasError2 = true;
+onError(2, _err);
+}
+if(!_hasError2) {
+onResult(2, _result2, () => {
+onDone();
+}, () => {
+onDone();
+});
+}
+}, () => {
+onDone();
+});
+}, _err1 => {
+if(_hasResult1) throw _err1;
+onError(1, _err1);
+});
+}, () => {
+onDone();
+});
+}
+});
+"
+`;
+
+exports[`HookCodeFactory taps (multiple sync) callTapsLooping 1`] = `
+"var _loop;
+do {
+_loop = false;
+var _fn0 = _x[0];
+var _result0 = _fn0(a, b, c);
+if(_result0 !== undefined) {
+_loop = true;
+} else {
+var _fn1 = _x[1];
+var _result1 = _fn1(a, b, c);
+if(_result1 !== undefined) {
+_loop = true;
+} else {
+var _fn2 = _x[2];
+var _result2 = _fn2(a, b, c);
+if(_result2 !== undefined) {
+_loop = true;
+} else {
+if(!_loop) {
+onDone();
+}
+}
+}
+}
+} while(_loop);
+"
+`;
+
+exports[`HookCodeFactory taps (multiple sync) callTapsParallel 1`] = `
+"do {
+var _counter = 3;
+var _done = () => {
+onDone();
+};
+if(_counter <= 0) break;
+var _fn0 = _x[0];
+var _result0 = _fn0(a, b, c);
+if(_counter > 0) {
+onResult(0, _result0, () => {
+if(--_counter === 0) _done();
+}, () => {
+_counter = 0;
+_done();
+});
+}
+if(_counter <= 0) break;
+var _fn1 = _x[1];
+var _result1 = _fn1(a, b, c);
+if(_counter > 0) {
+onResult(1, _result1, () => {
+if(--_counter === 0) _done();
+}, () => {
+_counter = 0;
+_done();
+});
+}
+if(_counter <= 0) break;
+var _fn2 = _x[2];
+var _result2 = _fn2(a, b, c);
+if(_counter > 0) {
+onResult(2, _result2, () => {
+if(--_counter === 0) _done();
+}, () => {
+_counter = 0;
+_done();
+});
+}
+} while(false);
+"
+`;
+
+exports[`HookCodeFactory taps (multiple sync) callTapsSeries 1`] = `
+"var _fn0 = _x[0];
+var _result0 = _fn0(a, b, c);
+onResult(0, _result0, () => {
+var _fn1 = _x[1];
+var _result1 = _fn1(a, b, c);
+onResult(1, _result1, () => {
+var _fn2 = _x[2];
+var _result2 = _fn2(a, b, c);
+onResult(2, _result2, () => {
+onDone();
+}, () => {
+onDone();
+});
+}, () => {
+onDone();
+});
+}, () => {
+onDone();
+});
+"
+`;
+
+exports[`HookCodeFactory taps (none) callTapsLooping 1`] = `
+"onDone();
+"
+`;
+
+exports[`HookCodeFactory taps (none) callTapsParallel 1`] = `
+"onDone();
+"
+`;
+
+exports[`HookCodeFactory taps (none) callTapsSeries 1`] = `
+"onDone();
+"
+`;
+
+exports[`HookCodeFactory taps (single async) callTapsLooping 1`] = `
+"var _looper = () => {
+var _loopAsync = false;
+var _loop;
+do {
+_loop = false;
+var _fn0 = _x[0];
+_fn0(a, b, c, (_err0, _result0) => {
+if(_err0) {
+onError(0, _err0);
+} else {
+if(_result0 !== undefined) {
+_loop = true;
+if(_loopAsync) _looper();
+} else {
+if(!_loop) {
+onDone();
+}
+}
+}
+});
+} while(_loop);
+_loopAsync = true;
+};
+_looper();
+"
+`;
+
+exports[`HookCodeFactory taps (single async) callTapsParallel 1`] = `
+"var _fn0 = _x[0];
+_fn0(a, b, c, (_err0, _result0) => {
+if(_err0) {
+onError(0, _err0);
+} else {
+onResult(0, _result0, () => {
+onDone();
+}, () => {
+onDone();
+});
+}
+});
+"
+`;
+
+exports[`HookCodeFactory taps (single async) callTapsSeries 1`] = `
+"var _fn0 = _x[0];
+_fn0(a, b, c, (_err0, _result0) => {
+if(_err0) {
+onError(0, _err0);
+} else {
+onResult(0, _result0, () => {
+onDone();
+}, () => {
+onDone();
+});
+}
+});
+"
+`;
+
+exports[`HookCodeFactory taps (single promise) callTapsLooping 1`] = `
+"var _looper = () => {
+var _loopAsync = false;
+var _loop;
+do {
+_loop = false;
+var _fn0 = _x[0];
+var _hasResult0 = false;
+var _promise0 = _fn0(a, b, c);
+if (!_promise0 || !_promise0.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise0 + ')');
+_promise0.then(_result0 => {
+_hasResult0 = true;
+if(_result0 !== undefined) {
+_loop = true;
+if(_loopAsync) _looper();
+} else {
+if(!_loop) {
+onDone();
+}
+}
+}, _err0 => {
+if(_hasResult0) throw _err0;
+onError(0, _err0);
+});
+} while(_loop);
+_loopAsync = true;
+};
+_looper();
+"
+`;
+
+exports[`HookCodeFactory taps (single promise) callTapsParallel 1`] = `
+"var _fn0 = _x[0];
+var _hasResult0 = false;
+var _promise0 = _fn0(a, b, c);
+if (!_promise0 || !_promise0.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise0 + ')');
+_promise0.then(_result0 => {
+_hasResult0 = true;
+onResult(0, _result0, () => {
+onDone();
+}, () => {
+onDone();
+});
+}, _err0 => {
+if(_hasResult0) throw _err0;
+onError(0, _err0);
+});
+"
+`;
+
+exports[`HookCodeFactory taps (single promise) callTapsSeries 1`] = `
+"var _fn0 = _x[0];
+var _hasResult0 = false;
+var _promise0 = _fn0(a, b, c);
+if (!_promise0 || !_promise0.then)
+  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise0 + ')');
+_promise0.then(_result0 => {
+_hasResult0 = true;
+onResult(0, _result0, () => {
+onDone();
+}, () => {
+onDone();
+});
+}, _err0 => {
+if(_hasResult0) throw _err0;
+onError(0, _err0);
+});
+"
+`;
+
+exports[`HookCodeFactory taps (single sync) callTapsLooping 1`] = `
+"var _loop;
+do {
+_loop = false;
+var _fn0 = _x[0];
+var _result0 = _fn0(a, b, c);
+if(_result0 !== undefined) {
+_loop = true;
+} else {
+if(!_loop) {
+onDone();
+}
+}
+} while(_loop);
+"
+`;
+
+exports[`HookCodeFactory taps (single sync) callTapsParallel 1`] = `
+"var _fn0 = _x[0];
+var _result0 = _fn0(a, b, c);
+onResult(0, _result0, () => {
+onDone();
+}, () => {
+onDone();
+});
+"
+`;
+
+exports[`HookCodeFactory taps (single sync) callTapsSeries 1`] = `
+"var _fn0 = _x[0];
+var _result0 = _fn0(a, b, c);
+onResult(0, _result0, () => {
+onDone();
+}, () => {
+onDone();
+});
+"
+`;
diff --git a/node_modules/tapable/lib/__tests__/__snapshots__/SyncHooks.js.snap b/node_modules/tapable/lib/__tests__/__snapshots__/SyncHooks.js.snap
new file mode 100644
index 00000000..10a4126d
--- /dev/null
+++ b/node_modules/tapable/lib/__tests__/__snapshots__/SyncHooks.js.snap
@@ -0,0 +1,876 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP

+

+exports[`SyncBailHook should have to correct behavior 1`] = `

+Object {

+  "async": Object {},

+  "intercept": Object {},

+  "sync": Object {

+    "callAsyncIntercepted": Object {

+      "type": "async",

+      "value": 6,

+    },

+    "callAsyncInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedTap1": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "callAsyncInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "callAsyncMultipleSync": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncMultipleSyncCalled1": true,

+    "callAsyncMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "async",

+    },

+    "callAsyncMultipleSyncErrorCalled1": true,

+    "callAsyncMultipleSyncErrorCalled2": true,

+    "callAsyncMultipleSyncWithArg": Object {

+      "type": "async",

+      "value": 84,

+    },

+    "callAsyncMultipleSyncWithArgCalled1": 42,

+    "callAsyncMultipleSyncWithArgFirstReturn": Object {

+      "type": "async",

+      "value": 84,

+    },

+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgLastReturn": Object {

+      "type": "async",

+      "value": 85,

+    },

+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgs": Object {

+      "type": "async",

+      "value": 129,

+    },

+    "callAsyncMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "callAsyncNone": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncNoneWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSync": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncSingleSyncCalled": true,

+    "callAsyncSingleSyncWithArg": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncSingleSyncWithArgCalled": 42,

+    "callIntercepted": Object {

+      "type": "return",

+      "value": 6,

+    },

+    "callInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "callInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callInterceptedTap1": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "callInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "callMultipleSync": Object {

+      "type": "return",

+      "value": 42,

+    },

+    "callMultipleSyncCalled1": true,

+    "callMultipleSyncError": Object {

+      "error": "Error in sync2",

+    },

+    "callMultipleSyncErrorCalled1": true,

+    "callMultipleSyncErrorCalled2": true,

+    "callMultipleSyncWithArg": Object {

+      "type": "return",

+      "value": 84,

+    },

+    "callMultipleSyncWithArgCalled1": 42,

+    "callMultipleSyncWithArgFirstReturn": Object {

+      "type": "return",

+      "value": 84,

+    },

+    "callMultipleSyncWithArgFirstReturnCalled1": 42,

+    "callMultipleSyncWithArgLastReturn": Object {

+      "type": "return",

+      "value": 85,

+    },

+    "callMultipleSyncWithArgLastReturnCalled1": 42,

+    "callMultipleSyncWithArgLastReturnCalled2": 42,

+    "callMultipleSyncWithArgNoReturn": Object {

+      "type": "no result",

+    },

+    "callMultipleSyncWithArgNoReturnCalled1": 42,

+    "callMultipleSyncWithArgNoReturnCalled2": 42,

+    "callMultipleSyncWithArgs": Object {

+      "type": "return",

+      "value": 129,

+    },

+    "callMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "callNone": Object {

+      "type": "no result",

+    },

+    "callNoneWithArg": Object {

+      "type": "no result",

+    },

+    "callSingleSync": Object {

+      "type": "return",

+      "value": 42,

+    },

+    "callSingleSyncCalled": true,

+    "callSingleSyncWithArg": Object {

+      "type": "return",

+      "value": 42,

+    },

+    "callSingleSyncWithArgCalled": 42,

+    "promiseIntercepted": Object {

+      "type": "promise",

+      "value": 6,

+    },

+    "promiseInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedTap1": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "promiseInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "promiseMultipleSync": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseMultipleSyncCalled1": true,

+    "promiseMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "promise",

+    },

+    "promiseMultipleSyncErrorCalled1": true,

+    "promiseMultipleSyncErrorCalled2": true,

+    "promiseMultipleSyncWithArg": Object {

+      "type": "promise",

+      "value": 84,

+    },

+    "promiseMultipleSyncWithArgCalled1": 42,

+    "promiseMultipleSyncWithArgFirstReturn": Object {

+      "type": "promise",

+      "value": 84,

+    },

+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,

+    "promiseMultipleSyncWithArgLastReturn": Object {

+      "type": "promise",

+      "value": 85,

+    },

+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,

+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,

+    "promiseMultipleSyncWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,

+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,

+    "promiseMultipleSyncWithArgs": Object {

+      "type": "promise",

+      "value": 129,

+    },

+    "promiseMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "promiseNone": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseNoneWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSync": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseSingleSyncCalled": true,

+    "promiseSingleSyncWithArg": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseSingleSyncWithArgCalled": 42,

+  },

+}

+`;

+

+exports[`SyncHook should have to correct behavior 1`] = `

+Object {

+  "async": Object {},

+  "intercept": Object {},

+  "sync": Object {

+    "callAsyncIntercepted": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedTap1": Object {

+      "fn": 2,

+      "name": "sync2",

+      "type": "sync",

+    },

+    "callAsyncInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "callAsyncMultipleSync": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncCalled1": true,

+    "callAsyncMultipleSyncCalled2": true,

+    "callAsyncMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "async",

+    },

+    "callAsyncMultipleSyncErrorCalled1": true,

+    "callAsyncMultipleSyncErrorCalled2": true,

+    "callAsyncMultipleSyncWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgCalled1": 42,

+    "callAsyncMultipleSyncWithArgCalled2": 42,

+    "callAsyncMultipleSyncWithArgFirstReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgFirstReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgLastReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgNoReturn": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgs": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "callAsyncMultipleSyncWithArgsCalled2": Array [

+      42,

+      43,

+      44,

+    ],

+    "callAsyncNone": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncNoneWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSync": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSyncCalled": true,

+    "callAsyncSingleSyncWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSyncWithArgCalled": 42,

+    "callIntercepted": Object {

+      "type": "no result",

+    },

+    "callInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "callInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callInterceptedTap1": Object {

+      "fn": 2,

+      "name": "sync2",

+      "type": "sync",

+    },

+    "callInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "callMultipleSync": Object {

+      "type": "no result",

+    },

+    "callMultipleSyncCalled1": true,

+    "callMultipleSyncCalled2": true,

+    "callMultipleSyncError": Object {

+      "error": "Error in sync2",

+    },

+    "callMultipleSyncErrorCalled1": true,

+    "callMultipleSyncErrorCalled2": true,

+    "callMultipleSyncWithArg": Object {

+      "type": "no result",

+    },

+    "callMultipleSyncWithArgCalled1": 42,

+    "callMultipleSyncWithArgCalled2": 42,

+    "callMultipleSyncWithArgFirstReturn": Object {

+      "type": "no result",

+    },

+    "callMultipleSyncWithArgFirstReturnCalled1": 42,

+    "callMultipleSyncWithArgFirstReturnCalled2": 42,

+    "callMultipleSyncWithArgLastReturn": Object {

+      "type": "no result",

+    },

+    "callMultipleSyncWithArgLastReturnCalled1": 42,

+    "callMultipleSyncWithArgLastReturnCalled2": 42,

+    "callMultipleSyncWithArgNoReturn": Object {

+      "type": "no result",

+    },

+    "callMultipleSyncWithArgNoReturnCalled1": 42,

+    "callMultipleSyncWithArgNoReturnCalled2": 42,

+    "callMultipleSyncWithArgs": Object {

+      "type": "no result",

+    },

+    "callMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "callMultipleSyncWithArgsCalled2": Array [

+      42,

+      43,

+      44,

+    ],

+    "callNone": Object {

+      "type": "no result",

+    },

+    "callNoneWithArg": Object {

+      "type": "no result",

+    },

+    "callSingleSync": Object {

+      "type": "no result",

+    },

+    "callSingleSyncCalled": true,

+    "callSingleSyncWithArg": Object {

+      "type": "no result",

+    },

+    "callSingleSyncWithArgCalled": 42,

+    "promiseIntercepted": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedTap1": Object {

+      "fn": 2,

+      "name": "sync2",

+      "type": "sync",

+    },

+    "promiseInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "promiseMultipleSync": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncCalled1": true,

+    "promiseMultipleSyncCalled2": true,

+    "promiseMultipleSyncError": Object {

+      "error": "Error in sync2",

+      "type": "promise",

+    },

+    "promiseMultipleSyncErrorCalled1": true,

+    "promiseMultipleSyncErrorCalled2": true,

+    "promiseMultipleSyncWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgCalled1": 42,

+    "promiseMultipleSyncWithArgCalled2": 42,

+    "promiseMultipleSyncWithArgFirstReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,

+    "promiseMultipleSyncWithArgFirstReturnCalled2": 42,

+    "promiseMultipleSyncWithArgLastReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,

+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,

+    "promiseMultipleSyncWithArgNoReturn": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,

+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,

+    "promiseMultipleSyncWithArgs": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "promiseMultipleSyncWithArgsCalled2": Array [

+      42,

+      43,

+      44,

+    ],

+    "promiseNone": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseNoneWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSync": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSyncCalled": true,

+    "promiseSingleSyncWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSyncWithArgCalled": 42,

+  },

+}

+`;

+

+exports[`SyncLoopHook should have to correct behavior 1`] = `

+Object {

+  "async": Object {},

+  "sync": Object {

+    "callAsyncInterceptedSync": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncInterceptedSyncCalled1": 83,

+    "callAsyncInterceptedSyncCalled2": 42,

+    "callAsyncInterceptedSyncCalledCall": 1,

+    "callAsyncInterceptedSyncCalledLoop": 83,

+    "callAsyncInterceptedSyncCalledTap": 125,

+    "callAsyncMultipleSync": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncMultipleSyncCalled1": 83,

+    "callAsyncMultipleSyncCalled2": 42,

+    "callAsyncNone": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncNoneWithArg": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSync": Object {

+      "type": "async",

+      "value": undefined,

+    },

+    "callAsyncSingleSyncCalled": 42,

+    "callInterceptedSync": Object {

+      "type": "no result",

+    },

+    "callInterceptedSyncCalled1": 83,

+    "callInterceptedSyncCalled2": 42,

+    "callInterceptedSyncCalledCall": 1,

+    "callInterceptedSyncCalledLoop": 83,

+    "callInterceptedSyncCalledTap": 125,

+    "callMultipleSync": Object {

+      "type": "no result",

+    },

+    "callMultipleSyncCalled1": 83,

+    "callMultipleSyncCalled2": 42,

+    "callNone": Object {

+      "type": "no result",

+    },

+    "callNoneWithArg": Object {

+      "type": "no result",

+    },

+    "callSingleSync": Object {

+      "type": "no result",

+    },

+    "callSingleSyncCalled": 42,

+    "promiseInterceptedSync": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseInterceptedSyncCalled1": 83,

+    "promiseInterceptedSyncCalled2": 42,

+    "promiseInterceptedSyncCalledCall": 1,

+    "promiseInterceptedSyncCalledLoop": 83,

+    "promiseInterceptedSyncCalledTap": 125,

+    "promiseMultipleSync": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseMultipleSyncCalled1": 83,

+    "promiseMultipleSyncCalled2": 42,

+    "promiseNone": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseNoneWithArg": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSync": Object {

+      "type": "promise",

+      "value": undefined,

+    },

+    "promiseSingleSyncCalled": 42,

+  },

+}

+`;

+

+exports[`SyncWaterfallHook should have to correct behavior 1`] = `

+Object {

+  "async": Object {},

+  "intercept": Object {},

+  "sync": Object {

+    "callAsyncIntercepted": Object {

+      "type": "async",

+      "value": 9,

+    },

+    "callAsyncInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callAsyncInterceptedTap1": Object {

+      "fn": 2,

+      "name": "sync2",

+      "type": "sync",

+    },

+    "callAsyncInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "callAsyncMultipleSync": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "callAsyncMultipleSyncError": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "callAsyncMultipleSyncWithArg": Object {

+      "type": "async",

+      "value": 127,

+    },

+    "callAsyncMultipleSyncWithArgCalled1": 42,

+    "callAsyncMultipleSyncWithArgCalled2": 84,

+    "callAsyncMultipleSyncWithArgFirstReturn": Object {

+      "type": "async",

+      "value": 84,

+    },

+    "callAsyncMultipleSyncWithArgFirstReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgFirstReturnCalled2": 84,

+    "callAsyncMultipleSyncWithArgLastReturn": Object {

+      "type": "async",

+      "value": 85,

+    },

+    "callAsyncMultipleSyncWithArgLastReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgLastReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgNoReturn": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncMultipleSyncWithArgNoReturnCalled1": 42,

+    "callAsyncMultipleSyncWithArgNoReturnCalled2": 42,

+    "callAsyncMultipleSyncWithArgs": Object {

+      "type": "async",

+      "value": 217,

+    },

+    "callAsyncMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "callAsyncMultipleSyncWithArgsCalled2": Array [

+      129,

+      43,

+      44,

+    ],

+    "callAsyncNone": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "callAsyncNoneWithArg": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncSingleSync": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "callAsyncSingleSyncWithArg": Object {

+      "type": "async",

+      "value": 42,

+    },

+    "callAsyncSingleSyncWithArgCalled": 42,

+    "callIntercepted": Object {

+      "type": "return",

+      "value": 9,

+    },

+    "callInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "callInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "callInterceptedTap1": Object {

+      "fn": 2,

+      "name": "sync2",

+      "type": "sync",

+    },

+    "callInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "callMultipleSync": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "callMultipleSyncError": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "callMultipleSyncWithArg": Object {

+      "type": "return",

+      "value": 127,

+    },

+    "callMultipleSyncWithArgCalled1": 42,

+    "callMultipleSyncWithArgCalled2": 84,

+    "callMultipleSyncWithArgFirstReturn": Object {

+      "type": "return",

+      "value": 84,

+    },

+    "callMultipleSyncWithArgFirstReturnCalled1": 42,

+    "callMultipleSyncWithArgFirstReturnCalled2": 84,

+    "callMultipleSyncWithArgLastReturn": Object {

+      "type": "return",

+      "value": 85,

+    },

+    "callMultipleSyncWithArgLastReturnCalled1": 42,

+    "callMultipleSyncWithArgLastReturnCalled2": 42,

+    "callMultipleSyncWithArgNoReturn": Object {

+      "type": "return",

+      "value": 42,

+    },

+    "callMultipleSyncWithArgNoReturnCalled1": 42,

+    "callMultipleSyncWithArgNoReturnCalled2": 42,

+    "callMultipleSyncWithArgs": Object {

+      "type": "return",

+      "value": 217,

+    },

+    "callMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "callMultipleSyncWithArgsCalled2": Array [

+      129,

+      43,

+      44,

+    ],

+    "callNone": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "callNoneWithArg": Object {

+      "type": "return",

+      "value": 42,

+    },

+    "callSingleSync": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "callSingleSyncWithArg": Object {

+      "type": "return",

+      "value": 42,

+    },

+    "callSingleSyncWithArgCalled": 42,

+    "promiseIntercepted": Object {

+      "type": "promise",

+      "value": 9,

+    },

+    "promiseInterceptedCall1": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedCall2": Array [

+      1,

+      2,

+      3,

+    ],

+    "promiseInterceptedTap1": Object {

+      "fn": 2,

+      "name": "sync2",

+      "type": "sync",

+    },

+    "promiseInterceptedTap2": Object {

+      "fn": 3,

+      "name": "sync1",

+      "type": "sync",

+    },

+    "promiseMultipleSync": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "promiseMultipleSyncError": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "promiseMultipleSyncWithArg": Object {

+      "type": "promise",

+      "value": 127,

+    },

+    "promiseMultipleSyncWithArgCalled1": 42,

+    "promiseMultipleSyncWithArgCalled2": 84,

+    "promiseMultipleSyncWithArgFirstReturn": Object {

+      "type": "promise",

+      "value": 84,

+    },

+    "promiseMultipleSyncWithArgFirstReturnCalled1": 42,

+    "promiseMultipleSyncWithArgFirstReturnCalled2": 84,

+    "promiseMultipleSyncWithArgLastReturn": Object {

+      "type": "promise",

+      "value": 85,

+    },

+    "promiseMultipleSyncWithArgLastReturnCalled1": 42,

+    "promiseMultipleSyncWithArgLastReturnCalled2": 42,

+    "promiseMultipleSyncWithArgNoReturn": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseMultipleSyncWithArgNoReturnCalled1": 42,

+    "promiseMultipleSyncWithArgNoReturnCalled2": 42,

+    "promiseMultipleSyncWithArgs": Object {

+      "type": "promise",

+      "value": 217,

+    },

+    "promiseMultipleSyncWithArgsCalled1": Array [

+      42,

+      43,

+      44,

+    ],

+    "promiseMultipleSyncWithArgsCalled2": Array [

+      129,

+      43,

+      44,

+    ],

+    "promiseNone": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "promiseNoneWithArg": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseSingleSync": Object {

+      "error": "Waterfall hooks must have at least one argument",

+    },

+    "promiseSingleSyncWithArg": Object {

+      "type": "promise",

+      "value": 42,

+    },

+    "promiseSingleSyncWithArgCalled": 42,

+  },

+}

+`;