tests: add several unit tests for text layout

Author: BlueZeeKing

tests/unit/elements/Text.cpp

@@ -8,6 +8,12 @@
 #include <layout/Positioner.hpp>
 
 #include "../tricks/Tricks.hpp"
+#include "element/Element.hpp"
+#include "hyprtoolkit/element/Element.hpp"
+#include "hyprtoolkit/element/Null.hpp"
+#include "hyprtoolkit/element/Rectangle.hpp"
+#include "hyprtoolkit/element/RowLayout.hpp"
+#include "hyprtoolkit/types/SizeType.hpp"
 
 using namespace Hyprtoolkit;
 using namespace Hyprutils::Math;
@@ -25,60 +31,136 @@ TEST(Element, text) {
     text.reset();
 }
 
-// an auto label gets no room hint and its box tracks its own clamped preferred, so the box feeds
-// back into the next layout. a transient narrow box on first layout (e.g. before an async icon
-// sibling reflows the row) must not lock the text ellipsized: once the box equals the clamped
-// preferred the clamp has to release and the text recover. #94 compared the box against a cached
-// natural size, so the box-feedback condition stayed true and the ellipsis locked forever. this is
-// the hyprlauncher regression.
-TEST(Element, textEllipsizeRecoversFromTransientClamp) {
+TEST(Element, textPreferredSize) {
     Tests::Tricks::createBackendSupport();
 
+    auto text = CTextBuilder::begin()->text("Hello World Foo Bar Baz")->noEllipsize(true)->commence();
+
+    const auto NATURAL_SIZE = text->preferredSize({0, 0});
+    EXPECT_TRUE(NATURAL_SIZE.has_value());
+
+    const auto WRAPPED_SIZE = text->preferredSize({ NATURAL_SIZE->x * 3 / 4, NATURAL_SIZE->y * 3 });
+    EXPECT_TRUE(WRAPPED_SIZE.has_value());
+    EXPECT_LE(WRAPPED_SIZE->x, NATURAL_SIZE->x * 3 / 4);
+    EXPECT_GT(WRAPPED_SIZE->y, NATURAL_SIZE->y);
+
+    text->rebuild()->noEllipsize(false)->commence();
+    const auto ELLIPSIZED_SIZE = text->preferredSize({ NATURAL_SIZE->x * 3 / 4, NATURAL_SIZE->y * 3 });
+    EXPECT_TRUE(ELLIPSIZED_SIZE.has_value());
+    EXPECT_LE(ELLIPSIZED_SIZE->x, NATURAL_SIZE->x * 3 / 4);
+    EXPECT_EQ(ELLIPSIZED_SIZE->y, NATURAL_SIZE->y);
+
+    const auto FINAL_NATURAL_SIZE = text->preferredSize({0, 0});
+    EXPECT_TRUE(FINAL_NATURAL_SIZE.has_value());
+    EXPECT_EQ(FINAL_NATURAL_SIZE->x, FINAL_NATURAL_SIZE->x);
+    EXPECT_EQ(FINAL_NATURAL_SIZE->y, FINAL_NATURAL_SIZE->y);
+
+    text.reset();
+}
+
+TEST(Element, textGrowsAgainstNeighbor) {
+    Tests::Tricks::createBackendSupport();
+
+    const CBox POSITION = { 0, 0, 1000, 100 };
+
+    auto layout = CRowLayoutBuilder::begin()->commence();
+    auto text   = CTextBuilder::begin()->text("Hello World Foo Bar Baz")->commence();
+    auto rect   = CRectangleBuilder::begin()->size({CDynamicSize::HT_SIZE_AUTO, CDynamicSize::HT_SIZE_ABSOLUTE, {1, 10}})->commence();
+    rect->setGrow(true);
+
+    layout->addChild(text);
+    layout->addChild(rect);
+
+    g_positioner->position(layout, POSITION);
+
+    EXPECT_EQ(rect->impl->position.width + text->impl->position.width, POSITION.width);
+    const auto PREVIOUS_TEXT_WIDTH = text->impl->position.width;
+
+    text->rebuild()->text("Hello World Foo Bar Baz but longer");
+    EXPECT_EQ(rect->impl->position.width + text->impl->position.width, POSITION.width);
+    EXPECT_GE(text->impl->position.width, PREVIOUS_TEXT_WIDTH);
+
+    text.reset();
+    rect.reset();
+    layout.reset();
+}
+
+TEST(Element, textGrowsAfterShrinking) {
+    Tests::Tricks::createBackendSupport();
+
+    const CBox POSITION = { 0, 0, 1000, 100 };
+
     auto text = CTextBuilder::begin()->text("Hello World Foo Bar Baz")->commence();
 
-    // natural width: a generous box, no room hint
-    g_positioner->position(text, {{}, {1000.F, 20.F}}, {-1.F, -1.F});
-    const float NATURAL = text->preferredSize({}).value_or(Vector2D{}).x;
-    EXPECT_GT(NATURAL, 40.F);
+    g_positioner->position(text, POSITION);
+    const auto NATURAL_TEXT_WIDTH = text->impl->position.width;
 
-    // a transient narrow box on first layout clamps it
-    g_positioner->position(text, {{}, {NATURAL * 0.3F, 20.F}}, {-1.F, -1.F});
-    EXPECT_LT(text->preferredSize({}).value_or(Vector2D{}).x, NATURAL);
+    g_positioner->position(text, CBox{0, 0, NATURAL_TEXT_WIDTH * 3 / 4, 100 });
+    EXPECT_LT(text->impl->position.width, NATURAL_TEXT_WIDTH);
 
-    // from here the layout hands the auto label a box equal to its own preferred. feed that back a
-    // few frames: it must converge back to NATURAL, not stay locked at the clamped width.
-    for (int i = 0; i < 4; ++i) {
-        const auto PREF = text->preferredSize({}).value_or(Vector2D{});
-        g_positioner->position(text, {{}, PREF}, {-1.F, -1.F});
-    }
-    EXPECT_FLOAT_EQ(text->preferredSize({}).value_or(Vector2D{}).x, NATURAL);
+    g_positioner->position(text, POSITION);
+    EXPECT_EQ(text->impl->position.width, NATURAL_TEXT_WIDTH);
 
     text.reset();
 }
 
-// a stable room hint (e.g. the combobox row layout) clamps to the room and stays put, no per-frame
-// flicker at the fit/elide boundary.
-TEST(Element, textEllipsizeStableUnderRoomHint) {
+TEST(Element, textSideBySide) {
+    Tests::Tricks::createBackendSupport();
+
+    const CBox POSITION = { 0, 0, 300, 100 };
+
+    auto text1  = CTextBuilder::begin()
+                      ->size({CDynamicSize::HT_SIZE_PERCENT, CDynamicSize::HT_SIZE_AUTO, {0.5, 1.0}})
+                      ->text("First longish paragraph goes here. I love Hyprland it is the best.")
+                      ->noEllipsize(true)
+                      ->commence();
+    auto text2  = CTextBuilder::begin()
+                      ->size({CDynamicSize::HT_SIZE_PERCENT, CDynamicSize::HT_SIZE_AUTO, {0.5, 1.0}})
+                      ->text("Second longish paragraph goes here. Who needs GTK and Qt when you have Hyprtoolkit?")
+                      ->noEllipsize(true)
+                      ->commence();
+    auto layout = CRowLayoutBuilder::begin()
+                      ->commence();
+
+    const auto NATURAL_HEIGHT = text1->preferredSize({0, 0})->y;
+
+    layout->addChild(text1);
+    layout->addChild(text2);
+
+    g_positioner->position(layout, POSITION);
+
+    ASSERT_EQ(layout->impl->position.width, POSITION.width);
+    ASSERT_EQ(text1->impl->position.width, POSITION.width / 2);
+    ASSERT_EQ(text2->impl->position.width, POSITION.width / 2);
+    ASSERT_EQ(text1->impl->position.width, text2->impl->position.x);
+    ASSERT_GT(text1->impl->position.height, NATURAL_HEIGHT);
+    ASSERT_GT(text2->impl->position.height, NATURAL_HEIGHT);
+
+    text1.reset();
+    text2.reset();
+    layout.reset();
+}
+
+TEST(Element, textShrinkingThenGrowing) {
     Tests::Tricks::createBackendSupport();
 
-    auto        text    = CTextBuilder::begin()->text("Hello World Foo Bar Baz")->commence();
-    const float NATURAL = text->preferredSize({}).value_or(Vector2D{}).x;
-    EXPECT_GT(NATURAL, 20.F);
+    // This container is necessary because we need the text to auto size itself
+    // if we position it directly, the text sizing code is never run
+    auto container = CNullBuilder::begin()->commence();
+    auto text      = CTextBuilder::begin()
+                    ->text("First longish paragraph goes here. I love Hyprland it is the best.")
+                    ->commence();
 
-    const CBox     widebox = {{}, {NATURAL, 20.F}};
-    const Vector2D tight   = {NATURAL * 0.4F, 20.F};
+    container->addChild(text);
 
-    g_positioner->position(text, widebox, tight);
-    const float CLAMPED = text->preferredSize({}).value_or(Vector2D{}).x;
-    EXPECT_LT(CLAMPED, NATURAL);
+    const auto NATURAL_WIDTH = text->preferredSize({0, 0})->x;
 
-    // same room again does not flip the size
-    g_positioner->position(text, widebox, tight);
-    EXPECT_FLOAT_EQ(text->preferredSize({}).value_or(Vector2D{}).x, CLAMPED);
+    g_positioner->position(container, { 0, 0,  NATURAL_WIDTH * 3 / 4, 100 });
+    ASSERT_LE(text->impl->position.width, NATURAL_WIDTH * 3 / 4);
 
-    // room grows back: recover to full
-    g_positioner->position(text, widebox, {NATURAL + 80.F, 20.F});
-    EXPECT_FLOAT_EQ(text->preferredSize({}).value_or(Vector2D{}).x, NATURAL);
+    g_positioner->position(container, { 0, 0,  NATURAL_WIDTH * 2, 100 });
+    ASSERT_EQ(text->impl->position.width, NATURAL_WIDTH);
 
+    container.reset();
     text.reset();
-}
+}