@qooxdoo/framework 7.8.0 → 7.9.1

package/source/class/qx/test/Promise.js

@@ -2,6 +2,18 @@ qx.Class.define("qx.test.Promise", {
   extend: qx.dev.unit.TestCase,
 
   members: {
+    /**
+     * Tests the isPromise method
+     */
+    testIsPromise() {
+      var p = new qx.Promise(function () {});
+      this.assertTrue(qx.Promise.isPromise(p));
+      this.assertFalse(qx.Promise.isPromise(null));
+      this.assertFalse(qx.Promise.isPromise({}));
+      this.assertTrue(qx.Promise.isPromise(qx.Promise.resolve()));
+      this.assertTrue(qx.Promise.isPromise(Promise.resolve()));
+      this.assertTrue(qx.Promise.isPromise({ then: function () {} }));
+    },
     /**
      * Tests a new promise that resolves with no errors
      */
@@ -52,8 +64,332 @@ qx.Class.define("qx.test.Promise", {
       this.wait(1000);
     },
 
+    /**
+     * Tests promise being rejected externally using `reject` method
+     * Also tests binding catch
+     */
+    testExternalReject() {
+      var promise = new qx.Promise();
+      promise.catch(function (e) {
+        this.assertEquals("oops", e.message);
+        setTimeout(() => this.resume(), 1);
+      }, this);
+      promise.reject(new Error("oops"));
+      this.wait(1000);
+    },
+
+    /**
+     * Tests that cancelling promise will cause `then` and `catch` to not be called
+     * (finally must be called)
+     */
+    testCancel1() {
+      if (qx.core.Environment.get("qx.Promise.useNativePromise")) {
+        console.warn(
+          "Skipping test because the native promise implementation of qx.Promise does not support cancellation"
+        );
+        return;
+      } else {
+        let promise = new qx.Promise((resolve, reject) => {
+          setTimeout(() => {
+            resolve();
+          }, 500);
+        });
+        promise
+          .then(() => this.fail("Should not call!"))
+          .then(() => this.fail("Should not call!"));
+
+        promise.catch(() => {
+          this.fail("Should not call!");
+        });
+
+        let output = "";
+
+        promise
+          .then(
+            () => new qx.Promise((resolve, reject) => reject(new Error("oops")))
+          )
+          .catch(() => this.fail("Should not call!"))
+          .finally(() => {
+            output += "1";
+          })
+          .then(() => {
+            this.fail("Should not call!");
+          });
+
+        let f = promise.finally(() => {
+          setTimeout(() => {
+            output += "2";
+            this.assertEquals("12", output);
+            this.resume();
+          }, 100);
+        });
+        this.assertInstance(f, qx.Promise);
+        promise.cancel();
+        this.wait(1000);
+      }
+    },
+
+    /**
+     * Ensures that non of the handlers in the chain are called when a promise is cancelled immediately
+     */
+    testCancel2() {
+      if (qx.core.Environment.get("qx.Promise.useNativePromise")) {
+        console.warn(
+          "Skipping test because the native promise implementation of qx.Promise does not support cancellation"
+        );
+        return;
+      } else {
+        let output = "";
+        let promise = qx.Promise.resolve()
+          .then(
+            () =>
+              new qx.Promise(resolve => {
+                output += "1";
+                setTimeout(resolve, 100);
+              })
+          )
+          .then(
+            () =>
+              new qx.Promise(resolve => {
+                output += "2";
+                setTimeout(resolve, 100);
+              })
+          )
+          .then(
+            () =>
+              new qx.Promise(resolve => {
+                output += "3";
+                setTimeout(resolve, 100);
+              })
+          )
+          .finally(() => {
+            this.assertEquals("", output);
+            this.resume();
+          });
+
+        promise.cancel();
+        this.wait(1000);
+      }
+    },
+
+    /**
+     * Ensures that the promise chain does not continue after a promise is cancelled, except ALL the `finally` calls
+     * which are both ancestors and descendants of the cancelled promise, which have not been called yet.
+    
+     */
+    testCancel3() {
+      if (qx.core.Environment.get("qx.Promise.useNativePromise")) {
+        console.warn(
+          "Skipping test because the native promise implementation of qx.Promise does not support cancellation"
+        );
+        return;
+      } else {
+        let output = "";
+        let promise = qx.Promise.resolve()
+          .then(
+            () =>
+              new qx.Promise(resolve => {
+                output += "1";
+                setTimeout(resolve, 100);
+              })
+          )
+          .then(
+            () =>
+              new qx.Promise(resolve => {
+                output += "2";
+                setTimeout(resolve, 100);
+                setTimeout(() => promise.cancel(), 150);
+              })
+          )
+          .finally(() => {
+            if (output.at(-1) !== "2") {
+              this.fail("finally called twice!");
+            }
+            output += "3";
+          })
+          .then(
+            () =>
+              new qx.Promise(resolve => {
+                output += "4";
+                setTimeout(resolve, 100);
+              })
+          )
+          .then(
+            () =>
+              new qx.Promise(resolve => {
+                this.fail("Should not call!");
+              })
+          )
+          .finally(() => {
+            output += "5";
+          })
+          .then(() => this.fail("should not call!"))
+          .finally(() => {
+            output += "6";
+          });
+
+        let promise2 = promise
+          .then(() => this.fail("should not call!"))
+          .finally(() => {
+            output += "7";
+          })
+          .then(() => this.fail("should not call!"))
+          .finally(() => {
+            output += "8";
+            this.assertEquals("12345678", output);
+            this.resume();
+          });
+
+        this.wait(1000);
+      }
+    },
+
+    /**
+     * Tests that cancelling a promise will not stop its chain from executing if there are promises which depend on some stages in the chain
+     */
+    testCancel4() {
+      if (qx.core.Environment.get("qx.Promise.useNativePromise")) {
+        console.warn(
+          "Skipping test because the native promise implementation of qx.Promise does not support cancellation"
+        );
+        return;
+      } else {
+        let output = "";
+        let promise1 = qx.Promise.resolve().then(() => {
+          output += "1";
+        });
+
+        let branch1 = promise1.then(() => {
+          output += "2";
+        });
+        let branch2 = promise1
+          .then(() => (output += "3"))
+          .finally(() => {
+            setTimeout(() => {
+              this.assertEquals("13", output);
+              this.resume();
+            }, 100);
+          });
+
+        branch1.cancel();
+        this.wait(1000);
+      }
+    },
+
+    /**
+     * Ensures exception is thrown when trying to call `then` for a promise which has already been cancelled.
+     */
+    testThenAfterCancel() {
+      if (qx.core.Environment.get("qx.Promise.useNativePromise")) {
+        console.warn(
+          "Skipping test because the native promise implementation of qx.Promise does not support cancellation"
+        );
+        return;
+      } else {
+        let promise = new qx.Promise((resolve, reject) => {
+          setTimeout(() => {
+            resolve();
+          }, 300);
+        });
+        promise.cancel();
+        promise
+          .then(() => this.fail("Should not call!"))
+          .catch(e => {
+            this.assertEquals("late cancellation observer", e.message);
+            setTimeout(this.resume(), 1);
+          });
+
+        this.wait(1000);
+      }
+    },
+
+    /**
+     * Ensures exception is thrown when trying to call `catch` for a promise which has already been cancelled.
+     */
+    testCatchAfterCancel() {
+      if (qx.core.Environment.get("qx.Promise.useNativePromise")) {
+        console.warn(
+          "Skipping test because the native promise implementation of qx.Promise does not support cancellation"
+        );
+        return;
+      } else {
+        let promise = new qx.Promise((resolve, reject) => {
+          setTimeout(() => {
+            resolve();
+          }, 300);
+        });
+        promise.cancel();
+        promise
+          .then(() => {
+            this.fail("Should not call!");
+          })
+          .catch(e => {
+            this.assertEquals("late cancellation observer", e.message);
+            setTimeout(() => this.resume(), 1);
+          });
+
+        this.wait(1000);
+      }
+    },
+
+    /**
+     * Ensures exception is thrown when trying to call `finally` for a promise which has already been cancelled.
+     */
+    testFinallyAfterCancel() {
+      if (qx.core.Environment.get("qx.Promise.useNativePromise")) {
+        console.warn(
+          "Skipping test because the native promise implementation of qx.Promise does not support cancellation"
+        );
+        return;
+      } else {
+        let promise = new qx.Promise((resolve, reject) => {
+          setTimeout(() => {
+            resolve();
+          }, 300);
+        });
+        promise.cancel();
+        promise
+          .then(() => {
+            this.fail("Should not call!");
+          })
+          .catch(e => {
+            this.assertEquals("late cancellation observer", e.message);
+            setTimeout(() => this.resume(), 1);
+          });
+
+        this.wait(1000);
+      }
+    },
+
+    /**
+     * Ensures a promise can still be cancelled after it has been settled
+     */
+    testCancelAfterSettled() {
+      if (qx.core.Environment.get("qx.Promise.useNativePromise")) {
+        console.warn(
+          "Skipping test because the native promise implementation of qx.Promise does not support cancellation"
+        );
+        return;
+      } else {
+        let promise = qx.Promise.resolve();
+        promise
+          .then(() => {
+            promise.cancel();
+          })
+          .then(() => {
+            setTimeout(() => this.resume(), 1);
+          });
+
+        this.wait(1000);
+      }
+    },
+
+    /**
+     * Ensures that `finally` is run when the promise rejects
+     */
     testCatchFinally() {
       var caughtException = null;
+      var t = this;
       qx.Promise.resolve()
         .then(function () {
           throw new Error("oops");
@@ -63,11 +399,59 @@ qx.Class.define("qx.test.Promise", {
         })
         .finally(function () {
           this.assertNotNull(caughtException);
-          this.resume();
+          this.assertIdentical(this, t);
+          setTimeout(() => this.resume(), 1);
         }, this);
       this.wait(1000);
     },
 
+    /**
+     * Tests that the `promisify` method works for operations functions.
+     * Also ensures the return value of `.then` is a qx.Promise
+     */
+    testPromisifyResolve() {
+      function feedMe(fruit, callback) {
+        setTimeout(function () {
+          if (fruit == "raspberry") {
+            callback(null, "That's nice");
+          } else {
+            callback(new Error("No thank you!"), null);
+          }
+        }, 100);
+      }
+
+      let feedMeAsync = qx.Promise.promisify(feedMe);
+
+      feedMeAsync("raspberry").then(value => {
+        this.assertEquals("That's nice", value);
+        this.resume();
+      });
+      this.wait(1000);
+    },
+
+    /**
+     * Tests that the `promisify` method works for unsuccessful operations
+     */
+    testPromisifyReject() {
+      function feedMe(fruit, callback) {
+        setTimeout(function () {
+          if (fruit == "raspberry") {
+            callback(null, "That's nice");
+          } else {
+            callback(new Error("No thank you!"), null);
+          }
+        }, 100);
+      }
+
+      let feedMeAsync = qx.Promise.promisify(feedMe);
+
+      feedMeAsync("ping pong balls").catch(err => {
+        this.assertEquals("No thank you!", err.message);
+        this.resume();
+      });
+      this.wait(1000);
+    },
+
     /**
      * Tests the qx.Promise.allOf method
      */
@@ -82,14 +466,16 @@ qx.Class.define("qx.test.Promise", {
         e: dt
       };
 
-      qx.Promise.allOf(obj).then(function (obj2) {
+      let promise = qx.Promise.allOf(obj);
+      this.assertInstance(promise, qx.Promise);
+      promise.then(function (obj2) {
         t.assertTrue(obj === obj2);
         t.assertEquals("one", obj.a);
         t.assertEquals("two", obj.b);
         t.assertEquals("three", obj.c);
         t.assertEquals("four", obj.d);
         t.assertTrue(obj.e === dt);
-        t.resume();
+        setTimeout(() => t.resume(), 1);
       });
       obj.a.then(function () {
         obj.b.resolve("two");
@@ -101,6 +487,51 @@ qx.Class.define("qx.test.Promise", {
       t.wait(1000);
     },
 
+    /**
+     * Checks that if one of the promises in the allOf array rejects,
+     * the overall result will reject
+     */
+    testAllOfReject() {
+      var t = this;
+      var obj = {
+        a: new qx.Promise(),
+        b: new qx.Promise()
+      };
+
+      qx.Promise.allOf(qx.Promise.resolve(obj)).catch(function (reason) {
+        t.assertEquals("two", reason.message);
+        setTimeout(() => t.resume(), 1);
+      });
+
+      obj.b.reject(new Error("two"));
+      obj.a.resolve("one");
+      t.wait(1000);
+    },
+
+    /**
+     * Tests the qx.Promise.allOf being passed a promise of an object instead of a straight value
+     */
+    testAllOfPromiseObj() {
+      var t = this;
+      var obj = {
+        a: new qx.Promise(),
+        b: new qx.Promise()
+      };
+
+      qx.Promise.allOf(qx.Promise.resolve(obj)).then(function (obj2) {
+        t.assertTrue(obj === obj2);
+        t.assertEquals("one", obj.a);
+        t.assertEquals("two", obj.b);
+
+        setTimeout(() => t.resume(), 1);
+      });
+      obj.a.then(function () {
+        obj.b.resolve("two");
+      });
+      obj.a.resolve("one");
+      t.wait(1000);
+    },
+
     /**
      * Tests that setting a property value with a promise will delay setting the
      * value until the promise is resolved.  In this case, the property is *not*
@@ -128,7 +559,7 @@ qx.Class.define("qx.test.Promise", {
       p.then(function () {
         t.assertEquals(123, obj.getAlpha());
         qx.Class.undefine("testPropertySetValueAsPromise1.Clazz");
-        t.resume();
+        setTimeout(() => t.resume(), 1);
       });
       this.wait(1000);
     },
@@ -160,7 +591,7 @@ qx.Class.define("qx.test.Promise", {
       obj.setAlphaAsync(p).then(function () {
         t.assertEquals(123, obj.getAlpha());
         qx.Class.undefine("testPropertySetValueAsPromise2.Clazz");
-        t.resume();
+        setTimeout(() => t.resume(), 1);
       });
       this.wait(1000);
     },
@@ -623,7 +1054,7 @@ qx.Class.define("qx.test.Promise", {
     },
 
     /**
-     * Tests the each method of promise, using qx.data.Array which the Bluebird implementation
+     * Tests the each method of promise, using qx.data.Array which the native Promise
      * does not understand.  The values are scalar values
      */
     testEach1() {
@@ -634,19 +1065,20 @@ qx.Class.define("qx.test.Promise", {
       arr.push("c");
       var str = "";
       var promise = qx.Promise.resolve(arr);
-      promise
-        .forEach(function (item) {
-          str += item;
-        })
-        .then(function () {
-          t.assertEquals("abc", str);
-          t.resume();
-        });
+      var forEachReturn = promise.forEach(function (item) {
+        str += item;
+        this.assertIdentical(t, this);
+      }, this);
+      forEachReturn.then(function () {
+        t.assertEquals("abc", str);
+        setTimeout(() => t.resume(), 1);
+      });
+      this.assertInstance(forEachReturn, qx.Promise);
       t.wait(1000);
     },
 
     /**
-     * Tests the each method of promise, using qx.data.Array which the Bluebird implementation
+     * Tests the each method of promise, using qx.data.Array which the native Promise
      * does not understand.  The values are a mixture of promises and scalar values
      */
     testEach2() {
@@ -693,6 +1125,39 @@ qx.Class.define("qx.test.Promise", {
       t.wait(1000);
     },
 
+    /**
+     * Checks that the each method will reject if one of the promises in the array rejects
+     */
+    testEachReject() {
+      let arr = [qx.Promise.resolve("a"), qx.Promise.reject(new Error("b"))];
+
+      var str = "";
+      var promiseArr = qx.Promise.resolve(arr);
+      var pEach = qx.Promise.forEach(promiseArr, function (item) {
+        str += item;
+      });
+      pEach.catch(reason => {
+        this.assertEquals("b", reason.message);
+        setTimeout(() => this.resume(), 1);
+      });
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `each` method being passed with a promise of an array,
+     * not a straight array
+     */
+    testEachPromiseArray() {
+      var promiseArr = qx.Promise.resolve([1, 2, 3]);
+
+      qx.Promise.forEach(promiseArr, (item, index) => {
+        this.assertEquals(index, item - 1);
+      }).then(result => {
+        setTimeout(() => this.resume(), 1);
+      });
+      this.wait(1000);
+    },
+
     /**
      * Tests unhandled rejections being passed to the global error handler
      */
@@ -700,6 +1165,7 @@ qx.Class.define("qx.test.Promise", {
       var t = this;
       qx.event.GlobalError.setErrorHandler(function (ex) {
         t.assertEquals(ex.message, "oops");
+        qx.event.GlobalError.setErrorHandler(null);
         t.resume();
       });
       var self = this;
@@ -726,7 +1192,7 @@ qx.Class.define("qx.test.Promise", {
       this.assertInstance(promise, qx.Promise);
       promise.then(function (value) {
         t.assertEquals(value, "yes");
-        t.resume();
+        setTimeout(() => t.resume(), 1);
       });
       this.wait(1000);
     },
@@ -739,7 +1205,7 @@ qx.Class.define("qx.test.Promise", {
       var p = qx.Promise.resolve("hello").bind(this);
       p.then(function (value) {
         qx.core.Assert.assertIdentical(t, this);
-        t.resume();
+        setTimeout(() => this.resume(), 1);
       });
       this.wait(1000);
     },
@@ -757,7 +1223,7 @@ qx.Class.define("qx.test.Promise", {
         this
       ).then(function (value) {
         qx.core.Assert.assertIdentical(t, this);
-        this.resume();
+        setTimeout(() => this.resume(), 1);
       }, this);
       this.wait(1000);
     },
@@ -775,7 +1241,7 @@ qx.Class.define("qx.test.Promise", {
       var t = this;
       qx.Promise.resolve(true).then(function () {
         qx.core.Assert.assertIdentical(qx.Promise, this);
-        t.resume();
+        setTimeout(() => t.resume(), 1);
       }, qx.Promise);
       this.wait(1000);
     },
@@ -787,7 +1253,7 @@ qx.Class.define("qx.test.Promise", {
       var t = this;
       qx.Promise.resolve(true, this).then(function () {
         qx.core.Assert.assertIdentical(t, this);
-        t.resume();
+        setTimeout(() => this.resume(), 1);
       });
       this.wait(1000);
     },
@@ -799,7 +1265,7 @@ qx.Class.define("qx.test.Promise", {
       var t = this;
       qx.Promise.reject(new Error("Dummy Error"), this).catch(function () {
         qx.core.Assert.assertIdentical(t, this);
-        t.resume();
+        setTimeout(() => this.resume(), 1);
       });
       this.wait(1000);
     },
@@ -819,8 +1285,665 @@ qx.Class.define("qx.test.Promise", {
           t.assertEquals(str, "foo");
           t.assertInstance(arr, qx.data.Array);
           t.assertEquals(arr.join(""), "abc");
-          t.resume();
+          setTimeout(() => t.resume(), 1);
+        });
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `race` method when no promises in the array reject
+     */
+    testRaceResolve() {
+      var promiseB = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve("b");
+        }, 200);
+      });
+      var promiseC = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve("c");
+        }, 100);
+      });
+      var promiseD = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve("d");
+        }, 300);
+      });
+      var arr = [promiseB, promiseC, promiseD];
+      let promise = qx.Promise.resolve(arr).race();
+      promise.then(val => {
+        this.assertEquals("c", val);
+        this.resume();
+      });
+      this.assertInstance(promise, qx.Promise);
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `race` method when one promise in the array rejects
+     */
+    testRaceReject() {
+      var promiseB = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve("b");
+        }, 200);
+      });
+      var promiseC = new qx.Promise(function (resolve, reject) {
+        setTimeout(function () {
+          reject(new Error("c"));
+        }, 100);
+      });
+      var arr = new qx.data.Array([promiseB, promiseC]);
+      qx.Promise.resolve(arr)
+        .race()
+        .then(val => {
+          this.fail("Should not resolve");
+        })
+        .catch(err => {
+          this.assertEquals("c", err.message);
+          this.resume();
         });
+
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `race` method when the array contains a straight (i.e. non-promise) value
+     */
+    testRaceStraightValue() {
+      var promiseB = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve("b");
+        }, 200);
+      });
+      var arr = ["a", promiseB];
+      qx.Promise.race(qx.Promise.resolve(arr)).then(val => {
+        this.assertEquals("a", val);
+        setTimeout(() => this.resume(), 1);
+      });
+
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `any` method when all promises in the array resolve
+     */
+    testAnyResolve() {
+      var promiseB = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve("b");
+        }, 200);
+      });
+      var promiseC = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve("c");
+        }, 100);
+      });
+      var promiseD = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve("d");
+        }, 300);
+      });
+      var arr = [promiseB, promiseC, promiseD];
+      let promise = qx.Promise.resolve(arr).any();
+      promise.then(val => {
+        this.assertEquals("c", val);
+        this.resume();
+      });
+      this.assertInstance(promise, qx.Promise);
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `any` method when one promise in the array rejects.
+     * The overall result should the result of the first promise that resolves
+     */
+    testAnyOneReject() {
+      var promiseB = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve("b");
+        }, 200);
+      });
+      var promiseC = new qx.Promise(function (resolve, reject) {
+        setTimeout(function () {
+          reject(new Error("c"));
+        }, 100);
+      });
+      var promiseD = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve("d");
+        }, 300);
+      });
+      var arr = new qx.data.Array([promiseB, promiseC, promiseD]);
+      qx.Promise.any(qx.Promise.resolve(arr)).then(val => {
+        this.assertEquals("b", val);
+        this.resume();
+      });
+
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `any` method when all promises in the array reject.
+     */
+    testAnyAllReject() {
+      var promiseB = new qx.Promise(function (resolve, reject) {
+        setTimeout(function () {
+          reject(new Error("b"));
+        }, 200);
+      });
+      var promiseC = new qx.Promise(function (resolve, reject) {
+        setTimeout(function () {
+          reject(new Error("c"));
+        }, 100);
+      });
+      var promiseD = new qx.Promise(function (resolve, reject) {
+        setTimeout(function () {
+          reject(new Error("d"));
+        }, 300);
+      });
+
+      var arr = [promiseB, promiseC, promiseD];
+      qx.Promise.resolve(arr)
+        .any()
+        .catch(aggErr => {
+          this.resume();
+        });
+
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `any` method when an empty array is passed in.
+     */
+    testAnyEmptyArray() {
+      qx.Promise.resolve([])
+        .any()
+        .catch(aggErr => {
+          setTimeout(() => this.resume(), 1);
+        });
+
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `any` method when a straight (i.e. non-promise value) is passed in.
+     * It should resolve to that value
+     */
+    testAnyStraightValue() {
+      var promiseB = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve("b");
+        }, 200);
+      });
+      var arr = ["a", promiseB];
+      qx.Promise.resolve(arr)
+        .any()
+        .then(val => {
+          this.assertEquals("a", val);
+          setTimeout(() => this.resume(), 1);
+        });
+
+      this.wait(1000);
+    },
+
+    /**
+     * Tests that `reduce` succeeds when no promise rejects
+     */
+    testReduceResolve() {
+      var promiseB = qx.Promise.resolve(1);
+
+      var promiseC = qx.Promise.resolve(2);
+      var promiseD = qx.Promise.resolve(3);
+      var arr = [promiseB, promiseC, promiseD];
+      let promise = qx.Promise.resolve(arr).reduce(
+        async (acc, item, index, length) => {
+          this.assertEquals(index, item - 1);
+          this.assertEquals(length, 3);
+          return acc + item;
+        },
+        0
+      );
+      promise.then(result => {
+        this.assertEquals(6, result);
+        setTimeout(() => this.resume(), 1);
+      });
+      this.assertInstance(promise, qx.Promise);
+      this.wait(1000);
+    },
+
+    /**
+     * Tests that `reduce` rejects when one promise in the array rejects
+     */
+    testReduceOneReject() {
+      var promiseB = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve(2);
+        }, 200);
+      });
+
+      var promiseC = new qx.Promise(function (resolve, reject) {
+        setTimeout(function () {
+          reject(new Error("oops"));
+        }, 100);
+      });
+      var promiseD = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve(4);
+        }, 300);
+      });
+      var arr = new qx.data.Array([promiseB, promiseC, promiseD]);
+      qx.Promise.reduce(
+        qx.Promise.resolve(arr),
+        async (acc, item) => acc + item,
+        0
+      ).catch(err => {
+        this.assertEquals("oops", err.message);
+        this.resume();
+      });
+      this.wait(1000);
+    },
+
+    /**
+     * Tests that `reduce` rejects when the reducer function throws an error
+     */
+    testReduceMapperReject() {
+      var promiseB = qx.Promise.resolve(2);
+      var promiseC = qx.Promise.resolve(3);
+      var promiseD = qx.Promise.resolve(4);
+      var arr = [promiseB, promiseC, promiseD];
+      qx.Promise.resolve(arr)
+        .reduce(async (acc, item) => {
+          throw new Error("oops");
+        }, 0)
+        .catch(err => {
+          this.assertEquals("oops", err.message);
+          setTimeout(() => this.resume(), 1);
+        });
+      this.wait(1000);
+    },
+
+    /**
+     * Tests that `filter` succeeds when no promise rejects
+     */
+    testFilterResolve() {
+      var promiseB = qx.Promise.resolve(2);
+      var promiseC = qx.Promise.resolve(3);
+      var promiseD = qx.Promise.resolve(4);
+      var promiseE = qx.Promise.resolve(5);
+      var arr = [promiseB, promiseC, promiseD, promiseE, 6];
+      let t = this;
+      let p = qx.Promise.resolve(arr).filter(async function (
+        item,
+        index,
+        length
+      ) {
+        t.assertEquals(index, item - 2);
+        t.assertEquals(5, length);
+        t.assertIdentical(t, this);
+        return item % 2 === 0;
+      },
+      this);
+      p.then(evens => {
+        this.assertArrayEquals([2, 4, 6], evens);
+        //force resume to run on next tick so that we call resume after wait
+        setTimeout(() => this.resume(), 1);
+      });
+      this.assertInstance(p, qx.Promise);
+      this.wait(1000);
+    },
+
+    /**
+     * Tests `concurrency` option for method `filter`
+     */
+    testFilterConcurrency() {
+      let arr = new qx.data.Array([qx.Promise.resolve(1), 2, 3, 4]);
+
+      let maxReached = false;
+      let concurrency = 2;
+      let running = 0;
+
+      let t = this;
+
+      qx.Promise.filter(
+        qx.Promise.resolve(arr),
+        async function (item) {
+          running++;
+          if (running > concurrency) {
+            t.fail("Too many running tasks");
+          } else if (running == concurrency) {
+            maxReached = true;
+          }
+          await new Promise(resolve => setTimeout(resolve, 200));
+          running--;
+          return item % 2 === 0;
+        },
+        { concurrency }
+      ).then(result => {
+        this.assertTrue(maxReached);
+        this.assertArrayEquals([2, 4], result);
+        this.resume();
+      });
+
+      this.wait(1000);
+    },
+
+    /**
+     * Tests that `filter` rejects when one promise in the array rejects
+     */
+    testFilterRejectValue() {
+      var promiseB = qx.Promise.reject(new Error("oops"));
+
+      var promiseC = qx.Promise.resolve(3);
+      var promiseD = qx.Promise.resolve(4);
+      var arr = [promiseB, promiseC, promiseD, 6];
+      qx.Promise.resolve(arr)
+        .filter(async (item, index, length) => item % 2 === 0)
+        .catch(e => {
+          this.assertEquals("oops", e.message);
+          setTimeout(() => this.resume(), 1);
+        });
+
+      this.wait(1000);
+    },
+
+    /**
+     * Tests that `filter` rejects when the iterator function throws an error
+     */
+    testFilterRejectFilterer() {
+      var promiseB = qx.Promise.resolve(2);
+
+      var promiseC = qx.Promise.resolve(3);
+      var promiseD = qx.Promise.resolve(4);
+      var arr = [promiseB, promiseC, promiseD, 6];
+      qx.Promise.resolve(arr)
+        .filter(async item => {
+          throw new Error("oops");
+        })
+        .catch(e => {
+          this.assertEquals("oops", e.message);
+          setTimeout(() => this.resume(), 1);
+        });
+
+      this.wait(1000);
+    },
+
+    /**
+     * Tests that the `some` method resolves when no promise rejects
+     */
+    testSomeResolve() {
+      var promiseB = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve(2);
+        }, 200);
+      });
+
+      var promiseC = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve(3);
+        }, 100);
+      });
+      var promiseD = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve(4);
+        }, 300);
+      });
+      var arr = [promiseB, promiseC, promiseD, 6];
+      let p = qx.Promise.resolve(arr).some(2);
+      p.then(result => {
+        this.assertArrayEquals([6, 3], result);
+        this.resume();
+      });
+      this.assertInstance(p, qx.Promise);
+      this.wait(1000);
+    },
+
+    /**
+     * Tests that the `some` method still resolves when one promise rejects
+     * such that enough promises still resolve.
+     * Also tests with a straight value in the array
+     */
+    testSomeOneReject() {
+      var promiseB = new qx.Promise(function (resolve, reject) {
+        setTimeout(function () {
+          reject(new Error("oops"));
+        }, 200);
+      });
+
+      var promiseC = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve(3);
+        }, 100);
+      });
+      var promiseD = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve(4);
+        }, 300);
+      });
+      var arr = new qx.data.Array([promiseB, promiseC, promiseD, 6]);
+      qx.Promise.some(qx.Promise.resolve(arr), 3).then(result => {
+        this.assertArrayEquals([6, 3, 4], result);
+        this.resume();
+      });
+      this.wait(1000);
+    },
+
+    /**
+     * Ensures that the `some` method rejects
+     * when too many promises reject such that there aren't enough
+     * resolved promises to satisfy the count
+     */
+    testSomeTooManyReject() {
+      var promiseB = new qx.Promise(function (resolve, reject) {
+        setTimeout(function () {
+          reject(new Error("oops"));
+        }, 200);
+      });
+
+      var promiseC = new qx.Promise(function (resolve, reject) {
+        setTimeout(function () {
+          reject(new Error("oops1"));
+        }, 100);
+      });
+      var promiseD = new qx.Promise(function (resolve) {
+        setTimeout(function () {
+          resolve(4);
+        }, 300);
+      });
+      var arr = [promiseB, promiseC, promiseD, 6];
+      qx.Promise.resolve(arr)
+        .some(3)
+        .catch(error => {
+          let errors = qx.lang.Type.isArray(error.errors)
+            ? error.errors
+            : error;
+
+          this.assertArrayEquals(
+            ["oops1", "oops"],
+            errors.map(e => e.message)
+          );
+          this.resume();
+        });
+      this.wait(1000);
+    },
+
+    /**
+     * Ensures that the `map` method resolves when no promise rejects
+     */
+    testMapResolve() {
+      var promiseB = qx.Promise.resolve(2);
+
+      var promiseC = qx.Promise.resolve(3);
+      var promiseD = qx.Promise.resolve(4);
+      var arr = [promiseB, promiseC, promiseD, 5];
+      var t = this;
+      let p = qx.Promise.resolve(arr).map(function (item, index, length) {
+        t.assertEquals(index, item - 2);
+        t.assertEquals(length, 4);
+        this.assertIdentical(t, this);
+        return item * 2;
+      }, this);
+      p.then(result => {
+        this.assertArrayEquals([4, 6, 8, 10], result);
+        setTimeout(() => this.resume(), 1);
+      });
+      this.assertInstance(p, qx.Promise);
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `concurrency` option of the `map` method
+     */
+    testMapConcurrency() {
+      let promiseA = qx.Promise.resolve(1);
+      let arr = new qx.data.Array([promiseA, 2, 3, 4]);
+
+      let maxReached = false;
+      let concurrency = 2;
+      let running = 0;
+
+      let t = this;
+
+      let promise = qx.Promise.map(
+        qx.Promise.resolve(arr),
+        async function (item) {
+          running++;
+          if (running > concurrency) {
+            t.fail("Too many running tasks");
+          } else if (running == concurrency) {
+            maxReached = true;
+          }
+          await new qx.Promise(resolve => setTimeout(resolve, 200));
+          running--;
+          return item * 2;
+        },
+        { concurrency }
+      ).then(result => {
+        this.assertTrue(maxReached);
+        this.assertArrayEquals([2, 4, 6, 8], result);
+        this.resume();
+      });
+
+      this.assertInstance(promise, qx.Promise);
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `map` method when one promise in the array rejects
+     */
+    testMapOneReject() {
+      var promiseB = qx.Promise.resolve(2);
+
+      var promiseC = qx.Promise.reject(new Error("oops"));
+      var promiseD = qx.Promise.resolve(4);
+      var arr = [promiseB, promiseC, promiseD];
+      qx.Promise.resolve(arr)
+        .map(async item => item * 2)
+        .catch(err => {
+          this.assertEquals("oops", err.message);
+          setTimeout(() => this.resume(), 1);
+        });
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `map` method rejects when the iterator (mapper) function rejects.
+     */
+    testMapMapperReject() {
+      var promiseB = qx.Promise.resolve(2);
+
+      var promiseC = qx.Promise.resolve(3);
+      var promiseD = qx.Promise.resolve(4);
+      var arr = [promiseB, promiseC, promiseD];
+      qx.Promise.resolve(arr)
+        .map(async item => {
+          throw new Error("oops");
+        })
+        .catch(err => {
+          this.assertEquals("oops", err.message);
+          setTimeout(() => this.resume(), 1);
+        });
+      this.wait(1000);
+    },
+
+    /**
+     * Ensures the `mapSeries` method resolves when no promise rejects.
+     * Also tests custom context for the iterator function
+     */
+    testMapSeriesResolve() {
+      var promiseB = qx.Promise.resolve(1);
+      var promiseC = qx.Promise.resolve(2);
+      var promiseD = qx.Promise.resolve(3);
+
+      let checkIndex = 0;
+
+      var arr = [promiseB, promiseC, promiseD, 4];
+      let p = qx.Promise.resolve(arr).mapSeries(async (item, index, length) => {
+        this.assertEquals(checkIndex++, index);
+        this.assertEquals(4, length);
+        return item * 2;
+      });
+      p.then(doubles => {
+        this.assertArrayEquals([2, 4, 6, 8], doubles);
+        setTimeout(() => this.resume(), 1);
+      });
+      this.assertInstance(p, qx.Promise);
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `mapSeries` method when one promise in the array rejects.
+     * The returned promise should reject.
+     */
+    testMapSeriesOneReject() {
+      var promiseB = qx.Promise.reject(new Error("oops"));
+      var promiseC = qx.Promise.resolve(2);
+      var promiseD = qx.Promise.resolve(3);
+
+      var arr = [promiseB, promiseC, promiseD];
+      qx.Promise.resolve(arr)
+        .mapSeries(async item => item * 2)
+        .catch(e => {
+          this.assertEquals("oops", e.message);
+          setTimeout(() => this.resume(), 1);
+        });
+
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `mapSeries` method when the iterator rejects.
+     * The returned promise should reject.
+     */
+    testMapSeriesMapperReject() {
+      var promiseB = qx.Promise.resolve(2);
+      var promiseC = qx.Promise.resolve(3);
+      var promiseD = qx.Promise.resolve(4);
+      var arr = [promiseB, promiseC, promiseD];
+      qx.Promise.resolve(arr)
+        .mapSeries(async item => {
+          throw new Error("oops");
+        })
+        .catch(err => {
+          this.assertEquals("oops", err.message);
+          setTimeout(() => this.resume(), 1);
+        });
+      this.wait(1000);
+    },
+
+    /**
+     * Tests the `mapSeries` being passed with the promise of the array,
+     * which is also a qx.data.Array, which the native Promise does not understand
+     */
+    testMapSeriesPromiseArray() {
+      var promiseArr = qx.Promise.resolve(new qx.data.Array([1, 2, 3]));
+
+      qx.Promise.mapSeries(promiseArr, (item, index) => {
+        this.assertEquals(index, item - 1);
+        return item * 2;
+      }).then(result => {
+        setTimeout(() => this.resume(), 1);
+      });
       this.wait(1000);
     }
   },