Upgraded to .NET 10 (#1147)

app/Tests/Chat/ChatRestrictionsTests.cs

@@ -56,14 +56,14 @@ public sealed class ChatRestrictionsTests
 
         foreach (var combined in new[] { fromDataSource.StricterOf(fromMailbox), fromMailbox.StricterOf(fromDataSource) })
         {
-            Assert.Multiple(() =>
+            using (Assert.EnterMultipleScope())
             {
                 Assert.That(combined.ProviderConfidence, Is.EqualTo(ConfidenceLevel.HIGH));
                 Assert.That(combined.DataSecurity, Is.EqualTo(DataSourceSecurity.SELF_HOSTED), "Data for self-hosted providers only keeps them as the only choice, whichever side brings it.");
                 Assert.That(combined.OutboundData.Restriction, Is.EqualTo(OutboundDataRestriction.ONLY_CONFIGURED_SERVICES));
                 Assert.That(combined.OutboundData.Reference, Is.EqualTo(MAILBOX_ID), "The source which demands the strictest restriction is the one to name.");
                 Assert.That(combined.WebAddressesWrittenByModels, Is.EquivalentTo(new[] { RequestKey("https://example.org/report"), RequestKey("https://example.org/minutes") }), "What models wrote on either side never counts as given.");
-            });
+            }
         }
     }
 
@@ -72,11 +72,11 @@ public sealed class ChatRestrictionsTests
     {
         var restrictions = ChatRestrictions.NONE.WithWebAddressesWrittenByModelIn("The report is on https://EXAMPLE.org/report#summary, and the minutes are on http://10.20.30.40:8000/minutes/. Write to ftp://example.org/upload.");
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(restrictions.WebAddressesWrittenByModels, Is.EquivalentTo(new[] { RequestKey("https://example.org/report"), RequestKey("http://10.20.30.40:8000/minutes/") }), "Only addresses a web page could be read from count, compared as the server gets asked for them.");
             Assert.That(ChatRestrictions.NONE.WebAddressesWrittenByModels, Is.Empty, "Adding addresses leaves NONE as it is.");
-        });
+        }
     }
 
     [Test]
@@ -84,11 +84,11 @@ public sealed class ChatRestrictionsTests
     {
         var restrictions = new ChatRestrictions(ConfidenceLevel.MEDIUM, DataSourceSecurity.ALLOW_ANY, new(OutboundDataRestriction.ONLY_LINKS_FROM_CHAT, OutboundDataOrigin.DATA_SOURCE, DATA_SOURCE_ID), []).WithWebAddressesWrittenByModelIn("See https://example.org/report.");
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             AssertSame(restrictions.StricterOf(ChatRestrictions.NONE), restrictions);
             AssertSame(ChatRestrictions.NONE.StricterOf(restrictions), restrictions);
-        });
+        }
     }
 
     [Test]
@@ -131,11 +131,11 @@ public sealed class ChatRestrictionsTests
 
         chatToStart.RequireRestrictions(new(ConfidenceLevel.HIGH, DataSourceSecurity.SELF_HOSTED, new(OutboundDataRestriction.ONLY_CONFIGURED_SERVICES, OutboundDataOrigin.MAILBOX, MAILBOX_ID), []));
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             AssertSame(chatToStart.CaptureRestrictions(), new(ConfidenceLevel.HIGH, DataSourceSecurity.SELF_HOSTED, new(OutboundDataRestriction.ONLY_CONFIGURED_SERVICES, OutboundDataOrigin.MAILBOX, MAILBOX_ID), []));
             AssertSame(assistantThread.CaptureRestrictions(), ChatRestrictions.NONE);
-        });
+        }
     }
 
     [Test]
@@ -148,11 +148,11 @@ public sealed class ChatRestrictionsTests
         chat.RequireProviderConfidence(ConfidenceLevel.HIGH);
         chat.RequireDataSecurity(DataSourceSecurity.SELF_HOSTED);
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(snapshot.ProviderConfidence, Is.EqualTo(ConfidenceLevel.LOW), "Content which left the chat does not hold what the chat read afterward.");
             Assert.That(snapshot.DataSecurity, Is.EqualTo(DataSourceSecurity.NOT_SPECIFIED));
-        });
+        }
     }
 
     [Test]
@@ -162,12 +162,12 @@ public sealed class ChatRestrictionsTests
         var selfHostedProvider = this.AddProvider(SELF_HOSTED_PROVIDER_ID, LLMProviders.SELF_HOSTED, isSelfHosted: true);
         var restrictions = ChatRestrictions.NONE with { DataSecurity = DataSourceSecurity.SELF_HOSTED };
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(restrictions.IsLLMProviderAllowed(cloudProvider), Is.False);
             Assert.That(restrictions.IsLLMProviderAllowed(selfHostedProvider), Is.True);
             Assert.That(ChatRestrictions.NONE.IsLLMProviderAllowed(cloudProvider), Is.True, "Content which demands nothing may go to any provider.");
-        });
+        }
     }
 
     [Test]
@@ -178,11 +178,11 @@ public sealed class ChatRestrictionsTests
         var higherLevels = Enum.GetValues<ConfidenceLevel>().Where(candidate => candidate > level).ToList();
         Assume.That(higherLevels, Is.Not.Empty, "The provider has the highest level there is, so no content can demand more of it.");
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That((ChatRestrictions.NONE with { ProviderConfidence = level }).IsLLMProviderAllowed(provider), Is.True);
             Assert.That((ChatRestrictions.NONE with { ProviderConfidence = higherLevels.Min() }).IsLLMProviderAllowed(provider), Is.False);
-        });
+        }
     }
 
     [Test]
@@ -194,21 +194,24 @@ public sealed class ChatRestrictionsTests
         chat.RequireDataSecurity(DataSourceSecurity.SELF_HOSTED);
         ChatThread? newChat = null;
 
-        Assert.Multiple(() =>
+        using (Assert.EnterMultipleScope())
         {
             Assert.That(chat.IsLLMProviderAllowed(cloudProvider), Is.EqualTo(chat.CaptureRestrictions().IsLLMProviderAllowed(cloudProvider)));
             Assert.That(chat.IsLLMProviderAllowed(selfHostedProvider), Is.EqualTo(chat.CaptureRestrictions().IsLLMProviderAllowed(selfHostedProvider)));
             Assert.That(newChat.IsLLMProviderAllowed(cloudProvider), Is.True, "A new chat demands nothing yet.");
-        });
+        }
     }
 
-    private static void AssertSame(ChatRestrictions actual, ChatRestrictions expected) => Assert.Multiple(() =>
+    private static void AssertSame(ChatRestrictions actual, ChatRestrictions expected)
     {
-        Assert.That(actual.ProviderConfidence, Is.EqualTo(expected.ProviderConfidence));
-        Assert.That(actual.DataSecurity, Is.EqualTo(expected.DataSecurity));
-        Assert.That(actual.OutboundData, Is.EqualTo(expected.OutboundData));
-        Assert.That(actual.WebAddressesWrittenByModels, Is.EquivalentTo(expected.WebAddressesWrittenByModels));
-    });
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(actual.ProviderConfidence, Is.EqualTo(expected.ProviderConfidence));
+            Assert.That(actual.DataSecurity, Is.EqualTo(expected.DataSecurity));
+            Assert.That(actual.OutboundData, Is.EqualTo(expected.OutboundData));
+            Assert.That(actual.WebAddressesWrittenByModels, Is.EquivalentTo(expected.WebAddressesWrittenByModels));
+        }
+    }
 
     private static string RequestKey(string address) => WebAddresses.CreateRequestKey(new Uri(address));