From 0404c672c839fe6c27497d05c017f9602ce8137a Mon Sep 17 00:00:00 2001 From: Dmitrii Vasilev Date: Mon, 19 Oct 2026 07:10:16 +0700 Subject: [PATCH] test(claw): kill the real check_state.t27 and merge_lane.t27 mutation survivors A mutation sweep left 7 of 40 check_state.t27 mutants alive, 3 of them real. It left 18 of 92 merge_lane.t27 mutants alive, 12 of them real. Ten new tests kill all 15. They cover: - every wait status - the 1024-row and 4096-row caps (none had a test) - a blank line, which was counted as an unreadable row - an open run of age 0 - label-only with no missing label - an empty event name - the letters a and z in an event name - the dashboard reading each row from its first byte The carriage-return tests in both specs wrote "\r", which in a t27 literal is a backslash and an r. They now write the byte 13 and assert that it is there (#10722). Production code is unchanged. A full re-sweep leaves 36/40 and 86/92, and every mutant left is an equivalent one. check_state 17/17 and merge_lane 30/30 pass in t27c and t27b, with 0 vacuous passes. The 7 committed gen/c/claw files are byte-identical. Both seals are resaved; 32/32 seals verify. Closes #10724 Closes #10722 Co-Authored-By: Claude Opus 5.5 --- .trinity/seals/claw_ClawCheckState.json | 18 ++-- .trinity/seals/claw_ClawMergeLane.json | 18 ++-- specs/claw/check_state.t27 | 64 +++++++++++++- specs/claw/merge_lane.t27 | 110 +++++++++++++++++++++++- 4 files changed, 190 insertions(+), 20 deletions(-) diff --git a/.trinity/seals/claw_ClawCheckState.json b/.trinity/seals/claw_ClawCheckState.json index b9cc7ef288..85c9f1de14 100644 --- a/.trinity/seals/claw_ClawCheckState.json +++ b/.trinity/seals/claw_ClawCheckState.json @@ -7,27 +7,27 @@ }, { "spec": "specs/claw/text.t27", - "spec_hash": "sha256:b65da69dff231c61a6d3a48558af9e17af42e1acbe3f4763348f1f0c2f118f21" + "spec_hash": "sha256:968755ec1917f766eb2cdd0ab4c0c48aef028a0e7d69e191911695e925b286ad" } ], "config": "gen=c,rust,verilog,zig;tests=zig", - "gen_hash_c": "sha256:a12ac6811d377dbe066936d7d83874b6500f8cdb1857f114657b1445842d0b49", - "gen_hash_rust": "sha256:bd33e233b20fd2a284adb6c1d4ec4f52a78c7e3dde773cbaffbf01c392e00919", - "gen_hash_verilog": "sha256:1aae7f4b971d6bb0c1797a7bedf54a461dd4f705efad6aa1cacb5db973ccd12d", - "gen_hash_zig": "sha256:84f004a0e9d83668dbd79f4a0eb7ec6c7f6ecd290a2f482faa27aced8b03037c", + "gen_hash_c": "sha256:e4a61dbf1879a0e79f0ded5903ca710761bbeabf8d898d28bee4279e7fbc17ae", + "gen_hash_rust": "sha256:92081417741464afd951b1e51ced21199edb1a4365dc03aac395daed47277467", + "gen_hash_verilog": "sha256:0de652d676622e312842837dc722d69176107729c64ce2995dee5a0137b1b5cb", + "gen_hash_zig": "sha256:ccf7cb6d2c09d05c9bd75193f00bb8fa1fa1c455fa70999e4750685fbd2ead21", "module": "ClawCheckState", "ring": 12, "seal_schema": 2, - "sealed_at": "2026-10-18T19:55:01Z", + "sealed_at": "2026-10-19T00:08:47Z", "sealed_by": "t27c-bootstrap@0.5.2", - "spec_hash": "sha256:f5f05cce0d40d19693618461a81702761d27917cc6d1a3dfb53d8c06ba8b4ab4", + "spec_hash": "sha256:0a036f9c3e48e9c91b1cdadc806d63db91d5f7638157d26b355bd4db42014d83", "spec_path": "specs/claw/check_state.t27", "tests": { "failed": 0, "failing": [], "forced": false, - "passed": 12, - "total": 12, + "passed": 17, + "total": 17, "vacuous": 0 }, "toolchain": { diff --git a/.trinity/seals/claw_ClawMergeLane.json b/.trinity/seals/claw_ClawMergeLane.json index b36782b45a..898897264c 100644 --- a/.trinity/seals/claw_ClawMergeLane.json +++ b/.trinity/seals/claw_ClawMergeLane.json @@ -7,27 +7,27 @@ }, { "spec": "specs/claw/text.t27", - "spec_hash": "sha256:b65da69dff231c61a6d3a48558af9e17af42e1acbe3f4763348f1f0c2f118f21" + "spec_hash": "sha256:968755ec1917f766eb2cdd0ab4c0c48aef028a0e7d69e191911695e925b286ad" } ], "config": "gen=c,rust,verilog,zig;tests=zig", - "gen_hash_c": "sha256:2d4e93a910650e9b46d12fcc739be63ad7a240b8c13f835415bcf1ad313645f0", - "gen_hash_rust": "sha256:ab91d88ed9f58d800b1d0b8c5d0ae94d21531c5858b04f2aeff59ec552f5e4c3", - "gen_hash_verilog": "sha256:c90355854c1fe3836be5b2433b04686c263199de040e73793116228a4fc69178", - "gen_hash_zig": "sha256:0d2296bd2fd606c4a215fca1758c9613786ab5865f9ae758288e01a96e0c15b3", + "gen_hash_c": "sha256:9e64d9f311afe66e2933493b7a4fb09e64d24acf2527f13ce429738a01f32b27", + "gen_hash_rust": "sha256:0649a78a43e68e68d61fcbcba21c738e0a5767f5b60dee1c2214eed7f3165927", + "gen_hash_verilog": "sha256:58fca36ac6be6e63f55a9cc268a1695a9a046d858ac100fc84bd00fce5752909", + "gen_hash_zig": "sha256:ca374fe84de07ca60506572b960144fbcfc46ffc3da72942e15d4743efa82d37", "module": "ClawMergeLane", "ring": 12, "seal_schema": 2, - "sealed_at": "2026-10-18T20:55:41Z", + "sealed_at": "2026-10-19T00:08:51Z", "sealed_by": "t27c-bootstrap@0.5.2", - "spec_hash": "sha256:91d755a5c6b463f115856e61765ac8c7915f72ab988b53fcc0241edec08765ca", + "spec_hash": "sha256:43b070ab365c203b897b555f2ad2743f4b56049cf8186057743df02b990e0b5a", "spec_path": "specs/claw/merge_lane.t27", "tests": { "failed": 0, "failing": [], "forced": false, - "passed": 23, - "total": 23, + "passed": 30, + "total": 30, "vacuous": 0 }, "toolchain": { diff --git a/specs/claw/check_state.t27 b/specs/claw/check_state.t27 index 655d5e7852..a6c3971f5e 100644 --- a/specs/claw/check_state.t27 +++ b/specs/claw/check_state.t27 @@ -258,7 +258,6 @@ test an_unknown_or_inconsistent_row_is_unreadable { assert t_class("COMPLETED\tMAYBE\n", 16) == K_BAD; assert t_class("DONE\tSUCCESS\n", 13) == K_BAD; assert t_class("COMPLETED\tSUCCESS\textra\n", 24) == K_BAD; - assert t_class("COMPLETED\tSUCCESS\r\n", 19) == K_BAD; assert t_class("completed\tsuccess\n", 18) == K_BAD; } @@ -310,3 +309,66 @@ test a_clipped_plan_still_advances_the_cursor { assert out[0] == 'C'; assert out[1] == '\t'; } + +// `"\r"` in a t27 literal is a backslash and an `r`, so the tests below write the carriage return +// as the byte 13 and assert that it is there (#10722). + +test a_carriage_return_after_the_conclusion_is_unreadable { + var row : [24]u8 = undefined; + const w : usize = put_str(&row, 24, 0, "COMPLETED\tSUCCESS", 17); + row[w] = 13; + row[w + 1] = '\n'; + assert w == 17; + assert row[17] == 13; + var st : [4]u32 = undefined; + assert check_counts(&row, 19, &st) == 1; + assert st[K_BAD as usize] == 1; + assert st[K_PASS as usize] == 0; +} + +test a_line_that_is_only_a_carriage_return_is_an_unreadable_row { + var raw : [24]u8 = undefined; + var w : usize = put_str(&raw, 24, 0, "COMPLETED\tSUCCESS\n", 18); + raw[w] = 13; + raw[w + 1] = '\n'; + w += 2; + assert raw[18] == 13; + var st : [4]u32 = undefined; + assert check_counts(&raw, w, &st) == 2; + assert st[K_PASS as usize] == 1; + assert st[K_BAD as usize] == 1; + var out : [128]u8 = undefined; + const o : usize = check_plan(&raw, w, &out, 128); + assert buf_has(&out, o, "V\tpending\n", 10) == true; +} + +// The tests below were written against a mutation sweep of this file (#10724). + +test every_wait_status_with_no_conclusion_is_pending { + assert t_class("QUEUED\t-\n", 9) == K_WAIT; + assert t_class("IN_PROGRESS\t-\n", 14) == K_WAIT; + assert t_class("WAITING\t-\n", 10) == K_WAIT; + assert t_class("PENDING\t-\n", 10) == K_WAIT; + assert t_class("REQUESTED\t-\n", 12) == K_WAIT; + assert t_class("REQUESTED\tSUCCESS\n", 18) == K_BAD; +} + +test the_row_cap_reads_1024_rows_and_refuses_the_next { + var raw : [9225]u8 = undefined; + var st : [4]u32 = undefined; + const n : usize = t_rows(&raw, 9225, 0, "QUEUED\t-\n", 9, 1024); + assert n == 9216; + assert check_counts(&raw, n, &st) == 1024; + assert st[K_WAIT as usize] == 1024; + assert st[K_BAD as usize] == 0; + const m : usize = t_rows(&raw, 9225, n, "QUEUED\t-\n", 9, 1); + assert m == 9225; + assert check_counts(&raw, m, &st) == 1025; + assert st[K_WAIT as usize] == 1024; + assert st[K_BAD as usize] == 1; +} + +test the_dashboard_reads_each_row_from_its_first_byte { + assert dashboard_failing("COMPLETED\tSUCCESS\nCONTEXT\tFAILURE\n", 34) == 0; + assert dashboard_failing("COMPLETED\tSUCCESS\nCOMPLETED\tFAILURE\n", 36) == 1; +} diff --git a/specs/claw/merge_lane.t27 b/specs/claw/merge_lane.t27 index 49a0c151e5..7fdb4fab90 100644 --- a/specs/claw/merge_lane.t27 +++ b/specs/claw/merge_lane.t27 @@ -630,8 +630,16 @@ test an_unreadable_row_counts_as_somebody_elses { test a_carriage_return_or_a_near_name_is_not_the_merger { var st : [4]u32 = undefined; - assert ms_counts("Auto Merge Ready PRs\tworkflow_run\r\n", 35, &st) == 1; + // `"\r"` in a t27 literal is a backslash and an `r`, so the carriage return is the byte 13 (#10722). + var cr : [40]u8 = undefined; + const w : usize = put_str(&cr, 40, 0, "Auto Merge Ready PRs\tworkflow_run", 33); + cr[w] = 13; + cr[w + 1] = '\n'; + assert w == 33; + assert cr[33] == 13; + assert ms_counts(&cr, 35, &st) == 1; assert st[MS_BAD] == 1; + assert st[MS_ROWS] == 0; assert st[MS_MERGER_ROWS] == 0; assert ms_counts("Auto Merge Ready PR\tworkflow_run\n", 33, &st) == 1; assert st[MS_ROWS] == 1; @@ -664,3 +672,103 @@ test the_share_total_counts_unreadable_rows { assert buf_has(&out, w, "S\tmerger share: 1 of 2 queued runs are the merger's, 1 of them workflow_run; 1 unreadable\n", 90) == true; assert buf_has(&out, w, "F\tmerger-share\thigh\n", 20) == true; } + +// The tests below were written against a mutation sweep of this file (#10724). + +fn t_rep(dst : []u8, cap : usize, w : usize, row : str, row_len : usize, count : u32) -> usize { + var x : usize = w; + var i : u32 = 0; + while (i < count) { + x = put_str(dst, cap, x, row, row_len); + i += 1; + } + return x; +} + +test a_blank_line_is_not_a_row_in_any_reader { + var st : [8]u32 = undefined; + assert ml_counts("queued\t-\t5\n\nqueued\t-\t5\n", 23, &st) == 2; + assert st[ML_QUEUED] == 2; + assert st[ML_BAD] == 0; + assert my_counts("schedule\t1\t0\t0\n\n", 16, &st) == 1; + assert st[MY_RUNS] == 1; + assert st[MY_BAD] == 0; + assert ms_counts("x\tpush\n\n", 8, &st) == 1; + assert st[MS_ROWS] == 1; + assert st[MS_BAD] == 0; +} + +test an_open_run_of_age_zero_is_read { + var st : [8]u32 = undefined; + assert ml_counts("queued\t-\t0\n", 11, &st) == 1; + assert st[ML_QUEUED] == 1; + assert st[ML_BAD] == 0; + assert st[ML_OLDEST] == 0; +} + +test the_merger_rows_cap_at_4096_and_refuse_the_next { + var raw : [45067]u8 = undefined; + var st : [8]u32 = undefined; + const n : usize = t_rep(&raw, 45067, 0, "queued\t-\t5\n", 11, 4096); + assert n == 45056; + assert ml_counts(&raw, n, &st) == 4096; + assert st[ML_QUEUED] == 4096; + assert st[ML_BAD] == 0; + const m : usize = t_rep(&raw, 45067, n, "queued\t-\t5\n", 11, 1); + assert m == 45067; + assert ml_counts(&raw, m, &st) == 4097; + assert st[ML_QUEUED] == 4096; + assert st[ML_BAD] == 1; +} + +test the_yield_rows_cap_at_4096_and_refuse_the_next { + var raw : [61455]u8 = undefined; + var st : [5]u32 = undefined; + const n : usize = t_rep(&raw, 61455, 0, "schedule\t1\t0\t0\n", 15, 4096); + assert n == 61440; + assert my_counts(&raw, n, &st) == 4096; + assert st[MY_RUNS] == 4096; + assert st[MY_BAD] == 0; + const m : usize = t_rep(&raw, 61455, n, "schedule\t1\t0\t0\n", 15, 1); + assert m == 61455; + assert my_counts(&raw, m, &st) == 4097; + assert st[MY_RUNS] == 4096; + assert st[MY_BAD] == 1; +} + +test the_share_rows_cap_at_4096_and_refuse_the_next { + var raw : [28679]u8 = undefined; + var st : [4]u32 = undefined; + const n : usize = t_rep(&raw, 28679, 0, "x\tpush\n", 7, 4096); + assert n == 28672; + assert ms_counts(&raw, n, &st) == 4096; + assert st[MS_ROWS] == 4096; + assert st[MS_BAD] == 0; + const m : usize = t_rep(&raw, 28679, n, "x\tpush\n", 7, 1); + assert m == 28679; + assert ms_counts(&raw, m, &st) == 4097; + assert st[MS_ROWS] == 4096; + assert st[MS_BAD] == 1; +} + +test an_empty_run_is_label_only_only_when_a_label_was_missing { + var st : [5]u32 = undefined; + assert my_counts("schedule\t0\t0\t0\n", 15, &st) == 1; + assert st[MY_EMPTY] == 1; + assert st[MY_LABEL_ONLY] == 0; +} + +test an_event_name_is_lower_case_letters_from_a_to_z { + var st : [4]u32 = undefined; + assert ms_counts("x\t\n", 3, &st) == 1; + assert st[MS_BAD] == 1; + assert st[MS_ROWS] == 0; + assert ms_counts("x\tworkflow_dispatch\n", 20, &st) == 1; + assert st[MS_ROWS] == 1; + assert ms_counts("x\tzz\n", 5, &st) == 1; + assert st[MS_ROWS] == 1; + assert ms_counts("x\t`\n", 4, &st) == 1; + assert st[MS_BAD] == 1; + assert ms_counts("x\t{\n", 4, &st) == 1; + assert st[MS_BAD] == 1; +}