Allow status code variant creation from uint

Stack/Opc.Ua.Types/BuiltIn/Variant.cs

@@ -2354,6 +2354,14 @@ private void SetScalar(object value, TypeInfo typeInfo)
                     m_value = ((Variant)value).Value;
                     TypeInfo = TypeInfo.Construct(m_value);
                     return;
+                case BuiltInType.StatusCode:
+                    if (value is uint code)
+                    {
+                        m_value = new StatusCode(code);
+                        return;
+                    }
+                    m_value = value;
+                    return;
                 // just save the value.
                 case >= BuiltInType.Null and <= BuiltInType.Enumeration:
                     m_value = value;
@@ -2408,6 +2416,19 @@ private void SetArray(Array array, TypeInfo typeInfo)
                         return;
                     }
 
+                    m_value = array;
+                    return;
+                case BuiltInType.StatusCode:
+                    if (array is uint[] codes)
+                    {
+                        var statusCodes = new StatusCode[codes.Length];
+                        for (int ii = 0; ii < codes.Length; ii++)
+                        {
+                            statusCodes[ii] = new StatusCode(codes[ii]);
+                        }
+                        m_value = statusCodes;
+                        return;
+                    }
                     m_value = array;
                     return;
                 // convert encodeables to extension objects.

Tests/Opc.Ua.Core.Tests/Types/BuiltIn/BuiltInTests.cs

@@ -204,6 +204,91 @@ public void VariantFromEnumArray()
             // Variant variant6 = new Variant(daysdays);
         }
 
+        /// <summary>
+        /// Initialize Variant from uint with StatusCode TypeInfo.
+        /// Tests that a Variant created from uint with StatusCode TypeInfo
+        /// can be properly cast to StatusCode.
+        /// </summary>
+        [Test]
+        public void VariantFromUIntWithStatusCodeTypeInfo()
+        {
+            // Test scalar StatusCode creation from uint
+            uint statusCodeValue = StatusCodes.Good;
+            var variant = new Variant(statusCodeValue, TypeInfo.Scalars.StatusCode);
+
+            Assert.AreEqual(BuiltInType.StatusCode, variant.TypeInfo.BuiltInType);
+            Assert.NotNull(variant.Value);
+
+            // Cast the Value to StatusCode
+            StatusCode statusCode = (StatusCode)variant.Value;
+            Assert.AreEqual(StatusCodes.Good, statusCode.Code);
+
+            // Test with different status code values
+            uint badNodeIdValue = StatusCodes.BadNodeIdInvalid;
+            var variant2 = new Variant(badNodeIdValue, TypeInfo.Scalars.StatusCode);
+
+            Assert.AreEqual(BuiltInType.StatusCode, variant2.TypeInfo.BuiltInType);
+            StatusCode statusCode2 = (StatusCode)variant2.Value;
+            Assert.AreEqual(StatusCodes.BadNodeIdInvalid, statusCode2.Code);
+
+            // Test with custom status code value
+            uint customValue = 0x80AB0000;
+            var variant3 = new Variant(customValue, TypeInfo.Scalars.StatusCode);
+
+            Assert.AreEqual(BuiltInType.StatusCode, variant3.TypeInfo.BuiltInType);
+            StatusCode statusCode3 = (StatusCode)variant3.Value;
+            Assert.AreEqual(customValue, statusCode3.Code);
+        }
+
+        /// <summary>
+        /// Initialize Variant from uint array with StatusCode TypeInfo.
+        /// Tests that a Variant created from uint[] with StatusCode TypeInfo
+        /// can be properly cast to StatusCode[].
+        /// </summary>
+        [Test]
+        public void VariantFromUIntArrayWithStatusCodeTypeInfo()
+        {
+            // Test array StatusCode creation from uint[]
+            uint[] statusCodeValues = [
+                StatusCodes.Good,
+                StatusCodes.BadNodeIdInvalid,
+                StatusCodes.BadUnexpectedError,
+                StatusCodes.BadInternalError
+            ];
+
+            var variant = new Variant(statusCodeValues, TypeInfo.Arrays.StatusCode);
+
+            Assert.AreEqual(BuiltInType.StatusCode, variant.TypeInfo.BuiltInType);
+            Assert.NotNull(variant.Value);
+            Assert.IsTrue(variant.Value is StatusCode[]);
+
+            // Cast the Value to StatusCode array
+            StatusCode[] statusCodes = (StatusCode[])variant.Value;
+            Assert.AreEqual(statusCodeValues.Length, statusCodes.Length);
+
+            for (int i = 0; i < statusCodeValues.Length; i++)
+            {
+                Assert.AreEqual(statusCodeValues[i], statusCodes[i].Code);
+            }
+
+            // Test empty array
+            uint[] emptyArray = [];
+            var variant2 = new Variant(emptyArray, TypeInfo.Arrays.StatusCode);
+
+            Assert.AreEqual(BuiltInType.StatusCode, variant2.TypeInfo.BuiltInType);
+            StatusCode[] emptyStatusCodes = (StatusCode[])variant2.Value;
+            Assert.AreEqual(0, emptyStatusCodes.Length);
+
+            // Test single element array
+            uint[] singleElement = [StatusCodes.BadTimeout];
+            var variant3 = new Variant(singleElement, TypeInfo.Arrays.StatusCode);
+
+            Assert.AreEqual(BuiltInType.StatusCode, variant3.TypeInfo.BuiltInType);
+            StatusCode[] singleStatusCode = (StatusCode[])variant3.Value;
+            Assert.AreEqual(1, singleStatusCode.Length);
+            Assert.AreEqual(StatusCodes.BadTimeout, singleStatusCode[0].Code);
+        }
+
         /// <summary>
         /// Validate ExtensionObject special cases and constructors.
         /// </summary>