kindred/create
1
1
Fork 0
Code Issues 53 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Gui: Rename StyleParameters::Length to StyleParameters::Numeric

Browse Source 
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.
This commit is contained in:
Kacper Donat
2025-08-10 23:06:41 +02:00
parent cf55183ece
commit 322ed2c7bc
7 changed files with 109 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/Gui/Dialogs/DlgThemeEditor.cpp
View File

@@ -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");

17
src/Gui/StyleParameters/ParameterManager.cpp
View File

@@ -31,30 +31,31 @@
#include <QRegularExpression>
#include <QString>
#include <ranges>
#include <utility>
#include <variant>
#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<Length>(*this)) {
auto [value, unit] = std::get<Length>(*this);
if (std::holds_alternative<Numeric>(*this)) {
auto [value, unit] = std::get<Numeric>(*this);
return fmt::format("{}{}", value, unit);
}

22
src/Gui/StyleParameters/ParameterManager.h
View File

@@ -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;
};
/**

12
src/Gui/StyleParameters/Parser.cpp
View File

@@ -80,7 +80,7 @@ Value FunctionCall::evaluate(const EvaluationContext& context) const
// 100 required by Qt.
//
// NOLINTNEXTLINE(*-magic-numbers)
auto amount = 100 + static_cast<int>(std::get<Length>(amountArg).value);
auto amount = 100 + static_cast<int>(std::get<Numeric>(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<Base::Color>(firstColorArg);
auto secondColor = std::get<Base::Color>(secondColorArg);
auto amount = Base::fromPercent(static_cast<long>(std::get<Length>(amountArg).value));
auto amount = Base::fromPercent(static_cast<long>(std::get<Numeric>(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<Length>(lval) || !std::holds_alternative<Length>(rval)) {
if (!std::holds_alternative<Numeric>(lval) || !std::holds_alternative<Numeric>(rval)) {
THROWM(Base::ExpressionError, "Math operations are supported only on lengths");
}
auto lhs = std::get<Length>(lval);
auto rhs = std::get<Length>(rval);
auto lhs = std::get<Numeric>(lval);
auto rhs = std::get<Numeric>(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<Length>(val);
auto v = std::get<Numeric>(val);
switch (op) {
case Operator::Add:
return v;

2
src/Gui/StyleParameters/Parser.h
View File

@@ -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)})

40
tests/src/Gui/StyleParameters/ParameterManagerTest.cpp
View File

@@ -66,8 +66,8 @@ TEST_F(ParameterManagerTest, BasicParameterResolution)
{
{
auto result = manager.resolve("BaseSize");
EXPECT_TRUE(std::holds_alternative<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result1));
EXPECT_TRUE(std::holds_alternative<Numeric>(result1));
// Second resolution should use cached value
auto result2 = manager.resolve("BaseSize");
EXPECT_TRUE(std::holds_alternative<Length>(result2));
EXPECT_TRUE(std::holds_alternative<Numeric>(result2));
// Results should be identical
auto length1 = std::get<Length>(result1);
auto length2 = std::get<Length>(result2);
auto length1 = std::get<Numeric>(result1);
auto length2 = std::get<Numeric>(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<Length>(result1));
auto length1 = std::get<Length>(result1);
EXPECT_TRUE(std::holds_alternative<Numeric>(result1));
auto length1 = std::get<Numeric>(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<Length>(result2));
auto length2 = std::get<Length>(result2);
EXPECT_TRUE(std::holds_alternative<Numeric>(result2));
auto length2 = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(result);
EXPECT_DOUBLE_EQ(length.value, 7.0); // (16 - 2) / 2 = 14 / 2 = 7
EXPECT_EQ(length.unit, "px");
}

120
tests/src/Gui/StyleParameters/ParserTest.cpp
View File

@@ -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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(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<Length>(result));
auto length = std::get<Length>(result);
EXPECT_TRUE(std::holds_alternative<Numeric>(result));
auto length = std::get<Numeric>(result);
EXPECT_DOUBLE_EQ(length.value, 10.0); // (10 - 5) * 2 = 5 * 2 = 10
EXPECT_EQ(length.unit, "");
}