@qooxdoo/framework 7.9.2 → 8.0.0-beta.1

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

@@ -231,7 +231,7 @@ qx.Class.define("qx.test.Class", {
         this.assertException(
           function () {
             qx.Class.define("qx.MyClass1", {
-              include: [qx.ui.core.MChildrenHandling]
+              include: [qx.core.MLogging]
             });
           },
           Error,
@@ -280,7 +280,7 @@ qx.Class.define("qx.test.Class", {
     },
 
     testSubClassOf() {
-      this.assertTrue(qx.Class.isSubClassOf(qx.ui.core.Widget, qx.core.Object));
+      this.assertTrue(qx.Class.isSubClassOf(qx.data.Array, qx.core.Object));
     },
 
     testClassUndefine() {
@@ -479,6 +479,314 @@ qx.Class.define("qx.test.Class", {
       });
 
       qx.Class.undefine("qx.DeferFoo");
+    },
+
+    testGetPropertyDescriptorStatic() {
+      // Define a test class with properties
+      var TestClass = qx.Class.define(null, {
+        extend: qx.core.Object,
+        properties: {
+          myProp: {
+            init: "default",
+            check: "String",
+            nullable: false
+          },
+
+          anotherProp: {
+            init: 42,
+            check: "Integer"
+          }
+        }
+      });
+
+      // Test static method on qx.Class
+      var descriptor = qx.Class.getPropertyDescriptor(TestClass, "myProp");
+      this.assertNotNull(descriptor, "Property descriptor should not be null");
+      this.assertInstance(
+        descriptor,
+        qx.core.property.Property,
+        "Should return Property object"
+      );
+
+      this.assertEquals("myProp", descriptor.getPropertyName(), "Property name should match");
+
+      var definition = descriptor.getDefinition();
+      this.assertEquals(
+        "default",
+        definition.init,
+        "Init value should match"
+      );
+
+      this.assertEquals(
+        "String",
+        definition.check,
+        "Check type should match"
+      );
+
+      // Test with another property
+      descriptor = qx.Class.getPropertyDescriptor(TestClass, "anotherProp");
+      this.assertNotNull(
+        descriptor,
+        "Second property descriptor should not be null"
+      );
+
+      this.assertEquals(
+        "anotherProp",
+        descriptor.getPropertyName(),
+        "Second property name should match"
+      );
+
+      // Test with non-existent property
+      descriptor = qx.Class.getPropertyDescriptor(TestClass, "nonExistent");
+      this.assertNull(
+        descriptor,
+        "Non-existent property descriptor should be null"
+      );
+    },
+
+    testGetPropertyDescriptorInstance() {
+      // Define a test class with properties
+      var TestClass = qx.Class.define(null, {
+        extend: qx.core.Object,
+        properties: {
+          instanceProp: {
+            init: "test",
+            check: "String",
+            event: "changeInstanceProp"
+          },
+
+          inheritableProp: {
+            init: null,
+            nullable: true,
+            inheritable: true
+          }
+        }
+      });
+
+      var instance = new TestClass();
+
+      // Test accessing via static method with bound instance
+      var descriptor = qx.Class.getPropertyDescriptor(TestClass, "instanceProp", instance);
+      this.assertNotNull(
+        descriptor,
+        "Property descriptor should not be null"
+      );
+
+      this.assertInstance(
+        descriptor,
+        qx.core.property.Property,
+        "Should return Property object"
+      );
+
+      this.assertEquals(
+        "instanceProp",
+        descriptor.getPropertyName(),
+        "Property name should match"
+      );
+
+      var definition = descriptor.getDefinition();
+      this.assertEquals(
+        "test",
+        definition.init,
+        "Init value should match"
+      );
+
+      this.assertEquals(
+        "changeInstanceProp",
+        definition.event,
+        "Event should match"
+      );
+
+      // Test inheritable property
+      descriptor = qx.Class.getPropertyDescriptor(TestClass, "inheritableProp", instance);
+      this.assertNotNull(
+        descriptor,
+        "Inheritable property descriptor should not be null"
+      );
+
+      this.assertTrue(
+        descriptor.isInheritable(),
+        "Inheritable property should be marked as inheritable"
+      );
+
+      // Test with non-existent property
+      descriptor = qx.Class.getPropertyDescriptor(TestClass, "nonExistent", instance);
+      this.assertNull(
+        descriptor,
+        "Non-existent property descriptor should be null"
+      );
+
+      instance.dispose();
+    },
+
+    testGetPropertyDescriptorSetGet() {
+      // Define a test class with properties
+      var TestClass = qx.Class.define(null, {
+        extend: qx.core.Object,
+        properties: {
+          count: {
+            init: 0,
+            check: "Integer"
+          },
+
+          label: {
+            init: "default",
+            check: "String",
+            event: "changeLabel"
+          }
+        }
+      });
+
+      var instance = new TestClass();
+
+      // Get property descriptor via static method with bound instance
+      var countDescriptor = qx.Class.getPropertyDescriptor(TestClass, "count", instance);
+      this.assertNotNull(
+        countDescriptor,
+        "Property descriptor should not be null"
+      );
+
+      // Test using descriptor's set method directly (bound to instance)
+      countDescriptor.set(42);
+      this.assertEquals(42, instance.getCount(), "Value set via descriptor should be retrievable via getter");
+
+      // Test using descriptor's get method directly (bound to instance)
+      var value = countDescriptor.get();
+      this.assertEquals(42, value, "Value should be retrievable via descriptor's get method");
+
+      // Test with another property
+      var labelDescriptor = qx.Class.getPropertyDescriptor(TestClass, "label", instance);
+
+      // Set value via descriptor (no .call needed, already bound)
+      labelDescriptor.set("test value");
+      this.assertEquals(
+        "test value",
+        labelDescriptor.get(),
+        "Property value set and get via descriptor should match"
+      );
+
+      // Verify the value is also accessible via normal getter
+      this.assertEquals(
+        "test value",
+        instance.getLabel(),
+        "Value set via descriptor should be accessible via normal getter"
+      );
+
+      // Verify change event was fired
+      var eventFired = false;
+      instance.addListener("changeLabel", function(e) {
+        eventFired = true;
+        this.assertEquals("new value", e.getData(), "Event data should match new value");
+      }, this);
+
+      labelDescriptor.set("new value");
+      this.assertTrue(eventFired, "Change event should have been fired");
+
+      instance.dispose();
+    },
+
+    testGetPropertyDescriptorInheritance() {
+      // Define a base class with a property
+      var BaseClass = qx.Class.define(null, {
+        extend: qx.core.Object,
+        properties: {
+          baseProp: {
+            init: "base",
+            check: "String"
+          }
+        }
+      });
+
+      // Define a derived class with its own property
+      var DerivedClass = qx.Class.define(null, {
+        extend: BaseClass,
+        properties: {
+          derivedProp: {
+            init: "derived",
+            check: "String"
+          }
+        }
+      });
+
+      var instance = new DerivedClass();
+
+      // Test that we can get the base class property from derived instance
+      var baseDescriptor = qx.Class.getPropertyDescriptor(DerivedClass, "baseProp", instance);
+      this.assertNotNull(
+        baseDescriptor,
+        "Base property should be accessible from derived instance"
+      );
+
+      this.assertEquals(
+        "baseProp",
+        baseDescriptor.getPropertyName(),
+        "Base property name should match"
+      );
+
+      // Test that we can get the derived class property
+      var derivedDescriptor = qx.Class.getPropertyDescriptor(DerivedClass, "derivedProp", instance);
+      this.assertNotNull(
+        derivedDescriptor,
+        "Derived property should be accessible"
+      );
+
+      this.assertEquals(
+        "derivedProp",
+        derivedDescriptor.getPropertyName(),
+        "Derived property name should match"
+      );
+
+      // Test static method with inheritance
+      var staticBaseDescriptor = qx.Class.getPropertyDescriptor(
+        DerivedClass,
+        "baseProp"
+      );
+
+      this.assertNotNull(
+        staticBaseDescriptor,
+        "Base property should be accessible via static method on derived class"
+      );
+
+      instance.dispose();
+    },
+
+    testGetPropertyDescriptorStaticWithCall() {
+      // Test that static method without instance parameter works with .call()
+      var TestClass = qx.Class.define(null, {
+        extend: qx.core.Object,
+        properties: {
+          value: {
+            init: 0,
+            check: "Integer"
+          }
+        }
+      });
+
+      var instance = new TestClass();
+
+      // Get descriptor via static method WITHOUT instance parameter
+      var descriptor = qx.Class.getPropertyDescriptor(TestClass, "value");
+      this.assertNotNull(descriptor, "Descriptor should not be null");
+
+      // Should work with .call() syntax
+      descriptor.set.call(instance, 100);
+      this.assertEquals(100, instance.getValue(), "Value should be set via .call()");
+
+      var value = descriptor.get.call(instance);
+      this.assertEquals(100, value, "Value should be retrievable via .call()");
+
+      // Get descriptor via static method WITH instance parameter
+      var boundDescriptor = qx.Class.getPropertyDescriptor(TestClass, "value", instance);
+      this.assertNotNull(boundDescriptor, "Bound descriptor should not be null");
+
+      // Should work with direct calls (no .call needed)
+      boundDescriptor.set(200);
+      this.assertEquals(200, instance.getValue(), "Value should be set directly");
+
+      var boundValue = boundDescriptor.get();
+      this.assertEquals(200, boundValue, "Value should be retrievable directly");
+
+      instance.dispose();
     }
   }
 });

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

@@ -19,7 +19,9 @@
 /**
  * @ignore(qx.ExtendUseLog1, qx.Mix, qx.MLogger, qx.MMix1, qx.MMix1.foo)
  * @ignore(qx.MMix2, qx.MPatch, qx.Patch1, qx.Patch2, qx.UseLog1, qx.UseLog2)
- * @ignore(qx.UseLog3)
+ * @ignore(qx.UseLog3, qx.MOverridable, qx.MOverridable2, qx.OverrideClass1)
+ * @ignore(qx.OverrideClass2, qx.OverrideClass3, qx.OverrideClass4)
+ * @ignore(qx.PatchIncludeTest)
  */
 
 qx.Class.define("qx.test.Mixin", {
@@ -66,6 +68,7 @@ qx.Class.define("qx.test.Mixin", {
       this.assertEquals("red", mix.getColor());
 
       if (this.isDebugOn()) {
+        // Test that including multiple mixins with conflicting members still throws an error
         this.assertException(
           function () {
             qx.Class.define("qx.Mix1", {
@@ -78,26 +81,25 @@ qx.Class.define("qx.test.Mixin", {
           "Overwriting member",
           "t1"
         );
+      }
 
-        this.assertException(
-          function () {
-            qx.Class.define("qx.Mix2", {
-              extend: Object,
-              include: qx.MMix1,
-              construct() {},
+      // Test that class members can override mixin members (issue #9142)
+      // This should now be allowed
+      qx.Class.define("qx.Mix2", {
+        extend: Object,
+        include: qx.MMix1,
+        construct() {},
 
-              members: {
-                bar() {
-                  return "bar";
-                }
-              }
-            });
-          },
-          Error,
-          "Overwriting member",
-          "t2"
-        );
-      }
+        members: {
+          bar() {
+            return "bar from class";
+          }
+        }
+      });
+
+      // Verify that the class's version of bar() is used
+      var mix2 = new qx.Mix2();
+      this.assertEquals("bar from class", mix2.bar());
 
       // this is allowed
       qx.Class.define("qx.Mix3", {
@@ -123,7 +125,7 @@ qx.Class.define("qx.test.Mixin", {
             });
           },
           Error,
-          "already has a property",
+          "Overwriting member or property",
           "t3"
         );
       }
@@ -147,7 +149,8 @@ qx.Class.define("qx.test.Mixin", {
       qx.Class.include(qx.UseLog1, qx.MLogger);
       this.assertEquals("Juhu", new qx.UseLog1().log("Juhu"));
 
-      // not allowed to overwrite!
+      // With issue #9142 fix: Class members can override mixin members
+      // When including a mixin after class definition, the class's version is preserved
       qx.Class.define("qx.UseLog2", {
         extend: Object,
         construct() {},
@@ -159,15 +162,9 @@ qx.Class.define("qx.test.Mixin", {
         }
       });
 
-      if (this.isDebugOn()) {
-        this.assertException(
-          function () {
-            qx.Class.include(qx.UseLog2, qx.MLogger);
-          },
-          Error,
-          "Overwriting member"
-        );
-      }
+      // This should now be allowed - the class's log() is preserved
+      qx.Class.include(qx.UseLog2, qx.MLogger);
+      this.assertEquals("foo", new qx.UseLog2().log("Juhu"));
 
       // allowed to overwrite!
       qx.Class.define("qx.UseLog3", {
@@ -190,6 +187,47 @@ qx.Class.define("qx.test.Mixin", {
       this.assertEquals("Juhu", new qx.ExtendUseLog1().log("Juhu"));
     },
 
+    /**
+     * Tests that super in a Mixin calls the affected class' super method
+     */
+    testIncludeSuper() {
+      qx.Class.define("qx.A", {
+        extend: qx.core.Object,
+
+        members: {
+          sayJuhu() {
+            return "Juhu";
+          }
+        }
+      });
+
+      qx.Mixin.define("qx.MB", {
+        members: {
+          sayJuhu() {
+            return super.sayJuhu() + " from Mixin";
+          }
+        }
+      });
+
+      qx.Class.define("qx.B", {
+        include: [qx.MB],
+        extend: qx.A,
+
+        members: {
+          foo() {
+            return "bar";
+          }
+        }
+      });
+
+      let b = new qx.B();
+      this.assertEquals("Juhu from Mixin", b.sayJuhu());
+      this.assertEquals("bar", b.foo());
+
+      qx.Class.undefine("qx.A");
+      qx.Class.undefine("qx.B");
+    },
+
     testPatchOverwritten() {
       qx.Class.define("qx.Patch1", {
         extend: qx.core.Object,
@@ -239,16 +277,27 @@ qx.Class.define("qx.test.Mixin", {
         }
       });
 
+      // With issue #9142 fix: qx.Class.include no longer throws an error
+      // when class members conflict with mixin members. The class's version is preserved.
       if (this.isDebugOn()) {
-        this.assertException(
-          function () {
-            qx.Class.include(qx.Patch1, qx.MPatch);
-          },
-          Error,
-          new RegExp('Overwriting member ".*" of Class ".*" is not allowed!')
-        );
+        // Create a temporary class to test include behavior
+        qx.Class.define("qx.PatchIncludeTest", {
+          extend: qx.core.Object,
+          members: {
+            sayJuhu() {
+              return "Original";
+            }
+          }
+        });
+
+        // This should not throw an error
+        qx.Class.include(qx.PatchIncludeTest, qx.MPatch);
+        var oTest = new qx.PatchIncludeTest();
+        this.assertEquals("Original", oTest.sayJuhu()); // Class's version is preserved
+        oTest.dispose();
       }
 
+      // qx.Class.patch still overwrites as before
       qx.Class.patch(qx.Patch1, qx.MPatch);
       qx.Class.patch(qx.Patch2, qx.MPatch);
 
@@ -477,6 +526,8 @@ qx.Class.define("qx.test.Mixin", {
       var o = new qx.PatchDerived();
       this.assertEquals("Juhu Derived Mixin", o.sayJuhu());
       o.dispose();
+      qx.Class.undefine("qx.Patch");
+      qx.Class.undefine("qx.PatchDerived");
     },
 
     testPatchOverwrittenDerivedInBaseClass() {
@@ -515,6 +566,8 @@ qx.Class.define("qx.test.Mixin", {
       var o = new qx.PatchDerived();
       this.assertEquals("Juhu Mixin Derived", o.sayJuhu());
       o.dispose();
+      qx.Class.undefine("qx.Patch");
+      qx.Class.undefine("qx.PatchDerived");
     },
 
     testPatchMultiOverwrittenDerived() {
@@ -608,8 +661,10 @@ qx.Class.define("qx.test.Mixin", {
       qx.Class.patch(qx.D, qx.MDB);
 
       var o = new qx.D();
-      this.assertEquals("Double MA MB", o.sayJuhu());
+      var ret = o.sayJuhu();
+      this.assertEquals("Double MA MB", ret);
       o.dispose();
+      qx.Class.undefine("qx.D");
     },
 
     testDoubleMixinWithSuperStruct() {
@@ -865,11 +920,106 @@ qx.Class.define("qx.test.Mixin", {
       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()
-      );
+      this.assertEquals("G1 M1G1 M2G1 M3G1 M4G1 G2 M1G2 M2G2 M4G2 M5G2 G3 M2G3 M3G3 G4 M1G4 M3G4 G5 M1G5", g5.sayJuhu());
       g5.dispose();
+    },
+
+    /**
+     * Test for issue #9142: Classes should be able to override mixin methods
+     * This test verifies that a class can override a method defined in a mixin
+     * and can optionally call the mixin's implementation using super
+     */
+    testMixinMethodOverride() {
+      // Define a mixin with a method
+      qx.Mixin.define("qx.MOverridable", {
+        members: {
+          greet() {
+            return "Hello from Mixin";
+          },
+
+          calculate(a, b) {
+            return a + b;
+          }
+        }
+      });
+
+      // Test 1: Class overrides mixin method without calling super
+      qx.Class.define("qx.OverrideClass1", {
+        extend: qx.core.Object,
+        include: qx.MOverridable,
+
+        members: {
+          greet() {
+            return "Hello from Class";
+          }
+        }
+      });
+
+      var obj1 = new qx.OverrideClass1();
+      this.assertEquals("Hello from Class", obj1.greet());
+      obj1.dispose();
+
+      // Test 2: Class completely overrides mixin methods with different implementations
+      // Note: Calling the mixin's version from the class override is not currently
+      // supported by qooxdoo's base call mechanism (this.base looks in superclass, not mixins)
+      qx.Class.define("qx.OverrideClass2", {
+        extend: qx.core.Object,
+        include: qx.MOverridable,
+
+        members: {
+          greet() {
+            return "Completely overridden by Class";
+          },
+
+          calculate(a, b) {
+            return (a + b) * 10; // Different calculation
+          }
+        }
+      });
+
+      var obj2 = new qx.OverrideClass2();
+      this.assertEquals("Completely overridden by Class", obj2.greet());
+      this.assertEquals(50, obj2.calculate(2, 3)); // (2 + 3) * 10 = 50
+      obj2.dispose();
+
+      // Test 3: Derived class inherits the overridden method
+      qx.Class.define("qx.OverrideClass3", {
+        extend: qx.OverrideClass1
+      });
+
+      var obj3 = new qx.OverrideClass3();
+      this.assertEquals("Hello from Class", obj3.greet());
+      obj3.dispose();
+
+      // Test 4: Class overrides mixin method after mixin is included
+      qx.Mixin.define("qx.MOverridable2", {
+        members: {
+          getValue() {
+            return "Value from Mixin2";
+          }
+        }
+      });
+
+      qx.Class.define("qx.OverrideClass4", {
+        extend: qx.core.Object,
+        include: qx.MOverridable2,
+
+        members: {
+          getValue() {
+            return "Overridden by class";
+          }
+        }
+      });
+
+      var obj4 = new qx.OverrideClass4();
+      this.assertEquals("Overridden by class", obj4.getValue());
+      obj4.dispose();
+
+      // Cleanup
+      qx.Class.undefine("qx.OverrideClass1");
+      qx.Class.undefine("qx.OverrideClass2");
+      qx.Class.undefine("qx.OverrideClass3");
+      qx.Class.undefine("qx.OverrideClass4");
     }
   }
 });