Upgraded to .NET 10 (#1147)

app/Tests/Models/Matching/MatchPatternTests.cs

@@ -21,11 +21,11 @@ public sealed class MatchPatternTests
         var onAlibaba = new MatchPattern { Kind = MatchKind.SEGMENT, Text = "qwq", OnlyOn = LLMProviders.ALIBABA_CLOUD };
         var name = new ModelId("qwq-32b");
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(onAlibaba.Matches(name, LLMProviders.ALIBABA_CLOUD, ModelVendor.UNKNOWN), Is.True);
             Assert.That(onAlibaba.Matches(name, LLMProviders.SELF_HOSTED, ModelVendor.UNKNOWN), Is.False);
-        });
+        }
     }
 
     [Test]
@@ -34,11 +34,11 @@ public sealed class MatchPatternTests
         var fromAnthropic = new MatchPattern { Kind = MatchKind.SEGMENT, Text = "claude", OnlyFrom = ModelVendor.ANTHROPIC };
         var name = new ModelId("claude-sonnet-4-0");
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(fromAnthropic.Matches(name, LLMProviders.LITE_LLM, ModelVendor.ANTHROPIC), Is.True);
             Assert.That(fromAnthropic.Matches(name, LLMProviders.LITE_LLM, ModelVendor.UNKNOWN), Is.False);
-        });
+        }
     }
 
     [Test]
@@ -46,12 +46,12 @@ public sealed class MatchPatternTests
     {
         var withVision = new MatchPattern { Kind = MatchKind.SEGMENT, Text = "qwen3.8", AlsoContains = ["vl"] };
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(withVision.Matches(new ModelId("qwen3.8-27b-vl"), LLMProviders.SELF_HOSTED, ModelVendor.UNKNOWN), Is.True);
             Assert.That(withVision.Matches(new ModelId("qwen3.8-27b"), LLMProviders.SELF_HOSTED, ModelVendor.UNKNOWN), Is.False);
             Assert.That(withVision.Matches(new ModelId("qwen3.8-27b-vllm"), LLMProviders.SELF_HOSTED, ModelVendor.UNKNOWN), Is.False, "\"vl\" inside another name part is not the vision variant.");
-        });
+        }
     }
 
     [Test]
@@ -62,11 +62,11 @@ public sealed class MatchPatternTests
         //
         var withoutTools = new MatchPattern { Kind = MatchKind.SEGMENT, Text = "salamandra", NotContains = ["tools"] };
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(withoutTools.Matches(new ModelId("salamandra-7b-instruct"), LLMProviders.SELF_HOSTED, ModelVendor.UNKNOWN), Is.True);
             Assert.That(withoutTools.Matches(new ModelId("salamandra-7b-instruct-tools"), LLMProviders.SELF_HOSTED, ModelVendor.UNKNOWN), Is.False);
-        });
+        }
     }
 
     [TestCase("gpt-5.1", true)]

app/Tests/Models/Matching/ModelFamilyIndexTests.cs

@@ -29,11 +29,11 @@ public sealed class ModelFamilyIndexTests
         var distill = Selector("deepseek-r1", MatchKind.SEGMENT, new() { Adds = Capability.TEXT_INPUT | Capability.FUNCTION_CALLING, Reasoning = ReasoningSupport.ALWAYS });
         var name = new ModelId("deepseek-r1-distill-llama-70b");
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(ModelFamilyIndex.Build([llama, distill]).Explain(name, ANY_PROVIDER, ModelVendor.UNKNOWN).Selector, Is.SameAs(distill));
             Assert.That(ModelFamilyIndex.Build([distill, llama]).Explain(name, ANY_PROVIDER, ModelVendor.UNKNOWN).Selector, Is.SameAs(distill), "The order the rules arrive in must not change the answer.");
-        });
+        }
     }
 
     [Test]
@@ -47,11 +47,11 @@ public sealed class ModelFamilyIndexTests
         var chat = Selector("gpt-5-chat", MatchKind.PREFIX, new() { Adds = Capability.TEXT_INPUT, Reasoning = ReasoningSupport.NONE });
         var index = ModelFamilyIndex.Build([reasoning, chat]);
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(index.Resolve(new ModelId("gpt-5-chat-latest"), ANY_PROVIDER, ModelVendor.UNKNOWN).Reasoning, Is.EqualTo(ReasoningSupport.NONE));
             Assert.That(index.Resolve(new ModelId("gpt-5-pro"), ANY_PROVIDER, ModelVendor.UNKNOWN).Reasoning, Is.EqualTo(ReasoningSupport.ALWAYS));
-        });
+        }
     }
 
     [Test]
@@ -79,11 +79,11 @@ public sealed class ModelFamilyIndexTests
         var index = ModelFamilyIndex.Build([openWeights, commercial]);
         var name = new ModelId("qwq-32b");
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(index.Explain(name, LLMProviders.ALIBABA_CLOUD, ModelVendor.UNKNOWN).Selector, Is.SameAs(commercial));
             Assert.That(index.Explain(name, LLMProviders.SELF_HOSTED, ModelVendor.UNKNOWN).Selector, Is.SameAs(openWeights));
-        });
+        }
     }
 
     [Test]
@@ -98,11 +98,11 @@ public sealed class ModelFamilyIndexTests
         var baseCheckpoint = Modifier("base", MatchKind.SEGMENT, new() { Removes = Capability.FUNCTION_CALLING });
         var index = ModelFamilyIndex.Build([family, baseCheckpoint]);
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(index.Resolve(new ModelId("llama-3.3-70b"), ANY_PROVIDER, ModelVendor.UNKNOWN).Has(Capability.FUNCTION_CALLING), Is.True);
             Assert.That(index.Resolve(new ModelId("llama-3.3-70b-base"), ANY_PROVIDER, ModelVendor.UNKNOWN).Has(Capability.FUNCTION_CALLING), Is.False);
-        });
+        }
     }
 
     [Test]
@@ -113,11 +113,11 @@ public sealed class ModelFamilyIndexTests
         var narrow = Modifier("instruct-nano", MatchKind.SEGMENT, new() { Removes = Capability.FUNCTION_CALLING });
         var resolution = ModelFamilyIndex.Build([narrow, broad, family]).Explain(new ModelId("llama-3.3-instruct-nano"), ANY_PROVIDER, ModelVendor.UNKNOWN);
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(resolution.Modifiers.Select(modifier => modifier.Pattern.Text), Is.EqualTo(new[] { "instruct", "instruct-nano" }));
             Assert.That(resolution.Profile.Has(Capability.FUNCTION_CALLING), Is.False);
-        });
+        }
     }
 
     [Test]
@@ -154,12 +154,12 @@ public sealed class ModelFamilyIndexTests
         var oneWay = ModelFamilyIndex.Build([one, other]).Explain(name, ANY_PROVIDER, ModelVendor.UNKNOWN);
         var otherWay = ModelFamilyIndex.Build([other, one]).Explain(name, ANY_PROVIDER, ModelVendor.UNKNOWN);
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(oneWay.IsAmbiguous, Is.True);
             Assert.That(otherWay.IsAmbiguous, Is.True);
             Assert.That(oneWay.Selector, Is.SameAs(otherWay.Selector), "Which of the two answers must not depend on the order they arrived in.");
-        });
+        }
     }
 
     [Test]
@@ -190,11 +190,11 @@ public sealed class ModelFamilyIndexTests
         var index = ModelFamilyIndex.Build([Selector("llama", MatchKind.SEGMENT, new() { Adds = Capability.TEXT_INPUT })]);
         var resolution = index.Explain(new ModelId("something-nobody-wrote-a-rule-for"), ANY_PROVIDER, ModelVendor.UNKNOWN);
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(resolution.IsKnown, Is.False);
             Assert.That(resolution.Profile, Is.EqualTo(ModelProfile.UNKNOWN));
-        });
+        }
     }
 
     [Test]
@@ -227,11 +227,11 @@ public sealed class ModelFamilyIndexTests
         //
         var index = ModelFamilyIndex.Build([Selector("GPT-5", MatchKind.PREFIX, new() { Adds = Capability.TEXT_INPUT })]);
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(index.Rules.Where(rule => !rule.Pattern.IsWellFormed), Is.Not.Empty);
             Assert.That(index.Explain(new ModelId("gpt-5.1"), ANY_PROVIDER, ModelVendor.UNKNOWN).IsKnown, Is.False);
-        });
+        }
     }
 
     private static ModelRule Selector(string text, MatchKind kind, ModelProfileChange change, string origin = "test") => new(new() { Kind = kind, Text = text }, ModelRuleKind.SELECTOR, change, origin);

app/Tests/Models/Matching/ModelIdTests.cs

@@ -30,11 +30,11 @@ public sealed class ModelIdTests
     {
         var id = new ModelId(reported);
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(id.IsEmpty, Is.True);
             Assert.That(id.Normalized, Is.Empty);
-        });
+        }
     }
 
     [Test]
@@ -42,11 +42,11 @@ public sealed class ModelIdTests
     {
         var id = new ModelId("Qwen3.8:27B-MLX");
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(id.Original, Is.EqualTo("Qwen3.8:27B-MLX"));
             Assert.That(id.ToString(), Is.EqualTo("Qwen3.8:27B-MLX"));
-        });
+        }
     }
 
     [Test]
@@ -54,13 +54,13 @@ public sealed class ModelIdTests
     {
         ModelId untouched = default;
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(untouched.IsEmpty, Is.True);
             Assert.That(untouched.Original, Is.Empty);
             Assert.That(untouched.Normalized, Is.Empty);
             Assert.That(untouched.Segments.GetEnumerator().MoveNext(), Is.False);
-        });
+        }
     }
 
     [Test]
@@ -69,11 +69,11 @@ public sealed class ModelIdTests
         var fromOllama = new ModelId("Qwen3.8:27b");
         var fromHub = new ModelId("qwen3.8-27b");
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(fromOllama, Is.EqualTo(fromHub));
             Assert.That(fromOllama.GetHashCode(), Is.EqualTo(fromHub.GetHashCode()));
-        });
+        }
     }
 
     [Test]

app/Tests/Models/Matching/RuleSpecificityTests.cs

@@ -82,10 +82,10 @@ public sealed class RuleSpecificityTests
         var winner = RuleSpecificity.Of(expectedWinner);
         var loser = RuleSpecificity.Of(expectedLoser);
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(winner.CompareTo(loser), Is.GreaterThan(0));
             Assert.That(loser.CompareTo(winner), Is.LessThan(0), "The comparison has to say the same thing in both directions.");
-        });
+        }
     }
 }