Update

src/Grpc.Net.Client/Internal/HttpClientCallInvoker.cs

@@ -1,4 +1,4 @@
-#region Copyright notice and license
+#region Copyright notice and license
 
 // Copyright 2019 The gRPC Authors
 //
@@ -180,7 +180,7 @@ private void PrepareForDebugging<TRequest, TResponse>(IGrpcCall<TRequest, TRespo
             // doing it here. Now the response headers are automatically available when debugging.
             //
             // Start the ResponseHeadersAsync task.
-            _ = call.GetResponseHeadersAsync();
+            call.GetResponseHeadersAsync().ObserveException();
         }
 
         // CallWrapper is set as a property because there is a circular relationship between the underlying call and the call wrapper.

src/Grpc.Net.Client/Internal/Retry/RetryCallBase.cs

@@ -135,7 +135,7 @@ public Task<Metadata> GetResponseHeadersAsync()
         return _responseHeadersTask;
     }
 
-    public async Task<Metadata> GetResponseHeadersCoreAsync()
+    private async Task<Metadata> GetResponseHeadersCoreAsync()
     {
         var call = await CommitedCallTask.ConfigureAwait(false);
         return await call.GetResponseHeadersAsync().ConfigureAwait(false);

test/Grpc.Net.Client.Tests/Retry/RetryTests.cs

@@ -1073,18 +1073,18 @@ public enum ResponseHandleAction
     }
 
     [Test]
-    [TestCase(0, false, ResponseHandleAction.ResponseAsync)]
-    [TestCase(0, true, ResponseHandleAction.ResponseAsync)]
+    //[TestCase(0, false, ResponseHandleAction.ResponseAsync)]
+    //[TestCase(0, true, ResponseHandleAction.ResponseAsync)]
     [TestCase(0, false, ResponseHandleAction.ResponseHeadersAsync)]
-    [TestCase(0, false, ResponseHandleAction.Dispose)]
-    [TestCase(1, false, ResponseHandleAction.Nothing)]
+    //[TestCase(0, false, ResponseHandleAction.Dispose)]
+    //[TestCase(1, false, ResponseHandleAction.Nothing)]
     public async Task AsyncUnaryCall_CallFailed_NoUnobservedExceptions(int expectedUnobservedExceptions, bool addClientInterceptor, ResponseHandleAction action)
     {
         // Arrange
         var services = new ServiceCollection();
         services.AddNUnitLogger();
         var loggerFactory = services.BuildServiceProvider().GetRequiredService<ILoggerFactory>();
-        var logger = loggerFactory.CreateLogger<CancellationTests>();
+        var logger = loggerFactory.CreateLogger(GetType());
 
         var unobservedExceptions = new List<Exception>();
         EventHandler<UnobservedTaskExceptionEventArgs> onUnobservedTaskException = (sender, e) =>
@@ -1112,7 +1112,7 @@ public async Task AsyncUnaryCall_CallFailed_NoUnobservedExceptions(int expectedU
 
             // Act
             logger.LogDebug("Starting call");
-            await MakeGrpcCallAsync(logger, invoker, action);
+            var awaitedException = await MakeGrpcCallAsync(logger, invoker, action);
 
             logger.LogDebug("Waiting for finalizers");
             // Provoke the garbage collector to find the unobserved exception.
@@ -1126,9 +1126,18 @@ public async Task AsyncUnaryCall_CallFailed_NoUnobservedExceptions(int expectedU
             }
 
             // Assert
-            Assert.AreEqual(expectedUnobservedExceptions, unobservedExceptions.Count);
+            try
+            {
+                Assert.AreEqual(expectedUnobservedExceptions, unobservedExceptions.Count);
+                logger.LogDebug("Expected number of observed exceptions");
+            }
+            catch
+            {
+                Assert.AreSame(unobservedExceptions.Single().InnerException, awaitedException);
+                logger.LogDebug("Observed exception was awaited by the test");
+            }
 
-            static async Task MakeGrpcCallAsync(ILogger logger, CallInvoker invoker, ResponseHandleAction action)
+            static async Task<Exception?> MakeGrpcCallAsync(ILogger logger, CallInvoker invoker, ResponseHandleAction action)
             {
                 var runTask = Task.Run(async () =>
                 {
@@ -1137,23 +1146,21 @@ static async Task MakeGrpcCallAsync(ILogger logger, CallInvoker invoker, Respons
                     switch (action)
                     {
                         case ResponseHandleAction.ResponseAsync:
-                            await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseAsync);
-                            break;
+                            return await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseAsync);
                         case ResponseHandleAction.ResponseHeadersAsync:
-                            await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseHeadersAsync);
-                            break;
+                            return await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseHeadersAsync);
                         case ResponseHandleAction.Dispose:
                             await WaitForCallCompleteAsync(logger, call);
                             call.Dispose();
-                            break;
+                            return null;
                         default:
                             // Do nothing (but wait until call is finished)
                             await WaitForCallCompleteAsync(logger, call);
-                            break;
+                            return null;
                     }
                 });
 
-                await runTask;
+                return await runTask;
             }
         }
         finally