From 8701ec807e2f370f264649a1df1e59e392b191de Mon Sep 17 00:00:00 2001 From: WarmUpTill Date: Sun, 21 Jan 2024 18:15:25 +0100 Subject: [PATCH] Add more tests --- lib/utils/regex-config.cpp | 10 + lib/utils/regex-config.hpp | 12 +- plugins/base/utils/json-helpers.cpp | 3 + tests/CMakeLists.txt | 64 +++- tests/json.cpp | 53 +++ tests/main.cpp | 2 + tests/{tests.cpp => math.cpp} | 1 - tests/mocks/obs-data.cpp | 506 ++++++++++++++++++++++++++++ tests/mocks/obs-data.h | 253 ++++++++++++++ tests/mocks/ui-helpers.cpp | 36 ++ tests/mocks/utility.cpp | 83 +++++ tests/regex.cpp | 90 +++++ 12 files changed, 1102 insertions(+), 11 deletions(-) create mode 100644 tests/json.cpp create mode 100644 tests/main.cpp rename tests/{tests.cpp => math.cpp} (99%) create mode 100644 tests/mocks/obs-data.cpp create mode 100644 tests/mocks/obs-data.h create mode 100644 tests/mocks/ui-helpers.cpp create mode 100644 tests/mocks/utility.cpp create mode 100644 tests/regex.cpp diff --git a/lib/utils/regex-config.cpp b/lib/utils/regex-config.cpp index 109e7ccf..7f9deed5 100644 --- a/lib/utils/regex-config.cpp +++ b/lib/utils/regex-config.cpp @@ -37,6 +37,16 @@ void RegexConfig::CreateBackwardsCompatibleRegex(bool enable, bool setOptions) } } +QRegularExpression::PatternOptions RegexConfig::GetPatternOptions() const +{ + return _options; +} + +void RegexConfig::SetPatternOptions(QRegularExpression::PatternOptions options) +{ + _options = options; +} + QRegularExpression RegexConfig::GetRegularExpression(const QString &expr) const { if (_partialMatch) { diff --git a/lib/utils/regex-config.hpp b/lib/utils/regex-config.hpp index 223719a4..c110237d 100644 --- a/lib/utils/regex-config.hpp +++ b/lib/utils/regex-config.hpp @@ -1,6 +1,7 @@ #pragma once -#include "obs-data.h" +#include "export-symbol-helper.hpp" +#include #include #include #include @@ -23,11 +24,10 @@ public: EXPORT bool Enabled() const { return _enable; } EXPORT void SetEnabled(bool enable) { _enable = enable; } - EXPORT void CreateBackwardsCompatibleRegex(bool, bool = true); - EXPORT QRegularExpression::PatternOptions GetPatternOptions() const - { - return _options; - }; + EXPORT void CreateBackwardsCompatibleRegex(bool enable, + bool setOptions = true); + EXPORT QRegularExpression::PatternOptions GetPatternOptions() const; + void SetPatternOptions(QRegularExpression::PatternOptions); EXPORT QRegularExpression GetRegularExpression(const QString &) const; EXPORT QRegularExpression GetRegularExpression(const std::string &) const; diff --git a/plugins/base/utils/json-helpers.cpp b/plugins/base/utils/json-helpers.cpp index d2c46e1c..6628e782 100644 --- a/plugins/base/utils/json-helpers.cpp +++ b/plugins/base/utils/json-helpers.cpp @@ -12,6 +12,9 @@ QString FormatJsonString(std::string s) QString FormatJsonString(QString json) { QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8()); + if (doc.isNull()) { + return ""; + } return QString::fromUtf8(doc.toJson(QJsonDocument::Indented)); } diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 862f8efa..322c9558 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -6,17 +6,73 @@ add_executable(${PROJECT_NAME}) target_compile_definitions(${PROJECT_NAME} PRIVATE UNIT_TEST) target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_17) +target_sources(${PROJECT_NAME} PRIVATE main.cpp mocks/obs-data.cpp + mocks/ui-helpers.cpp mocks/utility.cpp) +target_include_directories( + ${PROJECT_NAME} PRIVATE mocks ${ADVSS_SOURCE_DIR}/lib/utils + ${ADVSS_SOURCE_DIR}/plugins/base/utils) + +# --- Qt --- # + +target_link_libraries(${PROJECT_NAME} PUBLIC Qt::Core Qt::Widgets) + +if(TARGET Qt6::Core) + set(_QT_VERSION + 6 + CACHE INTERNAL "") +elseif(TARGET Qt5::Core) + set(_QT_VERSION + 5 + CACHE INTERNAL "") +endif() + +macro(add_qt_lib lib_name) + add_custom_command( + TARGET ${PROJECT_NAME} + POST_BUILD + COMMAND + ${CMAKE_COMMAND} -E copy_if_different + $ + $) +endmacro() + +add_qt_lib(Core) +add_qt_lib(Gui) +add_qt_lib(Widgets) + +set_target_properties( + ${PROJECT_NAME} + PROPERTIES AUTOMOC ON + AUTOUIC ON + AUTORCC ON) + +# --- json --- # + target_sources( ${PROJECT_NAME} - PRIVATE tests.cpp ${ADVSS_SOURCE_DIR}/lib/utils/math-helpers.cpp + PRIVATE json.cpp ${ADVSS_SOURCE_DIR}/plugins/base/utils/json-helpers.cpp) + +# --- math --- # + +target_sources( + ${PROJECT_NAME} + PRIVATE math.cpp ${ADVSS_SOURCE_DIR}/lib/utils/math-helpers.cpp ${ADVSS_SOURCE_DIR}/lib/utils/obs-module-helper.cpp) -target_include_directories( - ${PROJECT_NAME} PRIVATE "${ADVSS_SOURCE_DIR}/lib/utils" - "${ADVSS_SOURCE_DIR}/deps/exprtk") +target_include_directories(${PROJECT_NAME} + PRIVATE ${ADVSS_SOURCE_DIR}/deps/exprtk) if(MSVC) target_compile_options(${PROJECT_NAME} PUBLIC /MP /d2FH4- /wd4267 /wd4267 /bigobj) endif() +# --- regex --- # + +target_sources( + ${PROJECT_NAME} + PRIVATE regex.cpp ${ADVSS_SOURCE_DIR}/lib/utils/regex-config.cpp + ${ADVSS_SOURCE_DIR}/plugins/base/utils/text-helpers.cpp) + +# --- # + enable_testing() diff --git a/tests/json.cpp b/tests/json.cpp new file mode 100644 index 00000000..d1b1d81b --- /dev/null +++ b/tests/json.cpp @@ -0,0 +1,53 @@ +#include "catch.hpp" + +#include + +TEST_CASE("FormatJsonString", "[json-helpers]") +{ + auto result = advss::FormatJsonString(QString("")); + REQUIRE(result == ""); + + result = advss::FormatJsonString(QString("abc")); + REQUIRE(result == ""); + + result = advss::FormatJsonString(QString("{}")); + REQUIRE(result == "{\n}\n"); + + result = advss::FormatJsonString(QString("{\"test\":true}")); + REQUIRE(result == "{\n \"test\": true\n}\n"); +} + +TEST_CASE("MatchJson", "[json-helpers]") +{ + advss::RegexConfig regex; + bool result = advss::MatchJson("", "", regex); + REQUIRE(result == true); + + result = advss::MatchJson("a", "", regex); + REQUIRE(result == false); + + result = advss::MatchJson("{}", "abc", regex); + REQUIRE(result == false); + + result = advss::MatchJson("{}", "{}", regex); + REQUIRE(result == true); + + result = advss::MatchJson("{\"test\":true}", + "{\n \"test\": true\n}\n", regex); + REQUIRE(result == true); + + regex.SetEnabled(true); + result = advss::MatchJson("", "{\n \"test\": true\n}\n", regex); + REQUIRE(result == false); + + result = advss::MatchJson("{\"test\":true}", + "{\n \"test\": true\n}\n", regex); + REQUIRE(result == true); + + result = advss::MatchJson("{\n \"test\": true\n}\n", "(.|\\n)*", + regex); + REQUIRE(result == true); + + result = advss::MatchJson("{\n \"test\": true\n}\n", "(", regex); + REQUIRE(result == false); +} diff --git a/tests/main.cpp b/tests/main.cpp new file mode 100644 index 00000000..0c7c351f --- /dev/null +++ b/tests/main.cpp @@ -0,0 +1,2 @@ +#define CATCH_CONFIG_MAIN +#include "catch.hpp" diff --git a/tests/tests.cpp b/tests/math.cpp similarity index 99% rename from tests/tests.cpp rename to tests/math.cpp index 3baf96e3..cd082a55 100644 --- a/tests/tests.cpp +++ b/tests/math.cpp @@ -1,4 +1,3 @@ -#define CATCH_CONFIG_MAIN #include "catch.hpp" #include diff --git a/tests/mocks/obs-data.cpp b/tests/mocks/obs-data.cpp new file mode 100644 index 00000000..ebfb406f --- /dev/null +++ b/tests/mocks/obs-data.cpp @@ -0,0 +1,506 @@ +#include "obs-data.h" + +struct obs_data_item { +}; + +struct obs_data { +}; + +struct obs_data_array { +}; + +struct obs_data_number { +}; + +obs_data_t *obs_data_create() +{ + return nullptr; +} + +obs_data_t *obs_data_create_from_json(const char *json_string) +{ + return nullptr; +} + +obs_data_t *obs_data_create_from_json_file(const char *json_file) +{ + return nullptr; +} + +obs_data_t *obs_data_create_from_json_file_safe(const char *json_file, + const char *backup_ext) +{ + return nullptr; +} + +void obs_data_addref(obs_data_t *data) {} + +void obs_data_release(obs_data_t *data) {} + +const char *obs_data_get_json(obs_data_t *data) +{ + return ""; +} + +const char *obs_data_get_json_pretty(obs_data_t *data) +{ + return ""; +} + +const char *obs_data_get_last_json(obs_data_t *data) +{ + return ""; +} + +bool obs_data_save_json(obs_data_t *data, const char *file) +{ + return false; +} + +bool obs_data_save_json_safe(obs_data_t *data, const char *file, + const char *temp_ext, const char *backup_ext) +{ + return false; +} + +bool obs_data_save_json_pretty_safe(obs_data_t *data, const char *file, + const char *temp_ext, + const char *backup_ext) +{ + return false; +} + +obs_data_t *obs_data_get_defaults(obs_data_t *data) +{ + return nullptr; +} + +void obs_data_apply(obs_data_t *target, obs_data_t *apply_data) {} + +void obs_data_erase(obs_data_t *data, const char *name) {} + +void obs_data_clear(obs_data_t *target) {} + +void obs_data_set_string(obs_data_t *data, const char *name, const char *val) {} + +void obs_data_set_int(obs_data_t *data, const char *name, long long val) {} + +void obs_data_set_double(obs_data_t *data, const char *name, double val) {} + +void obs_data_set_bool(obs_data_t *data, const char *name, bool val) {} + +void obs_data_set_obj(obs_data_t *data, const char *name, obs_data_t *obj) {} + +void obs_data_set_array(obs_data_t *data, const char *name, + obs_data_array_t *array) +{ +} + +void obs_data_set_default_string(obs_data_t *data, const char *name, + const char *val) +{ +} + +void obs_data_set_default_int(obs_data_t *data, const char *name, long long val) +{ +} + +void obs_data_set_default_double(obs_data_t *data, const char *name, double val) +{ +} + +void obs_data_set_default_bool(obs_data_t *data, const char *name, bool val) {} + +void obs_data_set_default_obj(obs_data_t *data, const char *name, + obs_data_t *obj) +{ +} + +void obs_data_set_default_array(obs_data_t *data, const char *name, + obs_data_array_t *arr) +{ +} + +void obs_data_set_autoselect_string(obs_data_t *data, const char *name, + const char *val) +{ +} + +void obs_data_set_autoselect_int(obs_data_t *data, const char *name, + long long val) +{ +} + +void obs_data_set_autoselect_double(obs_data_t *data, const char *name, + double val) +{ +} + +void obs_data_set_autoselect_bool(obs_data_t *data, const char *name, bool val) +{ +} + +void obs_data_set_autoselect_obj(obs_data_t *data, const char *name, + obs_data_t *obj) +{ +} + +void obs_data_set_autoselect_array(obs_data_t *data, const char *name, + obs_data_array_t *arr) +{ +} + +const char *obs_data_get_string(obs_data_t *data, const char *name) +{ + return ""; +} + +long long obs_data_get_int(obs_data_t *data, const char *name) +{ + return 0; +} + +double obs_data_get_double(obs_data_t *data, const char *name) +{ + return 0.0; +} + +bool obs_data_get_bool(obs_data_t *data, const char *name) +{ + return false; +} + +obs_data_t *obs_data_get_obj(obs_data_t *data, const char *name) +{ + return nullptr; +} + +obs_data_array_t *obs_data_get_array(obs_data_t *data, const char *name) +{ + return nullptr; +} + +const char *obs_data_get_default_string(obs_data_t *data, const char *name) +{ + return ""; +} + +long long obs_data_get_default_int(obs_data_t *data, const char *name) +{ + return 0; +} + +double obs_data_get_default_double(obs_data_t *data, const char *name) +{ + return 0.0; +} + +bool obs_data_get_default_bool(obs_data_t *data, const char *name) +{ + return false; +} + +obs_data_t *obs_data_get_default_obj(obs_data_t *data, const char *name) +{ + return nullptr; +} + +obs_data_array_t *obs_data_get_default_array(obs_data_t *data, const char *name) +{ + return nullptr; +} + +const char *obs_data_get_autoselect_string(obs_data_t *data, const char *name) +{ + return ""; +} + +long long obs_data_get_autoselect_int(obs_data_t *data, const char *name) +{ + return 0; +} + +double obs_data_get_autoselect_double(obs_data_t *data, const char *name) +{ + return 0, 0; +} + +bool obs_data_get_autoselect_bool(obs_data_t *data, const char *name) +{ + return false; +} + +obs_data_t *obs_data_get_autoselect_obj(obs_data_t *data, const char *name) +{ + return nullptr; +} + +obs_data_array_t *obs_data_get_autoselect_array(obs_data_t *data, + const char *name) +{ + return nullptr; +} + +obs_data_array_t *obs_data_array_create() +{ + return nullptr; +} + +void obs_data_array_addref(obs_data_array_t *array) {} + +void obs_data_array_release(obs_data_array_t *array) {} + +size_t obs_data_array_count(obs_data_array_t *array) +{ + return 0; +} + +obs_data_t *obs_data_array_item(obs_data_array_t *array, size_t idx) +{ + return nullptr; +} + +size_t obs_data_array_push_back(obs_data_array_t *array, obs_data_t *obj) +{ + return 0; +} + +void obs_data_array_insert(obs_data_array_t *array, size_t idx, obs_data_t *obj) +{ +} + +void obs_data_array_push_back_array(obs_data_array_t *array, + obs_data_array_t *array2) +{ +} + +void obs_data_array_erase(obs_data_array_t *array, size_t idx) {} + +void obs_data_array_enum(obs_data_array_t *array, + void (*cb)(obs_data_t *data, void *param), void *param) +{ +} + +/* ------------------------------------------------------------------------- */ +/* Item status inspection */ + +bool obs_data_has_user_value(obs_data_t *data, const char *name) +{ + return false; +} + +bool obs_data_has_default_value(obs_data_t *data, const char *name) +{ + return false; +} + +bool obs_data_has_autoselect_value(obs_data_t *data, const char *name) +{ + return false; +} + +bool obs_data_item_has_user_value(obs_data_item_t *item) +{ + return false; +} + +bool obs_data_item_has_default_value(obs_data_item_t *item) +{ + return false; +} + +bool obs_data_item_has_autoselect_value(obs_data_item_t *item) +{ + return false; +} + +/* ------------------------------------------------------------------------- */ +/* Clearing data values */ + +void obs_data_unset_user_value(obs_data_t *data, const char *name) {} + +void obs_data_unset_default_value(obs_data_t *data, const char *name) {} + +void obs_data_unset_autoselect_value(obs_data_t *data, const char *name) {} + +void obs_data_item_unset_user_value(obs_data_item_t *item) {} + +void obs_data_item_unset_default_value(obs_data_item_t *item) {} + +void obs_data_item_unset_autoselect_value(obs_data_item_t *item) {} + +/* ------------------------------------------------------------------------- */ +/* Item iteration */ + +obs_data_item_t *obs_data_first(obs_data_t *data) +{ + return nullptr; +} + +obs_data_item_t *obs_data_item_byname(obs_data_t *data, const char *name) +{ + return nullptr; +} + +bool obs_data_item_next(obs_data_item_t **item) +{ + return false; +} + +void obs_data_item_release(obs_data_item_t **item) {} + +void obs_data_item_remove(obs_data_item_t **item) {} + +enum obs_data_type obs_data_item_gettype(obs_data_item_t *item) +{ + return OBS_DATA_NULL; +} + +enum obs_data_number_type obs_data_item_numtype(obs_data_item_t *item) +{ + return OBS_DATA_NUM_INVALID; +} + +const char *obs_data_item_get_name(obs_data_item_t *item) +{ + return nullptr; +} + +void obs_data_item_set_string(obs_data_item_t **item, const char *val) {} + +void obs_data_item_set_int(obs_data_item_t **item, long long val) {} + +void obs_data_item_set_double(obs_data_item_t **item, double val) {} + +void obs_data_item_set_bool(obs_data_item_t **item, bool val) {} + +void obs_data_item_set_obj(obs_data_item_t **item, obs_data_t *val) {} + +void obs_data_item_set_array(obs_data_item_t **item, obs_data_array_t *val) {} + +void obs_data_item_set_default_string(obs_data_item_t **item, const char *val) +{ +} + +void obs_data_item_set_default_int(obs_data_item_t **item, long long val) {} + +void obs_data_item_set_default_double(obs_data_item_t **item, double val) {} + +void obs_data_item_set_default_bool(obs_data_item_t **item, bool val) {} + +void obs_data_item_set_default_obj(obs_data_item_t **item, obs_data_t *val) {} + +void obs_data_item_set_default_array(obs_data_item_t **item, + obs_data_array_t *val) +{ +} + +void obs_data_item_set_autoselect_string(obs_data_item_t **item, + const char *val) +{ +} + +void obs_data_item_set_autoselect_int(obs_data_item_t **item, long long val) {} + +void obs_data_item_set_autoselect_double(obs_data_item_t **item, double val) {} + +void obs_data_item_set_autoselect_bool(obs_data_item_t **item, bool val) {} + +void obs_data_item_set_autoselect_obj(obs_data_item_t **item, obs_data_t *val) +{ +} + +void obs_data_item_set_autoselect_array(obs_data_item_t **item, + obs_data_array_t *val) +{ +} + +const char *obs_data_item_get_string(obs_data_item_t *item) +{ + return ""; +} + +long long obs_data_item_get_int(obs_data_item_t *item) +{ + return 0; +} + +double obs_data_item_get_double(obs_data_item_t *item) +{ + return 0.0; +} + +bool obs_data_item_get_bool(obs_data_item_t *item) +{ + return false; +} + +obs_data_t *obs_data_item_get_obj(obs_data_item_t *item) +{ + return nullptr; +} + +obs_data_array_t *obs_data_item_get_array(obs_data_item_t *item) +{ + return nullptr; +} + +const char *obs_data_item_get_default_string(obs_data_item_t *item) +{ + return ""; +} + +long long obs_data_item_get_default_int(obs_data_item_t *item) +{ + return 0; +} + +double obs_data_item_get_default_double(obs_data_item_t *item) +{ + return 0.0; +} + +bool obs_data_item_get_default_bool(obs_data_item_t *item) +{ + return false; +} + +obs_data_t *obs_data_item_get_default_obj(obs_data_item_t *item) +{ + return nullptr; +} + +obs_data_array_t *obs_data_item_get_default_array(obs_data_item_t *item) +{ + return nullptr; +} + +const char *obs_data_item_get_autoselect_string(obs_data_item_t *item) +{ + return ""; +} + +long long obs_data_item_get_autoselect_int(obs_data_item_t *item) +{ + return 0; +} + +double obs_data_item_get_autoselect_double(obs_data_item_t *item) +{ + return 0.0; +} + +bool obs_data_item_get_autoselect_bool(obs_data_item_t *item) +{ + return false; +} + +obs_data_t *obs_data_item_get_autoselect_obj(obs_data_item_t *item) +{ + return nullptr; +} + +obs_data_array_t *obs_data_item_get_autoselect_array(obs_data_item_t *item) +{ + return nullptr; +} diff --git a/tests/mocks/obs-data.h b/tests/mocks/obs-data.h new file mode 100644 index 00000000..71b5ce59 --- /dev/null +++ b/tests/mocks/obs-data.h @@ -0,0 +1,253 @@ +#pragma once +#include "export-symbol-helper.hpp" + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct obs_data; +struct obs_data_item; +struct obs_data_array; +typedef struct obs_data obs_data_t; +typedef struct obs_data_item obs_data_item_t; +typedef struct obs_data_array obs_data_array_t; + +enum obs_data_type { + OBS_DATA_NULL, + OBS_DATA_STRING, + OBS_DATA_NUMBER, + OBS_DATA_BOOLEAN, + OBS_DATA_OBJECT, + OBS_DATA_ARRAY +}; + +enum obs_data_number_type { + OBS_DATA_NUM_INVALID, + OBS_DATA_NUM_INT, + OBS_DATA_NUM_DOUBLE +}; + +/* ------------------------------------------------------------------------- */ +/* Main usage functions */ + +EXPORT obs_data_t *obs_data_create(); +EXPORT obs_data_t *obs_data_create_from_json(const char *json_string); +EXPORT obs_data_t *obs_data_create_from_json_file(const char *json_file); +EXPORT obs_data_t *obs_data_create_from_json_file_safe(const char *json_file, + const char *backup_ext); +EXPORT void obs_data_addref(obs_data_t *data); +EXPORT void obs_data_release(obs_data_t *data); + +EXPORT const char *obs_data_get_json(obs_data_t *data); +EXPORT const char *obs_data_get_json_pretty(obs_data_t *data); +EXPORT const char *obs_data_get_last_json(obs_data_t *data); +EXPORT bool obs_data_save_json(obs_data_t *data, const char *file); +EXPORT bool obs_data_save_json_safe(obs_data_t *data, const char *file, + const char *temp_ext, + const char *backup_ext); +EXPORT bool obs_data_save_json_pretty_safe(obs_data_t *data, const char *file, + const char *temp_ext, + const char *backup_ext); + +EXPORT void obs_data_apply(obs_data_t *target, obs_data_t *apply_data); + +EXPORT void obs_data_erase(obs_data_t *data, const char *name); +EXPORT void obs_data_clear(obs_data_t *data); + +/* Set functions */ +EXPORT void obs_data_set_string(obs_data_t *data, const char *name, + const char *val); +EXPORT void obs_data_set_int(obs_data_t *data, const char *name, long long val); +EXPORT void obs_data_set_double(obs_data_t *data, const char *name, double val); +EXPORT void obs_data_set_bool(obs_data_t *data, const char *name, bool val); +EXPORT void obs_data_set_obj(obs_data_t *data, const char *name, + obs_data_t *obj); +EXPORT void obs_data_set_array(obs_data_t *data, const char *name, + obs_data_array_t *array); + +/* + * Creates an obs_data_t * filled with all default values. + */ +EXPORT obs_data_t *obs_data_get_defaults(obs_data_t *data); + +/* + * Default value functions. + */ +EXPORT void obs_data_set_default_string(obs_data_t *data, const char *name, + const char *val); +EXPORT void obs_data_set_default_int(obs_data_t *data, const char *name, + long long val); +EXPORT void obs_data_set_default_double(obs_data_t *data, const char *name, + double val); +EXPORT void obs_data_set_default_bool(obs_data_t *data, const char *name, + bool val); +EXPORT void obs_data_set_default_obj(obs_data_t *data, const char *name, + obs_data_t *obj); +EXPORT void obs_data_set_default_array(obs_data_t *data, const char *name, + obs_data_array_t *arr); + +/* + * Application overrides + * Use these to communicate the actual values of settings in case the user + * settings aren't appropriate + */ +EXPORT void obs_data_set_autoselect_string(obs_data_t *data, const char *name, + const char *val); +EXPORT void obs_data_set_autoselect_int(obs_data_t *data, const char *name, + long long val); +EXPORT void obs_data_set_autoselect_double(obs_data_t *data, const char *name, + double val); +EXPORT void obs_data_set_autoselect_bool(obs_data_t *data, const char *name, + bool val); +EXPORT void obs_data_set_autoselect_obj(obs_data_t *data, const char *name, + obs_data_t *obj); +EXPORT void obs_data_set_autoselect_array(obs_data_t *data, const char *name, + obs_data_array_t *arr); + +/* + * Get functions + */ +EXPORT const char *obs_data_get_string(obs_data_t *data, const char *name); +EXPORT long long obs_data_get_int(obs_data_t *data, const char *name); +EXPORT double obs_data_get_double(obs_data_t *data, const char *name); +EXPORT bool obs_data_get_bool(obs_data_t *data, const char *name); +EXPORT obs_data_t *obs_data_get_obj(obs_data_t *data, const char *name); +EXPORT obs_data_array_t *obs_data_get_array(obs_data_t *data, const char *name); + +EXPORT const char *obs_data_get_default_string(obs_data_t *data, + const char *name); +EXPORT long long obs_data_get_default_int(obs_data_t *data, const char *name); +EXPORT double obs_data_get_default_double(obs_data_t *data, const char *name); +EXPORT bool obs_data_get_default_bool(obs_data_t *data, const char *name); +EXPORT obs_data_t *obs_data_get_default_obj(obs_data_t *data, const char *name); +EXPORT obs_data_array_t *obs_data_get_default_array(obs_data_t *data, + const char *name); + +EXPORT const char *obs_data_get_autoselect_string(obs_data_t *data, + const char *name); +EXPORT long long obs_data_get_autoselect_int(obs_data_t *data, + const char *name); +EXPORT double obs_data_get_autoselect_double(obs_data_t *data, + const char *name); +EXPORT bool obs_data_get_autoselect_bool(obs_data_t *data, const char *name); +EXPORT obs_data_t *obs_data_get_autoselect_obj(obs_data_t *data, + const char *name); +EXPORT obs_data_array_t *obs_data_get_autoselect_array(obs_data_t *data, + const char *name); + +/* Array functions */ +EXPORT obs_data_array_t *obs_data_array_create(); +EXPORT void obs_data_array_addref(obs_data_array_t *array); +EXPORT void obs_data_array_release(obs_data_array_t *array); + +EXPORT size_t obs_data_array_count(obs_data_array_t *array); +EXPORT obs_data_t *obs_data_array_item(obs_data_array_t *array, size_t idx); +EXPORT size_t obs_data_array_push_back(obs_data_array_t *array, + obs_data_t *obj); +EXPORT void obs_data_array_insert(obs_data_array_t *array, size_t idx, + obs_data_t *obj); +EXPORT void obs_data_array_push_back_array(obs_data_array_t *array, + obs_data_array_t *array2); +EXPORT void obs_data_array_erase(obs_data_array_t *array, size_t idx); +EXPORT void obs_data_array_enum(obs_data_array_t *array, + void (*cb)(obs_data_t *data, void *param), + void *param); + +/* ------------------------------------------------------------------------- */ +/* Item status inspection */ + +EXPORT bool obs_data_has_user_value(obs_data_t *data, const char *name); +EXPORT bool obs_data_has_default_value(obs_data_t *data, const char *name); +EXPORT bool obs_data_has_autoselect_value(obs_data_t *data, const char *name); + +EXPORT bool obs_data_item_has_user_value(obs_data_item_t *data); +EXPORT bool obs_data_item_has_default_value(obs_data_item_t *data); +EXPORT bool obs_data_item_has_autoselect_value(obs_data_item_t *data); + +/* ------------------------------------------------------------------------- */ +/* Clearing data values */ + +EXPORT void obs_data_unset_user_value(obs_data_t *data, const char *name); +EXPORT void obs_data_unset_default_value(obs_data_t *data, const char *name); +EXPORT void obs_data_unset_autoselect_value(obs_data_t *data, const char *name); + +EXPORT void obs_data_item_unset_user_value(obs_data_item_t *data); +EXPORT void obs_data_item_unset_default_value(obs_data_item_t *data); +EXPORT void obs_data_item_unset_autoselect_value(obs_data_item_t *data); + +/* ------------------------------------------------------------------------- */ +/* Item iteration */ + +EXPORT obs_data_item_t *obs_data_first(obs_data_t *data); +EXPORT obs_data_item_t *obs_data_item_byname(obs_data_t *data, + const char *name); +EXPORT bool obs_data_item_next(obs_data_item_t **item); +EXPORT void obs_data_item_release(obs_data_item_t **item); +EXPORT void obs_data_item_remove(obs_data_item_t **item); + +/* Gets Item type */ +EXPORT enum obs_data_type obs_data_item_gettype(obs_data_item_t *item); +EXPORT enum obs_data_number_type obs_data_item_numtype(obs_data_item_t *item); +EXPORT const char *obs_data_item_get_name(obs_data_item_t *item); + +/* Item set functions */ +EXPORT void obs_data_item_set_string(obs_data_item_t **item, const char *val); +EXPORT void obs_data_item_set_int(obs_data_item_t **item, long long val); +EXPORT void obs_data_item_set_double(obs_data_item_t **item, double val); +EXPORT void obs_data_item_set_bool(obs_data_item_t **item, bool val); +EXPORT void obs_data_item_set_obj(obs_data_item_t **item, obs_data_t *val); +EXPORT void obs_data_item_set_array(obs_data_item_t **item, + obs_data_array_t *val); + +EXPORT void obs_data_item_set_default_string(obs_data_item_t **item, + const char *val); +EXPORT void obs_data_item_set_default_int(obs_data_item_t **item, + long long val); +EXPORT void obs_data_item_set_default_double(obs_data_item_t **item, + double val); +EXPORT void obs_data_item_set_default_bool(obs_data_item_t **item, bool val); +EXPORT void obs_data_item_set_default_obj(obs_data_item_t **item, + obs_data_t *val); +EXPORT void obs_data_item_set_default_array(obs_data_item_t **item, + obs_data_array_t *val); + +EXPORT void obs_data_item_set_autoselect_string(obs_data_item_t **item, + const char *val); +EXPORT void obs_data_item_set_autoselect_int(obs_data_item_t **item, + long long val); +EXPORT void obs_data_item_set_autoselect_double(obs_data_item_t **item, + double val); +EXPORT void obs_data_item_set_autoselect_bool(obs_data_item_t **item, bool val); +EXPORT void obs_data_item_set_autoselect_obj(obs_data_item_t **item, + obs_data_t *val); +EXPORT void obs_data_item_set_autoselect_array(obs_data_item_t **item, + obs_data_array_t *val); + +/* Item get functions */ +EXPORT const char *obs_data_item_get_string(obs_data_item_t *item); +EXPORT long long obs_data_item_get_int(obs_data_item_t *item); +EXPORT double obs_data_item_get_double(obs_data_item_t *item); +EXPORT bool obs_data_item_get_bool(obs_data_item_t *item); +EXPORT obs_data_t *obs_data_item_get_obj(obs_data_item_t *item); +EXPORT obs_data_array_t *obs_data_item_get_array(obs_data_item_t *item); + +EXPORT const char *obs_data_item_get_default_string(obs_data_item_t *item); +EXPORT long long obs_data_item_get_default_int(obs_data_item_t *item); +EXPORT double obs_data_item_get_default_double(obs_data_item_t *item); +EXPORT bool obs_data_item_get_default_bool(obs_data_item_t *item); +EXPORT obs_data_t *obs_data_item_get_default_obj(obs_data_item_t *item); +EXPORT obs_data_array_t *obs_data_item_get_default_array(obs_data_item_t *item); + +EXPORT const char *obs_data_item_get_autoselect_string(obs_data_item_t *item); +EXPORT long long obs_data_item_get_autoselect_int(obs_data_item_t *item); +EXPORT double obs_data_item_get_autoselect_double(obs_data_item_t *item); +EXPORT bool obs_data_item_get_autoselect_bool(obs_data_item_t *item); +EXPORT obs_data_t *obs_data_item_get_autoselect_obj(obs_data_item_t *item); +EXPORT obs_data_array_t * +obs_data_item_get_autoselect_array(obs_data_item_t *item); + +#ifdef __cplusplus +} +#endif diff --git a/tests/mocks/ui-helpers.cpp b/tests/mocks/ui-helpers.cpp new file mode 100644 index 00000000..3cd23767 --- /dev/null +++ b/tests/mocks/ui-helpers.cpp @@ -0,0 +1,36 @@ +#include "ui-helpers.hpp" + +namespace advss { + +QMetaObject::Connection PulseWidget(QWidget *widget, QColor startColor, + QColor endColor, bool once) +{ + return {}; +} + +void SetHeightToContentHeight(QListWidget *list) {} + +void SetButtonIcon(QPushButton *button, const char *path) {} + +int FindIdxInRagne(QComboBox *list, int start, int stop, + const std::string &value, Qt::MatchFlags flags) +{ + return -1; +} + +bool DisplayMessage(const QString &msg, bool question, bool modal) +{ + return false; +} + +void DisplayTrayMessage(const QString &title, const QString &msg, + const QIcon &icon) +{ +} + +std::string GetThemeTypeName() +{ + return "Dark"; +} + +} // namespace advss diff --git a/tests/mocks/utility.cpp b/tests/mocks/utility.cpp new file mode 100644 index 00000000..ff365918 --- /dev/null +++ b/tests/mocks/utility.cpp @@ -0,0 +1,83 @@ +#include "utility.hpp" + +#include + +namespace advss { + +std::pair GetCursorPos() +{ + return {0, 0}; +} + +bool DoubleEquals(double left, double right, double epsilon) +{ + return (fabs(left - right) < epsilon); +} + +void ReplaceAll(std::string &str, const std::string &from, + const std::string &to) +{ + if (from.empty()) { + return; + } + size_t start_pos = 0; + while ((start_pos = str.find(from, start_pos)) != std::string::npos) { + str.replace(start_pos, from.length(), to); + start_pos += to.length(); + } +} + +std::optional GetJsonField(const std::string &jsonStr, + const std::string &fieldToExtract) +{ + return {}; +} + +bool CompareIgnoringLineEnding(QString &s1, QString &s2) +{ + // Let QT deal with different types of lineendings + QTextStream s1stream(&s1); + QTextStream s2stream(&s2); + + while (!s1stream.atEnd() || !s2stream.atEnd()) { + QString s1s = s1stream.readLine(); + QString s2s = s2stream.readLine(); + if (s1s != s2s) { + return false; + } + } + + if (!s1stream.atEnd() && !s2stream.atEnd()) { + return false; + } + + return true; +} + +std::string GetDataFilePath(const std::string &file) +{ + return ""; +} + +QString GetDefaultSettingsSaveLocation() +{ + return ""; +} + +void listAddClicked(QListWidget *list, QWidget *newWidget, + QPushButton *addButton, + QMetaObject::Connection *addHighlight) +{ +} + +bool listMoveUp(QListWidget *list) +{ + return false; +} + +bool listMoveDown(QListWidget *list) +{ + return false; +} + +} // namespace advss diff --git a/tests/regex.cpp b/tests/regex.cpp new file mode 100644 index 00000000..52ac4a61 --- /dev/null +++ b/tests/regex.cpp @@ -0,0 +1,90 @@ +#include "catch.hpp" + +#include +#include + +TEST_CASE("Enable", "[regex-config]") +{ + advss::RegexConfig regex(false); + REQUIRE(regex.Enabled() == false); + + regex.SetEnabled(true); + REQUIRE(regex.Enabled() == true); +} + +TEST_CASE("Matches (default options)", "[regex-config]") +{ + advss::RegexConfig regex(true); + + bool result = regex.Matches(std::string(""), ""); + REQUIRE(result == true); + + result = regex.Matches(std::string("a"), "a"); + REQUIRE(result == true); + + result = regex.Matches(std::string("a"), ""); + REQUIRE(result == false); + + result = regex.Matches(std::string("a"), "abc"); + REQUIRE(result == false); + + result = regex.Matches(std::string("abc"), "abc"); + REQUIRE(result == true); + + result = regex.Matches(std::string("abc"), "a"); + REQUIRE(result == false); +} + +TEST_CASE("Matches (regex options)", "[regex-config]") +{ + advss::RegexConfig regex(true); + + bool result = regex.Matches(std::string("abc"), "abc"); + REQUIRE(result == true); + + result = regex.Matches(std::string("abc"), "Abc"); + REQUIRE(result == false); + + regex.SetPatternOptions(QRegularExpression::CaseInsensitiveOption); + result = regex.Matches(std::string("abc"), "Abc"); + REQUIRE(result == true); +} + +TEST_CASE("Matches (invalid expression)", "[regex-config]") +{ + advss::RegexConfig regex(true); + bool result = regex.Matches(std::string("a"), "("); + REQUIRE(result == false); + + regex = advss::RegexConfig::PartialMatchRegexConfig(); + result = regex.Matches(std::string("abc"), "("); + REQUIRE(result == false); +} + +TEST_CASE("Matches (PartialMatchRegexConfig)", "[regex-config]") +{ + auto regex = advss::RegexConfig::PartialMatchRegexConfig(); + regex.SetEnabled(true); + bool result = regex.Matches(std::string(""), ""); + REQUIRE(result == true); + + result = regex.Matches(std::string("a"), ""); + REQUIRE(result == true); + + result = regex.Matches(std::string("a"), "abc"); + REQUIRE(result == false); + + result = regex.Matches(std::string("abc"), "abc"); + REQUIRE(result == true); + + result = regex.Matches(std::string("abc"), "a"); + REQUIRE(result == true); +} + +TEST_CASE("EscapeForRegex , [text-helpers]") +{ + REQUIRE(advss::EscapeForRegex("") == ""); + REQUIRE(advss::EscapeForRegex("abcdefg") == "abcdefg"); + REQUIRE(advss::EscapeForRegex("(abcdefg)") == "\\(abcdefg\\)"); + REQUIRE(advss::EscapeForRegex("\\(abcdefg)") == "\\\\(abcdefg\\)"); +}