Task #249 — Driver test-client CLIs: shared lib + Modbus CLI first

Mirrors the v1 otopcua-cli value prop (ad-hoc shell-level PLC validation) for
the Modbus-TCP driver, and lays down the shared scaffolding that AB CIP, AB
Legacy, S7, and TwinCAT CLIs will build on.

New projects:
  - src/ZB.MOM.WW.OtOpcUa.Driver.Cli.Common/ — DriverCommandBase (verbose
    flag + Serilog config) + SnapshotFormatter (single-tag + table +
    write-result renders with invariant-culture value formatting + OPC UA
    status-code shortnames + UTC-normalised timestamps).
  - src/ZB.MOM.WW.OtOpcUa.Driver.Modbus.Cli/ — otopcua-modbus-cli executable.
    Commands: probe, read, write, subscribe. ModbusCommandBase carries the
    host/port/unit-id flags + builds ModbusDriverOptions with Probe.Enabled
    =false (CLI runs are one-shot; driver-internal keep-alive would race).

Commands + coverage:
  - probe              single FC03 + GetHealth() + pretty-print
  - read               region × address × type synth into one driver tag
  - write              same shape + --value parsed per --type
  - subscribe          polled-subscription stream until Ctrl+C

Tests (38 total):
  - 16 SnapshotFormatterTests covering: status-code shortnames, unknown
    codes fall back to hex, null value + timestamp placeholders, bool
    lowercase, float invariant culture, string quoting, write-result shape,
    aligned table columns, mismatched-length rejection, UTC normalisation.
  - 22 Modbus CLI tests:
      · ReadCommandTests.SynthesiseTagName (5 theory cases)
      · WriteCommandParseValueTests (17 cases: bool aliases, unknown rejected,
        Int16 bounds, UInt16/Bcd16 type, Float32/64 invariant culture,
        String passthrough, BitInRegister, Int32 MinValue, non-numeric reject)

Wiring:
  - ZB.MOM.WW.OtOpcUa.slnx grew 4 entries (2 src + 2 tests).
  - docs/Driver.Modbus.Cli.md — operator-facing runbook with examples per
    command + output format + typical workflows.

Regression: full-solution build clean; shared-lib tests 16/0, Modbus CLI tests
22/0.

Next up: repeat the pattern for AB CIP (shares ~40% more with Modbus via
libplctag), then AB Legacy, S7, TwinCAT. The shared base stays as-is unless
one of those exposes a gap the Modbus-first pass missed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/ZB.MOM.WW.OtOpcUa.Driver.Modbus.Cli.Tests/WriteCommandParseValueTests.cs

@@ -0,0 +1,90 @@
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Driver.Modbus.Cli.Commands;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.Modbus.Cli.Tests;
+
+/// <summary>
+///     Covers the <c>--value</c> string → CLR type parser inside
+///     <see cref="WriteCommand.ParseValue"/>. This is the piece that guards against
+///     locale surprises (e.g. comma-as-decimal-separator on PL locales), so all numeric
+///     paths assert the invariant-culture path.
+/// </summary>
+[Trait("Category", "Unit")]
+public sealed class WriteCommandParseValueTests
+{
+    [Theory]
+    [InlineData("true", true)]
+    [InlineData("false", false)]
+    [InlineData("1", true)]
+    [InlineData("0", false)]
+    [InlineData("YES", true)]
+    [InlineData("No", false)]
+    [InlineData("on", true)]
+    [InlineData("off", false)]
+    public void ParseValue_Bool_accepts_common_aliases(string raw, bool expected)
+    {
+        WriteCommand.ParseValue(raw, ModbusDataType.Bool).ShouldBe(expected);
+    }
+
+    [Fact]
+    public void ParseValue_Bool_rejects_unknown_strings()
+    {
+        Should.Throw<CliFx.Exceptions.CommandException>(
+            () => WriteCommand.ParseValue("maybe", ModbusDataType.Bool));
+    }
+
+    [Fact]
+    public void ParseValue_Int16_parses_positive_and_negative()
+    {
+        WriteCommand.ParseValue("-32768", ModbusDataType.Int16).ShouldBe((short)-32768);
+        WriteCommand.ParseValue("32767", ModbusDataType.Int16).ShouldBe((short)32767);
+    }
+
+    [Fact]
+    public void ParseValue_UInt16_and_Bcd16_both_yield_ushort()
+    {
+        WriteCommand.ParseValue("65535", ModbusDataType.UInt16).ShouldBeOfType<ushort>();
+        WriteCommand.ParseValue("65535", ModbusDataType.Bcd16).ShouldBeOfType<ushort>();
+    }
+
+    [Fact]
+    public void ParseValue_Float32_uses_invariant_culture_period_as_decimal_separator()
+    {
+        WriteCommand.ParseValue("3.14", ModbusDataType.Float32).ShouldBe(3.14f);
+    }
+
+    [Fact]
+    public void ParseValue_Float64_handles_larger_precision()
+    {
+        var result = WriteCommand.ParseValue("2.718281828", ModbusDataType.Float64);
+        result.ShouldBeOfType<double>();
+        ((double)result).ShouldBe(2.718281828d, 0.0000001d);
+    }
+
+    [Fact]
+    public void ParseValue_String_returns_raw_string_unmodified()
+    {
+        WriteCommand.ParseValue("hello world", ModbusDataType.String).ShouldBe("hello world");
+    }
+
+    [Fact]
+    public void ParseValue_BitInRegister_accepts_bool_aliases()
+    {
+        WriteCommand.ParseValue("true", ModbusDataType.BitInRegister).ShouldBe(true);
+        WriteCommand.ParseValue("0", ModbusDataType.BitInRegister).ShouldBe(false);
+    }
+
+    [Fact]
+    public void ParseValue_Int32_parses_negative_max()
+    {
+        WriteCommand.ParseValue("-2147483648", ModbusDataType.Int32).ShouldBe(int.MinValue);
+    }
+
+    [Fact]
+    public void ParseValue_rejects_non_numeric_for_numeric_types()
+    {
+        Should.Throw<FormatException>(
+            () => WriteCommand.ParseValue("not-a-number", ModbusDataType.Int32));
+    }
+}