broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, location is not None, mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode != 'error', mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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:
Build a bounded manual redirect result without issuing the next request: the manual no dispatch branch emits an incorrect decision.

Build a bounded manual redirect result without issuing the next request. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error', status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode != 'follow', status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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:
Build a bounded manual redirect result without issuing the next request: the redirect error envelope branch emits an incorrect decision.

Build a bounded manual redirect result without issuing the next request. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if origin == 'same' else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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:
Build a bounded manual redirect result without issuing the next request: the opaque status branch emits an incorrect decision.

Build a bounded manual redirect result without issuing the next request. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body, 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body if mode == 'follow' else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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:
Build a bounded manual redirect result without issuing the next request: the opaque body branch emits an incorrect decision.

Build a bounded manual redirect result without issuing the next request. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and exposed else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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:
Build a bounded manual redirect result without issuing the next request: the manual result kind branch emits an incorrect decision.

Build a bounded manual redirect result without issuing the next request. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed, exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', origin == 'same', exposed and mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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:
Build a bounded manual redirect result without issuing the next request: the header exposure origin branch emits an incorrect decision.

Build a bounded manual redirect result without issuing the next request. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed, location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', mode != 'error', location is not None, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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:
Build a bounded manual redirect result without issuing the next request: the body readability branch emits an incorrect decision.

Build a bounded manual redirect result without issuing the next request. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', status >= 300, status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', bool(location), status//100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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:
Build a bounded manual redirect result without issuing the next request: the missing location not redirect branch emits an incorrect decision.

Build a bounded manual redirect result without issuing the next request. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, 3 if location else 2]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, mode, location, exposed, origin, body, status):
    return {'request': request, 'decision': [location if exposed else None, mode == 'follow' and location is not None, mode == 'error' and location is not None, status if exposed else 0, body if exposed else '', 'manual-redirect' if mode == 'manual' and location is not None else 'response', exposed and origin == 'same', exposed and mode != 'error', location is not None, status%100]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'manual', '/b', True, 'same', 'abc', 302), {'request': '/requests/' + str(N) + '/0', 'decision': ['/b', False, False, 302, 'abc', 'manual-redirect', True, True, True, 3]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'follow', '', True, 'cross', 'read', 307), {'request': '/requests/' + str(N) + '/1', 'decision': ['', True, False, 307, 'read', 'response', False, True, True, 3]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'error', '/d', True, 'same', 'err', 301), {'request': '/requests/' + str(N) + '/2', 'decision': ['/d', False, True, 301, 'err', 'response', True, False, True, 3]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'manual', '/e', False, 'same', 'abc', 303), {'request': '/requests/' + str(N) + '/3', 'decision': [None, False, False, 0, '', 'manual-redirect', False, False, True, 3]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'error', None, True, 'same', '', 200), {'request': '/requests/' + str(N) + '/4', 'decision': [None, False, False, 200, '', 'response', True, False, False, 2]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'follow', None, False, 'cross', 'body', 404), {'request': '/requests/' + str(N) + '/5', 'decision': [None, False, False, 0, '', 'response', False, False, False, 4]})
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:
Build a bounded manual redirect result without issuing the next request: the status class report branch emits an incorrect decision.

Build a bounded manual redirect result without issuing the next request. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [original, statuses[-1], len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final if statuses[-1] < 400 else original, statuses[-1], len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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:
Expose final response metadata without leaking intermediate representation state: the effective url branch emits an incorrect decision.

Expose final response metadata without leaking intermediate representation state. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[0], len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, min(statuses), len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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:
Expose final response metadata without leaking intermediate representation state: the final status branch emits an incorrect decision.

Expose final response metadata without leaking intermediate representation state. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], original != final, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>2, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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:
Expose final response metadata without leaking intermediate representation state: the redirected even return to origin branch emits an incorrect decision.

Expose final response metadata without leaking intermediate representation state. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, '' if len(statuses)>1 else body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body if statuses[-1] == 200 else '', final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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:
Expose final response metadata without leaking intermediate representation state: the final body only branch emits an incorrect decision.

Expose final response metadata without leaking intermediate representation state. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, sum(intermediate_lengths)+final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, max(intermediate_lengths+[final_length]), sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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:
Expose final response metadata without leaking intermediate representation state: the content length final branch emits an incorrect decision.

Expose final response metadata without leaking intermediate representation state. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, final_length, final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, final_length, sum(intermediate_lengths), statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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:
Expose final response metadata without leaking intermediate representation state: the transport bytes all responses branch emits an incorrect decision.

Expose final response metadata without leaking intermediate representation state. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses, len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses[1:], len(statuses)-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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:
Expose final response metadata without leaking intermediate representation state: the history excludes final branch emits an incorrect decision.

Expose final response metadata without leaking intermediate representation state. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses), statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(set(statuses))-1, statuses[-1]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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:
Expose final response metadata without leaking intermediate representation state: the redirect response count branch emits an incorrect decision.

Expose final response metadata without leaking intermediate representation state. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, any(s>=300 for s in statuses), statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[0]>=400, statuses[0]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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:
Expose final response metadata without leaking intermediate representation state: the failure from terminal status branch emits an incorrect decision.

Expose final response metadata without leaking intermediate representation state. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, statuses[-1]]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, original, final, statuses, body, intermediate_lengths, final_length):
    return {'request': request, 'decision': [final, statuses[-1], len(statuses)>1, body, final_length, sum(intermediate_lengths)+final_length, statuses[:-1], len(statuses)-1, statuses[-1]>=400, max(statuses)]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', '/a', '/c', [301, 302, 200], 'ok', [8, 9], 2), {'request': '/requests/' + str(N) + '/0', 'decision': ['/c', 200, True, 'ok', 2, 19, [301, 302], 2, False, 301]})
check('fixture 2', solve('/requests/' + str(N) + '/1', '/a', '/a', [200], '', [], 0), {'request': '/requests/' + str(N) + '/1', 'decision': ['/a', 200, False, '', 0, 0, [], 0, False, 200]})
check('fixture 3', solve('/requests/' + str(N) + '/2', '/x', '/y', [307, 404], 'err', [100], 3), {'request': '/requests/' + str(N) + '/2', 'decision': ['/y', 404, True, 'err', 3, 103, [307], 1, True, 307]})
check('fixture 4', solve('/requests/' + str(N) + '/3', '/x', '/x', [302, 302, 200], 'done', [0, 2], 4), {'request': '/requests/' + str(N) + '/3', 'decision': ['/x', 200, True, 'done', 4, 6, [302, 302], 2, False, 302]})
check('fixture 5', solve('/requests/' + str(N) + '/4', '/m', '/n', [308, 204], '', [5], 0), {'request': '/requests/' + str(N) + '/4', 'decision': ['/n', 204, True, '', 0, 5, [308], 1, False, 308]})
check('fixture 6', solve('/requests/' + str(N) + '/5', '/v', '/w', [303, 500], 'bad', [7], 3), {'request': '/requests/' + str(N) + '/5', 'decision': ['/w', 500, True, 'bad', 3, 10, [303], 1, True, 303]})
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:
Expose final response metadata without leaking intermediate representation state: the first hop record branch emits an incorrect decision.

Expose final response metadata without leaking intermediate representation state. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, scheme, host, port, method, path, query, partition, vary):
    return {'request': request, 'decision': ['https', host.lower(), None if (scheme,port) in (("https",443),("http",80)) else port, method, path, query, '=' in query, partition, vary, len(vary)]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'https', 'H.TEST', 443, 'GET', '/A', 'x=1', 'tab1', ['en', 'gzip']), {'request': '/requests/' + str(N) + '/0', 'decision': ['https', 'h.test', None, 'GET', '/A', 'x=1', True, 'tab1', ['en', 'gzip'], 2]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'https', 'h.test', 8443, 'HEAD', '/a', 'x=2', 'tab2', ['fr', 'br']), {'request': '/requests/' + str(N) + '/1', 'decision': ['https', 'h.test', 8443, 'HEAD', '/a', 'x=2', True, 'tab2', ['fr', 'br'], 2]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'http', 'h.test', 80, 'POST', '/a', 'q=', 'tab1', []), {'request': '/requests/' + str(N) + '/2', 'decision': ['http', 'h.test', None, 'POST', '/a', 'q=', True, 'tab1', [], 0]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'http', 'Z.TEST', 8080, 'GET', '/b', 'b=2&a=1&b=2', 'tab3', ['en', 'br']), {'request': '/requests/' + str(N) + '/3', 'decision': ['http', 'z.test', 8080, 'GET', '/b', 'b=2&a=1&b=2', True, 'tab3', ['en', 'br'], 2]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'https', 'h.test', 443, 'PUT', '/B', 'flag', 'tab2', ['']), {'request': '/requests/' + str(N) + '/4', 'decision': ['https', 'h.test', None, 'PUT', '/B', 'flag', False, 'tab2', [''], 1]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'https', 'h.test', 443, 'GET', '/a', 'x=1', 'tab1', ['gzip', 'en', 'gzip']), {'request': '/requests/' + str(N) + '/5', 'decision': ['https', 'h.test', None, 'GET', '/a', 'x=1', True, 'tab1', ['gzip', 'en', 'gzip'], 3]})
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
from urllib.parse import urlsplit, unquote, quote
import posixpath
import re
N = 1
observations = []
def solve(request, scheme, host, port, method, path, query, partition, vary):
    return {'request': request, 'decision': ['http', host.lower(), None if (scheme,port) in (("https",443),("http",80)) else port, method, path, query, '=' in query, partition, vary, len(vary)]}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve('/requests/' + str(N) + '/0', 'https', 'H.TEST', 443, 'GET', '/A', 'x=1', 'tab1', ['en', 'gzip']), {'request': '/requests/' + str(N) + '/0', 'decision': ['https', 'h.test', None, 'GET', '/A', 'x=1', True, 'tab1', ['en', 'gzip'], 2]})
check('fixture 2', solve('/requests/' + str(N) + '/1', 'https', 'h.test', 8443, 'HEAD', '/a', 'x=2', 'tab2', ['fr', 'br']), {'request': '/requests/' + str(N) + '/1', 'decision': ['https', 'h.test', 8443, 'HEAD', '/a', 'x=2', True, 'tab2', ['fr', 'br'], 2]})
check('fixture 3', solve('/requests/' + str(N) + '/2', 'http', 'h.test', 80, 'POST', '/a', 'q=', 'tab1', []), {'request': '/requests/' + str(N) + '/2', 'decision': ['http', 'h.test', None, 'POST', '/a', 'q=', True, 'tab1', [], 0]})
check('fixture 4', solve('/requests/' + str(N) + '/3', 'http', 'Z.TEST', 8080, 'GET', '/b', 'b=2&a=1&b=2', 'tab3', ['en', 'br']), {'request': '/requests/' + str(N) + '/3', 'decision': ['http', 'z.test', 8080, 'GET', '/b', 'b=2&a=1&b=2', True, 'tab3', ['en', 'br'], 2]})
check('fixture 5', solve('/requests/' + str(N) + '/4', 'https', 'h.test', 443, 'PUT', '/B', 'flag', 'tab2', ['']), {'request': '/requests/' + str(N) + '/4', 'decision': ['https', 'h.test', None, 'PUT', '/B', 'flag', False, 'tab2', [''], 1]})
check('fixture 6', solve('/requests/' + str(N) + '/5', 'https', 'h.test', 443, 'GET', '/a', 'x=1', 'tab1', ['gzip', 'en', 'gzip']), {'request': '/requests/' + str(N) + '/5', 'decision': ['https', 'h.test', None, 'GET', '/a', 'x=1', True, 'tab1', ['gzip', 'en', 'gzip'], 3]})
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:
Partition redirect cache entries by their declared request dimensions: the scheme key branch emits an incorrect decision.

Partition redirect cache entries by their declared request dimensions. The explicit fixture inputs and outputs define a bounded offline policy; request identity must accompany the decision.

split: open-access