@qooxdoo/framework 7.9.2 → 8.0.0-beta.2

package/source/class/qx/test/tool/cli/Flag.js

@@ -0,0 +1,413 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2025 Henner Kollmann
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Henner Kollmann (Henner.Kollmann@gmx.de, @hkollmann)
+
+************************************************************************ */
+
+qx.Class.define("qx.test.tool.cli.Flag", {
+  extend: qx.dev.unit.TestCase,
+
+  members: {
+    testBasicFlagCreation() {
+      let flag = new qx.tool.cli.Flag("verbose");
+      this.assertEquals("verbose", flag.getName());
+      this.assertNull(flag.getShortCode());
+      this.assertNull(flag.getDescription());
+      this.assertNull(flag.getValue());
+    },
+
+    testFlagProperties() {
+      let flag = new qx.tool.cli.Flag("output-file");
+      flag.set({
+        type: "string",
+        shortCode: "o",
+        description: "Output file path",
+        value: "default.txt"
+      });
+      
+      this.assertEquals("outputFile", flag.getName()); // transformed to camelCase
+      this.assertEquals("string", flag.getType());
+      this.assertEquals("o", flag.getShortCode());
+      this.assertEquals("Output file path", flag.getDescription());
+      this.assertEquals("default.txt", flag.getValue());
+    },
+
+    testBooleanFlag() {
+      let flag = new qx.tool.cli.Flag("verbose").set({
+        type: "boolean"
+      });
+      
+      // Test parsing boolean flag without value (should default to true)
+      flag.parse("--verbose", () => null);
+      this.assertTrue(flag.getValue());
+    },
+
+    testBooleanFlagWithValue() {
+      let flag = new qx.tool.cli.Flag("debug").set({
+        type: "boolean"
+      });
+      
+      // Test parsing boolean flag with explicit true value
+      flag.parse("--debug=true", () => null);
+      this.assertTrue(flag.getValue());
+      
+      // Test parsing boolean flag with explicit false value
+      flag.setValue(null); // reset
+      flag.parse("--debug=false", () => null);
+      this.assertFalse(flag.getValue());
+      
+      // Test parsing boolean flag with "yes" value
+      flag.setValue(null); // reset
+      flag.parse("--debug=yes", () => null);
+      this.assertTrue(flag.getValue());
+      
+      // Test parsing boolean flag with "no" value
+      flag.setValue(null); // reset
+      flag.parse("--debug=no", () => null);
+      this.assertFalse(flag.getValue());
+    },
+
+    testBooleanFlagInvalidValue() {
+      let flag = new qx.tool.cli.Flag("debug").set({
+        type: "boolean"
+      });
+      
+      this.assertException(() => {
+        flag.parse("--debug=invalid", () => null);
+      }, Error, /Invalid value.*expected nothing.*or the words true or false/);
+    },
+
+    testStringFlag() {
+      let flag = new qx.tool.cli.Flag("output").set({
+        type: "string"
+      });
+      
+      let argIndex = 0;
+      let args = ["file.txt"];
+      function fnGetMore(index) {
+        return args[index] || null;
+      }
+      
+      flag.parse("--output", fnGetMore);
+      this.assertEquals("file.txt", flag.getValue());
+    },
+
+    testStringFlagWithEquals() {
+      let flag = new qx.tool.cli.Flag("output").set({
+        type: "string"
+      });
+      
+      flag.parse("--output=filename.txt", () => null);
+      this.assertEquals("filename.txt", flag.getValue());
+    },
+
+    testIntegerFlag() {
+      let flag = new qx.tool.cli.Flag("count").set({
+        type: "integer"
+      });
+      
+      let args = ["42"];
+      function fnGetMore(index) {
+        return args[index] || null;
+      }
+      
+      flag.parse("--count", fnGetMore);
+      this.assertEquals(42, flag.getValue());
+      this.assertEquals("number", typeof flag.getValue());
+    },
+
+    testIntegerFlagWithEquals() {
+      let flag = new qx.tool.cli.Flag("port").set({
+        type: "integer"
+      });
+      
+      flag.parse("--port=8080", () => null);
+      this.assertEquals(8080, flag.getValue());
+    },
+
+    testIntegerFlagInvalid() {
+      let flag = new qx.tool.cli.Flag("count").set({
+        type: "integer"
+      });
+      
+      this.assertException(() => {
+        flag.parse("--count=invalid", () => null);
+      }, Error, /Invalid value.*expected an integer/);
+    },
+
+    testFloatFlag() {
+      let flag = new qx.tool.cli.Flag("ratio").set({
+        type: "float"
+      });
+      
+      let args = ["3.14"];
+      function fnGetMore(index) {
+        return args[index] || null;
+      }
+      
+      flag.parse("--ratio", fnGetMore);
+      this.assertEquals(3.14, flag.getValue());
+      this.assertEquals("number", typeof flag.getValue());
+    },
+
+    testFloatFlagInvalid() {
+      let flag = new qx.tool.cli.Flag("ratio").set({
+        type: "float"
+      });
+      
+      this.assertException(() => {
+        flag.parse("--ratio=invalid", () => null);
+      }, Error, /Invalid value.*expected a number/);
+    },
+
+    testArrayFlag() {
+      let flag = new qx.tool.cli.Flag("include").set({
+        type: "string",
+        array: true
+      });
+      
+      let argIndex = 0;
+      let args = ["path1", "path2", "path3"];
+      function fnGetMore(index, rebase) {
+        if (rebase) {
+          argIndex += index;
+          return null;
+        }
+        return args[argIndex + index] || null;
+      }
+      
+      flag.parse("--include", fnGetMore);
+      let values = flag.getValue();
+      
+      this.assertTrue(qx.lang.Type.isArray(values));
+      this.assertEquals(3, values.length);
+      this.assertEquals("path1", values[0]);
+      this.assertEquals("path2", values[1]);
+      this.assertEquals("path3", values[2]);
+    },
+
+    testArrayFlagSingleValue() {
+      let flag = new qx.tool.cli.Flag("exclude").set({
+        type: "string",
+        array: true
+      });
+      
+      let argIndex = 0;
+      let args = ["single"];
+      function fnGetMore(index, rebase) {
+        if (rebase) {
+          argIndex += index;
+          return null;
+        }
+        return args[argIndex + index] || null;
+      }
+      
+      flag.parse("--exclude", fnGetMore);
+      let values = flag.getValue();
+      
+      this.assertTrue(qx.lang.Type.isArray(values));
+      this.assertEquals(1, values.length);
+      this.assertEquals("single", values[0]);
+    },
+
+    testArrayFlagEmpty() {
+      let flag = new qx.tool.cli.Flag("tags").set({
+        type: "string",
+        array: true
+      });
+      
+      this.assertException(() => {
+        flag.parse("--tags", () => null);
+      }, Error, /Invalid value.*expected at least one value/);
+    },
+
+    testFlagMatching() {
+      let flag = new qx.tool.cli.Flag("verbose-output").set({
+        shortCode: "v"
+      });
+      
+      this.assertTrue(flag.is("--verbose-output"));
+      this.assertTrue(flag.is("--verboseOutput")); // camelCase
+      this.assertTrue(flag.is("-v"));
+      this.assertFalse(flag.is("--other"));
+      this.assertFalse(flag.is("-x"));
+    },
+
+    testFlagMatchingWithEquals() {
+      let flag = new qx.tool.cli.Flag("output");
+      
+      this.assertTrue(flag.is("--output=file.txt"));
+      this.assertFalse(flag.is("--other=value"));
+    },
+
+    testUsageGeneration() {
+      let flag = new qx.tool.cli.Flag("verbose").set({
+        type: "boolean",
+        shortCode: "v",
+        description: "Enable verbose output",
+        value: false
+      });
+      
+      let usage = flag.usage();
+      
+      this.assertMatch(usage, /--verbose\|-v/);
+      this.assertMatch(usage, /Boolean/);
+      this.assertMatch(usage, /\[default: false\]/);
+      this.assertMatch(usage, /Enable verbose output/);
+    },
+
+    testUsageGenerationString() {
+      let flag = new qx.tool.cli.Flag("output").set({
+        type: "string",
+        shortCode: "o",
+        description: "Output file path"
+      });
+      
+      let usage = flag.usage();
+      
+      this.assertMatch(usage, /--output\|-o/);
+      this.assertMatch(usage, /\(String\)/);
+      this.assertMatch(usage, /-/); // No default value indicator
+      this.assertMatch(usage, /Output file path/);
+    },
+
+    testUsageGenerationArray() {
+      let flag = new qx.tool.cli.Flag("include").set({
+        type: "string",
+        array: true,
+        description: "Include paths"
+      });
+      
+      let usage = flag.usage();
+      
+      this.assertMatch(usage, /--include/);
+      this.assertMatch(usage, /\[String\]/); // Array notation
+      this.assertMatch(usage, /Include paths/);
+    },
+
+    testUsageGenerationEnum() {
+      let flag = new qx.tool.cli.Flag("level").set({
+        type: ["debug", "info", "warn", "error"],
+        description: "Log level"
+      });
+      
+      let usage = flag.usage();
+      
+      this.assertMatch(usage, /--level/);
+      this.assertMatch(usage, /\[debug,info,warn,error\]/);
+      this.assertMatch(usage, /Log level/);
+    },
+
+    testEnumFlagValueSelection() {
+      let flag = new qx.tool.cli.Flag("level").set({
+        type: ["debug", "info", "warn", "error"],
+        description: "Log level"
+      });
+      
+      // Test valid values
+      flag.parse("--level=debug", () => null);
+      this.assertEquals("debug", flag.getValue());
+      
+      flag.setValue(null);
+      flag.parse("--level=info", () => null);
+      this.assertEquals("info", flag.getValue());
+      
+      flag.setValue(null);
+      flag.parse("--level=warn", () => null);
+      this.assertEquals("warn", flag.getValue());
+      
+      flag.setValue(null);
+      flag.parse("--level=error", () => null);
+      this.assertEquals("error", flag.getValue());
+      
+      // Test invalid value should throw error
+      this.assertException(() => {
+        flag.parse("--level=invalid", () => null);
+      }, Error);
+    },
+
+    testHyphenatedName() {
+      let flag = new qx.tool.cli.Flag("outputFile");
+      this.assertEquals("output-file", flag.getHyphenatedName());
+    },
+
+    testToString() {
+      let flag = new qx.tool.cli.Flag("verbose");
+      flag.setDescription("Enable verbose output");
+      this.assertEquals("verbose", flag.toString());
+      
+      let flagNoName = new qx.tool.cli.Flag();
+      flagNoName.setDescription("Test description");
+      this.assertEquals("Test description", flagNoName.toString());
+    },
+
+    testParseWithMockGetMore() {
+      let flag = new qx.tool.cli.Flag("files").set({
+        type: "string",
+        array: true
+      });
+      
+      let consumed = 0;
+      function mockGetMore(index, rebase) {
+        let values = ["file1.txt", "file2.txt", "--other-flag"];
+        if (rebase) {
+          consumed = index;
+          return null;
+        }
+        let value = values[index];
+        // Stop at next flag
+        if (value && value.startsWith("-")) {
+          return null;
+        }
+        return value || null;
+      }
+      
+      flag.parse("--files", mockGetMore);
+      let result = flag.getValue();
+      
+      this.assertTrue(qx.lang.Type.isArray(result));
+      this.assertEquals(2, result.length);
+      this.assertEquals("file1.txt", result[0]);
+      this.assertEquals("file2.txt", result[1]);
+      this.assertEquals(2, consumed); // Verify correct number of arguments were consumed
+    },
+
+    testArrayFlagWithCommaSeparatedValues() {
+      let flag = new qx.tool.cli.Flag("array").set({
+        type: "string",
+        array: true
+      });
+      
+      let consumed = 0;
+      function mockGetMore(index, rebase) {
+        let values = ["additional-arg"];
+        if (rebase) {
+          consumed = index;
+          return null;
+        }
+        return values[index] || null;
+      }
+      
+      flag.parse("--array=test,test2", mockGetMore);
+      let values = flag.getValue();
+      
+      this.assertTrue(qx.lang.Type.isArray(values));
+      this.assertEquals(2, values.length);
+      this.assertEquals("test", values[0]);
+      this.assertEquals("test2", values[1]);
+      this.assertEquals(0, consumed); // Verify no additional arguments were consumed
+    }
+  }
+});

package/source/class/qx/test/tool/cli/__init__.js

@@ -0,0 +1,3 @@
+/**
+ * Test classes for the qx.tool.cli package
+ */

package/source/class/qx/test/ui/LayoutTestCase.js

@@ -178,20 +178,7 @@ qx.Class.define("qx.test.ui.LayoutTestCase", {
     assertWidgetDispose(clazz, args, msg) {
       this.assertDestroy(
         function () {
-          var argStr = [];
-          for (var i = 0; i < args.length; i++) {
-            argStr.push("qx.test.ui.LayoutTestCase.$$args" + "[" + i + "]");
-          }
-
-          qx.test.ui.LayoutTestCase.$$clazz = clazz;
-          qx.test.ui.LayoutTestCase.$$args = args;
-          var str =
-            "new qx.test.ui.LayoutTestCase.$$clazz" +
-            "(" +
-            argStr.join(", ") +
-            ");";
-          var widget = eval(str);
-
+          var widget = new clazz(...args);
           this.getRoot().add(widget);
           this.flush();
 

package/source/class/qx/test/ui/basic/Label.js

@@ -264,6 +264,112 @@ qx.Class.define("qx.test.ui.basic.Label", {
         label.getContentElement().getValue(),
         "label must have the current locale set"
       );
+    },
+
+    /**
+     * Test for issue #9564: Translated string as property init value causes
+     * invalid calculation of label width.
+     *
+     * This test reproduces the issue where a LocalizedString created before
+     * translations are loaded (typical for property init values) causes the
+     * label to calculate its width based on the untranslated message ID
+     * instead of the actual translated text.
+     */
+    testTranslatedStringPropertyInitWidth() {
+      this.require(["qx.dynlocale"]);
+
+      var localeManager = qx.locale.Manager.getInstance();
+
+      // Save the current locale to restore it later
+      var originalLocale = localeManager.getLocale();
+
+      try {
+        // Set up a translation with a short message ID and a long translation
+        var shortMsgId = "ISSUE_9564_TEST_MESSAGE";
+        var longTranslation =
+          "This is a very long translated string that should be much wider than the message ID";
+
+        localeManager.setLocale("en");
+
+        // IMPORTANT: Create LocalizedString BEFORE the translation is loaded
+        // This simulates the typical scenario where tr() is called in a property init
+        var localizedStr = qx.locale.Manager.tr(shortMsgId);
+
+        // At this point, localizedStr contains the message ID as fallback text
+        // because the translation hasn't been loaded yet
+        this.assertEquals(
+          shortMsgId,
+          localizedStr.toString(),
+          "LocalizedString should contain message ID before translation is loaded"
+        );
+
+        // NOW load the translation (simulating translations loading after class definition)
+        localeManager.addTranslation("en", {
+          [shortMsgId]: longTranslation
+        });
+
+        // Create two labels for comparison
+        // Label 1: Uses the LocalizedString directly (simulates property init)
+        var labelWithLocalizedString = new qx.ui.basic.Label();
+        labelWithLocalizedString.setValue(localizedStr);
+
+        // Label 2: Uses the plain translated string for comparison
+        var labelWithPlainString = new qx.ui.basic.Label(longTranslation);
+
+        // Add both labels to the root
+        this.getRoot().add(labelWithLocalizedString);
+        this.getRoot().add(labelWithPlainString);
+
+        // Flush to ensure layout is calculated
+        this.flush();
+
+        // Trigger the changeLocale event to simulate the fix for issue #9564
+        // In a real application, this is automatically triggered by qx.bom.Lifecycle.onReady()
+        // but in the test context, we need to trigger it manually
+        localeManager.fireDataEvent("changeLocale", localeManager.getLocale());
+
+        // Flush again to apply the changes from the changeLocale event
+        this.flush();
+
+        // Both labels should display the same translated text
+        this.assertEquals(
+          longTranslation,
+          labelWithLocalizedString.getContentElement().getValue(),
+          "Label with LocalizedString should display the translated text"
+        );
+
+        this.assertEquals(
+          longTranslation,
+          labelWithPlainString.getContentElement().getValue(),
+          "Label with plain string should display the translated text"
+        );
+
+        // Get the bounds of both labels
+        var boundsWithLocalizedString =
+          labelWithLocalizedString.getBounds();
+        var boundsWithPlainString = labelWithPlainString.getBounds();
+
+        // Both labels should have the same width since they display the same text
+        // This is the core assertion for issue #9564
+        // In the buggy version, labelWithLocalizedString would have a width based on
+        // the short message ID, not the long translated text
+        this.assertEquals(
+          boundsWithPlainString.width,
+          boundsWithLocalizedString.width,
+          "Label with LocalizedString should have the same width as label with plain translated string. " +
+            "Expected: " +
+            boundsWithPlainString.width +
+            ", Actual: " +
+            boundsWithLocalizedString.width
+        );
+
+        // Clean up
+        labelWithLocalizedString.destroy();
+        labelWithPlainString.destroy();
+      } finally {
+        // Restore the original locale
+        localeManager.setLocale(originalLocale);
+      }
     }
   }
 });

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

@@ -168,7 +168,7 @@ qx.Class.define("qx.test.ui.core.Blocker", {
       );
 
       focusedWidget = qx.ui.core.Widget.getWidgetByElement(
-        focusHandler.getFocus()
+        focusHandler.getFocusedElement()
       );
 
       this.assertFalse(
@@ -188,7 +188,7 @@ qx.Class.define("qx.test.ui.core.Blocker", {
       this.assertTrue(activeWidget === txt1, "text field 1 must be active");
 
       focusedWidget = qx.ui.core.Widget.getWidgetByElement(
-        focusHandler.getFocus()
+        focusHandler.getFocusedElement()
       );
 
       this.assertTrue(focusedWidget === txt2, "text field 2 must be focused");
@@ -227,7 +227,8 @@ qx.Class.define("qx.test.ui.core.Blocker", {
       this.assertFalse(blockerElement.isIncluded(), "isIncluded()");
 
       // text field must not be focused
-      widget = qx.ui.core.Widget.getWidgetByElement(focusHandler.getFocus());
+      widget =
+        qx.ui.core.Widget.getWidgetByElement(focusHandler.getFocusedElement());
       this.assertFalse(
         widget === txt,
         "text field must be focused, because it is destroyed"
@@ -235,6 +236,127 @@ qx.Class.define("qx.test.ui.core.Blocker", {
 
       txt.destroy();
       this.flush();
+    },
+
+    testBlockContent() {
+      // Create a container widget with specific position
+      var container = new qx.ui.container.Composite(new qx.ui.layout.Canvas());
+      this.getRoot().add(container, { left: 100, top: 50 });
+      container.setWidth(200);
+      container.setHeight(150);
+      this.flush();
+
+      // Create blocker for the container
+      var blocker = new qx.ui.core.Blocker(container);
+      var blockerElement = blocker.getBlockerElement();
+
+      // Block content
+      blocker.blockContent(10);
+      this.flush();
+
+      this.assertTrue(blocker.isBlocked(), "blocker should be blocked");
+      this.assertTrue(blockerElement.isIncluded(), "blocker element should be included");
+
+      // Verify blocker dimensions match container
+      var styles = blockerElement.getAllStyles();
+      this.assertEquals("200px", styles.width, "blocker width should match container width");
+      this.assertEquals("150px", styles.height, "blocker height should match container height");
+
+      // Verify blocker position is 0,0 (relative to container, not layout parent)
+      // This is the fix for issue #10411
+      this.assertEquals("0px", styles.left, "blocker left should be 0 when blocking content");
+      this.assertEquals("0px", styles.top, "blocker top should be 0 when blocking content");
+
+      // Cleanup
+      blocker.unblock();
+      blocker.dispose();
+      container.destroy();
+      this.flush();
+    },
+
+    testBlockContentPositioning() {
+      // Create a container at a non-zero position
+      var container = new qx.ui.container.Composite(new qx.ui.layout.Canvas());
+      this.getRoot().add(container, { left: 150, top: 100 });
+      container.setWidth(300);
+      container.setHeight(200);
+      this.flush();
+
+      var blocker = new qx.ui.core.Blocker(container);
+      var blockerElement = blocker.getBlockerElement();
+
+      // Block the content
+      blocker.blockContent(5);
+      this.flush();
+
+      var styles = blockerElement.getAllStyles();
+
+      // The blocker should be positioned at 0,0 relative to the container
+      // NOT at the container's position (150, 100)
+      this.assertEquals("0px", styles.left, "blocker should be at left: 0");
+      this.assertEquals("0px", styles.top, "blocker should be at top: 0");
+      this.assertEquals("300px", styles.width, "blocker width should match container");
+      this.assertEquals("200px", styles.height, "blocker height should match container");
+
+      // Cleanup
+      blocker.unblock();
+      blocker.dispose();
+      container.destroy();
+      this.flush();
+    },
+
+    testNormalBlockVsBlockContent() {
+      // Create two containers to compare normal block vs blockContent
+      var container1 = new qx.ui.container.Composite(new qx.ui.layout.Canvas());
+      var container2 = new qx.ui.container.Composite(new qx.ui.layout.Canvas());
+
+      this.getRoot().add(container1, { left: 50, top: 50 });
+      this.getRoot().add(container2, { left: 300, top: 50 });
+
+      container1.setWidth(100);
+      container1.setHeight(100);
+      container2.setWidth(100);
+      container2.setHeight(100);
+
+      this.flush();
+
+      var blocker1 = new qx.ui.core.Blocker(container1);
+      var blocker2 = new qx.ui.core.Blocker(container2);
+
+      // Normal block - blocker is added to layout parent
+      blocker1.block();
+      this.flush();
+
+      var styles1 = blocker1.getBlockerElement().getAllStyles();
+
+      // BlockContent - blocker is added to the widget itself
+      blocker2.blockContent(5);
+      this.flush();
+
+      var styles2 = blocker2.getBlockerElement().getAllStyles();
+
+      // Normal block: blocker positioned at container's position in layout parent
+      this.assertEquals("50px", styles1.left, "normal block uses container's left position");
+      this.assertEquals("50px", styles1.top, "normal block uses container's top position");
+
+      // BlockContent: blocker positioned at 0,0 relative to container
+      this.assertEquals("0px", styles2.left, "blockContent uses 0 for left position");
+      this.assertEquals("0px", styles2.top, "blockContent uses 0 for top position");
+
+      // Both should have same dimensions as their containers
+      this.assertEquals("100px", styles1.width);
+      this.assertEquals("100px", styles1.height);
+      this.assertEquals("100px", styles2.width);
+      this.assertEquals("100px", styles2.height);
+
+      // Cleanup
+      blocker1.unblock();
+      blocker2.unblock();
+      blocker1.dispose();
+      blocker2.dispose();
+      container1.destroy();
+      container2.destroy();
+      this.flush();
     }
   }
 });