test_station.py
http-3.0/station/test_station.py · 216 line(s) · py
"""Python parity tests for the SLeeLa HTTP 3.0 Station (J-STA-0001).
Mirrors the C classifier (station_classifier.c) and session state machine
(station_session.c) so the Station's judgment can be checked independently and
kept consistent across languages. Runs with plain `python3 test_station.py`
(pytest optional; not required in this sandbox).
The numbers here MUST match station_abi.h.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from enum import IntEnum
from typing import List, Optional
# ---- ABI mirror (must equal station_abi.h) --------------------------------
SL_TCP_FIN, SL_TCP_SYN, SL_TCP_RST, SL_TCP_PSH = 0x01, 0x02, 0x04, 0x08
SL_TCP_ACK, SL_TCP_URG, SL_TCP_ECE, SL_TCP_CWR = 0x10, 0x20, 0x40, 0x80
URG_MAX = 8
class Cond(IntEnum):
NONE = 0
INTENTIONAL = 1
LEGAL = 2
WARNING = 3
EMERGENCY = 4
class Hop(IntEnum):
CANCEL = -1
HOLD = 0
ADVANCE = 1
class Premise(IntEnum):
START = 0
INTERMEDIARY = 1
CANCELLING = 2
class State(IntEnum):
IDLE = 0
OPEN = 1
CLEAR = 2
UNCLEAR = 3
HUNG_UP = 4
DISASTROUS = 5
PARTY_A, PARTY_B = 0, 1
# ---- classifier parity (station_classifier.c) -----------------------------
def classify_hop(hop_delta: int) -> Hop:
if hop_delta < 0:
return Hop.CANCEL
if hop_delta > 0:
return Hop.ADVANCE
return Hop.HOLD
def classify_condition(flags: int, urg_units: int) -> Cond:
if not (flags & SL_TCP_URG) or urg_units == 0:
return Cond.NONE
if (flags & (SL_TCP_URG | SL_TCP_PSH | SL_TCP_ACK)) == (SL_TCP_URG | SL_TCP_PSH | SL_TCP_ACK) and urg_units == URG_MAX:
return Cond.EMERGENCY
if (flags & (SL_TCP_URG | SL_TCP_PSH)) == (SL_TCP_URG | SL_TCP_PSH):
return Cond.WARNING
if (flags & (SL_TCP_URG | SL_TCP_ACK)) == (SL_TCP_URG | SL_TCP_ACK) and urg_units == URG_MAX:
return Cond.LEGAL
return Cond.INTENTIONAL
def classify_premise(hop: Hop, current_open: Optional[Premise]) -> Premise:
if hop == Hop.CANCEL:
return Premise.CANCELLING
if hop == Hop.ADVANCE:
if current_open is None or current_open == Premise.CANCELLING:
return Premise.START
if current_open == Premise.START:
return Premise.INTERMEDIARY
return Premise.INTERMEDIARY
# HOLD
return current_open if current_open is not None else Premise.START
# ---- session/state-machine parity (station_session.c) ---------------------
@dataclass
class PartyState:
open_premise: Optional[Premise] = None
acked_peer: bool = False
finished: bool = False
@dataclass
class Session:
state: State = State.OPEN
parties: List[PartyState] = field(default_factory=lambda: [PartyState(), PartyState()])
legal_asserted: bool = False
records: int = 0
def signal(self, party: int, urg: int, hop_delta: int, extra: int = 0) -> Optional[Cond]:
if self.state in (State.CLEAR, State.DISASTROUS):
return None
ps = self.parties[party]
flags = extra | (SL_TCP_URG if urg > 0 else 0)
if flags & SL_TCP_RST:
self.state = State.DISASTROUS
self.records += 1
return Cond.WARNING
if flags & SL_TCP_FIN:
ps.finished = True
if (flags & SL_TCP_ACK) and not (flags & SL_TCP_URG):
ps.acked_peer = True
cond = classify_condition(flags, urg)
if cond != Cond.NONE:
hop = classify_hop(hop_delta)
prem = classify_premise(hop, ps.open_premise)
self.records += 1
if cond == Cond.LEGAL:
self.legal_asserted = True
ps.open_premise = prem
if flags & SL_TCP_ACK:
ps.acked_peer = True
self._recompute()
return cond
def _recompute(self) -> None:
a, b = self.parties
if (a.open_premise == Premise.INTERMEDIARY and b.open_premise == Premise.INTERMEDIARY
and a.acked_peer and b.acked_peer):
self.state = State.CLEAR
elif a.finished or b.finished:
self.state = State.HUNG_UP
elif a.open_premise == Premise.CANCELLING or b.open_premise == Premise.CANCELLING:
self.state = State.UNCLEAR
else:
self.state = State.OPEN
# ---- tests ----------------------------------------------------------------
def test_hop_verbs():
assert classify_hop(-1) == Hop.CANCEL
assert classify_hop(0) == Hop.HOLD
assert classify_hop(1) == Hop.ADVANCE
def test_condition_table():
assert classify_condition(0, 5) == Cond.NONE # no URG bit
assert classify_condition(SL_TCP_URG, 0) == Cond.NONE # zero magnitude
assert classify_condition(SL_TCP_URG, 3) == Cond.INTENTIONAL
assert classify_condition(SL_TCP_URG | SL_TCP_ACK, URG_MAX) == Cond.LEGAL
assert classify_condition(SL_TCP_URG | SL_TCP_PSH, 4) == Cond.WARNING
assert classify_condition(SL_TCP_URG | SL_TCP_PSH | SL_TCP_ACK, URG_MAX) == Cond.EMERGENCY
def test_premise_triple():
# start -> intermediary via successive ADVANCE, then cancelling via CANCEL
assert classify_premise(Hop.ADVANCE, None) == Premise.START
assert classify_premise(Hop.ADVANCE, Premise.START) == Premise.INTERMEDIARY
assert classify_premise(Hop.CANCEL, Premise.INTERMEDIARY) == Premise.CANCELLING
def test_clear_agreement():
s = Session()
s.signal(PARTY_A, 3, +1)
s.signal(PARTY_B, 3, +1)
s.signal(PARTY_A, 5, +1, SL_TCP_ACK)
s.signal(PARTY_B, 5, +1, SL_TCP_ACK)
assert s.state == State.CLEAR
assert s.records == 4
def test_unclear_on_cancel():
s = Session()
s.signal(PARTY_A, 4, +1)
s.signal(PARTY_B, 4, +1)
s.signal(PARTY_A, 4, -1)
assert s.state == State.UNCLEAR
def test_hung_up_on_fin():
s = Session()
s.signal(PARTY_A, 3, +1)
s.signal(PARTY_B, 0, 0, SL_TCP_FIN)
assert s.state == State.HUNG_UP
def test_disastrous_on_rst():
s = Session()
s.signal(PARTY_A, 3, +1)
s.signal(PARTY_B, 0, 0, SL_TCP_RST)
assert s.state == State.DISASTROUS
def _run_all() -> int:
failures = 0
for name, fn in sorted(globals().items()):
if name.startswith("test_") and callable(fn):
try:
fn()
print(f" [ok] {name}")
except AssertionError as exc: # pragma: no cover
print(f" [FAIL] {name}: {exc}")
failures += 1
print("Station parity tests:", "PASS" if failures == 0 else f"FAIL ({failures})")
return failures
if __name__ == "__main__":
raise SystemExit(_run_all())