@qooxdoo/framework 7.7.1 → 7.8.0

package/source/class/qx/io/jsonrpc/protocol/Request.js

@@ -29,10 +29,17 @@ qx.Class.define("qx.io.jsonrpc.protocol.Request", {
      */
     __current_request_id: 0,
 
+    /**
+     * Returns the current request id
+     * @returns {Number}
+     */
     getCurrentId() {
       return qx.io.jsonrpc.protocol.Request.__current_request_id;
     },
 
+    /**
+     * Resets the request id to zero
+     */
     resetId() {
       qx.io.jsonrpc.protocol.Request.__current_request_id = 0;
     }
@@ -69,13 +76,14 @@ qx.Class.define("qx.io.jsonrpc.protocol.Request", {
     __promise: null,
 
     /**
-     * Getter for promise which resolves with the result to the request
+     * Getter for promise which resolves with the result to the request, if successful
      * @return {qx.Promise}
      */
     getPromise() {
       return this.__promise;
     },
 
+
     /**
      * Determines how an exception during transport is handled. Standard
      * behavior is to reject the request's promise with that exception.
@@ -84,11 +92,7 @@ qx.Class.define("qx.io.jsonrpc.protocol.Request", {
      * @param {qx.io.exception.Transport} exception
      */
     handleTransportException(exception) {
-      try {
-        this.getPromise().reject(exception);
-      } catch (e) {
-        this.warn("Promise has already been rejected");
-      }
+      this.__promise.reject(exception);
     }
   }
 });

package/source/class/qx/lang/Function.js

@@ -173,7 +173,7 @@ qx.Bootstrap.define("qx.lang.Function", {
         return func;
       }
 
-      return function (event) {
+      let result = function (event) {
         if (qx.core.Environment.get("qx.debug")) {
           function testSelf(self) {
             if (
@@ -233,6 +233,10 @@ qx.Bootstrap.define("qx.lang.Function", {
           return func.apply(options.self || this, args);
         }
       };
+      if (qx.core.Environment.get("qx.debug")) {
+        result.$$original = func;
+      }
+      return result;
     },
 
     /**

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

@@ -610,6 +610,266 @@ qx.Class.define("qx.test.Mixin", {
       var o = new qx.D();
       this.assertEquals("Double MA MB", o.sayJuhu());
       o.dispose();
+    },
+
+    testDoubleMixinWithSuperStruct() {
+      qx.Class.define("qx.E1", {
+        extend: qx.core.Object,
+        members: {
+          sayJuhu() {
+            return "E1";
+          }
+        }
+      });
+      qx.Mixin.define("qx.ME1a", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} ME1`;
+          }
+        }
+      });
+      qx.Mixin.define("qx.ME1b", {
+        members: {
+          // does not implement `sayJuhu`
+        }
+      });
+
+      qx.Class.define("qx.E2", {
+        extend: qx.E1,
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} E2`;
+          }
+        }
+      });
+      qx.Mixin.define("qx.ME2a", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} ME2a`;
+          }
+        }
+      });
+      qx.Mixin.define("qx.ME2b", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} ME2b`;
+          }
+        }
+      });
+
+      qx.Class.patch(qx.E1, qx.ME1a);
+      qx.Class.patch(qx.E1, qx.ME1b);
+      qx.Class.patch(qx.E2, qx.ME2a);
+      qx.Class.patch(qx.E2, qx.ME2b);
+
+      const e = new qx.E2();
+      this.assertEquals("E1 ME1 E2 ME2a ME2b", e.sayJuhu());
+      e.dispose();
+    },
+
+    /**
+     * tests a large structure to ensure that combinations of patch order,
+     * presence of given method, nor patched class count have an impact on
+     * the behavior of `super` in mixin methods.
+     */
+    testLotsMixinLotsSuper() {
+      qx.Class.define("qx.G1", {
+        extend: qx.core.Object,
+        members: {
+          sayJuhu() {
+            return "G1";
+          }
+        }
+      });
+      qx.Mixin.define("qx.M1G1", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M1G1`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G1, qx.M1G1);
+      qx.Mixin.define("qx.M2G1", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M2G1`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G1, qx.M2G1);
+      qx.Mixin.define("qx.M3G1", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M3G1`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G1, qx.M3G1);
+      qx.Mixin.define("qx.M4G1", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M4G1`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G1, qx.M4G1);
+      qx.Mixin.define("qx.M5G1", {
+        members: {
+          // does not implement `sayJuhu`
+        }
+      });
+      qx.Class.patch(qx.G1, qx.M5G1);
+      qx.Mixin.define("qx.M6G1", {
+        members: {
+          // does not implement `sayJuhu`
+        }
+      });
+      qx.Class.patch(qx.G1, qx.M6G1);
+
+      qx.Class.define("qx.G2", {
+        extend: qx.G1,
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} G2`;
+          }
+        }
+      });
+      qx.Mixin.define("qx.M1G2", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M1G2`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G2, qx.M1G2);
+      qx.Mixin.define("qx.M2G2", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M2G2`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G2, qx.M2G2);
+      qx.Mixin.define("qx.M3G2", {
+        members: {
+          // does not implement `sayJuhu`
+        }
+      });
+      qx.Class.patch(qx.G2, qx.M3G2);
+      qx.Mixin.define("qx.M4G2", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M4G2`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G2, qx.M4G2);
+      qx.Mixin.define("qx.M5G2", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M5G2`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G2, qx.M5G2);
+
+      qx.Class.define("qx.G3", {
+        extend: qx.G2,
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} G3`;
+          }
+        }
+      });
+      qx.Mixin.define("qx.M1G3", {
+        members: {
+          // does not implement `sayJuhu`
+        }
+      });
+      qx.Class.patch(qx.G3, qx.M1G3);
+      qx.Mixin.define("qx.M2G3", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M2G3`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G3, qx.M2G3);
+      qx.Mixin.define("qx.M3G3", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M3G3`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G3, qx.M3G3);
+      qx.Mixin.define("qx.M4G3", {
+        members: {
+          // does not implement `sayJuhu`
+        }
+      });
+      qx.Class.patch(qx.G3, qx.M4G3);
+
+      qx.Class.define("qx.G4", {
+        extend: qx.G3,
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} G4`;
+          }
+        }
+      });
+      qx.Mixin.define("qx.M1G4", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M1G4`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G4, qx.M1G4);
+      qx.Mixin.define("qx.M2G4", {
+        members: {
+          // does not implement `sayJuhu`
+        }
+      });
+      qx.Class.patch(qx.G4, qx.M2G4);
+      qx.Mixin.define("qx.M3G4", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M3G4`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G4, qx.M3G4);
+
+      qx.Class.define("qx.G5", {
+        extend: qx.G4,
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} G5`;
+          }
+        }
+      });
+      qx.Mixin.define("qx.M1G5", {
+        members: {
+          sayJuhu() {
+            return `${super.sayJuhu()} M1G5`;
+          }
+        }
+      });
+      qx.Class.patch(qx.G5, qx.M1G5);
+      qx.Mixin.define("qx.M2G5", {
+        members: {
+          // does not implement `sayJuhu`
+        }
+      });
+      qx.Class.patch(qx.G5, qx.M2G5);
+
+      const g5 = new qx.G5();
+      this.assertEquals(
+        "G1 M1G1 M2G1 M3G1 M4G1 G2 M1G2 M2G2 M4G2 M5G2 G3 M2G3 M3G3 G4 M1G4 M3G4 G5 M1G5",
+        g5.sayJuhu()
+      );
+      g5.dispose();
     }
   }
 });

package/source/class/qx/test/bom/client/Pdfjs.js

@@ -33,6 +33,10 @@ qx.Class.define("qx.test.bom.client.Pdfjs", {
     "test: is PDF.js available"() {
       this.require(["firefox"]);
 
+      if (navigator.plugins.length == 0) {
+        this.skip("test disabled on headless browsers");
+      }
+
       qx.core.Environment.getAsync(
         "plugin.pdfjs",
         function (result) {

package/source/class/qx/test/bom/element/AnimationJs.js

@@ -66,6 +66,9 @@ qx.Class.define("qx.test.bom.element.AnimationJs", {
       if (qx.core.Environment.get("browser.name") == "chrome") {
         throw new qx.dev.unit.RequirementError();
       }
+      if (qx.core.Environment.get("browser.name") == "safari") {
+        throw new qx.dev.unit.RequirementError();
+      }
 
       var handle = qx.bom.element.Animation.animate(this.__el, {
         duration: 100,

package/source/class/qx/test/bom/element/Style.js

@@ -98,6 +98,7 @@ qx.Class.define("qx.test.bom.element.Style", {
         qx.core.Environment.get("browser.version") < 6;
 
       if (
+        engine == "gecko" ||
         engine == "opera" ||
         (engine == "webkit" &&
           !isOldSafari &&

package/source/class/qx/test/bom/media/MediaTestCase.js

@@ -202,6 +202,12 @@ qx.Class.define("qx.test.bom.media.MediaTestCase", {
           "HTML5 audio/video playback must be triggered by user interaction in Chrome on Android."
         );
       }
+      if (qx.core.Environment.get("browser.name") == "safari") {
+        this.skip(
+          "we can not detect headless mode in safari"
+        );
+      }
+
       this.assertTrue(this._media.isPaused());
 
       this._media.addListener("play", e => {

package/source/class/qx/test/core/Environment.js

@@ -537,6 +537,50 @@ qx.Class.define("qx.test.core.Environment", {
 
       // 3d transform support
       this.assertBoolean(qx.core.Environment.get("css.transform.3d"));
+    },
+
+    /**
+     * This test is only run if "qx.environment.allowRuntimeMutations" is false which you need to
+     * manually set in the test runner configuration.
+     */
+    testRuntimeMutationsIfNotAvailable() {
+      if (qx.core.Environment.get("qx.environment.allowRuntimeMutations") === false) {
+        // the mutation methods should not be available
+        for (let key in ['set', 'remove', 'reset']) {
+          this.assertUndefined(qx.core.Environment[key], `The method "qx.core.Environment.${key}()" should not be available.`);
+        }
+      } else {
+        this.skip("Runtime mutations are enabled.");
+      }
+    },
+
+    testRuntimeMutationsIfAvailable() {
+      if (qx.core.Environment.get("qx.environment.allowRuntimeMutations") === false) {
+        this.skip("Runtime mutations are disabled.");
+        return;
+      }
+      // compile-time environment
+      const qxVersion = qx.core.Environment.get("qx.version");
+      qx.core.Environment.set("qx.version", "1.0");
+      this.assertEquals("1.0", qx.core.Environment.get("qx.version"));
+      qx.core.Environment.reset("qx.version");
+      this.assertEquals(qxVersion, qx.core.Environment.get("qx.version"));
+      qx.core.Environment.remove("qx.version");
+      this.assertUndefined(qx.core.Environment.get("qx.version"));
+
+      // runtime environment
+      const browserName = qx.core.Environment.get("browser.name");
+      qx.core.Environment.set("browser.name", "lynx");
+      this.assertEquals("lynx", qx.core.Environment.get("browser.name"));
+      qx.core.Environment.reset("browser.name");
+      this.assertEquals(browserName, qx.core.Environment.get("browser.name"));
+      qx.core.Environment.remove("browser.name");
+      this.assertUndefined(qx.core.Environment.get("browser.name"));
+
+      // cleanup
+      qx.core.Environment.reset();
+      this.assertEquals(qxVersion, qx.core.Environment.get("qx.version"));
+      this.assertEquals(browserName, qx.core.Environment.get("browser.name"));
     }
   }
 });

package/source/class/qx/test/io/MAssert.js

@@ -41,6 +41,100 @@ qx.Mixin.define("qx.test.io.MAssert", {
         msg = `Failed to assert that '${actual}' contains '${expectedFragment}'.`;
       }
       this.assert(actual.includes(expectedFragment), msg);
+    },
+
+    PROMISE: {
+      map: null,
+      PENDING: "pending",
+      FULFILLED: "fulfilled",
+      REJECTED: "rejected"
+    },
+
+    /**
+     * Observes a promise so that its state can later be determined for the assertPromise*()
+     * methods.
+     * @param {Promise} promise
+     */
+    observePromise(promise) {
+      if (!this.PROMISE.map) {
+        this.PROMISE.map = new WeakMap();
+      }
+      let state = this.PROMISE.PENDING;
+      promise.then(
+        () => (state = this.PROMISE.FULFILLED),
+        () => (state = this.PROMISE.REJECTED)
+      );
+      let stateFn = () => state;
+      this.PROMISE.map.set(promise, stateFn);
+    },
+
+    /**
+     * Returns the state of the given promise, which is either "pending", "fulfilled", or "rejected".
+     * Requires that the observePromise() method has previously been called with given promise.
+     * @param {Promise} promise
+     * @returns {String}
+     */
+    getPromiseState(promise) {
+      let stateFn = this.PROMISE.map && this.PROMISE.map.get(promise);
+      if (!stateFn) {
+        throw new Error(
+          "Promise is not being observed, call observePromise() first."
+        );
+      }
+      return stateFn();
+    },
+
+    /**
+     * Asserts that the given promise object is still pending
+     * @param {Promise} promise
+     * @param {String?} msg Optional failure message
+     */
+    assertPromisePending(promise, msg) {
+      let state = this.getPromiseState(promise);
+      this.assert(
+        state == this.PROMISE.PENDING,
+        msg || `Promise should be pending, but is ${state}.`
+      );
+    },
+
+    /**
+     * Asserts that the given promise object is settled, i.e. has either
+     * been fulfilled or rejected
+     * @param {Promise} promise
+     * @param {String?} msg Optional failure message
+     */
+    assertPromiseSettled(promise, msg) {
+      let state = this.getPromiseState(promise);
+      this.assert(
+        state != this.PROMISE.PENDING,
+        msg || `Promise should be settled, but is pending.`
+      );
+    },
+
+    /**
+     * Asserts that the given promise object has been fulfilled
+     * @param {Promise} promise
+     * @param {String?} msg Optional failure message
+     */
+    assertPromiseFulfilled(promise, msg) {
+      let state = this.getPromiseState(promise);
+      this.assert(
+        state == this.PROMISE.FULFILLED,
+        msg || `Promise should be fulfilled, but is ${state}.`
+      );
+    },
+
+    /**
+     * Asserts that the given promise object has been rejected
+     * @param {Promise} promise
+     * @param {String?} msg Optional failure message
+     */
+    assertPromiseRejected(promise, msg) {
+      let state = this.getPromiseState(promise);
+      this.assert(
+        state == this.PROMISE.REJECTED,
+        msg || `Promise should be rejected, but is ${state}.`
+      );
     }
   }
 });

package/source/class/qx/test/io/TestMAssert.js

@@ -0,0 +1,47 @@
+/* ************************************************************************
+
+   qooxdoo - the javascript framework for coders
+
+   http://qooxdoo.org
+
+   Copyright:
+     2025 qooxdoo contributors
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * Tests for qx.io.jsonrpc.Client with qx.test.io.request.PostMessage transport
+ * @ignore(Worker)
+ * @ignore(self)
+ */
+qx.Class.define("qx.test.io.TestMAssert", {
+  extend: qx.dev.unit.TestCase,
+
+  include: [qx.test.io.MAssert],
+
+  members: {
+
+    /**
+     * Test the promise Assertion API
+     */
+    testPromiseAssertions() {
+      let p1 = new Promise(resolve => setTimeout(resolve, 10));
+      this.observePromise(p1);
+      this.assertPromisePending(p1);
+      this.wait(100, () => this.assertPromiseFulfilled(p1));
+      let p2 = new Promise((_, reject) => setTimeout(reject, 10));
+      this.observePromise(p2);
+      this.wait(100, () => {
+        this.assertPromiseRejected(p2);
+        this.assertPromiseSettled(p2);
+      });
+    }
+  }
+});