perf(doubles): drop the forks from the spy hot path

[Chemaclass]

🤔 Background

A spy-heavy test paid subprocess forks per spied call and per assertion. A 200-call test took 1111 ms where the fork-free floor is ~111 ms.

	before	after
assert_have_been_called ×200	1111 ms	170 ms
assert_same ×200 (fork-free floor)	111 ms	111 ms

💡 Three fork classes removed, none inherent

$(cat "$file") for a counter.spy::times_to_slot read its count that way; the file holds one short number, so read -r — a builtin — does it with no fork. The generated spy body did the same $(cat) on every spied invocation, the hottest of the three.

14 sites wrapping bashunit's own pure-bash helpers in $( ) — paying a subshell to compute something the shell could compute in place. Both helpers already ship return-slot variants for exactly this reason (normalize_variable_name_to_slot, normalize_test_function_name_to_slot) and simply weren't being used here.

Defaulted labels needed restructuring, not substitution.local label="${2:-$(...)}" only evaluates the default when $2 is absent, so those became an explicit if [ -z "$label" ] to keep that laziness.

✅ Checked, not assumed

• FUNCNAME is stable across a command substitution — verified directly. Moving these calls out of $( ) while still passing "${FUNCNAME[1]}" resolves to the same frame, so failure labels are unchanged.
• The counter read is guarded with a numeric case, so a truncated or empty file yields 0 exactly as the old || builtin echo 0 did.

📊 A note for whoever profiles this next

My first attempt converted only the eleven assertion-level forks: 1111 ms → 1031 ms, a 7% win. The cost was almost entirely inside the spy helper, not at the call sites. Measure before concluding which fork matters.

🔒 Verification

Bash 3.0 safe — read, case and parameter expansion only; compat gate green (14/14). Fork budgets unchanged (11/11). make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1657 sequential / 1616 parallel-simple-strict.

[Chemaclass]

🤔 Background

A spy-heavy test paid subprocess forks per spied call and per assertion. A 200-call test took 1111 ms where the fork-free floor is ~111 ms.

	before	after
assert_have_been_called ×200	1111 ms	170 ms
assert_same ×200 (fork-free floor)	111 ms	111 ms

💡 Three fork classes removed, none inherent

$(cat "$file") for a counter.spy::times_to_slot read its count that way; the file holds one short number, so read -r — a builtin — does it with no fork. The generated spy body did the same $(cat) on every spied invocation, the hottest of the three.

14 sites wrapping bashunit's own pure-bash helpers in $( ) — paying a subshell to compute something the shell could compute in place. Both helpers already ship return-slot variants for exactly this reason (normalize_variable_name_to_slot, normalize_test_function_name_to_slot) and simply weren't being used here.

Defaulted labels needed restructuring, not substitution.local label="${2:-$(...)}" only evaluates the default when $2 is absent, so those became an explicit if [ -z "$label" ] to keep that laziness.

✅ Checked, not assumed

• FUNCNAME is stable across a command substitution — verified directly. Moving these calls out of $( ) while still passing "${FUNCNAME[1]}" resolves to the same frame, so failure labels are unchanged.
• The counter read is guarded with a numeric case, so a truncated or empty file yields 0 exactly as the old || builtin echo 0 did.

📊 A note for whoever profiles this next

My first attempt converted only the eleven assertion-level forks: 1111 ms → 1031 ms, a 7% win. The cost was almost entirely inside the spy helper, not at the call sites. Measure before concluding which fork matters.

🔒 Verification

Bash 3.0 safe — read, case and parameter expansion only; compat gate green (14/14). Fork budgets unchanged (11/11). make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1657 sequential / 1616 parallel-simple-strict.

[Chemaclass]

🤔 Background

A spy-heavy test paid subprocess forks per spied call and per assertion. A 200-call test took 1111 ms where the fork-free floor is ~111 ms.

	before	after
assert_have_been_called ×200	1111 ms	170 ms
assert_same ×200 (fork-free floor)	111 ms	111 ms

💡 Three fork classes removed, none inherent

$(cat "$file") for a counter.spy::times_to_slot read its count that way; the file holds one short number, so read -r — a builtin — does it with no fork. The generated spy body did the same $(cat) on every spied invocation, the hottest of the three.

14 sites wrapping bashunit's own pure-bash helpers in $( ) — paying a subshell to compute something the shell could compute in place. Both helpers already ship return-slot variants for exactly this reason (normalize_variable_name_to_slot, normalize_test_function_name_to_slot) and simply weren't being used here.

Defaulted labels needed restructuring, not substitution.local label="${2:-$(...)}" only evaluates the default when $2 is absent, so those became an explicit if [ -z "$label" ] to keep that laziness.

✅ Checked, not assumed

• FUNCNAME is stable across a command substitution — verified directly. Moving these calls out of $( ) while still passing "${FUNCNAME[1]}" resolves to the same frame, so failure labels are unchanged.
• The counter read is guarded with a numeric case, so a truncated or empty file yields 0 exactly as the old || builtin echo 0 did.

📊 A note for whoever profiles this next

My first attempt converted only the eleven assertion-level forks: 1111 ms → 1031 ms, a 7% win. The cost was almost entirely inside the spy helper, not at the call sites. Measure before concluding which fork matters.

🔒 Verification

Bash 3.0 safe — read, case and parameter expansion only; compat gate green (14/14). Fork budgets unchanged (11/11). make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1657 sequential / 1616 parallel-simple-strict.

[Chemaclass]

🤔 Background

A spy-heavy test paid subprocess forks per spied call and per assertion. A 200-call test took 1111 ms where the fork-free floor is ~111 ms.

	before	after
assert_have_been_called ×200	1111 ms	170 ms
assert_same ×200 (fork-free floor)	111 ms	111 ms

💡 Three fork classes removed, none inherent

$(cat "$file") for a counter.spy::times_to_slot read its count that way; the file holds one short number, so read -r — a builtin — does it with no fork. The generated spy body did the same $(cat) on every spied invocation, the hottest of the three.

14 sites wrapping bashunit's own pure-bash helpers in $( ) — paying a subshell to compute something the shell could compute in place. Both helpers already ship return-slot variants for exactly this reason (normalize_variable_name_to_slot, normalize_test_function_name_to_slot) and simply weren't being used here.

Defaulted labels needed restructuring, not substitution.local label="${2:-$(...)}" only evaluates the default when $2 is absent, so those became an explicit if [ -z "$label" ] to keep that laziness.

✅ Checked, not assumed

• FUNCNAME is stable across a command substitution — verified directly. Moving these calls out of $( ) while still passing "${FUNCNAME[1]}" resolves to the same frame, so failure labels are unchanged.
• The counter read is guarded with a numeric case, so a truncated or empty file yields 0 exactly as the old || builtin echo 0 did.

📊 A note for whoever profiles this next

My first attempt converted only the eleven assertion-level forks: 1111 ms → 1031 ms, a 7% win. The cost was almost entirely inside the spy helper, not at the call sites. Measure before concluding which fork matters.

🔒 Verification

Bash 3.0 safe — read, case and parameter expansion only; compat gate green (14/14). Fork budgets unchanged (11/11). make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1657 sequential / 1616 parallel-simple-strict.

[Chemaclass]

🤔 Background

A spy-heavy test paid subprocess forks per spied call and per assertion. A 200-call test took 1111 ms where the fork-free floor is ~111 ms.

	before	after
assert_have_been_called ×200	1111 ms	170 ms
assert_same ×200 (fork-free floor)	111 ms	111 ms

💡 Three fork classes removed, none inherent

$(cat "$file") for a counter.spy::times_to_slot read its count that way; the file holds one short number, so read -r — a builtin — does it with no fork. The generated spy body did the same $(cat) on every spied invocation, the hottest of the three.

14 sites wrapping bashunit's own pure-bash helpers in $( ) — paying a subshell to compute something the shell could compute in place. Both helpers already ship return-slot variants for exactly this reason (normalize_variable_name_to_slot, normalize_test_function_name_to_slot) and simply weren't being used here.

Defaulted labels needed restructuring, not substitution.local label="${2:-$(...)}" only evaluates the default when $2 is absent, so those became an explicit if [ -z "$label" ] to keep that laziness.

✅ Checked, not assumed

• FUNCNAME is stable across a command substitution — verified directly. Moving these calls out of $( ) while still passing "${FUNCNAME[1]}" resolves to the same frame, so failure labels are unchanged.
• The counter read is guarded with a numeric case, so a truncated or empty file yields 0 exactly as the old || builtin echo 0 did.

📊 A note for whoever profiles this next

My first attempt converted only the eleven assertion-level forks: 1111 ms → 1031 ms, a 7% win. The cost was almost entirely inside the spy helper, not at the call sites. Measure before concluding which fork matters.

🔒 Verification

Bash 3.0 safe — read, case and parameter expansion only; compat gate green (14/14). Fork budgets unchanged (11/11). make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1657 sequential / 1616 parallel-simple-strict.

[Chemaclass]

🤔 Background

A spy-heavy test paid subprocess forks per spied call and per assertion. A 200-call test took 1111 ms where the fork-free floor is ~111 ms.

	before	after
assert_have_been_called ×200	1111 ms	170 ms
assert_same ×200 (fork-free floor)	111 ms	111 ms

💡 Three fork classes removed, none inherent

$(cat "$file") for a counter.spy::times_to_slot read its count that way; the file holds one short number, so read -r — a builtin — does it with no fork. The generated spy body did the same $(cat) on every spied invocation, the hottest of the three.

14 sites wrapping bashunit's own pure-bash helpers in $( ) — paying a subshell to compute something the shell could compute in place. Both helpers already ship return-slot variants for exactly this reason (normalize_variable_name_to_slot, normalize_test_function_name_to_slot) and simply weren't being used here.

Defaulted labels needed restructuring, not substitution.local label="${2:-$(...)}" only evaluates the default when $2 is absent, so those became an explicit if [ -z "$label" ] to keep that laziness.

✅ Checked, not assumed

• FUNCNAME is stable across a command substitution — verified directly. Moving these calls out of $( ) while still passing "${FUNCNAME[1]}" resolves to the same frame, so failure labels are unchanged.
• The counter read is guarded with a numeric case, so a truncated or empty file yields 0 exactly as the old || builtin echo 0 did.

📊 A note for whoever profiles this next

My first attempt converted only the eleven assertion-level forks: 1111 ms → 1031 ms, a 7% win. The cost was almost entirely inside the spy helper, not at the call sites. Measure before concluding which fork matters.

🔒 Verification

Bash 3.0 safe — read, case and parameter expansion only; compat gate green (14/14). Fork budgets unchanged (11/11). make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1657 sequential / 1616 parallel-simple-strict.

[Chemaclass]

🤔 Background

A spy-heavy test paid subprocess forks per spied call and per assertion. A 200-call test took 1111 ms where the fork-free floor is ~111 ms.

	before	after
assert_have_been_called ×200	1111 ms	170 ms
assert_same ×200 (fork-free floor)	111 ms	111 ms

💡 Three fork classes removed, none inherent

$(cat "$file") for a counter.spy::times_to_slot read its count that way; the file holds one short number, so read -r — a builtin — does it with no fork. The generated spy body did the same $(cat) on every spied invocation, the hottest of the three.

14 sites wrapping bashunit's own pure-bash helpers in $( ) — paying a subshell to compute something the shell could compute in place. Both helpers already ship return-slot variants for exactly this reason (normalize_variable_name_to_slot, normalize_test_function_name_to_slot) and simply weren't being used here.

Defaulted labels needed restructuring, not substitution.local label="${2:-$(...)}" only evaluates the default when $2 is absent, so those became an explicit if [ -z "$label" ] to keep that laziness.

✅ Checked, not assumed

• FUNCNAME is stable across a command substitution — verified directly. Moving these calls out of $( ) while still passing "${FUNCNAME[1]}" resolves to the same frame, so failure labels are unchanged.
• The counter read is guarded with a numeric case, so a truncated or empty file yields 0 exactly as the old || builtin echo 0 did.

📊 A note for whoever profiles this next

My first attempt converted only the eleven assertion-level forks: 1111 ms → 1031 ms, a 7% win. The cost was almost entirely inside the spy helper, not at the call sites. Measure before concluding which fork matters.

🔒 Verification

Bash 3.0 safe — read, case and parameter expansion only; compat gate green (14/14). Fork budgets unchanged (11/11). make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1657 sequential / 1616 parallel-simple-strict.

[Chemaclass]

🤔 Background

A spy-heavy test paid subprocess forks per spied call and per assertion. A 200-call test took 1111 ms where the fork-free floor is ~111 ms.

	before	after
assert_have_been_called ×200	1111 ms	170 ms
assert_same ×200 (fork-free floor)	111 ms	111 ms

💡 Three fork classes removed, none inherent

$(cat "$file") for a counter.spy::times_to_slot read its count that way; the file holds one short number, so read -r — a builtin — does it with no fork. The generated spy body did the same $(cat) on every spied invocation, the hottest of the three.

14 sites wrapping bashunit's own pure-bash helpers in $( ) — paying a subshell to compute something the shell could compute in place. Both helpers already ship return-slot variants for exactly this reason (normalize_variable_name_to_slot, normalize_test_function_name_to_slot) and simply weren't being used here.

Defaulted labels needed restructuring, not substitution.local label="${2:-$(...)}" only evaluates the default when $2 is absent, so those became an explicit if [ -z "$label" ] to keep that laziness.

✅ Checked, not assumed

• FUNCNAME is stable across a command substitution — verified directly. Moving these calls out of $( ) while still passing "${FUNCNAME[1]}" resolves to the same frame, so failure labels are unchanged.
• The counter read is guarded with a numeric case, so a truncated or empty file yields 0 exactly as the old || builtin echo 0 did.

📊 A note for whoever profiles this next

My first attempt converted only the eleven assertion-level forks: 1111 ms → 1031 ms, a 7% win. The cost was almost entirely inside the spy helper, not at the call sites. Measure before concluding which fork matters.

🔒 Verification

Bash 3.0 safe — read, case and parameter expansion only; compat gate green (14/14). Fork budgets unchanged (11/11). make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1657 sequential / 1616 parallel-simple-strict.