diff --git a/src/test/Makefile b/src/test/Makefile index e36632d0754..961172eac35 100644 --- a/src/test/Makefile +++ b/src/test/Makefile @@ -62,7 +62,9 @@ OBJ_TESTS = \ obj_list_valgrind\ obj_list_macro\ obj_locks\ + obj_log_get_treshold\ obj_log_set_function\ + obj_log_set_treshold\ obj_mem\ obj_memblock\ obj_memcheck\ diff --git a/src/test/obj_log_get_treshold/.gitignore b/src/test/obj_log_get_treshold/.gitignore new file mode 100644 index 00000000000..72cb85ece1c --- /dev/null +++ b/src/test/obj_log_get_treshold/.gitignore @@ -0,0 +1 @@ +obj_log_get_treshold diff --git a/src/test/obj_log_get_treshold/Makefile b/src/test/obj_log_get_treshold/Makefile new file mode 100644 index 00000000000..8629483392b --- /dev/null +++ b/src/test/obj_log_get_treshold/Makefile @@ -0,0 +1,14 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright 2024, Intel Corporation + +TARGET = obj_log_get_treshold +OBJS = obj_log_get_treshold.o + +BUILD_STATIC_DEBUG=n +BUILD_STATIC_NONDEBUG=n + +# required for proper mock integration +LIBPMEMOBJ=internal-debug + +include ../Makefile.inc +LDFLAGS += $(call extract_funcs, obj_log_get_treshold.c) diff --git a/src/test/obj_log_get_treshold/TESTS.py b/src/test/obj_log_get_treshold/TESTS.py new file mode 100755 index 00000000000..47094061bf6 --- /dev/null +++ b/src/test/obj_log_get_treshold/TESTS.py @@ -0,0 +1,27 @@ +#!../env.py +# SPDX-License-Identifier: BSD-3-Clause +# Copyright 2024, Intel Corporation +# + + +import testframework as t +from testframework import granularity as g + + +@g.require_granularity(g.ANY) +# The 'debug' build is chosen arbitrarily to ensure these tests are run only +# once. No dynamic libraries are used nor .static_* builds are available. +@t.require_build('debug') +class OBJ_LOG(t.BaseTest): + test_type = t.Short + + def run(self, ctx): + ctx.exec('obj_log_get_treshold', self.test_case) + + +class TEST0(OBJ_LOG): + test_case = 'test_log_get_treshold' + + +class TEST1(OBJ_LOG): + test_case = 'test_log_get_treshold_EAGAIN' diff --git a/src/test/obj_log_get_treshold/obj_log_get_treshold.c b/src/test/obj_log_get_treshold/obj_log_get_treshold.c new file mode 100644 index 00000000000..5649188a40d --- /dev/null +++ b/src/test/obj_log_get_treshold/obj_log_get_treshold.c @@ -0,0 +1,117 @@ +// SPDX-License-Identifier: BSD-3-Clause +/* Copyright 2024, Intel Corporation */ + +/* + * obj_log_get_treshold.c -- unit test for pmemobj_log_get_treshold + */ + +#include "unittest.h" +#include "log_internal.h" +#include "libpmemobj/log.h" + +#define NO_ARGS_CONSUMED 0 + +#define VALIDATED_CALL 127 +#define CALLED (VALIDATED_CALL + 1) + +static enum core_log_threshold core_tresholds[] = { + CORE_LOG_THRESHOLD, + CORE_LOG_THRESHOLD_AUX +}; + +static enum core_log_level core_levels[] = { + CORE_LOG_LEVEL_HARK, + CORE_LOG_LEVEL_FATAL, + CORE_LOG_LEVEL_ERROR, + CORE_LOG_LEVEL_WARNING, + CORE_LOG_LEVEL_NOTICE, + CORE_LOG_LEVEL_INFO, + CORE_LOG_LEVEL_DEBUG +}; + +/* Mock */ +static struct { + enum core_log_threshold exp_threshold; + enum core_log_level level; + int ret; +} Core_log_get_treshold; + +FUNC_MOCK(core_log_get_threshold, int, enum core_log_threshold threshold, + enum core_log_level *level) + FUNC_MOCK_RUN(VALIDATED_CALL) { + UT_ASSERTeq(threshold, Core_log_get_treshold.exp_threshold); + if (Core_log_get_treshold.ret == 0) + *level = Core_log_get_treshold.level; + return Core_log_get_treshold.ret; + } +FUNC_MOCK_RUN_DEFAULT { + return _FUNC_REAL(core_log_get_threshold)(threshold, level); +} +FUNC_MOCK_END + +/* Helper */ +static int +test_log_get_treshold_helper(int error) +{ + errno = NO_ERRNO; + Core_log_get_treshold.ret = error == NO_ERRNO ? 0: error; + for (enum pmemobj_log_threshold treshold = PMEMOBJ_LOG_THRESHOLD; + treshold <= PMEMOBJ_LOG_THRESHOLD_AUX; treshold++) { + Core_log_get_treshold.exp_threshold = core_tresholds[treshold]; + for (enum pmemobj_log_level exp_level = PMEMOBJ_LOG_LEVEL_HARK; + exp_level <= PMEMOBJ_LOG_LEVEL_DEBUG; exp_level++) { + enum pmemobj_log_level level; + Core_log_get_treshold.level = core_levels[exp_level]; + FUNC_MOCK_RCOUNTER_SET(core_log_get_threshold, + VALIDATED_CALL); + int ret = pmemobj_log_get_threshold(treshold, &level); + if (error == NO_ERRNO) { + UT_ASSERTeq(ret, 0); + UT_ASSERTeq(level, exp_level); + UT_ASSERTeq(errno, NO_ERRNO); + } else { + UT_ASSERTeq(ret, 1); + UT_ASSERTeq(errno, error); + } + UT_ASSERTeq(RCOUNTER(core_log_get_threshold), CALLED); + /* no need to test the error path for all values */ + if (error != NO_ERRNO) + return NO_ARGS_CONSUMED; + } + } + return NO_ARGS_CONSUMED; +} + +/* Tests */ +/* + * Check: + * - if core_log_get_treshold is called with proper arguments + * - if pmemobj_log_get_treshold return 0 (no error) + * - if each PMEMOBJ_LOG_LEVEL corespond to relevant CORE_LOG_LEVEL + * - no errno is set + */ +static int +test_log_get_treshold(const struct test_case *tc, int argc, char *argv[]) +{ + return test_log_get_treshold_helper(NO_ERRNO); +} + +/* Check pmemobj_log_get_threshold EAGAIN error handling. */ +static int +test_log_get_treshold_EAGAIN(const struct test_case *tc, int argc, char *argv[]) +{ + return test_log_get_treshold_helper(EAGAIN); +} + +static struct test_case test_cases[] = { + TEST_CASE(test_log_get_treshold), + TEST_CASE(test_log_get_treshold_EAGAIN), +}; + +int +main(int argc, char *argv[]) +{ + START(argc, argv, "obj_log_get_treshold"); + TEST_CASE_PROCESS(argc, argv, test_cases, ARRAY_SIZE(test_cases)); + DONE(NULL); +} diff --git a/src/test/obj_log_set_function/TESTS.py b/src/test/obj_log_set_function/TESTS.py index 2965e56b1ff..7d59355dd63 100755 --- a/src/test/obj_log_set_function/TESTS.py +++ b/src/test/obj_log_set_function/TESTS.py @@ -25,23 +25,3 @@ class TEST0(OBJ_LOG): class TEST1(OBJ_LOG): test_case = 'test_log_set_function_EAGAIN' - - -class TEST2(OBJ_LOG): - test_case = 'test_log_set_treshold' - - -class TEST3(OBJ_LOG): - test_case = 'test_log_set_treshold_EAGAIN' - - -class TEST4(OBJ_LOG): - test_case = 'test_log_set_treshold_EINVAL' - - -class TEST5(OBJ_LOG): - test_case = 'test_log_get_treshold' - - -class TEST6(OBJ_LOG): - test_case = 'test_log_get_treshold_EAGAIN' diff --git a/src/test/obj_log_set_function/obj_log_set_function.c b/src/test/obj_log_set_function/obj_log_set_function.c index 69ec6cc4063..b367402bea9 100644 --- a/src/test/obj_log_set_function/obj_log_set_function.c +++ b/src/test/obj_log_set_function/obj_log_set_function.c @@ -2,7 +2,7 @@ /* Copyright 2024, Intel Corporation */ /* - * obj_log_set_function.c -- unit test for pmemobj_log_set_function + * obj_log_set_function.c -- unit test for pmemobj_log_set_treshold */ #include "unittest.h" @@ -80,187 +80,9 @@ test_log_set_function_EAGAIN(const struct test_case *tc, int argc, char *argv[]) return test_log_set_function_helper(EAGAIN); } -/* - * *** pmemobj_log_set_treshold() tests *** - */ -static enum core_log_threshold core_tresholds[] = { - CORE_LOG_THRESHOLD, - CORE_LOG_THRESHOLD_AUX -}; - -static enum core_log_level core_levels[] = { - CORE_LOG_LEVEL_HARK, - CORE_LOG_LEVEL_FATAL, - CORE_LOG_LEVEL_ERROR, - CORE_LOG_LEVEL_WARNING, - CORE_LOG_LEVEL_NOTICE, - CORE_LOG_LEVEL_INFO, - CORE_LOG_LEVEL_DEBUG -}; - -/* Mock */ -static struct { - enum core_log_threshold exp_threshold; - enum core_log_level exp_level; - int ret; -} Core_log_set_treshold; - -FUNC_MOCK(core_log_set_threshold, int, enum core_log_threshold threshold, - enum core_log_level level) - FUNC_MOCK_RUN(VALIDATED_CALL) { - UT_ASSERTeq(threshold, Core_log_set_treshold.exp_threshold); - UT_ASSERTeq(level, Core_log_set_treshold.exp_level); - return Core_log_set_treshold.ret; - } -FUNC_MOCK_RUN_DEFAULT { - return _FUNC_REAL(core_log_set_threshold)(threshold, level); -} -FUNC_MOCK_END - -/* Helper */ -static int -test_log_set_treshold_helper(int error) -{ - errno = NO_ERRNO; - Core_log_set_treshold.ret = error == NO_ERRNO ? 0: error; - for (enum pmemobj_log_threshold treshold = PMEMOBJ_LOG_THRESHOLD; - treshold <= PMEMOBJ_LOG_THRESHOLD_AUX; treshold++) { - Core_log_set_treshold.exp_threshold = core_tresholds[treshold]; - for (enum pmemobj_log_level level = PMEMOBJ_LOG_LEVEL_HARK; - level <= PMEMOBJ_LOG_LEVEL_DEBUG; level++) { - Core_log_set_treshold.exp_level = core_levels[level]; - FUNC_MOCK_RCOUNTER_SET(core_log_set_threshold, - VALIDATED_CALL); - int ret = pmemobj_log_set_threshold(treshold, level); - if (error == NO_ERRNO) { - UT_ASSERTeq(ret, 0); - UT_ASSERTeq(errno, NO_ERRNO); - } else { - UT_ASSERTeq(ret, 1); - UT_ASSERTeq(errno, error); - } - UT_ASSERTeq(RCOUNTER(core_log_set_threshold), CALLED); - /* no need to test the error path for all values */ - if (error != NO_ERRNO) - return NO_ARGS_CONSUMED; - } - } - return NO_ARGS_CONSUMED; -} - -/* Tests */ -/* - * Check: - * - if core_log_set_treshold is called with proper arguments - * - if pmemobj_log_set_treshold return 0 (no error) - * - if each PMEMOBJ_LOG_LEVEL corespond to relevant CORE_LOG_LEVEL - * - no errno is set - */ -static int -test_log_set_treshold(const struct test_case *tc, int argc, char *argv[]) -{ - return test_log_set_treshold_helper(NO_ERRNO); -} - -/* Check pmemobj_log_set_threshold EAGAIN error handling. */ -static int -test_log_set_treshold_EAGAIN(const struct test_case *tc, int argc, char *argv[]) -{ - return test_log_set_treshold_helper(EAGAIN); -} - -/* Check pmemobj_log_set_threshold EINVAL error handling. */ -static int -test_log_set_treshold_EINVAL(const struct test_case *tc, int argc, char *argv[]) -{ - return test_log_set_treshold_helper(EINVAL); -} - -/* - * *** pmemobj_log_get_treshold() tests *** - */ -/* Mock */ -static struct { - enum core_log_threshold exp_threshold; - enum core_log_level level; - int ret; -} Core_log_get_treshold; - -FUNC_MOCK(core_log_get_threshold, int, enum core_log_threshold threshold, - enum core_log_level *level) - FUNC_MOCK_RUN(VALIDATED_CALL) { - UT_ASSERTeq(threshold, Core_log_get_treshold.exp_threshold); - if (Core_log_get_treshold.ret == 0) - *level = Core_log_get_treshold.level; - return Core_log_get_treshold.ret; - } -FUNC_MOCK_RUN_DEFAULT { - return _FUNC_REAL(core_log_get_threshold)(threshold, level); -} -FUNC_MOCK_END - -/* Helper */ -static int -test_log_get_treshold_helper(int error) -{ - errno = NO_ERRNO; - Core_log_get_treshold.ret = error == NO_ERRNO ? 0: error; - for (enum pmemobj_log_threshold treshold = PMEMOBJ_LOG_THRESHOLD; - treshold <= PMEMOBJ_LOG_THRESHOLD_AUX; treshold++) { - Core_log_get_treshold.exp_threshold = core_tresholds[treshold]; - for (enum pmemobj_log_level exp_level = PMEMOBJ_LOG_LEVEL_HARK; - exp_level <= PMEMOBJ_LOG_LEVEL_DEBUG; exp_level++) { - enum pmemobj_log_level level; - Core_log_get_treshold.level = core_levels[exp_level]; - FUNC_MOCK_RCOUNTER_SET(core_log_get_threshold, - VALIDATED_CALL); - int ret = pmemobj_log_get_threshold(treshold, &level); - if (error == NO_ERRNO) { - UT_ASSERTeq(ret, 0); - UT_ASSERTeq(level, exp_level); - UT_ASSERTeq(errno, NO_ERRNO); - } else { - UT_ASSERTeq(ret, 1); - UT_ASSERTeq(errno, error); - } - UT_ASSERTeq(RCOUNTER(core_log_get_threshold), CALLED); - /* no need to test the error path for all values */ - if (error != NO_ERRNO) - return NO_ARGS_CONSUMED; - } - } - return NO_ARGS_CONSUMED; -} - -/* Tests */ -/* - * Check: - * - if core_log_get_treshold is called with proper arguments - * - if pmemobj_log_get_treshold return 0 (no error) - * - if each PMEMOBJ_LOG_LEVEL corespond to relevant CORE_LOG_LEVEL - * - no errno is set - */ -static int -test_log_get_treshold(const struct test_case *tc, int argc, char *argv[]) -{ - return test_log_get_treshold_helper(NO_ERRNO); -} - -/* Check pmemobj_log_get_threshold EAGAIN error handling. */ -static int -test_log_get_treshold_EAGAIN(const struct test_case *tc, int argc, char *argv[]) -{ - return test_log_get_treshold_helper(EAGAIN); -} - static struct test_case test_cases[] = { TEST_CASE(test_log_set_function), TEST_CASE(test_log_set_function_EAGAIN), - TEST_CASE(test_log_set_treshold), - TEST_CASE(test_log_set_treshold_EAGAIN), - TEST_CASE(test_log_set_treshold_EINVAL), - TEST_CASE(test_log_get_treshold), - TEST_CASE(test_log_get_treshold_EAGAIN), }; int diff --git a/src/test/obj_log_set_treshold/.gitignore b/src/test/obj_log_set_treshold/.gitignore new file mode 100644 index 00000000000..bc77b806407 --- /dev/null +++ b/src/test/obj_log_set_treshold/.gitignore @@ -0,0 +1 @@ +obj_log_set_treshold diff --git a/src/test/obj_log_set_treshold/Makefile b/src/test/obj_log_set_treshold/Makefile new file mode 100644 index 00000000000..d36f662524a --- /dev/null +++ b/src/test/obj_log_set_treshold/Makefile @@ -0,0 +1,14 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright 2024, Intel Corporation + +TARGET = obj_log_set_treshold +OBJS = obj_log_set_treshold.o + +BUILD_STATIC_DEBUG=n +BUILD_STATIC_NONDEBUG=n + +# required for proper mock integration +LIBPMEMOBJ=internal-debug + +include ../Makefile.inc +LDFLAGS += $(call extract_funcs, obj_log_set_treshold.c) diff --git a/src/test/obj_log_set_treshold/TESTS.py b/src/test/obj_log_set_treshold/TESTS.py new file mode 100755 index 00000000000..46103946474 --- /dev/null +++ b/src/test/obj_log_set_treshold/TESTS.py @@ -0,0 +1,27 @@ +#!../env.py +# SPDX-License-Identifier: BSD-3-Clause +# Copyright 2024, Intel Corporation +# + + +import testframework as t +from testframework import granularity as g + + +@g.require_granularity(g.ANY) +# The 'debug' build is chosen arbitrarily to ensure these tests are run only +# once. No dynamic libraries are used nor .static_* builds are available. +@t.require_build('debug') +class OBJ_LOG(t.BaseTest): + test_type = t.Short + + def run(self, ctx): + ctx.exec('obj_log_set_treshold', self.test_case) + + +class TEST0(OBJ_LOG): + test_case = 'test_log_set_treshold_EAGAIN' + + +class TEST1(OBJ_LOG): + test_case = 'test_log_set_treshold_EINVAL' diff --git a/src/test/obj_log_set_treshold/obj_log_set_treshold.c b/src/test/obj_log_set_treshold/obj_log_set_treshold.c new file mode 100644 index 00000000000..da109633346 --- /dev/null +++ b/src/test/obj_log_set_treshold/obj_log_set_treshold.c @@ -0,0 +1,122 @@ +// SPDX-License-Identifier: BSD-3-Clause +/* Copyright 2024, Intel Corporation */ + +/* + * obj_log_set_treshold.c -- unit test for pmemobj_log_set_function + */ + +#include "unittest.h" +#include "log_internal.h" +#include "libpmemobj/log.h" + +#define NO_ARGS_CONSUMED 0 + +#define VALIDATED_CALL 127 +#define CALLED (VALIDATED_CALL + 1) + +static enum core_log_threshold core_tresholds[] = { + CORE_LOG_THRESHOLD, + CORE_LOG_THRESHOLD_AUX +}; + +static enum core_log_level core_levels[] = { + CORE_LOG_LEVEL_HARK, + CORE_LOG_LEVEL_FATAL, + CORE_LOG_LEVEL_ERROR, + CORE_LOG_LEVEL_WARNING, + CORE_LOG_LEVEL_NOTICE, + CORE_LOG_LEVEL_INFO, + CORE_LOG_LEVEL_DEBUG +}; + +/* Mock */ +static struct { + enum core_log_threshold exp_threshold; + enum core_log_level exp_level; + int ret; +} Core_log_set_treshold; + +FUNC_MOCK(core_log_set_threshold, int, enum core_log_threshold threshold, + enum core_log_level level) + FUNC_MOCK_RUN(VALIDATED_CALL) { + UT_ASSERTeq(threshold, Core_log_set_treshold.exp_threshold); + UT_ASSERTeq(level, Core_log_set_treshold.exp_level); + return Core_log_set_treshold.ret; + } +FUNC_MOCK_RUN_DEFAULT { + return _FUNC_REAL(core_log_set_threshold)(threshold, level); +} +FUNC_MOCK_END + +/* Helper */ +static int +test_log_set_treshold_helper(int error) +{ + errno = NO_ERRNO; + Core_log_set_treshold.ret = error == NO_ERRNO ? 0: error; + for (enum pmemobj_log_threshold treshold = PMEMOBJ_LOG_THRESHOLD; + treshold <= PMEMOBJ_LOG_THRESHOLD_AUX; treshold++) { + Core_log_set_treshold.exp_threshold = core_tresholds[treshold]; + for (enum pmemobj_log_level level = PMEMOBJ_LOG_LEVEL_HARK; + level <= PMEMOBJ_LOG_LEVEL_DEBUG; level++) { + Core_log_set_treshold.exp_level = core_levels[level]; + FUNC_MOCK_RCOUNTER_SET(core_log_set_threshold, + VALIDATED_CALL); + int ret = pmemobj_log_set_threshold(treshold, level); + if (error == NO_ERRNO) { + UT_ASSERTeq(ret, 0); + UT_ASSERTeq(errno, NO_ERRNO); + } else { + UT_ASSERTeq(ret, 1); + UT_ASSERTeq(errno, error); + } + UT_ASSERTeq(RCOUNTER(core_log_set_threshold), CALLED); + /* no need to test the error path for all values */ + if (error != NO_ERRNO) + return NO_ARGS_CONSUMED; + } + } + return NO_ARGS_CONSUMED; +} + +/* Tests */ +/* + * Check: + * - if core_log_set_treshold is called with proper arguments + * - if pmemobj_log_set_treshold return 0 (no error) + * - if each PMEMOBJ_LOG_LEVEL corespond to relevant CORE_LOG_LEVEL + * - no errno is set + */ +static int +test_log_set_treshold(const struct test_case *tc, int argc, char *argv[]) +{ + return test_log_set_treshold_helper(NO_ERRNO); +} + +/* Check pmemobj_log_set_threshold EAGAIN error handling. */ +static int +test_log_set_treshold_EAGAIN(const struct test_case *tc, int argc, char *argv[]) +{ + return test_log_set_treshold_helper(EAGAIN); +} + +/* Check pmemobj_log_set_threshold EINVAL error handling. */ +static int +test_log_set_treshold_EINVAL(const struct test_case *tc, int argc, char *argv[]) +{ + return test_log_set_treshold_helper(EINVAL); +} + +static struct test_case test_cases[] = { + TEST_CASE(test_log_set_treshold), + TEST_CASE(test_log_set_treshold_EAGAIN), + TEST_CASE(test_log_set_treshold_EINVAL), +}; + +int +main(int argc, char *argv[]) +{ + START(argc, argv, "obj_log_set_treshold"); + TEST_CASE_PROCESS(argc, argv, test_cases, ARRAY_SIZE(test_cases)); + DONE(NULL); +}