amos 9d633e9e67 Batch 15 (20261023-C-hwe-scale-15): 320 HWE-derived repair tasks
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>
2026-10-27 01:55:56 +08:00

485 lines
32 KiB
Python

import base64
import hashlib
import json
import math
import os
from pathlib import Path
import random
import re
import shutil
import subprocess
import sys
import tempfile
import zlib
CONTEXT = '#include "reader.hpp"\n\n#include <charconv>\n#include <iostream>\n#include <sstream>\n#include <string>\n#include <system_error>\n#include <vector>\n\nusing exception_reader::Event;\nusing exception_reader::Reader;\nusing exception_reader::Request;\nusing exception_reader::Result;\nusing exception_reader::Store;\n\nnamespace {\n\nstd::vector<std::string> words(const std::string &line)\n{\n std::istringstream input(line);\n std::vector<std::string> output;\n std::string word;\n while (input >> word) {\n output.push_back(word);\n }\n return output;\n}\n\nint nibble(char value)\n{\n if (value >= \'0\' && value <= \'9\') {\n return value - \'0\';\n }\n if (value >= \'a\' && value <= \'f\') {\n return value - \'a\' + 10;\n }\n if (value >= \'A\' && value <= \'F\') {\n return value - \'A\' + 10;\n }\n return -1;\n}\n\nbool decode(const std::string &source, std::string &output)\n{\n output.clear();\n if (source == "-") {\n return true;\n }\n if (source.size() % 2 != 0) {\n return false;\n }\n for (std::size_t at = 0; at < source.size(); at += 2) {\n const int high = nibble(source[at]);\n const int low = nibble(source[at + 1]);\n if (high < 0 || low < 0) {\n return false;\n }\n output.push_back(static_cast<char>((high << 4) | low));\n }\n return true;\n}\n\nstd::string encode(const std::string &source)\n{\n static const char digits[] = "0123456789abcdef";\n if (source.empty()) {\n return "-";\n }\n std::string output;\n output.reserve(source.size() * 2);\n for (unsigned char byte : source) {\n output.push_back(digits[byte >> 4]);\n output.push_back(digits[byte & 15]);\n }\n return output;\n}\n\ntemplate<typename Number>\nbool parse_number(const std::string &text, Number &output)\n{\n if (text.empty()) {\n return false;\n }\n const char *first = text.data();\n const char *last = first + text.size();\n const auto result = std::from_chars(first, last, output);\n return result.ec == std::errc{} && result.ptr == last;\n}\n\nvoid print_result(const Result &result)\n{\n std::cout << "Q " << exception_reader::status_name(result.status)\n << \' \' << result.lines\n << \' \' << result.bytes\n << \' \' << result.longest\n << \' \' << result.digest\n << \' \' << result.index_value\n << \' \' << result.opened\n << \' \' << result.closed\n << \' \' << result.live << \'\\n\';\n}\n\nclass Observer {\npublic:\n explicit Observer(std::size_t capacity)\n : store_(capacity), reader_(store_) {}\n\n bool execute(const std::vector<std::string> &parts)\n {\n if (parts.empty()) {\n return true;\n }\n if (parts[0] == "P") {\n return put(parts);\n }\n if (parts[0] == "A") {\n return append(parts);\n }\n if (parts[0] == "O") {\n return open(parts);\n }\n if (parts[0] == "D") {\n return duplicate(parts);\n }\n if (parts[0] == "R") {\n return read(parts);\n }\n if (parts[0] == "C") {\n return close(parts);\n }\n if (parts[0] == "J") {\n return jump(parts);\n }\n if (parts[0] == "I") {\n return inspect(parts);\n }\n if (parts[0] == "Q") {\n return query(parts);\n }\n if (parts[0] == "S") {\n return state(parts);\n }\n return false;\n }\n\nprivate:\n bool put(const std::vector<std::string> &parts)\n {\n if (parts.size() != 3 || parts[1].empty()) {\n return false;\n }\n std::string bytes;\n if (!decode(parts[2], bytes)) {\n return false;\n }\n store_.put(parts[1], bytes);\n std::cout << "P " << parts[1] << \'\\n\';\n return true;\n }\n\n bool query(const std::vector<std::string> &parts)\n {\n if (parts.size() != 6 || parts[1].empty()) {\n return false;\n }\n unsigned use_index = 0;\n std::size_t chunk = 0;\n long long fault_after = 0;\n if (!parse_number(parts[3], use_index) || use_index > 1 ||\n !parse_number(parts[4], chunk) ||\n !parse_number(parts[5], fault_after)) {\n return false;\n }\n const Request request{parts[1], parts[2], use_index != 0,\n chunk, fault_after};\n print_result(reader_.run(request));\n return true;\n }\n\n bool append(const std::vector<std::string> &parts)\n {\n if (parts.size() != 3 || !store_.contains(parts[1])) {\n return false;\n }\n std::string bytes;\n if (!decode(parts[2], bytes)) {\n return false;\n }\n store_.append(parts[1], bytes);\n std::cout << "A " << parts[1] << \' \'\n << store_.file_size(parts[1]) << \'\\n\';\n return true;\n }\n\n bool open(const std::vector<std::string> &parts)\n {\n if (parts.size() != 2) return false;\n try {\n const int handle = store_.open(parts[1]);\n std::cout << "O " << handle << \'\\n\';\n } catch (const exception_reader::Missing &) {\n std::cout << "O MISSING\\n";\n } catch (const exception_reader::Exhausted &) {\n std::cout << "O EXHAUSTED\\n";\n }\n return true;\n }\n\n bool duplicate(const std::vector<std::string> &parts)\n {\n int handle = 0;\n if (parts.size() != 2 || !parse_number(parts[1],handle)) return false;\n try {\n const int next = store_.clone(handle);\n std::cout << "D " << next << \'\\n\';\n } catch (const exception_reader::BadHandle &) {\n std::cout << "D BAD_HANDLE\\n";\n } catch (const exception_reader::Exhausted &) {\n std::cout << "D EXHAUSTED\\n";\n }\n return true;\n }\n\n bool read(const std::vector<std::string> &parts)\n {\n int handle = 0;\n std::size_t limit = 0;\n long long fault = 0;\n if (parts.size() != 4 || !parse_number(parts[1],handle) ||\n !parse_number(parts[2],limit) || limit == 0 ||\n !parse_number(parts[3],fault)) return false;\n try {\n const std::string piece = store_.read(handle,limit,fault);\n std::cout << "R " << encode(piece) << \'\\n\';\n } catch (const exception_reader::BadHandle &) {\n std::cout << "R BAD_HANDLE\\n";\n } catch (const exception_reader::ReadFault &) {\n std::cout << "R READ_ERROR\\n";\n }\n return true;\n }\n\n bool close(const std::vector<std::string> &parts)\n {\n int handle = 0;\n if (parts.size() != 2 || !parse_number(parts[1],handle)) return false;\n try {\n store_.close(handle);\n std::cout << "C " << handle << \'\\n\';\n } catch (const exception_reader::BadHandle &) {\n std::cout << "C BAD_HANDLE\\n";\n }\n return true;\n }\n\n bool jump(const std::vector<std::string> &parts)\n {\n int handle = 0;\n std::size_t offset = 0;\n if (parts.size() != 3 || !parse_number(parts[1],handle) ||\n !parse_number(parts[2],offset)) return false;\n try {\n store_.seek(handle,offset);\n std::cout << "J " << offset << \'\\n\';\n } catch (const exception_reader::BadHandle &) {\n std::cout << "J BAD_HANDLE\\n";\n } catch (const std::invalid_argument &) {\n std::cout << "J RANGE_ERROR\\n";\n }\n return true;\n }\n\n bool inspect(const std::vector<std::string> &parts)\n {\n int handle = 0;\n if (parts.size() != 2 || !parse_number(parts[1],handle)) return false;\n try {\n const std::size_t position = store_.position(handle);\n const std::size_t remaining = store_.remaining(handle);\n std::cout << "I " << position << \' \' << remaining << \'\\n\';\n } catch (const exception_reader::BadHandle &) {\n std::cout << "I BAD_HANDLE\\n";\n }\n return true;\n }\n\n bool state(const std::vector<std::string> &parts)\n {\n if (parts.size() != 1) {\n return false;\n }\n const std::vector<Event> events = store_.events();\n std::cout << "S " << store_.live() << \' \'\n << events.size() - previous_event_ << \'\\n\';\n for (std::size_t at = previous_event_; at < events.size(); ++at) {\n const Event &event = events[at];\n std::cout << "E " << event.kind << \' \' << event.handle\n << \' \' << event.amount << \'\\n\';\n }\n previous_event_ = events.size();\n return true;\n }\n\n Store store_;\n Reader reader_;\n std::size_t previous_event_ = 0;\n};\n\n}\n\nint main()\n{\n Observer observer(3);\n std::string line;\n while (std::getline(std::cin, line)) {\n if (!observer.execute(words(line))) {\n return 2;\n }\n }\n return std::cin.bad() ? 2 : 0;\n}\n'
CANDIDATES = ('reader.hpp', 'reader.cpp')
COMPILE_DEADLINE = 25
RUN_DEADLINE = 16
CLEAN_DEADLINE = 8
ABSENCE_DEADLINE = 8
SUPERVISOR = r'''
import base64, ctypes, hashlib, json, os, signal, subprocess, sys, time
from pathlib import Path
def stat(pid):
try:
raw = Path('/proc/%d/stat' % pid).read_text()
except (FileNotFoundError, ProcessLookupError):
return None
close = raw.rfind(')')
values = raw[close + 2:].split()
return (values[0], int(values[1]), int(values[19]))
def table(errors):
found = {}
try:
names = os.listdir('/proc')
except Exception as exc:
errors.append('proc-list:' + repr(exc)); return found
for name in names:
if not name.isdigit(): continue
try:
item = stat(int(name))
if item is not None: found[int(name)] = item
except Exception as exc:
errors.append('proc-stat:' + name + ':' + repr(exc))
return found
def descendants(owner, owner_start, found):
own = found.get(owner)
if own is None or own[2] != owner_start or own[0] in ('Z','X'):
return {}
current = {owner}
result = {}
while True:
added = False
for pid, (state, ppid, start) in found.items():
if pid in result or pid == owner or ppid not in current: continue
result[pid] = (state, ppid, start)
if state not in ('Z','X'):
current.add(pid)
added = True
if not added: break
return result
def fresh_kill(pid, start, errors):
try:
current = stat(pid)
if current is None or current[2] != start or current[0] in ('Z','X'):
return False
os.kill(pid, signal.SIGKILL)
return True
except (FileNotFoundError, ProcessLookupError):
return False
except Exception as exc:
errors.append('signal:' + repr(exc))
return False
def reap_adopted(errors):
while True:
try: pid, _ = os.waitpid(-1, os.WNOHANG)
except ChildProcessError: return
except Exception as exc:
errors.append('reap:' + repr(exc)); return
if pid == 0: return
def main():
argv = json.loads(sys.argv[1]); cwd = sys.argv[2]
deadline = float(sys.argv[3]); input_bytes = base64.b64decode(sys.argv[4])
errors = []; started = time.monotonic(); sup = os.getpid()
try:
if ctypes.CDLL(None).prctl(36, 1, 0, 0, 0) != 0:
errors.append('subreaper:prctl returned nonzero')
except Exception as exc: errors.append('subreaper:' + repr(exc))
ownstat = stat(sup)
ownstart = ownstat[2] if ownstat else None
proc = None; leader_start = None; leader_rc = None
timed_out = False; stdout = b''; stderr = b''; reaped = False
try:
proc = subprocess.Popen(argv, cwd=cwd, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE, start_new_session=True)
leaderstat = stat(proc.pid)
leader_start = leaderstat[2] if leaderstat else None
if leader_start is None: errors.append('leader-start-missing')
try:
stdout, stderr = proc.communicate(input_bytes, timeout=deadline)
except subprocess.TimeoutExpired:
timed_out = True
except Exception as exc: errors.append('execute:' + repr(exc))
limit = time.monotonic() + 3.0
observed = set(); signaled = set()
last = {}
while proc is not None and time.monotonic() < limit:
seen = table(errors)
last = descendants(sup, ownstart, seen)
for pid, (_, _, start) in last.items():
observed.add((pid,start))
if fresh_kill(pid, start, errors): signaled.add((pid,start))
try:
if proc.poll() is not None:
leader_rc = proc.wait(timeout=0.05); reaped = True
except Exception as exc: errors.append('leader-wait:' + repr(exc))
if reaped: reap_adopted(errors)
seen = table(errors)
last = descendants(sup, ownstart, seen)
living = {pid: info for pid, info in last.items() if info[0] not in ('Z','X')}
if reaped and not living: break
time.sleep(0.02)
if proc is not None:
try:
more_out, more_err = proc.communicate(timeout=0.2)
stdout, stderr = more_out, more_err
if not reaped:
leader_rc = proc.returncode; reaped = True
except Exception as exc: errors.append('communicate-final:' + repr(exc))
if reaped: reap_adopted(errors)
final = descendants(sup, ownstart, table(errors))
living = {pid: info for pid, info in final.items() if info[0] not in ('Z','X')}
absence = not living and not any(info[0] in ('Z','X') for info in final.values())
rc = 124 if timed_out else leader_rc
elapsed = time.monotonic() - started
wire = dict(supervisor_pid=sup, supervisor_start=ownstart,
leader_pid=proc.pid if proc is not None else None, leader_start=leader_start,
uid=os.getuid(), gid=os.getgid(), groups=os.getgroups(),
argv=argv, elapsed=elapsed, timeout=timed_out, rc=rc,
leader_rc=leader_rc, reaped=reaped, descendants_absent=absence,
descendants=[(pid, info[2], info[0]) for pid, info in sorted(final.items())],
observed_descendants=sorted(observed), signaled_descendants=sorted(signaled),
exceptions=errors, stdout_len=len(stdout), stderr_len=len(stderr),
stdout_sha256=hashlib.sha256(stdout).hexdigest(),
stderr_sha256=hashlib.sha256(stderr).hexdigest(),
stdout=base64.b64encode(stdout).decode('ascii'),
stderr=base64.b64encode(stderr).decode('ascii'))
sys.stdout.write(json.dumps(wire, separators=(',',':')))
return 0
if __name__ == '__main__': raise SystemExit(main())
'''
def is_int(x):
return type(x) is int
def checked_wire(raw, argv, deadline, expected_uid, expected_gid, expected_groups):
if type(raw) is not dict: raise ValueError('wire type')
keys = ('supervisor_pid','supervisor_start','leader_pid','leader_start','uid','gid',
'groups','argv','elapsed','timeout','rc','leader_rc','reaped',
'descendants_absent','descendants','observed_descendants','signaled_descendants',
'exceptions','stdout_len','stderr_len',
'stdout_sha256','stderr_sha256','stdout','stderr')
if any(key not in raw for key in keys): raise ValueError('wire missing field')
for key in ('supervisor_pid','supervisor_start','leader_pid','leader_start'):
if not is_int(raw[key]) or raw[key] <= 0: raise ValueError('wire pid/start')
if raw['supervisor_pid'] == raw['leader_pid']: raise ValueError('wire pid alias')
if not is_int(raw['uid']) or not is_int(raw['gid']): raise ValueError('wire uid/gid')
if raw['uid'] != expected_uid or raw['gid'] != expected_gid: raise ValueError('wire identity')
if type(raw['groups']) is not list or any(not is_int(x) for x in raw['groups']):
raise ValueError('wire groups type')
if raw['groups'] != expected_groups: raise ValueError('wire groups')
if type(raw['argv']) is not list or raw['argv'] != argv: raise ValueError('wire argv')
elapsed = raw['elapsed']
if type(elapsed) not in (int,float) or not math.isfinite(elapsed) or not 0 <= elapsed <= deadline+4:
raise ValueError('wire elapsed')
if type(raw['timeout']) is not bool or type(raw['reaped']) is not bool or \
type(raw['descendants_absent']) is not bool: raise ValueError('wire flags')
if not is_int(raw['rc']) or not is_int(raw['leader_rc']): raise ValueError('wire rc')
if raw['timeout'] and raw['rc'] != 124: raise ValueError('wire timeout rc')
if not raw['timeout'] and raw['rc'] != raw['leader_rc']: raise ValueError('wire leader rc')
if not raw['reaped'] or not raw['descendants_absent']: raise ValueError('wire closure')
if type(raw['descendants']) is not list or type(raw['exceptions']) is not list or \
raw['exceptions']: raise ValueError('wire descendants/errors')
if raw['descendants']: raise ValueError('wire descendants remaining')
for key in ('observed_descendants','signaled_descendants'):
if type(raw[key]) is not list or any(type(item) is not list or len(item)!=2 or
any(not is_int(n) or n<=0 for n in item) for item in raw[key]):
raise ValueError('wire topology '+key)
if any(item not in raw['observed_descendants'] for item in raw['signaled_descendants']):
raise ValueError('wire signal ancestry')
for stream in ('stdout','stderr'):
if not is_int(raw[stream+'_len']) or raw[stream+'_len'] < 0: raise ValueError('wire io len')
if type(raw[stream]) is not str or type(raw[stream+'_sha256']) is not str:
raise ValueError('wire io type')
data = base64.b64decode(raw[stream], validate=True)
if len(data) != raw[stream+'_len'] or hashlib.sha256(data).hexdigest() != raw[stream+'_sha256']:
raise ValueError('wire io digest')
raw[stream+'_bytes'] = data
return raw
def supervised(argv, cwd, deadline, stdin=b''):
isolated = os.environ.get('ROLLOUT_GRADE_ISOLATION') == 'uid65534'
uid = 65534 if isolated else os.getuid()
gid = 65534 if isolated else os.getgid()
groups = [] if isolated else os.getgroups()
args = [sys.executable, '-I', '-c', SUPERVISOR, json.dumps(argv), str(cwd),
str(deadline), base64.b64encode(stdin).decode('ascii')]
wrapper = subprocess.run(args, capture_output=True, timeout=deadline+8)
if wrapper.returncode != 0:
raise RuntimeError('supervisor rc=%s wire_len=%d wire_sha=%s stderr=%s' %
(wrapper.returncode,len(wrapper.stdout),hashlib.sha256(wrapper.stdout).hexdigest(),
wrapper.stderr[-200:].decode('utf-8','replace')))
wire_facts=(len(wrapper.stdout),hashlib.sha256(wrapper.stdout).hexdigest())
try:
wire = json.loads(wrapper.stdout)
wire=checked_wire(wire, argv, deadline, uid, gid, groups)
except Exception as exc:
raise ValueError('supervisor wire rc=%d len=%d sha=%s: %s' %
(wrapper.returncode,wire_facts[0],wire_facts[1],exc)) from exc
wire['wrapper_rc']=wrapper.returncode
wire['wire_len'],wire['wire_sha256']=wire_facts
return wire
def finish_phase(wire, name):
if wire['timeout'] or wire['rc'] != 0:
raise RuntimeError('%s rc=%s timeout=%s' % (name,wire['rc'],wire['timeout']))
class Model:
def __init__(self):
self.files = {}; self.handles = {}; self.events = []; self.output = []
def put(self, name, data):
self.files[name] = data; self.output.append('P '+name)
def append(self, name, data):
self.files[name] += data; self.output.append('A %s %d' % (name,len(self.files[name])))
def open(self, name):
if name not in self.files: return None, 'MISSING'
if len(self.handles) >= 3: return None, 'EXHAUSTED'
handle = next(x for x in range(1,4) if x not in self.handles)
self.handles[handle] = [name,0]; self.events.append(('O',handle,0))
return handle, None
def clone(self, handle):
if handle not in self.handles: return None,'BAD_HANDLE'
if len(self.handles) >= 3: return None,'EXHAUSTED'
next_handle=next(x for x in range(1,4) if x not in self.handles)
self.handles[next_handle]=self.handles[handle].copy()
self.events.append(('O',next_handle,0))
return next_handle,None
def raw_open(self,name):
handle,error=self.open(name)
self.output.append('O '+(str(handle) if handle is not None else error))
def raw_clone(self,handle):
next_handle,error=self.clone(handle)
self.output.append('D '+(str(next_handle) if next_handle is not None else error))
def raw_read(self,handle,limit,fault):
if handle not in self.handles: outcome='BAD_HANDLE'
else:
piece,bad=self.read(handle,limit,fault)
outcome='READ_ERROR' if bad else (piece.hex() or '-')
self.output.append('R '+outcome)
def raw_close(self,handle):
if handle not in self.handles: self.output.append('C BAD_HANDLE')
else:
self.close(handle)
self.output.append('C '+str(handle))
def raw_seek(self,handle,offset):
if handle not in self.handles: outcome='BAD_HANDLE'
elif offset > len(self.files[self.handles[handle][0]]): outcome='RANGE_ERROR'
else:
self.handles[handle][1]=offset
outcome=str(offset)
self.output.append('J '+outcome)
def raw_inspect(self,handle):
if handle not in self.handles: self.output.append('I BAD_HANDLE')
else:
name,pos=self.handles[handle]
self.output.append('I %d %d' % (pos,len(self.files[name])-pos))
def read(self, handle, chunk, fault):
name,pos = self.handles[handle]; data = self.files[name]
if pos == len(data):
self.events.append(('R',handle,0)); return b'',False
if fault >= 0 and pos >= fault: return b'',True
stop = min(pos+chunk,len(data))
if fault >= 0: stop = min(stop,fault)
piece = data[pos:stop]; self.handles[handle][1] = stop
self.events.append(('R',handle,len(piece)))
return piece,False
def close(self, handle):
del self.handles[handle]; self.events.append(('C',handle,0))
def query(self, primary,index,use,chunk,fault):
start = len(self.events); data = bytearray(); value = -1; status = 'OK'
if not 1 <= chunk <= 64 or fault < -1: status = 'BAD_REQUEST'
else:
handle,status = self.open(primary)
if handle is not None:
status = 'OK'
while True:
piece,bad = self.read(handle,chunk,fault)
if bad: status = 'READ_ERROR'; break
if not piece: break
data.extend(piece)
self.close(handle)
if status == 'OK' and use:
second,error = self.open(index)
if second is None: status = error
else:
raw = bytearray()
while True:
piece,_ = self.read(second,chunk,-1)
if not piece: break
raw.extend(piece)
self.close(second)
content = bytes(raw)
if content.endswith(b'\n'): content=content[:-1]
significant=content.lstrip(b'0')
if not content or any(x < 48 or x > 57 for x in content) or \
len(significant) > 7 or int(significant or b'0') > 1000000:
status = 'INDEX_ERROR'
else: value = int(significant or b'0')
b = bytes(data); lines=b.count(b'\n')+int(bool(b) and not b.endswith(b'\n'))
longest=max((len(x) for x in b.split(b'\n')),default=0)
if b.endswith(b'\n'): longest=max((len(x) for x in b[:-1].split(b'\n')),default=0)
digest=2166136261
for x in b: digest=((digest^x)*16777619)&0xffffffff
events=self.events[start:]
opened=sum(x[0]=='O' for x in events); closed=sum(x[0]=='C' for x in events)
self.output.append('Q %s %d %d %d %d %d %d %d %d' %
(status,lines,len(b),longest,digest,value,opened,closed,len(self.handles)))
def state(self):
self.output.append('S %d %d' % (len(self.handles),len(self.events)))
for event in self.events:
self.output.append('E %s %d %d' % event)
self.events.clear()
def cases():
m=Model(); commands=[]; rng=random.Random(0x726561646572)
def put(name,data): m.put(name,data); commands.append('P %s %s' % (name,data.hex() or '-'))
def append(name,data): m.append(name,data); commands.append('A %s %s' % (name,data.hex() or '-'))
def query(name,index,use,chunk,fault):
m.query(name,index,use,chunk,fault)
commands.append('Q %s %s %d %d %d' % (name,index,int(use),chunk,fault))
def state(): m.state(); commands.append('S')
def raw_o(name): m.raw_open(name); commands.append('O '+name)
def raw_d(handle): m.raw_clone(handle); commands.append('D '+str(handle))
def raw_r(handle,limit,fault):
m.raw_read(handle,limit,fault); commands.append('R %d %d %d' % (handle,limit,fault))
def raw_c(handle): m.raw_close(handle); commands.append('C '+str(handle))
def raw_j(handle,offset): m.raw_seek(handle,offset); commands.append('J %d %d' % (handle,offset))
def raw_i(handle): m.raw_inspect(handle); commands.append('I '+str(handle))
put('a',b'alpha\nbeta'); put('idx',b'42\n'); put('bad',b'12x'); put('empty',b'')
query('a','-',False,2,6); state()
query('a','idx',True,3,-1); state()
query('a','bad',True,2,-1); state()
for payload in (b'',b'\n',b'a',b'a\n',b'\r\n',b'a\x00b\ncc',b'abc\n\nxy'):
put('data',payload)
query('data','-',False,1,-1); state()
for fault in (0,1,len(payload),len(payload)+1):
query('data','-',False,3,fault); state()
for i,content in enumerate((b'0',b'00042\n',b'1000000',b'1000001',b'-1',b'+2',b'1\n2',b'\n',b'',b'9'*100)):
put('ix',content)
query('a','ix',True,1+(i%7),-1); state()
put('ix',b'0'*5000); query('a','ix',True,64,-1); state()
append('a',b'\nmore\r\n'); query('a','idx',True,64,-1); state()
for i in range(25):
data=bytes(rng.randrange(256) for _ in range(rng.randrange(0,150)))
put('random',data)
chunk=rng.randrange(1,65); fault=rng.choice([-1,0,1,len(data)//2,len(data)])
query('random','-',False,chunk,fault); state()
query('missing','-',False,4,-1); state()
query('a','-',False,0,-1); state()
query('a','-',False,65,-1); state()
query('a','-',False,4,-2); state()
raw_o('a'); raw_i(1); raw_r(1,2,-1); raw_i(1)
raw_d(1); raw_j(2,5); raw_i(2); state()
query('a','idx',True,2,-1); state()
raw_o('a'); raw_d(1); raw_i(7); state()
raw_c(2); raw_c(3); raw_c(1); raw_c(1); state()
raw_o('missing'); raw_d(7); raw_r(7,2,-1); raw_j(7,0); state()
raw_o('a'); raw_j(1,10000); raw_i(1); raw_c(1); state()
return ('\n'.join(commands)+'\n').encode(), ('\n'.join(m.output)+'\n').encode(),len(commands)
def number(token):
if not re.fullmatch(rb'[+-]?[0-9]+',token):
raise ValueError('nondecimal numeric token')
negative=token[:1]==b'-'
digits=token[1:] if token[:1] in (b'-',b'+') else token
significant=digits.lstrip(b'0') or b'0'
if len(significant)>20:
raise ValueError('numeric token out of observable range')
value=int(significant)
return -value if negative else value
def output_rows(data):
if data.endswith(b'\n'):
data=data[:-1]
rows=[]
for line in data.split(b'\n'):
tokens=re.split(rb'[ \t\r]+',line.strip(b' \t\r'))
if not tokens or not tokens[0]: raise ValueError('empty output row')
tag=tokens[0]
if tag==b'Q' and len(tokens)==10 and tokens[1] in (
b'OK',b'BAD_REQUEST',b'READ_ERROR',b'INDEX_ERROR',b'MISSING',b'EXHAUSTED'):
row=(tag,tokens[1],*(number(x) for x in tokens[2:]))
elif tag==b'S' and len(tokens)==3:
row=(tag,number(tokens[1]),number(tokens[2]))
elif tag==b'E' and len(tokens)==4 and tokens[1] in (b'O',b'R',b'C'):
row=(tag,tokens[1],number(tokens[2]),number(tokens[3]))
elif tag==b'P' and len(tokens)==2:
row=(tag,tokens[1])
elif tag==b'A' and len(tokens)==3:
row=(tag,tokens[1],number(tokens[2]))
elif tag in (b'O',b'D',b'C',b'J') and len(tokens)==2:
row=(tag,tokens[1] if tokens[1] in (b'MISSING',b'EXHAUSTED',b'BAD_HANDLE',b'RANGE_ERROR')
else number(tokens[1]))
elif tag==b'I' and len(tokens)==2 and tokens[1]==b'BAD_HANDLE':
row=(tag,tokens[1])
elif tag==b'I' and len(tokens)==3:
row=(tag,number(tokens[1]),number(tokens[2]))
elif tag==b'R' and len(tokens)==2:
if tokens[1] in (b'READ_ERROR',b'BAD_HANDLE',b'-'):
value=tokens[1]
else:
if not re.fullmatch(rb'(?:[0-9a-fA-F]{2})+',tokens[1]):
raise ValueError('invalid hex observation')
value=bytes.fromhex(tokens[1].decode('ascii'))
row=(tag,value)
else:
raise ValueError('invalid output row')
rows.append(row)
return rows
def main(candidate):
candidate=Path(candidate)
data,expected,checks=cases()
scratch=Path(tempfile.mkdtemp(prefix='exception-reader-'))
work=scratch/'work'
result='FAIL'; reason='unknown'; phases={}
try:
work.mkdir()
for name in CANDIDATES:
(work/name).write_bytes((candidate/name).read_bytes())
(work/'reader-demo.cpp').write_text(CONTEXT)
os.chmod(work,0o777)
compiler=['g++','-std=c++17','-O2','-Wall','-Wextra','-pedantic',
'-o',str(work/'reader-demo'),str(work/'reader-demo.cpp'),str(work/'reader.cpp')]
phases['compiler']=supervised(compiler,work,COMPILE_DEADLINE)
finish_phase(phases['compiler'],'compiler')
phases['candidate']=supervised([str(work/'reader-demo')],work,RUN_DEADLINE,data)
finish_phase(phases['candidate'],'candidate')
if output_rows(phases['candidate']['stdout_bytes']) != output_rows(expected):
reason='observation mismatch'
else:
result='PASS'; reason='all observations equal'
except Exception as exc:
result='FAIL'
reason=type(exc).__name__+': '+str(exc)
finally:
cleanup=['python3','-I','-c','import shutil,sys; shutil.rmtree(sys.argv[1])',str(scratch)]
absence=['python3','-I','-c',
'import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: raise SystemExit(0)\nraise SystemExit(1)',str(scratch)]
for label,argv,deadline in (('cleanup',cleanup,CLEAN_DEADLINE),
('absence',absence,ABSENCE_DEADLINE)):
try:
phases[label]=supervised(argv,Path('/'),deadline)
finish_phase(phases[label],label)
except Exception as exc:
result='FAIL'; reason+=('; '+label+' '+type(exc).__name__+': '+str(exc))
record=dict(result=result,reason=reason,checks=checks,
phases={key:{k:v for k,v in value.items() if not k.endswith('_bytes') and k not in ('stdout','stderr')}
for key,value in phases.items()})
packed=base64.b64encode(zlib.compress(json.dumps(record,sort_keys=True,separators=(',',':')).encode(),9)).decode()
print('META_ZLIB64 '+packed,file=sys.stderr)
print('PASS' if result=='PASS' else 'FAIL')
return 0 if result=='PASS' else 1
if __name__=='__main__':
raise SystemExit(main(sys.argv[1]))