Files
goodwe-addon/goodwe_controller/test_ev13.py
T
Claude 57a9f56a64
infra-pin / fresh (pull_request) Successful in 2s
checks / unit (pull_request) Successful in 27m17s
EV-13: guard the P4 live check's last sample (test_named_absence)
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-22 07:58:56 +01:00

1205 lines
49 KiB
Python

"""EV-13: a refused current write shows ONE amber row, not two.
`python3 -B test_ev13.py`
The bug: `ManualWriter._write` armed the stuck-reading check on every write,
refused or not. A charger that ignores the write keeps its old setpoint, so the
read-back does not move, and 60 s later "Charger reading may be stuck" showed
beside "The charger did not take the setting", and the car figure was not
trusted (EV-15 rig: it latched the quarter).
The rule (owner's delegate, decision (b)): a refused write skips the arm ONLY
when the charger shows life: a change in the energy counter, a phase current or
the power, in a sample taken after the write was sent and within `TOOK_S` of it,
against the last value before. Present but unchanged, absent before, a stale
sample (taken before the send): not life. No life: it arms as before, dated the
send. A frozen charger (every write looks refused) is still caught.
Shapes: S = a tracker fed by a script (the test chooses each sample's values,
taken-at and arrival), W = the real Controller on `chargersim.SimCharger`, C =
`ev04_peak.drive` (the SAFETY-81 plant). Times are model seconds.
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
1. S: what counts as life (T3-T10, T12, T15)
2. W: live refusals, one amber row (T1, T2, T19)
3. W: no life, accepted writes, transitions (T11, T14, T17, T18, T20, T21)
4. W: errors, restart (T13, T25)
5. C: the peak guard (T16, T22-T24)
6. Writes, as on the base (T26)
"""
import asyncio
import dataclasses
import hashlib
import logging
import os
import sys
from datetime import datetime, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "tools"))
from app import carmode, chargers as CH, freshness # noqa: E402
from app.main import Controller # noqa: E402
from chargersim import FakeHa, SimCharger # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
class _Log(logging.Handler):
def __init__(self):
super().__init__(logging.DEBUG)
self.rec = []
def emit(self, r):
self.rec.append((r.levelname, r.getMessage()))
def text(self, level=None):
return "\n".join(m for lv, m in self.rec if level in (None, lv))
LOG = _Log()
logging.getLogger("goodwe").addHandler(LOG)
logging.getLogger("goodwe").setLevel(logging.DEBUG)
logging.getLogger("goodwe").propagate = False
UTC = datetime(2026, 11, 22, tzinfo=timezone.utc)
DAY = "2026-11-22"
TS = 1000.0 # t_s in the S shape
TOOK_S, STUCK_S = CH.TOOK_S, CH.STUCK_S
# =========================================================================== #
print("1. S: WHAT COUNTS AS LIFE")
# =========================================================================== #
def rd(e=1.000, p=11040.0, cur=(16.0, 15.9, 16.0), a=16.0, taken=None,
state="C", ph=None):
"""`cur` is `current_a` (a missing phase is left out of it); `ph` is the
per-phase `phase_a` (None for a missing phase) the driver also sets."""
return CH.ChargerReading(
available=True, state=state, charging=state == "C", power_w=p,
energy_kwh=e, current_a=cur, allowed_a=a, setpoint_a=a,
phases_allowed=3, taken_at=taken, phase_a=ph or ())
def steady(changes=None, start=1, end=130, **base):
"""One sample a second from TS+start to TS+end, taken on arrival. `changes`
is {second after TS: kwargs}; each change stays."""
out, kw = [], dict(base)
for s in range(start, end + 1):
kw.update((changes or {}).get(s, {}))
out.append((TS + s, rd(**kw)))
return out
def play(timeline, mode="live", ok=False, was=16.0, to=10.0, pre_end=0,
pre=None, end=TS + 130):
"""The tracker sees the pre-write samples, then the write (refused unless
`ok`), then `timeline` = [(arrival, ChargerReading)].
live: the write returns at once (HA said no), samples come after it.
ring: the write waited TOOK_S; the cycle's samples came meanwhile.
polls: the write waited and saw the samples itself (nothing else did).
Returns (tracker, first second `stuck()` was True, armed_at ever set)."""
tr = CH.CarTracker()
seen = {"armed": False, "first": None}
def obs(at, r):
tr.observe(r, at, UTC, DAY)
seen["armed"] |= tr.armed_at is not None
if seen["first"] is None and tr.stuck(at):
seen["first"] = at
for i in range(-20, pre_end + 1):
obs(TS + i, rd(**(pre or {})))
inside = [x for x in timeline if x[0] <= TS + TOOK_S]
outside = [x for x in timeline if x[0] > TS + TOOK_S]
if mode == "live":
tr.note_write(TS, was, to, ok)
rest = timeline
elif mode == "ring":
for at, r in inside:
obs(at, r)
tr.note_write(TS, was, to, ok)
rest = outside
else:
tr.note_write(TS, was, to, ok, [
(r.taken_at if r.taken_at is not None else at, r)
for at, r in inside])
rest = outside
seen["armed"] |= tr.armed_at is not None
for at, r in sorted(rest, key=lambda x: x[0]):
if at <= end:
obs(at, r)
return tr, seen["first"], seen["armed"]
MODES = ("live", "ring", "polls")
N1, N2 = [], [] # (name, never stuck) / (name, seconds from the send to stuck)
def pend(tr):
"""The refusal window a tracker keeps open (None: none)."""
return getattr(tr, "_pend", None)
def life(name, changes, **kw):
for m in MODES:
tr, first, armed = play(steady(changes), m, **kw)
N1.append((f"{name} [{m}]", first is None and not tr.stuck_now))
check(f"{name} [{m}]: not armed, never stuck to TS+130",
tr.armed_at is None and first is None and not armed
and not tr.stuck_now)
def armed(name, tl, at=TS, **kw):
for m in MODES:
tr, first, ever = play(tl, m, **kw)
N2.append((f"{name} [{m}]", None if first is None else first - TS))
check(f"{name} [{m}]: armed at the send, stuck at TS+60 (+-1), "
f"not before TS+59 (first {first})",
first is not None and TS + 59 <= first <= TS + 61
and tr.armed_at == at and tr.stuck_now)
life("T3 energy alone steps 10 Wh at +4", {4: dict(e=1.010)})
life("T4 one phase current alone (L2 15.9 -> 16.0) at +4",
{4: dict(cur=(16.0, 16.0, 16.0))})
life("T5 power alone (11040 -> 11080 W) at +4", {4: dict(p=11080.0)})
life("T9 the step at +9, inside the window", {9: dict(e=1.010)})
life("T9 the step exactly at +10 (the edge counts)", {10: dict(e=1.010)})
life("T12(a) power None, state C, energy rising", {4: dict(e=1.010)},
pre=dict(p=None))
# P1/P2 (review): a phase that drops out or comes back is no change: the
# others must not shift against another phase's old value
armed("P1 L1 present before, absent after, all else frozen",
steady(cur=(16.0, 16.1)))
armed("P2 L1 absent before, present after (current_a only), all else frozen",
steady(), pre=dict(cur=(15.9, 16.0)))
armed("P1 per phase: L1 present before, absent after (phase_a)",
steady(cur=(16.0, 16.1), ph=(None, 16.0, 16.1)),
pre=dict(ph=(15.9, 16.0, 16.1)))
armed("P2 per phase: L1 absent before, present after (phase_a)",
steady(ph=(15.9, 16.0, 16.1)), pre=dict(cur=(16.0, 16.1),
ph=(None, 16.0, 16.1)))
life("P5 per phase: L1 absent, L2 really changes (phase_a)",
{4: dict(cur=(16.2, 16.1), ph=(None, 16.2, 16.1))},
pre=dict(cur=(16.0, 16.1), ph=(None, 16.0, 16.1)))
armed("T6 present but unchanged: every sample repeats the pre-write values",
steady())
armed("T9 the step at +11 is outside the window; armed_at is the send, not "
"+10 or +11", steady({11: dict(e=1.010)}))
armed("T10 energy absent before, present after: no change against a last "
"value", steady({4: dict(e=1.010)}), pre=dict(e=None))
armed("T12(b) power None, nothing else changes", steady(p=None),
pre=dict(p=None))
# T7: a stale sample: the pre-write sample again, the same taken-at time
for what, e in (("the same values", 1.000), ("changed values", 1.010)):
tl = [(TS + s, rd(e=e, taken=TS - 1.0)) for s in range(1, 131)]
armed(f"T7 stale sample ({what}, taken-at TS-1 again and again)", tl)
# T8: the late pre-write sample (EV-12 ordering): taken TS-1, arrives TS+2
late = [(TS + s, rd(e=1.010, taken=TS - 1.0) if s == 2 else rd(e=1.010))
for s in range(2, 131)]
armed("T8 a sample taken at TS-1 (+10 Wh) arrives at TS+2, nothing changes "
"after it", late, pre_end=-3)
# T15: the STUCK_MIN_A edge is as before
t15 = CH.CarTracker()
t15.observe(rd(), TS, UTC, DAY)
t15.note_write(TS, 10, 10.9)
a09 = t15.armed_at
t15.note_write(TS, 10, 11)
a10 = t15.armed_at
t15b = CH.CarTracker()
t15b.observe(rd(), TS, UTC, DAY)
t15b.note_write(TS, None, 10)
check("T15 a 0.9 A move does not arm, 1.0 A does, an unknown `was` does",
a09 is None and a10 == TS and t15b.armed_at == TS)
t15c = CH.CarTracker()
t15c.observe(rd(), TS, UTC, DAY)
t15c.note_write(TS, 10, 10.9, False)
t15d = CH.CarTracker()
t15d.observe(rd(), TS, UTC, DAY)
t15d.note_write(TS, 10, 11, False)
for i in range(1, 80):
t15d.observe(rd(), TS + i, UTC, DAY)
check("T15 a refused 0.9 A move arms nothing and leaves nothing waiting; a "
"refused 1.0 A move with no life arms",
t15c.armed_at is None and pend(t15c) is None and t15d.armed_at == TS
and t15d.stuck_now)
# the details the plan implies
tr = CH.CarTracker()
tr.observe(rd(), TS, UTC, DAY)
tr.note_write(TS, 16, 10, True)
check("E3: an accepted write arms at once, at the send", tr.armed_at == TS
and pend(tr) is None)
tr = CH.CarTracker()
for i in range(-5, 1):
tr.observe(rd(), TS + i, UTC, DAY)
tr.note_write(TS, 16, 10, False)
tr.observe(rd(), TS + 3, UTC, DAY)
tr.note_write(TS + 5, 10, 8, True)
check("an accepted write while a refusal's window is open arms at the "
"accepted write, and the window is dropped",
tr.armed_at == TS + 5 and pend(tr) is None)
tr = CH.CarTracker()
for i in range(-5, 1):
tr.observe(rd(), TS + i, UTC, DAY)
tr.note_write(TS, 16, 10, False)
tr.note_write(TS + 5, 10, 6, False)
tr.note_write(TS + 10, 6, 5, False)
for i in range(1, 70):
tr.observe(rd(), TS + i, UTC, DAY)
check("T20 shape: refusals 5 s apart with nothing changing arm once, dated "
"the FIRST", tr.armed_at == TS and tr.stuck_now)
tr = CH.CarTracker()
for i in range(-5, 1):
tr.observe(rd(), TS + i, UTC, DAY)
tr.note_write(TS, 16, 10, False)
for i in range(1, 5):
tr.observe(rd(e=1.010), TS + i, UTC, DAY)
tr.note_write(TS + 20, 10, 8, False)
check("a refusal that showed life leaves no window; a later refusal gets "
"its own", pend(tr) is not None and pend(tr)["t"] == TS + 20
and tr.armed_at is None)
# T18 (tracker): an armed check is neither cleared nor delayed by a refusal
tr = CH.CarTracker()
for i in range(-5, 1):
tr.observe(rd(), TS + i, UTC, DAY)
tr.note_write(TS, 16, 10, True)
for i in range(1, 20):
tr.observe(rd(), TS + i, UTC, DAY)
tr.note_write(TS + 20, 10, 8, False)
for i in range(20, 61):
tr.observe(rd(e=1.0 + i / 1000.0), TS + i, UTC, DAY)
check("T18 (tracker) an accepted write armed at TS; a live refusal at TS+20 "
"neither clears nor delays it: stuck at TS+60",
tr.armed_at == TS and tr.stuck_now and pend(tr) is None)
# =========================================================================== #
# W: the real Controller on the charger model
# =========================================================================== #
class _Store:
def __init__(self):
self.data = {}
def set(self, k, v):
self.data[k] = v
def get(self, k, d=None):
return self.data.get(k, d)
def set_time(self, k, v):
self.data[k] = v.isoformat()
def get_time(self, k):
v = self.data.get(k)
return None if v is None else datetime.fromisoformat(v)
class _Pub:
enabled = False
def __init__(self):
self.values = []
def publish(self, v):
self.values.append(dict(v))
def close(self):
pass
class Site(FakeHa):
def __init__(self, charger, grid=500.0, batt=0.0, pv=2000.0):
super().__init__(charger, None)
self.grid, self.batt, self.pv = grid, batt, pv
async def limits(self, _e):
return (-5000.0, 5000.0, 1.0)
def _all(self):
out = super()._all()
for eid, val, unit in (("sensor.grid", self.grid, "W"),
("sensor.soc", 50.0, "%"),
("sensor.batt", self.batt, "W"),
("sensor.pv", self.pv, "W")):
out[eid] = {"entity_id": eid, "state": str(val),
"attributes": {"unit_of_measurement": unit}}
return out
async def number(self, entity_id, invert=False):
s = self._all().get(entity_id)
try:
v = float(s["state"])
except (TypeError, ValueError, KeyError):
return None
return -v if invert else v
async def set_number(self, entity_id, value):
if entity_id == "number.sp":
self.sets.append((entity_id, float(value)))
self.batt = float(value)
return True
return await super().set_number(entity_id, float(value))
BASE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
"soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
"meter_source": "off", "max_w": 5000, "gain": 0.6, "slew_w": 500,
"deadband_w": 15, "target_grid_w": 0, "step_w": 10, "heartbeat_s": 10,
"stale_input_s": 15, "shadow_mode": "off", "peak_cap_w": 3500,
"pv_entities": ["sensor.pv"]}
SET = "number.wallbox_power_connector_max_current_socket_1"
CAR = dict(BASE, ev_charger="alfen_ha", ev_max_a=16, ev_phases="auto",
ev_current_entity=SET)
CLOCK = [1000.0]
freshness.monotonic = lambda: CLOCK[0]
class World:
"""A real Controller on the charger model, one clock for all of it."""
def __init__(self, opts=CAR, sim=None, store=None, setpoint=16, phases=3,
grid=800.0, beside=False):
self.sim = sim or SimCharger(setpoint_a=setpoint)
self.sim.plug_in()
self.sim.phases_allowed = phases
self.site = Site(self.sim, grid=grid)
self.store = store or _Store()
self.t = 1000.0
CLOCK[0] = self.t
self.off = self.t - self.sim.t # sim time + off = this clock
self.make(opts)
if beside:
self.beside()
def beside(self):
"""The writer runs BESIDE the cycle, as in production: the cycle reads
(and the tracker sees) the charger while a write waits for its
read-back, one poll per cycle."""
gate = asyncio.Event()
async def sleep(_s):
gate.clear()
await gate.wait()
async def settle():
gate.set()
for _ in range(5):
await asyncio.sleep(0)
self.drv._sleep = sleep
self.c.car_settle = settle
def make(self, opts):
self.c = Controller(dict(opts), self.site, self.store, _Pub(),
stop=asyncio.Event())
self.c.auto = True
self.c.dev_min, self.c.dev_max = -5000.0, 5000.0
self.drv = self.c.charger
self.drv._sleep = self.sleep
self.drv._clock = lambda: CLOCK[0]
async def sleep(self, s):
self.sim.tick(s)
self.t += s
CLOCK[0] = self.t
async def step(self, n=1, dt=1.0):
out = []
for _ in range(n):
self.sim.tick(dt)
self.t += dt
CLOCK[0] = self.t
await self.c.read_inputs(now_mono=self.t)
await self.c.cycle()
await self.c.car_settle()
tk = self.c.car
out.append((tk.obs_at, tk.armed_at, tk.stuck(self.t)))
return out
async def act(self, what, value):
return await self.c.handle_action(what, value=value)
def rows(self):
return {r["id"]: r for r in self.c.checks()}
def amber(self):
"""The charger's amber rows: not ok, warn."""
return sorted(i for i, r in self.rows().items()
if r["warn"] and not r["ok"] and i.startswith("charger"))
def sends(self):
"""The model seconds (this clock) of every current write received."""
return [x[0] + self.off for x in self.sim.writes("current")]
def run(coro):
return asyncio.run(coro)
SEND = {} # T26: what the charger was sent, per shape
def keep(key, w, res):
"""The writes of one run: the driver's calls (second, value, taken) and
what the model received (model second, kind, value)."""
SEND[key] = ([(round(t), a, r) for t, a, r in res],
[(round(x[0]), x[1], x[2]) for x in w.sim.writes()])
async def live_car(setpoint=16, phases=3, **kw):
"""Manual, the car charging `setpoint` A on `phases`, ramped up."""
w = World(setpoint=setpoint, phases=phases, **kw)
await w.step(6)
await w.act("car_phases", phases) # the wish is what the car has
await w.act("car_mode", "manual")
await w.act("car_current", setpoint)
await w.step(4)
return w
def spy_on(w):
"""[(send time, current, ok)] of every `write_current`."""
res, real = [], w.drv.write_current
async def spy(a):
t = w.t
r = await real(a)
res.append((t, a, r))
return r
w.drv.write_current = spy
return res
def never_stuck(tr, lo=0):
return all(a is None and not s for _t, a, s in tr[lo:])
def first_stuck(tr):
return next((t for t, _a, s in tr if s), None)
# =========================================================================== #
print("\n2. W: LIVE REFUSALS SHOW ONE AMBER ROW")
# =========================================================================== #
# Each W shape runs twice: the writer inside the cycle (the model's own
# waits), and BESIDE it as in production (the cycle reads while a write waits).
SIDES = ((False, "inside"), (True, "beside"))
async def t1(kind, beside):
w = await live_car(beside=beside)
w.sim.refuse = kind
res = spy_on(w)
await w.act("car_current", 10)
tr = await w.step(400)
return w, res, tr
for beside, side in SIDES:
for kind, nm in (("ignore", "T1 the charger ignores it (HA says yes)"),
("error", "T2 HA refuses at once (False at +0)")):
LOG.rec.clear()
w, res, tr = run(t1(kind, beside))
ts = [t for t, _a, _r in res]
keep(f"{nm[:2]}-{kind}-{side}", w, res)
nm = f"{nm} [{side}]"
check(f"{nm}: three tries about a minute apart, all refused, then "
f"it gives up ({[round(x - ts[0]) for x in ts]})",
len(res) == 3 and not any(r for _t, _a, r in res)
and all(55 <= b - a <= 75 for a, b in zip(ts, ts[1:]))
and w.c.car_writer.gave_up)
N1.append((nm, never_stuck(tr)))
check(f"{nm}: the car shows life inside each window: never armed, "
"never stuck, to 400 s", never_stuck(tr))
check(f"{nm}: after the 3rd try exactly ONE amber charger row, "
f"charger_refused ({w.amber()})",
w.amber() == ["charger_refused"])
check(f"{nm}: the car figure is still used by the alarm path",
w.c.car_alarm_w() is not None)
check(f"{nm}: N8 one CHARGER_REFUSED warning, no Traceback; N7 no "
"'another writer' row",
LOG.text("WARNING").count("CHARGER_REFUSED") == 1
and "Traceback" not in LOG.text()
and "charger_other" not in w.rows()
and "charger_writer" not in w.rows())
async def t19(beside):
w = await live_car(16, 3, beside=beside)
w.sim.refuse = "ignore"
res = spy_on(w)
await w.act("car_phases", 1)
tr = await w.step(400)
return w, res, tr
for beside, side in SIDES:
LOG.rec.clear()
w, res, tr = run(t19(beside))
keep(f"T19-{side}", w, res)
N1.append((f"T19 [{side}]", never_stuck(tr)))
check(f"T19 [{side}] the 0 A of a phase change is ignored and the car "
"keeps drawing: tried MAX_TRIES times, no select, never armed or "
"stuck", len(res) == carmode.MAX_TRIES
and not any(r for _t, _a, r in res)
and all(a == 0.0 for _t, a, _r in res)
and not w.sim.writes("phases") and never_stuck(tr))
check(f"T19 [{side}] ...and no charger_stuck row; charger_refused shows "
f"({w.amber()})", "charger_refused" in w.amber()
and "charger_stuck" not in w.amber())
# =========================================================================== #
print("\n3. W: NO LIFE, ACCEPTED WRITES, TRANSITIONS")
# =========================================================================== #
async def t11(beside):
w = await live_car(beside=beside)
w.sim.set_current(5) # under 6 A: B, exactly 0 W, waiting
await w.step(8)
w.sim.refuse = "ignore"
res = spy_on(w)
await w.act("car_current", 10)
tr = await w.step(300)
return w, res, tr
for beside, side in SIDES:
LOG.rec.clear()
w, res, tr = run(t11(beside))
keep(f"T11-{side}", w, res)
t_s = res[0][0]
fs = first_stuck(tr)
N2.append((f"T11 [{side}]", None if fs is None else fs - t_s))
check(f"T11 [{side}] a paused car (B, 0 W) shows no life: it arms as "
f"today, stuck at t_s+60 ({fs - t_s if fs else None})",
w.sim.state == "B" and w.sim.power_w == 0.0 and fs is not None
and 59 <= fs - t_s <= 61)
check(f"T11 [{side}] ...and after the 3rd try both amber rows show: "
f"{w.amber()}", w.amber() == ["charger_refused", "charger_stuck"])
async def t14():
w = await live_car(beside=True)
w.sim.lag_s = 3.0 # the read-back is seen by the cycle
w.sim.freeze_power() # the power sticks, the rest is live
res = spy_on(w)
await w.act("car_current", 8)
tr = await w.step(100)
return w, res, tr
LOG.rec.clear()
w, res, tr = run(t14())
t_s = res[0][0]
fs = first_stuck(tr)
check(f"T14 an ACCEPTED write (read-back 3 s late) under a frozen power: "
f"stuck at t_s+60 (+-1), as before ({fs - t_s if fs else None})",
res[0][2] is True and fs is not None and 59 <= fs - t_s <= 61
and w.c.car.armed_at == t_s)
check("T14 ...the amber row 'charger_stuck' shows, and the car figure is not "
"trusted while stuck (N4)", "charger_stuck" in w.amber()
and w.c.car.car_w_trusted(w.t) is None and w.c.car_alarm_w() is None)
async def t17():
w = await live_car(beside=True)
w.sim.refuse = "ignore"
res = spy_on(w)
await w.act("car_current", 10)
tr = await w.step(70) # tries at t_s and t_s+60: live
w.sim.refuse = None
w.sim.lag_s = 3.0
w.sim.freeze_power()
await w.act("car_current", 12)
tr += await w.step(120)
return w, res, tr
LOG.rec.clear()
w, res, tr = run(t17())
t_s, t_acc = res[0][0], res[-1][0]
fs = first_stuck(tr)
check(f"T17 live refusals (not armed), then an accepted write at t_s+"
f"{t_acc - t_s:.0f}: not armed before it, stuck at ITS +60 (+-1) "
f"({fs - t_acc if fs else None})",
res[-1][2] is True and t_acc - t_s > 61 and fs is not None
and 59 <= fs - t_acc <= 61
and all(a is None for t, a, _s in tr if t < t_acc))
async def t18():
w = await live_car(beside=True)
w.sim.lag_s = 3.0
w.sim.freeze_power()
res = spy_on(w)
await w.act("car_current", 12) # accepted: arms
tr = await w.step(19)
w.sim.lag_s = 0.0
w.sim.refuse = "ignore"
await w.act("car_current", 10) # a live refusal 20 s later
tr += await w.step(100)
return w, res, tr
LOG.rec.clear()
w, res, tr = run(t18())
t0 = res[0][0]
fs = first_stuck(tr)
check(f"T18 an accepted write armed at t0; a live refusal at t0+"
f"{res[1][0] - t0:.0f} neither clears nor delays it: stuck at t0+60 "
f"({fs - t0 if fs else None}), still dated t0",
len(res) >= 2 and res[1][2] is False and fs is not None
and 59 <= fs - t0 <= 61 and tr[-1][1] == t0
and all(a == t0 for _t, a, _s in tr if a is not None))
async def t21(beside):
w = await live_car(10, 3, beside=beside)
w.sim.lag_s = 14.0
res = spy_on(w)
await w.act("car_current", 12)
tr = await w.step(120)
return w, res, tr
for beside, side in SIDES:
LOG.rec.clear()
w, res, tr = run(t21(beside))
keep(f"T21-{side}", w, res)
check(f"T21 [{side}] HA took it, the read-back comes 14 s late (False at "
"+10): never stuck, no 'another writer' row, 12 A adopted, one "
"write", [(a, r) for _t, a, r in res] == [(12.0, False)]
and not any(st for _t, _a, st in tr)
and "charger_other" not in w.rows()
and "charger_writer" not in w.rows()
and w.c.car_writer.last_a == 12.0 and w.sim.readback_a == 12.0)
async def t20(beside):
"""EV-28 T15 shape: the 0 A is taken and the car stops, the select is
taken, then the restore is refused MAX_TRIES times 5 s apart at 0 W."""
w = await live_car(16, 3, beside=beside)
res = spy_on(w)
await w.act("car_phases", 1)
for _ in range(60):
await w.step(1)
if w.sim.phases_allowed == 1:
break
w.sim.refuse = "error"
tr = await w.step(150)
return w, res, tr
for beside, side in SIDES:
LOG.rec.clear()
w, res, tr = run(t20(beside))
keep(f"T20-{side}", w, res)
rest = [x for x in res if x[1] == 16.0]
fs = first_stuck(tr)
t_r = rest[0][0] if rest else None
N2.append((f"T20 [{side}]", None if not (fs and t_r) else fs - t_r))
check(f"T20 [{side}] the 0 A is taken, the restore is refused "
f"{len(rest)} times at 0 W with nothing changing: it arms as on "
f"the base, dated the first refusal (stuck at +"
f"{fs - t_r if fs and t_r else None})",
len(rest) >= carmode.MAX_TRIES and not any(r for _t, _a, r in rest)
and w.sim.power_w == 0.0 and fs is not None and 59 <= fs - t_r <= 61)
check(f"T20 [{side}] ...no select besides the one made, and the rows "
f"are as on the base ({w.amber()})",
len(w.sim.writes("phases")) == 1
and "charger_stuck" in w.amber())
# =========================================================================== #
print("\n4. W: AN ERROR AND A RESTART")
# =========================================================================== #
async def t13(exc):
w = await live_car()
n0 = len(LOG.rec)
async def boom(a):
await w.sleep(1.0)
raise exc
w.drv.write_current = boom
await w.act("car_current", 10)
tr = await w.step(30)
return w, tr, n0
from app import hass # noqa: E402
for exc in (RuntimeError("the link broke"), hass.ReadOnly("read only")):
LOG.rec.clear()
w, tr, n0 = run(t13(exc))
errs = [m for lv, m in LOG.rec[n0:]
if lv == "ERROR" and "car charger step failed" in m]
check(f"T13 write_current raises {type(exc).__name__}: as on the base: "
"never armed, no window left, no refusal counted, the mute set, "
f"the step error logged once ({len(errs)})",
never_stuck(tr) and pend(w.c.car) is None
and w.c.car_writer.fails == 0 and w.c.car.mute_until > 0
and len(errs) == 1)
async def t25():
w = await live_car()
w.sim.refuse = "ignore"
await w.act("car_current", 10)
await w.step(75) # two tries
fails_before = w.c.car_writer.fails
w.make(CAR) # a restart: a new Controller
return w, fails_before
w, fb = run(t25())
check("T25 a restart after 2 refusals: a fresh tracker and writer, nothing "
"armed, nothing waiting, no failures counted",
fb == 2 and w.c.car.armed_at is None and pend(w.c.car) is None
and not w.c.car.stuck(w.t) and w.c.car_writer.fails == 0)
# =========================================================================== #
print("\n5. C: THE PEAK GUARD (the real Controller on the SAFETY-81 plant)")
# =========================================================================== #
import ev04_peak as P # noqa: E402
import safety81_sim as s81 # noqa: E402
HOUSE = 3000.0
AIM = 6050.0
def drive(events, dur, house=HOUSE, aim=AIM, **kw):
"""P.drive with a trace per second, taken before that second's cycle:
(second, armed_at, stuck, car_alarm_w, the alarms so far)."""
tr = []
def note(plant, c):
tr.append((plant.t, c.car.armed_at, c.car.stuck_now, c.car_alarm_w()))
ev = {t: note for t in range(0, dur)}
for t, fn in events.items():
ev[t] = (lambda p, c, fn=fn: (fn(p, c), note(p, c)))
kw.setdefault("phases", 3)
kw.setdefault("setpoint", 16)
kw.setdefault("user_a", 16)
r = P.drive(s81.constant(house), dur=dur, rating=12000.0, soc=60.0,
cap=aim, events=ev, **kw)
return r, tr
def user_change(a):
def fn(plant, c):
asyncio.get_event_loop().create_task(c.handle_action(
"car_current", value=a))
return fn
def reserve(plant, c):
"""Both units at the peak reserve, the house on, the car 11 kW."""
plant.soc = 19.0
plant.load = lambda t: HOUSE + plant.ch.power_w
def sends(r):
return [(round(x[0]), x[1], x[2]) for x in r["sim"].writes()]
def amber_rows(r):
return sorted(x["id"] for x in r["c"].checks()
if x["warn"] and not x["ok"] and x["id"].startswith("charger"))
ALARMS = P.ALARMS + ("goodwe_peak_floor_limited",)
def alarm_list(r):
return P.ids(r, *P.ALARMS)
# T22: a live refusal under a car-caused overload raises nothing the twin
# does not
def t22_events(change):
ev = {300: lambda p, c: (reserve(p, c), setattr(p.ch, "refuse", "ignore")
if change else None)}
if change:
ev[301] = user_change(10)
return ev
r_ref, tr_ref = drive(t22_events(True), 700)
r_twin, tr_twin = drive(t22_events(False), 700)
w_ref = [x[3] for x in tr_ref if x[0] >= 300]
w_twin = [x[3] for x in tr_twin if x[0] >= 300]
check("T22 PRECONDITION: the refusals happened (3 tries) and the twin wrote "
"nothing", len(r_ref["sim"].writes("current")) == 3
and r_twin["sim"].writes("current") == [])
check("T22 a live refusal under a car-caused overload: the car figure used by "
"the alarm path is the twin's every cycle from 300 to 700 (+-1 W)",
len(w_ref) == len(w_twin) and all(
(a is None and b is None) or (a is not None and b is not None
and abs(a - b) <= 1.0)
for a, b in zip(w_ref, w_twin)))
check(f"T22 ...and the alarms are the twin's ({alarm_list(r_ref)} vs "
f"{alarm_list(r_twin)})", alarm_list(r_ref) == alarm_list(r_twin)
and alarm_list(r_ref) == [])
check("T22 ...never armed, never stuck", all(a is None and not s
for _t, a, s, _w in tr_ref))
# T16: the test_ev04 section 9 shape: everything frozen, the car really goes,
# the user sets 10 A: the write is refused and nothing changes
def freeze_all(plant, c):
plant.ch.freeze() # every reading sticks, the
plant.ch.unplug() # read-back too; the car goes
plant.load = lambda at: 9000.0 + plant.ch.power_w
r16, tr16 = drive({60: lambda p, c: (freeze_all(p, c),
user_change(10)(p, c))}, 400,
house=1100.0, aim=3500.0)
SEND["T16"] = ([], sends(r16))
log16 = [x for x in r16["c"].car_writer.log if x[0] == "current"]
t_s = log16[0][2] if log16 else None
fs = next((t for t, _a, s, _w in tr16 if s), None)
al16 = P.ids(r16, "goodwe_peak_saturated")
N2.append(("T16", None if fs is None else fs - t_s))
N1.append(("T22", all(a is None and not st for _t, a, st, _w in tr_ref)))
check(f"T16 everything frozen, the write is refused: it arms at t_s={t_s} "
f"and is stuck at t_s+60 +-2 (first {fs})",
t_s is not None and fs is not None and 58 <= fs - t_s <= 62
and not any(x[3] for x in log16))
check(f"T16 ...after MAX_TRIES both rows show: {amber_rows(r16)}",
amber_rows(r16) == ["charger_refused", "charger_stuck"])
check("T16 ...the car figure is not used while stuck, and the normal alarm "
f"fires before freeze+60+60+25 ({al16})",
r16["c"].car_alarm_w() is None and len(al16) == 1
and al16[0][0] < 60 + 60 + 25)
# T23 (EV-10 trap): a 6 A, 1 phase car (1.38 kW) takes no energy step inside
# the window, so its refusal arms as today. The house then steps 1.7 kW over
# the aim: the car does not explain it, so the alarm comes at the twins' cycle.
def t23_events(change, t_s=570):
def house_drain(plant, c): # test_ev10's trap shape
plant.soc = 19.0
plant.load = lambda at: 12000.0 + plant.ch.power_w
return {t_s - 1: lambda p, c: (setattr(p.ch, "refuse", "ignore")
if change else None),
t_s: user_change(8) if change else (lambda p, c: None),
t_s + 30: house_drain}
def t23(change, mode="manual"):
return drive(t23_events(change), 800, house=1100.0, aim=4500.0,
phases=1, setpoint=6, user_a=6, mode=mode)
r23, tr23 = t23(True)
r23a, tr23a = t23(False)
r23o, tr23o = t23(False, mode="off")
a23, a23a, a23o = (P.ids(x, *P.ALARMS) for x in (r23, r23a, r23o))
check(f"T23 PRECONDITION: the refusal found no life (6 A, 1.38 kW): it armed "
f"as today, stuck at t_s+60", any(s for _t, _a, s, _w in tr23)
and len(r23["sim"].writes("current")) >= 1)
check(f"T23 the alarm fires at the same second as both twins (refusal "
f"{a23}, no write {a23a}, Off {a23o})", len(a23) == 1
and [n for _t, n in a23] == [n for _t, n in a23a]
and abs(a23[0][0] - a23a[0][0]) <= 1 and a23o
and abs(a23[0][0] - a23o[0][0]) <= 1)
# T24 (EV-18): after a live refusal (not armed) the energy meter stops while
# the power says 11 kW: the figure is contradicted and the quarter latched.
# (The tries are at 300, 360 and 420, each live; the meter stops after them.)
def meter_stops(plant, c):
sim, tick = plant.ch, plant.ch.tick
def stuck_meter(secs=1.0):
kwh = sim.kwh
tick(secs)
sim.kwh = kwh
sim.tick = stuck_meter
def t24(change):
ev = {299: lambda p, c: (reserve(p, c), setattr(p.ch, "refuse", "ignore")
if change else None),
300: user_change(10) if change else (lambda p, c: None),
432: meter_stops} # after the 3rd try's window
seen = []
def watch(plant, c):
seen.append((plant.t, c._car_contradicted(c.car_now()),
c._car_contra_block))
for t in range(300, 700):
prev = ev.get(t)
ev[t] = (lambda p, c, prev=prev: (prev(p, c) if prev else None,
watch(p, c)))
r, tr = drive(ev, 700)
return r, tr, seen
r24, tr24, seen24 = t24(True)
check("T24 PRECONDITION: a live refusal at 300 (not armed)",
len(r24["sim"].writes("current")) >= 1
and all(a is None and not st for t, a, st, _w in tr24))
check("T24 after a live refusal the meter that falls short for a window "
"contradicts the figure and latches the quarter (a refusal hides no "
"contradiction)", any(x[1] for x in seen24)
and seen24[-1][2] is not None)
# =========================================================================== #
print("\n6. WRITES: THE SAME AS ON THE BASE (T26, N3)")
# =========================================================================== #
if os.environ.get("EV13_DUMP"):
for k in sorted(SEND):
print("DUMP", repr(k), repr(SEND[k]))
BASE_SENDS = { # recorded on 76f4de2 (release/1.0 before EV-13)
'T1-ignore-beside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], [(11, 'current', 10.0), (71, 'current', 10.0), (131, 'current', 10.0)]),
'T1-ignore-inside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], [(11, 'current', 10.0), (71, 'current', 10.0), (131, 'current', 10.0)]),
'T11-beside': ([(1019, 10.0, False), (1079, 10.0, False), (1139, 10.0, False)], [(19, 'current', 10.0), (79, 'current', 10.0), (139, 'current', 10.0)]),
'T11-inside': ([(1019, 10.0, False), (1079, 10.0, False), (1139, 10.0, False)], [(19, 'current', 10.0), (79, 'current', 10.0), (139, 'current', 10.0)]),
'T16': ([], [(61, 'current', 10.0), (131, 'current', 10.0), (201, 'current', 10.0)]),
'T19-beside': ([(1011, 0.0, False), (1071, 0.0, False), (1131, 0.0, False)], [(11, 'current', 0.0), (71, 'current', 0.0), (131, 'current', 0.0)]),
'T19-inside': ([(1011, 0.0, False), (1071, 0.0, False), (1131, 0.0, False)], [(11, 'current', 0.0), (71, 'current', 0.0), (131, 'current', 0.0)]),
'T2-error-beside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], []),
'T2-error-inside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], []),
'T20-beside': ([(1011, 0.0, True), (1025, 16.0, False), (1030, 16.0, False), (1035, 16.0, False), (1095, 16.0, False), (1155, 16.0, False)], [(11, 'current', 0.0), (15, 'phases', 1)]),
'T20-inside': ([(1011, 0.0, True), (1025, 16.0, False), (1030, 16.0, False), (1035, 16.0, False), (1095, 16.0, False), (1155, 16.0, False)], [(11, 'current', 0.0), (15, 'phases', 1)]),
'T21-beside': ([(1011, 12.0, False)], [(11, 'current', 12.0)]),
'T21-inside': ([(1011, 12.0, False)], [(11, 'current', 12.0)]),
}
for k in sorted(SEND):
check(f"T26 {k}: the writes (second, value, taken) and what the model "
"received are the base's", BASE_SENDS.get(k) == SEND[k])
check("T26 no write above the clamp (16 A), and the one select (T20) came "
"with the car at 0 W", all(a <= 16.0 for v in SEND.values()
for _t, a, _r in v[0])
and sorted(k for k, v in SEND.items()
if any(x[1] == "phases" for x in v[1])) == ["T20-beside",
"T20-inside"])
# =========================================================================== #
print("\n7. A REFUSAL, THEN THE CHARGER GOES UNAVAILABLE")
# =========================================================================== #
GONE = CH.ChargerReading(available=False, why="no answer")
def gone_then_back(back_at, mode):
"""Refusal at TS; no answer until `back_at`; then the frozen reading."""
tl = [(TS + s, GONE if s < back_at else rd()) for s in range(1, 131)]
return play(tl, mode)
for mode in ("live", "ring"):
tr, first, _ = gone_then_back(21, mode)
check(f"unavailable [{mode}]: a refusal, no answer from TS+1 to TS+20 "
f"(past TOOK_S), then the reading back and frozen: armed dated the "
f"send, stuck at TS+60 as on the base (first {first})",
tr.armed_at == TS and first is not None and TS + 59 <= first
<= TS + 61 and pend(tr) is None)
tl = [(TS + k, GONE) for k in range(1, 31)]
tr, first, _ = play(tl, mode)
check(f"unavailable [{mode}]: a refusal and no answer at all for 30 s: "
"armed dated the send while it is still unavailable, as on the "
"base", tr.armed_at == TS and pend(tr) is None)
tr, first, _ = gone_then_back(75, mode)
check(f"unavailable [{mode}]: no answer until TS+75: the window lapsed "
f"unseen, so the first reading back is stuck at once, as on the base "
f"(first {first})", tr.armed_at == TS and first == TS + 75)
tr, first, _ = gone_then_back(5, mode)
check(f"unavailable [{mode}]: back inside the window and frozen: the "
"window runs on and arms at the send", tr.armed_at == TS
and first is not None and TS + 59 <= first <= TS + 61)
# P4 (review): a refusal with no life, and a read-back that arrives late but
# inside TOOK_S. The base arms at the send and the moved read-back disarms it
# ("it moved: alive"); the window must do the same, not arm on the new value.
zero = dict(p=0.0, cur=(0.0, 0.0, 0.0))
tr, first, ever = play(steady({5: dict(a=10.0)}, **zero), "live", pre=zero)
check(f"P4 [live]: no life, the read-back moves at +5, after the refusal was "
f"noted: armed dated the send and disarmed by the move, never stuck, "
f"as on the base ({tr.armed_at}, {first})", first is None
and tr.armed_at is None and not tr.stuck_now and pend(tr) is None)
# The live case, looked at second by second: between the send and the move the
# refusal is a window dated the send (not yet armed, as nothing is decided);
# it arms dated TS when it runs out, with the sig AT THE SEND, so the moved
# read-back disarms it at once (kills the reviewer's R1: arm with the current sig).
_dates = []
_tr = CH.CarTracker()
for _i in range(-20, 1):
_tr.observe(rd(**zero), TS + _i, UTC, DAY)
_orig = _tr._pend_arm
_tr._pend_arm = lambda: (_dates.append((_tr._pend or {}).get("t")), _orig())
_tr.note_write(TS, 16.0, 10.0, False)
_mid = []
for _s, _r in steady({5: dict(a=10.0)}, end=14, **zero):
_tr.observe(_r, _s, UTC, DAY)
_mid.append((_s - TS, (pend(_tr) or {}).get("t"), _tr.armed_at))
check("P4 [live]: from the send to the move the refusal is an open window "
"dated TS (armed_at still None)", all(w == TS and a is None
for s, w, a in _mid if s < 11))
_last = _mid[-1] if _mid else None
check(f"P4 [live]: the window arms dated TS when it runs out, and the moved "
f"read-back disarms it in the same sample ({_dates}, {_last})",
_last is not None and _dates == [TS] and _tr.armed_at is None and not _tr.stuck_now
and pend(_tr) is None)
tr, first, ever = play(steady({5: dict(a=10.0)}, **zero), "ring", pre=zero)
check(f"P4 [ring]: the read-back moved inside the window BEFORE the refusal "
f"was noted (the write waited): it still arms, dated the send, and is "
f"stuck at +60, as on the base (armed {tr.armed_at}, first {first})",
tr.armed_at == TS and first == TS + 60)
# ... and the same read-back arriving AFTER the window leaves it stuck until
# it moves: 12 s in, the base has been armed since the send, so it disarms then
tr, first, ever = play(steady({12: dict(a=10.0)}, **zero), "live", pre=zero)
check("P4 the read-back moves at +12 (after the window): disarmed then, "
"never stuck", first is None and tr.armed_at is None)
tr, first, ever = play(steady({70: dict(a=10.0)}, **zero), "live", pre=zero)
check(f"P4 the read-back moves at +70: stuck at +60 first, as on the base "
f"(first {first}-{TS})", first == TS + 60 and tr.armed_at is None)
# =========================================================================== #
print("\n8. N-IDS")
# =========================================================================== #
check(f"N1: no stuck after refusals that all showed life (T1-T5, T9 edges, "
f"T12a, T19, T22: {len(N1)} runs)", len(N1) >= 20
and all(ok for _n, ok in N1))
check(f"N2: every refusal with no life is stuck within 61 s of its send "
f"(T6-T11, T12b, T16, T20: {len(N2)} runs)", len(N2) >= 20
and all(d is not None and d <= 61 for _n, d in N2))
for _p in ("P1 L1 present before", "P2 L1 absent before",
"P1 per phase", "P2 per phase"):
_runs = [d for n, d in N2 if n.startswith(_p)]
check(f"N2 includes {_p!r} in all three modes: {len(_runs)} runs, each "
f"stuck within 61 s of its send", len(_runs) == 3
and all(d is not None and d <= 61 for d in _runs))
check("N5: no house-caused alarm later than the no-write twin or Off (T22 "
"equals its twin; T23 within a second of both)",
alarm_list(r_ref) == alarm_list(r_twin)
and abs(a23[0][0] - a23a[0][0]) <= 1 and abs(a23[0][0] - a23o[0][0]) <= 1)
from app import messages # noqa: E402
check("N6: the constants and the row texts (EN and NL) are the base's",
(CH.STUCK_S, CH.STUCK_MIN_A, CH.OWN_WRITE_MUTE_S, CH.TOOK_S) ==
(60.0, 1.0, 15.0, 10.0)
and (carmode.MAX_TRIES, carmode.RETRY_S) == (3, 60.0)
and messages.row_charger_stuck() ==
"The charger reading may be stuck, so check the charger."
and messages.row_charger_stuck().nl ==
"De meting van de laadpaal staat mogelijk vast, dus controleer de "
"laadpaal."
and messages.row_charger_refused() ==
"The charger did not take the setting, so check the charger."
and messages.row_charger_refused().nl ==
"De laadpaal nam de instelling niet over, dus controleer de laadpaal.")
# =========================================================================== #
print("\n9. T27: THE EV-04 SECTION 9 CHECKS ARE THE BASE'S; T28: THE MUTANTS")
# =========================================================================== #
S9_SHA = "2a40480c804574207b0c81096365363c8d608eeb32285a1c18700478fc37fc41"
src04 = open(os.path.join(HERE, "test_ev04.py")).read()
a9 = src04.index('9. THE PEAK GUARD')
b9 = src04.index("# a plausible figure is bounded by what the read-back allows")
sec9 = src04[a9:b9]
check("T27 test_ev04 section 9 is byte-identical to 76f4de2",
hashlib.sha256(sec9.encode()).hexdigest() == S9_SHA)
check("T27 ...its two stuck checks are there",
"the amber row 'Charger reading may be stuck' says so" in sec9
and "...while stuck, the car figure is not used by the alarm path" in sec9)
# the other files T27 names (ev04, ev10, ev10b, ev15, ev18, ev19, ev28,
# named_absence, bytecode) are test files of their own: CI runs every
# test_*.py, so a red one fails this PR; not re-run from here.
MUTANTS = {
"M1": (" before = [x for x in self._ring if x[0] <= now]\n",
" return\n before = [x for x in self._ring if x[0] "
"<= now]\n"),
"M2": (" if old and all(v != o for o in old):", " if old:"),
"M3": (" t = now if r.taken_at is None else r.taken_at\n",
" t = now\n"),
"M4": (" self._pend_feed(t, v, t)\n\n def _life",
" self._pend_feed(t, v, t)\n self._pend_arm()\n\n"
" def _life"),
"M5": (' if max(t, arrival) > p["t"] + TOOK_S:\n'
' self._pend_arm()',
' if max(t, arrival) > p["t"] + TOOK_S:\n'
' self._pend_arm(max(t, arrival))'),
}
M5_SIG = (" def _pend_arm(self) -> None:",
" def _pend_arm(self, at=None) -> None:")
M5_SET = (' self.armed_at, self.armed_sig = p["t"], p["sig"]',
' self.armed_at, self.armed_sig = (p["t"] if at is None '
'else at), p["sig"]')
# what each mutant must turn red (substrings of the failing check names)
RED = {"M1": ["T6 ", "T7 ", "T11 ", "T16 "], "M2": ["T6 "],
"M3": ["T7 ", "T8 "], "M4": ["T2 "], "M5": ["T9 ", "T16 "]}
def mutant_run(name):
"""A copy of the tree with the bug put back; test_ev13 (and, for the
stuck rows, test_ev04) run in it. The children skip this section."""
import shutil
import subprocess
import tempfile
d = tempfile.mkdtemp(prefix="ev13m-")
dst = os.path.join(d, "gc")
shutil.copytree(HERE, dst, ignore=shutil.ignore_patterns(
"__pycache__", "*.pyc"))
p = os.path.join(dst, "app", "chargers.py")
txt = open(p).read()
edits = [MUTANTS[name]] + ([M5_SIG, M5_SET] if name == "M5" else [])
for old, new in edits:
assert txt.count(old) == 1, (name, old)
txt = txt.replace(old, new)
open(p, "w").write(txt)
env = dict(os.environ, EV13_MUTANT="1", PYTHONDONTWRITEBYTECODE="1")
procs = {f: subprocess.Popen(
[sys.executable, "-B", f], cwd=dst, env=env, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT, text=True)
for f in ("test_ev13.py", "test_ev04.py")}
out = {f: pr.communicate()[0] for f, pr in procs.items()}
shutil.rmtree(d, ignore_errors=True)
return {f: [ln for ln in o.splitlines() if ln.strip().startswith("FAIL")]
for f, o in out.items()}, {f: procs[f].returncode for f in procs}
if not os.environ.get("EV13_MUTANT"):
import concurrent.futures
with concurrent.futures.ThreadPoolExecutor(5) as ex:
res = dict(zip(MUTANTS, ex.map(mutant_run, MUTANTS)))
for name in MUTANTS:
reds, rcs = res[name]
got = reds["test_ev13.py"]
check(f"T28 {name}: test_ev13 goes red ({len(got)} checks) in "
f"{RED[name]}", rcs["test_ev13.py"] != 0
and all(any(k in ln for ln in got) for k in RED[name]))
check("T28 M1 also turns the two test_ev04 section 9 stuck checks red",
res["M1"][1]["test_ev04.py"] != 0
and any("amber row 'Charger reading may be stuck'" in ln
for ln in res["M1"][0]["test_ev04.py"])
and any("car figure is not used" in ln
for ln in res["M1"][0]["test_ev04.py"]))
check("T28 M2 turns test_ev04 section 9 red too; M3, M4 and M5 do not "
"(its 85 s bound is too loose to see M5's 10 s: see the report)",
res["M2"][1]["test_ev04.py"] != 0
and all(res[m][1]["test_ev04.py"] == 0 for m in ("M3", "M4", "M5")))
print()
if fails:
print(f"FAIL: {len(fails)} check(s)")
for f in fails:
print(" -", f)
sys.exit(1)
print("ok: EV-13")