lei.chen/myxce
1
0
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
myxce/src/scheduler/testsuite/test_repl_round_rollup.c
Rongsong Shen 5ee1d6cb08
feat(scheduler-sim-repl-verbosity): task 7.2 - implement resource formatting helpers 
Implements repl_is_bytes_valued_resource()/repl_format_bytes_human()
(mirroring xce_test's confirmed is_bytes_valued_resource()/
format_bytes_human() precedent exactly) and the units_mode setting
(explicitly defaulted to both, not left to zero-init) wired into
set units raw|human|both alongside the existing set speed/output/verify
branches (Requirements 6.1-6.3). All 8 of task 7.1's tests pass.

Split repl_format_ts_human(), the Jobid Range Compressor (task 1.2),
and these two new helpers out of repl.c into a new repl_fmt.c: adding
them in place pushed repl.c to 929 lines (16.1% over the 800-line
cap), and unlike task 6.2's single-function split attempt (which
didn't even achieve compliance), bundling these three pure-formatter
groups together does - repl.c settles at 587 lines, repl_fmt.c at 402,
both comfortably under cap. Required a matching #include line in the
20 test files that white-box #include repl.c, plus extending
test_sim_isolation.c's forbidden-include/symbol scan to cover the new
file, following the repl_rollup.c split precedent from task 2.2.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YAWMhfRJFnmmnG8h97yUDd
2026-09-02 17:45:06 +00:00

1023 lines
39 KiB
C
Raw Blame History

/*
* test_repl_round_rollup.c - contract test for the interactive simulation
* REPL's Round Rollup component (scheduler-sim-repl-verbosity spec, task
* 2.1, Requirements 2 and 3): per-round decision summaries, collapsing of
* repetitive rounds, and the shared repl_round_collapse_flush() flush entry
* point.
*
* Split out of test_repl_execution_control.c -- see design.md's own
* "**Correction (post-review, task 2.1)**" note in its "New/Modified Test
* Files" section. Landing these tests there per the original plan pushed
* that file from 937 to 1563 lines, well past this project's 800-line cap
* and past the ~1000-line threshold this exact spec family already treats
* as a split trigger -- the same reason test_repl_snapshot_params.c was
* split out of test_repl_breakpoints_inspection.c (see that file pair's own
* meson.build comments). Following that established convention, this file
* duplicates (rather than shares via a new header) whatever pre-existing
* static fixture helpers it needs from test_repl_execution_control.c.
*
* Fixture strategy and white-box #include set: identical to
* test_repl_execution_control.c (see that file's own header comment) --
* this file exercises the same real sched_sim_driver_run() end-to-end,
* forked-child, real-stdout-capture technique.
*
* See the section header comment below (carried over verbatim from
* test_repl_execution_control.c, task 2.1's original landing spot) for the
* RED-phase rationale and the assumed output contract these tests pin.
*/
#include <errno.h>
#include <limits.h>
#include <stdatomic.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
#include <unity/unity.h>
#include "controller.capnp.h"
#include "kvmgr.h"
#include "scheduler.h"
#include "xstring.h"
/* Pull in the real functions under test into this TU (white-box #include,
* same convention as test_repl_execution_control.c/
* test_repl_breakpoints_inspection.c). */
#include "../src/core.c"
#include "../src/core_clock.c"
#include "../src/core_events.c"
#include "../src/core_session.c"
#include "../src/decision.c"
#include "../src/plugin.c"
#include "../src/plugins/builtin_fcfs.c"
#include "../src/recording.c"
#include "../src/recording_session.c"
#include "../src/repl.c"
#include "../src/repl_fmt.c"
#include "../src/repl_rollup.c"
#include "../src/repl_break.c"
#include "../src/repl_info.c"
#include "../src/repl_params.c"
#include "../src/sim.c"
#include "../src/sim_loop.c"
#include "../src/sim_picker.c" /* bug-1567: sched_sim_driver_run() now calls sim_bootstrap_picker() (sim_loop.c-cap sibling) as an extern -- undefined reference at link time otherwise */
#include "../src/sim_record.c"
#include "../src/sim_verify.c"
#include "../src/snapshot.c"
#include "../src/snapshot_load.c"
#include "../src/snapshot_wire.c"
void kill_sched_job(void* arg) { (void)arg; }
void kill_sched_queue(void* arg) { (void)arg; }
void kill_sched_worker(void* arg) { (void)arg; }
void kill_sched_user(void* arg) { (void)arg; }
void kill_sched_project(void* arg) { (void)arg; }
void kill_sched_resval(xce_val_t* val) { (void)val; }
/* resource-accounting.md's reconciliation (resource.c, not linked here --
* this file only #includes core_events.c). core_events.c's
* XCE_CORE_EVENT_JOB_RUSAGE handler calls this whenever job->accounts !=
* NULL; link-satisfying stub only, same rationale as every other stub in
* this block (see test_job_update.c's identical stub). */
int sched_reconcile_job_resource_usage(xce_sched_core_t* c,
xce_job_account_t* a,
xce_job_rusages_t* r)
{
(void)c; (void)a; (void)r; return 0;
}
void sched_worker_release_host_ctx(xce_sched_worker_t* w) { (void)w; }
int sched_fill_limit_requests(xce_scheduler_t* sched, xvec_idval_t* vec,
xlist_t* limits)
{
(void)sched;
(void)vec;
(void)limits;
return 0;
}
/* sched_sim_driver_run()'s (sim_loop.c, scheduler-sim-decision-parity task
* 2.1) new round-boundary call to the relocated sched_account_jobs()
* (core.h) -- a no-op stand-in here since this file does not link
* scheduler.c/resource.c, same rationale test_sim_equivalence.c's own copy
* documents. */
int sched_account_jobs(xce_sched_core_t* core)
{
(void)core;
return 0;
}
/* Real reimplementation of schedobj.c's sched_resolve_job_picker -- same
* copy test_sim_alt_events.c/test_sim_verify.c/test_sim_event_loop.c/
* test_repl_execution_control.c each carry (schedobj.c is not linked here:
* it would need plugin_register(), which requires a genuine
* xce_scheduler_t* neither this file's fixtures nor sim_loop.c's own
* core-scoped registration path have, Req 5 AC 17). */
int sched_resolve_job_picker(xce_sched_core_t* core, xce_sched_plugin_t** out)
{
xce_sched_plugin_t* plugin = NULL;
int rc = 0;
if ((core == NULL) || (out == NULL)) {
return -EINVAL;
}
*out = NULL;
if (core->job_pick_plugin == NULL) {
return -EINVAL;
}
lock(core->plugins, RTTI_LOCK_READ);
rc = key_find(core->plugins, core->job_pick_plugin, (void**)&plugin);
unlock(core->plugins);
if (rc <= 0) {
return (rc < 0) ? rc : -ENOENT;
}
if ((plugin == NULL) || (plugin->picker_iface == NULL)
|| (plugin->picker_iface->next_job == NULL)
|| (plugin->picker_iface->begin_session == NULL)
|| (plugin->picker_iface->end_session == NULL)
|| (plugin->picker_iface->on_dispatch == NULL)
|| (plugin->picker_iface->on_pend == NULL)) {
return -EINVAL;
}
*out = plugin;
return 0;
}
void setUp(void) { return; }
void tearDown(void) { return; }
/* ---------------------------------------------------------------------- */
/* Fixture helpers -- duplicated from test_repl_execution_control.c (same */
/* techniques test_sim_alt_events.c/test_sim_verify.c already establish), */
/* per this file pair's established split convention (see header comment */
/* above): copied, not shared via a new header. */
/* ---------------------------------------------------------------------- */
static void make_tmp_dir(char* out, size_t out_len, const char* suffix)
{
char tmpl[PATH_MAX];
snprintf(tmpl, sizeof(tmpl), "/tmp/sched_replexec%s_XXXXXX", suffix);
TEST_ASSERT_NOT_NULL(mkdtemp(tmpl));
TEST_ASSERT_TRUE(strlen(tmpl) < out_len);
strcpy(out, tmpl);
}
static void build_fixture_scheduler(xce_scheduler_t* sched, char* record_dir)
{
int rc;
memset(sched, 0, sizeof(*sched));
mylock_init(&(sched->record_lock));
rc = xce_sched_core_init(&(sched->core));
TEST_ASSERT_EQUAL_INT(0, rc);
sched->core.job_pick_plugin = (char*)"builtin_fcfs";
sched->record_dir = record_dir;
}
static FILE* write_header_and_snapshot(char* out_path, size_t out_path_len,
const char* suffix)
{
char record_dir[PATH_MAX];
xce_scheduler_t sched;
int rc;
make_tmp_dir(record_dir, sizeof(record_dir), suffix);
build_fixture_scheduler(&sched, record_dir);
rc = sched_record_start(&sched, "fixture.replay");
TEST_ASSERT_EQUAL_INT(0, rc);
TEST_ASSERT_TRUE(strlen(sched.record_file_path) < out_path_len);
strcpy(out_path, sched.record_file_path);
return sched.record_file;
}
static void append_queue_update_event(FILE* f, uint64_t ts,
const char* queue_name)
{
xce_queue_t queue;
replay_event_t src;
struct capn c;
struct capn_segment* cs;
ReplayEvent_ptr p;
memset(&queue, 0, sizeof(queue));
queue.queue = (char*)queue_name;
queue.status = QUEUE_STAT_OPEN;
queue.priority = 1;
memset(&src, 0, sizeof(src));
src.ts = ts;
src.body_which = ReplayEvent_body_queueUpdate;
src.body.queue_update = &queue;
capn_init_malloc(&c);
cs = capn_root(&c).seg;
encode_ReplayEvent_ptr(cs, &p, &src);
capn_setp(capn_root(&c), 0, p.p);
TEST_ASSERT_EQUAL_INT(0, write_capnp_message(f, &c));
capn_free(&c);
}
static void append_jobs_push_event(FILE* f, uint64_t ts, uint64_t jobid,
const char* queue_name)
{
job_submit_data_t submit;
xce_job_t job;
xce_job_t* jobs[1];
xce_jobs_data_t jobs_data;
replay_event_t src;
struct capn c;
struct capn_segment* cs;
ReplayEvent_ptr p;
memset(&submit, 0, sizeof(submit));
submit.queue = (char*)queue_name;
submit.user = (char*)"alice";
submit.mintasks = 1;
submit.maxtasks = 1;
memset(&job, 0, sizeof(job));
job.jobid = jobid;
job.state = JOB_STAT_PEND;
job.submit = &submit;
jobs[0] = &job;
memset(&jobs_data, 0, sizeof(jobs_data));
jobs_data.n_total = 1;
jobs_data.count = 1;
jobs_data.jobs = jobs;
memset(&src, 0, sizeof(src));
src.ts = ts;
src.body_which = ReplayEvent_body_jobsPush;
src.body.jobs_push = &jobs_data;
capn_init_malloc(&c);
cs = capn_root(&c).seg;
encode_ReplayEvent_ptr(cs, &p, &src);
capn_setp(capn_root(&c), 0, p.p);
TEST_ASSERT_EQUAL_INT(0, write_capnp_message(f, &c));
capn_free(&c);
}
static void append_replay_session(FILE* f, uint64_t begin_round)
{
struct capn c;
struct capn_segment* cs;
ReplaySession_ptr sp;
capn_init_malloc(&c);
cs = capn_root(&c).seg;
sp = new_ReplaySession(cs);
ReplaySession_set_beginRound(sp, begin_round);
capn_setp(capn_root(&c), 0, sp.p);
TEST_ASSERT_EQUAL_INT(0, write_capnp_message(f, &c));
capn_free(&c);
}
static void append_end_of_stream_marker(FILE* f)
{
replay_event_t src;
struct capn c;
struct capn_segment* cs;
ReplayEvent_ptr p;
memset(&src, 0, sizeof(src));
src.body_which = ReplayEvent_body_endSession;
capn_init_malloc(&c);
cs = capn_root(&c).seg;
encode_ReplayEvent_ptr(cs, &p, &src);
capn_setp(capn_root(&c), 0, p.p);
TEST_ASSERT_EQUAL_INT(0, write_capnp_message(f, &c));
capn_free(&c);
}
static void write_text_file(const char* path, const char* content)
{
FILE* f = fopen(path, "w");
TEST_ASSERT_NOT_NULL(f);
TEST_ASSERT_TRUE(fputs(content, f) >= 0);
fclose(f);
}
static char* read_whole_file(const char* path)
{
FILE* f = fopen(path, "rb");
long len;
char* buf;
TEST_ASSERT_NOT_NULL(f);
TEST_ASSERT_EQUAL_INT(0, fseek(f, 0, SEEK_END));
len = ftell(f);
TEST_ASSERT_TRUE(len >= 0);
rewind(f);
buf = (char*)malloc((size_t)len + 1);
TEST_ASSERT_NOT_NULL(buf);
if (len > 0) {
TEST_ASSERT_EQUAL_INT((int)len, (int)fread(buf, 1, (size_t)len, f));
}
buf[len] = '\0';
fclose(f);
return buf;
}
/* Same dup()/dup2()-around-STDOUT_FILENO capture technique
* test_sim_verify.c's own capture_stdout_around() establishes. */
static char* capture_stdout_around(void (*fn)(void))
{
char tmp[] = "/tmp/xce_replexec_stdoutcap_XXXXXX";
int fd = mkstemp(tmp);
int saved_stdout;
off_t len;
char* buf;
TEST_ASSERT_TRUE_MESSAGE(fd >= 0, "mkstemp for stdout capture must "
"succeed");
fflush(stdout);
saved_stdout = dup(STDOUT_FILENO);
TEST_ASSERT_TRUE_MESSAGE(saved_stdout >= 0, "dup(STDOUT_FILENO) must "
"succeed");
TEST_ASSERT_TRUE_MESSAGE(dup2(fd, STDOUT_FILENO) >= 0,
"dup2 redirect of STDOUT_FILENO must succeed");
fn();
fflush(stdout);
dup2(saved_stdout, STDOUT_FILENO);
close(saved_stdout);
len = lseek(fd, 0, SEEK_CUR);
TEST_ASSERT_TRUE(len >= 0);
buf = (char*)calloc(1, (size_t)len + 1);
TEST_ASSERT_NOT_NULL(buf);
TEST_ASSERT_TRUE(lseek(fd, 0, SEEK_SET) == 0);
if (len > 0) {
ssize_t nread = read(fd, buf, (size_t)len);
TEST_ASSERT_TRUE(nread == len);
}
close(fd);
unlink(tmp);
return buf;
}
/* ---------------------------------------------------------------------- */
/* scheduler-sim-repl-verbosity spec, task 2.1 -- RED-phase tests for the */
/* Round Rollup (design.md's component of that name): per-round decision */
/* summaries, collapsing of repetitive rounds, and the shared */
/* repl_round_collapse_flush() flush entry point (Requirements 2, 3). */
/* */
/* THIS TASK (2.1) IS RED-PHASE ONLY: repl_round_collapse_flush() does not */
/* exist anywhere in this codebase yet (task 2.2, a separate later task, */
/* implements it in repl.c and wires it into xce_repl_post_session_check()/*/
/* xce_repl_on_replay_complete()). Declaring it below as a local `extern` */
/* (same technique test_repl_output_compression.c's own header comment */
/* establishes for repl_fmt_jobid_range() before task 1.2 existed) makes */
/* test_round_collapse_flush_is_a_safe_noop_when_nothing_active() below */
/* fail this WHOLE FILE at LINK time (undefined reference) until task 2.2 */
/* lands -- exactly the same RED-phase shape task 1.1's own file took, and */
/* exactly what this task's own dispatch text calls out as valid evidence */
/* ("a build/link failure if you reference a new helper ... that doesn't */
/* exist yet"). Every other test below is a full end-to-end, forked-child, */
/* real-stdout-capture proof (same technique test_repl_execution_control.c's*/
/* own Tests 2/3 establish), since the Round Rollup's own boundary is */
/* behavioral, not a pure function -- those tests build and link fine */
/* today (they reference only already-existing symbols) but FAIL THEIR OWN */
/* ASSERTIONS at runtime, because today's REPL still prints the old */
/* unconditional per-decision echo with no summarizing/collapsing/flush */
/* behavior at all. */
/* */
/* Assumed output contract (design.md's Round Rollup component documents */
/* the fingerprint/collapse ALGORITHM and the repl_round_collapse_flush() */
/* service-interface contract, but not a byte-exact print format -- this */
/* comment fixes the literal format these tests pin, for task 2.2 to */
/* satisfy, mirroring test_repl_output_compression.c's own "Assumed output */
/* contract" precedent): */
/* */
/* - Every completed round is tracked as part of an "active" fingerprint */
/* range (dispatch/pend/preempt counts from the existing last_n_* */
/* tally, PLUS the current pend-jobid set queried directly from */
/* core->jobs for JOB_IS_PEND -- design.md's state-derived-pend-set */
/* decision, Requirement 2.4). A round whose fingerprint MATCHES the */
/* active range silently extends it (no print). A round whose */
/* fingerprint DIFFERS flushes (prints) the active range first, then */
/* begins tracking the new round as a fresh active range of its own */
/* (not yet printed -- print is always one step deferred until the */
/* range is known to have ended, via a later mismatch, a structural */
/* event/breakpoint hit (repl_break.c, task 3's own scope), or replay */
/* completion). */
/* - A NON-IDLE range (its fingerprint has at least one decision) is */
/* ALWAYS eventually flushed and printed, even if its own round count */
/* never exceeds 1 (Requirement 2.1's "one summary line" for a round */
/* with at least one decision). */
/* - An IDLE range (zero decisions, empty pend-jobid set) is printed */
/* ONLY once its own round count reaches 2 or more (Requirement 3.1); */
/* a genuinely isolated single idle round produces NO output at all, */
/* ever (Requirement 2.2's "shall not print an individual line"). */
/* - Print format, non-idle: "round <first>-<last> (<count> round(s), */
/* t=<first-ts-human>..<last-ts-human>): <D> dispatch, <P> pend, */
/* <X> preempt -- jobids=<repl_fmt_jobid_range() rendering>" (prefixed */
/* "[sim] ", this file family's universal convention). <first>/<last> */
/* are the range's bounding round numbers (rs->session_count values, */
/* 1-based, the same number `info session` reports); ts-human is */
/* repl_format_ts_human() applied to each bounding round's own */
/* begin_round value (Requirement 3.4's "covered time span"). */
/* - Print format, idle (count >= 2 only): identical bounds/count/span */
/* preamble, body "idle" instead of a decision-count/jobids clause. */
/* - Tests below use substring containment (strstr()), not full-line */
/* equality, wherever more than one job's identifier could appear in */
/* the same rendering -- repl_fmt_jobid_range()'s grouping order */
/* depends on core->jobs' own kvmgr iteration order, which these tests */
/* do not assume anything about beyond "every affected id appears */
/* somewhere in its own round's rendering." */
/* ---------------------------------------------------------------------- */
/*
* repl_round_collapse_flush (task 2.2, NOT YET IMPLEMENTED -- see this
* section's own header comment above). Signature copied verbatim from
* design.md's Round Rollup Service Interface.
*/
extern void repl_round_collapse_flush(xce_sched_sim_driver_t* sim);
/*
* append_job_state_change_event - same capnp-encode-one-ReplayEvent shape
* append_queue_update_event()/append_jobs_push_event() above establish,
* for a JobStateChangeEvent (controller.capnp, task 7.2) body. Used to
* mutate a job's state directly via the wire event core_events.c's
* XCE_CORE_EVENT_JOB_STATE_CHANGE handler applies -- WITHOUT ever routing
* through a live decision object, the exact mechanism this section's tests
* use to exercise Requirement 2.4's state-derived (not decision-tally-
* derived) pend-jobid set, independent of bug-1611.
*/
static void append_job_state_change_event(FILE* f, uint64_t ts,
uint64_t jobid, uint32_t old_state,
uint32_t new_state)
{
job_state_change_event_t change;
replay_event_t src;
struct capn c;
struct capn_segment* cs;
ReplayEvent_ptr p;
memset(&change, 0, sizeof(change));
change.jobid = jobid;
change.old_state = old_state;
change.new_state = new_state;
change.exit_code = 0;
memset(&src, 0, sizeof(src));
src.ts = ts;
src.body_which = ReplayEvent_body_jobStateChange;
src.body.job_state_change = &change;
capn_init_malloc(&c);
cs = capn_root(&c).seg;
encode_ReplayEvent_ptr(cs, &p, &src);
capn_setp(capn_root(&c), 0, p.p);
TEST_ASSERT_EQUAL_INT(0, write_capnp_message(f, &c));
capn_free(&c);
}
/* build_round_marker - the bounds+count PREFIX of this section's own
* pinned collapsed-range/round-summary format (see header comment above),
* e.g. build_round_marker(buf, sz, 1, 3) -> "round 1-3 (3 round(s)". Used
* as a strstr() needle -- deliberately stops short of the timestamp/
* decision-count/jobids tail, which individual tests check separately
* with their own needles. */
static void build_round_marker(char* out, size_t outsz, uint64_t start_round,
uint64_t end_round)
{
snprintf(out, outsz, "round %llu-%llu (%llu round(s)",
(unsigned long long)start_round, (unsigned long long)end_round,
(unsigned long long)(end_round - start_round + 1));
}
/* child_run_repl_and_exit / run_repl_fixture_and_capture - the same fork/
* freopen/waitpid/capture shape child_continue_then_inspect()/Test 2
* (test_repl_execution_control.c) establish, factored into one shared pair
* since this section's seven fixtures all follow the identical "run a
* scripted continue+quit to completion, capture real stdout" shape with
* nothing test-specific in the fork/capture plumbing itself -- only the
* replay fixture content and the post-hoc assertions differ per test. */
static void child_run_repl_and_exit(const char* replay_path,
const char* script_path,
const char* capture_path)
{
xce_sched_sim_driver_t sim;
sched_sim_args_t args;
if (freopen(script_path, "r", stdin) == NULL) {
_exit(120);
}
if (freopen(capture_path, "w", stdout) == NULL) {
_exit(121);
}
memset(&sim, 0, sizeof(sim));
memset(&args, 0, sizeof(args));
args.replay_path = replay_path;
args.sim_start_ts = SCHED_SIM_START_TS_LATEST;
args.sim_speed = 0;
args.interactive = true;
(void)sched_sim_driver_run(&sim, &args);
fflush(stdout);
_exit(111); /* unreachable -- the script's `quit` must already have
* exited */
}
static char* run_repl_fixture_and_capture(const char* replay_path,
const char* script,
const char* aux_suffix)
{
char aux_dir[PATH_MAX];
char script_path[PATH_MAX];
char capture_path[PATH_MAX];
pid_t pid;
int status;
make_tmp_dir(aux_dir, sizeof(aux_dir), aux_suffix);
snprintf(script_path, sizeof(script_path), "%s/script.txt", aux_dir);
snprintf(capture_path, sizeof(capture_path), "%s/capture.out", aux_dir);
write_text_file(script_path, script);
pid = fork();
TEST_ASSERT_TRUE_MESSAGE(pid >= 0, "fork() must succeed");
if (pid == 0) {
child_run_repl_and_exit(replay_path, script_path, capture_path);
_exit(112); /* unreachable -- child_run_repl_and_exit never returns */
}
TEST_ASSERT_EQUAL_INT_MESSAGE(pid, waitpid(pid, &status, 0),
"waitpid must reap the REPL child");
TEST_ASSERT_TRUE_MESSAGE(WIFEXITED(status),
"the REPL child must exit normally via quit's "
"exit(0)");
TEST_ASSERT_EQUAL_INT(0, WEXITSTATUS(status));
return read_whole_file(capture_path);
}
/* ---------------------------------------------------------------------- */
/* Test: a round with >=1 decision produces one summary line naming */
/* decision counts and the affected job's identifier (Requirement 2.1). */
/* ---------------------------------------------------------------------- */
static void test_round_with_decisions_prints_summary_with_counts_and_jobid(
void)
{
char replay_path[PATH_MAX];
FILE* f;
char* captured;
char jobid_x[64];
char round_marker[64];
f = write_header_and_snapshot(replay_path, sizeof(replay_path),
"_rrsingle");
TEST_ASSERT_NOT_NULL(f);
append_queue_update_event(f, 1000ULL, "normal");
append_jobs_push_event(f, 1500ULL, 5001ULL, "normal");
append_replay_session(f, 2000000000ULL); /* round 1: 1 pend (X) */
append_end_of_stream_marker(f);
fclose(f);
captured = run_repl_fixture_and_capture(replay_path, "continue\nquit\n",
"_rrsingleaux");
fmt_jobid(jobid_x, sizeof(jobid_x), 5001ULL);
build_round_marker(round_marker, sizeof(round_marker), 1, 1);
TEST_ASSERT_NOT_NULL_MESSAGE(
strstr(captured, round_marker),
"a round with a decision must be reported with its own round "
"bounds/count (Requirement 2.1)");
TEST_ASSERT_NOT_NULL_MESSAGE(
strstr(captured, "1 pend"),
"the round summary must name the decision-type count (Requirement "
"2.1)");
TEST_ASSERT_NOT_NULL_MESSAGE(
strstr(captured, jobid_x),
"the round summary must name the affected job's identifier "
"(Requirement 2.1)");
free(captured);
printf("test_round_with_decisions_prints_summary_with_counts_and_jobid: "
"PASS\n");
}
/* ---------------------------------------------------------------------- */
/* Test: a round with zero decisions produces no individual line, and two */
/* or more consecutive idle rounds collapse into a single range */
/* notification (Requirements 2.2, 3.1, 3.5). */
/* ---------------------------------------------------------------------- */
static void
test_consecutive_idle_rounds_collapse_and_suppress_individual_lines(void)
{
char replay_path[PATH_MAX];
FILE* f;
char* captured;
char jobid_x[64];
char idle_marker[64];
char round3_marker[64];
char* idle_pos;
char* round3_pos;
f = write_header_and_snapshot(replay_path, sizeof(replay_path),
"_rridle");
TEST_ASSERT_NOT_NULL(f);
append_queue_update_event(f, 1000ULL, "normal");
append_replay_session(f, 2000000000ULL); /* round 1: idle, no jobs yet */
append_replay_session(f, 3000000000ULL); /* round 2: idle too */
append_jobs_push_event(f, 3500000000ULL, 5002ULL, "normal");
append_replay_session(f, 4000000000ULL); /* round 3: 1 pend (X) */
append_end_of_stream_marker(f);
fclose(f);
captured = run_repl_fixture_and_capture(replay_path, "continue\nquit\n",
"_rridleaux");
fmt_jobid(jobid_x, sizeof(jobid_x), 5002ULL);
build_round_marker(idle_marker, sizeof(idle_marker), 1, 2);
build_round_marker(round3_marker, sizeof(round3_marker), 3, 3);
idle_pos = strstr(captured, idle_marker);
round3_pos = strstr(captured, round3_marker);
TEST_ASSERT_NOT_NULL_MESSAGE(
idle_pos, "two consecutive idle rounds must collapse into ONE "
"range notification covering rounds 1-2 (Requirement "
"3.1)");
TEST_ASSERT_NOT_NULL_MESSAGE(
round3_pos, "round 3's own decision must still be reported once "
"the idle streak ends (Requirement 2.1)");
TEST_ASSERT_TRUE_MESSAGE(
idle_pos < round3_pos,
"the idle range must be flushed and printed BEFORE round 3's own "
"line is eventually reported (Requirement 3.5)");
TEST_ASSERT_NULL_MESSAGE(
strstr(captured, "round 1-1"),
"round 1 must never be reported as its own individual line -- "
"zero-decision rounds produce no individual line (Requirement "
"2.2)");
TEST_ASSERT_NULL_MESSAGE(
strstr(captured, "round 2-2"),
"round 2 must never be reported as its own individual line either "
"(Requirement 2.2)");
TEST_ASSERT_NOT_NULL_MESSAGE(strstr(captured, jobid_x),
"round 3's summary must name its own "
"affected job (Requirement 2.1)");
free(captured);
printf("test_consecutive_idle_rounds_collapse_and_suppress_individual_"
"lines: PASS\n");
}
/* ---------------------------------------------------------------------- */
/* Test: two or more consecutive rounds with an identical nonzero decision */
/* outcome collapse into a single range notification that states its */
/* round bounds, round count, and covered time span (Requirements 3.2, */
/* 3.3, 3.4). */
/* ---------------------------------------------------------------------- */
static void
test_identical_nonzero_outcome_rounds_collapse_with_bounds_count_and_span(
void)
{
char replay_path[PATH_MAX];
FILE* f;
char* captured;
char jobid_x[64];
char round_marker[64];
char ts_start_human[32];
char ts_end_human[32];
f = write_header_and_snapshot(replay_path, sizeof(replay_path),
"_rrspan");
TEST_ASSERT_NOT_NULL(f);
append_queue_update_event(f, 1000ULL, "normal");
append_jobs_push_event(f, 1500ULL, 5003ULL, "normal");
append_replay_session(f, 2000000000ULL); /* round 1: 1 pend (X) */
append_replay_session(f, 3000000000ULL); /* round 2: same outcome */
append_replay_session(f, 4000000000ULL); /* round 3: same outcome again */
append_jobs_push_event(f, 4500000000ULL, 5004ULL, "normal");
append_replay_session(f, 5000000000ULL); /* round 4: outcome changes */
append_end_of_stream_marker(f);
fclose(f);
captured = run_repl_fixture_and_capture(replay_path, "continue\nquit\n",
"_rrspanaux");
fmt_jobid(jobid_x, sizeof(jobid_x), 5003ULL);
build_round_marker(round_marker, sizeof(round_marker), 1, 3);
repl_format_ts_human(2000000000ULL, ts_start_human,
sizeof(ts_start_human));
repl_format_ts_human(4000000000ULL, ts_end_human, sizeof(ts_end_human));
TEST_ASSERT_NOT_NULL_MESSAGE(
strstr(captured, round_marker),
"three consecutive rounds sharing the same nonzero decision "
"outcome must collapse into ONE range covering rounds 1-3, "
"stating the round count (Requirement 3.2, 3.3)");
TEST_ASSERT_NOT_NULL_MESSAGE(
strstr(captured, ts_start_human),
"the collapsed range must state the covered time span's START "
"(Requirement 3.4)");
TEST_ASSERT_NOT_NULL_MESSAGE(
strstr(captured, ts_end_human),
"the collapsed range must state the covered time span's END "
"(Requirement 3.4)");
TEST_ASSERT_NOT_NULL_MESSAGE(
strstr(captured, jobid_x),
"the collapsed range must still name the affected job (Requirement "
"2.1, applied to the collapsed range)");
free(captured);
printf(
"test_identical_nonzero_outcome_rounds_collapse_with_bounds_count_"
"and_span: PASS\n");
}
/* ---------------------------------------------------------------------- */
/* Test: a change in decision outcome ends the active collapsed range and */
/* reports it before the new outcome's own content (Requirement 3.5). */
/* ---------------------------------------------------------------------- */
static void test_change_in_outcome_ends_active_collapsed_range(void)
{
char replay_path[PATH_MAX];
FILE* f;
char* captured;
char round1_marker[64];
char round2_marker[64];
char* round1_pos;
char* round2_pos;
f = write_header_and_snapshot(replay_path, sizeof(replay_path),
"_rrchange");
TEST_ASSERT_NOT_NULL(f);
append_queue_update_event(f, 1000ULL, "normal");
append_jobs_push_event(f, 1500ULL, 5005ULL, "normal");
append_replay_session(f, 2000000000ULL); /* round 1: 1 pend (X) */
append_jobs_push_event(f, 2500000000ULL, 5006ULL, "normal");
append_replay_session(f, 3000000000ULL); /* round 2: 2 pend (X,Y) --
* a DIFFERENT outcome */
append_end_of_stream_marker(f);
fclose(f);
captured = run_repl_fixture_and_capture(replay_path, "continue\nquit\n",
"_rrchangeaux");
build_round_marker(round1_marker, sizeof(round1_marker), 1, 1);
build_round_marker(round2_marker, sizeof(round2_marker), 2, 2);
round1_pos = strstr(captured, round1_marker);
round2_pos = strstr(captured, round2_marker);
TEST_ASSERT_NOT_NULL_MESSAGE(
round1_pos, "round 1's outcome (1 pend) must be reported once its "
"own distinct streak ends (Requirement 2.1)");
TEST_ASSERT_NOT_NULL_MESSAGE(
round2_pos, "round 2's DIFFERENT outcome (2 pend) must be reported "
"as its own entry (Requirement 2.1)");
TEST_ASSERT_TRUE_MESSAGE(
round1_pos < round2_pos,
"a change in decision outcome must END and flush the active "
"collapsed range BEFORE the new round's own content is reported "
"(Requirement 3.5)");
free(captured);
printf("test_change_in_outcome_ends_active_collapsed_range: PASS\n");
}
/* ---------------------------------------------------------------------- */
/* Test: a job's tracked status change between rounds is reflected in the */
/* FOLLOWING round's summary even though no dispatch decision is ever */
/* produced for it anywhere (this simulator's own picker thread never */
/* truly dispatches, sim_loop.c's own task-11.2 documented scope */
/* boundary) -- exercises design.md's state-derived (not decision-tally- */
/* derived) pend-jobid set, independent of bug-1611 (Requirement 2.4). */
/* ---------------------------------------------------------------------- */
static void
test_job_status_change_reflected_in_following_round_without_dispatch_event(
void)
{
char replay_path[PATH_MAX];
FILE* f;
char* captured;
char jobid_x[64];
char jobid_y[64];
char round2_marker[64];
char* round2_pos;
f = write_header_and_snapshot(replay_path, sizeof(replay_path),
"_rrstatechg");
TEST_ASSERT_NOT_NULL(f);
append_queue_update_event(f, 1000ULL, "normal");
append_jobs_push_event(f, 1500ULL, 5007ULL, "normal"); /* X */
append_jobs_push_event(f, 1600ULL, 5008ULL, "normal"); /* Y */
append_replay_session(f, 2000000000ULL); /* round 1: 2 pend (X,Y) */
/* X leaves PEND state via a bare state-change notification -- no
* dispatch decision is ever produced anywhere for X. */
append_job_state_change_event(f, 2500000000ULL, 5007ULL, JOB_STAT_PEND,
JOB_STAT_RUN);
append_replay_session(f, 3000000000ULL); /* round 2: only Y still pend */
append_end_of_stream_marker(f);
fclose(f);
captured = run_repl_fixture_and_capture(replay_path, "continue\nquit\n",
"_rrstatechgaux");
fmt_jobid(jobid_x, sizeof(jobid_x), 5007ULL);
fmt_jobid(jobid_y, sizeof(jobid_y), 5008ULL);
build_round_marker(round2_marker, sizeof(round2_marker), 2, 2);
round2_pos = strstr(captured, round2_marker);
TEST_ASSERT_NOT_NULL_MESSAGE(
strstr(captured, jobid_x),
"round 1's summary must still name X while it was pending");
TEST_ASSERT_NOT_NULL_MESSAGE(
round2_pos, "round 2's (now different) outcome must be reported "
"once round 1's streak ends (Requirement 2.1)");
TEST_ASSERT_NOT_NULL_MESSAGE(
strstr(round2_pos, jobid_y),
"round 2's summary must name Y, still pending (Requirement 2.1)");
TEST_ASSERT_NULL_MESSAGE(
strstr(round2_pos, jobid_x),
"round 2's summary must NOT name X any more -- its pending status "
"changed via a bare JOB_STATE_CHANGE with no dispatch decision "
"ever produced for it, yet the round summary must still reflect "
"the change (Requirement 2.4, design.md's state-derived pend-set "
"decision)");
free(captured);
printf(
"test_job_status_change_reflected_in_following_round_without_"
"dispatch_event: PASS\n");
}
/* ---------------------------------------------------------------------- */
/* Test: repl_round_collapse_flush() is a safe no-op when no range is */
/* active, and calling it twice in a row prints nothing either time */
/* (design.md's Round Rollup Service Interface -- Requirement 3's shared */
/* flush capability). */
/* ---------------------------------------------------------------------- */
static xce_sched_sim_driver_t* g_round_rollup_flush_sim;
static void call_round_collapse_flush_twice(void)
{
repl_round_collapse_flush(g_round_rollup_flush_sim);
repl_round_collapse_flush(g_round_rollup_flush_sim);
}
static void test_round_collapse_flush_is_a_safe_noop_when_nothing_active(
void)
{
xce_sched_sim_driver_t sim;
char* captured;
memset(&sim, 0, sizeof(sim));
sim.interactive = true;
sim.repl_state = repl_state_ensure(&sim);
TEST_ASSERT_NOT_NULL(sim.repl_state);
g_round_rollup_flush_sim = &sim;
captured = capture_stdout_around(
call_round_collapse_flush_twice);
TEST_ASSERT_EQUAL_STRING_MESSAGE(
"", captured,
"repl_round_collapse_flush() must print nothing when no collapsed "
"range is active, and calling it twice in a row must not print "
"anything either time");
free(captured);
free(sim.repl_state);
printf(
"test_round_collapse_flush_is_a_safe_noop_when_nothing_active: "
"PASS\n");
}
/* ---------------------------------------------------------------------- */
/* Test: an active collapsed range still open at replay completion is */
/* flushed and printed BEFORE xce_repl_on_replay_complete()'s existing */
/* completion banner (Requirement 3.6). */
/* ---------------------------------------------------------------------- */
static void
test_active_collapsed_range_flushed_before_replay_complete_banner(void)
{
char replay_path[PATH_MAX];
FILE* f;
char* captured;
char jobid_x[64];
char round_marker[64];
char* round_pos;
char* banner_pos;
f = write_header_and_snapshot(replay_path, sizeof(replay_path),
"_rrcomplete");
TEST_ASSERT_NOT_NULL(f);
append_queue_update_event(f, 1000ULL, "normal");
append_jobs_push_event(f, 1500ULL, 5009ULL, "normal");
append_replay_session(f, 2000000000ULL); /* round 1: 1 pend (X) */
append_replay_session(f, 3000000000ULL); /* round 2: same outcome --
* still active, no round 3
* ever arrives to force a
* flush */
append_end_of_stream_marker(f);
fclose(f);
captured = run_repl_fixture_and_capture(replay_path, "continue\nquit\n",
"_rrcompleteaux");
fmt_jobid(jobid_x, sizeof(jobid_x), 5009ULL);
build_round_marker(round_marker, sizeof(round_marker), 1, 2);
round_pos = strstr(captured, round_marker);
banner_pos = strstr(captured, "[sim] replay complete.");
TEST_ASSERT_NOT_NULL_MESSAGE(
round_pos, "the still-open collapsed range (rounds 1-2) must be "
"flushed at replay completion (Requirement 3.6)");
TEST_ASSERT_NOT_NULL_MESSAGE(banner_pos,
"replay completion must still print its "
"existing banner");
TEST_ASSERT_TRUE_MESSAGE(
round_pos < banner_pos,
"an active collapsed range open at replay completion must be "
"flushed and printed BEFORE xce_repl_on_replay_complete()'s "
"existing completion banner (Requirement 3.6)");
TEST_ASSERT_NOT_NULL_MESSAGE(strstr(captured, jobid_x),
"the flushed range must still name its "
"affected job");
free(captured);
printf(
"test_active_collapsed_range_flushed_before_replay_complete_"
"banner: PASS\n");
}
int main(void)
{
UNITY_BEGIN();
RUN_TEST(test_round_with_decisions_prints_summary_with_counts_and_jobid);
RUN_TEST(
test_consecutive_idle_rounds_collapse_and_suppress_individual_lines);
RUN_TEST(
test_identical_nonzero_outcome_rounds_collapse_with_bounds_count_and_span);
RUN_TEST(test_change_in_outcome_ends_active_collapsed_range);
RUN_TEST(
test_job_status_change_reflected_in_following_round_without_dispatch_event);
RUN_TEST(test_round_collapse_flush_is_a_safe_noop_when_nothing_active);
RUN_TEST(
test_active_collapsed_range_flushed_before_replay_complete_banner);
return UNITY_END();
}
Reference in a new issue View git blame Copy permalink