Fix DataRow issues related to serialization/deserialization

src/Adapter/MSTest.TestAdapter/Discovery/AssemblyEnumerator.cs

@@ -460,6 +460,7 @@ private static bool ProcessITestDataSourceTests(UnitTestElement test, Reflection
                 try
                 {
                     discoveredTest.TestMethod.SerializedData = DataSerializationHelper.Serialize(d);
+                    discoveredTest.TestMethod.ActualData = d;
                     discoveredTest.TestMethod.DataType = DynamicDataType.ITestDataSource;
                 }
                 catch (SerializationException ex)

src/Adapter/MSTest.TestAdapter/Execution/TestMethodRunner.cs

@@ -172,7 +172,7 @@ internal UnitTestResult[] RunTestMethod()
         {
             if (_test.DataType == DynamicDataType.ITestDataSource)
             {
-                object?[]? data = DataSerializationHelper.Deserialize(_test.SerializedData);
+                object?[]? data = _test.ActualData ?? DataSerializationHelper.Deserialize(_test.SerializedData);
                 TestResult[] testResults = ExecuteTestWithDataSource(null, data);
                 results.AddRange(testResults);
             }

src/Adapter/MSTest.TestAdapter/ObjectModel/TestMethod.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Collections.Concurrent;
 using System.Collections.ObjectModel;
 using System.Diagnostics.CodeAnalysis;
 
@@ -28,6 +29,8 @@ public sealed class TestMethod : ITestMethod
     private string? _declaringClassFullName;
     private string? _declaringAssemblyName;
 
+    private static readonly ConcurrentDictionary<string, object?[]> DataDictionary = new();
+
     public TestMethod(string name, string fullClassName, string assemblyName, bool isAsync)
         : this(null, null, null, name, fullClassName, assemblyName, isAsync, null, TestIdGenerationStrategy.FullyQualified)
     {
@@ -137,6 +140,29 @@ public string? DeclaringClassFullName
     /// </summary>
     internal string?[]? SerializedData { get; set; }
 
+    private object?[]? _actualData;
+
+    [DisallowNull]
+    internal object?[]? ActualData
+    {
+        get
+        {
+            if (_actualData is not null)
+            {
+                return _actualData;
+            }
+
+            DataDictionary.TryGetValue(UniqueName, out _actualData);
+            return _actualData;
+        }
+
+        set
+        {
+            _actualData = value;
+            DataDictionary.TryAdd(UniqueName, value);
+        }
+    }
+
     /// <summary>
     /// Gets or sets the test group set during discovery.
     /// </summary>

test/IntegrationTests/MSTest.Acceptance.IntegrationTests/DataRowTests.cs

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.Acceptance.IntegrationTests;
+using Microsoft.Testing.Platform.Acceptance.IntegrationTests.Helpers;
+using Microsoft.Testing.Platform.Helpers;
+
+namespace MSTest.Acceptance.IntegrationTests;
+
+[TestGroup]
+public class DataRowTests : AcceptanceTestBase
+{
+    private const string SourceCode = """
+#file DataSourceTests.csproj
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>$TargetFramework$</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <OutputType>Exe</OutputType>
+        <LangVersion>preview</LangVersion>
+        <EnableMSTestRunner>true</EnableMSTestRunner>
+    </PropertyGroup>
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$MicrosoftNETTestSdkVersion$" />
+        <PackageReference Include="MSTest.TestAdapter" Version="$MSTestVersion$" />
+        <PackageReference Include="MSTest.TestFramework" Version="$MSTestVersion$" />
+    </ItemGroup>
+</Project>
+
+#file MyTestClass.cs
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+[TestClass]
+public class MyTestClass
+{
+    [DataTestMethod]
+    [DataRow((byte)0, new object[] { (byte)0 })]
+    [DataRow((short)0, new object[] { (short)0 })]
+    [DataRow((long)0, new object[] { (long)0 })]
+    public void CheckNestedInputTypes(object org, object nested)
+    {
+        Assert.AreEqual(org.GetType(), (((object[])nested)[0].GetType()));
+    }
+}
+""";
+
+    private readonly AcceptanceFixture _acceptanceFixture;
+
+    public DataRowTests(ITestExecutionContext testExecutionContext, AcceptanceFixture acceptanceFixture)
+        : base(testExecutionContext) => _acceptanceFixture = acceptanceFixture;
+
+    public async Task TestDataRowNumericalInArrayDoesNotLoseOriginalType()
+    {
+        using TestAsset generator = await TestAsset.GenerateAssetAsync(
+            "DataRowTests",
+            SourceCode
+            .PatchCodeWithReplace("$MSTestVersion$", MSTestVersion)
+            .PatchCodeWithReplace("$MicrosoftNETTestSdkVersion$", MicrosoftNETTestSdkVersion)
+            .PatchCodeWithReplace("$TargetFramework$", TargetFrameworks.NetCurrent.Arguments),
+            addPublicFeeds: true);
+
+        await DotnetCli.RunAsync(
+            $"build {generator.TargetAssetPath} -c Release",
+            _acceptanceFixture.NuGetGlobalPackagesFolder.Path,
+            retryCount: 0);
+
+        var testHost = TestHost.LocateFrom(generator.TargetAssetPath, "DataSourceTests", TargetFrameworks.NetCurrent.Arguments);
+
+        TestHostResult result = await testHost.ExecuteAsync();
+        result.AssertExitCodeIs(ExitCodes.Success);
+        result.AssertOutputContainsSummary(failed: 0, passed: 3, skipped: 0);
+    }
+}