test_everything.py

"""
PortusSIM self-test runner.

Programmatically exercises every major feature of the application
and reports green/red status. Run from the project root:

    python test_everything.py

The tests run headlessly (no GUI window appears) and complete in under
a minute. A non-zero exit code indicates failures.

What's tested:
  - Module imports
  - Core simulation (default config, presets, seeds)
  - Reproducibility (same seed = same results)
  - 1D parameter sweep
  - 2D parameter sweep with heatmap data
  - Inequality metrics (Gini, top share)
  - Custom layouts
  - Generation/inheritance system
  - Config save/load
  - Summary export and reload for comparison

What's NOT tested:
  - Visual layout (colors, fonts, alignment)
  - Animations and transitions
  - Theme switching
  - Click handlers on widgets
For those, run the app and use the manual checklist in TESTING.md.
"""

import os
import sys
import json
import tempfile
import time
import copy
import traceback


# Colorized output
class C:
    GREEN = "\033[92m"
    RED = "\033[91m"
    YELLOW = "\033[93m"
    BLUE = "\033[94m"
    BOLD = "\033[1m"
    DIM = "\033[2m"
    RESET = "\033[0m"


PASS = 0
FAIL = 0
FAILURES = []


def test(name):
    """Decorator that registers a test function."""
    def decorator(fn):
        def wrapped():
            global PASS, FAIL
            start = time.time()
            try:
                fn()
                elapsed = time.time() - start
                print(f"  {C.GREEN}✓{C.RESET} {name} {C.DIM}({elapsed:.2f}s){C.RESET}")
                PASS += 1
            except AssertionError as e:
                elapsed = time.time() - start
                print(f"  {C.RED}✗{C.RESET} {name} {C.DIM}({elapsed:.2f}s){C.RESET}")
                print(f"    {C.RED}{e}{C.RESET}")
                FAIL += 1
                FAILURES.append((name, str(e), None))
            except Exception as e:
                elapsed = time.time() - start
                print(f"  {C.RED}✗{C.RESET} {name} {C.DIM}({elapsed:.2f}s){C.RESET}")
                tb = traceback.format_exc()
                print(f"    {C.RED}{type(e).__name__}: {e}{C.RESET}")
                FAIL += 1
                FAILURES.append((name, str(e), tb))
        return wrapped
    return decorator


def section(label):
    print()
    print(f"{C.BOLD}{C.BLUE}── {label} ──{C.RESET}")


# ============================================================================
# Tests
# ============================================================================

@test("All modules import cleanly")
def test_imports():
    import simulation.engine
    import simulation.world
    import simulation.merchant
    import simulation.town
    import simulation.sweep
    import simulation.metrics
    import simulation.demographics
    import data.config
    import data.exporter


@test("Default config has required fields")
def test_default_config():
    from data.config import DEFAULT_CONFIG
    required = [
        "num_elites", "num_middle", "num_poor",
        "elite_starting_wealth", "middle_starting_wealth", "poor_starting_wealth",
        "trust_max", "trust_increment", "market_pull",
        "simulation_days", "num_runs",
    ]
    for key in required:
        assert key in DEFAULT_CONFIG, f"Missing key in DEFAULT_CONFIG: {key}"


@test("Single simulation runs and produces merchants")
def test_single_sim():
    from simulation.engine import run_simulation
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 100
    result = run_simulation(cfg)
    assert "merchants" in result, "Result missing merchants"
    assert len(result["merchants"]) > 0, "No merchants in result"
    m = result["merchants"][0]
    assert hasattr(m, "wealth"), "Merchant missing wealth attribute"
    assert hasattr(m, "social_class"), "Merchant missing social_class"
    assert hasattr(m, "history"), "Merchant missing history"
    assert hasattr(m, "trusted_partners"), "Merchant missing trusted_partners"


@test("Reproducibility — same seed gives same result")
def test_reproducibility():
    from simulation.engine import run_simulation
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 200
    r1 = run_simulation(copy.deepcopy(cfg))
    r2 = run_simulation(copy.deepcopy(cfg))
    final1 = [m.wealth for m in r1["merchants"]]
    final2 = [m.wealth for m in r2["merchants"]]
    assert final1 == final2, f"Same seed produced different results: {final1[:3]} vs {final2[:3]}"


@test("Different seeds give different results")
def test_seed_variation():
    from simulation.engine import run_simulation
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["simulation_days"] = 200
    cfg["seed"] = 1
    r1 = run_simulation(copy.deepcopy(cfg))
    cfg["seed"] = 2
    r2 = run_simulation(copy.deepcopy(cfg))
    final1 = [m.wealth for m in r1["merchants"]]
    final2 = [m.wealth for m in r2["merchants"]]
    assert final1 != final2, "Different seeds should give different results"


@test("Multiple runs aggregation")
def test_multiple_runs():
    from simulation.engine import run_multiple
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 100
    results = run_multiple(cfg, 3)
    assert len(results) == 3, f"Expected 3 results, got {len(results)}"
    for r in results:
        assert "merchants" in r
        assert "config" in r


@test("Gini coefficient is computed correctly")
def test_gini():
    from simulation.metrics import gini_coefficient
    assert abs(gini_coefficient([10, 10, 10, 10])) < 0.001, "Equality should give Gini~0"
    g = gini_coefficient([0, 0, 0, 100])
    assert 0.7 < g < 0.8, f"Max inequality (n=4) should give Gini~0.75, got {g}"
    assert gini_coefficient([]) == 0.0
    assert gini_coefficient([5]) == 0.0


@test("Top-N share is computed correctly")
def test_top_share():
    from simulation.metrics import top_share
    assert abs(top_share([10, 10, 10, 10], 0.25) - 0.25) < 0.001
    assert abs(top_share([0, 0, 0, 100], 0.25) - 1.0) < 0.001


@test("Summary metrics produces all expected keys")
def test_summary_metrics():
    from simulation.engine import run_multiple
    from simulation.metrics import summary_metrics
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 100
    results = run_multiple(cfg, 2)
    m = summary_metrics(results)
    for key in ["gini", "top_10_share", "p90_p10_ratio", "gini_by_class"]:
        assert key in m, f"summary_metrics missing key: {key}"
    assert 0 <= m["gini"] <= 1, f"Gini out of range: {m['gini']}"


@test("1D parameter sweep runs and aggregates")
def test_1d_sweep():
    from simulation.sweep import run_sweep, linspace
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 50
    result = run_sweep(cfg, "trust_max", linspace(0, 0.3, 3), runs_per_value=2)
    assert "results_by_value" in result
    assert len(result["results_by_value"]) == 3
    for v, stats in result["results_by_value"].items():
        assert "elite" in stats
        assert "bankruptcy_rate" in stats["elite"]


@test("2D parameter sweep runs and produces grid")
def test_2d_sweep():
    from simulation.sweep import run_sweep_2d, linspace
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 50
    result = run_sweep_2d(
        cfg,
        "trust_max", linspace(0, 0.2, 3),
        "market_pull", linspace(0.3, 0.9, 2),
        runs_per_cell=2,
    )
    assert "cells" in result
    assert len(result["cells"]) == 2, f"Expected 2 Y rows, got {len(result['cells'])}"
    assert len(result["cells"][0]) == 3, f"Expected 3 X cols"
    # Each cell should be an aggregated stats dict
    for row in result["cells"]:
        for cell in row:
            assert cell is not None
            assert "elite" in cell


@test("All 5 presets load and have valid config")
def test_presets():
    from data import exporter
    from data.config import validate_config
    presets_dir = exporter.get_presets_dir()
    if not os.path.exists(presets_dir):
        raise AssertionError(f"Presets dir not found: {presets_dir}")
    files = sorted(f for f in os.listdir(presets_dir) if f.endswith(".json"))
    assert len(files) >= 5, f"Expected ≥5 presets, found {len(files)}"
    for f in files:
        path = os.path.join(presets_dir, f)
        cfg = exporter.load_config(path)
        problems = validate_config(cfg)
        errors = [m for sev, m in problems if sev == "error"]
        assert not errors, f"Preset {f} has errors: {errors}"


@test("Save/load config round-trip preserves values")
def test_config_roundtrip():
    from data import exporter
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 123
    cfg["trust_max"] = 0.15
    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
        path = f.name
    try:
        exporter.save_config(cfg, path)
        loaded = exporter.load_config(path)
        assert loaded["seed"] == 123
        assert abs(loaded["trust_max"] - 0.15) < 0.0001
    finally:
        os.unlink(path)


@test("Summary export and reload for comparison")
def test_summary_roundtrip():
    from simulation.engine import run_simulation
    from data import exporter
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 50
    result = run_simulation(cfg)
    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
        path = f.name
    try:
        exporter.export_summary_json(result, path)
        # Load it back for the comparison view
        loaded_list = exporter.load_summary_for_comparison(path)
        assert len(loaded_list) == 1
        loaded = loaded_list[0]
        assert "merchants" in loaded
        assert "config" in loaded
        # Final wealth should round-trip
        original_final = sorted(m.wealth for m in result["merchants"])
        loaded_final = sorted(m.wealth for m in loaded["merchants"])
        assert original_final == loaded_final
    finally:
        os.unlink(path)


@test("Generations and inheritance produce next-generation merchants")
def test_generations():
    from simulation.engine import run_simulation
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 200
    cfg["generations_enabled"] = True
    cfg["inheritance_fraction"] = 0.7
    result = run_simulation(cfg)
    # At least one merchant should have a non-1 generation OR a parent
    gens = [getattr(m, "generation", 1) for m in result["merchants"]]
    assert max(gens) >= 1, "Generation tracking missing"


@test("Custom layout grid validates and runs")
def test_custom_layout():
    from simulation.engine import run_simulation
    from simulation.world import RICH_NEIGHBORHOOD, POOR_NEIGHBORHOOD, MARKET, EMPTY
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 50
    # Build a tiny custom layout
    grid_size = cfg.get("grid_size", 12)
    custom = [[EMPTY for _ in range(grid_size)] for _ in range(grid_size)]
    # Place a market in the middle and a residential patch nearby
    mid = grid_size // 2
    custom[mid][mid] = MARKET
    custom[0][0] = RICH_NEIGHBORHOOD
    custom[grid_size - 1][grid_size - 1] = POOR_NEIGHBORHOOD
    cfg["custom_layout"] = custom
    result = run_simulation(cfg)
    assert "merchants" in result


@test("Imports of all UI modules (no Qt window)")
def test_ui_imports():
    # Make sure all UI modules can at least be imported without crashing.
    # We don't construct widgets here (would need QApplication).
    import importlib
    modules = [
        "ui.styles_v2",
        "ui.design_system",
        "ui.help_content",
        "ui.sweep_2d_dialog",
        "ui.worker",
        "ui.v2.heatmap_view",
        "ui.v2.trust_network_view",
        "ui.v2.welcome_dialog",
        "ui.v2.comparison_view",
        "ui.v2.results_sidebar",
        "ui.v2.chart_canvas",
        "ui.v2.parameters_panel",
        "ui.v2.single_run_view",
        "ui.v2.sweep_view",
        "ui.v2.top_nav",
        "ui.v2.main_window",
        "ui.v2.animations",
    ]
    for mod in modules:
        importlib.import_module(mod)


@test("App icon files exist at all required sizes")
def test_logo_assets():
    sizes = [16, 24, 32, 48, 64, 128, 256, 512]
    for s in sizes:
        path = f"assets/logo/portussim_mark_{s}.png"
        assert os.path.exists(path), f"Missing logo: {path}"
        path_white = f"assets/logo/portussim_mark_white_{s}.png"
        assert os.path.exists(path_white), f"Missing white logo: {path_white}"


@test("Inter font bundle exists")
def test_font_bundle():
    path = "assets/fonts/Inter-Variable.ttf"
    assert os.path.exists(path), f"Missing font: {path}"
    size = os.path.getsize(path)
    assert size > 100_000, f"Font file too small ({size} bytes), likely corrupt"


@test("Summary report builds HTML for typical run")
def test_summary_report():
    from simulation.engine import run_multiple
    from simulation.summary_report import build_summary_html
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 100
    results = run_multiple(cfg, 2)
    html = build_summary_html(results, theme="light")
    assert "<style>" in html
    assert "Interpretation" in html
    assert "Configuration" in html
    assert "Comparison to bundled findings" in html
    # Should classify into one of the trust regimes
    assert any(label in html for label in [
        "near-zero trust", "cliff zone", "moderate trust", "high trust"
    ])
    # Should mention all four findings
    assert "Finding 1" in html
    assert "Finding 2" in html
    assert "Finding 3" in html
    assert "Finding 4" in html


@test("Summary report classifies high-trust regime as elite collapse")
def test_summary_classification_high_trust():
    from simulation.engine import run_multiple
    from simulation.summary_report import build_summary_html
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 200
    cfg["trust_max"] = 0.3  # high trust
    results = run_multiple(cfg, 2)
    html = build_summary_html(results, theme="light")
    # High trust should produce elite collapse
    assert "Elite class collapse" in html or "Elite class is unstable" in html, \
        "High-trust regime should classify elite as collapsing or unstable"
    assert "high trust" in html, "Should identify high-trust regime"


@test("Historical comparison data is well-formed")
def test_historical_data():
    from simulation.historical_comparisons import (
        HISTORICAL_GINI_REFERENCES, find_gini_comparisons, COMPARISON_CAVEAT
    )
    assert len(HISTORICAL_GINI_REFERENCES) >= 8, "Should have at least 8 references"
    for ref in HISTORICAL_GINI_REFERENCES:
        assert "place" in ref
        assert "period" in ref
        assert "gini" in ref and 0 <= ref["gini"] <= 1, f"Bad Gini for {ref.get('place')}"
        assert "citation" in ref and ref["citation"], f"Missing citation for {ref.get('place')}"
        assert "measure" in ref and ref["measure"] in ("income", "wealth")
    assert len(COMPARISON_CAVEAT) > 100


@test("find_gini_comparisons returns sensible matches across regimes")
def test_gini_comparisons_match():
    from simulation.historical_comparisons import find_gini_comparisons
    low = find_gini_comparisons(0.27, top_n=3)
    assert "Sweden" in low[0][0]["place"], f"Expected Sweden as closest to 0.27, got {low[0][0]['place']}"
    mid = find_gini_comparisons(0.43, top_n=3, prefer_period_match="ancient")
    assert any("Roman Empire" in r[0]["place"] for r in mid[:2]), \
        "Roman Empire should be in top 2 matches for Gini 0.43 with ancient preference"


@test("Summary report includes historical context section")
def test_summary_includes_historical():
    from simulation.engine import run_multiple
    from simulation.summary_report import build_summary_html
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 42
    cfg["simulation_days"] = 100
    results = run_multiple(cfg, 2)
    html = build_summary_html(results, theme="light")
    assert "Historical context" in html
    assert "Scheidel" in html or "Alfani" in html or "Kron" in html, \
        "Summary should cite at least one historical source"
    assert "illustrative, not calibrated" in html


@test("Debug log collector captures entries with severity levels")
def test_debug_log():
    from ui.v2.debug_log import LOG
    LOG.clear()
    LOG.info("Test info entry", context_key=42)
    LOG.warn("Test warning")
    LOG.error("Test error")
    entries = LOG.entries()
    assert len(entries) == 3, f"Expected 3 entries, got {len(entries)}"
    assert entries[0]["level"] == "INFO"
    assert entries[1]["level"] == "WARN"
    assert entries[2]["level"] == "ERROR"
    assert entries[0]["context"]["context_key"] == 42
    LOG.clear()
    assert len(LOG.entries()) == 0


@test("Debug log handles exception with traceback")
def test_debug_log_exception():
    from ui.v2.debug_log import LOG
    LOG.clear()
    try:
        raise ValueError("intentional test exception")
    except Exception:
        LOG.exception("Caught test exception")
    entries = LOG.entries()
    assert len(entries) == 1
    assert entries[0]["level"] == "ERROR"
    assert "traceback" in entries[0]["context"]
    assert "ValueError" in entries[0]["context"]["traceback"]


@test("Animated stat card survives back-to-back updates (regression)")
def test_stat_card_back_to_back():
    """Regression test for the RuntimeError users hit when running two
    simulations in quick succession. After the first animation finished,
    its underlying C++ QVariantAnimation was deleted by Qt, but the Python
    reference remained — calling .stop() on it raised RuntimeError and
    left the UI stuck on 'Running...'."""
    # Needs a QApplication, but can run headless
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtCore import QEventLoop, QTimer
    from PySide6.QtWidgets import QApplication
    app = QApplication.instance() or QApplication([])

    from ui.v2.results_sidebar import StatCard
    card = StatCard("Test", "—", "")

    # First animated update
    card.set_value_animated(40.0,
                            formatter=lambda v: f"{v:.1f}%",
                            subtitle="2 of 5",
                            duration_ms=50)
    # Wait for animation to finish AND for DeleteWhenStopped to delete the
    # underlying C++ object
    loop = QEventLoop()
    QTimer.singleShot(300, loop.quit)
    loop.exec()

    # Second update — this used to crash with RuntimeError
    card.set_value_animated(80.0,
                            formatter=lambda v: f"{v:.1f}%",
                            subtitle="4 of 5",
                            duration_ms=50)
    # Should not have raised


@test("Inheritance fraction is now a sweepable parameter")
def test_inheritance_in_sweep():
    from simulation.sweep import SWEEPABLE_PARAMETERS
    assert "inheritance_fraction" in SWEEPABLE_PARAMETERS
    assert "middle_starting_wealth" in SWEEPABLE_PARAMETERS
    assert "poor_starting_wealth" in SWEEPABLE_PARAMETERS


@test("Sweep produces per-seed records for CSV export")
def test_sweep_per_seed_records():
    from simulation.sweep import run_sweep
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 9000
    cfg["generations_enabled"] = True
    cfg["simulation_days"] = 100
    result = run_sweep(cfg, "inheritance_fraction", [0.0, 0.5, 1.0],
                       runs_per_value=2)
    records = result["per_run_records"]
    assert len(records) == 6, f"Expected 6 records (3 values × 2 seeds), got {len(records)}"
    # Each record has the expected fields
    for r in records:
        assert "seed" in r and r["seed"] is not None
        assert "parameter_value" in r
        assert "gini" in r and 0 <= r["gini"] <= 1
        assert "elite_bk_pct" in r
        assert "middle_bk_pct" in r
        assert "poor_bk_pct" in r
    # Seeds should be unique
    seeds = [r["seed"] for r in records]
    assert len(set(seeds)) == len(seeds), "Seeds should be unique across runs"


@test("Per-seed CSV export produces valid file")
def test_per_seed_csv_export():
    from simulation.sweep import run_sweep
    from data.exporter import export_sweep_per_run_csv
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 9100
    cfg["generations_enabled"] = True
    cfg["simulation_days"] = 100
    result = run_sweep(cfg, "inheritance_fraction", [0.0, 1.0], runs_per_value=2)
    import tempfile as _t
    with _t.NamedTemporaryFile(mode="w", suffix=".csv", delete=False) as f:
        path = f.name
    try:
        export_sweep_per_run_csv(result, filename=path)
        with open(path) as f:
            content = f.read()
        # 1 header line + 4 data rows
        lines = content.strip().split("\n")
        assert len(lines) == 5, f"Expected 5 lines (header + 4 rows), got {len(lines)}"
        assert "gini" in lines[0]
        assert "seed" in lines[0]
        assert "elite_bk_pct" in lines[0]
    finally:
        os.unlink(path)


@test("Configure New Sweep button wiring (regression)")
def test_configure_sweep_wiring():
    """Three bugs once lived here:
      1. SweepDialog was called with base_config= but doesn't accept it
      2. Caller used dialog.get_sweep_config(), which doesn't exist
      3. sweep_view.display_results() called sweep_results.display_results(),
         but the panel method is display_sweep()
    Each was silently swallowed by Qt's signal-slot machinery, making
    the Configure New Sweep button appear to do nothing.
    """
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtWidgets import QApplication
    app = QApplication.instance() or QApplication([])

    # Bug 1: SweepDialog must accept being called with just (parent)
    from ui.sweep_dialog import SweepDialog
    dlg = SweepDialog(None)
    # Bug 2: it must expose parameter(), values(), runs_per_value()
    assert hasattr(dlg, "parameter") and callable(dlg.parameter)
    assert hasattr(dlg, "values") and callable(dlg.values)
    assert hasattr(dlg, "runs_per_value") and callable(dlg.runs_per_value)

    # Bug 3: sweep_view.display_results must work
    from ui.v2.sweep_view import SweepView
    sv = SweepView()
    assert hasattr(sv.sweep_results, "display_sweep"), \
        "sweep panel must expose display_sweep"


@test("Help content includes Reproducibility section about Python versions")
def test_reproducibility_help():
    from ui import help_content
    assert hasattr(help_content, "REPRODUCIBILITY"), \
        "REPRODUCIBILITY help section should exist"
    text = help_content.REPRODUCIBILITY
    assert "Python version" in text
    assert "randint" in text
    assert "random()" in text
    # Should explicitly mention that random.random is the stable one
    assert "stable" in text.lower() or "guarantee" in text.lower()


@test("Scenario save / load round-trip preserves config and metadata")
def test_scenario_round_trip():
    from data.scenario import (
        build_scenario, save_scenario, load_scenario,
        extract_config, extract_metadata,
    )
    from data.config import DEFAULT_CONFIG
    import tempfile as _t, os as _os
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 4321
    cfg["trust_max"] = 0.123
    scenario = build_scenario(
        cfg,
        name="Test scenario",
        description="A description.",
        author="Test Author",
        historical_period="Roman Imperial",
        tags=["test", "demo"],
        citation="Author (2026)",
    )
    with _t.NamedTemporaryFile(mode="w", suffix=".scenario", delete=False) as f:
        path = f.name
    try:
        save_scenario(scenario, path)
        loaded, was_scenario = load_scenario(path)
        assert was_scenario, "Should detect new format"
        cfg2 = extract_config(loaded)
        meta2 = extract_metadata(loaded)
        assert cfg2["seed"] == 4321
        assert abs(cfg2["trust_max"] - 0.123) < 1e-9
        assert meta2["name"] == "Test scenario"
        assert meta2["author"] == "Test Author"
        assert meta2["historical_period"] == "Roman Imperial"
        assert meta2["tags"] == ["test", "demo"]
        assert "python_version" in meta2
    finally:
        _os.unlink(path)


@test("Scenario loader handles legacy config files (backward compat)")
def test_scenario_legacy_compat():
    from data.scenario import load_scenario, extract_config
    from data.config import DEFAULT_CONFIG
    import tempfile as _t, os as _os, json as _j
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 9999
    with _t.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
        path = f.name
        _j.dump(cfg, f)
    try:
        loaded, was_scenario = load_scenario(path)
        assert not was_scenario, "Legacy config should not be detected as new format"
        cfg2 = extract_config(loaded)
        assert cfg2["seed"] == 9999
    finally:
        _os.unlink(path)


@test("Save scenario dialog metadata extraction")
def test_scenario_dialog_metadata():
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtWidgets import QApplication
    app = QApplication.instance() or QApplication([])
    from ui.scenario_dialog import SaveScenarioDialog
    dlg = SaveScenarioDialog()
    dlg.name_edit.setText("My Scenario")
    dlg.description_edit.setPlainText("A description.")
    dlg.author_edit.setText("Author")
    dlg.period_combo.setCurrentText("Roman Imperial")
    dlg.tags_edit.setText("a, b, c")
    meta = dlg.metadata()
    assert meta["name"] == "My Scenario"
    assert meta["description"] == "A description."
    assert meta["author"] == "Author"
    assert meta["historical_period"] == "Roman Imperial"
    assert meta["tags"] == ["a", "b", "c"]


@test("ScenarioInfoDialog accepts long descriptions without breaking layout")
def test_scenario_info_dialog():
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtWidgets import QApplication
    app = QApplication.instance() or QApplication([])
    from ui.scenario_dialog import ScenarioInfoDialog
    long_desc = "Lorem ipsum dolor sit amet. " * 50  # ~1500 chars
    dlg = ScenarioInfoDialog(
        None,
        name="Test scenario",
        description=long_desc,
        author="Author",
        historical_period="Roman Imperial",
        tags=["a", "b"],
        citation="Author (2026)",
        python_version="3.13.9",
        portussim_version="1.0",
        created="2026-06-06T14:30:00+00:00",
    )
    # The dialog should be fixed-width, NOT expand with a very long string
    assert dlg.size().width() < 800, \
        "Dialog width should be capped (was the QMessageBox bug)"
    assert dlg.size().height() < 800
    # from_metadata should work too
    dlg2 = ScenarioInfoDialog.from_metadata(None, {
        "name": "X", "description": "Y", "author": "Z",
        "historical_period": "", "tags": [], "citation": "",
        "python_version": "", "portussim_version": "", "created": "",
    })
    assert dlg2 is not None


@test("Top nav Scenario button enables/disables on demand")
def test_top_nav_scenario_button():
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtWidgets import QApplication
    app = QApplication.instance() or QApplication([])
    from ui.v2.top_nav import TopNavBar
    nav = TopNavBar()
    assert not nav.scenario_btn.isEnabled(), \
        "Scenario button should start disabled"
    nav.set_scenario_active("Test scenario name")
    assert nav.scenario_btn.isEnabled()
    assert "Test scenario name" in nav.scenario_btn.toolTip()
    nav.set_scenario_active(None)
    assert not nav.scenario_btn.isEnabled()


@test("Time-series long-format export produces tidy CSV")
def test_time_series_long_export():
    from simulation.engine import run_multiple
    from data.exporter import export_time_series_long
    from data.config import DEFAULT_CONFIG
    import tempfile as _t, os as _os
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 100
    cfg["simulation_days"] = 10
    results = run_multiple(cfg, 1)

    with _t.NamedTemporaryFile(mode="w", suffix=".csv", delete=False) as f:
        path = f.name
    try:
        export_time_series_long(results, path)
        with open(path) as f:
            lines = f.read().strip().split("\n")
        # Provenance lines start with #
        provenance = [l for l in lines if l.startswith("#")]
        data = [l for l in lines if not l.startswith("#")]
        # Header + N merchants * (days+1) rows
        n_merchants = len(results[0]["merchants"])
        expected_data_rows = 1 + n_merchants * 11  # header + each day 0..10
        assert len(provenance) >= 7, f"Need provenance header, got {len(provenance)}"
        assert len(data) == expected_data_rows, \
            f"Expected {expected_data_rows} data rows, got {len(data)}"
        # Header check
        header = data[0]
        for col in ("run", "day", "merchant_id", "social_class", "wealth"):
            assert col in header
        # Python version recorded
        assert any("python_version" in p for p in provenance)
    finally:
        _os.unlink(path)


@test("Time-series wide-format export has one column per merchant")
def test_time_series_wide_export():
    from simulation.engine import run_multiple
    from data.exporter import export_time_series_wide
    from data.config import DEFAULT_CONFIG
    import tempfile as _t, os as _os
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 100
    cfg["simulation_days"] = 5
    results = run_multiple(cfg, 1)

    with _t.NamedTemporaryFile(mode="w", suffix=".csv", delete=False) as f:
        path = f.name
    try:
        export_time_series_wide(results, path)
        with open(path) as f:
            lines = f.read().strip().split("\n")
        data = [l for l in lines if not l.startswith("#")]
        header_cols = data[0].split(",")
        n_merchants = len(results[0]["merchants"])
        # run + day + N merchants
        assert len(header_cols) == n_merchants + 2, \
            f"Wide format header should have run + day + {n_merchants} merchants"
        # Each merchant name in the header
        names = {m.name for m in results[0]["merchants"]}
        for name in names:
            assert name in header_cols, f"Merchant {name} missing from header"
    finally:
        _os.unlink(path)


@test("Events export captures trade events")
def test_events_export():
    from simulation.engine import run_multiple
    from data.exporter import export_events
    from data.config import DEFAULT_CONFIG
    import tempfile as _t, os as _os
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 100
    cfg["simulation_days"] = 50  # need enough days for trades to happen
    results = run_multiple(cfg, 1)

    with _t.NamedTemporaryFile(mode="w", suffix=".csv", delete=False) as f:
        path = f.name
    try:
        export_events(results, path)
        with open(path) as f:
            lines = f.read().strip().split("\n")
        data = [l for l in lines if not l.startswith("#")]
        # At minimum should have header + some trade events
        assert len(data) > 1, "Should have at least one trade event"
        header_cols = data[0].split(",")
        for col in ("run", "event_type", "day", "source", "target"):
            assert col in header_cols, f"Missing column: {col}"
    finally:
        _os.unlink(path)


@test("Sweep file save/load round trip preserves all key data")
def test_sweep_file_round_trip():
    from simulation.sweep import run_sweep
    from data.sweep_file import build_sweep_file, save_sweep_file, load_sweep_file
    from data.config import DEFAULT_CONFIG
    import tempfile as _t, os as _os
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 100
    cfg["simulation_days"] = 50
    sweep = run_sweep(cfg, "trust_max", [0.05, 0.1], runs_per_value=3)
    sweep_file = build_sweep_file(sweep, cfg, name="Test", author="Tester")

    with _t.NamedTemporaryFile(mode="w", suffix=".sweep", delete=False) as f:
        path = f.name
    try:
        save_sweep_file(sweep_file, path)
        loaded = load_sweep_file(path)
        assert loaded["parameter"] == "trust_max"
        assert loaded["values"] == [0.05, 0.1]
        assert len(loaded["per_run_records"]) == 6
        assert loaded["metadata"]["name"] == "Test"
        assert loaded["metadata"]["author"] == "Tester"
        assert "python_version" in loaded["metadata"]
        # base_config preserved
        assert loaded["base_config"]["seed"] == 100
    finally:
        _os.unlink(path)


@test("Sweep comparison detects significant differences")
def test_sweep_comparison():
    from simulation.sweep import run_sweep
    from data.sweep_file import build_sweep_file
    from simulation.sweep_compare import compare_sweeps
    from data.config import DEFAULT_CONFIG
    cfg_a = copy.deepcopy(DEFAULT_CONFIG)
    cfg_a["seed"] = 200
    cfg_a["simulation_days"] = 100
    sweep_a = run_sweep(cfg_a, "trust_max", [0.05, 0.15], runs_per_value=5)
    file_a = build_sweep_file(sweep_a, cfg_a, name="A")
    # B is a copy of A with a different starting seed — should give slightly different
    cfg_b = copy.deepcopy(cfg_a)
    cfg_b["seed"] = 500
    sweep_b = run_sweep(cfg_b, "trust_max", [0.05, 0.15], runs_per_value=5)
    file_b = build_sweep_file(sweep_b, cfg_b, name="B")

    result = compare_sweeps(file_a, file_b, metric_key="gini")
    assert result["comparable"], "Same parameter should be comparable"
    assert result["parameter"] == "trust_max"
    assert len(result["rows"]) == 2  # two shared values
    for row in result["rows"]:
        assert row["a_n"] == 5
        assert row["b_n"] == 5
        assert row["t"] is not None
        assert row["p"] is not None


@test("Sweep comparison flags non-comparable sweeps")
def test_sweep_comparison_incompatible():
    from simulation.sweep import run_sweep
    from data.sweep_file import build_sweep_file
    from simulation.sweep_compare import compare_sweeps
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 100
    cfg["simulation_days"] = 50
    sweep_a = run_sweep(cfg, "trust_max", [0.05, 0.1], runs_per_value=2)
    sweep_b = run_sweep(cfg, "market_pull", [0.5, 0.7], runs_per_value=2)
    file_a = build_sweep_file(sweep_a, cfg, name="A")
    file_b = build_sweep_file(sweep_b, cfg, name="B")
    result = compare_sweeps(file_a, file_b)
    assert not result["comparable"]
    assert "different parameters" in result["verdict"].lower()


@test("Compare view: table allows selection (regression — was NoSelection)")
def test_compare_view_table_selectable():
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtWidgets import QApplication, QAbstractItemView
    app = QApplication.instance() or QApplication([])
    from ui.v2.sweep_compare_view import SweepCompareView
    v = SweepCompareView()
    mode = v.table.selectionMode()
    assert mode != QAbstractItemView.SelectionMode.NoSelection, \
        "Table must allow selection so users can copy"


@test("Compare view: slots accept apply_theme without errors")
def test_compare_view_slot_theme():
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtWidgets import QApplication
    app = QApplication.instance() or QApplication([])
    from ui.v2.sweep_compare_view import SweepSlot
    slot = SweepSlot("a", "#0969DA", theme_name="light")
    # Switching themes shouldn't crash and should change stylesheets
    sheet_before = slot.title_label.styleSheet()
    slot.apply_theme("dark")
    sheet_after = slot.title_label.styleSheet()
    assert sheet_before != sheet_after, "Title label stylesheet must change with theme"


@test("Compare view table copy produces tab-separated text")
def test_compare_view_table_copy():
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtWidgets import QApplication, QTableWidgetItem
    app = QApplication.instance() or QApplication([])
    from ui.v2.sweep_compare_view import SweepCompareView
    v = SweepCompareView()
    v.table.setRowCount(2)
    v.table.setItem(0, 0, QTableWidgetItem("0.05"))
    v.table.setItem(0, 1, QTableWidgetItem("0.371"))
    v.table.setItem(0, 2, QTableWidgetItem("0.447"))
    v.table.setItem(0, 3, QTableWidgetItem("0.001 *"))
    v.table.selectRow(0)
    v._copy_selection()
    clip = app.clipboard().text()
    assert "\t" in clip
    assert "0.05" in clip
    assert "0.001 *" in clip


@test("Hypothesis test: clear-cut SUPPORTED case")
def test_hypothesis_supported():
    from simulation.hypothesis import Hypothesis, run_test, DIRECTION_GT
    h = Hypothesis(
        name="H1",
        condition_a_label="A", condition_b_label="B",
        parameter="x", parameter_value=0.1,
        samples_a=[0.85, 0.86, 0.87, 0.88, 0.89, 0.85, 0.86, 0.87, 0.88, 0.89],
        samples_b=[0.45, 0.46, 0.47, 0.48, 0.49, 0.45, 0.46, 0.47, 0.48, 0.49],
        direction=DIRECTION_GT, alpha=0.05,
    )
    r = run_test(h)
    assert r["supported"], f"Expected SUPPORTED but got {r['verdict']}"
    assert r["p"] < 0.001  # huge effect, should be tiny p
    assert abs(r["cohens_d"]) > 5  # very large effect


@test("Hypothesis test: NOT SUPPORTED when direction is wrong")
def test_hypothesis_wrong_direction():
    from simulation.hypothesis import Hypothesis, run_test, DIRECTION_GT
    # Predicted A > B but actually A < B
    h = Hypothesis(
        samples_a=[0.4, 0.42, 0.41, 0.43, 0.44],
        samples_b=[0.5, 0.52, 0.51, 0.53, 0.54],
        direction=DIRECTION_GT, alpha=0.05,
    )
    r = run_test(h)
    assert not r["supported"]
    assert "opposite" in r["verdict_detail"].lower()


@test("Hypothesis test: two-tailed direction")
def test_hypothesis_two_tailed():
    from simulation.hypothesis import Hypothesis, run_test, DIRECTION_NEQ
    h = Hypothesis(
        samples_a=[0.4, 0.42, 0.41, 0.43, 0.44, 0.42, 0.41, 0.43],
        samples_b=[0.5, 0.52, 0.51, 0.53, 0.54, 0.52, 0.51, 0.53],
        direction=DIRECTION_NEQ, alpha=0.05,
    )
    r = run_test(h)
    assert r["supported"], "Two-tailed test should support a clear difference"
    assert "two-tailed" in r["test_label"]


@test("Hypothesis set: round-trip preserves results")
def test_hypothesis_set_round_trip():
    from simulation.hypothesis import Hypothesis, run_test, DIRECTION_LT
    from data.hypothesis_set import save_hypothesis_set, load_hypothesis_set
    import tempfile as _t, os as _os
    h = Hypothesis(
        name="Test",
        samples_a=[0.1, 0.2, 0.3, 0.4, 0.5],
        samples_b=[0.6, 0.7, 0.8, 0.9, 1.0],
        direction=DIRECTION_LT, alpha=0.05,
    )
    run_test(h)
    with _t.NamedTemporaryFile(mode="w", suffix=".hypotheses", delete=False) as f:
        path = f.name
    try:
        save_hypothesis_set([h], path, set_name="Test set")
        loaded, meta = load_hypothesis_set(path)
        assert len(loaded) == 1
        assert loaded[0].name == "Test"
        assert loaded[0].result is not None
        assert loaded[0].result["supported"] == h.result["supported"]
        assert meta["name"] == "Test set"
        assert "python_version" in meta
    finally:
        _os.unlink(path)


@test("Pre-registration text includes all key components")
def test_preregistration_text():
    from simulation.hypothesis import (
        Hypothesis, run_test, format_preregistration, DIRECTION_GT,
    )
    h = Hypothesis(
        name="H1: Inheritance reduces Gini",
        condition_a_label="Baseline",
        condition_b_label="Treatment",
        parameter="trust_max", parameter_value=0.10,
        metric_label="Gini coefficient",
        samples_a=[0.8, 0.85, 0.82, 0.83, 0.84, 0.85, 0.82, 0.83],
        samples_b=[0.4, 0.45, 0.42, 0.43, 0.44, 0.45, 0.42, 0.43],
        direction=DIRECTION_GT, alpha=0.05,
    )
    run_test(h)
    text = format_preregistration(h)
    # Must contain the essentials
    assert "PRE-REGISTERED HYPOTHESIS" in text
    assert "H1: Inheritance reduces Gini" in text
    assert "GREATER THAN" in text
    assert "α = 0.05" in text
    assert "Welch's t-test" in text
    assert "Mean A:" in text
    assert "Mean B:" in text
    assert "Cohen's d" in text
    assert "VERDICT" in text


@test("Hypothesis view: form is interactive after +New (regression)")
def test_hypothesis_view_form_interactive():
    """Previously the form started disabled and never got re-enabled after
    clicking +New, so users couldn't fill anything in."""
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtWidgets import QApplication
    app = QApplication.instance() or QApplication([])
    from ui.v2.hypothesis_test_view import HypothesisTestView
    v = HypothesisTestView()
    v._on_new()
    assert v.name_edit.isEnabled(), "name_edit must be enabled after +New"
    assert v.sweep_a_btn.isEnabled(), "sweep_a_btn must be enabled after +New"
    assert v.run_btn.isEnabled(), "run_btn must be enabled after +New"


@test("Hypothesis view: theme switch updates label colors (regression)")
def test_hypothesis_view_theme_switch():
    """Previously labels kept the first-applied theme's color forever
    because apply_theme skipped labels that already had a color."""
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtWidgets import QApplication, QLabel
    app = QApplication.instance() or QApplication([])
    from ui.v2.hypothesis_test_view import HypothesisTestView
    from ui.design_system import palette
    v = HypothesisTestView(theme_name="light")
    light_color = palette("light")["text_primary"]
    # Find a known label
    found = None
    for lbl in v.findChildren(QLabel):
        if lbl.text() == "Hypothesis definition":
            found = lbl
            break
    assert found is not None
    assert light_color.lower() in found.styleSheet().lower()
    # Switch to dark
    v.apply_theme("dark")
    dark_color = palette("dark")["text_primary"]
    assert dark_color.lower() in found.styleSheet().lower(), (
        f"After theme switch to dark, label should have dark color "
        f"{dark_color}, got stylesheet {found.styleSheet()!r}"
    )
    assert light_color.lower() not in found.styleSheet().lower(), (
        "Old light color should be stripped"
    )


@test("Holm-Bonferroni correction matches hand-computed example")
def test_holm_bonferroni():
    from simulation.hypothesis import holm_bonferroni
    # p = [0.01, 0.04, 0.03, 0.005] -> adjusted [0.03, 0.06, 0.06, 0.02]
    adj = holm_bonferroni([0.01, 0.04, 0.03, 0.005])
    assert abs(adj[0] - 0.03) < 1e-9
    assert abs(adj[1] - 0.06) < 1e-9
    assert abs(adj[2] - 0.06) < 1e-9
    assert abs(adj[3] - 0.02) < 1e-9
    # None entries pass through
    adj2 = holm_bonferroni([0.01, None, 0.005])
    assert adj2[1] is None
    assert abs(adj2[0] - 0.01) < 1e-9 and abs(adj2[2] - 0.01) < 1e-9


@test("Minimum detectable effect approximation")
def test_min_detectable_effect():
    from simulation.hypothesis import min_detectable_effect
    # n=5 vs 5, one-tailed 0.05: (1.6449+0.8416)*sqrt(0.4) ≈ 1.573
    mde = min_detectable_effect(5, 5, 0.05, two_tailed=False)
    assert abs(mde - 1.5727) < 0.001
    # More samples -> smaller MDE
    assert min_detectable_effect(50, 50, 0.05) < mde
    # Two-tailed is harder than one-tailed
    assert min_detectable_effect(5, 5, 0.05, two_tailed=True) > mde
    # Degenerate
    assert min_detectable_effect(1, 5) is None


@test("Pre-registration block includes correction and power info")
def test_prereg_with_correction():
    from simulation.hypothesis import (
        Hypothesis, run_test, format_preregistration, DIRECTION_GT,
    )
    h = Hypothesis(
        name="H1", samples_a=[0.8, 0.82, 0.81, 0.83, 0.84],
        samples_b=[0.4, 0.42, 0.41, 0.43, 0.44],
        direction=DIRECTION_GT, alpha=0.05,
    )
    run_test(h)
    text = format_preregistration(h, n_comparisons=3, adjusted_p=0.012,
                                    mde=1.57)
    assert "MULTIPLE COMPARISONS" in text
    assert "one of 3 tested" in text
    assert "Holm-Bonferroni adjusted p = 0.012" in text
    assert "minimum detectable effect" in text


@test("RNG refactor: bit-identical to legacy global-seed behavior (golden)")
def test_rng_golden_match():
    """The dedicated random.Random instance must produce the exact
    sequence the old random.seed(global) approach produced, so all
    previously recorded experimental results remain reproducible."""
    from simulation.engine import run_simulation
    from simulation.metrics import gini_coefficient
    from data.config import DEFAULT_CONFIG
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 777
    cfg["simulation_days"] = 300
    cfg["generations_enabled"] = True
    cfg["inheritance_fraction"] = 0.5
    r = run_simulation(cfg)
    gini = round(gini_coefficient([m.wealth for m in r["merchants"]]), 10)
    assert gini == 0.3322190239, f"Golden gini mismatch: {gini}"
    assert sorted(m.wealth for m in r["merchants"]) == [
        0, 0, 0, 147, 162, 193, 247, 373, 435, 450,
        463, 470, 482, 498, 528, 574, 577, 586, 633, 825,
    ]
    assert r["total_bankruptcies"] == 3
    assert r["max_generation"] == 2


@test("RNG refactor: immune to global random module pollution")
def test_rng_isolation():
    from simulation.engine import run_simulation
    from data.config import DEFAULT_CONFIG
    import random as _glob
    cfg = copy.deepcopy(DEFAULT_CONFIG)
    cfg["seed"] = 1234
    cfg["simulation_days"] = 100
    r1 = run_simulation(cfg)
    # Pollute the global random state between runs
    _glob.seed(999)
    for _ in range(100):
        _glob.random()
    r2 = run_simulation(cfg)
    w1 = sorted(m.wealth for m in r1["merchants"])
    w2 = sorted(m.wealth for m in r2["merchants"])
    assert w1 == w2, "Global random pollution must not affect simulation"


@test("Empirical: CSV parsing is liberal and reports skips")
def test_empirical_parse():
    from data.empirical import parse_evidence_csv
    import tempfile as _t, os as _os
    with _t.NamedTemporaryFile(mode="w", suffix=".csv", delete=False) as f:
        f.write("# comment\narea,site\n12.5,A\njunk,B\n30.2,C\n-5,D\n44.0,E\n")
        p = f.name
    try:
        values, skipped, label = parse_evidence_csv(p)
        assert values == [12.5, 30.2, 44.0]
        assert skipped == 2  # junk + non-positive
        assert label == "area"
    finally:
        _os.unlink(p)


@test("Empirical: natural breaks find the gaps in trimodal data")
def test_empirical_natural_breaks():
    from data.empirical import natural_breaks_3, classify
    data = ([50 + i for i in range(30)]        # poor: 50-79
            + [200 + i for i in range(20)]      # middle: 200-219
            + [600 + i * 10 for i in range(8)])  # elite: 600-670
    b1, b2 = natural_breaks_3(data)
    assert 80 <= b1 <= 200, f"b1={b1} should fall in the first gap"
    assert 220 <= b2 <= 600, f"b2={b2} should fall in the second gap"
    poor, middle, elite = classify(data, b1, b2)
    assert len(poor) == 30 and len(middle) == 20 and len(elite) == 8


@test("Empirical: derivation emits correct config keys and ratios")
def test_empirical_derive():
    from data.empirical import natural_breaks_3, derive_parameters
    data = [50.0] * 30 + [200.0] * 20 + [600.0] * 8
    # Perturb so values aren't identical within class (variance > 0 not
    # required, but break search needs distinct values overall)
    data = [v + (i % 7) for i, v in enumerate(data)]
    b1, b2 = natural_breaks_3(data)
    partial, summary = derive_parameters(data, b1, b2, total_population=20)
    # Exact config key names — a mismatch here silently no-ops set_config
    for key in ("num_poor", "num_middle", "num_elites",
                 "poor_starting_wealth", "middle_starting_wealth",
                 "elite_starting_wealth"):
        assert key in partial, f"Missing config key {key}"
    assert sum(partial[k] for k in ("num_poor", "num_middle",
                                      "num_elites")) == 20
    assert partial["poor_starting_wealth"] == 50  # anchored
    # Ratios preserved within rounding: 200/50=4x, 600/50=12x (±jitter)
    assert 3.5 <= partial["middle_starting_wealth"] / 50 <= 4.5
    assert 10.5 <= partial["elite_starting_wealth"] / 50 <= 13.5
    assert 0 < summary["empirical_gini"] < 1


@test("Empirical: dialog end-to-end with the bundled example")
def test_empirical_dialog():
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtWidgets import QApplication
    app = QApplication.instance() or QApplication([])
    from ui.empirical_dialog import ImportEvidenceDialog
    from data.empirical import parse_evidence_csv
    values, _, label = parse_evidence_csv(
        "examples/example_house_areas_synthetic.csv")
    dlg = ImportEvidenceDialog(theme_name="light")
    dlg.load_values(values, label=label, filename="example.csv")
    assert dlg.apply_btn.isEnabled()
    dlg._on_apply()
    assert dlg.partial_config["num_poor"] >= 1
    assert dlg.anchor_metadata["method"] == "natural"
    assert dlg.anchor_metadata["empirical_gini"] > 0
    # Scenario round trip with anchor
    from data.scenario import build_scenario, save_scenario, load_scenario
    import tempfile as _t
    sc = build_scenario({"seed": 1}, name="T",
                          empirical_anchor=dlg.anchor_metadata)
    with _t.NamedTemporaryFile(mode="w", suffix=".scenario",
                                 delete=False) as f:
        p = f.name
    try:
        save_scenario(sc, p)
        loaded, _ = load_scenario(p)
        assert loaded["scenario"]["empirical_anchor"]["n_households"] == 152
    finally:
        _os.unlink(p)


@test("Validation banner compares simulated vs empirical Gini")
def test_validation_banner():
    import os as _os
    _os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtWidgets import QApplication
    app = QApplication.instance() or QApplication([])
    from ui.v2.results_sidebar import ResultsSidebar
    sb = ResultsSidebar()
    anchor = {"source_file": "ev.csv", "empirical_gini": 0.50}
    sb.set_validation_target(anchor)
    sb._update_validation(0.53)
    assert "gap +0.030" in sb.validation_label.text()
    assert "close match" in sb.validation_label.text()
    sb._update_validation(0.62)
    assert "large gap" in sb.validation_label.text()
    sb.set_validation_target(None)
    assert not sb.validation_label.isVisible()


# ============================================================================
# Run all tests
# ============================================================================

def main():
    print(f"{C.BOLD}PortusSIM self-test{C.RESET}")
    print(f"{C.DIM}{os.getcwd()}{C.RESET}")

    section("Core simulation")
    test_imports()
    test_default_config()
    test_single_sim()
    test_reproducibility()
    test_seed_variation()
    test_multiple_runs()

    section("Metrics")
    test_gini()
    test_top_share()
    test_summary_metrics()

    section("Summary report")
    test_summary_report()
    test_summary_classification_high_trust()

    section("Historical comparison")
    test_historical_data()
    test_gini_comparisons_match()
    test_summary_includes_historical()

    section("Debug log")
    test_debug_log()
    test_debug_log_exception()

    section("Regressions")
    test_stat_card_back_to_back()

    section("Sweep enhancements")
    test_inheritance_in_sweep()
    test_sweep_per_seed_records()
    test_per_seed_csv_export()
    test_configure_sweep_wiring()

    section("Documentation")
    test_reproducibility_help()

    section("Scenarios")
    test_scenario_round_trip()
    test_scenario_legacy_compat()
    test_scenario_dialog_metadata()
    test_scenario_info_dialog()
    test_top_nav_scenario_button()

    section("Time-series export")
    test_time_series_long_export()
    test_time_series_wide_export()
    test_events_export()

    section("Sweep comparison")
    test_sweep_file_round_trip()
    test_sweep_comparison()
    test_sweep_comparison_incompatible()
    test_compare_view_table_selectable()
    test_compare_view_slot_theme()
    test_compare_view_table_copy()

    section("Hypothesis testing")
    test_hypothesis_supported()
    test_hypothesis_wrong_direction()
    test_hypothesis_two_tailed()
    test_hypothesis_set_round_trip()
    test_preregistration_text()
    test_hypothesis_view_form_interactive()
    test_hypothesis_view_theme_switch()
    test_holm_bonferroni()
    test_min_detectable_effect()
    test_prereg_with_correction()

    section("RNG architecture")
    test_rng_golden_match()
    test_rng_isolation()

    section("Empirical anchoring")
    test_empirical_parse()
    test_empirical_natural_breaks()
    test_empirical_derive()
    test_empirical_dialog()
    test_validation_banner()

    section("Parameter sweeps")
    test_1d_sweep()
    test_2d_sweep()

    section("Persistence and I/O")
    test_presets()
    test_config_roundtrip()
    test_summary_roundtrip()

    section("Advanced features")
    test_generations()
    test_custom_layout()

    section("UI module imports")
    test_ui_imports()

    section("Assets")
    test_logo_assets()
    test_font_bundle()

    print()
    total = PASS + FAIL
    if FAIL == 0:
        print(f"{C.GREEN}{C.BOLD}All {total} tests passed.{C.RESET}")
        return 0
    else:
        print(f"{C.RED}{C.BOLD}{FAIL} of {total} tests failed.{C.RESET}")
        print()
        print(f"{C.BOLD}Failures:{C.RESET}")
        for name, msg, tb in FAILURES:
            print(f"  {C.RED}✗{C.RESET} {name}: {msg}")
            if tb:
                print(f"{C.DIM}{tb}{C.RESET}")
        return 1


if __name__ == "__main__":
    sys.exit(main())