Files
SPHLite/tests/app/test_worker_ipc_selftest.c
T
2026-07-05 21:41:34 +08:00

331 lines
12 KiB
C

#include "sph_worker_blocks.h"
#include "sph_worker_ipc.h"
#include "sph_worker_runtime.h"
#include <stdio.h>
#include <string.h>
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
static int fail(const char *message)
{
fprintf(stderr, "%s\n", message);
return 1;
}
#ifdef _WIN32
typedef struct worker_selftest_t {
sphlite_worker_options_t options;
char solver_id[16];
char case_file[128];
char ipc_name[128];
char command_block[128];
char data_block[128];
char log_path[256];
char worker_id[64];
HANDLE command_mapping;
HANDLE data_mapping;
HANDLE command_event;
HANDLE done_event;
sphlite_worker_command_block_t *command;
sphlite_worker_data_exchange_t *data;
HANDLE thread;
DWORD thread_id;
int worker_result;
} worker_selftest_t;
static DWORD WINAPI worker_thread_main(LPVOID user_data)
{
worker_selftest_t *selftest = (worker_selftest_t *)user_data;
selftest->worker_result = sphlite_worker_run_real_ipc(&selftest->options);
return (DWORD)selftest->worker_result;
}
static void selftest_close(worker_selftest_t *selftest)
{
if (selftest->thread != 0) (void)CloseHandle(selftest->thread);
if (selftest->command != 0) (void)UnmapViewOfFile(selftest->command);
if (selftest->data != 0) (void)UnmapViewOfFile(selftest->data);
if (selftest->command_mapping != 0) {
(void)CloseHandle(selftest->command_mapping);
}
if (selftest->data_mapping != 0) {
(void)CloseHandle(selftest->data_mapping);
}
if (selftest->command_event != 0) (void)CloseHandle(selftest->command_event);
if (selftest->done_event != 0) (void)CloseHandle(selftest->done_event);
}
static int selftest_init(worker_selftest_t *selftest, const char *suffix,
int timeout_ms)
{
DWORD pid = GetCurrentProcessId();
(void)memset(selftest, 0, sizeof(*selftest));
(void)snprintf(selftest->solver_id, sizeof(selftest->solver_id), "SPH");
(void)snprintf(selftest->case_file, sizeof(selftest->case_file),
"tests/data/coupling_region_080.inp");
(void)snprintf(selftest->ipc_name, sizeof(selftest->ipc_name),
"sphlite_selftest_%lu_%s", (unsigned long)pid, suffix);
(void)snprintf(selftest->command_block, sizeof(selftest->command_block),
"%s.command", selftest->ipc_name);
(void)snprintf(selftest->data_block, sizeof(selftest->data_block),
"%s.data", selftest->ipc_name);
(void)snprintf(selftest->log_path, sizeof(selftest->log_path),
"build-codex-unix/%s.log", selftest->ipc_name);
(void)snprintf(selftest->worker_id, sizeof(selftest->worker_id),
"selftest");
selftest->command_mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, 0,
PAGE_READWRITE, 0, sizeof(sphlite_worker_command_block_t),
selftest->command_block);
selftest->data_mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, 0,
PAGE_READWRITE, 0, sizeof(sphlite_worker_data_exchange_t),
selftest->data_block);
if (selftest->command_mapping == 0 || selftest->data_mapping == 0) {
selftest_close(selftest);
return fail("self-test mapping creation failed");
}
{
char command_event_name[128];
char done_event_name[128];
(void)snprintf(command_event_name, sizeof(command_event_name),
"%s.command_event", selftest->ipc_name);
(void)snprintf(done_event_name, sizeof(done_event_name),
"%s.done_event", selftest->ipc_name);
selftest->command_event = CreateEventA(0, FALSE, FALSE,
command_event_name);
selftest->done_event = CreateEventA(0, FALSE, FALSE,
done_event_name);
}
if (selftest->command_event == 0 || selftest->done_event == 0) {
selftest_close(selftest);
return fail("self-test event creation failed");
}
selftest->command = (sphlite_worker_command_block_t *)MapViewOfFile(
selftest->command_mapping, FILE_MAP_ALL_ACCESS, 0, 0,
sizeof(sphlite_worker_command_block_t));
selftest->data = (sphlite_worker_data_exchange_t *)MapViewOfFile(
selftest->data_mapping, FILE_MAP_ALL_ACCESS, 0, 0,
sizeof(sphlite_worker_data_exchange_t));
if (selftest->command == 0 || selftest->data == 0) {
selftest_close(selftest);
return fail("self-test map view failed");
}
(void)memset(selftest->command, 0,
sizeof(sphlite_worker_command_block_t));
sphlite_worker_data_exchange_clear(selftest->data);
sphlite_worker_options_init(&selftest->options);
selftest->options.enabled = 1;
selftest->options.solver_id = selftest->solver_id;
selftest->options.case_file = selftest->case_file;
selftest->options.ipc_name = selftest->ipc_name;
selftest->options.command_block = selftest->command_block;
selftest->options.data_prefix = selftest->data_block;
selftest->options.log_path = selftest->log_path;
selftest->options.timeout_ms = timeout_ms;
selftest->options.worker_id = selftest->worker_id;
return 0;
}
static int selftest_start(worker_selftest_t *selftest)
{
selftest->thread = CreateThread(0, 0, worker_thread_main, selftest, 0,
&selftest->thread_id);
if (selftest->thread == 0) {
return fail("self-test worker thread failed");
}
if (WaitForSingleObject(selftest->done_event, 5000) != WAIT_OBJECT_0) {
return fail("self-test READY wait failed");
}
if (selftest->command->worker_state != SPHLITE_WORKER_STATE_READY ||
selftest->command->error_code != SPHLITE_WORKER_ERROR_OK) {
return fail("self-test READY state mismatch");
}
return 0;
}
static int selftest_send(worker_selftest_t *selftest, int sequence,
int command, int step_id, double dt,
int expected_state, int expected_error)
{
selftest->command->version = SPHLITE_WORKER_COMMAND_BLOCK_VERSION;
selftest->command->sequence = sequence;
selftest->command->command = command;
selftest->command->step_id = step_id;
selftest->command->dt = dt;
if (!SetEvent(selftest->command_event)) {
return fail("self-test command signal failed");
}
if (WaitForSingleObject(selftest->done_event, 5000) != WAIT_OBJECT_0) {
return fail("self-test DONE wait failed");
}
if (selftest->command->ack_sequence != sequence ||
selftest->command->worker_state != expected_state ||
selftest->command->error_code != expected_error) {
fprintf(stderr, "ack=%d state=%d error=%d\n",
selftest->command->ack_sequence,
selftest->command->worker_state,
selftest->command->error_code);
return fail("self-test command result mismatch");
}
return 0;
}
static int selftest_empty_coupling_step(worker_selftest_t *selftest,
int *sequence)
{
selftest->data->force_header.version = SPHLITE_WORKER_FORCE_BLOCK_VERSION;
selftest->data->force_header.count = 0;
*sequence += 1;
if (selftest_send(selftest, *sequence, SPHLITE_WORKER_COMMAND_IMPORT_LOADS,
*sequence, 0.0, SPHLITE_WORKER_STATE_DONE,
SPHLITE_WORKER_ERROR_OK) != 0) {
return 1;
}
*sequence += 1;
return selftest_send(selftest, *sequence, SPHLITE_WORKER_COMMAND_ADVANCE,
*sequence, 1.0e-9, SPHLITE_WORKER_STATE_DONE,
SPHLITE_WORKER_ERROR_OK);
}
static int selftest_join(worker_selftest_t *selftest, int expected_result)
{
DWORD code = 99;
if (WaitForSingleObject(selftest->thread, 5000) != WAIT_OBJECT_0) {
return fail("self-test worker join failed");
}
if (!GetExitCodeThread(selftest->thread, &code) ||
(int)code != expected_result ||
selftest->worker_result != expected_result) {
return fail("self-test worker result mismatch");
}
return 0;
}
static int check_command_selftest(void)
{
worker_selftest_t selftest;
int sequence = 0;
int i;
if (selftest_init(&selftest, "commands", 5000) != 0) return 1;
if (selftest_start(&selftest) != 0) {
selftest_close(&selftest);
return 1;
}
sequence = 1;
if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_INIT, 0, 0.0,
SPHLITE_WORKER_STATE_DONE, SPHLITE_WORKER_ERROR_OK) != 0) return 1;
sequence = 2;
if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_EXPORT_INTERFACE,
0, 0.0, SPHLITE_WORKER_STATE_DONE, SPHLITE_WORKER_ERROR_OK) != 0) {
return 1;
}
if (selftest.data->particle_header.count != 0) {
return fail("self-test empty export was not empty");
}
sequence = 3;
if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_READ_INPUT, 0,
0.0, SPHLITE_WORKER_STATE_DONE, SPHLITE_WORKER_ERROR_OK) != 0) {
return 1;
}
sequence = 4;
if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_BUILD_MODEL, 0,
0.0, SPHLITE_WORKER_STATE_DONE, SPHLITE_WORKER_ERROR_OK) != 0) {
return 1;
}
if (selftest_empty_coupling_step(&selftest, &sequence) != 0) {
return 1;
}
for (i = 0; i < 100; ++i) {
if (selftest_empty_coupling_step(&selftest, &sequence) != 0) {
return 1;
}
}
sequence += 1;
if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_EXPORT_INTERFACE,
sequence, 0.0, SPHLITE_WORKER_STATE_DONE,
SPHLITE_WORKER_ERROR_OK) != 0) {
return 1;
}
if (selftest.data->particle_header.count <= 0) {
return fail("self-test fixed particle export was empty");
}
sequence += 1;
if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_STOP,
sequence, 0.0,
SPHLITE_WORKER_STATE_STOPPED, SPHLITE_WORKER_ERROR_OK) != 0) {
return 1;
}
if (selftest_join(&selftest, 0) != 0) return 1;
selftest_close(&selftest);
return 0;
}
static int check_invalid_input_selftest(void)
{
worker_selftest_t selftest;
if (selftest_init(&selftest, "invalid", 5000) != 0) return 1;
(void)snprintf(selftest.case_file, sizeof(selftest.case_file),
"tests/data/does_not_exist_for_worker.inp");
if (selftest_start(&selftest) != 0) {
selftest_close(&selftest);
return 1;
}
if (selftest_send(&selftest, 1, SPHLITE_WORKER_COMMAND_INIT, 0, 0.0,
SPHLITE_WORKER_STATE_DONE, SPHLITE_WORKER_ERROR_OK) != 0) {
selftest_close(&selftest);
return 1;
}
if (selftest_send(&selftest, 2, SPHLITE_WORKER_COMMAND_READ_INPUT, 0,
0.0, SPHLITE_WORKER_STATE_ERROR,
SPHLITE_WORKER_ERROR_INTERNAL) != 0) {
selftest_close(&selftest);
return 1;
}
if (selftest_join(&selftest, 2) != 0) {
selftest_close(&selftest);
return 1;
}
selftest_close(&selftest);
return 0;
}
static int check_timeout_selftest(void)
{
worker_selftest_t selftest;
if (selftest_init(&selftest, "timeout", 100) != 0) return 1;
if (selftest_start(&selftest) != 0) {
selftest_close(&selftest);
return 1;
}
if (WaitForSingleObject(selftest.done_event, 5000) != WAIT_OBJECT_0) {
selftest_close(&selftest);
return fail("self-test timeout DONE wait failed");
}
if (selftest.command->worker_state != SPHLITE_WORKER_STATE_ERROR ||
selftest.command->error_code != SPHLITE_WORKER_ERROR_TIMEOUT) {
selftest_close(&selftest);
return fail("self-test timeout state mismatch");
}
if (selftest_join(&selftest, 2) != 0) {
selftest_close(&selftest);
return 1;
}
selftest_close(&selftest);
return 0;
}
#endif
int main(void)
{
#ifdef _WIN32
if (check_command_selftest() != 0) return 1;
if (check_invalid_input_selftest() != 0) return 1;
if (check_timeout_selftest() != 0) return 1;
#endif
return 0;
}