Refactor test Builder to use version-based contract resolution

TestPlaceholderTarget.Builder now defaults to CoreCLRContracts.Register and
supports AddContract<T>(version) for version-based resolution and
AddMockContract<T>(mock) for injecting test doubles. TestContractRegistry
supports Register, SetVersion, and SetMock with proper version lookup.

Migrated 5 Builder-pattern test files from factory lambdas to version-based
contract resolution.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: max-charlamb

src/native/managed/cdac/tests/AuxiliarySymbolsTests.cs

@@ -91,8 +91,8 @@ private static Target CreateTarget(
             .AddGlobals(
                 (Constants.Globals.AuxiliarySymbols, arrayAddress),
                 (Constants.Globals.AuxiliarySymbolCount, countFragment.Address))
-            .AddContract<IPlatformMetadata>(_ => Mock.Of<IPlatformMetadata>(p => p.GetCodePointerFlags() == default(CodePointerFlags)))
-            .AddContract<IAuxiliarySymbols>(static target => (IAuxiliarySymbols)new AuxiliarySymbols_1(target))
+            .AddMockContract<IPlatformMetadata>(Mock.Of<IPlatformMetadata>(p => p.GetCodePointerFlags() == default(CodePointerFlags)))
+            .AddContract<IAuxiliarySymbols>(version: 1)
             .Build();
     }
 

src/native/managed/cdac/tests/BuiltInCOMTests.cs

@@ -71,7 +71,6 @@ private static (string Name, ulong Value)[] CreateContractGlobals(MockBuiltInCom
             (Constants.Globals.RCWInterfaceCacheSize, MockRCW.InterfaceEntryCacheSize),
         ];
 
-
     [Theory]
     [ClassData(typeof(MockTarget.StdArch))]
     public void GetSimpleComCallWrapperData_ReturnsRefCountMasked(MockTarget.Architecture arch)

src/native/managed/cdac/tests/CodeVersionsTests.cs

@@ -158,12 +158,11 @@ internal Target CreateTarget(
             builder.Builder.GetMemoryContext().ReadFromTarget,
             CreateContractTypes(builder));
 
-        ContractRegistry reg = Mock.Of<ContractRegistry>(
-            c => c.CodeVersions == (ICodeVersions)new CodeVersions_1(target)
-                && c.RuntimeTypeSystem == mockRuntimeTypeSystem.Object
-                && c.ExecutionManager == mockExecutionManager.Object
-                && c.Loader == mockLoader.Object);
-        target.SetContracts(reg);
+        var registry = target.SetupContractRegistry();
+        registry.SetVersion<ICodeVersions>(1);
+        registry.SetMock(mockRuntimeTypeSystem.Object);
+        registry.SetMock(mockExecutionManager.Object);
+        registry.SetMock(mockLoader.Object);
         return target;
     }
 

src/native/managed/cdac/tests/DacStreamsTests.cs

@@ -43,8 +43,8 @@ private static unsafe void DacStreamsContractHelper(MockTarget.Architecture arch
         }
 
         var target = new TestPlaceholderTarget(arch, builder.GetMemoryContext().ReadFromTarget, DacStreamsTypes, DacStreamsGlobals);
-        target.SetContracts(Mock.Of<ContractRegistry>(
-            c => c.DacStreams == (IDacStreams)new DacStreams_1(target)));
+        var registry = target.SetupContractRegistry();
+        registry.SetVersion<IDacStreams>(1);
 
         testCase(target);
     }

src/native/managed/cdac/tests/DebuggerTests.cs

@@ -65,7 +65,7 @@ private static TestPlaceholderTarget BuildTarget(
             builder.AddGlobals((Constants.Globals.MetadataUpdatesApplied, metadataFrag.Address));
         }
 
-        builder.AddContract<IDebugger>(target => (IDebugger)new Debugger_1(target));
+        builder.AddContract<IDebugger>(version: 1);
 
         return builder.Build();
     }
@@ -82,7 +82,7 @@ private static TestPlaceholderTarget BuildNullDebuggerTarget(MockTarget.Architec
         helpers.WritePointer(debuggerPtrFrag.Data, 0);
         memBuilder.AddHeapFragment(debuggerPtrFrag);
         builder.AddGlobals((Constants.Globals.Debugger, debuggerPtrFrag.Address));
-        builder.AddContract<IDebugger>(target => (IDebugger)new Debugger_1(target));
+        builder.AddContract<IDebugger>(version: 1);
 
         return builder.Build();
     }

src/native/managed/cdac/tests/ExecutionManager/ExecutionManagerTests.cs

@@ -44,11 +44,9 @@ private static Target CreateTarget(MockExecutionManagerBuilder emBuilder)
         var arch = emBuilder.Builder.TargetTestHelpers.Arch;
         TestPlaceholderTarget.ReadFromTargetDelegate reader = emBuilder.Builder.GetMemoryContext().ReadFromTarget;
         var target = new TestPlaceholderTarget(arch, reader, CreateContractTypes(emBuilder), emBuilder.Globals);
-        IExecutionManager emContract = CreateExecutionManager(target, emBuilder.Version);
-        ContractRegistry reg = Mock.Of<ContractRegistry>(
-            c => c.ExecutionManager == emContract
-                && c.PlatformMetadata == new Mock<IPlatformMetadata>().Object);
-        target.SetContracts(reg);
+        var registry = target.SetupContractRegistry();
+        registry.SetVersion<IExecutionManager>(emBuilder.Version);
+        registry.SetMock(Mock.Of<IPlatformMetadata>());
         return target;
     }
 
@@ -80,16 +78,6 @@ private static void LinkHeapIntoAllCodeHeaps(MockExecutionManagerBuilder emBuild
         emBuilder.SetAllCodeHeaps(node.Address);
     }
 
-    private static IExecutionManager CreateExecutionManager(Target target, int version)
-    {
-        return version switch
-        {
-            1 => new ExecutionManager_1(target),
-            2 => new ExecutionManager_2(target),
-            _ => throw new NotImplementedException(),
-        };
-    }
-
     [Theory]
     [MemberData(nameof(StdArchAllVersions))]
     public void GetCodeBlockHandle_Null(int version, MockTarget.Architecture arch)

src/native/managed/cdac/tests/GCMemoryRegionTests.cs

@@ -26,15 +26,9 @@ private static IGC CreateGCContract(MockTarget.Architecture arch,
         TestPlaceholderTarget.ReadFromTargetDelegate readFromTarget)
     {
         var target = new TestPlaceholderTarget(arch, readFromTarget, types, globals, globalStrings);
-        var gcContract = CreateGC(target);
-        target.SetContracts(Mock.Of<ContractRegistry>(
-            c => c.GC == gcContract));
-        return gcContract;
-    }
-
-    private static IGC CreateGC(Target target)
-    {
-        return new GC_1(target);
+        var registry = target.SetupContractRegistry();
+        registry.SetVersion<IGC>(1);
+        return target.Contracts.GC;
     }
 
     private static (string Name, ulong Value)[] BuildGlobals(

src/native/managed/cdac/tests/GCTests.cs

@@ -142,8 +142,7 @@ public static TestPlaceholderTarget.Builder AddGCHeapWks(
         GCHeapBuilder config = new();
         configure(config);
         BuildWksHeap(targetBuilder, config);
-        targetBuilder.AddContract<IGC>(static target =>
-            (IGC)new GC_1(target));
+        targetBuilder.AddContract<IGC>(version: 1);
         return targetBuilder;
     }
 
@@ -155,8 +154,7 @@ public static TestPlaceholderTarget.Builder AddGCHeapSvr(
         GCHeapBuilder config = new();
         configure(config);
         heapAddress = BuildSvrHeap(targetBuilder, config);
-        targetBuilder.AddContract<IGC>(static target =>
-            (IGC)new GC_1(target));
+        targetBuilder.AddContract<IGC>(version: 1);
         return targetBuilder;
     }
 

src/native/managed/cdac/tests/ReJITTests.cs

@@ -40,8 +40,8 @@ private static ReJITContractContext CreateReJITContract(
         TestPlaceholderTarget target = targetBuilder
             .AddTypes(CreateContractTypes(rejitBuilder))
             .AddGlobals((nameof(Constants.Globals.ProfilerControlBlock), rejitBuilder.ProfilerControlBlockGlobalAddress))
-            .AddContract<IReJIT>(static target => (IReJIT)new ReJIT_1(target))
-            .AddContract<ICodeVersions>(_ => mockCodeVersions.Object)
+            .AddContract<IReJIT>(version: 1)
+            .AddMockContract<ICodeVersions>(mockCodeVersions.Object)
             .Build();
         return new ReJITContractContext(target.Contracts.ReJIT, target);
     }

src/native/managed/cdac/tests/TestPlaceholderTarget.cs

@@ -45,6 +45,21 @@ internal void SetContracts(ContractRegistry contracts)
         _contractRegistry = contracts;
     }
 
+    /// <summary>
+    /// Creates a <see cref="TestContractRegistry"/> with <see cref="CoreCLRContracts.Register"/>
+    /// applied, and sets it as the contract registry for this target. Returns the registry so
+    /// callers can call <see cref="TestContractRegistry.SetVersion{TContract}"/> and
+    /// <see cref="TestContractRegistry.SetMock{TContract}"/>.
+    /// </summary>
+    internal TestContractRegistry SetupContractRegistry(Action<ContractRegistry>? registrations = null)
+    {
+        var registry = new TestContractRegistry();
+        registry.SetTarget(this);
+        (registrations ?? CoreCLRContracts.Register)(registry);
+        _contractRegistry = registry;
+        return registry;
+    }
+
     /// <summary>
     /// Fluent builder for <see cref="TestPlaceholderTarget"/>. Accumulates types,
     /// globals, and contract factories from mock descriptors, then materializes the
@@ -57,7 +72,8 @@ internal class Builder
         private readonly Dictionary<DataType, Target.TypeInfo> _types = new();
         private readonly List<(string Name, ulong Value)> _globals = new();
         private readonly List<(string Name, string Value)> _globalStrings = new();
-        private readonly List<(Type Type, Func<Target, IContract> Factory)> _contractFactories = new();
+        private readonly List<Action<TestContractRegistry>> _contractSetups = new();
+        private Action<ContractRegistry> _registrations = CoreCLRContracts.Register;
 
         public Builder(MockTarget.Architecture arch)
         {
@@ -86,9 +102,21 @@ public Builder AddGlobalStrings(params (string Name, string Value)[] globalStrin
             return this;
         }
 
-        public Builder AddContract<TContract>(Func<Target, TContract> factory) where TContract : IContract
+        public Builder UseRegistrations(Action<ContractRegistry> registrations)
         {
-            _contractFactories.Add((typeof(TContract), target => factory(target)));
+            _registrations = registrations;
+            return this;
+        }
+
+        public Builder AddContract<TContract>(int version) where TContract : IContract
+        {
+            _contractSetups.Add(registry => registry.SetVersion<TContract>(version));
+            return this;
+        }
+
+        public Builder AddMockContract<TContract>(TContract mock) where TContract : IContract
+        {
+            _contractSetups.Add(registry => registry.SetMock(mock));
             return this;
         }
 
@@ -102,8 +130,12 @@ public TestPlaceholderTarget Build()
                 _globalStrings.ToArray());
 
             var registry = new TestContractRegistry();
-            foreach (var (type, factory) in _contractFactories)
-                registry.Add(type, new Lazy<IContract>(() => factory(target)));
+            registry.SetTarget(target);
+            _registrations(registry);
+
+            foreach (var setup in _contractSetups)
+                setup(registry);
+
             target.SetContracts(registry);
 
             return target;
@@ -455,22 +487,50 @@ public void Clear()
         }
     }
 
-    private sealed class TestContractRegistry : ContractRegistry
+    internal sealed class TestContractRegistry : ContractRegistry
     {
-        private readonly Dictionary<Type, Lazy<IContract>> _contracts = new();
+        private readonly Dictionary<(Type, int), Func<Target, IContract>> _creators = new();
+        private readonly Dictionary<Type, int> _versions = new();
+        private readonly Dictionary<Type, IContract> _mocks = new();
+        private readonly Dictionary<Type, IContract> _resolved = new();
+        private Target _target;
 
-        public void Add(Type type, Lazy<IContract> contract) => _contracts[type] = contract;
+        public void SetTarget(Target target) => _target = target;
+
+        public void SetVersion<TContract>(int version) where TContract : IContract
+            => _versions[typeof(TContract)] = version;
+
+        public void SetMock<TContract>(TContract mock) where TContract : IContract
+            => _mocks[typeof(TContract)] = mock;
+
+        public override void Register<TContract>(int version, Func<Target, TContract> creator)
+            => _creators[(typeof(TContract), version)] = t => creator(t);
 
         public override TContract GetContract<TContract>()
         {
-            if (_contracts.TryGetValue(typeof(TContract), out var lazy))
-                return (TContract)lazy.Value;
+            if (_resolved.TryGetValue(typeof(TContract), out var cached))
+                return (TContract)cached;
 
-            throw new NotImplementedException($"Contract {typeof(TContract).Name} is not registered.");
-        }
+            IContract contract;
+            if (_mocks.TryGetValue(typeof(TContract), out var mock))
+            {
+                contract = mock;
+            }
+            else if (_versions.TryGetValue(typeof(TContract), out int version))
+            {
+                if (!_creators.TryGetValue((typeof(TContract), version), out var creator))
+                    throw new NotImplementedException($"No implementation registered for contract '{typeof(TContract).Name}' version {version}.");
 
-        public override void Register<TContract>(int version, Func<Target, TContract> creator)
-            => throw new NotSupportedException("TestContractRegistry does not support dynamic registration. Use SetContracts to configure contracts for testing.");
+                contract = creator(_target);
+            }
+            else
+            {
+                throw new NotImplementedException($"Contract {typeof(TContract).Name} is not registered. Use AddContract<T>(version) or AddMockContract<T>(mock) on the Builder.");
+            }
+
+            _resolved[typeof(TContract)] = contract;
+            return (TContract)contract;
+        }
 
         public override void Flush() { }
     }