FAILURE MAP
← Case archive

FA-27831 / HTTP ranges / Open access

An object store maps upload part numbers and byte ranges onto stored parts: intersection offsets are relative to the containing part · case 01

An object store maps upload part numbers and byte ranges onto stored parts: intersection offsets are relative to the containing part.

Verified by executionVariant 1 · 14 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

The part-number-range-map-part-relative-offset decision uses sizes=x['parts'] total=sum(sizes) starts=[] acc=0 for s in sizes: starts.append(acc) acc+=s q=x['query'] if q[0]=='part': n=q[1] if not 1<=n<=len(sizes) or sizes[n-1]==0: return [416,'bytes */%d'%total] a=starts[n-1] return [206,'bytes %d-%d/%d'%(a,a+sizes[n-1]-1,total)] a,b=q[1],q[2] if not 0<=a<=b<total: return [416,'bytes */%d'%total] out=[] for i,s in enumerate(sizes): lo=max(a,starts[i]) hi=min(b,starts[i]+s-1) if lo<=hi: out.append([i+1,lo,hi-lo+1]) return [206,out].

VERIFIED REPAIR

Apply the bounded decision exactly: sizes=x['parts'] total=sum(sizes) starts=[] acc=0 for s in sizes: starts.append(acc) acc+=s q=x['query'] if q[0]=='part': n=q[1] if not 1<=n<=len(sizes) or sizes[n-1]==0: return [416,'bytes */%d'%total] a=starts[n-1] return [206,'bytes %d-%d/%d'%(a,a+sizes[n-1]-1,total)] a,b=q[1],q[2] if not 0<=a<=b<total: return [416,'bytes */%d'%total] out=[] for i,s in enumerate(sizes): lo=max(a,starts[i]) hi=min(b,starts[i]+s-1) if lo<=hi: out.append([i+1,lo-starts[i],hi-lo+1]) return [206,out]

Unsuccessful approach: The partial repair uses sizes=x['parts'] total=sum(sizes) starts=[] acc=0 for s in sizes: starts.append(acc) acc+=s q=x['query'] if q[0]=='part': n=q[1] if not 1<=n<=len(sizes) or sizes[n-1]==0: return [416,'bytes */%d'%total] a=starts[n-1] return [206,'bytes %d-%d/%d'%(a,a+sizes[n-1]-1,total)] a,b=q[1],q[2] if not 0<=a<=b<total: return [416,'bytes */%d'%total] out=[] for i,s in enumerate(sizes): lo=max(a,starts[i]) hi=min(b,starts[i]+s-1) if lo<=hi: out.append([i+1,lo-a,hi-lo+1]) return [206,out], which still violates the stated contract.

Case contract

x has stored part sizes in order and a query. ["part",n] (1-based) returns [206,bytes a-b/total] for that part, or [416,bytes */total] when n is outside 1..count or the part is empty. ["range",a,b] with inclusive bounds returns [416,bytes */total] unless 0<=a<=b<total; otherwise [206,rows] where each intersecting nonempty part yields [part-number,offset-within-part,count] in part order.

Why this case matters

Range responses combine representation identity, conditional requests, framing, and partial-object state.

1 / The failure

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(x):
    sizes=x['parts']
    total=sum(sizes)
    starts=[]
    acc=0
    for s in sizes:
        starts.append(acc)
        acc+=s
    q=x['query']
    if q[0]=='part':
        n=q[1]
        if not 1<=n<=len(sizes) or sizes[n-1]==0: return [416,'bytes */%d'%total]
        a=starts[n-1]
        return [206,'bytes %d-%d/%d'%(a,a+sizes[n-1]-1,total)]
    a,b=q[1],q[2]
    if not 0<=a<=b<total: return [416,'bytes */%d'%total]
    out=[]
    for i,s in enumerate(sizes):
        lo=max(a,starts[i])
        hi=min(b,starts[i]+s-1)
        if lo<=hi: out.append([i+1,lo,hi-lo+1])
    return [206,out]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('part-relative-offset fixture 0', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',2]}))), json.loads(json.dumps([206,'bytes 5-7/12'])))
check('part-relative-offset fixture 1', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',3]}))), json.loads(json.dumps([206,'bytes 8-11/12'])))
check('part-relative-offset fixture 2', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',0]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 3', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',-1]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 4', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',4]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 5', json.loads(json.dumps(solve({'parts':[5,0,4],'query':['part',2]}))), json.loads(json.dumps([416,'bytes */9'])))
check('part-relative-offset fixture 6', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',3,9]}))), json.loads(json.dumps([206,[[1,3,2],[2,0,3],[3,0,2]]])))
check('part-relative-offset fixture 7', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',4,5]}))), json.loads(json.dumps([206,[[1,4,1],[2,0,1]]])))
check('part-relative-offset fixture 8', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',5,7]}))), json.loads(json.dumps([206,[[2,0,3]]])))
check('part-relative-offset fixture 9', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',0,12]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 10', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',0,11]}))), json.loads(json.dumps([206,[[1,0,5],[2,0,3],[3,0,4]]])))
check('part-relative-offset fixture 11', json.loads(json.dumps(solve({'parts':[5,0,4],'query':['range',4,5]}))), json.loads(json.dumps([206,[[1,4,1],[3,0,1]]])))
check('part-relative-offset fixture 12', json.loads(json.dumps(solve({'parts':[],'query':['part',1]}))), json.loads(json.dumps([416,'bytes */0'])))
check('part-relative-offset fixture 13', json.loads(json.dumps(solve({'parts':[N,N],'query':['part',2]}))), json.loads(json.dumps([206,"bytes %d-%d/%d"%(N,2*N-1,2*N)])))
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)
Boundary fixtureActualExpectedOutcome
part-relative-offset fixture 0[206, 'bytes 5-7/12'][206, 'bytes 5-7/12']Passed
part-relative-offset fixture 1[206, 'bytes 8-11/12'][206, 'bytes 8-11/12']Passed
part-relative-offset fixture 2[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 3[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 4[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 5[416, 'bytes */9'][416, 'bytes */9']Passed
part-relative-offset fixture 6[206, [[1, 3, 2], [2, 5, 3], [3, 8, 2]]][206, [[1, 3, 2], [2, 0, 3], [3, 0, 2]]]Failed
part-relative-offset fixture 7[206, [[1, 4, 1], [2, 5, 1]]][206, [[1, 4, 1], [2, 0, 1]]]Failed
part-relative-offset fixture 8[206, [[2, 5, 3]]][206, [[2, 0, 3]]]Failed
part-relative-offset fixture 9[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 10[206, [[1, 0, 5], [2, 5, 3], [3, 8, 4]]][206, [[1, 0, 5], [2, 0, 3], [3, 0, 4]]]Failed
part-relative-offset fixture 11[206, [[1, 4, 1], [3, 5, 1]]][206, [[1, 4, 1], [3, 0, 1]]]Failed
part-relative-offset fixture 12[416, 'bytes */0'][416, 'bytes */0']Passed
part-relative-offset fixture 13[206, 'bytes 1-1/2'][206, 'bytes 1-1/2']Passed

SHA-256 / a95ef1997426090062a08acdeda9b55657f55c6188aabc59b5d872e41cbbe3e0

2 / The unsuccessful fix

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(x):
    sizes=x['parts']
    total=sum(sizes)
    starts=[]
    acc=0
    for s in sizes:
        starts.append(acc)
        acc+=s
    q=x['query']
    if q[0]=='part':
        n=q[1]
        if not 1<=n<=len(sizes) or sizes[n-1]==0: return [416,'bytes */%d'%total]
        a=starts[n-1]
        return [206,'bytes %d-%d/%d'%(a,a+sizes[n-1]-1,total)]
    a,b=q[1],q[2]
    if not 0<=a<=b<total: return [416,'bytes */%d'%total]
    out=[]
    for i,s in enumerate(sizes):
        lo=max(a,starts[i])
        hi=min(b,starts[i]+s-1)
        if lo<=hi: out.append([i+1,lo-a,hi-lo+1])
    return [206,out]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('part-relative-offset fixture 0', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',2]}))), json.loads(json.dumps([206,'bytes 5-7/12'])))
check('part-relative-offset fixture 1', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',3]}))), json.loads(json.dumps([206,'bytes 8-11/12'])))
check('part-relative-offset fixture 2', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',0]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 3', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',-1]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 4', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',4]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 5', json.loads(json.dumps(solve({'parts':[5,0,4],'query':['part',2]}))), json.loads(json.dumps([416,'bytes */9'])))
check('part-relative-offset fixture 6', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',3,9]}))), json.loads(json.dumps([206,[[1,3,2],[2,0,3],[3,0,2]]])))
check('part-relative-offset fixture 7', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',4,5]}))), json.loads(json.dumps([206,[[1,4,1],[2,0,1]]])))
check('part-relative-offset fixture 8', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',5,7]}))), json.loads(json.dumps([206,[[2,0,3]]])))
check('part-relative-offset fixture 9', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',0,12]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 10', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',0,11]}))), json.loads(json.dumps([206,[[1,0,5],[2,0,3],[3,0,4]]])))
check('part-relative-offset fixture 11', json.loads(json.dumps(solve({'parts':[5,0,4],'query':['range',4,5]}))), json.loads(json.dumps([206,[[1,4,1],[3,0,1]]])))
check('part-relative-offset fixture 12', json.loads(json.dumps(solve({'parts':[],'query':['part',1]}))), json.loads(json.dumps([416,'bytes */0'])))
check('part-relative-offset fixture 13', json.loads(json.dumps(solve({'parts':[N,N],'query':['part',2]}))), json.loads(json.dumps([206,"bytes %d-%d/%d"%(N,2*N-1,2*N)])))
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)
Boundary fixtureActualExpectedOutcome
part-relative-offset fixture 0[206, 'bytes 5-7/12'][206, 'bytes 5-7/12']Passed
part-relative-offset fixture 1[206, 'bytes 8-11/12'][206, 'bytes 8-11/12']Passed
part-relative-offset fixture 2[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 3[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 4[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 5[416, 'bytes */9'][416, 'bytes */9']Passed
part-relative-offset fixture 6[206, [[1, 0, 2], [2, 2, 3], [3, 5, 2]]][206, [[1, 3, 2], [2, 0, 3], [3, 0, 2]]]Failed
part-relative-offset fixture 7[206, [[1, 0, 1], [2, 1, 1]]][206, [[1, 4, 1], [2, 0, 1]]]Failed
part-relative-offset fixture 8[206, [[2, 0, 3]]][206, [[2, 0, 3]]]Passed
part-relative-offset fixture 9[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 10[206, [[1, 0, 5], [2, 5, 3], [3, 8, 4]]][206, [[1, 0, 5], [2, 0, 3], [3, 0, 4]]]Failed
part-relative-offset fixture 11[206, [[1, 0, 1], [3, 1, 1]]][206, [[1, 4, 1], [3, 0, 1]]]Failed
part-relative-offset fixture 12[416, 'bytes */0'][416, 'bytes */0']Passed
part-relative-offset fixture 13[206, 'bytes 1-1/2'][206, 'bytes 1-1/2']Passed

SHA-256 / 891fb9925be13421e08bcdc67d07ed65e1b589b529f0cf07ed3178fc44a4beb6

3 / The verified repair

Exit 0
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(x):
    sizes=x['parts']
    total=sum(sizes)
    starts=[]
    acc=0
    for s in sizes:
        starts.append(acc)
        acc+=s
    q=x['query']
    if q[0]=='part':
        n=q[1]
        if not 1<=n<=len(sizes) or sizes[n-1]==0: return [416,'bytes */%d'%total]
        a=starts[n-1]
        return [206,'bytes %d-%d/%d'%(a,a+sizes[n-1]-1,total)]
    a,b=q[1],q[2]
    if not 0<=a<=b<total: return [416,'bytes */%d'%total]
    out=[]
    for i,s in enumerate(sizes):
        lo=max(a,starts[i])
        hi=min(b,starts[i]+s-1)
        if lo<=hi: out.append([i+1,lo-starts[i],hi-lo+1])
    return [206,out]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('part-relative-offset fixture 0', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',2]}))), json.loads(json.dumps([206,'bytes 5-7/12'])))
check('part-relative-offset fixture 1', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',3]}))), json.loads(json.dumps([206,'bytes 8-11/12'])))
check('part-relative-offset fixture 2', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',0]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 3', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',-1]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 4', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['part',4]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 5', json.loads(json.dumps(solve({'parts':[5,0,4],'query':['part',2]}))), json.loads(json.dumps([416,'bytes */9'])))
check('part-relative-offset fixture 6', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',3,9]}))), json.loads(json.dumps([206,[[1,3,2],[2,0,3],[3,0,2]]])))
check('part-relative-offset fixture 7', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',4,5]}))), json.loads(json.dumps([206,[[1,4,1],[2,0,1]]])))
check('part-relative-offset fixture 8', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',5,7]}))), json.loads(json.dumps([206,[[2,0,3]]])))
check('part-relative-offset fixture 9', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',0,12]}))), json.loads(json.dumps([416,'bytes */12'])))
check('part-relative-offset fixture 10', json.loads(json.dumps(solve({'parts':[5,3,4],'query':['range',0,11]}))), json.loads(json.dumps([206,[[1,0,5],[2,0,3],[3,0,4]]])))
check('part-relative-offset fixture 11', json.loads(json.dumps(solve({'parts':[5,0,4],'query':['range',4,5]}))), json.loads(json.dumps([206,[[1,4,1],[3,0,1]]])))
check('part-relative-offset fixture 12', json.loads(json.dumps(solve({'parts':[],'query':['part',1]}))), json.loads(json.dumps([416,'bytes */0'])))
check('part-relative-offset fixture 13', json.loads(json.dumps(solve({'parts':[N,N],'query':['part',2]}))), json.loads(json.dumps([206,"bytes %d-%d/%d"%(N,2*N-1,2*N)])))
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)
Boundary fixtureActualExpectedOutcome
part-relative-offset fixture 0[206, 'bytes 5-7/12'][206, 'bytes 5-7/12']Passed
part-relative-offset fixture 1[206, 'bytes 8-11/12'][206, 'bytes 8-11/12']Passed
part-relative-offset fixture 2[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 3[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 4[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 5[416, 'bytes */9'][416, 'bytes */9']Passed
part-relative-offset fixture 6[206, [[1, 3, 2], [2, 0, 3], [3, 0, 2]]][206, [[1, 3, 2], [2, 0, 3], [3, 0, 2]]]Passed
part-relative-offset fixture 7[206, [[1, 4, 1], [2, 0, 1]]][206, [[1, 4, 1], [2, 0, 1]]]Passed
part-relative-offset fixture 8[206, [[2, 0, 3]]][206, [[2, 0, 3]]]Passed
part-relative-offset fixture 9[416, 'bytes */12'][416, 'bytes */12']Passed
part-relative-offset fixture 10[206, [[1, 0, 5], [2, 0, 3], [3, 0, 4]]][206, [[1, 0, 5], [2, 0, 3], [3, 0, 4]]]Passed
part-relative-offset fixture 11[206, [[1, 4, 1], [3, 0, 1]]][206, [[1, 4, 1], [3, 0, 1]]]Passed
part-relative-offset fixture 12[416, 'bytes */0'][416, 'bytes */0']Passed
part-relative-offset fixture 13[206, 'bytes 1-1/2'][206, 'bytes 1-1/2']Passed

SHA-256 / f669c4378050cec95361ca0046533b35efc89e54b0285c3fd56d7d81dcc91b85

Verification & scope

Deterministic simplified range service, with stipulated local policies and already parsed trusted inputs; not a complete HTTP implementation. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:41:28.583509+00:00.

Case digest / f552de9500d9c9eba10e0ad91030308a3d128acb3abf3af14fe71391abc2cfc9