Added additional EvtVariantTypes

Author: jschick04

src/EventLogExpert.Eventing.Tests/Helpers/EventMethodsTests.cs

@@ -108,6 +108,48 @@ public void ConvertVariant_WhenByte_ShouldReturnByte()
         Assert.Equal(expectedValue, result);
     }
 
+    [Fact]
+    public void ConvertVariant_WhenByteArray_ShouldReturnByteArray()
+    {
+        // Arrange
+        byte[] expectedBytes = [10, 20, 30, 40, 50];
+        IntPtr arrayPtr = Marshal.AllocHGlobal(expectedBytes.Length);
+
+        try
+        {
+            Marshal.Copy(expectedBytes, 0, arrayPtr, expectedBytes.Length);
+
+            var variant = CreateVariantWithCount(EvtVariantType.ByteArray, arrayPtr, (uint)expectedBytes.Length);
+
+            // Act
+            var result = EventMethods.ConvertVariant(variant);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.IsType<byte[]>(result);
+            Assert.Equal(expectedBytes, (byte[])result);
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(arrayPtr);
+        }
+    }
+
+    [Fact]
+    public void ConvertVariant_WhenByteArrayEmpty_ShouldReturnEmptyArray()
+    {
+        // Arrange
+        var variant = CreateVariantWithCount(EvtVariantType.ByteArray, IntPtr.Zero, 0);
+
+        // Act
+        var result = EventMethods.ConvertVariant(variant);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.IsType<byte[]>(result);
+        Assert.Empty((byte[])result);
+    }
+
     [Fact]
     public void ConvertVariant_WhenDouble_ShouldReturnDouble()
     {
@@ -487,6 +529,52 @@ public void ConvertVariant_WhenUInt32_ShouldReturnUInt32()
         Assert.Equal(expectedValue, result);
     }
 
+    [Fact]
+    public void ConvertVariant_WhenUInt32Array_ShouldReturnUInt32Array()
+    {
+        // Arrange
+        uint[] expectedValues = [100, 200, 300, 400];
+        IntPtr arrayPtr = Marshal.AllocHGlobal(sizeof(uint) * expectedValues.Length);
+
+        try
+        {
+            unsafe
+            {
+                var dest = new Span<uint>((void*)arrayPtr, expectedValues.Length);
+                expectedValues.CopyTo(dest);
+            }
+
+            var variant = CreateVariantWithCount(EvtVariantType.UInt32Array, arrayPtr, (uint)expectedValues.Length);
+
+            // Act
+            var result = EventMethods.ConvertVariant(variant);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.IsType<uint[]>(result);
+            Assert.Equal(expectedValues, (uint[])result);
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(arrayPtr);
+        }
+    }
+
+    [Fact]
+    public void ConvertVariant_WhenUInt32ArrayEmpty_ShouldReturnEmptyArray()
+    {
+        // Arrange
+        var variant = CreateVariantWithCount(EvtVariantType.UInt32Array, IntPtr.Zero, 0);
+
+        // Act
+        var result = EventMethods.ConvertVariant(variant);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.IsType<uint[]>(result);
+        Assert.Empty((uint[])result);
+    }
+
     [Fact]
     public void ConvertVariant_WhenUInt64_ShouldReturnUInt64()
     {
@@ -697,6 +785,8 @@ private static EvtVariant CreateVariantWithCount(EvtVariantType type, object? va
                     case EvtVariantType.SysTime:
                     case EvtVariantType.Binary:
                     case EvtVariantType.StringArray:
+                    case EvtVariantType.ByteArray:
+                    case EvtVariantType.UInt32Array:
                         *(nint*)buffer = (IntPtr)value;
                         break;
                     case EvtVariantType.SByte:

src/EventLogExpert.Eventing/Helpers/EventMethods.cs

@@ -166,8 +166,10 @@ internal enum EvtVariantType
     Handle,
     Xml,
 
-    // Custom types
-    StringArray = 129 // String masked with EVT_VARIANT_TYPE_ARRAY
+    // Array types (base type | EVT_VARIANT_TYPE_ARRAY)
+    StringArray = 129,
+    ByteArray = 132,
+    UInt32Array = 136
 }
 
 [Flags]
@@ -265,6 +267,31 @@ internal static partial class EventMethods
                 }
 
                 return stringArray;
+            case (int)EvtVariantType.ByteArray:
+                if (variant.Count == 0)
+                {
+                    return Array.Empty<byte>();
+                }
+
+                var byteArray = new byte[variant.Count];
+                Marshal.Copy(variant.Reference, byteArray, 0, byteArray.Length);
+
+                return byteArray;
+            case (int)EvtVariantType.UInt32Array:
+                if (variant.Count == 0)
+                {
+                    return Array.Empty<uint>();
+                }
+
+                var uintArray = new uint[variant.Count];
+
+                unsafe
+                {
+                    var source = new ReadOnlySpan<uint>((void*)variant.Reference, (int)variant.Count);
+                    source.CopyTo(uintArray);
+                }
+
+                return uintArray;
             default:
                 throw new InvalidDataException($"Invalid {nameof(EvtVariantType)}: {variant.Type}");
         }