function aspect(
	suite: Suite,
	method: string,
	callback: SuiteLifecycleFunction | TestLifecycleFunction
) {
	_after(suite, method, (originalReturn: any, args: IArguments) => {
		return Promise.resolve(originalReturn).then(() => {
			return callback.apply(currentSuite, args);
		});
	});
}

		return new Promise<void>(resolve => {
			const server = (this._httpServer = createServer(
				(request: IncomingMessage, response: ServerResponse) => {
					return this._handleHttp(request, response);
				}
			));
			this._sessions = {};
			this._codeCache = Object.create(null);

			const sockets: Socket[] = [];

			this._wsServer = new WebSocket.Server({ port: this.port + 1 });
			this._wsServer.on('connection', client => {
				this.executor.log('WebSocket connection opened:', client);
				this._handleWebSocket(client);
			});
			this._wsServer.on('error', error => {
				this.executor.emit('error', error);
			});

			// If sockets are not manually destroyed then Node.js will keep
			// itself running until they all expire
			after(server, 'close', function() {
				let socket: Socket | undefined;
				while ((socket = sockets.pop())) {
					socket.destroy();
				}
			});

			server.on('connection', socket => {
				sockets.push(socket);
				this.executor.log(
					'HTTP connection opened,',
					sockets.length,
					'open connections'
				);

				socket.on('close', () => {
					let index = sockets.indexOf(socket);
					index !== -1 && sockets.splice(index, 1);
					this.executor.log(
						'HTTP connection closed,',
						sockets.length,
						'open connections'
					);
				});
			});

			server.listen(this.port, () => {
				resolve();
			});
		});

		return new Promise((resolve) => {
			const server = this.server = createServer((request: IncomingMessage, response: ServerResponse) => {
				return this._handler(request, response);
			});
			this._sessions = {};
			this._codeCache = {};

			const sockets: Socket[] = [];

			// If sockets are not manually destroyed then Node.js will keep itself running until they all expire
			after(server, 'close', function () {
				let socket: Socket;
				while ((socket = sockets.pop())) {
					socket.destroy();
				}
			});

			server.on('connection', socket => {
				this.executor.log('HTTP connection opened');
				sockets.push(socket);

				// Disabling Nagle improves server performance on low-latency connections, which are more common
				// during testing than high-latency connections
				socket.setNoDelay(true);

				socket.on('close', function () {
					let index = sockets.indexOf(socket);
					index !== -1 && sockets.splice(index, 1);
				});
			});

			this._wsServer = new WebSocket.Server({ port: this.port + 1 });
			this._wsServer.on('connection', client => {
				this.executor.log('WebSocket connection opened:', client);
				this._handleWebSocket(client);
			});
			this._wsServer.on('error', error => {
				this.executor.emit('error', error);
			});

			server.listen(this.port, resolve);
		});

	private _assignCallback(child: WNode<TitlePane>, functionName: 'onRequestClose' | 'onRequestOpen', callback: (key: string) => void) {
		const existingProperty = child.properties[functionName];
		const property = () => { callback.call(this, `${ child.properties.key }`); };

		return existingProperty ? after(existingProperty, property) : property;
	}

//.........这里部分代码省略.........
				}
			});

			// Add "intern" object to both request and response objects
			Object.defineProperty(app.request, 'intern', {
				enumerable: true,
				get: () => context
			});
			Object.defineProperty(app.response, 'intern', {
				enumerable: true,
				get: () => context
			});

			// Handle JSON and form-encoded request bodies
			app.use(json({ limit: '1mb' }), urlencoded({ extended: true }));

			// Log all requests
			app.use((request, _response, next) => {
				this.executor.log(
					`${request.method} request for ${request.url}`
				);
				return next();
			});

			const internPath = this.executor.config.internPath;

			// Allow resolution using both __intern and node_modules/intern.
			// Note that internPath will always end with a '/'.
			app.use(
				[
					`/${internPath}__resolveSuites__`,
					'/__intern/__resolveSuites__'
				],
				resolveSuites(context)
			);

			// Map __intern to config.internPath
			app.use(
				'/__intern',
				express.static(internPath, { fallthrough: false })
			);

			// TODO: Allow user to add middleware here

			app.use(
				instrument(context),
				express.static(this.basePath),
				post(context),
				unhandled(),
				finalError()
			);

			httpServer = app.listen(this.port, resolve);
			httpServer.on('error', error => {
				if (isErrnoException(error) && error.code === 'EADDRINUSE') {
					const err: NodeJS.ErrnoException = new Error(
						`Something is already listening on the server port (${
							this.port
						})`
					);
					err.code = error.code;
					err.errno = error.errno;
					reject(err);
				} else if (!this._httpServer) {
					reject(error);
				} else {
					this.executor.emit('error', error);
				}
			});

			const sockets: Socket[] = [];

			// If sockets are not manually destroyed then Node.js will keep
			// itself running until they all expire
			after(httpServer, 'close', function() {
				let socket: Socket | undefined;
				while ((socket = sockets.pop())) {
					socket.destroy();
				}
			});

			httpServer.on('connection', socket => {
				sockets.push(socket);
				this.executor.log(
					'HTTP connection opened,',
					sockets.length,
					'open connections'
				);

				socket.on('close', () => {
					let index = sockets.indexOf(socket);
					index !== -1 && sockets.splice(index, 1);
					this.executor.log(
						'HTTP connection closed,',
						sockets.length,
						'open connections'
					);
				});
			});
		})