hyprwm/hyprlang
1
0
Fork 0
mirror of https://github.com/hyprwm/hyprlang.git synced 2025-05-12 21:30:37 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

core: clang-tidy and comp fixes (#63)

Browse source
This commit is contained in:
Honkazel 2025-02-08 05:44:54 +05:00 committed by GitHub
parent f41271d35c
commit 7a59f2de3f
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 170 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

101
.clang-tidy Normal file
View file

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

7
CMakeLists.txt
View file

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

34
src/common.cpp
View file

@ -1,6 +1,6 @@
#include "public.hpp"
#include "config.hpp"
#include <string.h>
#include <cstring>
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<int64_t*>(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<float*>(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<SVector2D*>(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() {

64
src/config.cpp
View file

@ -20,6 +20,7 @@ using namespace Hyprutils::String;
#include <crt_externs.h>
#define environ (*_NSGetEnviron())
#else
// NOLINTNEXTLINE
extern "C" char** environ;
#endif
@ -30,7 +31,7 @@ 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;
}
@ -60,13 +61,10 @@ static std::expected<std::string, eGetNextLineFailure> 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<const char*>(value.getValue())}, (eDataType)value.m_eType});
impl->defaultValues.emplace(name, SConfigDefaultValue{.data = std::string{std::any_cast<const char*>(value.getValue())}, .type = (eDataType)value.m_eType});
else
impl->defaultValues.emplace(name,
SConfigDefaultValue{reinterpret_cast<CConfigCustomValueType*>(value.m_pData)->defaultVal, (eDataType)value.m_eType,
reinterpret_cast<CConfigCustomValueType*>(value.m_pData)->handler,
reinterpret_cast<CConfigCustomValueType*>(value.m_pData)->dtor});
SConfigDefaultValue{.data = reinterpret_cast<CConfigCustomValueType*>(value.m_pData)->defaultVal,
.type = (eDataType)value.m_eType,
.handler = reinterpret_cast<CConfigCustomValueType*>(value.m_pData)->handler,
.dtor = reinterpret_cast<CConfigCustomValueType*>(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<const char*>(value.getValue())}, (eDataType)value.m_eType});
IT->get()->defaultValues.emplace(name, SConfigDefaultValue{.data = std::string{std::any_cast<const char*>(value.getValue())}, .type = (eDataType)value.m_eType});
else
IT->get()->defaultValues.emplace(name,
SConfigDefaultValue{reinterpret_cast<CConfigCustomValueType*>(value.m_pData)->defaultVal, (eDataType)value.m_eType,
reinterpret_cast<CConfigCustomValueType*>(value.m_pData)->handler,
reinterpret_cast<CConfigCustomValueType*>(value.m_pData)->dtor});
SConfigDefaultValue{.data = reinterpret_cast<CConfigCustomValueType*>(value.m_pData)->defaultVal,
.type = (eDataType)value.m_eType,
.handler = reinterpret_cast<CConfigCustomValueType*>(value.m_pData)->handler,
.dtor = reinterpret_cast<CConfigCustomValueType*>(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<int64_t, std::string> 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<int64_t, std::string> 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<int64_t, std::string> 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])
@ -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) {

2
tests/fuzz/main.cpp
View file

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

28
tests/parse/main.cpp Executable file → Normal file
View file

@ -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<int64_t>(config.getConfigValue("testInt")), 123);
EXPECT(std::any_cast<float>(config.getConfigValue("testFloat")), 123.456f);
auto EXP = Hyprlang::SVector2D{69, 420};
auto EXP = Hyprlang::SVector2D{.x = 69, .y = 420};
EXPECT(std::any_cast<Hyprlang::SVector2D>(config.getConfigValue("testVec")), EXP);
EXPECT(std::any_cast<const char*>(config.getConfigValue("testString")), std::string{"Hello World! # This is not a comment!"});
EXPECT(std::any_cast<const char*>(config.getConfigValue("testStringQuotes")), std::string{"\"Hello World!\""});