broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent_label']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['old_parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The scope completion transition produces an incorrect observable state.

Changing the parent picker invalidates child suggestions, child query epoch and incompatible child value. Draft may be preserved for a new scoped search. Child labels are never used as parent identifiers, and clearing a parent disables dependent search. Compatible values survive explicit scope membership checks.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child']
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

meaning: Fixture-count band, not measured model difficulty

deps: stdlib

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['members'][0] if d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The child completion transition produces an incorrect observable state.

Changing the parent picker invalidates child suggestions, child query epoch and incompatible child value. Draft may be preserved for a new scoped search. Child labels are never used as parent identifiers, and clearing a parent disables dependent search. Compatible values survive explicit scope membership checks.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return d['members']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The rows completion transition produces an incorrect observable state.

Changing the parent picker invalidates child suggestions, child query epoch and incompatible child value. Draft may be preserved for a new scoped search. Child labels are never used as parent identifiers, and clearing a parent disables dependent search. Compatible values survive explicit scope membership checks.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return bool(d['parent'])!=bool(d['old_parent'])
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent'] is None
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The parent-difference completion transition produces an incorrect observable state.

Changing the parent picker invalidates child suggestions, child query epoch and incompatible child value. Draft may be preserved for a new scoped search. Child labels are never used as parent identifiers, and clearing a parent disables dependent search. Compatible values survive explicit scope membership checks.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return ''
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['child']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The draft completion transition produces an incorrect observable state.

Changing the parent picker invalidates child suggestions, child query epoch and incompatible child value. Draft may be preserved for a new scoped search. Child labels are never used as parent identifiers, and clearing a parent disables dependent search. Compatible values survive explicit scope membership checks.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return True
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent']==d['old_parent']
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The enabled completion transition produces an incorrect observable state.

Changing the parent picker invalidates child suggestions, child query epoch and incompatible child value. Draft may be preserved for a new scoped search. Child labels are never used as parent identifiers, and clearing a parent disables dependent search. Compatible values survive explicit scope membership checks.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return True
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['old_parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The response completion transition produces an incorrect observable state.

Changing the parent picker invalidates child suggestions, child query epoch and incompatible child value. Draft may be preserved for a new scoped search. Child labels are never used as parent identifiers, and clearing a parent disables dependent search. Compatible values survive explicit scope membership checks.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return d['draft']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The pending completion transition produces an incorrect observable state.

Changing the parent picker invalidates child suggestions, child query epoch and incompatible child value. Draft may be preserved for a new scoped search. Child labels are never used as parent identifiers, and clearing a parent disables dependent search. Compatible values survive explicit scope membership checks.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is not None
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return True
    if event == 'descriptor': return [d['parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The membership completion transition produces an incorrect observable state.

Changing the parent picker invalidates child suggestions, child query epoch and incompatible child value. Draft may be preserved for a new scoped search. Child labels are never used as parent identifiers, and clearing a parent disables dependent search. Compatible values survive explicit scope membership checks.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['old_parent'],d['draft'],d['epoch']]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'scope': return d['parent']
    if event == 'child': return d['child'] if d['child'] in d['members'] else None
    if event == 'rows': return [] if d['parent']!=d['old_parent'] else d['rows']
    if event == 'parent-difference': return d['parent']!=d['old_parent']
    if event == 'draft': return d['draft']
    if event == 'enabled': return d['parent'] is not None
    if event == 'response': return d['response_parent']==d['parent']
    if event == 'pending': return None if d['parent']!=d['old_parent'] else d['pending']
    if event == 'membership': return d['child'] is None or d['child'] in d['members']
    if event == 'descriptor': return [d['parent'],d['draft'],0]
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'parent':'country-b','old_parent':'country-a','child':'city-a','members':['city-b'],'draft':'san','rows':['city-a'],'epoch':N,'response_parent':'country-a','parent_label':'Country B','pending':'san'}
boundary = {'parent':None,'old_parent':None,'child':None,'members':[],'draft':'','rows':[],'epoch':N,'response_parent':None,'parent_label':'','pending':None}
check('normal scope', solve('scope', normal), 'country-b')
check('boundary scope', solve('scope', boundary), None)
check('normal child', solve('child', normal), None)
check('boundary child', solve('child', boundary), None)
check('normal rows', solve('rows', normal), [])
check('boundary rows', solve('rows', boundary), [])
check('normal parent-difference', solve('parent-difference', normal), True)
check('boundary parent-difference', solve('parent-difference', boundary), False)
check('normal draft', solve('draft', normal), 'san')
check('boundary draft', solve('draft', boundary), '')
check('normal enabled', solve('enabled', normal), True)
check('boundary enabled', solve('enabled', boundary), False)
check('normal response', solve('response', normal), False)
check('boundary response', solve('response', boundary), True)
check('normal pending', solve('pending', normal), None)
check('boundary pending', solve('pending', boundary), None)
check('normal membership', solve('membership', normal), False)
check('boundary membership', solve('membership', boundary), True)
check('normal descriptor', solve('descriptor', normal), ['country-b','san',N])
check('boundary descriptor', solve('descriptor', boundary), [None,'',N])
variant = dict(normal, **{'draft':'q'*N})
check('variant query or selection payload', solve('draft', variant), 'q'*N)
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The descriptor completion transition produces an incorrect observable state.

Changing the parent picker invalidates child suggestions, child query epoch and incompatible child value. Draft may be preserved for a new scoped search. Child labels are never used as parent identifiers, and clearing a parent disables dependent search. Compatible values survive explicit scope membership checks.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'same-id': return d['old_object']==d['new_object']
    if event == 'rerender': return d['draft'] if d['dirty'] and not d['ack'] else d['label']
    if event == 'external-value': return d['incoming']
    if event == 'external-draft': return d['label']
    if event == 'external-preview': return ''
    if event == 'parent-echo': return [] if d['ack'] else [d['incoming']]
    if event == 'ack-dirty': return False if d['ack'] else d['dirty']
    if event == 'stale-parent': return d['incoming_epoch']==d['epoch']
    if event == 'label-refresh': return {'id':d['old_object']['id'],'label':d['new_object']['label']}
    if event == 'change-detection': return d['incoming']!=d['value']
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'value':'a','incoming':'b','label':'Bee','draft':'bea','dirty':True,'ack':False,'preview':'beam','epoch':N,'incoming_epoch':N-1,'old_object':{'id':'a','label':'A'},'new_object':{'id':'a','label':'A2'}}
boundary = {'value':None,'incoming':None,'label':'','draft':'','dirty':False,'ack':True,'preview':'','epoch':N,'incoming_epoch':N,'old_object':{'id':'','label':''},'new_object':{'id':'','label':''}}
check('normal same-id', solve('same-id', normal), True)
check('boundary same-id', solve('same-id', boundary), True)
check('normal rerender', solve('rerender', normal), 'bea')
check('boundary rerender', solve('rerender', boundary), '')
check('normal external-value', solve('external-value', normal), 'b')
check('boundary external-value', solve('external-value', boundary), None)
check('normal external-draft', solve('external-draft', normal), 'Bee')
check('boundary external-draft', solve('external-draft', boundary), '')
check('normal external-preview', solve('external-preview', normal), '')
check('boundary external-preview', solve('external-preview', boundary), '')
check('normal parent-echo', solve('parent-echo', normal), ['b'])
check('boundary parent-echo', solve('parent-echo', boundary), [])
check('normal ack-dirty', solve('ack-dirty', normal), True)
check('boundary ack-dirty', solve('ack-dirty', boundary), False)
check('normal stale-parent', solve('stale-parent', normal), False)
check('boundary stale-parent', solve('stale-parent', boundary), True)
check('normal label-refresh', solve('label-refresh', normal), {'id':'a','label':'A2'})
check('boundary label-refresh', solve('label-refresh', boundary), {'id':'','label':''})
check('normal change-detection', solve('change-detection', normal), True)
check('boundary change-detection', solve('change-detection', boundary), False)
variant = dict(normal, **{'incoming':'id'+str(N)})
check('variant query or selection payload', solve('external-value', variant), 'id'+str(N))
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'same-id': return False
    if event == 'rerender': return d['draft'] if d['dirty'] and not d['ack'] else d['label']
    if event == 'external-value': return d['incoming']
    if event == 'external-draft': return d['label']
    if event == 'external-preview': return ''
    if event == 'parent-echo': return [] if d['ack'] else [d['incoming']]
    if event == 'ack-dirty': return False if d['ack'] else d['dirty']
    if event == 'stale-parent': return d['incoming_epoch']==d['epoch']
    if event == 'label-refresh': return {'id':d['old_object']['id'],'label':d['new_object']['label']}
    if event == 'change-detection': return d['incoming']!=d['value']
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'value':'a','incoming':'b','label':'Bee','draft':'bea','dirty':True,'ack':False,'preview':'beam','epoch':N,'incoming_epoch':N-1,'old_object':{'id':'a','label':'A'},'new_object':{'id':'a','label':'A2'}}
boundary = {'value':None,'incoming':None,'label':'','draft':'','dirty':False,'ack':True,'preview':'','epoch':N,'incoming_epoch':N,'old_object':{'id':'','label':''},'new_object':{'id':'','label':''}}
check('normal same-id', solve('same-id', normal), True)
check('boundary same-id', solve('same-id', boundary), True)
check('normal rerender', solve('rerender', normal), 'bea')
check('boundary rerender', solve('rerender', boundary), '')
check('normal external-value', solve('external-value', normal), 'b')
check('boundary external-value', solve('external-value', boundary), None)
check('normal external-draft', solve('external-draft', normal), 'Bee')
check('boundary external-draft', solve('external-draft', boundary), '')
check('normal external-preview', solve('external-preview', normal), '')
check('boundary external-preview', solve('external-preview', boundary), '')
check('normal parent-echo', solve('parent-echo', normal), ['b'])
check('boundary parent-echo', solve('parent-echo', boundary), [])
check('normal ack-dirty', solve('ack-dirty', normal), True)
check('boundary ack-dirty', solve('ack-dirty', boundary), False)
check('normal stale-parent', solve('stale-parent', normal), False)
check('boundary stale-parent', solve('stale-parent', boundary), True)
check('normal label-refresh', solve('label-refresh', normal), {'id':'a','label':'A2'})
check('boundary label-refresh', solve('label-refresh', boundary), {'id':'','label':''})
check('normal change-detection', solve('change-detection', normal), True)
check('boundary change-detection', solve('change-detection', boundary), False)
variant = dict(normal, **{'incoming':'id'+str(N)})
check('variant query or selection payload', solve('external-value', variant), 'id'+str(N))
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The same-id completion transition produces an incorrect observable state.

Parent-provided value updates are distinguished from unacknowledged draft edits. An acknowledged commit may reset the draft to its label; unrelated rerenders preserve dirty draft. External value replacement clears preview and invalidates result epoch. Object identity is irrelevant; stable option identifiers determine equality.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'same-id': return d['old_object']['id']==d['new_object']['id']
    if event == 'rerender': return d['label']
    if event == 'external-value': return d['incoming']
    if event == 'external-draft': return d['label']
    if event == 'external-preview': return ''
    if event == 'parent-echo': return [] if d['ack'] else [d['incoming']]
    if event == 'ack-dirty': return False if d['ack'] else d['dirty']
    if event == 'stale-parent': return d['incoming_epoch']==d['epoch']
    if event == 'label-refresh': return {'id':d['old_object']['id'],'label':d['new_object']['label']}
    if event == 'change-detection': return d['incoming']!=d['value']
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'value':'a','incoming':'b','label':'Bee','draft':'bea','dirty':True,'ack':False,'preview':'beam','epoch':N,'incoming_epoch':N-1,'old_object':{'id':'a','label':'A'},'new_object':{'id':'a','label':'A2'}}
boundary = {'value':None,'incoming':None,'label':'','draft':'','dirty':False,'ack':True,'preview':'','epoch':N,'incoming_epoch':N,'old_object':{'id':'','label':''},'new_object':{'id':'','label':''}}
check('normal same-id', solve('same-id', normal), True)
check('boundary same-id', solve('same-id', boundary), True)
check('normal rerender', solve('rerender', normal), 'bea')
check('boundary rerender', solve('rerender', boundary), '')
check('normal external-value', solve('external-value', normal), 'b')
check('boundary external-value', solve('external-value', boundary), None)
check('normal external-draft', solve('external-draft', normal), 'Bee')
check('boundary external-draft', solve('external-draft', boundary), '')
check('normal external-preview', solve('external-preview', normal), '')
check('boundary external-preview', solve('external-preview', boundary), '')
check('normal parent-echo', solve('parent-echo', normal), ['b'])
check('boundary parent-echo', solve('parent-echo', boundary), [])
check('normal ack-dirty', solve('ack-dirty', normal), True)
check('boundary ack-dirty', solve('ack-dirty', boundary), False)
check('normal stale-parent', solve('stale-parent', normal), False)
check('boundary stale-parent', solve('stale-parent', boundary), True)
check('normal label-refresh', solve('label-refresh', normal), {'id':'a','label':'A2'})
check('boundary label-refresh', solve('label-refresh', boundary), {'id':'','label':''})
check('normal change-detection', solve('change-detection', normal), True)
check('boundary change-detection', solve('change-detection', boundary), False)
variant = dict(normal, **{'incoming':'id'+str(N)})
check('variant query or selection payload', solve('external-value', variant), 'id'+str(N))
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'same-id': return d['old_object']['id']==d['new_object']['id']
    if event == 'rerender': return d['value']
    if event == 'external-value': return d['incoming']
    if event == 'external-draft': return d['label']
    if event == 'external-preview': return ''
    if event == 'parent-echo': return [] if d['ack'] else [d['incoming']]
    if event == 'ack-dirty': return False if d['ack'] else d['dirty']
    if event == 'stale-parent': return d['incoming_epoch']==d['epoch']
    if event == 'label-refresh': return {'id':d['old_object']['id'],'label':d['new_object']['label']}
    if event == 'change-detection': return d['incoming']!=d['value']
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'value':'a','incoming':'b','label':'Bee','draft':'bea','dirty':True,'ack':False,'preview':'beam','epoch':N,'incoming_epoch':N-1,'old_object':{'id':'a','label':'A'},'new_object':{'id':'a','label':'A2'}}
boundary = {'value':None,'incoming':None,'label':'','draft':'','dirty':False,'ack':True,'preview':'','epoch':N,'incoming_epoch':N,'old_object':{'id':'','label':''},'new_object':{'id':'','label':''}}
check('normal same-id', solve('same-id', normal), True)
check('boundary same-id', solve('same-id', boundary), True)
check('normal rerender', solve('rerender', normal), 'bea')
check('boundary rerender', solve('rerender', boundary), '')
check('normal external-value', solve('external-value', normal), 'b')
check('boundary external-value', solve('external-value', boundary), None)
check('normal external-draft', solve('external-draft', normal), 'Bee')
check('boundary external-draft', solve('external-draft', boundary), '')
check('normal external-preview', solve('external-preview', normal), '')
check('boundary external-preview', solve('external-preview', boundary), '')
check('normal parent-echo', solve('parent-echo', normal), ['b'])
check('boundary parent-echo', solve('parent-echo', boundary), [])
check('normal ack-dirty', solve('ack-dirty', normal), True)
check('boundary ack-dirty', solve('ack-dirty', boundary), False)
check('normal stale-parent', solve('stale-parent', normal), False)
check('boundary stale-parent', solve('stale-parent', boundary), True)
check('normal label-refresh', solve('label-refresh', normal), {'id':'a','label':'A2'})
check('boundary label-refresh', solve('label-refresh', boundary), {'id':'','label':''})
check('normal change-detection', solve('change-detection', normal), True)
check('boundary change-detection', solve('change-detection', boundary), False)
variant = dict(normal, **{'incoming':'id'+str(N)})
check('variant query or selection payload', solve('external-value', variant), 'id'+str(N))
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The rerender completion transition produces an incorrect observable state.

Parent-provided value updates are distinguished from unacknowledged draft edits. An acknowledged commit may reset the draft to its label; unrelated rerenders preserve dirty draft. External value replacement clears preview and invalidates result epoch. Object identity is irrelevant; stable option identifiers determine equality.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'same-id': return d['old_object']['id']==d['new_object']['id']
    if event == 'rerender': return d['draft'] if d['dirty'] and not d['ack'] else d['label']
    if event == 'external-value': return d['value']
    if event == 'external-draft': return d['label']
    if event == 'external-preview': return ''
    if event == 'parent-echo': return [] if d['ack'] else [d['incoming']]
    if event == 'ack-dirty': return False if d['ack'] else d['dirty']
    if event == 'stale-parent': return d['incoming_epoch']==d['epoch']
    if event == 'label-refresh': return {'id':d['old_object']['id'],'label':d['new_object']['label']}
    if event == 'change-detection': return d['incoming']!=d['value']
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'value':'a','incoming':'b','label':'Bee','draft':'bea','dirty':True,'ack':False,'preview':'beam','epoch':N,'incoming_epoch':N-1,'old_object':{'id':'a','label':'A'},'new_object':{'id':'a','label':'A2'}}
boundary = {'value':None,'incoming':None,'label':'','draft':'','dirty':False,'ack':True,'preview':'','epoch':N,'incoming_epoch':N,'old_object':{'id':'','label':''},'new_object':{'id':'','label':''}}
check('normal same-id', solve('same-id', normal), True)
check('boundary same-id', solve('same-id', boundary), True)
check('normal rerender', solve('rerender', normal), 'bea')
check('boundary rerender', solve('rerender', boundary), '')
check('normal external-value', solve('external-value', normal), 'b')
check('boundary external-value', solve('external-value', boundary), None)
check('normal external-draft', solve('external-draft', normal), 'Bee')
check('boundary external-draft', solve('external-draft', boundary), '')
check('normal external-preview', solve('external-preview', normal), '')
check('boundary external-preview', solve('external-preview', boundary), '')
check('normal parent-echo', solve('parent-echo', normal), ['b'])
check('boundary parent-echo', solve('parent-echo', boundary), [])
check('normal ack-dirty', solve('ack-dirty', normal), True)
check('boundary ack-dirty', solve('ack-dirty', boundary), False)
check('normal stale-parent', solve('stale-parent', normal), False)
check('boundary stale-parent', solve('stale-parent', boundary), True)
check('normal label-refresh', solve('label-refresh', normal), {'id':'a','label':'A2'})
check('boundary label-refresh', solve('label-refresh', boundary), {'id':'','label':''})
check('normal change-detection', solve('change-detection', normal), True)
check('boundary change-detection', solve('change-detection', boundary), False)
variant = dict(normal, **{'incoming':'id'+str(N)})
check('variant query or selection payload', solve('external-value', variant), 'id'+str(N))
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'same-id': return d['old_object']['id']==d['new_object']['id']
    if event == 'rerender': return d['draft'] if d['dirty'] and not d['ack'] else d['label']
    if event == 'external-value': return d['label']
    if event == 'external-draft': return d['label']
    if event == 'external-preview': return ''
    if event == 'parent-echo': return [] if d['ack'] else [d['incoming']]
    if event == 'ack-dirty': return False if d['ack'] else d['dirty']
    if event == 'stale-parent': return d['incoming_epoch']==d['epoch']
    if event == 'label-refresh': return {'id':d['old_object']['id'],'label':d['new_object']['label']}
    if event == 'change-detection': return d['incoming']!=d['value']
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'value':'a','incoming':'b','label':'Bee','draft':'bea','dirty':True,'ack':False,'preview':'beam','epoch':N,'incoming_epoch':N-1,'old_object':{'id':'a','label':'A'},'new_object':{'id':'a','label':'A2'}}
boundary = {'value':None,'incoming':None,'label':'','draft':'','dirty':False,'ack':True,'preview':'','epoch':N,'incoming_epoch':N,'old_object':{'id':'','label':''},'new_object':{'id':'','label':''}}
check('normal same-id', solve('same-id', normal), True)
check('boundary same-id', solve('same-id', boundary), True)
check('normal rerender', solve('rerender', normal), 'bea')
check('boundary rerender', solve('rerender', boundary), '')
check('normal external-value', solve('external-value', normal), 'b')
check('boundary external-value', solve('external-value', boundary), None)
check('normal external-draft', solve('external-draft', normal), 'Bee')
check('boundary external-draft', solve('external-draft', boundary), '')
check('normal external-preview', solve('external-preview', normal), '')
check('boundary external-preview', solve('external-preview', boundary), '')
check('normal parent-echo', solve('parent-echo', normal), ['b'])
check('boundary parent-echo', solve('parent-echo', boundary), [])
check('normal ack-dirty', solve('ack-dirty', normal), True)
check('boundary ack-dirty', solve('ack-dirty', boundary), False)
check('normal stale-parent', solve('stale-parent', normal), False)
check('boundary stale-parent', solve('stale-parent', boundary), True)
check('normal label-refresh', solve('label-refresh', normal), {'id':'a','label':'A2'})
check('boundary label-refresh', solve('label-refresh', boundary), {'id':'','label':''})
check('normal change-detection', solve('change-detection', normal), True)
check('boundary change-detection', solve('change-detection', boundary), False)
variant = dict(normal, **{'incoming':'id'+str(N)})
check('variant query or selection payload', solve('external-value', variant), 'id'+str(N))
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The external-value completion transition produces an incorrect observable state.

Parent-provided value updates are distinguished from unacknowledged draft edits. An acknowledged commit may reset the draft to its label; unrelated rerenders preserve dirty draft. External value replacement clears preview and invalidates result epoch. Object identity is irrelevant; stable option identifiers determine equality.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'same-id': return d['old_object']['id']==d['new_object']['id']
    if event == 'rerender': return d['draft'] if d['dirty'] and not d['ack'] else d['label']
    if event == 'external-value': return d['incoming']
    if event == 'external-draft': return d['draft']
    if event == 'external-preview': return ''
    if event == 'parent-echo': return [] if d['ack'] else [d['incoming']]
    if event == 'ack-dirty': return False if d['ack'] else d['dirty']
    if event == 'stale-parent': return d['incoming_epoch']==d['epoch']
    if event == 'label-refresh': return {'id':d['old_object']['id'],'label':d['new_object']['label']}
    if event == 'change-detection': return d['incoming']!=d['value']
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'value':'a','incoming':'b','label':'Bee','draft':'bea','dirty':True,'ack':False,'preview':'beam','epoch':N,'incoming_epoch':N-1,'old_object':{'id':'a','label':'A'},'new_object':{'id':'a','label':'A2'}}
boundary = {'value':None,'incoming':None,'label':'','draft':'','dirty':False,'ack':True,'preview':'','epoch':N,'incoming_epoch':N,'old_object':{'id':'','label':''},'new_object':{'id':'','label':''}}
check('normal same-id', solve('same-id', normal), True)
check('boundary same-id', solve('same-id', boundary), True)
check('normal rerender', solve('rerender', normal), 'bea')
check('boundary rerender', solve('rerender', boundary), '')
check('normal external-value', solve('external-value', normal), 'b')
check('boundary external-value', solve('external-value', boundary), None)
check('normal external-draft', solve('external-draft', normal), 'Bee')
check('boundary external-draft', solve('external-draft', boundary), '')
check('normal external-preview', solve('external-preview', normal), '')
check('boundary external-preview', solve('external-preview', boundary), '')
check('normal parent-echo', solve('parent-echo', normal), ['b'])
check('boundary parent-echo', solve('parent-echo', boundary), [])
check('normal ack-dirty', solve('ack-dirty', normal), True)
check('boundary ack-dirty', solve('ack-dirty', boundary), False)
check('normal stale-parent', solve('stale-parent', normal), False)
check('boundary stale-parent', solve('stale-parent', boundary), True)
check('normal label-refresh', solve('label-refresh', normal), {'id':'a','label':'A2'})
check('boundary label-refresh', solve('label-refresh', boundary), {'id':'','label':''})
check('normal change-detection', solve('change-detection', normal), True)
check('boundary change-detection', solve('change-detection', boundary), False)
variant = dict(normal, **{'incoming':'id'+str(N)})
check('variant query or selection payload', solve('external-value', variant), 'id'+str(N))
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'same-id': return d['old_object']['id']==d['new_object']['id']
    if event == 'rerender': return d['draft'] if d['dirty'] and not d['ack'] else d['label']
    if event == 'external-value': return d['incoming']
    if event == 'external-draft': return d['incoming']
    if event == 'external-preview': return ''
    if event == 'parent-echo': return [] if d['ack'] else [d['incoming']]
    if event == 'ack-dirty': return False if d['ack'] else d['dirty']
    if event == 'stale-parent': return d['incoming_epoch']==d['epoch']
    if event == 'label-refresh': return {'id':d['old_object']['id'],'label':d['new_object']['label']}
    if event == 'change-detection': return d['incoming']!=d['value']
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'value':'a','incoming':'b','label':'Bee','draft':'bea','dirty':True,'ack':False,'preview':'beam','epoch':N,'incoming_epoch':N-1,'old_object':{'id':'a','label':'A'},'new_object':{'id':'a','label':'A2'}}
boundary = {'value':None,'incoming':None,'label':'','draft':'','dirty':False,'ack':True,'preview':'','epoch':N,'incoming_epoch':N,'old_object':{'id':'','label':''},'new_object':{'id':'','label':''}}
check('normal same-id', solve('same-id', normal), True)
check('boundary same-id', solve('same-id', boundary), True)
check('normal rerender', solve('rerender', normal), 'bea')
check('boundary rerender', solve('rerender', boundary), '')
check('normal external-value', solve('external-value', normal), 'b')
check('boundary external-value', solve('external-value', boundary), None)
check('normal external-draft', solve('external-draft', normal), 'Bee')
check('boundary external-draft', solve('external-draft', boundary), '')
check('normal external-preview', solve('external-preview', normal), '')
check('boundary external-preview', solve('external-preview', boundary), '')
check('normal parent-echo', solve('parent-echo', normal), ['b'])
check('boundary parent-echo', solve('parent-echo', boundary), [])
check('normal ack-dirty', solve('ack-dirty', normal), True)
check('boundary ack-dirty', solve('ack-dirty', boundary), False)
check('normal stale-parent', solve('stale-parent', normal), False)
check('boundary stale-parent', solve('stale-parent', boundary), True)
check('normal label-refresh', solve('label-refresh', normal), {'id':'a','label':'A2'})
check('boundary label-refresh', solve('label-refresh', boundary), {'id':'','label':''})
check('normal change-detection', solve('change-detection', normal), True)
check('boundary change-detection', solve('change-detection', boundary), False)
variant = dict(normal, **{'incoming':'id'+str(N)})
check('variant query or selection payload', solve('external-value', variant), 'id'+str(N))
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The external-draft completion transition produces an incorrect observable state.

Parent-provided value updates are distinguished from unacknowledged draft edits. An acknowledged commit may reset the draft to its label; unrelated rerenders preserve dirty draft. External value replacement clears preview and invalidates result epoch. Object identity is irrelevant; stable option identifiers determine equality.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'same-id': return d['old_object']['id']==d['new_object']['id']
    if event == 'rerender': return d['draft'] if d['dirty'] and not d['ack'] else d['label']
    if event == 'external-value': return d['incoming']
    if event == 'external-draft': return d['label']
    if event == 'external-preview': return d['preview']
    if event == 'parent-echo': return [] if d['ack'] else [d['incoming']]
    if event == 'ack-dirty': return False if d['ack'] else d['dirty']
    if event == 'stale-parent': return d['incoming_epoch']==d['epoch']
    if event == 'label-refresh': return {'id':d['old_object']['id'],'label':d['new_object']['label']}
    if event == 'change-detection': return d['incoming']!=d['value']
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'value':'a','incoming':'b','label':'Bee','draft':'bea','dirty':True,'ack':False,'preview':'beam','epoch':N,'incoming_epoch':N-1,'old_object':{'id':'a','label':'A'},'new_object':{'id':'a','label':'A2'}}
boundary = {'value':None,'incoming':None,'label':'','draft':'','dirty':False,'ack':True,'preview':'','epoch':N,'incoming_epoch':N,'old_object':{'id':'','label':''},'new_object':{'id':'','label':''}}
check('normal same-id', solve('same-id', normal), True)
check('boundary same-id', solve('same-id', boundary), True)
check('normal rerender', solve('rerender', normal), 'bea')
check('boundary rerender', solve('rerender', boundary), '')
check('normal external-value', solve('external-value', normal), 'b')
check('boundary external-value', solve('external-value', boundary), None)
check('normal external-draft', solve('external-draft', normal), 'Bee')
check('boundary external-draft', solve('external-draft', boundary), '')
check('normal external-preview', solve('external-preview', normal), '')
check('boundary external-preview', solve('external-preview', boundary), '')
check('normal parent-echo', solve('parent-echo', normal), ['b'])
check('boundary parent-echo', solve('parent-echo', boundary), [])
check('normal ack-dirty', solve('ack-dirty', normal), True)
check('boundary ack-dirty', solve('ack-dirty', boundary), False)
check('normal stale-parent', solve('stale-parent', normal), False)
check('boundary stale-parent', solve('stale-parent', boundary), True)
check('normal label-refresh', solve('label-refresh', normal), {'id':'a','label':'A2'})
check('boundary label-refresh', solve('label-refresh', boundary), {'id':'','label':''})
check('normal change-detection', solve('change-detection', normal), True)
check('boundary change-detection', solve('change-detection', boundary), False)
variant = dict(normal, **{'incoming':'id'+str(N)})
check('variant query or selection payload', solve('external-value', variant), 'id'+str(N))
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(event, d):
    if event == 'same-id': return d['old_object']['id']==d['new_object']['id']
    if event == 'rerender': return d['draft'] if d['dirty'] and not d['ack'] else d['label']
    if event == 'external-value': return d['incoming']
    if event == 'external-draft': return d['label']
    if event == 'external-preview': return d['label']
    if event == 'parent-echo': return [] if d['ack'] else [d['incoming']]
    if event == 'ack-dirty': return False if d['ack'] else d['dirty']
    if event == 'stale-parent': return d['incoming_epoch']==d['epoch']
    if event == 'label-refresh': return {'id':d['old_object']['id'],'label':d['new_object']['label']}
    if event == 'change-detection': return d['incoming']!=d['value']
    return {'unchanged': True}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
normal = {'value':'a','incoming':'b','label':'Bee','draft':'bea','dirty':True,'ack':False,'preview':'beam','epoch':N,'incoming_epoch':N-1,'old_object':{'id':'a','label':'A'},'new_object':{'id':'a','label':'A2'}}
boundary = {'value':None,'incoming':None,'label':'','draft':'','dirty':False,'ack':True,'preview':'','epoch':N,'incoming_epoch':N,'old_object':{'id':'','label':''},'new_object':{'id':'','label':''}}
check('normal same-id', solve('same-id', normal), True)
check('boundary same-id', solve('same-id', boundary), True)
check('normal rerender', solve('rerender', normal), 'bea')
check('boundary rerender', solve('rerender', boundary), '')
check('normal external-value', solve('external-value', normal), 'b')
check('boundary external-value', solve('external-value', boundary), None)
check('normal external-draft', solve('external-draft', normal), 'Bee')
check('boundary external-draft', solve('external-draft', boundary), '')
check('normal external-preview', solve('external-preview', normal), '')
check('boundary external-preview', solve('external-preview', boundary), '')
check('normal parent-echo', solve('parent-echo', normal), ['b'])
check('boundary parent-echo', solve('parent-echo', boundary), [])
check('normal ack-dirty', solve('ack-dirty', normal), True)
check('boundary ack-dirty', solve('ack-dirty', boundary), False)
check('normal stale-parent', solve('stale-parent', normal), False)
check('boundary stale-parent', solve('stale-parent', boundary), True)
check('normal label-refresh', solve('label-refresh', normal), {'id':'a','label':'A2'})
check('boundary label-refresh', solve('label-refresh', boundary), {'id':'','label':''})
check('normal change-detection', solve('change-detection', normal), True)
check('boundary change-detection', solve('change-detection', boundary), False)
variant = dict(normal, **{'incoming':'id'+str(N)})
check('variant query or selection payload', solve('external-value', variant), 'id'+str(N))
check('unknown completion event', solve('unrecognized', normal), {'unchanged': True})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
The external-preview completion transition produces an incorrect observable state.

Parent-provided value updates are distinguished from unacknowledged draft edits. An acknowledged commit may reset the draft to its label; unrelated rerenders preserve dirty draft. External value replacement clears preview and invalidates result epoch. Object identity is irrelevant; stable option identifiers determine equality.

split: open-access