All 161 task packages, including the 21 batch 6 C++17 tasks that passed
gates 1/2, are now in Git. rollout.catalog builds docs/task-catalog.{json,md}
from the task packages, a fresh trace5 calibration (128/128 PASS), every
verified controller receipt on the current task digest, documented holds
and digest-bound difficulty reviews. 123 tasks are usable (6 HARD),
5 are on hold and 33 still need a subprocess-only grader.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
475 lines
21 KiB
Python
475 lines
21 KiB
Python
"""Private byte oracle: prefix rescanning, builtin UTF-8, no candidate imports."""
|
|
import base64
|
|
import codecs
|
|
import copy
|
|
import json
|
|
from pathlib import Path
|
|
import random
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
|
|
CANDIDATES = ['utf8_prefix.cpp', 'unit_escape.cpp', 'service_identifier.cpp', 'specifier_program.cpp']
|
|
SAFE = set(b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_:.')
|
|
HEX = set(b'0123456789abcdefABCDEF')
|
|
EMPTY_SERVICE = ['', '', '', '', '', False]
|
|
|
|
|
|
def unicode_ok(raw):
|
|
try:
|
|
raw.decode('utf-8')
|
|
return True
|
|
except UnicodeError:
|
|
return False
|
|
|
|
|
|
def possible_utf8_tail(raw):
|
|
# Completion representatives for a single pending scalar: none, one/two/
|
|
# three ordinary continuation bytes, E0's minimum and F0's minimum.
|
|
suffixes = (b'', b'\x80', b'\x80\x80', b'\x80\x80\x80', b'\xa0\x80', b'\x90\x80\x80')
|
|
return any(unicode_ok(raw + suffix) for suffix in suffixes)
|
|
|
|
|
|
def escaped(raw):
|
|
if len(raw) > 4096 or not unicode_ok(raw):
|
|
return None
|
|
return b''.join(bytes([byte]) if byte in SAFE and not (index == 0 and byte == 46)
|
|
else ('\\x%02x' % byte).encode('ascii') for index, byte in enumerate(raw))
|
|
|
|
|
|
def unescape_prefix(raw, final=False):
|
|
decoded = bytearray()
|
|
index, pending = 0, 0
|
|
while index < len(raw):
|
|
byte = raw[index]
|
|
if byte in SAFE:
|
|
decoded.append(byte)
|
|
index += 1
|
|
continue
|
|
if byte != 92:
|
|
raise ValueError('bare byte')
|
|
tail = raw[index:]
|
|
if len(tail) >= 2 and tail[1] != 120:
|
|
raise ValueError('escape letter')
|
|
if len(tail) >= 3 and tail[2] not in HEX:
|
|
raise ValueError('first hex digit')
|
|
if len(tail) >= 4 and tail[3] not in HEX:
|
|
raise ValueError('second hex digit')
|
|
if len(tail) < 4:
|
|
pending = len(tail)
|
|
break
|
|
decoded.append(int(tail[2:4], 16))
|
|
index += 4
|
|
_, consumed = codecs.utf_8_decode(bytes(decoded), 'strict', final)
|
|
utf8_pending = len(decoded) - consumed
|
|
if not possible_utf8_tail(bytes(decoded)[consumed:]):
|
|
raise ValueError('impossible scalar prefix')
|
|
if final and pending:
|
|
raise ValueError('unfinished escape')
|
|
return bytes(decoded), utf8_pending, pending
|
|
|
|
|
|
def unescaped(raw):
|
|
if len(raw) > 16384:
|
|
return None
|
|
try:
|
|
return unescape_prefix(raw, True)[0]
|
|
except (ValueError, UnicodeError):
|
|
return None
|
|
|
|
|
|
def service(raw):
|
|
if not 1 <= len(raw) <= 4096 or not raw.endswith(b'.service'):
|
|
return None
|
|
parts = raw[:-8].split(b'@')
|
|
if len(parts) > 2 or not all(parts):
|
|
return None
|
|
prefix, instance = parts[0], parts[1] if len(parts) == 2 else b''
|
|
dp, di = unescaped(prefix), unescaped(instance)
|
|
if dp is None or di is None:
|
|
return None
|
|
return [raw, prefix, instance, dp, di, len(parts) == 2]
|
|
|
|
|
|
def service_wire(value):
|
|
return [item.hex() for item in value[:5]] + [value[5]] if value is not None else EMPTY_SERVICE[:]
|
|
|
|
|
|
def compiled(raw):
|
|
if len(raw) > 4096 or not unicode_ok(raw):
|
|
return None
|
|
kinds = {ord('n'): 1, ord('p'): 2, ord('i'): 3, ord('I'): 4, ord('%'): 5}
|
|
result, start = [], 0
|
|
while True:
|
|
percent = raw.find(b'%', start)
|
|
stop = len(raw) if percent < 0 else percent
|
|
if stop > start:
|
|
result.append((0, raw[start:stop]))
|
|
if percent < 0:
|
|
return result
|
|
if percent + 1 >= len(raw) or raw[percent + 1] not in kinds:
|
|
return None
|
|
result.append((kinds[raw[percent + 1]], b''))
|
|
start = percent + 2
|
|
|
|
|
|
def program_wire(value):
|
|
return [[kind, text.hex()] for kind, text in value]
|
|
|
|
|
|
def rendered(program, unit, capacity):
|
|
if program is None or len(program) > 4096 or not 0 <= capacity <= 65536:
|
|
return None
|
|
total = 0
|
|
for kind, text in program:
|
|
if not 0 <= kind <= 5 or (kind != 0 and text):
|
|
return None
|
|
if kind == 0:
|
|
total += len(text)
|
|
if total > 4096 or not unicode_ok(text):
|
|
return None
|
|
name = service(unit)
|
|
if name is None:
|
|
return None
|
|
replacements = {1: name[0], 2: name[1], 3: name[2], 4: name[4], 5: b'%'}
|
|
result = bytearray()
|
|
for kind, text in program:
|
|
value = text if kind == 0 else replacements[kind]
|
|
if len(result) + len(value) > capacity:
|
|
return None
|
|
result.extend(value)
|
|
return bytes(result)
|
|
|
|
|
|
class PrefixOracle:
|
|
def __init__(self):
|
|
self.mode, self.phase, self.capacity = 0, 0, 16384
|
|
self.raw, self.result = b'', b''
|
|
self.utf8_pending = self.escape_pending = 0
|
|
|
|
def view(self):
|
|
return [self.mode, self.phase, self.capacity, len(self.raw),
|
|
self.utf8_pending, self.escape_pending, self.result.hex()]
|
|
|
|
def fail(self):
|
|
self.phase, self.raw, self.result = 1, b'', b''
|
|
self.utf8_pending = self.escape_pending = 0
|
|
return 1
|
|
|
|
def reset(self, mode, capacity):
|
|
if mode not in (0, 1) or not 0 <= capacity <= 16384:
|
|
return 1
|
|
self.mode, self.phase, self.capacity = mode, 0, capacity
|
|
self.raw, self.result = b'', b''
|
|
self.utf8_pending = self.escape_pending = 0
|
|
return 0
|
|
|
|
def feed(self, chunk):
|
|
if self.phase != 0:
|
|
return 1
|
|
raw = self.raw + chunk
|
|
if len(raw) > (4096 if self.mode == 0 else 16384):
|
|
return self.fail()
|
|
try:
|
|
if self.mode == 0:
|
|
_, consumed = codecs.utf_8_decode(raw, 'strict', False)
|
|
if not possible_utf8_tail(raw[consumed:]):
|
|
raise ValueError('impossible scalar prefix')
|
|
utf8_pending, escape_pending = len(raw) - consumed, 0
|
|
else:
|
|
_, utf8_pending, escape_pending = unescape_prefix(raw)
|
|
except (ValueError, UnicodeError):
|
|
return self.fail()
|
|
self.raw = raw
|
|
self.utf8_pending, self.escape_pending = utf8_pending, escape_pending
|
|
return 0
|
|
|
|
def finish(self):
|
|
if self.phase == 2:
|
|
return 0
|
|
if self.phase == 1:
|
|
return 1
|
|
result = escaped(self.raw) if self.mode == 0 else unescaped(self.raw)
|
|
if result is None or len(result) > self.capacity:
|
|
return self.fail()
|
|
self.phase, self.result = 2, result
|
|
self.utf8_pending = self.escape_pending = 0
|
|
return 0
|
|
|
|
|
|
def token(raw):
|
|
return raw.hex() or '-'
|
|
|
|
|
|
class Matrix:
|
|
def __init__(self):
|
|
self.commands, self.expected, self.labels = [], [], []
|
|
self.streams = [PrefixOracle(), PrefixOracle()]
|
|
self.held_view, self.held_service = self.streams[0].view(), EMPTY_SERVICE[:]
|
|
self.held_program, self.held_result = [], b''
|
|
|
|
def emit(self, label, command, expected):
|
|
self.commands.append(command)
|
|
self.expected.append(copy.deepcopy(expected))
|
|
self.labels.append(label)
|
|
|
|
def nonce(self):
|
|
return b'old\0\xff' + str(len(self.commands)).encode('ascii')
|
|
|
|
def v(self, raw, label='C01'):
|
|
self.emit(label, 'V ' + token(raw), [unicode_ok(raw), True])
|
|
|
|
def convert(self, mode, raw, label):
|
|
result = escaped(raw) if mode == 0 else unescaped(raw)
|
|
self.held_result = result if result is not None else b''
|
|
self.emit(label, ('E' if mode == 0 else 'U') + ' ' + token(raw) + ' ' + token(self.nonce()),
|
|
[int(result is None), self.held_result.hex(), True])
|
|
|
|
def reset(self, slot, mode, capacity, label='C15'):
|
|
error = self.streams[slot].reset(mode, capacity)
|
|
self.emit(label, 'N %d %d %d' % (slot, mode, capacity), [error, self.streams[slot].view()])
|
|
|
|
def feed(self, slot, raw, label='C16'):
|
|
error = self.streams[slot].feed(raw)
|
|
self.emit(label, 'F %d %s' % (slot, token(raw)), [error, self.streams[slot].view(), True])
|
|
|
|
def finish(self, slot, label='C20'):
|
|
error = self.streams[slot].finish()
|
|
self.emit(label, 'D %d' % slot, [error, self.streams[slot].view()])
|
|
|
|
def query(self, slot, label='C23'):
|
|
self.held_view = self.streams[slot].view()
|
|
self.emit(label, 'Q %d' % slot, self.held_view)
|
|
|
|
def copied(self, slot, label='C23'):
|
|
nonce = self.nonce()
|
|
self.emit(label, 'Y %d %s' % (slot, token(nonce)),
|
|
[[17, 18, 19, 20, 21, 22, nonce.hex()], self.streams[slot].view()])
|
|
|
|
def parse(self, raw, label='C05'):
|
|
result = service(raw)
|
|
self.held_service = service_wire(result)
|
|
self.emit(label, 'P %s %s' % (token(raw), token(self.nonce())),
|
|
[int(result is None), self.held_service, True])
|
|
|
|
def compile(self, raw, label='C08'):
|
|
result = compiled(raw)
|
|
self.held_program = result if result is not None else []
|
|
self.emit(label, 'C %s %s' % (token(raw), token(self.nonce())),
|
|
[int(result is None), program_wire(self.held_program), True])
|
|
|
|
def render(self, program, unit, capacity, label='C10', held=False):
|
|
result = rendered(program, unit, capacity)
|
|
self.held_result = result if result is not None else b''
|
|
command = 'T' if held else 'R %d%s' % (len(program), ''.join(' %d %s' % (k, token(v)) for k, v in program))
|
|
command += ' %s %d %s' % (token(unit), capacity, token(self.nonce()))
|
|
self.emit(label, command, [int(result is None), self.held_result.hex(), True])
|
|
|
|
def expand(self, text, unit, capacity, label='C12'):
|
|
result = rendered(compiled(text), unit, capacity)
|
|
self.held_result = result if result is not None else b''
|
|
self.emit(label, 'X %s %s %d %s' % (token(text), token(unit), capacity, token(self.nonce())),
|
|
[int(result is None), self.held_result.hex(), True])
|
|
|
|
def history(self, label='C24'):
|
|
self.emit(label, 'H', [self.held_view, self.held_service, program_wire(self.held_program), self.held_result.hex()])
|
|
|
|
|
|
def cases():
|
|
c, rng = Matrix(), random.Random(30050017)
|
|
for byte in range(256):
|
|
c.v(bytes([byte]))
|
|
scalars = [0, 1, 0x7f, 0x80, 0x7ff, 0x800, 0xd7ff, 0xe000, 0xfeff, 0xffff, 0x10000, 0x10ffff]
|
|
scalars += [value for value in (rng.randrange(0x110000) for _ in range(120)) if not 0xd800 <= value <= 0xdfff]
|
|
good = [b'', b'.a', b'a.b', b'-/:_\\@%', b'\0', b'plain'] + [chr(x).encode('utf-8') for x in scalars]
|
|
bad = [b'\xc0\x80', b'\xc1\xbf', b'\xe0\x80\xaf', b'\xed\xa0\x80', b'\xed\xbf\xbf',
|
|
b'\xf0\x80\x80\x80', b'\xf4\x90\x80\x80', b'\xf5\x80\x80\x80', b'\xe4', b'\xe4\xb8', b'\xf0\x90\x80']
|
|
for raw in good + bad:
|
|
c.v(raw)
|
|
c.convert(0, raw, 'C02')
|
|
c.v(b'a' * 65537)
|
|
for raw in good:
|
|
encoded = escaped(raw)
|
|
c.convert(1, encoded, 'C03')
|
|
if encoded:
|
|
alternate = encoded.replace(b'\\x', b'\\X')
|
|
c.convert(1, alternate, 'C04')
|
|
for raw in [b'.hidden', b'\\xE4\\xB8\\xAD', b'\\x00', b'a\\x2db', b'\\x2Efoo', b'\\x25n']:
|
|
c.convert(1, raw, 'C03')
|
|
for raw in [b'\\', b'\\x', b'\\x0', b'\\q', b'\\X41', b'\\xGG', b'raw space', b'raw@', b'raw/', b'\0', b'\xff', b'\\xff', b'\\xc0\\x80']:
|
|
c.convert(1, raw, 'C04')
|
|
for raw in [b'a' * 4096, b'\0' * 4096, b'.' + b'a' * 4095, b'a' * 4097]:
|
|
c.convert(0, raw, 'C25')
|
|
for raw in [b'a' * 16384, b'\\x00' * 4096, b'a' * 16385]:
|
|
c.convert(1, raw, 'C25')
|
|
|
|
units = [b'a.service', b'.hidden.service', b'a.service.service', b'a@b.service',
|
|
b'x\\x40y@z.service', b'x@a\\x40b.service', b'\\x40.service', b'\\x00@\\x00.service',
|
|
b'\\xE4\\xB8\\xAD@\\xf0\\x9f\\x98\\x80.service', b'd@\\x25n.service']
|
|
for unit in units:
|
|
c.parse(unit, 'C06' if b'\\x40' in unit else 'C05')
|
|
for text in [b'', b'%n|%p|%i|%I|%%', b'ordinary\0text', b'%I', '中:%p'.encode()]:
|
|
c.expand(text, unit, 65536)
|
|
invalid_units = [b'', b'.service', b'@b.service', b'a@.service', b'a@b@c.service', b'a.socket',
|
|
b'a.SERVICE', b'a b.service', b'a/b.service', b'a%.service', b'a\0.service',
|
|
b'a\xff.service', b'a\\x.service', b'a\\xff.service', b'a\\xED\\xA0\\x80.service']
|
|
for unit in invalid_units:
|
|
c.parse(unit, 'C07')
|
|
c.expand(b'', unit, 0, 'C07')
|
|
for size in [4096, 4097]:
|
|
unit = b'a' * (size - 8) + b'.service'
|
|
c.parse(unit, 'C25')
|
|
for text in [b'', b'a', b'a%%b%n%i%p%I', b'\0%I\0', '字%%尾'.encode(), b'a' * 4096]:
|
|
c.compile(text)
|
|
for text in [b'%', b'%P', b'%x', b'a%q', b'%n%', b'%I\0%', b'\xff', b'a' * 4097]:
|
|
c.compile(text, 'C09')
|
|
programs = [[], [(0, b'')], [(0, b'%x'), (0, b'\0')], [(1, b''), (2, b''), (3, b''), (4, b''), (5, b'')],
|
|
[(0, b'a'), (0, b'b')], [(5, b'')] * 4096, [(0, b'a' * 2048), (0, b'b' * 2048)]]
|
|
for program in programs:
|
|
c.render(program, b'a@b.service', 65536)
|
|
for program in [[(-1, b'')], [(6, b'')], [(-(2**31), b'')], [(2**31-1, b'')], [(1, b'x')],
|
|
[(5, b'\0')], [(0, b'\xe4'), (0, b'\xb8\xad')], [(0, b'\xff')],
|
|
[(5, b'')] * 4097, [(0, b'a' * 4096), (0, b'x')]]:
|
|
c.render(program, b'a.service', 65536, 'C11')
|
|
for value in [b'%n', b'%p', b'%i', b'%I', b'%%', b'%z', b'%', '中%I\0'.encode()]:
|
|
unit = b'd@' + escaped(value) + b'.service'
|
|
c.expand(b'%I', unit, 65536, 'C13')
|
|
c.render([(0, b'%n'), (4, b''), (0, b'%I')], unit, 65536, 'C13')
|
|
for capacity in [0, 1, 2, 3, 4, 5, 65536, 65537, 2**64-1]:
|
|
c.expand(b'%I', b'd@\\xE4\\xB8\\xAD.service', capacity, 'C14')
|
|
c.render([], b'a.service', capacity, 'C14')
|
|
huge_unit = b'a' * 4088 + b'.service'
|
|
for capacity in [65535, 65536, 65537]:
|
|
c.render([(1, b'')] * 16, huge_unit, capacity, 'C14')
|
|
|
|
c.query(0, 'C15'); c.query(1, 'C15'); c.history()
|
|
for mode, capacity in [(-1, 0), (2, 0), (-(2**31), 0), (0, 16385), (1, 2**64-1)]:
|
|
c.reset(0, mode, capacity)
|
|
for raw in good[:18]:
|
|
for split in range(len(raw) + 1):
|
|
c.reset(0, 0, 16384)
|
|
c.feed(0, b''); c.feed(0, raw[:split]); c.query(0)
|
|
c.feed(0, b''); c.feed(0, raw[split:]); c.finish(0)
|
|
c.feed(0, b'', 'C20'); c.finish(0)
|
|
c.history(); c.copied(0)
|
|
for raw in [b'\\', b'\\x', b'\\x4', b'\\xe4', b'\\xe4\\', b'\\xe4\\x', b'\\xe4\\xB',
|
|
b'\\xe4\\xB8', b'\\xe4\\xB8\\', b'\\xe4\\xB8\\xAD', b'\\x00', b'.x', b'a\\x2db']:
|
|
c.reset(0, 1, 16384)
|
|
for byte in raw:
|
|
c.feed(0, bytes([byte]), 'C18')
|
|
c.feed(0, b'', 'C17')
|
|
c.query(0); c.finish(0, 'C17'); c.history()
|
|
prefix_pairs = [(b'\xe0\x80', None), (b'\xed\xa0', None),
|
|
(b'\xf0\x80', None), (b'\xf4\x90', None),
|
|
(b'\xe0\xa0', b'\x80'), (b'\xed\x9f', b'\xbf'),
|
|
(b'\xf0\x90', b'\x80\x80'), (b'\xf4\x8f', b'\xbf\xbf')]
|
|
for prefix, continuation in prefix_pairs:
|
|
for mode in (0, 1):
|
|
label = 'C20' if continuation is None else 'C16'
|
|
source = prefix if mode == 0 else b''.join(('\\x%02x' % byte).encode() for byte in prefix)
|
|
c.reset(0, mode, 16384); c.feed(0, source, label); c.query(0)
|
|
if continuation is not None:
|
|
tail = continuation if mode == 0 else b''.join(('\\x%02x' % byte).encode() for byte in continuation)
|
|
c.feed(0, tail, label)
|
|
c.finish(0, label)
|
|
for mode, raw in [(0, b'\xff'), (0, b'\xed\xa0'), (1, b'\\q'), (1, b'\\xff'), (1, b'x@'), (1, b'\\x0G')]:
|
|
c.reset(0, mode, 16384); c.feed(0, b'a'); c.feed(0, raw, 'C20')
|
|
c.feed(0, b'', 'C20'); c.finish(0); c.query(0)
|
|
c.reset(0, mode, 16384); c.feed(0, b'a'); c.finish(0); c.history()
|
|
for mode, raw, capacity in [(0, b'a', 0), (0, b'.', 3), (0, b'.', 4), (1, b'\\xE4\\xB8\\xAD', 2),
|
|
(1, b'\\xE4\\xB8\\xAD', 3), (1, b'', 0), (0, b'\0' * 4096, 16383), (0, b'\0' * 4096, 16384)]:
|
|
c.reset(0, mode, capacity); c.feed(0, raw, 'C19'); c.query(0, 'C19')
|
|
c.finish(0, 'C19'); c.query(0); c.copied(0)
|
|
c.reset(0, 2, 1); c.reset(0, mode, 16385); c.feed(0, b'', 'C20'); c.history()
|
|
for mode, limit in [(0, 4096), (1, 16384)]:
|
|
c.reset(0, mode, 16384); c.feed(0, b'a' * (limit - 1), 'C21')
|
|
c.feed(0, b'a', 'C21'); c.query(0); c.feed(0, b'a', 'C21'); c.finish(0, 'C21')
|
|
c.reset(0, mode, 16384); c.feed(0, b'a' * (limit + 1), 'C21'); c.finish(0, 'C21')
|
|
for trial in range(70):
|
|
raw = ''.join(rng.choice(['a', '.', '-', '/', '\0', '中', '😀', '%', '@']) for _ in range(rng.randrange(25))).encode()
|
|
mode = trial % 2
|
|
source = raw if mode == 0 else escaped(raw)
|
|
capacity = rng.choice([0, 1, 12, 128, 16384])
|
|
slot = trial % 2
|
|
c.reset(slot, mode, capacity)
|
|
position = 0
|
|
while position < len(source):
|
|
length = rng.randrange(1, 8)
|
|
c.feed(slot, source[position:position+length], 'C22'); position += length
|
|
c.query(slot); c.finish(slot, 'C22'); c.history(); c.copied(slot)
|
|
c.compile(b'prefix:%I/%p', 'C24'); c.query(0)
|
|
c.parse(b'other@unit.service', 'C24')
|
|
c.expand(b'changed:%n', b'new.service', 128, 'C24')
|
|
c.reset(0, 0, 16); c.feed(0, b'.a'); c.finish(0)
|
|
c.render(c.held_program, b'x@\\x25n.service', 128, 'C24', held=True); c.history()
|
|
c.render(c.held_program, b'bad.socket', 128, 'C24', held=True); c.history()
|
|
c.render(c.held_program, b'y@z.service', 128, 'C24', held=True); c.history()
|
|
c.compile(b'%', 'C24'); c.render(c.held_program, b'a.service', 0, 'C24', held=True); c.history()
|
|
return c
|
|
|
|
|
|
def equal(left, right):
|
|
if type(left) is not type(right):
|
|
return False
|
|
if isinstance(left, list):
|
|
return len(left) == len(right) and all(equal(a, b) for a, b in zip(left, right))
|
|
return left == right
|
|
|
|
|
|
def main():
|
|
matrix = cases()
|
|
context = json.loads((Path(__file__).resolve().parent / 'context.json').read_text())
|
|
scratch = Path(tempfile.mkdtemp(prefix='embedded-hard-unit-', dir='/tmp'))
|
|
for name, text in context.items():
|
|
(scratch / name).write_text(text)
|
|
for name in CANDIDATES:
|
|
(scratch / name).write_bytes((Path(sys.argv[1]) / name).read_bytes())
|
|
build = subprocess.run(['g++', '-std=c++17', '-O2', '-Wall', '-Wextra', '-pedantic',
|
|
'unit_observe.cpp', *CANDIDATES, '-o', 'unit_observe'],
|
|
cwd=scratch, text=True, encoding='utf-8', errors='replace',
|
|
capture_output=True, timeout=30)
|
|
if build.returncode:
|
|
print('FAILED_CHECKS ["C26"] build failed: ' + build.stderr[-1200:].replace('\n', ' '))
|
|
return 1
|
|
# shortcut: after candidate execution inspect captured pipes only; scratch is
|
|
# removed by container destruction or a separate trusted owner cleanup.
|
|
timed_out = False
|
|
try:
|
|
result = subprocess.run([str(scratch / 'unit_observe')], cwd=scratch,
|
|
input='\n'.join(matrix.commands) + '\n', text=True,
|
|
encoding='utf-8', errors='replace', capture_output=True, timeout=20)
|
|
output, exit_code = result.stdout, result.returncode
|
|
except subprocess.TimeoutExpired as error:
|
|
timed_out = True
|
|
output = error.stdout or b''
|
|
if isinstance(output, bytes): output = output.decode('utf-8', 'replace')
|
|
exit_code = -9
|
|
actual = output.splitlines()
|
|
failures = set(['C28'] if timed_out else ['C27'] if exit_code else [])
|
|
count, indexes, examples = max(len(actual), len(matrix.expected)), [], []
|
|
for index in range(count):
|
|
label = matrix.labels[index] if index < len(matrix.labels) else 'C27'
|
|
wanted = matrix.expected[index] if index < len(matrix.expected) else '<end>'
|
|
try: observed = json.loads(actual[index]) if index < len(actual) else '<missing>'
|
|
except ValueError: observed = actual[index]
|
|
if index >= len(actual) or index >= len(matrix.expected) or not equal(observed, wanted):
|
|
indexes.append(index); failures.add(label)
|
|
if len(examples) < 8:
|
|
examples.append('%s observation=%d got=%s expected=%s' %
|
|
(label, index, repr(observed)[:220], repr(wanted)[:220]))
|
|
if failures:
|
|
print('FAILED_CHECKS ' + json.dumps(sorted(failures)))
|
|
for example in examples: print(example)
|
|
bitmap = bytearray((count + 7) // 8)
|
|
for index in indexes: bitmap[index // 8] |= 1 << (index % 8)
|
|
diagnostic = {'observations': count, 'bits_lsb0': base64.b64encode(bitmap).decode(),
|
|
'failed_checks': sorted(failures), 'candidate_exit': exit_code, 'timeout': timed_out}
|
|
print('MISMATCH_BITMAP ' + json.dumps(diagnostic, separators=(',', ':')), file=sys.stderr)
|
|
return 1
|
|
print('PASS')
|
|
return 0
|
|
|
|
|
|
if __name__ == '__main__':
|
|
raise SystemExit(main())
|