"use strict";

function ok(a, msg) {
  dump("OK: " + !!a + "  =>  " + a + " " + msg + "\n");
  postMessage({ type: "status", status: !!a, msg: a + ": " + msg });
}

function is(a, b, msg) {
  dump("IS: " + (a === b) + "  =>  " + a + " | " + b + " " + msg + "\n");
  postMessage({
    type: "status",
    status: a === b,
    msg: a + " === " + b + ": " + msg,
  });
}

function isnot(a, b, msg) {
  dump("ISNOT: " + (a !== b) + "  =>  " + a + " | " + b + " " + msg + "\n");
  postMessage({
    type: "status",
    status: a !== b,
    msg: a + " !== " + b + ": " + msg,
  });
}

function promiseResolve() {
  ok(Promise, "Promise object should exist");

  var promise = new Promise(function(resolve, reject) {
    ok(resolve, "Promise.resolve exists");
    ok(reject, "Promise.reject exists");

    resolve(42);
  }).then(
    function(what) {
      ok(true, "Then - resolveCb has been called");
      is(what, 42, "ResolveCb received 42");
      runTest();
    },
    function() {
      ok(false, "Then - rejectCb has been called");
      runTest();
    }
  );
}

function promiseResolveNoArg() {
  var promise = new Promise(function(resolve, reject) {
    ok(resolve, "Promise.resolve exists");
    ok(reject, "Promise.reject exists");

    resolve();
  }).then(
    function(what) {
      ok(true, "Then - resolveCb has been called");
      is(what, undefined, "ResolveCb received undefined");
      runTest();
    },
    function() {
      ok(false, "Then - rejectCb has been called");
      runTest();
    }
  );
}

function promiseRejectNoHandler() {
  // This test only checks that the code that reports unhandled errors in the
  // Promises implementation does not crash or leak.
  var promise = new Promise(function(res, rej) {
    noSuchMethod();
  });
  runTest();
}

function promiseReject() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  }).then(
    function(what) {
      ok(false, "Then - resolveCb has been called");
      runTest();
    },
    function(what) {
      ok(true, "Then - rejectCb has been called");
      is(what, 42, "RejectCb received 42");
      runTest();
    }
  );
}

function promiseRejectNoArg() {
  var promise = new Promise(function(resolve, reject) {
    reject();
  }).then(
    function(what) {
      ok(false, "Then - resolveCb has been called");
      runTest();
    },
    function(what) {
      ok(true, "Then - rejectCb has been called");
      is(what, undefined, "RejectCb received undefined");
      runTest();
    }
  );
}

function promiseException() {
  var promise = new Promise(function(resolve, reject) {
    throw 42;
  }).then(
    function(what) {
      ok(false, "Then - resolveCb has been called");
      runTest();
    },
    function(what) {
      ok(true, "Then - rejectCb has been called");
      is(what, 42, "RejectCb received 42");
      runTest();
    }
  );
}

function promiseAsync_TimeoutResolveThen() {
  var handlerExecuted = false;

  setTimeout(function() {
    ok(handlerExecuted, "Handler should have been called before the timeout.");

    // Allow other assertions to run so the test could fail before the next one.
    setTimeout(runTest, 0);
  }, 0);

  Promise.resolve().then(function() {
    handlerExecuted = true;
  });

  ok(!handlerExecuted, "Handlers are not called before 'then' returns.");
}

function promiseAsync_ResolveTimeoutThen() {
  var handlerExecuted = false;

  var promise = Promise.resolve();

  setTimeout(function() {
    ok(handlerExecuted, "Handler should have been called before the timeout.");

    // Allow other assertions to run so the test could fail before the next one.
    setTimeout(runTest, 0);
  }, 0);

  promise.then(function() {
    handlerExecuted = true;
  });

  ok(!handlerExecuted, "Handlers are not called before 'then' returns.");
}

function promiseAsync_ResolveThenTimeout() {
  var handlerExecuted = false;

  Promise.resolve().then(function() {
    handlerExecuted = true;
  });

  setTimeout(function() {
    ok(handlerExecuted, "Handler should have been called before the timeout.");

    // Allow other assertions to run so the test could fail before the next one.
    setTimeout(runTest, 0);
  }, 0);

  ok(!handlerExecuted, "Handlers are not called before 'then' returns.");
}

function promiseAsync_SyncXHRAndImportScripts() {
  var handlerExecuted = false;

  Promise.resolve().then(function() {
    handlerExecuted = true;

    // Allow other assertions to run so the test could fail before the next one.
    setTimeout(runTest, 0);
  });

  ok(!handlerExecuted, "Handlers are not called until the next microtask.");

  var xhr = new XMLHttpRequest();
  xhr.open("GET", "testXHR.txt", false);
  xhr.send(null);

  ok(!handlerExecuted, "Sync XHR should not trigger microtask execution.");

  importScripts("../../../dom/xhr/tests/relativeLoad_import.js");

  ok(!handlerExecuted, "importScripts should not trigger microtask execution.");
}

function promiseDoubleThen() {
  var steps = 0;
  var promise = new Promise(function(r1, r2) {
    r1(42);
  });

  promise.then(
    function(what) {
      ok(true, "Then.resolve has been called");
      is(what, 42, "Value == 42");
      steps++;
    },
    function(what) {
      ok(false, "Then.reject has been called");
    }
  );

  promise.then(
    function(what) {
      ok(true, "Then.resolve has been called");
      is(steps, 1, "Then.resolve - step == 1");
      is(what, 42, "Value == 42");
      runTest();
    },
    function(what) {
      ok(false, "Then.reject has been called");
    }
  );
}

function promiseThenException() {
  var promise = new Promise(function(resolve, reject) {
    resolve(42);
  });

  promise
    .then(function(what) {
      ok(true, "Then.resolve has been called");
      throw "booh";
    })
    .catch(function(e) {
      ok(true, "Catch has been called!");
      runTest();
    });
}

function promiseThenCatchThen() {
  var promise = new Promise(function(resolve, reject) {
    resolve(42);
  });

  var promise2 = promise.then(
    function(what) {
      ok(true, "Then.resolve has been called");
      is(what, 42, "Value == 42");
      return what + 1;
    },
    function(what) {
      ok(false, "Then.reject has been called");
    }
  );

  isnot(promise, promise2, "These 2 promise objs are different");

  promise2
    .then(
      function(what) {
        ok(true, "Then.resolve has been called");
        is(what, 43, "Value == 43");
        return what + 1;
      },
      function(what) {
        ok(false, "Then.reject has been called");
      }
    )
    .catch(function() {
      ok(false, "Catch has been called");
    })
    .then(
      function(what) {
        ok(true, "Then.resolve has been called");
        is(what, 44, "Value == 44");
        runTest();
      },
      function(what) {
        ok(false, "Then.reject has been called");
      }
    );
}

function promiseRejectThenCatchThen() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  var promise2 = promise.then(
    function(what) {
      ok(false, "Then.resolve has been called");
    },
    function(what) {
      ok(true, "Then.reject has been called");
      is(what, 42, "Value == 42");
      return what + 1;
    }
  );

  isnot(promise, promise2, "These 2 promise objs are different");

  promise2
    .then(function(what) {
      ok(true, "Then.resolve has been called");
      is(what, 43, "Value == 43");
      return what + 1;
    })
    .catch(function(what) {
      ok(false, "Catch has been called");
    })
    .then(function(what) {
      ok(true, "Then.resolve has been called");
      is(what, 44, "Value == 44");
      runTest();
    });
}

function promiseRejectThenCatchThen2() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  promise
    .then(function(what) {
      ok(true, "Then.resolve has been called");
      is(what, 42, "Value == 42");
      return what + 1;
    })
    .catch(function(what) {
      is(what, 42, "Value == 42");
      ok(true, "Catch has been called");
      return what + 1;
    })
    .then(function(what) {
      ok(true, "Then.resolve has been called");
      is(what, 43, "Value == 43");
      runTest();
    });
}

function promiseRejectThenCatchExceptionThen() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  promise
    .then(
      function(what) {
        ok(false, "Then.resolve has been called");
      },
      function(what) {
        ok(true, "Then.reject has been called");
        is(what, 42, "Value == 42");
        throw what + 1;
      }
    )
    .catch(function(what) {
      ok(true, "Catch has been called");
      is(what, 43, "Value == 43");
      return what + 1;
    })
    .then(function(what) {
      ok(true, "Then.resolve has been called");
      is(what, 44, "Value == 44");
      runTest();
    });
}

function promiseThenCatchOrderingResolve() {
  var global = 0;
  var f = new Promise(function(r1, r2) {
    r1(42);
  });

  f.then(function() {
    f.then(function() {
      global++;
    });
    f.catch(function() {
      global++;
    });
    f.then(function() {
      global++;
    });
    setTimeout(function() {
      is(global, 2, "Many steps... should return 2");
      runTest();
    }, 0);
  });
}

function promiseThenCatchOrderingReject() {
  var global = 0;
  var f = new Promise(function(r1, r2) {
    r2(42);
  });

  f.then(
    function() {},
    function() {
      f.then(function() {
        global++;
      });
      f.catch(function() {
        global++;
      });
      f.then(
        function() {},
        function() {
          global++;
        }
      );
      setTimeout(function() {
        is(global, 2, "Many steps... should return 2");
        runTest();
      }, 0);
    }
  );
}

function promiseThenNoArg() {
  var promise = new Promise(function(resolve, reject) {
    resolve(42);
  });

  var clone = promise.then();
  isnot(promise, clone, "These 2 promise objs are different");
  promise.then(function(v) {
    clone.then(function(cv) {
      is(v, cv, "Both resolve to the same value");
      runTest();
    });
  });
}

function promiseThenUndefinedResolveFunction() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  try {
    promise.then(undefined, function(v) {
      is(v, 42, "Promise rejected with 42");
      runTest();
    });
  } catch (e) {
    ok(false, "then should not throw on undefined resolve function");
  }
}

function promiseThenNullResolveFunction() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  try {
    promise.then(null, function(v) {
      is(v, 42, "Promise rejected with 42");
      runTest();
    });
  } catch (e) {
    ok(false, "then should not throw on null resolve function");
  }
}

function promiseCatchNoArg() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  var clone = promise.catch();
  isnot(promise, clone, "These 2 promise objs are different");
  promise.catch(function(v) {
    clone.catch(function(cv) {
      is(v, cv, "Both reject to the same value");
      runTest();
    });
  });
}

function promiseNestedPromise() {
  new Promise(function(resolve, reject) {
    resolve(
      new Promise(function(r) {
        ok(true, "Nested promise is executed");
        r(42);
      })
    );
  }).then(function(value) {
    is(value, 42, "Nested promise is executed and then == 42");
    runTest();
  });
}

function promiseNestedNestedPromise() {
  new Promise(function(resolve, reject) {
    resolve(
      new Promise(function(r) {
        ok(true, "Nested promise is executed");
        r(42);
      }).then(function(what) {
        return what + 1;
      })
    );
  }).then(function(value) {
    is(value, 43, "Nested promise is executed and then == 43");
    runTest();
  });
}

function promiseWrongNestedPromise() {
  new Promise(function(resolve, reject) {
    resolve(
      new Promise(function(r, r2) {
        ok(true, "Nested promise is executed");
        r(42);
      })
    );
    reject(42);
  }).then(
    function(value) {
      is(value, 42, "Nested promise is executed and then == 42");
      runTest();
    },
    function(value) {
      ok(false, "This is wrong");
    }
  );
}

function promiseLoop() {
  new Promise(function(resolve, reject) {
    resolve(
      new Promise(function(r1, r2) {
        ok(true, "Nested promise is executed");
        r1(
          new Promise(function(r3, r4) {
            ok(true, "Nested nested promise is executed");
            r3(42);
          })
        );
      })
    );
  }).then(
    function(value) {
      is(value, 42, "Nested nested promise is executed and then == 42");
      runTest();
    },
    function(value) {
      ok(false, "This is wrong");
    }
  );
}

function promiseStaticReject() {
  var promise = Promise.reject(42).then(
    function(what) {
      ok(false, "This should not be called");
    },
    function(what) {
      is(what, 42, "Value == 42");
      runTest();
    }
  );
}

function promiseStaticResolve() {
  var promise = Promise.resolve(42).then(
    function(what) {
      is(what, 42, "Value == 42");
      runTest();
    },
    function() {
      ok(false, "This should not be called");
    }
  );
}

function promiseResolveNestedPromise() {
  var promise = Promise.resolve(
    new Promise(
      function(r, r2) {
        ok(true, "Nested promise is executed");
        r(42);
      },
      function() {
        ok(false, "This should not be called");
      }
    )
  ).then(
    function(what) {
      is(what, 42, "Value == 42");
      runTest();
    },
    function() {
      ok(false, "This should not be called");
    }
  );
}

function promiseUtilitiesDefined() {
  ok(Promise.all, "Promise.all must be defined when Promise is enabled.");
  ok(Promise.race, "Promise.race must be defined when Promise is enabled.");
  runTest();
}

function promiseAllArray() {
  var p = Promise.all([1, new Date(), Promise.resolve("firefox")]);
  ok(p instanceof Promise, "Return value of Promise.all should be a Promise.");
  p.then(
    function(values) {
      ok(Array.isArray(values), "Resolved value should be an array.");
      is(
        values.length,
        3,
        "Resolved array length should match iterable's length."
      );
      is(values[0], 1, "Array values should match.");
      ok(values[1] instanceof Date, "Array values should match.");
      is(values[2], "firefox", "Array values should match.");
      runTest();
    },
    function() {
      ok(
        false,
        "Promise.all shouldn't fail when iterable has no rejected Promises."
      );
      runTest();
    }
  );
}

function promiseAllWaitsForAllPromises() {
  var arr = [
    new Promise(function(resolve) {
      setTimeout(resolve.bind(undefined, 1), 50);
    }),
    new Promise(function(resolve) {
      setTimeout(resolve.bind(undefined, 2), 10);
    }),
    new Promise(function(resolve) {
      setTimeout(
        resolve.bind(
          undefined,
          new Promise(function(resolve2) {
            resolve2(3);
          })
        ),
        10
      );
    }),
    new Promise(function(resolve) {
      setTimeout(resolve.bind(undefined, 4), 20);
    }),
  ];

  var p = Promise.all(arr);
  p.then(
    function(values) {
      ok(Array.isArray(values), "Resolved value should be an array.");
      is(
        values.length,
        4,
        "Resolved array length should match iterable's length."
      );
      is(values[0], 1, "Array values should match.");
      is(values[1], 2, "Array values should match.");
      is(values[2], 3, "Array values should match.");
      is(values[3], 4, "Array values should match.");
      runTest();
    },
    function() {
      ok(
        false,
        "Promise.all shouldn't fail when iterable has no rejected Promises."
      );
      runTest();
    }
  );
}

function promiseAllRejectFails() {
  var arr = [
    new Promise(function(resolve) {
      setTimeout(resolve.bind(undefined, 1), 50);
    }),
    new Promise(function(resolve, reject) {
      setTimeout(reject.bind(undefined, 2), 10);
    }),
    new Promise(function(resolve) {
      setTimeout(resolve.bind(undefined, 3), 10);
    }),
    new Promise(function(resolve) {
      setTimeout(resolve.bind(undefined, 4), 20);
    }),
  ];

  var p = Promise.all(arr);
  p.then(
    function(values) {
      ok(
        false,
        "Promise.all shouldn't resolve when iterable has rejected Promises."
      );
      runTest();
    },
    function(e) {
      ok(
        true,
        "Promise.all should reject when iterable has rejected Promises."
      );
      is(e, 2, "Rejection value should match.");
      runTest();
    }
  );
}

function promiseRaceEmpty() {
  var p = Promise.race([]);
  ok(p instanceof Promise, "Should return a Promise.");
  // An empty race never resolves!
  runTest();
}

function promiseRaceValuesArray() {
  var p = Promise.race([true, new Date(), 3]);
  ok(p instanceof Promise, "Should return a Promise.");
  p.then(
    function(winner) {
      is(winner, true, "First value should win.");
      runTest();
    },
    function(err) {
      ok(false, "Should not fail " + err + ".");
      runTest();
    }
  );
}

function promiseRacePromiseArray() {
  var arr = [
    new Promise(function(resolve) {
      resolve("first");
    }),
    Promise.resolve("second"),
    new Promise(function() {}),
    new Promise(function(resolve) {
      setTimeout(function() {
        setTimeout(function() {
          resolve("fourth");
        }, 0);
      }, 0);
    }),
  ];

  var p = Promise.race(arr);
  p.then(function(winner) {
    is(winner, "first", "First queued resolution should win the race.");
    runTest();
  });
}

function promiseRaceReject() {
  var p = Promise.race([
    Promise.reject(new Error("Fail bad!")),
    new Promise(function(resolve) {
      setTimeout(resolve, 0);
    }),
  ]);

  p.then(
    function() {
      ok(false, "Should not resolve when winning Promise rejected.");
      runTest();
    },
    function(e) {
      ok(true, "Should be rejected");
      ok(e instanceof Error, "Should reject with Error.");
      ok(e.message == "Fail bad!", "Message should match.");
      runTest();
    }
  );
}

function promiseRaceThrow() {
  var p = Promise.race([
    new Promise(function(resolve) {
      nonExistent();
    }),
    new Promise(function(resolve) {
      setTimeout(resolve, 0);
    }),
  ]);

  p.then(
    function() {
      ok(false, "Should not resolve when winning Promise had an error.");
      runTest();
    },
    function(e) {
      ok(true, "Should be rejected");
      ok(
        e instanceof ReferenceError,
        "Should reject with ReferenceError for function nonExistent()."
      );
      runTest();
    }
  );
}

function promiseResolveArray() {
  var p = Promise.resolve([1, 2, 3]);
  ok(p instanceof Promise, "Should return a Promise.");
  p.then(function(v) {
    ok(Array.isArray(v), "Resolved value should be an Array");
    is(v.length, 3, "Length should match");
    is(v[0], 1, "Resolved value should match original");
    is(v[1], 2, "Resolved value should match original");
    is(v[2], 3, "Resolved value should match original");
    runTest();
  });
}

function promiseResolveThenable() {
  var p = Promise.resolve({
    then(onFulfill, onReject) {
      onFulfill(2);
    },
  });
  ok(p instanceof Promise, "Should cast to a Promise.");
  p.then(
    function(v) {
      is(v, 2, "Should resolve to 2.");
      runTest();
    },
    function(e) {
      ok(false, "promiseResolveThenable should've resolved");
      runTest();
    }
  );
}

function promiseResolvePromise() {
  var original = Promise.resolve(true);
  var cast = Promise.resolve(original);

  ok(cast instanceof Promise, "Should cast to a Promise.");
  is(cast, original, "Should return original Promise.");
  cast.then(function(v) {
    is(v, true, "Should resolve to true.");
    runTest();
  });
}

// Bug 1009569.
// Ensure that thenables are run on a clean stack asynchronously.
// Test case adopted from
// https://gist.github.com/getify/d64bb01751b50ed6b281#file-bug1-js.
function promiseResolveThenableCleanStack() {
  function immed(s) {
    x++;
    s();
  }
  function incX() {
    x++;
  }

  var x = 0;
  var thenable = { then: immed };
  var results = [];

  var p = Promise.resolve(thenable).then(incX);
  results.push(x);

  // check what happens after all "next cycle" steps
  // have had a chance to complete
  setTimeout(function() {
    // Result should be [0, 2] since `thenable` will be called async.
    is(results[0], 0, "Expected thenable to be called asynchronously");
    // See Bug 1023547 comment 13 for why this check has to be gated on p.
    p.then(function() {
      results.push(x);
      is(results[1], 2, "Expected thenable to be called asynchronously");
      runTest();
    });
  }, 1000);
}

// Bug 1062323
function promiseWrapperAsyncResolution() {
  var p = new Promise(function(resolve, reject) {
    resolve();
  });

  var results = [];
  var q = p
    .then(function() {
      results.push("1-1");
    })
    .then(function() {
      results.push("1-2");
    })
    .then(function() {
      results.push("1-3");
    });

  var r = p
    .then(function() {
      results.push("2-1");
    })
    .then(function() {
      results.push("2-2");
    })
    .then(function() {
      results.push("2-3");
    });

  Promise.all([q, r]).then(
    function() {
      var match =
        results[0] == "1-1" &&
        results[1] == "2-1" &&
        results[2] == "1-2" &&
        results[3] == "2-2" &&
        results[4] == "1-3" &&
        results[5] == "2-3";
      ok(match, "Chained promises should resolve asynchronously.");
      runTest();
    },
    function() {
      ok(false, "promiseWrapperAsyncResolution: One of the promises failed.");
      runTest();
    }
  );
}

var tests = [
  promiseResolve,
  promiseReject,
  promiseException,
  promiseAsync_TimeoutResolveThen,
  promiseAsync_ResolveTimeoutThen,
  promiseAsync_ResolveThenTimeout,
  promiseAsync_SyncXHRAndImportScripts,
  promiseDoubleThen,
  promiseThenException,
  promiseThenCatchThen,
  promiseRejectThenCatchThen,
  promiseRejectThenCatchThen2,
  promiseRejectThenCatchExceptionThen,
  promiseThenCatchOrderingResolve,
  promiseThenCatchOrderingReject,
  promiseNestedPromise,
  promiseNestedNestedPromise,
  promiseWrongNestedPromise,
  promiseLoop,
  promiseStaticReject,
  promiseStaticResolve,
  promiseResolveNestedPromise,
  promiseResolveNoArg,
  promiseRejectNoArg,

  promiseThenNoArg,
  promiseThenUndefinedResolveFunction,
  promiseThenNullResolveFunction,
  promiseCatchNoArg,
  promiseRejectNoHandler,

  promiseUtilitiesDefined,

  promiseAllArray,
  promiseAllWaitsForAllPromises,
  promiseAllRejectFails,

  promiseRaceEmpty,
  promiseRaceValuesArray,
  promiseRacePromiseArray,
  promiseRaceReject,
  promiseRaceThrow,

  promiseResolveArray,
  promiseResolveThenable,
  promiseResolvePromise,

  promiseResolveThenableCleanStack,

  promiseWrapperAsyncResolution,
];

function runTest() {
  if (!tests.length) {
    postMessage({ type: "finish" });
    return;
  }

  var test = tests.shift();
  test();
}

onmessage = function() {
  runTest();
};