关于Promise规范与执行顺序的问题

最近参照Promise/A+规范实现了一个自己的Promise，代码如下：

const enum PromiseState {
  PENDING = "pending",
  FULFILLED = "fulfilled",
  REJECTED = "rejected",
}

export class PromiseLike {
  private _state: PromiseState;
  private _value: any; // 被决议的终值
  private _callbacks: any[]; // then中被注册的回调

  constructor(exector: (resolve, reject) => any) {
    this._state = PromiseState.PENDING;
    this._value = undefined;
    this._callbacks = [];

    const resolve = value => {
      if (this._state !== PromiseState.PENDING) return;
      this._state = PromiseState.FULFILLED;
      this._value = value;

      createMicroTask(() => {
        this._callbacks.forEach(cb => {
          cb();
        });
      });
    };
    const reject = reason => {
      if (this._state !== PromiseState.PENDING) return;
      this._state = PromiseState.REJECTED;
      this._value = reason;

      createMicroTask(() => {
        this._callbacks.forEach(cb => {
          cb();
        });
      });
    };

    exector(resolve, reject);
  }

  then(onfulfilled?, onrejected?) {
    const onFulfilled = typeof onfulfilled === "function" ? onfulfilled : undefined;
    const onRejected = typeof onrejected === "function" ? onrejected : undefined;

    const returnValue = new PromiseLike((resolve, reject) => {
      const callback = () => {
        // 如果Promise已决议，不重复执行
        if (this._state === PromiseState.PENDING) {
          return;
        } else {
          let fn;
          // onFulfilled或onRejected为undefined则被忽略
          if (this._state === PromiseState.FULFILLED) {
            if (onFulfilled) {
              fn = onFulfilled;
            } else {
              resolve(this._value);
              return;
            }
          } else if (this._state === PromiseState.REJECTED) {
            if (onRejected) {
              fn = onRejected;
            } else {
              reject(this._value);
              return;
            }
          }
          let result;
          try {
            result = fn.call(undefined, this._value);
          } catch (e) {
            reject(e);
            return;
          }
          resolution(returnValue, result, resolve, reject);
        }
      };

      if (this._state !== PromiseState.PENDING) {
        createMicroTask(callback);
      } else {
        this._callbacks.push(callback);
      }
    });

    return returnValue;
  }
}

// [[Resolve]](promise,x)
function resolution(promise, value, resolve, reject) {
  if (promise === value) {
    reject(new TypeError("PromiseLike: promise cannot have the same reference with value"));
    return;
  } else if (typeof value === "function" || (value && typeof value === "object")) {
    let then;
    try {
      then = value.then;
    } catch (e) {
      reject(e);
      return;
    }
    if (typeof then === "function") {
      let called = false;
      const resolvePromise = val => {
        if (called) return;
        called = true;
        resolution(promise, val, resolve, reject);
      };
      const rejectPromise = res => {
        if (called) return;
        called = true;
        reject(res);
      };
      try {
        then.call(value, resolvePromise, rejectPromise);
      } catch (e) {
        rejectPromise(e);
      }
    } else {
      resolve(value);
    }
  } else {
    resolve(value);
  }
}

function createMicroTask(fn) {
  queueMicrotask(fn);
}

// 测试用
// export const adapter = {
//   deferred() {
//     let res, rej;
//     const promise = new PromiseLike((resolve, reject) => {
//       res = resolve;
//       rej = reject;
//     });
//     return {
//       promise,
//       resolve: res,
//       reject: rej,
//     };
//   },
// };
// module.exports = adapter;

这个代码通过了Promise/A+的所有测试用例。但是有这么一道关于Promise的面试题：

new Promise<void>((resolve, reject) => {
    resolve();
  })
    .then(() => {
      console.log(0);
      return new Promise((resolve, reject) => {
        resolve(4);
      });
    })
    .then(res => {
      console.log(res);
    });

  new Promise<void>((resolve, reject) => {
    resolve();
  })
    .then(() => {
      console.log(1);
    })
    .then(() => {
      console.log(2);
    })
    .then(() => {
      console.log(3);
    })
    .then(() => {
      console.log(5);
    })
    .then(() => {
      console.log(6);
    });

问代码的输出应该是什么。这道题的输出应该是0 1 2 3 4 5 6，但是用我自己写的PromiseLike，输出为：0 1 2 4 3 5 6。我在网上也找了几个别人实现的Promise，输出两种情况都有。所以我的问题是：

1. 是在哪一步出了问题导致结果不一样

2. 通过Promise/A+所有测试用例的Promise就是一个标准的Promise实现吗

   2.1 如果是，那这种输出不一样的情况是因为规范有遗漏吗

   2.2 如果不是，是因为Promise/A+官方测试用例有没覆盖到的情况吗

谢谢大家了