Phase 0 — mechanical rename ZB.MOM.WW.LmxOpcUa.* → ZB.MOM.WW.OtOpcUa.*

Renames all 11 projects (5 src + 6 tests), the .slnx solution file, all source-file namespaces, all axaml namespace references, and all v1 documentation references in CLAUDE.md and docs/*.md (excluding docs/v2/ which is already in OtOpcUa form). Also updates the TopShelf service registration name from "LmxOpcUa" to "OtOpcUa" per Phase 0 Task 0.6.

Preserves runtime identifiers per Phase 0 Out-of-Scope rules to avoid breaking v1/v2 client trust during coexistence: OPC UA `ApplicationUri` defaults (`urn:{GalaxyName}:LmxOpcUa`), server `EndpointPath` (`/LmxOpcUa`), `ServerName` default (feeds cert subject CN), `MxAccessConfiguration.ClientName` default (defensive — stays "LmxOpcUa" for MxAccess audit-trail consistency), client OPC UA identifiers (`ApplicationName = "LmxOpcUaClient"`, `ApplicationUri = "urn:localhost:LmxOpcUaClient"`, cert directory `%LocalAppData%\LmxOpcUaClient\pki\`), and the `LmxOpcUaServer` class name (class rename out of Phase 0 scope per Task 0.5 sed pattern; happens in Phase 1 alongside `LmxNodeManager → GenericDriverNodeManager` Core extraction). 23 LmxOpcUa references retained, all enumerated and justified in `docs/v2/implementation/exit-gate-phase-0.md`.

Build clean: 0 errors, 30 warnings (lower than baseline 167). Tests at strict improvement over baseline: 821 passing / 1 failing vs baseline 820 / 2 (one flaky pre-existing failure passed this run; the other still fails — both pre-existing and unrelated to the rename). `Client.UI.Tests`, `Historian.Aveva.Tests`, `Client.Shared.Tests`, `IntegrationTests` all match baseline exactly. Exit gate compliance results recorded in `docs/v2/implementation/exit-gate-phase-0.md` with all 7 checks PASS or DEFERRED-to-PR-review (#7 service install verification needs Windows service permissions on the reviewer's box).

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

tests/ZB.MOM.WW.OtOpcUa.Tests/OpcUa/DataValueConverterTests.cs

@@ -0,0 +1,165 @@
+using System;
+using Opc.Ua;
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Host.Domain;
+using ZB.MOM.WW.OtOpcUa.Host.OpcUa;
+
+namespace ZB.MOM.WW.OtOpcUa.Tests.OpcUa
+{
+    /// <summary>
+    ///     Verifies how bridge VTQ values are translated to and from OPC UA data values for the published namespace.
+    /// </summary>
+    public class DataValueConverterTests
+    {
+        /// <summary>
+        ///     Confirms that boolean runtime values are preserved when converted to OPC UA data values.
+        /// </summary>
+        [Fact]
+        public void FromVtq_Boolean()
+        {
+            var vtq = Vtq.Good(true);
+            var dv = DataValueConverter.FromVtq(vtq);
+            dv.Value.ShouldBe(true);
+            StatusCode.IsGood(dv.StatusCode).ShouldBe(true);
+        }
+
+        /// <summary>
+        ///     Confirms that integer runtime values are preserved when converted to OPC UA data values.
+        /// </summary>
+        [Fact]
+        public void FromVtq_Int32()
+        {
+            var vtq = Vtq.Good(42);
+            var dv = DataValueConverter.FromVtq(vtq);
+            dv.Value.ShouldBe(42);
+        }
+
+        /// <summary>
+        ///     Confirms that float runtime values are preserved when converted to OPC UA data values.
+        /// </summary>
+        [Fact]
+        public void FromVtq_Float()
+        {
+            var vtq = Vtq.Good(3.14f);
+            var dv = DataValueConverter.FromVtq(vtq);
+            dv.Value.ShouldBe(3.14f);
+        }
+
+        /// <summary>
+        ///     Confirms that double runtime values are preserved when converted to OPC UA data values.
+        /// </summary>
+        [Fact]
+        public void FromVtq_Double()
+        {
+            var vtq = Vtq.Good(3.14159);
+            var dv = DataValueConverter.FromVtq(vtq);
+            dv.Value.ShouldBe(3.14159);
+        }
+
+        /// <summary>
+        ///     Confirms that string runtime values are preserved when converted to OPC UA data values.
+        /// </summary>
+        [Fact]
+        public void FromVtq_String()
+        {
+            var vtq = Vtq.Good("hello");
+            var dv = DataValueConverter.FromVtq(vtq);
+            dv.Value.ShouldBe("hello");
+        }
+
+        /// <summary>
+        ///     Confirms that UTC timestamps remain UTC when a VTQ is converted for OPC UA clients.
+        /// </summary>
+        [Fact]
+        public void FromVtq_DateTime_IsUtc()
+        {
+            var utcTime = new DateTime(2024, 6, 15, 10, 30, 0, DateTimeKind.Utc);
+            var vtq = new Vtq(utcTime, utcTime, Quality.Good);
+            var dv = DataValueConverter.FromVtq(vtq);
+            ((DateTime)dv.Value).Kind.ShouldBe(DateTimeKind.Utc);
+        }
+
+        /// <summary>
+        ///     Confirms that elapsed-time values are exposed to OPC UA clients in seconds.
+        /// </summary>
+        [Fact]
+        public void FromVtq_TimeSpan_ConvertedToSeconds()
+        {
+            var vtq = Vtq.Good(TimeSpan.FromMinutes(2.5));
+            var dv = DataValueConverter.FromVtq(vtq);
+            dv.Value.ShouldBe(150.0);
+        }
+
+        /// <summary>
+        ///     Confirms that string arrays remain arrays when exposed through OPC UA.
+        /// </summary>
+        [Fact]
+        public void FromVtq_StringArray()
+        {
+            var arr = new[] { "a", "b", "c" };
+            var vtq = Vtq.Good(arr);
+            var dv = DataValueConverter.FromVtq(vtq);
+            dv.Value.ShouldBe(arr);
+        }
+
+        /// <summary>
+        ///     Confirms that integer arrays remain arrays when exposed through OPC UA.
+        /// </summary>
+        [Fact]
+        public void FromVtq_IntArray()
+        {
+            var arr = new[] { 1, 2, 3 };
+            var vtq = Vtq.Good(arr);
+            var dv = DataValueConverter.FromVtq(vtq);
+            dv.Value.ShouldBe(arr);
+        }
+
+        /// <summary>
+        ///     Confirms that bad runtime quality is translated to a bad OPC UA status code.
+        /// </summary>
+        [Fact]
+        public void FromVtq_BadQuality_MapsToStatusCode()
+        {
+            var vtq = Vtq.Bad(Quality.BadCommFailure);
+            var dv = DataValueConverter.FromVtq(vtq);
+            StatusCode.IsBad(dv.StatusCode).ShouldBe(true);
+        }
+
+        /// <summary>
+        ///     Confirms that uncertain runtime quality is translated to an uncertain OPC UA status code.
+        /// </summary>
+        [Fact]
+        public void FromVtq_UncertainQuality()
+        {
+            var vtq = Vtq.Uncertain(42);
+            var dv = DataValueConverter.FromVtq(vtq);
+            StatusCode.IsUncertain(dv.StatusCode).ShouldBe(true);
+        }
+
+        /// <summary>
+        ///     Confirms that null runtime values remain null when converted for OPC UA.
+        /// </summary>
+        [Fact]
+        public void FromVtq_NullValue()
+        {
+            var vtq = Vtq.Good(null);
+            var dv = DataValueConverter.FromVtq(vtq);
+            dv.Value.ShouldBeNull();
+        }
+
+        /// <summary>
+        ///     Confirms that a data value can round-trip back into a VTQ without losing the process value or quality.
+        /// </summary>
+        [Fact]
+        public void ToVtq_RoundTrip()
+        {
+            var original = new Vtq(42, DateTime.UtcNow, Quality.Good);
+            var dv = DataValueConverter.FromVtq(original);
+            var roundTrip = DataValueConverter.ToVtq(dv);
+
+            roundTrip.Value.ShouldBe(42);
+            roundTrip.Quality.ShouldBe(Quality.Good);
+        }
+    }
+}