Fix test-hygiene issues in GeneratedFactoriesTests for #1461

Two tests were interacting with the process-global ReflectionCacheSet.Shared
in ways that are unsafe under xUnit's parallel test execution:

- FactoryDelegate_CompiledGeneratorCache_ClearedByReflectionCacheSetClear
  called ReflectionCacheSet.Shared.Clear(), wiping the entire process-wide
  reflection cache that all other parallel tests depend on. Replaced with a
  fresh new ReflectionCacheSet() instance: directly adds an entry to the
  GeneratedFactoryServiceRegistrationGenerators cache, asserts NotEmpty,
  calls set.Clear(), asserts Empty. Proves the cache participates in clearing
  without any global side effects.

- FactoryDelegate_CompiledGeneratorCached_SiblingScopes asserted .Count
  stability on the shared cache, which is perturbed by parallel test classes
  populating other entries. Replaced the count-equality assertion with an
  identity check: captures the cached delegate reference (TryGetValue) after
  scope1, then after scope2/scope3 asserts Assert.Same on the same key —
  proving no recompilation occurred for that specific key regardless of what
  other tests add to the global cache.

Also adds FactoryDelegate_CompiledGeneratorCache_ClearedByReflectionCacheSetPredicateClear,
a new test (also using a fresh set instance) that exercises the predicate-based
Clear(predicate) path, proving that the Type component of the composite key
drives assembly-unload selective eviction while unrelated keys are preserved.

Author: tillig

test/Autofac.Test/Features/GeneratedFactories/GeneratedFactoriesTests.cs

@@ -475,21 +475,23 @@ public void FactoryDelegate_CompiledGeneratorCached_SiblingScopes()
         using var scope1 = container.BeginLifetimeScope(c => c.RegisterType<FuncConsumer1461>());
         scope1.Resolve<FuncConsumer1461>();
 
-        // After the first resolve, the compiled generator must be present in the cache.
-        Assert.True(ReflectionCacheSet.Shared.Internal.GeneratedFactoryServiceRegistrationGenerators.ContainsKey(cacheKey));
+        // After the first resolve, the compiled generator must be present in the shared cache.
+        var cache = ReflectionCacheSet.Shared.Internal.GeneratedFactoryServiceRegistrationGenerators;
+        Assert.True(cache.ContainsKey(cacheKey));
 
-        var countAfterFirstScope = ReflectionCacheSet.Shared.Internal.GeneratedFactoryServiceRegistrationGenerators.Count;
+        // Capture the cached delegate instance — sibling scopes must reuse the same compiled entry.
+        Assert.True(cache.TryGetValue(cacheKey, out var cachedGeneratorAfterScope1));
 
         using var scope2 = container.BeginLifetimeScope(c => c.RegisterType<FuncConsumer1461>());
         scope2.Resolve<FuncConsumer1461>();
 
         using var scope3 = container.BeginLifetimeScope(c => c.RegisterType<FuncConsumer1461>());
         scope3.Resolve<FuncConsumer1461>();
 
-        // Resolving the same Func<T> from additional sibling scopes must not add new cache entries;
-        // the count must remain stable after the first scope warms the entry.
-        var countAfterAllScopes = ReflectionCacheSet.Shared.Internal.GeneratedFactoryServiceRegistrationGenerators.Count;
-        Assert.Equal(countAfterFirstScope, countAfterAllScopes);
+        // The cached delegate for this key must be the same object reference after sibling scope
+        // resolutions — proving no recompilation occurred for the already-cached key.
+        Assert.True(cache.TryGetValue(cacheKey, out var cachedGeneratorAfterAllScopes));
+        Assert.Same(cachedGeneratorAfterScope1, cachedGeneratorAfterAllScopes);
     }
 
     [Fact]
@@ -644,19 +646,42 @@ public void FactoryDelegate_CompiledGeneratorCache_ClearedByReflectionCacheSetCl
     {
         // #1461: The generated-factory caches must participate in ReflectionCacheSet.Clear()
         // so that types from collectible AssemblyLoadContexts can be fully unloaded.
-        var builder = new ContainerBuilder();
-        builder.RegisterType<Dependency1461>();
-        using var container = builder.Build();
+        // Uses a fresh ReflectionCacheSet instance to avoid mutating process-global shared state.
+        var set = new ReflectionCacheSet();
+
+        var cache = set.Internal.GeneratedFactoryServiceRegistrationGenerators;
+        var key = (typeof(Func<Dependency1461>), Autofac.Features.GeneratedFactories.ParameterMapping.ByType);
+        cache[key] = null!;
+
+        Assert.NotEmpty(cache);
 
-        using var scope = container.BeginLifetimeScope(c => c.RegisterType<FuncConsumer1461>());
-        scope.Resolve<FuncConsumer1461>();
+        set.Clear();
+
+        Assert.Empty(cache);
+    }
+
+    [Fact]
+    public void FactoryDelegate_CompiledGeneratorCache_ClearedByReflectionCacheSetPredicateClear()
+    {
+        // #1461: The generated-factory caches must also participate in predicate-based
+        // ReflectionCacheSet.Clear(predicate), which is the path taken when a collectible
+        // AssemblyLoadContext is unloaded — only types belonging to the unloaded assembly
+        // are removed, leaving unrelated entries intact.
+        // Uses a fresh ReflectionCacheSet instance to avoid mutating process-global shared state.
+        var set = new ReflectionCacheSet();
 
-        var serviceRegCache = ReflectionCacheSet.Shared.Internal.GeneratedFactoryServiceRegistrationGenerators;
+        var cache = set.Internal.GeneratedFactoryServiceRegistrationGenerators;
+        var matchedKey = (typeof(Dependency1461), Autofac.Features.GeneratedFactories.ParameterMapping.ByType);
+        var unmatchedKey = (typeof(FuncConsumer1461), Autofac.Features.GeneratedFactories.ParameterMapping.ByName);
+        cache[matchedKey] = null!;
+        cache[unmatchedKey] = null!;
 
-        Assert.NotEmpty(serviceRegCache);
+        Assert.Equal(2, cache.Count);
 
-        ReflectionCacheSet.Shared.Clear();
+        // Simulate assembly-unload predicate: only remove entries whose Type key is Dependency1461.
+        set.Clear((member, _) => member == typeof(Dependency1461));
 
-        Assert.Empty(serviceRegCache);
+        Assert.False(cache.ContainsKey(matchedKey));
+        Assert.True(cache.ContainsKey(unmatchedKey));
     }
 }