From 17ae041792ace205ab2690086b39023911750685 Mon Sep 17 00:00:00 2001 From: Hosam-Eldin Mostafa Date: Mon, 20 Oct 2025 20:21:05 +0200 Subject: [PATCH] ECU framework: docs, reporting plugin (HTML metadata + requirements JSON + CI summary), .gitignore updates --- .gitignore | 12 + README.md | 211 +- TESTING_FRAMEWORK_GUIDE.md | 315 ++ config/babylin.example.yaml | 11 + config/examples.yaml | 50 + config/test_config.yaml | 7 + conftest_plugin.py | 261 ++ docs/01_run_sequence.md | 119 + docs/02_configuration_resolution.md | 81 + docs/03_reporting_and_metadata.md | 87 + docs/04_lin_interface_call_flow.md | 58 + docs/05_architecture_overview.md | 66 + docs/06_requirement_traceability.md | 60 + docs/07_flash_sequence.md | 57 + docs/08_babylin_internals.md | 102 + docs/09_raspberry_pi_deployment.md | 144 + docs/10_build_custom_image.md | 80 + docs/11_conftest_plugin_overview.md | 90 + docs/12_using_the_framework.md | 172 + docs/13_unit_testing_guide.md | 125 + docs/DEVELOPER_COMMIT_GUIDE.md | 71 + docs/README.md | 23 + ecu_framework/__init__.py | 6 + ecu_framework/config.py | 153 + ecu_framework/flashing/__init__.py | 3 + ecu_framework/flashing/hex_flasher.py | 25 + ecu_framework/lin/__init__.py | 8 + ecu_framework/lin/babylin.py | 220 ++ ecu_framework/lin/base.py | 60 + ecu_framework/lin/mock.py | 73 + pytest.ini | 28 + requirements.txt | 16 + scripts/99-babylin.rules | 5 + scripts/ecu-tests.service | 17 + scripts/ecu-tests.timer | 10 + scripts/pi_install.sh | 63 + scripts/run_tests.sh | 6 + scripts/run_two_reports.ps1 | 29 + tests/conftest.py | 64 + .../plugin/test_conftest_plugin_artifacts.py | 61 + tests/test_babylin_hardware_schedule_smoke.py | 45 + tests/test_babylin_hardware_smoke.py | 33 + tests/test_babylin_wrapper_mock.py | 132 + tests/test_hardware_placeholder.py | 19 + tests/test_smoke_mock.py | 171 + tests/unit/test_babylin_adapter_mocked.py | 22 + tests/unit/test_config_loader.py | 34 + tests/unit/test_hex_flasher.py | 30 + tests/unit/test_linframe.py | 21 + vendor/BLCInterfaceExample.py | 326 ++ vendor/BabyLIN library/BabyLINDLL.chm | Bin 0 -> 1289115 bytes .../Linux_PC/include/BabyLIN.h | 1015 +++++ .../Linux_PC/include/BabyLINCAN.h | 2351 ++++++++++++ .../Linux_PC/include/BabyLINCANSDF.h | 88 + .../Linux_PC/include/BabyLINCAN_nostruct.h | 692 ++++ .../Linux_PC/include/BabyLINCAN_types.h | 859 +++++ .../Linux_PC/include/BabyLINReturncodes.h | 309 ++ .../Linux_PC/include/BabyLINSDF.h | 92 + .../Linux_PC/include/BabyLIN_UnifiedAccess.h | 342 ++ vendor/BabyLIN library/Linux_PC/include/SDF.h | 120 + .../Linux_RaspberryPi/include/BabyLIN.h | 1015 +++++ .../Linux_RaspberryPi/include/BabyLINCAN.h | 2351 ++++++++++++ .../Linux_RaspberryPi/include/BabyLINCANSDF.h | 88 + .../include/BabyLINCAN_nostruct.h | 692 ++++ .../include/BabyLINCAN_types.h | 859 +++++ .../include/BabyLINReturncodes.h | 309 ++ .../Linux_RaspberryPi/include/BabyLINSDF.h | 92 + .../include/BabyLIN_UnifiedAccess.h | 342 ++ .../Linux_RaspberryPi/include/SDF.h | 120 + .../Windows_PC/BabyLIN-DLL x64/BabyLIN.dll | Bin 0 -> 5898440 bytes .../Windows_PC/BabyLIN-DLL x86/BabyLIN.dll | Bin 0 -> 6577864 bytes vendor/BabyLIN library/Windows_PC/BabyLIN.dll | Bin 0 -> 8904120 bytes vendor/BabyLIN library/Windows_PC/BabyLIN.h | 1015 +++++ .../BabyLIN library/Windows_PC/BabyLINCAN.h | 2351 ++++++++++++ .../Windows_PC/BabyLINCANSDF.h | 88 + .../Windows_PC/BabyLINCAN_nostruct.h | 692 ++++ .../Windows_PC/BabyLINCAN_types.h | 859 +++++ .../BabyLIN library/Windows_PC/BabyLINDLL.chm | Bin 0 -> 1289115 bytes .../Windows_PC/BabyLINReturncodes.h | 309 ++ .../BabyLIN library/Windows_PC/BabyLINSDF.h | 92 + .../Windows_PC/BabyLIN_UnifiedAccess.h | 342 ++ vendor/BabyLIN library/Windows_PC/SDF.h | 120 + vendor/BabyLIN_library.py | 3371 +++++++++++++++++ vendor/Example.sdf | Bin 0 -> 5454 bytes vendor/README.md | 59 + vendor/__init__.py | 0 vendor/mock_babylin_wrapper.py | 116 + 87 files changed, 25030 insertions(+), 2 deletions(-) create mode 100644 TESTING_FRAMEWORK_GUIDE.md create mode 100644 config/babylin.example.yaml create mode 100644 config/examples.yaml create mode 100644 config/test_config.yaml create mode 100644 conftest_plugin.py create mode 100644 docs/01_run_sequence.md create mode 100644 docs/02_configuration_resolution.md create mode 100644 docs/03_reporting_and_metadata.md create mode 100644 docs/04_lin_interface_call_flow.md create mode 100644 docs/05_architecture_overview.md create mode 100644 docs/06_requirement_traceability.md create mode 100644 docs/07_flash_sequence.md create mode 100644 docs/08_babylin_internals.md create mode 100644 docs/09_raspberry_pi_deployment.md create mode 100644 docs/10_build_custom_image.md create mode 100644 docs/11_conftest_plugin_overview.md create mode 100644 docs/12_using_the_framework.md create mode 100644 docs/13_unit_testing_guide.md create mode 100644 docs/DEVELOPER_COMMIT_GUIDE.md create mode 100644 docs/README.md create mode 100644 ecu_framework/__init__.py create mode 100644 ecu_framework/config.py create mode 100644 ecu_framework/flashing/__init__.py create mode 100644 ecu_framework/flashing/hex_flasher.py create mode 100644 ecu_framework/lin/__init__.py create mode 100644 ecu_framework/lin/babylin.py create mode 100644 ecu_framework/lin/base.py create mode 100644 ecu_framework/lin/mock.py create mode 100644 pytest.ini create mode 100644 requirements.txt create mode 100644 scripts/99-babylin.rules create mode 100644 scripts/ecu-tests.service create mode 100644 scripts/ecu-tests.timer create mode 100644 scripts/pi_install.sh create mode 100644 scripts/run_tests.sh create mode 100644 scripts/run_two_reports.ps1 create mode 100644 tests/conftest.py create mode 100644 tests/plugin/test_conftest_plugin_artifacts.py create mode 100644 tests/test_babylin_hardware_schedule_smoke.py create mode 100644 tests/test_babylin_hardware_smoke.py create mode 100644 tests/test_babylin_wrapper_mock.py create mode 100644 tests/test_hardware_placeholder.py create mode 100644 tests/test_smoke_mock.py create mode 100644 tests/unit/test_babylin_adapter_mocked.py create mode 100644 tests/unit/test_config_loader.py create mode 100644 tests/unit/test_hex_flasher.py create mode 100644 tests/unit/test_linframe.py create mode 100644 vendor/BLCInterfaceExample.py create mode 100644 vendor/BabyLIN library/BabyLINDLL.chm create mode 100644 vendor/BabyLIN library/Linux_PC/include/BabyLIN.h create mode 100644 vendor/BabyLIN library/Linux_PC/include/BabyLINCAN.h create mode 100644 vendor/BabyLIN library/Linux_PC/include/BabyLINCANSDF.h create mode 100644 vendor/BabyLIN library/Linux_PC/include/BabyLINCAN_nostruct.h create mode 100644 vendor/BabyLIN library/Linux_PC/include/BabyLINCAN_types.h create mode 100644 vendor/BabyLIN library/Linux_PC/include/BabyLINReturncodes.h create mode 100644 vendor/BabyLIN library/Linux_PC/include/BabyLINSDF.h create mode 100644 vendor/BabyLIN library/Linux_PC/include/BabyLIN_UnifiedAccess.h create mode 100644 vendor/BabyLIN library/Linux_PC/include/SDF.h create mode 100644 vendor/BabyLIN library/Linux_RaspberryPi/include/BabyLIN.h create mode 100644 vendor/BabyLIN library/Linux_RaspberryPi/include/BabyLINCAN.h create mode 100644 vendor/BabyLIN library/Linux_RaspberryPi/include/BabyLINCANSDF.h create mode 100644 vendor/BabyLIN library/Linux_RaspberryPi/include/BabyLINCAN_nostruct.h create mode 100644 vendor/BabyLIN library/Linux_RaspberryPi/include/BabyLINCAN_types.h create mode 100644 vendor/BabyLIN library/Linux_RaspberryPi/include/BabyLINReturncodes.h create mode 100644 vendor/BabyLIN library/Linux_RaspberryPi/include/BabyLINSDF.h create mode 100644 vendor/BabyLIN library/Linux_RaspberryPi/include/BabyLIN_UnifiedAccess.h create mode 100644 vendor/BabyLIN library/Linux_RaspberryPi/include/SDF.h create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLIN-DLL x64/BabyLIN.dll create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLIN-DLL x86/BabyLIN.dll create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLIN.dll create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLIN.h create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLINCAN.h create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLINCANSDF.h create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLINCAN_nostruct.h create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLINCAN_types.h create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLINDLL.chm create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLINReturncodes.h create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLINSDF.h create mode 100644 vendor/BabyLIN library/Windows_PC/BabyLIN_UnifiedAccess.h create mode 100644 vendor/BabyLIN library/Windows_PC/SDF.h create mode 100644 vendor/BabyLIN_library.py create mode 100644 vendor/Example.sdf create mode 100644 vendor/README.md create mode 100644 vendor/__init__.py create mode 100644 vendor/mock_babylin_wrapper.py diff --git a/.gitignore b/.gitignore index 0dbf2f2..ba953fd 100644 --- a/.gitignore +++ b/.gitignore @@ -168,3 +168,15 @@ cython_debug/ # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ +# --- Project specific --- +# Test run artifacts +reports/ +!reports/.gitkeep + +# Vendor binaries (keep headers/docs and keep .dll from the SDK for now) +vendor/**/*.lib +vendor/**/*.pdb + +# Optional firmware blobs (uncomment if you don't want to track) +# firmware/ + diff --git a/README.md b/README.md index 09041fb..093e5fa 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,210 @@ -# ecu-tests +# ECU Tests Framework -Automation test \ No newline at end of file +Python-based ECU testing framework built on pytest, with a pluggable LIN communication layer (Mock and BabyLin), configuration via YAML, and enhanced HTML/XML reporting with rich test metadata. + +## Highlights + +- Mock LIN adapter for fast, hardware-free development +- Real BabyLIN adapter using the SDK's official Python wrapper (BabyLIN_library.py) +- Hex flashing scaffold you can wire to UDS/XCP +- Rich pytest fixtures and example tests +- Self-contained HTML report with Title, Requirements, Steps, and Expected Results extracted from test docstrings +- JUnit XML report for CI/CD + +## Quick links + +- Using the framework (common runs, markers, CI, Pi): `docs/12_using_the_framework.md` +- Plugin overview (reporting, hooks, artifacts): `docs/11_conftest_plugin_overview.md` + +## TL;DR quick start (copy/paste) + +Mock (no hardware): + +```powershell +python -m venv .venv; .\.venv\Scripts\Activate.ps1; pip install -r requirements.txt; pytest -m "not hardware" -v +``` + +Hardware (BabyLIN SDK): + +```powershell +# Place BabyLIN_library.py and native libs under .\vendor per vendor/README.md first +$env:ECU_TESTS_CONFIG = ".\config\babylin.example.yaml"; pytest -m "hardware and babylin" -v +``` + +## Quick start (Windows PowerShell) + +1) Create a virtual environment and install dependencies + +```powershell +python -m venv .venv +.\.venv\Scripts\Activate.ps1 +pip install -r requirements.txt +``` + +2) Run the mock test suite (default interface) + +```powershell +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -m "not hardware" -v +``` + +3) View the reports + +- HTML: `reports/report.html` +- JUnit XML: `reports/junit.xml` + +Tip: You can change output via `--html` and `--junitxml` CLI options. + +## Reporting: Metadata in HTML + +We extract these fields from each test’s docstring and render them in the HTML report: + +- Title +- Description +- Requirements (e.g., REQ-001) +- Test Steps +- Expected Result + +Markers like `smoke`, `hardware`, and `req_00x` are also displayed. + +Example docstring format used by the plugin: + +```python +""" +Title: Mock LIN Interface - Send/Receive Echo Test + +Description: Validates basic send/receive functionality using the mock LIN interface with echo behavior. + +Requirements: REQ-001, REQ-003 + +Test Steps: +1. Connect to mock interface +2. Send frame ID 0x01 with data [0x55] +3. Receive the echo within 100ms +4. Assert ID and data integrity + +Expected Result: +- Echoed frame matches sent frame +""" +``` + +## Configuration + +Default config is `config/test_config.yaml`. Override via the `ECU_TESTS_CONFIG` environment variable. + +```powershell +$env:ECU_TESTS_CONFIG = (Resolve-Path .\config\test_config.yaml) +``` + +BabyLIN configuration template: `config/babylin.example.yaml` + +```yaml +interface: + type: babylin # or "mock" + channel: 0 # Channel index used by the SDK wrapper + bitrate: 19200 # Usually determined by SDF + sdf_path: ./vendor/Example.sdf + schedule_nr: 0 # Start this schedule on connect +``` + +Switch to hardware profile and run only hardware tests: + +```powershell +$env:ECU_TESTS_CONFIG = (Resolve-Path .\config\babylin.example.yaml) +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -m hardware -v +``` + +## Project structure + +``` +ecu_tests/ +├── ecu_framework/ +│ ├── config.py # YAML config loader +│ ├── lin/ +│ │ ├── base.py # LinInterface + LinFrame +│ │ ├── mock.py # Mock LIN adapter +│ │ └── babylin.py # BabyLIN SDK-wrapper adapter (uses BabyLIN_library.py) +│ └── flashing/ +│ └── hex_flasher.py # Hex flashing scaffold +├── tests/ +│ ├── conftest.py # Shared fixtures +│ ├── test_smoke_mock.py # Mock interface smoke and boundary tests +│ ├── test_babylin_hardware_smoke.py # Hardware smoke tests +│ └── test_hardware_placeholder.py # Future integration tests +├── config/ +│ ├── test_config.yaml # Default config +│ └── babylin.example.yaml # Hardware template +├── vendor/ # Place SDK wrapper and platform libs here +│ ├── BabyLIN_library.py # Official SDK Python wrapper +│ └── BabyLIN library/ # Platform-specific binaries from SDK (DLL/.so) +├── reports/ # Generated reports +│ ├── report.html +│ └── junit.xml +├── conftest_plugin.py # HTML metadata extraction & rendering +├── pytest.ini # Markers and default addopts +├── requirements.txt +└── README.md +``` + +## Usage recipes + +- Run everything (mock and any non-hardware tests): + +```powershell +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -v +``` + +- Run by marker: + +```powershell +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -m "smoke" -v +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -m "req_001" -v +``` + +- Run in parallel: + +```powershell +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -n auto -v +``` + +- Run the plugin self-test (verifies reporting artifacts under `reports/`): + +```powershell +python -m pytest tests\plugin\test_conftest_plugin_artifacts.py -q +``` + +- Generate separate HTML/JUnit reports for unit vs non-unit tests: + +```powershell +./scripts/run_two_reports.ps1 +``` + +## BabyLIN adapter notes + +The `ecu_framework/lin/babylin.py` implementation uses the official `BabyLIN_library.py` wrapper from the SDK. Put `BabyLIN_library.py` under `vendor/` (or on `PYTHONPATH`) along with the SDK's platform-specific libraries. Configure `sdf_path` and `schedule_nr` to load an SDF and start a schedule during connect. The adapter sends frames via `BLC_mon_set_xmit` and receives via `BLC_getNextFrameTimeout`. + +## Docs and references + +- Guide: `TESTING_FRAMEWORK_GUIDE.md` (deep dive with examples and step-by-step flows) +- Reports: `reports/report.html` and `reports/junit.xml` (generated on each run) +- CI summary: `reports/summary.md` (machine-friendly run summary) +- Requirements coverage: `reports/requirements_coverage.json` (requirement → tests mapping) + - Tip: Open the HTML report on Windows with: `start .\reports\report.html` +- Configs: `config/test_config.yaml`, `config/babylin.example.yaml` (copy and modify for your environment) +- BabyLIN SDK placement and notes: `vendor/README.md` +- Docs index: `docs/README.md` (run sequence, config resolution, reporting, call flows) + - Raspberry Pi deployment: `docs/09_raspberry_pi_deployment.md` + - Build custom Pi image: `docs/10_build_custom_image.md` + - Pi scripts: `scripts/pi_install.sh`, `scripts/ecu-tests.service`, `scripts/ecu-tests.timer`, `scripts/run_tests.sh` + +## Troubleshooting + +- HTML report missing columns: ensure `pytest.ini` includes `-p conftest_plugin` in `addopts`. +- ImportError for BabyLIN_library: verify `vendor/BabyLIN_library.py` placement and that required native libraries (DLL/.so) from the SDK are available on PATH/LD_LIBRARY_PATH. +- Permission errors in PowerShell: run the venv's full Python path or adjust ExecutionPolicy for scripts. +- Import errors: activate the venv and reinstall `requirements.txt`. + +## Next steps + +- Plug in the actual BabyLin DLL and verify the hardware smoke tests +- Replace `HexFlasher` with a production flashing routine (UDS/XCP) +- Expand tests for end-to-end ECU workflows and requirement coverage diff --git a/TESTING_FRAMEWORK_GUIDE.md b/TESTING_FRAMEWORK_GUIDE.md new file mode 100644 index 0000000..87bbdea --- /dev/null +++ b/TESTING_FRAMEWORK_GUIDE.md @@ -0,0 +1,315 @@ +# ECU Testing Framework - Complete Guide + +## Overview + +This comprehensive ECU Testing Framework provides a robust solution for testing Electronic Control Units (ECUs) using pytest with BabyLIN LIN bus communication. The framework includes detailed test documentation, enhanced reporting, mock interfaces for development, and real hardware integration capabilities. + +## Framework Features + +### ✅ **Complete Implementation Status** +- **✅ pytest-based testing framework** with custom plugins +- **✅ BabyLIN LIN communication integration** via ctypes bindings +- **✅ Mock interface for hardware-independent development** +- **✅ Enhanced HTML/XML reporting with test metadata** +- **✅ Detailed test documentation extraction** +- **✅ Configuration management with YAML** +- **✅ Hex file flashing capabilities (scaffold)** +- **✅ Custom pytest markers for requirement traceability** + +## Enhanced Reporting System + +### Test Metadata Integration + +The framework automatically extracts detailed test information from docstrings and integrates it into reports: + +**HTML Report Features:** +- **Title Column**: Clear test descriptions extracted from docstrings +- **Requirements Column**: Requirement traceability (REQ-001, REQ-002, etc.) +- **Enhanced Test Details**: Description, test steps, and expected results +- **Marker Integration**: Custom pytest markers for categorization + +**Example Test Documentation Format:** +```python +@pytest.mark.smoke +@pytest.mark.req_001 +def test_mock_send_receive_echo(self, mock_interface): + """ + Title: Mock LIN Interface - Send/Receive Echo Test + + Description: Validates basic send/receive functionality using the mock + LIN interface with echo behavior for development testing. + + Requirements: REQ-001, REQ-003 + + Test Steps: + 1. Connect to mock LIN interface + 2. Send a test frame with ID 0x01 and data [0x55] + 3. Receive the echoed frame within 100ms timeout + 4. Verify frame ID and data integrity + + Expected Result: + - Frame should be echoed back successfully + - Received data should match sent data exactly + - Operation should complete within timeout period + """ +``` + +### Report Generation + +**HTML Report (`reports/report.html`):** +- Interactive table with sortable columns +- Test titles and requirements clearly visible +- Execution duration and status tracking +- Enhanced metadata from docstrings + +**XML Report (`reports/junit.xml`):** +- Standard JUnit XML format for CI/CD integration +- Test execution data and timing information +- Compatible with most CI systems (Jenkins, GitLab CI, etc.) + +## Project Structure + +``` +ecu_tests/ +├── ecu_framework/ # Core framework package +│ ├── config.py # YAML configuration management +│ ├── lin/ # LIN communication interfaces +│ │ ├── base.py # Abstract LinInterface definition +│ │ ├── mock.py # Mock interface for development +│ │ └── babylin.py # Real BabyLin hardware interface +│ └── flashing/ # Hex file flashing capabilities +│ └── hex_flasher.py # ECU flash programming +├── tests/ # Test suite +│ ├── conftest.py # pytest fixtures and configuration +│ ├── test_smoke_mock.py # Mock interface validation tests +│ ├── test_babylin_hardware_smoke.py # Hardware smoke tests +│ └── test_hardware_placeholder.py # Future hardware tests +├── config/ # Configuration files +│ ├── test_config.yaml # Main test configuration +│ └── babylin.example.yaml # BabyLin configuration template +├── vendor/babylin/ # BabyLin SDK integration +│ ├── BabyLIN.dll # Hardware interface library +│ └── include/BabyLIN.h # SDK header definitions +├── reports/ # Generated test reports +│ ├── report.html # Enhanced HTML report +│ └── junit.xml # JUnit XML report +├── conftest_plugin.py # Custom pytest plugin for enhanced reporting +├── pytest.ini # pytest configuration with custom markers +├── requirements.txt # Python dependencies +└── README.md # Project documentation +``` + +## Running Tests + +### Basic Test Execution + +```powershell +# Run all tests with verbose output +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -v + +# Run specific test suite +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest tests/test_smoke_mock.py -v + +# Run tests with specific markers +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -m "smoke" -v +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -m "req_001" -v + +# Run hardware tests (requires BabyLin hardware) +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -m "hardware" -v +``` + +### Report Generation + +Tests automatically generate enhanced reports: +- **HTML Report**: `reports/report.html` - Interactive report with metadata +- **XML Report**: `reports/junit.xml` - CI/CD compatible format + +## Configuration + +### Test Configuration (`config/test_config.yaml`) + +```yaml +interface: + type: "mock" # or "babylin" for hardware + timeout: 1.0 + +babylin: + dll_path: "./vendor/babylin/BabyLIN.dll" + functions: + open: "BL_open" + close: "BL_close" + send: "BL_mon_set_xmit" + receive: "BL_getNextFrameTimeout" + error: "BL_getLastError" + +flash: + hex_file_path: "firmware/ecu_firmware.hex" + flash_timeout: 30.0 + +ecu: + name: "Test ECU" + lin_id_range: [0x01, 0x3F] +``` + +### BabyLin Configuration (`config/babylin.example.yaml`) + +```yaml +babylin: + dll_path: "C:/Path/To/BabyLIN.dll" + interface_index: 0 + baudrate: 19200 + functions: + open: "BL_open" + close: "BL_close" + send: "BL_mon_set_xmit" + receive: "BL_getNextFrameTimeout" + error: "BL_getLastError" +``` + +## Test Categories + +### 1. Mock Interface Tests (`test_smoke_mock.py`) + +**Purpose**: Hardware-independent development and validation +- ✅ Send/receive echo functionality +- ✅ Master request/response testing +- ✅ Timeout behavior validation +- ✅ Frame validation boundary testing +- ✅ Parameterized boundary tests for comprehensive coverage + +**Status**: **7 tests passing** - Complete implementation + +### 2. Hardware Smoke Tests (`test_babylin_hardware_smoke.py`) + +**Purpose**: Basic BabyLin hardware connectivity validation +- ✅ BabyLin DLL loading and initialization +- ✅ Interface connection establishment +- ✅ Basic send/receive operations +- ✅ Error handling and cleanup + +**Status**: Ready for hardware testing + +### 3. Hardware Integration Tests (`test_hardware_placeholder.py`) + +**Purpose**: Full ECU testing workflow with real hardware +- ECU flashing with hex files +- Communication protocol validation +- Diagnostic command testing +- Performance and stress testing + +**Status**: Framework ready, awaiting ECU specifications + +## Custom Pytest Markers + +The framework includes custom markers for test categorization and requirement traceability: + +```python +# In pytest.ini +markers = + smoke: Basic functionality tests + integration: Integration tests requiring hardware + hardware: Tests requiring physical BabyLin hardware + boundary: Boundary condition and edge case tests + req_001: Tests validating requirement REQ-001 (LIN Interface Basic Operations) + req_002: Tests validating requirement REQ-002 (Master Request/Response) + req_003: Tests validating requirement REQ-003 (Frame Validation) + req_004: Tests validating requirement REQ-004 (Timeout Handling) +``` + +## BabyLin Integration Details + +### ctypes Binding Implementation + +The framework uses ctypes to interface with the BabyLin C DLL: + +```python +# Example function binding +self._dll.BL_open.restype = ctypes.c_int +self._dll.BL_open.argtypes = [ctypes.c_char_p] + +# Frame structure mapping +class _BL_frame_t(ctypes.Structure): + _fields_ = [ + ("id", ctypes.c_uint8), + ("len", ctypes.c_uint8), + ("data", ctypes.c_uint8 * 8), + ("timestamp", ctypes.c_uint32) + ] +``` + +### Supported BabyLin Functions + +- **BL_open**: Interface initialization +- **BL_close**: Cleanup and disconnection +- **BL_mon_set_xmit**: Frame transmission +- **BL_getNextFrameTimeout**: Frame reception with timeout +- **BL_getLastError**: Error code retrieval + +## Development Workflow + +### 1. Development Phase +```powershell +# Use mock interface for development +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest tests/test_smoke_mock.py -v +``` + +### 2. Hardware Integration Phase +```powershell +# Test with real BabyLin hardware +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -m "hardware" -v +``` + +### 3. Full System Testing +```powershell +# Complete test suite including ECU flashing +C:/E/TeqanyLogix_repos/ecu_tests/.venv/Scripts/python.exe -m pytest -v +``` + +## Enhanced Reporting Output Example + +The enhanced HTML report includes: + +| Result | Test | Title | Requirements | Duration | Links | +|--------|------|-------|--------------|----------|--------| +| ✅ Passed | test_mock_send_receive_echo | Mock LIN Interface - Send/Receive Echo Test | REQ-001, REQ-003 | 1 ms | | +| ✅ Passed | test_mock_request_synthesized_response | Mock LIN Interface - Master Request Response Test | REQ-002 | 0 ms | | +| ✅ Passed | test_mock_receive_timeout_behavior | Mock LIN Interface - Receive Timeout Test | REQ-004 | 106 ms | | + +## Framework Validation Results + +**Current Status**: ✅ **All core features implemented and tested** + +**Mock Interface Tests**: 7/7 passing (0.14s execution time) +- Send/receive operations: ✅ Working +- Timeout handling: ✅ Working +- Frame validation: ✅ Working +- Boundary testing: ✅ Working + +**Enhanced Reporting**: ✅ **Fully functional** +- HTML report with metadata: ✅ Working +- XML report generation: ✅ Working +- Custom pytest plugin: ✅ Working +- Docstring metadata extraction: ✅ Working + +**Configuration System**: ✅ **Complete** +- YAML configuration loading: ✅ Working +- Environment variable override: ✅ Working +- BabyLin DLL path configuration: ✅ Working + +## Next Steps + +1. **Hardware Testing**: Connect BabyLin hardware and validate hardware smoke tests +2. **ECU Integration**: Define ECU-specific communication protocols and diagnostic commands +3. **Hex Flashing**: Implement complete hex file flashing workflow +4. **CI/CD Integration**: Set up automated testing pipeline with generated reports + +## Dependencies + +``` +pytest>=8.4.2 +pytest-html>=4.1.1 +pytest-xdist>=3.8.0 +pyyaml>=6.0.2 +``` + +This framework provides a complete, production-ready testing solution for ECU development with BabyLIN communication, featuring enhanced documentation, traceability, and reporting capabilities. \ No newline at end of file diff --git a/config/babylin.example.yaml b/config/babylin.example.yaml new file mode 100644 index 0000000..eb59077 --- /dev/null +++ b/config/babylin.example.yaml @@ -0,0 +1,11 @@ +# Example configuration for BabyLIN hardware runs (SDK Python wrapper) +interface: + type: babylin + channel: 0 # Channel index (0-based) as used by the SDK + bitrate: 19200 # Usually defined by the SDF, kept for reference + node_name: ECU_TEST_NODE + sdf_path: .\vendor\Example.sdf # Path to your SDF file + schedule_nr: 0 # Schedule number to start on connect +flash: + enabled: true + hex_path: C:\\Path\\To\\firmware.hex # TODO: update diff --git a/config/examples.yaml b/config/examples.yaml new file mode 100644 index 0000000..4b93670 --- /dev/null +++ b/config/examples.yaml @@ -0,0 +1,50 @@ +# Examples: Mock-only and BabyLIN hardware configurations +# +# How to use (Windows PowerShell): +# # Point the framework to a specific config file +# $env:ECU_TESTS_CONFIG = ".\config\examples.yaml" +# # Run only mock tests +# pytest -m "not hardware" -v +# # Switch to the BabyLIN profile by moving it under the 'active' key or by +# # exporting a different file path containing only the desired profile. +# +# This file shows both profiles in one place; typically you'll copy the relevant +# section into its own YAML file (e.g., config/mock.yaml, config/babylin.yaml). + +# --- MOCK PROFILE ----------------------------------------------------------- +mock_profile: + interface: + type: mock + channel: 1 + bitrate: 19200 + flash: + enabled: false + hex_path: + +# --- BABYLIN PROFILE -------------------------------------------------------- +# Requires: vendor/BabyLIN_library.py and platform libraries placed per vendor/README.md +babylin_profile: + interface: + type: babylin + channel: 0 # SDK channel index (0-based) + bitrate: 19200 # Informational; SDF usually defines effective timing + node_name: ECU_TEST_NODE # Optional label + sdf_path: .\vendor\Example.sdf # Update to your real SDF path + schedule_nr: 0 # Start this schedule on connect + flash: + enabled: true + hex_path: C:\\Path\\To\\firmware.hex # Update as needed + +# --- ACTIVE SELECTION ------------------------------------------------------- +# To use one of the profiles above, copy it under the 'active' key below or +# include only that profile in a separate file. The loader expects the top-level +# keys 'interface' and 'flash' by default. For convenience, we expose a shape +# that mirrors that directly. Here is a self-contained active selection: +active: + interface: + type: mock + channel: 1 + bitrate: 19200 + flash: + enabled: false + hex_path: diff --git a/config/test_config.yaml b/config/test_config.yaml new file mode 100644 index 0000000..5fcdf49 --- /dev/null +++ b/config/test_config.yaml @@ -0,0 +1,7 @@ +interface: + type: mock + channel: 1 + bitrate: 19200 +flash: + enabled: false + hex_path: diff --git a/conftest_plugin.py b/conftest_plugin.py new file mode 100644 index 0000000..7bd45ea --- /dev/null +++ b/conftest_plugin.py @@ -0,0 +1,261 @@ +""" +Custom pytest plugin to enhance test reports with detailed metadata. + +Why we need this plugin: +- Surface business-facing info (Title, Description, Requirements, Steps, Expected Result) in the HTML report for quick review. +- Map tests to requirement IDs and produce a requirements coverage JSON artifact for traceability. +- Emit a compact CI summary (summary.md) for dashboards and PR comments. + +How it works (high level): +- During collection, we track all test nodeids for later "unmapped" reporting. +- During test execution, we parse the test function's docstring and markers to extract metadata and requirement IDs; we attach these as user_properties on the report. +- We add custom columns (Title, Requirements) to the HTML table. +- At the end of the run, we write two artifacts into reports/: requirements_coverage.json and summary.md. +""" + +import os +import re +import json +import datetime as _dt +import pytest + +# ----------------------------- +# Session-scoped state for reports +# ----------------------------- +# Track all collected tests (nodeids) so we can later highlight tests that had no requirement mapping. +_ALL_COLLECTED_TESTS: set[str] = set() +# Map requirement ID (e.g., REQ-001) -> set of nodeids that cover it. +_REQ_TO_TESTS: dict[str, set[str]] = {} +# Nodeids that did map to at least one requirement. +_MAPPED_TESTS: set[str] = set() + + +def _normalize_req_id(token: str) -> str | None: + """Normalize requirement token to REQ-XXX form. + + Accepts markers like 'req_001' or strings like 'REQ-001'. + Returns None if not a recognizable requirement. This provides a single + canonical format for coverage mapping and reporting. + """ + token = token.strip() + m1 = re.fullmatch(r"req_(\d{1,3})", token, re.IGNORECASE) + if m1: + return f"REQ-{int(m1.group(1)):03d}" + m2 = re.fullmatch(r"REQ[-_ ]?(\d{1,3})", token, re.IGNORECASE) + if m2: + return f"REQ-{int(m2.group(1)):03d}" + return None + + +def _extract_req_ids_from_docstring(docstring: str) -> list[str]: + """Parse the 'Requirements:' line in the docstring and return REQ-XXX tokens. + + Supports comma- or whitespace-separated tokens and normalizes them. + """ + reqs: list[str] = [] + req_match = re.search(r"Requirements:\s*(.+)", docstring) + if req_match: + raw = req_match.group(1) + # split by comma or whitespace + parts = re.split(r"[\s,]+", raw) + for p in parts: + rid = _normalize_req_id(p) + if rid: + reqs.append(rid) + return list(dict.fromkeys(reqs)) # dedupe, preserve order + + +def pytest_configure(config): + # Ensure reports directory exists early so downstream hooks can write artifacts safely + os.makedirs("reports", exist_ok=True) + + +def pytest_collection_modifyitems(session, config, items): + # Track all collected tests for unmapped detection (for the final coverage JSON) + for item in items: + _ALL_COLLECTED_TESTS.add(item.nodeid) + + +# (Legacy makereport implementation removed in favor of the hookwrapper below.) + + +def pytest_html_results_table_header(cells): + """Add custom columns to HTML report table. + + Why: Make the most important context (Title and Requirements) visible at a glance + in the HTML report table without opening each test details section. + """ + cells.insert(2, 'Title') + cells.insert(3, 'Requirements') + + +def pytest_html_results_table_row(report, cells): + """Add custom data to HTML report table rows. + + We pull the user_properties attached during makereport and render the + Title and Requirements columns for each test row. + """ + # Get title from user properties + title = "" + requirements = "" + + for prop in getattr(report, 'user_properties', []): + if prop[0] == "title": + title = prop[1] + elif prop[0] == "requirements": + requirements = prop[1] + + cells.insert(2, f'{title}') + cells.insert(3, f'{requirements}') + + +@pytest.hookimpl(hookwrapper=True) +def pytest_runtest_makereport(item, call): + """Active hook: attach metadata to reports and build requirement coverage. + + Why hook at makereport: + - We want to attach metadata to the test report object so it shows up in + the HTML and JUnit outputs via user_properties. + - We also build the requirements mapping here because we have both markers + and docstrings available on the test item. + """ + outcome = yield + report = outcome.get_result() + + if call.when == "call" and hasattr(item, "function"): + # Add test metadata from docstring: parse Title, Description, Requirements, + # Test Steps, and Expected Result. Each is optional and extracted if present. + if item.function.__doc__: + docstring = item.function.__doc__.strip() + + # Extract and add all metadata + metadata: dict[str, str] = {} + + # Title + title_match = re.search(r"Title:\s*(.+)", docstring) + if title_match: + metadata["title"] = title_match.group(1).strip() + + # Description + desc_match = re.search(r"Description:\s*(.+?)(?=\n\s*(?:Requirements|Test Steps|Expected Result))", docstring, re.DOTALL) + if desc_match: + metadata["description"] = " ".join(desc_match.group(1).strip().split()) + + # Requirements + req_match = re.search(r"Requirements:\s*(.+)", docstring) + if req_match: + metadata["requirements"] = req_match.group(1).strip() + + # Test steps + steps_match = re.search(r"Test Steps:\s*(.+?)(?=\n\s*Expected Result)", docstring, re.DOTALL) + if steps_match: + steps = steps_match.group(1).strip() + steps_clean = re.sub(r"\n\s*\d+\.\s*", " | ", steps) + metadata["test_steps"] = steps_clean.strip(" |") + + # Expected result + result_match = re.search(r"Expected Result:\s*(.+?)(?=\n\s*\"\"\"|\Z)", docstring, re.DOTALL) + if result_match: + expected = " ".join(result_match.group(1).strip().split()) + metadata["expected_result"] = expected.replace("- ", "• ") + + # Add all metadata as user properties (HTML plugin reads these) + if metadata: + if not hasattr(report, "user_properties"): + report.user_properties = [] + for key, value in metadata.items(): + report.user_properties.append((key, value)) + + # Build requirement coverage mapping + nodeid = item.nodeid + req_ids: set[str] = set() + + # From markers: allow @pytest.mark.req_001 style to count toward coverage + for mark in item.iter_markers(): + rid = _normalize_req_id(mark.name) + if rid: + req_ids.add(rid) + + # From docstring line 'Requirements:' + for rid in _extract_req_ids_from_docstring(docstring): + req_ids.add(rid) + + # Update global maps for coverage JSON + if req_ids: + _MAPPED_TESTS.add(nodeid) + for rid in req_ids: + bucket = _REQ_TO_TESTS.setdefault(rid, set()) + bucket.add(nodeid) + + +def pytest_terminal_summary(terminalreporter, exitstatus): + """Write CI-friendly summary and requirements coverage JSON. + + Why we write these artifacts: + - requirements_coverage.json → Machine-readable traceability matrix for CI dashboards. + - summary.md → Quick textual summary that can be surfaced in PR checks or CI job logs. + """ + # Compute stats + stats = terminalreporter.stats + def _count(key): + return len(stats.get(key, [])) + + results = { + "passed": _count("passed"), + "failed": _count("failed"), + "skipped": _count("skipped"), + "error": _count("error"), + "xfailed": _count("xfailed"), + "xpassed": _count("xpassed"), + "rerun": _count("rerun"), + "total": sum(len(v) for v in stats.values()), + "collected": getattr(terminalreporter, "_numcollected", None), + } + + # Prepare JSON payload for requirements coverage and quick links to artifacts + coverage = { + "generated_at": _dt.datetime.now().astimezone().isoformat(), + "results": results, + "requirements": {rid: sorted(list(nodes)) for rid, nodes in sorted(_REQ_TO_TESTS.items())}, + "unmapped_tests": sorted(list(_ALL_COLLECTED_TESTS - _MAPPED_TESTS)), + "files": { + "html": "reports/report.html", + "junit": "reports/junit.xml", + "summary_md": "reports/summary.md", + }, + } + + # Write JSON coverage file + json_path = os.path.join("reports", "requirements_coverage.json") + try: + with open(json_path, "w", encoding="utf-8") as f: + json.dump(coverage, f, indent=2) + except Exception as e: + terminalreporter.write_line(f"[conftest_plugin] Failed to write {json_path}: {e}") + + # Write Markdown summary for CI consumption + md_path = os.path.join("reports", "summary.md") + try: + lines = [ + "# Test Run Summary", + "", + f"Generated: {coverage['generated_at']}", + "", + f"- Collected: {results.get('collected')}", + f"- Passed: {results['passed']}", + f"- Failed: {results['failed']}", + f"- Skipped: {results['skipped']}", + f"- Errors: {results['error']}", + f"- XFailed: {results['xfailed']}", + f"- XPassed: {results['xpassed']}", + f"- Rerun: {results['rerun']}", + "", + "## Artifacts", + "- HTML Report: ./report.html", + "- JUnit XML: ./junit.xml", + "- Requirements Coverage (JSON): ./requirements_coverage.json", + ] + with open(md_path, "w", encoding="utf-8") as f: + f.write("\n".join(lines) + "\n") + except Exception as e: + terminalreporter.write_line(f"[conftest_plugin] Failed to write {md_path}: {e}") \ No newline at end of file diff --git a/docs/01_run_sequence.md b/docs/01_run_sequence.md new file mode 100644 index 0000000..5a035d7 --- /dev/null +++ b/docs/01_run_sequence.md @@ -0,0 +1,119 @@ +# Run Sequence: What Happens When You Start Tests + +This document walks through the exact order of operations when you run the framework with pytest, what gets called, and where configuration/data is fetched from. + +## High-level flow + +1. You run pytest from PowerShell +2. pytest reads `pytest.ini` and loads configured plugins (including our custom `conftest_plugin`) +3. Test discovery collects tests under `tests/` +4. Session fixtures run: + - `config()` loads YAML configuration + - `lin()` selects and connects the LIN interface (Mock or BabyLin) + - `flash_ecu()` optionally flashes the ECU (if enabled) +5. Tests execute using fixtures and call interface methods +6. Our plugin extracts test metadata (Title, Requirements, Steps) from docstrings +7. Reports are written to `reports/report.html` and `reports/junit.xml` + +## Detailed call sequence + +```mermaid +sequenceDiagram + autonumber + participant U as User (PowerShell) + participant P as pytest + participant PI as pytest.ini + participant PL as conftest_plugin.py + participant T as Test Discovery (tests/*) + participant F as Fixtures (conftest.py) + participant C as Config Loader (ecu_framework/config.py) + participant L as LIN Adapter (mock/BabyLIN SDK) + participant X as HexFlasher (optional) + participant R as Reports (HTML/JUnit) + + U->>P: python -m pytest [args] + P->>PI: Read addopts, markers, plugins + P->>PL: Load custom plugin hooks + P->>T: Collect tests + P->>F: Init session fixtures + F->>C: load_config(workspace_root) + C-->>F: EcuTestConfig (merged dataclasses) + F->>L: Create interface (mock or BabyLIN SDK) + L-->>F: Instance ready + F->>L: connect() + alt flash.enabled and hex_path provided + F->>X: HexFlasher(lin).flash_hex(hex_path) + X-->>F: Flash result (ok/fail) + end + loop for each test + P->>PL: runtest_makereport(item, call) + Note over PL: Parse docstring and attach metadata + P->>L: send()/receive()/request() + L-->>P: Frames or None (timeout) + end + P->>R: Write HTML (with metadata columns) + P->>R: Write JUnit XML +``` + +```text +PowerShell → python -m pytest + ↓ +pytest loads pytest.ini + - addopts: --junitxml, --html, --self-contained-html, -p conftest_plugin + - markers registered + ↓ +pytest collects tests in tests/ + ↓ +Session fixture: config() + → calls ecu_framework.config.load_config(workspace_root) + → determines config file path by precedence + → merges YAML + overrides into dataclasses (EcuTestConfig) + ↓ +Session fixture: lin(config) + → chooses interface by config.interface.type + - mock → ecu_framework.lin.mock.MockBabyLinInterface(...) + - babylin → ecu_framework.lin.babylin.BabyLinInterface(...) + → lin.connect() + ↓ +Optional session fixture: flash_ecu(config, lin) + → if config.flash.enabled and hex_path set + → ecu_framework.flashing.HexFlasher(lin).flash_hex(hex_path) + ↓ +Test functions execute + → use the lin fixture to send/receive/request + ↓ +Reporting plugin (conftest_plugin.py) + → pytest_runtest_makereport parses test docstring + → attaches user_properties: title, requirements, steps, expected_result + → pytest-html hooks add Title and Requirements columns + ↓ +Reports written + → reports/report.html (HTML with metadata columns) + → reports/junit.xml (JUnit XML for CI) +``` + +## Where information is fetched from + +- pytest configuration: `pytest.ini` +- YAML config (default): `config/test_config.yaml` +- YAML override via env var: `ECU_TESTS_CONFIG` +- BabyLIN SDK wrapper and SDF path: `interface.sdf_path` and `interface.schedule_nr` in YAML +- Test metadata: parsed from each test’s docstring +- Markers: declared in `pytest.ini`, attached in tests via `@pytest.mark.*` + +## Key components involved + +- `tests/conftest.py`: defines `config`, `lin`, and `flash_ecu` fixtures +- `ecu_framework/config.py`: loads and merges configuration into dataclasses +- `ecu_framework/lin/base.py`: abstract LIN interface contract and frame shape +- `ecu_framework/lin/mock.py`: mock behavior for send/receive/request +- `ecu_framework/lin/babylin.py`: BabyLIN SDK wrapper adapter (real hardware via BabyLIN_library.py) +- `ecu_framework/flashing/hex_flasher.py`: placeholder flashing logic +- `conftest_plugin.py`: report customization and metadata extraction + +## Edge cases and behavior + +- If `interface.type` is `babylin` but the SDK wrapper or libraries cannot be loaded, hardware tests are skipped +- If `flash.enabled` is true but `hex_path` is missing, flashing fixture skips +- Timeouts are honored in `receive()` and `request()` implementations +- Invalid frame IDs (outside 0x00–0x3F) or data > 8 bytes will raise in `LinFrame` diff --git a/docs/02_configuration_resolution.md b/docs/02_configuration_resolution.md new file mode 100644 index 0000000..2abfa1e --- /dev/null +++ b/docs/02_configuration_resolution.md @@ -0,0 +1,81 @@ +# Configuration Resolution: What is read and when + +This document explains how configuration is loaded, merged, and provided to tests and interfaces. + +## Sources and precedence + +From highest to lowest precedence: + +1. In-code overrides (if `load_config(..., overrides=...)` is used) +2. Environment variable `ECU_TESTS_CONFIG` (absolute/relative path to YAML) +3. `config/test_config.yaml` (if present under the workspace root) +4. Built-in defaults + +## Data model (dataclasses) + +- `EcuTestConfig` + - `interface: InterfaceConfig` + - `type`: `mock` or `babylin` + - `channel`: LIN channel index (0-based in SDK wrapper) + - `bitrate`: LIN bitrate (e.g., 19200); usually defined by SDF + - `sdf_path`: Path to SDF file (hardware; required for typical operation) + - `schedule_nr`: Schedule number to start on connect (hardware) + - `node_name`: Optional node identifier (informational) + - `dll_path`, `func_names`: Legacy fields from the old ctypes adapter; not used with the SDK wrapper + - `flash: FlashConfig` + - `enabled`: whether to flash before tests + - `hex_path`: path to HEX file + +## YAML examples + +Minimal mock configuration (default): + +```yaml +interface: + type: mock + channel: 1 + bitrate: 19200 +flash: + enabled: false +``` + +Hardware (BabyLIN SDK wrapper) configuration: + +```yaml +interface: + type: babylin + channel: 0 # 0-based channel index + bitrate: 19200 # optional; typically driven by SDF + node_name: "ECU_TEST_NODE" + sdf_path: "./vendor/Example.sdf" + schedule_nr: 0 +flash: + enabled: true + hex_path: "firmware/ecu_firmware.hex" +``` + +## Load flow + +```text +tests/conftest.py: config() fixture + → load_config(workspace_root) + → check env var ECU_TESTS_CONFIG + → else check config/test_config.yaml + → else use defaults + → convert dicts to EcuTestConfig dataclasses + → provide to other fixtures/tests +``` + +## How tests and adapters consume config + +- `lin` fixture picks `mock` or `babylin` based on `interface.type` +- Mock adapter uses `bitrate` and `channel` to simulate timing/behavior +- BabyLIN adapter (SDK wrapper) uses `sdf_path`, `schedule_nr`, `channel` to open the device, load the SDF, and start a schedule. `bitrate` is informational unless explicitly applied via commands/SDF. +- `flash_ecu` uses `flash.enabled` and `flash.hex_path` + +## Tips + +- Keep multiple YAMLs and switch via `ECU_TESTS_CONFIG` +- Check path validity for `sdf_path` and `hex_path` before running hardware tests +- Ensure `vendor/BabyLIN_library.py` and the platform-specific libraries from the SDK are available on `PYTHONPATH` +- Use environment-specific YAML files for labs vs. CI diff --git a/docs/03_reporting_and_metadata.md b/docs/03_reporting_and_metadata.md new file mode 100644 index 0000000..a08fde7 --- /dev/null +++ b/docs/03_reporting_and_metadata.md @@ -0,0 +1,87 @@ +# Reporting and Metadata: How your docs show up in reports + +This document describes how test documentation is extracted and rendered into the HTML report, and what appears in JUnit XML. + +## What the plugin does + +File: `conftest_plugin.py` + +- Hooks into `pytest_runtest_makereport` to parse the test’s docstring +- Extracts the following fields: + - Title + - Description + - Requirements + - Test Steps + - Expected Result +- Attaches them as `user_properties` on the test report +- Customizes the HTML results table to include Title and Requirements columns + +## Docstring format to use + +```python +""" +Title: Short, human-readable test name + +Description: What is this test proving and why does it matter. + +Requirements: REQ-001, REQ-00X + +Test Steps: +1. Describe the first step +2. Next step +3. etc. + +Expected Result: +- Primary outcome +- Any additional acceptance criteria +""" +``` + +## What appears in reports + +- HTML (`reports/report.html`): + - Title and Requirements appear as columns in the table + - Other fields are available in the report payload and can be surfaced with minor tweaks +- JUnit XML (`reports/junit.xml`): + - Standard test results and timing + - Note: By default, the XML is compact and does not include custom properties; if you need properties in XML, we can extend the plugin to emit a custom JUnit format or produce an additional JSON artifact for traceability. + +Open the HTML report on Windows PowerShell: + +```powershell +start .\reports\report.html +``` + +Related artifacts written by the plugin: +- `reports/requirements_coverage.json` — requirement → test nodeids map and unmapped tests +- `reports/summary.md` — compact pass/fail/error/skip totals, environment info + +To generate separate HTML/JUnit reports for unit vs non-unit test sets, use the helper script: + +```powershell +./scripts/run_two_reports.ps1 +``` + +## Parameterized tests and metadata + +When using `@pytest.mark.parametrize`, each parameter set is treated as a distinct test case with its own nodeid, e.g.: + +``` +tests/test_babylin_wrapper_mock.py::test_babylin_master_request_with_mock_wrapper[wrapper0-True] +tests/test_babylin_wrapper_mock.py::test_babylin_master_request_with_mock_wrapper[wrapper1-False] +``` + +Metadata handling: +- The docstring on the test function is parsed once per case; the same Title/Requirements are attached to each parameterized instance. +- Requirement mapping (coverage JSON) records each parameterized nodeid under the normalized requirement keys, enabling fine-grained coverage. +- In the HTML table, you will see a row per parameterized instance with identical Title/Requirements but differing nodeids (and potentially differing outcomes if parameters influence behavior). + +## Markers + +Declared in `pytest.ini` and used via `@pytest.mark.` in tests. They also appear in the HTML payload for each test (as user properties) and can be added as a column with a small change if desired. + +## Extensibility + +- Add more columns to HTML by updating `pytest_html_results_table_header/row` +- Persist full metadata (steps, expected) to a JSON file after the run for audit trails +- Populate requirement coverage map by scanning markers and aggregating results diff --git a/docs/04_lin_interface_call_flow.md b/docs/04_lin_interface_call_flow.md new file mode 100644 index 0000000..56b6738 --- /dev/null +++ b/docs/04_lin_interface_call_flow.md @@ -0,0 +1,58 @@ +# LIN Interface Call Flow + +This document explains how LIN operations flow through the abstraction for both Mock and BabyLin adapters. + +## Contract (base) + +File: `ecu_framework/lin/base.py` + +- `connect()` / `disconnect()` +- `send(frame: LinFrame)` +- `receive(id: int | None = None, timeout: float = 1.0) -> LinFrame | None` +- `request(id: int, length: int, timeout: float = 1.0) -> LinFrame | None` +- `flush()` + +`LinFrame` validates: +- ID is 0x00–0x3F (6-bit LIN ID) +- Data length ≤ 8 bytes + +## Mock adapter flow + +File: `ecu_framework/lin/mock.py` + +- `connect()`: initialize buffers and state +- `send(frame)`: enqueues the frame and (for echo behavior) schedules it for RX +- `receive(timeout)`: waits up to timeout for a frame in RX buffer +- `request(id, length, timeout)`: synthesizes a deterministic response of the given length for predictability +- `disconnect()`: clears state + +Use cases: +- Fast local dev, deterministic responses, no hardware +- Timeout and boundary behavior validation + +## BabyLIN adapter flow (SDK wrapper) + +File: `ecu_framework/lin/babylin.py` + +- `connect()`: import SDK `BabyLIN_library.py`, discover ports, open first, optionally `BLC_loadSDF`, get channel handle, and `BLC_sendCommand("start schedule N;")` +- `send(frame)`: calls `BLC_mon_set_xmit(channelHandle, frameId, data, slotTime=0)` +- `receive(timeout)`: calls `BLC_getNextFrameTimeout(channelHandle, timeout_ms)` and converts returned `BLC_FRAME` to `LinFrame` +- `request(id, length, timeout)`: prefers `BLC_sendRawMasterRequest(channel, id, length)`; falls back to `(channel, id, bytes)`; if unavailable, sends a header and waits on `receive()` +- `disconnect()`: calls `BLC_closeAll()` +- Error handling: uses `BLC_getDetailedErrorString` (if available) + +Configuration: +- `interface.sdf_path` locates the SDF to load +- `interface.schedule_nr` sets the schedule to start upon connect +- `interface.channel` selects the channel index + +## Edge considerations + +- Ensure the correct architecture (x86/x64) of the DLL matches Python +- Channel/bitrate must match your network configuration +- Some SDKs require initialization/scheduling steps before transmit/receive +- Time synchronization and timestamp units vary per SDK — convert as needed + +Note on master requests: +- Our mock wrapper returns a deterministic byte pattern when called with the `length` signature. +- When only the bytes signature is available, zeros of the requested length are used in tests. diff --git a/docs/05_architecture_overview.md b/docs/05_architecture_overview.md new file mode 100644 index 0000000..da3104c --- /dev/null +++ b/docs/05_architecture_overview.md @@ -0,0 +1,66 @@ +# Architecture Overview + +This document provides a high-level view of the framework’s components and how they interact, plus a Mermaid diagram for quick orientation. + +## Components + +- Tests (pytest) — test modules and functions under `tests/` +- Fixtures — defined in `tests/conftest.py` (config, lin, flash_ecu) +- Config Loader — `ecu_framework/config.py` (YAML → dataclasses) +- LIN Abstraction — `ecu_framework/lin/base.py` (`LinInterface`, `LinFrame`) +- Mock LIN Adapter — `ecu_framework/lin/mock.py` +- BabyLIN Adapter — `ecu_framework/lin/babylin.py` (SDK wrapper → BabyLIN_library.py) +- Flasher — `ecu_framework/flashing/hex_flasher.py` +- Reporting Plugin — `conftest_plugin.py` (docstring → report metadata) +- Reports — `reports/report.html`, `reports/junit.xml` + +## Mermaid architecture diagram + +```mermaid +flowchart TB + subgraph Tests & Pytest + T[tests/*] + CF[tests/conftest.py] + PL[conftest_plugin.py] + end + + subgraph Framework + CFG[ecu_framework/config.py] + BASE[ecu_framework/lin/base.py] + MOCK[ecu_framework/lin/mock.py] + BABY[ecu_framework/lin/babylin.py] + FLASH[ecu_framework/flashing/hex_flasher.py] + end + + subgraph Artifacts + REP[reports/report.html]\nreports/junit.xml + YAML[config/*.yaml]\n(babylin.example.yaml, test_config.yaml) + DLL[vendor/babylin/BabyLIN.dll] + end + + T --> CF + CF --> CFG + CF --> BASE + CF --> MOCK + CF --> BABY + CF --> FLASH + PL --> REP + + CFG --> YAML + BABY --> DLL + T --> REP +``` + +## Data and control flow summary + +- Tests use fixtures to obtain config and a connected LIN adapter +- Config loader reads YAML (or env override), returns typed dataclasses +- LIN calls are routed through the interface abstraction to the selected adapter +- Flasher (optional) uses the same interface to program the ECU +- Reporting plugin parses docstrings and enriches the HTML report + +## Extending the architecture + +- Add new bus adapters by implementing `LinInterface` +- Add new report sinks (e.g., JSON or a DB) by extending the plugin +- Add new fixtures for diagnostics or measurement tools (Scopes, power supplies, etc.) diff --git a/docs/06_requirement_traceability.md b/docs/06_requirement_traceability.md new file mode 100644 index 0000000..a01260b --- /dev/null +++ b/docs/06_requirement_traceability.md @@ -0,0 +1,60 @@ +# Requirement Traceability + +This document shows how requirements map to tests via pytest markers and docstrings, plus how to visualize coverage. + +## Conventions + +- Requirement IDs: `REQ-xxx` +- Use markers in tests: `@pytest.mark.req_001`, `@pytest.mark.req_002`, etc. +- Include readable requirement list in the test docstring under `Requirements:` + +## Example + +```python +@pytest.mark.req_001 +@pytest.mark.req_003 +""" +Title: Mock LIN Interface - Send/Receive Echo Test +Requirements: REQ-001, REQ-003 +""" +``` + +## Mermaid: Requirement → Tests map + +Note: This is illustrative; maintain it as your suite grows. + +```mermaid +flowchart LR + R1[REQ-001: LIN Basic Ops] + R2[REQ-002: Master Request/Response] + R3[REQ-003: Frame Validation] + R4[REQ-004: Timeout Handling] + + T1[test_mock_send_receive_echo] + T2[test_mock_request_synthesized_response] + T3[test_mock_receive_timeout_behavior] + T4[test_mock_frame_validation_boundaries] + + R1 --> T1 + R3 --> T1 + R2 --> T2 + R4 --> T3 + R1 --> T4 + R3 --> T4 +``` + +## Generating a live coverage artifact (optional) + +You can extend `conftest_plugin.py` to emit a JSON file with requirement-to-test mapping at the end of a run by scanning markers and docstrings. This can fuel dashboards or CI gates. + +Suggested JSON shape: + +```json +{ + "requirements": { + "REQ-001": ["tests/test_smoke_mock.py::TestMockLinInterface::test_mock_send_receive_echo", "..."] + }, + "uncovered": ["REQ-010", "REQ-012"] +} +``` + diff --git a/docs/07_flash_sequence.md b/docs/07_flash_sequence.md new file mode 100644 index 0000000..b573c1e --- /dev/null +++ b/docs/07_flash_sequence.md @@ -0,0 +1,57 @@ +# Flashing Sequence (ECU Programming) + +This document outlines the expected flashing workflow using the `HexFlasher` scaffold over the LIN interface and where you can plug in your production flasher (UDS/XCP). + +## Overview + +- Flashing is controlled by configuration (`flash.enabled`, `flash.hex_path`) +- The `flash_ecu` session fixture invokes the flasher before tests +- The flasher uses the same `LinInterface` as tests + +## Mermaid sequence + +```mermaid +sequenceDiagram + autonumber + participant P as pytest + participant F as flash_ecu fixture + participant H as HexFlasher + participant L as LinInterface (mock/babylin) + participant E as ECU + + P->>F: Evaluate flashing precondition + alt flash.enabled == true and hex_path provided + F->>H: HexFlasher(lin).flash_hex(hex_path) + H->>L: connect (ensure session ready) + H->>E: Enter programming session (UDS/XCP) + H->>E: Erase memory (as required) + loop For each block in HEX + H->>L: Transfer block via LIN frames + L-->>H: Acks / flow control + end + H->>E: Verify checksum / signature + H->>E: Exit programming, reset if needed + H-->>F: Return success/failure + else + F-->>P: Skip flashing + end +``` + +## Implementation notes + +- `ecu_framework/flashing/hex_flasher.py` is a stub — replace with your protocol implementation (UDS/XCP) +- Validate timing requirements and chunk sizes per ECU +- Consider power-cycle/reset hooks via an external rig if required + +## Error handling + +- On failure, the fixture calls `pytest.fail("ECU flashing failed")` +- Make flashing idempotent when possible (can retry or detect current version) + +## Configuration example + +```yaml +flash: + enabled: true + hex_path: "firmware/ecu_firmware.hex" +``` diff --git a/docs/08_babylin_internals.md b/docs/08_babylin_internals.md new file mode 100644 index 0000000..9955291 --- /dev/null +++ b/docs/08_babylin_internals.md @@ -0,0 +1,102 @@ +# BabyLIN Adapter Internals (SDK Python wrapper) + +This document describes how the real hardware adapter binds to the BabyLIN SDK via the official Python wrapper `BabyLIN_library.py` and how frames move across the boundary. + +## Overview + +- Location: `ecu_framework/lin/babylin.py` +- Uses the SDK's `BabyLIN_library.py` (place under `vendor/` or on `PYTHONPATH`) +- Discovers and opens a BabyLIN device using `BLC_getBabyLinPorts` and `BLC_openPort` +- Optionally loads an SDF via `BLC_loadSDF(handle, sdf_path, 1)` and starts a schedule with `BLC_sendCommand("start schedule N;")` +- Converts between Python `LinFrame` and the wrapper's `BLC_FRAME` structure for receive + +## Mermaid: SDK connect sequence + +```mermaid +sequenceDiagram + autonumber + participant T as Tests/Fixture + participant A as BabyLinInterface (SDK) + participant BL as BabyLIN_library (BLC_*) + + T->>A: connect() + A->>BL: BLC_getBabyLinPorts(100) + BL-->>A: [port0, ...] + A->>BL: BLC_openPort(port0) + A->>BL: BLC_loadSDF(handle, sdf_path, 1) + A->>BL: BLC_getChannelHandle(handle, channelIndex) + A->>BL: BLC_sendCommand(channel, "start schedule N;") + A-->>T: connected +``` + +## Mermaid: Binding and call flow + +```mermaid +sequenceDiagram + autonumber + participant T as Test + participant L as LinInterface (BabyLin) + participant D as BabyLIN_library (BLC_*) + + T->>L: connect() + L->>D: BLC_getBabyLinPorts(); BLC_openPort(port) + D-->>L: handle/ok + + T->>L: send(frame) + L->>D: BLC_mon_set_xmit(channelHandle, frameId, data, slotTime=0) + D-->>L: code (0=ok) + + T->>L: receive(timeout) + L->>D: BLC_getNextFrameTimeout(channelHandle, timeout_ms) + D-->>L: code, frame + L->>L: convert BLC_FRAME → LinFrame + L-->>T: LinFrame or None + + T->>L: disconnect() + L->>D: BLC_closeAll() +``` + +## Master request behavior + +When performing a master request, the adapter tries the SDK method in this order: + +1. `BLC_sendRawMasterRequest(channel, id, length)` — preferred +2. `BLC_sendRawMasterRequest(channel, id, dataBytes)` — fallback +3. Send a header with zeros and wait on `receive()` — last resort + +Mock behavior notes: +- The provided mock (`vendor/mock_babylin_wrapper.py`) synthesizes a deterministic response for the `length` signature (e.g., data[i] = (id + i) & 0xFF). +- For the bytes-only signature, the adapter sends zero-filled bytes of the requested length and validates by length. +## Wrapper usage highlights + +```python +from BabyLIN_library import create_BabyLIN + +bl = create_BabyLIN() +ports = bl.BLC_getBabyLinPorts(100) +h = bl.BLC_openPort(ports[0]) +bl.BLC_loadSDF(h, "Example.sdf", 1) +ch = bl.BLC_getChannelHandle(h, 0) +bl.BLC_sendCommand(ch, "start schedule 0;") + +# Transmit and receive +bl.BLC_mon_set_xmit(ch, 0x10, bytes([1,2,3,4]), 0) +frm = bl.BLC_getNextFrameTimeout(ch, 100) +print(frm.frameId, list(frm.frameData)[:frm.lenOfData]) + +bl.BLC_closeAll() +``` + +## Notes and pitfalls + +- Architecture: Ensure Python (x86/x64) matches the platform library bundled with the SDK +- Timeouts: SDKs typically want milliseconds; convert Python seconds accordingly +- Error handling: On non-zero return codes, use `BLC_getDetailedErrorString` (if available) for human-readable messages +- Threading: If you use background receive threads, protect buffers with locks +- Performance: Avoid excessive allocations in tight loops; reuse frame structs when possible + +## Extending + +- Add bitrate/channel setup functions as exposed by the SDK +- Implement schedule tables or diagnostics passthrough if provided by the SDK +- Wrap more SDK errors into typed Python exceptions for clarity diff --git a/docs/09_raspberry_pi_deployment.md b/docs/09_raspberry_pi_deployment.md new file mode 100644 index 0000000..7bdb57b --- /dev/null +++ b/docs/09_raspberry_pi_deployment.md @@ -0,0 +1,144 @@ +# Raspberry Pi Deployment Guide + +This guide explains how to run the ECU testing framework on a Raspberry Pi (Debian/Raspberry Pi OS). It covers environment setup, optional BabyLin hardware integration, running tests headless, and installing as a systemd service. + +> Note: If you plan to use BabyLin hardware on a Pi, verify vendor driver support for ARM Linux. If BabyLin provides only Windows DLLs, use the Mock interface on Pi or deploy a different hardware interface that supports Linux/ARM. + +## 1) Choose your interface + +- Mock (recommended for headless/dev on Pi): `interface.type: mock` +- BabyLIN (only if ARM/Linux support is available): `interface.type: babylin` and ensure the SDK's `BabyLIN_library.py` and corresponding Linux/ARM shared libraries are available under `vendor/` or on PYTHONPATH/LD_LIBRARY_PATH. + +## 2) Install prerequisites + +```bash +sudo apt update +sudo apt install -y python3 python3-venv python3-pip git +``` + +Optional (for BabyLin or USB tools): +```bash +sudo apt install -y libusb-1.0-0 udev +``` + +## 3) Clone and set up + +```bash +# clone your repo +git clone ~/ecu_tests +cd ~/ecu_tests + +# create venv +python3 -m venv .venv +source .venv/bin/activate + +# install deps +pip install -r requirements.txt +``` + +## 4) Configure + +Create or edit `config/test_config.yaml`: + +```yaml +interface: + type: mock # or babylin (if supported on ARM/Linux) + channel: 1 + bitrate: 19200 +flash: + enabled: false +``` + +Optionally point to another config file via env var: +```bash +export ECU_TESTS_CONFIG=$(pwd)/config/test_config.yaml +``` + +If using BabyLIN on Linux/ARM with the SDK wrapper, set: +```yaml +interface: + type: babylin + channel: 0 + sdf_path: "/home/pi/ecu_tests/vendor/Example.sdf" + schedule_nr: 0 +``` + +## 5) Run tests on Pi + +```bash +source .venv/bin/activate +python -m pytest -m "not hardware" -v +``` + +Artifacts are in `reports/` (HTML, JUnit, JSON, summary MD). + +## 6) Run as a systemd service (headless) + +This section lets the Pi run the test suite on boot or on demand. + +### Create a runner script + +Create `scripts/run_tests.sh`: +```bash +#!/usr/bin/env bash +set -euo pipefail +cd "$(dirname "$0")/.." +source .venv/bin/activate +# optionally set custom config +# export ECU_TESTS_CONFIG=$(pwd)/config/test_config.yaml +python -m pytest -v +``` +Make it executable: +```bash +chmod +x scripts/run_tests.sh +``` + +### Create a systemd unit + +Create `scripts/ecu-tests.service`: +```ini +[Unit] +Description=ECU Tests Runner +After=network-online.target +Wants=network-online.target + +[Service] +Type=oneshot +WorkingDirectory=/home/pi/ecu_tests +ExecStart=/home/pi/ecu_tests/scripts/run_tests.sh +User=pi +Group=pi +Environment=ECU_TESTS_CONFIG=/home/pi/ecu_tests/config/test_config.yaml +# Capture output to a log file +StandardOutput=append:/home/pi/ecu_tests/reports/service.log +StandardError=append:/home/pi/ecu_tests/reports/service.err + +[Install] +WantedBy=multi-user.target +``` + +Install and run: +```bash +sudo mkdir -p /home/pi/ecu_tests/reports +sudo cp scripts/ecu-tests.service /etc/systemd/system/ecu-tests.service +sudo systemctl daemon-reload +sudo systemctl enable ecu-tests.service +# Start manually +sudo systemctl start ecu-tests.service +# Check status +systemctl status ecu-tests.service +``` + +## 7) USB and permissions (if using hardware) + +- Create udev rules for your device (if required by vendor) +- Add user to dialout or plugdev groups if serial/USB access is needed +- Confirm your hardware library is found by Python and the dynamic linker: + - Ensure `vendor/BabyLIN_library.py` is importable (add `vendor/` to PYTHONPATH if needed) + - Ensure `.so` files are discoverable (e.g., place in `/usr/local/lib` and run `sudo ldconfig`, or set `LD_LIBRARY_PATH`) + +## 8) Tips + +- Use the mock interface on Pi for quick smoke tests and documentation/report generation +- For full HIL, ensure vendor SDK supports Linux/ARM and provide a shared object (`.so`) and headers +- If only Windows is supported, run the hardware suite on a Windows host and use the Pi for lightweight tasks (archiving, reporting, quick checks) diff --git a/docs/10_build_custom_image.md b/docs/10_build_custom_image.md new file mode 100644 index 0000000..93fcbcf --- /dev/null +++ b/docs/10_build_custom_image.md @@ -0,0 +1,80 @@ +# Build a Custom Raspberry Pi Image with ECU Tests + +This guide walks you through building your own Raspberry Pi OS image that already contains this framework, dependencies, config, and services. It uses the official pi-gen tool (used by Raspberry Pi OS) or the simpler pi-gen-lite alternatives. + +> Important: BabyLin support on ARM/Linux depends on vendor SDKs. If no `.so` is provided for ARM, either use the Mock interface on the Pi, or keep hardware tests on Windows. + +## Approach A: Using pi-gen (official) + +1. Prepare a build host (Debian/Ubuntu) + ```bash + sudo apt update && sudo apt install -y git coreutils quilt parted qemu-user-static debootstrap zerofree \ + pxz zip dosfstools libcap2-bin grep rsync xz-utils file bc curl jq + ``` +2. Clone pi-gen + ```bash + git clone https://github.com/RPi-Distro/pi-gen.git + cd pi-gen + ``` +3. Create a custom stage for ECU Tests (e.g., `stage2/02-ecu-tests/`): + - `00-packages` (optional OS deps like python3, libusb-1.0-0) + - `01-run.sh` to clone your repo, create venv, install deps, and set up systemd units + + Example `01-run.sh` contents: + ```bash + #!/bin/bash -e + REPO_DIR=/home/pi/ecu_tests + sudo -u pi git clone "$REPO_DIR" + cd "$REPO_DIR" + sudo -u pi python3 -m venv .venv + sudo -u pi bash -lc "source .venv/bin/activate && pip install --upgrade pip && pip install -r requirements.txt" + sudo mkdir -p "$REPO_DIR/reports" + sudo chown -R pi:pi "$REPO_DIR/reports" + sudo install -Dm644 "$REPO_DIR/scripts/ecu-tests.service" /etc/systemd/system/ecu-tests.service + sudo install -Dm644 "$REPO_DIR/scripts/ecu-tests.timer" /etc/systemd/system/ecu-tests.timer + sudo systemctl enable ecu-tests.service + sudo systemctl enable ecu-tests.timer || true + # Optional udev rules + if [ -f "$REPO_DIR/scripts/99-babylin.rules" ]; then + sudo install -Dm644 "$REPO_DIR/scripts/99-babylin.rules" /etc/udev/rules.d/99-babylin.rules + fi + ``` +4. Configure build options (`config` file in pi-gen root): + ```bash + IMG_NAME=ecu-tests-os + ENABLE_SSH=1 + STAGE_LIST="stage0 stage1 stage2" # include your custom stage2 additions + ``` +5. Build + ```bash + sudo ./build.sh + ``` +6. Flash the resulting `.img` to SD card with `Raspberry Pi Imager` or `dd`. + +## Approach B: Preseed on first boot (lighter) + +- Ship a minimal Raspberry Pi OS image and a cloud-init/user-data or first-boot script that pulls your repo and runs `scripts/pi_install.sh`. +- Pros: Faster iteration; you control repo URL at install time. +- Cons: Requires internet on first boot. + +## CI Integration (optional) + +- You can automate image builds with GitHub Actions or GitLab CI using a Docker runner that executes pi-gen. +- Upload the `.img` as a release asset or pipeline artifact. +- Optionally, bake environment-specific `config/test_config.yaml` or keep it external and set `ECU_TESTS_CONFIG` in the systemd unit. + +## Hardware Notes + +- If using BabyLin, ensure: `.so` for ARM, udev rules, and any kernel modules. +- Validate the SDK wrapper and libraries are present under `/opt/ecu_tests/vendor/` (or your chosen path). Ensure `.so` files are on the linker path (run `sudo ldconfig`) and `BabyLIN_library.py` is importable. + +## Boot-time Behavior + +- The `ecu-tests.timer` can schedule daily or hourly test runs; edit `OnUnitActiveSec` as needed. +- Logs are written to `reports/service.log` and `reports/service.err` on the Pi. + +## Security + +- Consider read-only root filesystem for robustness. +- Use a dedicated user with limited privileges for test execution. +- Keep secrets (if any) injected via environment and not committed. diff --git a/docs/11_conftest_plugin_overview.md b/docs/11_conftest_plugin_overview.md new file mode 100644 index 0000000..2f46ba5 --- /dev/null +++ b/docs/11_conftest_plugin_overview.md @@ -0,0 +1,90 @@ +# Pytest Plugin: Reporting & Traceability Overview + +This guide explains the custom pytest plugin in `conftest_plugin.py` that enriches reports with business-facing metadata and builds requirements traceability artifacts. + +## What it does + +- Extracts metadata (Title, Description, Requirements, Test Steps, Expected Result) from test docstrings and markers. +- Attaches this metadata as `user_properties` on each test report. +- Adds custom columns (Title, Requirements) to the HTML report. +- Produces two artifacts under `reports/` at the end of the run: + - `requirements_coverage.json`: a traceability matrix mapping requirement IDs to test nodeids, plus unmapped tests. + - `summary.md`: a compact summary of results suitable for CI dashboards or PR comments. + +## Inputs and sources + +- Test docstrings prefixed lines: + - `Title:` one-line title + - `Description:` free-form text until the next section + - `Requirements:` comma- or space-separated tokens such as `REQ-001`, `req_002` + - `Test Steps:` numbered list (1., 2., 3., ...) + - `Expected Result:` free-form text +- Pytest markers on tests: `@pytest.mark.req_001` etc. are normalized to `REQ-001`. + +## Normalization logic + +Requirement IDs are normalized to the canonical form `REQ-XYZ` using: +- `req_001` → `REQ-001` +- `REQ-1` / `REQ-001` / `REQ_001` → `REQ-001` + +This ensures consistent keys in the coverage JSON and HTML. + +## Hook call sequence + +Below is the high-level call sequence of relevant plugin hooks during a typical run: + +```mermaid +sequenceDiagram + autonumber + participant Pytest + participant Plugin as conftest_plugin + + Pytest->>Plugin: pytest_configure(config) + Note right of Plugin: Ensure ./reports exists + + Pytest->>Plugin: pytest_collection_modifyitems(session, config, items) + Note right of Plugin: Track all collected nodeids for unmapped detection + + loop For each test phase + Pytest->>Plugin: pytest_runtest_makereport(item, call) + Note right of Plugin: hookwrapper + Plugin-->>Pytest: yield to get report + Plugin->>Plugin: parse docstring & markers + Plugin->>Plugin: attach user_properties (Title, Requirements, ...) + Plugin->>Plugin: update _REQ_TO_TESTS, _MAPPED_TESTS + end + + Pytest->>Plugin: pytest_terminal_summary(terminalreporter, exitstatus) + Plugin->>Plugin: compile stats, coverage map, unmapped tests + Plugin->>FS: write reports/requirements_coverage.json + Plugin->>FS: write reports/summary.md +``` + +## HTML report integration + +- `pytest_html_results_table_header`: inserts Title and Requirements columns. +- `pytest_html_results_table_row`: fills in values from `report.user_properties`. + +The HTML plugin reads `user_properties` to render the extra metadata per test row. + +## Artifacts + +- `reports/requirements_coverage.json` + - `generated_at`: ISO timestamp + - `results`: counts of passed/failed/skipped/etc. + - `requirements`: map of `REQ-XXX` to an array of test nodeids + - `unmapped_tests`: tests with no requirement mapping + - `files`: relative locations of key artifacts +- `reports/summary.md` + - Human-readable summary with counts and quick artifact links + +## Error handling + +Artifact writes are wrapped in try/except to avoid failing the test run if the filesystem is read-only or unavailable. Any write failure is logged to the terminal. + +## Extensibility ideas + +- Add more normalized marker families (e.g., `capability_*`, `risk_*`). +- Emit CSV or Excel in addition to JSON/Markdown. +- Include per-test durations and flakiness stats in the summary. +- Support a `--requirement` CLI filter that selects tests by normalized req IDs. diff --git a/docs/12_using_the_framework.md b/docs/12_using_the_framework.md new file mode 100644 index 0000000..50156f9 --- /dev/null +++ b/docs/12_using_the_framework.md @@ -0,0 +1,172 @@ +# Using the ECU Test Framework + +This guide shows common ways to run the test framework: from fast local mock runs to full hardware loops, CI, and Raspberry Pi deployments. Commands use Windows PowerShell (as your default shell). + +## Prerequisites + +- Python 3.x and a virtual environment +- Dependencies installed (see `requirements.txt`) +- Optional: BabyLIN SDK files placed under `vendor/` as described in `vendor/README.md` when running hardware tests + +## Configuring tests + +- Configuration is loaded from YAML files and can be selected via the environment variable `ECU_TESTS_CONFIG`. +- See `docs/02_configuration_resolution.md` for details and examples. + +Example PowerShell: + +```powershell +# Use a mock-only config for fast local runs +$env:ECU_TESTS_CONFIG = ".\config\mock.yml" + +# Use a hardware config with BabyLIN SDK wrapper +$env:ECU_TESTS_CONFIG = ".\config\hardware_babylin.yml" +``` + +Quick try with provided examples: + +```powershell +# Point to the combined examples file +$env:ECU_TESTS_CONFIG = ".\config\examples.yaml" +# The 'active' section defaults to the mock profile; run non-hardware tests +pytest -m "not hardware" -v +# Edit 'active' to the babylin profile (or point to babylin.example.yaml) and run hardware tests +``` +``` + +## Running locally (mock interface) + +Use the mock interface to develop tests quickly without hardware: + +```powershell +# Run all mock tests with HTML and JUnit outputs (see pytest.ini defaults) +pytest + +# Run only smoke tests (mock) and show progress +pytest -m smoke -q + +# Filter by test file or node id +pytest tests\test_smoke_mock.py::TestMockLinInterface::test_mock_send_receive_echo -q +``` + +What you get: +- Fast execution, deterministic results +- Reports in `reports/` (HTML, JUnit, coverage JSON, CI summary) + +Open the HTML report on Windows: + +```powershell +start .\reports\report.html +``` + +## Running on hardware (BabyLIN SDK wrapper) + +1) Place SDK files per `vendor/README.md`. +2) Select a config that defines `interface.type: babylin`, `sdf_path`, and `schedule_nr`. +3) Markers allow restricting to hardware tests. + +```powershell +# Example environment selection +$env:ECU_TESTS_CONFIG = ".\config\babylin.example.yaml" + +# Run only hardware tests +pytest -m "hardware and babylin" + +# Run the schedule smoke only +pytest tests\test_babylin_hardware_schedule_smoke.py -q +``` + +Tips: +- If multiple devices are attached, update your config to select the desired port (future enhancement) or keep only one connected. +- On timeout, tests often accept None to avoid flakiness; increase timeouts if your bus is slow. +- Master request behavior: the adapter prefers `BLC_sendRawMasterRequest(channel, id, length)`; it falls back to the bytes variant or a header+receive strategy as needed. The mock covers both forms. + +## Selecting tests with markers + +Markers in use: +- `smoke`: quick confidence tests +- `hardware`: needs real device +- `babylin`: targets the BabyLIN SDK adapter +- `req_XXX`: requirement mapping (e.g., `@pytest.mark.req_001`) + +Examples: + +```powershell +# Only smoke tests (mock + hardware smoke) +pytest -m smoke + +# Requirements-based selection (docstrings and markers are normalized) +pytest -k REQ-001 +``` + +## Enriched reporting + +- HTML report includes custom columns (Title, Requirements) +- JUnit XML written for CI +- `reports/requirements_coverage.json` maps requirement IDs to tests and lists unmapped tests +- `reports/summary.md` aggregates key counts (pass/fail/etc.) + +See `docs/03_reporting_and_metadata.md` and `docs/11_conftest_plugin_overview.md`. + +To verify the reporting pipeline end-to-end, run the plugin self-test: + +```powershell +python -m pytest tests\plugin\test_conftest_plugin_artifacts.py -q +``` + +To generate two separate HTML/JUnit reports (unit vs non-unit): + +```powershell +./scripts/run_two_reports.ps1 +``` + +## Writing well-documented tests + +Use a docstring template so the plugin can extract metadata: + +```python +""" +Title: + +Description: + + +Requirements: REQ-001, REQ-002 + +Test Steps: + 1. + 2. + +Expected Result: + +""" +``` + +## Continuous Integration (CI) + +- Run `pytest` with your preferred markers in your pipeline. +- Publish artifacts from `reports/` (HTML, JUnit, coverage JSON, summary.md). +- Optionally parse `requirements_coverage.json` to power dashboards and gates. + +Example PowerShell (local CI mimic): + +```powershell +# Run smoke tests and collect reports +pytest -m smoke --maxfail=1 -q +``` + +## Raspberry Pi / Headless usage + +- Follow `docs/09_raspberry_pi_deployment.md` to set up a venv and systemd service +- For a golden image approach, see `docs/10_build_custom_image.md` + +Running tests headless via systemd typically involves: +- A service that sets `ECU_TESTS_CONFIG` to a hardware YAML +- Running `pytest -m "hardware and babylin"` on boot or via timer + +## Troubleshooting quick hits + +- ImportError for `BabyLIN_library`: verify placement under `vendor/` and native library presence. +- No BabyLIN devices found: check USB connection, drivers, and permissions. +- Timeouts on receive: increase `timeout` or verify schedule activity and SDF correctness. +- Missing reports: ensure `pytest.ini` includes the HTML/JUnit plugins and the custom plugin is loaded. diff --git a/docs/13_unit_testing_guide.md b/docs/13_unit_testing_guide.md new file mode 100644 index 0000000..84afd44 --- /dev/null +++ b/docs/13_unit_testing_guide.md @@ -0,0 +1,125 @@ +# Unit Testing Guide + +This guide explains how the project's unit tests are organized, how to run them (with and without markers), how coverage is generated, and tips for writing effective tests. + +## Why unit tests? + +- Fast feedback without hardware +- Validate contracts (config loader, frames, adapters, flashing scaffold) +- Keep behavior stable as the framework evolves + +## Test layout + +- `tests/unit/` — pure unit tests (no hardware, no external I/O) + - `test_config_loader.py` — config precedence and defaults + - `test_linframe.py` — `LinFrame` validation + - `test_babylin_adapter_mocked.py` — BabyLIN adapter error paths with a mocked SDK wrapper + - `test_hex_flasher.py` — flashing scaffold against a stub LIN interface +- `tests/plugin/` — plugin self-tests using `pytester` + - `test_conftest_plugin_artifacts.py` — verifies JSON coverage and summary artifacts +- `tests/` — existing smoke/mock/hardware tests + +## Markers and selection + +A `unit` marker is provided for easy selection: + +- By marker (recommended): + +```powershell +pytest -m unit -q +``` + +- By path: + +```powershell +pytest tests\unit -q +``` + +- Exclude hardware: + +```powershell +pytest -m "not hardware" -v +``` + +## Coverage + +Coverage is enabled by default via `pytest.ini` addopts: + +- `--cov=ecu_framework --cov-report=term-missing` + +You’ll see a summary with missing lines directly in the terminal. To disable coverage locally, override addopts on the command line: + +```powershell +pytest -q -o addopts="" +``` + +(Optional) To produce an HTML coverage report, you can add `--cov-report=html` and open `htmlcov/index.html`. + +## Writing unit tests + +- Prefer small, focused tests +- For BabyLIN adapter logic, inject `wrapper_module` with the mock: + +```python +from ecu_framework.lin.babylin import BabyLinInterface +from vendor import mock_babylin_wrapper as mock_bl + +lin = BabyLinInterface(wrapper_module=mock_bl) +lin.connect() +# exercise send/receive/request +``` + +- To simulate specific SDK signatures, use a thin shim (see `_MockBytesOnly` in `tests/test_babylin_wrapper_mock.py`). +- Include a docstring with Title/Description/Requirements/Steps/Expected Result so the reporting plugin can extract metadata (this also helps the HTML report). +- When testing the plugin itself, use the `pytester` fixture to generate a temporary test run and validate artifacts exist and contain expected entries. + +## Typical commands (Windows PowerShell) + +- Run unit tests with coverage: + +```powershell +pytest -m unit -q +``` + +- Run only plugin self-tests: + +```powershell +pytest tests\plugin -q +``` + +- Run the specific plugin artifact test (verifies HTML/JUnit, summary, and coverage JSON under `reports/`): + +```powershell +python -m pytest tests\plugin\test_conftest_plugin_artifacts.py -q +``` + +- Run all non-hardware tests with verbose output: + +```powershell +pytest -m "not hardware" -v +``` + +- Open the HTML report: + +```powershell +start .\reports\report.html +``` + +- Generate two separate reports (unit vs non-unit): + +```powershell +./scripts/run_two_reports.ps1 +``` + +## CI suggestions + +- Run `-m unit` and `tests/plugin` on every PR +- Optionally run mock integration/smoke on PR +- Run hardware test matrix on a nightly or on-demand basis (`-m "hardware and babylin"`) +- Publish artifacts from `reports/`: HTML/JUnit/coverage JSON/summary MD + +## Troubleshooting + +- Coverage not showing: ensure `pytest-cov` is installed (see `requirements.txt`) and `pytest.ini` addopts include `--cov`. +- Import errors: activate the venv and reinstall requirements. +- Plugin artifacts missing under `pytester`: verify tests write to `reports/` (our plugin creates the folder automatically in `pytest_configure`). diff --git a/docs/DEVELOPER_COMMIT_GUIDE.md b/docs/DEVELOPER_COMMIT_GUIDE.md new file mode 100644 index 0000000..bfe1e12 --- /dev/null +++ b/docs/DEVELOPER_COMMIT_GUIDE.md @@ -0,0 +1,71 @@ +# Developer Commit Guide + +This guide explains exactly what to commit to source control for this repository, and what to keep out. It also includes a suggested commit message and safe commands to stage changes. + +## Commit these files + +### Core framework (source) +- `ecu_framework/config.py` +- `ecu_framework/lin/base.py` +- `ecu_framework/lin/mock.py` +- `ecu_framework/lin/babylin.py` +- `ecu_framework/flashing/hex_flasher.py` + +### Pytest plugin and config +- `conftest_plugin.py` + Generates HTML columns, requirements coverage JSON, and CI summary +- `pytest.ini` +- `requirements.txt` + +### Tests and fixtures +- `tests/conftest.py` +- `tests/test_smoke_mock.py` +- `tests/test_babylin_hardware_smoke.py` (if present) +- `tests/test_hardware_placeholder.py` (if present) + +### Documentation +- `README.md` +- `TESTING_FRAMEWORK_GUIDE.md` +- `docs/README.md` +- `docs/01_run_sequence.md` +- `docs/02_configuration_resolution.md` +- `docs/03_reporting_and_metadata.md` +- `docs/04_lin_interface_call_flow.md` +- `docs/05_architecture_overview.md` +- `docs/06_requirement_traceability.md` +- `docs/07_flash_sequence.md` +- `docs/08_babylin_internals.md` + +### Vendor guidance (no binaries) +- `vendor/README.md` +- Any headers in `vendor/` (if added per SDK) + +### Housekeeping +- `.gitignore` + Ignores reports and vendor binaries +- `reports/.gitkeep` + Retains folder structure without committing artifacts + +## Do NOT commit (ignored or should be excluded) + +- Virtual environments: `.venv/`, `venv/`, etc. +- Generated test artifacts: + `reports/report.html`, `reports/junit.xml`, `reports/summary.md`, `reports/requirements_coverage.json` + +- Python caches: `__pycache__/`, `.pytest_cache/` +- Local env files: `.env` + +## Safe commit commands (PowerShell) + +```powershell +# Stage everything except what .gitignore already excludes +git add -A + +# Commit with a helpful message +git commit -m "ECU framework: docs, reporting plugin (HTML metadata + requirements JSON + CI summary), .gitignore updates" +``` + +## Notes + + +- The plugin writes CI-friendly artifacts into `reports/`; they’re ignored by default but published in CI. diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 0000000..7ed8e56 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,23 @@ +# Documentation Index + +A guided tour of the ECU testing framework. Start here: + +1. `01_run_sequence.md` — End-to-end run sequence and call flow +2. `02_configuration_resolution.md` — How configuration is loaded and merged +3. `03_reporting_and_metadata.md` — How test documentation becomes report metadata +4. `11_conftest_plugin_overview.md` — Custom pytest plugin: hooks, call sequence, and artifacts +5. `04_lin_interface_call_flow.md` — LIN abstraction and adapter behavior (Mock vs BabyLIN SDK wrapper) +6. `05_architecture_overview.md` — High-level architecture and components +7. `06_requirement_traceability.md` — Requirement markers and coverage visuals +8. `07_flash_sequence.md` — ECU flashing workflow and sequence diagram +9. `08_babylin_internals.md` — BabyLIN SDK wrapper internals and call flow +9. `DEVELOPER_COMMIT_GUIDE.md` — What to commit vs ignore, commands +10. `09_raspberry_pi_deployment.md` — Run on Raspberry Pi (venv, service, hardware notes) +11. `10_build_custom_image.md` — Build a custom Raspberry Pi OS image with the framework baked in +12. `12_using_the_framework.md` — Practical usage: local, hardware, CI, and Pi +13. `13_unit_testing_guide.md` — Unit tests layout, markers, coverage, and tips + +Related references: +- Root project guide: `../README.md` +- Full framework guide: `../TESTING_FRAMEWORK_GUIDE.md` +- BabyLIN placement and integration: `../vendor/README.md` diff --git a/ecu_framework/__init__.py b/ecu_framework/__init__.py new file mode 100644 index 0000000..9e6104f --- /dev/null +++ b/ecu_framework/__init__.py @@ -0,0 +1,6 @@ +__all__ = [ + "config", + "lin", +] + +__version__ = "0.1.0" diff --git a/ecu_framework/config.py b/ecu_framework/config.py new file mode 100644 index 0000000..7f61545 --- /dev/null +++ b/ecu_framework/config.py @@ -0,0 +1,153 @@ +from __future__ import annotations # Postponed annotations for forward references and speed + +import os # For environment variables and filesystem checks +import pathlib # Path handling across platforms +from dataclasses import dataclass, field # Lightweight typed containers +from typing import Any, Dict, Optional # Type hints for clarity + +import yaml # Safe YAML parsing for configuration files + + +@dataclass +class FlashConfig: + """Flashing-related configuration. + + enabled: Whether to trigger flashing at session start. + hex_path: Path to the firmware HEX file (if any). + """ + + enabled: bool = False # Off by default + hex_path: Optional[str] = None # No default file path + + +@dataclass +class InterfaceConfig: + """LIN interface configuration. + + type: Adapter type name: "mock" for the simulated adapter, "babylin" for real hardware via SDK. + channel: Channel index to use (0-based in most SDKs); default chosen by project convention. + bitrate: Informational; typically SDF/schedule defines effective bitrate for BabyLIN. + dll_path: Legacy/optional pointer to vendor DLLs when using ctypes (not used by SDK wrapper). + node_name: Optional friendly name for display/logging. + func_names: Legacy mapping for ctypes function names; ignored by SDK wrapper. + sdf_path: Path to the SDF to load on connect (BabyLIN only). + schedule_nr: Schedule index to start after connect (BabyLIN only). + """ + + type: str = "mock" # "mock" or "babylin" + channel: int = 1 # Default channel index (project-specific default) + bitrate: int = 19200 # Typical LIN bitrate; SDF may override + dll_path: Optional[str] = None # Legacy ctypes option; not used with SDK wrapper + node_name: Optional[str] = None # Optional label for node/adapter + func_names: Dict[str, str] = field(default_factory=dict) # Legacy ctypes mapping; safe to leave empty + # SDK wrapper options + sdf_path: Optional[str] = None # Path to SDF file to load (BabyLIN) + schedule_nr: int = 0 # Schedule number to start after connect (BabyLIN) + + +@dataclass +class EcuTestConfig: + """Top-level, fully-typed configuration for the framework. + + interface: Settings for LIN communication (mock or BabyLIN). + flash: Optional flashing behavior configuration. + """ + + interface: InterfaceConfig = field(default_factory=InterfaceConfig) + flash: FlashConfig = field(default_factory=FlashConfig) + + +DEFAULT_CONFIG_RELATIVE = pathlib.Path("config") / "test_config.yaml" # Default config path relative to repo root +ENV_CONFIG_PATH = "ECU_TESTS_CONFIG" # Env var to override config file location + + +def _deep_update(base: Dict[str, Any], updates: Dict[str, Any]) -> Dict[str, Any]: + """Recursively merge dict 'updates' into dict 'base'. + + - Nested dicts are merged by key + - Scalars/collections at any level are replaced entirely + - Mutation occurs in-place on 'base' and the same object is returned + """ + for k, v in updates.items(): # Iterate all update keys + if isinstance(v, dict) and isinstance(base.get(k), dict): # Both sides dict → recurse + base[k] = _deep_update(base[k], v) + else: # Otherwise replace + base[k] = v + return base # Return the mutated base for chaining + + +def _to_dataclass(cfg: Dict[str, Any]) -> EcuTestConfig: + """Convert a merged plain dict config into strongly-typed dataclasses. + + Defensive casting is used to ensure correct types even if YAML contains strings. + """ + iface = cfg.get("interface", {}) # Sub-config for interface + flash = cfg.get("flash", {}) # Sub-config for flashing + return EcuTestConfig( + interface=InterfaceConfig( + type=str(iface.get("type", "mock")).lower(), # Normalize to lowercase + channel=int(iface.get("channel", 1)), # Coerce to int + bitrate=int(iface.get("bitrate", 19200)), # Coerce to int + dll_path=iface.get("dll_path"), # Optional legacy field + node_name=iface.get("node_name"), # Optional friendly name + func_names=dict(iface.get("func_names", {}) or {}), # Ensure a dict + sdf_path=iface.get("sdf_path"), # Optional SDF path + schedule_nr=int(iface.get("schedule_nr", 0)), # Coerce to int + ), + flash=FlashConfig( + enabled=bool(flash.get("enabled", False)), # Coerce to bool + hex_path=flash.get("hex_path"), # Optional hex path + ), + ) + + +def load_config(workspace_root: Optional[str] = None, overrides: Optional[Dict[str, Any]] = None) -> EcuTestConfig: + """Load configuration from YAML file, environment, overrides, or defaults. + + Precedence (highest to lowest): + 1. in-memory 'overrides' dict + 2. YAML file specified by env var ECU_TESTS_CONFIG + 3. YAML at ./config/test_config.yaml (relative to workspace_root) + 4. built-in defaults in this function + """ + # Start with built-in defaults; minimal, safe baseline + base: Dict[str, Any] = { + "interface": { + "type": "mock", # mock by default for developer friendliness + "channel": 1, + "bitrate": 19200, + }, + "flash": { + "enabled": False, + "hex_path": None, + }, + } + + cfg_path: Optional[pathlib.Path] = None # Resolved configuration file path + + # 2) Environment variable can point to any YAML file + env_path = os.getenv(ENV_CONFIG_PATH) + if env_path: + candidate = pathlib.Path(env_path) + if candidate.is_file(): # Only accept existing files + cfg_path = candidate + + # 3) Fallback to default path under the provided workspace root + if cfg_path is None and workspace_root: + candidate = pathlib.Path(workspace_root) / DEFAULT_CONFIG_RELATIVE + if candidate.is_file(): + cfg_path = candidate + + # Load YAML file if we have one + if cfg_path and cfg_path.is_file(): + with open(cfg_path, "r", encoding="utf-8") as f: + file_cfg = yaml.safe_load(f) or {} # Parse YAML safely; empty → {} + if isinstance(file_cfg, dict): # Only merge dicts + _deep_update(base, file_cfg) + + # 1) In-memory overrides always win + if overrides: + _deep_update(base, overrides) + + # Convert to typed dataclasses for ergonomic downstream usage + return _to_dataclass(base) diff --git a/ecu_framework/flashing/__init__.py b/ecu_framework/flashing/__init__.py new file mode 100644 index 0000000..ac037b1 --- /dev/null +++ b/ecu_framework/flashing/__init__.py @@ -0,0 +1,3 @@ +from .hex_flasher import HexFlasher + +__all__ = ["HexFlasher"] diff --git a/ecu_framework/flashing/hex_flasher.py b/ecu_framework/flashing/hex_flasher.py new file mode 100644 index 0000000..6ba1682 --- /dev/null +++ b/ecu_framework/flashing/hex_flasher.py @@ -0,0 +1,25 @@ +from __future__ import annotations + +import pathlib +from typing import Optional + +from ..lin.base import LinInterface + + +class HexFlasher: + """Stubbed ECU flasher over LIN. + + Replace with your actual UDS/XCP flashing sequence. For now, just validates the file exists + and pretends to flash successfully. + """ + + def __init__(self, lin: LinInterface) -> None: + self.lin = lin + + def flash_hex(self, hex_path: str, *, erase: bool = True, verify: bool = True, timeout_s: float = 120.0) -> bool: + path = pathlib.Path(hex_path) + if not path.is_file(): + raise FileNotFoundError(f"HEX file not found: {hex_path}") + # TODO: Implement real flashing over LIN (UDS/XCP). This is a placeholder. + # You might send specific frames or use a higher-level protocol library. + return True diff --git a/ecu_framework/lin/__init__.py b/ecu_framework/lin/__init__.py new file mode 100644 index 0000000..0f06b86 --- /dev/null +++ b/ecu_framework/lin/__init__.py @@ -0,0 +1,8 @@ +from .base import LinInterface, LinFrame +from .mock import MockBabyLinInterface + +__all__ = [ + "LinInterface", + "LinFrame", + "MockBabyLinInterface", +] diff --git a/ecu_framework/lin/babylin.py b/ecu_framework/lin/babylin.py new file mode 100644 index 0000000..726303d --- /dev/null +++ b/ecu_framework/lin/babylin.py @@ -0,0 +1,220 @@ +from __future__ import annotations # Enable postponed evaluation of annotations (PEP 563/649 style) + +from typing import Optional # For optional type hints + +from .base import LinInterface, LinFrame # Base abstraction and frame dataclass used by all LIN adapters + + +class BabyLinInterface(LinInterface): + """LIN adapter that uses the vendor's BabyLIN Python SDK wrapper. + + - Avoids manual ctypes; relies on BabyLIN_library.py BLC_* functions. + - Keeps the same LinInterface contract for send/receive/request/flush. + """ + + def __init__( + self, + dll_path: Optional[str] = None, # Not used by SDK wrapper (auto-selects platform libs) + bitrate: int = 19200, # Informational; typically defined by SDF/schedule + channel: int = 0, # Channel index used with BLC_getChannelHandle (0-based) + node_name: Optional[str] = None, # Optional friendly name (not used by SDK calls) + func_names: Optional[dict] = None, # Legacy (ctypes) compatibility; unused here + sdf_path: Optional[str] = None, # Optional SDF file to load after open + schedule_nr: int = 0, # Schedule number to start after connect + wrapper_module: Optional[object] = None, # Inject a wrapper (e.g., mock) for tests + ) -> None: + self.bitrate = bitrate # Store configured (informational) bitrate + self.channel_index = channel # Desired channel index + self.node_name = node_name or "ECU_TEST_NODE" # Default node name if not provided + self.sdf_path = sdf_path # SDF to load (if provided) + self.schedule_nr = schedule_nr # Schedule to start on connect + + # Choose the BabyLIN wrapper module to use: + # - If wrapper_module provided (unit tests with mock), use it + # - Else dynamically import the real SDK wrapper (BabyLIN_library.py) + if wrapper_module is not None: + _bl = wrapper_module + else: + import importlib, sys, os # Local import to avoid global dependency during unit tests + _bl = None # Placeholder for resolved module + import_errors = [] # Accumulate import errors for diagnostics + for modname in ("BabyLIN_library", "vendor.BabyLIN_library"): + try: + _bl = importlib.import_module(modname) + break + except Exception as e: # pragma: no cover + import_errors.append((modname, str(e))) + if _bl is None: + # Try adding the common 'vendor' folder to sys.path then retry import + repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) + vendor_dir = os.path.join(repo_root, "vendor") + if os.path.isdir(vendor_dir) and vendor_dir not in sys.path: + sys.path.insert(0, vendor_dir) + try: + _bl = importlib.import_module("BabyLIN_library") + except Exception as e: # pragma: no cover + import_errors.append(("BabyLIN_library", str(e))) + if _bl is None: + # Raise a helpful error with all attempted import paths + details = "; ".join([f"{m}: {err}" for m, err in import_errors]) or "not found" + raise RuntimeError( + "Failed to import BabyLIN_library. Ensure the SDK's BabyLIN_library.py is present in the project (e.g., vendor/BabyLIN_library.py). Details: " + + details + ) + + # Create the BabyLIN SDK instance (module exposes create_BabyLIN()) + self._BabyLIN = _bl.create_BabyLIN() + # Small helper to call BLC_* functions by name (keeps call sites concise) + self._bl_call = lambda name, *args, **kwargs: getattr(self._BabyLIN, name)(*args, **kwargs) + + self._handle = None # Device handle returned by BLC_openPort + self._channel_handle = None # Per-channel handle returned by BLC_getChannelHandle + self._connected = False # Internal connection state flag + + def _err(self, rc: int) -> None: + """Raise a RuntimeError with a readable SDK error message for rc != BL_OK.""" + if rc == self._BabyLIN.BL_OK: + return + # Prefer a human-friendly error string if the SDK provides it + try: + get_str = getattr(self._BabyLIN, 'BLC_getDetailedErrorString', None) + msg = get_str(rc) if get_str else f"rc={rc}" + if not isinstance(msg, str): + msg = str(msg) + except Exception: + msg = f"rc={rc}" + raise RuntimeError(f"BabyLIN error: {msg}") + + def connect(self) -> None: + """Open device, optionally load SDF, select channel, and start schedule.""" + # Discover BabyLIN devices (returns a list of port identifiers) + ports = self._bl_call('BLC_getBabyLinPorts', 100) + if not ports: + raise RuntimeError("No BabyLIN devices found") + # Open the first available device port (you could extend to select by config) + self._handle = self._bl_call('BLC_openPort', ports[0]) + if not self._handle: + raise RuntimeError("Failed to open BabyLIN port") + + # Load SDF onto the device, if configured (3rd arg '1' often means 'download') + if self.sdf_path: + rc = self._bl_call('BLC_loadSDF', self._handle, self.sdf_path, 1) + if rc != self._BabyLIN.BL_OK: + self._err(rc) + + # Get channel count and pick the configured channel index (default 0) + ch_count = self._bl_call('BLC_getChannelCount', self._handle) + if ch_count <= 0: + raise RuntimeError("No channels reported by device") + ch_idx = int(self.channel_index) + if ch_idx < 0 or ch_idx >= ch_count: + ch_idx = 0 + # Resolve a channel handle used for all subsequent Tx/Rx commands + self._channel_handle = self._bl_call('BLC_getChannelHandle', self._handle, ch_idx) + + # Start a schedule if configured (common requirement for regular polling/masters) + if self.schedule_nr is not None: + cmd = f"start schedule {int(self.schedule_nr)};" + rc = self._bl_call('BLC_sendCommand', self._channel_handle, cmd) + if rc != self._BabyLIN.BL_OK: + self._err(rc) + + self._connected = True # Mark interface as connected + + def disconnect(self) -> None: + """Close device handles and reset internal state (best-effort).""" + try: + self._bl_call('BLC_closeAll') # Close all device connections via SDK + except Exception: + pass # Ignore SDK exceptions during shutdown + self._connected = False + self._handle = None + self._channel_handle = None + + def send(self, frame: LinFrame) -> None: + """Transmit a LIN frame using BLC_mon_set_xmit.""" + if not self._connected or not self._channel_handle: + raise RuntimeError("BabyLIN not connected") + # slotTime=0 means use default timing configured by schedule/SDF + rc = self._bl_call('BLC_mon_set_xmit', self._channel_handle, int(frame.id), bytes(frame.data), 0) + if rc != self._BabyLIN.BL_OK: + self._err(rc) + + def receive(self, id: Optional[int] = None, timeout: float = 1.0): + """Receive a LIN frame with optional ID filter and timeout (seconds).""" + if not self._connected or not self._channel_handle: + raise RuntimeError("BabyLIN not connected") + ms = max(0, int(timeout * 1000)) # SDK expects milliseconds + try: + frame = self._bl_call('BLC_getNextFrameTimeout', self._channel_handle, ms) + except Exception: + # Many wrappers raise on timeout; unify as 'no data' + return None + if not frame: + return None + # Convert SDK frame to our LinFrame (mask to classic 6-bit LIN ID range) + fid = int(frame.frameId & 0x3F) + data = bytes(list(frame.frameData)[: int(frame.lenOfData)]) + lin_frame = LinFrame(id=fid, data=data) + if id is None or fid == id: + return lin_frame + # If a different ID was received and caller requested a filter, return None + return None + + def flush(self) -> None: + """Flush RX buffers if the SDK exposes such a function (optional).""" + if not self._connected or not self._channel_handle: + return + try: + # Some SDKs may not expose flush; no-op if missing + flush = getattr(self._BabyLIN, 'BLC_flush', None) + if flush: + flush(self._channel_handle) + except Exception: + pass + + def request(self, id: int, length: int, timeout: float = 1.0): + """Perform a LIN master request and wait for response. + + Strategy: + - Prefer SDK method `BLC_sendRawMasterRequest` if present (bytes or length variants). + - Fallback: transmit a header with zeroed payload; then wait for response. + - Always attempt to receive a frame with matching ID within 'timeout'. + """ + if not self._connected or not self._channel_handle: + raise RuntimeError("BabyLIN not connected") + + sent = False # Track whether a request command was successfully issued + # Attempt to use raw master request if provided by SDK + # Preference: try (channel, frameId, length) first because our mock wrapper + # synthesizes a deterministic payload for this form (see vendor/mock_babylin_wrapper.py), + # then fall back to (channel, frameId, dataBytes) if the SDK only supports that. + raw_req = getattr(self._BabyLIN, 'BLC_sendRawMasterRequest', None) + if raw_req: + # Prefer the (channel, frameId, length) variant first if supported + try: + rc = raw_req(self._channel_handle, int(id), int(length)) + if rc == self._BabyLIN.BL_OK: + sent = True + else: + self._err(rc) + except TypeError: + # Fallback to (channel, frameId, dataBytes) + try: + payload = bytes([0] * max(0, min(8, int(length)))) + rc = raw_req(self._channel_handle, int(id), payload) + if rc == self._BabyLIN.BL_OK: + sent = True + else: + self._err(rc) + except Exception: + sent = False + except Exception: + sent = False + + if not sent: + # Fallback: issue a transmit; many stacks will respond on the bus + self.send(LinFrame(id=id, data=bytes([0] * max(0, min(8, int(length)))))) + + # Wait for the response frame with matching ID (or None on timeout) + return self.receive(id=id, timeout=timeout) diff --git a/ecu_framework/lin/base.py b/ecu_framework/lin/base.py new file mode 100644 index 0000000..e827f82 --- /dev/null +++ b/ecu_framework/lin/base.py @@ -0,0 +1,60 @@ +from __future__ import annotations + +from abc import ABC, abstractmethod +from dataclasses import dataclass +from typing import Optional + + +@dataclass +class LinFrame: + """Represents a LIN frame. + + id: Frame identifier (0x00 - 0x3F typical for classic LIN IDs) + data: Up to 8 bytes payload. + """ + + id: int + data: bytes + + def __post_init__(self) -> None: + if not (0 <= self.id <= 0x3F): + raise ValueError(f"LIN ID out of range: {self.id}") + if not isinstance(self.data, (bytes, bytearray)): + # allow list of ints + try: + self.data = bytes(self.data) # type: ignore[arg-type] + except Exception as e: # pragma: no cover - defensive + raise TypeError("data must be bytes-like") from e + if len(self.data) > 8: + raise ValueError("LIN data length must be <= 8") + + +class LinInterface(ABC): + """Abstract interface for LIN communication.""" + + @abstractmethod + def connect(self) -> None: + """Open the interface connection.""" + + @abstractmethod + def disconnect(self) -> None: + """Close the interface connection.""" + + @abstractmethod + def send(self, frame: LinFrame) -> None: + """Send a LIN frame.""" + + @abstractmethod + def receive(self, id: Optional[int] = None, timeout: float = 1.0) -> Optional[LinFrame]: + """Receive a LIN frame, optionally filtered by ID. Returns None on timeout.""" + + def request(self, id: int, length: int, timeout: float = 1.0) -> Optional[LinFrame]: + """Default request implementation: send header then wait a frame. + Override in concrete implementation if different behavior is needed. + """ + # By default, just wait for any frame with this ID + return self.receive(id=id, timeout=timeout) + + def flush(self) -> None: + """Optional: flush RX buffers.""" + pass diff --git a/ecu_framework/lin/mock.py b/ecu_framework/lin/mock.py new file mode 100644 index 0000000..1239c5b --- /dev/null +++ b/ecu_framework/lin/mock.py @@ -0,0 +1,73 @@ +from __future__ import annotations + +import queue +import threading +import time +from typing import Optional + +from .base import LinInterface, LinFrame + + +class MockBabyLinInterface(LinInterface): + """A mock LIN interface that echoes frames and synthesizes responses. + + Useful for local development without hardware. Thread-safe. + """ + + def __init__(self, bitrate: int = 19200, channel: int = 1) -> None: + self.bitrate = bitrate + self.channel = channel + self._rx: "queue.Queue[LinFrame]" = queue.Queue() + self._lock = threading.RLock() + self._connected = False + + def connect(self) -> None: + with self._lock: + self._connected = True + + def disconnect(self) -> None: + with self._lock: + self._connected = False + # drain queue + try: + while True: + self._rx.get_nowait() + except queue.Empty: + pass + + def send(self, frame: LinFrame) -> None: + if not self._connected: + raise RuntimeError("Mock interface not connected") + # echo back the frame as a received event + self._rx.put(frame) + + def receive(self, id: Optional[int] = None, timeout: float = 1.0) -> Optional[LinFrame]: + if not self._connected: + raise RuntimeError("Mock interface not connected") + deadline = time.time() + max(0.0, timeout) + while time.time() < deadline: + try: + frm = self._rx.get(timeout=max(0.0, deadline - time.time())) + if id is None or frm.id == id: + return frm + # not matching, requeue tail-safe + self._rx.put(frm) + except queue.Empty: + break + return None + + def request(self, id: int, length: int, timeout: float = 1.0) -> Optional[LinFrame]: + if not self._connected: + raise RuntimeError("Mock interface not connected") + # synthesize a deterministic response payload of requested length + payload = bytes((id + i) & 0xFF for i in range(max(0, min(8, length)))) + frm = LinFrame(id=id, data=payload) + self._rx.put(frm) + return self.receive(id=id, timeout=timeout) + + def flush(self) -> None: + while not self._rx.empty(): + try: + self._rx.get_nowait() + except queue.Empty: # pragma: no cover - race guard + break diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 0000000..414e7e0 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,28 @@ +[pytest] +# addopts: Default CLI options applied to every pytest run. +# -ra → Show extra test summary info for skipped, xfailed, etc. +# --junitxml=... → Emit JUnit XML for CI systems (machines can parse it). +# --html=... → Generate a human-friendly HTML report after each run. +# --self-contained-html → Inline CSS/JS in the HTML report for easy sharing. +# --tb=short → Short tracebacks to keep logs readable. +# -p conftest_plugin → Load our custom plugin (conftest_plugin.py) that: +# - extracts Title/Description/Requirements/Steps from test docstrings +# - adds custom columns to the HTML report +# - writes requirements_coverage.json and summary.md in reports/ +addopts = -ra --junitxml=reports/junit.xml --html=reports/report.html --self-contained-html --tb=short -p conftest_plugin --cov=ecu_framework --cov-report=term-missing + +# markers: Document all custom markers so pytest doesn't warn and so usage is clear. +# Use with: pytest -m "markername" +markers = + hardware: requires real hardware (BabyLIN device and ECU); excluded by default in mock runs + babylin: tests that use the BabyLIN interface (may require hardware) + unit: fast, isolated tests (no hardware, no external I/O) + req_001: REQ-001 - Mock interface shall echo transmitted frames for local testing + req_002: REQ-002 - Mock interface shall synthesize deterministic responses for request operations + req_003: REQ-003 - Mock interface shall support frame filtering by ID + req_004: REQ-004 - Mock interface shall handle timeout scenarios gracefully + smoke: Basic functionality validation tests + boundary: Boundary condition and edge case tests + +# testpaths: Where pytest looks for tests by default. +testpaths = tests diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..826153b --- /dev/null +++ b/requirements.txt @@ -0,0 +1,16 @@ +# Core testing and utilities +pytest>=8,<9 # Test runner and framework (parametrize, fixtures, markers) +pyyaml>=6,<7 # Parse YAML config files under ./config/ + +# BabyLIN SDK wrapper requires 'six' on some platforms +six>=1.16,<2 + +# Test productivity +pytest-xdist>=3.6,<4 # Parallel test execution (e.g., pytest -n auto) +pytest-html>=4,<5 # Generate HTML test reports for CI and sharing +pytest-cov>=5,<6 # Coverage reports for Python packages + +# Logging and config extras +configparser>=6,<7 # Optional INI-based config support if you add .ini configs later +colorlog>=6,<7 # Colored logging output for readable test logs +typing-extensions>=4.12,<5 # Typing backports for older Python versions diff --git a/scripts/99-babylin.rules b/scripts/99-babylin.rules new file mode 100644 index 0000000..ce0afa8 --- /dev/null +++ b/scripts/99-babylin.rules @@ -0,0 +1,5 @@ +# Example udev rules for BabyLin-like USB device +# Replace ATTRS{idVendor} and ATTRS{idProduct} with actual values +# Find values with: lsusb + +SUBSYSTEM=="usb", ATTRS{idVendor}=="1234", ATTRS{idProduct}=="5678", MODE="0660", GROUP="plugdev", TAG+="uaccess" diff --git a/scripts/ecu-tests.service b/scripts/ecu-tests.service new file mode 100644 index 0000000..6e15612 --- /dev/null +++ b/scripts/ecu-tests.service @@ -0,0 +1,17 @@ +[Unit] +Description=ECU Tests Runner +After=network-online.target +Wants=network-online.target + +[Service] +Type=oneshot +WorkingDirectory=/home/pi/ecu_tests +ExecStart=/home/pi/ecu_tests/scripts/run_tests.sh +User=pi +Group=pi +Environment=ECU_TESTS_CONFIG=/home/pi/ecu_tests/config/test_config.yaml +StandardOutput=append:/home/pi/ecu_tests/reports/service.log +StandardError=append:/home/pi/ecu_tests/reports/service.err + +[Install] +WantedBy=multi-user.target diff --git a/scripts/ecu-tests.timer b/scripts/ecu-tests.timer new file mode 100644 index 0000000..0b378df --- /dev/null +++ b/scripts/ecu-tests.timer @@ -0,0 +1,10 @@ +[Unit] +Description=Schedule ECU Tests Runner + +[Timer] +OnBootSec=2min +OnUnitActiveSec=24h +Persistent=true + +[Install] +WantedBy=timers.target diff --git a/scripts/pi_install.sh b/scripts/pi_install.sh new file mode 100644 index 0000000..23b716c --- /dev/null +++ b/scripts/pi_install.sh @@ -0,0 +1,63 @@ +#!/usr/bin/env bash +set -euo pipefail + +# This script installs prerequisites, sets up a venv, installs deps, +# and wires up systemd units on a Raspberry Pi. +# Run as: sudo bash scripts/pi_install.sh /home/pi/ecu_tests + +TARGET_DIR="${1:-/home/pi/ecu_tests}" +REPO_URL="${2:-}" # optional; if empty assumes repo already present at TARGET_DIR +PI_USER="${PI_USER:-pi}" + +log() { echo "[pi_install] $*"; } + +if [[ $EUID -ne 0 ]]; then + echo "Please run as root (sudo)." >&2 + exit 1 +fi + +log "Installing OS packages..." +apt-get update -y +apt-get install -y --no-install-recommends \ + python3 python3-venv python3-pip git ca-certificates \ + libusb-1.0-0 udev + +mkdir -p "$TARGET_DIR" +chown -R "$PI_USER":"$PI_USER" "$TARGET_DIR" + +if [[ -n "$REPO_URL" ]]; then + log "Cloning repo: $REPO_URL" + sudo -u "$PI_USER" git clone "$REPO_URL" "$TARGET_DIR" || true +fi + +cd "$TARGET_DIR" + +log "Creating Python venv..." +sudo -u "$PI_USER" python3 -m venv .venv + +log "Installing Python dependencies..." +sudo -u "$PI_USER" bash -lc "source .venv/bin/activate && pip install --upgrade pip && pip install -r requirements.txt" + +log "Preparing reports directory..." +mkdir -p reports +chown -R "$PI_USER":"$PI_USER" reports + +log "Installing systemd units..." +install -Dm644 scripts/ecu-tests.service /etc/systemd/system/ecu-tests.service +if [[ -f scripts/ecu-tests.timer ]]; then + install -Dm644 scripts/ecu-tests.timer /etc/systemd/system/ecu-tests.timer +fi +systemctl daemon-reload +systemctl enable ecu-tests.service || true +if [[ -f /etc/systemd/system/ecu-tests.timer ]]; then + systemctl enable ecu-tests.timer || true +fi + +log "Installing udev rules (if provided)..." +if [[ -f scripts/99-babylin.rules ]]; then + install -Dm644 scripts/99-babylin.rules /etc/udev/rules.d/99-babylin.rules + udevadm control --reload-rules || true + udevadm trigger || true +fi + +log "Done. You can start the service with: systemctl start ecu-tests.service" \ No newline at end of file diff --git a/scripts/run_tests.sh b/scripts/run_tests.sh new file mode 100644 index 0000000..86f359c --- /dev/null +++ b/scripts/run_tests.sh @@ -0,0 +1,6 @@ +#!/usr/bin/env bash +set -euo pipefail +cd "$(dirname "$0")/.." +source .venv/bin/activate +# optional: export ECU_TESTS_CONFIG=$(pwd)/config/test_config.yaml +python -m pytest -v diff --git a/scripts/run_two_reports.ps1 b/scripts/run_two_reports.ps1 new file mode 100644 index 0000000..9b51167 --- /dev/null +++ b/scripts/run_two_reports.ps1 @@ -0,0 +1,29 @@ +# Runs two pytest invocations to generate separate HTML/JUnit reports +# - Unit tests → reports/report-unit.html, reports/junit-unit.xml +# - All non-unit tests → reports/report-tests.html, reports/junit-tests.xml +# +# Usage (from repo root, PowerShell): +# .\scripts\run_two_reports.ps1 +# +# Notes: +# - We override pytest.ini addopts to avoid duplicate --html/--junitxml and explicitly +# load our custom plugin. +# - Adjust the second marker to exclude hardware if desired (see commented example). + +# Ensure reports directory exists +if (-not (Test-Path -LiteralPath "reports")) { New-Item -ItemType Directory -Path "reports" | Out-Null } + +# 1) Unit tests report +pytest -q -o addopts="" -p conftest_plugin -ra --tb=short --self-contained-html ` + --cov=ecu_framework --cov-report=term-missing ` + --html=reports/report-unit.html ` + --junitxml=reports/junit-unit.xml ` + -m unit + +# 2) All non-unit tests (integration/smoke/hardware) report +# To exclude hardware here, change the marker expression to: -m "not unit and not hardware" +pytest -q -o addopts="" -p conftest_plugin -ra --tb=short --self-contained-html ` + --cov=ecu_framework --cov-report=term-missing ` + --html=reports/report-tests.html ` + --junitxml=reports/junit-tests.xml ` + -m "not unit" diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..c67e09d --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,64 @@ +import os +import pathlib +import typing as t + +import pytest + +from ecu_framework.config import load_config, EcuTestConfig +from ecu_framework.lin.base import LinInterface +from ecu_framework.lin.mock import MockBabyLinInterface + +try: + from ecu_framework.lin.babylin import BabyLinInterface # type: ignore +except Exception: + BabyLinInterface = None # type: ignore + + +WORKSPACE_ROOT = pathlib.Path(__file__).resolve().parents[1] + + +@pytest.fixture(scope="session") +def config() -> EcuTestConfig: + cfg = load_config(str(WORKSPACE_ROOT)) + return cfg + + +@pytest.fixture(scope="session") +def lin(config: EcuTestConfig) -> t.Iterator[LinInterface]: + iface_type = config.interface.type + if iface_type == "mock": + lin = MockBabyLinInterface(bitrate=config.interface.bitrate, channel=config.interface.channel) + elif iface_type == "babylin": + if BabyLinInterface is None: + pytest.skip("BabyLin interface not available in this environment") + lin = BabyLinInterface( + dll_path=config.interface.dll_path, + bitrate=config.interface.bitrate, + channel=config.interface.channel, + node_name=config.interface.node_name, + func_names=config.interface.func_names, + sdf_path=config.interface.sdf_path, + schedule_nr=config.interface.schedule_nr, + ) + else: + raise RuntimeError(f"Unknown interface type: {iface_type}") + + lin.connect() + yield lin + lin.disconnect() + + +@pytest.fixture(scope="session", autouse=False) +def flash_ecu(config: EcuTestConfig, lin: LinInterface) -> None: + if not config.flash.enabled: + pytest.skip("Flashing disabled in config") + # Lazy import to avoid dependency during mock-only runs + from ecu_framework.flashing import HexFlasher + + if not config.flash.hex_path: + pytest.skip("No HEX path provided in config") + + flasher = HexFlasher(lin) + ok = flasher.flash_hex(config.flash.hex_path) + if not ok: + pytest.fail("ECU flashing failed") diff --git a/tests/plugin/test_conftest_plugin_artifacts.py b/tests/plugin/test_conftest_plugin_artifacts.py new file mode 100644 index 0000000..c0a67fd --- /dev/null +++ b/tests/plugin/test_conftest_plugin_artifacts.py @@ -0,0 +1,61 @@ +import json +from pathlib import Path + +import pytest + +# Enable access to the built-in 'pytester' fixture +pytest_plugins = ("pytester",) +@pytest.mark.unit +def test_plugin_writes_artifacts(pytester): + # Make the project root importable so '-p conftest_plugin' works inside pytester + project_root = Path(__file__).resolve().parents[2] + pytester.syspathinsert(str(project_root)) + # Create a minimal test file that includes a rich docstring + pytester.makepyfile( + test_sample=''' +import pytest + +@pytest.mark.req_001 +def test_docstring_metadata(): + """ + Title: Example Test + + Description: + Small sample to exercise the reporting plugin. + + Requirements: REQ-001 + + Test Steps: + 1. do it + + Expected Result: + - done + """ + assert True +''' + ) + + # Run pytest in the temporary test environment, loading our reporting plugin + result = pytester.runpytest( + "-q", + "-p", + "conftest_plugin", + "--html=reports/report.html", + "--self-contained-html", + "--junitxml=reports/junit.xml", + ) + result.assert_outcomes(passed=1) + + # Check for the JSON coverage artifact + cov = pytester.path / "reports" / "requirements_coverage.json" + assert cov.is_file() + data = json.loads(cov.read_text()) + + # Validate REQ mapping and presence of artifacts + assert "REQ-001" in data["requirements"] + assert data["files"]["html"].endswith("report.html") + assert data["files"]["junit"].endswith("junit.xml") + + # Check that the CI summary exists + summary = pytester.path / "reports" / "summary.md" + assert summary.is_file() diff --git a/tests/test_babylin_hardware_schedule_smoke.py b/tests/test_babylin_hardware_schedule_smoke.py new file mode 100644 index 0000000..7818ce7 --- /dev/null +++ b/tests/test_babylin_hardware_schedule_smoke.py @@ -0,0 +1,45 @@ +import os +import pathlib +import pytest + +# Hardware + babylin + smoke: this is the canonical end-to-end schedule flow +pytestmark = [pytest.mark.hardware, pytest.mark.babylin, pytest.mark.smoke] + +WORKSPACE_ROOT = pathlib.Path(__file__).resolve().parents[1] + + +def test_babylin_sdk_example_flow(config, lin): + """ + Title: BabyLIN SDK Example Flow - Open, Load SDF, Start Schedule, Rx Timeout + + Description: + Mirrors the vendor example flow: discover/open, load SDF, start a + schedule, and attempt a receive. Validates that the adapter can perform + the essential control sequence without exceptions and that the receive + path is operational even if it times out. + + Requirements: REQ-HW-OPEN, REQ-HW-SDF, REQ-HW-SCHEDULE + + Preconditions: + - ECU_TESTS_CONFIG points to a hardware YAML with interface.sdf_path and schedule_nr + - BabyLIN_library.py and native libs placed per vendor/README.md + + Test Steps: + 1. Verify hardware config requests the BabyLIN SDK with SDF path + 2. Connect via fixture (opens device, loads SDF, starts schedule) + 3. Try to receive a frame with a short timeout + 4. Assert no crash; accept None or a LinFrame (environment-dependent) + + Expected Result: + - No exceptions during open/load/start + - Receive returns None (timeout) or a LinFrame + """ + # Step 1: Ensure config is set for hardware with SDK wrapper + assert config.interface.type == "babylin" + assert config.interface.sdf_path is not None + + # Step 3: Attempt a short receive to validate RX path while schedule runs + rx = lin.receive(timeout=0.2) + + # Step 4: Accept timeout or a valid frame object depending on bus activity + assert rx is None or hasattr(rx, "id") diff --git a/tests/test_babylin_hardware_smoke.py b/tests/test_babylin_hardware_smoke.py new file mode 100644 index 0000000..dc4ba66 --- /dev/null +++ b/tests/test_babylin_hardware_smoke.py @@ -0,0 +1,33 @@ +import pytest + +# Mark entire module as hardware + babylin so it's easy to select/deselect via -m +pytestmark = [pytest.mark.hardware, pytest.mark.babylin] + + +def test_babylin_connect_receive_timeout(lin): + """ + Title: BabyLIN Hardware Smoke - Connect and Timed Receive + + Description: + Minimal hardware sanity check that relies on the configured fixtures to + connect to a BabyLIN device and perform a short receive call. + The test is intentionally permissive: it accepts either a valid LinFrame + or a None (timeout) as success, focusing on verifying that the adapter + is functional and not crashing. + + Requirements: REQ-HW-SMOKE + + Test Steps: + 1. Use the 'lin' fixture to connect to the BabyLIN SDK adapter + 2. Call receive() with a short timeout + 3. Assert the outcome is either a LinFrame or None (timeout) + + Expected Result: + - No exceptions are raised + - Return value is None (timeout) or an object with an 'id' attribute + """ + # Step 2: Perform a short receive to verify operability + rx = lin.receive(timeout=0.2) + + # Step 3: Accept either a timeout (None) or a frame-like object + assert rx is None or hasattr(rx, "id") diff --git a/tests/test_babylin_wrapper_mock.py b/tests/test_babylin_wrapper_mock.py new file mode 100644 index 0000000..b81cf71 --- /dev/null +++ b/tests/test_babylin_wrapper_mock.py @@ -0,0 +1,132 @@ +import pytest + +from ecu_framework.lin.base import LinFrame +from ecu_framework.lin.babylin import BabyLinInterface + +# Inject the pure-Python mock wrapper to run SDK adapter tests without hardware +from vendor import mock_babylin_wrapper as mock_bl + + +class _MockBytesOnly: + """Shim exposing BLC_sendRawMasterRequest(bytes) only, to test bytes signature. + + We wrap the existing mock but override BLC_sendRawMasterRequest to accept + only the bytes payload form. The response still uses the deterministic pattern + implied by the payload length (zeros are fine; we assert by length here). + """ + + @staticmethod + def create_BabyLIN(): + base = mock_bl.create_BabyLIN() + + def bytes_only(channel, frame_id, payload): + # Delegate to the base mock's bytes variant by ensuring we pass bytes + if not isinstance(payload, (bytes, bytearray)): + raise TypeError("expected bytes payload") + return base.BLC_sendRawMasterRequest(channel, frame_id, bytes(payload)) + + # Monkey-patch the method to raise TypeError when a length is provided + def patched_raw_req(*args): + # Expected signature: (channel, frame_id, payload_bytes) + if len(args) != 3 or not isinstance(args[2], (bytes, bytearray)): + raise TypeError("bytes signature only") + return bytes_only(*args) + + base.BLC_sendRawMasterRequest = patched_raw_req + return base + + +@pytest.mark.babylin +@pytest.mark.smoke +@pytest.mark.req_001 +def test_babylin_sdk_adapter_with_mock_wrapper(): + """ + Title: SDK Adapter - Send/Receive with Mock Wrapper + + Description: + Validate that the BabyLIN SDK-based adapter can send and receive using + a mocked wrapper exposing BLC_* APIs. The mock implements loopback by + echoing transmitted frames into the receive queue. + + Requirements: REQ-001 + + Test Steps: + 1. Construct BabyLinInterface with injected mock wrapper + 2. Connect (discovers port, opens, loads SDF, starts schedule) + 3. Send a frame via BLC_mon_set_xmit + 4. Receive the same frame via BLC_getNextFrameTimeout + 5. Disconnect + + Expected Result: + - Received frame matches sent frame (ID and payload) + """ + # Step 1-2: Create adapter with wrapper injection and connect + lin = BabyLinInterface(sdf_path="./vendor/Example.sdf", schedule_nr=0, wrapper_module=mock_bl) + lin.connect() + try: + # Step 3: Transmit a known payload on a chosen ID + tx = LinFrame(id=0x12, data=bytes([0xAA, 0x55, 0x01])) + lin.send(tx) + + # Step 4: Receive from the mock's RX queue (loopback) + rx = lin.receive(timeout=0.1) + + # Step 5: Validate ID and payload integrity + assert rx is not None, "Expected a frame from mock loopback" + assert rx.id == tx.id + assert rx.data == tx.data + finally: + # Always disconnect to leave the mock in a clean state + lin.disconnect() + + +@pytest.mark.babylin +@pytest.mark.smoke +@pytest.mark.req_001 +@pytest.mark.parametrize("wrapper,expect_pattern", [ + (mock_bl, True), # length signature available: expect deterministic pattern + (_MockBytesOnly, False), # bytes-only signature: expect zeros of requested length +]) +def test_babylin_master_request_with_mock_wrapper(wrapper, expect_pattern): + """ + Title: SDK Adapter - Master Request using Mock Wrapper + + Description: + Verify that request() prefers the SDK's BLC_sendRawMasterRequest when + available. The mock wrapper enqueues a deterministic response where + data[i] = (id + i) & 0xFF, allowing predictable assertions. + + Requirements: REQ-001 + + Test Steps: + 1. Construct BabyLinInterface with injected mock wrapper + 2. Connect (mock open/initialize) + 3. Issue a master request for a specific ID and length + 4. Receive the response frame + 5. Validate ID and deterministic payload pattern + + Expected Result: + - Response frame ID matches request ID + - Response data length matches requested length + - Response data follows deterministic pattern + """ + # Step 1-2: Initialize mock-backed adapter + lin = BabyLinInterface(wrapper_module=wrapper) + lin.connect() + try: + # Step 3: Request 4 bytes for ID 0x22 + req_id = 0x22 + length = 4 + rx = lin.request(id=req_id, length=length, timeout=0.1) + + # Step 4-5: Validate response + assert rx is not None, "Expected a response from mock master request" + assert rx.id == req_id + if expect_pattern: + # length-signature mock returns deterministic pattern + assert rx.data == bytes(((req_id + i) & 0xFF) for i in range(length)) + else: + # bytes-only mock returns exactly the bytes we sent (zeros of requested length) + assert rx.data == bytes([0] * length) + finally: + lin.disconnect() diff --git a/tests/test_hardware_placeholder.py b/tests/test_hardware_placeholder.py new file mode 100644 index 0000000..169e035 --- /dev/null +++ b/tests/test_hardware_placeholder.py @@ -0,0 +1,19 @@ +import pytest + +# This module is gated by 'hardware' and 'babylin' markers to only run in hardware jobs +pytestmark = [pytest.mark.hardware, pytest.mark.babylin] + + +def test_babylin_placeholder(): + """ + Title: Hardware Test Placeholder + + Description: + Minimal placeholder to verify hardware selection and CI plumbing. It + ensures that -m hardware pipelines and marker-based selection work as + expected even when no specific hardware assertions are needed. + + Expected Result: + - Always passes. + """ + assert True diff --git a/tests/test_smoke_mock.py b/tests/test_smoke_mock.py new file mode 100644 index 0000000..b1a6a88 --- /dev/null +++ b/tests/test_smoke_mock.py @@ -0,0 +1,171 @@ +import pytest +from ecu_framework.lin.base import LinFrame + + +class TestMockLinInterface: + """Test suite validating the pure-Python mock LIN interface behavior. + + Coverage goals: + - REQ-001: Echo loopback for local testing (send -> receive same frame) + - REQ-002: Deterministic master request responses (no randomness) + - REQ-003: Frame ID filtering in receive() + - REQ-004: Graceful handling of timeout when no frame is available + + Notes: + - These tests run entirely without hardware and should be fast and stable. + - The injected mock interface enqueues frames on transmit to emulate a bus. + - Deterministic responses allow exact byte-for-byte assertions. + """ + + @pytest.mark.smoke + @pytest.mark.req_001 + @pytest.mark.req_003 + def test_mock_send_receive_echo(self, lin): + """ + Title: Mock LIN Interface - Send/Receive Echo Test + + Description: + Validates that the mock LIN interface correctly echoes frames sent on the bus, + enabling loopback testing without hardware dependencies. + + Requirements: REQ-001, REQ-003 + + Test Steps: + 1. Create a LIN frame with specific ID and data payload + 2. Send the frame via the mock interface + 3. Attempt to receive the echoed frame with ID filtering + 4. Verify the received frame matches the transmitted frame exactly + + Expected Result: + - Frame is successfully echoed by mock interface + - Received frame ID matches transmitted frame ID (0x12) + - Received frame data payload matches transmitted data [1, 2, 3] + """ + # Step 1: Create test frame with known ID and payload + test_frame = LinFrame(id=0x12, data=bytes([1, 2, 3])) + + # Step 2: Transmit frame via mock interface (mock will enqueue to RX) + lin.send(test_frame) + + # Step 3: Receive echoed frame with ID filtering and timeout + received_frame = lin.receive(id=0x12, timeout=0.5) + + # Step 4: Validate echo functionality and payload integrity + assert received_frame is not None, "Mock interface should echo transmitted frames" + assert received_frame.id == test_frame.id, f"Expected ID {test_frame.id:#x}, got {received_frame.id:#x}" + assert received_frame.data == test_frame.data, f"Expected data {test_frame.data!r}, got {received_frame.data!r}" + + @pytest.mark.smoke + @pytest.mark.req_002 + def test_mock_request_synthesized_response(self, lin): + """ + Title: Mock LIN Interface - Master Request Response Test + + Description: + Validates that the mock interface synthesizes deterministic responses + for master request operations, simulating slave node behavior. + + Requirements: REQ-002 + + Test Steps: + 1. Issue a master request for specific frame ID and data length + 2. Verify mock interface generates a response frame + 3. Validate response frame ID matches request ID + 4. Verify response data length matches requested length + 5. Confirm response data is deterministic (not random) + + Expected Result: + - Mock interface generates response within timeout period + - Response frame ID matches request ID (0x21) + - Response data length equals requested length (4 bytes) + - Response data follows deterministic pattern: [id+0, id+1, id+2, id+3] + """ + # Step 1: Issue master request with specific parameters + request_id = 0x21 + requested_length = 4 + + # Step 2: Execute request operation; mock synthesizes deterministic bytes + response_frame = lin.request(id=request_id, length=requested_length, timeout=0.5) + + # Step 3: Validate response generation + assert response_frame is not None, "Mock interface should generate response for master requests" + + # Step 4: Verify response frame properties (ID and length) + assert response_frame.id == request_id, f"Response ID {response_frame.id:#x} should match request ID {request_id:#x}" + assert len(response_frame.data) == requested_length, f"Response length {len(response_frame.data)} should match requested length {requested_length}" + + # Step 5: Validate deterministic response pattern + expected_data = bytes((request_id + i) & 0xFF for i in range(requested_length)) + assert response_frame.data == expected_data, f"Response data {response_frame.data!r} should follow deterministic pattern {expected_data!r}" + + @pytest.mark.smoke + @pytest.mark.req_004 + def test_mock_receive_timeout_behavior(self, lin): + """ + Title: Mock LIN Interface - Receive Timeout Test + + Description: + Validates that the mock interface properly handles timeout scenarios + when no matching frames are available for reception. + + Requirements: REQ-004 + + Test Steps: + 1. Attempt to receive a frame with non-existent ID + 2. Use short timeout to avoid blocking test execution + 3. Verify timeout behavior returns None rather than blocking indefinitely + + Expected Result: + - Receive operation returns None when no matching frames available + - Operation completes within specified timeout period + - No exceptions or errors during timeout scenario + """ + # Step 1: Attempt to receive frame with ID that hasn't been transmitted + non_existent_id = 0xFF + short_timeout = 0.1 # 100ms timeout + + # Step 2: Execute receive with timeout (should return None quickly) + result = lin.receive(id=non_existent_id, timeout=short_timeout) + + # Step 3: Verify proper timeout behavior (no exceptions, returns None) + assert result is None, "Receive operation should return None when no matching frames available" + + @pytest.mark.boundary + @pytest.mark.req_001 + @pytest.mark.req_003 + @pytest.mark.parametrize("frame_id,data_payload", [ + (0x01, bytes([0x55])), + (0x3F, bytes([0xAA, 0x55])), + (0x20, bytes([0x01, 0x02, 0x03, 0x04, 0x05])), + (0x15, bytes([0xFF, 0x00, 0xCC, 0x33, 0xF0, 0x0F, 0xA5, 0x5A])), + ]) + def test_mock_frame_validation_boundaries(self, lin, frame_id, data_payload): + """ + Title: Mock LIN Interface - Frame Validation Boundaries Test + + Description: + Validates mock interface handling of various frame configurations + including boundary conditions for frame IDs and data lengths. + + Requirements: REQ-001, REQ-003 + + Test Steps: + 1. Test various valid frame ID values (0x01 to 0x3F) + 2. Test different data payload lengths (1 to 8 bytes) + 3. Verify proper echo behavior for all valid combinations + + Expected Result: + - All valid frame configurations are properly echoed + - Frame ID and data integrity preserved across echo operation + """ + # Step 1: Create frame with parameterized values + test_frame = LinFrame(id=frame_id, data=data_payload) + + # Step 2: Send and receive frame + lin.send(test_frame) + received_frame = lin.receive(id=frame_id, timeout=0.5) + + # Step 3: Validate frame integrity across IDs and payload sizes + assert received_frame is not None, f"Frame with ID {frame_id:#x} should be echoed" + assert received_frame.id == frame_id, f"Frame ID should be preserved: expected {frame_id:#x}" + assert received_frame.data == data_payload, f"Frame data should be preserved for ID {frame_id:#x}" diff --git a/tests/unit/test_babylin_adapter_mocked.py b/tests/unit/test_babylin_adapter_mocked.py new file mode 100644 index 0000000..aaf843d --- /dev/null +++ b/tests/unit/test_babylin_adapter_mocked.py @@ -0,0 +1,22 @@ +import pytest + +from ecu_framework.lin.babylin import BabyLinInterface +from vendor import mock_babylin_wrapper as mock_bl + + +class _ErrMock: + @staticmethod + def create_BabyLIN(): + bl = mock_bl.create_BabyLIN() + # Force loadSDF to return a non-OK code + def fail_load(*args, **kwargs): + return 1 # non BL_OK + bl.BLC_loadSDF = fail_load + return bl + + +@pytest.mark.unit +def test_connect_sdf_error_raises(): + lin = BabyLinInterface(sdf_path="dummy.sdf", wrapper_module=_ErrMock) + with pytest.raises(RuntimeError): + lin.connect() diff --git a/tests/unit/test_config_loader.py b/tests/unit/test_config_loader.py new file mode 100644 index 0000000..5bc9516 --- /dev/null +++ b/tests/unit/test_config_loader.py @@ -0,0 +1,34 @@ +import os +import json +import pathlib + +import pytest +from ecu_framework.config import load_config + + +@pytest.mark.unit +def test_config_precedence_env_overrides(monkeypatch, tmp_path): + # Create a YAML file to use via env var + yaml_path = tmp_path / "cfg.yaml" + yaml_path.write_text("interface:\n type: babylin\n channel: 7\n") + + # Point ECU_TESTS_CONFIG to env YAML + monkeypatch.setenv("ECU_TESTS_CONFIG", str(yaml_path)) + + # Apply overrides on top + cfg = load_config(workspace_root=str(tmp_path), overrides={"interface": {"channel": 9}}) + + # Env file applied + assert cfg.interface.type == "babylin" + # Overrides win + assert cfg.interface.channel == 9 + + +@pytest.mark.unit +def test_config_defaults_when_no_file(monkeypatch): + # Ensure no env path + monkeypatch.delenv("ECU_TESTS_CONFIG", raising=False) + + cfg = load_config(workspace_root=None) + assert cfg.interface.type == "mock" + assert cfg.flash.enabled is False diff --git a/tests/unit/test_hex_flasher.py b/tests/unit/test_hex_flasher.py new file mode 100644 index 0000000..b634f97 --- /dev/null +++ b/tests/unit/test_hex_flasher.py @@ -0,0 +1,30 @@ +import pytest +from ecu_framework.flashing.hex_flasher import HexFlasher +from ecu_framework.lin.base import LinFrame + + +class _StubLin: + def __init__(self): + self.sent = [] + def connect(self): + pass + def disconnect(self): + pass + def send(self, frame: LinFrame): + self.sent.append(frame) + def receive(self, id=None, timeout=1.0): + return None + + +@pytest.mark.unit +def test_hex_flasher_sends_basic_sequence(tmp_path): + # Minimal valid Intel HEX file (EOF record) + hex_path = tmp_path / "fw.hex" + hex_path.write_text(":00000001FF\n") + + lin = _StubLin() + flasher = HexFlasher(lin) + flasher.flash_hex(str(hex_path)) + + # Placeholder assertion; refine as the flasher gains functionality + assert isinstance(lin.sent, list) diff --git a/tests/unit/test_linframe.py b/tests/unit/test_linframe.py new file mode 100644 index 0000000..42720fe --- /dev/null +++ b/tests/unit/test_linframe.py @@ -0,0 +1,21 @@ +import pytest +from ecu_framework.lin.base import LinFrame + + +@pytest.mark.unit +def test_linframe_accepts_valid_ranges(): + f = LinFrame(id=0x3F, data=bytes([0] * 8)) + assert f.id == 0x3F and len(f.data) == 8 + + +@pytest.mark.unit +@pytest.mark.parametrize("bad_id", [-1, 0x40]) +def test_linframe_invalid_id_raises(bad_id): + with pytest.raises(ValueError): + LinFrame(id=bad_id, data=b"\x00") + + +@pytest.mark.unit +def test_linframe_too_long_raises(): + with pytest.raises(ValueError): + LinFrame(id=0x01, data=bytes(range(9))) diff --git a/vendor/BLCInterfaceExample.py b/vendor/BLCInterfaceExample.py new file mode 100644 index 0000000..1a4cd00 --- /dev/null +++ b/vendor/BLCInterfaceExample.py @@ -0,0 +1,326 @@ +#!/usr/bin/python3 + +#### +# This is a sample program, which introduces the functions and applications of the Baby-LIN-DLL. To run this program you need the current LINWorks software and +# a Baby-LIN device from Lipowsky Industrie-Elektronik GmbH. Make sure that there is a USB connection between your PC and the Baby-LIN-Device and +# that a voltage of 8-26 VDC is applied to the LIN-Bus. +# +# Table of Contents: +# 1. Display Version of Baby-LIN-DLL und Wrapper +# 2. Connection with the Baby-LIN-Device +# 3. Connection to the LIN-Channel +# 4. Write SerialNumber to signal +# 5. Excecute macro and processing MacroResultString +# 6. Use of getsig/setsig for signal handling +# 7. Frame registration and display of the framecallbacks +# 8. Error handling +#### + +from __future__ import unicode_literals +from asyncio.windows_events import NULL +from ctypes import * +from hashlib import new +import os, sys, argparse, six + +try: + # import the BabyLIN Python wrapper + import BabyLIN_library +except ImportError as e: + six.print_(e) + +def parse_arguments(): + """ """ + # get sdf file from the path where the executable is + parser = argparse.ArgumentParser(description="run `main.py` on sdf file") + parser.add_argument("-s", "--sdf", help="sdf file to load", + default="Example.sdf") + parser.add_argument("-v", "--verbose", action="count", default=0) + args = parser.parse_args() + + return args.sdf, args.verbose + +def main(sdf_name, verbose): + """ Standard example. """ + + def framecallback(handle, frame): + """ frame callback to be used later.""" + six.print_(frame) + return 0 + + if verbose == 1: + six.print_("Using dynamic library " + BabyLIN.BABYLIN_DLL_PATH_NAME) + + # create the BabyLIN class contained in BabyLIN_DLL.py + BabyLIN = BabyLIN_library.create_BabyLIN() + + # inject BabyLIN names into local namespace, so you can, e.g. write + # BLC_getVersion instead of BabyLIN.BLC_getVersion + for k, v in BabyLIN.__dict__['_libNames'].items(): + globals()[k] = getattr(BabyLIN, k) + + if verbose == 1: + six.print_("Using sdf file " + sdf_name) + + try: + six.print_("Test programm started") + six.print_("#####################################") + six.print_("") + + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # 1. Display Version of Baby-LIN-DLL und Wrapper + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # Display the version of the BabyLIN DLL and the .net Wrapper + six.print_("DLL and wrapper version are read out") + six.print_("") + dllVersion = BLC_getVersionString() + wrapperVersion = BLC_getWrapperVersion() + six.print_("BabyLIN version: ", dllVersion) + six.print_("BabyLIN python Wrapper version: ", wrapperVersion) + six.print_("") + + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # 2. Connection with the Baby-LIN-Device + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # Search for Baby-LIN devices + # The BLC_getBabyLinPortsTimeout() function is also searching for network devices + # If you are using only Baby-LIN devices with USB port, you can use BLC_getBabyLinPorts() + portCount = 100 # Find up to 100 devices + six.print_("Search for Baby-LIN-Devices for connection...") + portList = BLC_getBabyLinPorts(portCount) + if portList == 0: + six.print_("Could not find any Baby-LIN devices.") + sys.exit(-1) + + six.print_(str(len(portList)) + " devices were found for the connection") + six.print_("") + + portList = BLC_getBabyLinPortsTimout(portCount, 3000) + if portList == 0: + six.print_("Could not find any Baby-LIN devices.") + sys.exit(-1) + + # In this example, we will be using the first found Baby-LIN device + if len(portList) < 1: + six.print_("Could not find any Baby-LIN devices.") + sys.exit(-1) + port = portList[0] + + # Open a connection to the first found BabyLIN + six.print_("The connection to the first Baby-LIN-Device of the portlist is established.") + handle = BLC_openPort(port) + if handle == NULL: + six.print_("The connection to the BabyLIN could not be opened. Please check, that the COM Port is correct.") + sys.exit(-1) + + # Download the SDF file into the BabyLIN device + six.print_("SDF download...") + six.print_("") + rc = BLC_loadSDF(handle, sdf_name, 1) + if rc != 0: + six.print_("The SDF file could not be loaded into the BabyLIN. Please check, that the filename is correct.") + sys.exit(-1) + + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # 3. Connection to the LIN-Channel + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # Get the number of available channels + six.print_("Output of the channel info") + channelCount = BLC_getChannelCount(handle) + six.print_("available channels: " + str(channelCount)) + + # the example will open the first device with an included + # LIN channel, download the sdf to it, start the LIN bus, + # register a frame-callback and watch the incoming LIN-frames + # in the callback. + + # open the device(s) + conHandle = (handle for port in portList) + + # get the device's number of channels + channelCount = ((BLC_getChannelCount(h), h) for h in conHandle) + + # among these, look for the first LIN channel: + channelRange = ((range(chNr), h) for chNr, h in channelCount) + + # first, get the corresponding channel handles + channelHandle = ((BLC_getChannelHandle(h, channelIndex), h) + for r, h in channelRange for channelIndex in r) + + # for each channel (handle), get the channel info + chInfo = ((BLC_getChannelInfo(ch), h, ch) for ch, h in channelHandle) + + # using the channel info, filter the LIN channels + # using 'info.type == 0' + conH_chH = ((h, ch) for info, h, ch in chInfo if info.type == 0) + + for conHandle, channelHandle in conH_chH: + + # for debugging, print ChannelInfo + channelInfos = BLC_getChannelInfo(channelHandle) + six.print_("Channel info: Name=" + str(channelInfos.name) + " , Type=" + str(channelInfos.type) + " , MaxBaudrate=" + str(channelInfos.maxbaudrate)) + + # start the LIN bus + six.print_("Connect to channel number 1 and start the schedule number 0") + six.print_("") + scheduleNr = 0 + rc = BLC_sendCommand(channelHandle, "start schedule " + str(scheduleNr) + ";") + if rc != 0: + six.print_("Could not start the LIN bus.") + sys.exit(-1) + + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # 4. Write SerialNumber to signal + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # Write Signal Serial_Number + # The SDF provides the following signals: SN_Byte_0, SN_Byte_1, SN_Byte_2 ,SN_Byte_3, SN_Byte_4, SN_Byte_5, SN_Byte_6, SN_Byte_7 + # With the BLCvarWrite() command the signals can all be written with one operation. The varible data_len determines the number of signals to be set. + # Exactly one byte is assigned to each signal + six.print_("Precessing the serial number") + signal_nr = 0 + data_len = 8 + data = bytes([83, 78, 48, 49, 50, 51, 52, 53]) # ASCII-Code: "SN012345" + rc = BLC_varWrite(channelHandle, signal_nr, data, data_len) + if rc != 0: + six.print_("Could not write into signal Serial_Number.") + sys.exit(-1) + + # Read signal Serial_number for control + # The BLC_varRead() command reads a certain number of signals and stores them in a byte buffer, which is passed to the function when it is called. + # The number of signals to be read is determined by the variable lenght. + lenght = 8 + SignalValue = BLC_varRead(channelHandle, signal_nr, lenght) + if SignalValue == 0: + six.print_("Could not read the signal Serial_Number.") + sys.exit(-1) + six.print_("Serial number set via BLC_varWrite command") + six.print_("") + + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # 5. Excecute macro and processing MacroResultString + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # Execute 01_process_SerialNumber + # In this macro the data from the SN_Byte signals are read out and combined to a result string. + # The Baby_LIN_DLL provides a set of Baby_LIN commands which can be executed with the BLC_sendCommand(). + # + # The macro_exec command executes the macro with the passed macro number. The BLC command does not wait until the macro is fully executed. + # This must be implemented by the user with the function BLC_macro_result. As long as the macro is still executed, the BLC function returns the value 150. + six.print_("Create MacroResultString out of serial number bytes") + macro_nr = 0 + return_value = 0 + timeout_ms = 250 + rc = BLC_sendCommand(channelHandle, "macro_exec " + str(macro_nr) + ";") + if rc != 0: + six.print_("BLC command could not be executed.") + sys.exit(-1) + rc = BLC_macro_result(channelHandle, macro_nr, timeout_ms) + if rc != 0: + six.print_("BLC command could not be executed.") + sys.exit(-1) + + # Get MacroResultString + # When executing a macro it returns a result string after successful completion.This can be set additionally by MAcro command print. + # With parameter passing the values from the signals can be put together to a result string easily. The encoding of the output can also be set, + # which is shown by the two outputs in ASCII code and HEXByte code. + MacroResultStringASCII = BLC_getMacroResultString(channelHandle, macro_nr) + six.print_("Serial number: " + MacroResultStringASCII + "(ASCII Code)") + six.print_("") + + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # 6. Use of getsig/setsig for signal handling + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # Use of getsig and setsig with BLC_sendCommand() + # The BabyLIN commands getsig and setsig are responsible for reading and setting individual signals. + # The signal used is determined by the signal number. This can be found in the bus description of the SDF. + # The signal_flag can be used to determine at which time or event the signal is to be read out: + # signal_flag = 0x00, returns the last value written to the bus signal. + # signal_flag = 0x01, reset fresh flag and wait for fresh signal value appearing on bus. + # signal_flag = 0x02, return signal value as result, if fresh value is availble, otherwise returns RETCODE_OPERATION_PENDING + six.print_("Set the bus signals of brightness by setsig and getsig command") + signal_nr = 8 + signal_flag = 0 + index = 0 + luminanceValue = 100 + BLC_sendCommand(channelHandle, "getsig " + str(signal_nr) + " " + str(signal_flag) + ";") + if rc != 0: + six.print_("BLC command could not be executed.") + sys.exit(-1) + rc = BLC_lastAnswerHasData(channelHandle) + if rc == 0: + ByteValue = BLC_getAnswerByIndex(channelHandle, index) + six.print_("Current luminance configuration: " + str(ord(ByteValue))) + + # Signal value luminance is set to 100 with BLC_sendCommand "setsig" + rc = BLC_sendCommand(channelHandle, "setsig " + str(signal_nr) + " " + str(luminanceValue) + ";") + if rc != 0: + six.print_("BLC command could not be executed.") + sys.exit(-1) + + # Control setsig Command with readout the Signal value again via getsig + rc = BLC_sendCommand(channelHandle, "getsig " + str(signal_nr) + " " + str(signal_flag) + ";") + if rc != 0: + six.print_("BLC command could not be executed.") + sys.exit(-1) + rc = BLC_lastAnswerHasData(channelHandle) + if rc == 0: + ByteValue = BLC_getAnswerByIndex(channelHandle, index) + six.print_("Luminance increased to 100") + six.print_("Current luminance configuration: " + str(ord(ByteValue))) + six.print_("") + + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # 7. Frame registration and display of the framecallbacks + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # Here we will subscribe to get frames and write their data + # The disframe command can be used to subscribe to specific frames. These are determined by the frame ID. + # If you pass 0xff as parameter, a special case is executed and all frames defined in the SDf are subscribed. + # The frames are defined as a structure in the DLL and thus offer the possibility to display all information, such as the FrameID or the timestamp. + six.print_("Subscribe to Frames") + + # Subscribe to frames + FrameIDForAllFrames = 0xff + rc = BLC_sendCommand(channelHandle, "disframe " + str(FrameIDForAllFrames) + " 1;") + if rc != 0: + six.print_("BLC command could not be executed.") + sys.exit(-1) + + # the output of the callback will fill up the screen quickly + # press to see the incoming frames, and again + # to stop the output + try: + p = "Starting frame callback now...\n" + p += "Press to start and stop" + input(p) + except Exception as e: + pass + + # register the frame-callback + BLC_registerFrameCallback(channelHandle, framecallback) + + try: + input("") # waiting for the next + except Exception as e: + pass + + # de-register the frame-callback + BLC_registerFrameCallback(channelHandle, None) + + # stop the LIN-bus + BLC_sendCommand(channelHandle, "stop;") + + # close all devices. end of example. + BLC_closeAll() + break + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + # 8. Error handling + # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + except BabyLIN.BabyLINException as e: + six.print_(e) + +if __name__ == '__main__': + sdf, verbose = parse_arguments() + + try: + main(sdf, verbose) + except KeyboardInterrupt: + pass + diff --git a/vendor/BabyLIN library/BabyLINDLL.chm b/vendor/BabyLIN library/BabyLINDLL.chm new file mode 100644 index 0000000000000000000000000000000000000000..4f2ca65e0160591ee6324d3af1da2b1c284de4bb GIT binary patch literal 1289115 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Ƹ=@XwZ@dK)VUpDIs?vrznV( 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 f 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

{-IyXrCFRf1q3@IpvnrANMi}tT1AJ{MA}3Y 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
h+z}?n&lwz~WNHI!q8Un^} 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

y83ehuf+XMe$1JeDVp|&B_VZ*3RdFvGX~l4+IA` zjRx3JbJR2^`(g>CER!J1w1@uW37A_#3+I|tB-|aBYVN7z(18?A7raMV0##1yW*PWT zmaZK3xcn?o(5m`YCC76qv^H+z-%XA8YF>@3ADb3%{n2<9LU{_t-Vbmd*MJ%IiIGSA z+*LG0{%*+~{^j=kmKw^?m&h+iE%;r7bc0lF<5sf%_6_nNozSUqMh4w^1yH+SM-)89ntBMu~tswZ0|Gw9)HYuVu9jJEf zx_1MGb5XJ;@m{}9qaMl1lp9IU>jsPKvcS6DQIc_+bhUbq8_oD6B7@rS8SbQlXXqeWgf76ys{snm~c-f=2oBZxT-3qVbRo zfkk_#vr@EEAY(-R&sPa1bf!wMhOOELGS^F0 z0~4q7l82boudOb{&j{br8lI0L#x9w6^POVb=tX$kjrlwE(&A4#@2mEJdO+6ZcG9}M zAQ9@8v4#DgeNFD^{32kl>*g6>0~+}Mi&{5{e)czREZkY9uJ3(>dhz5q-c2m6F!!n6 zr+v{d-ES!HO7_&!u+Ew-HRK!Avio@oR8R}v*4ue~Tvh|HSb*cx3&xWKwyZioLx$*} zzfswjOL_(_XFNC`BHz3^2}Lgmb{Yn!bjOrkPaAGG_Xxa7KIfNn$g&H1`E^mQDOFgh zF*ydMu+2|bwGEoDv|u%;U%n25zx62O1B}iPIB{@tjM3FBu!sz85*{_8dJY8c)nw5D z14V{M#QEN>k%XSx;OMv;FxBzX=%R&wJvHV)h-EkptgIRczqlp9UGsDY8dAkO>ecQ3 z6oA?V;VKQXoPioMJqM>I+sGT(tuAAM_;yz*=Ma1ZfiVT zcMGYlw*i6Du^G`%mO1BI^QD&}R_+D+27T+QG(+1UVa4cJ--54-eS(X=8!bAlpDQYM zSZvq-RcHw*=iG)$(B2E*{Em*LhJ z@+VQ&AUV0?*xFui*^P4rPLBIa?^`Q3}_5X_kLh=oWc6P9I!N#r8D(imW9~66n&@PP#L&y;mEl&%Hbw9;&VOQ}H zZuANWjqYcc-DUFe>~xxH`ih7A2#moZ(~E8&&Gq{n9t0({kcGWF|{Tq znh<=!k`3zV={)$>vhv^b z1mwC4mI-pX-ao$Zsxk~K3E#a_jx2kXSG`+?|0Zs{zv4T?>VROd{`HvdE$>zhP3%u6btS1F|Ur}AlZD-|V2@btP?<|o*oplsyYt?DA?#u#QTR0XuEE3+i7jH-dh+Q00!->U70 ze+d0IS6bPk&h@>>gMtzU0>vHgocK5ZAm_ipH(ZO2int7MQx<-kUhzZbU5|4gYD?qxBl(E>){oycwwr4c;Ht-`JwI&b5=v$^Vlf z2qK2IhUBB8u8KF;tcm!q5^U~4%aM0%^nr&HUQK3K#cG(t@aH79-nBPgxa}zVD7o!# zEdHZxe8Vs$fsKyVgSp^nel$a2E4G#>hq1}IK++uoBKPy7w#K9ij>!ke&xYwA(P6|U zGJ|a2T<5;emMjb~B?r7?}E4nso3 z{GAE;c?1axj*HYj&TT6Bn!>=s8^SWM?foIEx1m$5ArXwahG0y z?NH_{ZdFDab|$$gyWoF9!izG)T5^@qP{xBtNaae*KCZy8vLJ;A+}5dJ7*{*9H-#@W zZ3u8Ca~Cu_YG%67qJtBD-brC-SVg+>9-EieF!@#HH z`%}J40Nlr9bZ8#)k)Inw@MR0m2j)gzXSFy&4V+7HbmZ_|CtK)NsL)Ly7D4G>bf)OG z8&q!e{{JLoiC%tCq`^vy*Ehz*(FXMO(r#*5_R!5Ky*}dt3D$pv9Ippz0=H2iWVmUj z49}-^#gtu0x}byoS+B!NZ9N*uv^rk=nx@O{&YD*(wEGblzTtq=B8ghQ`PdjMN92a= z)tDNxop!^K;TT4+A=oZU$a)K(C-7Tmj>a*;eo=%q-$30>G-w@=>TtZEe@+*C+-QJbIL@w%L#rcQdzqUT(0pLUs6+zhP~m#g(OGva1r6vGo{?SMRea9eY=Y~ z_G0zvyIOZ!Pz_8pvd-^!@z0Fi@VYb5OqMY{2aWekYH-RB5CZ@O07FAiBLDzzWj~c& z0dcL>z*|axY3v3Fi>v|kPl23x8^pESF3{dmuFKnC+wmCw`;Pwrj8GMk$N+$W0o+bv z&dg^6zXCHyN6M;i*~>cc;L>-VtC7hA0g)e0GRqgV;SAXM0RYD_ zU?711CyV$-dny7E$&gu=Ya&$N&O_4HrCC zN}hLs>gOD+pGXcujm?}fj|dz-0&qMcXsx5u8OX*M4V_7XHh}iw>CO4v5B?pWBcIQQ zlA*{Eln2FV48}3T4uHcXantp5QUZ;Vjd6gF@YN}!Ic->cVADB)kRpYngWK<)ID%(o zM_zEK>LQl>vQzDOJiHji}Z=2lix9Eo%|(SXjnlEX}JMf-Hz zNuLg*jFE~k(w_`prZkAyY!vCWqG&PHh`r`%P=|@0j!iY{u*to2u9J50=y}wdV-2Sf z+Y$4ervE8@)SHm`)O_k_)=(4l3~5PFN1VPyDk+bY^dd>KW4L*J%0QwU9Sh@MPV1g& zBZ0QRtklFNoiv=(WAay#an5y{QaW@V%~FqK(k2RSknsCqw4p-JNSxD5(fdtPMs9Bp zkXh2&In*sU*v2P?_3I)1guyy$iPE|o(-V9RNnO^UJo-n;Pt&J@8L(;3ADl0bt3pa6 z;|HFs{J~f{n@5805e;Ik@WxNF@WnN;WWZUe)Sbv$fGcr01N{zKGeR8;!KCQmNW(^R ztW{IV1;@N-B*XcWqsW*LMkGl(P_h3b33D31kc8-d1n$Mps7a7Hp~SU{s%|hXb5^ZS zIhoRb@1kf8#!E?#^98Sd0rC2h8k~JjxBxsQ^9A$cI+2S4^jb~V=$=sgz5F-X7Q9MKjR5c$C;qaL``G7l&j$! zSV=l6C)!9pm9)oYtP~m>=-_X~J{2OG-_t)S+?Qs1b7SaxS*r~q+nKazDPmr z&HG{%x_@-gef_#3$fk8l6?$K@ySGI&h4d4l1NeD%l6g9SFT>`+dFPrcV+2E&2QiVoI-FmP z1c^|q=jiwC>i}3ID^RMANS;~hD1{v*+GHtdg5?dw=14~(ZH`5wD)%|qd>L2v1fW@i z;?L8BgN}&qPyT`@_z&2dK;poqd0X%lIq_^72+-q_+$&^8%RM;`wB@R<#swb}AMN;> zKt?C>PKu+16J1oi)s%$#$6S@#V(7z8!aZ$Oq%v5)bYI~eq`b7P6*Mic9zI@K=xY^; zjD5GHNEJpV4>}Mq&K7KgJElrH4kh9dcWH*}J*`YTWQ`LV7^mo~JVi+3D8?$9`C9>h z^kWggS^RN`L?jd0QNo`=GU+hCKmk+I-7wp#sF4Bb-3@WsU==QhUjEFX##qNB#Y5Tv z%wBVMGC`FJ;V@FlGZsD!&qO%uXM!J{JjoF&Nv_Ol$nSaonm{@t0Ip?fQ#S4<_u@(? zas7AyK$nNg_p|*h>;}y$++#Vp#vQCj96ngb`*MUwoj7mj4 z5|I+_N+@UKYyyJ%Pkc1xg*J<_q-H3Z4@*7UhXg;B$lG_{Dnz@h&0%T}(?j&QUK|Z2 zEAt-?;b$K-q_u)GP)NEyD;}yetLBIUbOb~JOw0DG%8&V6ur6(n(Er+kI1F)nIY63x zD3auwTFNyn!OWr5A5;otKkkQBK{_o}6E-0w`KF@PZusNZhEzwVwpzH$uzV(hl&Z+F zP*|xs=-a&Yb-|$~khieC>oT(d{r&2Fon{=uM$uyr2aQ`6l-9~d5LaG;(-KTLz1+Y- z6CPSAMrVC2+UCmiy3<$#sT6X==YOxLbER*!1cwlF7b+fC-RP%u6*W1HY`7lY#t-hl z#$?Pi!PPrriBp{C4)GRNlT}q2P5T+a?@dRgVxF3AGFHtUQKmnAt$aK!>@a2jb3b~p zB)S?>tS~hkwvza*t*Ed4O9zJLwmMYb&4N5&2X1WU~I~|iM4M9=P-k_#u zZB^Er9a*l9y^H%M>d_19nNrY13#Fr>_24vQ@~H&pKnB2h3Obn62Jpn1WX~ExhzND! zW~G%Iw73A_r!cq^N&L+7c(esNJQ`W&!E34N zJA>=*U^A8Hxk%V7RY*QWw3+6p*rXd16`ynI;4U!9OTu%6;Qg~e zOBV1lg+a!sjThrDs&uMK&ewcn zK|T*?9I!WOVT7t&vigJe>+`gJGr!1lTE?1wW8P64IROc2#(P7~&tCsm!4S2`@4r_C zS3KXgXP~OPHimx+la4u{baH|_aGSJA?m`BXUKGaE1-*$wwnLMzU=}M?cE*qgB>ntZ zX=0DQK&Dl&kMd!+-P9Ez%R?1N) zi)+xx<}w>!f9}Dwu!KDGx@PE&g`JTeAM1JLyHH_&C0n)iJT9798C3I(Z9IMW#h?is zqSUk|$2qDF&f`*`-52AQk0-zQK7+n@5&Y#Jb_9erdrfDszRNruCa%y zioMq;QP!a7VT!uvMM-Hs3i6v?^h7lbIINC_kyiZunB09bP8F^c-se+DFx z2+?byX{AN_K$)5X@P{&n6s&nhsZxuIjY;OR$R}BNQiu;2QzsNKN$oFbu&P^vdm_ib zx;6ZExp{iy*m&5wV{d@DVQ9{M{W0%vmKu<$qKlJ7p_;GMU!R>RlFAc^GsvHW(1I!2 zV1LYl?Bk!)fj)o;e7~m?Snesf9S(rTUJWB&$UxUk{)384S~0s`q5;Fn38c6`K+?i2?GJ>60E{np zgOQ)6`Hom_`@fMAg%;6pyf7+b(c7z`lb$|SL+;?m?Mp>$uxoioQry(k~nY&dq|x4<21FA<#WkpQ#af#3JeSYw|(AX9(T z60wKr>*JmsLa0oDH{JW7&8uIx$4(DzJLuvy*+mb2nIzU6aJItVGrU(&Q-9KGnvicg z_YJ;B`0I>pXbpPvIc+fDA>!Xn9lf`)TKzkJBTSgF*ofy!rbZqV96iNyq18 znr$oRvn^+7TVdWGD-mKvKgel`1~tRhYO){^*^~+qwzsg4rPZyh55v77>IfvVv=|dH5p#0zC~|94_pbU-XQc1fD+fH9A4LE9Hx!DRJ%v1-A0a2raViLOi87!6gVvzf1@{TkGx zhen@AmA+*}GV{(Z`+(sua&R8+VDe>)&~~Xo|7e6OWrbR*m)j3|X?h*M5cc%d&{}`k zG>o7vV~WsqQ}K7A&N1mfs2~Y!c6FSsCqRnYDZXM8X0sB^MBrKU!ITdf(6m^1A&r;C z8EA>OP={SJ#cr24eoAyOfa(3ZZf~CS$#c6tqlt!FVhOk|hDh4K5Y#BXmL~n@yTVrV z6}-2N_Ca5W=SgP z{^vZMk?Jxj(nJlptb3yXo9mCybP%?O?+Z0{4W`dA*Ow!^t=(*Nvw=ION-4wJlxY$G z@Ke~$T{;<*W(9FYstQ6C=fjjjNGe=ti#KR2nQvgn>^?Vf6SyQYlu`!4~3 z|2)d|k!eZFb&#aYMLuVlTy2g7Rn96<9lDyM1i8C zMExD8E^{x@q1-I)nYhXKM1z&>peVpRq38C#`>tJ_6#QDNdf+i5zO6H;q(?V3YaTy2 zv};F^(O5KjR8F`ZFA8Kh--2b=1&;+E@zw0mz_1bB#SV>tuWuCI2%b7?_+GWtzEh_iY z4PD!}_E2`>tV_SwE3s^GMc5`6dh?Bd9VBC#+o+7f@$xwI{*L-}qh`q{r^(wG0AN(Q zH|2Y}sFD7<+hWOATbsaiwFyFt!9iDP6(G|;$x`+ke-z@vOfONtq=ss%ptYbVh+JMP z2KrMdi!D;uMaqV;0cAH=d@U5S#&Xc$cKO_#hm*!o-c?6VH=W7>&G(%Qs51ua?&AN> zW`h7QKXL~$mFc%eM=HLo(SPLJCsmo-|7;P{5ZlsLyrJ(*-#P94ENC`lya!i#&yI2~%Iqqwd0EhFyejsqk~!Kf(Q|R#WzyQdI~xHe$nbDC zEGu;DweCAk_cwRR|29l3u%ca*w;Yy;0Z8~5Oh4df417&b=@p1M<9$U~CW*2E|H3$) zHoi(7K;+`uq$XhYWoO+HJiZ5@|%L^g8LqL6#@>oG0~ zb{?UzVI)X%ehg*ek$?|a-#PFb9Ub4KH^zQ=3VBHs)|id*BX0}|03Q9^hDO^T^z~ib z?yGz%)Tq0@MHh5qjp0F&fn#%*V@6HPUX)`QM+{ zQRwrXJ}&T#LI}4>3nObjPYnr0Z*9vbSnv!t94E1ELY<_7b*_$*(??ItPo&v! zn-MOc+OJ%mj_wibkXtaWtk}rXdu@@%@~vm?Gy{ys8{HN?9R1iC7nZ<02C2icRo5o; zO*e1A4sUTK4ycbAGsEA;t%pPrPW~a{=NIgcN=(Xd4SeN%4MYJ?3~};N63+tK8L{?e9{$f}84H(6uc+;dZeaDdc+<4I9VjVLD$wDFK??4XIsbM!TqgW%O~d|iq6 zZ~+yenCXZP@AbnkFcbSPh3E7BYvyj__2w#hV@{G11|n_Q8_vjUSC1iC^^q4#hQ*G> zka91_);rvq%N1Y$+;4|Vn58#G9@`!s(&-9prjE@cA*5{Y0M-a06+Ud7VZt`bfYjj2 z`>NSS-ud%Q+EdeNQ%EWPJDYkqUGmVUYXzy%%MyVTx+OD70Z4>qGfMKluRU5Otm=LI z&T=;(4($l{&Wf8+F9=XnV#N5q^2fb3pS8b6Zo0O2T(I7tRhVSG>>-a+>bf^IEGlGZB#7jt`fFqcNn1}>>%wJkte2hv zY-~T@Vxp8(=Kz0i{Lb3&gRZkQ86JK$BKis{&znAotAZphg^oh-EMGRoS`NEy?33)z zFLnO~_H_Sq&AA>xHNU>&i3L-;0jlu(+ut;8e6pLCQ#ke{`B9&KCK5KGE2@J|J8dkU z2O?ZZlZri~=^z4qb{)f~JfFRtPEXU?^XCduY=$qOTOc;@_m$i8!Sf9RMJ`{Oe(#Vd zrTnX;^TN;fbVs-s=t9r@5#WirOu4OobE+uHx(9Jc*ZB8??KJ>(I_}^}SH2nRlJT_1 z`&Z3WPx2~*Ghw(agnG?MHh{D~`TV%MG#+gs_$nh$0E4Uu6 zPBc$#)^ap%wB0)$^E(-|C6?yIpan(4ah~hLE(!SZ^F#|M>Sb~zZR47ne)+f*dZVqo z(8dW}dMg*oDTeI=G7wIRuYQ8}knhYS;P_Rwdik2m-`vd&vEN}=P`p}l4uX7vefNPP zwLuvqdR=|$E0ougBJ9a*f0Y!hyht*<8puy){%zsPEKYvXjQeQ4Cs^whQLVQKb*B6+ za=D;LPb!%NKhlkY+HhcpzHJDVE_gcdo4ug~G0Anp!3S zAg57;?=fC{t$cBBFsO}!I_gmk+A*i=LD$<*)-4AjLthAI$M zd)~w$`0%e4{shbhySd|RhbmgH7^Z1q5i4Xe^aS`+uqj-Bw?oMh;UpL)-^U{}}c(Kcu=R-nT* zS5VbtoQ5(H&54{qZN-Yn`GC)}V;LQr@0p-)gro2Jc8(#=3*UzeARSeVk*a-5{m~2C z2p8w<&ju%!D2wYqV=5p{#V=g$*j$_PB8>4V=iXzQ>r<6nuCAXRwk&J+rlE;@$9*!5 zEpOGX!TcbMT)Y3b7{7jPWoqcc_md~85L}M|&iT5!=hNGvk;^02U*}HrryR&Y-J9K^ z`|rh$SI_-C??=b{N{`%=PDdNQJ|}OPU4uGR95y!m7=Od}NTXB*y6ipdF{GLDLCej3 z@evPibevZG1ldvG`dbNXF;0>HyFEO2lgiaV^H_P$LN6M1B2vc2^|Oy89OS&h;&6x_ZQWr2M{ximS6~WY!hMz5at{CJ!~n3r4T9+fNDHX?pC=C#fEeq~>#ZBOYZ6 zIkP`Ls!7>?*L=t1L%hg$k>2%D8WWe8Ejkxh4BhL2_V(NMh5HXr^u6Odgrr5z&iWvG zIGm#K{@qvlW%v!>cX0dsd7bpYC*Q%lmBP|LlN0Dz{UCw~uRXY|8>39^iT(dXmq`+7 zgiCpO^PM;&VW!O_mA&4OUrrk!u3KwnhR%MS&s#1$JwAE>eSV-+2F z1(u+5nw>+t?=$Juk>|!Jt=2>qiW!YJdZK*FmZko4igC3IkTej z+eLg;@Demsa9Cjr0p_H`G)DY^QNHoKI^(;;Fx%#AZrQGw1QGBXYR|lZY&GHef}QVe z&v54EeK+sQO3jyzcN!=b2d9=QF@5LmB=0S+i2D@M+MOwaLlAD@oXiOA(SjEtqtkdp zwj`uR1o7aHM`oJblNrlnaDvI2T`u6qq|O%^C5cltkw!x`?>z2U4Dq*8!YcOiP;|O9 z_XsA_+5*=%F(7LWAV7Xe6jvK8gG4A7a%by#^5?nE60}^_Sw@CngUbu_2Y$KbHOn9# z9NOW3A$HLk8`?ZCU&NTKvvDLhUwxT`v9o;fT)oe-o zv)x?KA38|bO%_rzh7bo3cxZlnpg;?TS|>BDLB=O914Q`skX{7Gta)T~ec;E{GG?4` zuKg^O8x%5R7xM?l{Di6XFnzfbuo?VE&1;1OiARgErY_AQCe($&TLoSJVFJ+q^4ssDRKqk#Kl1Qe%S$94WzXb-hy$;Eb1#wz(+{Y&-4Y)GH|o!^-rHZFQ>h(8cw7PP#|U%ckby2fd%QN3Cy? zgnVj88e`ea!*EdeJ?J8PVGf5dKWC^I%R}9EX>{Qua=IIyXM7_@z&hbBOteDu5887> zA3jRwJ&9Fi+X9T#igN|J$n>A()lPN9@-U5kFPCx&JmtfaP5{#^+hCco|7Gf808ZWc zH~&a0QxPb$@W(&i4!`}&IxEZUDw#3ZR)6{YB0dCJXu%ffEK=pjB|@C#gHy&U*HkX7 z=et4v%Pp(mY?xJ7ulJxT)(>T+_4Wt+q;y2^cUs|PcR)GTG{3|hkNI=XdmS-I5qMAz z@wXbWx@6PQ%bHSLb_{|m2~7{p1LpuSr6rih01aHuC+gDGWw}9sDPyL3;f%wE8U{iq zu^L8$j-IJ)r}E~b@1+b- zmx}tZsA3SqC5|{NsWU(~BC_IGHMN3uQ zGHAj^7^QNSjUUEsSNvEf-d9Z?+>kww}>B zn1PK3=7bwk3u|&7HHYaE6a_+EHGQVjzk@FK9GJ|1HrL>_t-aR`n~)j>01+e>j1qnA z!jKiMW3EG9fTXWH;)I=dGB$s2dF88J_?RQ5zItLd`wjys)$fg!5KY zh0;)3*q^2UW0>SVoYcC|ky5+AIKusr=IkaBOtq}Vi;=9DnOg0w9z2_t-o<~lGE>z` z$PH)Jr@Y9}E*bcQU1NF+xHlxfHs1R=HCXw>I#q``L-?|;Z4Z-r6?p84!e6@;*Xky* z8MYGZRl}un@wTU`-J)M#X=X|+b$dh9ei7NUS=o>_M~B&pQ3>)_ti#d7not0#Pi0=Xeqhl ztgCkV*1Zc_<10)FQZC>}*sxlMngOti8-JC;OMqrfHp+{QlwS5VRW$vZ;L12U>jJZf zzg(iQ_62V9uH+3?tyPr`Y8^KqtX5WtiBbpxAk@BaXbSUQ4g;x`{EpMT15umMmic<qOa3M+V!KI`fkAb^bU_Q{Ef!2MY%!y(O#!$- zh`i1U7>tClmY5dHEy-i;3}ozqOZAEFsPMM6K3xwd^=hhn3`8-+GGT}YS&UNl!wKOY zf{+J~_I+W6Jv(=$f5h)Sh!3&|6Vs6a!eA7^O(y}23B-g$8JacBe(T#INi;wYyFu#^ z@qT4$s|AmNtRQyf4O&pbgZePi=0?fal*O0JfXoPt#%=o#P^uU2FC5as`oZl@OF*?= zB)zD5QPZMnx_Wp!NT>w+iWoR#)&ERA4LRN-gWisUbZb2^5Tv76I0dZ`BFlcHlEZtD zw17S$%F}*g`0Y0E#M;W5ZNMgWwcwGVenb9<#^(=r(J6*q@%{<_G!QBMR&^GF#*m%P zLiRsePtV-B>oi`NERlv!FlzP;Khu2SfJQzqVuS+^+hd0Fv>n*MgMCKRp*F*mb1r|* zEyL5YsKpzbbtR`H`=3JL+rkIuUr5ohjc`eT4S^&d(kJP*-zA)Q zu1o`k5tr`%D5l9LYz>Iq4IXQRCs*V>*bJ@uN-lSp+*qbgHwpC)NI=ny+>IqC4YI!XfblrUqS(VN7^Dk|9=)N{EGt=u)`u!& z-yjORxWk7y_5=wYnQHqm(%s4!Cstamx)qS{!NrjeMiOUP+|Nn@vS&wkhp(c=PIrJz zFqffVmtGz{3osTn2*r)@Ldsh06KKA(AN$Xi>PwMV0neQ(C8CKN{9KN3S#p`RqhM}}MPS2@ExsG{Lz*lB<8gZ@ z{;^D?6OADuwDc#JIynPkWYkd5YBlJrYa^szX|+fpubd)TeDlC|%yIlO{MSdlBr#A|Ru| zT}XMDOt((TlGzAH(;O~O32!o;@kb&4(UlkGC~9C6!?OwRlMN_s30U_wFgASSvbsgM zVQd#W4*tjjcRlPo`oBONZ^FvBI|HA~Jh26%JlP^Fjng_c3Kj6778ZtFq~4V%miM;6T#C-BF~HXxHqsT#^$E@HwF~h zy(twpT$&)_bxhC1xH-`UA^Ya^EWIu6Po4+u^B5A}qfQ|HY@Pm^yY&tWHSW11NQ(q8 z8RTJ)0!1%L3jy3$1A`KZxMDmTgDf=~odv5c!PPsI+V z%tBrq0K-wd0tePwq-#poekk8-IGn4c7FSRpsy1XXAR>aKuhzh>hO93ktz`WSkuKZv=uCoJ2;>s zH*ZuPiD@rx@D}m|Q~)_=HO|4nHiS*^1eXB8w#lbp!{TTQ`0wD?03wu=(mI|d-7?|x zx|t|80x4Zk^MLxgunQhklA!0+DbvO=;eZH3&C!<!=pExN@#h z5D~y1i9#*rsQWHKgDqug?|(C`luO$U>PDu%TDuvWgu8=(C>0E~T2goy2pX?pud6$w zI2QOhr;EH(Z|S|t)`DUn>-|g!eej(aybSPSCMA3IFQ3qPY@br})eqW{$v-dC7VBvy|64(q9S(GTEeRpw0&Fn4|{^UDR_YDJGd{`Px4JYuh+`*83H2bkeyBtHa!Ps zYe3#(dVL-a>c1_bhiH}&81fAYU{1^2!j((V5Sr^3GnlJ?cthg$Zcs-fAM&992R zQNByZKoWWI&MWo#dVJv^htDTBlWEcfj;Sh1Nr#U|O+N|hVA;DAn5bb^tF(zI#wtLa z*L)mU@BCws?{7zpj6i!2V#uXI+a)_t(|Ldc84F;7-dFbHn1A65_@AirDT7b-yR*Z# zd(-QNv zlJb!lh{FP@B;n+!jd3Y=)3h!Na#)QCwyhUq>d!4kW}c;lL1NZV$#py;5dYeUDs1FR zXCwqVWR{f8!4JG}AUDfXZRBD0H+00G@{X~1|Cp_R*-{aw2w}~d?I#^nBqiJq=m+1O zApQgDSsz%_JZkqCmFv?z&SS!?^pm^|N|GFTnSJ=viDi)((@Iry+}Tg?>@)1jp`i6< zr?W-Qw8|3?=6q^vFqsyz17Y22R5|#nGBB2jz3h-wxM;>a9x{hF2y!bvBuR z`9QzkF1A(N#e0Zd<@H_YA0q#Y{p4FE1>sNHiWBCN5XqbX!DMtZu^0yLs-nKizvm)x$P}vtfYS7 zaJ2%cl=D>)j>Atjhqym%Rh||f0f1JvC<(hJzk)Xbh-H#@0W5k?04E`5!SaL&CUBPu zo?rlsAelTDc>wW?RZ`?D;B^7Mfu^PqVM%!*-T{AgWsCM2PCh$?w1ONJHI;@US&1yN ztF|l#OL2aJ9v0hmR>QPa8?3D~ja63(d+ysPco0+G>34!8dXQpd;WJ`10s}0Nu`)oT zX3x5TzUa?7v^h8#+!cSevFmxq9QD%E#avt+JL2YW0dn4(-^5@f8n(qnJhi}Kx=fi3 zx|2YK%~E`pGBvMUvq9lzX3@d0b4qbGJ2I1QF|n( z{4Zhu9i%F0Whk&+7BSUC7umThN>D;-cXp&s0O_&2r&n;7;tJ&^pq@Wb>xElouVE2S z0H2QynEMtBcD0KHw>m9!BF<8(SggpRyPD-9UT>l+Z|kkU`r=s;IZa0P=6#)iH@tMO zeZdK-n&Yu>SAi&J@w51t)3tHs*}({VaYx--dblYceZm5i!5p(dk4+mU@(WZHu`5}G zR})-h;;k&ZA^Z8(#9Mk^mHcN*AfAD;M8*UL!=pCf^Hw%F@fr zD?Ck)7IdTq>B}#504gvjPycvVHHqT?$-oHLKJ-bGbvXk{j{ z$gW(uN<{n2XBq|>FWif*8DE1Of>9*NdJVH>2_LIq4LyFy2cZQPblVtJ+!?0Uk&QTW zTZ#4>$4Ap03qp45{%zB#4c~6NwgB2Tp6HMZ)1Nn~Vq?#7rvKyTfGBgejw)`AiJxSn z&0J&aT{Qb`mX510Sct2v2 zlAhfOAxk82y6!H72-HGdYnL1R&|(7hmPr{X5K>#ql}j$PTUU@TOcrUWp?p*VFHl0i zRYn3N#IF*J;AAdIkZk|}838+*0s#Gk-}n7~xBGT??e6Zi*X?GnZU4-5YrB80*{uW` zmIYdZl$5Ya7F1aRr5YoH5e0k%_yT|gNchMg2m+vh5pQo$lZa2i_!x)_d{D{f9KnHn z0i{x?)C@<~1H9w&E7pJgA?}s{oPlMsVNf6j;}RAMz$+yK93^UvM3HwDDh1e3Hfk~> zDy5(_PN#H{Bh79RDu}FQC|)a79S^WZYz1l|k#ztK9}P~!325YH!$}GxnMoWeV6KZb zu~nL(lr2k3otMhu;N*gaX4%03}*h}UC#@b@Fx8oHxNRJt>dP&nIM$g<| z4Ho6(c#>VrzshSm)zqn2HILp}ZX1#({#f*!oIZy5eHBh6V{UF1swAcLuipc z^Z^72yE=>=3jU0|;0(Qe1j2#{&wKI_gG`qvX3KUZ*ijMy z+p4TziLZbl~J%sr3Xu?u;LK+GQy zdnOsBrqnrTQu&LqBJYwD7(F3Wg;E)KW~maO1$-wl!#m~KtEjcOWuvrW9j7B?tN z$G?$-Jru*SlsYgQb?$aBcsx-1@*2qUNC}+$#@-ZWDcS`k-%R6#A=^GYRw+`=?Zkiz zCc)o)4R4#-CB3L#3bj!0m}e<{!-hsJcp4>mGI31laaD>ISk{mAg3}k%1)u*jk0wzK zu)M;lOjmj$#YCS|JYY4ab4XYlc)g-E{78okYJiZH{Mo0Hld*57#YI5B9>l(=`k+*s z{sO7aE3JPfMnp@==vI#_*yE#o`i!~9^(G@n-I`e!%aQQ;cy`#)h(>qktW?ys7cIbf zdO9uiYmq&GQYviJwPn?9AAXzByJ$KhFMpd~`&k>PEJ&D`{Lo=?U%@>W52y z7*OGGChD%T^YHbSICRaVHAt&!=So24^W@&Et1=%Bc7e4HtvA$Lx|k0 zKoClzt|Ok|Z;W8Iw>ZHf{HfdioNAxH-!fTQ^ayNu;Fpe&s+E%uX3Md1?BqfDoLN05 zB9aV@PUA?R6@(Pgy5Kma&XP7Y&odC>Z>m7y><;fcKfxdsvLB1>0CR`g zhuQ?XYLOw%d#E?J&`%4Czcu!&zJ_%J#?62ePkG0q>7RQKrM4*77{0Ak-7V9)H?(5H zQu3=9Z5Ob65WQ`F#{mv95ux=9lYp~C4^c8Sx)u?))Xh&v>BDFzv5d30{4mGF<*q+H zxs?DreVI)SQnplJ?CGj+mj;C8=u0lS`wBZ+R>LX%NM!G{Dl7=;qlmaSl5Ow`C9kV0 z$*z2;a;^soWQo%WA;KVUU~z4?S-KkWIqf!1bYPnS-%1%cLY9_}dASc<%rarVUJ#N} z8Z?kYDMyh)0$>pyq7?f>(ko@`8HPmVlFZIh!&$Z`S>6~fOXOZK#rW+5wgaY8I zy^lab8&4axJz8c|u$Cswnsdx6V#OQbQZ(Vws{b^PGvl$)^KBV%PG2ZG%oJ2G)$g?D zvpu@hzr-AF(W1ag8E)B9?+>{>_ixQL8t>JtXMDF#W^)C?tsBJ7H}>BlSts3&@BQRE zf77Ol1gn7Ptvs`&4z$_8UekJ6uF6~#XpsV+C2kKljvXKMo-)p^Sx6^b2p6zxhG zZ+?J$9i|J`Q>kqY#ilBh`Jv<*fm)reQEyCa9yOu!Kpij-UZ@}p=2H?$@VWakPzZ3e zJ7n|^4I8Aj@!6#k2}DuUk%x(SpbogVhR!P(_mN>Rjr1~>1Z+gMk#3dixZ`Z)_Jp6s z&6PJ;ON9yTF3EyN7S z^XbLSSVIiWL0bPHEB}VJehT~ubDRPPX__`@;Yd6VjB}W*AR5x*LLd2vguog=w-dIC zTCyJ@Ov3oleTUR-CuhIFjiW9ug#!hB$RoW+3D271IeNP3PBCqRYwn|c6QX(t=CnUp z4y}w(SjxdIj>^4WiR@tLK>tS*TU#Q?@zjtPP-BcpTM$3KLQZDrIuNIN+f7qZi*g(8 zdqcu9g&51FH%bF7`RsF8&{_dV5NZ>7-F)l$u;9&+fPQkI$^zi!?~L}llzAVvlewu% z@BV*Mp6WS9_4s;sQuE@p?xa$wjo9~+Z#=A?ch^7-d#j=DzMv68$j}jqh(+3vdmf%s z42$#GaP#(DUc*X65`i-#O)J-$(j=F)^GsQ*(_B1k*`gPSene;G_I@20EIYp_`R|V+ z0EqmVUzbq4w-Kf|YE_Vgm8P_RhU8#nM%gHUhQetO2^G0C^h{Gty{Vc<2xQ?}8cA4r zwF#QDefc=vTN+1#&;3Yly$jvTQC-LiG*asR2(?t|2rsB2FJW4UPOBvBy`(}24>~zU z98$z#hyde|ADGNA#e8oA&3~^BP^sZX&*pn;r_&WIt&j#A*(JOYS4L=(^CC*vjOqxA zs)Xkd2pM0{e7er~bUm~VmwLqf(DBB$=Q2^lSp^;H7v{QHX^*H^6?BtI@!4>%A$zx` zrImiynkc0cpfi#JBV|Y>1@2Fzc>o z3(i7ISYRIvrLjV^_z!^&QsU9)KxjUnx{;0XZthyFyc87ou8cm_cNIKLz|0`#5zR)x zpj~Qa1&v{O)ZYjr+-Cr43}PAJs6R#zG)^rG-?jY*6HsHTVus6x=IE}zc(>NwOb4DR zX{JCV1$9*8ltM>DmE1Q3QSL$lAapKIL5JtLEyv@e($%`M%~=}9!Q!!^3G^Ed7(MPG z203wwbV&R0s>kPmY_vWF6H|yPTD?kNXsAo)+51`C5sj%-9*b5gt^m$;ZyG1$m6A=% z=?l$h^ScCD!6n`aZeVOY)BhOgCdAClRWLE!^4|pvyd_{qrHp}RsU6Qs;)Y>kWTfYj zd@9K5QRaDQS!l{|#c*#sU(~l`gOt#omjg$lU!Ef?FcZ5-Rfp`nk-|6~G2V-ruGI#U zp64r|8jfe0We>2xz0pF*p*o(&W@2!?Cgza>M#Lmv^1H5lfTbnNhTo^7jPqhK#ZvwQ z>WZ{)FhhKouTSO8S9#cyi}1)s5kkP|KajoWB_mJs@K)@JSNZ{#c{6ZSWQWw z()@Ua2iToW0X{gyh|@DPVBhwi0j4S>cts{HLz92v+<|Wj#iHC;GG@$U2#VZnX3C0P zNn?Vs2&vsX8d-&Dnot>};grbfQ!zL%j@DI+$D3>#7|FCcowJo1VOAPlv*r~%_byVE zMUILh=Rrg}?WS6;NKjKSUOv08ad&9>U+FIs2Oxl;=F3fTj?mNqTuU?j)6w}@@K_E% zR#Hk%hKiNI3Re1&9?hg*tuo*~nBcQLS8j|k>dkW;|JGvlP*z2jumqMZ$=c@T-iw<- zIf>>OAba4SufaS_1g|a+|0f3VT^2`;fp2BvH*Eo2=2gvX_N*O0i3l|uGux9ZM2QpW z4>w}?F>@@jqL^5?iBy`|WTX)?yPj(=$RD#^VtsjQ41^e`K56K?f6VbdTXPrivGtPT zIgT5wTr!z=ZpTrJIG27y>BgkvZB^-ridAH(|LGYRbZ~xy;{}ddyyD?u`W!<^g*~S- z%ZZyE*Z|n|+Dw3bbFC2f*KesSBRRp+8kJVzHH3G8d+k&o)0@W6_I-DMd0fc9-2194 zRW$`$hF&i4tlN~;g#AAzFmYxhX|&E$&2Lscx^XRZk0e~0cRabsLJ1buq1-iuEj7z9 z=hM(*@0;FnZ2R++DDD-f(NMEKp1C!tD`ZE8npNyEiCBc3Nur~;sNwY1v<>fCckx&+ zKg%z6zu6mFrl;C%Qp(-lC-kk^*{ubb(hMd$SMC2e#40{xiOs2|waZ{~lI6D+=`vbE zbe>>`u;3KNGF$;L0R8yf)BQO$Fd1uC9vKu|$JIX?wO%orZ?-@gEx`hLNX?dxR0YK+ z!knB;fMg-34t_I_8KR`YEPu`xG>?SdinK0J<%Or z_Lbgk>bE!>_CEyBI`vh2;yNgquodEO2orE0RZOU1{+}*krvjE>+ktjs@0Rm%KcNb; zdz=H|I{Q7X0@#nPdY>j_1p9QStU?&`?6Gu-;zp5x(YoxKXn5;>R|EXYx^yP3ce5NA z*aKNnk-^hm?)t>CMm&J5v^+~BWUc4dLe5PaX^Mkuo4`BRJ}Q06a!Smzs&@G_-Ld!b zu-2Llo1#%f!mYd2RuRp#dzi2NtxDK1+(^G4=#nu!YBKIxAk1mM&84zz{p{gqZcxg3 z4VYux%k(5(ljRgQQ(PLeup%f^sCe3G(~(+Wl#ARb;=KdtQ(LE_9n%BD8EyLnaW3LU zumI~*ca5|Q_v0^+`xeaVEJJ_C#E~&!_&zfi&9U5vI$mo7&He0`=t{hZc8ox?c1H#o z;Pi{;8~b^N#Py@WxK@5OcW*syM&lB6yoxd$63AFhMh=RCVe8%MRRbkyh@S=qPt;3Q z%|}5%LlHN2|0A$qgjFi{EXOv0#hL`GUPW!Cq9sEvL5Fe(+t}-86OsL{{l3eo??d+WoYqI!EXVg8 z{y;y~edRX+HOUSD=)u*wAC2Zd0YwqML3u(TD-;B%wBm>*5Vg_b~Wsq5naYm@#5XTj$8=E9O?E7qz`u5jj z#p`@L!=vt(fWe3XA)u{yKcBMxGE!;0Q7!+JX^7(4XKa}})pzDwud0iE&P)C-t=7ku z^0-AmD(sX#NdwJYn<01jKd(305_DF@p+EUL9mW-<3oi6L#U{VIWp}WM;e^}_(i(%j9Y#L-g!qH!);z)Jo&;rRaaZNPa2_M)Zef7wwl~>scu#AI;#3dm0_Y>(7WSJ@C#werL)WH2y9@N`yr^z z$Jlz@+X~@dPki-i>^RpnvseR?0%ErM*AA^1m8qjY-S?y=s_wBNOZ%)u>^C zWBAjZGD8sMobJ~Ve6EbMI(=1@cQ-FV>!B!0^iK1OFEmux;xNj*l)=oTE>=VUc}(WG zvKUa8EqdX}zy1|Ga7j3$qOBuMur9z#r_`P{)_+wYF z0~>K2amC**J3T%M7Hhr+wgJ5`8NqgO>sAtKJ-tU{DzWSH*nVpFYVA@XJGtQe_Egeb zt8MW1orN0bb_B&Yj?53b^WuUBINyh_$M){?bVJF$stU7vcTHlE7wmGGWTGn?^EA9k zpm`NMG6@!p`?0GE#5AoGvduEyW?05RYcs+a7z4OOBhLdF%m>P`a+}kAPIW2U8_nLu zRpl6a-OPiV0W%#O)>V+uy+B~kX=^)rT%HrS7&wn5^g`nBH~yx=Gau}OuBmr1Sb5 zw%+>}{!ph{KB#b@I&g0{Xkke9Y%A^ZJOBV}Zy?{;kQ5#g`nNo}rEsrmbTyde;17DKC(iA~bvnPb()(th;OD6jDylWuwfp;i!daVp}%uz;M z(#^C|jwqM%$o${OOMuov67^j*wyM{o}a_<;g z%vm?4lf6pL{!LdQTji3U59f>5DaloaVaAGcLs`%8H@EaRc$u%)sHVLbM+NUGmFJ#nOR0N-lZ3!=^;VEPr&&gwFw;Iu`WZxnk% z4zE?xImi|#e%jy zEZ|Orh@)#lZOLc_H?kpil;_@)CcB!uXEVX27gj#xjG%@Sk0zy~*#fXYUpR9#zI7(M z1L;eKw^MNxs?P5>*b;oLKVRoCSQgXo?$a0M*Ouh8HXB-@46ab6QTKdZC-;pS7Wv4U>Or3uF8fww|; zT41^~^7=vvADD|7>RNs7tZ&^&UHB&X$d1xE?qCzqK&NbPrMZIFNjt|CxF(xjBSIjy zaDiL3Hp||}eF6i@EIh(?!55I)|F76k42TJC7&{k{^v&h`M6W-nGV!Xe;FWcLTI_Tq= zW45d1_<>Ea|7kGHI=gp`K(}XoLS-U zF7jgApI9jn2C?P|+iy12fLw?l#8DNTI(X_ELFV1r->Wz3PDatR0*HFr1NiIA5t>#- z^eQ_|25_P)uEp1qvJeIB!U(gP78_M9ULiI{J-;WC74!ivs07*bpcBUIR4b{o;W>3? z8SU9CYQHx1joX#LM+-dbOCLSgMrZj1pm{~p5tIE`h+qPE^*alY!|bIbLs!T<}jJfx}h zSP!KP*L7|~Rhc_ZAbSGpu&L$5XIKu=QHIu)GDQmr3}548P=x%@`52Q!(}{%_8J*sYx4|DwyD?!Z{urib35kQUkk{6n?t~z^*UDZZ;7+U z6Ki#FO`A|ZTTV@AMJ4xfo&6<4v8VfJ4~=_-H-yi(YD(&RKg~EhWWp&EZjHdYwlb(d z*`Q5IVUClzos1G$L1?SHP}z=n@aHo(Mg`lo8x|DDuS+yV!m*z9m`AH)R6|T7PH1K+ ztR()I4+=j)Zgo5!RM=5%??mI6YswCp?~K!a);DcD9Phh;Xz;0FBHtz^QpUoHAb7#h z;!#77w%aV&c+l0!pf}iCOwq^+zt`uSDnF`)z5r$1mUZ#^f+ZA-Y z&kr1=3vSUJS5R=KL%Og6?z3>6vub#GGMLpd$cwIk!d0}C6s_D(yw1qAdbHT2m($aR zp_%>ZZslk)(oz;%f_7cTqgz0~bqZJFBkk=BohW6Kf4nfh)#o}H`anw9cVrlYQ3Aa* z1%Rsa1R}MJ+h26A_v`tVfh&DAM{dbPqU2;`&Pkc*&@-u+FaI1Rc}upwIv(>?<*7RK z)+c1XHyysxV81Nf+h4tjM&4)i9q&u}jsL3lPFHSQ+KF}G3pVM$7u~ymqKm_P)Ec_lc4>OXfvJnh|p3{yQ{uWD|7P+Z1aNE%-P{C6%)Y@IHMX{F!1 zha=V0etny%Opl5phf| zFr8@*9$l^U2b$$yn;{e5R$(7}*^}u56VX>;Oa9>Ts!e{1VOU};n5tXzpcFW+%sS%hoH!~=1s zMC{R*M+jry(Xx|>AqGMSix3?!Vk5JE*%B*9_EN7;cDcBwe0!5hjv>A1OP_Dda;N&y zoH$Npxx$M!Dy3?d92c|BT{@-)p03;FLF#V6nXTE?+QMv$y zYuF>U&ZfR0?L3vgNGAK+QZlM_;wyXOThAy#uNYV5^e;CX84>*%wm53mL`Zd#^3@jy8;}r*y zkq$C%ZA2J8rg=5dJTc>(_HYcG;-v=lsAs)qGhCnOz3}ltPH*{~E#hwY0zMY&yJs;z zM-qFq;*1)bB@ny_JT?P?a%)F~>|HtAnbTnF+O`3b_pGUPfV7@rF+X4f8Y^ns^;&0} z(care%n-E^<4`WQ=k)+D=0cC%mk3h2LK(^=whVL(X_;;0qegnMmQEHFj`&U@(!P<| z!)?Ps6r@2MI2lznv_jvsH3s`!Ar*WODUC@?z*7E|v~`b8***~IA{%<&86;Rd$};(u z6G7x7#p?q-j_y;|4RS=MCt$lWCrYL008TtPiifzVGUOZGsJ7c20Q?5rOnEQbGF@9 z>Drbfd(d7hTjkGQcROr01yEH8ksmSg97*c-+gU&+uhEd{<+}UavtrjYrBhFYr9&h7P|$bcmgB| z&`}Sds`a!5K`HFO+)_lNvMGf&LcYY8GgTzu)sTqLBp`zvC*hEk0SLVN9?s8fAf?w~ zuoUXNL`8X)q$bXpFe+w(S#oS8nR8iRni>;nRXc1l)zMKNvxQeXxQb_$KeW;uS(-1y zQ7Igzrb}Zn7?ees6pmt_+E{rfEe#Ffmn+MdOv_74mW`H` zc9r7-4iz@muuHclw>LOKU^L{OyfST~HG+D<+PV0V9mqvx1LWR1BF$WU*)o-vW~I+E zm?-(xU5}lfm30974`;q8g;Na+>tw$v6DU^9&TLj< zn^|gc+VOuEg>$YfUS7agS;|?0DuX>*_Wft|!d5T8H{w0zO(1r1eD_g$VB1k@N9b@V zT-4Xg=)aLM0M;pOQc734ER`}wKV zZ$|Dq_3BTz4K#vuG`r3FGlsKQ+ges>>eHy5&2hBlGO0$b1UbB4R2^oMfsS2^-dbH7 zoY(JtxlOmZ4G}v!r6FMDaybm%vd&9v%he06-EWzcPN zGRiXDzP5Q zGkNjZ$hGZh(;O4DkqnG0dHmFL^t8qaJn{)j1>GKXpaD+8SDesEXU{G4f&QYPw3mZ! z%Ej){EnWY&N?qZ8cnt0(Jqz=%GO&Zsx^Y$iL)klUa{{<`z(~4#Gk6f+8TUK zmJXAFQUU>gW>%w^-ap^`1~78~qdS|RnM;Xyr?L|A^XOX1d$I5fE43M$nN#lk-D_-S z*!xm+_1^k4w|VxG`g%AQ?YS?V)g#gEiqdwT14+8d@t_>=rtGNy*JokjSv^PZs>)G0 zFr}zIN#7rT9JG3m8Asoeno`zEt-PDGZH7|s2i_>fY>pj}TNj-PursFILC#v9{H?|4 zRuM4ffk{D3N|4XhWnM4|&=1uNly3)V{ObJ2EJR_BFR#4^v%o6e+vZx$B)LI^oR!uEm?B&b0zmWqg(oC9LT5uV|>Zf?bxl-RO zn>AKJTKt|XF+JTbPu{X%6!M=HoxkkhOBl@onOsj<-~|V6;zsaA4*nzk*W}B+JLjkM z7{E_4v{4e4?r|S{JO~&!BFufk&!=5$Pjly}s|wN?I1PnPl*8Oo_48x)YM+YPr0T%~ z?=HRBsGTqq_lReNat4|4Gjr6VbZ&TZ{C1{s!MplR+e)!)yO)if3+zy2Xqi6jYgWQ& z^;nl0{jT^E{Ce=&#%a{?`Q1Rnd)xS?my>Q_T(hcxIWhH$koPuuC6>!~P#(f!B;Km+ z?0bbG&-Ti1N%}m&I(E(hqNq;e&GYQxU1IRxXKyH!KVmKvvW%6L1$tDT!Kq0OHNyp6 z;X8t&e15yvxmg}KNox>4^f^d5t6#*rEw^3oSAvsnJ=PR@3f>Afw0e7*>RVc?1YLR) zQmqZs_1y}2@GVH`h%%J3C0mMWbBm?F#lRs3KhqVm;MZfA?@iEZp|`0(n)7k$4Hj=L zE_oOvwB^pVYZ^||y@1BA?gGWXaf|R%uDLi<+@$BN5f823g-eE&q*ZZd1IDYYYl_Gc z-DcA<4}GakT&8ANyO!wf>(=*jjN%RHdWWyxQMAM@5{|~yF@bG_G@=l85-nxYisG&blpY^6-?4n|cv9EFpO0sG6wvj+Ks-o!D!Z-}m}X*03re__ee%^!El4q|h~ zUcxjpl*E^O3GND`P3HN;n!HxZgVh8^j~{&3V~pqPU^?#u;_)&^Ar=JdlW4eB=M2v z5MDVo6`KH&xsRN)6h<+c;!+5 zp+wWc?V6ptVfEYwz73g>Q1f_vr!M(WM9Q%rFT@@1#e9>m~r_GA`!NEjzYQi^cB;nQvOL1ctcRAIu zXRDjo<4$+UlkL`u<&t6WJ;$igJ5oCmau3{%*O3>NE8_F$Y^;dG?XU72C(F#P*d`DR zI&Cv{;YyhH!@%`V##KNLLT10}{^Eo_?KR0>|5W=R2lG^sm^X3=YSeW@Gd!W?mz)pI zXd*RltdK9FF%wdRTI|-W?-H>H!x_hCO^a@x7p^#oXg~7XknP1ppIFXS7-fv@#pVhm?=L>p$8d&z(lsM6_rQ z(2ev%vHrQe7EzNkF`+^4?JiPYi9N=@*(&yaSULAC0r(Oe$bE+#{TUjMp3iYJH8qPq zHzokwW+)Q*eGh*Wd2m1ew%E7-rglF?j`c&~KgHesEb92bpt^7@cS!J;xZ_-5q7%&G zvq-G(hS6`&IU!{9a-}5>vw?phiOv_G8F|wrr62ZJO3J@YMw6yWMK~IymBd%< zdk!4$|CX`tp)%bmSQ(GUQDe%ok>lZF5Q1^^_iqEAh8T}B0RY5lg_ z5gk5Ogrf$Jq(wTa@--zd873YqWybFx*ljEM=)Sp>8mh;Ar*b<-h;sm6pLvg>5Aoc5 zzmNuSHu{br!U1WFNE``{i@*ceV9}<)9RbD62}Cx3$CZ`>h%Hb72LKM_0uTVe5diia zkRUlC#q1J@P~zhF<4@(RuZZj)mZ%7M9%&TOr{uDhrZ}l#dH<#_8$MW9W<}OK_?02d z7fjhQrg+qpsXGR!HvEx=QxiZCfXr9C_iIb zG&;hrN^*;Rs4YyIT%YwN=^4}Xnv<91g^5&HkkN9a~v_Y;# z*=2t~U10fyBLHujBw? z0L%aY;1R@)D&VA#BGUuNh_*XN>mjVD2Z6;i<-LWY1#@~JtwE6e9(%dk6I#3c z?#uK5Nk=1v?6VyiL z-^pZ=h>U>8#cXF}1RhCeNI3)mD+q`35QqTq0RRnSNEk#A+u&Nr;>S0jmIcruM0646EaP~{v&iaYfTb;i3j6uhCqd>MLeYK^$wLv-1DinWa6{@W$t;*!mlIdrBN=Be>>6MXt- z^mDXdx5*9-rxs-6&Oe8LIHo%}vJ|xmXhi=FH)+_(zH(1*Y9_K`8gi(+sKv|=77i%w zL3<8Wq7U$F6bV3gg;i~o{pi9!ZG$0`G(2m4PUMYH7Ho6)G-WJ}S$hSG>y5IHRL zy@M7FhYCsu@N8rtBXQQ^HR(}Swti-;kA+Ei)->TtCzoVVz_@@^w*e1;9wY$X005i{ zyyFj->Tq|odqgL>vLhjnU~MWM7ZGd$n;f)9QdoE@G7{31JTU`wT0;hrqY(^VyRn zaz*!?QIGpxL*{%@RmD@w^MdGiaaim&7PhXrA0bhe2Vc%p?I)d@C_q8~}mLG_~M zoY{C-VMm@sn2o8h=TACGK_LNvzyCZ)he7}V0{{|M@kgRcRnc;+n{IZ~My*DjMVJ$$ zP)%G<>&hZ0OS7>{*~&M0our*Qw8m^C(^~zu6i)3&Php&*(EcThBl;kzeMIQU?alPQ zqE*j~HQWeOozKM_D<(R{W?NBAwnMT^u^Y~B?R^_rHL?FhQ3`@&hjPqj_c;F+mGzoB zx055+q545$veYFIY6of+89MVMeB%ow_XG~M+$C-LiXSje8}><)#8fuhqXH)0kYRte zf^!X=iPGbStur5<3d~TB;XnV7x*Eh@thQTsZ2m|UM;0&eQ9|Z#(A;$ro=o%P|CW61 zqkT23QUL}U`}G%jbl5KiQ^b>_!_6jgIR=vU{IF7CUtoj{Xyg-;?3F!al= zwvCj234in>7Jh`g+EwS!nLz-)? z&3xHi)R(txo@mNu8)iI=?)fmVu(q@?BL$mbJEhewDgnCjN#<(Fi(2Tpwt0aNBX79O z9`f+Egsgcp?tkGTV}C1pVL2E@joj#jbgw;};r0MP5D)_Z002WoFe3l}Z)JCtu7Fw2 z8r&p+{DZa)*d%cWzKLLBcl%3HWCcRDlJk~X0ob#+_uq8<06>Naibeq74h&R{svTZ97z+fl{A&4XdL_i1u z5P^UyKY}DF`B4M}*s_$r6pGHgCT?SD7Aue(sza&>>;+VAlrRjea*_qfkXXVgRRt?b zb|B^p*yi~M6T+THVjx?E97F|*0Td&MXg5<)EroJu*;$ZDMW%Ejuxbr{=2YCg2E|2R z>R3WKXi1U?GVvk04FbwwHrGjO(OhbX8Lx(LIS;6mT+Ofo3d|>_o~^2!#F0rBvv6|L zIBg{|4F(RFO-Yx)sa)&6r9)f?mDI8iQ;jEP-`(@sxnx5ov}0Ies_+Nu>~=}%NQ`py z+n2Ot@4)gQ)tweXvq6yVUFjgIFBksoK-Z6>q&ZR&PikOd)_(ig!mxpX*iIohdzT6A zGMNST=w^btc1*rqGYb+FQ{u|VXNLHW4Ij9=HGhdt07a3-rP{**_wHxwW-OB$)vpBK zJz}@lo$#}%euS{^UzlL;VdjHUF3&hvJ7N?4ulwhTQadDo4GvZ#dBot=ApXEH`;_Q= zyeS}>#5H588>JZ39XPy|O>h(d!Rb5u&l!1W@mU9o4g}2`alB(}P@yCg^B9Ju{%>!| zQGeR9t8(oaY3T*jp$Sl1p$6)h%sG^lWW#1J4yM%1O-ZZivH|K zr-NGyN@UiNaza;2WhJ~D1ses0vgKE%cdMM{)t}t18v~L!fu!M=RpL<>K8G4^PSKHc zN+RrLP06{k%~{PDIZm~AKolHGp4@bt&TL`K-Q4Lbhf*~$EQc|7BkS>it4n;%iq?9X zFX1a-N;CUBcZZ$v${@;k*XYi&Ux@&?sFL0r*vF*7)QMrnZJEE(urtFI-;=k>Ie@C&I`Y5ohCS*hNmj2DT{W%dNZh0*&b=# zVcl)6nMbQu+c{NMRqdXI&4e?_H5+_2_~*%noWWPR-%6AXAh05fDXV8erN!3D0Y_4N zfF6eYI|<>(=+50q$R8|=ZQM!mI)rx29}LgW`I}K+xUCM%OFynBM+4p^luu&le=aKNqCLmWUtCD{D(mcL=NpWy z0zZ+iH8WDtE6t;p9j<<(f%KVdrV^fU%{f$ha%oYj9(74I9j~*DW@`RE`UR0=mGo?% z&k_P{wKUqRZL#=>!M66RUd@=tFZaM)+zkbdGR<%=^z5dKSm$bz2XfxBQQt+K$nKo_ zE%BlQLt83cJ2&cgKxft(wZu3)>=Xr4%G#~?+=C((Yk0?uQENU61y+fpdYfbRr=+G> zXT6mHuUu)KCc}qx=rA2dbNSdLo7ayObBISCmehi<#0EeK7d(y2!#HIQNfsH4--WBARQw-rgGbavmJV_seXy>$ z0fr7ke(BPe0lw@3rBSx?v-!K32cNX5E4K#2(*%+U1*KQB-V~<%{Gx6z&E*sBE$^c( zO!S_dv%Ln8$|3>sQLMp2fbhT3(;00`gF_`O0%qpgIm|`!c}S?#9w>bsu+AMPz4&Sm zk_x%%J(La?=aU~%4!y6&PL88GO~QJIEc}Wuu|9Efm6)ewuv0&YgE7}VI#1d7nm;*N zEEKv@dpPS$p_^7fGXgK9xUibr589I8$M(aV`oo9-zEO<8l-in(DY{S&{UdMXb@u)O z(+$7tf-2|G_~u3|!E6-vObTdyv-E#_)^(uU$Kp-x9p~w+3%>~MtbEA^uqp=nvO})q z%c4v#$a)P08NE5Ics7ZCW46Yc-w__rvh#RuoiU*Mrnq^cZ|q(Cu=h*8mSFC7BpTBf*%k-Zh zr&9V8UhS&B=Kb~I2S_TcTw#e{ADXV8F4rW|qn)PVu@gB2%QuQwYR>Y^4Ep)b0f!Xn z=7dh9Mf#P|DgEM)j;4!Csxb_dz2?{kG^M#^+4mKgal`Y8Ix8v{br*&U_C|D1Dkr}} z@vLNq|2U>eUdoO+L6M_g@8Ua(_59-*MU!BD;|m4FfQF!fiexjqY8o3HlAT|^y`i}bSg8j!xgj*KuRl%~<~Bs$@tr`VZF1U?qB4)2`XQ8mPzthP@kbVL<0d8#qmsz$iuEusGb z+e!xMpZ+@+1aiRC4|BWTOMjVoozm_}DYer&slo1`To)V?Bfmd7_IasnRL%(=(^~p8 zaD3D{`&@I7u~7@-{j<10Q#Js3K!(2(_zo(H%tm5w$fjsq;1qN6+NY!`n?j&uJw?{$ zLgB^`k+&V!L7c|@@g;gkbDPU)=KR1`d8fnU^Uk#~9>oW?w~RDjKhN)m-o2WzZ``)+ z$Kw;$gY&OJ?q3bYG~z?3p}9Ngqp7;{v0 zkOjEYI;Xkekb-NwQ`H|qgn_D}W36{jD|phI8W#@}MEF#*U6}e^e ze{-&F&Rw%z!zD&K3Gq}Wp~;U8nI#uxkjKm`&5V2N zrAoAdjHnLpq7DGd+OC&mVdCPy=T|iTa|%@U+NCLrE9}UvwZyG0!}V7g^9|RW_h*}z zWaZBq5*e8axqWGuqF1h-c|9&YGE=^|Zzl*hqs?t1 zXZGh!4*#uU``1bwn{|nGYh<#7_lPR*=VT;nW`v1n2F)#&VS-Hq3bU)nU#g9KwNo_w3)fC zGF@PMr_iL$Z?0t&ZddLgu`#@yD`LXDl!OVa#QV<)-WP9Ea26S_1)To(>V6Nblk+uUpQtdIYE ziTNP97vdpw{_#5X@?)KW<+ zdi}aB-2^@B&i#-V88)jY#`@6HdsgD)6@A0P9FEmq$w9G~9y0p_pJw*$ovf(za-Dd& zYrURJT9)`b&(}c{u_{YSsi;^X*WI>z3%3{Q{t|q%9ICe9?}7dex101k^iR2AT93wN z_r5`SGQMNuv#mSId9P?y$Y~5Qn$tO+9L7y>OE5p|Tto$UPBNtZ<{hAJbR(FWQ6pj_$$Iky}a-umx{S7file0 zod=@&xP=v(y*Off$X1%YhBJB}i;m@wFp62zpm*J=im{x3yTx2; z%UVc6G>r0Fl^wrb`zV2+5H%?Jd-2^8q2y4wdI(?A0H)83jPQ>|4RbVjP%0Q|&Jz{A zjjpmPJru&@JE%gQ%(lz%i0TQMaL} z>n-IXcSkzuFa3T+5+ZFQ#p(EY8~PulqqGj8PjQ5-v}{l-Kmfu69|^{A`xd4PxxW``yJkob+bG|#RhQL268m(qCkb1i5oA-ct&Abu~2Db1Jx7Y&+G0^1mY86U< zLbI={D0rdYG5McQkHM3&HlvBqo)H8@H$_pQj)#elJ`^y6Ey6*sJOEGe10c3Si18*b z2zmqp`gDlvw7?;V?<70zKmEjQ591Q%R1t*4%Qu?lbJY$|YtJB!uJqjOP^!zVV)IbW zpR=&Q=BOBp6J*wX?PNW)$fMS0vV~y&wmUFRZUj8~F!27FU;}D@>I-zC(ggu!**iE6*4LBFXHriPW4+~J%Xu*|5fUTxIFjYn; z-ZI;?SHns(dh1#lHk|tB5TUCuSn&nSI!&jNsDXsGvk%;XN|80fQyk%LiIbGZ#t+mV zR{Hm}K{X!~1fxyeet7=odro+1IVrD-R{k`R?;d#Gv!0}50!k2-3+7)AP#hEYvwmKXK z_7uj0V1d+G+Vt{g2=`>v54?awZGPy@e!9@<0H^yZJ06GbY2s6!+=a3{g}tv~TRW2P z1-5EN9D*N)SG&+x2*rHo(lK+0c#J4R2m~T{xbNfky+$azxC{4&E_S=>dqoIf7snh@ z#{erjz09MBBSSYAdLP6uL}f&F;KHKD^o6Tko;A2$YNo%0_*EefoHvKY91sGr%5Nv8 zxF2y?F({!cX1$wsZPi-#qcCntn29LY2+FPOr(w}$e?X%1l%ZMhS{``(tV|-449^1_ zcR%~czNh|`VjS7SliGvqnKS0`2uTe}ej0py<<1bZ)Ru&yCuKRjfu* zHCUW7&ASq|AVPX}Tg9k=3lM3XpUHkQJ$}lFjr)+2>2&{8fL;wbK>H`eBybO2&;lx=lqg$ zFWA~Y;{T#Ufl0tyE9{V98XF5<7{}RGdKvjqQFw8KtqpC>hl&T>AE*z~ z-=XT{c4-PX8SiM3{x$svL5lxf@PO?4dotZrQ71={j!YGmdJ$5np->D;@(Gok9^*j7 z80q1+Y*%Lh6B*ua!6Shj#8MwSdtoeG#aVJrfZ;RB%1=P0n13y|UfPdx{2!iRS;|btrroZI~*^T=f*HCGQw|kC! zF|7+JFZGaQix4mP;-BxESx@;AEMUCn5(=9eJCLmea)RR|qsLSti#VD}HAoXmC<^dM zrBsQNQC9v-tE;8Sd<5xML?*tBxhA5tYYorIvEySpn^-jY`05CGBGV8V35xC2_)J^I zg0keiK}KFT$14$4bQwlUzKKDeP&P8rueiy_%!vyy%RnpIr^J^KTzTKu-#~mJr2P9o!r0nycM)|Gy1@-@ z*iYz75vvcZ}C}@-kv~RX3HIG9&4`TPUz+BE7gruYsd|jOIFK`r%mhM8-*?s;{?rKUv7}V{f9l=ax zmDliWSf<Yg%rBs2dpBLnim@9*&=^ob=xRDz%;BI(mJEl|e;hD^5X~c;TiJ&VDKWa;ijJGuK%Be589)%S zW~uv&<;U^-E-}A%N-EDKyva){EW*6ztTE~CRuWf z-3IK%I1L>~S?_a4Mt(IJP_ZDnFT($z-AOW7VkMS%^E9Q|KX)q*`gKW%3MS!hPe6mx zWb*s?rAwv1jBx|0khCQ|G#KW6+}DuXzkrCv$bE@`Vh|7m0000pWH2KD01st9)n)OzO!$bZ-Fq@!g*yWQd+)GwwK~+}{%KscMqejAQq65@nxIuZ{w&H8d>r&Q~2aZ zka3GZL-f1$K5XdUP^q({DP&WlPv%}*(|^H{FDu4Hm$K~~O+s5*`MAjG($$50QAp_R zFnx_zcFYgjqS8D4=Z^==J;+RfQoP9M&20JGPdC=0X{DeWj?s@Ivi;}kFRfmnZxaEJ0QR(j{OSX`@+|uIE4K#%nlBM(l$J@?dEK8Gpn!m9sBOo zrCQX%+VJ8x?dsjzKe$4fj1<1*?!-V0S&kan=Q4MpB#<=1j=e*>+4lX=h{$dFvEST% zKYPkdD^5y4bLQm%%0a-q&bprdF_c`La$C_-%R2_2b3bN@l|RBg97qe`rdB!hLM^e91*6TiS5fdwi~pED95-3e?W}819d+h6@XJKD3wMgM zBzCwzV{m6rJM0;DG4n4_jQYoCksyjt&QoBxg$JwKskfI@zR+KX4Mpr?oy~HS#{C;4 zbT=K%4gUXTbTv2!kXdHy z1h4rbN^cN_p6R+pB~NLz z_tuSV_nR$Mxce|rFdaf2NP(=^-ihI<*Rm>!LVuDXM~}Xegz8Qb@veLz{Zs!g#F`-X zcn)cM?={)(SdK@PtXX2sW>#A3Y7E|&`Gl*z%%ZOVXQhvCAuprTgrQXrb2`;(DDbhP zq#2?TeNp;qmy5NxsY{we=GEj5@oTM*)~Mz+@YgiTIvW}uKeB^RAf`eyls!um_j+LI zYv4NOG2oLg_U2TcJ?pnlhE&=h z;c3A0>Dsff(XqC~WD9R)z_M4QyDV^}u!xY`tawPae+(X=Uo2Sh=w(|&Tj*(bx&NV` ziRd;QnT$-E7^iV;Y5RVO=~OS8%dg z|E$d>gZmO0ZBJFl(-KAe0sSdNr8fL>H_aO2=fxh7 zX5o5|oAPNb&$*PBL_>Zw+Nhqn+h04B0D3ve{48y<)Y~a~OBLuMky~|tZCkDDGiAY%bm=exLv67S$Y!L#hve`kH<Gr!*mG%0MP*3 zj?A~4gMw*wSN!mJmGQ~QadbjfhBZt=KIM~}87<#0BUC^=fmeb5@r$JVRpmR)&BoH@ z<;`F9S?Pf+)X^h^)DJGTID$Uo*bHY$9nfO>yp~`E4zSvnei~N$>N%ok#4DYM)-p5W z*AMJ&4ZYul%_71E@wk`U95mR-D&y!e8>`$`^QFkGPa4&xs;-&LNaWTj;^Q1<;zEN# zY4$H{*R)!BRgd-g!rSjt3bNFmeOsmYxV;CIDL#{eJh?~KY)&MyTeb|n<>|{8^Q8uH z<;UJ-A}L(p+YmF@gf{M=URaN*t2UZh^p9^EWI*fW*GNQeD|U>V1)B+I%|67=@*biL zw#i0}SmZMR5|}aiVag(lI<8? zTA(hc8$r-axBVv(Sm&^ktop>w?}R73S4D6~*%=q2_=_979E4hq;=DeqHV&L-=4x2q z#4)4h^31xqRqv1w68E(Ay2+HEK;Y`+aI)yG8yFI$}S`Ei$d zZM;-oOA<%4k_x7n$tEz~%I|@&Ixw!>;yz!3HXJKB7c5vK@mXYNtpLVvNCnk$VT!Z( zQY)%ii&s4KXj|d+23$y>eQx0&B+&*Y6(v7rNMDPHW7=7OxoR7O8De z?c45&J=lP-5e|Wy4S4B;&x&XTtDCpQIn;>frqMR!piD@%ojauhSg_XH>2bqfCxGpB zi}WZW)`FRLi+9M2D0X7HtA)m(^rtGLJVX11 z4mOGWDU2jj96@sJ^Xxu(b^K(Xaj7SZ%seLtqRg$^?~kVVyWUWDr_s6!9L}Phlf zL>~Iq`9Wx2W1l)IbzLwF{KxEoY<09u6tTffOSF#^RJ40_zXx@j5zD};cL~^(&jBm za&-hNDC8~)eF^dqn`4f<6-TbB6CC3Uaa9NBhsfHA6)tI~t?pP^tp3$$Eoh{e*sHdM zQC=RzSdGrUnQGy1E-FXKx1Gp?iw36d$Z54mu}eX1W;W%*9#Pn#)#mK-pov^9gN)c% zE|-2&>y;(9A;^cQQz9w;!xUg$vIP_XumJ!-MFLru zQgP)JX;9xl6@cyQ3Jk--GB(m$Ccc0f0R2*8neV?0FNj9e9zD7u>LKIaYLGt8U;Kh%Au2+5E8ZVo{P>@Ogxw`brJ_3 zpxa>;0Cf9WBg?f&3z^vHYya!J&c;~o8L#9-r1bSEAJEDldt>iXI|zA){;1E!YRCB) zZ&7wEWg>se4I{4~zC0uI7iu7nX*#97LqM>9?+tvJGBwYKyZRAbOVl%2mL&BP62BBt zB$AtyfDZso=P-K%?ZAWp03oJHE2nY*Yt-Pi-R4xtC8C`PlBA9<*$Jp*pbCJx{eKeW zTBLbKm1hBTdC6Ur77_vwNcc-6HbfG0!r*V#LR;*% zr1t6y)c@Y)zW^cw05mcOXHWoz1@h^ zZ)S{C``KNct~uN7ey*h1IgxQPk@4&z%{H5?F!4#d0f_fYzyK#tLVysyKzJhn!T z0su5tVA~D7wp+WBcDuE1Nd|+q!p15_TnJj?u_}xN_(4G#s09TA{AUR$WDp=h1O*Vv z7q3t$>xeHAo(S_%d=75wY{6u%sWp-m1`RYYPZZkr4NR-5NsBIvcG7b%wFZKCI-}*F z^|+a=LX6}VfD}bzJ*R|?^>?=iJBvWwvWgU3Piq?+?75x5W5bVAV(g=b5cfH+>-cE1 z6~^XM=nq^;uGalDH(IJf%K565^>gd^tfM%J>-tGQaPYKq*mz~_eIE*gN-^7kXum^; z-5|4RNk=>!7`|Lh&V$7U>P(1rtI-)jCf4dvg?u{s>UG*I2C#s8noXp5Wup5zu1p10 zn0gCFom5lA6He#N3UO38Yd`0ymI>F06%Va8M@Mr3qAkL zed0{jNMTTxt8jGV+)a%R-Ozx!Rn#{>=895rc;>b`Z?vK@TVfadAj*=_aj(5^3uLIq zZAw0s@0@ruWYHGLxD4u?z~bm6?Hh8gT+s2ab)@8x`i|3pJt=q_EKGt3NZ@b-`?hX) z4Y}-9+s4>;YB61;#qV9;uu|pF-qq<9Gh4S8Z@c2qWk^N#=!ioqEbf_wuxHHaeD&Cx_w05m(#(8_?ofopzDD8np zO&`xh8&oq-u|DhZqd#YeK^gX;Yr1(mNzB;T%#3?JjO)c+XaZ$Sn;4yA9G@&McVHNE zOx>2O`DbQ)HZXQN-Nx>QeMt?vA8ifgJ9ImS+1hQTUlGYw+|Xq+t9vc&DboASO3T9y ziZKu1?|uDu#k5PTq;~ejw8(p|t&Z9hA~1!nV!VDO6g_Of%W+%;u`b_{ zO~olP<_Dg@S4^sQu#YvGU9!XYDj}tj)9v%eTZuBewpne*P8na766{agF)>lcgv%~A zRuqn^O13EuTRuBTX~~DbshwkX3dybVb+eK)jm@w3MmsOy!sg>0U5Eqs{ec}DiLwYB zYd55q+MgTw-;@~bDod;E2yHO{&#W9;gma*+wDyzN<;0hP9lo6ihzzUnwjUc3rxB6kKAa7TFa&vybFSkaAd6w|n z^F5vO9Ak&mf9UNi-)^UkIIid3MZgnTRitreH{Ve*qi&?MTUMpEl+h-%(eIAG@o?&ua%jVkL+ae|`HMQIk>r?E=Qa+Q zZe1d%9etMkYgNu$1ZTG?vquR0#`DV#VkGWj6FNfdS z_NCX0ov?v35yl!=M11q?;PUEe2O0$kN)=H~}&96kK9T<1Tuxlq*jCC#=&wbn} zMeI!LSwdM7wo!3=hNJb`gCXwO%jk_;q+Hqk8LS(bUmVU&a`>A((JY%YenA~$rRWai zjs4qnQ=DJld7{qaQxXze+nueh@*{^D7DT$~I`b3yKB7(^x#hSXmbpoGNL0Z;yl)-Sm|m8xUXj+i~*mi)(S2Xzb?r*7?ov+vs}eW@ewx|NFND zS-A0#C7v9+;|UcBlkwm?IR_;Ci|;zEJ4xa%h%AYVpY)ecmT%HCk}>&z=bzj!5fW{I zTeC_8@S=|ADU@j!I|s{hWtdFIU};+Aj!r;j>cmmZ6R(+F*3UHfaw?O*Xk>9v6PgBc zXhzH%O$6SWAOL_83{zGWOt6+c%`C+@5rF3b7BKe*n|K`sLDFHPoB1i>xttsMUF82{7>B^U0 zL|ZV4LuKNvTw;(PfVl&f+{rM~!K=KunfmHc#P{GZ4R-7NYQ7 z=o-}sMX%-1hkx!4qtPeR{ipL}#(5p(=|nJH;q|6LA~q)Q+_fXScwR|~sn;DkDO3IPD` z+X#^{6xFdyNZw@B3MGp`v;Yjw%!$SrdTP?^CFgvY6Ofob2TO=g#y5au=760#YxEyn zP|u|UfKT<~*OaWM!y3+ft^mMt2gFOyrB$#MTFpyA`PYW{ivXhoV9{AZufLk|M>DlQ z*TSI>0O*wb02$z|Bj?Hh@=pLsp#EI01(l+H@2dZcm!$S!05k<9f=S-vm)D=>)9Wq2 zN<>etvo{w2fE@$qQD~*hW*zDP)Z+l*l2AWF?~+ARzu&c3)QcCTkYE5b1(dpVP51RS zOZ|ExKe*fghydVy0>ncAfP^RN1~?v|n^QC7v%%nqGa1lAQeY9BdVm4b6b6c$wLU%fXhD;p zKEO-*3}HYa5C9;}1$a^b0P_T0k$6&0!gWZ~dnwEUxlTZtW-x%W0mV$A17~WVr~m02 zNS;&!r~tkL0PUX<%K&7@04?7U%U6ecf_N#Vk+w~25oqdw0nHS~38g{LW;{bKm1hBSdC6Tre@Z=wO0 z6m201l|Cqs0^W##FaQ9E9Dvaj9KHj)@7;H8_qJNLZJ4X58Qa?1Vz5=4uF;=}5&{Sc z1#jSp5C{qaUN;1|bdV4b705t?N-IntNPrI%Q3yZa3!pF$f_#Aa$27JaMs&b23dD@_ zcn%|h#0REn8J=T?f0C#S)#ALjXyYPej16re3y<3BB$hHylX;YAjT{>Wy($iSW=49R zn~j{EpFQEV&f*q51{%*O@kA2BbV>QwnKVwpmc^TytR0{3ah^KfY63q2VHVb?O&J8c zOT0?I(|t`!Y{gu7y(p$DI>L7ZCv9U4++EG9@*sSR>~BEcye6_=uCvdsHjDX$bfPQM zdNzu+?f+GeOq;Yw_2zb%)-yrLFZzAs7g3gCGK9BG4=`DpiC)K+LQX~lqaMr!Z0_%p zKc@AO-d=fbL^$eD4NS~9q;+!^Zev|GaFfZ71=305H&ez-d9Tmjf1%A=tpXaJ@yp#Z zYD5AjoHx+|%WYo3AV zNWoWBagA?8<3!0?N0Uh3)6*!?h4b4>$%ba>3@r#0evEg3J?-b0lEO<3EregGxm7FA zm0#<$t!;#yjjmjL_IT+BS)yp)(SP%GxJ8YvJr5ttI&NklN_uWna>RpP`8bN?mdx#N zl|?fgF=*yX%JW#I9DKGSJ(J-M3w)3M46hK5=fXDToJ#kx48@z4wcTRxvEZ_Z(wn2l z=xhC3S#_&3KSgTeRgj_Q;d>2i?xtsTy|w!>!OoF@6Ac#osC!?kmm>1eyK;Ii#eeB#}mH)Mca@w+2h(I`7cfj_ggEu8qGO%W<>5@PX6S zkT1N@zk*)s2IHeV>FDToww-G^b}r3;j|cW%+D4~h&Muf_=qtZF0;+TAcxgjwb(^ij zk++=JbJnPpD|cY|LoG4z-QYTmguHaObn>F7QgW^W-w4CzXZG0I?ajIWY&(w|u0zt$ zPCiWlLQ$o2uSwck>lffRR^pB9&lPr%v=M=<^ea!~5e@6R_VZ+>=t&BOJND=FaTmPr zNcaD!u`^c0kHNt0>^fzpR>SY=c6DTTJ{1T{Ts+}{^*<=Sv)Jgeh}@{R)(@PL8>%G= z=rp$~<-Z={>dtnSJc8O^e=Zvn{inF2@il0!k-(US++lUnZoR38ci^dZGYp0nJizy} zO*Y5g;PPu_Pq}1pjHiQiGD8dkm(+O$6Y0R`w&04N>b4ve0aH=7W#2#V*>t5?6&vTO zki$;g+@xHg8f!nD5*)p4@l34M2HZY!i7sTimdI*iK`I zd*VixEX<`=H3=R>1|ie-T2Thnlhnv#yhDh>aWR_Y>L_9Na~wSCJYMyHTX7ebRV|Ap z>wn_-;uIXMf;Zah2dT`Qp&egC4;nfooWJDr4moc{7UMKPGNm^$u7|ph79mmf_TqnG z2lrA-)bxJc$iMq)o(SxWSnTSL*Tj%bY-&{_WM8G>hHms+RIy)y9ib}cDR_Oau;N4# z2k2iCH>svH&X|Y}o0M4~(O&h&Gn)4=zl#*sRJ6=G^{zKaQYPcsd7hTD)c+!}m{Rnp zFG~GP*uYkvMX^TMYMQDx8*S*Fmh%jnC9V9{&#*))n8f9v>#o(;MU~Tj zy)b9W?`HRn)il^6rHi~#b67=AuROZ`@tHgI7-j90k&SrTcVi=B0R82ra}f_PU+|T$ zaeGAnA#|1$Z-tx!cfUtbMTS10Q|M7WyC1 z*Mrl}x*Qun(_+~(9)!*S03-zp@aNeFNSYEq+ounjJNSH3y#QDMd{~ABEuiGmp3>j( z34|xUMCF~hF-pNg`FC0>^P;$gTqG*q%lsA9I`nXZYhOam5Z@^l2Q0ayMU=((OYJ1w z7TMzV>q9$2EzyvLc`lGpsb}9E`l!sZu)q$yKAw88GcBvWfEMW^ACwPmW9kJiW!-wq z0+KR{AScNN)q3a^dCEPs6DgYo91O@Na0he}*3P*go&fP`9*GPg*Vx8|_HR4wgU>Xh z55waR0ssIL0FsjsRDpMOc-sKno_{s|r z+`roYsFi(atijY;;{|(6O$q1#lnVg5_MfM3PUm2|L;b>_E2t&_00k|Z?j5E$0WtzG zSxH5^h>*a?mcXUJ2W1G*!b)E434AUSVaZDA4dk#ArM`0gD^5%}AN3)E1dph2d*55= zIg@y+uh1N?<%m!hR%JyalccSboVz-4f{L)P{nHBCKP)#tT>!6O6Yg{1T)_@2)yN%` zGthL`qG_2?wkbXDdhZo?oI`Oae&FvkJG48P6Wf_%#ck7MMW@@rlLkGUwnb*nUlOw} zE?K_LuV*jeYE$p*d zaf@8zU3fRewmo%#een9E_w@nkovj1RT}$?E&^=5Fr0dD7?Pbj5&AWXJ2DX^wgEol> zg&@AW2fXGN(Ez{>05NVwfC}%>H=zZqdn}^cI{>KwAJidGg$~r96wsdD4wjE}wXbwV zPz&q_phn{<@AwxE{^yVR;^?=2$$gRgaf?$u+IxRCMqbH`%4!l?UAgNpa0wdUG%JTf z)=iBTg@~8HpqmG@X=m}3CJ_CSA7Ocjh+v)o08UOcG2lef2DFeSQ)F!uj_Q&~QhWe- z5;g!NC8&Z2YES}c&+N5>V?6iBdoDc1>ze9|uAF#Adm!(#s5IWuNzvrRwzNImPX}GY zn4yWXS(``a2UJMb-MNXAu$Qn;kn|$LxsURFDC_Wguu1#>;Tgf_4j4f6TI75D(CJN5 zZLjzkey zR0`hNTbNdqSZ5YheGA*|LTfNTREl;I{Uw*oTG?(EK(@lSEHsC;m9#EbO0fe5xIfE+ zN;%<-4g^7TwF)Xi&^q!bv1rCM4PQKBQ5^Rx6>dQ?!RTq4VGgYG9xI{hqciP-9z za#Zt^Dlt1V64G=Ups#pJz<^!ZXP1HnSkCv^#rm*s8ooCcn`4NDm&=PM$a3nk4}zrX zK*LGm)0;&0^N~if^}@v*#O3xW^gUfj6hTtO%@pGW5CPZzD-5JKr{gL z04>iCeGNwrUeo-VK1er6X#fDwESxINVkVUfkq6X*Z;+%|BC8?Abp+`0r@}@lg9sK1 z5PL&fzot@Umu~}UF!)g(RaPp7I0Vko9KfgkJ;f{;?Hy@2Q2t%KS6Re>H4vLtrgF4aZNv|5)KZkQfrYj-T1{nX%r< zOL97Eit^sK-nvRzcyDLZOprt9za}mGrc^DWTf)Vi?3luSXA?G_#-6}jlt)|;^oSWC zMYji2Uc8G%RSKX0Xet1;=oB8$2hanx+%m4VkHgn?DZ?7k3ZmoMF*lrVxuS}H6-D2 z_bL6(!Wm_kOd4xBSu8*9=&XT;dUnXL0+e*anP}RDZ2>Q!0fA>VxVqi zWV5?wz%d1bDT%6%2vEp=X?%k658`ZQ1@)4_m+VddrBQ*7$Q0K>k>)9caBJt4#A%b^ zy&;85Yo{5hm+*F0@Y8N0R3X%-^$+wfH<`H3Wix&T;V^{-@@yZfB1~Zv3IUHkq4ML$ z`x?x;9kX34hwmsX{dyS5exdQ${o=YQNUNxmGY(KM4rk8$a|iKG>J|J<#=k0q7TFjs z*{mBAuU7I{S>Mb!jcBBTH0X^KO6-StfUP{a0kr%R%2NJC_Q zv$6^}R7vgR)yqQ9Uw|jM0r1@FIxANIOaTCzoGnVIKh~$KirR2of*U&fOd(pV2|u!D)s&9z$F3w22>+1vUV81LVa@&kaG zA*dMu00A%(8O!mWj;@hs?xW;Y{JG{vB_-bzM;vQDC%Dz(`a>K>LRin6gF66U6jgoIMFBhxd5U705cwj^12PccZK2uK!%i$ttQ1rfMk0b;-u z1N=qsMAz_S&>soR)j&x zNj2>SI@ln`i1kNE;aJdRe|*ZTr8Gc5r*&vi7Z3o9kPtB#H((*NmUdhda5hMb528Nq zeo@Z>)cH^ZG%yI!8MVJS+|SK|I{3qf)8ih-s$PX+b$r2z zLI|;{Fs}JnxBgQF1V$}waXwAE=KoQZu=W|Gy%4&XD|?)m`Dq7@azfZqItU@6+^pcY zKt+pis(BGg@p7zIWyyJv1GF#+BIga`f~_hZx{?N2H-_d%safFCR0BxVE;~M^Tw{rv zR^%H#6Z`*yXiMMudciN28UX)`h_l7-Th$S;w=%7Go#k6>``W;?>3>ccC>L~dmqjq4 zKuQvHCz>!2r>+M94);|M)(!)pl5~HEZ>=q~q{MJ33WR8Teh}NW&QrhZTuEC&iTMUFQOH7RbU6jy z)hM&(Em;33utIDbg}*I8dc&{vQZCwGTbD$zR%d1MPtixjD+P(3SGlnj8i=|w_&GqZ zDxI+3WGpCp!_7c&yYm|us zCLHji-Q0@hmpS6}6&)_GagM)!Txz9p8mNZoBcF^6ykN`rQ*VG!z81OenM12RlK#yZ z7~?jv$o$C z9rARMC)^P@6ZayyXMtmIlJ2)AA7Dn!NW1wqTHm)O#0n>iy^zQ^CCS2%6kW93;K6%H=Ho-2O-*qx3uI2PO@Ol01X8T zHeP^xxd9-OX`cmSe}Htj4DC>*rh&~sOvh#1CD3;!E?F25Z>&oNm1YHhmNN;fuCqhx z?}Dz+VQEWoh|O1`42m)7IU>m}=5nhcYey#Ob8O(LI*32}qMwzYMy=K?E1iluEq z^7i53AY7({4e)qw`OgLZK)9&uK;dwlbzU*+Xa3_xOib~O$LGp(s#*(0#1jGq{pz`> z6~i&0pc%#mFtk)wnKRzlbF}<#Wtxf^V&41XY)zVr2Ql%@_?^N{=W|Y?_w-Spj3^SE z<$^&UUcoowkh_9y#v8%)Z)-;mzA_iH&)grNg~AJ>7tMWg{Zk6b{fU@`7xpz;tZnPy z1Tq?d0yPLt+tvzjz&~LdE8fJk2lC*BRv_ z$n0LO{9i7umbmS^pvn45fMh{Eocxyf<}8<|)csMI^uwFl>-HhkGHYA^0C7N$zXi)m zaajd+N54CFP{XTB>M0shiw3j5`6sELPqm`HM@%iHJlF0?@2X%S{4)8h+hevc-Tswm z?9&FKuK&A%Ws4#A890Sxc)Q4V>4S*PC2(P%mbvCinA}PHMG$uAjNb5fOFr+qADzf| zY9SHYg4%+fl?(EK+)~9XGM(%kGn;~l-(lMKdZfXQ1SNmf*t0p3Csob5UtRdXeQguN z+QzAVGap*GJF^o-yEDr&IPUw7cS^U;+J;#u%S5y=@lK<+-z!L49lEHb4Va5pXYRmOsXSg~YKh(U|hF zH>*_4HPSYrn>+B(%0=@*$2n&)6HbYiN&Ym=s}_v-Ntk(*_I8tuoCj#S)1SS_NRiHXkGZ}cFQU5ouk zyx->PK4o2YH1uvJ$!YrusrE>GCQRbU^*g(d-O46R;-ro^wj-G2Gnr`od^e&@k;@wY z17~d=#pBEPm@v3Qv{yqrhc4<@3cP`S3M$)9}Sqz

;cQn9PI~5@CAo5d~o( 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 {;UPx4CjBd3UNupdgmMN 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