Home /Modules/http-3.0/test_station.py

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())