Self Derived Expected Value

What goes wrong

The expected value in the assertion is produced by the same function, constant, or format as the actual value. If that code changes, both sides change together, so the test proves only that the code agrees with itself, not that it meets the contract.

Example

The test compares the price formatter's output with the price formatter's output for the same price, so a broken formatter still passes.

Not to be confused with

The expected value follows the implementation; test data where two alternatives happen to be equal is Primary And Fallback Equal In Test, an independent literal that correctly fails after a deliberate change is Test Still Expects The Old Value, and a production check comparing a config to itself is Guard Compares Config To Itself.

Discovered by

@sks24git GitHub

Field notes · 20

@sks24git2026-11-04

A status test reads the expected code from the same constant the handler uses. Change the constant to a wrong value and the test agrees with it.

Write the expected value as a literal in the test. A mirrored constant cannot catch its own mistake.

@sks24git2026-11-04

A test writes the value it then reads back and asserts on. It proves the read works but never that production writes the value at all.

Let the code under test write what you assert. Planting the value tests only the reader.

@sks24git2026-10-29beat 1 review round

A guard test built its input from the same threshold it was meant to protect. Raise the threshold a hundredfold and the test still passes, so the flood the guard stops can come back unseen.

Pin thresholds with literal test inputs. A test that reads the constant moves with it.
Test both sides of a cutoff. One case at the edge and one past it catch drift either way.

@sks24git2026-10-27beat 2 review rounds

A UI test builds its expected button list from the same constant the UI renders, and posts only one of nine actions. Delete an action from the constant and the suite stays green while the button is gone.

Expected values come from the spec, not the code. A list copied from the implementation proves nothing.
Exercise every action once. One sample leaves the rest unwired.

@sks24git2026-10-21

A help text restates legal deadlines by hand next to the quoted source, and no test pins the numbers. Swap two dates and every test stays green while users are told the wrong day to file or pay.

Pin every number you show to users in a test. A copied rule drifts without a sound.
Quote the source next to the copy. A reviewer can check the two side by side.

@sks24git2026-10-16beat 1 review round

A freshness threshold was tested with ages computed from the constant itself, never with the literal spec number. Change the constant and the test still passes, so a stale feed can count as live unnoticed.

Pin spec numbers as literals in tests. A test that derives its inputs from the constant moves with it and proves nothing.

@sks24git2026-10-15

A test computed its expected value from the same constant as the code under test. Change the limit to any wrong number and the test still passes, so the number in the spec has no guard.

Assert spec numbers as literals. An expectation built from the code's own constant moves with every bad edit.

@sks24git2026-09-29beat 3 review rounds

The test looped over the same list of groups the guard reads to build its cases. Drop a group from that list and the guard stops checking it, while every test stays green.

Spell cases out; never read them from the code under test. A fixture built from the constant shrinks with it.
Mutate each branch before review. A branch no test fails on is not guarded.

@sks24git2026-09-14beat 17 review rounds

A test compared whole rows built by two calls, and one field counts seconds to a reset. The calls straddle a second boundary on a slow machine, and the failure reads as a wire change nobody made.

Freeze the clock before comparing across calls. A flake whose message blames the code teaches the next reader to delete the assertion.

@sks24git2026-09-12beat 3 review rounds

A script printed the rows whose values it was about to overwrite only inside the apply branch. The dry run the operator reads never showed the one record that would be destroyed, and confirmation came after.

Everything the apply destroys must print in the dry run. A preview that hides the loss is worse than none.
Print the whole header block in usage; a truncated one drops the protocol.

@sks24git2026-09-12beat 2 review rounds

A destructive script gated itself by comparing two counts derived from the same predicate text. Drop a term from that predicate and both sides move together, so the gate passes while the statement clears every row.

A guard must be computed independently of what it guards. Two counts from one expression agree by construction.
Carry a fix across every sibling script. The one you skipped runs next.

@sks24git2026-09-12

A test built its expected value from the same constant the code reads, so both sides move together. Narrow the constant and the unit suite stays green; only DB-gated tests catch it, and they skip without a database.

Pin one literal per constant. An assertion that reads the same constant as the code is green by construction.
Ask which tests actually run. A mutant caught only by skipped tests is not caught.

@sks24git2026-09-10beat 2 review rounds

The gate excluded one structural non-delivery code and missed its twin. A warning whose row was placed but never sent read as a real delivery failure, locking a past-due subject forever.

Exclude the class, not the one code you remembered. List every terminal state the writer can emit.
A worker owns more outcomes than its reader knows about.

@sks24git2026-09-10beat 1 review round

A wait tool let go after 45 seconds and told the caller "call again", while a monitor field beside it said "every 240". The agent obeyed the tool, not the field, and polled once a minute for the whole run.

Give one number, from one place. Two cadences in one reply and the agent picks the shorter.
A blocking tool is not a timer. Tell the caller to sleep in the background; never "call me again".

@sks24git2026-09-10beat 2 review rounds

Retargeting a test's strict-read assertion left the pricing multiplier pinned by nothing: the new case asserts only that the cached value equals the live one. Any other integer field of the row passes it.

When you retarget an assertion, ask what it used to be the only witness for. A moved test leaves a hole exactly where someone once thought coverage was needed.

@sks24git2026-09-09beat 3 review rounds

The predicate had eleven cases; the refusal that calls it had none. Delete both failure calls and every test stays green, because no live input can reach that branch any more.

Test the refusal, not only the rule it uses. The mutation that ships is a deleted call site.
A branch no real input reaches is protected only by a written fixture.

@sks24git2026-09-05beat 3 review rounds

Rows were stamped "reported" in their own commit, then the page was sent, then a failed send un-stamped them. A pod killed between the stamp and the send leaves the burst marked reported with nobody paged.

A claim before a network call needs a lease. Reopen it when no confirmed delivery follows within a window.
Record the attempt time, not only the success. A timeout is unknown, not failed.

@sks24git2026-09-05beat 9 review rounds

A page flips every product name to a rival's when a switch is thrown, but one cross-sell line already named the rival and passed through untouched. The flipped page then invites its reader to what it already shows.

A rewrite table needs an entry for every term already on the page. The word that never needed swapping is left wrong.
A gate that re-derives the code's heuristic can't fail where it does.

@sks24git2026-09-04beat 1 review round

A repository test compared a method to the value a method returned, both built by the same column mapper. Swap two same-typed column reads and every test stays green while a timezone field holds a fingerprint.

An oracle must not share the code under test. Assert each field against a literal.
Mutate before you trust. Swap two same-typed reads; if nothing reddens, nothing is pinned.

@sks24git2026-08-29

One field, checked in the writer only for one kind of proof and in the reader for every kind. The record is written as success and then refused forever by the check that reads it, and rewriting it changes nothing.

Check a record the same way in its writer and its reader. A laxer writer creates state the reader can never accept.
Fail-closed is not free. It blocks work already paid for.