it('should run handlers in order', async () => {
      const options: KernelMessage.IExecuteRequest = {
        code: 'test',
        silent: false,
        store_history: true,
        user_expressions: {},
        allow_stdin: true,
        stop_on_error: false
      };

      const tester = new KernelTester();
      const kernel = await tester.start();
      const future = kernel.requestExecute(options, false);

      // The list of emissions from the anyMessage signal.
      const msgSignal: string[][] = [];
      const msgSignalExpected: string[][] = [];

      // The list of message processing calls
      const calls: string[][] = [];
      const callsExpected: string[][] = [];

      function pushIopub(msgId: string) {
        callsExpected.push([msgId, 'future hook a']);
        callsExpected.push([msgId, 'future hook b']);
        callsExpected.push([msgId, 'kernel hook a']);
        callsExpected.push([msgId, 'kernel hook b']);
        callsExpected.push([msgId, 'iopub']);
        msgSignalExpected.push([msgId, 'iopub']);
      }

      function pushCommOpen(msgId: string) {
        pushIopub(msgId);
        callsExpected.push([msgId, 'comm open']);
      }

      function pushCommMsg(msgId: string) {
        pushIopub(msgId);
        callsExpected.push([msgId, 'comm msg']);
      }

      function pushCommClose(msgId: string) {
        pushIopub(msgId);
        callsExpected.push([msgId, 'comm close']);
      }

      function pushStdin(msgId: string) {
        callsExpected.push([msgId, 'stdin']);
        msgSignalExpected.push([msgId, 'stdin']);
      }

      function pushReply(msgId: string) {
        callsExpected.push([msgId, 'reply']);
        msgSignalExpected.push([msgId, 'shell']);
      }

      const anyMessageDone = new PromiseDelegate();
      const handlingBlock = new PromiseDelegate();

      tester.onMessage(message => {
        tester.onMessage(() => {
          return;
        });
        tester.parentHeader = message.header;

        pushIopub(tester.sendStatus('busy', 'busy'));
        pushIopub(tester.sendStream('stdout', { name: 'stdout', text: 'foo' }));
        pushCommOpen(
          tester.sendCommOpen('comm open', {
            target_name: 'commtarget',
            comm_id: 'commid',
            data: {}
          })
        );
        pushIopub(
          tester.sendDisplayData('display 1', { data: {}, metadata: {} })
        );
        pushCommMsg(
          tester.sendCommMsg('comm 1', { comm_id: 'commid', data: {} })
        );
        pushCommMsg(
          tester.sendCommMsg('comm 2', { comm_id: 'commid', data: {} })
        );
        pushCommClose(
          tester.sendCommClose('comm close', { comm_id: 'commid', data: {} })
        );
        pushStdin(
          tester.sendInputRequest('stdin', { prompt: '', password: false })
        );
        pushIopub(
          tester.sendDisplayData('display 2', {
            data: {},
            metadata: {},
            transient: { display_id: 'displayid' }
          })
        );
        pushIopub(
          tester.sendUpdateDisplayData('update display', {
            data: {},
            metadata: {},
//.........这里部分代码省略.........

 tester.onMessage(msg => {
   expect(msg.header.msg_type).to.equal('input_reply');
   done.resolve(null);
 });

 kernel.anyMessage.connect((k, args) => {
   msgSignal.push([args.msg.header.msg_id, args.msg.channel]);
   if (args.msg.header.msg_id === 'execute reply') {
     anyMessageDone.resolve(undefined);
   }
 });

 const hook = (comm: Kernel.IComm, msg: KernelMessage.ICommOpenMsg) => {
   promise.resolve([comm, msg]);
 };

 .then(() => { transform.resolve(transformation); })

 .catch(reason => {
   conflated.reject(reason);
   conflated = null;
 });

      execute: (args: IRouter.ILocation) => {
        // Since the command can be executed an arbitrary number of times, make
        // sure it is safe to call multiple times.
        if (resolved) {
          return;
        }

        const { hash, path, search } = args;
        const workspace = Private.getWorkspace(router);
        const query = URLExt.queryStringToObject(search || '');
        const clone = query['clone'];
        const source = typeof clone === 'string' ? clone : workspace;

        let promise: Promise<any>;

        // If the default /lab workspace is being cloned, copy it out of local
        // storage instead of making a round trip to the server because it
        // does not exist on the server.
        if (source === clone && source === '') {
          const prefix = `${source}:${info.namespace}:`;
          const mask = (key: string) => key.replace(prefix, '');
          const contents = StateDB.toJSON(prefix, mask);

          resolved = true;
          transform.resolve({ type: 'overwrite', contents });
          promise = Promise.resolve();
        }


        // If there is no promise, fetch the source and overwrite the database.
        promise = promise || workspaces.fetch(source).then(saved => {
          // If this command is called after a reset, the state database will
          // already be resolved.
          if (!resolved) {
            resolved = true;
            transform.resolve({ type: 'overwrite', contents: saved.data });
          }
        }).catch(reason => {
          console.warn(`Fetching workspace (${workspace}) failed:`, reason);

          // If the workspace does not exist, cancel the data transformation and
          // save a workspace with the current user state data.
          if (!resolved) {
            resolved = true;
            transform.resolve({ type: 'cancel', contents: null });
          }
        }).then(() => {
          // Any time the local state database changes, save the workspace.
          if (workspace) {
            state.changed.connect(listener, state);
          }
        });

        return promise.catch(reason => {
          console.warn(`${CommandIDs.loadState} failed:`, reason);
        }).then(() => {
          const immediate = true;

          if (source === clone) {
            // Maintain the query string parameters but remove `clone`.
            delete query['clone'];

            const url = path + URLExt.objectToQueryString(query) + hash;
            const cloned = commands.execute(CommandIDs.saveState, { immediate })
              .then(() => router.stop);

            // After the state has been cloned, navigate to the URL.
            cloned.then(() => { router.navigate(url, { silent: true }); });

            return cloned;
          }

          // After the state database has finished loading, save it.
          return commands.execute(CommandIDs.saveState, { immediate });
        });
      }