Understand the failure.
Verify the repair.
Small, reproducible software failures. The broken implementation, the fix that didn’t work, and the one that passed—preserved together.
Explore the cases ↓How results are verified ↗WHAT THE ARCHIVE CONTAINS
100840 executable cases. 20168 are open.
Every case records the implementation that fails, the fix that did not work, and the repair that passed its checks—with recorded outputs and source hashes. This release adds 100840 cases across 20168 failure mechanisms and 254 domains.
The open tier gives you the failure and the unsuccessful fix for one case in every mechanism. The remaining 80672 cases, 5 variants per mechanism, are member-only: the verified repair, its recorded checks, and the full fixture suite are held in the member archive. Read the methodology ↗
A RECORD OF WHAT WENT WRONG
Browse the archive / 100840
Stack-depth verifier: goto treated as falling through · case 01
Well-formed methods with dead code after goto are rejected with bogus underflows.
Stack-depth verifier: goto treated as falling through · case 02
Well-formed methods with dead code after goto are rejected with bogus underflows.
Stack-depth verifier: goto treated as falling through · case 03
Well-formed methods with dead code after goto are rejected with bogus underflows.
Stack-depth verifier: goto treated as falling through · case 04
Well-formed methods with dead code after goto are rejected with bogus underflows.
Stack-depth verifier: goto treated as falling through · case 05
Well-formed methods with dead code after goto are rejected with bogus underflows.
Stack-depth verifier: ifeq leaves its condition on the stack · case 01
Both branch targets are verified one slot too deep and max stack is overstated.
Stack-depth verifier: ifeq leaves its condition on the stack · case 02
Both branch targets are verified one slot too deep and max stack is overstated.
Stack-depth verifier: ifeq leaves its condition on the stack · case 03
Both branch targets are verified one slot too deep and max stack is overstated.
Stack-depth verifier: ifeq leaves its condition on the stack · case 04
Both branch targets are verified one slot too deep and max stack is overstated.
Stack-depth verifier: ifeq leaves its condition on the stack · case 05
Both branch targets are verified one slot too deep and max stack is overstated.
Stack-depth verifier: merges only reject deeper arrivals · case 01
A control-flow merge reached with a shallower stack on the second path is accepted.
Stack-depth verifier: merges only reject deeper arrivals · case 02
A control-flow merge reached with a shallower stack on the second path is accepted.
Stack-depth verifier: merges only reject deeper arrivals · case 03
A control-flow merge reached with a shallower stack on the second path is accepted.
Stack-depth verifier: merges only reject deeper arrivals · case 04
A control-flow merge reached with a shallower stack on the second path is accepted.
Stack-depth verifier: merges only reject deeper arrivals · case 05
A control-flow merge reached with a shallower stack on the second path is accepted.
Stack-depth verifier: negative targets index from the end · case 01
A branch to -1 verifies the last instruction instead of being rejected.
Stack-depth verifier: negative targets index from the end · case 02
A branch to -1 verifies the last instruction instead of being rejected.
Stack-depth verifier: negative targets index from the end · case 03
A branch to -1 verifies the last instruction instead of being rejected.
Stack-depth verifier: negative targets index from the end · case 04
A branch to -1 verifies the last instruction instead of being rejected.
Stack-depth verifier: negative targets index from the end · case 05
A branch to -1 verifies the last instruction instead of being rejected.
Stack-depth verifier: exact operand count flagged as underflow · case 01
Any instruction whose required operands exactly fill the stack is rejected.
Stack-depth verifier: exact operand count flagged as underflow · case 02
Any instruction whose required operands exactly fill the stack is rejected.
Stack-depth verifier: exact operand count flagged as underflow · case 03
Any instruction whose required operands exactly fill the stack is rejected.
Stack-depth verifier: exact operand count flagged as underflow · case 04
Any instruction whose required operands exactly fill the stack is rejected.
Stack-depth verifier: exact operand count flagged as underflow · case 05
Any instruction whose required operands exactly fill the stack is rejected.
Call frames: arguments bound in pop order · case 01
Two-argument functions see their parameters swapped; sub(a, b) returns b - a.
Call frames: arguments bound in pop order · case 02
Two-argument functions see their parameters swapped; sub(a, b) returns b - a.
Call frames: arguments bound in pop order · case 03
Two-argument functions see their parameters swapped; sub(a, b) returns b - a.
Call frames: arguments bound in pop order · case 04
Two-argument functions see their parameters swapped; sub(a, b) returns b - a.
Call frames: arguments bound in pop order · case 05
Two-argument functions see their parameters swapped; sub(a, b) returns b - a.
Call frames: zero-argument call clears the caller stack · case 01
After calling a function with no arguments the caller loses all pending operands and faults.
Call frames: zero-argument call clears the caller stack · case 02
After calling a function with no arguments the caller loses all pending operands and faults.
Call frames: zero-argument call clears the caller stack · case 03
After calling a function with no arguments the caller loses all pending operands and faults.
Call frames: zero-argument call clears the caller stack · case 04
After calling a function with no arguments the caller loses all pending operands and faults.
Call frames: zero-argument call clears the caller stack · case 05
After calling a function with no arguments the caller loses all pending operands and faults.
Call frames: return re-executes the call instruction · case 01
Every return immediately calls the function again until the depth limit is hit.
Call frames: return re-executes the call instruction · case 02
Every return immediately calls the function again until the depth limit is hit.
Call frames: return re-executes the call instruction · case 03
Every return immediately calls the function again until the depth limit is hit.
Call frames: return re-executes the call instruction · case 04
Every return immediately calls the function again until the depth limit is hit.
Call frames: return re-executes the call instruction · case 05
Every return immediately calls the function again until the depth limit is hit.
Call frames: zero padding placed before arguments · case 01
Functions with extra locals read zero where their first parameter should be.
Call frames: zero padding placed before arguments · case 02
Functions with extra locals read zero where their first parameter should be.
Call frames: zero padding placed before arguments · case 03
Functions with extra locals read zero where their first parameter should be.
Call frames: zero padding placed before arguments · case 04
Functions with extra locals read zero where their first parameter should be.
Call frames: zero padding placed before arguments · case 05
Functions with extra locals read zero where their first parameter should be.
Call frames: return resumes at the caller's own return address · case 01
Returns from nested calls jump to the grandparent's continuation or fault at top level.
Call frames: return resumes at the caller's own return address · case 02
Returns from nested calls jump to the grandparent's continuation or fault at top level.
Call frames: return resumes at the caller's own return address · case 03
Returns from nested calls jump to the grandparent's continuation or fault at top level.
Call frames: return resumes at the caller's own return address · case 04
Returns from nested calls jump to the grandparent's continuation or fault at top level.
Call frames: return resumes at the caller's own return address · case 05
Returns from nested calls jump to the grandparent's continuation or fault at top level.
Call frames: return value pushed beneath caller operands · case 01
Expressions that use a call result with pending operands compute with swapped operands.
Call frames: return value pushed beneath caller operands · case 02
Expressions that use a call result with pending operands compute with swapped operands.
Call frames: return value pushed beneath caller operands · case 03
Expressions that use a call result with pending operands compute with swapped operands.
Call frames: return value pushed beneath caller operands · case 04
Expressions that use a call result with pending operands compute with swapped operands.
Call frames: return value pushed beneath caller operands · case 05
Expressions that use a call result with pending operands compute with swapped operands.
Exception tables: protected range end treated as inclusive · case 01
An exception raised by the first instruction after a try block is caught by that block's handler.
Exception tables: protected range end treated as inclusive · case 02
An exception raised by the first instruction after a try block is caught by that block's handler.
Exception tables: protected range end treated as inclusive · case 03
An exception raised by the first instruction after a try block is caught by that block's handler.
Exception tables: protected range end treated as inclusive · case 04
An exception raised by the first instruction after a try block is caught by that block's handler.
Exception tables: protected range end treated as inclusive · case 05
An exception raised by the first instruction after a try block is caught by that block's handler.
Exception tables: narrowest range preferred over table order · case 01
Where a wide handler is listed before a narrow one, the narrow handler wins.
Exception tables: narrowest range preferred over table order · case 02
Where a wide handler is listed before a narrow one, the narrow handler wins.
Exception tables: narrowest range preferred over table order · case 03
Where a wide handler is listed before a narrow one, the narrow handler wins.
Exception tables: narrowest range preferred over table order · case 04
Where a wide handler is listed before a narrow one, the narrow handler wins.
Exception tables: narrowest range preferred over table order · case 05
Where a wide handler is listed before a narrow one, the narrow handler wins.
Exception tables: handler requires the exact thrown type · case 01
catch (IOException) no longer catches FileNotFoundException.
Exception tables: handler requires the exact thrown type · case 02
catch (IOException) no longer catches FileNotFoundException.
Exception tables: handler requires the exact thrown type · case 03
catch (IOException) no longer catches FileNotFoundException.
Exception tables: handler requires the exact thrown type · case 04
catch (IOException) no longer catches FileNotFoundException.
Exception tables: handler requires the exact thrown type · case 05
catch (IOException) no longer catches FileNotFoundException.
Exception tables: finally entries never match · case 01
finally blocks are skipped and errors escape methods that should run cleanup code.
Exception tables: finally entries never match · case 02
finally blocks are skipped and errors escape methods that should run cleanup code.
Exception tables: finally entries never match · case 03
finally blocks are skipped and errors escape methods that should run cleanup code.
Exception tables: finally entries never match · case 04
finally blocks are skipped and errors escape methods that should run cleanup code.
Exception tables: finally entries never match · case 05
finally blocks are skipped and errors escape methods that should run cleanup code.
Exception tables: caller frames looked up at the return address · case 01
An exception propagating out of a call at the end of a try block misses the caller's handler.
Exception tables: caller frames looked up at the return address · case 02
An exception propagating out of a call at the end of a try block misses the caller's handler.
Exception tables: caller frames looked up at the return address · case 03
An exception propagating out of a call at the end of a try block misses the caller's handler.
Exception tables: caller frames looked up at the return address · case 04
An exception propagating out of a call at the end of a try block misses the caller's handler.
Exception tables: caller frames looked up at the return address · case 05
An exception propagating out of a call at the end of a try block misses the caller's handler.
Exception tables: handler entered with stale operands · case 01
Handlers see leftover operands beneath the exception and stack-depth verification assumptions break.
Exception tables: handler entered with stale operands · case 02
Handlers see leftover operands beneath the exception and stack-depth verification assumptions break.
Exception tables: handler entered with stale operands · case 03
Handlers see leftover operands beneath the exception and stack-depth verification assumptions break.
Exception tables: handler entered with stale operands · case 04
Handlers see leftover operands beneath the exception and stack-depth verification assumptions break.
Exception tables: handler entered with stale operands · case 05
Handlers see leftover operands beneath the exception and stack-depth verification assumptions break.
Line table: line deltas decoded as unsigned bytes · case 01
Lines that move backwards (loops, decorators) jump forward by hundreds.
Line table: line deltas decoded as unsigned bytes · case 02
Lines that move backwards (loops, decorators) jump forward by hundreds.
Line table: line deltas decoded as unsigned bytes · case 03
Lines that move backwards (loops, decorators) jump forward by hundreds.
Line table: line deltas decoded as unsigned bytes · case 04
Lines that move backwards (loops, decorators) jump forward by hundreds.
Line table: line deltas decoded as unsigned bytes · case 05
Lines that move backwards (loops, decorators) jump forward by hundreds.
Line table: zero deltas treated as no-line markers · case 01
Instructions that stay on the same line report no line, while true markers subtract 128.
Line table: zero deltas treated as no-line markers · case 02
Instructions that stay on the same line report no line, while true markers subtract 128.
Line table: zero deltas treated as no-line markers · case 03
Instructions that stay on the same line report no line, while true markers subtract 128.
Line table: zero deltas treated as no-line markers · case 04
Instructions that stay on the same line report no line, while true markers subtract 128.
Line table: zero deltas treated as no-line markers · case 05
Instructions that stay on the same line report no line, while true markers subtract 128.
Line table: offsets equal to an entry start use the previous line · case 01
The first instruction of each line is attributed to the line before it; offset 0 wraps to the last line.
Line table: offsets equal to an entry start use the previous line · case 02
The first instruction of each line is attributed to the line before it; offset 0 wraps to the last line.
Line table: offsets equal to an entry start use the previous line · case 03
The first instruction of each line is attributed to the line before it; offset 0 wraps to the last line.
Line table: offsets equal to an entry start use the previous line · case 04
The first instruction of each line is attributed to the line before it; offset 0 wraps to the last line.
Line table: offsets equal to an entry start use the previous line · case 05
The first instruction of each line is attributed to the line before it; offset 0 wraps to the last line.
INSPECTABLE BY DESIGN
Every result has a runnable source.
Runnable implementations with recorded outputs, source hashes, and explicit contracts. Related variants share a failure mechanism and belong together in evaluation splits.
Read the methodology ↗