From 744e47f9ce87ada87bbb5ba16170c341bab3c580 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler Date: Mon, 21 Oct 2024 09:37:17 -0400 Subject: Rename "files" and "file_without_ext" to improve readability --- tests/CMakeLists.txt | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) (limited to 'tests') diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index f4380e0..9748196 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -12,30 +12,30 @@ set(win_msvc_cflags /Wall) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/data/generic.ini ${CMAKE_CURRENT_BINARY_DIR} COPYONLY) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/data/result.xml ${CMAKE_CURRENT_BINARY_DIR} COPYONLY) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/data/result_error.xml ${CMAKE_CURRENT_BINARY_DIR} COPYONLY) -file(GLOB files "test_*.c") +file(GLOB source_files "test_*.c") if (BASH_PROGRAM) add_test (rt_generic ${BASH_PROGRAM} ${CMAKE_CURRENT_SOURCE_DIR}/rt_generic.sh) endif() -foreach(file ${files}) - string(REGEX REPLACE "(^.*/|\\.[^.]*$)" "" file_without_ext ${file}) - add_executable(${file_without_ext} ${file}) +foreach(source_file ${source_files}) + string(REGEX REPLACE "(^.*/|\\.[^.]*$)" "" test_executable ${source_file}) + add_executable(${test_executable} ${source_file}) if (CMAKE_C_COMPILER_ID STREQUAL "GNU") - target_compile_options(${file_without_ext} PRIVATE ${nix_cflags} ${nix_gnu_cflags}) + target_compile_options(${test_executable} PRIVATE ${nix_cflags} ${nix_gnu_cflags}) elseif (CMAKE_C_COMPILER_ID MATCHES "Clang") - target_compile_options(${file_without_ext} PRIVATE ${nix_cflags} ${nix_clang_cflags}) + target_compile_options(${test_executable} PRIVATE ${nix_cflags} ${nix_clang_cflags}) elseif (CMAKE_C_COMPILER_ID STREQUAL "MSVC") - target_compile_options(${file_without_ext} PRIVATE ${win_cflags} ${win_msvc_cflags}) + target_compile_options(${test_executable} PRIVATE ${win_cflags} ${win_msvc_cflags}) endif() - target_link_libraries(${file_without_ext} PRIVATE stasis_core) - add_test(${file_without_ext} ${file_without_ext}) - set_tests_properties(${file_without_ext} + target_link_libraries(${test_executable} PRIVATE stasis_core) + add_test(${test_executable} ${test_executable}) + set_tests_properties(${test_executable} PROPERTIES - TIMEOUT 120) - set_tests_properties(${file_without_ext} + TIMEOUT 240) + set_tests_properties(${test_executable} PROPERTIES SKIP_RETURN_CODE 127) - set_property(TEST ${file_without_ext} + set_property(TEST ${test_executable} PROPERTY ENVIRONMENT "STASIS_SYSCONFDIR=${CMAKE_SOURCE_DIR}") endforeach() \ No newline at end of file -- cgit From 265f4e249da104c964e15ab004b48ca1f47feec5 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler Date: Mon, 21 Oct 2024 11:40:09 -0400 Subject: Add BUILD_TESTING_RT build option * The user can choose to (not) run the long scripted statis test(s) --- tests/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tests') diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 9748196..0da290f 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -14,7 +14,7 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/data/result.xml ${CMAKE_CURRENT_BINAR configure_file(${CMAKE_CURRENT_SOURCE_DIR}/data/result_error.xml ${CMAKE_CURRENT_BINARY_DIR} COPYONLY) file(GLOB source_files "test_*.c") -if (BASH_PROGRAM) +if (BASH_PROGRAM AND BUILD_TESTING_RT) add_test (rt_generic ${BASH_PROGRAM} ${CMAKE_CURRENT_SOURCE_DIR}/rt_generic.sh) endif() -- cgit From 5d21c2c6eab632cc519eb23e529c2d985ac04921 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler Date: Mon, 21 Oct 2024 12:11:05 -0400 Subject: Change signature: * delivery_gather_tool_versions now returns non-zero if unable to determine a tool's version --- tests/test_conda.c | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'tests') diff --git a/tests/test_conda.c b/tests/test_conda.c index 2ed869a..c379216 100644 --- a/tests/test_conda.c +++ b/tests/test_conda.c @@ -126,6 +126,13 @@ void test_conda_index() { STASIS_ASSERT(conda_index("channel") == 0, "cannot index a simple conda channel"); } +void test_delivery_gather_tool_versions() { + int status = delivery_gather_tool_versions(&ctx); + STASIS_ASSERT(status == 0, "Failed to gather tool versions"); + STASIS_ASSERT(!isempty(ctx.conda.tool_version), "conda version is empty"); + STASIS_ASSERT(!isempty(ctx.conda.tool_build_version), "conda_build version is empty"); +} + int main(int argc, char *argv[]) { STASIS_TEST_BEGIN_MAIN(); STASIS_TEST_FUNC *tests[] = { -- cgit From c2f4dafbb58a1348632d6a5accc703a1fa4871b7 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler Date: Mon, 21 Oct 2024 12:15:33 -0400 Subject: Add tests: * test_pip_index_provides * test_conda_provides * test_conda_get_active_environment * test_delivery_gather_tool_versions Fix tests: * global.sysconfdir duplicates the environment string * Use delivery_free() * Use globals_free() --- tests/test_conda.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 52 insertions(+), 2 deletions(-) (limited to 'tests') diff --git a/tests/test_conda.c b/tests/test_conda.c index c379216..9ad12c8 100644 --- a/tests/test_conda.c +++ b/tests/test_conda.c @@ -126,6 +126,50 @@ void test_conda_index() { STASIS_ASSERT(conda_index("channel") == 0, "cannot index a simple conda channel"); } +void test_pip_index_provides() { + struct testcase { + const char *pindex; + const char *name; + int expected; + }; + struct testcase tc[] = { + {.pindex = PYPI_INDEX_DEFAULT, .name = "firewatch", .expected = 1}, + {.pindex = PYPI_INDEX_DEFAULT, .name = "doesnotexistfirewatch", .expected = 0}, + {.pindex = "bad_index", .name = "firewatch", .expected = 0}, + {.pindex = PYPI_INDEX_DEFAULT, .name = "", .expected = -1}, + {.pindex = "", .name = "", .expected = -1}, + }; + for (size_t i = 0; i < sizeof(tc) / sizeof(*tc); i++) { + struct testcase *test = &tc[i]; + int result = pip_index_provides(test->pindex, test->name) ; + STASIS_ASSERT(result == test->expected, "Unexpected result"); + } +} + +void test_conda_get_active_environment() { + conda_activate(ctx.storage.conda_install_prefix, "base"); + STASIS_ASSERT(strcmp(conda_get_active_environment(), "base") == 0, "base environment not active"); +} + +void test_conda_provides() { + struct testcase { + const char *name; + int expected; + }; + struct testcase tc[] = { + {.name = "fitsverify", .expected = 1}, + {.name = "doesnotexistfitsverify", .expected = 0}, + {.name = "", .expected = 0}, + }; + + for (size_t i = 0; i < sizeof(tc) / sizeof(*tc); i++) { + struct testcase *test = &tc[i]; + int result = conda_provides(test->name); + printf("%s returned %d, expecting %d\n", test->name, result, test->expected); + STASIS_ASSERT(result == test->expected, "Unexpected result"); + } +} + void test_delivery_gather_tool_versions() { int status = delivery_gather_tool_versions(&ctx); STASIS_ASSERT(status == 0, "Failed to gather tool versions"); @@ -140,11 +184,15 @@ int main(int argc, char *argv[]) { test_conda_installation, test_conda_activate, test_conda_setup_headless, + test_conda_provides, + test_conda_get_active_environment, test_conda_exec, test_python_exec, test_conda_env_create_from_uri, test_conda_env_create_export_remove, test_conda_index, + test_pip_index_provides, + test_delivery_gather_tool_versions, }; const char *ws = "workspace"; @@ -172,8 +220,8 @@ int main(int argc, char *argv[]) { ctx._stasis_ini_fp.delivery = ini; ctx._stasis_ini_fp.delivery_path = realpath("mock.ini", NULL); - setenv("TMPDIR", cwd_workspace, 1); - globals.sysconfdir = getenv("STASIS_SYSCONFDIR"); + const char *sysconfdir = getenv("STASIS_SYSCONFDIR"); + globals.sysconfdir = strdup(sysconfdir ? sysconfdir : STASIS_SYSCONFDIR); ctx.storage.root = strdup(cwd_workspace); setenv("LANG", "C", 1); @@ -186,5 +234,7 @@ int main(int argc, char *argv[]) { if (rmtree(cwd_workspace)) { perror(cwd_workspace); } + delivery_free(&ctx); + globals_free(); STASIS_TEST_END_MAIN(); } \ No newline at end of file -- cgit From 1f2e44c2ec28a1df11040cd56299fdddbfcd7452 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler Date: Mon, 21 Oct 2024 12:16:23 -0400 Subject: Add tests: * test_mp_fail_fast * test_mp_stop_continue --- tests/test_multiprocessing.c | 82 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) (limited to 'tests') diff --git a/tests/test_multiprocessing.c b/tests/test_multiprocessing.c index b9cd309..3377783 100644 --- a/tests/test_multiprocessing.c +++ b/tests/test_multiprocessing.c @@ -1,5 +1,6 @@ #include "testing.h" #include "multiprocessing.h" +#include static struct MultiProcessingPool *pool; char *commands[] = { @@ -12,6 +13,10 @@ char *commands[] = { }; void test_mp_pool_init() { + STASIS_ASSERT((pool = mp_pool_init(NULL, "mplogs")) == NULL, "Pool should not be initialized with invalid ident"); + STASIS_ASSERT((pool = mp_pool_init("mypool", NULL)) == NULL, "Pool should not be initialized with invalid logname"); + STASIS_ASSERT((pool = mp_pool_init(NULL, NULL)) == NULL, "Pool should not be initialized with invalid arguments"); + pool = NULL; STASIS_ASSERT((pool = mp_pool_init("mypool", "mplogs")) != NULL, "Pool initialization failed"); STASIS_ASSERT_FATAL(pool != NULL, "Should not be NULL"); STASIS_ASSERT(pool->num_alloc == MP_POOL_TASK_MAX, "Wrong number of default records"); @@ -56,6 +61,7 @@ void test_mp_task() { pool = mp_pool_init("mypool", "mplogs"); if (pool) { + pool->status_interval = 3; for (size_t i = 0; i < sizeof(commands) / sizeof(*commands); i++) { struct MultiProcessingTask *task; char task_name[100] = {0}; @@ -113,6 +119,80 @@ void test_mp_pool_workflow() { } } +void test_mp_fail_fast() { + char *commands_ff[] = { + "sleep 1; true", + "sleep 2; true", + "sleep 3; false", + "sleep 10; true", // these... + "sleep 10; true", // shouldn't... + "sleep 10; true", // execute... but need to be here to satisfy the signaled_by test below + }; + + struct MultiProcessingPool *p; + STASIS_ASSERT((p = mp_pool_init("failfast", "failfastlogs")) != NULL, "Failed to initialize pool"); + for (size_t i = 0; i < sizeof(commands_ff) / sizeof(*commands_ff); i++) { + struct MultiProcessingTask *task; + char *command = commands_ff[i]; + STASIS_ASSERT(mp_pool_task(p, "task", NULL, (char *) command) != NULL, "Failed to queue task"); + } + + STASIS_ASSERT(mp_pool_join(p, get_cpu_count(), MP_POOL_FAIL_FAST) < 0, "Unexpected result"); + + struct result { + int total_signaled; + int total_status; + int total_unused; + } result = { + .total_signaled = 0, + .total_status = 0, + .total_unused = 0, + }; + for (size_t i = 0; i < p->num_used; i++) { + struct MultiProcessingTask *task = &p->task[i]; + if (task->signaled_by) result.total_signaled++; + if (task->status) result.total_status++; + if (task->pid == MP_POOL_PID_UNUSED) result.total_unused++; + } + STASIS_ASSERT(result.total_status == 1, "Unexpected status count"); + STASIS_ASSERT(result.total_signaled == 3, "Unexpected signal count"); + STASIS_ASSERT(result.total_unused == 5, "Unexpected PID. Should be marked UNUSED."); + mp_pool_show_summary(p); + mp_pool_free(&p); +} + +pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; +static void *pool_container(void *data) { + char *commands_sc[] = { + "sleep 10; echo done sleeping" + }; + struct MultiProcessingPool **x = (struct MultiProcessingPool **) data; + struct MultiProcessingPool *p = (*x); + pthread_mutex_lock(&mutex); + mp_pool_task(p, "stop_resume_test", NULL, commands_sc[0]); + mp_pool_join(p, 1, 0); + mp_pool_show_summary(p); + mp_pool_free(&p); + pthread_mutex_unlock(&mutex); + return NULL; +} + +void test_mp_stop_continue() { + struct MultiProcessingPool *p = NULL; + STASIS_ASSERT((p = mp_pool_init("stopcontinue", "stopcontinuelogs")) != NULL, "Failed to initialize pool"); + pthread_t th; + pthread_create(&th, NULL, pool_container, &p); + sleep(2); + if (p->task[0].pid != MP_POOL_PID_UNUSED) { + STASIS_ASSERT(kill(p->task[0].pid, SIGSTOP) == 0, "SIGSTOP failed"); + sleep(2); + STASIS_ASSERT(kill(p->task[0].pid, SIGCONT) == 0, "SIGCONT failed"); + } else { + STASIS_ASSERT(false, "Task was marked as unused when it shouldn't have been"); + } + pthread_join(th, NULL); +} + int main(int argc, char *argv[]) { STASIS_TEST_BEGIN_MAIN(); STASIS_TEST_FUNC *tests[] = { @@ -121,6 +201,8 @@ int main(int argc, char *argv[]) { test_mp_pool_join, test_mp_pool_free, test_mp_pool_workflow, + test_mp_fail_fast, + test_mp_stop_continue }; STASIS_TEST_RUN(tests); STASIS_TEST_END_MAIN(); -- cgit From d2bdc3db2ab07804c4c19b7bc88ff68aa8627692 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler Date: Mon, 21 Oct 2024 12:16:58 -0400 Subject: Add tests: * test_envctl_init * test_envctl_register --- tests/test_envctl.c | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 tests/test_envctl.c (limited to 'tests') diff --git a/tests/test_envctl.c b/tests/test_envctl.c new file mode 100644 index 0000000..eab0186 --- /dev/null +++ b/tests/test_envctl.c @@ -0,0 +1,72 @@ +#include "testing.h" +#include "envctl.h" + +void test_envctl_init() { + struct EnvCtl *envctl; + STASIS_ASSERT_FATAL((envctl = envctl_init()) != NULL, "envctl could not be initialized"); + STASIS_ASSERT(envctl->num_alloc == STASIS_ENVCTL_DEFAULT_ALLOC, "freshly initialized envctl does not have the correct number records"); + STASIS_ASSERT(envctl->num_used == 0, "freshly initialized envctl should have no allocations in use"); + STASIS_ASSERT(envctl->item != NULL, "freshly initialized envctl should have an empty items array. this one is NULL."); + STASIS_ASSERT(envctl->item[0] == NULL, "freshly initialized envctl should not have any items. this one does."); + envctl_free(&envctl); + STASIS_ASSERT(envctl == NULL, "envctl should be NULL after envctl_free()"); +} + +static int except_passthru(const void *a, const void *b) { + const struct EnvCtl_Item *item = a; + const char *name = b; + if (!envctl_check_required(item->flags) && envctl_check_present(item, name)) { + return STASIS_ENVCTL_RET_SUCCESS; + } + return STASIS_ENVCTL_RET_FAIL; +} + +static int except_required(const void *a, const void *b) { + const struct EnvCtl_Item *item = a; + const char *name = b; + if (envctl_check_required(item->flags) && envctl_check_present(item, name)) { + return STASIS_ENVCTL_RET_SUCCESS; + } + return STASIS_ENVCTL_RET_FAIL; +} + +static int except_redact(const void *a, const void *b) { + const struct EnvCtl_Item *item = a; + const char *name = b; + if (envctl_check_redact(item->flags) && envctl_check_present(item, name)) { + return STASIS_ENVCTL_RET_SUCCESS; + } + return STASIS_ENVCTL_RET_FAIL; +} + +void test_envctl_register() { + struct EnvCtl *envctl; + envctl = envctl_init(); + setenv("passthru", "true", 1); + setenv("required", "true", 1); + setenv("redact", "true", 1); + envctl_register(&envctl, STASIS_ENVCTL_PASSTHRU, except_passthru, "passthru"); + envctl_register(&envctl, STASIS_ENVCTL_REQUIRED, except_required, "required"); + envctl_register(&envctl, STASIS_ENVCTL_REDACT, except_redact, "redact"); + + unsigned flags[] = { + STASIS_ENVCTL_PASSTHRU, + STASIS_ENVCTL_REQUIRED, + STASIS_ENVCTL_REDACT, + }; + for (size_t i = 0; i < envctl->num_used; i++) { + struct EnvCtl_Item *item = envctl->item[i]; + STASIS_ASSERT(item->flags == flags[i], "incorrect flag for item"); + } + envctl_free(&envctl); +} + +int main(int argc, char *argv[]) { + STASIS_TEST_BEGIN_MAIN(); + STASIS_TEST_FUNC *tests[] = { + test_envctl_init, + test_envctl_register, + }; + STASIS_TEST_RUN(tests); + STASIS_TEST_END_MAIN(); +} \ No newline at end of file -- cgit From a27fb62977c7a3faf9032ffbc7e6531700e30441 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler Date: Mon, 21 Oct 2024 13:17:16 -0400 Subject: The CI internal clocks are off? I don't see why these failed. * Increasing sleep times might help. --- tests/test_multiprocessing.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) (limited to 'tests') diff --git a/tests/test_multiprocessing.c b/tests/test_multiprocessing.c index 3377783..750a001 100644 --- a/tests/test_multiprocessing.c +++ b/tests/test_multiprocessing.c @@ -122,17 +122,16 @@ void test_mp_pool_workflow() { void test_mp_fail_fast() { char *commands_ff[] = { "sleep 1; true", - "sleep 2; true", - "sleep 3; false", - "sleep 10; true", // these... - "sleep 10; true", // shouldn't... - "sleep 10; true", // execute... but need to be here to satisfy the signaled_by test below + "sleep 3; true", + "sleep 5; false", + "sleep 30; true", // these... + "sleep 30; true", // shouldn't... + "sleep 30; true", // execute... but need to be here to satisfy the signaled_by test below }; struct MultiProcessingPool *p; STASIS_ASSERT((p = mp_pool_init("failfast", "failfastlogs")) != NULL, "Failed to initialize pool"); for (size_t i = 0; i < sizeof(commands_ff) / sizeof(*commands_ff); i++) { - struct MultiProcessingTask *task; char *command = commands_ff[i]; STASIS_ASSERT(mp_pool_task(p, "task", NULL, (char *) command) != NULL, "Failed to queue task"); } @@ -156,7 +155,7 @@ void test_mp_fail_fast() { } STASIS_ASSERT(result.total_status == 1, "Unexpected status count"); STASIS_ASSERT(result.total_signaled == 3, "Unexpected signal count"); - STASIS_ASSERT(result.total_unused == 5, "Unexpected PID. Should be marked UNUSED."); + STASIS_ASSERT(result.total_unused > 0, "Unexpected PIDs present. Should be marked UNUSED."); mp_pool_show_summary(p); mp_pool_free(&p); } -- cgit From b46552ef9e37e60f7913c9776f73637e17a1d9e6 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler Date: Tue, 22 Oct 2024 01:33:35 -0400 Subject: Update test_mp_fail_fast * Record status(s) and just verify they're non-zero. Checking for exact values is difficult when you don't know the hardware ahead of time. * Apply HOLD state --- tests/test_multiprocessing.c | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) (limited to 'tests') diff --git a/tests/test_multiprocessing.c b/tests/test_multiprocessing.c index 750a001..13a343d 100644 --- a/tests/test_multiprocessing.c +++ b/tests/test_multiprocessing.c @@ -140,22 +140,28 @@ void test_mp_fail_fast() { struct result { int total_signaled; - int total_status; + int total_status_fail; + int total_status_success; int total_unused; } result = { .total_signaled = 0, - .total_status = 0, + .total_status_fail = 0, + .total_status_success = 0, .total_unused = 0, }; for (size_t i = 0; i < p->num_used; i++) { struct MultiProcessingTask *task = &p->task[i]; if (task->signaled_by) result.total_signaled++; - if (task->status) result.total_status++; - if (task->pid == MP_POOL_PID_UNUSED) result.total_unused++; + if (task->status > 0) result.total_status_fail++; + if (task->status == 0) result.total_status_success++; + if (task->pid == MP_POOL_PID_UNUSED && task->status == MP_POOL_TASK_STATUS_INITIAL) result.total_unused++; } - STASIS_ASSERT(result.total_status == 1, "Unexpected status count"); - STASIS_ASSERT(result.total_signaled == 3, "Unexpected signal count"); - STASIS_ASSERT(result.total_unused > 0, "Unexpected PIDs present. Should be marked UNUSED."); + fprintf(stderr, "total_status_fail = %d\ntotal_status_success = %d\ntotal_signaled = %d\ntotal_unused = %d\n", + result.total_status_fail, result.total_status_success, result.total_signaled, result.total_unused); + STASIS_ASSERT(result.total_status_fail, "Should have failures"); + STASIS_ASSERT(result.total_status_success, "Should have successes"); + STASIS_ASSERT(result.total_signaled, "Should have signaled PIDs"); + STASIS_ASSERT(result.total_unused, "Should have PIDs marked UNUSED."); mp_pool_show_summary(p); mp_pool_free(&p); } -- cgit From ebb75d08d5f680f13867f71528b83df62a9d27b0 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler Date: Tue, 22 Oct 2024 01:47:34 -0400 Subject: Update test_mp_fail_fast * Brute force the conditions required to make this work. Issue 128 jobs. --- tests/test_multiprocessing.c | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) (limited to 'tests') diff --git a/tests/test_multiprocessing.c b/tests/test_multiprocessing.c index 13a343d..7cc8bc7 100644 --- a/tests/test_multiprocessing.c +++ b/tests/test_multiprocessing.c @@ -120,20 +120,26 @@ void test_mp_pool_workflow() { } void test_mp_fail_fast() { - char *commands_ff[] = { + char *commands_ff[128] = { "sleep 1; true", "sleep 3; true", "sleep 5; false", - "sleep 30; true", // these... - "sleep 30; true", // shouldn't... - "sleep 30; true", // execute... but need to be here to satisfy the signaled_by test below }; + // Pad the array with tasks. None of these should execute when + // the "fail fast" conditions are met + char *nopcmd = "sleep 30; true"; + for (size_t i = 3; i < sizeof(commands_ff) / sizeof(*commands_ff); i++) { + commands_ff[i] = nopcmd; + } + struct MultiProcessingPool *p; STASIS_ASSERT((p = mp_pool_init("failfast", "failfastlogs")) != NULL, "Failed to initialize pool"); for (size_t i = 0; i < sizeof(commands_ff) / sizeof(*commands_ff); i++) { char *command = commands_ff[i]; - STASIS_ASSERT(mp_pool_task(p, "task", NULL, (char *) command) != NULL, "Failed to queue task"); + char taskname[100] = {0}; + snprintf(taskname, sizeof(taskname) - 1, "task_%03zu", i); + STASIS_ASSERT(mp_pool_task(p, taskname, NULL, (char *) command) != NULL, "Failed to queue task"); } STASIS_ASSERT(mp_pool_join(p, get_cpu_count(), MP_POOL_FAIL_FAST) < 0, "Unexpected result"); -- cgit From 30f48145d1a1c747c40f94e2a7314d4bdf61cf55 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler Date: Tue, 22 Oct 2024 09:11:11 -0400 Subject: Update test_mp_fail_fast * macOS Actions runners have 3 vCPUs. No wonder this wasn't working. Reduce the success count to 1. --- tests/test_multiprocessing.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'tests') diff --git a/tests/test_multiprocessing.c b/tests/test_multiprocessing.c index 7cc8bc7..7c9d695 100644 --- a/tests/test_multiprocessing.c +++ b/tests/test_multiprocessing.c @@ -121,7 +121,6 @@ void test_mp_pool_workflow() { void test_mp_fail_fast() { char *commands_ff[128] = { - "sleep 1; true", "sleep 3; true", "sleep 5; false", }; @@ -129,7 +128,7 @@ void test_mp_fail_fast() { // Pad the array with tasks. None of these should execute when // the "fail fast" conditions are met char *nopcmd = "sleep 30; true"; - for (size_t i = 3; i < sizeof(commands_ff) / sizeof(*commands_ff); i++) { + for (size_t i = 2; i < sizeof(commands_ff) / sizeof(*commands_ff); i++) { commands_ff[i] = nopcmd; } -- cgit