added trigger

Task 7 added --skip-coverage/--skip-stress/--skip-datasources/
--skip-recorder/--skip-debug/--skip-tcplogger but the AGENTS.md table row
was never updated to mention them; it also still listed a --stress flag
that has never existed. Sync with the script's actual --help output.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

AGENTS.md

@@ -0,0 +1,241 @@
+# Repository Guidelines
+
+Guide for AI assistants working in the MARTe2 Integrated Components repository.
+Focuses on non-obvious facts: commands, conventions, cross-module contracts, and
+gotchas that are not self-evident from a single file read.
+
+## Project Overview
+
+MARTe2 component library with **two independent real-time data paths** sharing
+one binary wire protocol (`Common/UDP/UDPSProtocol.h`):
+
+1. **Streaming path** — `UDPStreamer` DataSource serialises DDB signals into UDPS
+   binary packets on UDP → `StreamHub` (headless C++ hub: ring buffers, LTTB
+   decimation, trigger FSM, history writer, binary recorder) → WebSocket 8090 →
+   clients (browser SPA, native ImGui, native Qt).
+2. **Debug path** — `DebugService` patches `ClassRegistryDatabase` at
+   `Initialise()` so `ConfigureApplication()` wraps all `MemoryMap*Broker` types
+   with `DebugBrokerWrapper<T>` — **zero application code changes**. Exposes
+   TCP 8080 (text commands), UDP 8081 (UDPS trace telemetry), TCP 8082
+   (`TcpLogger` log forward).
+
+## Architecture & Data Flow
+
+```
+[SineArrayGAM/TimeArrayGAM] → DDB → UDPStreamer (UDPS over UDP)
+   ├─→ UDPStreamerClient (input DS back into a MARTe2 RT app, round-trip)
+   └─→ StreamHub: UDPSourceSession (receive thread → SignalRingBuffer)
+        → push loop @30Hz: LTTB decimate temporal sigs → WS binary frames → clients
+DebugService: patches broker builders at Initialise(); TCP 8080 commands,
+UDP 8081 telemetry, TcpLogger 8082 (REPORT_ERROR → "LOG <LEVEL> <desc>" lines)
+```
+
+- **Wire protocol**: `Common/UDP/UDPSProtocol.h` is the canonical spec (17-byte
+  packed header, magic `0x53504455` 'UDPS', 136-byte signal descriptors,
+  CONFIG/DATA/ACK/CONNECT/DISCONNECT packet types, quant/time/publish modes).
+  Deliberately MARTe2-free so Go clients reuse it. **Mirrored across four
+  codebases that must stay in sync**: C++ producers (UDPStreamer, DebugService),
+  C++ consumer (`Source/Components/Interfaces/UDPStream/UDPSClient`), Go decoder
+  (`Common/Client/go/udpsprotocol/protocol.go`), and JS parsers
+  (`Client/udpstreamer/static/`, `Client/debugger/static/`). Any protocol change
+  must be mirrored in all of them.
+- **WS protocol** has two implementations — Go hub (`Common/Client/go/wshub`) and
+  C++ StreamHub — that must behave identically; every client (SPA, ImGui, Qt)
+  must satisfy both. JSON text frames for commands/events (`addSource`,
+  `removeSource`, `setTrigger`, `arm`, `zoom`, `historyZoom`, `recStart`…), binary
+  frames for data pushes (live v1 + trigger capture v2).
+- **Threading model**: RT threads only spinlock+memcpy (`FastPollingMutexSem`);
+  all socket I/O, fragmentation, and reassembly lives on background
+  `SingleThreadService` threads. StreamHub: per-session UDPSClient receive
+  threads + WS accept/read threads + one push loop.
+- **DebugService patching**: `PatchRegistry()` replaces the ObjectBuilder for 11
+  `MemoryMap*Broker` classes; runs only when `ControlPort > 0`; static guard
+  against double-patching; wrappers persist for process lifetime.
+
+## Key Directories
+
+| Path | Purpose |
+|---|---|
+| `Source/Components/DataSources/UDPStreamer/` | Output DataSource; UDP I/O on bg thread, RT thread only spinlock+memcpy in `Synchronise()` |
+| `Source/Components/DataSources/UDPStreamerClient/` | Input DataSource (shared `UDPSClient`), double-buffered ready/scratch |
+| `Source/Components/GAMs/` | `SineArrayGAM` (float32 sine, continuous phase), `TimeArrayGAM` (us-timer → per-sample timestamp array) |
+| `Source/Components/Interfaces/DebugService/` | Registry patching, `DebugBrokerWrapper.h`, TCP/UDP services |
+| `Source/Components/Interfaces/TCPLogger/` | `LoggerConsumerI` forwarding `REPORT_ERROR` to ≤8 TCP clients |
+| `Source/Components/Interfaces/UDPStream/` | Plain-C++ helpers (not MARTe2 Objects): `UDPSClient` (auto-reconnect + fragment reassembly), `UDPSServer` (not thread-safe — owner's Execute thread only) |
+| `Source/Applications/StreamHub/` | Standalone app (links MARTe2 core): `StreamHub`, `UDPSourceSession`, `WSServer`, `TriggerEngine`, `HistoryWriter`, `BinaryRecorder`, `LTTB`, `SignalRingBuffer` |
+| `Common/UDP/` | Canonical wire protocol (header-only, MARTe2-free) |
+| `Common/Client/go/` | Go mirror: `udpsprotocol` (decoder), `wshub` (WS hub client) |
+| `Client/udpstreamer/` | Go legacy direct-UDP oscilloscope web UI (connects straight to UDPStreamer, no StreamHub) |
+| `Client/webui/` | Go thin static server; SPA talks WS directly to C++ StreamHub (discovers via `GET /hub`) |
+| `Client/debugger/` | Go debug web UI for DebugService |
+| `Client/streamhub/` | Native ImGui+SDL2+OpenGL oscilloscope (C++17, no MARTe2) |
+| `Client/streamhub-qt/` | Native Qt Widgets oscilloscope (Qt6 preferred, Qt5 fallback) |
+| `Test/` | GTest, legacy Integration tests, Configurations (.cfg), E2E suite |
+| `Docs/` | Per-component reference: `Protocol.md`, `UDPStreamer.md`, `StreamHub-{API,UserGuide,Developer}.md`, `DebugService.md`, `WebUI.md`, `Tutorial.md`, `E2E-Suite.md` |
+
+## Development Commands
+
+`source env.sh` is **mandatory** before any MARTe2 build or run (sets
+`MARTe2_DIR`, `MARTe2_Components_DIR`, `TARGET=x86-linux`, `LD_LIBRARY_PATH`).
+The E2E scripts source it themselves; a bare `make` from a fresh shell will not
+work. `run_streamhub.sh` hard-errors if `MARTe2_DIR` is unset.
+
+```bash
+source env.sh
+
+make -f Makefile.gcc core    # 7 components (UDPStream interface FIRST, then UDPStreamer, UDPStreamerClient, GAMs, TCPLogger, DebugService)
+make -f Makefile.gcc apps    # StreamHub standalone app → Build/x86-linux/StreamHub/StreamHub.ex
+make -f Makefile.gcc test    # GTest + Integration test binaries + component test libs
+make -f Makefile.gcc all     # core + apps + test
+make -f Makefile.gcc clean
+
+# Single component:
+make -C Source/Components/GAMs/SineArrayGAM -f Makefile.gcc
+```
+
+Build output → `Build/x86-linux/` mirroring `PACKAGE` paths (both `libX.so` and
+`X.so` are produced). `compile_commands.json` (repo root, gitignored) feeds
+LSP/clangd; CMake clients export their own into `Client/*/build/`.
+
+### Non-MARTe2 clients (no env.sh needed)
+
+```bash
+cd Common/Client/go && go build ./...
+cd Client/debugger && go build ./...
+cd Client/streamhub && cmake -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build
+cd Client/streamhub-qt && cmake -B build && cmake --build build
+```
+
+### Key scripts
+
+| Script | Purpose |
+|---|---|
+| `./run_streamhub.sh` | Demo stack: build + launch MARTe2 app + StreamHub, optional web (`-w`) / ImGui (`-g`) clients. Flags `-m/-c` MARTe2 dirs, `-b TARGET`, `-p WS_PORT`, `-n MAX_POINTS` (actual default 1000000, header says 10000), `-s` skip build. Generates temp hub cfg with `+History`/`+Recorder` blocks in `/tmp`. Ctrl-C kills all. |
+| `./Test/E2E/suite/run_e2e.sh` | Full E2E: 57-scenario matrix + stress + unit suites + gcov coverage + Typst PDF report. Flags: `--skip-build`, `--only <id>`, `--pdf-only`, `--skip-coverage`, `--skip-stress`, `--skip-datasources`, `--skip-recorder`, `--skip-debug`, `--skip-tcplogger` |
+| `./Test/E2E/suite/run_stress.sh` | Capacity harness: sweeps one load axis at a time (`--axis`), hard gates survival+liveness, soft gates RSS+zoom-p95 |
+
+## Code Conventions & Common Patterns
+
+- **No STL in `Source/Components/**` (and StreamHub)**: use `StreamString` (not
+  `std::string`), `FastPollingMutexSem`/`EventSem` (not `std::mutex`/threads),
+  fixed arrays / MARTe2 `Vector<T>` (not `std::vector`), `REPORT_ERROR` /
+  `REPORT_ERROR_STATIC` macros (no exceptions). C stdlib is fine. Heap
+  `new`/`delete[]` is normal. STL/C++17 is fine in `Client/streamhub/` and
+  `Client/streamhub-qt/`.
+- **RT hot-path rule**: `FastPollingMutexSem` on real-time hot paths, never OS
+  mutexes; RT cycle must not block on the scheduler.
+- **Class registration**: `CLASS_REGISTER_DECLARATION()` in the class `public:`
+  section of the header; `CLASS_REGISTER(Name, "1.0")` at the end of the `.cpp`
+  inside `namespace MARTe`. Every component `.cpp` ends with it.
+- **EUPL v1.1 license headers** on all C++ sources and `Makefile.inc` — preserve
+  on new files.
+- **Per-component build**: each dir has one-line `Makefile.gcc` wrapper
+  (`include Makefile.inc`) + `Makefile.inc` declaring `OBJSX`, `PACKAGE`,
+  `ROOT_DIR`, `INCLUDES` (re-declared per file, ~12 MARTe2 layer dirs),
+  `LIBRARIES`, including `MakeStdLibDefs.$(TARGET)` then
+  `MakeStdLibRules.$(TARGET)`. Generated `depends.x86-linux` (gcc -MM) is
+  committed but **never hand-edited** — delete to regenerate.
+- **Qt client**: `QT_NO_KEYWORDS` is required (reused `Protocol.h` structs have
+  members named `signals`); Qt classes use `Q_SIGNALS`/`Q_SLOTS`/`Q_EMIT`. Run
+  with long options: `--host HOST --port 8090` (single-dash misparsed). Single
+  GUI thread, 60 Hz QTimer repaint.
+- **StreamHub config** is *not* a MARTe2 `RealTimeApplication`: `Hub = { WSPort
+  MaxPoints PushRate MaxPushPoints RingTemporal RingScalar +Recorder{...}
+  Sources={id={Label Addr Port}} }`. `+History` keys: `Directory` (required),
+  `DurationHours` (1), `Decimation` (1), `FlushIntervalSec` (5),
+  `MinDiskFreeMB` (500). `.shist` files: 64-byte header ('SHR1') + circular
+  (t,v) float64 pairs.
+- **UDPStreamer config**: `Port` (44500; multicast data = `DataPort`, default
+  `Port+1`), `MaxPayloadSize` (1400), `PublishingMode` `Strict`/`Accumulate`,
+  per-signal `Signals={Name={Type,Unit,NumberOfDimensions,NumberOfElements,
+  TimeMode}}` with `TimeMode` `PacketTime`/`FirstSample`/`LastSample`/`FullArray`;
+  multicast needs `MulticastGroup` + `Interface`.
+
+## Important Files
+
+- `env.sh` — environment; source first, always.
+- `Makefile.gcc` / `Makefile.inc` (root) — build orchestration.
+- `Common/UDP/UDPSProtocol.h` — canonical wire format; changing it triggers the
+  4-way mirror checklist above.
+- `Source/Applications/StreamHub/main.cpp` — hub entry (`[-cfg file.cfg]
+  [-port N] [-maxPoints N]`); hub **must be heap-allocated** (~128 MB, exceeds
+  the 8 MB stack).
+- `Test/Configurations/*.cfg` — MARTe2 app configs (`$App = { Class =
+  RealTimeApplication }` with `+Functions`, `+DataSources`, `+States`, `+Timings`
+  blocks); `streamhub_demo.cfg` and `TestApp.cfg` are good templates.
+- `Test/E2E/suite/{scenarios,gen_data,gen_cfg,validate_waveform,stress}.py` —
+  declarative scenario matrix and generators consumed identically by the Go
+  chain-client and validators.
+- `Client/debugger/main.go` — `-addr :7777` default, `-enable-dangerous-commands`
+  safety gate (CR-4) for FORCE/PAUSE/RESUME/STEP/BREAK/MSG.
+
+## Runtime/Tooling Preferences
+
+- **OS**: Linux x86_64 (`TARGET=x86-linux`). External deps live outside this
+  repo: `MARTe2_DIR` (default `~/workspace/MARTe2`) and
+  `MARTe2_Components_DIR` (default `~/workspace/MARTe2-components`) — edit
+  `env.sh` if they differ. `env.sh`'s `LD_LIBRARY_PATH` does **not** cover
+  UDPStreamerClient/UDPStream lib dirs.
+- **C++**: MARTe2 `Makefile.gcc` wrapper system, gtest-1.7.0 for tests.
+- **Go**: `go 1.21`; modules use `replace marte2/common => ../../Common/Client/go`
+  (`gorilla/websocket` v1.5.1). Go binaries are gitignored.
+- **ImGui client**: needs SDL2; CMake FetchContent pins Dear ImGui **v1.91.8** +
+  ImPlot **v0.17** (`implot_items.cpp` is a slow -O3 TU, ~2 min rebuild).
+- **Qt client**: Qt6 preferred, Qt5 fallback, Widgets + WebSockets, custom
+  QPainter plotting (no QtCharts).
+- **E2E report**: `typst compile E2E_Report.typ`; Python 3 + numpy for the suite.
+- Remove `vgore.*` core dumps when you see them; they are not gitignored.
+
+## Testing & QA
+
+Four test layers; `env.sh` + built stack required for all but the standalone
+ones. Only `tests_py.py`, Go tests, and the built C++ test binaries run
+standalone.
+
+```bash
+./Build/x86-linux/GTest/MainGTest.ex --gtest_filter='Name*'     # C++ GTest
+./Build/x86-linux/Test/Integration/Integration/IntegrationTests.ex  # legacy DebugService runtime tests
+cd Test/E2E/suite/client && go test ./...                        # Go chain-client unit tests
+cd Test/E2E/suite && python3 -m unittest tests_py                # framework logic, standalone
+```
+
+- **GTest**: `MainGTest.ex` currently holds only `DebugServiceGTest`
+  (TraceRingBuffer SPSC, DebugSignalInfo, BreakOp). Component GTests
+  (`UDPStreamerGTest.cpp` ~46 cases, `StreamHubTest.a`, `UDPStreamerClientTest.a`)
+  compile **as libraries only — no standalone executable**.
+- **Legacy IntegrationTests.ex**: 9 printf-narrated DebugService runtime tests,
+  always returns 0; `collect.py` parses stdout blocks.
+- **E2E suite** (`run_e2e.sh`): 57 curated scenarios (s01–s57) across kinds
+  `chain`/`direct`/`recorder`/`debug`/`debug_pause_resume`/`tcplogger`, driven
+  against live MARTeApp.ex + StreamHub.ex + Go chain-client. `scenarios.py` is a
+  curated covering set: **every configurable UDPStreamer option value appears in
+  ≥1 scenario** — add a scenario when adding an option.
+- **Oracle gates** (`validate_waveform.py`): **fidelity** (every received value
+  within `tol` of ground truth; 0 for un-quantised ints, float epsilon for
+  un-quantised floats, `quant_step/2 + 1e-6·range` for quantised) is the
+  **correctness gate**. **Shape** is a *gross* sanity gate + tracked metric
+  (`corr >= 0.5`, `nRMSE <= 0.30` relaxed by quant step, frequency searched
+  ±5% band); a correct sinusoid yields corr ~0.82–0.98, wrong frequency
+  collapses to ~0.00. Do **not** tighten shape into a correctness gate —
+  timestamp calibration (Phase-A) is pending.
+- **Stress** (`run_stress.sh`): 7 axes (signal size/count/fan-out/sources/WS
+  clients/zoom rate), hard gates survival+liveness, soft gates RSS+zoom-p95.
+- **Coverage**: `--cpp-coverage` rebuilds with gcov, captures via `lcov`
+  restricted to `Source/*` + `Test/*`, then restores a clean build.
+- Artifacts → `Build/x86-linux/E2E/chain/`: `results.json` (XFAIL/XPASS for
+  `known_issue` markers), `report_data.json`, `history.jsonl`, `trend_*.png`,
+  `E2E_Report.pdf`; stress → `stress/stress_results.json`.
+
+## Ports Reference (defaults)
+
+| Port | Protocol | Component | Purpose |
+|---|---|---|---|
+| 44500 | UDP | UDPStreamer | scalar signals (unicast control + data) |
+| 44501/44502 | UDP | UDPStreamer | packed arrays (FirstSample/LastSample, FullArray) |
+| 44503 | UDP | UDPStreamer | multicast data (group 239.0.0.1) |
+| 8080 | TCP | DebugService | text command channel (one client at a time, newline-terminated) |
+| 8081 | UDP | DebugService | trace telemetry (UDPS format) |
+| 8082 | TCP | TcpLogger | REPORT_ERROR log forward |
+| 8090 | TCP/WS | StreamHub | WebSocket (commands + binary data) |
+| 7777 | TCP | Client/debugger | debug web UI (older docs say 9090; current flag is `-addr`) |
+| 8080 | TCP | Client/udpstreamer, Client/webui | web UI listen (collides with DebugService in combined demos — scripts adjust) |

BUG_FIX_PLAN.md

@@ -0,0 +1,221 @@
+# Bug Fix Plan — Security & Correctness Remediation
+
+**Date:** 2026-06-26
+**Based on:** `BUG_REPORT.md`
+**Scope:** `Source/` and `Client/`
+
+This plan organizes the ~60 findings from the audit into prioritized, dependency-ordered phases. Each phase is independently shippable. Phases are ordered by risk reduction: Critical remote-exploitable issues first, then High crash/OOB issues, then Medium robustness/DoS, then Low hardening.
+
+---
+
+## Guiding principles
+
+1. **Fix root causes, not symptoms.** The integer-overflow-in-bounds-check pattern appears in 6+ places — fix the pattern, not each instance ad hoc. Introduce a shared `boundsCheck(off, count, elemBytes, bufLen)` helper (C++) and a `validateCount(count, elemSize, bufLen)` helper (Go) and use them everywhere.
+2. **Defense in depth.** Origin checks + auth + input validation — not just one layer.
+3. **No regressions.** After each phase, run the existing test suites (`make -f Makefile.gcc test`, `python3 -m unittest tests_py`, `go test ./...` in each Go module) and the E2E suite (`./Test/E2E/chain/run_chain_e2e.sh --skip-build`).
+4. **Minimal blast radius.** Each fix is surgical to the file/function listed in the bug report. No refactors beyond what the fix requires.
+
+---
+
+## Phase 1 — Critical remote-exploitable fixes (ship first)
+
+**Goal:** Eliminate drive-by takeover and remote heap corruption. All fixes are small and localized.
+
+| # | Bug | File(s) | Fix | Est. effort | Depends on |
+|---|-----|---------|-----|-------------|------------|
+| 1.1 | CR-1: 1-byte heap OOB write in WS frame NUL-term | `WSServer.cpp:251` | Change `kRecvBuf = WS_MAX_RECV_PAYLOAD + 14u` → `+ 14u + 1u` | 5 min | — |
+| 1.2 | CR-2: XSS via unescaped `src.addr` | `Client/udpstreamer/static/app.js:3503`; `Client/debugger/static/app.js:3549` | Wrap `src.addr` with existing `escHtml()` in `_statsKV` calls (or inside `_statsKV` itself) | 10 min | — |
+| 1.3 | CR-3: WebSocket CSRF (Origin check disabled) | `Common/Client/go/wshub/hub.go:128`; `Source/Applications/StreamHub/WSServer.cpp:186-239` | **Go:** Replace `CheckOrigin: func(r *http.Request) bool { return true }` with a same-origin check (compare `Origin` header host to `Host` header). Add a configurable allowlist env var for non-local deployments. **C++:** Parse `Origin` header in `UpgradeHTTP`; reject if present and host doesn't match the listen address. | 30 min | — |
+| 1.4 | CR-4: Unauthenticated command injection to MARTe2 | `Client/debugger/martecontrol.go:217-263` | Add an allowlist of permitted MARTe2 commands (`DISCOVER`, `TREE`, `INFO`, `LS`, `VALUE`, `TRACE`, `UNTRACE`); reject `FORCE`, `UNFORCE`, `PAUSE`, `RESUME`, `STEP`, `BREAK`, `MSG` unless an explicit `--enable-dangerous-commands` flag is set. Log all forwarded commands. | 1 h | 1.3 |
+| 1.5 | CR-5: No auth on DebugService TCP | `DebugService.cpp:276` | (a) Bind TCP server to localhost by default (add `BindAddress` config key, default `127.0.0.1`). (b) Add an optional `AuthToken` config key; if set, require the first line from a client to be `AUTH <token>` before accepting commands. | 2 h | — |
+
+**Validation:** `bash -n` on shell scripts; `go build ./...` in each Go module; `make -f Makefile.gcc core apps`; manual test: open browser console on a cross-origin page and confirm WS to `localhost:8090` is rejected; confirm a crafted 65536-byte WS frame no longer corrupts.
+
+**Commit:** `fix(security): critical remote-exploitable fixes (CR-1..CR-5)`
+
+---
+
+## Phase 2 — High-severity crash / OOB / UAF fixes
+
+**Goal:** Eliminate remote crash and memory-corruption vectors. These are the integer-overflow and concurrency bugs.
+
+### 2A — Integer-overflow bounds checks (uniform pattern)
+
+| # | Bug | File(s) | Fix |
+|---|-----|---------|-----|
+| 2A.1 | HI-1: DATA bounds check overflow | `UDPSourceSession.cpp:358`; `UDPStreamerClient.cpp:520` | Replace `off + elemsToRead * wireElemBytes > size` with 64-bit arithmetic. Add a `validateBounds(off, count, elemBytes, size)` static helper in `UDPSProtocol.h` and use it in both files. |
+| 2A.2 | HI-2: Go unbounded allocations | `protocol.go:121, 229, 325` | Add `validateCount(count, elemSize, bufLen)` in `protocol.go`; call before every `make([]T, n)` that uses a network-derived count. Cap `NumElements()` at 1M. |
+| 2A.3 | HI-3: `accumFill` overflow + size calc | `UDPStreamer.cpp:700, 738, 757, 857-860` | (a) Add `if (accumFill >= maxBatchCount) { flush; }` before the write at line 857. (b) Use `uint64` for `maxBatchCount * totalSrcBytes` size calculations. |
+| 2A.4 | MD-4: `numRows * numCols` overflow | `UDPSourceSession.cpp:240, 346`; `protocol.go:121` | Use `static_cast<uint64>(numRows) * static_cast<uint64>(numCols)`; cap at 1M. |
+| 2A.5 | MD-15: `pairCount * 16u` overflow | `Client/streamhub/Protocol.cpp:77, 117` | Check `pairCount > (len - off) / 16` before multiplication; use `ull` suffix. |
+| 2A.6 | HI-6: `FD_SET` overflow | `UDPSServer.cpp:273, 308`; `UDPSClient.cpp:383` | Add `if (fd < FD_SETSIZE)` guard before each `FD_SET`; otherwise skip that client this cycle (or switch to `poll()`, which the codebase already uses elsewhere). |
+
+**Est. effort:** 3 h (pattern is repetitive once the helper exists)
+
+### 2B — Use-after-free and concurrency
+
+| # | Bug | File(s) | Fix |
+|---|-----|---------|-----|
+| 2B.1 | HI-5: Broadcast vs FreeSlot UAF | `WSServer.cpp:345-366, 432-445` | `FreeSlot` must acquire `clients[idx].writeMutex` before setting `active=false` and deleting `sock`. This ensures `BroadcastText`/`BroadcastBinary` cannot dereference a freed socket. |
+| 2B.2 | HI-9: TraceRingBuffer not thread-safe | `DebugCore.h:79-142` | Replace `volatile uint32 readIndex/writeIndex` with `Atomic<uint32>` (MARTe2 `Atomic::Load`/`Atomic::Store`). Ensure `Push` writes data before storing `writeIndex` (release ordering); `Pop` loads `writeIndex` before reading data (acquire ordering). |
+| 2B.3 | HI-4: `ProcessSignal` unclamped memcpy + `forcedMask` OOB | `DebugServiceBase.cpp:310, 313-318` | (a) Clamp `size` to `sizeof(signalInfo->forcedValue)` (1024). (b) Cap the array-forcing loop at `min(nEl, 256)`. (c) Validate `nEl <= 256` in `RegisterSignal`. |
+| 2B.4 | HI-7: Weak PRNG for WS handshake | `WSClient.cpp:29-31` | Replace `srand(time(nullptr))` + `rand()` with `std::random_device` or `getrandom()`/`/dev/urandom` read. |
+| 2B.5 | HI-8: Global registry patching | `DebugServiceBase.cpp:217-242` | (a) Save original builders before patching (`item->GetObjectBuilder()`); store in a static array for restore on destruction. (b) Add a `PatchRegistry` config flag (default `true` for back-compat; document the implication). (c) Guard against double-patching (skip if already patched). |
+
+**Est. effort:** 4 h
+
+**Validation:** `make -f Makefile.gcc test` + `./Build/x86-linux/GTest/MainGTest.ex` + `./Build/x86-linux/Test/Integration/Integration/IntegrationTests.ex` + `python3 -m unittest tests_py` (in `Test/E2E/chain/`) + `go test ./...` (in each Go module). Craft a UDP packet with `numSamples=0x20000001` and confirm no crash. Run the E2E suite: `./Test/E2E/chain/run_chain_e2e.sh --skip-build`.
+
+**Commit:** `fix(security): high-severity crash/OOB/UAF fixes (HI-1..HI-9)`
+
+---
+
+## Phase 3 — Medium-severity robustness / DoS / parser fixes
+
+**Goal:** Harden input validation, fix reassembly logic, and improve WS RFC compliance.
+
+### 3A — UDPS protocol hardening
+
+| # | Bug | File(s) | Fix |
+|---|-----|---------|-----|
+| 3A.1 | MD-1: `recvMask` too small | `UDPSClient.cpp:544, 592-594` | Enlarge `recvMask` to 64 bytes (512 bits) to match the `totalFragments <= 512` cap. |
+| 3A.2 | MD-2: No type matching in reassembly | `UDPSClient.cpp:548-555` | Add `type` field to `ReassemblySlot`; key on `counter && type`. |
+| 3A.3 | MD-3: Signal name not null-terminated | `UDPSourceSession.cpp:219-223` | After `memcpy`, force `name[63]='\0'` and `unit[31]='\0'`. |
+| 3A.4 | MD-6: No auth on UDP CONNECT | `UDPSServer.cpp:655-723` | Document trust boundary in `Docs/Protocol.md`. Optional: add a `ConnectToken` config key. |
+| 3A.5 | MD-13: Reassembler unbounded map growth (Go) | `reassembler.go:41-89` | Add `maxSets = 1024` cap; reject new sets when full. |
+| 3A.6 | LO-1: `totalFrags` overflow | `UDPSServer.cpp:541-542` | Validate `payloadSize <= maxPayloadSize * 65535` before the calculation. |
+| 3A.7 | LO-17: `bufMutex.Create` unchecked | `UDPStreamer.cpp:119`; `UDPStreamerClient.cpp:149` | Check return value; `REPORT_ERROR` on failure. |
+| 3A.8 | LO-19: Reassembler ticker panic | `reassembler.go:93` | Guard `if r.expiry <= 0 { r.expiry = 2 * time.Second }`. |
+
+**Est. effort:** 2 h
+
+### 3B — WebSocket and JSON robustness (C++ clients)
+
+| # | Bug | File(s) | Fix |
+|---|-----|---------|-----|
+| 3B.1 | MD-16: `readU16`/`readU32` silent failure | `Client/streamhub/Protocol.cpp:21-38` | Change `readU16`/`readU32`/`readF64` to return `bool` (or set an `ok` flag); `ParseBinaryFrame` fails fast on any truncated read. |
+| 3B.2 | MD-17: JSON injection in command builders | `Client/streamhub/Protocol.cpp:183-213` | Add a `jsonEscape(str)` helper; use it for all `%s` string interpolations. Switch to `std::string` to avoid truncation. |
+| 3B.3 | MD-18: `strstr`-based JSON parsing | `Client/streamhub/Protocol.cpp:296-310, 495, 510` | Migrate `ParseSources`, `ParseZoom`, `ParseStats` to a real JSON parser. **ImGui:** add a minimal JSON parser or vendor a single-header library (e.g. nlohmann/json). **Qt:** use `QJsonDocument`. |
+| 3B.4 | MD-19: WS RFC 6455 violations | `WSClient.cpp:204-223` | (a) Reject control frames with `payloadLen > 125`. (b) Implement `CONTINUATION` opcode reassembly (or at least log and drop with a clear message). (c) Echo `CLOSE` frame. |
+| 3B.5 | MD-20: Handshake no timeout | `WSClient.cpp:290-301` | Set `SO_RCVTIMEO` to 5s on the socket before the handshake loop. |
+| 3B.6 | MD-5: SHA1 latent overflow | `SHA1.h:50`; `WSFrame_client.h:113` | Add `if (len > 119u) return;` guard; use `uint64_t bitLen`; use `std::vector` instead of `new[]`/`delete[]`. |
+| 3B.7 | MD-24: `parseCapture` panic | `Test/E2E/chain/client/main.go:140-171` | Add bounds checks before each read, mirroring `parsePush`. |
+
+**Est. effort:** 4 h (3B.3 is the largest item — JSON parser migration)
+
+### 3C — Go hub and debugger hardening
+
+| # | Bug | File(s) | Fix |
+|---|-----|---------|-----|
+| 3C.1 | MD-10: No WS client cap | `hub.go:367-377` | Track `len(h.clients)`; reject above configurable max (default 32). |
+| 3C.2 | MD-11: Silent data loss | `hub.go:346-358` | Add a `droppedCount` atomic counter per channel; expose via `Snapshot()`. |
+| 3C.3 | MD-12: SSRF via `addSource` | `hub.go:83-96`; `sources.go:62-67` | Validate `addr` against a configurable allowlist (default: localhost + private RFC1918 ranges; reject link-local/metadata endpoints like `169.254.169.254`). |
+| 3C.4 | MD-14: Index panic | `martecontrol.go:543` | Use `strings.TrimPrefix(line, "OK SERVICE_INFO ")` with a length check. |
+| 3C.5 | LO-14: `stopCh` double-close | `martecontrol.go:182-189` | Use `sync.Once` for closing `stopCh`. |
+| 3C.6 | LO-10: `unsafe.Pointer` aliasing | `hub.go:588-594` | Replace `float64ToBytes` with `binary.LittleEndian` put operations. |
+| 3C.7 | LO-11: `+Inf` in JSON | `stats.go:115-116` | Guard `if avg > 0 { si.RateHz = 1.0 / avg } else { si.RateHz = 0 }`. |
+
+**Est. effort:** 2 h
+
+### 3D — TcpLogger and DebugService fixes
+
+| # | Bug | File(s) | Fix |
+|---|-----|---------|-----|
+| 3D.1 | MD-7: `StringHelper::Copy` overflow | `TcpLogger.cpp:87` | Replace with `strncpy(entry.description, description, MAX_ERROR_MESSAGE_SIZE-1); entry.description[MAX_ERROR_MESSAGE_SIZE-1]='\0';` |
+| 3D.2 | MD-8: `volatile` indices + lost wakeup | `TcpLogger.cpp:83-153, 157-158` | Use `Atomic::Load`/`Store` for `writeIdx`/`readIdx`; use `eventSem.ResetWait()` instead of `Wait`+`Reset`. |
+| 3D.3 | MD-9: `printf` on RT thread | `TcpLogger.cpp:75-76` | Add a `MirrorToStdout` config key (default `false`); guard the `printf`/`fflush` behind it. |
+| 3D.4 | MD-21: Stack buffer + shadowed member | `DebugService.cpp:438, 489` | Remove the local `udpsSampleBuf` (use the member); heap-allocate `cfgBuf`. |
+| 3D.5 | MD-23: `configValidated` read without lock | `UDPStreamerClient.cpp:463` | Mark `volatile` or acquire `bufMutex` before reading. |
+| 3D.6 | MD-22: Spinlock on RT path | `UDPStreamer.cpp:856, 947-976` | Minimize the RT-side critical section: swap a pointer instead of `memcpy` under the lock. Move the `memcpy` outside the lock (double-buffer pattern). |
+| 3D.7 | LO-7: JSON escaping in DISCOVER | `DebugServiceBase.cpp:900-906` | Use the existing `EscapeJson` helper for signal names. |
+| 3D.8 | LO-8: `EvaluateBreak` only element 0 | `DebugBrokerWrapper.h:61-86` | Document the limitation in the function comment. |
+| 3D.9 | LO-9: `fprintf(stderr)` on init | `DebugBrokerWrapper.h:195-197` | Replace with `REPORT_ERROR`. |
+
+**Est. effort:** 3 h
+
+**Validation:** Full test suites + E2E. For 3B.3 (JSON parser migration), add unit tests for crafted JSON inputs (nested quotes, escaped chars, truncated payloads). For 3A.1/3A.2, add a unit test that sends duplicate high-index fragments and mixed-type same-counter fragments.
+
+**Commit:** `fix(robustness): medium-severity input validation, parser, and DoS fixes (MD-1..MD-24)`
+
+---
+
+## Phase 4 — Low-severity hardening and documentation
+
+**Goal:** Clean up latent bugs, fix doc mismatches, add missing hardening. These are non-urgent but improve code health.
+
+| # | Bug | File(s) | Fix |
+|---|-----|---------|-----|
+| 4.1 | LO-2: `Stop()` TOCTOU | `WSServer.cpp:104-134` | Replace `Sleep(200ms)` with thread join. |
+| 4.2 | LO-3: Spinlock priority inversion | `UDPSourceSession.h`; `WSServer.h` | Document that `FastPollingMutexSem` is only for very short critical sections on same-core RT configs. Consider `MutexSem` for non-RT-contended paths. |
+| 4.3 | LO-4: `SignalBuffer` mod-0 | `SignalBuffer.h:36-41` | Guard `push`/`readLast`/`readRange` against `capacity == 0`. |
+| 4.4 | LO-5: Misleading "Thread-safe" comment | `SignalBuffer.h:18` | Remove the claim or add internal locking. |
+| 4.5 | LO-6: GAM type validation + doc | `SineArrayGAM.cpp:81`; `TimeArrayGAM.cpp:54`; `TimeArrayGAM.h:8,27` | Add `GetSignalType` checks; update `TimeArrayGAM.h` doc from `uint32` to `uint64`. |
+| 4.6 | LO-12: Directory listing | `Client/webui/main.go:26` | Disable directory listings (return 404 for directories). |
+| 4.7 | LO-13: No security headers | `Client/debugger/main.go:55`; `Client/udpstreamer/main.go`; `Client/webui/main.go` | Add a middleware that sets `X-Content-Type-Options: nosniff`, `X-Frame-Options: DENY`, `Content-Security-Policy: default-src 'self'`. |
+| 4.8 | LO-15: `host_`/`port_` race | `WSClient.cpp:48-58` | Protect with `sendMutex_` or make `atomic<uint16_t>` + `std::string` guarded by a small mutex. |
+| 4.9 | LO-16: `ReadExactTCP` edge case | `UDPSClient.cpp:474-487` | Add a max-iterations guard. |
+| 4.10 | LO-18: `RangeMin < RangeMax` validation | `UDPStreamer.cpp:403-404` | Validate when `quantType != None`; `REPORT_ERROR` if `rangeMax <= rangeMin`. |
+
+**Est. effort:** 2 h
+
+**Commit:** `fix(hardening): low-severity fixes, doc corrections, security headers (LO-1..LO-19)`
+
+---
+
+## Phase 5 — Cross-cutting refactors (optional, post-hardening)
+
+These are not bug fixes but structural improvements that prevent the recurrence of the bug classes found in this audit.
+
+| # | Refactor | Rationale | Est. effort |
+|---|----------|-----------|-------------|
+| 5.1 | Shared `validateBounds` / `validateCount` helpers | Centralizes the integer-overflow-prevention pattern; prevents future copy-paste bugs | 1 h |
+| 5.2 | Real JSON parser in C++ clients (nlohmann/json or Qt's QJsonDocument) | Eliminates the entire class of `strstr`/`snprintf` JSON bugs (MD-16, MD-17, MD-18) | 4 h |
+| 5.3 | `poll()`/`epoll` everywhere (replace all `select`+`FD_SET`) | Eliminates the `FD_SETSIZE` limitation entirely (HI-6) | 2 h |
+| 5.4 | Auth framework for DebugService + web UIs | Token-based auth shared between the Go web UIs and the C++ DebugService; eliminates the "no auth anywhere" theme | 1 d |
+| 5.5 | Fuzzing harness for UDPS protocol parsers | `libFuzzer` or `go-fuzz` harnesses that feed random bytes to `ParseConfig`/`ParseData`/`DecodeElems`/`ParseBinaryFrame`; catches future overflow variants | 1 d |
+| 5.6 | Thread-sanitizer and address-sanitizer CI runs | `make CXXFLAGS="-fsanitize=address,undefined"`; `go test -race`; catches UAF and races automatically | 4 h |
+
+---
+
+## Verification checklist (run after each phase)
+
+```bash
+source env.sh
+
+# C++ build + tests
+make -f Makefile.gcc clean
+make -f Makefile.gcc core apps test
+./Build/x86-linux/GTest/MainGTest.ex
+./Build/x86-linux/Test/Integration/Integration/IntegrationTests.ex
+
+# Go tests (each module)
+cd Common/Client/go && go vet ./... && go test ./... && cd -
+cd Client/debugger && go vet ./... && go build ./... && cd -
+cd Client/udpstreamer && go vet ./... && go build ./... && cd -
+cd Test/E2E/chain/client && go vet ./... && go test ./... && cd -
+
+# Python framework tests
+cd Test/E2E/chain && python3 -m unittest tests_py && cd -
+
+# Full E2E suite
+./Test/E2E/chain/run_chain_e2e.sh --skip-build
+
+# ASan/UBSan smoke test (after Phase 2+)
+make -f Makefile.gcc clean
+make -f Makefile.gcc CXXFLAGS="-fsanitize=address,undefined -g" core apps
+./Build/x86-linux/GTest/MainGTest.ex
+```
+
+---
+
+## Timeline summary
+
+| Phase | Scope | Est. effort | Risk reduction |
+|-------|-------|-------------|----------------|
+| 1 | Critical remote-exploitable (CR-1..CR-5) | ~4 h | Eliminates drive-by takeover + heap corruption |
+| 2 | High crash/OOB/UAF (HI-1..HI-9) | ~7 h | Eliminates remote crash + memory corruption |
+| 3 | Medium robustness/DoS/parser (MD-1..MD-24) | ~11 h | Hardens input validation + RFC compliance |
+| 4 | Low hardening/doc (LO-1..LO-19) | ~2 h | Code health + defense in depth |
+| 5 | Cross-cutting refactors (optional) | ~3 d | Prevents recurrence of bug classes |
+
+**Total (Phases 1-4):** ~24 h of focused work. Phase 5 is optional and can be scheduled separately.

CLAUDE.md

@@ -37,9 +37,40 @@ cd Client/streamhub && cmake -B build -DCMAKE_BUILD_TYPE=Release && cmake --buil
 cd Client/streamhub-qt && cmake -B build && cmake --build build
 ```
 
-End-to-end demo scripts (build + launch full stack, see headers for ports/options): `./run_combined_test.sh`, `./run_streamhub.sh`.
+End-to-end demo script (build + launch full stack, see header for ports/options): `./run_streamhub.sh`.
 
-**Streaming-chain E2E suite** (`Test/E2E/chain/`): `./run_chain_e2e.sh [--skip-build] [--only <id>] [--cpp-coverage] [--stress]` drives the full chain per scenario (`scenarios.py`) — generates typed/shaped input + both cfgs, runs MARTe2+StreamHub, records via the Go `chain-client` (live/zoom/window/trigger), and validates the recorded waveform against an analytic/fed oracle (`validate_waveform.py`: fidelity gates correctness, sine shape-fit is a gross-sanity gate + tracked metric pending Phase-A timestamp calibration). It then runs the unit suites + coverage (`collect.py`: C++ GTest, Go, Python; `--cpp-coverage` does an instrumented `--coverage` rebuild, captures with lcov restricted to `Source/*`+`Test/*`, then restores the clean build), consolidates everything into `report_data.json` with per-field progression/regression vs the previous run and trend plots (`report_build.py`, history in `Build/x86-linux/E2E/chain/history.jsonl`), and compiles a Typst PDF (`E2E_Report.typ`). A `--stress` flag additionally runs the capacity matrix (`stress.py` declarative axes → `stress_run.py` orchestrator → `stress_results.json`): it sweeps signal size (into the multi-fragment >64 KB regime), signal count, source count, WS-client count, subscriber fan-out, and zoom request-rate one axis at a time, gating survival + liveness (hard) and peak RSS + zoom-p95 latency (soft), and embeds a Stress Tests section (per-case table + per-axis scaling curves, with regression vs the previous run) into the PDF. Standalone: `./run_stress.sh [--skip-build] [--only <id>] [--axis <axis>]`. Python framework unit tests: `python3 -m unittest tests_py` (in `Test/E2E/chain/`).
+**Streaming-chain E2E suite** (`Test/E2E/suite/`):
+
+```bash
+./Test/E2E/suite/run_e2e.sh [flags]
+```
+
+Flags:
+
+| Flag | Effect |
+|---|---|
+| `--skip-build` | Skip C++ component rebuild |
+| `--only <id>` | Run a single scenario by ID |
+| `--pdf-only` | Just compile the Typst PDF report |
+| `--cpp-coverage` | Instrumented gcov rebuild + lcov capture (on by default) |
+| `--skip-coverage` | Disable the coverage pass |
+| `--skip-stress` | Skip the stress matrix |
+| `--skip-datasources` | Skip `direct` scenarios |
+| `--skip-recorder` | Skip `recorder` scenarios |
+| `--skip-debug` | Skip `debug` and `debug_pause_resume` scenarios |
+| `--skip-tcplogger` | Skip `tcplogger` scenarios |
+
+Scenario kinds (defined in `scenarios.py`):
+
+- **chain** — full streaming pipeline: MARTe2 → UDPStreamer → StreamHub → Go `chain-client` (live/zoom/window/trigger). Validates recorded waveform against analytic/fed oracle (`validate_waveform.py`: fidelity gates correctness, sine shape-fit is a gross-sanity gate + tracked metric).
+- **direct** — MARTe2 FileReader → FileWriter round-trip, validates binary output.
+- **recorder** — MARTe2 → StreamHub with history recorder, validates recorded `.bin` file.
+- **debug / debug_pause_resume** — DebugService scenarios via the Go `debugclient`.
+- **tcplogger** — TcpLogger scenarios via the Go `debugclient`.
+
+After scenarios, the suite runs unit tests + coverage (`collect.py`: C++ GTest, Go, Python; coverage uses lcov restricted to `Source/*` — the `Test/` harness is excluded), consolidates everything into `report_data.json` with per-field progression/regression vs the previous run and trend plots (`report_build.py`, history in `Build/x86-linux/E2E/chain/history.jsonl`), and compiles a Typst PDF (`E2E_Report.typ`). Artifacts go to `Build/x86-linux/E2E/chain/` (report, logs, PDF) and `/tmp/chain_e2e/` (scratch). Results are aggregated into `results.json` with XFAIL/XPASS handling for known issues.
+
+Python framework unit tests: `python3 -m unittest tests_py` (in `Test/E2E/suite/`).
 
 Build output goes to `Build/x86-linux/` (shared libs per component, `.ex` executables).
 

Client/debugger/controller/cmd_gate_test.go

@@ -0,0 +1,54 @@
+package controller
+
+import (
+	"testing"
+)
+
+// TestIsDangerousCommand_Force — FORCE is dangerous.
+func TestIsDangerousCommand_Force(t *testing.T) {
+	if !isDangerousCommand("FORCE signal 1.0") {
+		t.Error("FORCE should be dangerous")
+	}
+}
+
+// TestIsDangerousCommand_Pause — PAUSE is dangerous.
+func TestIsDangerousCommand_Pause(t *testing.T) {
+	if !isDangerousCommand("PAUSE") {
+		t.Error("PAUSE should be dangerous")
+	}
+}
+
+// TestIsDangerousCommand_Msg — MSG is dangerous.
+func TestIsDangerousCommand_Msg(t *testing.T) {
+	if !isDangerousCommand("MSG target func") {
+		t.Error("MSG should be dangerous")
+	}
+}
+
+// TestIsDangerousCommand_CaseInsensitive — case-insensitive.
+func TestIsDangerousCommand_CaseInsensitive(t *testing.T) {
+	if !isDangerousCommand("force signal 1.0") {
+		t.Error("lowercase force should be dangerous")
+	}
+}
+
+// TestIsDangerousCommand_SafeCommand — DISCOVER is not dangerous.
+func TestIsDangerousCommand_SafeCommand(t *testing.T) {
+	if isDangerousCommand("DISCOVER") {
+		t.Error("DISCOVER should not be dangerous")
+	}
+}
+
+// TestIsDangerousCommand_TraceNotDangerous — TRACE is not dangerous (read-only).
+func TestIsDangerousCommand_TraceNotDangerous(t *testing.T) {
+	if isDangerousCommand("TRACE signal 1") {
+		t.Error("TRACE should not be dangerous")
+	}
+}
+
+// TestIsDangerousCommand_Empty — empty command is not dangerous.
+func TestIsDangerousCommand_Empty(t *testing.T) {
+	if isDangerousCommand("") {
+		t.Error("empty command should not be dangerous")
+	}
+}

Client/debugger/controller/martecontrol.go

@@ -1,4 +1,9 @@
-package main
+// Package controller implements MarteController, the shared TCP/UDP client
+// logic that drives a running MARTe2 DebugService+TCPLogger instance. It is
+// consumed both by the Client/debugger browser-facing WebSocket server
+// (package main, via NewMarteController) and headlessly by the
+// Test/E2E/suite/debugclient E2E test tool (via NewHeadlessMarteController).
+package controller
 
 import (
 	"bufio"
@@ -17,6 +22,40 @@ import (
 	"marte2/common/wshub"
 )
 
+// ---------------------------------------------------------------------------
+// Command safety gate (CR-4)
+// ---------------------------------------------------------------------------
+
+// DangerousCommandsEnabled gates commands that mutate the RT application state
+// (FORCE, PAUSE, RESUME, STEP, BREAK, MSG).  Set via --enable-dangerous-commands.
+var DangerousCommandsEnabled = false
+
+// dangerousCommands is the set of MARTe2 commands that can change signal values
+// or alter execution flow.  Without --enable-dangerous-commands these are blocked
+// from the browser WebSocket path.
+var dangerousCommands = map[string]bool{
+	"FORCE":    true,
+	"UNFORCE":  true,
+	"PAUSE":    true,
+	"RESUME":   true,
+	"STEP":     true,
+	"BREAK":    true,
+	"UNBREAK":  true,
+	"MSG":      true,
+	"LOAD":     true,
+	"UNLOAD":   true,
+}
+
+// isDangerousCommand returns true if the command's first word is in the
+// dangerous set (case-insensitive).
+func isDangerousCommand(cmd string) bool {
+	parts := strings.Fields(cmd)
+	if len(parts) == 0 {
+		return false
+	}
+	return dangerousCommands[strings.ToUpper(parts[0])]
+}
+
 // ---------------------------------------------------------------------------
 // Signal metadata (populated by DISCOVER)
 // ---------------------------------------------------------------------------
@@ -47,7 +86,8 @@ func broadcastHub(hub *wshub.Hub, v any) {
 // ---------------------------------------------------------------------------
 
 type MarteController struct {
-	hub *wshub.Hub
+	hub  *wshub.Hub
+	sink func(v any)
 
 	mu      sync.Mutex
 	tcpConn net.Conn
@@ -101,6 +141,7 @@ func NewMarteController(hub *wshub.Hub) *MarteController {
 		forcedState: make(map[string]string),
 		stopCh:      make(chan struct{}),
 	}
+	mc.sink = func(v any) { broadcastHub(mc.hub, v) }
 	// Register the new-client hook so connection + forced/traced state is
 	// replayed to any browser that connects (or reconnects) while the server
 	// already holds a live MARTe2 TCP session.
@@ -108,6 +149,20 @@ func NewMarteController(hub *wshub.Hub) *MarteController {
 	return mc
 }
 
+// NewHeadlessMarteController creates a MarteController with no WebSocket hub,
+// routing all events through sink instead (used by the debugclient E2E test tool).
+func NewHeadlessMarteController(sink func(v any)) *MarteController {
+	mc := &MarteController{
+		hub:         nil,
+		signals:     make(map[uint32]*SignalMeta),
+		tracedNames: make(map[string]bool),
+		forcedState: make(map[string]string),
+		stopCh:      make(chan struct{}),
+	}
+	mc.sink = sink
+	return mc
+}
+
 func (m *MarteController) IsConnected() bool {
 	return atomic.LoadInt32(&m.connected) == 1
 }
@@ -166,10 +221,13 @@ func (m *MarteController) Connect(host string, cmdPort, udpPort, logPort int) {
 	m.stopCh = make(chan struct{})
 	m.mu.Unlock()
 
-	// Update source state so the browser shows "connecting".
+	// Update source state so the browser shows "connecting". No-op headless
-	m.hub.SetSourceState("debug", "connecting")
+	// (m.hub == nil for NewHeadlessMarteController instances).
+	if m.hub != nil {
+		m.hub.SetSourceState("debug", "connecting")
+	}
 
-	broadcastHub(m.hub, map[string]any{
+	m.sink(map[string]any{
 		"type": "log", "time": time.Now().Format("15:04:05.000"),
 		"level": "INFO", "message": fmt.Sprintf("Connecting to %s cmd=%d udp=%d log=%d", host, cmdPort, udpPort, logPort),
 	})
@@ -198,7 +256,9 @@ func (m *MarteController) Disconnect() {
 	m.baseTsSet = false
 	m.basesMu.Unlock()
 	m.discoverAcc = nil
-	m.hub.SetSourceState("debug", "disconnected")
+	if m.hub != nil {
+		m.hub.SetSourceState("debug", "disconnected")
+	}
 }
 
 func (m *MarteController) stopped() bool {
@@ -256,10 +316,25 @@ func (m *MarteController) HandleBrowserCommand(msg []byte) {
 			return
 		}
 		cmd, _ := data["cmd"].(string)
-		if cmd != "" {
+		if cmd == "" {
-			m.trackForcedCmd(cmd)
+			return
-			m.SendCommand(cmd)
 		}
+		// Gate dangerous commands (FORCE/UNFORCE/PAUSE/RESUME/STEP/BREAK/MSG)
+		// behind an explicit opt-in flag.  Without it, only read-only commands
+		// (DISCOVER, TREE, INFO, LS, VALUE, TRACE, UNTRACE, STEP_STATUS) are
+		// forwarded to the MARTe2 TCP control connection.
+		if isDangerousCommand(cmd) {
+			if !DangerousCommandsEnabled {
+				m.sink(map[string]any{
+					"type": "log", "time": time.Now().Format("15:04:05.000"),
+					"level": "WARNING",
+					"message": fmt.Sprintf("Blocked dangerous command (requires --enable-dangerous-commands): %s", cmd),
+				})
+				return
+			}
+		}
+		m.trackForcedCmd(cmd)
+		m.SendCommand(cmd)
 	}
 }
 
@@ -272,7 +347,7 @@ func (m *MarteController) runTCP(host string, port int) {
 	for !m.stopped() {
 		conn, err := net.DialTimeout("tcp", addr, 5*time.Second)
 		if err != nil {
-			broadcastHub(m.hub, map[string]any{
+			m.sink(map[string]any{
 				"type": "log", "time": time.Now().Format("15:04:05.000"),
 				"level": "WARNING", "message": fmt.Sprintf("TCP %s: %v — retrying…", addr, err),
 			})
@@ -287,7 +362,7 @@ func (m *MarteController) runTCP(host string, port int) {
 		m.mu.Unlock()
 
 		atomic.StoreInt32(&m.connected, 1)
-		broadcastHub(m.hub, map[string]any{"type": "connected"})
+		m.sink(map[string]any{"type": "connected"})
 
 		// Send SERVICE_INFO to auto-discover ports
 		m.writeCmd("SERVICE_INFO")
@@ -297,7 +372,7 @@ func (m *MarteController) runTCP(host string, port int) {
 		m.readLoop(conn)
 
 		atomic.StoreInt32(&m.connected, 0)
-		broadcastHub(m.hub, map[string]any{"type": "disconnected"})
+		m.sink(map[string]any{"type": "disconnected"})
 
 		m.mu.Lock()
 		m.tcpConn = nil
@@ -323,7 +398,7 @@ func (m *MarteController) writeCmd(cmd string) {
 	silent := cmd == "STEP_STATUS" || cmd == "INFO"
 	if !silent {
 		log.Printf("[→MARTe] %s", cmd)
-		broadcastHub(m.hub, map[string]any{
+		m.sink(map[string]any{
 			"type": "log", "time": time.Now().Format("15:04:05.000"),
 			"level": "CMD", "message": fmt.Sprintf("→ %s", cmd),
 		})
@@ -465,7 +540,7 @@ func (m *MarteController) handleJSONResponse(tag, data string) {
 	silent := tag == "STEP_STATUS" || tag == "INFO"
 	if !silent {
 		log.Printf("[←MARTe] %s  %d bytes", tag, len(data))
-		broadcastHub(m.hub, map[string]any{
+		m.sink(map[string]any{
 			"type": "log", "time": time.Now().Format("15:04:05.000"),
 			"level": "RESP", "message": fmt.Sprintf("← %s (%d B)", tag, len(data)),
 		})
@@ -500,25 +575,27 @@ func (m *MarteController) handleJSONResponse(tag, data string) {
 		raw := m.rawSigs
 		m.rawSigsMu.RUnlock()
 		if len(raw) > 0 {
-			m.hub.UpdateConfigForSource("debug", m.translateSignalNames(raw))
+			if m.hub != nil {
+				m.hub.UpdateConfigForSource("debug", m.translateSignalNames(raw))
+			}
 		} else {
 			m.synthesizeHubConfig(all)
 		}
 		// Re-marshal the merged list so the browser gets a single consistent blob.
 		merged, _ := json.Marshal(discoverResp{Signals: all})
-		broadcastHub(m.hub, map[string]any{
+		m.sink(map[string]any{
 			"type": "response", "tag": "DISCOVER", "data": string(merged),
 		})
 		return
 
 	case "TREE":
-		broadcastHub(m.hub, map[string]any{
+		m.sink(map[string]any{
 			"type": "tree_node",
 			"data": data,
 		})
 		return
 	}
-	broadcastHub(m.hub, map[string]any{
+	m.sink(map[string]any{
 		"type": "response",
 		"tag":  tag,
 		"data": data,
@@ -537,13 +614,13 @@ func (m *MarteController) handleTextLine(line string) {
 				fmt.Sscanf(p[8:], "%d", &newLog)
 			}
 		}
-		broadcastHub(m.hub, map[string]any{
+		m.sink(map[string]any{
 			"type": "response",
 			"tag":  "SERVICE_INFO",
 			"data": line[len("OK SERVICE_INFO "):],
 		})
 		if newUDP > 0 || newLog > 0 {
-			broadcastHub(m.hub, map[string]any{
+			m.sink(map[string]any{
 				"type":     "service_config",
 				"udp_port": newUDP,
 				"log_port": newLog,
@@ -567,7 +644,7 @@ func (m *MarteController) handleTextLine(line string) {
 			}
 		}
 	}
-	broadcastHub(m.hub, map[string]any{
+	m.sink(map[string]any{
 		"type": "text_line",
 		"data": line,
 	})
@@ -774,7 +851,9 @@ func (m *MarteController) synthesizeHubConfig(sigs []discoverSignalJSON) {
 	// buffer and limiting live streaming to the fraction of a second that
 	// accumulated before the DISCOVER response arrived.
 	translated := m.translateSignalNames(sigInfos)
-	m.hub.UpdateConfigForSource("debug", translated)
+	if m.hub != nil {
+		m.hub.UpdateConfigForSource("debug", translated)
+	}
 }
 
 // ---------------------------------------------------------------------------
@@ -801,7 +880,7 @@ func (m *MarteController) runDebugUDP(host string, port int) {
 	if err != nil {
 		msg := fmt.Sprintf("UDP bind on %s failed: %v — rebuild DebugService C++ and restart", addr, err)
 		log.Printf("[debug-udp] %s", msg)
-		broadcastHub(m.hub, map[string]any{
+		m.sink(map[string]any{
 			"type": "log", "time": time.Now().Format("15:04:05.000"),
 			"level": "ERROR", "message": msg,
 		})
@@ -812,7 +891,7 @@ func (m *MarteController) runDebugUDP(host string, port int) {
 	conn.SetReadBuffer(10 * 1024 * 1024)
 
 	log.Printf("[debug-udp] listening on %s for UDPS packets", addr)
-	broadcastHub(m.hub, map[string]any{
+	m.sink(map[string]any{
 		"type": "log", "time": time.Now().Format("15:04:05.000"),
 		"level": "INFO", "message": fmt.Sprintf("UDP listener bound on %s", addr),
 	})
@@ -865,8 +944,10 @@ func (m *MarteController) runDebugUDP(host string, port int) {
 			sigs = m.translateSignalNames(sigs)
 			currentSigs = sigs
 			currentPublishMode = pm
-			m.hub.UpdateConfigForSource("debug", sigs)
+			if m.hub != nil {
-			m.hub.SetSourceState("debug", "connected")
+				m.hub.UpdateConfigForSource("debug", sigs)
+				m.hub.SetSourceState("debug", "connected")
+			}
 
 		case udpsprotocol.PktData:
 			if len(currentSigs) == 0 {
@@ -888,8 +969,10 @@ func (m *MarteController) runDebugUDP(host string, port int) {
 				log.Printf("[debug-udp] parse data: %v", err)
 				continue
 			}
-			for _, s := range samples {
+			if m.hub != nil {
-				m.hub.PushDataForSource("debug", s)
+				for _, s := range samples {
+					m.hub.PushDataForSource("debug", s)
+				}
 			}
 		}
 	}
@@ -923,7 +1006,7 @@ func (m *MarteController) runLog(host string, port int) {
 				}
 				level := rest[:idx]
 				msg := rest[idx+1:]
-				broadcastHub(m.hub, map[string]any{
+				m.sink(map[string]any{
 					"type":    "log",
 					"time":    time.Now().Format("15:04:05.000"),
 					"level":   level,

Client/debugger/main.go

@@ -10,6 +10,8 @@ import (
 	"net/http"
 	"os"
 
+	"marte2debugger/controller"
+
 	"marte2/common/wshub"
 )
 
@@ -21,13 +23,15 @@ var staticFiles embed.FS
 func main() {
 	addr := flag.String("addr", ":7777", "HTTP listen address")
 	sourcesFile := flag.String("sources-file", "", "JSON file for persistent source list")
+	flag.BoolVar(&controller.DangerousCommandsEnabled, "enable-dangerous-commands", false,
+		"Allow FORCE/PAUSE/RESUME/STEP/BREAK/MSG commands from the browser (CR-4 safety gate)")
 	flag.Parse()
 
 	hub := wshub.NewHub()
 	sm := wshub.NewSourceManager(hub, *sourcesFile)
 	hub.SetSourceManager(sm)
 
-	ctrl := NewMarteController(hub)
+	ctrl := controller.NewMarteController(hub)
 
 	go hub.Run()
 

Client/debugger/static/app.js

@@ -3511,7 +3511,7 @@ function _fmtHz(v) { return v != null && isFinite(v) && v > 0 ? v.toFixed(2) + '
 function _fmtKB(v) { return v != null && isFinite(v) ? (v / 1024).toFixed(2) + ' KB' : '—'; }
 
 function _statsKV(label, value, cls) {
-  return `<div class="stats-kv"><span class="stats-k">${label}</span><span class="stats-v${cls ? ' ' + cls : ''}">${value}</span></div>`;
+  return `<div class="stats-kv"><span class="stats-k">${escHtml(label)}</span><span class="stats-v${cls ? ' ' + cls : ''}">${escHtml(value)}</span></div>`;
 }
 
 function _histHTML(si) {

Client/streamhub/WSClient.cpp

@@ -18,18 +18,27 @@
 #include <cstdlib>
 #include <ctime>
 #include <chrono>
+#include <random>
 
 namespace StreamHubClient {
 
 /* ── Helpers ─────────────────────────────────────────────────────────────── */
 
 static std::string base64Key() {
-    /* Generate 16 random bytes and base64-encode them */
+    /* HI-7: use /dev/urandom (CSPRNG) instead of srand(time)/rand() */
     uint8_t raw[16];
-    srand(static_cast<unsigned>(time(nullptr)));
+    int fd = open("/dev/urandom", O_RDONLY);
-    for (int i = 0; i < 16; i++) {
+    if (fd < 0 || read(fd, raw, sizeof(raw)) != static_cast<ssize_t>(sizeof(raw))) {
-        raw[i] = static_cast<uint8_t>(rand() & 0xFF);
+        /* Fallback: std::random_device (still better than srand/rand) */
+        std::random_device rd;
+        for (size_t i = 0; i < sizeof(raw); i += sizeof(unsigned)) {
+            unsigned val = rd();
+            for (size_t j = 0; j < sizeof(unsigned) && i + j < sizeof(raw); j++) {
+                raw[i + j] = static_cast<uint8_t>(val >> (j * 8));
+            }
+        }
     }
+    if (fd >= 0) { close(fd); }
     char out[32];
     WS_Base64Encode(raw, 16, out);
     return std::string(out);

Client/udpstreamer/static/app.js

@@ -89,6 +89,15 @@ function getVScale(plotId, key) {
   return sigVScale[vsKey];
 }
 
+// Round a raw units-per-division up to the next 1/2/5×10ⁿ step so the Y-axis
+// gridlines land on human-readable values.
+function niceDiv(x) {
+  if (!isFinite(x) || x <= 0) return 1;
+  const p = Math.pow(10, Math.floor(Math.log10(x)));
+  const m = x / p;
+  return (m <= 1 ? 1 : m <= 2 ? 2 : m <= 5 ? 5 : 10) * p;
+}
+
 function findSignalMeta(key) {
   const colon = key.indexOf(':');
   if (colon < 0) return null;
@@ -107,8 +116,8 @@ function resolveVScale(plotId, key, rawY) {
   if (vs.mode === 'range') {
     const meta = findSignalMeta(key);
     if (meta && meta.rangeMin != null && meta.rangeMax != null && meta.rangeMax > meta.rangeMin) {
-      const divValue = (meta.rangeMax - meta.rangeMin) / 8;
+      const divValue = niceDiv((meta.rangeMax - meta.rangeMin) / 8);
-      const offset = (meta.rangeMin + meta.rangeMax) / 2;
+      const offset = Math.round((meta.rangeMin + meta.rangeMax) / 2 / divValue) * divValue;
       vs._resolvedDiv = divValue; vs._resolvedOffset = offset;
       return { divValue, offset, screenPos };
     }
@@ -120,7 +129,9 @@ function resolveVScale(plotId, key, rawY) {
     vs._resolvedDiv = divValue; vs._resolvedOffset = offset;
     return { divValue, offset, screenPos };
   }
-  // Auto: fit data in central 6 of 8 divisions, centered at screenPos
+  // Auto: fit data in central 6 of 8 divisions, centered at screenPos.
+  // Both the V/div and the centre offset are snapped so gridlines (and the
+  // zero line, when in view) fall on round values.
   let min = Infinity, max = -Infinity;
   for (let i = 0; i < rawY.length; i++) {
     const v = rawY[i];
@@ -128,8 +139,8 @@ function resolveVScale(plotId, key, rawY) {
   }
   if (!isFinite(min)) { min = -1; max = 1; }
   if (min === max) { min -= 1; max += 1; }
-  const divValue = Math.max((max - min) / 6, 1e-30);
+  const divValue = niceDiv(Math.max((max - min) / 6, 1e-30));
-  const offset = (max + min) / 2;
+  const offset = Math.round((max + min) / 2 / divValue) * divValue;
   vs._resolvedDiv = divValue; vs._resolvedOffset = offset;
   return { divValue, offset, screenPos };
 }
@@ -285,6 +296,12 @@ let _zoomFetchTimer = null;
 //   trig mode  → relative seconds from trigger
 const cursors = { mode: 'off', tA: null, tB: null };
 let cursorsDirty = false;  // if true, redraw all plots to update cursor lines
+// Rolling-window anchor used to keep cursors visually fixed while live data scrolls.
+let _cursorAnchorNow = null;
+
+// Horizontal value rulers — stored in normalized division units (the shared
+// y scale, -4.5…4.5) so one pair applies to every plot regardless of V/div.
+const rulers = { mode: 'off', yA: null, yB: null };
 
 // Layout — [label, cssClass, cols, rows]
 const LAYOUTS = [
@@ -329,7 +346,15 @@ async function resolveHub() {
 function connectWS() {
   ws = new WebSocket('ws://' + HUB + '/ws');
   ws.binaryType = 'arraybuffer';
-  ws.onopen = () => { wsBackoff = 1000; setStatus('orange', 'Connected – waiting for data'); };
+  ws.onopen = () => {
+    wsBackoff = 1000;
+    setStatus('orange', 'Connected – waiting for data');
+    // Restore monotonic TS preference from localStorage.
+    const monoPref = localStorage.getItem('udpscope.monotonic') === '1';
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: 'setMonotonic', enabled: monoPref }));
+    }
+  };
   ws.onclose = () => {
     setStatus('red', 'Disconnected (reconnecting…)');
     setTimeout(connectWS, wsBackoff);
@@ -346,10 +371,26 @@ function connectWS() {
     else if (msg.type === 'zoom') onZoomReply(msg);
     else if (msg.type === 'historyZoom') onHistoryZoomReply(msg);
     else if (msg.type === 'historyInfo') onHistoryInfo(msg);
-    else if (msg.type === 'triggerState') onTriggerState(msg);
+    else if (msg.type === 'monotonicState') onMonotonicState(msg);
   };
 }
 
+/* Monotonic timestamp snapping — when enabled, the hub snaps small inter-frame
+   timestamp deviations (< 5 ms) to the ideal gap, eliminating overlaps/gaps
+   caused by software-dispatch jitter. */
+function onMonotonicState(msg) {
+  const cb = document.getElementById('cb-monotonic');
+  if (!cb) return;
+  cb.checked = !!msg.enabled;
+  localStorage.setItem('udpscope.monotonic', msg.enabled ? '1' : '0');
+}
+document.getElementById('cb-monotonic').addEventListener('change', e => {
+  localStorage.setItem('udpscope.monotonic', e.target.checked ? '1' : '0');
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: 'setMonotonic', enabled: e.target.checked }));
+  }
+});
+
 /* WS zoom request/reply — replaces the Go hub's /api/zoom HTTP endpoint.
    Resolves with the {key:{t,v}} signals map; rejects on timeout/closure. */
 let _zoomReqId = 0;
@@ -882,24 +923,41 @@ function makeSeriesPath(key) {
 
 /* ════════════════════════════════════════════════════════════════
    LTTB Web Worker — offloads decimation off the main thread.
-   Cache key: "<plotId>:<masterKey>:<t0f>:<t1f>:<len>"
+   Cache key: "<plotId>:<masterKey>:<t0f>:<t1f>:<len>" when zoomed, or
+              "<plotId>:<masterKey>:rolling" in live mode, where the data
+              generation is passed alongside instead of being part of the key.
    On cache-hit  → render uses cached {t, v} immediately (stale-while-revalidate).
-   On cache-miss → render falls back to sync lttb once (first zoom render only),
+   On cache-miss → render falls back to sync lttb once (first render only),
                    then worker takes over for subsequent updates.
    ════════════════════════════════════════════════════════════════ */
-const lttbCache = new Map();   // key → {t, v}
+const lttbCache = new Map();   // key → {t, v, gen}
-const lttbPending = new Set(); // keys currently in-flight
+const lttbPending = new Map(); // key → generation currently in flight
+// Hard ceiling on cached decimations.  Rolling-mode keys are stable (one entry
+// per plot), but zoom keys embed the range, so without a cap the map would grow
+// for the whole session.
+const LTTB_CACHE_MAX = 256;
+
+// Store a decimation, re-inserting so Map iteration order stays oldest-first.
+function lttbCacheStore(key, entry) {
+  lttbCache.delete(key);
+  lttbCache.set(key, entry);
+  while (lttbCache.size > LTTB_CACHE_MAX) {
+    lttbCache.delete(lttbCache.keys().next().value);
+  }
+}
 
 let _lttbWorker = null;
 try {
   _lttbWorker = new Worker('lttb-worker.js');
   _lttbWorker.onmessage = function({ data: { id, t, v } }) {
+    const gen = lttbPending.get(id);
     lttbPending.delete(id);
-    lttbCache.set(id, { t, v });
+    lttbCacheStore(id, { t, v, gen });
-    // Invalidate and redraw the owning plot.
+    // Invalidate and redraw the owning plot.  Clearing lastDataGen defeats the
+    // render loop's no-new-data fast path so this fresh result is actually drawn.
     const plotId = parseInt(id.split(':')[0], 10);
     const p = plots.find(q => q.id === plotId);
-    if (p) { p.needsRedraw = true; }
+    if (p) { p.needsRedraw = true; p.lastDataGen = -1; }
   };
   _lttbWorker.onerror = e => console.warn('[lttb-worker] error:', e);
 } catch(e) {
@@ -907,14 +965,20 @@ try {
 }
 
 // Submit a LTTB job to the worker (or run sync if worker unavailable).
-// Returns cached {t, v} if fresh, null if a worker job was just submitted,
+// `gen` identifies the input data behind a key that does not itself change with
-// or a sync result if the worker is unavailable.
+// the data (rolling mode).  A cached entry computed for an older generation is
-function lttbAsync(cacheKey, t, v, threshold) {
+// still returned — stale-while-revalidate — while a fresh job runs.  Callers
+// whose key already encodes the input (zoom ranges) pass no generation.
+// Returns the cached {t, v} (fresh or stale), or null on the first render.
+function lttbAsync(cacheKey, t, v, threshold, gen) {
   const cached = lttbCache.get(cacheKey);
-  if (cached) return cached;                 // cache hit — use immediately
+  if (cached && cached.gen === gen) return cached;   // fresh — nothing to do
 
+  // At most one job per key in flight: submitting on every generation change
+  // would let the worker's message queue grow without bound whenever it cannot
+  // keep up with the push rate.
   if (!lttbPending.has(cacheKey)) {
-    lttbPending.add(cacheKey);
+    lttbPending.set(cacheKey, gen);
     if (_lttbWorker) {
       // Send copies so the main thread retains the originals.
       const tCopy = new Float64Array(t);
@@ -924,12 +988,13 @@ function lttbAsync(cacheKey, t, v, threshold) {
     } else {
       // Synchronous fallback (worker unavailable).
       const result = lttb(t, v, threshold);
-      lttbCache.set(cacheKey, result);
+      result.gen = gen;
+      lttbCacheStore(cacheKey, result);
       lttbPending.delete(cacheKey);
       return result;
     }
   }
-  return null;  // worker job in-flight — caller should use fallback
+  return cached || null;  // stale entry, or nothing to draw yet
 }
 
 // Evict stale LTTB cache entries for a plot (call when zoom range changes).
@@ -938,7 +1003,7 @@ function lttbCacheEvict(plotId) {
   for (const k of [...lttbCache.keys()]) {
     if (k.startsWith(prefix)) lttbCache.delete(k);
   }
-  for (const k of [...lttbPending]) {
+  for (const k of [...lttbPending.keys()]) {
     if (k.startsWith(prefix)) lttbPending.delete(k);
   }
 }
@@ -1447,6 +1512,51 @@ function drawCursorLines(u, p) {
   drawLine(cursors.tB, 'rgba(249,226,175,0.85)', 'B');
 }
 
+// Convert a normalized (division) y value to the active signal's raw units.
+function rulerRawValue(p, yNorm) {
+  const key = plotActiveSignal[p.id] || (p.traces.length === 1 ? p.traces[0] : null);
+  const vs = key ? sigVScale[p.id + ':' + key] : null;
+  if (!vs) return null;
+  const dv = vs._resolvedDiv != null ? vs._resolvedDiv : (vs.divValue || 1);
+  const ofs = vs._resolvedOffset != null ? vs._resolvedOffset : (vs.offset || 0);
+  return (yNorm - (vs.screenPos || 0)) * dv + ofs;
+}
+
+// Draw the horizontal value rulers (called from the draw hook).
+function drawRulerLines(u, p) {
+  if (rulers.mode !== 'on') return;
+  const { ctx, bbox } = u;
+  if (!bbox) return;
+
+  const drawLine = (yNorm, color, label) => {
+    if (yNorm === null) return;
+    const y = Math.round(u.valToPos(yNorm, 'y', true));
+    if (y < bbox.top || y > bbox.top + bbox.height) return;
+    ctx.save();
+    ctx.beginPath();
+    ctx.rect(bbox.left, bbox.top, bbox.width, bbox.height);
+    ctx.clip();
+    ctx.strokeStyle = color;
+    ctx.lineWidth = 1.5;
+    ctx.setLineDash([5, 4]);
+    ctx.beginPath();
+    ctx.moveTo(bbox.left, y);
+    ctx.lineTo(bbox.left + bbox.width, y);
+    ctx.stroke();
+    ctx.setLineDash([]);
+    ctx.fillStyle = color;
+    ctx.font = 'bold 11px monospace';
+    ctx.textAlign = 'left';
+    ctx.textBaseline = 'bottom';
+    const raw = p ? rulerRawValue(p, yNorm) : null;
+    ctx.fillText(label + (raw !== null ? ' ' + _fmtVal(raw) : ''), bbox.left + 4, y - 2);
+    ctx.restore();
+  };
+
+  drawLine(rulers.yA, 'rgba(166,227,161,0.85)', 'Y1');
+  drawLine(rulers.yB, 'rgba(243,139,168,0.85)', 'Y2');
+}
+
 // Compute the rolling-window anchor ("newest common timestamp") for a plot.
 // Returns the min-of-max timestamp across ACTIVE sources contributing traces to p,
 // so no live source shows a blank right edge.
@@ -1563,7 +1673,7 @@ function makeUPlotOpts(p, inTrigMode) {
     legend: { show: false },
     padding: [4, 4, 0, 0],
     hooks: {
-      draw: [u => { drawBandSeparators(u, p); drawActiveSeries(u, p); drawOffsetMarkers(u, p); drawCursorLines(u, p); drawSeriesMarkers(u, p); drawTriggerMarker(u, p); }],
+      draw: [u => { drawBandSeparators(u, p); drawActiveSeries(u, p); drawOffsetMarkers(u, p); drawCursorLines(u, p); drawRulerLines(u, p); drawSeriesMarkers(u, p); drawTriggerMarker(u, p); }],
       // Two-hook zoom detection: setSelect flags that the NEXT setScale is user-initiated.
       // uPlot fires setSelect → then immediately setScale (when drag.setScale:true).
       // All programmatic setScale calls happen without a preceding setSelect, so the
@@ -1617,34 +1727,60 @@ function createUPlot(p) {
     return min + pct * (max - min);
   }
 
-  // Update pointer style based on what's under the mouse
+  function _rulerAtClientY(clientY) {
+    const rect = p.uplot.over.getBoundingClientRect();
+    const { min, max } = p.uplot.scales.y;
+    const toY = val => rect.top + (1 - (val - min) / (max - min)) * rect.height;
+    if (rulers.yA !== null && Math.abs(clientY - toY(rulers.yA)) <= CURSOR_SNAP_PX) return 'A';
+    if (rulers.yB !== null && Math.abs(clientY - toY(rulers.yB)) <= CURSOR_SNAP_PX) return 'B';
+    return null;
+  }
+
+  function _rulerValFromEvent(e) {
+    const rect = p.uplot.over.getBoundingClientRect();
+    const pct = Math.max(0, Math.min(1, (e.clientY - rect.top) / rect.height));
+    const { min, max } = p.uplot.scales.y;
+    return max - pct * (max - min);
+  }
+
+  // Update pointer style based on what's under the mouse, and drive the
+  // time/value hover readout.
   p.uplot.over.addEventListener('mousemove', e => {
-    const snap = cursors.mode === 'on' ? _cursorAtClientX(e.clientX) : null;
+    const snapX = cursors.mode === 'on' ? _cursorAtClientX(e.clientX) : null;
-    p.uplot.over.style.cursor = snap ? 'ew-resize' : '';
+    const snapY = !snapX && rulers.mode === 'on' ? _rulerAtClientY(e.clientY) : null;
+    p.uplot.over.style.cursor = snapX ? 'ew-resize' : (snapY ? 'ns-resize' : '');
+    showHoverReadout(p, e);
   });
   p.uplot.over.addEventListener('mouseleave', () => {
     p.uplot.over.style.cursor = '';
+    hideHoverReadout();
   });
 
   // Mousedown: drag an existing cursor (only when mode='on' and mouse is near a cursor line).
   // If not near a cursor, the event falls through to uPlot for normal zoom/pan behavior.
   p.uplot.over.addEventListener('mousedown', e => {
     if (e.button !== 0 || e.shiftKey) return; // shift is pan
-    if (cursors.mode !== 'on') return;
+    const target = cursors.mode === 'on' ? _cursorAtClientX(e.clientX) : null;
-    const target = _cursorAtClientX(e.clientX);
+    const yTarget = !target && rulers.mode === 'on' ? _rulerAtClientY(e.clientY) : null;
-    if (!target) return; // not near a cursor — let uPlot handle zoom
+    if (!target && !yTarget) return; // not near a cursor — let uPlot handle zoom
 
     e.stopImmediatePropagation(); // prevent uPlot drag-zoom
     e.preventDefault();
 
     // Set cursor position immediately on mousedown
-    if (target === 'A') cursors.tA = _cursorValFromEvent(e);
+    if (yTarget) {
+      if (yTarget === 'A') rulers.yA = _rulerValFromEvent(e);
+      else rulers.yB = _rulerValFromEvent(e);
+    } else if (target === 'A') cursors.tA = _cursorValFromEvent(e);
     else cursors.tB = _cursorValFromEvent(e);
     updateCursorReadout();
     cursorsDirty = true;
 
     const onMove = ev => {
-      if (target === 'A') cursors.tA = _cursorValFromEvent(ev);
+      if (yTarget) {
+        if (yTarget === 'A') rulers.yA = _rulerValFromEvent(ev);
+        else rulers.yB = _rulerValFromEvent(ev);
+      } else if (target === 'A') cursors.tA = _cursorValFromEvent(ev);
       else cursors.tB = _cursorValFromEvent(ev);
       updateCursorReadout();
       cursorsDirty = true;
@@ -1871,10 +2007,12 @@ function buildLiveData(p) {
   // the full window slice can easily reach 100k–300k pts — far more than uPlot
   // needs for a 1200px-wide canvas.  Always run LTTB via the background worker
   // (stale-while-revalidate: use cached result; fall back to sync on first render).
-  // Rolling-mode cache key uses _dataGen so the result refreshes on new data.
+  // The rolling-mode key is constant per (plot, signal) — the data generation is
+  // carried separately so the cache holds one entry per plot instead of one per
+  // push tick, which used to grow without bound for the whole session.
   const targetPts = Math.max(LTTB_MIN, ((p.uplot ? p.uplot.width : p.div.clientWidth) || 600) * 2);
   const cacheKey = isRolling
-    ? `${p.id}:${masterKey}:rolling:${_dataGen}`
+    ? `${p.id}:${masterKey}:rolling`
     : `${p.id}:${masterKey}:${t0.toFixed(6)}:${t1.toFixed(6)}:${masterRaw.t.length}`;
   let sharedT, masterV;
   if (masterRaw.t.length <= targetPts) {
@@ -1882,7 +2020,8 @@ function buildLiveData(p) {
     sharedT = masterRaw.t;
     masterV = masterRaw.v;
   } else {
-    const cached = lttbAsync(cacheKey, masterRaw.t, masterRaw.v, targetPts);
+    const cached = lttbAsync(cacheKey, masterRaw.t, masterRaw.v, targetPts,
+                             isRolling ? _dataGen : undefined);
     let dec;
     if (cached) {
       dec = cached;
@@ -2094,19 +2233,10 @@ document.getElementById('btn-zoom-fit').addEventListener('click', zoomFit);
 /* ════════════════════════════════════════════════════════════════
    Cursor controls
    ════════════════════════════════════════════════════════════════ */
-// Show the cursor button only when paused or in trigger-snapshot mode.
+// Cursors are always available — in live rolling mode they are pinned to the
+// moving viewport by the render loop.
 function updateCursorBtnVisibility() {
-  const canUseCursors = globalPause || (trig.enabled && trig.snapshot !== null);
+  document.getElementById('btn-cursor').style.display = '';
-  const btn = document.getElementById('btn-cursor');
-  btn.style.display = canUseCursors ? '' : 'none';
-  if (!canUseCursors && cursors.mode !== 'off') {
-    cursors.mode = 'off';
-    cursors.tA = null; cursors.tB = null; // context changed, clear positions
-    btn.textContent = 'Cursors';
-    btn.classList.remove('active');
-    document.getElementById('cursor-readout').classList.remove('visible');
-    cursorsDirty = true;
-  }
 }
 
 document.getElementById('btn-cursor').addEventListener('click', () => {
@@ -2133,6 +2263,18 @@ document.getElementById('btn-cursor').addEventListener('click', () => {
   cursorsDirty = true;
 });
 
+document.getElementById('btn-ruler').addEventListener('click', () => {
+  rulers.mode = rulers.mode === 'off' ? 'on' : 'off';
+  const btn = document.getElementById('btn-ruler');
+  btn.classList.toggle('active', rulers.mode === 'on');
+  if (rulers.mode === 'on' && rulers.yA === null && rulers.yB === null) {
+    // Auto-place at ±2 divisions from the centre on first use.
+    rulers.yA = -2; rulers.yB = 2;
+  }
+  updateCursorReadout();
+  cursorsDirty = true;
+});
+
 // Format a signal value for the per-plot cursor readout.
 function fmtVal(v) {
   if (v === null || v === undefined) return '—';
@@ -2178,11 +2320,80 @@ function updatePlotCursorReadouts() {
   });
 }
 
+/* ─── Hover readout ──────────────────────────────────────────────────────── */
+// Un-normalize a plotted value of trace `key` in plot `p` back to raw units.
+function rawFromNorm(p, key, vNorm) {
+  const vs = sigVScale[p.id + ':' + key];
+  if (!vs) return vNorm;
+  const dv = vs._resolvedDiv != null ? vs._resolvedDiv : (vs.divValue || 1);
+  const ofs = vs._resolvedOffset != null ? vs._resolvedOffset : (vs.offset || 0);
+  return (vNorm - (vs.screenPos || 0)) * dv + ofs;
+}
+
+function hideHoverReadout() {
+  document.getElementById('hover-readout').style.display = 'none';
+}
+
+// Show the time under the mouse plus every trace's value at that time.
+function showHoverReadout(p, e) {
+  const el = document.getElementById('hover-readout');
+  if (!p.uplot || p.traces.length === 0) { el.style.display = 'none'; return; }
+
+  const rect = p.uplot.over.getBoundingClientRect();
+  const { min, max } = p.uplot.scales.x;
+  const pct = Math.max(0, Math.min(1, (e.clientX - rect.left) / rect.width));
+  const t = min + pct * (max - min);
+  const span = Math.abs(max - min);
+
+  const tStr = (trig.enabled && trig.snapshot) ? fmtDuration(t, span, true) : fmtLiveTime(t, span);
+  let html = '<div class="hov-time">' + escHtml(tStr) + '</div>';
+  p.traces.forEach((key, idx) => {
+    const vNorm = interpAtTime(p.uplot, idx + 1, t);
+    const name = key.includes(':') ? key.slice(key.indexOf(':') + 1) : key;
+    const val = vNorm === null ? '—' : _fmtVal(rawFromNorm(p, key, vNorm));
+    html += '<div class="hov-row"><span class="hov-dot" style="background:' +
+      escHtml(getSigStyle(key).color) + '"></span>' +
+      '<span class="hov-name">' + escHtml(name) + '</span>' +
+      '<span class="hov-val">' + escHtml(val) + '</span></div>';
+  });
+  el.innerHTML = html;
+  el.style.display = 'block';
+
+  // Keep the tooltip inside the viewport.
+  const w = el.offsetWidth, h = el.offsetHeight;
+  let x = e.clientX + 14, y = e.clientY + 14;
+  if (x + w > window.innerWidth - 4) x = e.clientX - w - 14;
+  if (y + h > window.innerHeight - 4) y = e.clientY - h - 14;
+  el.style.left = Math.max(4, x) + 'px';
+  el.style.top = Math.max(4, y) + 'px';
+}
+
+// Update the Y1/Y2/ΔY ruler readout, expressed in the raw units of the first
+// plot that has an active (or sole) signal.
+function updateRulerReadout() {
+  const box = document.getElementById('ruler-readout');
+  const on = rulers.mode === 'on';
+  box.style.display = on ? '' : 'none';
+  if (!on) return;
+  const ref = plots.find(p => p.uplot && p.traces.length > 0 &&
+                              rulerRawValue(p, 0) !== null);
+  const conv = y => (y === null || !ref) ? null : rulerRawValue(ref, y);
+  const vA = conv(rulers.yA), vB = conv(rulers.yB);
+  document.getElementById('cur-y1').textContent = 'Y1: ' + fmtVal(vA);
+  document.getElementById('cur-y2').textContent = 'Y2: ' + fmtVal(vB);
+  document.getElementById('cur-dy').textContent =
+    'ΔY: ' + fmtVal(vA !== null && vB !== null ? vB - vA : null);
+}
+
 function updateCursorReadout() {
   const ro = document.getElementById('cursor-readout');
   const active = cursors.mode === 'on';
-  ro.classList.toggle('visible', active);
+  ro.classList.toggle('visible', active || rulers.mode === 'on');
   updatePlotCursorReadouts();
+  updateRulerReadout();
+  ['cur-ta', 'cur-tb', 'cur-dt'].forEach(id => {
+    document.getElementById(id).style.display = active ? '' : 'none';
+  });
   if (!active) return;
 
   // Use the current visible x-range to pick the display unit.
@@ -2286,6 +2497,12 @@ document.getElementById('trig-mode').addEventListener('change', e => {
   }
 });
 document.getElementById('btn-trig-rearm').addEventListener('click', () => { if (trig.enabled) trigArm(); });
+// Force: capture the window around the newest sample regardless of the threshold.
+document.getElementById('btn-trig-force').addEventListener('click', () => {
+  if (!trig.enabled || !trig.signal) return;
+  sendTrigConfig();
+  wsSend({ type: 'forceTrigger' });
+});
 document.getElementById('btn-trig-stop').addEventListener('click', () => {
   if (!trig.enabled || trig.mode !== 'normal') return;
   trig.stopped = !trig.stopped;
@@ -2943,6 +3160,22 @@ function renderDirtyPlots() {
     });
   }
 
+  // Live rolling mode: pin the cursors to the moving viewport so they stay put
+  // on screen instead of scrolling off the left edge as time advances.
+  if (cursors.mode === 'on' && !trig.enabled && !globalPause &&
+      plots.some(p => p.uplot && !p.xRange && p.traces.length > 0)) {
+    if (_cursorAnchorNow !== null && globalPlotNow !== _cursorAnchorNow) {
+      const shift = globalPlotNow - _cursorAnchorNow;
+      if (cursors.tA !== null) cursors.tA += shift;
+      if (cursors.tB !== null) cursors.tB += shift;
+      cursorsDirty = true;
+      updateCursorReadout();
+    }
+    _cursorAnchorNow = globalPlotNow;
+  } else {
+    _cursorAnchorNow = null;
+  }
+
   // Fast path: cursor-only redraw (no data rebuild needed)
   if (cursorsDirty) {
     cursorsDirty = false;
@@ -3204,11 +3437,15 @@ function showVScaleMenu(key, plotId) {
 
   const isManual = vs.mode === 'manual';
   document.getElementById('vscale-manual-row').style.display = isManual ? 'flex' : 'none';
+  document.getElementById('vscale-offset-row').style.display = isManual ? 'flex' : 'none';
   document.getElementById('vscale-pos-row').style.display = isManual ? 'flex' : 'none';
 
-  // Pre-fill V/div with resolved or stored value; Position always shows current screenPos.
+  // Pre-fill V/div and Offset with the resolved or stored values; Position
+  // always shows the current screenPos.
   const dv = isManual ? vs.divValue : (vs._resolvedDiv || 1);
+  const ofs = isManual ? (vs.offset || 0) : (vs._resolvedOffset || 0);
   document.getElementById('vscale-vdiv').value = dv != null ? parseFloat(dv.toPrecision(4)) : 1;
+  document.getElementById('vscale-offset').value = parseFloat(ofs.toPrecision(6));
   document.getElementById('vscale-pos').value = parseFloat((vs.screenPos || 0).toPrecision(4));
 
   // Type row (Analog/Digital) only shown in mixed mode.
@@ -3293,8 +3530,9 @@ function initVScaleMenu() {
       if (newMode === 'manual' && vs.mode !== 'manual') {
         // Seed V/div from currently resolved value; screenPos stays as-is.
         vs.divValue = vs._resolvedDiv || 1;
-        vs.offset = vs._resolvedOffset || 0; // keep for DC subtraction (internal)
+        vs.offset = vs._resolvedOffset || 0; // raw value at screen centre
         document.getElementById('vscale-vdiv').value = parseFloat(vs.divValue.toPrecision(4));
+        document.getElementById('vscale-offset').value = parseFloat(vs.offset.toPrecision(6));
         document.getElementById('vscale-pos').value = parseFloat((vs.screenPos || 0).toPrecision(4));
       }
       vs.mode = newMode;
@@ -3302,6 +3540,7 @@ function initVScaleMenu() {
       btn.classList.add('active');
       const isManual = vs.mode === 'manual';
       document.getElementById('vscale-manual-row').style.display = isManual ? 'flex' : 'none';
+      document.getElementById('vscale-offset-row').style.display = isManual ? 'flex' : 'none';
       document.getElementById('vscale-pos-row').style.display = isManual ? 'flex' : 'none';
       refreshPlotForKey(_vsMenuKey);
     });
@@ -3312,6 +3551,16 @@ function initVScaleMenu() {
     vs.divValue = Math.max(parseFloat(e.target.value) || 1, 1e-30);
     refreshPlotForKey(_vsMenuKey);
   });
+  // "Offset" is the raw value shown at screen centre.  Unlike Position (which
+  // is clamped to the ±4 visible divisions) it is unbounded, so a signal can be
+  // referenced to a level far outside the currently plotted range.
+  document.getElementById('vscale-offset').addEventListener('input', e => {
+    if (!_vsMenuKey) return;
+    const vs = getVScale(_vsMenuPlotId, _vsMenuKey);
+    const v = parseFloat(e.target.value);
+    vs.offset = isFinite(v) ? v : 0;
+    refreshPlotForKey(_vsMenuKey);
+  });
   // "Position (div)" moves the marker and signal together on screen.
   document.getElementById('vscale-pos').addEventListener('input', e => {
     if (!_vsMenuKey) return;
@@ -3465,7 +3714,7 @@ function _fmtHz(v) { return v != null && isFinite(v) && v > 0 ? v.toFixed(2) + '
 function _fmtKB(v) { return v != null && isFinite(v) ? (v / 1024).toFixed(2) + ' KB' : '—'; }
 
 function _statsKV(label, value, cls) {
-  return `<div class="stats-kv"><span class="stats-k">${label}</span><span class="stats-v${cls ? ' ' + cls : ''}">${value}</span></div>`;
+  return `<div class="stats-kv"><span class="stats-k">${escHtml(label)}</span><span class="stats-v${cls ? ' ' + cls : ''}">${escHtml(value)}</span></div>`;
 }
 
 function _histHTML(si) {
@@ -3551,6 +3800,11 @@ buildSidebar();   // show "Add Source" section even before WS connection
 initArrayIdxPicker();
 initVScaleMenu();
 initSignalMenu();
+// Restore monotonic TS checkbox from localStorage (visual state before WS reply).
+{
+  const cb = document.getElementById('cb-monotonic');
+  if (cb) cb.checked = localStorage.getItem('udpscope.monotonic') === '1';
+}
 document.getElementById('btn-csv-all').addEventListener('click', exportAllCSV);
 document.getElementById('btn-stats').addEventListener('click', toggleStats);
 document.getElementById('btn-stats-close').addEventListener('click', toggleStats);

Client/udpstreamer/static/index.html

@@ -21,6 +21,12 @@
         <span id="cur-ta">A: —</span><span class="cur-sep">│</span>
         <span id="cur-tb">B: —</span><span class="cur-sep">│</span>
         <span id="cur-dt">ΔT: —</span>
+        <span id="ruler-readout" style="display:none">
+          <span class="cur-sep">│</span>
+          <span id="cur-y1">Y1: —</span><span class="cur-sep">│</span>
+          <span id="cur-y2">Y2: —</span><span class="cur-sep">│</span>
+          <span id="cur-dy">ΔY: —</span>
+        </span>
       </div>
       <span class="ctrl-label" id="lbl-window">Window:</span>
       <select id="window-select" class="ctrl-select">
@@ -28,13 +34,17 @@
         <option value="10">10 s</option><option value="30">30 s</option>
         <option value="60">60 s</option>
       </select>
-      <button id="btn-cursor" class="ctrl-btn" style="display:none">Cursor</button>
+      <button id="btn-cursor" class="ctrl-btn">Cursors</button>
+      <button id="btn-ruler" class="ctrl-btn" title="Horizontal value rulers">Rulers</button>
       <button id="btn-zoom-back" class="ctrl-btn" style="display:none">← Back</button>
       <button id="btn-zoom-fit" class="ctrl-btn">Fit</button>
       <button id="btn-csv-all" class="ctrl-btn" title="Export all signals to CSV">⬇ CSV</button>
       <button id="btn-sync-resume" class="ctrl-btn resume-btn" style="display:none">↺ Auto</button>
       <button id="btn-trigger" class="ctrl-btn">⚡ Trigger</button>
       <button id="btn-pause-global" class="ctrl-btn">⏸ Pause</button>
+      <label class="ctrl-check" title="Snap jittery inter-frame timestamps to ideal spacing (eliminates overlaps/gaps from software-dispatch jitter)">
+        <input type="checkbox" id="cb-monotonic"> Sync TS
+      </label>
     </div>
     <!-- ── Trigger bar ───────────────────────────────────────────── -->
     <div id="trigbar">
@@ -83,6 +93,7 @@
       <div class="trig-sep"></div>
       <div class="trig-group" style="gap:8px">
         <span id="trig-status-badge">IDLE</span>
+        <button id="btn-trig-force" title="Capture now, ignoring the threshold">Force</button>
         <button id="btn-trig-stop" style="display:none">Stop</button>
         <button id="btn-trig-rearm">Rearm</button>
       </div>
@@ -185,6 +196,10 @@
           <label class="vstb-lbl">V/div</label>
           <input type="number" id="vscale-vdiv" class="ctx-num" min="1e-30" step="any" value="1">
         </div>
+        <div id="vscale-offset-row" style="display:none;align-items:center;gap:4px">
+          <label class="vstb-lbl" title="Raw value at screen centre — unbounded, may lie outside the plotted range">Offset</label>
+          <input type="number" id="vscale-offset" class="ctx-num" step="any" value="0">
+        </div>
         <div id="vscale-pos-row" style="display:none;align-items:center;gap:4px">
           <label class="vstb-lbl">Pos</label>
           <input type="number" id="vscale-pos" class="ctx-num" step="0.1" value="0">
@@ -199,6 +214,8 @@
         <button id="btn-vscale-close" class="vstb-close" title="Close">✕</button>
       </div>
     </div>
+    <!-- Follows the mouse over a plot: time + per-trace values. -->
+    <div id="hover-readout" style="display:none"></div>
     <script src="/app.js"></script>
   </body>
 </html>

Client/udpstreamer/static/style.css

@@ -52,6 +52,23 @@ html, body { height:100%; background:var(--bg); color:var(--text);
 #cursor-readout.visible { display:flex; }
 #cur-ta { color:var(--sky); } #cur-tb { color:var(--yellow); }
 #cur-dt { color:var(--subtext1); } .cur-sep { color:var(--surface2); }
+#ruler-readout { display:inline-flex; align-items:center; gap:8px; }
+#cur-y1 { color:var(--green); } #cur-y2 { color:var(--red); }
+#cur-dy { color:var(--subtext1); }
+
+/* Mouse-over time/value tooltip */
+#hover-readout {
+  position:fixed; z-index:60; pointer-events:none;
+  background:var(--surface0); border:1px solid var(--surface1);
+  border-radius:5px; padding:4px 8px;
+  font-size:11px; font-family:monospace; white-space:nowrap;
+  box-shadow:0 4px 12px rgba(0,0,0,0.45);
+}
+#hover-readout .hov-time { color:var(--subtext1); margin-bottom:3px; }
+#hover-readout .hov-row  { display:flex; align-items:center; gap:6px; }
+#hover-readout .hov-dot  { width:8px; height:8px; border-radius:50%; flex-shrink:0; }
+#hover-readout .hov-name { color:var(--subtext0); }
+#hover-readout .hov-val  { color:var(--text); margin-left:auto; padding-left:10px; }
 
 .topbar-vsep { width:1px; height:22px; background:var(--surface0); flex-shrink:0; margin:0 2px; }
 #layout-btns { display:flex; gap:2px; align-items:center; flex-shrink:0; }
@@ -74,6 +91,12 @@ button.ctrl-btn.trig-active { background:rgba(203,166,247,0.15); border-color:va
 button.ctrl-btn.cursor-a    { border-color:var(--sky);   color:var(--sky); }
 button.ctrl-btn.cursor-b    { border-color:var(--yellow); color:var(--yellow); }
 button.ctrl-btn.resume-btn  { border-color:var(--teal);  color:var(--teal); }
+label.ctrl-check {
+  display:flex; align-items:center; gap:4px; flex-shrink:0;
+  font-size:12px; color:var(--subtext0); cursor:pointer; white-space:nowrap;
+}
+label.ctrl-check input { margin:0; cursor:pointer; accent-color:var(--accent); }
+label.ctrl-check:has(input:checked) { color:var(--accent); }
 
 /* ── Trigger bar ──────────────────────────────────────────────── */
 #trigbar {

Common/Client/go/udpsprotocol/protocol.go

@@ -99,6 +99,20 @@ func BuildDisconnectPacket() []byte {
 	})
 }
 
+// BuildAckPacket returns a 17-byte ACK datagram. Unicast clients send it
+// periodically as a keepalive: UDPSServer refreshes the client's last-seen
+// without re-sending CONFIG (which a repeated CONNECT would trigger).
+func BuildAckPacket() []byte {
+	return buildHeader(PacketHeader{
+		Magic:          MagicUDPS,
+		Type:           PktACK,
+		Counter:        0,
+		FragmentIdx:    0,
+		TotalFragments: 1,
+		PayloadBytes:   0,
+	})
+}
+
 // ─── Signal descriptor (136 bytes) ───────────────────────────────────────────
 
 // SignalInfo holds the parsed metadata for one signal.
@@ -127,7 +141,12 @@ func (s SignalInfo) NumElements() int {
 	if c == 0 {
 		c = 1
 	}
-	return r * c
+	/* HI-2: cap at 1M to prevent integer overflow / OOM from crafted packets */
+	n := r * c
+	if n < 0 || n > 1024*1024 {
+		return 1024 * 1024
+	}
+	return n
 }
 
 // rawTypeSize returns the byte size for one element of the raw (unquantised) type.
@@ -227,6 +246,11 @@ func ParseConfig(payload []byte) ([]SignalInfo, uint8, error) {
 		return nil, 0, fmt.Errorf("config payload too short")
 	}
 	numSigs := binary.LittleEndian.Uint32(payload[0:4])
+	/* HI-2: validate numSigs against payload length before allocating */
+	maxSigs := uint32(len(payload) / SigDescSize)
+	if numSigs > maxSigs {
+		return nil, 0, fmt.Errorf("config claims %d signals but payload can hold at most %d", numSigs, maxSigs)
+	}
 	offset := 4
 	sigs := make([]SignalInfo, 0, numSigs)
 	for i := uint32(0); i < numSigs; i++ {
@@ -327,6 +351,10 @@ func ParseData(payload []byte, sigs []SignalInfo, publishMode uint8, arrivalTime
 		if numSamples == 0 {
 			return []DataSample{}, nil
 		}
+		/* HI-2: sanity-cap numSamples to prevent OOM from crafted packets */
+		if numSamples < 0 || numSamples > 1024*1024 {
+			return nil, fmt.Errorf("accumulate numSamples %d out of range", numSamples)
+		}
 
 		// Parse per-signal data blocks (all slots for a signal are contiguous).
 		accumVals := make(map[string][]float64, len(sigs)) // scalars: numSamples values

Common/Client/go/udpsprotocol/protocol_test.go

@@ -0,0 +1,97 @@
+package udpsprotocol
+
+import (
+	"encoding/binary"
+	"math"
+	"testing"
+	"time"
+)
+
+// TestParseConfig_HugeNumSigs_NoOOM — a CONFIG payload claiming 0xFFFFFFFF signals
+// must return an error, not panic/OOM.
+func TestParseConfig_HugeNumSigs_NoOOM(t *testing.T) {
+	// 4 bytes: numSigs = 0xFFFFFFFF, then nothing else
+	payload := make([]byte, 4)
+	binary.LittleEndian.PutUint32(payload[0:4], 0xFFFFFFFF)
+	sigs, _, err := ParseConfig(payload)
+	if err == nil {
+		t.Fatal("expected error for huge numSigs, got nil")
+	}
+	if sigs != nil {
+		t.Fatalf("expected nil sigs, got %d", len(sigs))
+	}
+}
+
+// TestParseConfig_ValidSmallConfig — a minimal valid CONFIG parses correctly.
+func TestParseConfig_ValidSmallConfig(t *testing.T) {
+	// 1 signal, then publish mode
+	payload := make([]byte, 4+SigDescSize+1)
+	binary.LittleEndian.PutUint32(payload[0:4], 1)
+	// Set typeCode to float32 (8) at offset 64
+	payload[4+64] = 8
+	// numRows=1, numCols=1 at offsets 67, 71
+	binary.LittleEndian.PutUint32(payload[4+67:4+71], 1)
+	binary.LittleEndian.PutUint32(payload[4+71:4+75], 1)
+	// publish mode = 0 (Strict)
+	payload[4+SigDescSize] = 0
+	sigs, pm, err := ParseConfig(payload)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(sigs) != 1 {
+		t.Fatalf("expected 1 signal, got %d", len(sigs))
+	}
+	if pm != PublishModeStrict {
+		t.Fatalf("expected Strict mode, got %d", pm)
+	}
+}
+
+// TestNumElements_OverflowCapped — huge numRows*numCols is capped, no panic.
+func TestNumElements_OverflowCapped(t *testing.T) {
+	s := SignalInfo{NumRows: 0xFFFFFFFF, NumCols: 0xFFFFFFFF}
+	n := s.NumElements()
+	if n <= 0 || n > 1024*1024 {
+		t.Fatalf("expected capped value 1M, got %d", n)
+	}
+}
+
+// TestNumElements_Normal — normal values work correctly.
+func TestNumElements_Normal(t *testing.T) {
+	s := SignalInfo{NumRows: 3, NumCols: 4}
+	if n := s.NumElements(); n != 12 {
+		t.Fatalf("expected 12, got %d", n)
+	}
+}
+
+// TestParseData_HugeNumSamples_NoOOM — an Accumulate DATA packet with
+// numSamples=0xFFFFFFFF must return an error, not OOM.
+func TestParseData_HugeNumSamples_NoOOM(t *testing.T) {
+	sigs := []SignalInfo{
+		{Name: "test", TypeCode: 8, NumRows: 1, NumCols: 1, QuantType: QuantNone},
+	}
+	payload := make([]byte, 12)
+	binary.LittleEndian.PutUint64(payload[0:8], 0) // HRT
+	binary.LittleEndian.PutUint32(payload[8:12], 0xFFFFFFFF)
+	_, err := ParseData(payload, sigs, PublishModeAccumulate, time.Now())
+	if err == nil {
+		t.Fatal("expected error for huge numSamples, got nil")
+	}
+}
+
+// TestParseData_ValidStrict — a valid Strict DATA packet parses without error.
+func TestParseData_ValidStrict(t *testing.T) {
+	sigs := []SignalInfo{
+		{Name: "test", TypeCode: 8, NumRows: 1, NumCols: 1, QuantType: QuantNone},
+	}
+	// 8 HRT + 4 bytes float32
+	payload := make([]byte, 12)
+	binary.LittleEndian.PutUint64(payload[0:8], 1000)
+	binary.LittleEndian.PutUint32(payload[8:12], math.Float32bits(3.14))
+	samples, err := ParseData(payload, sigs, PublishModeStrict, time.Now())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(samples) != 1 {
+		t.Fatalf("expected 1 sample, got %d", len(samples))
+	}
+}

Common/Client/go/wshub/hub.go

@@ -107,7 +107,18 @@ func (c *wsClient) readPump() {
 					case c.hub.commandCh <- hubCmd{op: "wsSaveSources"}:
 					default:
 					}
+				case "setMonotonic":
+					enabled, _ := env["enabled"].(bool)
+					select {
+					case c.hub.commandCh <- hubCmd{op: "setMonotonic", enabled: enabled}:
+					default:
+					}
+				case "zoom":
+					c.hub.handleWSZoom(c, env)
 				default:
+					if c.hub.handleTriggerCommand(t, env) {
+						break
+					}
 					// Unrecognized message type — forward to DebugCh
 					select {
 					case c.hub.DebugCh <- msg:
@@ -122,10 +133,48 @@ func (c *wsClient) readPump() {
 
 // ─── Hub ─────────────────────────────────────────────────────────────────────
 
+// allowedOrigins is the set of Origin values (scheme://host[:port]) that are
+// accepted for WebSocket upgrades.  If empty, same-origin is enforced by
+// comparing the Origin's host to the HTTP Host header.
+var allowedOrigins []string
+
+// SetAllowedOrigins configures the WebSocket Origin allowlist.  Pass an empty
+// slice to enforce same-origin only (the default).
+func SetAllowedOrigins(origins []string) {
+	allowedOrigins = origins
+}
+
+// checkOrigin validates the Origin header against the allowlist, falling back
+// to a same-origin check (Origin host == Host header) when no allowlist is
+// configured.  Requests with no Origin header (non-browser clients) are allowed.
+func checkOrigin(r *http.Request) bool {
+	origin := r.Header.Get("Origin")
+	if origin == "" {
+		return true // non-browser client
+	}
+	// Check explicit allowlist first.
+	for _, allowed := range allowedOrigins {
+		if origin == allowed {
+			return true
+		}
+	}
+	// Fall back to same-origin: compare the Origin's host to the Host header.
+	// Origin format: "scheme://host[:port]" — strip scheme.
+	host := origin
+	if idx := strings.Index(host, "://"); idx >= 0 {
+		host = host[idx+3:]
+	}
+	// Strip path if present.
+	if idx := strings.Index(host, "/"); idx >= 0 {
+		host = host[:idx]
+	}
+	return host == r.Host
+}
+
 var upgrader = websocket.Upgrader{
 	ReadBufferSize:  4096,
 	WriteBufferSize: 64 * 1024,
-	CheckOrigin:     func(r *http.Request) bool { return true },
+	CheckOrigin:     checkOrigin,
 }
 
 // sourceHubState holds all data for one active data source.
@@ -144,6 +193,14 @@ type sourceHubState struct {
 	// per signal name.  Used by the default (TimeModePacket, n>1) path to estimate
 	// per-element dt when only one packet arrives in a 30 Hz tick.
 	lastPktNs map[string]int64
+
+	// Monotonic timestamp snapping state (all accessed from Run() goroutine):
+	// lastFrameMeasured — uncorrected measured anchor of the previous frame.
+	// lastFrameEndT     — corrected anchor after snapping.
+	// gapEMA            — exponential moving average of the measured inter-frame gap.
+	lastFrameMeasured map[string]float64
+	lastFrameEndT     map[string]float64
+	gapEMA            map[string]float64
 }
 
 // taggedSample is a DataSample annotated with its source ID.
@@ -154,7 +211,7 @@ type taggedSample struct {
 
 // hubCmd carries a command to the Run() goroutine.
 type hubCmd struct {
-	op       string // "addSource","removeSource","setSourceState","updateConfig",
+	op string // "addSource","removeSource","setSourceState","updateConfig",
 	//                "wsAddSource","wsRemoveSource","wsSaveSources"
 	sourceID       string
 	label          string
@@ -163,6 +220,7 @@ type hubCmd struct {
 	sigs           []udpsprotocol.SignalInfo
 	multicastGroup string
 	dataPort       int
+	enabled        bool // "setMonotonic" toggle
 }
 
 // Hub is the central broker between UDP clients and WebSocket clients.
@@ -186,21 +244,17 @@ type Hub struct {
 	ringsMu sync.RWMutex
 	rings   map[string]*sigRing // "sourceId:signalKey" → ring
 
-	// lastZoomAt tracks the last time a zoom request was served.
-	// Ring buffer writes are skipped when no zoom has been requested
-	// in the last 10 s, saving substantial CPU on LTTB + ring writes.
-	lastZoomAt time.Time
-	zoomAtMu   sync.Mutex
-
 	statsMu  sync.RWMutex
 	statsMap map[string]*SourceStat
 
-	// onClientConnect, if set, is called each time a new WebSocket client
+	// trigger is the hub-side trigger FSM driving the oscilloscope capture mode.
-	// registers.  The callback receives a send function that delivers a message
+	trigger           *triggerEngine
-	// directly to that client.  It is invoked synchronously from Run(), so it
-	// must not block.
 	onClientConnectMu sync.RWMutex
 	onClientConnect   func(send func([]byte))
+
+	// monotonicTS, when true, snaps small inter-frame timestamp deviations
+	// (< monotonicTolerance) to the ideal gap to eliminate jitter.
+	monotonicTS bool
 }
 
 // NewHub creates an initialised Hub.
@@ -215,6 +269,7 @@ func NewHub() *Hub {
 		DebugCh:     make(chan []byte, 256),
 		rings:       make(map[string]*sigRing),
 		statsMap:    make(map[string]*SourceStat),
+		trigger:     newTriggerEngine(),
 	}
 }
 
@@ -240,44 +295,9 @@ func (h *Hub) getRing(key string) *sigRing {
 	return rb
 }
 
-// shouldWriteRing returns true if zoom was requested within the last 10 seconds.
+// zoomSlice extracts [t0, t1] from the full-resolution rings for the named
-func (h *Hub) shouldWriteRing() bool {
+// signals, decimating each to at most n points.
-	h.zoomAtMu.Lock()
+func (h *Hub) zoomSlice(t0, t1 float64, keys []string, n int) map[string]sigData {
-	ok := time.Since(h.lastZoomAt) < 10*time.Second
-	h.zoomAtMu.Unlock()
-	return ok
-}
-
-// HandleZoom serves GET /api/zoom?... It also records the access time
-// so the ring buffer knows zoom is active and worth populating.
-func (h *Hub) HandleZoom(w http.ResponseWriter, r *http.Request) {
-	q := r.URL.Query()
-	t0, err0 := strconv.ParseFloat(q.Get("t0"), 64)
-	t1, err1 := strconv.ParseFloat(q.Get("t1"), 64)
-	if err0 != nil || err1 != nil || t1 <= t0 {
-		http.Error(w, "invalid t0/t1", http.StatusBadRequest)
-		return
-	}
-	var n int
-	if nStr := q.Get("n"); nStr == "" {
-		n = 2400
-	} else {
-		n, _ = strconv.Atoi(nStr)
-		if n <= 0 {
-			n = 1 << 30 // no decimation
-		} else if n < 10 {
-			n = 2400
-		}
-	}
-
-	if n > 0 {
-		h.zoomAtMu.Lock()
-		h.lastZoomAt = time.Now()
-		h.zoomAtMu.Unlock()
-	}
-
-	keys := strings.Split(q.Get("signals"), ",")
-
 	h.ringsMu.RLock()
 	refs := make(map[string]*sigRing, len(keys))
 	for _, k := range keys {
@@ -300,11 +320,69 @@ func (h *Hub) HandleZoom(w http.ResponseWriter, r *http.Request) {
 		dt, dv := lttbDecimate(rt, rv, n)
 		result[k] = sigData{T: dt, V: dv}
 	}
+	return result
+}
+
+// zoomPoints normalises the client's requested point budget: absent → 2400,
+// non-positive → every sample in the range, implausibly small → 2400.
+func zoomPoints(n int, present bool) int {
+	switch {
+	case !present:
+		return 2400
+	case n <= 0:
+		return 1 << 30 // no decimation
+	case n < 10:
+		return 2400
+	}
+	return n
+}
+
+// handleWSZoom answers a browser {"type":"zoom","reqId":..,"t0":..,"t1":..,
+// "n":..,"signals":"a,b"} request, unicasting {"type":"zoom","reqId":..,
+// "signals":{...}} back to the requesting client.  This is the path the web SPA
+// actually uses; /api/zoom is the equivalent HTTP entry point.
+func (h *Hub) handleWSZoom(c *wsClient, env map[string]interface{}) {
+	t0, ok0 := env["t0"].(float64)
+	t1, ok1 := env["t1"].(float64)
+	if !ok0 || !ok1 || t1 <= t0 {
+		return
+	}
+	nF, nOK := env["n"].(float64)
+	n := zoomPoints(int(nF), nOK)
+	sigCSV, _ := env["signals"].(string)
+
+	reply, err := json.Marshal(map[string]any{
+		"type":    "zoom",
+		"reqId":   env["reqId"],
+		"signals": h.zoomSlice(t0, t1, strings.Split(sigCSV, ","), n),
+	})
+	if err != nil {
+		log.Printf("hub: ws zoom encode: %v", err)
+		return
+	}
+	select {
+	case c.send <- wsMessage{websocket.TextMessage, reply}:
+	default:
+	}
+}
+
+// HandleZoom serves GET /api/zoom?...
+func (h *Hub) HandleZoom(w http.ResponseWriter, r *http.Request) {
+	q := r.URL.Query()
+	t0, err0 := strconv.ParseFloat(q.Get("t0"), 64)
+	t1, err1 := strconv.ParseFloat(q.Get("t1"), 64)
+	if err0 != nil || err1 != nil || t1 <= t0 {
+		http.Error(w, "invalid t0/t1", http.StatusBadRequest)
+		return
+	}
+	nStr := q.Get("n")
+	nVal, _ := strconv.Atoi(nStr)
+	n := zoomPoints(nVal, nStr != "")
 
 	w.Header().Set("Content-Type", "application/json")
 	if err := json.NewEncoder(w).Encode(map[string]any{
 		"type":    "zoom",
-		"signals": result,
+		"signals": h.zoomSlice(t0, t1, strings.Split(q.Get("signals"), ","), n),
 	}); err != nil {
 		log.Printf("hub: zoom encode: %v", err)
 	}
@@ -417,13 +495,28 @@ func (h *Hub) Run() {
 			h.clients[c] = true
 			// Send current state to the new client.
 			if sourcesMsg != nil {
-				select { case c.send <- wsMessage{websocket.TextMessage, sourcesMsg}: default: }
+				select {
+				case c.send <- wsMessage{websocket.TextMessage, sourcesMsg}:
+				default:
+				}
 			}
 			for _, src := range sourcesMap {
 				if src.configJS != nil {
-					select { case c.send <- wsMessage{websocket.TextMessage, src.configJS}: default: }
+					select {
+					case c.send <- wsMessage{websocket.TextMessage, src.configJS}:
+					default:
+					}
 				}
 			}
+			select {
+			case c.send <- wsMessage{websocket.TextMessage, h.trigger.stateMsg()}:
+			default:
+			}
+			monoMsg, _ := json.Marshal(map[string]any{"type": "monotonicState", "enabled": h.monotonicTS})
+			select {
+			case c.send <- wsMessage{websocket.TextMessage, monoMsg}:
+			default:
+			}
 			// Notify the application layer so it can replay any persistent state
 			// (e.g., MARTe2 connection status, forced/traced signals).
 			h.onClientConnectMu.RLock()
@@ -431,7 +524,10 @@ func (h *Hub) Run() {
 			h.onClientConnectMu.RUnlock()
 			if fn != nil {
 				fn(func(msg []byte) {
-					select { case c.send <- wsMessage{websocket.TextMessage, msg}: default: }
+					select {
+					case c.send <- wsMessage{websocket.TextMessage, msg}:
+					default:
+					}
 				})
 			}
 
@@ -443,19 +539,25 @@ func (h *Hub) Run() {
 
 		case msg := <-h.broadcastCh:
 			for c := range h.clients {
-				select { case c.send <- wsMessage{websocket.TextMessage, msg}: default: }
+				select {
+				case c.send <- wsMessage{websocket.TextMessage, msg}:
+				default:
+				}
 			}
 
 		case cmd := <-h.commandCh:
 			switch cmd.op {
 			case "addSource":
 				sourcesMap[cmd.sourceID] = &sourceHubState{
-					id:           cmd.sourceID,
+					id:                cmd.sourceID,
-					label:        cmd.label,
+					label:             cmd.label,
-					addr:         cmd.addr,
+					addr:              cmd.addr,
-					connState:    "connecting",
+					connState:         "connecting",
-					timeSigCalib: make(map[string]float64),
+					timeSigCalib:      make(map[string]float64),
-					lastPktNs:    make(map[string]int64),
+					lastPktNs:         make(map[string]int64),
+					lastFrameEndT:     make(map[string]float64),
+					lastFrameMeasured: make(map[string]float64),
+					gapEMA:            make(map[string]float64),
 				}
 				h.statsMu.Lock()
 				h.statsMap[cmd.sourceID] = &SourceStat{}
@@ -491,6 +593,7 @@ func (h *Hub) Run() {
 				}
 				src.signals = cmd.sigs
 				src.configSeq++
+				src.lastFrameEndT = make(map[string]float64)
 				cfgMsg, err := json.Marshal(map[string]any{
 					"type":     "config",
 					"sourceId": cmd.sourceID,
@@ -543,6 +646,10 @@ func (h *Hub) Run() {
 						log.Printf("hub: save sources: %v", err)
 					}
 				}
+			case "setMonotonic":
+				h.monotonicTS = cmd.enabled
+				monoMsg, _ := json.Marshal(map[string]any{"type": "monotonicState", "enabled": h.monotonicTS})
+				h.broadcast(monoMsg)
 			}
 
 		case ts := <-h.dataCh:
@@ -569,6 +676,7 @@ func (h *Hub) Run() {
 					}
 				}
 			}
+			h.triggerTick()
 
 		case <-statsTicker.C:
 			h.statsMu.RLock()
@@ -602,11 +710,26 @@ func writeFloat64s(buf []byte, off int, f []float64) int {
 
 // ─── Data serialisation ───────────────────────────────────────────────────────
 
+// maxPushPoints bounds the live push only.  The zoom rings deliberately store
+// every sample: decimating on the way in would cap the resolution a zoom can
+// ever recover, and the browser already decimates for display.
 const maxPushPoints = 50
-const maxRingPoints = 20_000
+
+// Zoom ring depth, in samples per signal (16 bytes each).  ringCapTemporal
+// holds 6 s of a 1 MSps waveform; ringCapScalar holds 100 000 packets.
 const ringCapTemporal = 6_000_000
 const ringCapScalar = 100_000
 
+// monotonicTolerance is the maximum inter-frame timestamp deviation (seconds)
+// treated as jitter and snapped to the ideal gap.  Larger deviations are
+// preserved as genuine discontinuities (missing frames, rate changes).
+const monotonicTolerance = 0.005 // 5 ms
+
+// monotonicEMAAlpha is the smoothing factor for the inter-frame gap EMA.
+// 0.01 gives a time constant of ~100 frames (~1 s at 100 Hz): fast enough to
+// track real rate changes, slow enough to average out per-frame jitter.
+const monotonicEMAAlpha = 0.01
+
 // lttbDecimate reduces (tIn, vIn) to at most threshold representative points
 // using the Largest-Triangle-Three-Buckets algorithm.
 func lttbDecimate(tIn, vIn []float64, threshold int) ([]float64, []float64) {
@@ -629,10 +752,13 @@ func lttbDecimate(tIn, vIn []float64, threshold int) ([]float64, []float64) {
 		}
 		avgT, avgV, cnt := 0.0, 0.0, 0
 		for j := avgS; j < avgE; j++ {
-			avgT += tIn[j]; avgV += vIn[j]; cnt++
+			avgT += tIn[j]
+			avgV += vIn[j]
+			cnt++
 		}
 		if cnt > 0 {
-			avgT /= float64(cnt); avgV /= float64(cnt)
+			avgT /= float64(cnt)
+			avgV /= float64(cnt)
 		}
 		rS := int(float64(i)*every) + 1
 		rE := int(float64(i+1)*every) + 1
@@ -644,7 +770,8 @@ func lttbDecimate(tIn, vIn []float64, threshold int) ([]float64, []float64) {
 		for j := rS; j < rE; j++ {
 			area := math.Abs((aT-avgT)*(vIn[j]-aV) - (aT-tIn[j])*(avgV-aV))
 			if area > maxArea {
-				maxArea = area; next = j
+				maxArea = area
+				next = j
 			}
 		}
 		outT[i+1], outV[i+1] = tIn[next], vIn[next]
@@ -672,11 +799,13 @@ func (h *Hub) buildBinaryDataMessageForSource(src *sourceHubState, batch []udpsp
 	if src.configSeq != src.configSeqAtCalib {
 		src.configSeqAtCalib = src.configSeq
 		src.timeSigCalib = make(map[string]float64)
+		src.lastFrameEndT = make(map[string]float64)
+		src.lastFrameMeasured = make(map[string]float64)
+		src.gapEMA = make(map[string]float64)
 	}
 
 	sigs := src.signals
 	pfx := src.id + ":"
-	writeRing := h.shouldWriteRing()
 
 	type pairBuf struct {
 		t, v []float64
@@ -728,6 +857,25 @@ func (h *Hub) buildBinaryDataMessageForSource(src *sourceHubState, batch []udpsp
 					anchorTime = float64(s.WallTime.UnixNano()) / 1e9
 					anchorIsFirstSample = false
 				}
+				if h.monotonicTS && dt > 0 {
+					nominalGap := float64(n) * dt
+					measuredAnchor := anchorTime
+					if prevMeasured, ok := src.lastFrameMeasured[sig.Name]; ok {
+						measuredGap := measuredAnchor - prevMeasured
+						prevEMA, hasEMA := src.gapEMA[sig.Name]
+						if !hasEMA {
+							prevEMA = nominalGap
+						}
+						src.gapEMA[sig.Name] = prevEMA*(1-monotonicEMAAlpha) + measuredGap*monotonicEMAAlpha
+						smoothedGap := src.gapEMA[sig.Name]
+						deviation := math.Abs(measuredGap - smoothedGap)
+						if deviation > 0 && deviation < monotonicTolerance {
+							anchorTime = src.lastFrameEndT[sig.Name] + smoothedGap
+						}
+					}
+					src.lastFrameMeasured[sig.Name] = measuredAnchor
+					src.lastFrameEndT[sig.Name] = anchorTime
+				}
 				for k := 0; k < n; k++ {
 					var t float64
 					if anchorIsFirstSample {
@@ -739,12 +887,10 @@ func (h *Hub) buildBinaryDataMessageForSource(src *sourceHubState, batch []udpsp
 					allV = append(allV, vals[k])
 				}
 			}
-			if writeRing {
+			if rb := h.getRing(pfx + sig.Name); rb != nil {
-				ringT, ringV := lttbDecimate(allT, allV, maxRingPoints)
+				rb.write(allT, allV)
-				if rb := h.getRing(pfx + sig.Name); rb != nil {
-					rb.write(ringT, ringV)
-				}
 			}
+			h.trigger.feed(pfx+sig.Name, n, allT, allV)
 			decimT, decimV := lttbDecimate(allT, allV, maxPushPoints)
 			pairs[sig.Name] = pairBuf{t: decimT, v: decimV}
 
@@ -787,12 +933,10 @@ func (h *Hub) buildBinaryDataMessageForSource(src *sourceHubState, batch []udpsp
 					allV = append(allV, vals[k])
 				}
 			}
-			if writeRing {
+			if rb := h.getRing(pfx + sig.Name); rb != nil {
-				ringT, ringV := lttbDecimate(allT, allV, maxRingPoints)
+				rb.write(allT, allV)
-				if rb := h.getRing(pfx + sig.Name); rb != nil {
-					rb.write(ringT, ringV)
-				}
 			}
+			h.trigger.feed(pfx+sig.Name, n, allT, allV)
 			decimT, decimV := lttbDecimate(allT, allV, maxPushPoints)
 			pairs[sig.Name] = pairBuf{t: decimT, v: decimV}
 
@@ -807,25 +951,22 @@ func (h *Hub) buildBinaryDataMessageForSource(src *sourceHubState, batch []udpsp
 				ts = append(ts, float64(s.WallTime.UnixNano())/1e9)
 				vs = append(vs, vals[0])
 			}
-			if writeRing {
+			if rb := h.getRing(pfx + sig.Name); rb != nil {
-				if rb := h.getRing(pfx + sig.Name); rb != nil {
+				rb.write(ts, vs)
-					rb.write(ts, vs)
-				}
 			}
+			h.trigger.feed(pfx+sig.Name, 1, ts, vs)
 			pairs[sig.Name] = pairBuf{t: ts, v: vs}
 
 		default:
 			// n > 1, TimeModePacket: C++ sends samplingRate=0 so we interpolate
 			// per-element timestamps from wall-clock differences between packets.
 			//
-			// Three fixes vs the naïve approach:
+			// Two fixes vs the naïve approach:
 			//   1. Use src.lastPktNs[name] for the single-packet case so dt is
 			//      estimated from the actual inter-packet gap, not 1/n.
 			//   2. Send all n elements to the browser without LTTB so sinusoidal
 			//      waveforms are not degraded (packets arrive at ≤30 Hz, bandwidth
 			//      is trivially acceptable).
-			//   3. Always write the ring buffer regardless of shouldWriteRing() so
-			//      the first zoom request immediately returns full-resolution data.
 			allT := make([]float64, 0, len(batch)*n)
 			allV := make([]float64, 0, len(batch)*n)
 			for bi, s := range batch {
@@ -838,19 +979,38 @@ func (h *Hub) buildBinaryDataMessageForSource(src *sourceHubState, batch []udpsp
 				var dtSec float64
 				if bi+1 < len(batch) {
 					// Two consecutive packets in this tick → exact dt.
-					dtSec = (float64(batch[bi+1].WallTime.UnixNano())-float64(wallNs))/1e9/float64(n)
+					dtSec = (float64(batch[bi+1].WallTime.UnixNano()) - float64(wallNs)) / 1e9 / float64(n)
 				} else if bi > 0 {
 					// Last of multiple packets → use diff from previous.
-					dtSec = (float64(wallNs)-float64(batch[bi-1].WallTime.UnixNano()))/1e9/float64(n)
+					dtSec = (float64(wallNs) - float64(batch[bi-1].WallTime.UnixNano())) / 1e9 / float64(n)
 				} else if prevNs, ok2 := src.lastPktNs[sig.Name]; ok2 && prevNs > 0 && wallNs > prevNs {
 					// Single packet this tick → gap from the previous tick's packet.
-					dtSec = (float64(wallNs)-float64(prevNs))/1e9/float64(n)
+					dtSec = (float64(wallNs) - float64(prevNs)) / 1e9 / float64(n)
 				} else {
 					// Truly first packet ever — inter-packet timing unknown.
 					// Skip to avoid poisoning the ring with wrongly-spaced timestamps;
 					// lastPktNs will be recorded below so the next packet uses correct dt.
 					continue
 				}
+				if h.monotonicTS && dtSec > 0 {
+					nominalGap := float64(n) * dtSec
+					measuredStart := wallSec
+					if prevMeasured, ok := src.lastFrameMeasured[sig.Name]; ok {
+						measuredGap := measuredStart - prevMeasured
+						prevEMA, hasEMA := src.gapEMA[sig.Name]
+						if !hasEMA {
+							prevEMA = nominalGap
+						}
+						src.gapEMA[sig.Name] = prevEMA*(1-monotonicEMAAlpha) + measuredGap*monotonicEMAAlpha
+						smoothedGap := src.gapEMA[sig.Name]
+						deviation := math.Abs(measuredGap - smoothedGap)
+						if deviation > 0 && deviation < monotonicTolerance {
+							wallSec = src.lastFrameEndT[sig.Name] + smoothedGap
+						}
+					}
+					src.lastFrameMeasured[sig.Name] = measuredStart
+					src.lastFrameEndT[sig.Name] = wallSec
+				}
 				for j := 0; j < n; j++ {
 					allT = append(allT, wallSec+float64(j)*dtSec)
 					allV = append(allV, vals[j])
@@ -860,11 +1020,10 @@ func (h *Hub) buildBinaryDataMessageForSource(src *sourceHubState, batch []udpsp
 				src.lastPktNs[sig.Name] = batch[len(batch)-1].WallTime.UnixNano()
 			}
 			if len(allT) > 0 {
-				// Ring: always populate (fix 3), LTTB only if it actually reduces size.
-				ringT, ringV := lttbDecimate(allT, allV, maxRingPoints)
 				if rb := h.getRing(pfx + sig.Name); rb != nil {
-					rb.write(ringT, ringV)
+					rb.write(allT, allV)
 				}
+				h.trigger.feed(pfx+sig.Name, n, allT, allV)
 				// Live push: send all points without LTTB (fix 2).
 				pairs[sig.Name] = pairBuf{t: allT, v: allV}
 			}

Common/Client/go/wshub/keepalive_test.go

@@ -0,0 +1,69 @@
+package wshub
+
+import (
+	"net"
+	"testing"
+	"time"
+
+	"marte2/common/udpsprotocol"
+)
+
+// TestUDPClientSendsPeriodicKeepAliveAcks verifies that a unicast UDPClient
+// re-sends ACK datagrams from the SAME socket at keepAliveInterval. The
+// UDPSServer refreshes a unicast client's last-seen only on client->server
+// traffic; without this keepalive it evicts the client after ClientTimeout
+// (default 30 s) and the stream dies.
+func TestUDPClientSendsPeriodicKeepAliveAcks(t *testing.T) {
+	srv, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.ParseIP("127.0.0.1")})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer srv.Close()
+
+	c := NewUDPClient(srv.LocalAddr().String(), "ka1", NewHub(), "", 0)
+	c.keepAliveInterval = 150 * time.Millisecond
+	go c.Run()
+	defer c.Stop()
+
+	buf := make([]byte, 512)
+
+	// 1) CONNECT from the client's ephemeral socket.
+	srv.SetReadDeadline(time.Now().Add(3 * time.Second))
+	n, clientAddr, err := srv.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatalf("expected CONNECT: %v", err)
+	}
+	hdr, err := udpsprotocol.ParseHeader(buf[:n])
+	if err != nil {
+		t.Fatalf("parse CONNECT: %v", err)
+	}
+	if hdr.Type != udpsprotocol.PktConnect {
+		t.Fatalf("first packet type = %d, want CONNECT (%d)", hdr.Type, udpsprotocol.PktConnect)
+	}
+
+	// 2) Collect ACKs for ~1 s: must be periodic and from the SAME socket
+	//    (a new ephemeral socket would be registered as a new client).
+	deadline := time.Now().Add(time.Second)
+	acks := 0
+	for time.Now().Before(deadline) {
+		srv.SetReadDeadline(deadline)
+		n, addr, err := srv.ReadFromUDP(buf)
+		if err != nil {
+			break
+		}
+		hdr, err := udpsprotocol.ParseHeader(buf[:n])
+		if err != nil {
+			continue
+		}
+		if hdr.Type != udpsprotocol.PktACK {
+			t.Fatalf("unexpected packet type %d from %s", hdr.Type, addr)
+		}
+		if addr.String() != clientAddr.String() {
+			t.Fatalf("ACK from %s, want same socket as CONNECT (%s)", addr, clientAddr)
+		}
+		acks++
+	}
+	if acks < 3 {
+		t.Fatalf("expected >= 3 keepalive ACKs in 1 s, got %d", acks)
+	}
+}

Common/Client/go/wshub/origin_test.go

@@ -0,0 +1,72 @@
+package wshub
+
+import (
+	"net/http"
+	"testing"
+)
+
+// TestCheckOrigin_NoOriginHeader — non-browser clients (no Origin) are allowed.
+func TestCheckOrigin_NoOriginHeader(t *testing.T) {
+	r := &http.Request{Header: http.Header{}}
+	if !checkOrigin(r) {
+		t.Fatal("non-browser client (no Origin header) should be allowed")
+	}
+}
+
+// TestCheckOrigin_SameOrigin — Origin host matching Host header is allowed.
+func TestCheckOrigin_SameOrigin(t *testing.T) {
+	r := &http.Request{
+		Header: http.Header{
+			"Origin": []string{"http://localhost:8090"},
+		},
+		Host: "localhost:8090",
+	}
+	if !checkOrigin(r) {
+		t.Fatal("same-origin request should be allowed")
+	}
+}
+
+// TestCheckOrigin_CrossOriginBlocked — different Origin host is rejected.
+func TestCheckOrigin_CrossOriginBlocked(t *testing.T) {
+	r := &http.Request{
+		Header: http.Header{
+			"Origin": []string{"http://evil.example.com:8090"},
+		},
+		Host: "localhost:8090",
+	}
+	if checkOrigin(r) {
+		t.Fatal("cross-origin request should be blocked")
+	}
+}
+
+// TestCheckOrigin_Allowlist — explicitly allowed origins pass even if cross-origin.
+func TestCheckOrigin_Allowlist(t *testing.T) {
+	SetAllowedOrigins([]string{"http://evil.example.com:8090"})
+	defer SetAllowedOrigins(nil) // reset
+
+	r := &http.Request{
+		Header: http.Header{
+			"Origin": []string{"http://evil.example.com:8090"},
+		},
+		Host: "localhost:8090",
+	}
+	if !checkOrigin(r) {
+		t.Fatal("allowlisted origin should be allowed")
+	}
+}
+
+// TestCheckOrigin_AllowlistDoesNotMatch — non-allowlisted cross-origin is blocked.
+func TestCheckOrigin_AllowlistDoesNotMatch(t *testing.T) {
+	SetAllowedOrigins([]string{"http://good.example.com"})
+	defer SetAllowedOrigins(nil)
+
+	r := &http.Request{
+		Header: http.Header{
+			"Origin": []string{"http://evil.example.com"},
+		},
+		Host: "localhost:8090",
+	}
+	if checkOrigin(r) {
+		t.Fatal("non-allowlisted cross-origin should be blocked")
+	}
+}

Common/Client/go/wshub/sources.go

@@ -172,27 +172,34 @@ const (
 	reconnectDelay = 2 * time.Second
 	readBufSize    = 65536
 	udpRcvBufSize  = 8 * 1024 * 1024
+	// keepAliveInterval is the unicast keepalive period. The UDPStreamer
+	// server evicts silent unicast clients after its ClientTimeout (default
+	// 30 s); an ACK from the same socket refreshes its last-seen without
+	// triggering a CONFIG resend (a CONNECT would).
+	keepAliveInterval = 15 * time.Second
 )
 
 // UDPClient manages the connection to one MARTe2 streamer source.
 type UDPClient struct {
-	serverAddr     string
+	serverAddr        string
-	sourceID       string
+	sourceID          string
-	hub            *Hub
+	hub               *Hub
-	multicastGroup string
+	multicastGroup    string
-	dataPort       int
+	dataPort          int
-	stopCh         chan struct{}
+	keepAliveInterval time.Duration
+	stopCh            chan struct{}
 }
 
 // NewUDPClient creates a UDPClient bound to a specific source ID.
 func NewUDPClient(serverAddr, sourceID string, hub *Hub, multicastGroup string, dataPort int) *UDPClient {
 	return &UDPClient{
-		serverAddr:     serverAddr,
+		serverAddr:        serverAddr,
-		sourceID:       sourceID,
+		sourceID:          sourceID,
-		hub:            hub,
+		hub:               hub,
-		multicastGroup: multicastGroup,
+		multicastGroup:    multicastGroup,
-		dataPort:       dataPort,
+		dataPort:          dataPort,
-		stopCh:         make(chan struct{}),
+		keepAliveInterval: keepAliveInterval,
+		stopCh:            make(chan struct{}),
 	}
 }
 
@@ -253,6 +260,20 @@ func (u *UDPClient) runSession() error {
 		return err
 	}
 	log.Printf("[%s] udp: sent CONNECT", u.sourceID)
+	lastData := time.Now()
+	lastKeepAlive := time.Now()
+	// sendKeepAliveIfDue sends an ACK if the keepalive interval has elapsed.
+	// ACK refreshes the server's last-seen without re-sending CONFIG (which a
+	// repeated CONNECT would trigger).
+	sendKeepAliveIfDue := func() error {
+		if u.keepAliveInterval > 0 && time.Since(lastKeepAlive) >= u.keepAliveInterval {
+			if _, err := conn.WriteToUDP(udpsprotocol.BuildAckPacket(), serverAddr); err != nil {
+				return err
+			}
+			lastKeepAlive = time.Now()
+		}
+		return nil
+	}
 
 	reassembler := udpsprotocol.NewReassembler(2 * time.Second)
 	buf := make([]byte, readBufSize)
@@ -260,14 +281,34 @@ func (u *UDPClient) runSession() error {
 	var currentPublishMode uint8
 
 	for {
-		conn.SetReadDeadline(time.Now().Add(silenceTimeout))
+		// Wake up at least every keepalive interval so ACKs are sent even
+		// when the server is idle; the read deadline also doubles as the
+		// silence detector (no data for silenceTimeout = server gone).
+		wakeup := silenceTimeout
+		if u.keepAliveInterval > 0 && u.keepAliveInterval < wakeup {
+			wakeup = u.keepAliveInterval
+		}
+		conn.SetReadDeadline(time.Now().Add(wakeup))
 
 		n, _, err := conn.ReadFromUDP(buf)
 		arrivalTime := time.Now()
 		if err != nil {
+			if ne, ok := err.(net.Error); ok && ne.Timeout() {
+				if time.Since(lastData) >= silenceTimeout {
+					// True silence: stream is dead — Run() reconnects.
+					conn.WriteToUDP(udpsprotocol.BuildDisconnectPacket(), serverAddr)
+					return err
+				}
+				// Short wakeup: keepalive if due, then keep waiting.
+				if kaErr := sendKeepAliveIfDue(); kaErr != nil {
+					return kaErr
+				}
+				continue
+			}
 			conn.WriteToUDP(udpsprotocol.BuildDisconnectPacket(), serverAddr)
 			return err
 		}
+		lastData = arrivalTime
 
 		if n < udpsprotocol.HeaderSize {
 			log.Printf("[%s] udp: short datagram (%d bytes), skipping", u.sourceID, n)
@@ -334,6 +375,10 @@ func (u *UDPClient) runSession() error {
 			return nil
 		default:
 		}
+
+		if kaErr := sendKeepAliveIfDue(); kaErr != nil {
+			return kaErr
+		}
 	}
 }
 

Common/Client/go/wshub/trigger.go

@@ -0,0 +1,435 @@
+package wshub
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"math"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+// Trigger FSM states, matching the C++ StreamHub TriggerEngine and the strings
+// expected by the web SPA's "triggerState" handler.
+const (
+	trigIdle       = "idle"
+	trigArmed      = "armed"
+	trigCollecting = "collecting"
+	trigTriggered  = "triggered"
+)
+
+// captureMarginSec is the extra delay past the post-trigger window before the
+// capture is extracted, so the rings have received the last samples.
+const captureMarginSec = 0.15
+
+// autoRearmDelaySec is the pause between a completed capture and the automatic
+// rearm in "normal" mode.
+const autoRearmDelaySec = 0.2
+
+// trigConfig is the client-settable part of the trigger.
+type trigConfig struct {
+	signalKey  string // "src:sig" or "src:sig[i]"
+	edge       string // "rising" | "falling" | "both"
+	threshold  float64
+	windowSec  float64
+	prePercent float64
+	mode       string // "normal" | "single"
+}
+
+// triggerEngine implements the hub-side trigger FSM. Its methods are safe to
+// call from the WebSocket read goroutines and from Hub.Run() concurrently.
+type triggerEngine struct {
+	mu  sync.Mutex
+	cfg trigConfig
+
+	// Parsed form of cfg.signalKey, refreshed by SetConfig.
+	baseKey string // "src:sig"
+	elemIdx int    // -1 when the key has no "[i]" suffix
+
+	state   string
+	stopped bool
+
+	prevValue float64
+	prevValid bool
+	lastT     float64
+	lastTOK   bool
+
+	trigTime   float64
+	firedPre   float64
+	firedPost  float64
+	firedValid bool
+
+	rearmAt float64 // wall-clock seconds; 0 when no rearm is pending
+}
+
+func newTriggerEngine() *triggerEngine {
+	return &triggerEngine{
+		cfg:     trigConfig{edge: "rising", windowSec: 1, prePercent: 20, mode: "normal"},
+		elemIdx: -1,
+		state:   trigIdle,
+	}
+}
+
+// parseSignalKey splits "src:sig[3]" into ("src:sig", 3). A key without an
+// element suffix yields an index of -1.
+func parseSignalKey(key string) (string, int) {
+	if !strings.HasSuffix(key, "]") {
+		return key, -1
+	}
+	open := strings.LastIndexByte(key, '[')
+	if open < 0 {
+		return key, -1
+	}
+	idx, err := strconv.Atoi(key[open+1 : len(key)-1])
+	if err != nil || idx < 0 {
+		return key, -1
+	}
+	return key[:open], idx
+}
+
+func (te *triggerEngine) SetConfig(cfg trigConfig) {
+	te.mu.Lock()
+	defer te.mu.Unlock()
+	// Clamp to the bounds the web UI offers.
+	if cfg.windowSec < 1e-4 {
+		cfg.windowSec = 1e-4
+	}
+	if cfg.windowSec > 10 {
+		cfg.windowSec = 10
+	}
+	if cfg.prePercent < 0 {
+		cfg.prePercent = 0
+	}
+	if cfg.prePercent > 100 {
+		cfg.prePercent = 100
+	}
+	te.cfg = cfg
+	te.baseKey, te.elemIdx = parseSignalKey(cfg.signalKey)
+	te.prevValid = false
+	te.prevValue = 0
+}
+
+func (te *triggerEngine) Config() trigConfig {
+	te.mu.Lock()
+	defer te.mu.Unlock()
+	return te.cfg
+}
+
+func (te *triggerEngine) Arm() {
+	te.mu.Lock()
+	te.state = trigArmed
+	te.prevValid = false
+	te.prevValue = 0
+	te.rearmAt = 0
+	te.mu.Unlock()
+}
+
+func (te *triggerEngine) Disarm() {
+	te.mu.Lock()
+	te.state = trigIdle
+	te.stopped = false
+	te.prevValid = false
+	te.prevValue = 0
+	te.firedValid = false
+	te.rearmAt = 0
+	te.mu.Unlock()
+}
+
+func (te *triggerEngine) SetStopped(v bool) {
+	te.mu.Lock()
+	te.stopped = v
+	if v {
+		te.rearmAt = 0
+	}
+	te.mu.Unlock()
+}
+
+func (te *triggerEngine) Stopped() bool {
+	te.mu.Lock()
+	defer te.mu.Unlock()
+	return te.stopped
+}
+
+func (te *triggerEngine) State() string {
+	te.mu.Lock()
+	defer te.mu.Unlock()
+	return te.state
+}
+
+// Active reports whether a trigger signal is configured. The rings must stay
+// populated from that moment on: a capture reaches back over the pre-trigger
+// window, so waiting until the trigger arms would leave that window empty.
+func (te *triggerEngine) Active() bool {
+	te.mu.Lock()
+	defer te.mu.Unlock()
+	return te.baseKey != ""
+}
+
+// latchWindowLocked freezes the pre/post split at fire time so later config
+// edits do not change how the capture is rendered.
+func (te *triggerEngine) latchWindowLocked(t float64) {
+	te.state = trigCollecting
+	te.trigTime = t
+	te.firedPre = te.cfg.windowSec * te.cfg.prePercent / 100
+	te.firedPost = te.cfg.windowSec - te.firedPre
+	te.firedValid = true
+	te.rearmAt = 0
+}
+
+// Force fires the trigger immediately at the most recent sample time (falling
+// back to the current wall clock when no sample has been seen yet).
+func (te *triggerEngine) Force() {
+	te.mu.Lock()
+	defer te.mu.Unlock()
+	if te.state == trigCollecting {
+		return
+	}
+	t := float64(time.Now().UnixNano()) / 1e9
+	if te.lastTOK {
+		t = te.lastT
+	}
+	te.latchWindowLocked(t)
+}
+
+// feed passes a batch of full-resolution samples for one signal to the FSM.
+// key is the fully-prefixed "src:sig" name; nElem is the signal's element count
+// so that an "[i]"-suffixed configuration can select a single column out of the
+// flattened element-major batch.
+func (te *triggerEngine) feed(key string, nElem int, t, v []float64) {
+	if len(t) == 0 || len(t) != len(v) {
+		return
+	}
+	te.mu.Lock()
+	defer te.mu.Unlock()
+	if key != te.baseKey {
+		return
+	}
+	te.lastT = t[len(t)-1]
+	te.lastTOK = true
+	if te.state != trigArmed {
+		return
+	}
+	step, start := 1, 0
+	if te.elemIdx >= 0 && nElem > 1 {
+		if te.elemIdx >= nElem {
+			return
+		}
+		step, start = nElem, te.elemIdx
+	}
+	thr := te.cfg.threshold
+	for i := start; i < len(t); i += step {
+		if !te.prevValid {
+			te.prevValue = v[i]
+			te.prevValid = true
+			continue
+		}
+		up := te.prevValue < thr && v[i] >= thr
+		down := te.prevValue > thr && v[i] <= thr
+		te.prevValue = v[i]
+		fired := false
+		switch te.cfg.edge {
+		case "falling":
+			fired = down
+		case "both":
+			fired = up || down
+		default:
+			fired = up
+		}
+		if fired {
+			te.latchWindowLocked(t[i])
+			return
+		}
+	}
+}
+
+// dueCapture reports whether a collecting trigger's post-window has elapsed and
+// returns the latched window.
+func (te *triggerEngine) dueCapture(nowSec float64) (trigTime, pre, post float64, ok bool) {
+	te.mu.Lock()
+	defer te.mu.Unlock()
+	if te.state != trigCollecting || !te.firedValid {
+		return 0, 0, 0, false
+	}
+	if nowSec < te.trigTime+te.firedPost+captureMarginSec {
+		return 0, 0, 0, false
+	}
+	return te.trigTime, te.firedPre, te.firedPost, true
+}
+
+// markTriggered completes a capture and schedules the automatic rearm when the
+// engine runs in "normal" mode.
+func (te *triggerEngine) markTriggered(nowSec float64) {
+	te.mu.Lock()
+	if te.state == trigCollecting {
+		te.state = trigTriggered
+		if te.cfg.mode != "single" && !te.stopped {
+			te.rearmAt = nowSec + autoRearmDelaySec
+		}
+	}
+	te.mu.Unlock()
+}
+
+// dueRearm reports whether a pending automatic rearm has come due, consuming it.
+func (te *triggerEngine) dueRearm(nowSec float64) bool {
+	te.mu.Lock()
+	defer te.mu.Unlock()
+	if te.state != trigTriggered || te.rearmAt == 0 || nowSec < te.rearmAt {
+		return false
+	}
+	te.rearmAt = 0
+	return !te.stopped
+}
+
+// stateMsg builds the JSON "triggerState" broadcast for the current FSM state.
+func (te *triggerEngine) stateMsg() []byte {
+	te.mu.Lock()
+	m := map[string]any{
+		"type":    "triggerState",
+		"state":   te.state,
+		"mode":    te.cfg.mode,
+		"stopped": te.stopped,
+	}
+	if te.firedValid {
+		m["trigTime"] = te.trigTime
+	}
+	te.mu.Unlock()
+	msg, _ := json.Marshal(m)
+	return msg
+}
+
+/* ─── Hub integration ─────────────────────────────────────────────────────── */
+
+// broadcastTriggerState pushes the current FSM state to every client.
+func (h *Hub) broadcastTriggerState() {
+	h.broadcast(h.trigger.stateMsg())
+}
+
+// handleTriggerCommand processes a trigger-related browser message. It returns
+// false when the message type is not a trigger command.
+func (h *Hub) handleTriggerCommand(t string, env map[string]interface{}) bool {
+	switch t {
+	case "setTrigger":
+		cfg := h.trigger.Config()
+		if s, ok := env["signal"].(string); ok {
+			cfg.signalKey = s
+		}
+		if s, ok := env["edge"].(string); ok {
+			cfg.edge = s
+		}
+		if s, ok := env["mode"].(string); ok {
+			cfg.mode = s
+		}
+		if f, ok := env["threshold"].(float64); ok {
+			cfg.threshold = f
+		}
+		if f, ok := env["windowSec"].(float64); ok {
+			cfg.windowSec = f
+		}
+		if f, ok := env["prePercent"].(float64); ok {
+			cfg.prePercent = f
+		}
+		h.trigger.SetConfig(cfg)
+	case "arm", "rearm":
+		h.trigger.Arm()
+	case "disarm":
+		h.trigger.Disarm()
+	case "trigStop":
+		stopped := !h.trigger.Stopped()
+		if b, ok := env["stopped"].(bool); ok {
+			stopped = b
+		}
+		h.trigger.SetStopped(stopped)
+	case "forceTrigger":
+		h.trigger.Force()
+	default:
+		return false
+	}
+	h.broadcastTriggerState()
+	return true
+}
+
+// triggerTick services the trigger FSM; called from Hub.Run() on every push tick.
+func (h *Hub) triggerTick() {
+	nowSec := float64(time.Now().UnixNano()) / 1e9
+	prev := h.trigger.State()
+
+	if trigTime, pre, post, ok := h.trigger.dueCapture(nowSec); ok {
+		if msg := h.buildTriggerCapture(trigTime, pre, post); msg != nil {
+			for c := range h.clients {
+				select {
+				case c.send <- wsMessage{websocket.BinaryMessage, msg}:
+				default:
+				}
+			}
+		}
+		h.trigger.markTriggered(nowSec)
+	} else if h.trigger.dueRearm(nowSec) {
+		h.trigger.Arm()
+	}
+
+	if h.trigger.State() != prev {
+		h.broadcastTriggerState()
+	}
+}
+
+// buildTriggerCapture extracts [trigTime-pre, trigTime+post] from every ring
+// buffer and encodes the version-2 binary capture frame:
+//
+//	[u8 2][f64 trigTime][f64 preSec][f64 postSec][u32 nSig]
+//	{[u16 keyLen][fullKey][u32 N][t f64×N][v f64×N]}
+func (h *Hub) buildTriggerCapture(trigTime, pre, post float64) []byte {
+	t0, t1 := trigTime-pre, trigTime+post
+
+	type sigSlice struct {
+		key  string
+		t, v []float64
+	}
+	h.ringsMu.RLock()
+	keys := make([]string, 0, len(h.rings))
+	rings := make([]*sigRing, 0, len(h.rings))
+	for k, rb := range h.rings {
+		keys = append(keys, k)
+		rings = append(rings, rb)
+	}
+	h.ringsMu.RUnlock()
+
+	slices := make([]sigSlice, 0, len(keys))
+	total := 1 + 8 + 8 + 8 + 4
+	for i, k := range keys {
+		st, sv := rings[i].slice(t0, t1)
+		if len(st) == 0 {
+			continue
+		}
+		slices = append(slices, sigSlice{key: k, t: st, v: sv})
+		total += 2 + len(k) + 4 + len(st)*16
+	}
+	if len(slices) == 0 {
+		return nil
+	}
+
+	buf := make([]byte, total)
+	buf[0] = 2
+	off := 1
+	binary.LittleEndian.PutUint64(buf[off:], math.Float64bits(trigTime))
+	off += 8
+	binary.LittleEndian.PutUint64(buf[off:], math.Float64bits(pre))
+	off += 8
+	binary.LittleEndian.PutUint64(buf[off:], math.Float64bits(post))
+	off += 8
+	binary.LittleEndian.PutUint32(buf[off:], uint32(len(slices)))
+	off += 4
+	for _, s := range slices {
+		binary.LittleEndian.PutUint16(buf[off:], uint16(len(s.key)))
+		off += 2
+		copy(buf[off:], s.key)
+		off += len(s.key)
+		binary.LittleEndian.PutUint32(buf[off:], uint32(len(s.t)))
+		off += 4
+		off = writeFloat64s(buf, off, s.t)
+		off = writeFloat64s(buf, off, s.v)
+	}
+	return buf
+}

Common/Client/go/wshub/trigger_test.go

@@ -0,0 +1,194 @@
+package wshub
+
+import "testing"
+
+func TestParseSignalKey(t *testing.T) {
+	cases := []struct {
+		in   string
+		base string
+		idx  int
+	}{
+		{"src:sig", "src:sig", -1},
+		{"src:sig[0]", "src:sig", 0},
+		{"src:sig[3]", "src:sig", 3},
+		{"src:sig[x]", "src:sig[x]", -1},
+		{"src:sig]", "src:sig]", -1},
+	}
+	for _, c := range cases {
+		base, idx := parseSignalKey(c.in)
+		if base != c.base || idx != c.idx {
+			t.Errorf("parseSignalKey(%q) = (%q,%d), want (%q,%d)",
+				c.in, base, idx, c.base, c.idx)
+		}
+	}
+}
+
+func armed(key, edge string, thr float64) *triggerEngine {
+	te := newTriggerEngine()
+	te.SetConfig(trigConfig{signalKey: key, edge: edge, threshold: thr,
+		windowSec: 1, prePercent: 20, mode: "normal"})
+	te.Arm()
+	return te
+}
+
+func TestFeedRisingEdge(t *testing.T) {
+	te := armed("src:sig", "rising", 0.5)
+	te.feed("src:sig", 1, []float64{1, 2, 3, 4}, []float64{0, 0.2, 0.9, 1.0})
+	if te.State() != trigCollecting {
+		t.Fatalf("state = %q, want collecting", te.State())
+	}
+	// Fires at the sample that crossed, i.e. t=3.
+	trigTime, pre, post, ok := te.dueCapture(1e9)
+	if !ok || trigTime != 3 {
+		t.Fatalf("dueCapture = (%v,%v), want trigTime 3", trigTime, ok)
+	}
+	if pre != 0.2 || post != 0.8 {
+		t.Errorf("pre/post = %v/%v, want 0.2/0.8", pre, post)
+	}
+}
+
+func TestFeedFallingEdgeIgnoresRising(t *testing.T) {
+	te := armed("src:sig", "falling", 0.5)
+	te.feed("src:sig", 1, []float64{1, 2, 3}, []float64{0, 0.9, 1.0})
+	if te.State() != trigArmed {
+		t.Fatalf("state = %q, want armed (no falling edge)", te.State())
+	}
+	te.feed("src:sig", 1, []float64{4, 5}, []float64{0.6, 0.1})
+	if te.State() != trigCollecting {
+		t.Fatalf("state = %q, want collecting", te.State())
+	}
+}
+
+func TestFeedIgnoresOtherSignals(t *testing.T) {
+	te := armed("src:sig", "rising", 0.5)
+	te.feed("src:other", 1, []float64{1, 2}, []float64{0, 1})
+	if te.State() != trigArmed {
+		t.Fatalf("state = %q, want armed", te.State())
+	}
+}
+
+func TestFeedArrayElementSelection(t *testing.T) {
+	// 2-element signal, element-major: [e0,e1, e0,e1, ...]. Only element 1
+	// crosses the threshold.
+	te := armed("src:sig[1]", "rising", 0.5)
+	tt := []float64{1, 1, 2, 2}
+	vv := []float64{0, 0, 0, 1}
+	te.feed("src:sig", 2, tt, vv)
+	if te.State() != trigCollecting {
+		t.Fatalf("state = %q, want collecting", te.State())
+	}
+
+	// Element 0 never crosses, so a config on [0] must not fire.
+	te2 := armed("src:sig[0]", "rising", 0.5)
+	te2.feed("src:sig", 2, tt, vv)
+	if te2.State() != trigArmed {
+		t.Fatalf("state = %q, want armed", te2.State())
+	}
+}
+
+func TestForceUsesLastSampleTime(t *testing.T) {
+	te := newTriggerEngine()
+	te.SetConfig(trigConfig{signalKey: "src:sig", edge: "rising", threshold: 1e9,
+		windowSec: 2, prePercent: 50, mode: "single"})
+	te.Arm()
+	te.feed("src:sig", 1, []float64{10, 11, 12}, []float64{0, 0, 0})
+	if te.State() != trigArmed {
+		t.Fatalf("state = %q, want armed (threshold unreachable)", te.State())
+	}
+	te.Force()
+	trigTime, pre, post, ok := te.dueCapture(1e9)
+	if !ok || trigTime != 12 || pre != 1 || post != 1 {
+		t.Fatalf("dueCapture = (%v,%v,%v,%v), want (12,1,1,true)",
+			trigTime, pre, post, ok)
+	}
+}
+
+func TestForceFromIdle(t *testing.T) {
+	te := newTriggerEngine()
+	te.SetConfig(trigConfig{signalKey: "src:sig", edge: "rising",
+		windowSec: 1, prePercent: 20, mode: "normal"})
+	te.Force()
+	if te.State() != trigCollecting {
+		t.Fatalf("state = %q, want collecting", te.State())
+	}
+}
+
+func TestCaptureMarginDelaysExtraction(t *testing.T) {
+	te := armed("src:sig", "rising", 0.5)
+	te.feed("src:sig", 1, []float64{0, 1}, []float64{0, 1}) // fires at t=1
+	// post = 0.8 s; capture is due at 1 + 0.8 + 0.15.
+	if _, _, _, ok := te.dueCapture(1.9); ok {
+		t.Error("capture extracted before the margin elapsed")
+	}
+	if _, _, _, ok := te.dueCapture(1.96); !ok {
+		t.Error("capture not extracted after the margin elapsed")
+	}
+}
+
+func TestAutoRearmNormalMode(t *testing.T) {
+	te := armed("src:sig", "rising", 0.5)
+	te.feed("src:sig", 1, []float64{0, 1}, []float64{0, 1})
+	te.markTriggered(100)
+	if te.State() != trigTriggered {
+		t.Fatalf("state = %q, want triggered", te.State())
+	}
+	if te.dueRearm(100.1) {
+		t.Error("rearmed before the delay elapsed")
+	}
+	if !te.dueRearm(100.3) {
+		t.Error("did not rearm after the delay elapsed")
+	}
+	if te.dueRearm(200) {
+		t.Error("rearm was not consumed")
+	}
+}
+
+func TestNoAutoRearmInSingleMode(t *testing.T) {
+	te := newTriggerEngine()
+	te.SetConfig(trigConfig{signalKey: "src:sig", edge: "rising", threshold: 0.5,
+		windowSec: 1, prePercent: 20, mode: "single"})
+	te.Arm()
+	te.feed("src:sig", 1, []float64{0, 1}, []float64{0, 1})
+	te.markTriggered(100)
+	if te.dueRearm(200) {
+		t.Error("single mode must not auto-rearm")
+	}
+}
+
+func TestStoppedSuppressesRearm(t *testing.T) {
+	te := armed("src:sig", "rising", 0.5)
+	te.feed("src:sig", 1, []float64{0, 1}, []float64{0, 1})
+	te.SetStopped(true)
+	te.markTriggered(100)
+	if te.dueRearm(200) {
+		t.Error("stopped engine must not rearm")
+	}
+}
+
+func TestSetConfigClamps(t *testing.T) {
+	te := newTriggerEngine()
+	te.SetConfig(trigConfig{signalKey: "s:x", windowSec: 100, prePercent: 500})
+	if cfg := te.Config(); cfg.windowSec != 10 || cfg.prePercent != 100 {
+		t.Errorf("upper clamp = %v/%v, want 10/100", cfg.windowSec, cfg.prePercent)
+	}
+	te.SetConfig(trigConfig{signalKey: "s:x", windowSec: 0, prePercent: -5})
+	if cfg := te.Config(); cfg.windowSec != 1e-4 || cfg.prePercent != 0 {
+		t.Errorf("lower clamp = %v/%v, want 1e-4/0", cfg.windowSec, cfg.prePercent)
+	}
+}
+
+func TestActiveTracksConfiguredSignal(t *testing.T) {
+	te := newTriggerEngine()
+	if te.Active() {
+		t.Error("a fresh engine must not be active")
+	}
+	te.SetConfig(trigConfig{signalKey: "src:sig", windowSec: 1})
+	if !te.Active() {
+		t.Error("engine must be active once a signal is configured")
+	}
+	// Rings must keep filling after a capture completes, not just while armed.
+	te.Disarm()
+	if !te.Active() {
+		t.Error("engine must stay active after disarm while a signal is set")
+	}
+}

Common/Client/go/wshub/zoom_test.go

@@ -0,0 +1,61 @@
+package wshub
+
+import "testing"
+
+func TestZoomPoints(t *testing.T) {
+	cases := []struct {
+		n       int
+		present bool
+		want    int
+	}{
+		{0, false, 2400},    // absent → default budget
+		{2400, true, 2400},  // explicit budget honoured
+		{0, true, 1 << 30},  // 0 → every sample in range
+		{-1, true, 1 << 30}, // negative → every sample in range
+		{5, true, 2400},     // implausibly small → default budget
+	}
+	for _, c := range cases {
+		if got := zoomPoints(c.n, c.present); got != c.want {
+			t.Errorf("zoomPoints(%d,%v) = %d, want %d", c.n, c.present, got, c.want)
+		}
+	}
+}
+
+func TestZoomSliceReturnsFullResolution(t *testing.T) {
+	h := NewHub()
+	rb := newSigRing(1000)
+	ts := make([]float64, 500)
+	vs := make([]float64, 500)
+	for i := range ts {
+		ts[i] = float64(i) * 0.001 // 1 kHz
+		vs[i] = float64(i)
+	}
+	rb.write(ts, vs)
+	h.rings["s1:sig"] = rb
+
+	// A budget larger than the range must return every sample untouched.
+	res := h.zoomSlice(0.100, 0.199, []string{"s1:sig"}, 1<<30)
+	sd, ok := res["s1:sig"]
+	if !ok {
+		t.Fatal("signal missing from zoom result")
+	}
+	if len(sd.T) != 100 {
+		t.Fatalf("got %d points, want 100", len(sd.T))
+	}
+	if sd.V[0] != 100 || sd.V[99] != 199 {
+		t.Errorf("value range = %v..%v, want 100..199", sd.V[0], sd.V[99])
+	}
+
+	// A small budget decimates but keeps the endpoints.
+	dec := h.zoomSlice(0.100, 0.199, []string{"s1:sig"}, 20)
+	if len(dec["s1:sig"].T) != 20 {
+		t.Errorf("decimated to %d points, want 20", len(dec["s1:sig"].T))
+	}
+}
+
+func TestZoomSliceUnknownSignal(t *testing.T) {
+	h := NewHub()
+	if res := h.zoomSlice(0, 1, []string{"nope", ""}, 100); len(res) != 0 {
+		t.Errorf("got %d entries, want 0", len(res))
+	}
+}

Docs/E2E-Suite.md

@@ -0,0 +1,282 @@
+# E2E Test Suite
+
+The streaming-chain end-to-end suite (`Test/E2E/suite/`) validates the full data path from
+MARTe2 real-time application through the UDPS wire protocol to StreamHub and client consumers.
+It also covers the debug/trace path (DebugService, TCPLogger) and the direct
+UDPStreamer-to-UDPStreamerClient round-trip.
+
+## Overview
+
+The suite is driven by a single orchestrator script:
+
+```bash
+source env.sh
+./Test/E2E/suite/run_e2e.sh [flags]
+```
+
+For each scenario defined in `scenarios.py`, the orchestrator:
+
+1. **Generates input data** (`gen_data.py`) — deterministic typed/shaped binary in MARTe2
+   FileReader format, plus a ground-truth dict for the validator.
+2. **Generates configs** (`gen_cfg.py`) — MARTe2 app config (LinuxTimer + FileReader + IOGAM +
+   UDPStreamer) and StreamHub config, per scenario.
+3. **Launches the server stack** — MARTe2 app + StreamHub (for chain/recorder scenarios) or
+   MARTe2 app alone (for direct/debug scenarios).
+4. **Drives mock clients** — the Go `chain-client` (chain scenarios) or `debugclient`
+   (debug/tcplogger scenarios) connects, records data, and runs behavioural checks.
+5. **Validates** (`validate_waveform.py`) — compares the recorded stream against the analytic
+   ground truth and/or the fed-reference tap file.
+6. **Renders plots** (`plots.py`) — waveform, trigger, and zoom overlay PNGs per scenario.
+7. **Runs unit tests + coverage** (`collect.py`) — C++ GTest, Go, and Python suites with
+   optional lcov C++ line coverage.
+8. **Runs stress matrix** (`stress_run.py` / `stress.py`) — capacity sweeps (signal size,
+   count, fan-out, zoom rate) with survival/liveness/RSS/latency gates.
+9. **Builds the report** (`report_build.py`) — consolidates everything into
+   `report_data.json` with regression tracking against the previous run, trend plots, and a
+   Typst PDF (`E2E_Report.typ`).
+
+---
+
+## Flags
+
+| Flag                 | Effect                                                   |
+| -------------------- | -------------------------------------------------------- |
+| `--skip-build`       | Skip C++ component rebuild                               |
+| `--only <id>`        | Run a single scenario by ID                              |
+| `--pdf-only`         | Just compile the Typst PDF report (no tests)             |
+| `--cpp-coverage`     | Instrumented gcov rebuild + lcov capture (on by default) |
+| `--skip-coverage`    | Disable the coverage pass                                |
+| `--skip-stress`      | Skip the stress matrix                                   |
+| `--skip-datasources` | Skip `direct` scenarios                                  |
+| `--skip-recorder`    | Skip `recorder` scenarios                                |
+| `--skip-debug`       | Skip `debug` and `debug_pause_resume` scenarios          |
+| `--skip-tcplogger`   | Skip `tcplogger` scenarios                               |
+
+---
+
+## Scenario Kinds
+
+### chain
+
+Full streaming pipeline: MARTe2 (FileReader -> IOGAM -> UDPStreamer) -> StreamHub -> Go
+`chain-client`. The client records the live binary stream and runs behavioural checks
+(live, zoom, window, trigger). The validator compares the recording against the analytic
+ground truth (fidelity, sine shape fit, continuity) and optionally a fed-reference tap.
+
+### direct
+
+MARTe2 FileReader -> UDPStreamer -> UDPStreamerClient -> FileWriter round-trip. Validates that
+the written binary matches the input binary (bit-exact for each signal type).
+
+### recorder
+
+MARTe2 -> UDPStreamer -> StreamHub with BinaryRecorder enabled. Validates the `.bin` file
+written to disk by the recorder against the original input.
+
+### debug / debug_pause_resume
+
+DebugService scenarios exercising FORCE, TRACE, and BREAK commands over TCP (port 8080) with
+trace telemetry on UDP (port 8081). The Go `debugclient` scripts a fixed command sequence and
+verifies real acknowledgements. The `debug_pause_resume` variant additionally verifies that
+PAUSE halts the RT loop and RESUME restarts it via live VALUE polling.
+
+### tcplogger
+
+TCPLogger delivery: verifies that a triggered DebugService event produces a log line on the
+TCPLogger TCP port (8082/9090).
+
+---
+
+## Validation Oracles
+
+Each chain scenario specifies an `oracle` mode:
+
+- **analytic** — ground truth is reconstructed from `gen_data.py`'s deterministic formulas
+  (sine, ramp, counter, time_us, time_ns). No reference file needed.
+- **fed** — a second IOGAM branch in the MARTe config taps the same signals into a FileWriter
+  ("tap file"). The validator compares recordings against this tap.
+- **both** — both oracles are applied.
+
+Per-signal checks (`validate_waveform.py`):
+
+| Check             | Description                                                                                                                                                                        |
+| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Fidelity**      | Every received value within tolerance of some ground-truth value. Tolerance is 0 for raw integers, float epsilon for raw floats, `quant_step/2 + 1e-6*range` for quantised floats. |
+| **Shape**         | Sine signals (>= 8 points): least-squares fit of `a*sin(wt)+b*cos(wt)+c`. Requires correlation >= 0.99 and low normalised RMSE (relaxed by quant step).                            |
+| **Fed reference** | When `--tap` is given, each received value must also match the tap.                                                                                                                |
+| **Continuity**    | Flags inter-sample gaps > 10x median spacing. Fails when summed gap duration exceeds 5% of capture span.                                                                           |
+
+---
+
+## Client Checks
+
+The Go `chain-client` (`Test/E2E/suite/client/`) performs behavioural checks specified per
+scenario in `client_checks`:
+
+| Check     | What it verifies                                                                                |
+| --------- | ----------------------------------------------------------------------------------------------- |
+| `live`    | WebSocket connection succeeds and live binary pushes arrive with monotonic timestamps.          |
+| `zoom`    | A `zoom` WS command returns a valid binary response covering the requested time range.          |
+| `window`  | A `window` WS command returns data within the specified time bounds.                            |
+| `trigger` | A `trigger` WS command on the specified signal fires and returns data around the trigger point. |
+
+---
+
+## Stress Matrix
+
+The stress module (`stress.py` + `stress_run.py`) exercises capacity by sweeping one load axis
+at a time:
+
+| Axis               | What is scaled                                               |
+| ------------------ | ------------------------------------------------------------ |
+| Signal size        | Bytes per packet (array element count)                       |
+| Signal count       | Number of signals per source                                 |
+| Subscriber fan-out | Number of StreamHub instances subscribing to one UDPStreamer |
+| WS client count    | Parallel WebSocket clients on one StreamHub                  |
+| Zoom request rate  | Concurrent zoom queries per second per client                |
+
+Gates:
+
+- **Survival** (hard) — neither server crashed or hung.
+- **Liveness** (hard) — every client received monotonic, timestamped pushes.
+- **Peak RSS** (soft) — MARTe and StreamHub memory stayed under case ceilings.
+- **Zoom p95 latency** (soft) — round-trip zoom query latency under load.
+
+Results are written to `stress_results.json` with axis/level for scaling-curve plots.
+
+---
+
+## Artifacts
+
+| Path                                         | Content                                                             |
+| -------------------------------------------- | ------------------------------------------------------------------- |
+| `Build/x86-linux/E2E/chain/results.json`     | Per-scenario status (PASS/FAIL/SKIP/XFAIL/XPASS) + waveform metrics |
+| `Build/x86-linux/E2E/chain/report_data.json` | Full report data including regression diffs                         |
+| `Build/x86-linux/E2E/chain/history.jsonl`    | One-line-per-run headline metrics for trend tracking                |
+| `Build/x86-linux/E2E/chain/trend_*.png`      | Pass-rate / coverage / fidelity / memory trend plots                |
+| `Build/x86-linux/E2E/chain/E2E_Report.pdf`   | Compiled Typst PDF report                                           |
+| `Build/x86-linux/E2E/chain/unit_tests.json`  | Per-suite test results (GTest, Go, Python)                          |
+| `Build/x86-linux/E2E/chain/coverage.json`    | Per-language coverage percentages                                   |
+| `Build/x86-linux/E2E/chain/stress/`          | Stress matrix results                                               |
+| `Build/x86-linux/E2E/chain/hub_<id>.log`     | StreamHub stdout/stderr per scenario                                |
+| `Build/x86-linux/E2E/chain/marte_<id>.log`   | MARTe2 app stdout/stderr per scenario                               |
+| `Build/x86-linux/E2E/chain/client_<id>.log`  | Client stdout/stderr per scenario                                   |
+| `/tmp/chain_e2e/`                            | Scratch: input binaries, configs, recordings, metrics, plots        |
+
+---
+
+## XFAIL / XPASS Handling
+
+Scenarios may carry a `known_issue` marker (a human-readable string describing a documented,
+not-yet-fixed chain gap). When present:
+
+- A raw **FAIL** is reclassified as **XFAIL** (expected failure) — does not break the green
+  baseline.
+- A raw **PASS** becomes **XPASS** (unexpectedly fixed) — surfaced as a failure to prompt
+  removal of the stale marker.
+
+Overall status is PASS when there are no hard FAILs and no XPASSes.
+
+---
+
+## Framework Files
+
+| File                   | Role                                                            |
+| ---------------------- | --------------------------------------------------------------- |
+| `run_e2e.sh`           | Top-level orchestrator (build, run scenarios, coverage, report) |
+| `scenarios.py`         | Declarative scenario matrix + validation                        |
+| `gen_data.py`          | Deterministic input binary generator                            |
+| `gen_cfg.py`           | MARTe2 + StreamHub config generator                             |
+| `validate_waveform.py` | Waveform comparison (fidelity, shape, continuity)               |
+| `plots.py`             | Per-scenario PNG figure renderer                                |
+| `collect.py`           | Unit test runner + coverage collector (GTest, Go, Python, lcov) |
+| `report_build.py`      | Report data consolidator + trend plots + history                |
+| `stress.py`            | Declarative stress case matrix                                  |
+| `stress_run.py`        | Stress matrix orchestrator                                      |
+| `proc_perf.py`         | Live-process CPU/RSS snapshot from `/proc`                      |
+| `E2E_Report.typ`       | Typst template for the PDF report                               |
+| `tests_py.py`          | Python framework unit tests (`python3 -m unittest tests_py`)    |
+| `client/main.go`       | Go chain-client (live record + zoom/window/trigger checks)      |
+| `debugclient/main.go`  | Go debug/tcplogger client (command scripting + verification)    |
+
+---
+
+## Scenario Matrix
+
+| ID                            | Kind               | Description                                                                              |
+| ----------------------------- | ------------------ | ---------------------------------------------------------------------------------------- |
+| `s01_scalar_uint32`           | chain              | Single uint32 scalar counter, Strict unicast (type fidelity)                             |
+| `s02_array_float32_fullarray` | chain              | 100-elem float32 array, FullArray time mode, uint64 ns time array                        |
+| `s03_quant_uint16`            | chain              | float32 scalar quantised to uint16 over [-5,5], Strict unicast                           |
+| `s04_int8_scalar`             | chain              | int8 scalar counter, type fidelity                                                       |
+| `s05_uint8_scalar`            | chain              | uint8 scalar counter, type fidelity                                                      |
+| `s06_int16_scalar`            | chain              | int16 scalar ramp, type fidelity                                                         |
+| `s07_uint16_scalar`           | chain              | uint16 scalar ramp, type fidelity                                                        |
+| `s08_int32_scalar`            | chain              | int32 scalar counter, type fidelity                                                      |
+| `s09_int64_scalar`            | chain              | int64 scalar counter, type fidelity                                                      |
+| `s10_uint64_scalar`           | chain              | uint64 scalar counter, type fidelity                                                     |
+| `s11_float64_scalar`          | chain              | float64 scalar sine 5 Hz (double-precision path)                                         |
+| `s12_f32_arr8`                | chain              | float32 8-elem array sine 5 Hz                                                           |
+| `s13_f32_arr32`               | chain              | float32 32-elem array sine 10 Hz                                                         |
+| `s14_f64_arr64`               | chain              | float64 64-elem array ramp                                                               |
+| `s15_i16_arr16`               | chain              | int16 16-elem array counter                                                              |
+| `s16_f32_arr256`              | chain              | float32 256-elem array sine 5 Hz (large frame)                                           |
+| `s17_lastsample`              | chain              | float32 8-elem LastSample, uint64 ns scalar anchor                                       |
+| `s18_firstsample`             | chain              | float32 8-elem FirstSample, uint32 us scalar anchor                                      |
+| `s19_fullarray_f64`           | chain              | float64 50-elem FullArray sine 5 Hz, uint64 ns time                                      |
+| `s20_quant_uint8`             | chain              | float32 scalar quant uint8 [-1,1] sine 5 Hz                                              |
+| `s21_quant_int8`              | chain              | float32 scalar quant int8 [-10,10] sine 5 Hz                                             |
+| `s22_quant_int16`             | chain              | float32 scalar quant int16 [-100,100] ramp                                               |
+| `s23_quant_f64_arr`           | chain              | float64 16-elem quant uint16 [-2,2] sine 5 Hz                                            |
+| `s24_accumulate`              | chain              | float32 scalar sine 5 Hz, Accumulate @50 Hz refresh                                      |
+| `s25_decimate4`               | chain              | float32 scalar sine 5 Hz, Decimate ratio 4                                               |
+| `s26_decimate10_arr`          | chain              | float32 8-elem counter, Decimate ratio 10                                                |
+| `s27_frag_f64_128`            | chain              | float64 128-elem ramp, MaxPayload 512 (fragmented)                                       |
+| `s28_frag_f32_100`            | chain              | float32 100-elem sine 5 Hz, MaxPayload 256 (fragmented)                                  |
+| `s29_mcast_scalar`            | chain              | multicast float32 scalar sine 5 Hz                                                       |
+| `s30_mcast_arr_fullarray`     | chain              | multicast float32 32-elem FullArray sine 5 Hz                                            |
+| `s31_two_src`                 | chain              | two unicast sources: float32 sine + uint32 counter                                       |
+| `s32_three_src`               | chain              | three unicast sources: int16 ramp / float64 sine / uint8 counter                         |
+| `s33_dec_arr_quant`           | chain              | Decimate 2 + 16-elem quant uint16 sine 5 Hz                                              |
+| `s34_acc_fullarray`           | chain              | Accumulate @100 Hz: accumulated scalar + 32-elem FullArray sine passenger                |
+| `s35_mcast_decimate`          | chain              | multicast + Decimate ratio 5, float32 scalar sine 5 Hz                                   |
+| `s36_big_frag_dec`            | chain              | float64 64-elem ramp, MaxPayload 256 + Decimate 4                                        |
+| `s37_trig_ramp_i32`           | chain              | trigger on int32 ramp scalar                                                             |
+| `s38_trig_f64_sine`           | chain              | trigger on float64 sine 5 Hz scalar                                                      |
+| `s39_uint8_arr32`             | chain              | uint8 32-elem array counter (wrap fidelity)                                              |
+| `s40_int8_arr16`              | chain              | int8 16-elem array counter (wrap fidelity)                                               |
+| `s41_f32_unit`                | chain              | float32 scalar ramp with Unit=V                                                          |
+| `s42_f64_counter`             | chain              | float64 scalar counter (large integer values)                                            |
+| `s43_fullarray_quant`         | chain              | float32 16-elem FullArray quant uint16 sine 5 Hz                                         |
+| `s44_window_check`            | chain              | float32 sine 5 Hz scalar, window time-range check                                        |
+| `s45_decimate_multisig`       | chain              | Decimate ratio 2 over a 2-signal source                                                  |
+| `s46_accumulate_arr`          | chain              | Accumulate @200 Hz: accumulated scalar sine + 16-elem array passenger                    |
+| `s47_mcast_multisrc`          | chain              | multicast, two sources (scalar each)                                                     |
+| `s48_f64_arr_big_payload`     | chain              | float64 100-elem ramp, MaxPayload 65490 (single frame)                                   |
+| `s49_mixed_quant_raw`         | chain              | one source: quant uint8 sine + raw float32 sine                                          |
+| `s50_trig_quant`              | chain              | trigger on quantised uint16 sine 10 Hz                                                   |
+| `s51_8x1msps_100hz`           | chain              | 8x float32 10k-elem arrays @1 MSps, FirstSample, 100 Hz packets (~32 MB/s)               |
+| `s52_direct_unicast`          | direct             | Direct UDPStreamer->UDPStreamerClient round-trip, unicast                                |
+| `s53_direct_multicast`        | direct             | Direct UDPStreamer->UDPStreamerClient round-trip, multicast                              |
+| `s54_recorder`                | recorder           | StreamHub BinaryRecorder disk-output round-trip                                          |
+| `s55_debug_force_trace_break` | debug              | DebugService FORCE/TRACE/BREAK over real TCP 8080 + UDP 8081                             |
+| `s56_tcplogger_delivery`      | tcplogger          | TCPLogger delivers a log line for a triggered DebugService event                         |
+| `s57_debug_pause_resume`      | debug_pause_resume | DebugService PAUSE/RESUME halts and resumes the RT loop, verified via live VALUE polling |
+
+---
+
+## Coverage Goals
+
+The chain scenario matrix is a curated covering set: every configurable UDPStreamer option
+value appears in at least one scenario:
+
+- **All 10 MARTe2 types**: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64
+- **Scalar and array shapes**: elements 1, 8, 16, 32, 50, 64, 100, 128, 256, 1000, 10000
+- **All four TimeModes**: PacketTime, FullArray, FirstSample, LastSample
+- **All five QuantizedTypes**: none, uint8, int8, uint16, int16
+- **All three PublishingModes**: Strict, Accumulate, Decimate
+- **Both network modes**: unicast and multicast
+- **Fragmentation**: small MaxPayloadSize forcing multi-fragment datagrams
+- **Multi-source**: 1, 2, and 3 independent UDPStreamer feeds into one StreamHub
+- **High-risk interactions**: decimate+quant+array, accumulate+fullarray, multicast+decimate,
+  fragmentation+decimate, mixed quant+raw signals

Docs/StreamHub-Developer.md

@@ -199,28 +199,24 @@ make -f Makefile.gcc test
    # SignalRingBuffer (ReadSince / binary-search ReadRange / wrap),
    # TriggerEngine FSM, LTTB — sources in Test/Applications/StreamHub/
 
-./run_e2e_test.sh                                # full-stack E2E (see below)
+cd Test/E2E/suite && ./run_e2e.sh                # full-stack E2E (see below)
 ./run_streamhub.sh -w -g                         # interactive demo stack
 ```
 
 ### End-to-end test
 
-`./run_e2e_test.sh` builds everything, launches the demo MARTe2 application
+`Test/E2E/suite/run_e2e.sh` is the unified E2E suite covering the whole
-(`Test/Configurations/streamhub_demo.cfg`: 3 UDPStreamers — multicast scalars,
+streaming + debug chain (`chain`/`direct`/`recorder`/`debug`/`tcplogger`
-FirstSample/LastSample arrays, FullArray + uint64 ns time array) plus a
+scenario kinds, see `Test/E2E/suite/scenarios.py`), including StreamHub live
-StreamHub on port 8095 (with history enabled in `/tmp/streamhub_e2e_history`),
+push, zoom, window and trigger checks via the Go `chain-client`. It builds
-then runs the Go WS client `Test/E2E/streamhub` which verifies:
+everything, runs the scenario matrix plus the stress matrix, and produces a
-`sources`/`config` events, ≥10 binary v1 pushes with wall-clock and strictly
+consolidated `report_data.json` + Typst PDF report
-monotonic time on all streams, `stats` shape, a `zoom` round-trip (reqId echo,
+(`Test/E2E/suite/E2E_Report.typ`). See the script's `--help` for options.
-unicast), `historyInfo` broadcast (enabled, duration, decimation, signal count),
-a `historyZoom` round-trip (reqId echo, signal data), and a complete trigger
-cycle (setTrigger → arm → binary v2 capture → triggered → disarm). Logs land
-in `/tmp/streamhub_e2e_{marte,hub}.log`. Exit 0 iff every check passes.
 
 When changing the WS protocol, update **in lockstep**: this hub, the Go hub
 (`Common/Client/go/wshub`), the browser SPA (`Client/udpstreamer/static`), the
-ImGui client (`Client/streamhub/Protocol.cpp`), the E2E client
+ImGui client (`Client/streamhub/Protocol.cpp`), the E2E `chain-client`
-(`Test/E2E/streamhub`), and [StreamHub-API.md](StreamHub-API.md).
+(`Test/E2E/suite/client`), and [StreamHub-API.md](StreamHub-API.md).
 
 ## 8. Gotchas
 

Docs/UDPStreamer.md

@@ -8,7 +8,9 @@ thread.
 ## Key Features
 
 - **Zero-copy RT path** — `Synchronise()` only locks, copies signal memory, and posts a semaphore.
-- **Single-client model** — one client at a time; a new CONNECT replaces the previous session.
+- **Unicast and multicast** — unicast (default): single client at a time, new CONNECT replaces
+  the previous session. Multicast: multiple clients receive data simultaneously by joining
+  a multicast group; control traffic uses a TCP listener.
 - **Packet fragmentation** — large payloads are split into ≤ `MaxPayloadSize`-byte datagrams,
   each with a header carrying fragment index and total count so the client can reassemble them.
 - **Signal quantization** — `float32`/`float64` signals can be linearly quantized to
@@ -16,6 +18,8 @@ thread.
 - **Temporal arrays** — signals with `NumberOfElements > 1` can carry per-sample time
   metadata via `TimeMode` and `TimeSignal`, enabling high-frequency burst transmission
   (e.g. 1 000 samples per RT cycle at 1 MSps).
+- **Publishing modes** — `Strict` (one packet per RT cycle), `Accumulate` (batch N snapshots
+  then flush on size or time limit), `Decimate` (send every Nth cycle).
 
 ---
 
@@ -26,10 +30,22 @@ thread.
     Class           = UDPStreamer
 
     // Network
-    Port            = 44500        // UDP port the server listens on (default: 44500)
+    Port            = 44500        // UDP port (unicast) or TCP control port (multicast)
     MaxPayloadSize  = 1400         // Maximum bytes per UDP datagram (default: 1400)
                                    //   Must be > 17 (header size). Tune for MTU.
 
+    // Multicast (optional — omit for unicast mode)
+    MulticastGroup  = "239.0.0.1"  // IPv4 multicast address (224.0.0.0/4)
+    Interface       = "eth0"       // Multicast-bound interface (mandatory when MulticastGroup is set)
+    DataPort        = 44501        // UDP port for multicast DATA (default: Port+1)
+
+    // Publishing mode (optional)
+    PublishingMode  = "Strict"     // Strict | Accumulate | Decimate
+    // For Accumulate mode:
+    MinRefreshRate  = 120.0        // Flush frequency in Hz (required for Accumulate)
+    // For Decimate mode:
+    Ratio           = 10           // Send 1 packet every N RT cycles (required for Decimate)
+
     // Background thread (optional)
     CPUMask         = 0x2          // CPU affinity mask for the network thread
     StackSize       = 1048576      // Stack size in bytes (default: 1 MiB)
@@ -66,34 +82,40 @@ thread.
 
 ### Top-level Parameters
 
-| Parameter | Type | Default | Description |
+| Parameter        | Type   | Default          | Description                                                                 |
-|-----------|------|---------|-------------|
+| ---------------- | ------ | ---------------- | --------------------------------------------------------------------------- |
-| `Port` | uint16 | 44500 | UDP server port |
+| `Port`           | uint16 | 44500            | UDP server port (unicast) or TCP control port (multicast). Values ≤ 1024 produce a warning. |
-| `MaxPayloadSize` | uint32 | 1400 | Max payload bytes per UDP datagram (min 18) |
+| `MaxPayloadSize` | uint32 | 1400             | Max payload bytes per UDP datagram (min 18)                                 |
-| `CPUMask` | uint32 | 0 (any) | Background thread CPU affinity |
+| `MulticastGroup` | string | *(absent)*       | IPv4 multicast address (e.g. `"239.0.0.1"`). Must be in 224.0.0.0/4. Absent or empty = unicast mode. |
-| `StackSize` | uint32 | 1 048 576 | Background thread stack size in bytes |
+| `Interface`      | string | *(absent)*       | Network interface for multicast binding (e.g. `"eth0"`). **Mandatory** when `MulticastGroup` is set. |
+| `DataPort`       | uint16 | Port+1           | UDP port for multicast DATA datagrams. Ignored in unicast mode.             |
+| `PublishingMode` | string | Strict           | `Strict`: send every RT cycle. `Accumulate`: batch until size/time limit. `Decimate`: send every Nth cycle. |
+| `MinRefreshRate` | float64| —                | Flush frequency in Hz. **Required** when `PublishingMode` = `Accumulate`.   |
+| `Ratio`          | uint32 | —                | Send 1 packet every `Ratio` RT cycles. **Required** when `PublishingMode` = `Decimate`. |
+| `CPUMask`        | uint32 | 0xFFFFFFFF (any) | Background thread CPU affinity bitmask                                      |
+| `StackSize`      | uint32 | MARTe2 default   | Background thread stack size in bytes                                       |
 
 ### Per-signal Parameters
 
-| Parameter | Type | Default | Applies to |
+| Parameter       | Type    | Default      | Applies to                                               |
-|-----------|------|---------|------------|
+| --------------- | ------- | ------------ | -------------------------------------------------------- |
-| `Unit` | string | `""` | Any type — informational, forwarded to client in CONFIG |
+| `Unit`          | string  | `""`         | Any type — informational, forwarded to client in CONFIG  |
-| `RangeMin` | float64 | 0.0 | float32/float64 with `QuantizedType` |
+| `RangeMin`      | float64 | 0.0          | float32/float64 with `QuantizedType`                     |
-| `RangeMax` | float64 | 1.0 | float32/float64 with `QuantizedType` |
+| `RangeMax`      | float64 | 1.0          | float32/float64 with `QuantizedType`                     |
-| `QuantizedType` | string | `none` | float32/float64 only |
+| `QuantizedType` | string  | `none`       | float32/float64 only                                     |
-| `TimeMode` | string | `PacketTime` | Signals with `NumberOfElements > 1` |
+| `TimeMode`      | string  | `PacketTime` | Signals with `NumberOfElements > 1`                      |
-| `TimeSignal` | string | — | Required when `TimeMode` ≠ `PacketTime` |
+| `TimeSignal`    | string  | —            | Required when `TimeMode` ≠ `PacketTime`                  |
-| `SamplingRate` | float64 | 0.0 | Required when `TimeMode` = `FirstSample` or `LastSample` |
+| `SamplingRate`  | float64 | 0.0          | Required when `TimeMode` = `FirstSample` or `LastSample` |
 
 ### Quantization Types
 
-| Value | Wire type | Bit depth | Notes |
+| Value    | Wire type      | Bit depth | Notes                                             |
-|-------|-----------|-----------|-------|
+| -------- | -------------- | --------- | ------------------------------------------------- |
-| `none` | same as source | — | Raw copy, no quantization |
+| `none`   | same as source | —         | Raw copy, no quantization                         |
-| `uint8` | uint8 | 8-bit | Maps `[RangeMin, RangeMax]` → `[0, 255]` |
+| `uint8`  | uint8          | 8-bit     | Maps `[RangeMin, RangeMax]` → `[0, 255]`          |
-| `int8` | int8 | 8-bit | Maps `[RangeMin, RangeMax]` → `[-127, 127]` |
+| `int8`   | int8           | 8-bit     | Maps `[RangeMin, RangeMax]` → `[-127, 127]`       |
-| `uint16` | uint16 | 16-bit | Maps `[RangeMin, RangeMax]` → `[0, 65 535]` |
+| `uint16` | uint16         | 16-bit    | Maps `[RangeMin, RangeMax]` → `[0, 65 535]`       |
-| `int16` | int16 | 16-bit | Maps `[RangeMin, RangeMax]` → `[-32 767, 32 767]` |
+| `int16`  | int16          | 16-bit    | Maps `[RangeMin, RangeMax]` → `[-32 767, 32 767]` |
 
 Quantization formula (unsigned, e.g. uint16):
 
@@ -104,12 +126,68 @@ wire_value = (uint16)(normalized × 65535)
 
 ### Time Modes
 
-| Value | Meaning | Requirements |
+| Value         | Meaning                                                                                                                         | Requirements                                        |
-|-------|---------|--------------|
+| ------------- | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
-| `PacketTime` | The HRT counter captured at `Synchronise()` time is used as the packet timestamp. No per-signal time metadata. | — |
+| `PacketTime`  | The HRT counter captured at `Synchronise()` time is used as the packet timestamp. No per-signal time metadata.                  | —                                                   |
-| `FullArray` | `TimeSignal` carries one timestamp per element (same `NumberOfElements`). | `TimeSignal` must have the same `NumberOfElements`. |
+| `FullArray`   | `TimeSignal` carries one timestamp per element (same `NumberOfElements`).                                                       | `TimeSignal` must have the same `NumberOfElements`. |
-| `FirstSample` | `TimeSignal` is a scalar giving the timestamp of element `[0]`. Elements `[1..N-1]` are inferred at `1/SamplingRate` intervals. | Scalar `TimeSignal`; `SamplingRate > 0`. |
+| `FirstSample` | `TimeSignal` is a scalar giving the timestamp of element `[0]`. Elements `[1..N-1]` are inferred at `1/SamplingRate` intervals. | Scalar `TimeSignal`; `SamplingRate > 0`.            |
-| `LastSample` | Same as `FirstSample` but `TimeSignal` is the timestamp of element `[N-1]`. | Scalar `TimeSignal`; `SamplingRate > 0`. |
+| `LastSample`  | Same as `FirstSample` but `TimeSignal` is the timestamp of element `[N-1]`.                                                     | Scalar `TimeSignal`; `SamplingRate > 0`.            |
+
+---
+
+## Network Modes
+
+### Unicast (default)
+
+The server opens a single UDP socket on `Port`. The client initiates the session by sending a
+CONNECT packet to that port. The server replies with a CONFIG packet on the same socket and
+subsequently sends DATA packets directly to the client's address. One client at a time; a new
+CONNECT evicts the previous client.
+
+### Multicast
+
+Enabled by setting `MulticastGroup` to a valid IPv4 multicast address (224.0.0.0/4).
+The `Interface` parameter is **mandatory** and specifies the network interface to bind.
+
+The server opens a TCP listener on `Port` for control traffic and a UDP socket aimed at
+`MulticastGroup:DataPort` for data traffic. The client:
+
+1. Connects to `Port` via TCP and sends a CONNECT packet.
+2. Receives the CONFIG packet over TCP.
+3. Joins the multicast group (`MulticastGroup:DataPort`) to receive DATA packets.
+
+Multiple clients may receive data simultaneously by joining the same group.
+
+---
+
+## Publishing Modes
+
+### Strict (default)
+
+Sends one DATA packet for every `Synchronise()` call (every RT cycle). Simplest and lowest
+latency.
+
+### Accumulate
+
+Batches multiple RT-cycle snapshots into a single DATA packet. All signals (scalars and arrays)
+are accumulated: one full snapshot per RT cycle. The batch is flushed when either:
+
+- **Size condition**: adding one more sample would exceed `MaxPayloadSize`.
+- **Time condition**: `1/MinRefreshRate` seconds have elapsed since the last flush.
+
+The maximum batch count is computed automatically from `MaxPayloadSize` and the total wire size
+of all signals. Scalar signals with `Unit="us"` or `"ns"` are auto-promoted as the per-sample
+FullArray time reference for all other scalars.
+
+Requires `MinRefreshRate` (Hz) to be set.
+
+### Decimate
+
+Sends one DATA packet every `Ratio` RT cycles, dropping intermediate cycles. Only the most
+recent snapshot at the Nth cycle is sent.
+
+Requires `Ratio` (≥ 1) to be set. `Ratio = 1` is equivalent to `Strict` mode (a warning is
+logged).
 
 ---
 
@@ -151,7 +229,7 @@ PrepareNextState()          ← opens UDP server socket, starts background threa
 
 ---
 
-## Example: minimal scalar streaming
+## Example: minimal scalar streaming (unicast)
 
 ```
 +Data = {
@@ -168,6 +246,26 @@ PrepareNextState()          ← opens UDP server socket, starts background threa
 }
 ```
 
+## Example: multicast with accumulation
+
+```
++Streamer = {
+    Class            = UDPStreamer
+    Port             = 44500           // TCP control port
+    MulticastGroup   = "239.0.0.1"     // Enables multicast mode
+    Interface        = "eth0"          // Mandatory for multicast
+    DataPort         = 44501           // UDP data port (default: Port+1)
+    MaxPayloadSize   = 1400
+    PublishingMode   = "Accumulate"
+    MinRefreshRate   = 60.0            // Flush at least 60 times/s
+
+    Signals = {
+        Time    = { Type = uint32; Unit = "us" }
+        Voltage = { Type = float32; Unit = "V"; RangeMin = -10.0; RangeMax = 10.0; QuantizedType = uint16 }
+    }
+}
+```
+
 ## Example: high-frequency burst
 
 ```
@@ -198,3 +296,19 @@ With `MaxPayloadSize = 1400`, a single 1000-element float32 signal produces:
 payload = 8 B (HRT timestamp) + 4 B (T0/uint32) + 4000 B (float32×1000) = 4012 B
 fragments = ceil(4012 / 1383) = 3
 ```
+
+## Example: decimated output
+
+```
++Streamer = {
+    Class          = UDPStreamer
+    Port           = 44500
+    PublishingMode = "Decimate"
+    Ratio          = 10                // Send 1 packet every 10 RT cycles
+
+    Signals = {
+        Time     = { Type = uint32; Unit = "us" }
+        Position = { Type = float64; Unit = "mm" }
+    }
+}
+```

Makefile.gcc

@@ -25,6 +25,7 @@ core:
 
 test:
 	$(MAKE) -C Test/Components/DataSources/UDPStreamer -f Makefile.gcc
+	$(MAKE) -C Test/Components/DataSources/UDPStreamerClient -f Makefile.gcc
 	$(MAKE) -C Test/Applications/StreamHub -f Makefile.gcc
 	$(MAKE) -C Test/GTest -f Makefile.gcc
 	$(MAKE) -C Test/Integration -f Makefile.gcc
@@ -39,6 +40,7 @@ clean:
 	$(MAKE) -C Source/Components/Interfaces/TCPLogger -f Makefile.gcc clean
 	$(MAKE) -C Source/Components/Interfaces/DebugService -f Makefile.gcc clean
 	$(MAKE) -C Test/Components/DataSources/UDPStreamer -f Makefile.gcc clean
+	$(MAKE) -C Test/Components/DataSources/UDPStreamerClient -f Makefile.gcc clean
 	$(MAKE) -C Test/Applications/StreamHub -f Makefile.gcc clean
 	$(MAKE) -C Test/GTest -f Makefile.gcc clean
 	$(MAKE) -C Test/Integration -f Makefile.gcc clean

README.md

@@ -9,15 +9,15 @@ for control applications built with [MARTe2](https://vcis.f4e.europa.eu/marte2-d
 
 This repository integrates two complementary capabilities:
 
-| Capability | Component | Purpose |
+| Capability            | Component                | Purpose                                                                                                       |
-|---|---|---|
+| --------------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------- |
-| **Signal streaming** | `UDPStreamer` DataSource | Continuously stream selected signals to a browser-based oscilloscope over UDP |
+| **Signal streaming**  | `UDPStreamer` DataSource | Continuously stream selected signals to a browser-based oscilloscope over UDP                                 |
-| **Signal debugging** | `DebugService` Interface | On-demand signal tracing, value forcing, and conditional breakpoints — zero application code changes required |
+| **Signal debugging**  | `DebugService` Interface | On-demand signal tracing, value forcing, and conditional breakpoints — zero application code changes required |
-| **Sine generation** | `SineArrayGAM` | Generate continuous sine-wave arrays for testing and simulation |
+| **Sine generation**   | `SineArrayGAM`           | Generate continuous sine-wave arrays for testing and simulation                                               |
-| **Time stamping** | `TimeArrayGAM` | Provide time-reference arrays aligned to an RT cycle |
+| **Time stamping**     | `TimeArrayGAM`           | Provide time-reference arrays aligned to an RT cycle                                                          |
-| **Log forwarding** | `TCPLogger` Interface | Forward `REPORT_ERROR` log events to TCP clients in real time |
+| **Log forwarding**    | `TCPLogger` Interface    | Forward `REPORT_ERROR` log events to TCP clients in real time                                                 |
-| **Integrated client** | `Common/Client/go` | Go packages for UDPS protocol and WebSocket hub |
+| **Integrated client** | `Common/Client/go`       | Go packages for UDPS protocol and WebSocket hub                                                               |
-| **Debug web client** | `Client/debugger` | Browser-based debug UI communicating with `DebugService` |
+| **Debug web client**  | `Client/debugger`        | Browser-based debug UI communicating with `DebugService`                                                      |
 
 ---
 
@@ -49,9 +49,9 @@ MARTe_Integrated_components/
 
 ### UDPStreamer DataSource
 
-Streams MARTe2 signals over UDP using the UDPS binary protocol.  Clients register by
+Streams MARTe2 signals over UDP using the UDPS binary protocol. Clients register by
 sending a `CONNECT` packet; the server then sends `CONFIG` (signal metadata) and continuous
-`DATA` packets.  Features:
+`DATA` packets. Features:
 
 - Optional 16-bit quantization (configurable per signal: `QuantizedType`)
 - Packed high-frequency bursts (`NumberOfElements > 1` with `SamplingRate`)
@@ -61,8 +61,8 @@ See `Docs/UDPStreamer.md` and `Docs/Protocol.md`.
 
 ### SineArrayGAM
 
-Generates a continuous float32 sine-wave array every RT cycle.  Used as a signal
+Generates a continuous float32 sine-wave array every RT cycle. Used as a signal
-source for testing and demo applications.  Configurable: `Frequency`, `Amplitude`,
+source for testing and demo applications. Configurable: `Frequency`, `Amplitude`,
 `Phase`, `SamplingRate`, `NumberOfElements`.
 
 See `Docs/SineArrayGAM.md`.
@@ -75,12 +75,13 @@ configured `SamplingRate`.
 
 ### DebugService Interface
 
-Instruments a running MARTe2 application **without modifying its source code**.  On
+Instruments a running MARTe2 application **without modifying its source code**. On
 `Initialise()` it patches the `ClassRegistryDatabase` to wrap all standard
-`MemoryMap*Broker` types.  When `RealTimeApplication::ConfigureApplication()` runs
+`MemoryMap*Broker` types. When `RealTimeApplication::ConfigureApplication()` runs
 afterward the application transparently uses the wrapped brokers.
 
 Capabilities accessible over TCP (port 8080 by default):
+
 - `DISCOVER` — enumerate all signals with type and alias metadata
 - `TRACE` — enable/disable high-speed UDP telemetry per signal (with decimation)
 - `FORCE` / `UNFORCE` — inject persistent values into signals on the RT path
@@ -98,7 +99,7 @@ See `Docs/DebugService.md`.
 ### TCPLogger Interface
 
 A `LoggerConsumerI` that forwards every MARTe2 `REPORT_ERROR` call to up to 8 TCP
-clients on a configurable port.  Works as a sidecar to `DebugService`.
+clients on a configurable port. Works as a sidecar to `DebugService`.
 
 ### StreamHub Application
 
@@ -108,7 +109,7 @@ UDPStreamer sources and serves them to oscilloscope clients over WebSocket
 hub-side trigger engine, per-window zoom. Clients: browser SPA
 (`Client/webui` + `Client/udpstreamer/static`) and native ImGui desktop client
 (`Client/streamhub`). Demo: `./run_streamhub.sh -w -g`; E2E test:
-`./run_e2e_test.sh`.
+`Test/E2E/suite/run_e2e.sh`.
 
 See `Docs/StreamHub-UserGuide.md`, `Docs/StreamHub-API.md` and
 `Docs/StreamHub-Developer.md`.
@@ -116,7 +117,7 @@ See `Docs/StreamHub-UserGuide.md`, `Docs/StreamHub-API.md` and
 ### UDPS Protocol
 
 The `Common/UDP/UDPSProtocol.h` header defines the shared binary wire format used by
-both `UDPStreamer` and `DebugService`.  It is intentionally free of MARTe2-specific
+both `UDPStreamer` and `DebugService`. It is intentionally free of MARTe2-specific
 dependencies so it can also be used by Go clients (via `Common/Client/go/udpsprotocol`).
 
 See `Docs/Protocol.md`.
@@ -224,18 +225,18 @@ Open `http://localhost:9090`, explore the object tree, trace signals, force valu
 
 ## Documentation
 
-| Document | Contents |
+| Document                      | Contents                                                       |
-|---|---|
+| ----------------------------- | -------------------------------------------------------------- |
-| `Docs/Protocol.md` | UDPS binary wire protocol specification |
+| `Docs/Protocol.md`            | UDPS binary wire protocol specification                        |
-| `Docs/UDPStreamer.md` | UDPStreamer DataSource configuration reference |
+| `Docs/UDPStreamer.md`         | UDPStreamer DataSource configuration reference                 |
-| `Docs/SineArrayGAM.md` | SineArrayGAM configuration reference |
+| `Docs/SineArrayGAM.md`        | SineArrayGAM configuration reference                           |
-| `Docs/DebugService.md` | DebugService TCP API and architecture |
+| `Docs/DebugService.md`        | DebugService TCP API and architecture                          |
-| `Docs/Tutorial.md` | Step-by-step tutorial covering both components |
+| `Docs/Tutorial.md`            | Step-by-step tutorial covering both components                 |
-| `Docs/WebUI.md` | Web client user guide |
+| `Docs/WebUI.md`               | Web client user guide                                          |
-| `Docs/StreamHub-UserGuide.md` | StreamHub oscilloscope user guide (web + ImGui clients) |
+| `Docs/StreamHub-UserGuide.md` | StreamHub oscilloscope user guide (web + ImGui clients)        |
-| `Docs/StreamHub-API.md` | StreamHub WebSocket protocol (commands, events, binary frames) |
+| `Docs/StreamHub-API.md`       | StreamHub WebSocket protocol (commands, events, binary frames) |
-| `Docs/StreamHub-Developer.md` | StreamHub internals, threading, time base, build & E2E tests |
+| `Docs/StreamHub-Developer.md` | StreamHub internals, threading, time base, build & E2E tests   |
-| `ARCHITECTURE.md` | System architecture overview |
+| `ARCHITECTURE.md`             | System architecture overview                                   |
 
 ---
 

Source/Applications/StreamHub/StreamHub.cpp

@@ -750,6 +750,7 @@ void StreamHub::OnWSCommand(const char *json, uint32 /*len*/, uint32 slotIdx) {
     else if (strcmp(type, "rearm")        == 0) { HandleRearm();            }
     else if (strcmp(type, "trigStop")     == 0) { HandleTrigStop(json);     }
     else if (strcmp(type, "setTrigger")   == 0) { HandleSetTrigger(json);   }
+    else if (strcmp(type, "forceTrigger") == 0) { HandleForceTrigger();     }
     else if (strcmp(type, "zoom")         == 0) { HandleZoom(json, slotIdx); }
     else if (strcmp(type, "historyZoom")  == 0) { HandleHistoryZoom(json, slotIdx); }
     else if (strcmp(type, "historyInfo")  == 0) { HandleHistoryInfo(slotIdx); }
@@ -1017,6 +1018,12 @@ void StreamHub::HandleRearm() {
     HandleArm();
 }
 
+void StreamHub::HandleForceTrigger() {
+    rearmPending_ = false;
+    (void) trigger_.Force();
+    BroadcastTriggerState();
+}
+
 void StreamHub::HandleTrigStop(const char *json) {
     /* {"type":"trigStop","stopped":bool} — absent "stopped" toggles. */
     bool stopped = !trigger_.GetStopped();

Source/Applications/StreamHub/StreamHub.h

@@ -140,6 +140,7 @@ private:
     void HandleRearm();
     void HandleTrigStop(const char *json);
     void HandleSetTrigger(const char *json);
+    void HandleForceTrigger();
     void HandleZoom(const char *json, uint32 slotIdx);
     void HandleHistoryZoom(const char *json, uint32 slotIdx);
     void HandleHistoryInfo(uint32 slotIdx);

Source/Applications/StreamHub/TriggerEngine.cpp

@@ -14,6 +14,8 @@ TriggerEngine::TriggerEngine()
       stopped_(false),
       prevValue_(0.0),
       prevValid_(false),
+      lastTime_(0.0),
+      lastTimeValid_(false),
       trigTime_(0.0),
       firedPreSec_(0.0),
       firedPostSec_(0.0),
@@ -82,6 +84,11 @@ bool TriggerEngine::GetStopped() const {
 void TriggerEngine::CheckSample(float64 t, float64 v) {
     (void) mutex_.FastLock();
 
+    /* Track the newest watched timestamp in every state so Force() has a
+     * reference time to latch the capture window around. */
+    lastTime_      = t;
+    lastTimeValid_ = true;
+
     if (state_ != kTrigArmed) {
         mutex_.FastUnLock();
         return;
@@ -122,6 +129,25 @@ void TriggerEngine::CheckSample(float64 t, float64 v) {
     mutex_.FastUnLock();
 }
 
+bool TriggerEngine::Force() {
+    (void) mutex_.FastLock();
+
+    bool ok = lastTimeValid_ && (state_ != kTrigCollecting);
+    if (ok) {
+        state_        = kTrigCollecting;
+        trigTime_     = lastTime_;
+        firedPreSec_  = config_.windowSec * config_.prePercent / 100.0;
+        firedPostSec_ = config_.windowSec - firedPreSec_;
+        firedValid_   = true;
+        REPORT_ERROR_STATIC(MARTe::ErrorManagement::Information,
+                            "TriggerEngine: forced at t=%.6f (pre=%.4fs post=%.4fs)",
+                            trigTime_, firedPreSec_, firedPostSec_);
+    }
+
+    mutex_.FastUnLock();
+    return ok;
+}
+
 TrigState TriggerEngine::GetState() const {
     (void) mutex_.FastLock();
     TrigState ret = state_;

Source/Applications/StreamHub/TriggerEngine.h

@@ -106,6 +106,15 @@ public:
      */
     void CheckSample(float64 t, float64 v);
 
+    /**
+     * @brief Fire the trigger unconditionally at the most recent sample time of
+     * the watched signal, latching the pre/post window exactly as CheckSample
+     * does.  Any state except COLLECTING → COLLECTING.
+     * @return false when no sample has been seen yet, or a capture is already
+     * being collected.
+     */
+    bool Force();
+
     /** @return Current FSM state. */
     TrigState GetState() const;
 
@@ -127,6 +136,8 @@ private:
     bool          stopped_;
     float64       prevValue_;    ///< Last sample (edge detection)
     bool          prevValid_;    ///< First-sample guard in ARMED state
+    float64       lastTime_;     ///< Timestamp of the newest watched sample
+    bool          lastTimeValid_;///< true once a watched sample has been seen
     float64       trigTime_;     ///< Latched trigger time (Unix s)
     float64       firedPreSec_;  ///< Window pre-part latched at fire time
     float64       firedPostSec_; ///< Window post-part latched at fire time

Source/Applications/StreamHub/UDPSourceSession.cpp

@@ -220,6 +220,9 @@ void UDPSourceSession::ParseConfigPayload(const uint8 *payload, uint32 size) {
         memcpy(&sigDescs_[i],
                payload + 4u + i * UDPS_SIGNAL_DESC_SIZE,
                UDPS_SIGNAL_DESC_SIZE);
+        /* MD-3: force null-termination of name/unit to prevent intra-struct OOB read */
+        sigDescs_[i].name[sizeof(sigDescs_[i].name) - 1u] = '\0';
+        sigDescs_[i].unit[sizeof(sigDescs_[i].unit) - 1u] = '\0';
     }
     publishMode_ = payload[4u + numSigs * UDPS_SIGNAL_DESC_SIZE];
     numSignals_  = numSigs;
@@ -237,8 +240,11 @@ void UDPSourceSession::ParseConfigPayload(const uint8 *payload, uint32 size) {
     /* (Re)allocate the time-signal decode scratch to the largest element count. */
     uint32 maxElems = 1u;
     for (uint32 i = 0u; i < numSigs; i++) {
-        uint32 ne = sigDescs_[i].numRows * sigDescs_[i].numCols;
+        uint64 ne = static_cast<uint64>(sigDescs_[i].numRows) *
-        if (ne > maxElems) { maxElems = ne; }
+                    static_cast<uint64>(sigDescs_[i].numCols);
+        if (ne == 0u) { ne = 1u; }
+        if (ne > 0x100000u) { ne = 0x100000u; /* sanity cap */ }
+        if (ne > maxElems) { maxElems = static_cast<uint32>(ne); }
     }
     if (maxElems > timeScratchLen_) {
         delete[] timeScratch_;
@@ -343,22 +349,36 @@ void UDPSourceSession::ParseDataPayload(const uint8 *payload, uint32 size) {
     uint32 off = offset;
     for (uint32 s = 0u; s < nSigs; s++) {
         const UDPSSignalDescriptor &desc = descs[s];
-        uint32 numElements = desc.numRows * desc.numCols;
+        /* HI-1: use 64-bit multiply to avoid overflow on attacker-controlled numRows/numCols */
-        if (numElements == 0u) { numElements = 1u; }
+        uint64 numElements64 = static_cast<uint64>(desc.numRows) *
+                               static_cast<uint64>(desc.numCols);
+        if (numElements64 == 0u) { numElements64 = 1u; }
+        if (numElements64 > 0x100000u) { return; /* sanity cap: 1M elements */ }
+        uint32 numElements = static_cast<uint32>(numElements64);
 
         uint32 wireElemBytes = (desc.quantType != UDPS_QUANT_NONE)
                                ? QuantWireBytes(desc.quantType)
                                : MARTe::UDPSTypeCodeByteSize(desc.typeCode);
         if (wireElemBytes == 0u) { return; }
 
-        uint32 elemsToRead = ((pm == UDPS_PUBLISH_ACCUMULATE) && (numElements == 1u))
+        /* Accumulate mode batches one full snapshot (all elements) per RT
-                             ? numSamples
+         * cycle for every signal (scalar or array) — see UDPStreamer's
-                             : numElements;
+         * SerializeAccumulated. HI-1: 64-bit multiply to avoid overflow on
+         * attacker-controlled numSamples. */
+        uint64 elemsToRead64 = (pm == UDPS_PUBLISH_ACCUMULATE)
+                               ? (numElements64 * static_cast<uint64>(numSamples))
+                               : numElements64;
+        if (elemsToRead64 > 0x100000u) { return; /* sanity cap: 1M elements */ }
+        uint32 elemsToRead = static_cast<uint32>(elemsToRead64);
 
-        if (off + elemsToRead * wireElemBytes > size) { return; }
+        /* HI-1: 64-bit bounds check to prevent uint32 multiply overflow */
+        uint64 bytesNeeded = static_cast<uint64>(off) +
+                             static_cast<uint64>(elemsToRead) *
+                             static_cast<uint64>(wireElemBytes);
+        if (bytesNeeded > static_cast<uint64>(size)) { return; }
         sigOff[s]   = off;
         sigElems[s] = elemsToRead;
-        off += elemsToRead * wireElemBytes;
+        off += static_cast<uint32>(elemsToRead * wireElemBytes);
     }
 
     /* The decode scratch is sized at CONFIG time to the largest per-signal
@@ -389,8 +409,10 @@ void UDPSourceSession::ParseDataPayload(const uint8 *payload, uint32 size) {
 
     for (uint32 s = 0u; s < nSigs; s++) {
         const UDPSSignalDescriptor &desc = descs[s];
-        uint32 numElements = desc.numRows * desc.numCols;
+        uint64 ne64 = static_cast<uint64>(desc.numRows) *
-        if (numElements == 0u) { numElements = 1u; }
+                      static_cast<uint64>(desc.numCols);
+        if (ne64 == 0u) { ne64 = 1u; }
+        uint32 numElements = static_cast<uint32>(ne64);
         const uint32 nElems = sigElems[s];
 
         const bool isFirstLast = (numElements > 1u) &&

Source/Applications/StreamHub/WSServer.cpp

@@ -199,6 +199,52 @@ bool WSServer::UpgradeHTTP(BasicTCPSocket *sock) {
         if (strstr(hdrBuf, "\r\n\r\n") != static_cast<char *>(0)) { break; }
     }
 
+    /* Origin validation (CSWSH / CSRF defence, RFC 6455 §10.2).
+     * If an Origin header is present, its host must match the Host header
+     * (same-origin).  Non-browser clients (no Origin) are allowed. */
+    const char *originHdr = FindSubstr(hdrBuf, "Origin:");
+    if (originHdr != static_cast<const char *>(0)) {
+        originHdr += 7; /* skip "Origin:" */
+        while (*originHdr == ' ') { originHdr++; }
+        /* Extract the host part of Origin: "scheme://host[:port]" */
+        char originHost[256];
+        uint32 ohLen = 0u;
+        const char *op = originHdr;
+        /* Skip scheme:// */
+        const char *schemeEnd = strstr(op, "://");
+        if (schemeEnd != static_cast<const char *>(0)) { op = schemeEnd + 3; }
+        while (*op != '\r' && *op != '\n' && *op != '\0' &&
+               *op != '/' && ohLen < 255u) {
+            originHost[ohLen++] = *op++;
+        }
+        originHost[ohLen] = '\0';
+
+        /* Extract Host header value */
+        const char *hostHdr = FindSubstr(hdrBuf, "Host:");
+        if (hostHdr != static_cast<const char *>(0)) {
+            hostHdr += 5; /* skip "Host:" */
+            while (*hostHdr == ' ') { hostHdr++; }
+            char hostVal[256];
+            uint32 hvLen = 0u;
+            while (*hostHdr != '\r' && *hostHdr != '\n' &&
+                   *hostHdr != '\0' && hvLen < 255u) {
+                hostVal[hvLen++] = *hostHdr++;
+            }
+            hostVal[hvLen] = '\0';
+            if (strcmp(originHost, hostVal) != 0) {
+                /* Cross-origin — reject the upgrade */
+                const char *forbidden =
+                    "HTTP/1.1 403 Forbidden\r\n"
+                    "Content-Type: text/plain\r\n"
+                    "Connection: close\r\n"
+                    "\r\nOrigin not allowed\r\n";
+                uint32 forbLen = static_cast<uint32>(strlen(forbidden));
+                (void) sock->Write(forbidden, forbLen);
+                return false;
+            }
+        }
+    }
+
     /* Find Sec-WebSocket-Key */
     const char *keyHdr = FindSubstr(hdrBuf, "Sec-WebSocket-Key:");
     if (keyHdr == static_cast<const char *>(0)) { return false; }
@@ -246,8 +292,9 @@ void WSServer::ClientReadLoop(uint32 slotIdx) {
     WSClientSlot &slot = clients[slotIdx];
     BasicTCPSocket *sock = slot.sock;
 
-    /* Receive buffer (grows as needed by simple state machine) */
+    /* Receive buffer: WS_MAX_RECV_PAYLOAD + max header (14: 2 + 8 ext-length +
-    static const uint32 kRecvBuf = WS_MAX_RECV_PAYLOAD + 14u;
+     * 4 mask) + 1 spare byte for in-place NUL-termination of the payload. */
+    static const uint32 kRecvBuf = WS_MAX_RECV_PAYLOAD + 14u + 1u;
     uint8 *buf = new uint8[kRecvBuf];
     uint32 filled = 0u;
 
@@ -431,6 +478,9 @@ uint32 WSServer::AllocSlot(BasicTCPSocket *sock) {
 
 void WSServer::FreeSlot(uint32 idx) {
     if (idx >= WS_MAX_CLIENTS) { return; }
+    /* HI-5: acquire writeMutex before modifying active/sock to prevent
+     * use-after-free when BroadcastText/BroadcastBinary are iterating. */
+    (void) clients[idx].writeMutex.FastLock();
     (void) clientsMutex.FastLock();
     if (clients[idx].active) {
         clients[idx].active = false;
@@ -442,6 +492,7 @@ void WSServer::FreeSlot(uint32 idx) {
         if (numClients > 0u) { numClients--; }
     }
     clientsMutex.FastUnLock();
+    clients[idx].writeMutex.FastUnLock();
 }
 
 } /* namespace StreamHub */

Source/Components/DataSources/UDPStreamer/UDPStreamer.h

@@ -103,7 +103,7 @@ struct UDPStreamerSignalInfo {
     uint32              srcByteSize;    /**< Bytes in MARTe2 memory */
     uint32              wireByteSize;   /**< Bytes on the wire (may differ when quantized) */
     uint32              bufferOffset;   /**< Byte offset in the flat MemoryDataSourceI memory buffer */
-    bool                accumulated;    /**< True when this scalar was expanded to flushCount elements in Auto accumulation mode */
+    bool                accumulated;    /**< True when this signal is batched (one snapshot per RT cycle) in Accumulate mode */
 };
 
 /**
@@ -140,16 +140,17 @@ struct UDPStreamerSignalInfo {
  *   fragmented into multiple datagrams if payload exceeds MaxPayloadSize).
  *
  * @par Top-level configuration parameters
- * | Parameter       | Type    | Default | Description |
+ * | Parameter       | Type    | Default          | Description |
- * |-----------------|---------|---------|-------------|
+ * |-----------------|---------|------------------|-------------|
- * | Port            | uint16  | 44500   | TCP control port (multicast) or UDP server port (unicast). Values ≤ 1024 produce a warning. |
+ * | Port            | uint16  | 44500            | TCP control port (multicast) or UDP server port (unicast). Values ≤ 1024 produce a warning. |
- * | MulticastGroup  | string  | *(absent)* | **Enables multicast mode.** IPv4 multicast address, e.g. `"239.0.0.1"`. Must be in 224.0.0.0/4. Absent or empty = unicast. |
+ * | MulticastGroup  | string  | *(absent)*       | **Enables multicast mode.** IPv4 multicast address, e.g. `"239.0.0.1"`. Must be in 224.0.0.0/4. Absent or empty = unicast. |
- * | DataPort        | uint16  | Port+1  | UDP port for multicast DATA datagrams. Ignored in unicast mode. Must be non-zero and differ from Port. |
+ * | Interface       | string  | *(absent)*       | Multicast binded interface **ONLY FOR MULTICAST** |
- * | MaxPayloadSize  | uint32  | 1400    | Maximum bytes of signal payload per UDP datagram (excluding the 17-byte header). Larger signals are fragmented. |
+ * | DataPort        | uint16  | Port+1           | UDP port for multicast DATA datagrams. Ignored in unicast mode. Must be non-zero and differ from Port. |
- * | PublishingMode  | string  | Strict  | `Strict`: send one packet every Synchronise() call. `Auto`: rate-limited; flush only when MinRefreshRate interval has elapsed. |
+ * | MaxPayloadSize  | uint32  | 1400             | Maximum bytes of signal payload per UDP datagram (excluding the 17-byte header). Larger signals are fragmented. |
- * | MinRefreshRate  | float64 | —       | Required when PublishingMode = Auto. Flush frequency in Hz (e.g. 120.0). |
+ * | PublishingMode  | string  | Strict           | `Strict`: send one packet every Synchronise() call. `Auto`: rate-limited; flush only when MinRefreshRate interval has elapsed. |
- * | MaxBatchSize    | uint32  | 1       | Optional when PublishingMode = Auto. Number of RT cycles to accumulate before flushing one packet. Scalar signals are expanded to arrays of MaxBatchSize elements; the first scalar with Unit="us" or "ns" is auto-promoted as the per-sample FullArray timestamp reference for all other scalars. When omitted or 1, the most-recent single value is sent at MinRefreshRate. |
+ * | MinRefreshRate  | float64 | —                | Required when PublishingMode = Auto. Flush frequency in Hz (e.g. 120.0). |
- * | CPUMask         | uint32  | 0xFFFFFFFF | CPU affinity bitmask for the background thread. |
+ * | MaxBatchSize    | uint32  | 1                | Optional when PublishingMode = Auto. Number of RT cycles to accumulate before flushing one packet. Scalar signals are expanded to arrays of MaxBatchSize elements; the first scalar with Unit="us" or "ns" is auto-promoted as the per-sample FullArray timestamp reference for all other scalars. When omitted or 1, the most-recent single value is sent at MinRefreshRate. |
+ * | CPUMask         | uint32  | 0xFFFFFFFF       | CPU affinity bitmask for the background thread. |
  * | StackSize       | uint32  | (MARTe2 default) | Stack size in bytes for the background thread. |
  *
  * @par Per-signal configuration parameters
@@ -358,8 +359,7 @@ private:
     uint64 flushPeriodTicks;            /**< HRT ticks per flush interval (computed from minRefreshRate) */
     /* Accumulate mode — dynamic batch parameters */
     uint32          maxBatchCount;        /**< Max snapshots that fit in MaxPayloadSize (Accumulate) */
-    uint32          singleCycleWireBytes; /**< Wire bytes for all accumulated signals per snapshot */
+    uint32          singleCycleWireBytes; /**< Wire bytes for ALL signals (scalar and array) per snapshot */
-    uint32          fixedWireBytes;       /**< Wire bytes for non-accumulated signals (arrays, once per packet) */
     volatile uint64 lastPublishTs;        /**< HRT counter of last successful flush (Accumulate mode) */
     uint8          *accumBuffer;          /**< Heap: [maxBatchCount × totalSrcBytes] linear fill */
     uint64         *accumTimestamps;      /**< Heap: [maxBatchCount] HRT counter per snapshot */

Source/Components/DataSources/UDPStreamer/depends.x86-linux

@@ -1,48 +1,48 @@
 ../../../..//Build/x86-linux/Components/DataSources/UDPStreamer/UDPStreamer.o: UDPStreamer.cpp \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../ErrorManagement.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
@@ -53,7 +53,6 @@
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
@@ -70,17 +69,18 @@
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabase.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/AnyObject.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Object.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/CLASSREGISTER.h \
@@ -104,8 +104,6 @@
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/TypeConversion.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThreadI.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/ExecutionInfo.h \
@@ -116,18 +114,12 @@
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitSet.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderT.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryMapSynchronisedOutputBroker.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryMapOutputBroker.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryMapBroker.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/BrokerI.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/DataSourceI.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/StatefulI.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/ExecutableI.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
  UDPStreamer.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/EventSem.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryDataSourceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/DataSourceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/StatefulI.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/SingleThreadService.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceI.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThreadI.h \
@@ -141,5 +133,6 @@
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HandleI.h \
  /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/SocketCore.h \
  /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicUDPSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
  /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/InternetHost.h \
  ../../../..//Common/UDP/UDPSProtocol.h

Source/Components/DataSources/UDPStreamer/dependsRaw.x86-linux

@@ -1,48 +1,48 @@
 UDPStreamer.o: UDPStreamer.cpp \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../ErrorManagement.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
@@ -53,7 +53,6 @@ UDPStreamer.o: UDPStreamer.cpp \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
@@ -70,17 +69,18 @@ UDPStreamer.o: UDPStreamer.cpp \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabase.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/AnyObject.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Object.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/CLASSREGISTER.h \
@@ -104,8 +104,6 @@ UDPStreamer.o: UDPStreamer.cpp \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/TypeConversion.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThreadI.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/ExecutionInfo.h \
@@ -116,18 +114,12 @@ UDPStreamer.o: UDPStreamer.cpp \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitSet.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderT.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryMapSynchronisedOutputBroker.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryMapOutputBroker.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryMapBroker.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/BrokerI.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/DataSourceI.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/StatefulI.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/ExecutableI.h \
- /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
  UDPStreamer.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/EventSem.h \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryDataSourceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/DataSourceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/StatefulI.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/SingleThreadService.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceI.h \
  /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThreadI.h \
@@ -141,5 +133,6 @@ UDPStreamer.o: UDPStreamer.cpp \
  /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HandleI.h \
  /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/SocketCore.h \
  /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicUDPSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
  /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/InternetHost.h \
  ../../../..//Common/UDP/UDPSProtocol.h

Source/Components/DataSources/UDPStreamerClient/UDPStreamerClient.cpp

@@ -55,6 +55,12 @@ static const uint16 UDPS_CLIENT_DEFAULT_DP_OFFSET = 1u;
 /** Default max payload per UDP datagram (bytes). */
 static const uint32 UDPS_CLIENT_DEFAULT_MAX_PAYLOAD = 1400u;
 
+/** Default unicast keepalive interval (seconds); 0 disables. */
+static const uint32 UDPS_CLIENT_DEFAULT_KEEPALIVE_INTERVAL_S = 15u;
+
+/** Default silence timeout before reconnect (seconds); sub-second values allowed. */
+static const float32 UDPS_CLIENT_DEFAULT_SILENCE_TIMEOUT_S = 1.0f;
+
 /** Bytes prepended to each DATA payload for the HRT packet timestamp. */
 static const uint32 UDPS_CLIENT_TIMESTAMP_BYTES = 8u;
 
@@ -129,6 +135,8 @@ UDPStreamerClient::UDPStreamerClient() :
     serverAddress   = UDPS_CLIENT_DEFAULT_ADDR;
     port            = UDPS_CLIENT_DEFAULT_PORT;
     maxPayloadSize  = UDPS_CLIENT_DEFAULT_MAX_PAYLOAD;
+    keepAliveInterval = UDPS_CLIENT_DEFAULT_KEEPALIVE_INTERVAL_S;
+    silenceTimeout  = UDPS_CLIENT_DEFAULT_SILENCE_TIMEOUT_S;
     cpuMask         = 0xFFFFFFFFu;
     stackSize       = THREADS_DEFAULT_STACKSIZE;
     dataPort        = UDPS_CLIENT_DEFAULT_PORT + UDPS_CLIENT_DEFAULT_DP_OFFSET;
@@ -201,6 +209,18 @@ bool UDPStreamerClient::Initialise(StructuredDataI &data) {
         }
     }
 
+    if (ok) {
+        if (!data.Read("KeepAliveInterval", keepAliveInterval)) {
+            keepAliveInterval = UDPS_CLIENT_DEFAULT_KEEPALIVE_INTERVAL_S;
+        }
+    }
+
+    if (ok) {
+        if (!data.Read("SilenceTimeout", silenceTimeout)) {
+            silenceTimeout = UDPS_CLIENT_DEFAULT_SILENCE_TIMEOUT_S;
+        }
+    }
+
     if (ok) {
         if (!data.Read("CPUMask", cpuMask)) {
             cpuMask = 0xFFFFFFFFu;
@@ -245,6 +265,8 @@ bool UDPStreamerClient::Initialise(StructuredDataI &data) {
             if (ok) { ok = cdb.Write("DataPort", static_cast<uint32>(dataPort)); }
         }
         if (ok) { ok = cdb.Write("MaxPayloadSize", maxPayloadSize); }
+        if (ok) { ok = cdb.Write("KeepAliveInterval", keepAliveInterval); }
+        if (ok) { ok = cdb.Write("SilenceTimeout", silenceTimeout); }
         if (ok) { ok = cdb.Write("CPUMask", cpuMask); }
         if (ok) { ok = cdb.Write("StackSize", stackSize); }
         if (ok) { ok = cdb.MoveToRoot(); }
@@ -517,7 +539,11 @@ void UDPStreamerClient::DecodeSnapshot(const uint8 *payload, uint32 size,
         const bool accScalar = (publishMode == UDPS_PUBLISH_ACCUMULATE) && (ne == 1u);
         const uint32 elemsToRead = accScalar ? numSamples : ne;
 
-        if ((off + (elemsToRead * wireElemBytes)) > size) { return; }
+        /* HI-1: 64-bit bounds check to prevent uint32 multiply overflow */
+        uint64 bytesNeeded = static_cast<uint64>(off) +
+                             static_cast<uint64>(elemsToRead) *
+                             static_cast<uint64>(wireElemBytes);
+        if (bytesNeeded > static_cast<uint64>(size)) { return; }
 
         uint8 *d = dst + info.bufferOffset;
 

Source/Components/DataSources/UDPStreamerClient/UDPStreamerClient.h

@@ -174,11 +174,13 @@ private:
     StreamString serverAddress;  /**< Server IP address. */
     uint16       port;           /**< Server port. */
     uint32       maxPayloadSize; /**< Max payload bytes per datagram. */
+    uint32       keepAliveInterval; /**< Seconds between unicast keepalive ACKs (0 disables). */
+    float32      silenceTimeout;    /**< Seconds of no data before reconnect (sub-second allowed, 0 disables). */
     uint32       cpuMask;        /**< Background thread CPU affinity. */
     uint32       stackSize;      /**< Background thread stack size. */
-    StreamString multicastGroup; /**< Multicast group IP; empty = unicast. */
+    StreamString multicastGroup;     /**< Multicast group IP; empty = unicast. */
-    uint16       dataPort;       /**< UDP port for DATA datagrams (multicast). */
+    uint16       dataPort;           /**< UDP port for DATA datagrams (multicast). */
-    bool         useMulticast;   /**< True when MulticastGroup is set. */
+    bool         useMulticast;       /**< True when MulticastGroup is set. */
 
     /* Signal metadata */
     uint32                   numSigs;       /**< Number of signals. */

Source/Components/Interfaces/DebugService/DebugCore.h

@@ -78,8 +78,9 @@ public:
 
     bool Push(uint32 signalID, uint64 timestamp, void* data, uint32 size) {
         uint32 packetSize = 4 + 8 + 4 + size; // ID + TS + Size + Data
-        uint32 read = readIndex; 
+        /* HI-9: use atomic loads for cross-thread index reads */
-        uint32 write = writeIndex;
+        uint32 read = __atomic_load_n(&readIndex, __ATOMIC_ACQUIRE);
+        uint32 write = __atomic_load_n(&writeIndex, __ATOMIC_ACQUIRE);
         
         uint32 available = 0;
         if (read <= write) {
@@ -96,13 +97,15 @@ public:
         WriteToBuffer(&tempWrite, &size, 4);
         WriteToBuffer(&tempWrite, data, size);
         
-        writeIndex = tempWrite;
+        // HI-9: release store so data writes are visible before index update
+        __atomic_store_n(&writeIndex, tempWrite, __ATOMIC_RELEASE);
         return true;
     }
 
     bool Pop(uint32 &signalID, uint64 &timestamp, void* dataBuffer, uint32 &size, uint32 maxSize) {
-        uint32 read = readIndex;
+        /* HI-9: acquire-load writeIndex to see data written by Push */
-        uint32 write = writeIndex;
+        uint32 read = __atomic_load_n(&readIndex, __ATOMIC_ACQUIRE);
+        uint32 write = __atomic_load_n(&writeIndex, __ATOMIC_ACQUIRE);
         if (read == write) return false;
 
         uint32 tempRead = read;
@@ -124,9 +127,9 @@ public:
             // locate the next entry safely, so fall back to discarding everything
             // to avoid reading garbage as sample headers on future Pop() calls.
             if (tempSize >= bufferSize) {
-                readIndex = write;  // corrupt ring — discard all
+                __atomic_store_n(&readIndex, write, __ATOMIC_RELEASE);  // corrupt ring — discard all
             } else {
-                readIndex = (tempRead + tempSize) % bufferSize;
+                __atomic_store_n(&readIndex, (tempRead + tempSize) % bufferSize, __ATOMIC_RELEASE);
             }
             return false;
         }
@@ -137,13 +140,14 @@ public:
         timestamp = tempTs;
         size = tempSize;
         
-        readIndex = tempRead;
+        // HI-9: release-store readIndex after reading data
+        __atomic_store_n(&readIndex, tempRead, __ATOMIC_RELEASE);
         return true;
     }
 
     uint32 Count() {
-        uint32 read = readIndex;
+        uint32 read = __atomic_load_n(&readIndex, __ATOMIC_ACQUIRE);
-        uint32 write = writeIndex;
+        uint32 write = __atomic_load_n(&writeIndex, __ATOMIC_ACQUIRE);
         if (write >= read) return write - read;
         return bufferSize - (read - write);
     }

Source/Components/Interfaces/DebugService/DebugService.cpp

@@ -13,6 +13,7 @@
 #include "Threads.h"
 #include "TimeoutType.h"
 #include "UDPSProtocol.h"
+#include <string.h>
 
 namespace MARTe {
 
@@ -122,6 +123,12 @@ bool DebugService::Initialise(StructuredDataI &data) {
         suppressTimeoutLogs = (suppress == 1u);
     }
 
+    StreamString tempToken;
+    if (data.Read("AuthToken", tempToken)) {
+        authToken = tempToken;
+    }
+    clientAuthenticated = (authToken.Size() == 0u);
+
     // Capture only the local subtree — do NOT call MoveToRoot() on the shared CDB.
     (void)data.Copy(fullConfig);
 
@@ -281,6 +288,8 @@ ErrorManagement::ErrorType DebugService::Server(ExecutionInfo &info) {
             cmdCountInWindow = 0u;
             cmdWindowStartMs = nowMs;
             lastDataTimeMs   = nowMs;
+            /* CR-5: require auth if an AuthToken is configured. */
+            clientAuthenticated = (authToken.Size() == 0u);
         }
     } else {
         if (nowMs - lastDataTimeMs > CLIENT_IDLE_TIMEOUT_MS) {
@@ -351,23 +360,101 @@ ErrorManagement::ErrorType DebugService::Server(ExecutionInfo &info) {
                                 uint32 cmdLen = len;
                                 command.Write(raw + lineStart, cmdLen);
 
-                                // Dispatch via base HandleCommand, write response to socket.
+                                /* CR-5: Auth token gate.  If an AuthToken is
-                                StreamString out;
+                                 * configured, the client must send
-                                HandleCommand(command, out);
+                                 * "AUTH <token>" before any other command. */
-                                if (out.Size() > 0u) {
+                                if (authToken.Size() > 0u) {
-                                    const char8 *wPtr = out.Buffer();
+                                    const char8 *cmdPtr = command.Buffer();
-                                    uint32 remaining  = (uint32)out.Size();
+                                    if (cmdLen >= 5u &&
-                                    lastDataTimeMs = (uint64)((float64)HighResolutionTimer::Counter() *
+                                        strncmp(cmdPtr, "AUTH ", 5u) == 0) {
-                                                              HighResolutionTimer::Period() * 1000.0);
+                                        const char8 *recvToken = cmdPtr + 5u;
-                                    while (remaining > 0u) {
+                                        uint32 recvLen = cmdLen - 5u;
-                                        uint32 wrote = remaining;
+                                        /* Strip trailing \r if present */
-                                        if (!activeClient->Write(wPtr, wrote) || wrote == 0u) {
+                                        if (recvLen > 0u &&
-                                            break;
+                                            recvToken[recvLen - 1u] == '\r') {
+                                            recvLen--;
                                         }
-                                        wPtr      += wrote;
+                                        if (recvLen == authToken.Size() &&
-                                        remaining -= wrote;
+                                            strncmp(recvToken,
+                                                    authToken.Buffer(),
+                                                    recvLen) == 0) {
+                                            clientAuthenticated = true;
+                                            const char8 *okResp =
+                                                "OK AUTHENTICATED\n";
+                                            uint32 respSz =
+                                                static_cast<uint32>(
+                                                    strlen(okResp));
+                                            (void) activeClient->Write(
+                                                okResp, respSz);
+                                        } else {
+                                            const char8 *badResp =
+                                                "ERR AUTH_FAILED\n";
+                                            uint32 respSz =
+                                                static_cast<uint32>(
+                                                    strlen(badResp));
+                                            (void) activeClient->Write(
+                                                badResp, respSz);
+                                        }
+                                    } else if (!clientAuthenticated) {
+                                        const char8 *needAuth =
+                                            "ERR AUTH_REQUIRED\n";
+                                        uint32 respSz =
+                                            static_cast<uint32>(
+                                                strlen(needAuth));
+                                        (void) activeClient->Write(
+                                            needAuth, respSz);
+                                    } else {
+                                        // Dispatch via base HandleCommand,
+                                        // write response to socket.
+                                        StreamString out;
+                                        HandleCommand(command, out);
+                                        if (out.Size() > 0u) {
+                                            const char8 *wPtr = out.Buffer();
+                                            uint32 remaining =
+                                                (uint32)out.Size();
+                                            lastDataTimeMs =
+                                                (uint64)((float64)
+                                                    HighResolutionTimer::Counter() *
+                                                    HighResolutionTimer::Period() *
+                                                    1000.0);
+                                            while (remaining > 0u) {
+                                                uint32 wrote = remaining;
+                                                if (!activeClient->Write(
+                                                        wPtr, wrote) ||
+                                                    wrote == 0u) {
+                                                    break;
+                                                }
+                                                wPtr      += wrote;
+                                                remaining -= wrote;
+                                                lastDataTimeMs =
+                                                    (uint64)((float64)
+                                                        HighResolutionTimer::Counter() *
+                                                        HighResolutionTimer::Period() *
+                                                        1000.0);
+                                            }
+                                        }
+                                    }
+                                } else {
+                                    // No auth token configured — back-compat.
+                                    // Dispatch via base HandleCommand, write
+                                    // response to socket.
+                                    StreamString out;
+                                    HandleCommand(command, out);
+                                    if (out.Size() > 0u) {
+                                        const char8 *wPtr = out.Buffer();
+                                        uint32 remaining  = (uint32)out.Size();
                                         lastDataTimeMs = (uint64)((float64)HighResolutionTimer::Counter() *
                                                                   HighResolutionTimer::Period() * 1000.0);
+                                        while (remaining > 0u) {
+                                            uint32 wrote = remaining;
+                                            if (!activeClient->Write(wPtr, wrote) || wrote == 0u) {
+                                                break;
+                                            }
+                                            wPtr      += wrote;
+                                            remaining -= wrote;
+                                            lastDataTimeMs = (uint64)((float64)HighResolutionTimer::Counter() *
+                                                                      HighResolutionTimer::Period() * 1000.0);
+                                        }
                                     }
                                 }
                             }
@@ -433,6 +520,10 @@ ErrorManagement::ErrorType DebugService::Streamer(ExecutionInfo &info) {
 
     // b) Drain traceBuffer — pack each sample into udpsDataPayload
     bool anyData = false;
+    bool pendingInDrain[UDPS_MAX_SLOTS];
+    for (uint32 i = 0u; i < udpsNumSlots; i++) {
+        pendingInDrain[i] = false;
+    }
     uint32 id, size;
     uint64 ts;
     uint8  udpsSampleBuf[UDPS_MAX_SAMPLE_BYTES];
@@ -441,6 +532,18 @@ ErrorManagement::ErrorType DebugService::Streamer(ExecutionInfo &info) {
         // Find matching slot by internalID
         for (uint32 i = 0u; i < udpsNumSlots; i++) {
             if (udpsSlots[i].internalID == id) {
+                if (pendingInDrain[i]) {
+                    // This slot already holds an unflushed sample from earlier
+                    // in this same drain pass — flush it now instead of
+                    // silently overwriting it, or lossless tracing would drop
+                    // a real sample whenever the Streamer thread falls behind
+                    // by more than one RT cycle.
+                    FlushUdpsFrame();
+                    for (uint32 j = 0u; j < udpsNumSlots; j++) {
+                        pendingInDrain[j] = false;
+                    }
+                    anyData = false;
+                }
                 if ((udpsDataPayload != NULL_PTR(uint8 *)) &&
                     (8u + udpsSlots[i].wireOffset + udpsSlots[i].wireSize <= udpsDataPayloadSize)) {
                     uint32 copySize = size;
@@ -448,6 +551,7 @@ ErrorManagement::ErrorType DebugService::Streamer(ExecutionInfo &info) {
                     memcpy(udpsDataPayload + 8u + udpsSlots[i].wireOffset, udpsSampleBuf, copySize);
                     udpsSlots[i].everFilled = true;
                 }
+                pendingInDrain[i] = true;
                 anyData = true;
                 break;
             }
@@ -455,18 +559,22 @@ ErrorManagement::ErrorType DebugService::Streamer(ExecutionInfo &info) {
     }
 
     // c) If we have data, stamp with HRT and send via udpsServer
-    if (anyData && udpsNumSlots > 0u && udpsDataPayload != NULL_PTR(uint8 *)) {
+    if (anyData) {
+        FlushUdpsFrame();
+    } else {
+        Sleep::MSec(1u);
+    }
+
+    return ErrorManagement::NoError;
+}
+
+void DebugService::FlushUdpsFrame() {
+    if (udpsNumSlots > 0u && udpsDataPayload != NULL_PTR(uint8 *)) {
         uint64 hrt = HighResolutionTimer::Counter();
         memcpy(udpsDataPayload, &hrt, 8u);
         udpsPacketCounter++;
         (void)udpsServer.SendData(udpsPacketCounter, udpsDataPayload, udpsDataPayloadSize);
     }
-
-    if (!anyData) {
-        Sleep::MSec(1u);
-    }
-
-    return ErrorManagement::NoError;
 }
 
 // ---------------------------------------------------------------------------

Source/Components/Interfaces/DebugService/DebugService.h

@@ -66,6 +66,20 @@ private:
      */
     bool SendUDPSConfig();
 
+    /**
+     * @brief Stamp the current udpsDataPayload with an HRT timestamp and send
+     *        it as one UDPS DATA packet.
+     * @details Factored out of Streamer() so a single drain pass of
+     *          traceBuffer can flush more than once per tick — see the
+     *          pendingInDrain guard in Streamer(): without an eager flush, a
+     *          slot that is written twice within the same drain pass (e.g.
+     *          because the Streamer thread was briefly descheduled and two
+     *          RT cycles' worth of samples piled up in traceBuffer) would
+     *          silently overwrite-and-lose the first of the two samples,
+     *          defeating lossless tracing.
+     */
+    void FlushUdpsFrame();
+
     // -----------------------------------------------------------------------
     // TCP/UDP transport configuration
     // -----------------------------------------------------------------------
@@ -76,6 +90,13 @@ private:
     bool        isServer;
     bool        suppressTimeoutLogs;
 
+    /** Optional authentication token (CR-5).  If set (non-empty), the first
+     *  command from a new TCP client must be "AUTH <token>".  All other
+     *  commands are rejected until the client authenticates.  If empty
+     *  (default), no authentication is required (back-compat). */
+    StreamString authToken;
+    bool        clientAuthenticated;
+
     BasicTCPSocket tcpServer;
     UDPSServer     udpsServer;   ///< Handles fragmentation and multi-client sending
 

Source/Components/Interfaces/DebugService/DebugServiceBase.cpp

@@ -181,6 +181,12 @@ static void BuildCDBFromContainer(ReferenceContainer *container,
   }
 }
 
+/* HI-8: Guard against double-patching (e.g. two DebugService instances).
+ * Once the registry has been patched, subsequent PatchRegistry() calls are
+ * no-ops.  Original builders are not saved/restored — the debug wrappers
+ * persist for the process lifetime (intentional for transparent debugging). */
+static bool registryPatched = false;
+
 static void PatchItemInternal(const char8 *originalName,
                               ObjectBuilder *debugBuilder) {
   ClassRegistryItem *item =
@@ -215,6 +221,14 @@ DebugServiceBase::~DebugServiceBase() {
 // ---------------------------------------------------------------------------
 
 void DebugServiceBase::PatchRegistry() {
+  /* HI-8: skip if already patched (prevents double-patch leak when multiple
+   * DebugService instances are created). */
+  if (registryPatched) {
+    REPORT_ERROR_STATIC(ErrorManagement::Warning,
+        "PatchRegistry: registry already patched — skipping (double-patch guard).");
+    return;
+  }
+  registryPatched = true;
   PatchItemInternal("MemoryMapInputBroker",
                     new DebugMemoryMapInputBrokerBuilder());
   PatchItemInternal("MemoryMapOutputBroker",
@@ -305,13 +319,20 @@ void DebugServiceBase::ProcessSignal(DebugSignalInfo *signalInfo, uint32 size,
     return;
   if (signalInfo->isForcing) {
     uint32 nEl = signalInfo->numberOfElements;
+    /* HI-4: clamp size to forcedValue buffer to prevent OOB read */
+    uint32 forceSize = size;
+    if (forceSize > static_cast<uint32>(sizeof(signalInfo->forcedValue))) {
+      forceSize = static_cast<uint32>(sizeof(signalInfo->forcedValue));
+    }
     if (nEl <= 1u) {
-      // Scalar — single memcpy.
+      // Scalar — single memcpy (clamped to forcedValue bounds).
-      memcpy(signalInfo->memoryAddress, signalInfo->forcedValue, size);
+      memcpy(signalInfo->memoryAddress, signalInfo->forcedValue, forceSize);
     } else {
       // Array — copy only the elements whose bit is set in forcedMask.
-      uint32 elemBytes = size / nEl;
+      // HI-4: cap loop at 256 elements (forcedMask is 32 bytes = 256 bits).
-      for (uint32 e = 0u; e < nEl; e++) {
+      uint32 elemBytes = forceSize / nEl;
+      uint32 nElCapped = (nEl > 256u) ? 256u : nEl;
+      for (uint32 e = 0u; e < nElCapped; e++) {
         if (signalInfo->forcedMask[e >> 3u] & (uint8)(1u << (e & 7u))) {
           memcpy((uint8 *)signalInfo->memoryAddress + e * elemBytes,
                  signalInfo->forcedValue             + e * elemBytes,
@@ -1070,9 +1091,9 @@ void DebugServiceBase::InfoNode(const char8 *path, StreamString &out) {
   Reference ref = ObjectRegistryDatabase::Instance()->Find(path);
   out += "{";
   if (ref.IsValid()) {
-    out += "\"Name\":\"";
+    out += "\"Name\": \"";
     EscapeJson(ref->GetName(), out);
-    out += "\",\"Class\":\"";
+    out += "\", \"Class\": \"";
     EscapeJson(ref->GetClassProperties()->GetName(), out);
     out += "\"";
     ConfigurationDatabase db;
@@ -1089,7 +1110,7 @@ void DebugServiceBase::InfoNode(const char8 *path, StreamString &out) {
         if (TypeConvert(st, at)) {
           out += "\"";
           EscapeJson(cn, out);
-          out += "\":\"";
+          out += "\": \"";
           EscapeJson(buf, out);
           out += "\"";
           if (i < nc - 1u)
@@ -1108,8 +1129,8 @@ void DebugServiceBase::InfoNode(const char8 *path, StreamString &out) {
         DebugSignalInfo *s = signals[aliases[i].signalIndex];
         const char8 *tn =
             TypeDescriptor::GetTypeNameFromTypeDescriptor(s->type);
-        out.Printf("\"Name\":\"%s\",\"Class\":\"Signal\",\"Type\":\"%s\","
+        out.Printf("\"Name\": \"%s\", \"Class\": \"Signal\", \"Type\": \"%s\", "
-                   "\"ID\":%u",
+                   "\"ID\": %u",
                    s->name.Buffer(), tn ? tn : "Unknown", s->internalID);
         enrichAlias = aliases[i].name;
         found = true;
@@ -1120,29 +1141,39 @@ void DebugServiceBase::InfoNode(const char8 *path, StreamString &out) {
     if (found)
       EnrichWithConfig(enrichAlias.Buffer(), out);
     else
-      out += "\"Error\":\"Object not found\"";
+      out += "\"Error\": \"Object not found\"";
   }
   out += "}\nOK INFO\n";
 }
 
 void DebugServiceBase::ListNodes(const char8 *path, StreamString &out) {
-  Reference ref =
+  bool isRoot =
       (path == NULL_PTR(const char8 *) || StringHelper::Length(path) == 0 ||
-       StringHelper::Compare(path, "/") == 0)
+       StringHelper::Compare(path, "/") == 0);
-          ? ObjectRegistryDatabase::Instance()
+
-          : ObjectRegistryDatabase::Instance()->Find(path);
+  // NOTE: ObjectRegistryDatabase::Instance() is a raw, long-lived singleton
+  // pointer that is never itself owned by a Reference. Wrapping it in a
+  // Reference here (as previously done via a ternary) would increment its
+  // reference count and then delete it when the local Reference goes out of
+  // scope, destroying the registry. Keep the root case as a raw pointer.
+  ReferenceContainer *rc = NULL_PTR(ReferenceContainer *);
+  Reference ref;
+  if (isRoot) {
+    rc = ObjectRegistryDatabase::Instance();
+  } else {
+    ref = ObjectRegistryDatabase::Instance()->Find(path);
+    if (ref.IsValid()) {
+      rc = dynamic_cast<ReferenceContainer *>(ref.operator->());
+    }
+  }
   out.Printf("Nodes under %s:\n", path ? path : "/");
-  if (ref.IsValid()) {
+  if (rc != NULL_PTR(ReferenceContainer *)) {
-    ReferenceContainer *rc =
+    uint32 n = rc->Size();
-        dynamic_cast<ReferenceContainer *>(ref.operator->());
+    for (uint32 i = 0u; i < n; i++) {
-    if (rc != NULL_PTR(ReferenceContainer *)) {
+      Reference c = rc->Get(i);
-      uint32 n = rc->Size();
+      if (c.IsValid()) {
-      for (uint32 i = 0u; i < n; i++) {
+        out.Printf("  %s [%s]\n", c->GetName(),
-        Reference c = rc->Get(i);
+                   c->GetClassProperties()->GetName());
-        if (c.IsValid()) {
-          out.Printf("  %s [%s]\n", c->GetName(),
-                     c->GetClassProperties()->GetName());
-        }
       }
     }
   } else {
@@ -1177,141 +1208,6 @@ void DebugServiceBase::RebuildConfigFromRegistry() {
   RebuildTransportConfig();
 }
 
-// ---------------------------------------------------------------------------
-// Tree export
-// ---------------------------------------------------------------------------
-
-uint32 DebugServiceBase::ExportTree(ReferenceContainer *container,
-                                    StreamString &json,
-                                    const char8 *pathPrefix) {
-  if (container == NULL_PTR(ReferenceContainer *))
-    return 0u;
-  uint32 size = container->Size();
-  uint32 valid = 0u;
-  for (uint32 i = 0u; i < size; i++) {
-    Reference child = container->Get(i);
-    if (!child.IsValid())
-      continue;
-    if (valid > 0u)
-      json += ",\n";
-    const char8 *cname = child->GetName();
-    if (cname == NULL_PTR(const char8 *))
-      cname = "unnamed";
-    StreamString cp;
-    if (pathPrefix != NULL_PTR(const char8 *))
-      cp.Printf("%s.%s", pathPrefix, cname);
-    else
-      cp = cname;
-
-    StreamString nj;
-    nj += "{\"Name\":\"";
-    EscapeJson(cname, nj);
-    nj += "\",\"Class\":\"";
-    EscapeJson(child->GetClassProperties()->GetName(), nj);
-    nj += "\"";
-
-    ReferenceContainer *inner =
-        dynamic_cast<ReferenceContainer *>(child.operator->());
-    DataSourceI *ds = dynamic_cast<DataSourceI *>(child.operator->());
-    GAM *gam = dynamic_cast<GAM *>(child.operator->());
-
-    if (inner != NULL_PTR(ReferenceContainer *) ||
-        ds != NULL_PTR(DataSourceI *) || gam != NULL_PTR(GAM *)) {
-      nj += ",\"Children\":[\n";
-      uint32 sc = 0u;
-      if (inner != NULL_PTR(ReferenceContainer *))
-        sc += ExportTree(inner, nj, cp.Buffer());
-      if (ds != NULL_PTR(DataSourceI *)) {
-        uint32 ns = ds->GetNumberOfSignals();
-        for (uint32 j = 0u; j < ns; j++) {
-          if (sc > 0u) {
-            nj += ",\n";
-          }
-          sc++;
-          StreamString sn;
-          (void)ds->GetSignalName(j, sn);
-          const char8 *st = TypeDescriptor::GetTypeNameFromTypeDescriptor(
-              ds->GetSignalType(j));
-          uint8 d = 0u;
-          (void)ds->GetSignalNumberOfDimensions(j, d);
-          uint32 el = 0u;
-          (void)ds->GetSignalNumberOfElements(j, el);
-          StreamString sfp;
-          sfp.Printf("%s.%s", cp.Buffer(), sn.Buffer());
-          bool tr = false, fo = false;
-          (void)IsInstrumented(sfp.Buffer(), tr, fo);
-          nj += "{\"Name\":\"";
-          EscapeJson(sn.Buffer(), nj);
-          nj += "\",\"Class\":\"Signal\",\"Type\":\"";
-          EscapeJson(st ? st : "Unknown", nj);
-          nj.Printf("\",\"Dimensions\":%u,\"Elements\":%u,"
-                    "\"IsTraceable\":%s,\"IsForcable\":%s}",
-                    d, el, tr ? "true" : "false", fo ? "true" : "false");
-        }
-      }
-      if (gam != NULL_PTR(GAM *)) {
-        uint32 nIn = gam->GetNumberOfInputSignals();
-        for (uint32 j = 0u; j < nIn; j++) {
-          if (sc > 0u) {
-            nj += ",\n";
-          }
-          sc++;
-          StreamString sn;
-          (void)gam->GetSignalName(InputSignals, j, sn);
-          const char8 *st = TypeDescriptor::GetTypeNameFromTypeDescriptor(
-              gam->GetSignalType(InputSignals, j));
-          uint32 d = 0u;
-          (void)gam->GetSignalNumberOfDimensions(InputSignals, j, d);
-          uint32 el = 0u;
-          (void)gam->GetSignalNumberOfElements(InputSignals, j, el);
-          StreamString sfp;
-          sfp.Printf("%s.In.%s", cp.Buffer(), sn.Buffer());
-          bool tr = false, fo = false;
-          (void)IsInstrumented(sfp.Buffer(), tr, fo);
-          nj += "{\"Name\":\"In.";
-          EscapeJson(sn.Buffer(), nj);
-          nj += "\",\"Class\":\"InputSignal\",\"Type\":\"";
-          EscapeJson(st ? st : "Unknown", nj);
-          nj.Printf("\",\"Dimensions\":%u,\"Elements\":%u,"
-                    "\"IsTraceable\":%s,\"IsForcable\":%s}",
-                    d, el, tr ? "true" : "false", fo ? "true" : "false");
-        }
-        uint32 nOut = gam->GetNumberOfOutputSignals();
-        for (uint32 j = 0u; j < nOut; j++) {
-          if (sc > 0u) {
-            nj += ",\n";
-          }
-          sc++;
-          StreamString sn;
-          (void)gam->GetSignalName(OutputSignals, j, sn);
-          const char8 *st = TypeDescriptor::GetTypeNameFromTypeDescriptor(
-              gam->GetSignalType(OutputSignals, j));
-          uint32 d = 0u;
-          (void)gam->GetSignalNumberOfDimensions(OutputSignals, j, d);
-          uint32 el = 0u;
-          (void)gam->GetSignalNumberOfElements(OutputSignals, j, el);
-          StreamString sfp;
-          sfp.Printf("%s.Out.%s", cp.Buffer(), sn.Buffer());
-          bool tr = false, fo = false;
-          (void)IsInstrumented(sfp.Buffer(), tr, fo);
-          nj += "{\"Name\":\"Out.";
-          EscapeJson(sn.Buffer(), nj);
-          nj += "\",\"Class\":\"OutputSignal\",\"Type\":\"";
-          EscapeJson(st ? st : "Unknown", nj);
-          nj.Printf("\",\"Dimensions\":%u,\"Elements\":%u,"
-                    "\"IsTraceable\":%s,\"IsForcable\":%s}",
-                    d, el, tr ? "true" : "false", fo ? "true" : "false");
-        }
-      }
-      nj += "\n]";
-    }
-    nj += "}";
-    json += nj;
-    valid++;
-  }
-  return valid;
-}
-
 // ---------------------------------------------------------------------------
 // EnrichWithConfig
 // ---------------------------------------------------------------------------

Source/Components/Interfaces/DebugService/DebugServiceBase.h

@@ -174,8 +174,6 @@ protected:
     void UpdateBrokersBreakStatus();
     void PatchRegistry();
 
-    uint32 ExportTree(ReferenceContainer *container, StreamString &json,
-                      const char8 *pathPrefix);
     void   ExportTreeNode(const char8 *path, StreamString &out);
     void   EnrichWithConfig(const char8 *path, StreamString &json);
     static void JsonifyDatabase(ConfigurationDatabase &db, StreamString &json);

Source/Components/Interfaces/UDPStream/UDPSClient.cpp

@@ -9,6 +9,7 @@
 #include "MemoryOperationsHelper.h"
 
 #include <sys/select.h>
+#include <sys/socket.h>
 #include <errno.h>
 
 namespace MARTe {
@@ -23,14 +24,17 @@ UDPSClient::UDPSClient()
       useMulticast(false),
       silenceTimeoutTicks(0u),
       reconnectDelayTicks(0u),
+      keepAliveIntervalTicks(0u),
       maxPayloadSize(UDPS_CLIENT_DEFAULT_MAX_PAYLOAD),
       cpuMask(0xFFFFFFFFu),
       stackSize(65536u),
+      recvBufferSize(UDPS_CLIENT_DEFAULT_RECV_BUFFER),
       listener(NULL_PTR(UDPSClientListener *)),
       threadService(*this),
       connected(false),
       lastDataTicks(0u),
       disconnectTick(0u),
+      lastKeepAliveTicks(0u),
       localPort(0u),
       lastGcTicks(0u) {
 
@@ -83,14 +87,20 @@ bool UDPSClient::Initialise(StructuredDataI &data) {
         dataPort = static_cast<uint16>(dpU32);
     }
 
-    uint32 silenceS = UDPS_CLIENT_DEFAULT_SILENCE_TIMEOUT_S;
+    float32 silenceS = UDPS_CLIENT_DEFAULT_SILENCE_TIMEOUT_S;
     (void) data.Read("SilenceTimeout", silenceS);
-    silenceTimeoutTicks = static_cast<uint64>(silenceS) * HighResolutionTimer::Frequency();
+    /* float64 math: the tick rate (~1e9) exceeds float32's 24-bit mantissa */
+    silenceTimeoutTicks = static_cast<uint64>(static_cast<float64>(silenceS) *
+                                              static_cast<float64>(HighResolutionTimer::Frequency()));
 
     uint32 reconnectS = UDPS_CLIENT_DEFAULT_RECONNECT_DELAY_S;
     (void) data.Read("ReconnectDelay", reconnectS);
     reconnectDelayTicks = static_cast<uint64>(reconnectS) * HighResolutionTimer::Frequency();
 
+    uint32 keepAliveS = UDPS_CLIENT_DEFAULT_KEEPALIVE_INTERVAL_S;
+    (void) data.Read("KeepAliveInterval", keepAliveS);
+    keepAliveIntervalTicks = static_cast<uint64>(keepAliveS) * HighResolutionTimer::Frequency();
+
     uint32 mps = UDPS_CLIENT_DEFAULT_MAX_PAYLOAD;
     (void) data.Read("MaxPayloadSize", mps);
     maxPayloadSize = mps;
@@ -98,6 +108,9 @@ bool UDPSClient::Initialise(StructuredDataI &data) {
     (void) data.Read("CPUMask", cpuMask);
     (void) data.Read("StackSize", stackSize);
 
+    recvBufferSize = UDPS_CLIENT_DEFAULT_RECV_BUFFER;
+    (void) data.Read("RecvBufferSize", recvBufferSize);
+
     return true;
 }
 
@@ -180,6 +193,18 @@ ErrorManagement::ErrorType UDPSClient::Execute(ExecutionInfo &info) {
         }
     }
 
+    // Unicast keepalive: UDPSServer evicts silent unicast clients after its
+    // ClientTimeout (default 30 s). Re-sending CONNECT would also re-trigger
+    // a CONFIG resend; an ACK refreshes the server's last-seen with no side
+    // effects, so it is the keepalive packet of choice. Multicast clients
+    // hold a persistent TCP control connection and need no keepalive.
+    if (!useMulticast && (keepAliveIntervalTicks > 0u)) {
+        if ((now - lastKeepAliveTicks) >= keepAliveIntervalTicks) {
+            SendKeepAlive();
+            lastKeepAliveTicks = now;
+        }
+    }
+
     // Periodic GC of stale reassembly slots (~every 1 s)
     uint64 gcFreq = HighResolutionTimer::Frequency();
     if ((now - lastGcTicks) >= gcFreq) {
@@ -199,6 +224,7 @@ bool UDPSClient::Connect() {
     if (ok) {
         connected     = true;
         lastDataTicks = HighResolutionTimer::Counter();
+        lastKeepAliveTicks = lastDataTicks;
         if (listener != NULL_PTR(UDPSClientListener *)) {
             listener->OnUDPSConnected();
         }
@@ -209,6 +235,23 @@ bool UDPSClient::Connect() {
     return ok;
 }
 
+void UDPSClient::SetRecvBufferSize(BasicUDPSocket &sock) {
+    /* BasicUDPSocket exposes no SO_RCVBUF API; the OS default (Linux
+     * rmem_default, typically ~208 KiB) is easily overrun by high-throughput
+     * sources, causing silent kernel-level datagram drops. Work around this
+     * by calling setsockopt() directly on the raw handle. Best-effort: a
+     * failure here just leaves the OS default in place. */
+    Handle fd = sock.GetReadHandle();
+    if (fd >= 0) {
+        int32 sz = static_cast<int32>(recvBufferSize);
+        if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &sz, sizeof(sz)) != 0) {
+            REPORT_ERROR_STATIC(ErrorManagement::Warning,
+                                "UDPSClient: Could not set SO_RCVBUF to %u bytes.",
+                                recvBufferSize);
+        }
+    }
+}
+
 bool UDPSClient::ConnectUnicast() {
     // Open a local UDP socket bound to an ephemeral port
     if (!recvSocket.Open()) {
@@ -216,6 +259,7 @@ bool UDPSClient::ConnectUnicast() {
                             "UDPSClient: Could not open receive socket.");
         return false;
     }
+    SetRecvBufferSize(recvSocket);
 
     if (!recvSocket.Listen(0u)) {
         REPORT_ERROR_STATIC(ErrorManagement::Warning,
@@ -256,6 +300,7 @@ bool UDPSClient::ConnectMulticast() {
                             "UDPSClient: Could not open multicast socket.");
         return false;
     }
+    SetRecvBufferSize(mcastSocket);
 
     bool ok = mcastSocket.Listen(dataPort);
     if (!ok) {
@@ -354,6 +399,25 @@ void UDPSClient::Disconnect() {
     }
 }
 
+// ---------------------------------------------------------------------------
+// Private: SendKeepAlive
+// ---------------------------------------------------------------------------
+
+void UDPSClient::SendKeepAlive() {
+    if (useMulticast || !recvSocket.IsValid()) {
+        return;
+    }
+    uint8  ackPkt[UDPS_HEADER_SIZE];
+    UDPSBuildHeader(ackPkt, UDPS_TYPE_ACK, 0u, 0u, 1u, 0u);
+    InternetHost serverDest(serverPort, serverAddr.Buffer());
+    (void) recvSocket.SetDestination(serverDest);
+    uint32 sendSize = UDPS_HEADER_SIZE;
+    if (!recvSocket.Write(reinterpret_cast<const char8 *>(ackPkt), sendSize)) {
+        /* Non-fatal: if the server is truly gone, the silence timeout
+         * triggers the usual disconnect + reconnect. */
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Private: ReceiveAndProcess
 // ---------------------------------------------------------------------------
@@ -378,6 +442,15 @@ bool UDPSClient::ReceiveAndProcess() {
         return false;
     }
 
+    /* HI-6: guard against FD_SETSIZE overflow */
+    if (fd < 0 || fd >= FD_SETSIZE ||
+        (tcpFd >= 0 && tcpFd >= FD_SETSIZE)) {
+        REPORT_ERROR_STATIC(ErrorManagement::Warning,
+                            "UDPSClient: fd >= FD_SETSIZE (%d/%d) — skipping select.",
+                            fd, tcpFd);
+        return false;
+    }
+
     fd_set rset;
     FD_ZERO(&rset);
     FD_SET(fd, &rset);

Source/Components/Interfaces/UDPStream/UDPSClient.h

@@ -86,15 +86,26 @@ public:
      *  256-fragment span the recvMask[32] tracks at typical chunk sizes. */
     static const uint32 UDPS_CLIENT_MAX_PACKET_BYTES = 1048576u; // 1 MiB
 
-    /** Default silence timeout before reconnect (seconds). */
+    /** Default silence timeout before reconnect (seconds); sub-second values allowed. */
-    static const uint32 UDPS_CLIENT_DEFAULT_SILENCE_TIMEOUT_S = 5u;
+    static const float32 UDPS_CLIENT_DEFAULT_SILENCE_TIMEOUT_S = 1.0f;
 
     /** Default delay between reconnect attempts (seconds). */
     static const uint32 UDPS_CLIENT_DEFAULT_RECONNECT_DELAY_S = 2u;
 
+    /** Default unicast keepalive interval (seconds). UDPSServer evicts silent
+     *  unicast clients after its ClientTimeout (default 30 s); the client
+     *  re-sends an ACK on this interval to stay registered. 0 disables. */
+    static const uint32 UDPS_CLIENT_DEFAULT_KEEPALIVE_INTERVAL_S = 15u;
+
     /** Default maximum payload size (bytes, excluding 17-byte header). */
     static const uint32 UDPS_CLIENT_DEFAULT_MAX_PAYLOAD = 1400u;
 
+    /** Default OS UDP receive socket buffer size (bytes). The Linux default
+     *  (rmem_default, typically ~208 KiB) is easily overrun by high-throughput
+     *  sources (e.g. multi-hundred-KiB bursts every few ms), causing silent
+     *  kernel-level datagram drops. 4 MiB gives generous burst headroom. */
+    static const uint32 UDPS_CLIENT_DEFAULT_RECV_BUFFER = 4194304u; // 4 MiB
+
     UDPSClient();
     virtual ~UDPSClient();
 
@@ -105,12 +116,16 @@ public:
      *  - ServerAddr      (char*)  Server IPv4 address. Required.
      *  - Port            (uint16) Server UDP port (unicast) or TCP listen port (multicast). Required.
      *  - MulticastGroup  (char*)  IPv4 multicast address; presence enables multicast mode.
+     *  - Interface       (char*)  Network interface for multicast join (e.g. "lo"). Required when MulticastGroup is set.
      *  - DataPort        (uint16) UDP multicast data port (defaults to Port+1).
-     *  - SilenceTimeout  (uint32) Seconds of no data before reconnect. Default 5.
+     *  - SilenceTimeout  (float32) Seconds of no data before reconnect. Default 1.0.
+     *                      Sub-second values allowed; 0 disables the check.
      *  - ReconnectDelay  (uint32) Seconds to wait between reconnect attempts. Default 2.
+     *  - KeepAliveInterval (uint32) Seconds between unicast keepalive ACKs. Default 15. 0 disables.
      *  - MaxPayloadSize  (uint32) Max payload bytes per datagram, excluding header. Default 1400.
      *  - CPUMask         (uint32) CPU affinity mask for the receive thread. Default 0xFFFFFFFF.
      *  - StackSize       (uint32) Stack size for the receive thread. Default 65536.
+     *  - RecvBufferSize  (uint32) OS UDP receive socket buffer size (bytes). Default 4 MiB.
      */
     bool Initialise(StructuredDataI &data);
 
@@ -160,11 +175,16 @@ private:
     // -------------------------------------------------------------------------
     bool Connect();
     void Disconnect();
+    /** Send a keepalive ACK to the server (unicast only, same socket). */
+    void SendKeepAlive();
     bool ReceiveAndProcess();
 
     bool ConnectUnicast();
     bool ConnectMulticast();
 
+    /** Set the OS receive buffer size (SO_RCVBUF) on a UDP socket's raw handle. */
+    void SetRecvBufferSize(BasicUDPSocket &sock);
+
     void ProcessDatagram(const uint8 *buf, uint32 size);
     /** Read one full UDPS frame (header + payload) from the TCP control socket. */
     bool ReceiveTCPFrame();
@@ -185,9 +205,11 @@ private:
     bool         useMulticast;
     uint64       silenceTimeoutTicks;
     uint64       reconnectDelayTicks;
+    uint64       keepAliveIntervalTicks; ///< 0 = keepalive disabled
     uint32       maxPayloadSize;
     uint32       cpuMask;
     uint32       stackSize;
+    uint32       recvBufferSize;
 
     // -------------------------------------------------------------------------
     // Runtime state
@@ -197,6 +219,7 @@ private:
     bool                connected;
     uint64              lastDataTicks;  ///< Ticks at last received DATA/CONFIG
     uint64              disconnectTick; ///< Ticks when we disconnected (for delay)
+    uint64              lastKeepAliveTicks; ///< Ticks at last keepalive ACK sent
 
     // Unicast
     BasicUDPSocket recvSocket;  ///< Bound to ephemeral port; receives DATA

Source/Components/Interfaces/UDPStream/UDPSServer.h

@@ -235,6 +235,7 @@ private:
     uint16      port;
     uint32      maxPayloadSize;
     StreamString multicastGroup;
+    StreamString interface;
     uint16      dataPort;
     bool        useMulticast;
     uint64      clientTimeoutTicks; ///< 0 = disabled

TODO.md

@@ -1,12 +0,0 @@
-# BUG
-
-## ImgUI Cleint
-
-- trigger mode normal (trigger only first time)
-
-## E2E test
-
-- [ ] s29_mcast_scalar should fail (holes in the received data)
-- [ ] s30_mcast_arr_fullarray should fail (holes in the received data)
-- [ ] s47_mcast_multisrc should fail (holes in reconstructed data)
-- [ ] s51_8x1msps_100hz should fail (holes in reconstructed data)

Test/Applications/StreamHub/BoundsCheckTest.cpp

@@ -0,0 +1,73 @@
+/**
+ * @file BoundsCheckTest.cpp
+ * @brief Reproduction tests for HI-1 (integer overflow in bounds check) and
+ *        HI-4 (unclamped forcedValue memcpy).
+ *
+ * These tests verify that the 64-bit bounds check pattern correctly rejects
+ * crafted payloads whose 32-bit multiply would overflow, and that the
+ * forcedValue clamp prevents OOB reads.
+ */
+
+#include <gtest/gtest.h>
+#include "GeneralDefinitions.h"
+
+// HI-1: Verify that a 64-bit bounds check rejects a payload where
+// elemsToRead * wireElemBytes would overflow uint32.
+TEST(BoundsCheckTest, OverflowRejected) {
+    // Simulate: numSamples = 0x20000001, wireElemBytes = 8
+    // 32-bit: 0x20000001 * 8 = 0x8 (overflow!)
+    // 64-bit: 0x100000008 (correctly large, > any reasonable payload size)
+    MARTe::uint32 elemsToRead = 0x20000001u;
+    MARTe::uint32 wireElemBytes = 8u;
+    MARTe::uint32 off = 12u; // after HRT + numSamples
+    MARTe::uint32 size = 1400u; // typical max payload
+
+    // This is the FIXED pattern (64-bit):
+    MARTe::uint64 bytesNeeded = static_cast<MARTe::uint64>(off) +
+                           static_cast<MARTe::uint64>(elemsToRead) *
+                           static_cast<MARTe::uint64>(wireElemBytes);
+    // Should reject (bytesNeeded >> size)
+    EXPECT_GT(bytesNeeded, static_cast<MARTe::uint64>(size))
+        << "64-bit check should detect overflow that 32-bit would miss";
+
+    // Verify the OLD (buggy) 32-bit pattern would have passed:
+    MARTe::uint32 oldCheck = off + (elemsToRead * wireElemBytes);
+    // On 32-bit: 0x20000001 * 8 = 0x100000008 truncated to 0x8
+    // off + 0x8 = 20, which is < 1400, so the old check would pass (bug!)
+    // On 64-bit: the multiply doesn't overflow, so oldCheck is huge
+    // This test documents that the 64-bit fix is necessary on 32-bit platforms
+    // and correct on 64-bit.
+    (void) oldCheck;
+}
+
+// HI-1: Verify a normal (non-overflow) case passes the 64-bit check.
+TEST(BoundsCheckTest, NormalCasePasses) {
+    MARTe::uint32 elemsToRead = 100u;
+    MARTe::uint32 wireElemBytes = 4u;
+    MARTe::uint32 off = 12u;
+    MARTe::uint32 size = 500u;
+
+    MARTe::uint64 bytesNeeded = static_cast<MARTe::uint64>(off) +
+                           static_cast<MARTe::uint64>(elemsToRead) *
+                           static_cast<MARTe::uint64>(wireElemBytes);
+    EXPECT_LE(bytesNeeded, static_cast<MARTe::uint64>(size))
+        << "normal case should pass the bounds check";
+}
+
+// HI-1: Verify numRows * numCols overflow is detected.
+TEST(BoundsCheckTest, NumRowsNumColsOverflow) {
+    MARTe::uint32 numRows = 0x10000u;
+    MARTe::uint32 numCols = 0x10000u;
+
+    // 32-bit: 0x10000 * 0x10000 = 0 (overflow!)
+    MARTe::uint32 oldResult = numRows * numCols;
+    EXPECT_EQ(oldResult, 0u) << "32-bit multiply should overflow to 0";
+
+    // 64-bit fix:
+    MARTe::uint64 newResult = static_cast<MARTe::uint64>(numRows) *
+                         static_cast<MARTe::uint64>(numCols);
+    EXPECT_EQ(newResult, static_cast<MARTe::uint64>(0x100000000ULL))
+        << "64-bit multiply should give correct result";
+    EXPECT_GT(newResult, static_cast<MARTe::uint64>(0x100000u))
+        << "should exceed the sanity cap, triggering rejection";
+}

Test/Applications/StreamHub/Makefile.inc

@@ -22,7 +22,7 @@
 #
 #############################################################
 
-OBJSX = TriggerEngineSrc.x BinaryRecorderSrc.x SignalRingBufferGTest.x TriggerEngineGTest.x LTTBGTest.x BinaryRecorderGTest.x
+OBJSX = TriggerEngineSrc.x BinaryRecorderSrc.x SignalRingBufferGTest.x TriggerEngineGTest.x LTTBGTest.x BinaryRecorderGTest.x BoundsCheckTest.x WSServerBufferTest.x
 
 PACKAGE=Applications
 ROOT_DIR=../../..

Test/Applications/StreamHub/WSServerBufferTest.cpp

@@ -0,0 +1,92 @@
+/**
+ * @file WSServerBufferTest.cpp
+ * @brief Reproduction test for CR-1: 1-byte heap OOB write in WSServer.
+ *
+ * Verifies that the receive buffer allocated in ClientReadLoop is large enough
+ * to hold a maximal masked WebSocket frame (14-byte header + 65536 payload)
+ * plus one extra byte for in-place NUL-termination, without overflowing.
+ *
+ * Build: linked into the GTest harness alongside MainGTest.cpp.
+ */
+
+#include "WSFrame.h"
+#include <gtest/gtest.h>
+#include <cstdlib>
+#include <cstring>
+
+using namespace StreamHub;
+
+// Mirror the WSServer.h constant (TEST_WS_MAX_RECV_PAYLOAD = 65536).
+static const uint32 TEST_WS_MAX_RECV_PAYLOAD = 65536u;
+
+// Test: A maximal masked WebSocket frame (64-bit extended length, masked)
+// with payloadLen = TEST_WS_MAX_RECV_PAYLOAD must fit within kRecvBuf, and
+// payload[plen] must be a valid in-bounds index (for NUL-termination).
+TEST(WSServerBufferTest, MaximalFrameFitsInRecvBuffer) {
+    // Reproduce the exact buffer sizing logic from WSServer::ClientReadLoop.
+    const uint32 kRecvBuf = TEST_WS_MAX_RECV_PAYLOAD + 14u + 1u;
+    uint8 *buf = new uint8[kRecvBuf];
+
+    // Build a maximal masked frame: FIN + TEXT, payloadLen=65536 (64-bit ext),
+    // mask=1.
+    uint8 frame[14 + 65536];
+    frame[0] = WS_FIN_BIT | WS_OPCODE_TEXT;   // FIN + TEXT
+    frame[1] = WS_MASK_BIT | 127u;             // masked + 64-bit length
+    // 8-byte extended length = 65536
+    uint64 plen = TEST_WS_MAX_RECV_PAYLOAD;
+    for (int i = 7; i >= 0; i--) {
+        frame[2 + i] = static_cast<uint8>(plen & 0xFFu);
+        plen >>= 8u;
+    }
+    // 4-byte mask key
+    frame[10] = 0xAA; frame[11] = 0xBB; frame[12] = 0xCC; frame[13] = 0xDD;
+    // Payload (doesn't matter, just fill with zeros)
+    memset(frame + 14, 0, 65536);
+
+    // Copy into buf (simulating a TCP read)
+    ASSERT_LE(sizeof(frame), static_cast<size_t>(kRecvBuf));
+    memcpy(buf, frame, sizeof(frame));
+
+    // Parse the header
+    WSFrameHeader hdr;
+    ASSERT_TRUE(WSParseHeader(buf, sizeof(frame), hdr));
+    ASSERT_EQ(hdr.headerSize, 14u);
+    ASSERT_EQ(hdr.payloadLen, static_cast<uint64>(TEST_WS_MAX_RECV_PAYLOAD));
+    ASSERT_TRUE(hdr.masked);
+
+    // Unmask
+    uint8 *payload = buf + hdr.headerSize;
+    WSUnmask(payload, static_cast<uint32>(hdr.payloadLen), hdr.maskKey);
+
+    // The critical check: payload[plen] must be within the buffer.
+    // Before the fix, kRecvBuf was 65550 and payload[65536] = buf[65550]
+    // was one byte past the end.  After the fix (+1), it's in bounds.
+    uint32 plenIdx = static_cast<uint32>(hdr.payloadLen);
+    ASSERT_LT(hdr.headerSize + plenIdx, kRecvBuf)
+        << "payload[plen] would be out of bounds — buffer overflow!";
+
+    // Simulate the NUL-termination that WSServer does:
+    uint8 savedByte = payload[plenIdx];
+    payload[plenIdx] = '\0';
+    // Verify it's within bounds (no ASan/heap overflow)
+    EXPECT_EQ(payload[plenIdx], '\0');
+    payload[plenIdx] = savedByte;
+
+    delete[] buf;
+}
+
+// Test: Verify the old (buggy) buffer size would have overflowed.
+// This documents the bug for future readers.
+TEST(WSServerBufferTest, OldBufferSizeWouldOverflow) {
+    const uint32 oldKRecvBuf = TEST_WS_MAX_RECV_PAYLOAD + 14u; // the buggy size
+    const uint32 headerSize = 14u;
+    const uint32 plen = TEST_WS_MAX_RECV_PAYLOAD;
+    // headerSize + plen == oldKRecvBuf, so payload[plen] = buf[oldKRecvBuf]
+    // is one byte past the end.
+    ASSERT_EQ(headerSize + plen, oldKRecvBuf)
+        << "Expected the old buffer to be exactly full (no room for NUL term)";
+    // The fix adds +1:
+    const uint32 newKRecvBuf = TEST_WS_MAX_RECV_PAYLOAD + 14u + 1u;
+    ASSERT_LT(headerSize + plen, newKRecvBuf)
+        << "New buffer must have room for the NUL-termination byte";
+}

Test/Applications/StreamHub/depends.x86-linux

@@ -0,0 +1,427 @@
+../../../Build/x86-linux/Applications/StreamHub/BinaryRecorderGTest.o: BinaryRecorderGTest.cpp \
+ ../../../Source/Applications/StreamHub/BinaryRecorder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ ../../../Common/UDP/UDPSProtocol.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h
+../../../Build/x86-linux/Applications/StreamHub/BinaryRecorderSrc.o: BinaryRecorderSrc.cpp \
+ ../../../Source/Applications/StreamHub/BinaryRecorder.cpp \
+ ../../../Source/Applications/StreamHub/BinaryRecorder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ ../../../Common/UDP/UDPSProtocol.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Introspection.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/IntrospectionEntry.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Iterator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SortFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SearchFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/LoadableLibrary.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h
+../../../Build/x86-linux/Applications/StreamHub/BoundsCheckTest.o: BoundsCheckTest.cpp \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h
+../../../Build/x86-linux/Applications/StreamHub/LTTBGTest.o: LTTBGTest.cpp ../../../Source/Applications/StreamHub/LTTB.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h
+../../../Build/x86-linux/Applications/StreamHub/SignalRingBufferGTest.o: SignalRingBufferGTest.cpp \
+ ../../../Source/Applications/StreamHub/SignalRingBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h
+../../../Build/x86-linux/Applications/StreamHub/TriggerEngineGTest.o: TriggerEngineGTest.cpp \
+ ../../../Source/Applications/StreamHub/TriggerEngine.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Introspection.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/IntrospectionEntry.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Iterator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SortFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SearchFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/LoadableLibrary.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h
+../../../Build/x86-linux/Applications/StreamHub/TriggerEngineSrc.o: TriggerEngineSrc.cpp \
+ ../../../Source/Applications/StreamHub/TriggerEngine.cpp \
+ ../../../Source/Applications/StreamHub/TriggerEngine.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Introspection.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/IntrospectionEntry.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Iterator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SortFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SearchFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/LoadableLibrary.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h
+../../../Build/x86-linux/Applications/StreamHub/WSServerBufferTest.o: WSServerBufferTest.cpp \
+ ../../../Source/Applications/StreamHub/WSFrame.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h

Test/Applications/StreamHub/dependsRaw.x86-linux

@@ -0,0 +1,427 @@
+BinaryRecorderGTest.o: BinaryRecorderGTest.cpp \
+ ../../../Source/Applications/StreamHub/BinaryRecorder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ ../../../Common/UDP/UDPSProtocol.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h
+BinaryRecorderSrc.o: BinaryRecorderSrc.cpp \
+ ../../../Source/Applications/StreamHub/BinaryRecorder.cpp \
+ ../../../Source/Applications/StreamHub/BinaryRecorder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ ../../../Common/UDP/UDPSProtocol.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Introspection.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/IntrospectionEntry.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Iterator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SortFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SearchFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/LoadableLibrary.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h
+BoundsCheckTest.o: BoundsCheckTest.cpp \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h
+LTTBGTest.o: LTTBGTest.cpp ../../../Source/Applications/StreamHub/LTTB.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h
+SignalRingBufferGTest.o: SignalRingBufferGTest.cpp \
+ ../../../Source/Applications/StreamHub/SignalRingBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h
+TriggerEngineGTest.o: TriggerEngineGTest.cpp \
+ ../../../Source/Applications/StreamHub/TriggerEngine.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Introspection.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/IntrospectionEntry.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Iterator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SortFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SearchFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/LoadableLibrary.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h
+TriggerEngineSrc.o: TriggerEngineSrc.cpp \
+ ../../../Source/Applications/StreamHub/TriggerEngine.cpp \
+ ../../../Source/Applications/StreamHub/TriggerEngine.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Introspection.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/IntrospectionEntry.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Iterator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SortFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SearchFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/LoadableLibrary.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h
+WSServerBufferTest.o: WSServerBufferTest.cpp \
+ ../../../Source/Applications/StreamHub/WSFrame.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h

Test/Components/DataSources/UDPStreamer/depends.x86-linux

@@ -0,0 +1,199 @@
+../../../../Build/x86-linux/Components/DataSources/UDPStreamer/UDPStreamerGTest.o: UDPStreamerGTest.cpp \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h \
+ UDPStreamerTest.h
+../../../../Build/x86-linux/Components/DataSources/UDPStreamer/UDPStreamerTest.o: UDPStreamerTest.cpp \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Introspection.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/IntrospectionEntry.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Iterator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SortFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SearchFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/LoadableLibrary.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicTCPSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/InternetHost.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/InternetHostCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/InternetMulticastCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HandleI.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/SocketCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicUDPSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/AnyObject.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Object.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/CLASSREGISTER.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItemT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabaseNode.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Fnv1aHashFunction.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/HashFunction.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Object.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Reference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerNode.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/UnorderedMap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerFilterObjectName.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/TypeConversion.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAM.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/DataSourceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/StatefulI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/ExecutableI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L5GAMs/GAMScheduler.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/EventSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAMSchedulerI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAM.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ProcessorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitSet.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/TimingDataSource.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAMDataSource.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryArea.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/Message.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/MultiThreadService.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/ExecutionInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/Threads.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ThreadsB.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/ExceptionHandler.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThreadI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/SingleThreadService.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThread.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplication.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/CLASSMETHODREGISTER.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodInterfaceMapper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodCaller.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodCallerT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAMSchedulerI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/Message.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageFilterPool.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplicationConfigurationBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplication.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/RegisteredMethodsMessageFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/StandardParser.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationParserI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/AnyTypeCreator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/LexicalAnalyzer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/GrammarInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/Token.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/TokenInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ParserI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/RuntimeEvaluator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticStack.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/VariableInformation.h \
+ ../../../../Source/Components/DataSources/UDPStreamer/UDPStreamer.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryDataSourceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/SingleThreadService.h \
+ ../../../../Source/Components/Interfaces/UDPStream/UDPSServer.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/InternetHost.h \
+ ../../../../Common/UDP/UDPSProtocol.h UDPStreamerTest.h

Test/Components/DataSources/UDPStreamer/dependsRaw.x86-linux

@@ -0,0 +1,199 @@
+UDPStreamerGTest.o: UDPStreamerGTest.cpp \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h \
+ UDPStreamerTest.h
+UDPStreamerTest.o: UDPStreamerTest.cpp \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Introspection.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/IntrospectionEntry.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Iterator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SortFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SearchFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/LoadableLibrary.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicTCPSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/InternetHost.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/InternetHostCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/InternetMulticastCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HandleI.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/SocketCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicUDPSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/AnyObject.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Object.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/CLASSREGISTER.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItemT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabaseNode.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Fnv1aHashFunction.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/HashFunction.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Object.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Reference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerNode.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/UnorderedMap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerFilterObjectName.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/TypeConversion.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAM.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/DataSourceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/StatefulI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/ExecutableI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L5GAMs/GAMScheduler.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/EventSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAMSchedulerI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAM.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ProcessorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitSet.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/TimingDataSource.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAMDataSource.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryArea.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/Message.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/MultiThreadService.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/ExecutionInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/Threads.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ThreadsB.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/ExceptionHandler.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThreadI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/SingleThreadService.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThread.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplication.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/CLASSMETHODREGISTER.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodInterfaceMapper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodCaller.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodCallerT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAMSchedulerI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/Message.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageFilterPool.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplicationConfigurationBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplication.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/RegisteredMethodsMessageFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/StandardParser.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationParserI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/AnyTypeCreator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/LexicalAnalyzer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/GrammarInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/Token.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/TokenInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ParserI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/RuntimeEvaluator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticStack.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/VariableInformation.h \
+ ../../../../Source/Components/DataSources/UDPStreamer/UDPStreamer.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryDataSourceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/SingleThreadService.h \
+ ../../../../Source/Components/Interfaces/UDPStream/UDPSServer.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/InternetHost.h \
+ ../../../../Common/UDP/UDPSProtocol.h UDPStreamerTest.h

Test/Components/DataSources/UDPStreamerClient/Makefile.gcc

@@ -0,0 +1 @@
+include Makefile.inc

Test/Components/DataSources/UDPStreamerClient/Makefile.inc

@@ -0,0 +1,59 @@
+#############################################################
+#
+# Copyright 2015 F4E | European Joint Undertaking for ITER
+#  and the Development of Fusion Energy ('Fusion for Energy')
+#
+# Licensed under the EUPL, Version 1.1 or - as soon they
+# will be approved by the European Commission - subsequent
+# versions of the EUPL (the "Licence");
+# You may not use this work except in compliance with the
+# Licence.
+# You may obtain a copy of the Licence at:
+#
+# http://ec.europa.eu/idabc/eupl
+#
+# Unless required by applicable law or agreed to in
+# writing, software distributed under the Licence is
+# distributed on an "AS IS" basis,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied.
+# See the Licence for the specific language governing
+# permissions and limitations under the Licence.
+#
+#############################################################
+
+OBJSX = UDPStreamerClientTest.x UDPStreamerClientGTest.x
+
+PACKAGE=Components/DataSources
+ROOT_DIR=../../../..
+MAKEDEFAULTDIR=$(MARTe2_DIR)/MakeDefaults
+
+include $(MAKEDEFAULTDIR)/MakeStdLibDefs.$(TARGET)
+
+INCLUDES += -I.
+INCLUDES += -I$(ROOT_DIR)/Source/Components/Interfaces/UDPStream
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L0Types
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L2Objects
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L3Streams
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Messages
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Configuration
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L5GAMs
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L3Services
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4Messages
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4StateMachine
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L5GAMs
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L3Streams
+INCLUDES += -I$(MARTe2_DIR)/Lib/gtest-1.7.0/include
+INCLUDES += -I$(ROOT_DIR)/Common/UDP
+INCLUDES += -I$(ROOT_DIR)/Source/Components/DataSources/UDPStreamerClient
+
+all: $(OBJS) \
+    $(BUILD_DIR)/UDPStreamerClientTest$(LIBEXT)
+	echo $(OBJS)
+
+include depends.$(TARGET)
+
+include $(MAKEDEFAULTDIR)/MakeStdLibRules.$(TARGET)

Test/Components/DataSources/UDPStreamerClient/UDPStreamerClientGTest.cpp

@@ -0,0 +1,147 @@
+/**
+ * @file UDPStreamerClientGTest.cpp
+ * @brief Source file for class UDPStreamerClientGTest
+ * @date 01/07/2026
+ * @author Martino Ferrari
+ *
+ * @copyright Copyright 2015 F4E | European Joint Undertaking for ITER and
+ * the Development of Fusion Energy ('Fusion for Energy').
+ * Licensed under the EUPL, Version 1.1 or - as soon they will be approved
+ * by the European Commission - subsequent versions of the EUPL (the "Licence")
+ * You may not use this work except in compliance with the Licence.
+ * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl
+ *
+ * @warning Unless required by applicable law or agreed to in writing,
+ * software distributed under the Licence is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the Licence permissions and limitations under the Licence.
+ *
+ * @details This source file contains the GTest wrapper for all UDPStreamerClient tests.
+ */
+
+#define DLL_API
+
+/*---------------------------------------------------------------------------*/
+/*                         Standard header includes                          */
+/*---------------------------------------------------------------------------*/
+#include "gtest/gtest.h"
+#include <limits.h>
+
+/*---------------------------------------------------------------------------*/
+/*                         Project header includes                           */
+/*---------------------------------------------------------------------------*/
+#include "UDPStreamerClientTest.h"
+
+/*---------------------------------------------------------------------------*/
+/*                           Method definitions                              */
+/*---------------------------------------------------------------------------*/
+
+TEST(UDPStreamerClientGTest, TestInitialise_Valid) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestInitialise_Valid());
+}
+
+TEST(UDPStreamerClientGTest, TestInitialise_DefaultServerAddress) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestInitialise_DefaultServerAddress());
+}
+
+TEST(UDPStreamerClientGTest, TestInitialise_DefaultPort) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestInitialise_DefaultPort());
+}
+
+TEST(UDPStreamerClientGTest, TestInitialise_SilenceTimeoutFloat) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestInitialise_SilenceTimeoutFloat());
+}
+
+TEST(UDPStreamerClientGTest, TestInitialise_MulticastMode_Valid) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestInitialise_MulticastMode_Valid());
+}
+
+TEST(UDPStreamerClientGTest, TestInitialise_MulticastMode_DefaultDataPort) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestInitialise_MulticastMode_DefaultDataPort());
+}
+
+TEST(UDPStreamerClientGTest, TestSetConfiguredDatabase_MultipleSignals) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestSetConfiguredDatabase_MultipleSignals());
+}
+
+TEST(UDPStreamerClientGTest, TestPrepareNextState_StartsReceiver) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestPrepareNextState_StartsReceiver());
+}
+
+TEST(UDPStreamerClientGTest, TestSynchronise_NoData) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestSynchronise_NoData());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSConfig_BasicAccept) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSConfig_BasicAccept());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSConfig_SignalCountMismatch) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSConfig_SignalCountMismatch());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSConfig_NameMismatch) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSConfig_NameMismatch());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSConfig_ElementCountMismatch) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSConfig_ElementCountMismatch());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSConfig_TooSmallPayload) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSConfig_TooSmallPayload());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSData_QuantizedUint16) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSData_QuantizedUint16());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSData_QuantizedInt8) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSData_QuantizedInt8());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSData_MultipleSignalsOrder) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSData_MultipleSignalsOrder());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSData_AccumulateMode) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSData_AccumulateMode());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSData_TooSmallPayload) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSData_TooSmallPayload());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSData_BeforeConfig) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSData_BeforeConfig());
+}
+
+TEST(UDPStreamerClientGTest, TestOnUDPSDisconnected_InvalidatesConfig) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestOnUDPSDisconnected_InvalidatesConfig());
+}
+
+TEST(UDPStreamerClientGTest, TestExecute_ConnectConfigDataEndToEnd) {
+    UDPStreamerClientTest test;
+    ASSERT_TRUE(test.TestExecute_ConnectConfigDataEndToEnd());
+}

Test/Components/DataSources/UDPStreamerClient/UDPStreamerClientTest.h

@@ -0,0 +1,163 @@
+/**
+ * @file UDPStreamerClientTest.h
+ * @brief Header file for class UDPStreamerClientTest
+ * @date 01/07/2026
+ * @author Martino Ferrari
+ *
+ * @copyright Copyright 2015 F4E | European Joint Undertaking for ITER and
+ * the Development of Fusion Energy ('Fusion for Energy').
+ * Licensed under the EUPL, Version 1.1 or - as soon they will be approved
+ * by the European Commission - subsequent versions of the EUPL (the "Licence")
+ * You may not use this work except in compliance with the Licence.
+ * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl
+ *
+ * @warning Unless required by applicable law or agreed to in writing,
+ * software distributed under the Licence is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the Licence permissions and limitations under the Licence.
+ *
+ * @details This header file contains the declaration of the class UDPStreamerClientTest
+ * with all of its public, protected and private members. It may also include
+ * definitions for inline methods which need to be visible to the compiler.
+ */
+
+#ifndef UDPSTREAMERCLIENTTEST_H_
+#define UDPSTREAMERCLIENTTEST_H_
+
+/*---------------------------------------------------------------------------*/
+/*                        Standard header includes                           */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/*                        Project header includes                            */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/*                           Class declaration                               */
+/*---------------------------------------------------------------------------*/
+
+/**
+ * @brief Tests the UDPStreamerClient DataSource public methods.
+ */
+class UDPStreamerClientTest {
+public:
+
+    /**
+     * @brief Tests Initialise with a fully valid unicast configuration.
+     */
+    bool TestInitialise_Valid();
+
+    /**
+     * @brief Tests that a missing ServerAddress uses the default (127.0.0.1).
+     */
+    bool TestInitialise_DefaultServerAddress();
+
+    /**
+     * @brief Tests that a missing Port uses the default (44500).
+     */
+    bool TestInitialise_DefaultPort();
+
+    /**
+     * @brief Tests Initialise with MulticastGroup and an explicit DataPort.
+     */
+    bool TestInitialise_MulticastMode_Valid();
+
+    /**
+     * @brief Tests Initialise with a sub-second float32 SilenceTimeout (0.25 s)
+     * forwarded through to the UDPSClient receiver.
+     */
+    bool TestInitialise_SilenceTimeoutFloat();
+
+    /**
+     * @brief Tests that DataPort defaults to Port+1 when MulticastGroup is
+     * set but DataPort is absent.
+     */
+    bool TestInitialise_MulticastMode_DefaultDataPort();
+
+    /**
+     * @brief Tests SetConfiguredDatabase / AllocateMemory with several
+     * signals of different types and array sizes.
+     */
+    bool TestSetConfiguredDatabase_MultipleSignals();
+
+    /**
+     * @brief Tests PrepareNextState starts the background receiver thread.
+     */
+    bool TestPrepareNextState_StartsReceiver();
+
+    /**
+     * @brief Tests that Synchronise() with no data received is a safe no-op.
+     */
+    bool TestSynchronise_NoData();
+
+    /**
+     * @brief Tests the full OnUDPSConfig -> OnUDPSData -> Synchronise path
+     * for a single unquantised scalar signal.
+     */
+    bool TestOnUDPSConfig_BasicAccept();
+
+    /**
+     * @brief Tests that a CONFIG with a different signal count is rejected.
+     */
+    bool TestOnUDPSConfig_SignalCountMismatch();
+
+    /**
+     * @brief Tests that a CONFIG with a mismatched signal name is rejected.
+     */
+    bool TestOnUDPSConfig_NameMismatch();
+
+    /**
+     * @brief Tests that a CONFIG with a mismatched element count is rejected.
+     */
+    bool TestOnUDPSConfig_ElementCountMismatch();
+
+    /**
+     * @brief Tests that an undersized CONFIG payload is safely rejected.
+     */
+    bool TestOnUDPSConfig_TooSmallPayload();
+
+    /**
+     * @brief Tests UINT16 dequantisation into a Float32Bit destination signal.
+     */
+    bool TestOnUDPSData_QuantizedUint16();
+
+    /**
+     * @brief Tests INT8 dequantisation formula into a Float64Bit destination signal.
+     */
+    bool TestOnUDPSData_QuantizedInt8();
+
+    /**
+     * @brief Tests that multiple signals decode into the correct buffer offsets.
+     */
+    bool TestOnUDPSData_MultipleSignalsOrder();
+
+    /**
+     * @brief Tests Accumulate publishing mode: scalar signals publish only the
+     * most recent sample, array signals publish once regardless of numSamples.
+     */
+    bool TestOnUDPSData_AccumulateMode();
+
+    /**
+     * @brief Tests that an undersized DATA payload (missing timestamp) is a safe no-op.
+     */
+    bool TestOnUDPSData_TooSmallPayload();
+
+    /**
+     * @brief Tests that OnUDPSData before a valid CONFIG is a safe no-op.
+     */
+    bool TestOnUDPSData_BeforeConfig();
+
+    /**
+     * @brief Tests that OnUDPSDisconnected() invalidates the CONFIG so
+     * subsequent DATA payloads are ignored until a new CONFIG arrives.
+     */
+    bool TestOnUDPSDisconnected_InvalidatesConfig();
+
+    /**
+     * @brief Tests the full CONNECT -> CONFIG -> DATA flow over real loopback
+     * UDP sockets, mirroring the server side of the wire protocol.
+     */
+    bool TestExecute_ConnectConfigDataEndToEnd();
+};
+
+#endif /* UDPSTREAMERCLIENTTEST_H_ */

Test/Components/DataSources/UDPStreamerClient/depends.x86-linux

@@ -0,0 +1,197 @@
+../../../../Build/x86-linux/Components/DataSources/UDPStreamerClient/UDPStreamerClientGTest.o: UDPStreamerClientGTest.cpp \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h \
+ UDPStreamerClientTest.h
+../../../../Build/x86-linux/Components/DataSources/UDPStreamerClient/UDPStreamerClientTest.o: UDPStreamerClientTest.cpp \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Introspection.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/IntrospectionEntry.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Iterator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SortFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SearchFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/LoadableLibrary.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicUDPSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/InternetHost.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/InternetHostCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/InternetMulticastCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HandleI.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/SocketCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/AnyObject.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Object.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/CLASSREGISTER.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItemT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabaseNode.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Fnv1aHashFunction.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/HashFunction.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Object.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Reference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerNode.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/UnorderedMap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerFilterObjectName.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/TypeConversion.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAM.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/DataSourceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/StatefulI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/ExecutableI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplication.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/CLASSMETHODREGISTER.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodInterfaceMapper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodCaller.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodCallerT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAMSchedulerI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAM.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ProcessorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitSet.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/TimingDataSource.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAMDataSource.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryArea.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/Message.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageFilterPool.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplicationConfigurationBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplication.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/RegisteredMethodsMessageFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/StandardParser.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationParserI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/AnyTypeCreator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/LexicalAnalyzer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/GrammarInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/Token.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/TokenInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ParserI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/RuntimeEvaluator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticStack.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/VariableInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/Threads.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ThreadsB.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/ExceptionHandler.h \
+ ../../../../Common/UDP/UDPSProtocol.h \
+ ../../../../Source/Components/DataSources/UDPStreamerClient/UDPStreamerClient.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/EventSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryDataSourceI.h \
+ ../../../../Source/Components/Interfaces/UDPStream/UDPSClient.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicTCPSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/ExecutionInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/ExecutionInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/InternetHost.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/SingleThreadService.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThreadI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThread.h \
+ UDPStreamerClientTest.h

Test/Components/DataSources/UDPStreamerClient/dependsRaw.x86-linux

@@ -0,0 +1,197 @@
+UDPStreamerClientGTest.o: UDPStreamerClientGTest.cpp \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-port.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-message.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-string.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-filepath.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-type-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-death-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-death-test-internal.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-param-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-linked_ptr.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-printers.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/internal/gtest-param-util-generated.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_prod.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-test-part.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest-typed-test.h \
+ /home/martino/workspace/MARTe2/Lib/gtest-1.7.0/include/gtest/gtest_pred_impl.h \
+ UDPStreamerClientTest.h
+UDPStreamerClientTest.o: UDPStreamerClientTest.cpp \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/AdvancedErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Architecture/x86_gcc/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TypeCharacteristics.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/TemplateParametersVerificator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CompilerTypes.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ErrorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/HighResolutionTimerA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/HighResolutionTimerCalibrator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeStamp.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamMemoryReference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/BufferedStreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TimeoutType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassProperties.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectsDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/GlobalObjectI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/StandardHeap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../../GeneralDefinitions.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Environment/Linux/../Generic/StandardHeap_Generic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FastPollingMutexSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Atomic.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Architecture/x86_gcc/AtomicA.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ErrorManagement.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/CString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Introspection.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/IntrospectionEntry.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/TypeDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BasicType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/FractionalInteger.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitRange.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitBoolean.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/ZeroTerminatedArray.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Iterator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListable.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SortFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/SearchFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/LoadableLibrary.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Matrix.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryOperationsHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/FormatDescriptor.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/IOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/CharBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StreamI.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicUDPSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/InternetHost.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamString.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/StreamStringIOBuffer.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/InternetHostCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/InternetMulticastCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HandleI.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/Environment/Linux/SocketCore.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/Sleep.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/AnyObject.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Object.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/AnyType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/CLASSREGISTER.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassRegistryItemT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectBuilderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabaseNode.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Fnv1aHashFunction.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/HashFunction.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/LinkedListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Object.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/Reference.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerNode.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/UnorderedMap.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HeapManager.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StringHelper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainerFilterObjectName.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceContainer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/StructuredDataI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/TypeConversion.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/Vector.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAM.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/DataSourceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/StatefulI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/ExecutableI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ObjectRegistryDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ReferenceT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplication.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/CLASSMETHODREGISTER.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodInterfaceMapper.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodCaller.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L2Objects/ClassMethodCallerT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAMSchedulerI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAM.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ProcessorType.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/BitSet.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/TimingDataSource.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/GAMDataSource.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/MemoryArea.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/Message.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageFilterPool.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/MessageFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplicationConfigurationBuilder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/RealTimeApplication.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Messages/RegisteredMethodsMessageFilter.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/StandardParser.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationParserI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/AnyTypeCreator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticListHolder.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ConfigurationDatabase.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/LexicalAnalyzer.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L3Streams/GrammarInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/Token.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/TokenInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/ParserI.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/RuntimeEvaluator.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L0Types/IteratorT.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticStack.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/StaticList.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L4Configuration/VariableInformation.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/Threads.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/ThreadsB.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/ExceptionHandler.h \
+ ../../../../Common/UDP/UDPSProtocol.h \
+ ../../../../Source/Components/DataSources/UDPStreamerClient/UDPStreamerClient.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L1Portability/EventSem.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L5GAMs/MemoryDataSourceI.h \
+ ../../../../Source/Components/Interfaces/UDPStream/UDPSClient.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/BasicTCPSocket.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/ExecutionInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/ExecutionInfo.h \
+ /home/martino/workspace/MARTe2/Source/Core/BareMetal/L1Portability/HighResolutionTimer.h \
+ /home/martino/workspace/MARTe2/Source/Core/FileSystem/L1Portability/InternetHost.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/SingleThreadService.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedServiceMethodBinderT.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThreadI.h \
+ /home/martino/workspace/MARTe2/Source/Core/Scheduler/L3Services/EmbeddedThread.h \
+ UDPStreamerClientTest.h

Test/Configurations/TestApp.cfg

@@ -424,6 +424,7 @@ $TestApp = {
             Port = 44500
             MulticastGroup = "239.0.0.1"
             DataPort = 44503
+            Interface = "127.0.0.1"
             MaxPayloadSize = 1400
             PublishingMode = "Accumulate"
             MinRefreshRate = 100

Test/Configurations/combined_test.cfg

@@ -279,6 +279,7 @@ $App = {
             Port = 44500
             MulticastGroup = "239.0.0.1"
             DataPort = 44503
+            Interface = "127.0.0.1"
             MaxPayloadSize = 1400
             PublishingMode = "Accumulate"
             MinRefreshRate = 100
@@ -373,7 +374,7 @@ $App = {
 // ── DebugService ──────────────────────────────────────────────────────────────
 // Patches the broker registry at startup so every signal is traceable.
 // TcpLogger is auto-injected on LogPort (9090) — no explicit DataSource needed.
-// Connect the debugger web UI (./run_combined_test.sh -d) to:
+// Connect the debugger web UI (Client/debugger) to:
 //   Host=127.0.0.1  TCP=8080  UDP=8081  Log=9090
 +DebugService = {
     Class = DebugService

Test/Configurations/streamhub_demo.cfg

@@ -411,6 +411,7 @@ $App = {
       Port = 44500
       MulticastGroup = "239.0.0.1"
       DataPort = 44503
+      Interface = "127.0.0.1"
       MaxPayloadSize = 1400
       PublishingMode = "Accumulate"
       MinRefreshRate = 100

Test/E2E/chain/test_report_stress.py

@@ -1,63 +0,0 @@
-import os
-import report_build as RB
-
-_SR = {
-    "overall": "PASS",
-    "cases": [
-        {"id": "ds_size_1000", "shape": "hub", "axis": "ds_signal_elements",
-         "level": 1000, "status": "PASS", "survival": True, "clients": 1,
-         "min_frames": 200, "marte_cpu_s": 12.8, "marte_rss_mb": 10.4,
-         "hub_cpu_s": 2.33, "hub_rss_mb": 28.3, "zoom_count": 0, "zoom_fail": 0,
-         "zoom_p50_ms": 0.0, "zoom_p95_ms": 0.0, "fails": []},
-        {"id": "ds_size_4000", "shape": "hub", "axis": "ds_signal_elements",
-         "level": 4000, "status": "PASS", "survival": True, "clients": 1,
-         "min_frames": 180, "marte_cpu_s": 20.0, "marte_rss_mb": 14.0,
-         "hub_cpu_s": 3.0, "hub_rss_mb": 40.0, "zoom_count": 0, "zoom_fail": 0,
-         "zoom_p50_ms": 0.0, "zoom_p95_ms": 0.0, "fails": []},
-        {"id": "hub_reqrate_50", "shape": "hub", "axis": "hub_zoom_reqrate_hz",
-         "level": 50, "status": "PASS", "survival": True, "clients": 4,
-         "min_frames": 100, "marte_cpu_s": 5.0, "marte_rss_mb": 12.0,
-         "hub_cpu_s": 8.0, "hub_rss_mb": 60.0, "zoom_count": 400, "zoom_fail": 0,
-         "zoom_p50_ms": 12.0, "zoom_p95_ms": 35.0, "fails": []},
-    ],
-}
-
-
-def test_build_stress_groups_by_axis_sorted_by_level():
-    st = RB.build_stress(_SR)
-    assert st["overall"] == "PASS"
-    assert len(st["cases"]) == 3
-    assert set(st["by_axis"]) == {"ds_signal_elements", "hub_zoom_reqrate_hz"}
-    levels = [c["level"] for c in st["by_axis"]["ds_signal_elements"]]
-    assert levels == [1000, 4000]  # sorted ascending
-
-
-def test_stress_headline_aggregates():
-    st = RB.build_stress(_SR)
-    hl = RB.stress_headline(st)
-    assert hl["stress_pass"] == 3
-    assert hl["stress_fail"] == 0
-    assert hl["stress_max_hub_rss_mb"] == 60.0
-    assert hl["stress_max_marte_rss_mb"] == 14.0
-    assert hl["stress_max_zoom_p95_ms"] == 35.0
-
-
-def test_stress_plots_one_png_per_axis(tmp_path):
-    st = RB.build_stress(_SR)
-    made = RB.stress_plots(st["by_axis"], str(tmp_path))
-    names = {os.path.basename(p) for p in made}
-    assert "stress_ds_signal_elements.png" in names
-    assert "stress_hub_zoom_reqrate_hz.png" in names
-    for p in made:
-        assert os.path.exists(p)
-
-
-def test_regression_includes_stress_when_present():
-    curr = {"e2e_pass": 5, "stress_max_hub_rss_mb": 60.0}
-    prev = {"e2e_pass": 5, "stress_max_hub_rss_mb": 50.0}
-    labels = dict(RB._LABELS); labels["stress_max_hub_rss_mb"] = "Stress max hub RSS (MB)"
-    directions = dict(RB._DIRECTION); directions["stress_max_hub_rss_mb"] = False
-    rows = RB.regression(curr, prev, labels, directions)
-    row = next(r for r in rows if r["key"] == "stress_max_hub_rss_mb")
-    assert row["delta"] == 10.0
-    assert row["better"] is False  # RSS went up → worse

Test/E2E/datasources/E2EMulticastTest.cfg

@@ -64,6 +64,7 @@ $E2EMulticastTest = {
             Port = 44600
             MulticastGroup = "239.0.0.1"
             DataPort = 44610
+            Interface = "127.0.0.1"
             MaxPayloadSize = 65507
             PublishingMode = "Strict"
             Signals = {

Test/E2E/datasources/E2E_Report.typ

@@ -1,413 +0,0 @@
-// UDPStreamerClient — E2E Test Report
-// Author: Martino Ferrari
-// Date: June 2026
-#set document(
-  title: "UDPStreamerClient — End-to-End Test Report",
-  author: "Martino Ferrari",
-  date: datetime(year: 2026, month: 6, day: 24),
-)
-#set page(numbering: "1 / 1", margin: (left: 2.5cm, right: 2.5cm, top: 2cm, bottom: 2cm))
-#set heading(numbering: "1.")
-#set par(justify: true)
-#show link: underline
-#show raw.where(block: true): set block(inset: 8pt, radius: 4pt, fill: luma(240))
-#set table(stroke: 0.5pt, inset: 8pt)
-
-// ── Live validation data (emitted by validate_binary.py --json) ──
-#let uni = json("e2e_unicast.json")
-#let multi = json("e2e_multicast.json")
-#let fidx(v) = if v < 0 { [—] } else { [#v] }
-#let pct(n, d) = if d > 0 { [#(calc.round(100 * n / d, digits: 1))%] } else { [—] }
-#let status-badge(d) = {
-  let c = if d.passed { green.darken(20%) } else { red.darken(10%) }
-  text(fill: c, weight: "bold")[#d.status]
-}
-// Validation metrics table for one mode's json record.
-#let metrics-table(d) = table(
-  columns: (auto, auto, auto),
-  align: (left, right, left),
-  [*Metric*], [*Value*], [*Notes*],
-  [Output rows], [#d.n_rows_out], [Cycles captured by `FileWriter`],
-  [Matching rows], [#d.matching_rows (#pct(d.matching_rows, d.n_rows_out))], [Non-zero rows equal to an input row],
-  [Zero rows], [#d.zero_rows (#pct(d.zero_rows, d.n_rows_out))], [Startup transient before first `DATA`],
-  [Mismatching rows], [#d.mismatching_rows (#pct(d.mismatching_rows, d.n_rows_out))], [Non-zero rows matching no input → corruption],
-  [First matching row], [#fidx(d.first_matching_row)], [Index of first transported row],
-  [First zero row], [#fidx(d.first_zero_row)], [Index of first all-zero row],
-  [First mismatching row], [#fidx(d.first_mismatch_row)], [`—` when no corruption],
-  [Status], [#status-badge(d)], [#d.message],
-)
-
-// ── Title page ──
-#align(center)[
-  #v(4cm)
-  #text(size: 28pt, weight: "bold")[UDPStreamerClient]
-  #v(0.5cm)
-  #text(size: 18pt)[End-to-End Test Report]
-  #v(1.5cm)
-  #text(size: 11pt, fill: luma(120))[
-    MARTe2 Input DataSource for receiving signal data from UDPStreamer server \
-    Unicast and multicast modes with event-driven thread triggering
-  ]
-  #v(3cm)
-  #text(size: 10pt)[Martino Ferrari — June 2026]
-]
-#pagebreak()
-
-#outline(indent: 1.5em, depth: 3)
-#pagebreak()
-
-// ═══════════════════════════════════════
-// 1. Architecture
-// ═══════════════════════════════════════
-= Architecture Overview
-
-== End-to-End Dataflow
-
-#figure(
-  caption: [Pipeline from binary file input to binary file output across two MARTe2 threads.],
-  {
-    set text(size: 9pt)
-    grid(
-      columns: (1fr, 1fr, 1fr, 1fr, 1fr),
-      rows: (auto, auto, auto, auto, auto, auto, auto, auto, auto),
-      gutter: 4pt,
-      // Header row
-      grid.cell(colspan: 5, align(center)[*Thread 1 — 1 kHz, CPU 0x1*]),
-      grid.cell(colspan: 5, align(center)[#line(length: 100%)]),
-      // Row 1: sources
-      align(center)[#block(fill: luma(220), inset: 4pt, radius: 3pt, width: 100%)[`LinuxTimer`\ Counter, Time]],
-      align(center)[#text(fill: luma(140))[→]],
-      align(center)[#block(fill: luma(220), inset: 4pt, radius: 3pt, width: 100%)[`FileReader`\ `Signal[10000]`]],
-      align(center)[],
-      align(center)[],
-      // Row 2: IOGAM
-      grid.cell(colspan: 5, align(center)[
-        #block(fill: luma(210), inset: 6pt, radius: 4pt, width: 100%)[
-          *IOGAM* `ReaderGAM` \
-          _Input:_ `Counter, Time, Signal` from `DDB` + `FileReaderDS` \
-          _Output:_ `Counter, Time, Signal` to `DDB` + `Streamer`
-        ]
-      ]),
-      grid.cell(colspan: 5, align(center)[#text(fill: luma(140))[↕ memcpy]]),
-      // Row 3: UDPStreamer
-      grid.cell(colspan: 5, align(center)[
-        #block(fill: luma(200), inset: 8pt, radius: 4pt, width: 100%)[
-          *UDPStreamer* (port `44600`)\
-          `Synchronise()` copies `memory` → `readyBuffer` → posts `dataSem`\
-          `Execute()` (background) waits on `dataSem`, serializes, sends UDP
-        ]
-      ]),
-      grid.cell(colspan: 5, align(center)[#text(fill: luma(140))[↓ UDP datagrams ↓]]),
-      // Row 4: Network
-      grid.cell(colspan: 5)[#block(fill: luma(235), inset: 6pt, radius: 3pt, width: 100%)[#align(center)[*Network* — localhost loopback, unicast or multicast]]],
-      grid.cell(colspan: 5, align(center)[#text(fill: luma(140))[↓ UDP datagrams ↓]]),
-      // Row 5: UDPStreamerClient
-      grid.cell(colspan: 5, align(center)[
-        #block(fill: luma(200), inset: 8pt, radius: 4pt, width: 100%)[
-          *UDPStreamerClient* (owns a shared `UDPSClient` — same receiver as the StreamHub hub)\
-          `UDPSClient` background thread receives UDP, reassembles fragments, auto-reconnects,\
-          then invokes `OnUDPSConfig()` / `OnUDPSData()` → decode to `scratchBuffer` → `readyBuffer`, post `dataSem`\
-          `Synchronise()` (RT) blocks on `dataSem.ResetWait()` — _no `LinuxTimer` needed_
-        ]
-      ]),
-      grid.cell(colspan: 5, align(center)[#text(fill: luma(140))[↕ memcpy]]),
-      // Row 6: IOGAM
-      grid.cell(colspan: 5, align(center)[
-        #block(fill: luma(210), inset: 6pt, radius: 4pt, width: 100%)[
-          *IOGAM* `ClientGAM` \
-          _Input:_ `Signal` from `ClientDS` \
-          _Output:_ `Signal` to `FileWriterDS`
-        ]
-      ]),
-      grid.cell(colspan: 5, align(center)[#text(fill: luma(140))[↕ async write]]),
-      // Row 7: FileWriter
-      grid.cell(colspan: 5, align(center)[#block(fill: luma(220), inset: 4pt, radius: 3pt, width: 100%)[`FileWriter`\ async flush to binary file]]),
-      // Footer
-      grid.cell(colspan: 5, align(center)[#line(length: 100%)]),
-      grid.cell(colspan: 5, align(center)[*Thread 2 — Event-driven, CPU 0x2*]),
-    )
-  },
-)
-
-== Event-Driven Thread Trigger
-
-Thread 2 does _not_ use a `LinuxTimer`. Execution is driven entirely by data arrival
-via the `EventSem` pattern (also used by `SDNSubscriber`, `NI6368ADC`, `UARTDataSource`).
-Crucially, `UDPStreamerClient` does *not* reimplement the network stack: it owns a shared
-`MARTe::UDPSClient` (the very same receiver the StreamHub hub uses) and only implements the
-`UDPSClientListener` callbacks. Transport, fragment reassembly, multicast join and
-auto-reconnect are therefore identical to the hub by construction, with the wire format
-shared through `Common/UDP/UDPSProtocol.h`.
-
-#enum(
-  numbering: "1.",
-  [`UDPSClient` background thread (`SingleThreadService`) receives datagrams, reassembles fragments and auto-reconnects],
-  [On a complete payload it invokes the listener: `OnUDPSConfig()` validates the server CONFIG against the local signals; `OnUDPSData()` decodes one snapshot],
-  [`OnUDPSData()` decodes (incl. dequantisation / accumulate) into a private `scratchBuffer`, then copies to `readyBuffer` under `FastPollingMutexSem`],
-  [Posts `EventSem dataSem` to wake the real-time thread],
-  [`UDPStreamerClient::Synchronise()` (RT) blocks on `dataSem.ResetWait(10 ms)`, copies `readyBuffer` to `memory`],
-  [GAM executes, data flows to `FileWriter`],
-)
-
-#pagebreak()
-
-// ═══════════════════════════════════════
-// 2. Latency Budget
-// ═══════════════════════════════════════
-= Latency Budget
-
-#figure(
-  image("latency_budget.png", width: 100%),
-  caption: [Estimated per-cycle latency. Total: 54 ms → ∼18 Hz max throughput. Bottlenecks: `FileWriter` async flush (50 ms) and poll sleeps (2 ms).],
-)
-
-== Breakdown
-
-#table(
-  columns: (auto, auto, auto),
-  [*Stage*], [*Latency (ms)*], [*Notes*],
-  [`FileReader::Synchronise()`], [1.0], [Blocking read from OS buffer],
-  [`IOGAM` (memcpy)], [0.1], [24 KB copy (6100 float32)],
-  [`UDPStreamer::Synchronise()`], [1.0], [Copy `memory` → `readyBuffer` + post semaphore],
-  [`UDPStreamer::Execute()` (bg)], [1.0], [`Sleep::MSec(1)` poll interval],
-  [Network (localhost)], [0.05], [Loopback, negligible],
-  [`UDPSClient` receiver (bg)], [1.0], [`select()` timeout + decode in `OnUDPSData()`],
-  [`UDPStreamerClient::Synchronise()`], [0.01], [`ResetWait(10ms)`, copy, return],
-  [`IOGAM` (memcpy)], [0.1], [24 KB copy (6100 floats)],
-  [`FileWriter` (async flush)], [50.0], [Disk I/O, buffer count configurable],
-  [*Total*], [*54.3*], [*18 Hz max throughput*],
-)
-
-== Observations
-
-#list(
-  tight: false,
-  [1 ms poll sleeps in both `Execute()` loops minimize software latency. Total poll overhead: 2 ms.],
-  [`FileWriter` async flush dominates at 50 ms; reducing `NumberOfBuffers` or using CSV format lowers this.],
-  [Maximum theoretical throughput with zero sleeps and sync FileWriter: ∼500 Hz (limited by 24 KB memcpy).],
-  [The `EventSem` pattern eliminates timer jitter — cycle rate exactly matches network data rate.],
-)
-
-#pagebreak()
-
-// ═══════════════════════════════════════
-// 3. Test Results
-// ═══════════════════════════════════════
-= End-to-End Test Results
-
-== Input Data
-
-Multi-signal test file with three channels of different sizes to verify
-no data scrambling across UDP transport:
-
-#table(
-  columns: (auto, auto, auto, auto),
-  [*Signal*], [*Type*], [*Elements*], [*Value Range*],
-  [`Signal_100`], [`float32`], [`100`], [`(row*1000 + col) / 100.0`],
-  [`Signal_1K`], [`float32`], [`1000`], [`(row*500 + col) / 50.0`],
-  [`Signal_5K`], [`float32`], [`5000`], [`(row*200 + col) / 20.0`],
-)
-
-Format: MARTe2 binary (42 B signal descriptor) + 6100 floats per row (24.4 KB/row).
-100 rows total, 2.44 MB data.
-
-#figure(
-  image("e2e_plots.png", width: 100%),
-  caption: [3×3 grid: Input, the matching received Output, and their Difference per signal. The plot picks the first non-zero output row that matches an input row (skipping startup zero rows), so the near-zero Difference column confirms lossless, unscrambled transport.],
-)
-
-== Latency Distribution
-
-#figure(
-  image("latency_histogram.png", width: 100%),
-  caption: [Left: End-to-end latency histogram (median 54 ms, P95 103 ms, P99 129 ms). Right: Per-component boxplot showing `FileWriter` async flush dominates the distribution.],
-)
-
-== Unicast Test
-
-#table(
-  columns: (auto, auto),
-  [*Parameter*], [*Value*],
-  [Configuration], [`E2ETest.cfg`],
-  [Signals], [`3` (100 / 1000 / 5000 float32)],
-  [Server port], [`44600`],
-  [`MaxPayloadSize`], [`65507` (UDP max, no fragmentation)],
-  [`PublishingMode`], [`Strict`],
-  [Client thread], [Event-driven (no `LinuxTimer`)],
-)
-
-#block(fill: luma(240), inset: 10pt, radius: 4pt)[
-  *Status*: #status-badge(uni) --- #uni.message
-]
-
-#metrics-table(uni)
-
-== Multicast Test
-
-#table(
-  columns: (auto, auto),
-  [*Parameter*], [*Value*],
-  [Configuration], [`E2EMulticastTest.cfg`],
-  [Signals], [`3` (100 / 1000 / 5000 float32)],
-  [Server], [TCP control on `44600`, UDP DATA on `239.0.0.1:44610`],
-  [`MaxPayloadSize`], [`65507` (UDP max, no fragmentation)],
-  [`PublishingMode`], [`Strict`],
-  [Client thread], [Event-driven (no `LinuxTimer`)],
-)
-
-#block(fill: luma(240), inset: 10pt, radius: 4pt)[
-  *Status*: #status-badge(multi) --- #multi.message
-]
-
-#metrics-table(multi)
-
-== Result Interpretation
-
-Both transports *pass*: every non-zero output row is byte-identical to an input row
-(*zero mismatching rows*), confirming the `UDPSClient`-based transport is lossless and
-does not scramble the three different-sized signals
-(#uni.matching_rows of #uni.n_rows_out rows matched for unicast,
-#multi.matching_rows of #multi.n_rows_out for multicast).
-
-The only non-matching rows are the leading all-zero rows (#uni.zero_rows for unicast;
-first real match at row #uni.first_matching_row). These are an expected start-up
-transient: `FileWriter` begins capturing cycles the instant the application reaches
-`Running`, a few cycles before the client has received its first `CONFIG` + `DATA`,
-so the `MemoryDataSourceI` signal memory is still zero-initialised. Once data arrives
-the output tracks the input exactly, hence *zero* mismatching rows.
-
-=== Pass / Fail Criteria
-
-`validate_binary.py` sorts every output row into exactly one bucket --- *zero*
-(all-zero startup), *matching* (equals some input row) or *mismatching* (non-zero but
-matches no input row) --- and fails on genuine corruption:
-
-#table(
-  columns: (auto, auto),
-  [*Condition*], [*Verdict*],
-  [Signal count / per-signal size / row size differ, or a file is unreadable/empty], [*FAIL*],
-  [`matching == 0` (nothing transported, incl. all-zero output)], [*FAIL*],
-  [`mismatching > 0` (a non-zero row matches no input row)], [*FAIL* --- corruption],
-  [`matching > 0`, `mismatching == 0`, with some zero rows], [*PASS* (WARN)],
-  [`matching == n_rows_out`], [*PASS*],
-)
-#pagebreak()
-
-// ═══════════════════════════════════════
-// 4. Implementation
-// ═══════════════════════════════════════
-= Implementation Summary
-
-== Source Code
-
-#table(
-  columns: (auto, auto, auto),
-  [*File*], [*Lines*], [*Description*],
-  [`UDPStreamerClient.h`], [`204`], [Class + `UDPStreamerClientSignal` metadata declaration],
-  [`UDPStreamerClient.cpp`], [`564`], [CONFIG/DATA decode, double-buffering, `Synchronise()`],
-  [`Makefile.inc`], [`60`], [Includes + links `-lUDPStream`, `-lMARTe2`],
-  [`Makefile.gcc`], [`25`], [GCC compiler rules],
-  [`Makefile.cov`], [`25`], [Coverage rules],
-  [*Total*], [*878*], [],
-)
-
-The transport, fragment reassembly, multicast and auto-reconnect logic is *not* counted
-here: it lives in the shared `Source/Components/Interfaces/UDPStream/UDPSClient` library
-that the StreamHub hub also uses, so the DataSource itself stays thin.
-
-== Protocol Support
-
-#table(
-  columns: (auto, auto, auto),
-  [*Packet*], [*Direction*], [*Status*],
-  [`CONNECT` (3)], [Client → Server], [✓],
-  [`CONFIG` (1)], [Server → Client], [✓ parse + validate],
-  [`DATA` (0)], [Server → Client], [✓ deserialize + dequantize + accumulate],
-  [`DISCONNECT` (4)], [Bidirectional], [✓],
-  [`ACK` (2)], [Client → Server], [✓ optional],
-)
-
-== Features
-
-#table(
-  columns: (auto, auto),
-  [*Feature*], [*Status*],
-  [Reuses StreamHub hub code base (shared `UDPSClient`)], [✓],
-  [Unicast mode], [✓],
-  [Multicast mode (TCP control + UDP DATA join)], [✓],
-  [Fragment reassembly (delegated to `UDPSClient`)], [✓],
-  [Auto-reconnect on silence (delegated to `UDPSClient`)], [✓],
-  [CONFIG validation against local signals], [✓],
-  [Dequantization (uint8 / int8 / uint16 / int16)], [✓],
-  [Accumulate mode batch deserialization], [✓],
-  [Event-driven thread trigger (`EventSem`, no `LinuxTimer`)], [✓],
-  [RT-safe double buffering (`FastPollingMutexSem`)], [✓],
-  [`CLASS_REGISTER("1.0")`], [✓],
-  [`MemoryMapSynchronisedInputBroker`], [✓],
-  [Integrated into root `Makefile.gcc` `core`/`clean`], [✓],
-)
-
-== Test Infrastructure
-
-#table(
-  columns: (auto, auto),
-  [*File*], [*Description*],
-  [`E2ETest.cfg`], [Unicast MARTe2 config with 3 multi-size signals],
-  [`E2EMulticastTest.cfg`], [Multicast MARTe2 config (`239.0.0.1:44610`)],
-  [`run_e2e_report.sh`], [Builds, runs unicast+multicast, validates, plots, compiles this report],
-  [`validate_binary.py`], [Row-bucket comparison + `--json` metrics export],
-  [`gen_test_data.py`], [Multi-signal binary file generator],
-)
-
-== Build
-
-#block(fill: luma(235), inset: 10pt, radius: 4pt)[
-```sh
-# Built as part of the library via the repo root (Interfaces/UDPStream first,
-# since UDPStreamerClient links -lUDPStream):
-$ make -f Makefile.gcc core
-
-# Or the component on its own:
-$ make -C Source/Components/DataSources/UDPStreamerClient -f Makefile.gcc
-g++ -std=c++98 -Wall -Werror -Wno-invalid-offsetof \
-    -fPIC -fno-strict-aliasing -frtti -pthread -g \
-    -I. -I$ROOT/Common/UDP \
-    -I$ROOT/Source/Components/Interfaces/UDPStream \
-    UDPStreamerClient.cpp -o UDPStreamerClient.o
-g++ -shared UDPStreamerClient.o \
-    -L$ROOT/Build/x86-linux/Components/Interfaces/UDPStream -lUDPStream \
-    -L$MARTe2_DIR/Build/x86-linux/Core -lMARTe2 -o UDPStreamerClient.so
-```
-]
-
-Builds clean under `-Werror`; the DataSource reuses the hub's `UDPSClient` rather than
-duplicating any socket code.
-
-#pagebreak()
-
-// ═══════════════════════════════════════
-// 5. Next Steps
-// ═══════════════════════════════════════
-= Next Steps
-
-== Short-Term
-
-#list(
-  [*Reduce poll latency*: Lower `RECV_TIMEOUT_MS` from 10 to 1 ms. Lower `ResetWait` timeout from 1000 to 100 ms.],
-  [*Add GTest unit tests*: Fragment reassembly (2/5/100 fragments), dequantization accuracy, CONFIG parsing, accumulate mode.],
-)
-
-== Medium-Term
-
-#list(
-  [*Benchmark throughput*: Measure with varying signal sizes (100 / 1K / 10K / 100K floats) and plot curve.],
-  [*Multicast multi-client*: Verify multiple `UDPStreamerClient` instances join same group simultaneously.],
-  [*Remove poll sleeps entirely*: Use continuous `select()` with zero timeout + `EventSem` back-pressure.],
-)
-
-== Long-Term
-
-#list(
-  [*CI integration*: Add E2E test runner with automated comparison and regression detection.],
-  [*Performance profiling*: Identify exact memcpy and serialization costs with `perf`.],
-)

Test/E2E/datasources/run_e2e_report.sh

@@ -1,278 +0,0 @@
-#!/usr/bin/env bash
-# run_e2e_report.sh — End-to-end test + report generation
-#
-# Usage:  ./run_e2e_report.sh [--skip-tests] [--pdf-only]
-#
-# Steps:
-#   1. Generate multi-signal test data
-#   2. Build UDPStreamer + UDPStreamerClient
-#   3. Run unicast and multicast E2E tests
-#   4. Compare output against input
-#   5. Generate plots (input/output/diff, latency budget, latency histogram)
-#   6. Compile Typst report → PDF
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "${SCRIPT_DIR}/../../.." && pwd)"
-TARGET=x86-linux
-BUILD_DIR="${REPO_ROOT}/Build/${TARGET}"
-# Generated artifacts (plots, copied template, PDF) go here — never in the source tree.
-OUT_DIR="${BUILD_DIR}/E2E/datasources"
-mkdir -p "${OUT_DIR}"
-
-SKIP_TESTS=0
-PDF_ONLY=0
-for arg in "$@"; do
-    case "$arg" in
-        --skip-tests) SKIP_TESTS=1 ;;
-        --pdf-only)   PDF_ONLY=1 ;;
-        --help|-h)
-            echo "Usage: $0 [--skip-tests] [--pdf-only]"
-            echo "  --skip-tests  Skip E2E tests, only generate plots + PDF"
-            echo "  --pdf-only    Only compile Typst → PDF (requires existing plots)"
-            exit 0 ;;
-    esac
-done
-
-# ── Load environment ─────────────────────────────────────────────────────────
-ENV_SCRIPT="${REPO_ROOT}/env.sh"
-if [ ! -f "${ENV_SCRIPT}" ]; then
-    echo "ERROR: ${ENV_SCRIPT} not found." >&2
-    exit 1
-fi
-source "${ENV_SCRIPT}"
-
-COMP="${MARTe2_Components_DIR}/Build/${TARGET}/Components"
-export LD_LIBRARY_PATH="\
-${BUILD_DIR}/Components/DataSources/UDPStreamerClient:\
-${BUILD_DIR}/Components/DataSources/UDPStreamer:\
-${BUILD_DIR}/Components/Interfaces/UDPStream:\
-${MARTe2_DIR}/Build/${TARGET}/Core:\
-${COMP}/DataSources/LinuxTimer:\
-${COMP}/DataSources/LoggerDataSource:\
-${COMP}/DataSources/FileDataSource:\
-${COMP}/GAMs/IOGAM:\
-${LD_LIBRARY_PATH}"
-
-MARTE_APP="${MARTe2_DIR}/Build/${TARGET}/App/MARTeApp.ex"
-INPUT="/tmp/udpstreamer_test_input.bin"
-OUTPUT_U="/tmp/udpstreamer_test_output.bin"
-OUTPUT_M="/tmp/udpstreamer_test_output_multicast.bin"
-
-echo "=========================================="
-echo " UDPStreamer E2E Test & Report Generator"
-echo "=========================================="
-
-# ── Step 1-2: Generate data + build ──────────────────────────────────────────
-if [ "${PDF_ONLY}" -eq 0 ]; then
-    echo ""
-    echo "── Step 1: Generating test data ──"
-    python3 "${SCRIPT_DIR}/gen_test_data.py"
-
-    echo ""
-    echo "── Step 2: Building components ──"
-    make -C "${REPO_ROOT}/Source/Components/Interfaces/UDPStream" \
-         -f Makefile.gcc TARGET="${TARGET}" 2>&1 | tail -2
-    make -C "${REPO_ROOT}/Source/Components/DataSources/UDPStreamerClient" \
-         -f Makefile.gcc TARGET="${TARGET}" 2>&1 | tail -2
-    make -C "${REPO_ROOT}/Source/Components/DataSources/UDPStreamer" \
-         -f Makefile.gcc TARGET="${TARGET}" 2>&1 | tail -2
-fi
-
-# ── Step 3: Run E2E tests ────────────────────────────────────────────────────
-run_test() {
-    local name="$1" cfg="$2" output="$3"
-    echo ""
-    echo "── Test: ${name} ──"
-    rm -f "${output}"
-    if [ ! -x "${MARTE_APP}" ]; then
-        echo "  SKIP: MARTeApp.ex not found"; return 0
-    fi
-    timeout 6 "${MARTE_APP}" -l RealTimeLoader -f "${cfg}" -s Running 2>&1 | grep -E "^\[" > /tmp/e2e_log_${name}.txt &
-    local pid=$!
-    sleep 5
-    kill "${pid}" 2>/dev/null || true
-    wait "${pid}" 2>/dev/null || true
-    # Show log messages (reader/client first-element values)
-    grep -E "Log100_|Log1K_|Log5K_" /tmp/e2e_log_${name}.txt 2>/dev/null | head -20 || true
-    echo "  Done."
-}
-
-if [ "${SKIP_TESTS}" -eq 0 ] && [ "${PDF_ONLY}" -eq 0 ]; then
-    echo ""
-    echo "── Step 3: Running E2E tests ──"
-    run_test "Unicast"  "${SCRIPT_DIR}/E2ETest.cfg"           "${OUTPUT_U}"
-    run_test "Multicast" "${SCRIPT_DIR}/E2EMulticastTest.cfg" "${OUTPUT_M}"
-
-    # ── Step 3b: Validate ──
-    echo ""
-    echo "── Results ──"
-    RESULTS="${OUT_DIR}/e2e_results.txt"
-    : > "${RESULTS}"
-    for label in unicast multicast; do
-        [ "$label" = "unicast" ] && out="${OUTPUT_U}" || out="${OUTPUT_M}"
-        python3 "${SCRIPT_DIR}/validate_binary.py" "${INPUT}" "${out}" --label "${label}" \
-            --json "${OUT_DIR}/e2e_${label}.json" 2>&1 | tee -a "${RESULTS}" || true
-    done
-    echo "  Results saved to ${RESULTS} (+ e2e_unicast.json, e2e_multicast.json)"
-fi
-
-# ── Step 4: Generate plots ───────────────────────────────────────────────────
-echo ""
-echo "── Step 4: Generating plots ──"
-cd "${OUT_DIR}"
-
-python3 << 'PLOT_EOF'
-import struct, os, numpy as np
-import matplotlib; matplotlib.use('Agg'); import matplotlib.pyplot as plt
-from matplotlib.gridspec import GridSpec
-
-INPUT="/tmp/udpstreamer_test_input.bin"
-OUTPUT_U="/tmp/udpstreamer_test_output.bin"
-
-def read_binary(fn):
-    if not os.path.exists(fn): return None,None
-    with open(fn,'rb') as f:
-        ns=struct.unpack('<I',f.read(4))[0]; sigs=[]
-        for _ in range(ns):
-            tc=struct.unpack('<H',f.read(2))[0]; nm=f.read(32).rstrip(b'\x00').decode()
-            ne=struct.unpack('<I',f.read(4))[0]; sigs.append((nm,tc,ne))
-        return sigs,f.read()
-
-def row_bytes(sigs): return sum(ne for _,_,ne in sigs)*4
-def offsets(sigs):
-    off=[0]
-    for _,_,ne in sigs: off.append(off[-1]+ne*4)
-    return off
-def extract_row(sigs,raw,r):
-    rb=row_bytes(sigs); off=offsets(sigs); row=raw[r*rb:(r+1)*rb]
-    return {nm:np.frombuffer(row[off[i]:off[i]+ne*4],dtype=np.float32)
-            for i,(nm,_,ne) in enumerate(sigs)}
-
-in_sigs,in_raw=read_binary(INPUT)
-out_sigs,out_raw=read_binary(OUTPUT_U)
-if in_sigs is None: print("No input data"); exit(0)
-
-rb_in=row_bytes(in_sigs); nr_in=len(in_raw)//rb_in
-# Map each input row (bytes) → its index for fast lookup.
-input_row_idx={in_raw[r*rb_in:(r+1)*rb_in]:r for r in range(nr_in)}
-
-# Pick the first NON-ZERO output row that matches an input row, so the figure
-# shows real transported data rather than a startup zero row.
-in_idx,out_idx=0,None
-if out_sigs and out_raw:
-    rb_out=row_bytes(out_sigs); nr_out=len(out_raw)//rb_out
-    for r in range(nr_out):
-        rowb=out_raw[r*rb_out:(r+1)*rb_out]
-        if any(rowb) and rowb in input_row_idx:
-            out_idx=r; in_idx=input_row_idx[rowb]; break
-
-in_row=extract_row(in_sigs,in_raw,in_idx)
-out_row=extract_row(out_sigs,out_raw,out_idx) if out_idx is not None else None
-sigs_plot=[s[0] for s in in_sigs]; ns=len(sigs_plot)
-
-fig=plt.figure(figsize=(18,4.5*ns))
-gs=GridSpec(ns,3,figure=fig,hspace=0.4,wspace=0.3)
-
-for ri,sn in enumerate(sigs_plot):
-    ne=[s[2] for s in in_sigs if s[0]==sn][0]; ia=in_row[sn]
-    x=np.arange(ne)
-    for ci,title in enumerate(['Input','Output','Difference']):
-        ax=fig.add_subplot(gs[ri,ci])
-        if ri==0: ax.set_title(title,fontsize=10,fontweight='bold')
-        ax.set_xlabel('Element'); ax.grid(True,alpha=0.3)
-        if ci==0:
-            ax.plot(x,ia,'b-',lw=0.3)
-            ax.set_ylabel(f'{sn}\nValue'); ax.set_ylim(np.min(ia)-0.1,np.max(ia)+0.1)
-        elif ci==1:
-            if out_row is not None:
-                ax.plot(x,out_row[sn],'r-',lw=0.3); ax.set_ylabel('Value')
-            else: ax.text(0.5,0.5,'No matching output row',transform=ax.transAxes,ha='center',va='center',color='gray')
-        else:
-            if out_row is not None:
-                diff=ia-out_row[sn]; ax.plot(x,diff,'g-',lw=0.3)
-                ax.set_ylabel('ΔValue'); ax.set_ylim(np.min(diff)-0.1,np.max(diff)+0.1)
-                md=np.max(np.abs(diff))
-                ax.text(0.98,0.95,f'max|Δ|={md:.4f}',transform=ax.transAxes,ha='right',va='top',fontsize=7,
-                        bbox=dict(boxstyle='round',facecolor='wheat',alpha=0.5))
-            else: ax.text(0.5,0.5,'No matching output row',transform=ax.transAxes,ha='center',va='center',color='gray')
-
-st=(f'UDPStreamer E2E — Input (row {in_idx}) vs Output (row {out_idx}) vs Difference'
-    if out_idx is not None else 'UDPStreamer E2E — Input vs Output (no matching output row)')
-fig.suptitle(st,fontsize=13,fontweight='bold',y=0.998)
-plt.savefig('e2e_plots.png',dpi=150,bbox_inches='tight'); plt.close()
-print('  ✓ e2e_plots.png')
-
-# Latency histogram
-np.random.seed(42); n=10000
-fr=np.random.normal(1,0.2,n); io1=np.random.normal(0.1,0.02,n)
-us_s=np.random.normal(1,0.2,n); us_e=np.random.uniform(0.5,1.5,n)
-net=np.random.normal(0.05,0.01,n); uc_e=np.random.uniform(0.5,1.5,n)
-uc_s=np.random.exponential(0.01,n); io2=np.random.normal(0.1,0.02,n)
-fw=np.random.lognormal(mean=np.log(50),sigma=0.4,size=n)
-total=fr+io1+us_s+us_e+net+uc_e+uc_s+io2+fw
-
-fig,(ax1,ax2)=plt.subplots(1,2,figsize=(16,6))
-ax1.hist(total,bins=80,color='#3498db',edgecolor='white',alpha=0.8,density=True)
-ax1.axvline(np.median(total),color='red',ls='--',lw=2,label=f'Median: {np.median(total):.1f} ms')
-ax1.axvline(np.percentile(total,95),color='orange',ls='--',lw=2,label=f'P95: {np.percentile(total,95):.1f} ms')
-ax1.axvline(np.percentile(total,99),color='darkred',ls='--',lw=2,label=f'P99: {np.percentile(total,99):.1f} ms')
-ax1.set_xlabel('Latency (ms)'); ax1.set_ylabel('Density')
-ax1.set_title('E2E Latency Distribution',fontweight='bold'); ax1.legend(fontsize=8); ax1.grid(True,alpha=0.3)
-s=f'Median: {np.median(total):.1f} ms\nMean: {np.mean(total):.1f} ms\nP95: {np.percentile(total,95):.1f} ms\nP99: {np.percentile(total,99):.1f} ms'
-ax1.text(0.98,0.95,s,transform=ax1.transAxes,ha='right',va='top',fontsize=8,family='monospace',
-        bbox=dict(boxstyle='round',facecolor='wheat',alpha=0.5))
-
-data=[fr,io1,us_s,us_e,net,uc_e,uc_s,io2,fw]
-lbls=['FileReader','IOGAM','Streamer\nSync','Streamer\nExec','Network','Client\nExec','Client\nSync','IOGAM','FileWriter']
-cs=['#3498db','#2ecc71','#e74c3c','#f39c12','#9b59b6','#1abc9c','#e67e22','#2ecc71','#95a5a6']
-bp=ax2.boxplot(data,patch_artist=True,showfliers=False)
-for p,c in zip(bp['boxes'],cs): p.set_facecolor(c); p.set_alpha(0.7)
-ax2.set_xticklabels(lbls,rotation=45,ha='right',fontsize=7)
-ax2.set_ylabel('Latency (ms)'); ax2.set_title('Per-Component Distribution',fontweight='bold'); ax2.grid(True,alpha=0.3,axis='y')
-plt.tight_layout(); plt.savefig('latency_histogram.png',dpi=150); plt.close()
-print('  ✓ latency_histogram.png')
-
-# Latency budget bar chart
-fig,ax=plt.subplots(figsize=(12,6)); ax.axis('off')
-comps=['FileReader Sync','IOGAM (memcpy)','Streamer Sync','Streamer Exec(bg)','Network(localhost)','Client Exec(bg)','Client Sync','IOGAM (memcpy)','FileWriter(async)']
-lats=[1.0,0.1,1.0,1.0,0.05,1.0,0.01,0.1,50.0]
-cs2=['#3498db','#2ecc71','#e74c3c','#f39c12','#9b59b6','#1abc9c','#e67e22','#2ecc71','#95a5a6']
-yp=range(len(comps),0,-1)
-bars=ax.barh(list(yp),lats,color=cs2,edgecolor='white',lw=1.5)
-for b,l in zip(bars,lats):
-    ax.text(b.get_width()+0.2,b.get_y()+b.get_height()/2,f'{l:.1f} ms' if l>=1 else f'{l*1000:.0f} µs',va='center',fontsize=9,fontweight='bold')
-    ax.text(0.2,b.get_y()+b.get_height()/2,comps[len(comps)-int(b.get_y()+b.get_height())],va='center',fontsize=8,color='white',fontweight='bold')
-ax.set_xlabel('Latency (ms)',fontsize=11)
-ax.set_title('UDPStreamer E2E Latency Budget',fontsize=12,fontweight='bold')
-t=sum(lats)
-ax.text(0.15,-0.4,f'Total: {t:.1f} ms | Max throughput: {1000/t:.0f} Hz',fontsize=11,fontweight='bold',transform=ax.get_xaxis_transform())
-plt.tight_layout(); plt.savefig('latency_budget.png',dpi=150); plt.close()
-print('  ✓ latency_budget.png')
-print('  All plots generated.')
-PLOT_EOF
-
-# ── Step 5: Compile Typst → PDF (optional) ──────────────────────────────────
-echo ""
-echo "── Step 5: Compiling Typst report ──"
-if [ ! -f "${SCRIPT_DIR}/E2E_Report.typ" ]; then
-    echo "  SKIP: E2E_Report.typ template not present."
-elif ! command -v typst >/dev/null 2>&1; then
-    echo "  SKIP: typst not installed."
-else
-    # Compile from the build dir so the template's relative image() paths
-    # resolve against the freshly generated PNGs; keep the source .typ pristine.
-    cp "${SCRIPT_DIR}/E2E_Report.typ" "${OUT_DIR}/E2E_Report.typ"
-    typst compile "${OUT_DIR}/E2E_Report.typ" "${OUT_DIR}/E2E_Report.pdf" 2>&1
-    if [ -f "${OUT_DIR}/E2E_Report.pdf" ]; then
-        SIZE=$(ls -lh "${OUT_DIR}/E2E_Report.pdf" | awk '{print $5}')
-        echo "  ✓ Report generated: ${OUT_DIR}/E2E_Report.pdf (${SIZE})"
-    else
-        echo "  ✗ Typst compilation failed"
-    fi
-fi
-
-echo ""
-echo "=========================================="
-echo " Done — artifacts in ${OUT_DIR}"
-echo "=========================================="

Test/E2E/recorder/run_recorder_e2e.sh

@@ -1,144 +0,0 @@
-#!/usr/bin/env bash
-# run_recorder_e2e.sh — End-to-end test for the StreamHub binary recorder.
-#
-# Data path:
-#   FileReader(/tmp/udpstreamer_test_input.bin)
-#     -> IOGAM -> UDPStreamer(:44600)        [MARTe2 app, separate process]
-#       -> UDPS -> StreamHub UDPSClient
-#         -> BinaryRecorder -> /tmp/streamhub_rec_e2e/e2e_*.bin
-#
-# The recorder writes FileWriter-compatible binary files for un-quantized
-# float32 signals, so each recorded row is byte-identical to a streamed row.
-# validate_binary.py confirms every non-zero recorded row matches an input row.
-#
-# Usage:  ./run_recorder_e2e.sh [--skip-build]
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "${SCRIPT_DIR}/../../.." && pwd)"
-TARGET=x86-linux
-BUILD_DIR="${REPO_ROOT}/Build/${TARGET}"
-OUT_DIR="${BUILD_DIR}/E2E/recorder"
-mkdir -p "${OUT_DIR}"
-
-VALIDATOR="${SCRIPT_DIR}/../datasources/validate_binary.py"
-GEN_DATA="${SCRIPT_DIR}/../datasources/gen_test_data.py"
-INPUT="/tmp/udpstreamer_test_input.bin"
-REC_DIR="/tmp/streamhub_rec_e2e"
-
-SKIP_BUILD=0
-for arg in "$@"; do
-    case "$arg" in
-        --skip-build) SKIP_BUILD=1 ;;
-        --help|-h) echo "Usage: $0 [--skip-build]"; exit 0 ;;
-    esac
-done
-
-# ── Load environment ─────────────────────────────────────────────────────────
-ENV_SCRIPT="${REPO_ROOT}/env.sh"
-if [ ! -f "${ENV_SCRIPT}" ]; then
-    echo "ERROR: ${ENV_SCRIPT} not found." >&2
-    exit 1
-fi
-source "${ENV_SCRIPT}"
-
-COMP="${MARTe2_Components_DIR}/Build/${TARGET}/Components"
-export LD_LIBRARY_PATH="\
-${BUILD_DIR}/Components/DataSources/UDPStreamer:\
-${BUILD_DIR}/Components/Interfaces/UDPStream:\
-${MARTe2_DIR}/Build/${TARGET}/Core:\
-${COMP}/DataSources/LinuxTimer:\
-${COMP}/DataSources/FileDataSource:\
-${COMP}/GAMs/IOGAM:\
-${LD_LIBRARY_PATH:-}"
-
-MARTE_APP="${MARTe2_DIR}/Build/${TARGET}/App/MARTeApp.ex"
-STREAMHUB_EX="${BUILD_DIR}/StreamHub/StreamHub.ex"
-
-echo "=========================================="
-echo " StreamHub Recorder E2E Test"
-echo "=========================================="
-
-# ── Step 1: Generate test data ───────────────────────────────────────────────
-echo ""
-echo "── Step 1: Generating test data ──"
-python3 "${GEN_DATA}"
-
-# ── Step 2: Build components ──────────────────────────────────────────────────
-if [ "${SKIP_BUILD}" -eq 0 ]; then
-    echo ""
-    echo "── Step 2: Building components ──"
-    make -C "${REPO_ROOT}/Source/Components/Interfaces/UDPStream" \
-         -f Makefile.gcc TARGET="${TARGET}" 2>&1 | tail -2
-    make -C "${REPO_ROOT}/Source/Components/DataSources/UDPStreamer" \
-         -f Makefile.gcc TARGET="${TARGET}" 2>&1 | tail -2
-    make -C "${REPO_ROOT}/Source/Applications/StreamHub" \
-         -f Makefile.gcc TARGET="${TARGET}" 2>&1 | tail -2
-fi
-
-if [ ! -x "${MARTE_APP}" ]; then
-    echo "ERROR: MARTeApp.ex not found at ${MARTE_APP}" >&2
-    exit 1
-fi
-if [ ! -x "${STREAMHUB_EX}" ]; then
-    echo "ERROR: StreamHub.ex not found at ${STREAMHUB_EX}" >&2
-    exit 1
-fi
-
-# ── Step 3: Run the stack ─────────────────────────────────────────────────────
-echo ""
-echo "── Step 3: Running StreamHub + UDPStreamer ──"
-rm -rf "${REC_DIR}"
-mkdir -p "${REC_DIR}"
-
-HUB_LOG="${OUT_DIR}/streamhub.log"
-APP_LOG="${OUT_DIR}/marte.log"
-
-# Start StreamHub first so it is ready to receive the CONFIG packet.
-"${STREAMHUB_EX}" -cfg "${SCRIPT_DIR}/StreamHubRec.cfg" > "${HUB_LOG}" 2>&1 &
-HUB_PID=$!
-sleep 1
-
-cleanup() {
-    kill "${HUB_PID}" 2>/dev/null || true
-    kill "${APP_PID}" 2>/dev/null || true
-    wait "${HUB_PID}" 2>/dev/null || true
-    wait "${APP_PID}" 2>/dev/null || true
-}
-trap cleanup EXIT
-
-timeout 8 "${MARTE_APP}" -l RealTimeLoader -f "${SCRIPT_DIR}/RecorderStreamer.cfg" \
-    -s Running > "${APP_LOG}" 2>&1 &
-APP_PID=$!
-
-# Let data flow, then stop the streamer and give the push thread time to flush.
-sleep 7
-kill "${APP_PID}" 2>/dev/null || true
-wait "${APP_PID}" 2>/dev/null || true
-sleep 2
-kill "${HUB_PID}" 2>/dev/null || true
-wait "${HUB_PID}" 2>/dev/null || true
-trap - EXIT
-
-echo "  Done. StreamHub log: ${HUB_LOG}"
-
-# ── Step 4: Validate the recorded file ───────────────────────────────────────
-echo ""
-echo "── Step 4: Validating recorded output ──"
-# The recorder names files <sourceId>_<UTCstamp>_<seq>.bin; pick the newest.
-REC_FILE="$(ls -t "${REC_DIR}"/*.bin 2>/dev/null | head -1 || true)"
-if [ -z "${REC_FILE}" ]; then
-    echo "  ✗ FAIL: no recorded .bin file in ${REC_DIR}"
-    echo "  --- StreamHub log tail ---"
-    tail -20 "${HUB_LOG}" || true
-    exit 1
-fi
-echo "  Recorded file: ${REC_FILE} ($(stat -c%s "${REC_FILE}") B)"
-
-python3 "${VALIDATOR}" "${INPUT}" "${REC_FILE}" --label "recorder" \
-    --json "${OUT_DIR}/recorder_e2e.json"
-
-echo ""
-echo "=========================================="
-echo " Done — artifacts in ${OUT_DIR}"
-echo "=========================================="

Test/E2E/streamhub/go.mod

@@ -1,7 +0,0 @@
-module streamhub-e2e
-
-go 1.21
-
-require github.com/gorilla/websocket v1.5.1
-
-require golang.org/x/net v0.17.0 // indirect

Test/E2E/streamhub/main.go

@@ -1,561 +0,0 @@
-// Command streamhub-e2e is an end-to-end test client for the C++ StreamHub.
-//
-// It connects to a running StreamHub WebSocket endpoint (with at least one
-// connected UDPStreamer source, e.g. the stack launched by run_e2e_test.sh)
-// and verifies the full protocol:
-//
-//  1. "sources" event with at least one connected source
-//  2. "config" event per source with at least one signal
-//  3. binary v1 data pushes: parseable, per-signal monotonic time,
-//     timestamps within a few seconds of wall clock (Unix time base)
-//  4. "stats" event with a positive receive rate
-//  5. WS zoom round-trip: reqId echoed, points returned in [t0,t1]
-//  6. hub-side trigger: setTrigger+arm → triggerState(armed) → binary v2
-//     capture frame with the latched pre/post window
-//
-// Exit code 0 on success; 1 with a FAIL message otherwise.
-package main
-
-import (
-	"encoding/binary"
-	"encoding/json"
-	"flag"
-	"fmt"
-	"log"
-	"math"
-	"os"
-	"time"
-
-	"github.com/gorilla/websocket"
-)
-
-var hub = flag.String("hub", "127.0.0.1:8090", "StreamHub host:port")
-var timeout = flag.Duration("timeout", 30*time.Second, "overall test timeout")
-var verbose = flag.Bool("v", false, "log every received event")
-
-// ---------------------------------------------------------------------------
-// Wire types (subset of the StreamHub JSON protocol)
-// ---------------------------------------------------------------------------
-
-type sourceInfo struct {
-	ID    string `json:"id"`
-	Label string `json:"label"`
-	Addr  string `json:"addr"`
-	State string `json:"state"`
-}
-
-type signalInfo struct {
-	Name     string  `json:"name"`
-	TypeCode uint32  `json:"typeCode"`
-	NumRows  uint32  `json:"numRows"`
-	NumCols  uint32  `json:"numCols"`
-	TimeMode int     `json:"timeMode"`
-	Rate     float64 `json:"samplingRate"`
-}
-
-type statInfo struct {
-	State         string  `json:"state"`
-	TotalReceived uint64  `json:"totalReceived"`
-	RateHz        float64 `json:"rateHz"`
-	CycleHist     []f64   `json:"cycleHist"`
-}
-
-type f64 = float64
-
-type zoomPoints struct {
-	T []float64 `json:"t"`
-	V []float64 `json:"v"`
-}
-
-type historyInfoMsg struct {
-	Enabled       bool               `json:"enabled"`
-	DurationHours float64            `json:"durationHours"`
-	Decimation    uint32             `json:"decimation"`
-	Signals       map[string]struct {
-		T0       float64 `json:"t0"`
-		T1       float64 `json:"t1"`
-		Count    uint32  `json:"count"`
-		Capacity uint32  `json:"capacity"`
-	} `json:"signals"`
-}
-
-type event struct {
-	Type     string                `json:"type"`
-	Sources  json.RawMessage       `json:"sources"`
-	SourceID string                `json:"sourceId"`
-	Signals  json.RawMessage       `json:"signals"`
-	ReqID    uint32                `json:"reqId"`
-	State    string                `json:"state"`
-	TrigTime float64               `json:"trigTime"`
-}
-
-// Parsed binary v1 push frame: sourceId → signal → samples.
-type pushFrame struct {
-	sourceID string
-	signals  map[string]zoomPoints
-}
-
-// Parsed binary v2 capture frame.
-type captureFrame struct {
-	trigTime, preSec, postSec float64
-	signals                   map[string]zoomPoints
-}
-
-// ---------------------------------------------------------------------------
-// Binary parsers
-// ---------------------------------------------------------------------------
-
-func parsePush(b []byte) (*pushFrame, error) {
-	if len(b) < 2 || b[0] != 1 {
-		return nil, fmt.Errorf("not a v1 frame")
-	}
-	idLen := int(b[1])
-	off := 2
-	if len(b) < off+idLen+4 {
-		return nil, fmt.Errorf("truncated header")
-	}
-	f := &pushFrame{sourceID: string(b[off : off+idLen]),
-		signals: map[string]zoomPoints{}}
-	off += idLen
-	nSig := int(binary.LittleEndian.Uint32(b[off:]))
-	off += 4
-	for s := 0; s < nSig; s++ {
-		if len(b) < off+2 {
-			return nil, fmt.Errorf("truncated keyLen (sig %d)", s)
-		}
-		keyLen := int(binary.LittleEndian.Uint16(b[off:]))
-		off += 2
-		if len(b) < off+keyLen+4 {
-			return nil, fmt.Errorf("truncated key (sig %d)", s)
-		}
-		key := string(b[off : off+keyLen])
-		off += keyLen
-		n := int(binary.LittleEndian.Uint32(b[off:]))
-		off += 4
-		if len(b) < off+16*n {
-			return nil, fmt.Errorf("truncated data (sig %s n=%d)", key, n)
-		}
-		pts := zoomPoints{T: make([]float64, n), V: make([]float64, n)}
-		for i := 0; i < n; i++ {
-			pts.T[i] = math.Float64frombits(binary.LittleEndian.Uint64(b[off+8*i:]))
-		}
-		off += 8 * n
-		for i := 0; i < n; i++ {
-			pts.V[i] = math.Float64frombits(binary.LittleEndian.Uint64(b[off+8*i:]))
-		}
-		off += 8 * n
-		f.signals[key] = pts
-	}
-	return f, nil
-}
-
-func parseCapture(b []byte) (*captureFrame, error) {
-	if len(b) < 1+24+4 || b[0] != 2 {
-		return nil, fmt.Errorf("not a v2 frame")
-	}
-	rdF64 := func(off int) float64 {
-		return math.Float64frombits(binary.LittleEndian.Uint64(b[off:]))
-	}
-	f := &captureFrame{
-		trigTime: rdF64(1), preSec: rdF64(9), postSec: rdF64(17),
-		signals: map[string]zoomPoints{},
-	}
-	off := 25
-	nSig := int(binary.LittleEndian.Uint32(b[off:]))
-	off += 4
-	for s := 0; s < nSig; s++ {
-		keyLen := int(binary.LittleEndian.Uint16(b[off:]))
-		off += 2
-		key := string(b[off : off+keyLen])
-		off += keyLen
-		n := int(binary.LittleEndian.Uint32(b[off:]))
-		off += 4
-		if len(b) < off+16*n {
-			return nil, fmt.Errorf("truncated capture (sig %s n=%d)", key, n)
-		}
-		pts := zoomPoints{T: make([]float64, n), V: make([]float64, n)}
-		for i := 0; i < n; i++ {
-			pts.T[i] = math.Float64frombits(binary.LittleEndian.Uint64(b[off+8*i:]))
-		}
-		off += 8 * n
-		for i := 0; i < n; i++ {
-			pts.V[i] = math.Float64frombits(binary.LittleEndian.Uint64(b[off+8*i:]))
-		}
-		off += 8 * n
-		f.signals[key] = pts
-	}
-	return f, nil
-}
-
-// ---------------------------------------------------------------------------
-// Test driver
-// ---------------------------------------------------------------------------
-
-type client struct {
-	ws       *websocket.Conn
-	deadline time.Time
-
-	sources  []sourceInfo
-	configs  map[string][]signalInfo // sourceId → signals
-	pushes   []*pushFrame
-	stats    map[string]statInfo
-	zooms        map[uint32]map[string]zoomPoints
-	histZooms    map[uint32]map[string]zoomPoints
-	historyInfo  *historyInfoMsg
-	trigSt       []string // observed triggerState sequence
-	captures     []*captureFrame
-}
-
-func (c *client) send(v interface{}) {
-	b, _ := json.Marshal(v)
-	if err := c.ws.WriteMessage(websocket.TextMessage, b); err != nil {
-		fail("ws write: %v", err)
-	}
-}
-
-// pump reads one WS message (with a short read deadline) and dispatches it.
-func (c *client) pump() {
-	c.ws.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
-	mt, data, err := c.ws.ReadMessage()
-	if err != nil {
-		if websocket.IsUnexpectedCloseError(err) {
-			fail("ws closed: %v", err)
-		}
-		return // read timeout — fine
-	}
-	switch mt {
-	case websocket.BinaryMessage:
-		if len(data) == 0 {
-			return
-		}
-		switch data[0] {
-		case 1:
-			if f, err := parsePush(data); err == nil {
-				c.pushes = append(c.pushes, f)
-			} else {
-				fail("bad v1 frame: %v", err)
-			}
-		case 2:
-			if f, err := parseCapture(data); err == nil {
-				c.captures = append(c.captures, f)
-			} else {
-				fail("bad v2 frame: %v", err)
-			}
-		default:
-			fail("unknown binary frame version %d", data[0])
-		}
-	case websocket.TextMessage:
-		var ev event
-		if err := json.Unmarshal(data, &ev); err != nil {
-			fail("bad JSON event: %v (%.120s)", err, data)
-		}
-		if *verbose {
-			log.Printf("event %-12s %.160s", ev.Type, data)
-		}
-		switch ev.Type {
-		case "sources":
-			var srcs []sourceInfo
-			if err := json.Unmarshal(ev.Sources, &srcs); err == nil {
-				c.sources = srcs
-			}
-		case "config":
-			var sigs []signalInfo
-			if err := json.Unmarshal(ev.Signals, &sigs); err == nil {
-				c.configs[ev.SourceID] = sigs
-			} else {
-				log.Printf("config parse error: %v (%.200s)", err, data)
-			}
-		case "stats":
-			var st map[string]statInfo
-			if err := json.Unmarshal(ev.Sources, &st); err == nil {
-				c.stats = st
-			}
-		case "zoom":
-			var body struct {
-				Signals map[string]zoomPoints `json:"signals"`
-			}
-			if err := json.Unmarshal(data, &body); err == nil {
-				c.zooms[ev.ReqID] = body.Signals
-			}
-		case "historyZoom":
-			var body struct {
-				Signals map[string]zoomPoints `json:"signals"`
-			}
-			if err := json.Unmarshal(data, &body); err == nil {
-				c.histZooms[ev.ReqID] = body.Signals
-			}
-		case "historyInfo":
-			var hi historyInfoMsg
-			if err := json.Unmarshal(data, &hi); err == nil {
-				c.historyInfo = &hi
-			}
-		case "triggerState":
-			c.trigSt = append(c.trigSt, ev.State)
-		}
-	}
-}
-
-// waitFor pumps messages until cond() or the step deadline expires.
-func (c *client) waitFor(what string, d time.Duration, cond func() bool) {
-	end := time.Now().Add(d)
-	if end.After(c.deadline) {
-		end = c.deadline
-	}
-	for time.Now().Before(end) {
-		if cond() {
-			log.Printf("OK   %s", what)
-			return
-		}
-		c.pump()
-	}
-	fail("timeout waiting for %s", what)
-}
-
-func fail(format string, args ...interface{}) {
-	fmt.Printf("FAIL "+format+"\n", args...)
-	os.Exit(1)
-}
-
-func main() {
-	flag.Parse()
-	url := "ws://" + *hub + "/ws"
-	log.Printf("connecting to %s", url)
-
-	ws, _, err := websocket.DefaultDialer.Dial(url, nil)
-	if err != nil {
-		fail("dial %s: %v", url, err)
-	}
-	defer ws.Close()
-
-	c := &client{
-		ws:        ws,
-		deadline:  time.Now().Add(*timeout),
-		configs:   map[string][]signalInfo{},
-		zooms:     map[uint32]map[string]zoomPoints{},
-		histZooms: map[uint32]map[string]zoomPoints{},
-	}
-
-	// ── 1. sources ────────────────────────────────────────────────────────
-	c.send(map[string]interface{}{"type": "getSources"})
-	c.waitFor("sources event with a connected source", 10*time.Second, func() bool {
-		for _, s := range c.sources {
-			if s.State == "connected" {
-				return true
-			}
-		}
-		return false
-	})
-
-	// ── 2. config per connected source ───────────────────────────────────
-	for _, s := range c.sources {
-		log.Printf("source %s (%s): state=%s", s.ID, s.Label, s.State)
-		c.send(map[string]interface{}{"type": "getConfig", "sourceId": s.ID})
-	}
-	c.waitFor("config with signals for every connected source", 10*time.Second, func() bool {
-		for _, s := range c.sources {
-			if s.State != "connected" {
-				continue
-			}
-			if len(c.configs[s.ID]) == 0 {
-				return false
-			}
-		}
-		return len(c.sources) > 0
-	})
-
-	// ── 3. binary pushes: wall-clock time base + monotonicity ────────────
-	c.waitFor("binary v1 data pushes (>=10 frames)", 10*time.Second, func() bool {
-		return len(c.pushes) >= 10
-	})
-	now := float64(time.Now().UnixNano()) / 1e9
-	seen := map[string][]float64{} // last times per src:sig
-	for _, f := range c.pushes {
-		for key, pts := range f.signals {
-			full := f.sourceID + ":" + key
-			for i, t := range pts.T {
-				if math.Abs(t-now) > 30.0 {
-					fail("timestamp not wall-clock: %s t=%.3f now=%.3f", full, t, now)
-				}
-				prev := seen[full]
-				if len(prev) > 0 && t < prev[len(prev)-1]-1e-9 {
-					fail("non-monotonic time on %s: %.9f after %.9f (i=%d)",
-						full, t, prev[len(prev)-1], i)
-				}
-				seen[full] = append(seen[full], t)
-			}
-		}
-	}
-	if len(seen) == 0 {
-		fail("pushes contained no signal data")
-	}
-	log.Printf("OK   wall-clock & monotonic time on %d signal streams", len(seen))
-
-	// ── 4. stats ──────────────────────────────────────────────────────────
-	c.send(map[string]interface{}{"type": "getStats"})
-	c.waitFor("stats with positive rate", 10*time.Second, func() bool {
-		for _, st := range c.stats {
-			if st.State == "connected" && st.RateHz > 0 && st.TotalReceived > 0 {
-				return true
-			}
-		}
-		return false
-	})
-
-	// ── 5. zoom round-trip ───────────────────────────────────────────────
-	// Use the busiest streamed signal and the time range we actually saw.
-	var zoomKey string
-	var zMax int
-	for k, ts := range seen {
-		if len(ts) > zMax {
-			zMax, zoomKey = len(ts), k
-		}
-	}
-	ts := seen[zoomKey]
-	t1 := ts[len(ts)-1]
-	t0 := t1 - 0.5
-	const reqID = 4242
-	c.send(map[string]interface{}{
-		"type": "zoom", "reqId": reqID, "t0": t0, "t1": t1, "n": 200,
-		"signals": zoomKey,
-	})
-	c.waitFor(fmt.Sprintf("zoom reply (reqId=%d, %s)", reqID, zoomKey),
-		10*time.Second, func() bool {
-			sigs, ok := c.zooms[reqID]
-			if !ok {
-				return false
-			}
-			pts, ok := sigs[zoomKey]
-			if !ok || len(pts.T) < 2 {
-				fail("zoom reply missing %s (got %d signals)", zoomKey, len(sigs))
-			}
-			for _, t := range pts.T {
-				if t < t0-1e-6 || t > t1+1e-6 {
-					fail("zoom point outside range: t=%.9f not in [%.9f,%.9f]", t, t0, t1)
-				}
-			}
-			return true
-		})
-
-	// ── 5b. historyInfo — check the hub broadcast it on connect ─────────
-	if c.historyInfo != nil && c.historyInfo.Enabled {
-		log.Printf("OK   historyInfo: enabled, %.1fh, decimation=%d, %d signals",
-			c.historyInfo.DurationHours, c.historyInfo.Decimation,
-			len(c.historyInfo.Signals))
-
-		// ── 5c. historyZoom round-trip ──────────────────────────────────
-		const hReqID = 4243
-		c.send(map[string]interface{}{
-			"type": "historyZoom", "reqId": hReqID,
-			"t0": t0, "t1": t1, "n": 200,
-			"signals": zoomKey,
-		})
-		c.waitFor(fmt.Sprintf("historyZoom reply (reqId=%d, %s)", hReqID, zoomKey),
-			10*time.Second, func() bool {
-				sigs, ok := c.histZooms[hReqID]
-				if !ok {
-					return false
-				}
-				pts, ok := sigs[zoomKey]
-				if !ok || len(pts.T) < 1 {
-					// History data may still be sparse right after startup
-					return true
-				}
-				for _, ht := range pts.T {
-					if ht < t0-1e-6 || ht > t1+1e-6 {
-						fail("historyZoom point outside range: t=%.9f not in [%.9f,%.9f]", ht, t0, t1)
-					}
-				}
-				return true
-			})
-	} else {
-		log.Println("     (history not enabled — skipping historyZoom test)")
-	}
-
-	// ── 6. trigger: arm → capture ────────────────────────────────────────
-	// Trigger on an *oscillating* signal at its mean observed value: a
-	// monotonic ramp (counter, time array) crosses its past mean only once,
-	// before arming, so a rising edge would never fire on it.  Pick the
-	// busiest signal whose last push frame is non-monotonic (a sine).
-	lastVals := map[string][]float64{}
-	for _, f := range c.pushes {
-		for name, pts := range f.signals {
-			if len(pts.V) >= 4 {
-				lastVals[f.sourceID+":"+name] = pts.V
-			}
-		}
-	}
-	trigKey := ""
-	tMaxPts := 0
-	for k, vs := range lastVals {
-		monotonic := true
-		for i := 1; i < len(vs); i++ {
-			if vs[i] < vs[i-1] {
-				monotonic = false
-				break
-			}
-		}
-		if !monotonic && len(seen[k]) > tMaxPts {
-			tMaxPts, trigKey = len(seen[k]), k
-		}
-	}
-	if trigKey == "" {
-		fail("no oscillating signal found for trigger test")
-	}
-	vals := lastVals[trigKey]
-	mean := 0.0
-	for _, v := range vals {
-		mean += v
-	}
-	mean /= float64(len(vals))
-	log.Printf("     trigger signal %s, threshold %.6g", trigKey, mean)
-
-	c.send(map[string]interface{}{
-		"type": "setTrigger", "signal": trigKey, "edge": "rising",
-		"threshold": mean, "windowSec": 0.1, "prePercent": 20.0,
-		"mode": "single",
-	})
-	c.send(map[string]interface{}{"type": "arm"})
-	// The trigger can fire within microseconds of arming (5 MS/s sine), so
-	// the broadcast emitted by the arm command may already say "collecting"
-	// or even "triggered" — any of these proves the arm was accepted.
-	c.waitFor("triggerState: armed/collecting/triggered", 5*time.Second, func() bool {
-		for _, s := range c.trigSt {
-			if s == "armed" || s == "collecting" || s == "triggered" {
-				return true
-			}
-		}
-		return false
-	})
-	c.waitFor("binary v2 capture frame", 15*time.Second, func() bool {
-		return len(c.captures) > 0
-	})
-
-	cap0 := c.captures[0]
-	if math.Abs(cap0.preSec-0.02) > 1e-9 || math.Abs(cap0.postSec-0.08) > 1e-9 {
-		fail("capture window mismatch: pre=%.6f post=%.6f (want 0.02/0.08)",
-			cap0.preSec, cap0.postSec)
-	}
-	pts, ok := cap0.signals[trigKey]
-	if !ok || len(pts.T) == 0 {
-		fail("capture missing trigger signal %s (%d signals)", trigKey, len(cap0.signals))
-	}
-	for _, t := range pts.T {
-		if t < cap0.trigTime-cap0.preSec-1e-3 || t > cap0.trigTime+cap0.postSec+1e-3 {
-			fail("capture point outside window: t=%.9f trig=%.9f", t, cap0.trigTime)
-		}
-	}
-	log.Printf("OK   capture: trig=%.6f pre=%.3fs post=%.3fs %d signals",
-		cap0.trigTime, cap0.preSec, cap0.postSec, len(cap0.signals))
-
-	c.waitFor("triggerState: triggered", 5*time.Second, func() bool {
-		for _, s := range c.trigSt {
-			if s == "triggered" {
-				return true
-			}
-		}
-		return false
-	})
-	c.send(map[string]interface{}{"type": "disarm"})
-
-	fmt.Println("PASS streamhub-e2e: all checks passed")
-}

Test/E2E/suite/E2E_Report.typ

@@ -28,6 +28,8 @@
 #let ok_color = rgb("#1a7f37")
 #let bad_color = rgb("#cf222e")
 #let neutral = rgb("#57606a")
+#let fail_bg = rgb("#ffebe9")  // light-red row background for FAIL rows in scenario tables
+#let fail_row_fill(is_fail) = (x, y) => if y > 0 and is_fail(y - 1) { fail_bg } else { none }
 
 #let warn_color = rgb("#9a6700")   // XFAIL — expected/known failure
 #let xpass_color = rgb("#8250df")  // XPASS — stale marker, needs attention
@@ -204,6 +206,7 @@ MARTe2 processes, plus sustained client throughput (recorded samples ÷ duration
   align: (left, right, right, right, right, right),
   stroke: 0.4pt + rgb("#d0d7de"),
   inset: 5pt,
+  fill: fail_row_fill(i => e2e.scenarios.at(i).status == "FAIL"),
   table.header([*Scenario*], [*Hub CPU (s)*], [*Hub RSS (MB)*],
                [*MARTe CPU (s)*], [*MARTe RSS (MB)*], [*Throughput (sp/s)*]),
   ..e2e.scenarios.map(sc => {
@@ -220,43 +223,6 @@ MARTe2 processes, plus sustained client throughput (recorded samples ÷ duration
   }).flatten()
 )
 
-// ── stress / capacity ─────────────────────────────────────────────────────────
-#let stress = data.at("stress", default: none)
-#if stress != none [
-  = Stress Tests #h(6pt) #status_badge(stress.overall)
-  Capacity matrix: one load axis swept at a time. Hard gates — survival + client
-  liveness; soft gates — peak RSS and zoom p95 latency. The size axis crosses into
-  the multi-fragment (>64 KB packet) regime.
-  #v(4pt)
-  #table(
-    columns: (1.5fr, 1.6fr, 0.7fr, 0.7fr, 1fr, 1fr, 1fr, 1fr),
-    align: (left, left, right, center, right, right, right, right),
-    stroke: 0.4pt + rgb("#d0d7de"),
-    inset: 4pt,
-    table.header([*Case*], [*Axis*], [*Level*], [*Status*],
-                 [*MARTe RSS (MB)*], [*Hub RSS (MB)*],
-                 [*Hub CPU (s)*], [*Zoom p95 (ms)*]),
-    ..stress.cases.map(c => (
-      raw(c.id),
-      text(size: 8pt)[#c.axis],
-      [#c.level],
-      status_badge(c.status),
-      fnum(c.at("marte_rss_mb", default: none), digits: 1),
-      fnum(c.at("hub_rss_mb", default: none), digits: 1),
-      fnum(c.at("hub_cpu_s", default: none), digits: 2),
-      fnum(c.at("zoom_p95_ms", default: none), digits: 1),
-    )).flatten()
-  )
-  #let splots = data.at("stress_plots", default: ())
-  #if splots.len() > 0 [
-    #v(6pt)
-    == Scaling curves
-    #grid(columns: 2, gutter: 8pt,
-      ..splots.map(p => image(p, width: 100%))
-    )
-  ]
-]
-
 // ── per-scenario waveform fidelity ───────────────────────────────────────────
 = Scenarios
 #for sc in e2e.scenarios [
@@ -284,6 +250,7 @@ MARTe2 processes, plus sustained client throughput (recorded samples ÷ duration
     align: (left, center, left, left, right, right, right, center, center),
     stroke: 0.4pt + rgb("#d0d7de"),
     inset: 4pt,
+    fill: fail_row_fill(i => sc.signals.at(i).pass == false),
     table.header([*Signal*], [*Pass*], [*Type*], [*Quant*], [*Max abs err*],
                  [*Corr*], [*nRMSE*], [*Fidelity*], [*Shape*]),
     ..sc.signals.map(g => (
@@ -360,6 +327,81 @@ MARTe2 processes, plus sustained client throughput (recorded samples ÷ duration
   #v(6pt)
 ]
 
+// ── per-kind sections (direct/recorder/debug/tcplogger) ─────────────────────
+// Raw scenario records here come straight from results.json (not e2e.scenarios'
+// reshaping), so they only carry id/kind/status/known_issue/metrics — no
+// waveform-fidelity breakdown (already covered, where applicable, in the
+// Scenarios section above for chain-kind scenarios; these kinds run through
+// dedicated non-chain harnesses in run_e2e.sh).
+#let kind_table(title, block) = {
+  [= #title]
+  [#block.n_pass/#block.n_total passed.]
+  v(4pt)
+  if block.n_total == 0 {
+    text(fill: neutral)[_No scenarios of this kind in this run._]
+  } else {
+    table(
+      columns: (1.4fr, 0.8fr, 2fr),
+      align: (left, center, left),
+      stroke: 0.4pt + rgb("#d0d7de"),
+      inset: 5pt,
+      fill: fail_row_fill(i => block.scenarios.at(i).status == "FAIL"),
+      table.header([*Scenario*], [*Status*], [*Known issue*]),
+      ..block.scenarios.map(s => (
+        [#s.id],
+        status_badge(s.status),
+        if s.at("known_issue", default: none) != none {
+          text(size: 8pt, fill: rgb("#7d4e00"))[#s.known_issue]
+        } else { text(fill: neutral)[—] },
+      )).flatten()
+    )
+  }
+}
+
+#kind_table("Direct Round-Trip (UDPStreamer ↔ UDPStreamerClient)", data.direct)
+#kind_table("Recorder (BinaryRecorder disk output)", data.recorder)
+#kind_table("Debug Service E2E", data.debug)
+#kind_table("TCPLogger E2E", data.tcplogger)
+#kind_table("Debug Service PAUSE/RESUME E2E", data.debug_pause_resume)
+
+// ── stress tests ─────────────────────────────────────────────────────────────
+= Stress Tests
+#if data.stress == none [
+  _Not run this session._
+] else [
+  #align(center, status_badge(data.stress.overall) + h(8pt) + text(size: 11pt)[
+    #hl.at("stress_pass", default: 0) passed ·
+    #hl.at("stress_fail", default: 0) failed
+  ])
+  #v(4pt)
+  #for (axis, cases) in data.stress.by_axis [
+    == Axis: #raw(axis)
+    #table(
+      columns: (0.8fr, 0.8fr, 1fr, 1fr, 1fr, 1fr),
+      align: (right, center, right, right, right, right),
+      stroke: 0.4pt + rgb("#d0d7de"),
+      inset: 4pt,
+      table.header([*Level*], [*Status*], [*Hub RSS (MB)*], [*MARTe RSS (MB)*],
+                   [*Zoom p50 (ms)*], [*Zoom p95 (ms)*]),
+      ..cases.map(c => (
+        [#c.at("level", default: "n/a")],
+        status_badge(c.at("status", default: "?")),
+        fnum(c.at("hub_rss_mb", default: none), digits: 1),
+        fnum(c.at("marte_rss_mb", default: none), digits: 1),
+        fnum(c.at("zoom_p50_ms", default: none), digits: 1),
+        fnum(c.at("zoom_p95_ms", default: none), digits: 1),
+      )).flatten()
+    )
+  ]
+  #if data.stress_plots.len() > 0 [
+    #v(4pt)
+    == Scaling curves
+    #grid(columns: 2, gutter: 8pt,
+      ..data.stress_plots.map(p => image(p, width: 100%))
+    )
+  ]
+]
+
 // ── trend plots ──────────────────────────────────────────────────────────────
 #if data.trend_plots.len() > 0 [
   = Trends over runs

Test/E2E/suite/collect.py

@@ -21,6 +21,7 @@ import os
 import re
 import subprocess
 import sys
+import time
 import xml.etree.ElementTree as ET
 
 
@@ -60,18 +61,88 @@ def gtest_suite(gtest_bin, work):
     return s
 
 
-# ── Go ────────────────────────────────────────────────────────────────────────
+# ── C++ Integration (DebugService runtime, non-GTest) ─────────────────────────
 
-def go_suite(client_dir, work):
+def integration_suite(int_bin, work, timeout=220):
-    s = {"name": "Go (chain-client)", "lang": "go", "total": 0, "passed": 0,
+    """Run the printf-narrated IntegrationTests.ex binary and heuristically
+    derive per-test pass/fail from its stdout.
+
+    This binary predates GTest adoption and always ``return 0`` from main()
+    (only an internal 180s SIGALRM timeout or an OS-level crash produce a
+    non-zero exit), so exit code alone is not a reliable signal. Each of its
+    7 "--- Test N: ..." blocks prints "SUCCESS:"/"VALIDATION SUCCESSFUL:" on
+    success or "ERROR:"/"FAILURE:" on failure, so split stdout by those
+    headers and flag a block failed if it contains an ERROR/FAILURE marker.
+    Exercises DebugServiceBase.cpp/DebugService.cpp runtime logic that the
+    header-only DebugServiceGTest suite deliberately does not touch, so it is
+    the only source of real coverage for those files.
+    """
+    s = {"name": "C++ Integration", "lang": "cpp", "total": 0, "passed": 0,
          "failed": 0, "skipped": 0, "time_s": 0.0, "ok": False, "avail": False}
-    cov_p = os.path.join(work, "go_cover.out")
+    if not int_bin or not os.path.exists(int_bin):
-    rc, out, err = _run(["go", "test", "-json", f"-coverprofile={cov_p}", "./..."],
+        s["detail"] = "IntegrationTests binary not found"
-                        cwd=client_dir)
-    if rc == 127:
-        s["detail"] = "go toolchain not found"
         return s
     s["avail"] = True
+    t0 = time.time()
+    rc, out, err = _run([int_bin], timeout=timeout)
+    s["time_s"] = round(time.time() - t0, 1)
+    text = out + "\n" + err
+    blocks = re.split(r"\n(?=--- Test \d+:)", text)
+    test_blocks = [b for b in blocks if b.lstrip().startswith("--- Test")]
+    finished = "All Integration Tests Finished." in text
+    s["total"] = len(test_blocks)
+    s["failed"] = sum(1 for b in test_blocks if re.search(r"\b(ERROR|FAILURE):", b))
+    if not finished and s["total"] == 0:
+        # Crashed/timed out before printing anything useful.
+        s["total"] = 1
+        s["failed"] = 1
+        s["detail"] = f"binary did not complete (rc={rc}): {(err or out)[-200:]}"
+    elif not finished:
+        s["detail"] = f"binary exited rc={rc} before finishing all tests"
+    s["passed"] = s["total"] - s["failed"]
+    s["ok"] = finished and s["failed"] == 0 and s["total"] > 0
+    return s
+
+
+# ── Go ────────────────────────────────────────────────────────────────────────
+
+def go_all_suites(repo, work):
+    """Run Go test suites across all project modules and aggregate results."""
+    modules = [
+        (os.path.join(repo, "Test/E2E/suite/client"),
+         "Go (chain-client)"),
+        (os.path.join(repo, "Common/Client/go"),
+         "Go (common udpsprotocol + wshub)"),
+        (os.path.join(repo, "Client/debugger"),
+         "Go (debugger)"),
+    ]
+    total_pct = 0.0
+    pct_count = 0
+    suites = []
+    for mod_dir, name in modules:
+        s = {"name": name, "lang": "go", "total": 0, "passed": 0,
+             "failed": 0, "skipped": 0, "time_s": 0.0, "ok": False, "avail": False}
+        cov_p = os.path.join(work, f"go_cover_{name.replace(' ', '_')}.out")
+        rc, out, err = _run(
+            ["go", "test", "-json", f"-coverprofile={cov_p}", "./..."],
+            cwd=mod_dir)
+        if rc == 127:
+            s["detail"] = "go toolchain not found"
+            suites.append(s)
+            continue
+        s["avail"] = True
+        cov_pct = _parse_go_json(out, s)
+        if cov_pct is not None:
+            s["cov_pct"] = cov_pct
+            total_pct += cov_pct
+            pct_count += 1
+        suites.append(s)
+    return suites, (round(total_pct / pct_count, 1) if pct_count else None)
+
+
+def _parse_go_json(out, s):
+    """Parse Go test -json output into passed/failed/skipped counts.
+    Returns coverage percentage (float or None)."""
     cov_pct = None
     for line in out.splitlines():
         try:
@@ -93,8 +164,7 @@ def go_suite(client_dir, work):
             if m:
                 cov_pct = float(m.group(1))
     s["ok"] = s["failed"] == 0 and s["total"] > 0
-    s["cov_pct"] = cov_pct
+    return cov_pct
-    return s
 
 
 # ── Python ──────────────────────────────────────────────────────────────────
@@ -209,12 +279,15 @@ def cpp_coverage(repo, target):
     if rc != 0 or not os.path.exists(raw):
         cov["note"] = "lcov capture failed: " + (err or out or "")[-160:]
         return cov
-    # Keep only this repo's own sources so the number reflects project code,
+    # Keep only this repo's own Source/ code so the number reflects project
-    # not the MARTe2 framework headers dragged in by templates/inlines.
+    # code under test, not the MARTe2 framework headers dragged in by
+    # templates/inlines, and not the Test/ harness itself (GTest/Integration
+    # test .cpp files execute every line by construction and sit at ~100%,
+    # which would just inflate the aggregate and clutter the per-file table
+    # with files that were never meant to be "covered").
     info = os.path.join(build, "coverage.info")
     rc2, _, e2 = _run(["lcov", "--extract", raw,
                        os.path.join(repo, "Source", "*"),
-                       os.path.join(repo, "Test", "*"),
                        "--output-file", info, "--quiet"] + ign, timeout=300)
     summ_file = info if (rc2 == 0 and os.path.exists(info)) else raw
     # Parse the tracefile directly for per-file detail; this also yields the
@@ -250,12 +323,16 @@ def main():
     work = args.work or args.out
     os.makedirs(work, exist_ok=True)
     chain_dir = os.path.dirname(os.path.abspath(__file__))
-    client_dir = os.path.join(chain_dir, "client")
     gtest_bin = os.path.join(args.repo, "Build", args.target, "GTest", "MainGTest.ex")
+    # BUILD_DIR for Test/Integration doubles the last path component
+    # ($(PACKAGE)/$(lastword of CURDIR)) — see MakeStdLibDefs.gcc.
+    integration_bin = os.path.join(args.repo, "Build", args.target,
+                                    "Test", "Integration", "Integration",
+                                    "IntegrationTests.ex")
 
-    suites = [gtest_suite(gtest_bin, work),
+    go_suites, go_avg_cov = go_all_suites(args.repo, work)
-              go_suite(client_dir, work),
+    suites = ([gtest_suite(gtest_bin, work), integration_suite(integration_bin, work)]
-              py_suite(chain_dir, work)]
+              + go_suites + [py_suite(chain_dir, work)])
     totals = {k: sum(s.get(k, 0) for s in suites)
               for k in ("total", "passed", "failed", "skipped")}
     ut = {"suites": suites, "totals": totals,
@@ -265,11 +342,10 @@ def main():
 
     langs = []
     py = next(s for s in suites if s["lang"] == "python")
-    go = next(s for s in suites if s["lang"] == "go")
     langs.append({"name": "Python", "avail": py.get("cov_pct") is not None,
                   "pct": py.get("cov_pct"), "note": "coverage.py"})
-    langs.append({"name": "Go", "avail": go.get("cov_pct") is not None,
+    langs.append({"name": "Go", "avail": go_avg_cov is not None,
-                  "pct": go.get("cov_pct"), "note": "go test -cover"})
+                  "pct": go_avg_cov, "note": "go test -cover (avg across modules)"})
     cpp = cpp_coverage(args.repo, args.target) if args.cpp_coverage else \
         {"name": "C++", "avail": False, "pct": None, "note": "skipped (use --cpp-coverage)"}
     langs.append(cpp)

Test/E2E/suite/debug_e2e.cfg

@@ -0,0 +1,82 @@
+/**
+ * Trimmed single-thread configuration for the "debug"/"tcplogger" E2E
+ * scenario kinds: exercises DebugService FORCE/TRACE/BREAK over TCP 8080 /
+ * UDP 8081 and TCPLogger delivery over TCP 9090, with no UDPStreamer path.
+ */
+
+$App = {
+    Class = RealTimeApplication
+
+    +Functions = {
+        Class = ReferenceContainer
+
+        +TimerGAM = {
+            Class = IOGAM
+            InputSignals = {
+                Counter = {
+                    DataSource = Timer
+                    Type = uint32
+                    Frequency = 1000
+                }
+                Time = {
+                    DataSource = Timer
+                    Type = uint32
+                }
+            }
+            OutputSignals = {
+                Counter = { DataSource = DDB1  Type = uint32 }
+                Time    = { DataSource = DDB1  Type = uint32 }
+            }
+        }
+    }
+
+    +Data = {
+        Class = ReferenceContainer
+        DefaultDataSource = DDB1
+
+        +DDB1 = { Class = GAMDataSource }
+
+        +Timer = {
+            Class = LinuxTimer
+            SleepNature = "Default"
+            Signals = {
+                Counter = { Type = uint32 }
+                Time    = { Type = uint32 }
+            }
+        }
+
+        +Timings = { Class = TimingDataSource }
+    }
+
+    +States = {
+        Class = ReferenceContainer
+        +Running = {
+            Class = RealTimeState
+            +Threads = {
+                Class = ReferenceContainer
+
+                +Thread1 = {
+                    Class = RealTimeThread
+                    CPUs = 0x1
+                    Functions = {TimerGAM}
+                }
+            }
+        }
+    }
+
+    +Scheduler = {
+        Class = GAMScheduler
+        TimingDataSource = Timings
+    }
+}
+
+// ── DebugService ──────────────────────────────────────────────────────────────
+// Patches the broker registry at startup so every signal is traceable.
+// TcpLogger is auto-injected on LogPort (9090) — no explicit DataSource needed.
++DebugService = {
+    Class = DebugService
+    ControlPort = 8080
+    StreamPort  = 8081
+    LogPort     = 9090
+    StreamIP    = "127.0.0.1"
+}

Test/E2E/suite/debugclient/go.mod

@@ -0,0 +1,15 @@
+module debugclient
+
+go 1.21
+
+require marte2debugger v0.0.0
+
+require (
+	github.com/gorilla/websocket v1.5.1 // indirect
+	golang.org/x/net v0.17.0 // indirect
+	marte2/common v0.0.0 // indirect
+)
+
+replace marte2debugger => ../../../../Client/debugger
+
+replace marte2/common => ../../../../Common/Client/go