Batch 21 (20261027-A-bos-redo-21) rebuilt 40 of the 53 rejected Bos-qiao environments: hidden assertions that ran inside the candidate's process now run in a trusted parent that reads observations from a low-UID worker; gold bytes are unchanged. 9 were excluded for scope (ROS2, oversize, security core), 3 are blocked because the source requires an exec bit the platform does not freeze, 1 lacks requests/bs4 in trace6. Batch 18 (20261026-C-hwe-codegen-18) adds its last 34 of 134 tasks; the first 100 landed in 2f32624d. Claude reviewed 74/74 USABLE against current digests, canonical families, no ID or source overlap with main, plain public docs. Only the new task directories are taken; the stale pre-batch-20 copies of concur-release-capsule and resource-temp-link on the batch 21 branch and both branches' progress notes stay as main has them. Difficulty is unmeasured. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
501 lines
22 KiB
Python
501 lines
22 KiB
Python
"""Independent deterministic model; the C++ observer emits raw public return values only."""
|
|
from pathlib import Path
|
|
import hashlib
|
|
import json
|
|
import random
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
|
|
LOW = -(1 << 63)
|
|
HIGH = (1 << 63) - 1
|
|
ARITY = {'new':4,'drop':1,'point':3,'enable':3,'start':1,'finish':5,'append':2,
|
|
'reset':1,'status':1,'showpoint':2,'log':1,'script':1,'list':0}
|
|
DOMAINS = {'new':[(0,15),(0,2),(0,4),(0,64)],'drop':[(0,15)],
|
|
'point':[(0,15),(0,7),(0,65535)],'enable':[(0,15),(0,7),(0,1)],
|
|
'start':[(0,15)],'finish':[(0,15),(0,255),(0,2),(0,255),(0,255)],
|
|
'append':[(0,15)],'reset':[(0,15)],'status':[(0,15)],
|
|
'showpoint':[(0,15),(0,7)],'log':[(0,15)],'script':[(0,15)]}
|
|
MUTATE = {'new','drop','point','enable','start','finish','append','reset'}
|
|
|
|
def hx(data):
|
|
return data.hex() or '-'
|
|
|
|
def script(s):
|
|
lines=['set pagination off','set logging overwrite on',
|
|
'set logging enabled '+('on' if s['capacity'] else 'off'),'file program']
|
|
if s['mode']==1:
|
|
lines.append('target remote board:1234')
|
|
if s['mode']==2:
|
|
lines.append('core-file core')
|
|
lines += ['break *'+str(v[0]) for _,v in sorted(s['points'].items()) if v[1]]
|
|
if s['mode'] in (0,1):
|
|
lines.append(['run','continue'][s['mode']])
|
|
return ('\n'.join(lines+['thread apply all bt full','info registers','quit'])+'\n').encode()
|
|
|
|
class Model:
|
|
def __init__(self):
|
|
self.sessions={}
|
|
|
|
def apply(self,verb,args):
|
|
if verb=='list':
|
|
return 0, sorted(self.sessions)
|
|
bad=any(not lo <= args[i] <= hi for i,(lo,hi) in enumerate(DOMAINS[verb]))
|
|
if verb=='append':
|
|
bad |= len(args[1])>64
|
|
if verb=='finish' and args[2] in (1,2):
|
|
bad |= not 1<=args[3]<=31
|
|
if bad:
|
|
return 1,None
|
|
id=args[0]
|
|
s=self.sessions.get(id)
|
|
if verb=='new':
|
|
if s is not None:
|
|
return 2,None
|
|
self.sessions[id]=dict(id=id,mode=args[1],retries=args[2],capacity=args[3],
|
|
attempts=0,state=0,outcome=-1,debugger=-1,kind=-1,
|
|
value=-1,collector=-1,total=0,bytes=b'',points={})
|
|
return 0,None
|
|
if s is None:
|
|
return 3,None
|
|
if verb in ('drop','point','enable','start','reset') and s['state']==1:
|
|
return 4,None
|
|
if verb=='start' and s['state']==3:
|
|
return 5,None
|
|
if verb in ('finish','append') and s['state']!=1:
|
|
return 5,None
|
|
if verb=='point' and args[1] in s['points']:
|
|
return 2,None
|
|
if verb in ('enable','showpoint') and args[1] not in s['points']:
|
|
return 3,None
|
|
if verb=='drop':
|
|
del self.sessions[id]
|
|
elif verb=='point':
|
|
s['points'][args[1]]=[args[2],1]
|
|
elif verb=='enable':
|
|
s['points'][args[1]][1]=args[2]
|
|
elif verb=='start':
|
|
s['attempts']+=1
|
|
s['state']=1
|
|
for field in ['outcome','debugger','kind','value','collector']:
|
|
s[field]=-1
|
|
elif verb=='finish':
|
|
d,k,v,c=args[1:]
|
|
s.update(debugger=d,kind=k,value=v,collector=c)
|
|
reason = next((code for condition,code in [(d!=0,1),(k==0 and v!=0,2),
|
|
(k==1,3),(k==2,4),(c!=0,5)] if condition),0)
|
|
s['outcome']=reason
|
|
s['state']=2 if reason and s['attempts']<=s['retries'] else 3
|
|
elif verb=='append':
|
|
s['total']+=len(args[1])
|
|
merged=s['bytes']+args[1]
|
|
s['bytes']=merged[-s['capacity']:] if s['capacity'] else b''
|
|
elif verb=='reset':
|
|
s.update(attempts=0,state=0,total=0,bytes=b'')
|
|
for field in ['outcome','debugger','kind','value','collector']:
|
|
s[field]=-1
|
|
elif verb=='status':
|
|
return 0,[s[k] for k in ['id','mode','retries','capacity','attempts','state',
|
|
'outcome','debugger','kind','value','collector','total']]+[
|
|
len(s['points']),sum(p[1] for p in s['points'].values())]
|
|
elif verb=='showpoint':
|
|
return 0,[args[1],*s['points'][args[1]]]
|
|
elif verb=='log':
|
|
return 0,[s['total'],s['bytes']]
|
|
elif verb=='script':
|
|
return 0,script(s)
|
|
return 0,None
|
|
|
|
def format_result(verb,code,payload,count=None):
|
|
if verb in MUTATE:
|
|
return (f'R {code}'+(' '+str(count) if count is not None else '')+'\n').encode()
|
|
if verb=='status':
|
|
return ('S '+str(code)+' '+' '.join(map(str,payload if code==0 else [-1]*14))+'\n').encode()
|
|
if verb=='showpoint':
|
|
return ('P '+str(code)+' '+' '.join(map(str,payload if code==0 else [-1]*3))+'\n').encode()
|
|
if verb=='log':
|
|
total,data=payload if code==0 else (0,b'')
|
|
return f'L {code} {total} {hx(data)}\n'.encode()
|
|
if verb=='script':
|
|
return f'T {code} {hx(payload if code==0 else b"")}\n'.encode()
|
|
return ('I '+str(len(payload))+''.join(' '+str(id) for id in payload)+'\n').encode()
|
|
|
|
def render_command(verb,args):
|
|
return verb+''.join(' '+(hx(v) if isinstance(v,bytes) else str(v)) for v in args)
|
|
|
|
def cli(data,coverage=None):
|
|
model=Model()
|
|
lines=data.split(b'\n')
|
|
if lines[-1]==b'':
|
|
lines.pop()
|
|
output=[]
|
|
for index,line in enumerate(lines):
|
|
if index==4096:
|
|
output.append(b'LIMIT\n')
|
|
break
|
|
words=[v for v in re.split(b'[ \t]+',line) if v]
|
|
if not words:
|
|
output.append(b'SYNTAX\n');continue
|
|
try:
|
|
verb=words[0].decode('ascii')
|
|
except UnicodeError:
|
|
verb='?'
|
|
if verb not in ARITY or len(words)!=ARITY.get(verb,-2)+1:
|
|
output.append(b'SYNTAX\n');continue
|
|
args=[]
|
|
try:
|
|
for i,token in enumerate(words[1:]):
|
|
if verb=='append' and i==1:
|
|
if token==b'-':
|
|
args.append(b'')
|
|
elif len(token)%2==0 and re.fullmatch(b'[0-9a-fA-F]+',token):
|
|
args.append(bytes.fromhex(token.decode()))
|
|
else:
|
|
raise ValueError()
|
|
else:
|
|
if not re.fullmatch(b'-?[0-9]+',token):
|
|
raise ValueError()
|
|
value=int(token)
|
|
if not LOW<=value<=HIGH:
|
|
raise ValueError()
|
|
args.append(value)
|
|
except ValueError:
|
|
output.append(b'SYNTAX\n');continue
|
|
code,payload=model.apply(verb,args)
|
|
if coverage is not None:
|
|
coverage[verb].add(code)
|
|
output.append(format_result(verb,code,payload,len(model.sessions)))
|
|
return b''.join(output)
|
|
|
|
class Corpus:
|
|
def __init__(self):
|
|
self.lines=[]
|
|
self.output=[]
|
|
self.models=[Model(),Model()]
|
|
self.cli_codes={v:set() for v in ARITY}
|
|
self.api_codes={v:set() for v in ARITY}
|
|
self.cli_calls=0
|
|
self.api_calls=0
|
|
self.endpoints=[]
|
|
self.failures=0
|
|
self.cases=0
|
|
|
|
def fresh(self,obj):
|
|
self.lines.append(f'F {obj}\n')
|
|
self.output.append(b'F\n')
|
|
self.models[obj]=Model()
|
|
|
|
def call(self,verb,args=(),obj=0):
|
|
code,payload=self.models[obj].apply(verb,list(args))
|
|
self.lines.append(verb+f' {obj}'+''.join(' '+(hx(v) if isinstance(v,bytes) else str(v)) for v in args)+'\n')
|
|
self.output.append(format_result(verb,code,payload))
|
|
self.api_codes[verb].add(code)
|
|
self.api_calls+=1
|
|
return code
|
|
|
|
def observe(self,obj=0,ids=None):
|
|
self.call('list',obj=obj)
|
|
if ids is None:
|
|
ids=sorted(set(self.models[obj].sessions)|{0,15,9})
|
|
for id in ids:
|
|
self.call('status',[id],obj)
|
|
self.call('log',[id],obj)
|
|
self.call('script',[id],obj)
|
|
for slot in range(8):
|
|
self.call('showpoint',[id,slot],obj)
|
|
|
|
def cli_call(self,data,flags=1):
|
|
expected=cli(data,self.cli_codes)
|
|
self.lines.append(f'C {hx(data)} {flags}\n')
|
|
self.output.append(f'C 0 {hx(expected)} -\n'.encode())
|
|
self.cli_calls+=1
|
|
|
|
def scenario(self,commands,endpoint=None):
|
|
self.cases+=1
|
|
self.fresh(0)
|
|
self.fresh(1)
|
|
self.call('new',[9,2,4,7],1)
|
|
self.call('point',[9,7,1234],1)
|
|
self.call('start',[9],1)
|
|
self.call('append',[9,b'other\0\xff'],1)
|
|
self.observe(1,[9])
|
|
for verb,args in commands:
|
|
code=self.call(verb,args)
|
|
if code:
|
|
self.failures+=1
|
|
self.observe(0)
|
|
self.observe(1,[9])
|
|
if endpoint is not None:
|
|
self.endpoints.append([*endpoint,code])
|
|
if code!=0:
|
|
raise AssertionError(('endpoint not successful',endpoint,code))
|
|
mirror=Model()
|
|
cli_lines=[]
|
|
for verb,args in commands:
|
|
cli_lines.append(render_command(verb,args))
|
|
cli_code,_=mirror.apply(verb,args)
|
|
cli_lines.append('list')
|
|
for id in sorted(set(mirror.sessions)|{0,15,9}):
|
|
cli_lines += [f'status {id}',f'log {id}',f'script {id}']
|
|
cli_lines += [f'showpoint {id} {slot}' for slot in range(8)]
|
|
if endpoint is not None and cli_code!=0:
|
|
raise AssertionError(('CLI endpoint not successful',endpoint,cli_code))
|
|
if len(cli_lines)>4096:
|
|
raise AssertionError('scenario exceeds CLI limit')
|
|
data=('\n'.join(cli_lines)+'\n').encode()
|
|
self.cli_call(data)
|
|
|
|
def pair(self):
|
|
return ''.join(self.lines).encode(),b''.join(self.output)
|
|
|
|
# These preparations yield successful domain endpoints for each numeric parameter,
|
|
# while background sessions, nonzero payloads and all raw queries expose mutations.
|
|
def prepared(verb,args):
|
|
id=args[0]
|
|
good_id=id if 0<=id<=15 else 0
|
|
commands=[('new',[9,1,4,17]),('point',[9,5,63000])]
|
|
if verb=='new':
|
|
return commands
|
|
commands += [('new',[good_id,1,4,17])]
|
|
if verb in ('enable','showpoint'):
|
|
slot=args[1] if 0<=args[1]<=7 else 0
|
|
commands += [('point',[good_id,slot,65535])]
|
|
if verb=='enable' and args[2]==1:
|
|
commands += [('enable',[good_id,slot,0])]
|
|
elif verb not in ('point',):
|
|
commands += [('point',[good_id,7,65535])]
|
|
if verb in ('finish','append','log','status'):
|
|
commands += [('start',[good_id]),('append',[good_id,b'\x00\xffbaseline'])]
|
|
if verb in ('reset','drop'):
|
|
commands += [('start',[good_id]),('append',[good_id,b'reset-data']),
|
|
('finish',[good_id,0,0,0,0])]
|
|
return commands
|
|
|
|
def create_corpus():
|
|
c=Corpus()
|
|
defaults={'new':[0,1,2,8],'drop':[0],'point':[0,0,1234],
|
|
'enable':[0,0,1],'start':[0],'finish':[0,0,0,1,0],
|
|
'append':[0,b'\0\xff'],'reset':[0],'status':[0],
|
|
'showpoint':[0,0],'log':[0],'script':[0]}
|
|
for verb,domains in DOMAINS.items():
|
|
for p,(lo,hi) in enumerate(domains):
|
|
for v in dict.fromkeys([lo,hi,lo-1,hi+1,LOW,HIGH]):
|
|
args=list(defaults[verb]);args[p]=v
|
|
commands=prepared(verb,args)+[(verb,args)]
|
|
c.scenario(commands,(verb,p,v) if v in (lo,hi) else None)
|
|
# Dependent value domain for stopped/crashed target results, both successful ends.
|
|
for kind in [1,2]:
|
|
for value in [0,1,31,32,LOW,HIGH]:
|
|
args=[0,0,kind,value,0]
|
|
c.scenario(prepared('finish',args)+[('finish',args)],
|
|
('finish_signal_value',kind,value) if value in (1,31) else None)
|
|
# Rolling binary log, length domain, capacity zero, truncation, and empty append.
|
|
for capacity in [0,1,17,64]:
|
|
for length in [0,1,63,64,65]:
|
|
c.scenario([('new',[0,0,4,capacity]),('start',[0]),
|
|
('append',[0,b'nonzero']),('append',[0,bytes(range(length))])])
|
|
# Every outcome, collisions among simultaneous failures, retry exhaustion and reset.
|
|
for retry in range(5):
|
|
for d,k,v,tail in [(0,0,0,0),(0,0,0,255),(0,0,255,0),(0,1,1,0),
|
|
(0,2,31,0),(255,0,0,0),(255,2,31,255),(0,1,31,255)]:
|
|
commands=[('new',[0,2,retry,64]),('point',[0,7,65535])]
|
|
for attempt in range(retry+2):
|
|
commands += [('start',[0]),('append',[0,b'\0\n\xff']),('finish',[0,d,k,v,tail])]
|
|
commands += [('reset',[0]),('start',[0]),('finish',[0,0,0,0,0])]
|
|
c.scenario(commands)
|
|
# A success during an available retry finishes immediately, preserving attempt/log history.
|
|
for retries in range(1,5):
|
|
for failed in range(1,retries+1):
|
|
commands=[('new',[0,1,retries,17]),('point',[0,7,65535])]
|
|
for _ in range(failed):
|
|
commands += [('start',[0]),('append',[0,b'failed']),('finish',[0,0,0,7,0])]
|
|
commands += [('start',[0]),('append',[0,b'success']),('finish',[0,0,0,0,0]),('start',[0])]
|
|
c.scenario(commands)
|
|
result=c.models[0].sessions[0]
|
|
if (result['state'],result['attempts'],result['outcome'])!=(3,failed+1,0):
|
|
raise AssertionError('early success path')
|
|
# All slots, sorting, duplicate addresses, disabling and two live objects same id.
|
|
commands=[('new',[0,0,4,64])]
|
|
for slot in [7,0,5,2,6,1,4,3]:
|
|
commands += [('point',[0,slot,999 if slot%2 else slot]),('enable',[0,slot,slot%2])]
|
|
commands += [('enable',[0,7,0]),('enable',[0,7,0]),('point',[0,7,900]),
|
|
('start',[0]),('point',[0,7,-1]),('enable',[0,6,1]),('drop',[0]),
|
|
('reset',[0]),('start',[0]),('finish',[0,0,0,0,0]),('drop',[0]),
|
|
('new',[0,2,0,0]),('start',[0]),('finish',[0,0,0,0,0])]
|
|
c.scenario(commands)
|
|
# Range validation with additional missing/busy/state/existence conditions.
|
|
for verb,domains in DOMAINS.items():
|
|
for parameter,(lo,hi) in enumerate(domains):
|
|
for phase in ['absent','running','done']:
|
|
args=list(defaults[verb]);args[parameter]=hi+1
|
|
commands=[('new',[9,2,4,17]),('point',[9,7,60000]),
|
|
('start',[9]),('append',[9,b'nonzero-background'])]
|
|
if phase!='absent':
|
|
commands += [('new',[0,1,4,17]),('point',[0,0,700]),
|
|
('start',[0]),('append',[0,b'nonzero-target'])]
|
|
if phase=='done':
|
|
commands += [('finish',[0,0,0,0,0])]
|
|
commands.append((verb,args))
|
|
c.scenario(commands)
|
|
# Range of byte length is checked before missing/state, including simultaneous bad id.
|
|
for id in [0,2,LOW,HIGH]:
|
|
c.scenario([('new',[0,0,1,8]),('point',[0,7,42]),
|
|
('append',[id,b'X'*65])])
|
|
# Actual reachable CLI errors, including absent sessions/points, busy and state.
|
|
commands=[('new',[9,1,4,17]),('point',[9,7,60000]),('start',[9]),
|
|
('append',[9,b'background']),('finish',[9,0,0,1,0])]
|
|
for verb,args in defaults.items():
|
|
if verb!='new':
|
|
commands.append((verb,args))
|
|
commands += [('new',[0,0,0,8]),('new',[0,1,1,9]),('point',[0,0,1]),
|
|
('point',[0,0,2]),('enable',[0,7,1]),('append',[0,b'abc']),
|
|
('finish',[0,0,0,0,0]),('start',[0]),('append',[0,b'busy']),('drop',[0]),('reset',[0]),
|
|
('point',[0,1,1]),('enable',[0,0,0]),('enable',[0,7,0]),('start',[0]),
|
|
('finish',[0,0,0,0,0]),('start',[0]),('list',[])]
|
|
c.scenario(commands)
|
|
# Fixed seeded operations mix valid and invalid calls; every operation is observed.
|
|
rng=random.Random(113030)
|
|
commands=[('new',[0,0,4,8]),('new',[15,2,1,0])]
|
|
verbs=list(ARITY)
|
|
for _ in range(220):
|
|
v=rng.choice(verbs)
|
|
if v=='list':
|
|
args=[]
|
|
else:
|
|
args=list(defaults[v]);args[0]=rng.choice([0,15,2,-1,16])
|
|
if v=='new':
|
|
args[1:]=[rng.randrange(4),rng.randrange(6),rng.choice([0,8,64,65])]
|
|
elif v in ('point','enable','showpoint'):
|
|
args[1]=rng.choice([0,7,3,8,-1])
|
|
if v=='point': args[2]=rng.choice([0,1,65535,65536])
|
|
if v=='enable': args[2]=rng.choice([0,1,2])
|
|
elif v=='finish':
|
|
args[1:]=[rng.choice([0,1,255]),rng.randrange(3),rng.choice([0,1,31,255]),rng.choice([0,1,255])]
|
|
elif v=='append':
|
|
args[1]=bytes(rng.randrange(256) for _ in range(rng.choice([0,1,8,64,65])))
|
|
commands.append((v,args))
|
|
for offset in range(0,len(commands),40):
|
|
c.scenario([('new',[0,0,4,8]),('new',[15,2,1,0])]+commands[offset:offset+40])
|
|
# Two simultaneously live objects use the same IDs with independent states.
|
|
c.fresh(0);c.fresh(1)
|
|
for obj in [0,1]:
|
|
c.call('new',[0,obj,obj+1,8+obj],obj)
|
|
c.call('point',[0,7,100+obj],obj)
|
|
c.call('start',[0],obj)
|
|
c.call('append',[0,bytes([obj,255-obj])],obj)
|
|
for obj in [1,0,1,0]:
|
|
c.observe(obj,[0])
|
|
c.call('finish',[0,obj,0,0,0],obj)
|
|
c.observe(1-obj,[0])
|
|
required={'new':{0,1,2},'drop':{0,1,3,4},'point':{0,1,2,3,4},
|
|
'enable':{0,1,3,4},'start':{0,1,3,4,5},'finish':{0,1,3,5},
|
|
'append':{0,1,3,5},'reset':{0,1,3,4},'status':{0,1,3},
|
|
'showpoint':{0,1,3},'log':{0,1,3},'script':{0,1,3},'list':{0}}
|
|
if c.cli_codes!=required or c.api_codes!=required:
|
|
raise AssertionError(('code sets',c.cli_codes,c.api_codes))
|
|
return c
|
|
|
|
def boundary_data():
|
|
# Mixed physical lines precede a visible mutation on line 4096 and suppressed 4097.
|
|
prefix=['new 0 0 4 64','point 0 0 123','start 0','append 0 010203','finish 0 0 0 0 0']
|
|
mix=['status 0','','append 0 05','point 0 0 999','not-a-verb','log 0','script 0']
|
|
lines=prefix+[mix[i%len(mix)] for i in range(4095-len(prefix))]
|
|
lines += ['new 15 2 4 0','drop 15','reset 0','list']
|
|
return ('\n'.join(lines)+'\n').encode()
|
|
|
|
def scenes():
|
|
corpus=create_corpus()
|
|
api=corpus.pair()
|
|
edge=Corpus()
|
|
edge.cli_call(b'')
|
|
edge.cli_call(b'new 0 0 0 64\nstart 0\nappend 0 00FF0a\nlog 0',0)
|
|
edge.cli_call(b'status 0\nlist\n')
|
|
edge.cli_call(boundary_data())
|
|
edge.cli_call(b'\n'.join([b'list']*4096))
|
|
edge.cli_call(b'new 15 2 4 0\nscript 15\n')
|
|
edge.cli_call(b'status 15\nlist',0)
|
|
protocol=['new 0 0 4 64','point 0 7 65000','start 0','append 0 00ff0a',
|
|
'status 0','log 0','script 0','list']
|
|
# Each verb missing/excess arity, every numeric parameter lexical failure.
|
|
defaults={'new':['0','1','4','8'],'drop':['0'],'point':['0','0','1'],
|
|
'enable':['0','7','0'],'start':['0'],'finish':['0','0','0','0','0'],
|
|
'append':['0','00'],'reset':['0'],'status':['0'],'showpoint':['0','7'],
|
|
'log':['0'],'script':['0'],'list':[]}
|
|
for verb,args in defaults.items():
|
|
protocol.append(' '.join([verb,*args[:-1]]) if args else '')
|
|
protocol.append(' '.join([verb,*args,'extra']))
|
|
for p in range(len(args)-(verb=='append')):
|
|
for invalid in ['x','+1','1.0','1e2',str(HIGH+1),str(LOW-1),'1\r','-']:
|
|
a=list(args);a[p]=invalid;protocol.append(' '.join([verb,*a]))
|
|
protocol += ['status 0','showpoint 0 7','log 0','script 0','list']
|
|
protocol += ['append 0 0','append 0 zz','append 0 00xx','append 0 -',
|
|
' \tlog\t 000 \t ','status -0','status 0\r','NEW 0 0 0 0',
|
|
'finish 0 0 2 31 0','status 0','start 0','finish 0 255 0 0 0',
|
|
'status 0','start 0','finish 0 0 0 0 0','status 0','reset 0',
|
|
'log 0','script 0','drop 0','new 0 2 0 0','script 0']
|
|
observed=[]
|
|
for line in protocol:
|
|
observed.append(line)
|
|
observed += ['status 0','showpoint 0 7','log 0','script 0','list']
|
|
protocol=('\n'.join(observed)+'\n').encode()
|
|
smoke=b'new 7 0 1 8\npoint 7 0 4096\nscript 7\n'
|
|
nolf=b'new 15 1 0 0\npoint 15 7 65535\nscript 15\nlist'
|
|
return corpus,[('api',1,*api),('cli_edges',1,*edge.pair()),
|
|
('app_smoke',0,smoke,cli(smoke)),('app_protocol',0,protocol,cli(protocol)),
|
|
('app_empty',0,b'',b''),('app_nolf',0,nolf,cli(nolf)),
|
|
('app_max',0,boundary_data(),cli(boundary_data()))]
|
|
|
|
def summary(data):
|
|
return [len(data),hashlib.sha256(data).hexdigest()[:16]]
|
|
|
|
def launch(argv,cwd,data,expected,seconds):
|
|
process=subprocess.Popen(argv,cwd=cwd,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
|
|
timed=False
|
|
try:
|
|
out,err=process.communicate(data,timeout=seconds)
|
|
except subprocess.TimeoutExpired:
|
|
timed=True;process.kill();out,err=process.communicate()
|
|
reasons=[]
|
|
if timed: reasons.append('timeout')
|
|
if process.returncode!=0: reasons.append('exit')
|
|
if out!=expected: reasons.append('stdout')
|
|
if err: reasons.append('stderr')
|
|
return [process.pid,process.returncode,int(timed),summary(data),summary(expected),summary(out),summary(err),reasons]
|
|
|
|
def main():
|
|
candidate=Path(sys.argv[1]).resolve()
|
|
here=Path(__file__).resolve().parent
|
|
corpus,items=scenes()
|
|
sources={name:(candidate/name).read_bytes() for name in ['journal.hpp','journal.cpp','plan.cpp','cli.cpp','app.cpp']}
|
|
sources['observer.cpp']=(here/'observer.txt').read_bytes()
|
|
scratch=Path(tempfile.mkdtemp(prefix='journal-',dir=Path.cwd()))
|
|
for name,data in sources.items():
|
|
(scratch/name).write_bytes(data)
|
|
# All trusted filesystem reads and writes finish before the first compiler.
|
|
argv=[['g++','-std=c++17','-O2','journal.cpp','plan.cpp','cli.cpp','app.cpp','-o','app'],
|
|
['g++','-std=c++17','-O2','journal.cpp','plan.cpp','cli.cpp','observer.cpp','-o','observer'],
|
|
['./app'],['./observer']]
|
|
meta={'v':1,'cwd':str(scratch),'argv':argv,'b':[],'r':[]}
|
|
failures=[]
|
|
for index in range(2):
|
|
record=launch(argv[index],scratch,b'',b'',25)
|
|
# Compiler diagnostics are retained, but only build exit/timeout gate execution.
|
|
record[-1]=[v for v in record[-1] if v in ('timeout','exit')]
|
|
meta['b'].append([index,*record])
|
|
if record[-1]: failures.append('build'+str(index)+':'+','.join(record[-1]))
|
|
if not failures:
|
|
for name,which,data,expected in items:
|
|
record=launch(argv[2+which],scratch,data,expected,15)
|
|
meta['r'].append([name,2+which,*record])
|
|
if record[-1]: failures.append(name+':'+','.join(record[-1]))
|
|
encoded=json.dumps(meta,separators=(',',':'))
|
|
if len(encoded.encode())>=3900:
|
|
raise RuntimeError('metadata exceeds retention budget')
|
|
sys.stderr.write(encoded+'\n')
|
|
print('FAIL '+';'.join(failures) if failures else 'PASS')
|
|
return int(bool(failures))
|
|
|
|
if __name__=='__main__':
|
|
raise SystemExit(main())
|