Fix BaseVariableState to return correct BuiltInType for Byte arrays vs ByteString (#3384)

* Initial plan

* Fix ByteString vs Byte array distinction in WrappedValue

Modified BaseVariableState.WrappedValue to use DataType and ValueRank
when creating Variant to correctly distinguish between byte[] (Byte array)
and ByteString. Added tests to verify the fix.

Co-authored-by: romanett <[email protected]>

* Address code review feedback

- Remove redundant null check for NodeId (NodeId.IsNull handles null)
- Update comment in test to be more specific about ByteString testing

Co-authored-by: romanett <[email protected]>

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: romanett <[email protected]>

Author: Copilot

Stack/Opc.Ua.Types/State/BaseVariableState.cs

@@ -556,7 +556,21 @@ public object Value
         [DataMember(Name = "Value", Order = 0, IsRequired = false, EmitDefaultValue = false)]
         public Variant WrappedValue
         {
-            get => new(m_value);
+            get
+            {
+                // If we have a valid DataType and ValueRank, use them to construct the TypeInfo
+                // This is necessary to distinguish between byte[] (Byte array) and ByteString
+                if (m_value != null && !NodeId.IsNull(m_dataType))
+                {
+                    BuiltInType builtInType = TypeInfo.GetBuiltInType(m_dataType);
+                    if (builtInType != BuiltInType.Null)
+                    {
+                        TypeInfo typeInfo = TypeInfo.Create(builtInType, m_valueRank);
+                        return new Variant(m_value, typeInfo);
+                    }
+                }
+                return new Variant(m_value);
+            }
             set => Value = ExtractValueFromVariant(null, value.Value, false);
         }
 

Tests/Opc.Ua.Core.Tests/Stack/State/BaseDataVariableTypeStateSerializationTest.cs

@@ -125,5 +125,83 @@ public void ValueRankPersistBaseVariableState(
 
             Assert.AreEqual(valueRank, loadedVariable.ValueRank);
         }
+
+        /// <summary>
+        /// Test that byte[] array is correctly returned as Byte array type, not ByteString.
+        /// </summary>
+        [Test]
+        public void ByteArrayWrappedValueReturnsCorrectBuiltInType()
+        {
+            ITelemetryContext telemetry = NUnitTelemetryContext.Create();
+
+            // Create a BaseDataVariableState with byte[] value
+            var variableState = new BaseDataVariableState<byte[]>(null);
+            var serviceMessageContext = new ServiceMessageContext(telemetry);
+            var systemContext = new SystemContext(telemetry)
+            {
+                NamespaceUris = serviceMessageContext.NamespaceUris
+            };
+
+            variableState.Create(
+                systemContext,
+                new NodeId(1000),
+                new QualifiedName("ByteArrayVariable"),
+                new LocalizedText("ByteArrayVariable"),
+                true);
+
+            // Set DataType to Byte and ValueRank to OneDimension (array)
+            variableState.DataType = DataTypeIds.Byte;
+            variableState.ValueRank = ValueRanks.OneDimension;
+
+            // Set a byte array value
+            byte[] testValue = new byte[] { 1, 2, 3, 4, 5 };
+            variableState.Value = testValue;
+
+            // Get the WrappedValue and verify it's a Byte array, not ByteString
+            Variant wrappedValue = variableState.WrappedValue;
+
+            Assert.AreEqual(BuiltInType.Byte, wrappedValue.TypeInfo.BuiltInType, "BuiltInType should be Byte");
+            Assert.AreEqual(ValueRanks.OneDimension, wrappedValue.TypeInfo.ValueRank, "ValueRank should be OneDimension");
+            Assert.AreEqual(testValue, wrappedValue.Value, "Value should match the original byte array");
+        }
+
+        /// <summary>
+        /// Test that ByteString is still correctly returned as ByteString type.
+        /// </summary>
+        [Test]
+        public void ByteStringWrappedValueReturnsCorrectBuiltInType()
+        {
+            ITelemetryContext telemetry = NUnitTelemetryContext.Create();
+
+            // Create a BaseDataVariableState for ByteString testing
+            var variableState = new BaseDataVariableState<byte[]>(null);
+            var serviceMessageContext = new ServiceMessageContext(telemetry);
+            var systemContext = new SystemContext(telemetry)
+            {
+                NamespaceUris = serviceMessageContext.NamespaceUris
+            };
+
+            variableState.Create(
+                systemContext,
+                new NodeId(1001),
+                new QualifiedName("ByteStringVariable"),
+                new LocalizedText("ByteStringVariable"),
+                true);
+
+            // Set DataType to ByteString and ValueRank to Scalar
+            variableState.DataType = DataTypeIds.ByteString;
+            variableState.ValueRank = ValueRanks.Scalar;
+
+            // Set a byte array value (which represents a ByteString)
+            byte[] testValue = new byte[] { 1, 2, 3, 4, 5 };
+            variableState.Value = testValue;
+
+            // Get the WrappedValue and verify it's a ByteString
+            Variant wrappedValue = variableState.WrappedValue;
+
+            Assert.AreEqual(BuiltInType.ByteString, wrappedValue.TypeInfo.BuiltInType, "BuiltInType should be ByteString");
+            Assert.AreEqual(ValueRanks.Scalar, wrappedValue.TypeInfo.ValueRank, "ValueRank should be Scalar");
+            Assert.AreEqual(testValue, wrappedValue.Value, "Value should match the original byte array");
+        }
     }
 }