Fix DataRow issues related to serialization/deserialization

src/Adapter/MSTest.TestAdapter/Constants.cs

@@ -65,6 +65,7 @@
     internal static readonly TestProperty CssProjectStructureProperty = TestProperty.Register("CssProjectStructure", CssProjectStructureLabel, typeof(string), TestPropertyAttributes.Hidden, typeof(TestCase));
 
     internal static readonly TestProperty TestClassNameProperty = TestProperty.Register("MSTestDiscoverer.TestClassName", TestClassNameLabel, typeof(string), TestPropertyAttributes.Hidden, typeof(TestCase));
+    internal static readonly TestProperty TestCaseIndexProperty = TestProperty.Register("TestCaseIndexProperty", TestCaseIndexLabel, typeof(int), TestPropertyAttributes.Hidden, typeof(TestCase))
 
     internal static readonly TestProperty DeclaringClassNameProperty = TestProperty.Register("MSTestDiscoverer.DeclaringClassName", DeclaringClassNameLabel, typeof(string), TestPropertyAttributes.Hidden, typeof(TestCase));
 
@@ -131,6 +132,7 @@
     /// These Property names should not be localized.
     /// </summary>
     private const string TestClassNameLabel = "ClassName";
+    private const string TestCaseIndexLabel = "TestCaseIndex";
     private const string DeclaringClassNameLabel = "DeclaringClassName";
     private const string IsAsyncLabel = "IsAsync";
     private const string TestCategoryLabel = "TestCategory";

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/Extensions/TestCaseExtensions.cs

@@ -76,9 +76,11 @@ internal static UnitTestElement ToUnitTestElement(this TestCase testCase, string
             Constants.TestIdGenerationStrategyProperty,
             (int)TestIdGenerationStrategy.FullyQualified);
 
+        int? testCaseIndex = testCase.GetPropertyValue(Constants.TestCaseIndexProperty) as int?;
+
         TestMethod testMethod = testCase.ContainsManagedMethodAndType()
-            ? new(testCase.GetManagedType(), testCase.GetManagedMethod(), testCase.GetHierarchy()!, name, testClassName!, source, isAsync, testCase.DisplayName, testIdGenerationStrategy)
-            : new(name, testClassName!, source, isAsync, testCase.DisplayName, testIdGenerationStrategy);
+            ? new(testCase.GetManagedType(), testCase.GetManagedMethod(), testCase.GetHierarchy()!, name, testClassName!, source, isAsync, testCase.DisplayName, testIdGenerationStrategy, testCaseIndex)
+            : new(name, testClassName!, source, isAsync, testCase.DisplayName, testIdGenerationStrategy, testCaseIndex);
         var dataType = (DynamicDataType)testCase.GetPropertyValue(Constants.TestDynamicDataTypeProperty, (int)DynamicDataType.None);
         if (dataType != DynamicDataType.None)
         {

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,20 +29,23 @@ public sealed class TestMethod : ITestMethod
     private string? _declaringClassFullName;
     private string? _declaringAssemblyName;
 
+    private static readonly ConcurrentDictionary<int, object?[]> DataDictionary = new();
+    private static int s_currentTestIndex;
+
     public TestMethod(string name, string fullClassName, string assemblyName, bool isAsync)
         : this(null, null, null, name, fullClassName, assemblyName, isAsync, null, TestIdGenerationStrategy.FullyQualified)
     {
     }
 
     internal TestMethod(string name, string fullClassName, string assemblyName, bool isAsync, string? displayName,
-        TestIdGenerationStrategy testIdGenerationStrategy)
-        : this(null, null, null, name, fullClassName, assemblyName, isAsync, displayName, testIdGenerationStrategy)
+        TestIdGenerationStrategy testIdGenerationStrategy, int? testCaseIndex = null)
+        : this(null, null, null, name, fullClassName, assemblyName, isAsync, displayName, testIdGenerationStrategy, testCaseIndex)
     {
     }
 
     internal TestMethod(string? managedTypeName, string? managedMethodName, string?[]? hierarchyValues, string name,
         string fullClassName, string assemblyName, bool isAsync, string? displayName,
-        TestIdGenerationStrategy testIdGenerationStrategy)
+        TestIdGenerationStrategy testIdGenerationStrategy, int? testCaseIndex = null)
     {
         Guard.NotNullOrWhiteSpace(assemblyName);
 
@@ -64,6 +68,7 @@ internal TestMethod(string? managedTypeName, string? managedMethodName, string?[
         ManagedTypeName = managedTypeName;
         ManagedMethodName = managedMethodName;
         TestIdGenerationStrategy = testIdGenerationStrategy;
+        Index = testCaseIndex ?? Interlocked.Increment(ref s_currentTestIndex);
     }
 
     /// <inheritdoc />
@@ -72,6 +77,8 @@ internal TestMethod(string? managedTypeName, string? managedMethodName, string?[
     /// <inheritdoc />
     public string FullClassName { get; }
 
+    internal int Index { get; }
+
     /// <summary>
     /// Gets or sets the declaring assembly full name. This will be used while getting navigation data.
     /// This will be null if AssemblyName is same as DeclaringAssemblyName.
@@ -137,6 +144,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(Index, out _actualData);
+            return _actualData;
+        }
+
+        set
+        {
+            _actualData = value;
+            DataDictionary.TryAdd(Index, value);
+        }
+    }
+
     /// <summary>
     /// Gets or sets the test group set during discovery.
     /// </summary>

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

@@ -140,6 +140,8 @@ internal TestCase ToTestCase()
             testCase.SetPropertyValue(Constants.TestClassNameProperty, TestMethod.FullClassName);
         }
 
+        testCase.SetPropertyValue(Constants.TestCaseIndexProperty, TestMethod.Index);
+
         IReadOnlyCollection<string?> hierarchy = TestMethod.Hierarchy;
         if (hierarchy is { Count: > 0 })
         {

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);
+    }
+}