|
|
|
@@ -0,0 +1,827 @@
|
|
|
|
|
"""EV-14: the Car Why says what happens, not only what the user set.
|
|
|
|
|
`python3 -B test_ev14.py`
|
|
|
|
|
|
|
|
|
|
Display only (homeview._car_manual_why, ui_text en/nl):
|
|
|
|
|
E1 shadow mode: no Why says "You set"; with the car over the limit it says
|
|
|
|
|
what the add-on WOULD set and that this charge would set the peak.
|
|
|
|
|
E2 a phase change that did not happen (read phases differ from the setting):
|
|
|
|
|
"The charger stays on {real}", never "keeps it".
|
|
|
|
|
E3 the writer holds for another writer: "Something else set the charger".
|
|
|
|
|
E4 phases equal or unknown, no hold: exactly as before.
|
|
|
|
|
E5 texts in en and nl, same keys, UX-08 limits.
|
|
|
|
|
N2 the render writes nothing; N3 it never sends to the charger.
|
|
|
|
|
Mutants: see the dev report (M1-M14).
|
|
|
|
|
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
import asyncio
|
|
|
|
|
import copy
|
|
|
|
|
import dataclasses
|
|
|
|
|
import itertools
|
|
|
|
|
import json
|
|
|
|
|
import logging
|
|
|
|
|
import os
|
|
|
|
|
import re
|
|
|
|
|
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, ctl_car, homeview, uitext # noqa: E402
|
|
|
|
|
from app.carmode import PHASE_GAP_S, ManualWriter # noqa: E402
|
|
|
|
|
from app.main import Controller # noqa: E402
|
|
|
|
|
from app import freshness # noqa: E402
|
|
|
|
|
from chargersim import FakeHa, SimCharger # noqa: E402
|
|
|
|
|
from named_absence import nth, present # noqa: E402
|
|
|
|
|
|
|
|
|
|
fails = []
|
|
|
|
|
logging.getLogger("goodwe").setLevel(logging.CRITICAL)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def check(name, cond):
|
|
|
|
|
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
|
|
|
|
if not cond:
|
|
|
|
|
fails.append(name)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def run(coro):
|
|
|
|
|
return asyncio.run(coro)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# =========================================================================== #
|
|
|
|
|
# The texts the test holds the page to, written out (T34: base is byte-equal).
|
|
|
|
|
# =========================================================================== #
|
|
|
|
|
BASE_EN = {
|
|
|
|
|
"manual_set": "You set {a} A, {phases}. The charger keeps it, whatever the peak limit does.",
|
|
|
|
|
"manual_cover": "You set {a} A. The batteries give {kw} and help down to {pct}.",
|
|
|
|
|
"manual_over": "You set {a} A. The batteries are at {pct}, so this charge sets the peak.",
|
|
|
|
|
"manual_full": "You set {a} A. The batteries give all they can, so this charge sets the peak.",
|
|
|
|
|
"manual_nocover": "You set {a} A. The guard ignores the car, so this charge can set the peak.",
|
|
|
|
|
"manual_wait": "You set {a} A. It is set when a car is connected.",
|
|
|
|
|
"manual_would": "Shadow mode: the add-on would set {a} A, {phases}.",
|
|
|
|
|
"manual_stopped": "Control is stopped. The charger keeps its last setting.",
|
|
|
|
|
"manual_blocked": "The phases change once per 10 minutes at most. This waits.",
|
|
|
|
|
}
|
|
|
|
|
BASE_NL = {
|
|
|
|
|
"manual_set": "U stelde {a} A in, {phases}. De laadpaal houdt dit aan, wat de piekgrens ook doet.",
|
|
|
|
|
"manual_cover": "U stelde {a} A in. De batterijen leveren {kw} en helpen tot {pct}.",
|
|
|
|
|
"manual_over": "U stelde {a} A in. De batterijen staan op {pct}, dus deze lading bepaalt de piek.",
|
|
|
|
|
"manual_full": "U stelde {a} A in. De batterijen geven alles, dus deze lading bepaalt de piek.",
|
|
|
|
|
"manual_nocover": "U stelde {a} A in. De bewaking negeert de auto, dus deze lading kan de piek bepalen.",
|
|
|
|
|
"manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.",
|
|
|
|
|
"manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.",
|
|
|
|
|
"manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.",
|
|
|
|
|
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht.",
|
|
|
|
|
}
|
|
|
|
|
NEW_KEYS = ("manual_shadow_over", "manual_phases", "manual_other")
|
|
|
|
|
LANGS = ("en", "nl")
|
|
|
|
|
YOU = {"en": "You set", "nl": "U stelde"}
|
|
|
|
|
KEEPS = {"en": "The charger keeps it,", "nl": "De laadpaal houdt dit aan"}
|
|
|
|
|
WOULD = {"en": "would set", "nl": "zou"}
|
|
|
|
|
PEAK = {"en": "would set the peak", "nl": "zou de piek bepalen"}
|
|
|
|
|
STAYS = {"en": "stays on", "nl": "blijft op"}
|
|
|
|
|
OTHER = {"en": "Something else set the charger.", "nl": "Iets anders heeft de laadpaal ingesteld."}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def jwords(lang):
|
|
|
|
|
return uitext.words(lang)["home_words"]["car"]["why"]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def tx(lang, key, **kw):
|
|
|
|
|
"""Render a car.why text the way the page does (a missing key is a text
|
|
|
|
|
of its own, so a check on it is a FAIL, not a crash)."""
|
|
|
|
|
homeview._LANG[0] = uitext.lang_of(lang)
|
|
|
|
|
try:
|
|
|
|
|
return homeview._t("car.why." + key, **kw)
|
|
|
|
|
except Exception as e: # noqa: BLE001
|
|
|
|
|
return f"<EXC {type(e).__name__} {key}>"
|
|
|
|
|
finally:
|
|
|
|
|
homeview._LANG[0] = "en"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def pw(n):
|
|
|
|
|
homeview._LANG[0] = "en"
|
|
|
|
|
return homeview.car_phases_word(n)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def pw_l(lang, n):
|
|
|
|
|
homeview._LANG[0] = uitext.lang_of(lang)
|
|
|
|
|
try:
|
|
|
|
|
return homeview.car_phases_word(n)
|
|
|
|
|
finally:
|
|
|
|
|
homeview._LANG[0] = "en"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# =========================================================================== #
|
|
|
|
|
# A stub site for the unit rows: what _car_manual_why reads, nothing else.
|
|
|
|
|
# =========================================================================== #
|
|
|
|
|
@dataclasses.dataclass
|
|
|
|
|
class G:
|
|
|
|
|
floor_limited: bool = True
|
|
|
|
|
soc: object = 19.0
|
|
|
|
|
saturated: bool = False
|
|
|
|
|
floor_w: float = 300.0
|
|
|
|
|
able_w: object = None
|
|
|
|
|
ceiling_w: float = 4500.0
|
|
|
|
|
engaged: bool = True
|
|
|
|
|
blind: object = None
|
|
|
|
|
wanted_w: float = 300.0
|
|
|
|
|
within_aim: bool = False
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class Car:
|
|
|
|
|
def __init__(self, reading, fresh, last_good=None):
|
|
|
|
|
self.reading, self._fresh, self.last_good = reading, fresh, last_good
|
|
|
|
|
|
|
|
|
|
def fresh(self, _now):
|
|
|
|
|
return self._fresh
|
|
|
|
|
|
|
|
|
|
def status(self, *_a):
|
|
|
|
|
return "charging"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class U(ctl_car.CarMixin):
|
|
|
|
|
"""The attributes `_car_manual_why` and `_car_why_tick` read."""
|
|
|
|
|
|
|
|
|
|
def __init__(self, **kw):
|
|
|
|
|
self.o = {"ev_batt_cover": kw.get("cover", True)}
|
|
|
|
|
self._now = 0.0
|
|
|
|
|
self.w = 11000.0
|
|
|
|
|
self.site_batt_w, self.site_rating_w = 8100.0, 9600.0
|
|
|
|
|
self.shadow = kw.get("shadow", False)
|
|
|
|
|
self.auto = kw.get("auto", True)
|
|
|
|
|
self.peak_guard = kw.get("pg", G(
|
|
|
|
|
floor_limited=kw.get("floor", True),
|
|
|
|
|
floor_w=300.0 if kw.get("eng") else 0.0))
|
|
|
|
|
self.state = "charging"
|
|
|
|
|
self.car_init({}, type("St", (), {"data": {}, "set": lambda s, k, v: 0})())
|
|
|
|
|
self.car_a = kw.get("a", 10.0)
|
|
|
|
|
self.car_n = kw.get("n", 3)
|
|
|
|
|
self.car_over = kw.get("over", False)
|
|
|
|
|
wr = self.car_writer
|
|
|
|
|
wr.hold = wr.other = kw.get("hold", False)
|
|
|
|
|
wr.blocked = kw.get("blocked", False)
|
|
|
|
|
wr.seq = kw.get("seq", None)
|
|
|
|
|
wr.would = kw.get("would", None)
|
|
|
|
|
wr.phases_gave_up = kw.get("gave_up", False)
|
|
|
|
|
if "car" in kw:
|
|
|
|
|
self.car = kw["car"]
|
|
|
|
|
else:
|
|
|
|
|
real = kw.get("real", None)
|
|
|
|
|
rd = CH.ChargerReading(available=True, state="C", power_w=2300.0,
|
|
|
|
|
setpoint_a=10.0, allowed_a=10.0,
|
|
|
|
|
phases_allowed=real)
|
|
|
|
|
self.car = Car(rd, kw.get("fresh", True))
|
|
|
|
|
|
|
|
|
|
def car_now(self):
|
|
|
|
|
return self._now
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def snap(c):
|
|
|
|
|
"""Everything N2 says a render must not move."""
|
|
|
|
|
keep = {k: v for k, v in vars(c).items()
|
|
|
|
|
if k.startswith(("car_", "_car")) and k != "car"}
|
|
|
|
|
car = getattr(c, "car", None)
|
|
|
|
|
return repr((vars(c.car_writer), vars(car) if hasattr(car, "__dict__")
|
|
|
|
|
else None, keep, c.shadow, c.auto))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
N2_BAD = []
|
|
|
|
|
EXC = []
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def why(c, lang="en", key="charging"):
|
|
|
|
|
"""The Why text; an exception becomes a text; N2 is checked on every call."""
|
|
|
|
|
before = snap(c)
|
|
|
|
|
homeview._LANG[0] = uitext.lang_of(lang)
|
|
|
|
|
try:
|
|
|
|
|
out = homeview._car_manual_why(c, key)
|
|
|
|
|
except Exception as e: # noqa: BLE001
|
|
|
|
|
EXC.append(repr(e))
|
|
|
|
|
out = f"<EXC {type(e).__name__} {e}>"
|
|
|
|
|
finally:
|
|
|
|
|
homeview._LANG[0] = "en"
|
|
|
|
|
if snap(c) != before:
|
|
|
|
|
N2_BAD.append(out)
|
|
|
|
|
return out
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def exp(lang, key, **kw):
|
|
|
|
|
return tx(lang, key, **kw)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def a_(c):
|
|
|
|
|
return f"{float(c.car_a):.0f}"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
|
print("1. E1: shadow mode says what the add-on WOULD set")
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
|
SHADOW_BAD_CASES = {
|
|
|
|
|
"T1 floor": dict(floor=True, cover=True),
|
|
|
|
|
"T2 full": dict(floor=False, cover=True),
|
|
|
|
|
"T3 cover off": dict(floor=True, cover=False),
|
|
|
|
|
}
|
|
|
|
|
for label, kw in SHADOW_BAD_CASES.items():
|
|
|
|
|
for lang in LANGS:
|
|
|
|
|
c = U(shadow=True, over=True, a=16.0, n=3, would=(10.0, 3), **kw)
|
|
|
|
|
t = why(c, lang)
|
|
|
|
|
check(f"{label} ({lang}): would set 10 A and would set the peak; no "
|
|
|
|
|
f"'You set', no 16 A: {t!r}",
|
|
|
|
|
present(t) and WOULD[lang] in t and "10 A" in t
|
|
|
|
|
and PEAK[lang] in t and YOU[lang] not in t and "16 A" not in t)
|
|
|
|
|
check(f"{label} ({lang}): exactly the shadow-over text",
|
|
|
|
|
t == exp(lang, "manual_shadow_over", a="10",
|
|
|
|
|
phases=pw_l(lang, 3)))
|
|
|
|
|
|
|
|
|
|
for lang in LANGS:
|
|
|
|
|
c = U(shadow=True, over=True, a=12.0, n=3, would=None)
|
|
|
|
|
t = why(c, lang)
|
|
|
|
|
check(f"T4 ({lang}): writer not stepped: falls back to (car_a, car_n), "
|
|
|
|
|
f"12 A, 3 phases, no 'You set': {t!r}",
|
|
|
|
|
t == exp(lang, "manual_shadow_over", a="12", phases=pw_l(lang, 3))
|
|
|
|
|
and YOU[lang] not in t)
|
|
|
|
|
c = U(shadow=True, over=False, a=16.0, n=3, would=(10.0, 3))
|
|
|
|
|
check(f"T5 ({lang}): shadow, not over: exactly today's manual_would",
|
|
|
|
|
why(c, lang) == BASE_EN["manual_would"].format(
|
|
|
|
|
a="10", phases="3 phases") if lang == "en" else
|
|
|
|
|
why(c, lang) == BASE_NL["manual_would"].format(
|
|
|
|
|
a="10", phases="3 fasen"))
|
|
|
|
|
|
|
|
|
|
# T6/T7: the EV-16 episode, 5 s cycles, floor flipping every 10 s.
|
|
|
|
|
STEP = 5.0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def tick(c, g, t, shadow=None):
|
|
|
|
|
c._now = t
|
|
|
|
|
c.peak_guard = g
|
|
|
|
|
if shadow is not None:
|
|
|
|
|
c.shadow = shadow
|
|
|
|
|
c._car_why_tick(g, t)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def episode(c, secs, flip=10.0, shadow_off_at=None):
|
|
|
|
|
out, t = [], 0.0
|
|
|
|
|
while t < secs:
|
|
|
|
|
g = G(floor_limited=(int(t // flip) % 2 == 0))
|
|
|
|
|
off = shadow_off_at is not None and t >= shadow_off_at
|
|
|
|
|
tick(c, g, t, shadow=False if off else None)
|
|
|
|
|
out.append((t, why(c)))
|
|
|
|
|
t += STEP
|
|
|
|
|
return out
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
c = U(shadow=True, over=True, a=16.0, would=(10.0, 3))
|
|
|
|
|
ep = episode(c, 180.0)
|
|
|
|
|
texts = {t for _, t in ep}
|
|
|
|
|
check(f"T6: shadow over, floor flips for 180 s: one constant text, 0 changes "
|
|
|
|
|
f"({len(ep)} cycles)", len(ep) == 36 and len(texts) == 1
|
|
|
|
|
and all(PEAK["en"] in t for t in texts))
|
|
|
|
|
c = U(shadow=True, over=True, a=16.0, would=(10.0, 3))
|
|
|
|
|
ep = episode(c, 180.0, flip=1000.0, shadow_off_at=90.0)
|
|
|
|
|
first = [t for tt, t in ep if tt < 90.0]
|
|
|
|
|
later = [t for tt, t in ep if tt >= 90.0]
|
|
|
|
|
check("T7: shadow switched off mid-episode with the floor held: the shadow "
|
|
|
|
|
"text, then exactly today's manual_over (EV-16 hold)",
|
|
|
|
|
len(first) == 18 and len(later) == 18 and len(set(first)) == 1
|
|
|
|
|
and PEAK["en"] in nth(first)
|
|
|
|
|
and set(later) == {BASE_EN["manual_over"].format(a="16", pct=homeview._pct(
|
|
|
|
|
c.o.get("peak_soc_floor", 20)))})
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
|
print("\n2. E2 / E3: units")
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
|
for lang in LANGS:
|
|
|
|
|
c = U(real=1, n=3, a=10.0)
|
|
|
|
|
t = why(c, lang)
|
|
|
|
|
check(f"T9 ({lang}): 3 set, charger on 1: 'stays on 1 phase', not 'keeps "
|
|
|
|
|
f"it': {t!r}",
|
|
|
|
|
t == exp(lang, "manual_phases", a="10", phases=pw_l(lang, 3),
|
|
|
|
|
real=pw_l(lang, 1))
|
|
|
|
|
and STAYS[lang] in t and KEEPS[lang] not in t
|
|
|
|
|
and pw_l(lang, 1) in t)
|
|
|
|
|
c = U(real=3, n=1, a=10.0)
|
|
|
|
|
t = why(c, lang)
|
|
|
|
|
check(f"T10 ({lang}): 1 set, charger on 3: 'stays on 3 phases': {t!r}",
|
|
|
|
|
t == exp(lang, "manual_phases", a="10", phases=pw_l(lang, 1),
|
|
|
|
|
real=pw_l(lang, 3)) and pw_l(lang, 3) in t.split(". ")[-1]
|
|
|
|
|
and KEEPS[lang] not in t)
|
|
|
|
|
check("T9: the words are the brief's (EN and NL)",
|
|
|
|
|
why(U(real=1, n=3)) == "You set 10 A, 3 phases. The charger stays on 1 phase."
|
|
|
|
|
and why(U(real=1, n=3), "nl") ==
|
|
|
|
|
"U stelde 10 A in, 3 fasen. De laadpaal blijft op 1 fase.")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def sett(lang, c):
|
|
|
|
|
return exp(lang, "manual_set", a=a_(c), phases=pw_l(lang, c.car_n))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for lang in LANGS:
|
|
|
|
|
c = U(real=1, n=3, auto=False)
|
|
|
|
|
check(f"T13a ({lang}): phases differ, control stopped: manual_stopped",
|
|
|
|
|
why(c, lang) == exp(lang, "manual_stopped"))
|
|
|
|
|
c = U(real=1, n=3, shadow=True, would=(10.0, 3))
|
|
|
|
|
check(f"T13b ({lang}): phases differ, shadow: manual_would",
|
|
|
|
|
why(c, lang) == exp(lang, "manual_would", a="10",
|
|
|
|
|
phases=pw_l(lang, 3)))
|
|
|
|
|
for stage in ("zero", "settle"):
|
|
|
|
|
c = U(real=1, n=3, seq={"stage": stage})
|
|
|
|
|
check(f"T14 ({lang}): phases differ, sequence at {stage}: manual_set",
|
|
|
|
|
why(c, lang) == sett(lang, c))
|
|
|
|
|
c = U(real=1, n=3, blocked=True)
|
|
|
|
|
check(f"T15 ({lang}): phases differ, blocked: manual_blocked",
|
|
|
|
|
why(c, lang) == exp(lang, "manual_blocked"))
|
|
|
|
|
for key in ("none", "full"):
|
|
|
|
|
c = U(real=1, n=3)
|
|
|
|
|
check(f"T16 ({lang}): phases differ, key {key}: manual_wait",
|
|
|
|
|
why(c, lang, key) == exp(lang, "manual_wait", a="10"))
|
|
|
|
|
c = U(real=1, n=3, eng=True)
|
|
|
|
|
giving = max(0.0, float(c.site_batt_w))
|
|
|
|
|
homeview._LANG[0] = uitext.lang_of(lang)
|
|
|
|
|
kw_ = homeview._kw(giving)
|
|
|
|
|
pct_ = homeview._pct(20)
|
|
|
|
|
homeview._LANG[0] = "en"
|
|
|
|
|
check(f"T17 ({lang}): phases differ, cover engaged, not over: manual_cover",
|
|
|
|
|
why(c, lang) == exp(lang, "manual_cover", a="10", kw=kw_, pct=pct_))
|
|
|
|
|
for label, kw in (("floor", dict(floor=True)), ("full", dict(floor=False)),
|
|
|
|
|
("nocover", dict(cover=False))):
|
|
|
|
|
c = U(real=1, n=3, over=True, **kw)
|
|
|
|
|
want = ("manual_nocover" if label == "nocover" else
|
|
|
|
|
"manual_over" if label == "floor" else "manual_full")
|
|
|
|
|
check(f"T18 ({lang}): phases differ, car over ({label}): {want}",
|
|
|
|
|
why(c, lang) == exp(lang, want, a="10", pct=pct_))
|
|
|
|
|
|
|
|
|
|
# T19/T20 are in the World section. T21-T26: the hold, units.
|
|
|
|
|
for lang in LANGS:
|
|
|
|
|
c = U(hold=True, real=1, n=3)
|
|
|
|
|
t = why(c, lang)
|
|
|
|
|
check(f"T21 ({lang}): hold, phases differ, not given up: the hold text "
|
|
|
|
|
f"{t!r}", t == exp(lang, "manual_other") and OTHER[lang] in t
|
|
|
|
|
and STAYS[lang] not in t and YOU[lang] not in t)
|
|
|
|
|
for key in ("none", "full"):
|
|
|
|
|
c = U(hold=True, real=3, n=3)
|
|
|
|
|
check(f"T22 ({lang}): hold, key {key}: the hold text, not 'set when a "
|
|
|
|
|
f"car is connected'",
|
|
|
|
|
why(c, lang, key) == exp(lang, "manual_other"))
|
|
|
|
|
c = U(hold=True, blocked=True, real=3, n=3)
|
|
|
|
|
check(f"T23a ({lang}): hold with a stale blocked: the hold text",
|
|
|
|
|
why(c, lang) == exp(lang, "manual_other"))
|
|
|
|
|
c = U(hold=True, real=3, n=3, eng=True)
|
|
|
|
|
check(f"T23b ({lang}): hold with the cover engaged: the hold text",
|
|
|
|
|
why(c, lang) == exp(lang, "manual_other"))
|
|
|
|
|
for label, kw in (("floor", dict(floor=True)), ("full", dict(floor=False)),
|
|
|
|
|
("nocover", dict(cover=False))):
|
|
|
|
|
c = U(hold=True, over=True, real=3, n=3, **kw)
|
|
|
|
|
want = ("manual_nocover" if label == "nocover" else
|
|
|
|
|
"manual_over" if label == "floor" else "manual_full")
|
|
|
|
|
check(f"T24 ({lang}): hold and car over ({label}): {want}, no hold "
|
|
|
|
|
f"text", why(c, lang) == exp(lang, want, a="10", pct=pct_)
|
|
|
|
|
and OTHER[lang] not in why(c, lang))
|
|
|
|
|
for key in ("charging", "none"):
|
|
|
|
|
c = U(hold=True, auto=False, real=3, n=3)
|
|
|
|
|
check(f"T25 ({lang}): hold, control stopped, key {key}: manual_stopped",
|
|
|
|
|
why(c, lang, key) == exp(lang, "manual_stopped"))
|
|
|
|
|
c = U(hold=True, shadow=True, over=False, would=(10.0, 3))
|
|
|
|
|
check(f"T26a ({lang}): hold, shadow, not over: manual_would",
|
|
|
|
|
why(c, lang) == exp(lang, "manual_would", a="10",
|
|
|
|
|
phases=pw_l(lang, 3)))
|
|
|
|
|
c = U(hold=True, shadow=True, over=True, would=(10.0, 3))
|
|
|
|
|
check(f"T26b ({lang}): hold, shadow, over: the shadow-over text",
|
|
|
|
|
why(c, lang) == exp(lang, "manual_shadow_over", a="10",
|
|
|
|
|
phases=pw_l(lang, 3)))
|
|
|
|
|
|
|
|
|
|
# T29-T32: E4.
|
|
|
|
|
for lang in LANGS:
|
|
|
|
|
for n in (1, 3):
|
|
|
|
|
c = U(real=n, n=n, would=(10.0, 3))
|
|
|
|
|
want = (BASE_EN if lang == "en" else BASE_NL)["manual_set"].format(
|
|
|
|
|
a="10", phases=pw_l(lang, n))
|
|
|
|
|
check(f"T29 ({lang}): {n}/{n} phases: byte-identical manual_set",
|
|
|
|
|
why(c, lang) == want)
|
|
|
|
|
c = U(real=None, n=3)
|
|
|
|
|
check(f"T30 ({lang}): phases_allowed None: manual_set, no exception",
|
|
|
|
|
why(c, lang) == sett(lang, c))
|
|
|
|
|
c = U(real=3, n=1, fresh=False)
|
|
|
|
|
check(f"T32 ({lang}): reading not fresh: manual_set (stale is unknown)",
|
|
|
|
|
why(c, lang) == sett(lang, c))
|
|
|
|
|
c = U(car=Car(None, True))
|
|
|
|
|
check("T31a: reading None: today's text, no exception",
|
|
|
|
|
why(c) == sett("en", c))
|
|
|
|
|
rd = CH.ChargerReading(available=False, phases_allowed=1)
|
|
|
|
|
c = U(car=Car(rd, True, last_good=None), n=3)
|
|
|
|
|
check("T31b: reading unavailable (phases 1 vs 3): today's text",
|
|
|
|
|
why(c) == sett("en", c))
|
|
|
|
|
c = U(real=1, n=3, pg=None)
|
|
|
|
|
check("T31c: peak_guard None: no exception, the E2 text",
|
|
|
|
|
why(c) == exp("en", "manual_phases", a="10", phases="3 phases",
|
|
|
|
|
real="1 phase"))
|
|
|
|
|
c = U(real=1, n=3)
|
|
|
|
|
del c.car
|
|
|
|
|
check("T31d: no car object at all: no exception, today's text",
|
|
|
|
|
why(c) == sett("en", c))
|
|
|
|
|
check("T31: no exception from any of the above", not EXC)
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
|
print("\n3. E5: the texts")
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
|
PH = re.compile(r"\{(\w+)\}")
|
|
|
|
|
JARGON = {
|
|
|
|
|
"en": r"controllers?|control loop|setpoints?|SoC|state of charge|BMS|PV|"
|
|
|
|
|
r"failsafe|trip(?:ped)?|parked|discharg\w*|P1 feed|quarter-hour|"
|
|
|
|
|
r"payload|endpoint|JSON|API|timeout|boolean|config|commands?|"
|
|
|
|
|
r"charge level|ceiling|billed quarter|quarters?|banked|soft limit|"
|
|
|
|
|
r"open block|actuator|ESP32|master|meter source|circulating|"
|
|
|
|
|
r"sign disagreement|rail",
|
|
|
|
|
"nl": r"setpoints?|setpunt\w*|SoC|laadtoestand|BMS|PV|failsafe|regelaar|"
|
|
|
|
|
r"regellus|controller|latch|ontlad\w*|payload|endpoint|JSON|API|"
|
|
|
|
|
r"time-?out|boolean|config|kwartuur\w*|commando\w*|geparkeerd|"
|
|
|
|
|
r"ESP32|master",
|
|
|
|
|
}
|
|
|
|
|
JARGON = {k: re.compile(r"\b(?:" + v + r")\b", re.I) for k, v in JARGON.items()}
|
|
|
|
|
samples = {lang: [t for k, t in homeview.text_samples(lang) if k == "plan"]
|
|
|
|
|
for lang in LANGS}
|
|
|
|
|
for key in NEW_KEYS:
|
|
|
|
|
en_t = uitext.raw("en")["home_words"]["car"]["why"].get(key)
|
|
|
|
|
nl_t = uitext.raw("nl")["home_words"]["car"]["why"].get(key)
|
|
|
|
|
check(f"T33 {key}: in en.json and nl.json with the same placeholders",
|
|
|
|
|
isinstance(en_t, str) and isinstance(nl_t, str)
|
|
|
|
|
and set(PH.findall(en_t)) == set(PH.findall(nl_t)))
|
|
|
|
|
for lang in LANGS:
|
|
|
|
|
raw = jwords(lang).get(key, "")
|
|
|
|
|
vals = {k: "10" for k in PH.findall(raw)}
|
|
|
|
|
vals.update(phases=pw_l(lang, 3), real=pw_l(lang, 1))
|
|
|
|
|
shown = tx(lang, key, **vals)
|
|
|
|
|
sents = re.split(r"(?<=[.!?])\s+", shown)
|
|
|
|
|
nwords = [len(s.split()) for s in sents]
|
|
|
|
|
check(f"T33 {key} ({lang}): in text_samples as a plan line, no '{{', "
|
|
|
|
|
f"<=2 sentences of <=12 words ({nwords}), no jargon: {shown!r}",
|
|
|
|
|
shown in samples[lang] and "{" not in shown
|
|
|
|
|
and len(sents) <= 2 and max(nwords) <= 12
|
|
|
|
|
and not JARGON[lang].search(PH.sub("X", shown)))
|
|
|
|
|
for lang in LANGS:
|
|
|
|
|
base = BASE_EN if lang == "en" else BASE_NL
|
|
|
|
|
words = jwords(lang)
|
|
|
|
|
check(f"T34 ({lang}): the 9 existing manual_* texts are byte-identical",
|
|
|
|
|
all(words.get(k) == v for k, v in base.items()) and len(base) == 9)
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
|
print("\n4. T35: the property sweep (both languages)")
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
|
n_calls = 0
|
|
|
|
|
viol = {"i": [], "ii": [], "iii": [], "iv": []}
|
|
|
|
|
for (sh, ov, cv, fl, hd, au, bl, eg, sq, key, pa, cn, fr) in itertools.product(
|
|
|
|
|
(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1),
|
|
|
|
|
(None, {"stage": "zero"}), ("charging", "waiting", "none", "full"),
|
|
|
|
|
(None, 1, 3), (1, 3), (0, 1)):
|
|
|
|
|
for lang in LANGS:
|
|
|
|
|
c = U(shadow=bool(sh), over=bool(ov), cover=bool(cv), floor=bool(fl),
|
|
|
|
|
hold=bool(hd), auto=bool(au), blocked=bool(bl), eng=bool(eg),
|
|
|
|
|
seq=sq, real=pa,
|
|
|
|
|
n=cn, fresh=bool(fr), would=(10.0, 3))
|
|
|
|
|
t = why(c, lang, key)
|
|
|
|
|
n_calls += 1
|
|
|
|
|
if sh and YOU[lang] in t:
|
|
|
|
|
viol["i"].append((lang, t))
|
|
|
|
|
known = pa is not None and fr
|
|
|
|
|
if (not sh and au and not ov
|
|
|
|
|
and (hd or (known and pa != cn and sq is None))
|
|
|
|
|
and KEEPS[lang] in t):
|
|
|
|
|
viol["ii"].append((lang, t))
|
|
|
|
|
if "{" in t or "<EXC" in t:
|
|
|
|
|
viol["iii"].append((lang, t))
|
|
|
|
|
sents = re.split(r"(?<=[.!?])\s+", t)
|
|
|
|
|
if len(sents) > 2 or max(len(s.split()) for s in sents) > 12:
|
|
|
|
|
viol["iv"].append((lang, t))
|
|
|
|
|
check(f"T35 (i): shadow mode, no 'You set' anywhere ({n_calls} calls)",
|
|
|
|
|
n_calls == 2 * 24576 and not viol["i"])
|
|
|
|
|
check("T35 (ii): no 'keeps it' under hold or a known, fresh phase difference",
|
|
|
|
|
not viol["ii"])
|
|
|
|
|
check("T35 (iii): no '{' left, no exception", not viol["iii"] and not EXC)
|
|
|
|
|
check("T35 (iv): at most 2 sentences of 12 words (the new texts' share)",
|
|
|
|
|
not [v for v in viol["iv"]
|
|
|
|
|
if any(k in v[1] for k in ("stays on", "blijft op", "Something else",
|
|
|
|
|
"Iets anders", "would set the peak",
|
|
|
|
|
"zou de piek"))])
|
|
|
|
|
check("T35 (vi)/N2: no render changed the writer, the car or the controller "
|
|
|
|
|
f"({len(N2_BAD)} did)", not N2_BAD)
|
|
|
|
|
|
|
|
|
|
# =========================================================================== #
|
|
|
|
|
print("\n5. Integration: a real Controller on the charger model")
|
|
|
|
|
# =========================================================================== #
|
|
|
|
|
SET = "number.wallbox_power_connector_max_current_socket_1"
|
|
|
|
|
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"]}
|
|
|
|
|
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 _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 publish(self, v):
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
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))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class World:
|
|
|
|
|
def __init__(self, opts=CAR, setpoint=10, grid=800.0, phases=1):
|
|
|
|
|
self.sim = SimCharger(setpoint_a=setpoint)
|
|
|
|
|
self.sim.plug_in()
|
|
|
|
|
self.sim.phases_allowed = phases
|
|
|
|
|
self.site = Site(self.sim, grid=grid)
|
|
|
|
|
self.t = 1000.0
|
|
|
|
|
CLOCK[0] = self.t
|
|
|
|
|
self.c = Controller(dict(opts), self.site, _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
|
|
|
|
|
if hasattr(self.drv, "_sleep"):
|
|
|
|
|
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):
|
|
|
|
|
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()
|
|
|
|
|
|
|
|
|
|
async def act(self, what, value):
|
|
|
|
|
return await self.c.handle_action(what, value=value)
|
|
|
|
|
|
|
|
|
|
def writes(self, what=None):
|
|
|
|
|
return self.sim.writes(what)
|
|
|
|
|
|
|
|
|
|
@property
|
|
|
|
|
def wr(self):
|
|
|
|
|
return self.c.car_writer
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
W_BAD = []
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def block_why(w, lang="en"):
|
|
|
|
|
"""car_block's Why, with N2 and N3 held across the call."""
|
|
|
|
|
c = w.c
|
|
|
|
|
before = (snap(c), len(w.sim.log), list(w.drv.sent),
|
|
|
|
|
len(w.site.charger_writes()))
|
|
|
|
|
homeview._LANG[0] = uitext.lang_of(lang)
|
|
|
|
|
try:
|
|
|
|
|
out = homeview.car_block(c, datetime.now(timezone.utc))
|
|
|
|
|
t = out["why"] if out else "<no block>"
|
|
|
|
|
except Exception as e: # noqa: BLE001
|
|
|
|
|
t = f"<EXC {type(e).__name__} {e}>"
|
|
|
|
|
finally:
|
|
|
|
|
homeview._LANG[0] = "en"
|
|
|
|
|
after = (snap(c), len(w.sim.log), list(w.drv.sent),
|
|
|
|
|
len(w.site.charger_writes()))
|
|
|
|
|
if before != after:
|
|
|
|
|
W_BAD.append(t)
|
|
|
|
|
return t
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def set_text(w, lang="en"):
|
|
|
|
|
return exp(lang, "manual_set", a=f"{float(w.c.car_a):.0f}",
|
|
|
|
|
phases=pw_l(lang, w.c.car_n))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
async def ready(phases, a, to, ramp=200.0, delay=1.0, shadow="off"):
|
|
|
|
|
w = World(dict(CAR, shadow_mode=shadow), setpoint=a, phases=phases)
|
|
|
|
|
await w.step(8)
|
|
|
|
|
await w.act("car_phases", phases)
|
|
|
|
|
await w.act("car_mode", "manual")
|
|
|
|
|
await w.act("car_current", a)
|
|
|
|
|
await w.step(8)
|
|
|
|
|
w.sim.ramp_w_s, w.sim.stop_delay_s = ramp, delay
|
|
|
|
|
await w.act("car_phases", to)
|
|
|
|
|
return w
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
async def t8():
|
|
|
|
|
w = World(dict(CAR, shadow_mode="on"), setpoint=10, phases=3)
|
|
|
|
|
await w.step(8)
|
|
|
|
|
await w.act("car_phases", 3)
|
|
|
|
|
await w.act("car_mode", "manual")
|
|
|
|
|
await w.act("car_current", 16)
|
|
|
|
|
await w.step(80)
|
|
|
|
|
w.c.car_over = True
|
|
|
|
|
w.c.peak_guard = G(floor_limited=True)
|
|
|
|
|
return w, {lg: block_why(w, lg) for lg in LANGS}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
w8, t8w = run(t8())
|
|
|
|
|
would_a = nth(w8.wr.would) if w8.wr.would else None
|
|
|
|
|
check("T8: shadow world, Manual 16 A, car over: shadow-over text in en and "
|
|
|
|
|
f"nl, no 'You set': {t8w}",
|
|
|
|
|
w8.c.shadow and present(would_a) and w8.wr.would is not None
|
|
|
|
|
and all(PEAK[lg] in t8w[lg] and YOU[lg] not in t8w[lg] for lg in LANGS)
|
|
|
|
|
and t8w["en"] == exp("en", "manual_shadow_over",
|
|
|
|
|
a=f"{float(w8.wr.would[0]):.0f}",
|
|
|
|
|
phases=pw(w8.wr.would[1])))
|
|
|
|
|
check("T8/N3: shadow world: no simulator log, no driver send, no charger "
|
|
|
|
|
"write", w8.sim.log == [] and w8.drv.sent == []
|
|
|
|
|
and w8.site.charger_writes() == [])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
async def gave_up(refuse_select):
|
|
|
|
|
# 3 phases wanted -> the sim is on 1; or the other way, as EV-28's T11.
|
|
|
|
|
w = await ready(3, 16, 1, ramp=(3000.0 if refuse_select else 200.0))
|
|
|
|
|
if refuse_select:
|
|
|
|
|
w.sim.request_phases = lambda n: False
|
|
|
|
|
texts = {}
|
|
|
|
|
await w.step(40)
|
|
|
|
|
texts["try1"] = (w.wr.phases_gave_up, w.wr.phase_fails, block_why(w))
|
|
|
|
|
await w.step(int(PHASE_GAP_S) + 60)
|
|
|
|
|
await w.step(int(PHASE_GAP_S) + 60)
|
|
|
|
|
texts["end"] = (w.wr.phases_gave_up, w.wr.phase_fails, block_why(w),
|
|
|
|
|
block_why(w, "nl"))
|
|
|
|
|
return w, texts
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for label, refuse in (("T11 the car keeps drawing", False),
|
|
|
|
|
("T12 the select is refused", True)):
|
|
|
|
|
w_, tt = run(gave_up(refuse))
|
|
|
|
|
g1, f1, why1 = tt["try1"]
|
|
|
|
|
ge, fe, whye, whyn = tt["end"]
|
|
|
|
|
want = exp("en", "manual_phases", a="16", phases="1 phase",
|
|
|
|
|
real="3 phases")
|
|
|
|
|
check(f"{label}: after the 3rd failed try the Why is the E2 text "
|
|
|
|
|
f"{whye!r}", ge and fe == 3 and whye == want
|
|
|
|
|
and whyn == exp("nl", "manual_phases", a="16",
|
|
|
|
|
phases=pw_l("nl", 1), real=pw_l("nl", 3))
|
|
|
|
|
and w_.sim.phases_allowed == 3 and KEEPS["en"] not in whye)
|
|
|
|
|
check(f"{label}: before the give-up (gap wait) it is manual_blocked "
|
|
|
|
|
f"{why1!r}", not g1 and f1 >= 1
|
|
|
|
|
and why1 == exp("en", "manual_blocked"))
|
|
|
|
|
|
|
|
|
|
# T19: another writer raises the current during a phase change.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
async def other_in_seq():
|
|
|
|
|
w = World(CAR, setpoint=10, phases=1)
|
|
|
|
|
w.sim.ramp_w_s, w.sim.stop_delay_s = 50.0, 40.0
|
|
|
|
|
await w.step(60)
|
|
|
|
|
await w.act("car_mode", "manual")
|
|
|
|
|
await w.act("car_current", 10)
|
|
|
|
|
await w.step(3)
|
|
|
|
|
await w.act("car_phases", 3)
|
|
|
|
|
await w.step(3)
|
|
|
|
|
mid = (w.wr.seq is not None, block_why(w))
|
|
|
|
|
w.sim.set_current(9)
|
|
|
|
|
got = None
|
|
|
|
|
for _ in range(60):
|
|
|
|
|
await w.step(1)
|
|
|
|
|
if w.wr.other:
|
|
|
|
|
got = (block_why(w), block_why(w, "nl"))
|
|
|
|
|
break
|
|
|
|
|
return w, mid, got
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
w19, mid19, got19 = run(other_in_seq())
|
|
|
|
|
check("T19: during the sequence the Why is today's manual_set "
|
|
|
|
|
f"{mid19[1]!r}", mid19[0] and mid19[1] == set_text(w19))
|
|
|
|
|
check("T19: the first car_block after w.other turns True is the hold text "
|
|
|
|
|
f"(en and nl): {got19!r}",
|
|
|
|
|
got19 is not None and got19[0] == exp("en", "manual_other")
|
|
|
|
|
and got19[1] == exp("nl", "manual_other")
|
|
|
|
|
and YOU["en"] not in got19[0] and KEEPS["en"] not in got19[0]
|
|
|
|
|
and STAYS["en"] not in got19[0])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
async def t27():
|
|
|
|
|
w, _m, _g = await other_in_seq()
|
|
|
|
|
await w.act("car_current", 12)
|
|
|
|
|
await w.step(5)
|
|
|
|
|
return w, block_why(w)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
w27, why27 = run(t27())
|
|
|
|
|
okset = {set_text(w27), exp("en", "manual_blocked"),
|
|
|
|
|
exp("en", "manual_phases", a="12", phases="3 phases",
|
|
|
|
|
real="1 phase")}
|
|
|
|
|
check(f"T27: the user changes the current: the hold is lifted and the hold "
|
|
|
|
|
f"text is gone ({why27!r})", not w27.wr.hold
|
|
|
|
|
and why27 != exp("en", "manual_other") and why27 in okset)
|
|
|
|
|
|
|
|
|
|
# T20 / T28: the other writer on equal phases.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
async def other_equal():
|
|
|
|
|
w = World(CAR, setpoint=10, phases=1)
|
|
|
|
|
await w.step(8)
|
|
|
|
|
await w.act("car_phases", 1)
|
|
|
|
|
await w.act("car_mode", "manual")
|
|
|
|
|
await w.act("car_current", 10)
|
|
|
|
|
await w.step(10)
|
|
|
|
|
pre = block_why(w)
|
|
|
|
|
t0 = w.t
|
|
|
|
|
w.sim.set_current(8)
|
|
|
|
|
before, first, secs = [], None, None
|
|
|
|
|
for _ in range(60):
|
|
|
|
|
await w.step(1)
|
|
|
|
|
if w.wr.other:
|
|
|
|
|
first, secs = block_why(w), w.t - t0
|
|
|
|
|
break
|
|
|
|
|
before.append(block_why(w))
|
|
|
|
|
held_for = None
|
|
|
|
|
w.sim.set_current(10)
|
|
|
|
|
after = []
|
|
|
|
|
for _ in range(40):
|
|
|
|
|
await w.step(1)
|
|
|
|
|
after.append((w.wr.hold, block_why(w)))
|
|
|
|
|
if not w.wr.hold:
|
|
|
|
|
break
|
|
|
|
|
return w, pre, before, first, secs, after
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
w20, pre20, before20, first20, secs20, after20 = run(other_equal())
|
|
|
|
|
check("T20: before the hold the Why is today's manual_set, every step "
|
|
|
|
|
f"({len(before20)} steps)", pre20 == set_text(w20) and before20
|
|
|
|
|
and all(t == set_text(w20) for t in before20))
|
|
|
|
|
check(f"T20: the hold text from the first call after w.other turns True, "
|
|
|
|
|
f"{secs20} s after the write (<= WRITER_S + 5 = 35)",
|
|
|
|
|
first20 == exp("en", "manual_other") and secs20 is not None
|
|
|
|
|
and secs20 <= carmode.WRITER_S + 5.0)
|
|
|
|
|
check("T28: the other writer puts the current back: the hold clears and the "
|
|
|
|
|
"Why is manual_set in the same step",
|
|
|
|
|
len(after20) >= 1 and not after20[-1][0]
|
|
|
|
|
and after20[-1][1] == set_text(w20) and len(after20) <= 5)
|
|
|
|
|
|
|
|
|
|
# N2/N3 over every World call above.
|
|
|
|
|
check(f"N2/N3: every car_block call in the World rows changed nothing and "
|
|
|
|
|
f"sent nothing ({len(W_BAD)} did)", not W_BAD)
|
|
|
|
|
|
|
|
|
|
print()
|
|
|
|
|
if fails:
|
|
|
|
|
print(f"{len(fails)} FAILED")
|
|
|
|
|
sys.exit(1)
|
|
|
|
|
print("all ok")
|