diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 0000000..f0dfdf1 --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,101 @@ +WarningsAsErrors: '*' +HeaderFilterRegex: '.*\.hpp' +FormatStyle: file +Checks: > + -*, + bugprone-*, + -bugprone-easily-swappable-parameters, + -bugprone-forward-declararion-namespace, + -bugprone-forward-declararion-namespace, + -bugprone-macro-parentheses, + -bugprone-narrowing-conversions, + -bugprone-branch-clone, + -bugprone-assignment-in-if-condition, + concurrency-*, + -concurrency-mt-unsafe, + cppcoreguidelines-*, + -cppcoreguidelines-owning-memory, + -cppcoreguidelines-avoid-magic-numbers, + -cppcoreguidelines-pro-bounds-constant-array-index, + -cppcoreguidelines-avoid-const-or-ref-data-members, + -cppcoreguidelines-non-private-member-variables-in-classes, + -cppcoreguidelines-avoid-goto, + -cppcoreguidelines-pro-bounds-array-to-pointer-decay, + -cppcoreguidelines-avoid-do-while, + -cppcoreguidelines-avoid-non-const-global-variables, + -cppcoreguidelines-special-member-functions, + -cppcoreguidelines-explicit-virtual-functions, + -cppcoreguidelines-avoid-c-arrays, + -cppcoreguidelines-pro-bounds-pointer-arithmetic, + -cppcoreguidelines-narrowing-conversions, + -cppcoreguidelines-pro-type-union-access, + -cppcoreguidelines-pro-type-member-init, + -cppcoreguidelines-macro-usage, + -cppcoreguidelines-macro-to-enum, + -cppcoreguidelines-init-variables, + -cppcoreguidelines-pro-type-cstyle-cast, + -cppcoreguidelines-pro-type-vararg, + -cppcoreguidelines-pro-type-reinterpret-cast, + google-global-names-in-headers, + -google-readability-casting, + google-runtime-operator, + misc-*, + -misc-unused-parameters, + -misc-no-recursion, + -misc-non-private-member-variables-in-classes, + -misc-include-cleaner, + -misc-use-anonymous-namespace, + -misc-const-correctness, + modernize-*, + -modernize-return-braced-init-list, + -modernize-use-trailing-return-type, + -modernize-use-using, + -modernize-use-override, + -modernize-avoid-c-arrays, + -modernize-macro-to-enum, + -modernize-loop-convert, + -modernize-use-nodiscard, + -modernize-pass-by-value, + -modernize-use-auto, + performance-*, + -performance-avoid-endl, + -performance-unnecessary-value-param, + portability-std-allocator-const, + readability-*, + -readability-function-cognitive-complexity, + -readability-function-size, + -readability-identifier-length, + -readability-magic-numbers, + -readability-uppercase-literal-suffix, + -readability-braces-around-statements, + -readability-redundant-access-specifiers, + -readability-else-after-return, + -readability-container-data-pointer, + -readability-implicit-bool-conversion, + -readability-avoid-nested-conditional-operator, + -readability-redundant-member-init, + -readability-redundant-string-init, + -readability-avoid-const-params-in-decls, + -readability-named-parameter, + -readability-convert-member-functions-to-static, + -readability-qualified-auto, + -readability-make-member-function-const, + -readability-isolate-declaration, + -readability-inconsistent-declaration-parameter-name, + -clang-diagnostic-error, + +CheckOptions: + performance-for-range-copy.WarnOnAllAutoCopies: true + performance-inefficient-string-concatenation.StrictMode: true + readability-braces-around-statements.ShortStatementLines: 0 + readability-identifier-naming.ClassCase: CamelCase + readability-identifier-naming.ClassIgnoredRegexp: I.* + readability-identifier-naming.ClassPrefix: C # We can't use regex here?!?!?!? + readability-identifier-naming.EnumCase: CamelCase + readability-identifier-naming.EnumPrefix: e + readability-identifier-naming.EnumConstantCase: UPPER_CASE + readability-identifier-naming.FunctionCase: camelBack + readability-identifier-naming.NamespaceCase: CamelCase + readability-identifier-naming.NamespacePrefix: N + readability-identifier-naming.StructPrefix: S + readability-identifier-naming.StructCase: CamelCase diff --git a/CMakeLists.txt b/CMakeLists.txt index 70e8099..4ec92f4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -28,6 +28,13 @@ endif() add_compile_definitions(HYPRLANG_INTERNAL) set(CMAKE_CXX_STANDARD 23) +add_compile_options( + -Wall + -Wextra + -Wpedantic + -Wno-unused-parameter + -Wno-missing-field-initializers) +set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE) find_package(PkgConfig REQUIRED) pkg_check_modules(deps REQUIRED IMPORTED_TARGET hyprutils>=0.1.1) diff --git a/src/common.cpp b/src/common.cpp index cfe43bb..a1c1504 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -1,6 +1,6 @@ #include "public.hpp" #include "config.hpp" -#include +#include using namespace Hyprlang; @@ -30,38 +30,28 @@ CConfigValue::~CConfigValue() { } } -CConfigValue::CConfigValue(const int64_t value) { - m_pData = new int64_t; +CConfigValue::CConfigValue(const int64_t value) : m_eType(CONFIGDATATYPE_INT), m_pData(new int64_t) { *reinterpret_cast(m_pData) = value; - m_eType = CONFIGDATATYPE_INT; } -CConfigValue::CConfigValue(const float value) { - m_pData = new float; +CConfigValue::CConfigValue(const float value) : m_eType(CONFIGDATATYPE_FLOAT), m_pData(new float) { *reinterpret_cast(m_pData) = value; - m_eType = CONFIGDATATYPE_FLOAT; } -CConfigValue::CConfigValue(const SVector2D value) { - m_pData = new SVector2D; +CConfigValue::CConfigValue(const SVector2D value) : m_eType(CONFIGDATATYPE_VEC2), m_pData(new SVector2D) { *reinterpret_cast(m_pData) = value; - m_eType = CONFIGDATATYPE_VEC2; } -CConfigValue::CConfigValue(const char* value) { - m_pData = new char[strlen(value) + 1]; +CConfigValue::CConfigValue(const char* value) : m_eType(CONFIGDATATYPE_STR), m_pData(new char[strlen(value) + 1]) { strncpy((char*)m_pData, value, strlen(value)); ((char*)m_pData)[strlen(value)] = '\0'; - m_eType = CONFIGDATATYPE_STR; } -CConfigValue::CConfigValue(CConfigCustomValueType&& value) { - m_pData = new CConfigCustomValueType(value); - m_eType = CONFIGDATATYPE_CUSTOM; +CConfigValue::CConfigValue(CConfigCustomValueType&& value) : m_eType(CONFIGDATATYPE_CUSTOM), m_pData(new CConfigCustomValueType(value)) { + ; } -CConfigValue::CConfigValue(const CConfigValue& other) { - m_eType = other.m_eType; +CConfigValue::CConfigValue(const CConfigValue& other) : m_eType(other.m_eType) { setFrom(&other); } @@ -77,11 +67,9 @@ void* const* CConfigValue::getDataStaticPtr() const { return &m_pData; } -CConfigCustomValueType::CConfigCustomValueType(PCONFIGCUSTOMVALUEHANDLERFUNC handler_, PCONFIGCUSTOMVALUEDESTRUCTOR dtor_, const char* def) { - handler = handler_; - dtor = dtor_; - defaultVal = def; - lastVal = def; +CConfigCustomValueType::CConfigCustomValueType(PCONFIGCUSTOMVALUEHANDLERFUNC handler_, PCONFIGCUSTOMVALUEDESTRUCTOR dtor_, const char* def) : + handler(handler_), dtor(dtor_), defaultVal(def), lastVal(def) { + ; } CConfigCustomValueType::~CConfigCustomValueType() { @@ -216,4 +204,4 @@ void CConfigValue::setFrom(std::any ref) { throw "bad defaultFrom type"; } } -} \ No newline at end of file +} diff --git a/src/config.cpp b/src/config.cpp index d879c34..f1c01ca 100644 --- a/src/config.cpp +++ b/src/config.cpp @@ -20,17 +20,18 @@ using namespace Hyprutils::String; #include #define environ (*_NSGetEnviron()) #else +// NOLINTNEXTLINE extern "C" char** environ; #endif // defines -inline constexpr const char* ANONYMOUS_KEY = "__hyprlang_internal_anonymous_key"; +inline constexpr const char* ANONYMOUS_KEY = "__hyprlang_internal_anonymous_key"; inline constexpr const char* MULTILINE_SPACE_CHARSET = " \t"; // static size_t seekABIStructSize(const void* begin, size_t startOffset, size_t maxSize) { for (size_t off = startOffset; off < maxSize; off += 4) { - if (*(int*)((unsigned char*)begin + off) == int{HYPRLANG_END_MAGIC}) + if (*(int*)((unsigned char*)begin + off) == HYPRLANG_END_MAGIC) return off; } @@ -48,7 +49,7 @@ static std::expected getNextLine(std::istream& while (line.length() > 0 && line.at(line.length() - 1) == '\\') { const auto lastNonSpace = line.length() < 2 ? -1 : line.find_last_not_of(MULTILINE_SPACE_CHARSET, line.length() - 2); - line = line.substr(0, lastNonSpace + 1); + line = line.substr(0, lastNonSpace + 1); if (!std::getline(str, nextLine)) return std::unexpected(GETNEXTLINEFAILURE_BACKSLASH); @@ -60,13 +61,10 @@ static std::expected getNextLine(std::istream& return line; } - -CConfig::CConfig(const char* path, const Hyprlang::SConfigOptions& options_) { +CConfig::CConfig(const char* path, const Hyprlang::SConfigOptions& options_) : impl(new CConfigImpl) { SConfigOptions options; std::memcpy(&options, &options_, seekABIStructSize(&options_, 16, sizeof(SConfigOptions))); - impl = new CConfigImpl; - if (options.pathIsStream) impl->rawConfigString = path; else @@ -85,7 +83,7 @@ CConfig::CConfig(const char* path, const Hyprlang::SConfigOptions& options_) { impl->envVariables.push_back({VARIABLE, VALUE}); } - std::sort(impl->envVariables.begin(), impl->envVariables.end(), [&](const auto& a, const auto& b) { return a.name.length() > b.name.length(); }); + std::ranges::sort(impl->envVariables, [&](const auto& a, const auto& b) { return a.name.length() > b.name.length(); }); impl->configOptions = options; } @@ -99,40 +97,42 @@ void CConfig::addConfigValue(const char* name, const CConfigValue& value) { throw "Cannot addConfigValue after commence()"; if ((eDataType)value.m_eType != CONFIGDATATYPE_CUSTOM && (eDataType)value.m_eType != CONFIGDATATYPE_STR) - impl->defaultValues.emplace(name, SConfigDefaultValue{value.getValue(), (eDataType)value.m_eType}); + impl->defaultValues.emplace(name, SConfigDefaultValue{.data = value.getValue(), .type = (eDataType)value.m_eType}); else if ((eDataType)value.m_eType == CONFIGDATATYPE_STR) - impl->defaultValues.emplace(name, SConfigDefaultValue{std::string{std::any_cast(value.getValue())}, (eDataType)value.m_eType}); + impl->defaultValues.emplace(name, SConfigDefaultValue{.data = std::string{std::any_cast(value.getValue())}, .type = (eDataType)value.m_eType}); else impl->defaultValues.emplace(name, - SConfigDefaultValue{reinterpret_cast(value.m_pData)->defaultVal, (eDataType)value.m_eType, - reinterpret_cast(value.m_pData)->handler, - reinterpret_cast(value.m_pData)->dtor}); + SConfigDefaultValue{.data = reinterpret_cast(value.m_pData)->defaultVal, + .type = (eDataType)value.m_eType, + .handler = reinterpret_cast(value.m_pData)->handler, + .dtor = reinterpret_cast(value.m_pData)->dtor}); } void CConfig::addSpecialConfigValue(const char* cat, const char* name, const CConfigValue& value) { - const auto IT = std::find_if(impl->specialCategoryDescriptors.begin(), impl->specialCategoryDescriptors.end(), [&](const auto& other) { return other->name == cat; }); + const auto IT = std::ranges::find_if(impl->specialCategoryDescriptors, [&](const auto& other) { return other->name == cat; }); if (IT == impl->specialCategoryDescriptors.end()) throw "No such category"; if ((eDataType)value.m_eType != CONFIGDATATYPE_CUSTOM && (eDataType)value.m_eType != CONFIGDATATYPE_STR) - IT->get()->defaultValues.emplace(name, SConfigDefaultValue{value.getValue(), (eDataType)value.m_eType}); + IT->get()->defaultValues.emplace(name, SConfigDefaultValue{.data = value.getValue(), .type = (eDataType)value.m_eType}); else if ((eDataType)value.m_eType == CONFIGDATATYPE_STR) - IT->get()->defaultValues.emplace(name, SConfigDefaultValue{std::string{std::any_cast(value.getValue())}, (eDataType)value.m_eType}); + IT->get()->defaultValues.emplace(name, SConfigDefaultValue{.data = std::string{std::any_cast(value.getValue())}, .type = (eDataType)value.m_eType}); else IT->get()->defaultValues.emplace(name, - SConfigDefaultValue{reinterpret_cast(value.m_pData)->defaultVal, (eDataType)value.m_eType, - reinterpret_cast(value.m_pData)->handler, - reinterpret_cast(value.m_pData)->dtor}); + SConfigDefaultValue{.data = reinterpret_cast(value.m_pData)->defaultVal, + .type = (eDataType)value.m_eType, + .handler = reinterpret_cast(value.m_pData)->handler, + .dtor = reinterpret_cast(value.m_pData)->dtor}); - const auto CAT = std::find_if(impl->specialCategories.begin(), impl->specialCategories.end(), [cat, name](const auto& other) { return other->name == cat && other->isStatic; }); + const auto CAT = std::ranges::find_if(impl->specialCategories, [cat](const auto& other) { return other->name == cat && other->isStatic; }); if (CAT != impl->specialCategories.end()) CAT->get()->values[name].defaultFrom(IT->get()->defaultValues[name]); } void CConfig::removeSpecialConfigValue(const char* cat, const char* name) { - const auto IT = std::find_if(impl->specialCategoryDescriptors.begin(), impl->specialCategoryDescriptors.end(), [&](const auto& other) { return other->name == cat; }); + const auto IT = std::ranges::find_if(impl->specialCategoryDescriptors, [&](const auto& other) { return other->name == cat; }); if (IT == impl->specialCategoryDescriptors.end()) throw "No such category"; @@ -163,9 +163,8 @@ void CConfig::addSpecialCategory(const char* name, SSpecialCategoryOptions optio } // sort longest to shortest - std::sort(impl->specialCategories.begin(), impl->specialCategories.end(), [](const auto& a, const auto& b) -> int { return a->name.length() > b->name.length(); }); - std::sort(impl->specialCategoryDescriptors.begin(), impl->specialCategoryDescriptors.end(), - [](const auto& a, const auto& b) -> int { return a->name.length() > b->name.length(); }); + std::ranges::sort(impl->specialCategories, [](const auto& a, const auto& b) -> int { return a->name.length() > b->name.length(); }); + std::ranges::sort(impl->specialCategoryDescriptors, [](const auto& a, const auto& b) -> int { return a->name.length() > b->name.length(); }); } void CConfig::removeSpecialCategory(const char* name) { @@ -220,7 +219,7 @@ static std::expected configStringToInt(const std::string& if (!r.has_value() || !g.has_value() || !b.has_value()) return std::unexpected("failed parsing " + VALUEWITHOUTFUNC); - return a * (Hyprlang::INT)0x1000000 + r.value() * (Hyprlang::INT)0x10000 + g.value() * (Hyprlang::INT)0x100 + b.value(); + return (a * (Hyprlang::INT)0x1000000) + (r.value() * (Hyprlang::INT)0x10000) + (g.value() * (Hyprlang::INT)0x100) + b.value(); } else if (VALUEWITHOUTFUNC.length() == 8) { const auto RGBA = parseHex(VALUEWITHOUTFUNC); @@ -228,7 +227,7 @@ static std::expected configStringToInt(const std::string& return RGBA; // now we need to RGBA -> ARGB. The config holds ARGB only. - return (RGBA.value() >> 8) + 0x1000000 * (RGBA.value() & 0xFF); + return (RGBA.value() >> 8) + (0x1000000 * (RGBA.value() & 0xFF)); } return std::unexpected("rgba() expects length of 8 characters (4 bytes) or 4 comma separated values"); @@ -249,7 +248,7 @@ static std::expected configStringToInt(const std::string& if (!r.has_value() || !g.has_value() || !b.has_value()) return std::unexpected("failed parsing " + VALUEWITHOUTFUNC); - return (Hyprlang::INT)0xFF000000 + r.value() * (Hyprlang::INT)0x10000 + g.value() * (Hyprlang::INT)0x100 + b.value(); + return (Hyprlang::INT)0xFF000000 + (r.value() * (Hyprlang::INT)0x10000) + (g.value() * (Hyprlang::INT)0x100) + b.value(); } else if (VALUEWITHOUTFUNC.length() == 6) { const auto RGB = parseHex(VALUEWITHOUTFUNC); @@ -382,8 +381,7 @@ CParseResult CConfig::configSetValueSafe(const std::string& command, const std:: // find suitable key size_t biggest = 0; for (auto& catt : impl->specialCategories) { - if (catt->anonymousID > biggest) - biggest = catt->anonymousID; + biggest = std::max(catt->anonymousID, biggest); } biggest++; @@ -442,7 +440,7 @@ CParseResult CConfig::configSetValueSafe(const std::string& command, const std:: if (LHS.contains(" ") || RHS.contains(" ")) throw std::runtime_error("too many args"); - VALUEIT->second.setFrom(SVector2D{std::stof(LHS), std::stof(RHS)}); + VALUEIT->second.setFrom(SVector2D{.x = std::stof(LHS), .y = std::stof(RHS)}); } catch (std::exception& e) { result.setError(std::format("failed parsing a vec2: {}", e.what())); return result; @@ -476,14 +474,14 @@ CParseResult CConfig::configSetValueSafe(const std::string& command, const std:: } CParseResult CConfig::parseVariable(const std::string& lhs, const std::string& rhs, bool dynamic) { - auto IT = std::find_if(impl->variables.begin(), impl->variables.end(), [&](const auto& v) { return v.name == lhs.substr(1); }); + auto IT = std::ranges::find_if(impl->variables, [&](const auto& v) { return v.name == lhs.substr(1); }); if (IT != impl->variables.end()) IT->value = rhs; else { impl->variables.push_back({lhs.substr(1), rhs}); - std::sort(impl->variables.begin(), impl->variables.end(), [](const auto& lhs, const auto& rhs) { return lhs.name.length() > rhs.name.length(); }); - IT = std::find_if(impl->variables.begin(), impl->variables.end(), [&](const auto& v) { return v.name == lhs.substr(1); }); + std::ranges::sort(impl->variables, [](const auto& lhs, const auto& rhs) { return lhs.name.length() > rhs.name.length(); }); + IT = std::ranges::find_if(impl->variables, [&](const auto& v) { return v.name == lhs.substr(1); }); } if (dynamic) { @@ -618,7 +616,7 @@ CParseResult CConfig::parseLine(std::string line, bool dynamic) { size_t idx = 0; size_t depth = 0; - while ((colon = HANDLERNAME.find(":", idx)) != std::string::npos && impl->categories.size() > depth) { + while ((colon = HANDLERNAME.find(':', idx)) != std::string::npos && impl->categories.size() > depth) { auto actual = HANDLERNAME.substr(idx, colon - idx); if (actual != impl->categories[depth]) @@ -720,8 +718,8 @@ CParseResult CConfig::parse() { CParseResult CConfig::parseRawStream(const std::string& stream) { CParseResult result; - int rawLineNum = 0; - int lineNum = 0; + int rawLineNum = 0; + int lineNum = 0; std::stringstream str(stream); @@ -863,7 +861,7 @@ CConfigValue* CConfig::getSpecialConfigValuePtr(const char* category, const char void CConfig::registerHandler(PCONFIGHANDLERFUNC func, const char* name, SHandlerOptions options_) { SHandlerOptions options; std::memcpy(&options, &options_, seekABIStructSize(&options_, 0, sizeof(SHandlerOptions))); - impl->handlers.push_back(SHandler{name, options, func}); + impl->handlers.push_back(SHandler{.name = name, .options = options, .func = func}); } void CConfig::unregisterHandler(const char* name) { diff --git a/tests/fuzz/main.cpp b/tests/fuzz/main.cpp index 3f6effd..b0bfe00 100644 --- a/tests/fuzz/main.cpp +++ b/tests/fuzz/main.cpp @@ -11,7 +11,7 @@ std::string garbage() { std::string chars; for (int i = 0; i < len; ++i) { - chars += rand() % 254 + 1; + chars += std::to_string((rand() % 254) + 1); } return chars; diff --git a/tests/parse/main.cpp b/tests/parse/main.cpp old mode 100755 new mode 100644 index 52d3154..f0397ca --- a/tests/parse/main.cpp +++ b/tests/parse/main.cpp @@ -48,7 +48,7 @@ static Hyprlang::CParseResult handleFlagsTest(const char* COMMAND, const char* V } static Hyprlang::CParseResult handleCategoryKeyword(const char* COMMAND, const char* VALUE) { - categoryKeywordActualValues.push_back(VALUE); + categoryKeywordActualValues.emplace_back(VALUE); return Hyprlang::CParseResult(); } @@ -108,7 +108,7 @@ int main(int argc, char** argv, char** envp) { // setup config config.addConfigValue("testInt", (Hyprlang::INT)0); config.addConfigValue("testFloat", 0.F); - config.addConfigValue("testVec", Hyprlang::SVector2D{69, 420}); + config.addConfigValue("testVec", Hyprlang::SVector2D{.x = 69, .y = 420}); config.addConfigValue("testString", ""); config.addConfigValue("testStringColon", ""); config.addConfigValue("testEnv", ""); @@ -131,27 +131,27 @@ int main(int argc, char** argv, char** envp) { config.addConfigValue("myColors:random", (Hyprlang::INT)0); config.addConfigValue("customType", {Hyprlang::CConfigCustomValueType{&handleCustomValueSet, &handleCustomValueDestroy, "def"}}); - config.registerHandler(&handleDoABarrelRoll, "doABarrelRoll", {false}); - config.registerHandler(&handleFlagsTest, "flags", {true}); - config.registerHandler(&handleSource, "source", {false}); - config.registerHandler(&handleTestIgnoreKeyword, "testIgnoreKeyword", {false}); - config.registerHandler(&handleTestUseKeyword, ":testUseKeyword", {false}); - config.registerHandler(&handleNoop, "testCategory:testUseKeyword", {false}); - config.registerHandler(&handleCategoryKeyword, "testCategory:categoryKeyword", {false}); + config.registerHandler(&handleDoABarrelRoll, "doABarrelRoll", {.allowFlags = false}); + config.registerHandler(&handleFlagsTest, "flags", {.allowFlags = true}); + config.registerHandler(&handleSource, "source", {.allowFlags = false}); + config.registerHandler(&handleTestIgnoreKeyword, "testIgnoreKeyword", {.allowFlags = false}); + config.registerHandler(&handleTestUseKeyword, ":testUseKeyword", {.allowFlags = false}); + config.registerHandler(&handleNoop, "testCategory:testUseKeyword", {.allowFlags = false}); + config.registerHandler(&handleCategoryKeyword, "testCategory:categoryKeyword", {.allowFlags = false}); - config.addSpecialCategory("special", {"key"}); + config.addSpecialCategory("special", {.key = "key"}); config.addSpecialConfigValue("special", "value", (Hyprlang::INT)0); - config.addSpecialCategory("specialAnonymous", {nullptr, false, true}); + config.addSpecialCategory("specialAnonymous", {.key = nullptr, .ignoreMissing = false, .anonymousKeyBased = true}); config.addSpecialConfigValue("specialAnonymous", "value", (Hyprlang::INT)0); config.addConfigValue("multiline", ""); config.commence(); - config.addSpecialCategory("specialGeneric:one", {nullptr, true}); + config.addSpecialCategory("specialGeneric:one", {.key = nullptr, .ignoreMissing = true}); config.addSpecialConfigValue("specialGeneric:one", "value", (Hyprlang::INT)0); - config.addSpecialCategory("specialGeneric:two", {nullptr, true}); + config.addSpecialCategory("specialGeneric:two", {.key = nullptr, .ignoreMissing = true}); config.addSpecialConfigValue("specialGeneric:two", "value", (Hyprlang::INT)0); const Hyprlang::CConfigValue copyTest = {(Hyprlang::INT)1}; @@ -169,7 +169,7 @@ int main(int argc, char** argv, char** envp) { std::cout << " → Testing values\n"; EXPECT(std::any_cast(config.getConfigValue("testInt")), 123); EXPECT(std::any_cast(config.getConfigValue("testFloat")), 123.456f); - auto EXP = Hyprlang::SVector2D{69, 420}; + auto EXP = Hyprlang::SVector2D{.x = 69, .y = 420}; EXPECT(std::any_cast(config.getConfigValue("testVec")), EXP); EXPECT(std::any_cast(config.getConfigValue("testString")), std::string{"Hello World! # This is not a comment!"}); EXPECT(std::any_cast(config.getConfigValue("testStringQuotes")), std::string{"\"Hello World!\""});