@qooxdoo/framework 8.0.0-beta.1 → 8.0.0-beta.3

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

@@ -631,6 +631,225 @@ qx.Class.define("qx.test.Mixin", {
       o.dispose();
     },
 
+    /**
+     * Primary bug: when the same mixin is included in two different classes,
+     * addMembers() overwrites the shared mixin function's .base pointer on the
+     * second include, causing the first class's super() call to resolve to the
+     * wrong base method. Per-mixin-per-class $mixinBases storage fixes this.
+     */
+    testMixinInMultipleClasses() {
+      // Two unrelated base classes, each with a 'describe' method
+      qx.Class.define("qx.MBase1", {
+        extend: qx.core.Object,
+        members: {
+          describe() {
+            return "Base1";
+          }
+        }
+      });
+      qx.Class.define("qx.MBase2", {
+        extend: qx.core.Object,
+        members: {
+          describe() {
+            return "Base2";
+          }
+        }
+      });
+
+      // Same mixin included in both classes
+      qx.Mixin.define("qx.MDual", {
+        members: {
+          describe() {
+            return super.describe() + " + Mixin";
+          }
+        }
+      });
+
+      qx.Class.define("qx.MChild1", { extend: qx.MBase1, include: [qx.MDual] });
+      qx.Class.define("qx.MChild2", { extend: qx.MBase2, include: [qx.MDual] });
+
+      var c1 = new qx.MChild1();
+      var c2 = new qx.MChild2();
+
+      // Without the fix, c1.describe() would call Base2 (last include clobbered fn.base)
+      this.assertEquals("Base1 + Mixin", c1.describe());
+      this.assertEquals("Base2 + Mixin", c2.describe());
+
+      c1.dispose();
+      c2.dispose();
+      qx.Class.undefine("qx.MChild1");
+      qx.Class.undefine("qx.MChild2");
+      qx.Class.undefine("qx.MDual");
+      qx.Class.undefine("qx.MBase1");
+      qx.Class.undefine("qx.MBase2");
+    },
+
+    /**
+     * Regression test: when two different mixins both override the same method
+     * and are both patched into the same class, a naive per-class base cache
+     * (keyed by method name only) would be overwritten by the second patch,
+     * making the first mixin's super() resolve back to itself → infinite recursion.
+     * The per-mixin-per-class $mixinBases Map avoids this by using the mixin as
+     * the lookup key, so each mixin retains its own base reference.
+     */
+    testPatchTwoMixinsSameMethodNoInfiniteRecursion() {
+      qx.Class.define("qx.IRBase", {
+        extend: qx.core.Object,
+        members: {
+          describe() {
+            return "base";
+          }
+        }
+      });
+
+      qx.Mixin.define("qx.MIR1", {
+        members: {
+          describe() {
+            return super.describe() + " [m1]";
+          }
+        }
+      });
+
+      qx.Mixin.define("qx.MIR2", {
+        members: {
+          describe() {
+            return super.describe() + " [m2]";
+          }
+        }
+      });
+
+      qx.Class.patch(qx.IRBase, qx.MIR1);
+      qx.Class.patch(qx.IRBase, qx.MIR2);
+
+      var obj = new qx.IRBase();
+      // Without per-mixin base storage, MIR1's super() resolves to MIR1 itself → stack overflow
+      this.assertEquals("base [m1] [m2]", obj.describe());
+
+      obj.dispose();
+      qx.Class.undefine("qx.IRBase");
+      qx.Class.undefine("qx.MIR1");
+      qx.Class.undefine("qx.MIR2");
+    },
+
+    /**
+     * Mixin-in-mixin: an outer mixin composes an inner mixin (via include:)
+     * with no members of its own. When the outer mixin is applied to two
+     * different classes, the inner mixin's super() call must resolve to each
+     * class's own base — not the last class to include it (which would clobber
+     * the shared .base pointer on the inner mixin's function object).
+     */
+    testMixinInMixinMultipleClasses() {
+      // Inner mixin with a greet() calling super
+      qx.Mixin.define("qx.MInner", {
+        members: {
+          greet() {
+            return super.greet() + " [inner]";
+          }
+        }
+      });
+
+      // Pure composition mixin: no own members, just includes MInner
+      qx.Mixin.define("qx.MOuter", {
+        include: [qx.MInner]
+      });
+
+      qx.Class.define("qx.MIMBase1", {
+        extend: qx.core.Object,
+        members: {
+          greet() {
+            return "Alpha";
+          }
+        }
+      });
+      qx.Class.define("qx.MIMBase2", {
+        extend: qx.core.Object,
+        members: {
+          greet() {
+            return "Beta";
+          }
+        }
+      });
+
+      // Both classes include MOuter — MInner.greet's .base gets clobbered on the
+      // second include without per-mixin-per-class storage
+      qx.Class.define("qx.MIMClass1", { extend: qx.MIMBase1, include: [qx.MOuter] });
+      qx.Class.define("qx.MIMClass2", { extend: qx.MIMBase2, include: [qx.MOuter] });
+
+      var c1 = new qx.MIMClass1();
+      var c2 = new qx.MIMClass2();
+      // MInner.greet's super must resolve to each class's own base, not the last one applied
+      this.assertEquals("Alpha [inner]", c1.greet());
+      this.assertEquals("Beta [inner]", c2.greet());
+
+      c1.dispose();
+      c2.dispose();
+      qx.Class.undefine("qx.MIMClass1");
+      qx.Class.undefine("qx.MIMClass2");
+      qx.Class.undefine("qx.MIMBase1");
+      qx.Class.undefine("qx.MIMBase2");
+      qx.Class.undefine("qx.MOuter");
+      qx.Class.undefine("qx.MInner");
+    },
+
+    /**
+     * Deep inheritance: the mixin is included in an ancestor class several
+     * levels up. A second unrelated class also includes the same mixin,
+     * clobbering the shared .base pointer. The baseClassMethod lookup must
+     * traverse the inheritance chain to find $mixinBases on the ancestor and
+     * return the correct (per-class) base function.
+     */
+    testDeepInheritanceMixinBaseResolution() {
+      qx.Class.define("qx.DIBase1", {
+        extend: qx.core.Object,
+        members: {
+          describe() {
+            return "Base1";
+          }
+        }
+      });
+      qx.Class.define("qx.DIBase2", {
+        extend: qx.core.Object,
+        members: {
+          describe() {
+            return "Base2";
+          }
+        }
+      });
+
+      qx.Mixin.define("qx.MDI", {
+        members: {
+          describe() {
+            return super.describe() + " [mixin]";
+          }
+        }
+      });
+
+      // Mixin applied at Parent1; Child1 and Grandchild1 inherit it
+      qx.Class.define("qx.DIParent1", { extend: qx.DIBase1, include: [qx.MDI] });
+      qx.Class.define("qx.DIChild1", { extend: qx.DIParent1 });
+      qx.Class.define("qx.DIGrandchild1", { extend: qx.DIChild1 });
+
+      // Second unrelated class including the same mixin — clobbers MDI.$$members.describe.base
+      qx.Class.define("qx.DIParent2", { extend: qx.DIBase2, include: [qx.MDI] });
+
+      var deep = new qx.DIGrandchild1();
+      var other = new qx.DIParent2();
+
+      // $mixinBases must be found on DIParent1 (ancestor), not on the instance's own class
+      this.assertEquals("Base1 [mixin]", deep.describe());
+      this.assertEquals("Base2 [mixin]", other.describe());
+
+      deep.dispose();
+      other.dispose();
+      qx.Class.undefine("qx.DIGrandchild1");
+      qx.Class.undefine("qx.DIChild1");
+      qx.Class.undefine("qx.DIParent1");
+      qx.Class.undefine("qx.DIParent2");
+      qx.Class.undefine("qx.MDI");
+      qx.Class.undefine("qx.DIBase1");
+      qx.Class.undefine("qx.DIBase2");
+    },
+
     testDoubleMixin() {
       qx.Class.define("qx.D", {
         extend: qx.core.Object,

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

@@ -566,7 +566,7 @@ qx.Class.define("qx.test.Promise", {
 
     /**
      * Tests that a property apply method can return a promise; in this case, the
-     * property *is* marked as async, and we use the setAlphaAsync to test chaining
+     * and we use the setAlphaAsync to test chaining
      */
     testPropertySetValueAsyncApply2() {
       var t = this;
@@ -576,7 +576,6 @@ qx.Class.define("qx.test.Promise", {
           alpha: {
             init: null,
             nullable: true,
-            async: true,
             apply: "_applyAlpha",
 
             event: "changeAlpha"
@@ -632,9 +631,8 @@ qx.Class.define("qx.test.Promise", {
           alpha: {
             init: null,
             nullable: true,
-            async: true,
             event: "changeAlpha",
-            apply: () => { }
+            apply: () => {}
           }
         }
       });
@@ -685,8 +683,9 @@ qx.Class.define("qx.test.Promise", {
         });
 
         asyncObj.getAlphaAsync();
-        asyncObj.bind("alpha", syncObj, "bravo");
-        asyncObj.setAlphaAsync("zyx");
+        asyncObj.bindAsync("alpha", syncObj, "bravo").then(() => {
+          asyncObj.setAlphaAsync("zyx");
+        });
         qx.Promise.all([p1, p2]).then(function () {
           var p3 = new qx.Promise();
           syncObj.addListenerOnce("changeBravo", evt => {
@@ -707,10 +706,11 @@ qx.Class.define("qx.test.Promise", {
       /*
        * Test binding a "normal" sync property to an async property
        */
-      if (!qx.core.Environment.get("qx.core.property.Property.applyDuringConstruct")) {
-        console.warn("Not working with applyDuringConstruct = false, skipping testBinding async-to-sync part");
-        return;  // Test wird übersprungen, zählt als "ok"
-      }
+      //2026-FEB-25  - Commented this out because it causes this unit test to fail.
+      // if (!qx.core.Environment.get("qx.core.property.Property.applyDuringConstruct")) {
+      //   console.warn("Not working with applyDuringConstruct = false, skipping testBinding async-to-sync part");
+      //   return;
+      // }
       asyncToSync.then(function () {
         var asyncObj = new AsyncClazz();
         var syncObj = new SyncClazz();
@@ -755,7 +755,6 @@ qx.Class.define("qx.test.Promise", {
           alpha: {
             init: null,
             nullable: true,
-            async: true,
             apply: "_applyAlpha",
             event: "changeAlpha"
           }

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

@@ -107,7 +107,18 @@ qx.Class.define("qx.test.core.Property", {
 
           readOnly: {
             initFunction: () => 42,
-            immutable: "readonly"
+            immutable: "readonly",
+            apply() {
+              this.appliedReadOnly = true;
+            }
+          },
+
+          noAutoApply: {
+            initFunction:() => 24,
+            autoApply: false,
+            apply() {
+              throw new Error("Should not call here!")
+            }
           }
         },
 
@@ -159,11 +170,6 @@ qx.Class.define("qx.test.core.Property", {
             qx.test.cpnfv8.ExternalStorage._subclassStorage[property.getPropertyName()] = value;
           },
 
-          /**@override */
-          isAsyncStorage() {
-            return false;
-          },
-
           /**@override */
           get(thisObj, prop) {
             console.log("in externallyStored getter");
@@ -176,6 +182,11 @@ qx.Class.define("qx.test.core.Property", {
             qx.test.cpnfv8.ExternalStorage._subclassStorage[property.getPropertyName()] = value;
           },
 
+          /**@override */
+          supportsGetAsync() {
+            return false;
+          },
+
           /**@override */
           dereference(prop, property) {}
         },
@@ -224,7 +235,6 @@ qx.Class.define("qx.test.core.Property", {
           },
           delay: {
             init: 0,
-            async: true,
             getAsync: async (prop, self) => {
               let p;
               p = new qx.Promise((resolve, reject) => {
@@ -540,6 +550,7 @@ qx.Class.define("qx.test.core.Property", {
 
     testApply() {
       let obj = new qx.test.cpnfv8.Superclass();
+      this.assertTrue(obj.appliedReadOnly, "Expected apply method for property 'readOnly' to be called, but wasn't");
       this.assertEquals(3, obj.applyCount, "initial apply count should be 3");
       this.assertArrayEquals([null, undefined], obj.lastApply, "last apply call during construction");
       obj.setRunning(false);
@@ -574,6 +585,7 @@ qx.Class.define("qx.test.core.Property", {
       //old, deprecated behaviour
       qx.core.Environment.set("qx.core.property.Property.applyDuringConstruct", false);
       obj = new qx.test.cpnfv8.Superclass();
+      this.assertTrue(obj.appliedReadOnly, "Expected apply method for property 'readOnly' to be called, but wasn't");
       this.assertEquals(1, obj.applyCount, "old behaviour: initial apply count should be 1");
       obj.resetAnyProp();
       this.assertEquals(1, obj.applyCount, "old behaviour: apply count after reset should still be 1");
@@ -821,6 +833,21 @@ qx.Class.define("qx.test.core.Property", {
       let second = inst.getJsdocProp();
       this.assertArrayEquals([10, 20, 30], initial, "properties created with initFunction returned by getter should be the same");
       this.assertIdentical(initial, second, "properties created with initFunction returned by getter should be the same");      
+
+      try {
+        qx.Class.define(null, {
+          extend: qx.core.Object,
+          properties: {
+            badProp: {
+              init: 5,
+              initFunction: () => 10
+            }
+          }
+        });
+        this.fail("Defining a property with both init and initFunction should throw an error");
+      } catch (e) {
+        // expected
+      }
     },
 
     testDefinesThanSubClassWithInterface() {
@@ -1672,7 +1699,6 @@ qx.Class.define("qx.test.core.Property", {
           propTwo: {
             init: null,
             nullable: true,
-            async: true,
             apply: "_applyPropTwo",
             event: "changePropTwo"
           }
@@ -2295,7 +2321,6 @@ qx.Class.define("qx.test.core.Property", {
         extend: qx.core.Object,
         properties: {
           foo: {
-            async: true,
             init: 7,
             apply: function (value, old) {
               return new qx.Promise((resolve, reject) => {
@@ -2325,27 +2350,36 @@ qx.Class.define("qx.test.core.Property", {
 
     /**
      * Ensures that an error is thrown when trying to get an async property synchronously
-     * when the property is not ready yet, even if it has an init value.
+     * when the property is not ready yet.
      */
     testGetSyncWhenNotReady() {
       qx.Class.undefine("qx.test.cpnfv8.GetSyncTest");
+
+      let fooCached = undefined;
       var Clazz = qx.Class.define("qx.test.cpnfv8.GetSyncTest", {
         extend: qx.core.Object,
         properties: {
           foo: {
-            async: true,
-            init: 7
+            get() {
+              return fooCached;
+            },
+            getAsync() {
+              if (fooCached === undefined) {
+                fooCached = 7;
+              }
+              return fooCached;
+            },
+            set(value) {
+              fooCached = value;
+            }
           }
         }
       });
 
       const doit = async () => {
         let instance = new Clazz();
-        //The property storage will be set to the init value during construction,
-        //so we must reset it manually.
-        delete instance.$$propertyValues.foo;
         let prop = qx.Class.getByProperty(Clazz, "foo");
-        this.assertFalse(prop.isInitialized(instance), "Property foo should not be initialized");
+        this.assertFalse(prop.hasLocalValue(instance), "Property foo should not be locally defined");
         this.assertUndefined(instance.getSafe("foo"));
         try {
           instance.getFoo();

package/source/class/qx/test/data/singlevalue/Async.js

@@ -30,6 +30,19 @@ qx.Class.define("qx.test.data.singlevalue.Async", {
     __b2: null,
 
     setUp() {
+      qx.Bootstrap.undefine("qx.test.data.singlevalue.async.AsyncPropertyStorage");
+      qx.Bootstrap.define("qx.test.data.singlevalue.async.AsyncPropertyStorage", {
+        extend: qx.core.property.SimplePropertyStorage,
+        members: {
+          /**
+           * @Override
+           */
+          supportsGetAsync() {
+            return true;
+          }
+        }
+      });
+
       qx.Class.undefine("qx.test.data.singlevalue.async.Test");
       const Clazz = qx.Class.define("qx.test.data.singlevalue.async.Test", {
         extend: qx.core.Object,
@@ -38,17 +51,17 @@ qx.Class.define("qx.test.data.singlevalue.Async", {
            * The async input
            */
           ai: {
-            async: true,
             nullable: true,
-            init: null
+            init: null,
+            storage: qx.test.data.singlevalue.async.AsyncPropertyStorage
           },
           /**
            * The async output
            */
           ao: {
-            async: true,
             nullable: true,
-            init: null
+            init: null,
+            storage: qx.test.data.singlevalue.async.AsyncPropertyStorage
           },
           /**
            * Syncronous input

package/source/class/qx/test/data/singlevalue/Simple.js

@@ -791,6 +791,12 @@ qx.Class.define("qx.test.data.singlevalue.Simple", {
       person2.setFriend(null);
       this.assertEquals(3, timesCalled, "Converter should not be called when chain is broken and ignoreConverter is set and matches.");
       this.assertEquals("Patryk", person3.getName(), "Target should be reset when chain is broken");
+
+      //ensure that during the initial set, if the chain is incomplete (i.e. has a null value),
+      //the target property is reset (not set to null)
+      let person4 = new Person("Harry");
+      person3.bind("friend.friend.name", person4, "name");
+      this.assertEquals("Patryk", person4.getName(), "Target should be reset when chain has null element during initial set");
     }
   }
 });

package/source/class/qx/test/locale/Date.js

@@ -32,7 +32,7 @@ qx.Class.define("qx.test.locale.Date", {
     testGetAmMarker() {
       var Date = qx.locale.Date;
       var items = [
-        { locale: "ko", expected: "오전" },
+        { locale: "zh", expected: "上午" },
         { locale: "fr", expected: "AM" },
         { locale: "af", expected: "vm." }
       ];
@@ -46,7 +46,7 @@ qx.Class.define("qx.test.locale.Date", {
     testGetPMMarker() {
       var Date = qx.locale.Date;
       var items = [
-        { locale: "ko", expected: "오후" },
+        { locale: "zh", expected: "下午" },
         { locale: "fr", expected: "PM" },
         { locale: "af", expected: "nm." }
       ];

package/source/class/qx/test/performance/Property.js

@@ -50,7 +50,6 @@ qx.Class.define("qx.test.performance.Property", {
             nullable: true,
             check: "String",
             event: "changeAlpha",
-            async: true,
             apply: () => {}
           }
         }

package/source/class/qx/test/ui/core/SingleSelectionManager.js

@@ -0,0 +1,150 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   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.
+
+************************************************************************ */
+
+/**
+ * Minimal ISingleSelectionProvider implementation for unit testing.
+ *
+ * @internal
+ * @ignore(qx.test.ui.core.MockSingleSelectionProvider)
+ */
+qx.Class.define("qx.test.ui.core.MockSingleSelectionProvider", {
+  extend: qx.core.Object,
+  implement: [qx.ui.core.ISingleSelectionProvider],
+
+  construct(items) {
+    super();
+    this._items = items;
+  },
+
+  members: {
+    _items: null,
+
+    getItems() {
+      return this._items || [];
+    },
+
+    isItemSelectable(item) {
+      return true;
+    }
+  }
+});
+
+/**
+ * Tests for qx.ui.core.SingleSelectionManager
+ */
+qx.Class.define("qx.test.ui.core.SingleSelectionManager", {
+  extend: qx.dev.unit.TestCase,
+
+  members: {
+    __manager: null,
+    __provider: null,
+    __items: null,
+
+    setUp() {
+      this.__items = [new qx.core.Object(), new qx.core.Object(), new qx.core.Object()];
+      this.__provider = new qx.test.ui.core.MockSingleSelectionProvider(this.__items);
+      this.__manager = new qx.ui.core.SingleSelectionManager(this.__provider);
+    },
+
+    tearDown() {
+      this.__manager.dispose();
+      this.__provider.dispose();
+      for (var item of this.__items) {
+        item.dispose();
+      }
+      this.__items = null;
+    },
+
+    /**
+     * Regression test for the fix: resetSelected() with allowEmptySelection=false
+     * must NOT fire changeSelected when the first item is already selected.
+     */
+    testNoSpuriousEventWhenResetSelectedWithFirstItemAlreadySelected() {
+      this.__manager.setAllowEmptySelection(false);
+      this.__manager.resetSelected();
+      this.assertIdentical(this.__items[0], this.__manager.getSelected(), "item[0] should be auto-selected");
+
+      var eventCount = 0;
+      this.__manager.addListener("changeSelected", function () {
+        eventCount++;
+      });
+
+      this.__manager.resetSelected();
+
+      this.assertEquals(0, eventCount, "changeSelected must not fire when selection is unchanged");
+      this.assertIdentical(this.__items[0], this.__manager.getSelected(), "Selection must still be item[0]");
+    },
+
+    /**
+     * resetSelected() when another item is selected must fire changeSelected
+     * and switch back to item[0].
+     */
+    testEventFiredWhenResetSelectedChangesSelection() {
+      this.__manager.setAllowEmptySelection(false);
+      this.__manager.setSelected(this.__items[1]);
+
+      var eventCount = 0;
+      var eventData = null;
+      this.__manager.addListener("changeSelected", function (e) {
+        eventCount++;
+        eventData = e.getData();
+      });
+
+      this.__manager.resetSelected();
+
+      this.assertEquals(1, eventCount, "changeSelected must fire when selection changes");
+      this.assertIdentical(this.__items[0], eventData, "Event data should be item[0]");
+      this.assertIdentical(this.__items[0], this.__manager.getSelected(), "item[0] should be selected after reset");
+    },
+
+    /**
+     * setSelected() with the already-selected item must not fire changeSelected
+     * (pre-existing early-exit guard).
+     */
+    testNoEventWhenSetSelectedWithSameItem() {
+      this.__manager.setSelected(this.__items[0]);
+
+      var eventCount = 0;
+      this.__manager.addListener("changeSelected", function () {
+        eventCount++;
+      });
+
+      this.__manager.setSelected(this.__items[0]);
+
+      this.assertEquals(0, eventCount, "changeSelected must not fire when setting the same item");
+    },
+
+    /**
+     * Switching allowEmptySelection from true to false on an empty manager
+     * must auto-select item[0] and fire changeSelected exactly once.
+     */
+    testAllowEmptySelectionFalseTriggersAutoSelect() {
+      this.assertTrue(this.__manager.isSelectionEmpty(), "Selection should be empty initially");
+
+      var eventCount = 0;
+      var eventData = null;
+      this.__manager.addListener("changeSelected", function (e) {
+        eventCount++;
+        eventData = e.getData();
+      });
+
+      this.__manager.setAllowEmptySelection(false);
+
+      this.assertEquals(1, eventCount, "changeSelected must fire when auto-selecting the first item");
+      this.assertIdentical(this.__items[0], eventData, "Event data should be item[0]");
+      this.assertIdentical(this.__items[0], this.__manager.getSelected(), "item[0] should be auto-selected");
+    }
+  }
+});