request.on('end', () => {
				try {
					let rawMessages: any = JSON.parse(data);

					if (!Array.isArray(rawMessages)) {
						rawMessages = [rawMessages];
					}

					const messages: Message[] = rawMessages.map(function (messageString: string) {
						return JSON.parse(messageString);
					});

					Promise.all(messages.map(message => this._handleMessage(message))).then(
						() => {
							response.statusCode = 204;
							response.end();
						},
						() => {
							response.statusCode = 500;
							response.end();
						}
					);
				}
				catch (error) {
					response.statusCode = 500;
					response.end();
				}
			});

		return super._resolveConfig().then(() => {
			const config = this.config;

			if (!config.basePath) {
				config.basePath = process.cwd() + sep;
			}

			if (!config.internPath) {
				config.internPath = dirname(dirname(__dirname));
			}
			config.internPath = `${relative(process.cwd(), config.internPath)}${sep}`;

			if (config.reporters.length === 0) {
				config.reporters = [{ reporter: 'simple' }];
			}

			if (!config.nodeSuites) {
				config.nodeSuites = [];
			}

			if (config.benchmarkConfig) {
				config.reporters.push({
					reporter: 'benchmark',
					options: config.benchmarkConfig
				});
			}

			return Promise.all(['suites', 'nodeSuites'].map(property => {
				return expandFiles(config[property]).then(expanded => {
					config[property] = expanded;
				});
			// return void
			})).then(() => null);
		});

		'delay can be reusable': function () {
			const start = Date.now();
			const delay = timing.delay(251);
			const p1 = delay().then(function() {
				assert.approximately(Date.now() - start, 251, 150);
			});
			const p2 = delay('foo').then(function(value) {
				assert.strictEqual(value, 'foo');
				assert.approximately(Date.now() - start, 251, 150);
			});
			const p3 = delay(() => Promise.resolve('bar')).then(function(value) {
				assert.strictEqual(value, 'bar');
				assert.approximately(Date.now() - start, 251, 150);
			});
			return Promise.all([p1, p2, p3]);
		}

		return loader(moduleIds).then((modules: any[]) => {
			pluginResourceIds.forEach((resourceId: string, i: number) => {
				if (typeof resourceId === 'string') {
					const module = modules[i];
					const defaultExport = module['default'] || module;

					if (isPlugin(defaultExport)) {
						resourceId = typeof defaultExport.normalize === 'function' ?
							defaultExport.normalize(resourceId, resolver) :
							resolver(resourceId);

						modules[i] = defaultExport.load(resourceId, load);
					}
				}
			});

			return Promise.all(modules);
		});

	stop() {
		const promises: Promise<any>[] = [];

		if (this.server) {
			promises.push(new Promise(resolve => {
				this.server.close(resolve);
			}).then(() => {
				this.server = null;
			}));
		}

		if (this._wsServer) {
			promises.push(new Promise(resolve => {
				this._wsServer.close(resolve);
			}).then(() => {
				this._wsServer = null;
			}));
		}

		return Promise.all(promises).then(() => {
			this._codeCache = null;
		});
	}

export function expandFiles(patterns?: string[]) {
	if (!Array.isArray(patterns)) {
		patterns = [patterns];
	}
	return Promise.all(patterns.map(pattern => {
		if (glob.hasMagic(pattern)) {
			return new Promise<string[]>((resolve, reject) => {
				glob(pattern, (error, files) => {
					if (error) {
						reject(error);
					}
					else {
						resolve(files);
					}
				});
			});
		}
		return [pattern];
	})).then(fileSets => {
		return fileSets.reduce((allFiles, files) => {
			return allFiles.concat(files);
		}, []);
	});
}

					operations.push('read2');
					resolve();
				});
			});

			const writePromise2 = new Promise(function (resolve, reject) {
				write(function () {
					operations.push('write2');
					resolve();
				});
			});

			readHandle.destroy();
			writeHandle.destroy();

			return Promise.all([ readPromise1, readPromise2, writePromise1, writePromise2 ]).then(function () {
				assert.deepEqual(operations, [ 'read1', 'read2', 'write1', 'write2' ],
					'Read queue should drain before write, and destroyed items should not run');
			});
		},

		're-destroy'() {
			const handle = read(function () {});
			handle.destroy();
			assert.doesNotThrow(function () {
				handle.destroy();
			});
		}
	},

	order: {

	private _publish(message: Message) {
		const listeners = this._getSession(message.sessionId).listeners;
		return Promise.all(listeners.map(listener => listener(message.name, message.data)));
	}

		return new Task<DispatchResult>((resolve, reject) => {
			// *Always* start dispatching in a future turn, even if there were no deferrals.
			Promise.all(deferrals).then<DispatchResult>(
				() => {
					// The cancel() function used in the NavigationStartEvent is reused as the Task canceler.
					// Strictly speaking any navstart listener can cancel the dispatch asynchronously, as long as it
					// manages to do so before this turn.
					if (canceled) {
						return { success: false };
					}

					let redirect: undefined | string;
					const dispatched = this._routes.some((route) => {
						const result = route.select(context, segments, trailingSlash, searchParams);

						if (typeof result === 'string') {
							redirect = result;
							return true;
						}
						if (result.length === 0) {
							return false;
						}

						// Update the selected routes after selecting new routes, but before invoking the handlers.
						// This means the original value is available to guard() and params() functions, and the
						// new value when the newly selected routes are executed.
						//
						// Reset selected routes if not dispatched from start().
						this._currentSelection = dispatchFromStart ? result : [];

						for (const { handler, params } of result) {
							catchRejection(this, context, path, handler({ context, params }));
						}

						return true;
					});

					// Reset the selected routes if the dispatch was unsuccessful, or if a redirect was requested.
					if (!dispatched || redirect !== undefined) {
						this._currentSelection = [];
					}

					if (!dispatched && this._fallback) {
						catchRejection(this, context, path, this._fallback({ context, params: {} }));
						return { success: false };
					}

					const result: DispatchResult = { success: dispatched };
					if (redirect !== undefined) {
						result.redirect = redirect;
					}
					return result;
				},
				// When deferrals are canceled their corresponding promise is rejected. Ensure the task resolves
				// with `false` instead of being rejected too.
				() => {
					return { success: false };
				}
			).then(resolve, (error) => {
				reportError(this, context, path, error);
				reject(error);
			});
		}, cancel);