fix(engine): tighten property injection guard

Share the already-populated check between source-generated and reflection paths, and only skip reference-type properties.

Remove the unrelated SDK roll-forward change from this PR.

TUnit.Engine.Tests/Issue5753Tests.cs

@@ -18,4 +18,18 @@ await RunTestsWithFilter(
                 result => result.ResultSummary.Counters.NotExecuted.ShouldBe(0)
             ]);
     }
+
+    [Test]
+    public async Task ValueTypePropertyInjection_DoesNotTreatDefaultValueAsAlreadyPopulated()
+    {
+        await RunTestsWithFilter(
+            "/*/*/Issue5753ValueTypePropertyInjectionTests/*",
+            [
+                result => result.ResultSummary.Outcome.ShouldBe("Completed"),
+                result => result.ResultSummary.Counters.Total.ShouldBe(1),
+                result => result.ResultSummary.Counters.Passed.ShouldBe(1),
+                result => result.ResultSummary.Counters.Failed.ShouldBe(0),
+                result => result.ResultSummary.Counters.NotExecuted.ShouldBe(0)
+            ]);
+    }
 }

TUnit.Engine/Services/PropertyInjector.cs

@@ -252,17 +252,10 @@ private async Task InjectSourceGeneratedPropertyAsync(
         ConcurrentDictionary<object, byte> visitedObjects,
         CancellationToken cancellationToken)
     {
-        // First check if the property already has a value - skip if it does
-        // This handles nested objects that were already constructed with their properties set
         var property = GetCachedPropertyInfo(metadata.ContainingType, metadata.PropertyName);
-        if (property != null && property.CanRead)
+        if (IsPropertyAlreadyPopulated(property, instance))
         {
-            var existingValue = property.GetValue(instance);
-            if (existingValue != null)
-            {
-                // Property already has a value, don't overwrite it
-                return;
-            }
+            return;
         }
 
         var testContext = TestContext.Current;
@@ -329,7 +322,7 @@ private async Task InjectReflectionPropertyAsync(
         ConcurrentDictionary<object, byte> visitedObjects,
         CancellationToken cancellationToken)
     {
-        if (property.CanRead && property.GetValue(instance) != null)
+        if (IsPropertyAlreadyPopulated(property, instance))
         {
             return;
         }
@@ -355,6 +348,16 @@ private async Task InjectReflectionPropertyAsync(
         propertySetter(instance, resolvedValue);
     }
 
+    private static bool IsPropertyAlreadyPopulated(PropertyInfo? property, object instance)
+    {
+        if (property is null || !property.CanRead || property.PropertyType.IsValueType)
+        {
+            return false;
+        }
+
+        return property.GetValue(instance) is not null;
+    }
+
     private Task RecurseIntoNestedPropertiesAsync(
         object instance,
         PropertyInjectionPlan plan,

TUnit.TestProject/Bugs/5753/Tests.cs

@@ -11,26 +11,39 @@ public class Issue5753ReflectionPropertyInjectionTests
     public async Task InjectedProperty_IsNotResolvedAgain_WhenAlreadySet(Issue5753Container container)
     {
         await Assert.That(container.Service).IsNotNull();
-        await Assert.That(container.Service.InstanceNumber).IsEqualTo(1);
-        await Assert.That(Issue5753InjectedService.InstancesCreated).IsEqualTo(1);
+        await Assert.That(container.Service).IsSameReferenceAs(container.ServiceCapturedDuringInitialization);
         await Assert.That(container.Service.IsInitialized).IsTrue();
     }
 }
 
-public class Issue5753Container
+public class Issue5753ValueTypePropertyInjectionTests
 {
-    [ClassDataSource<Issue5753InjectedService>]
-    public Issue5753InjectedService Service { get; set; } = null!;
+    [Issue5753IntDataSource]
+    public int Value { get; set; }
+
+    [Test]
+    public async Task ValueTypeProperty_IsInjected_WhenDefaultValueIsBoxed()
+    {
+        await Assert.That(Value).IsEqualTo(42);
+    }
 }
 
-public class Issue5753InjectedService : IAsyncInitializer
+public class Issue5753Container : IAsyncInitializer
 {
-    private static int _instancesCreated;
+    [ClassDataSource<Issue5753InjectedService>]
+    public Issue5753InjectedService Service { get; set; } = null!;
 
-    public static int InstancesCreated => Volatile.Read(ref _instancesCreated);
+    public Issue5753InjectedService? ServiceCapturedDuringInitialization { get; private set; }
 
-    public int InstanceNumber { get; } = Interlocked.Increment(ref _instancesCreated);
+    public Task InitializeAsync()
+    {
+        ServiceCapturedDuringInitialization = Service;
+        return Task.CompletedTask;
+    }
+}
 
+public class Issue5753InjectedService : IAsyncInitializer
+{
     public bool IsInitialized { get; private set; }
 
     public Task InitializeAsync()
@@ -39,3 +52,12 @@ public Task InitializeAsync()
         return Task.CompletedTask;
     }
 }
+
+public class Issue5753IntDataSourceAttribute : TypedDataSourceAttribute<int>
+{
+    public override async IAsyncEnumerable<Func<Task<int>>> GetTypedDataRowsAsync(DataGeneratorMetadata dataGeneratorMetadata)
+    {
+        yield return () => Task.FromResult(42);
+        await Task.CompletedTask;
+    }
+}

global.json

@@ -1,7 +1,7 @@
 {
   "sdk": {
     "version": "10.0.203",
-    "rollForward": "latestFeature",
+    "rollForward": "latestMajor",
     "allowPrerelease": true
   },
   "test": {