One user-space repair task per eligible HWE debug-diag / compile-deploy base ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content filter. Each ships a public spec with a check-to-basis table, at least two defects with single-fix fixtures, a symptom-masking fixture and an alternative correct implementation. Claude re-checked all 320: structure, the HWE quality items and trace6 Docker calibration receipts against current digests (320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120 ad-hoc family names; the next batch maps them to the canonical list. The batch's 1,256-line progress log stays in its factory report and the 36-local branch batch15-hwe. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
287 lines
22 KiB
Python
287 lines
22 KiB
Python
"""Independent AST oracle; candidate identity owns all execution and cleanup."""
|
|
import base64
|
|
import bz2
|
|
import hashlib
|
|
import json
|
|
import math
|
|
import os
|
|
from pathlib import Path
|
|
import random
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import uuid
|
|
import zlib
|
|
SUPERVISOR = "import base64, ctypes, errno, hashlib, json, os, selectors, signal, subprocess, sys, time\ncfg=json.loads(sys.argv[1])\nstarted=time.monotonic()\nerrors=[]\nleader=None\nleader_start=None\nreal_rc=None\ntimed_out=False\nout=bytearray()\nerr=bytearray()\ntracked={}\nreaped=[]\n\ndef fault(where,e):\n errors.append([where,type(e).__name__,str(e)])\n\ndef identity(pid):\n try:\n data=open('/proc/%d/stat'%pid,'rb').read()\n fields=data[data.rfind(b')')+2:].split()\n return {'pid':pid,'ppid':int(fields[1]),'pgid':int(fields[2]),'start':int(fields[19]),'state':fields[0].decode('ascii')}\n except (FileNotFoundError,ProcessLookupError):\n return None\n\ndef owned_tokens(table, me, known):\n roots={me}\n roots.update(pid for pid,start in known.items() if pid in table and table[pid]['start']==start)\n owned=set()\n changed=True\n while changed:\n changed=False\n for pid,row in table.items():\n if pid != me and row['ppid'] in roots|owned and pid not in owned:\n owned.add(pid);changed=True\n owned.update(pid for pid,start in known.items() if pid in table and table[pid]['start']==start)\n return {pid:table[pid] for pid in owned}\n\ndef descendants():\n table={}\n for name in os.listdir('/proc'):\n if name.isdigit():\n try:\n row=identity(int(name))\n if row is not None: table[row['pid']]=row\n except OSError as e:\n if e.errno not in (errno.ENOENT,errno.ESRCH): fault('proc',e)\n found=owned_tokens(table,os.getpid(),tracked)\n for pid,row in found.items(): tracked[pid]=row['start']\n return found\n\ndef terminate(rows):\n for pid,row in rows.items():\n current=identity(pid)\n if current is not None and current['start']==row['start']:\n try: os.kill(pid,signal.SIGKILL)\n except ProcessLookupError: pass\n except OSError as e: fault('signal',e)\n\ndef reap_adopted(rows):\n # Popen owns its leader: poll/wait it before adopted descendant waitpid calls.\n global real_rc\n real_rc=leader.poll()\n for pid,row in rows.items():\n if pid==leader.pid or row['ppid']!=os.getpid(): continue\n current=identity(pid)\n if current is None or current['start']!=row['start']: continue\n try:\n got,status=os.waitpid(pid,os.WNOHANG)\n if got: reaped.append([got,row['start'],status])\n except ChildProcessError: pass\n except OSError as e: fault('reap',e)\n\nself_row=identity(os.getpid())\nremaining={}\ntry:\n if ctypes.CDLL(None,use_errno=True).prctl(36,1,0,0,0)!=0:\n raise OSError(ctypes.get_errno(),'PR_SET_CHILD_SUBREAPER')\n leader=subprocess.Popen(cfg['argv'],cwd=cfg['cwd'],stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,start_new_session=True)\n row=identity(leader.pid)\n if row is None: raise RuntimeError('leader identity vanished')\n leader_start=row['start'];tracked[leader.pid]=leader_start\n poller=selectors.DefaultSelector()\n for stream,tag in ((leader.stdout,'o'),(leader.stderr,'e')):\n os.set_blocking(stream.fileno(),False);poller.register(stream,selectors.EVENT_READ,tag)\n data=base64.b64decode(cfg['input'])\n sent=0\n if data:\n os.set_blocking(leader.stdin.fileno(),False);poller.register(leader.stdin,selectors.EVENT_WRITE,'i')\n else: leader.stdin.close()\n closing=None\n while True:\n now=time.monotonic()\n real_rc=leader.poll()\n if closing is None and (real_rc is not None or now-started>=cfg['deadline']):\n timed_out=real_rc is None;closing=now\n rows=descendants()\n if closing is not None: terminate(rows)\n reap_adopted(rows)\n for key,mask in poller.select(0.01):\n stream=key.fileobj\n try:\n if key.data=='i':\n n=os.write(stream.fileno(),data[sent:sent+65536]);sent+=n\n if sent==len(data):poller.unregister(stream);stream.close()\n else:\n for read_batch in range(64):\n try:part=os.read(stream.fileno(),65536)\n except BlockingIOError:break\n if part:(out if key.data=='o' else err).extend(part)\n else:poller.unregister(stream);stream.close();break\n except BrokenPipeError:\n poller.unregister(stream);stream.close()\n except BlockingIOError:pass\n remaining=descendants()\n if real_rc is not None and not remaining and not poller.get_map():break\n if closing is not None and now-closing>2:\n fault('recovery',RuntimeError('descendants or IO remained after recovery allowance'))\n break\n real_rc=leader.poll()\n if real_rc is not None: real_rc=leader.wait()\n remaining=descendants()\nexcept BaseException as e:\n fault('supervise',e)\n if leader is not None:\n try:\n terminate(descendants())\n until=time.monotonic()+2\n while time.monotonic()<until:\n rows=descendants();reap_adopted(rows)\n if not rows:break\n time.sleep(.01)\n real_rc=leader.poll();remaining=descendants()\n except BaseException as nested:fault('exception_cleanup',nested)\nrawout,rawerr=bytes(out),bytes(err)\nmeta={'nonce':cfg['nonce'],'argv':cfg['argv'],'deadline':cfg['deadline'],'uid':os.getuid(),'gid':os.getgid(),'groups':os.getgroups(),\n 'supervisor_pid':os.getpid(),'supervisor_start':self_row['start'],'leader_pid':leader.pid if leader else None,'leader_start':leader_start,\n 'leader_returncode':real_rc,'leader_reaped':real_rc is not None,'timeout':timed_out,\n 'controlled_returncode':124 if timed_out else real_rc,'elapsed':time.monotonic()-started,\n 'descendants_absent':not remaining,'processgroup_absent':not remaining,\n 'tracked':sorted([[pid,start] for pid,start in tracked.items()]),'reaped':reaped,'remaining':[[pid,row['start']] for pid,row in remaining.items()],\n 'stdout_len':len(rawout),'stdout_sha256':hashlib.sha256(rawout).hexdigest(),'stderr_len':len(rawerr),'stderr_sha256':hashlib.sha256(rawerr).hexdigest(),'exceptions':errors}\nsys.stdout.write(json.dumps({'m':meta,'o':base64.b64encode(rawout).decode(),'e':base64.b64encode(rawerr).decode()},separators=(',',':')))\n"
|
|
|
|
CANDIDATES=['expr_parse.c','expr_tree.c','expr_eval.c']
|
|
DEADLINES={'compiler':15,'candidate':20,'cleanup':5,'absence':5}
|
|
KEEP_WIRE=False
|
|
AUDIT=[]
|
|
FAILURES=[]
|
|
KINDS={'add':2,'sub':3,'mul':4,'min':5,'max':6,'neg':7,'abs':8,'sum':9}
|
|
ARITY={'add':2,'sub':2,'mul':2,'min':2,'max':2,'neg':1,'abs':1}
|
|
|
|
class Reject(Exception):
|
|
def __init__(self,status): self.status=status
|
|
|
|
def parse(raw,nodes=256,depth=32,budget=-1):
|
|
if len(raw)>4096:raise Reject(2)
|
|
try:text=raw.decode('ascii')
|
|
except UnicodeDecodeError:raise Reject(1)
|
|
tokens=re.findall(r'[()\s]|[^()\s]+',text,flags=re.ASCII)
|
|
position=0;allocated=0
|
|
def skip():
|
|
nonlocal position
|
|
while position<len(tokens) and tokens[position] in (' ','\t','\r','\n'):position+=1
|
|
def allocate(level):
|
|
nonlocal allocated
|
|
if allocated>=nodes or level>depth:raise Reject(2)
|
|
if budget>=0 and allocated>=budget:raise Reject(3)
|
|
allocated+=1
|
|
def expression(level):
|
|
nonlocal position
|
|
if position==len(tokens):raise Reject(1)
|
|
token=tokens[position];position+=1
|
|
if token=='(':
|
|
skip()
|
|
if position==len(tokens):raise Reject(1)
|
|
op=tokens[position];position+=1
|
|
if op not in KINDS:raise Reject(1)
|
|
allocate(level);args=[]
|
|
while True:
|
|
before=position;skip()
|
|
if position==len(tokens):raise Reject(1)
|
|
if tokens[position]==')':
|
|
position+=1
|
|
if len(args)!=(ARITY.get(op,len(args))) or not 1<=len(args)<=8:raise Reject(1)
|
|
return (op,args)
|
|
if before==position or len(args)==ARITY.get(op,8):raise Reject(1)
|
|
args.append(expression(level+1))
|
|
if re.fullmatch(r'-?[0-9]+',token):
|
|
value=int(token)
|
|
if not -1000000<=value<=1000000:raise Reject(1)
|
|
allocate(level);return ('number',value)
|
|
if re.fullmatch(r'[a-z][a-z0-9_]{0,14}',token):
|
|
allocate(level);return ('variable',token)
|
|
raise Reject(1)
|
|
skip();node=expression(1);skip()
|
|
if position!=len(tokens):raise Reject(1)
|
|
return node
|
|
|
|
def count(node):return 0 if node is None else 1+sum(map(count,node[1])) if node[0] in KINDS else 1
|
|
|
|
def height(node):return 0 if node is None else 1+max(map(height,node[1])) if node[0] in KINDS else 1
|
|
|
|
def canonical(node):
|
|
if node is None:return ''
|
|
if node[0] in KINDS:return '('+node[0]+''.join(' '+canonical(x) for x in node[1])+')'
|
|
return str(node[1])
|
|
|
|
def postorder(node):
|
|
if node is None:return []
|
|
if node[0] in KINDS:return sum((postorder(x) for x in node[1]),[])+[[KINDS[node[0]],0,'']]
|
|
return [[0,node[1],'']] if node[0]=='number' else [[1,0,node[1]]]
|
|
|
|
def view(node):return [count(node),height(node),0,canonical(node),postorder(node)]
|
|
|
|
def evaluate(node,bindings):
|
|
env={}
|
|
for name,value in bindings:
|
|
if not re.fullmatch(r'[a-z][a-z0-9_]{0,14}',name) or name in env or not -10**9<=value<=10**9:raise Reject(7)
|
|
env[name]=value
|
|
def calculate(node):
|
|
if node is None:return 0
|
|
op,arg=node
|
|
if op=='number':return arg
|
|
if op=='variable':
|
|
if arg not in env:raise Reject(5)
|
|
return env[arg]
|
|
values=[calculate(child) for child in arg]
|
|
if op=='add':result=values[0]+values[1]
|
|
elif op=='sub':result=values[0]-values[1]
|
|
elif op=='mul':result=values[0]*values[1]
|
|
elif op=='min':result=min(values)
|
|
elif op=='max':result=max(values)
|
|
elif op=='neg':result=-values[0]
|
|
elif op=='abs':result=abs(values[0])
|
|
else:
|
|
result=0
|
|
for value in values:
|
|
result+=value
|
|
if abs(result)>10**12:raise Reject(4)
|
|
if abs(result)>10**12:raise Reject(4)
|
|
return result
|
|
return calculate(node)
|
|
|
|
class Matrix:
|
|
def __init__(self):self.commands=[];self.expected=[];self.trees=[None,None];self.limits=[(256,32),(256,32)]
|
|
def emit(self,command,rc=0,extra=None):
|
|
self.commands.append(command)
|
|
self.expected.append([rc,sum(map(count,self.trees)),0,0,view(self.trees[0]),view(self.trees[1]),extra or []])
|
|
def p(self,raw,slot=0,budget=-1):
|
|
if isinstance(raw,str):raw=raw.encode()
|
|
try:self.trees[slot]=parse(raw,*self.limits[slot],budget);rc=0
|
|
except Reject as e:rc=e.status
|
|
self.emit('P %d %d %s'%(slot,budget,raw.hex() or '-'),rc)
|
|
def clone(self,dst,src,budget=-1):
|
|
node=self.trees[src]
|
|
rc=2 if count(node)>self.limits[dst][0] or height(node)>self.limits[dst][1] else 3 if budget>=0 and count(node)>budget else 0
|
|
if not rc:self.trees[dst]=node
|
|
self.emit('C %d %d %d'%(dst,src,budget),rc)
|
|
def destroy(self,slot):self.trees[slot]=None;self.emit('D %d'%slot)
|
|
def init(self,slot,nodes,depth):self.trees[slot]=None;self.limits[slot]=(nodes,depth);self.emit('I %d %d %d'%(slot,nodes,depth))
|
|
def query(self,slot=0,capacity=4097,bindings=()):
|
|
node=self.trees[slot];text=canonical(node).encode();rc=0;value=888888
|
|
try:value=evaluate(node,bindings)
|
|
except Reject as e:rc=e.status
|
|
render_rc=0 if capacity>len(text) else 6
|
|
observed=(text+b'\0') if not render_rc else b'Z'*capacity
|
|
command='Q %d %d %d'%(slot,capacity,len(bindings))+''.join(' %s %d'%item for item in bindings)
|
|
self.emit(command,extra=[rc,value,render_rc,len(text),observed.hex()])
|
|
def finish(self):self.expected.append(['END',0,0,0]);return ('\n'.join(self.commands)+'\n').encode(),self.expected
|
|
|
|
def cases():
|
|
c=Matrix();rng=random.Random(815091)
|
|
c.query();c.destroy(0)
|
|
for expression in ['0','-0','000001','-1000000','1000000','x','long_name12345','(add 2 (mul x 3))',
|
|
'(sub -7 -8)','(min 2 -3)','(max -1 9)','(neg (abs -5))','(sum 1 2 3 4 5 6 7 8)',
|
|
' \t( sum\n1\r2 )\n']:
|
|
c.p(expression);c.query(bindings=[('x',7)]);c.clone(1,0);c.destroy(0);c.query(1,bindings=[('x',-3)]);c.destroy(1)
|
|
c.p('(add 8 9)')
|
|
for bad in ['', ' ', '()', '(unknown 1)', '(add 1)', '(neg 1 2)', '(sum)', '(sum 1 2 3 4 5 6 7 8 9)',
|
|
'(add 1 2', '(sum 7 (mul 2 3)', '(add 1 2))', '1 2', '+1','1000001','-1000001','abcdefghijklmnop',
|
|
'a-b','(add 1x 2)','(add(neg 1) 2)','(add 1 2)garbage',b'a\x00',b'\xff']:
|
|
c.p(bad);c.query(capacity=1)
|
|
expr='(sum (add 1 2) (mul 3 4) (abs -7))'
|
|
for budget in range(12):c.p(expr,budget=budget)
|
|
c.p(expr)
|
|
for budget in range(12):c.clone(1,0,budget)
|
|
c.clone(0,0);c.destroy(1)
|
|
for nodes,depth,expression in [(1,32,'1'),(1,32,'(neg 1)'),(256,1,'(neg 1)'),(3,2,'(add 1 2)'),(3,2,'(neg (neg 1))')]:
|
|
c.init(1,nodes,depth);c.p(expression,1);c.clone(1,0)
|
|
c.init(1,256,32)
|
|
c.p('(add x (mul y z))');
|
|
for bindings in [[],[('x',1)],[('x',10),('y',-2),('z',3)],[('x',1),('x',2)],[('unused',10**9+1)],
|
|
[('Bad',0)],[('x',10**9),('y',10**9),('z',10**9)]]:c.query(bindings=bindings)
|
|
for text in ['(mul 1000000 1000000)','(mul (mul 1000000 1000000) 2)','(sum (mul 1000000 1000000) 1 -1)',
|
|
'(sub (neg (mul 1000000 1000000)) 1)','(min missing (mul (mul 1000000 1000000) 2))']:
|
|
c.p(text);c.query()
|
|
c.p('(add -001 2)')
|
|
for cap in [0,1,9,10,11,12,4097]:c.query(capacity=cap)
|
|
c.p('a'*4097)
|
|
def sized(n):
|
|
if n==1:return '1'
|
|
parts=min(8,n-1);sizes=[(n-1)//parts]*parts
|
|
for i in range((n-1)%parts):sizes[i]+=1
|
|
return '(sum '+' '.join(sized(x) for x in sizes)+')'
|
|
c.p(sized(256));c.p(sized(257))
|
|
c.p('v63');c.query(bindings=[('v%d'%i,i) for i in range(64)])
|
|
for depth in [31,32,33]:c.p('(neg '* (depth-1)+'1'+')'*(depth-1))
|
|
def tree(depth):
|
|
if depth==0 or rng.randrange(4)==0:return rng.choice(['x','y','-7','0','123'])
|
|
op=rng.choice(list(KINDS));arity=ARITY.get(op,rng.randrange(1,9))
|
|
return '('+op+' '+ ' '.join(tree(depth-1) for _ in range(arity))+')'
|
|
for index in range(25):
|
|
text=tree(3);c.p(text);c.query(bindings=[('x',rng.randrange(-20,21)),('y',rng.randrange(-20,21))])
|
|
if index%5==0:c.clone(1,0);c.p('42');c.query(1,bindings=[('x',5),('y',6)])
|
|
c.destroy(0);c.destroy(0);c.destroy(1)
|
|
return c.finish()
|
|
|
|
def exact(a,b):
|
|
if type(a) is not type(b):return False
|
|
if isinstance(a,list):return len(a)==len(b) and all(exact(x,y) for x,y in zip(a,b))
|
|
return a==b
|
|
|
|
def valid_meta(meta,cfg,out,err):
|
|
required={'nonce','argv','deadline','uid','gid','groups','supervisor_pid','supervisor_start','leader_pid','leader_start','leader_returncode','leader_reaped','timeout','controlled_returncode','elapsed','descendants_absent','processgroup_absent','tracked','reaped','remaining','stdout_len','stdout_sha256','stderr_len','stderr_sha256','exceptions'}
|
|
if type(meta) is not dict or set(meta)!=required:raise ValueError('metadata fields')
|
|
for key in ['supervisor_pid','supervisor_start','leader_pid','leader_start']:
|
|
if type(meta[key]) is not int or meta[key]<=0:raise ValueError('metadata identity '+key)
|
|
if meta['supervisor_pid']==meta['leader_pid']:raise ValueError('same leader/supervisor')
|
|
expected_uid=65534 if os.environ.get('ROLLOUT_GRADE_ISOLATION')=='uid65534' else os.getuid()
|
|
expected_gid=65534 if expected_uid==65534 else os.getgid()
|
|
if type(meta['uid']) is not int or type(meta['gid']) is not int or meta['uid']!=expected_uid or meta['gid']!=expected_gid:raise ValueError('identity uid/gid')
|
|
if type(meta['groups']) is not list or any(type(g) is not int or g<0 for g in meta['groups']):raise ValueError('groups type')
|
|
if meta['groups']!=([] if expected_uid==65534 else os.getgroups()):raise ValueError('groups identity')
|
|
if type(meta['elapsed']) not in (int,float) or not math.isfinite(meta['elapsed']) or not 0<=meta['elapsed']<=cfg['deadline']+3:raise ValueError('elapsed')
|
|
if type(meta['timeout']) is not bool:raise ValueError('timeout type')
|
|
for key in ['leader_returncode','controlled_returncode']:
|
|
if type(meta[key]) is not int:raise ValueError('returncode type')
|
|
if meta['controlled_returncode']!=(124 if meta['timeout'] else meta['leader_returncode']):raise ValueError('controlled rc')
|
|
if meta['timeout'] and meta['leader_returncode']==0:raise ValueError('timeout success contradiction')
|
|
for key in ['leader_reaped','descendants_absent','processgroup_absent']:
|
|
if type(meta[key]) is not bool or not meta[key]:raise ValueError(key)
|
|
for key in ['tracked','reaped','remaining','exceptions']:
|
|
if type(meta[key]) is not list:raise ValueError(key+' type')
|
|
if meta['remaining'] or meta['exceptions']:raise ValueError('remaining/exceptions')
|
|
for row in meta['tracked']:
|
|
if type(row) is not list or len(row)!=2 or any(type(n) is not int or n<=0 for n in row):raise ValueError('tracked row')
|
|
if [meta['leader_pid'],meta['leader_start']] not in meta['tracked']:raise ValueError('leader tracking')
|
|
for row in meta['reaped']:
|
|
if type(row) is not list or len(row)!=3 or any(type(n) is not int for n in row) or row[0]<=0 or row[1]<=0 or row[2]<0:raise ValueError('reaped row')
|
|
if meta['nonce']!=cfg['nonce'] or not exact(meta['argv'],cfg['argv']) or type(meta['deadline']) is not int or meta['deadline']!=cfg['deadline']:raise ValueError('binding')
|
|
for prefix,raw in [('stdout',out),('stderr',err)]:
|
|
if type(meta[prefix+'_len']) is not int or meta[prefix+'_len']<0 or meta[prefix+'_len']!=len(raw) or meta[prefix+'_sha256']!=hashlib.sha256(raw).hexdigest():raise ValueError('IO '+prefix)
|
|
|
|
def execute(stage,argv,cwd,input=b''):
|
|
cfg={'argv':argv,'cwd':str(cwd),'input':base64.b64encode(input).decode(),'deadline':DEADLINES[stage],'nonce':uuid.uuid4().hex}
|
|
result=subprocess.run([sys.executable,'-I','-c',SUPERVISOR,json.dumps(cfg,separators=(',',':'))],capture_output=True)
|
|
record={'stage':stage,'wrapper_rc':result.returncode,'wire_len':len(result.stdout),'wire_sha256':hashlib.sha256(result.stdout).hexdigest(),'wrapper_stderr_len':len(result.stderr),'wrapper_stderr_sha256':hashlib.sha256(result.stderr).hexdigest()}
|
|
if KEEP_WIRE:
|
|
if len(result.stdout)>131072:record['wire_deflate_b64']=base64.b64encode(zlib.compress(result.stdout,9)).decode()
|
|
else:record['wire_latin1']=result.stdout.decode('latin1')
|
|
record['wrapper_stderr_latin1']=result.stderr.decode('latin1')
|
|
AUDIT.append(record)
|
|
# Keep the actual wrapper facts before any wire parsing or metadata validation.
|
|
if result.returncode!=0 or result.stderr:raise ValueError(stage+' wrapper failure')
|
|
wire=json.loads(result.stdout)
|
|
if type(wire) is not dict or set(wire)!={'m','o','e'}:raise ValueError(stage+' wire fields')
|
|
out=base64.b64decode(wire['o'],validate=True);err=base64.b64decode(wire['e'],validate=True)
|
|
if not KEEP_WIRE:record['meta']=wire['m']
|
|
valid_meta(wire['m'],cfg,out,err)
|
|
if wire['m']['timeout'] or wire['m']['leader_returncode']!=0:raise ValueError(stage+' controlled/leader rc '+str(wire['m']['controlled_returncode']))
|
|
return out,err
|
|
|
|
CLEANUP="import shutil,sys; shutil.rmtree(sys.argv[1])"
|
|
ABSENCE="import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: print('ABSENT')\nelse: print('PRESENT'); raise SystemExit(1)"
|
|
|
|
def main():
|
|
scratch=None
|
|
prepared=False
|
|
try:
|
|
inputs,expected=cases()
|
|
context=json.loads((Path(__file__).resolve().parent/'context.json').read_text())
|
|
sources={name:(Path(sys.argv[1])/name).read_bytes() for name in CANDIDATES}
|
|
scratch=Path(tempfile.mkdtemp(prefix='expression-tree-',dir='/tmp'))
|
|
work=scratch/'work';work.mkdir(mode=0o777);os.chmod(work,0o777)
|
|
for name,text in context.items():(work/name).write_text(text)
|
|
for name,raw in sources.items():(work/name).write_bytes(raw)
|
|
prepared=True
|
|
execute('compiler',['gcc','-std=c11','-O2','-Wall','-Wextra','-pedantic','observe.c',*CANDIDATES,'-o','observe'],work)
|
|
raw,stderr=execute('candidate',[str(work/'observe')],work,inputs)
|
|
# Arbitrary stderr bytes are diagnostics; stdout is a strict UTF-8 JSON-line protocol.
|
|
observed=[json.loads(line) for line in raw.decode('utf-8','strict').splitlines()]
|
|
for i in range(max(len(observed),len(expected))):
|
|
got=observed[i] if i<len(observed) else '<missing>'
|
|
want=expected[i] if i<len(expected) else '<end>'
|
|
if not exact(got,want):
|
|
FAILURES.append('behavior observation=%d got=%r expected=%r'%(i,str(got)[:120],str(want)[:120]));break
|
|
except Exception as e:FAILURES.append('execution '+type(e).__name__+': '+str(e))
|
|
finally:
|
|
if scratch is not None:
|
|
for stage,script in [('cleanup',CLEANUP),('absence',ABSENCE)]:
|
|
try:
|
|
out,err=execute(stage,[sys.executable,'-I','-c',script,str(scratch)],'/tmp')
|
|
if stage=='absence' and out!=b'ABSENT\n':raise ValueError('absence protocol')
|
|
except Exception as e:FAILURES.append(stage+' '+type(e).__name__+': '+str(e))
|
|
facts={'prepared':prepared,'exceptions':FAILURES,'stages':AUDIT}
|
|
encoded=base64.b64encode(bz2.compress(json.dumps(facts,separators=(',',':')).encode(),9)).decode()
|
|
print('EXPR_AUDIT '+encoded,file=sys.stderr)
|
|
if FAILURES:
|
|
print('FAIL '+FAILURES[0][:220]);return 1
|
|
print('PASS');return 0
|
|
|
|
if __name__=='__main__':raise SystemExit(main())
|