From 8072dcac34f8a10ecd26e840bc2ed3f1bdf4a689 Mon Sep 17 00:00:00 2001 From: Kacper Donat Date: Sun, 10 Aug 2025 23:06:41 +0200 Subject: [PATCH] Gui: Rename StyleParameters::Length to StyleParameters::Numeric This change gives a better name to the parameter type that is used to store numeric values. Before it was called length, but it can store other quantities as well so the name is no longer fitting. --- src/Gui/Dialogs/DlgThemeEditor.cpp | 4 +- src/Gui/StyleParameters/ParameterManager.cpp | 17 +-- src/Gui/StyleParameters/ParameterManager.h | 22 ++-- src/Gui/StyleParameters/Parser.cpp | 12 +- src/Gui/StyleParameters/Parser.h | 2 +- .../StyleParameters/ParameterManagerTest.cpp | 40 +++--- tests/src/Gui/StyleParameters/ParserTest.cpp | 120 +++++++++--------- 7 files changed, 109 insertions(+), 108 deletions(-) diff --git a/src/Gui/Dialogs/DlgThemeEditor.cpp b/src/Gui/Dialogs/DlgThemeEditor.cpp index 03d614d588..e12180a8ed 100644 --- a/src/Gui/Dialogs/DlgThemeEditor.cpp +++ b/src/Gui/Dialogs/DlgThemeEditor.cpp @@ -65,8 +65,8 @@ QString typeOfTokenValue(const Gui::StyleParameters::Value& value) [](const std::string&) { return QWidget::tr("Generic"); }, - [](const Gui::StyleParameters::Length&) { - return QWidget::tr("Length"); + [](const Gui::StyleParameters::Numeric&) { + return QWidget::tr("Numeric"); }, [](const Base::Color&) { return QWidget::tr("Color"); diff --git a/src/Gui/StyleParameters/ParameterManager.cpp b/src/Gui/StyleParameters/ParameterManager.cpp index 5347634ca2..54efe995a0 100644 --- a/src/Gui/StyleParameters/ParameterManager.cpp +++ b/src/Gui/StyleParameters/ParameterManager.cpp @@ -31,30 +31,31 @@ #include #include #include +#include #include #endif namespace Gui::StyleParameters { -Length Length::operator+(const Length& rhs) const +Numeric Numeric::operator+(const Numeric& rhs) const { ensureEqualUnits(rhs); return {value + rhs.value, unit}; } -Length Length::operator-(const Length& rhs) const +Numeric Numeric::operator-(const Numeric& rhs) const { ensureEqualUnits(rhs); return {value - rhs.value, unit}; } -Length Length::operator-() const +Numeric Numeric::operator-() const { return {-value, unit}; } -Length Length::operator/(const Length& rhs) const +Numeric Numeric::operator/(const Numeric& rhs) const { if (rhs.value == 0) { THROWM(Base::RuntimeError, "Division by zero"); @@ -68,7 +69,7 @@ Length Length::operator/(const Length& rhs) const return {value / rhs.value, unit}; } -Length Length::operator*(const Length& rhs) const +Numeric Numeric::operator*(const Numeric& rhs) const { if (rhs.unit.empty() || unit.empty()) { return {value * rhs.value, unit}; @@ -78,7 +79,7 @@ Length Length::operator*(const Length& rhs) const return {value * rhs.value, unit}; } -void Length::ensureEqualUnits(const Length& rhs) const +void Numeric::ensureEqualUnits(const Numeric& rhs) const { if (unit != rhs.unit) { THROWM(Base::RuntimeError, @@ -90,8 +91,8 @@ void Length::ensureEqualUnits(const Length& rhs) const std::string Value::toString() const { - if (std::holds_alternative(*this)) { - auto [value, unit] = std::get(*this); + if (std::holds_alternative(*this)) { + auto [value, unit] = std::get(*this); return fmt::format("{}{}", value, unit); } diff --git a/src/Gui/StyleParameters/ParameterManager.h b/src/Gui/StyleParameters/ParameterManager.h index 8e53747c09..50902db46e 100644 --- a/src/Gui/StyleParameters/ParameterManager.h +++ b/src/Gui/StyleParameters/ParameterManager.h @@ -51,7 +51,7 @@ class Parser; * represents a dimensionless length that can be used as a scalar. This struct does not care about * unit conversions as its uses do not require it. */ -struct Length +struct Numeric { /// Numeric value of the length. double value; @@ -66,11 +66,11 @@ struct Length * and hence act as a scalar. * * @code{c++} - * Length a { 10, "px" }; - * Length b { 5, "px" }; + * Numeric a { 10, "px" }; + * Numeric b { 5, "px" }; * - * Length differentUnit { 3, "rem" } - * Length scalar { 2, "" }; + * Numeric differentUnit { 3, "rem" } + * Numeric scalar { 2, "" }; * * // basic operations with the same unit are allowed * auto sum = a + b; // 15 px @@ -85,16 +85,16 @@ struct Length * @endcode * @{ */ - Length operator+(const Length& rhs) const; - Length operator-(const Length& rhs) const; - Length operator-() const; + Numeric operator+(const Numeric& rhs) const; + Numeric operator-(const Numeric& rhs) const; + Numeric operator-() const; - Length operator/(const Length& rhs) const; - Length operator*(const Length& rhs) const; + Numeric operator/(const Numeric& rhs) const; + Numeric operator*(const Numeric& rhs) const; /// @} private: - void ensureEqualUnits(const Length& rhs) const; + void ensureEqualUnits(const Numeric& rhs) const; }; /** diff --git a/src/Gui/StyleParameters/Parser.cpp b/src/Gui/StyleParameters/Parser.cpp index 3cd22bc226..6e68e57a31 100644 --- a/src/Gui/StyleParameters/Parser.cpp +++ b/src/Gui/StyleParameters/Parser.cpp @@ -80,7 +80,7 @@ Value FunctionCall::evaluate(const EvaluationContext& context) const // 100 required by Qt. // // NOLINTNEXTLINE(*-magic-numbers) - auto amount = 100 + static_cast(std::get(amountArg).value); + auto amount = 100 + static_cast(std::get(amountArg).value); if (functionName == "lighten") { return Base::Color::fromValue(color.lighter(amount)); @@ -118,7 +118,7 @@ Value FunctionCall::evaluate(const EvaluationContext& context) const auto firstColor = std::get(firstColorArg); auto secondColor = std::get(secondColorArg); - auto amount = Base::fromPercent(static_cast(std::get(amountArg).value)); + auto amount = Base::fromPercent(static_cast(std::get(amountArg).value)); return Base::Color( (1 - amount) * firstColor.r + amount * secondColor.r, @@ -146,12 +146,12 @@ Value BinaryOp::evaluate(const EvaluationContext& context) const Value lval = left->evaluate(context); Value rval = right->evaluate(context); - if (!std::holds_alternative(lval) || !std::holds_alternative(rval)) { + if (!std::holds_alternative(lval) || !std::holds_alternative(rval)) { THROWM(Base::ExpressionError, "Math operations are supported only on lengths"); } - auto lhs = std::get(lval); - auto rhs = std::get(rval); + auto lhs = std::get(lval); + auto rhs = std::get(rval); switch (op) { case Operator::Add: @@ -174,7 +174,7 @@ Value UnaryOp::evaluate(const EvaluationContext& context) const THROWM(Base::ExpressionError, "Unary operations on colors are not supported"); } - auto v = std::get(val); + auto v = std::get(val); switch (op) { case Operator::Add: return v; diff --git a/src/Gui/StyleParameters/Parser.h b/src/Gui/StyleParameters/Parser.h index 34ff09ce6d..8d2ad27ecc 100644 --- a/src/Gui/StyleParameters/Parser.h +++ b/src/Gui/StyleParameters/Parser.h @@ -72,7 +72,7 @@ struct GuiExport ParameterReference: public Expr struct GuiExport Number: public Expr { - Length value; + Numeric value; Number(double value, std::string unit) : value({value, std::move(unit)}) diff --git a/tests/src/Gui/StyleParameters/ParameterManagerTest.cpp b/tests/src/Gui/StyleParameters/ParameterManagerTest.cpp index fd5e98cc6f..e3c53326f2 100644 --- a/tests/src/Gui/StyleParameters/ParameterManagerTest.cpp +++ b/tests/src/Gui/StyleParameters/ParameterManagerTest.cpp @@ -66,8 +66,8 @@ TEST_F(ParameterManagerTest, BasicParameterResolution) { { auto result = manager.resolve("BaseSize"); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 16.0); // Should get value from source2 (later source) EXPECT_EQ(length.unit, "px"); } @@ -96,16 +96,16 @@ TEST_F(ParameterManagerTest, ParameterReferences) { { auto result = manager.resolve("Margin"); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 32.0); // @BaseSize * 2 = 16 * 2 = 32 EXPECT_EQ(length.unit, "px"); } { auto result = manager.resolve("Padding"); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 8.0); // @BaseSize / 2 = 16 / 2 = 8 EXPECT_EQ(length.unit, "px"); } @@ -116,15 +116,15 @@ TEST_F(ParameterManagerTest, Caching) { // First resolution should cache the result auto result1 = manager.resolve("BaseSize"); - EXPECT_TRUE(std::holds_alternative(result1)); + EXPECT_TRUE(std::holds_alternative(result1)); // Second resolution should use cached value auto result2 = manager.resolve("BaseSize"); - EXPECT_TRUE(std::holds_alternative(result2)); + EXPECT_TRUE(std::holds_alternative(result2)); // Results should be identical - auto length1 = std::get(result1); - auto length2 = std::get(result2); + auto length1 = std::get(result1); + auto length2 = std::get(result2); EXPECT_DOUBLE_EQ(length1.value, length2.value); EXPECT_EQ(length1.unit, length2.unit); } @@ -134,8 +134,8 @@ TEST_F(ParameterManagerTest, CacheInvalidation) { // Initial resolution auto result1 = manager.resolve("BaseSize"); - EXPECT_TRUE(std::holds_alternative(result1)); - auto length1 = std::get(result1); + EXPECT_TRUE(std::holds_alternative(result1)); + auto length1 = std::get(result1); EXPECT_DOUBLE_EQ(length1.value, 16.0); // Reload should clear cache @@ -143,8 +143,8 @@ TEST_F(ParameterManagerTest, CacheInvalidation) // Resolution after reload should work the same auto result2 = manager.resolve("BaseSize"); - EXPECT_TRUE(std::holds_alternative(result2)); - auto length2 = std::get(result2); + EXPECT_TRUE(std::holds_alternative(result2)); + auto length2 = std::get(result2); EXPECT_DOUBLE_EQ(length2.value, 16.0); EXPECT_EQ(length1.unit, length2.unit); } @@ -164,8 +164,8 @@ TEST_F(ParameterManagerTest, SourcePriority) // Should get value from the latest source (highest priority) auto result = manager.resolve("BaseSize"); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 24.0); EXPECT_EQ(length.unit, "px"); } @@ -279,16 +279,16 @@ TEST_F(ParameterManagerTest, ComplexExpressions) { auto result = manager.resolve("ComplexMargin"); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 40.0); // (16 + 4) * 2 = 20 * 2 = 40 EXPECT_EQ(length.unit, "px"); } { auto result = manager.resolve("ComplexPadding"); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 7.0); // (16 - 2) / 2 = 14 / 2 = 7 EXPECT_EQ(length.unit, "px"); } diff --git a/tests/src/Gui/StyleParameters/ParserTest.cpp b/tests/src/Gui/StyleParameters/ParserTest.cpp index 563c1265e7..a2b550f34c 100644 --- a/tests/src/Gui/StyleParameters/ParserTest.cpp +++ b/tests/src/Gui/StyleParameters/ParserTest.cpp @@ -59,8 +59,8 @@ TEST_F(ParserTest, ParseNumbers) Parser parser("42"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 42.0); EXPECT_EQ(length.unit, ""); } @@ -69,8 +69,8 @@ TEST_F(ParserTest, ParseNumbers) Parser parser("10.5px"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 10.5); EXPECT_EQ(length.unit, "px"); } @@ -79,8 +79,8 @@ TEST_F(ParserTest, ParseNumbers) Parser parser("2.5em"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 2.5); EXPECT_EQ(length.unit, "em"); } @@ -89,8 +89,8 @@ TEST_F(ParserTest, ParseNumbers) Parser parser("100%"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 100.0); EXPECT_EQ(length.unit, "%"); } @@ -163,8 +163,8 @@ TEST_F(ParserTest, ParseParameterReferences) Parser parser("@TestParam"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 10.0); EXPECT_EQ(length.unit, "px"); } @@ -184,8 +184,8 @@ TEST_F(ParserTest, ParseParameterReferences) Parser parser("@TestNumber"); auto expr = parser.parse(); auto result = expr->evaluate({.manager = &manager, .context = {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 5.0); EXPECT_EQ(length.unit, ""); } @@ -198,8 +198,8 @@ TEST_F(ParserTest, ParseArithmeticOperations) Parser parser("10 + 5"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 15.0); EXPECT_EQ(length.unit, ""); } @@ -208,8 +208,8 @@ TEST_F(ParserTest, ParseArithmeticOperations) Parser parser("10px + 5px"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 15.0); EXPECT_EQ(length.unit, "px"); } @@ -218,8 +218,8 @@ TEST_F(ParserTest, ParseArithmeticOperations) Parser parser("10 - 5"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 5.0); EXPECT_EQ(length.unit, ""); } @@ -228,8 +228,8 @@ TEST_F(ParserTest, ParseArithmeticOperations) Parser parser("10px - 5px"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 5.0); EXPECT_EQ(length.unit, "px"); } @@ -238,8 +238,8 @@ TEST_F(ParserTest, ParseArithmeticOperations) Parser parser("10 * 5"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 50.0); EXPECT_EQ(length.unit, ""); } @@ -248,8 +248,8 @@ TEST_F(ParserTest, ParseArithmeticOperations) Parser parser("10px * 2"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 20.0); EXPECT_EQ(length.unit, "px"); } @@ -258,8 +258,8 @@ TEST_F(ParserTest, ParseArithmeticOperations) Parser parser("10 / 2"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 5.0); EXPECT_EQ(length.unit, ""); } @@ -268,8 +268,8 @@ TEST_F(ParserTest, ParseArithmeticOperations) Parser parser("10px / 2"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 5.0); EXPECT_EQ(length.unit, "px"); } @@ -282,8 +282,8 @@ TEST_F(ParserTest, ParseComplexExpressions) Parser parser("(10 + 5) * 2"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 30.0); EXPECT_EQ(length.unit, ""); } @@ -292,8 +292,8 @@ TEST_F(ParserTest, ParseComplexExpressions) Parser parser("(10px + 5px) * 2"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 30.0); EXPECT_EQ(length.unit, "px"); } @@ -302,8 +302,8 @@ TEST_F(ParserTest, ParseComplexExpressions) Parser parser("@TestParam + 5px"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 15.0); EXPECT_EQ(length.unit, "px"); } @@ -312,8 +312,8 @@ TEST_F(ParserTest, ParseComplexExpressions) Parser parser("@TestParam * @TestNumber"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 50.0); EXPECT_EQ(length.unit, "px"); } @@ -326,8 +326,8 @@ TEST_F(ParserTest, ParseUnaryOperations) Parser parser("+10"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 10.0); EXPECT_EQ(length.unit, ""); } @@ -336,8 +336,8 @@ TEST_F(ParserTest, ParseUnaryOperations) Parser parser("-10"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, -10.0); EXPECT_EQ(length.unit, ""); } @@ -346,8 +346,8 @@ TEST_F(ParserTest, ParseUnaryOperations) Parser parser("-10px"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, -10.0); EXPECT_EQ(length.unit, "px"); } @@ -476,8 +476,8 @@ TEST_F(ParserTest, ParseWhitespace) Parser parser(" 10 + 5 "); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 15.0); EXPECT_EQ(length.unit, ""); } @@ -486,8 +486,8 @@ TEST_F(ParserTest, ParseWhitespace) Parser parser("10px+5px"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 15.0); EXPECT_EQ(length.unit, "px"); } @@ -528,8 +528,8 @@ TEST_F(ParserTest, ParseEdgeCases) Parser parser("42"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 42.0); EXPECT_EQ(length.unit, ""); } @@ -551,8 +551,8 @@ TEST_F(ParserTest, ParseEdgeCases) Parser parser("@TestParam"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 10.0); EXPECT_EQ(length.unit, "px"); } @@ -565,8 +565,8 @@ TEST_F(ParserTest, ParseOperatorPrecedence) Parser parser("2 + 3 * 4"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 14.0); // 2 + (3 * 4) = 2 + 12 = 14 EXPECT_EQ(length.unit, ""); } @@ -575,8 +575,8 @@ TEST_F(ParserTest, ParseOperatorPrecedence) Parser parser("10 - 3 * 2"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 4.0); // 10 - (3 * 2) = 10 - 6 = 4 EXPECT_EQ(length.unit, ""); } @@ -585,8 +585,8 @@ TEST_F(ParserTest, ParseOperatorPrecedence) Parser parser("20 / 4 + 3"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 8.0); // (20 / 4) + 3 = 5 + 3 = 8 EXPECT_EQ(length.unit, ""); } @@ -599,8 +599,8 @@ TEST_F(ParserTest, ParseNestedParentheses) Parser parser("((2 + 3) * 4)"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 20.0); // (5) * 4 = 20 EXPECT_EQ(length.unit, ""); } @@ -609,8 +609,8 @@ TEST_F(ParserTest, ParseNestedParentheses) Parser parser("(10 - (3 + 2)) * 2"); auto expr = parser.parse(); auto result = expr->evaluate({&manager, {}}); - EXPECT_TRUE(std::holds_alternative(result)); - auto length = std::get(result); + EXPECT_TRUE(std::holds_alternative(result)); + auto length = std::get(result); EXPECT_DOUBLE_EQ(length.value, 10.0); // (10 - 5) * 2 = 5 * 2 = 10 EXPECT_EQ(length.unit, ""); }