Rongsong Shen
c9acd502c0
Bugs fixed, discovered across a day of live-operator testing against a real deployed cluster: - bug-1584: clock anchors never initialized to real wall-clock values, timestamps showed system uptime instead of Unix epoch. - bug-1585: heap-use-after-free in the normal-mode driver's periodic resval update path -- core_events.c's RESVALS_FULL/_DELTA handlers do a shallow zarray_put() of the wire-decoded xce_val_t*, but driver.c's release_translated_payload() unconditionally freed the same decoded array right after, so the next periodic report for the same worker+resource triggered a UAF read via kill_sched_resval(). New regression test: test_resval_ownership.c. - bug-1587/1588/1591: raw-ns/raw-uint64 jobid/timestamp prints across the REPL/SIM family converted to the same human-readable formatting already used elsewhere (fmt_jobid(), timestamp formatting). - bug-1590: repl_info.c's XCE_VAL_NUMERIC checks corrected to Value_u_fvalue, fixing `info worker`/`info resource` falling back to 0.00 for real numeric resvals. task 12.5 (Req 5.22 amendment) -- five REPL gaps surfaced by a live operator session, each with its own bug id: - bug-1594: `continue`/`step` reaching EOF with no breakpoint hit now re-enters the REPL via xce_repl_on_replay_complete() instead of exiting the process; step/continue issued after replay is already complete re-prompt instead of silently exiting. - bug-1595: `step`/`continue` now echo each input event (not just decisions) via repl_print_event_summary(), in real event/decision order. - bug-1593: `info resource <name>|all` now reports resource definition metadata restricted to XCE_RESF_GLOBAL/XCE_RESF_SHARED resources, read from core->sharedInst, instead of aggregating host-based resources across every worker. - bug-1596: repl_split_tokens() strips one matching pair of surrounding quote characters from each token. See requirements.md's Req 5 AC 22 "Amendment (2026-08-19)" for the full rationale on each of the five task 12.5 gaps. Full scheduler suite green (41/42; the one remaining failure, test_recordstart_symlink_escape_replies_error, is the pre-existing unrelated bug-1560).
709 lines
28 KiB
C
709 lines
28 KiB
C
/*
|
|
* test_repl_equivalence.c - REPL step/continue-to-completion vs batch
|
|
* simulation equivalence test (scheduler-core spec, task 12.4, Req 5 AC 22).
|
|
*
|
|
* This is NOT task 11.6's own regression test (test_sim_equivalence.c),
|
|
* which compares the NORMAL-mode driver against the SIMULATION driver. This
|
|
* task compares the SAME simulation driver (sched_sim_driver_run(),
|
|
* sim_loop.c) against itself, run twice against the SAME `.replay` fixture
|
|
* file, differing ONLY in `sim->interactive` -- once driven by a scripted
|
|
* `step`/`continue` REPL session (stdin freopen()'d from a script file, the
|
|
* SAME mechanism test_repl_execution_control.c's own Test 2/Test 3
|
|
* establish), once run straight through in batch mode. This is the exact
|
|
* empirical claim design.md's SimDriver "Invariants" section and
|
|
* requirements.md's Req 5 AC 22 "Deterministic replay is preserved"
|
|
* paragraph make: "The REPL never alters core state or event stream. It
|
|
* only controls *when* events are processed (by pausing), not *what* events
|
|
* are processed ... Interactive use with `step` and `continue` that runs to
|
|
* completion produces the same output as `--sim` without `--interactive`."
|
|
*
|
|
* Fixture (a genuine, non-trivial, PEND-only sequence -- see
|
|
* test_sim_equivalence.c's own header comment for why every decision the
|
|
* simulation driver can produce today is PEND, never DISPATCH:
|
|
* sim_picker_thread_fn()'s documented, out-of-this-task's-scope gap): TWO
|
|
* queues at different priorities ("high"=5, "normal"=1, forcing the real
|
|
* builtin_fcfs cross-queue priority ordering to run for real) and FOUR jobs
|
|
* split across THREE separate ReplaySession boundaries (2 jobs before
|
|
* session 1, one more before session 2, one more before session 3) -- the
|
|
* multi-session shape matters here specifically (unlike task 11.6's
|
|
* single-session fixture) because a `step 1` / `continue` script needs more
|
|
* than one session boundary to exercise both commands meaningfully.
|
|
*
|
|
* Capture mechanism: both runs set `sched_sim_args_t.output_path`
|
|
* (--sim-output, task 11.5) directly -- unconditional on `interactive`
|
|
* (confirmed by reading sim.c's sched_sim_driver_start(): the
|
|
* `args->output_path != NULL` -> fopen() gate has no interactive check) --
|
|
* so no `set output` REPL command is needed; both runs simply write their
|
|
* own full `.replay`-format decision stream to their own file, exactly like
|
|
* test_sim_equivalence.c's own file S. Since this fixture has THREE
|
|
* ReplaySession boundaries (not task 11.6's one), decoding cannot reuse that
|
|
* file's fixed-skip-count technique (N_MSGS_BEFORE_SESSION) -- this file's
|
|
* own decode_all_sessions() instead scans the whole output file structurally
|
|
* via sim.c's shared msg_root_has_shape() (ReplaySession's own distinct
|
|
* (1,2) word/pointer-count shape, per that function's own header comment),
|
|
* decoding every ReplaySession-shaped message in file order and skipping
|
|
* every other shape -- robust regardless of exactly how many ReplayEvent
|
|
* pass-through messages land between sessions on either side.
|
|
*
|
|
* Comparator: reuses sim_verify.c's own leaf-level structural comparators
|
|
* (sim_verify_job_alloc_eq()/sim_verify_job_preason_eq(), both `static` but
|
|
* visible in this TU via the white-box #include below), the same technique
|
|
* test_sim_equivalence.c's own replay_decision_content_eq() already
|
|
* establishes -- duplicated here (this file family's own established
|
|
* per-file-duplication convention; no shared test-utility header exists
|
|
* across this directory) rather than imported.
|
|
*
|
|
* Script design ("step 1\ncontinue\n", exactly 2 lines, regardless of how
|
|
* many sessions the fixture has): the pre-replay pause consumes "step 1"
|
|
* (mode=STEP, budget=1) -> session 1 runs -> post-session pause (budget
|
|
* reaches 0) consumes "continue" (mode=CONTINUE) -> every remaining session
|
|
* (2 and 3 here) runs to EOF with no further stdin read at all
|
|
* (repl_should_pause() returns false unconditionally in CONTINUE mode,
|
|
* repl.c). This exercises BOTH `step` and `continue` (task 12.4's own
|
|
* literal text: "using step/continue to completion") while staying safe
|
|
* against ever exhausting the script file and hitting readline()'s NULL/EOF
|
|
* path (which calls repl_cmd_quit() -> exit(0) and would kill this whole
|
|
* in-process test binary, not just the one test) -- CONTINUE mode, once
|
|
* entered, never reads stdin again no matter how many sessions remain.
|
|
*
|
|
* Why the RED-phase probe targets xce_repl_on_event(), not
|
|
* repl_should_pause(): task 12.1's own already-verified RED-phase probe
|
|
* (tasks.md) defeated repl_should_pause() (`return false;` instead of the
|
|
* real budget check) to prove `step N` pauses at the right session. That
|
|
* probe changes ONLY *when* stdin is read/control is regained -- it does
|
|
* NOT change *what* gets processed or in what order, so it would NOT turn
|
|
* THIS test's final decision-sequence comparison red (a genuinely
|
|
* reassuring, independently-confirmed fact about this architecture, not a
|
|
* gap in this test): every session still eventually runs to EOF regardless
|
|
* of pause timing, and this file's script already tolerates any pause
|
|
* schedule via CONTINUE's sticky non-pausing behavior. The correct
|
|
* synthetic probe for THIS specific invariant ("never alters ... what
|
|
* events are processed") has to touch a hook that can affect *content*, and
|
|
* only under `sim->interactive`: xce_repl_on_event(xce_sched_sim_driver_t*,
|
|
* xce_core_event_t* ev) (repl_break.c) takes a non-const `ev` and is called
|
|
* (sim_loop.c, via repl.h's xce_repl_check_event() wrapper, gated on
|
|
* `sim->interactive`) strictly BEFORE the event is appended to the
|
|
* accumulated batch that xce_core_push_events() later applies -- so a
|
|
* one-line mutation there (corrupting a JOBS_PUSH job's jobid, batch mode
|
|
* never calls this hook at all) is a real, load-bearing content divergence
|
|
* between the REPL run and the batch run, exactly the failure mode task
|
|
* 12.4 exists to catch. See this task's own tasks.md `_Verified:` entry for
|
|
* the actual probe text and observed failing test output.
|
|
*
|
|
* White-box #include set: identical to test_repl_execution_control.c's own
|
|
* (core.c, core_clock.c, core_events.c, core_session.c, decision.c,
|
|
* plugin.c, plugins/builtin_fcfs.c, recording.c, recording_session.c,
|
|
* repl.c, repl_break.c, repl_info.c, repl_params.c, sim.c, sim_loop.c,
|
|
* sim_record.c, sim_verify.c, snapshot.c, snapshot_load.c, snapshot_wire.c)
|
|
* -- no driver.c/recording_events.c: unlike test_sim_equivalence.c, this
|
|
* file never drives a real normal-mode recording session; both runs are
|
|
* pure simulation-driver replays of one hand-built fixture file, so it only
|
|
* needs the sim+repl stack, not the normal-mode driver stack.
|
|
*/
|
|
#include <errno.h>
|
|
#include <limits.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_sim_equivalence.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_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; }
|
|
|
|
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;
|
|
}
|
|
|
|
/* Real reimplementation of schedobj.c's sched_resolve_job_picker -- same
|
|
* copy every white-box test in this directory that does not link
|
|
* schedobj.c already establishes (test_repl_execution_control.c,
|
|
* test_sim_equivalence.c, etc.). */
|
|
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 -- same techniques test_repl_execution_control.c/ */
|
|
/* test_sim_equivalence.c already establish. */
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
static void make_tmp_dir(char* out, size_t out_len, const char* suffix)
|
|
{
|
|
char tmpl[PATH_MAX];
|
|
|
|
snprintf(tmpl, sizeof(tmpl), "/tmp/sched_replequiv%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;
|
|
}
|
|
|
|
/* Same as test_repl_execution_control.c's own helper, extended with a
|
|
* `priority` parameter (this file's own fixture needs two queues at
|
|
* different priorities, matching test_sim_equivalence.c's cross-queue
|
|
* ordering fixture, not the single fixed priority=1 that file's own
|
|
* single-queue fixture needed). */
|
|
static void append_queue_update_event(FILE* f, uint64_t ts,
|
|
const char* queue_name,
|
|
int32_t priority)
|
|
{
|
|
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 = priority;
|
|
|
|
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);
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
/* Decoding + comparison */
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* decode_all_sessions - scans `path` end to end, decoding every
|
|
* ReplaySession-shaped message (sim.c's own shared msg_root_has_shape(),
|
|
* ReplaySession's distinct (1,2) word/pointer-count shape) into a growable
|
|
* array, in file order, skipping every other message shape (ReplayHeader/
|
|
* SnapshotEntry/ReplayEvent). Unlike test_sim_equivalence.c's
|
|
* decode_session_after_skip() (a fixed skip count valid for exactly ONE
|
|
* ReplaySession), this file's fixture has THREE session boundaries, so a
|
|
* structural scan is used instead of a hardcoded message-index -- also
|
|
* robust against neither side needing to hand-count how many ReplayEvent
|
|
* pass-through messages precede each session (an implementation detail this
|
|
* test correctly does not otherwise care about).
|
|
*/
|
|
static void decode_all_sessions(const char* path, replay_session_t*** out,
|
|
int* out_count)
|
|
{
|
|
FILE* f = fopen(path, "r");
|
|
replay_session_t** sessions = NULL;
|
|
int count = 0;
|
|
|
|
TEST_ASSERT_NOT_NULL(f);
|
|
|
|
for (;;) {
|
|
struct capn c;
|
|
capn_ptr root;
|
|
|
|
if (capn_init_fp(&c, f, 0) != 0) {
|
|
break; /* EOF */
|
|
}
|
|
|
|
if (msg_root_has_shape(&c, &root, ReplaySession_word_count,
|
|
ReplaySession_pointer_count)) {
|
|
ReplaySession_ptr sp;
|
|
replay_session_t* decoded = NULL;
|
|
replay_session_t** grown;
|
|
|
|
sp.p = root;
|
|
decode_ReplaySession_ptr(&decoded, sp);
|
|
capn_free(&c);
|
|
|
|
TEST_ASSERT_NOT_NULL(decoded);
|
|
|
|
grown = (replay_session_t**)realloc(
|
|
sessions, (size_t)(count + 1) * sizeof(*sessions));
|
|
TEST_ASSERT_NOT_NULL(grown);
|
|
sessions = grown;
|
|
sessions[count] = decoded;
|
|
count++;
|
|
continue;
|
|
}
|
|
|
|
capn_free(&c);
|
|
}
|
|
|
|
fclose(f);
|
|
|
|
*out = sessions;
|
|
*out_count = count;
|
|
}
|
|
|
|
static void free_all_sessions(replay_session_t** sessions, int count)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
free_ReplaySession_ptr(&(sessions[i]));
|
|
}
|
|
free(sessions);
|
|
}
|
|
|
|
/*
|
|
* replay_decision_content_eq - structural equality between two DECODED
|
|
* ReplayDecision entries (batch's vs the REPL's own, at the same session
|
|
* and position). Same technique test_sim_equivalence.c's own function of
|
|
* the same name establishes (delegating to sim_verify.c's leaf comparators,
|
|
* duplicated here per this file family's own no-shared-header convention --
|
|
* see this file's header comment).
|
|
*/
|
|
static int replay_decision_content_eq(const replay_decision_t* a,
|
|
const replay_decision_t* b)
|
|
{
|
|
if ((a == NULL) || (b == NULL)) {
|
|
return 0;
|
|
}
|
|
if (a->body_which != b->body_which) {
|
|
return 0;
|
|
}
|
|
|
|
switch (a->body_which) {
|
|
case ReplayDecision_body_dispatch:
|
|
if ((a->body.dispatch == NULL) || (b->body.dispatch == NULL)) {
|
|
return 0;
|
|
}
|
|
return sim_verify_job_alloc_eq(a->body.dispatch->alloc,
|
|
b->body.dispatch->alloc);
|
|
|
|
case ReplayDecision_body_pend:
|
|
if ((a->body.pend == NULL) || (b->body.pend == NULL)) {
|
|
return 0;
|
|
}
|
|
return (a->body.pend->jobid == b->body.pend->jobid)
|
|
&& sim_verify_job_preason_eq(a->body.pend->reason,
|
|
b->body.pend->reason);
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
/* The central regression test (task 12.4's own Observable). */
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
static void
|
|
test_repl_step_continue_to_completion_matches_batch_decision_sequence(void)
|
|
{
|
|
char fixture_path[PATH_MAX];
|
|
char script_dir[PATH_MAX];
|
|
char script_path[PATH_MAX];
|
|
char batch_out_path[PATH_MAX];
|
|
char repl_out_path[PATH_MAX];
|
|
int batch_fd;
|
|
int repl_fd;
|
|
FILE* f;
|
|
xce_sched_sim_driver_t sim_batch;
|
|
xce_sched_sim_driver_t sim_repl;
|
|
sched_sim_args_t args_batch;
|
|
sched_sim_args_t args_repl;
|
|
replay_session_t** batch_sessions = NULL;
|
|
replay_session_t** repl_sessions = NULL;
|
|
int n_batch = 0;
|
|
int n_repl = 0;
|
|
int total_batch_decisions;
|
|
int saw_jobid_501;
|
|
int rc;
|
|
int i;
|
|
int j;
|
|
|
|
/* ---- Build ONE `.replay` fixture: two queues at different
|
|
* priorities, four jobs split across three ReplaySession boundaries --
|
|
* this file's own header comment explains why three sessions matter
|
|
* here (task 11.6's own single-session fixture would not exercise both
|
|
* `step` and `continue`). ---- */
|
|
f = write_header_and_snapshot(fixture_path, sizeof(fixture_path),
|
|
"_fixture");
|
|
TEST_ASSERT_NOT_NULL(f);
|
|
|
|
append_queue_update_event(f, 1000ULL, "high", 5);
|
|
append_queue_update_event(f, 1001ULL, "normal", 1);
|
|
|
|
append_jobs_push_event(f, 1500ULL, 501ULL, "high");
|
|
append_jobs_push_event(f, 1501ULL, 502ULL, "normal");
|
|
append_replay_session(f, 2000ULL); /* session 1 */
|
|
|
|
append_jobs_push_event(f, 2500ULL, 503ULL, "high");
|
|
append_replay_session(f, 3000ULL); /* session 2 */
|
|
|
|
append_jobs_push_event(f, 3500ULL, 504ULL, "normal");
|
|
append_replay_session(f, 4000ULL); /* session 3 */
|
|
|
|
append_end_of_stream_marker(f);
|
|
fclose(f);
|
|
|
|
/* ---- Run 1: batch mode (interactive=false), straight through, no
|
|
* stdin involvement at all. ---- */
|
|
snprintf(batch_out_path, sizeof(batch_out_path),
|
|
"/tmp/xce_replequiv_batch_XXXXXX");
|
|
batch_fd = mkstemp(batch_out_path);
|
|
TEST_ASSERT_TRUE(batch_fd >= 0);
|
|
close(batch_fd);
|
|
|
|
memset(&sim_batch, 0, sizeof(sim_batch));
|
|
memset(&args_batch, 0, sizeof(args_batch));
|
|
args_batch.replay_path = fixture_path;
|
|
args_batch.sim_start_ts = SCHED_SIM_START_TS_LATEST;
|
|
args_batch.sim_speed = 0; /* frozen -- deterministic, no wall-clock
|
|
* skew, matching every other equivalence
|
|
* fixture in this directory */
|
|
args_batch.output_path = batch_out_path;
|
|
args_batch.interactive = false;
|
|
|
|
rc = sched_sim_driver_run(&sim_batch, &args_batch);
|
|
TEST_ASSERT_EQUAL_INT(0, rc);
|
|
|
|
/* ---- Run 2: the SAME fixture, driven via the REPL's step/continue
|
|
* command loop to completion (see this file's header comment for why
|
|
* exactly "step 1\ncontinue\n" is both sufficient and safe against ever
|
|
* exhausting the script). ---- */
|
|
snprintf(repl_out_path, sizeof(repl_out_path),
|
|
"/tmp/xce_replequiv_repl_XXXXXX");
|
|
repl_fd = mkstemp(repl_out_path);
|
|
TEST_ASSERT_TRUE(repl_fd >= 0);
|
|
close(repl_fd);
|
|
|
|
make_tmp_dir(script_dir, sizeof(script_dir), "_script");
|
|
snprintf(script_path, sizeof(script_path), "%s/script.txt", script_dir);
|
|
/* task 12.5 (bug-1594): trailing `quit` -- `continue` now re-enters
|
|
* the REPL at replay completion instead of returning, so this side
|
|
* must run in a FORKED child (matching test_repl_execution_control.c's
|
|
* own Test 3 pattern); otherwise quit's exit(0) would tear down this
|
|
* whole test binary before the batch-vs-REPL comparison below ever
|
|
* runs. */
|
|
write_text_file(script_path, "step 1\ncontinue\nquit\n");
|
|
|
|
memset(&args_repl, 0, sizeof(args_repl));
|
|
args_repl.replay_path = fixture_path;
|
|
args_repl.sim_start_ts = SCHED_SIM_START_TS_LATEST;
|
|
args_repl.sim_speed = 0;
|
|
args_repl.output_path = repl_out_path;
|
|
args_repl.interactive = true;
|
|
|
|
{
|
|
pid_t pid = fork();
|
|
int status;
|
|
|
|
TEST_ASSERT_TRUE_MESSAGE(pid >= 0, "fork() must succeed");
|
|
|
|
if (pid == 0) {
|
|
if (freopen(script_path, "r", stdin) == NULL) {
|
|
_exit(120);
|
|
}
|
|
memset(&sim_repl, 0, sizeof(sim_repl));
|
|
(void)sched_sim_driver_run(&sim_repl, &args_repl);
|
|
_exit(111); /* unreachable -- quit must already have exited */
|
|
}
|
|
|
|
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), not crash/signal");
|
|
TEST_ASSERT_EQUAL_INT_MESSAGE(0, WEXITSTATUS(status),
|
|
"quit's exit(0) is the only correct "
|
|
"exit path");
|
|
}
|
|
|
|
/* ---- Decode every ReplaySession from both output files and compare
|
|
* the decision sequence, session by session, decision by decision. ---- */
|
|
decode_all_sessions(batch_out_path, &batch_sessions, &n_batch);
|
|
decode_all_sessions(repl_out_path, &repl_sessions, &n_repl);
|
|
|
|
TEST_ASSERT_EQUAL_INT_MESSAGE(3, n_batch,
|
|
"the fixture pushes exactly 3 "
|
|
"ReplaySession boundaries");
|
|
TEST_ASSERT_EQUAL_INT_MESSAGE(n_batch, n_repl,
|
|
"REPL step/continue-to-completion must "
|
|
"produce the SAME number of sessions as "
|
|
"batch mode");
|
|
|
|
/* Non-tautology guard #1: session 1 has EXACTLY 2 pending candidates
|
|
* (jobs 501/502) and nothing else could possibly be pending yet -- an
|
|
* unambiguous floor independent of whether a PEND'd job persists as a
|
|
* candidate into later sessions. */
|
|
TEST_ASSERT_EQUAL_INT(2, batch_sessions[0]->n_decisions);
|
|
|
|
/* Non-tautology guard #2: independently pin real decision CONTENT (not
|
|
* merely "both sides agree", which a shared bug in both runs could
|
|
* satisfy too) -- job 501 must appear as a PEND decision somewhere in
|
|
* session 1 on the batch side. */
|
|
saw_jobid_501 = 0;
|
|
for (j = 0; j < batch_sessions[0]->n_decisions; j++) {
|
|
replay_decision_t* d = batch_sessions[0]->decisions[j];
|
|
|
|
TEST_ASSERT_EQUAL_INT((int)ReplayDecision_body_pend,
|
|
(int)d->body_which);
|
|
if ((d->body.pend != NULL) && (d->body.pend->jobid == 501ULL)) {
|
|
saw_jobid_501 = 1;
|
|
}
|
|
}
|
|
TEST_ASSERT_TRUE_MESSAGE(saw_jobid_501,
|
|
"session 1's batch-mode decisions must "
|
|
"genuinely include job 501");
|
|
|
|
/* Non-tautology guard #3: at least 4 total decisions across the whole
|
|
* batch run (2 from session 1's own guaranteed floor above, plus at
|
|
* least 1 new candidate pushed before each of sessions 2 and 3) --
|
|
* proves this is not a degenerate empty-everything comparison. */
|
|
total_batch_decisions = 0;
|
|
for (i = 0; i < n_batch; i++) {
|
|
total_batch_decisions += batch_sessions[i]->n_decisions;
|
|
}
|
|
TEST_ASSERT_TRUE_MESSAGE(total_batch_decisions >= 4,
|
|
"the fixture must produce a genuinely "
|
|
"non-trivial decision sequence");
|
|
|
|
/* ---- The central equivalence assertion: per session, per decision,
|
|
* REPL step/continue-to-completion and batch mode must match exactly. ---- */
|
|
for (i = 0; i < n_batch; i++) {
|
|
TEST_ASSERT_EQUAL_INT_MESSAGE(
|
|
batch_sessions[i]->n_decisions, repl_sessions[i]->n_decisions,
|
|
"session decision COUNT must match between REPL and batch");
|
|
|
|
for (j = 0; j < batch_sessions[i]->n_decisions; j++) {
|
|
replay_decision_t* bd = batch_sessions[i]->decisions[j];
|
|
replay_decision_t* rd = repl_sessions[i]->decisions[j];
|
|
|
|
/* Independently pin the decision TYPE on each side (matches
|
|
* test_sim_equivalence.c's own "pin the type, don't just diff
|
|
* the two sides against each other" guard) -- every decision
|
|
* this fixture can produce is PEND (sim_picker_thread_fn()'s
|
|
* documented, out-of-scope DISPATCH gap). */
|
|
TEST_ASSERT_EQUAL_INT((int)ReplayDecision_body_pend,
|
|
(int)bd->body_which);
|
|
TEST_ASSERT_EQUAL_INT((int)ReplayDecision_body_pend,
|
|
(int)rd->body_which);
|
|
|
|
TEST_ASSERT_TRUE_MESSAGE(
|
|
replay_decision_content_eq(bd, rd),
|
|
"REPL step/continue-to-completion must produce a "
|
|
"byte-identical decision to batch mode at this session "
|
|
"and position");
|
|
}
|
|
}
|
|
|
|
free_all_sessions(batch_sessions, n_batch);
|
|
free_all_sessions(repl_sessions, n_repl);
|
|
|
|
unlink(batch_out_path);
|
|
unlink(repl_out_path);
|
|
|
|
printf("test_repl_step_continue_to_completion_matches_batch_decision_"
|
|
"sequence: PASS\n");
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
UNITY_BEGIN();
|
|
RUN_TEST(
|
|
test_repl_step_continue_to_completion_matches_batch_decision_sequence);
|
|
return UNITY_END();
|
|
}
|