Merge pull request #1220 from AArnott/libtemplateUpdate

AArnott · web-flow · commit fcfe71f8c8e0 · 2023-07-17T12:40:51.000-06:00
Merge latest Library.Template
diff --git a/Directory.Packages.props b/Directory.Packages.props
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
     <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
-    <MicroBuildVersion>2.0.130</MicroBuildVersion>
+    <MicroBuildVersion>2.0.131</MicroBuildVersion>
     <CodeAnalysisVersion>3.11.0</CodeAnalysisVersion>
     <CodeAnalysisVersion Condition="'$(IsTestProject)'=='true'">4.4.0</CodeAnalysisVersion>
     <CodefixTestingVersion>1.1.1</CodefixTestingVersion>
@@ -36,10 +36,10 @@
     <PackageVersion Include="System.Threading.Tasks.Dataflow" Version="7.0.0" />
     <PackageVersion Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
     <PackageVersion Include="System.ValueTuple" Version="4.5.0" />
-    <PackageVersion Include="xunit" Version="2.4.2" />
+    <PackageVersion Include="xunit" Version="2.5.0" />
     <PackageVersion Include="xunit.abstractions" Version="2.0.3" />
     <PackageVersion Include="Xunit.Combinatorial" Version="1.5.25" />
-    <PackageVersion Include="xunit.runner.visualstudio" Version="2.4.5" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="2.5.0" />
     <PackageVersion Include="Xunit.SkippableFact" Version="1.4.13" />
     <PackageVersion Include="Xunit.StaFact" Version="1.1.11" />
   </ItemGroup>
diff --git a/azure-pipelines/build.yml b/azure-pipelines/build.yml
@@ -33,7 +33,7 @@ jobs:
 
   - template: install-dependencies.yml
 
-  - script: dotnet tool run nbgv cloud -ca
+  - script: dotnet nbgv cloud -ca
     displayName: ⚙ Set build number
 
   - ${{ if eq(variables['system.collectionId'], '011b8bdf-6d56-4f87-be0d-0092136884d9') }}:
diff --git a/test/IsolatedTestHost/App.config b/test/IsolatedTestHost/App.config
@@ -10,13 +10,13 @@
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <dependentAssembly>
         <assemblyIdentity name="xunit.core" publicKeyToken="8d05b1bb7a6fdb6c" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-2.4.2.0" newVersion="2.4.2.0" />
+        <bindingRedirect oldVersion="0.0.0.0-2.5.0.0" newVersion="2.5.0.0" />
       </dependentAssembly>
     </assemblyBinding>
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <dependentAssembly>
         <assemblyIdentity name="xunit.execution.desktop" publicKeyToken="8d05b1bb7a6fdb6c" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-2.4.2.0" newVersion="2.4.2.0" />
+        <bindingRedirect oldVersion="0.0.0.0-2.5.0.0" newVersion="2.5.0.0" />
       </dependentAssembly>
     </assemblyBinding>
   </runtime>
diff --git a/test/Microsoft.VisualStudio.Threading.Tests/AssertEx.cs b/test/Microsoft.VisualStudio.Threading.Tests/AssertEx.cs
@@ -10,31 +10,31 @@ public static void Equal<T>(T expected, T actual, string message)
     {
         if (!EqualityComparer<T>.Default.Equals(expected, actual))
         {
-            throw new Xunit.Sdk.AssertActualExpectedException(expected, actual, message);
+            throw Xunit.Sdk.EqualException.ForMismatchedValues(expected, actual, message);
         }
     }
 
     public static void Equal<T>(T expected, T actual, string formattingMessage, params object[] formattingArgs)
     {
         if (!EqualityComparer<T>.Default.Equals(expected, actual))
         {
-            throw new Xunit.Sdk.AssertActualExpectedException(expected, actual, string.Format(CultureInfo.CurrentCulture, formattingMessage, formattingArgs));
+            throw Xunit.Sdk.EqualException.ForMismatchedValues(expected, actual, string.Format(CultureInfo.CurrentCulture, formattingMessage, formattingArgs));
         }
     }
 
     public static void NotEqual<T>(T expected, T actual, string message)
     {
         if (EqualityComparer<T>.Default.Equals(expected, actual))
         {
-            throw new Xunit.Sdk.AssertActualExpectedException(expected, actual, message);
+            throw Xunit.Sdk.NotEqualException.ForEqualValues(expected?.ToString() ?? "<null>", actual?.ToString() ?? "<null>", message);
         }
     }
 
     public static void NotEqual<T>(T expected, T actual, string formattingMessage, params object[] formattingArgs)
     {
         if (EqualityComparer<T>.Default.Equals(expected, actual))
         {
-            throw new Xunit.Sdk.AssertActualExpectedException(expected, actual, string.Format(CultureInfo.CurrentCulture, formattingMessage, formattingArgs));
+            throw Xunit.Sdk.NotEqualException.ForEqualValues(expected?.ToString() ?? "<null>", actual?.ToString() ?? "<null>", string.Format(CultureInfo.CurrentCulture, formattingMessage, formattingArgs));
         }
     }
 }
diff --git a/test/Microsoft.VisualStudio.Threading.Tests/AsyncAutoResetEventTests.cs b/test/Microsoft.VisualStudio.Threading.Tests/AsyncAutoResetEventTests.cs
@@ -121,7 +121,7 @@ public void WaitAsync_WithCancellationToken_DoesNotClaimSignal()
         try
         {
             waitTask.GetAwaiter().GetResult();
-            Assert.True(false, "Task was expected to transition to a canceled state.");
+            Assert.Fail("Task was expected to transition to a canceled state.");
         }
         catch (OperationCanceledException ex)
         {
@@ -148,7 +148,7 @@ public void WaitAsync_WithCancellationToken_PrecanceledDoesNotClaimExistingSigna
         try
         {
             this.evt.WaitAsync(token).GetAwaiter().GetResult();
-            Assert.True(false, "Task was expected to transition to a canceled state.");
+            Assert.Fail("Task was expected to transition to a canceled state.");
         }
         catch (OperationCanceledException ex)
         {
diff --git a/test/Microsoft.VisualStudio.Threading.Tests/AsyncReaderWriterLockTests.cs b/test/Microsoft.VisualStudio.Threading.Tests/AsyncReaderWriterLockTests.cs
@@ -2652,7 +2652,7 @@ await Task.Run(delegate
             try
             {
                 awaiter.GetResult();
-                Assert.True(false, "Expected OperationCanceledException not thrown.");
+                Assert.Fail("Expected OperationCanceledException not thrown.");
             }
             catch (OperationCanceledException)
             {
@@ -2670,7 +2670,7 @@ public void PrecancelledWriteLockAsyncRequestOnSTA()
         try
         {
             awaiter.GetResult();
-            Assert.True(false, "Expected OperationCanceledException not thrown.");
+            Assert.Fail("Expected OperationCanceledException not thrown.");
         }
         catch (OperationCanceledException)
         {
@@ -2702,7 +2702,7 @@ await Task.WhenAll(
                     try
                     {
                         awaiter.GetResult();
-                        cancellationTestConcluded.SetException(new ThrowsException(typeof(OperationCanceledException)));
+                        cancellationTestConcluded.SetException(ThrowsException.ForNoException(typeof(OperationCanceledException)));
                     }
                     catch (OperationCanceledException)
                     {
@@ -2740,7 +2740,7 @@ await Task.WhenAll(
                     try
                     {
                         awaiter.GetResult();
-                        cancellationTestConcluded.SetException(new ThrowsException(typeof(OperationCanceledException)));
+                        cancellationTestConcluded.SetException(ThrowsException.ForNoException(typeof(OperationCanceledException)));
                     }
                     catch (OperationCanceledException)
                     {
@@ -3026,7 +3026,7 @@ public void CompleteBlocksNewTopLevelLocksSTA()
         try
         {
             awaiter.GetResult();
-            Assert.True(false, "Expected exception not thrown.");
+            Assert.Fail("Expected exception not thrown.");
         }
         catch (InvalidOperationException)
         {
@@ -3047,7 +3047,7 @@ await Task.Run(delegate
             try
             {
                 awaiter.GetResult();
-                Assert.True(false, "Expected exception not thrown.");
+                Assert.Fail("Expected exception not thrown.");
             }
             catch (InvalidOperationException)
             {
@@ -3448,7 +3448,7 @@ public async Task OnBeforeWriteLockReleasedDelegateThrows()
                 this.asyncLock.Complete();
             }
 
-            Assert.True(false, "Expected exception not thrown.");
+            Assert.Fail("Expected exception not thrown.");
         }
         catch (AggregateException ex)
         {
@@ -4184,7 +4184,7 @@ public async Task WriteNestsReadWithWriteReleasedFirstWithoutTaskRun()
             try
             {
                 await completingTask; // observe any exception.
-                Assert.True(false, "Expected exception not thrown.");
+                Assert.Fail("Expected exception not thrown.");
             }
             catch (CriticalErrorException ex)
             {
@@ -4993,7 +4993,7 @@ private async Task MitigationAgainstAccidentalLockForkingHelper(Func<AsyncReader
                 bool dummy = this.asyncLock.IsReadLockHeld;
                 if (!successExpected)
                 {
-                    Assert.True(false, "Expected exception not thrown.");
+                    Assert.Fail("Expected exception not thrown.");
                 }
             }
             catch (Exception ex)
@@ -5009,7 +5009,7 @@ private async Task MitigationAgainstAccidentalLockForkingHelper(Func<AsyncReader
                 bool dummy = this.asyncLock.IsUpgradeableReadLockHeld;
                 if (!successExpected)
                 {
-                    Assert.True(false, "Expected exception not thrown.");
+                    Assert.Fail("Expected exception not thrown.");
                 }
             }
             catch (Exception ex)
@@ -5025,7 +5025,7 @@ private async Task MitigationAgainstAccidentalLockForkingHelper(Func<AsyncReader
                 bool dummy = this.asyncLock.IsWriteLockHeld;
                 if (!successExpected)
                 {
-                    Assert.True(false, "Expected exception not thrown.");
+                    Assert.Fail("Expected exception not thrown.");
                 }
             }
             catch (Exception ex)
@@ -5045,7 +5045,7 @@ private async Task MitigationAgainstAccidentalLockForkingHelper(Func<AsyncReader
             try
             {
                 releaser = await locker();
-                Assert.True(false, "Expected exception not thrown.");
+                Assert.Fail("Expected exception not thrown.");
             }
             catch (Exception ex)
             {
diff --git a/test/Microsoft.VisualStudio.Threading.Tests/AsyncReaderWriterResourceLockTests.cs b/test/Microsoft.VisualStudio.Threading.Tests/AsyncReaderWriterResourceLockTests.cs
@@ -310,7 +310,7 @@ public async Task PreparationSucceedsForConcurrentReadersWhenOneCancels()
                 try
                 {
                     await resourceTask;
-                    Assert.True(false, "Expected OperationCanceledException not thrown.");
+                    Assert.Fail("Expected OperationCanceledException not thrown.");
                 }
                 catch (OperationCanceledException)
                 {
@@ -461,7 +461,7 @@ public async Task PreparationIsAppliedToResourceImpactedByOutsideChangePredicate
                 (resource, s) =>
                 {
                     Assert.Same(state, s);
-                    Assert.True(false, "Read locks should not invoke this.");
+                    Assert.Fail("Read locks should not invoke this.");
                     return false;
                 },
                 state);
@@ -1216,7 +1216,7 @@ public async Task GetResourceAsyncRetriesFaultedPreparation()
             try
             {
                 await access.GetResourceAsync(1);
-                Assert.True(false, "Expected exception not thrown.");
+                Assert.Fail("Expected exception not thrown.");
             }
             catch (ApplicationException)
             {
@@ -1242,7 +1242,7 @@ public async Task PrepareResourceForConcurrentAccessAsync_ThrowsDuringReadShould
             try
             {
                 Resource? resource = await access.GetResourceAsync(1);
-                Assert.True(false, "Expected exception not thrown.");
+                Assert.Fail("Expected exception not thrown.");
             }
             catch (ApplicationException)
             {
@@ -1275,7 +1275,7 @@ public async Task PrepareResourceForConcurrentAccessAsync_ThrowsReleasingWriteSh
                     try
                     {
                         await writeAccess.ReleaseAsync();
-                        Assert.True(false, "Expected exception not thrown.");
+                        Assert.Fail("Expected exception not thrown.");
                     }
                     catch (ApplicationException)
                     {
@@ -1285,7 +1285,7 @@ public async Task PrepareResourceForConcurrentAccessAsync_ThrowsReleasingWriteSh
                 }
 
                 // Exiting the using block should also throw.
-                Assert.True(false, "Expected exception not thrown.");
+                Assert.Fail("Expected exception not thrown.");
             }
             catch (ApplicationException)
             {
@@ -1308,7 +1308,7 @@ public async Task PrepareResourceForConcurrentAccessAsync_ThrowsReleasingWriteSh
                 try
                 {
                     await readAccess.GetResourceAsync(1);
-                    Assert.True(false, "Expected exception not thrown.");
+                    Assert.Fail("Expected exception not thrown.");
                 }
                 catch (ApplicationException)
                 {
diff --git a/test/Microsoft.VisualStudio.Threading.Tests/AsyncSemaphoreTests.cs b/test/Microsoft.VisualStudio.Threading.Tests/AsyncSemaphoreTests.cs
@@ -158,7 +158,7 @@ public async Task ContestedAndCancelledWithTimeoutSpecified()
         try
         {
             await second;
-            Assert.True(false, "Expected OperationCanceledException not thrown.");
+            Assert.Fail("Expected OperationCanceledException not thrown.");
         }
         catch (OperationCanceledException ex)
         {
@@ -176,7 +176,7 @@ public void PreCancelled()
         try
         {
             enterAsyncTask.GetAwaiter().GetResult();
-            Assert.True(false, "Expected exception not thrown.");
+            Assert.Fail("Expected exception not thrown.");
         }
         catch (OperationCanceledException ex)
         {
diff --git a/test/Microsoft.VisualStudio.Threading.Tests/AwaitExtensionsTests.cs b/test/Microsoft.VisualStudio.Threading.Tests/AwaitExtensionsTests.cs
@@ -507,7 +507,7 @@ public async Task ConfigureAwaitForAggregateException_ThrowsAggregateException()
         try
         {
             await joint.ConfigureAwaitForAggregateException();
-            Assert.False(true, "Exception was not thrown.");
+            Assert.Fail("Exception was not thrown.");
         }
         catch (AggregateException ex)
         {
@@ -523,7 +523,7 @@ public async Task ConfigureAwaitForAggregateException_Canceled()
         try
         {
             await canceled.ConfigureAwaitForAggregateException();
-            Assert.False(true, "Exception was not thrown.");
+            Assert.Fail("Exception was not thrown.");
         }
         catch (OperationCanceledException)
         {
@@ -540,7 +540,7 @@ public async Task ConfigureAwaitForAggregateException_InnerCanceled()
         try
         {
             await joint.ConfigureAwaitForAggregateException();
-            Assert.False(true, "Exception was not thrown.");
+            Assert.Fail("Exception was not thrown.");
         }
         catch (OperationCanceledException)
         {
@@ -557,7 +557,7 @@ public async Task ConfigureAwaitForAggregateException_InnerCanceledAndFaulted()
         try
         {
             await joint.ConfigureAwaitForAggregateException();
-            Assert.False(true, "Exception was not thrown.");
+            Assert.Fail("Exception was not thrown.");
         }
         catch (AggregateException ex)
         {
@@ -718,7 +718,7 @@ public async Task AwaitRegKeyChange_Canceled()
             try
             {
                 await changeWatcherTask;
-                Assert.True(false, "Expected exception not thrown.");
+                Assert.Fail("Expected exception not thrown.");
             }
             catch (OperationCanceledException ex)
             {
@@ -756,7 +756,7 @@ public async Task AwaitRegKeyChange_CanceledAndImmediatelyDisposed()
         try
         {
             await watchingTask;
-            Assert.True(false, "Expected exception not thrown.");
+            Assert.Fail("Expected exception not thrown.");
         }
         catch (OperationCanceledException ex)
         {
diff --git a/test/Microsoft.VisualStudio.Threading.Tests/JoinableTaskAndAsyncReaderWriterLockTests.cs b/test/Microsoft.VisualStudio.Threading.Tests/JoinableTaskAndAsyncReaderWriterLockTests.cs
@@ -163,7 +163,7 @@ public async Task RunWithinUpgradeableReadLockThrows()
                 try
                 {
                     this.asyncPump.Run(() => Task.CompletedTask);
-                    Assert.False(true, "Expected InvalidOperationException not thrown.");
+                    Assert.Fail("Expected InvalidOperationException not thrown.");
                 }
                 catch (InvalidOperationException)
                 {
@@ -190,7 +190,7 @@ public async Task RunWithinWriteLockThrows()
                 try
                 {
                     this.asyncPump.Run(() => Task.CompletedTask);
-                    Assert.True(false, "Expected InvalidOperationException not thrown.");
+                    Assert.Fail("Expected InvalidOperationException not thrown.");
                 }
                 catch (InvalidOperationException)
                 {
diff --git a/test/Microsoft.VisualStudio.Threading.Tests/JoinableTaskTests.cs b/test/Microsoft.VisualStudio.Threading.Tests/JoinableTaskTests.cs
diff --git a/test/Microsoft.VisualStudio.Threading.Tests/ThreadingToolsTests.cs b/test/Microsoft.VisualStudio.Threading.Tests/ThreadingToolsTests.cs
diff --git a/test/Microsoft.VisualStudio.Threading.Tests/TplExtensionsTests.cs b/test/Microsoft.VisualStudio.Threading.Tests/TplExtensionsTests.cs

Original file line number	Diff line number	Diff line change
`@@ -10,31 +10,31 @@ public static void Equal<T>(T expected, T actual, string message)`
`10`	`10`	`{`
`11`	`11`	`if (!EqualityComparer<T>.Default.Equals(expected, actual))`
`12`	`12`	`{`
`13`		`- throw new Xunit.Sdk.AssertActualExpectedException(expected, actual, message);`
	`13`	`+ throw Xunit.Sdk.EqualException.ForMismatchedValues(expected, actual, message);`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public static void Equal<T>(T expected, T actual, string formattingMessage, params object[] formattingArgs)`
`18`	`18`	`{`
`19`	`19`	`if (!EqualityComparer<T>.Default.Equals(expected, actual))`
`20`	`20`	`{`
`21`		`- throw new Xunit.Sdk.AssertActualExpectedException(expected, actual, string.Format(CultureInfo.CurrentCulture, formattingMessage, formattingArgs));`
	`21`	`+ throw Xunit.Sdk.EqualException.ForMismatchedValues(expected, actual, string.Format(CultureInfo.CurrentCulture, formattingMessage, formattingArgs));`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`public static void NotEqual<T>(T expected, T actual, string message)`
`26`	`26`	`{`
`27`	`27`	`if (EqualityComparer<T>.Default.Equals(expected, actual))`
`28`	`28`	`{`
`29`		`- throw new Xunit.Sdk.AssertActualExpectedException(expected, actual, message);`
	`29`	`+ throw Xunit.Sdk.NotEqualException.ForEqualValues(expected?.ToString() ?? "<null>", actual?.ToString() ?? "<null>", message);`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public static void NotEqual<T>(T expected, T actual, string formattingMessage, params object[] formattingArgs)`
`34`	`34`	`{`
`35`	`35`	`if (EqualityComparer<T>.Default.Equals(expected, actual))`
`36`	`36`	`{`
`37`		`- throw new Xunit.Sdk.AssertActualExpectedException(expected, actual, string.Format(CultureInfo.CurrentCulture, formattingMessage, formattingArgs));`
	`37`	`+ throw Xunit.Sdk.NotEqualException.ForEqualValues(expected?.ToString() ?? "<null>", actual?.ToString() ?? "<null>", string.Format(CultureInfo.CurrentCulture, formattingMessage, formattingArgs));`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ public void WaitAsync_WithCancellationToken_DoesNotClaimSignal()`
`121`	`121`	`try`
`122`	`122`	`{`
`123`	`123`	`waitTask.GetAwaiter().GetResult();`
`124`		`- Assert.True(false, "Task was expected to transition to a canceled state.");`
	`124`	`+ Assert.Fail("Task was expected to transition to a canceled state.");`
`125`	`125`	`}`
`126`	`126`	`catch (OperationCanceledException ex)`
`127`	`127`	`{`
`@@ -148,7 +148,7 @@ public void WaitAsync_WithCancellationToken_PrecanceledDoesNotClaimExistingSigna`
`148`	`148`	`try`
`149`	`149`	`{`
`150`	`150`	`this.evt.WaitAsync(token).GetAwaiter().GetResult();`
`151`		`- Assert.True(false, "Task was expected to transition to a canceled state.");`
	`151`	`+ Assert.Fail("Task was expected to transition to a canceled state.");`
`152`	`152`	`}`
`153`	`153`	`catch (OperationCanceledException ex)`
`154`	`154`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2652,7 +2652,7 @@ await Task.Run(delegate`
`2652`	`2652`	`try`
`2653`	`2653`	`{`
`2654`	`2654`	`awaiter.GetResult();`
`2655`		`- Assert.True(false, "Expected OperationCanceledException not thrown.");`
	`2655`	`+ Assert.Fail("Expected OperationCanceledException not thrown.");`
`2656`	`2656`	`}`
`2657`	`2657`	`catch (OperationCanceledException)`
`2658`	`2658`	`{`
`@@ -2670,7 +2670,7 @@ public void PrecancelledWriteLockAsyncRequestOnSTA()`
`2670`	`2670`	`try`
`2671`	`2671`	`{`
`2672`	`2672`	`awaiter.GetResult();`
`2673`		`- Assert.True(false, "Expected OperationCanceledException not thrown.");`
	`2673`	`+ Assert.Fail("Expected OperationCanceledException not thrown.");`
`2674`	`2674`	`}`
`2675`	`2675`	`catch (OperationCanceledException)`
`2676`	`2676`	`{`
`@@ -2702,7 +2702,7 @@ await Task.WhenAll(`
`2702`	`2702`	`try`
`2703`	`2703`	`{`
`2704`	`2704`	`awaiter.GetResult();`
`2705`		`- cancellationTestConcluded.SetException(new ThrowsException(typeof(OperationCanceledException)));`
	`2705`	`+ cancellationTestConcluded.SetException(ThrowsException.ForNoException(typeof(OperationCanceledException)));`
`2706`	`2706`	`}`
`2707`	`2707`	`catch (OperationCanceledException)`
`2708`	`2708`	`{`
`@@ -2740,7 +2740,7 @@ await Task.WhenAll(`
`2740`	`2740`	`try`
`2741`	`2741`	`{`
`2742`	`2742`	`awaiter.GetResult();`
`2743`		`- cancellationTestConcluded.SetException(new ThrowsException(typeof(OperationCanceledException)));`
	`2743`	`+ cancellationTestConcluded.SetException(ThrowsException.ForNoException(typeof(OperationCanceledException)));`
`2744`	`2744`	`}`
`2745`	`2745`	`catch (OperationCanceledException)`
`2746`	`2746`	`{`
`@@ -3026,7 +3026,7 @@ public void CompleteBlocksNewTopLevelLocksSTA()`
`3026`	`3026`	`try`
`3027`	`3027`	`{`
`3028`	`3028`	`awaiter.GetResult();`
`3029`		`- Assert.True(false, "Expected exception not thrown.");`
	`3029`	`+ Assert.Fail("Expected exception not thrown.");`
`3030`	`3030`	`}`
`3031`	`3031`	`catch (InvalidOperationException)`
`3032`	`3032`	`{`
`@@ -3047,7 +3047,7 @@ await Task.Run(delegate`
`3047`	`3047`	`try`
`3048`	`3048`	`{`
`3049`	`3049`	`awaiter.GetResult();`
`3050`		`- Assert.True(false, "Expected exception not thrown.");`
	`3050`	`+ Assert.Fail("Expected exception not thrown.");`
`3051`	`3051`	`}`
`3052`	`3052`	`catch (InvalidOperationException)`
`3053`	`3053`	`{`
`@@ -3448,7 +3448,7 @@ public async Task OnBeforeWriteLockReleasedDelegateThrows()`
`3448`	`3448`	`this.asyncLock.Complete();`
`3449`	`3449`	`}`
`3450`	`3450`
`3451`		`- Assert.True(false, "Expected exception not thrown.");`
	`3451`	`+ Assert.Fail("Expected exception not thrown.");`
`3452`	`3452`	`}`
`3453`	`3453`	`catch (AggregateException ex)`
`3454`	`3454`	`{`
`@@ -4184,7 +4184,7 @@ public async Task WriteNestsReadWithWriteReleasedFirstWithoutTaskRun()`
`4184`	`4184`	`try`
`4185`	`4185`	`{`
`4186`	`4186`	`await completingTask; // observe any exception.`
`4187`		`- Assert.True(false, "Expected exception not thrown.");`
	`4187`	`+ Assert.Fail("Expected exception not thrown.");`
`4188`	`4188`	`}`
`4189`	`4189`	`catch (CriticalErrorException ex)`
`4190`	`4190`	`{`
`@@ -4993,7 +4993,7 @@ private async Task MitigationAgainstAccidentalLockForkingHelper(Func<AsyncReader`
`4993`	`4993`	`bool dummy = this.asyncLock.IsReadLockHeld;`
`4994`	`4994`	`if (!successExpected)`
`4995`	`4995`	`{`
`4996`		`- Assert.True(false, "Expected exception not thrown.");`
	`4996`	`+ Assert.Fail("Expected exception not thrown.");`
`4997`	`4997`	`}`
`4998`	`4998`	`}`
`4999`	`4999`	`catch (Exception ex)`
`@@ -5009,7 +5009,7 @@ private async Task MitigationAgainstAccidentalLockForkingHelper(Func<AsyncReader`
`5009`	`5009`	`bool dummy = this.asyncLock.IsUpgradeableReadLockHeld;`
`5010`	`5010`	`if (!successExpected)`
`5011`	`5011`	`{`
`5012`		`- Assert.True(false, "Expected exception not thrown.");`
	`5012`	`+ Assert.Fail("Expected exception not thrown.");`
`5013`	`5013`	`}`
`5014`	`5014`	`}`
`5015`	`5015`	`catch (Exception ex)`
`@@ -5025,7 +5025,7 @@ private async Task MitigationAgainstAccidentalLockForkingHelper(Func<AsyncReader`
`5025`	`5025`	`bool dummy = this.asyncLock.IsWriteLockHeld;`
`5026`	`5026`	`if (!successExpected)`
`5027`	`5027`	`{`
`5028`		`- Assert.True(false, "Expected exception not thrown.");`
	`5028`	`+ Assert.Fail("Expected exception not thrown.");`
`5029`	`5029`	`}`
`5030`	`5030`	`}`
`5031`	`5031`	`catch (Exception ex)`
`@@ -5045,7 +5045,7 @@ private async Task MitigationAgainstAccidentalLockForkingHelper(Func<AsyncReader`
`5045`	`5045`	`try`
`5046`	`5046`	`{`
`5047`	`5047`	`releaser = await locker();`
`5048`		`- Assert.True(false, "Expected exception not thrown.");`
	`5048`	`+ Assert.Fail("Expected exception not thrown.");`
`5049`	`5049`	`}`
`5050`	`5050`	`catch (Exception ex)`
`5051`	`5051`	`{`
Original file line number	Diff line number	Diff line change
`@@ -310,7 +310,7 @@ public async Task PreparationSucceedsForConcurrentReadersWhenOneCancels()`
`310`	`310`	`try`
`311`	`311`	`{`
`312`	`312`	`await resourceTask;`
`313`		`- Assert.True(false, "Expected OperationCanceledException not thrown.");`
	`313`	`+ Assert.Fail("Expected OperationCanceledException not thrown.");`
`314`	`314`	`}`
`315`	`315`	`catch (OperationCanceledException)`
`316`	`316`	`{`
`@@ -461,7 +461,7 @@ public async Task PreparationIsAppliedToResourceImpactedByOutsideChangePredicate`
`461`	`461`	`(resource, s) =>`
`462`	`462`	`{`
`463`	`463`	`Assert.Same(state, s);`
`464`		`- Assert.True(false, "Read locks should not invoke this.");`
	`464`	`+ Assert.Fail("Read locks should not invoke this.");`
`465`	`465`	`return false;`
`466`	`466`	`},`
`467`	`467`	`state);`
`@@ -1216,7 +1216,7 @@ public async Task GetResourceAsyncRetriesFaultedPreparation()`
`1216`	`1216`	`try`
`1217`	`1217`	`{`
`1218`	`1218`	`await access.GetResourceAsync(1);`
`1219`		`- Assert.True(false, "Expected exception not thrown.");`
	`1219`	`+ Assert.Fail("Expected exception not thrown.");`
`1220`	`1220`	`}`
`1221`	`1221`	`catch (ApplicationException)`
`1222`	`1222`	`{`
`@@ -1242,7 +1242,7 @@ public async Task PrepareResourceForConcurrentAccessAsync_ThrowsDuringReadShould`
`1242`	`1242`	`try`
`1243`	`1243`	`{`
`1244`	`1244`	`Resource? resource = await access.GetResourceAsync(1);`
`1245`		`- Assert.True(false, "Expected exception not thrown.");`
	`1245`	`+ Assert.Fail("Expected exception not thrown.");`
`1246`	`1246`	`}`
`1247`	`1247`	`catch (ApplicationException)`
`1248`	`1248`	`{`
`@@ -1275,7 +1275,7 @@ public async Task PrepareResourceForConcurrentAccessAsync_ThrowsReleasingWriteSh`
`1275`	`1275`	`try`
`1276`	`1276`	`{`
`1277`	`1277`	`await writeAccess.ReleaseAsync();`
`1278`		`- Assert.True(false, "Expected exception not thrown.");`
	`1278`	`+ Assert.Fail("Expected exception not thrown.");`
`1279`	`1279`	`}`
`1280`	`1280`	`catch (ApplicationException)`
`1281`	`1281`	`{`
`@@ -1285,7 +1285,7 @@ public async Task PrepareResourceForConcurrentAccessAsync_ThrowsReleasingWriteSh`
`1285`	`1285`	`}`
`1286`	`1286`
`1287`	`1287`	`// Exiting the using block should also throw.`
`1288`		`- Assert.True(false, "Expected exception not thrown.");`
	`1288`	`+ Assert.Fail("Expected exception not thrown.");`
`1289`	`1289`	`}`
`1290`	`1290`	`catch (ApplicationException)`
`1291`	`1291`	`{`
`@@ -1308,7 +1308,7 @@ public async Task PrepareResourceForConcurrentAccessAsync_ThrowsReleasingWriteSh`
`1308`	`1308`	`try`
`1309`	`1309`	`{`
`1310`	`1310`	`await readAccess.GetResourceAsync(1);`
`1311`		`- Assert.True(false, "Expected exception not thrown.");`
	`1311`	`+ Assert.Fail("Expected exception not thrown.");`
`1312`	`1312`	`}`
`1313`	`1313`	`catch (ApplicationException)`
`1314`	`1314`	`{`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ public async Task ContestedAndCancelledWithTimeoutSpecified()`
`158`	`158`	`try`
`159`	`159`	`{`
`160`	`160`	`await second;`
`161`		`- Assert.True(false, "Expected OperationCanceledException not thrown.");`
	`161`	`+ Assert.Fail("Expected OperationCanceledException not thrown.");`
`162`	`162`	`}`
`163`	`163`	`catch (OperationCanceledException ex)`
`164`	`164`	`{`
`@@ -176,7 +176,7 @@ public void PreCancelled()`
`176`	`176`	`try`
`177`	`177`	`{`
`178`	`178`	`enterAsyncTask.GetAwaiter().GetResult();`
`179`		`- Assert.True(false, "Expected exception not thrown.");`
	`179`	`+ Assert.Fail("Expected exception not thrown.");`
`180`	`180`	`}`
`181`	`181`	`catch (OperationCanceledException ex)`
`182`	`182`	`{`
Original file line number	Diff line number	Diff line change
`@@ -507,7 +507,7 @@ public async Task ConfigureAwaitForAggregateException_ThrowsAggregateException()`
`507`	`507`	`try`
`508`	`508`	`{`
`509`	`509`	`await joint.ConfigureAwaitForAggregateException();`
`510`		`- Assert.False(true, "Exception was not thrown.");`
	`510`	`+ Assert.Fail("Exception was not thrown.");`
`511`	`511`	`}`
`512`	`512`	`catch (AggregateException ex)`
`513`	`513`	`{`
`@@ -523,7 +523,7 @@ public async Task ConfigureAwaitForAggregateException_Canceled()`
`523`	`523`	`try`
`524`	`524`	`{`
`525`	`525`	`await canceled.ConfigureAwaitForAggregateException();`
`526`		`- Assert.False(true, "Exception was not thrown.");`
	`526`	`+ Assert.Fail("Exception was not thrown.");`
`527`	`527`	`}`
`528`	`528`	`catch (OperationCanceledException)`
`529`	`529`	`{`
`@@ -540,7 +540,7 @@ public async Task ConfigureAwaitForAggregateException_InnerCanceled()`
`540`	`540`	`try`
`541`	`541`	`{`
`542`	`542`	`await joint.ConfigureAwaitForAggregateException();`
`543`		`- Assert.False(true, "Exception was not thrown.");`
	`543`	`+ Assert.Fail("Exception was not thrown.");`
`544`	`544`	`}`
`545`	`545`	`catch (OperationCanceledException)`
`546`	`546`	`{`
`@@ -557,7 +557,7 @@ public async Task ConfigureAwaitForAggregateException_InnerCanceledAndFaulted()`
`557`	`557`	`try`
`558`	`558`	`{`
`559`	`559`	`await joint.ConfigureAwaitForAggregateException();`
`560`		`- Assert.False(true, "Exception was not thrown.");`
	`560`	`+ Assert.Fail("Exception was not thrown.");`
`561`	`561`	`}`
`562`	`562`	`catch (AggregateException ex)`
`563`	`563`	`{`
`@@ -718,7 +718,7 @@ public async Task AwaitRegKeyChange_Canceled()`
`718`	`718`	`try`
`719`	`719`	`{`
`720`	`720`	`await changeWatcherTask;`
`721`		`- Assert.True(false, "Expected exception not thrown.");`
	`721`	`+ Assert.Fail("Expected exception not thrown.");`
`722`	`722`	`}`
`723`	`723`	`catch (OperationCanceledException ex)`
`724`	`724`	`{`
`@@ -756,7 +756,7 @@ public async Task AwaitRegKeyChange_CanceledAndImmediatelyDisposed()`
`756`	`756`	`try`
`757`	`757`	`{`
`758`	`758`	`await watchingTask;`
`759`		`- Assert.True(false, "Expected exception not thrown.");`
	`759`	`+ Assert.Fail("Expected exception not thrown.");`
`760`	`760`	`}`
`761`	`761`	`catch (OperationCanceledException ex)`
`762`	`762`	`{`
Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ public async Task RunWithinUpgradeableReadLockThrows()`
`163`	`163`	`try`
`164`	`164`	`{`
`165`	`165`	`this.asyncPump.Run(() => Task.CompletedTask);`
`166`		`- Assert.False(true, "Expected InvalidOperationException not thrown.");`
	`166`	`+ Assert.Fail("Expected InvalidOperationException not thrown.");`
`167`	`167`	`}`
`168`	`168`	`catch (InvalidOperationException)`
`169`	`169`	`{`
`@@ -190,7 +190,7 @@ public async Task RunWithinWriteLockThrows()`
`190`	`190`	`try`
`191`	`191`	`{`
`192`	`192`	`this.asyncPump.Run(() => Task.CompletedTask);`
`193`		`- Assert.True(false, "Expected InvalidOperationException not thrown.");`
	`193`	`+ Assert.Fail("Expected InvalidOperationException not thrown.");`
`194`	`194`	`}`
`195`	`195`	`catch (InvalidOperationException)`
`196`	`196`	`{`