Merge pull request #1819 from rabbitmq/rabbitmq-dotnet-client-1818

lukebakken · web-flow · commit a2670254c629 · 2025-07-23T12:49:03.000-07:00
Investigate &amp; fix `SemaphoreFullException`
diff --git a/projects/RabbitMQ.Client/Impl/AsyncRpcContinuations.cs b/projects/RabbitMQ.Client/Impl/AsyncRpcContinuations.cs
@@ -30,7 +30,6 @@
 //---------------------------------------------------------------------------
 
 using System;
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
@@ -280,10 +279,20 @@ protected override async Task DoHandleCommandAsync(IncomingCommand cmd)
         {
             if (cmd.CommandId == ProtocolCommandId.BasicCancelOk)
             {
-                Debug.Assert(_consumerTag == new BasicCancelOk(cmd.MethodSpan)._consumerTag);
-                await _consumerDispatcher.HandleBasicCancelOkAsync(_consumerTag, CancellationToken)
-                    .ConfigureAwait(false);
-                _tcs.SetResult(true);
+                var result = new BasicCancelOk(cmd.MethodSpan);
+                if (_consumerTag == result._consumerTag)
+                {
+                    await _consumerDispatcher.HandleBasicCancelOkAsync(_consumerTag, CancellationToken)
+                        .ConfigureAwait(false);
+                    _tcs.SetResult(true);
+                }
+                else
+                {
+                    string msg = string.Format("Consumer tag '{0}' does not match expected consumer tag for basic.cancel operation {1}",
+                        result._consumerTag, _consumerTag);
+                    var ex = new InvalidOperationException(msg);
+                    _tcs.SetException(ex);
+                }
             }
             else
             {
diff --git a/projects/RabbitMQ.Client/Impl/Channel.BasicPublish.cs b/projects/RabbitMQ.Client/Impl/Channel.BasicPublish.cs
@@ -52,7 +52,7 @@ public async ValueTask BasicPublishAsync<TProperties>(string exchange, string ro
             try
             {
                 publisherConfirmationInfo =
-                    await MaybeStartPublisherConfirmationTracking(cancellationToken)
+                    await MaybeStartPublisherConfirmationTrackingAsync(cancellationToken)
                         .ConfigureAwait(false);
 
                 await MaybeEnforceFlowControlAsync(cancellationToken)
@@ -93,7 +93,7 @@ await ModelSendAsync(in cmd, in props, body, cancellationToken)
             }
             finally
             {
-                await MaybeEndPublisherConfirmationTracking(publisherConfirmationInfo, cancellationToken)
+                await MaybeEndPublisherConfirmationTrackingAsync(publisherConfirmationInfo, cancellationToken)
                     .ConfigureAwait(false);
             }
         }
@@ -107,7 +107,7 @@ public async ValueTask BasicPublishAsync<TProperties>(CachedString exchange, Cac
             try
             {
                 publisherConfirmationInfo =
-                    await MaybeStartPublisherConfirmationTracking(cancellationToken)
+                    await MaybeStartPublisherConfirmationTrackingAsync(cancellationToken)
                         .ConfigureAwait(false);
 
                 await MaybeEnforceFlowControlAsync(cancellationToken)
@@ -148,7 +148,7 @@ await ModelSendAsync(in cmd, in props, body, cancellationToken)
             }
             finally
             {
-                await MaybeEndPublisherConfirmationTracking(publisherConfirmationInfo, cancellationToken)
+                await MaybeEndPublisherConfirmationTrackingAsync(publisherConfirmationInfo, cancellationToken)
                     .ConfigureAwait(false);
             }
         }
diff --git a/projects/RabbitMQ.Client/Impl/Channel.PublisherConfirms.cs b/projects/RabbitMQ.Client/Impl/Channel.PublisherConfirms.cs
@@ -32,7 +32,6 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;
@@ -126,7 +125,7 @@ private void ConfigurePublisherConfirmations(bool publisherConfirmationsEnabled,
             _outstandingPublisherConfirmationsRateLimiter = outstandingPublisherConfirmationsRateLimiter;
         }
 
-        private async Task MaybeConfirmSelect(CancellationToken cancellationToken)
+        private async Task MaybeConfirmSelectAsync(CancellationToken cancellationToken)
         {
             if (_publisherConfirmationsEnabled)
             {
@@ -148,13 +147,14 @@ private async Task MaybeConfirmSelect(CancellationToken cancellationToken)
                     enqueued = Enqueue(k);
 
                     var method = new ConfirmSelect(false);
+
                     await ModelSendAsync(in method, k.CancellationToken)
                         .ConfigureAwait(false);
 
-                    bool result = await k;
-                    Debug.Assert(result);
-
-                    return;
+                    if (false == await k)
+                    {
+                        throw new InvalidOperationException(InternalConstants.BugFound);
+                    }
                 }
                 finally
                 {
@@ -180,12 +180,14 @@ private void HandleAck(ulong deliveryTag, bool multiple)
             {
                 if (multiple)
                 {
-                    foreach (KeyValuePair<ulong, TaskCompletionSource<bool>> pair in _confirmsTaskCompletionSources)
+                    foreach (KeyValuePair<ulong, TaskCompletionSource<bool>> pair in _confirmsTaskCompletionSources.ToArray())
                     {
                         if (pair.Key <= deliveryTag)
                         {
-                            pair.Value.SetResult(true);
-                            _confirmsTaskCompletionSources.Remove(pair.Key, out _);
+                            if (_confirmsTaskCompletionSources.TryRemove(pair.Key, out TaskCompletionSource<bool>? tcs))
+                            {
+                                tcs.SetResult(true);
+                            }
                         }
                     }
                 }
@@ -208,20 +210,22 @@ private void HandleNack(ulong deliveryTag, bool multiple, bool isReturn,
             {
                 if (multiple)
                 {
-                    foreach (KeyValuePair<ulong, TaskCompletionSource<bool>> pair in _confirmsTaskCompletionSources)
+                    foreach (KeyValuePair<ulong, TaskCompletionSource<bool>> pair in _confirmsTaskCompletionSources.ToArray())
                     {
                         if (pair.Key <= deliveryTag)
                         {
-                            PublishException ex = PublishExceptionFactory.Create(isReturn, pair.Key,
-                                exchange, routingKey, replyCode, replyText);
-                            pair.Value.SetException(ex);
-                            _confirmsTaskCompletionSources.Remove(pair.Key, out _);
+                            if (_confirmsTaskCompletionSources.TryRemove(pair.Key, out TaskCompletionSource<bool>? tcs))
+                            {
+                                PublishException ex = PublishExceptionFactory.Create(isReturn, pair.Key,
+                                    exchange, routingKey, replyCode, replyText);
+                                tcs.SetException(ex);
+                            }
                         }
                     }
                 }
                 else
                 {
-                    if (_confirmsTaskCompletionSources.Remove(deliveryTag, out TaskCompletionSource<bool>? tcs))
+                    if (_confirmsTaskCompletionSources.TryRemove(deliveryTag, out TaskCompletionSource<bool>? tcs))
                     {
                         PublishException ex = PublishExceptionFactory.Create(isReturn, deliveryTag,
                             exchange, routingKey, replyCode, replyText);
@@ -289,7 +293,7 @@ await _confirmSemaphore.WaitAsync(reason.CancellationToken)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private async Task<PublisherConfirmationInfo?> MaybeStartPublisherConfirmationTracking(CancellationToken cancellationToken)
+        private async Task<PublisherConfirmationInfo?> MaybeStartPublisherConfirmationTrackingAsync(CancellationToken cancellationToken)
         {
             if (_publisherConfirmationsEnabled)
             {
@@ -357,7 +361,7 @@ private bool MaybeHandleExceptionWithEnabledPublisherConfirmations(PublisherConf
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private async Task MaybeEndPublisherConfirmationTracking(PublisherConfirmationInfo? publisherConfirmationInfo,
+        private async Task MaybeEndPublisherConfirmationTrackingAsync(PublisherConfirmationInfo? publisherConfirmationInfo,
             CancellationToken cancellationToken)
         {
             if (_publisherConfirmationsEnabled)
@@ -388,6 +392,11 @@ private async Task MaybeEndPublisherConfirmationTracking(PublisherConfirmationIn
                         await publisherConfirmationInfo.MaybeWaitForConfirmationAsync(cancellationToken)
                             .ConfigureAwait(false);
                     }
+                    catch (OperationCanceledException)
+                    {
+                        _confirmsTaskCompletionSources.TryRemove(publisherConfirmationInfo.PublishSequenceNumber, out _);
+                        throw;
+                    }
                     finally
                     {
                         publisherConfirmationInfo.Dispose();
diff --git a/projects/RabbitMQ.Client/Impl/Channel.cs b/projects/RabbitMQ.Client/Impl/Channel.cs
@@ -234,8 +234,7 @@ await ModelSendAsync(in method, k.CancellationToken)
                         .ConfigureAwait(false);
                 }
 
-                bool result = await k;
-                Debug.Assert(result);
+                AssertResultIsTrue(await k);
 
                 await ConsumerDispatcher.WaitForShutdownAsync()
                     .ConfigureAwait(false);
@@ -387,10 +386,9 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                 try
                 {
-                    bool result = await k;
-                    Debug.Assert(result);
+                    AssertResultIsTrue(await k);
 
-                    await MaybeConfirmSelect(cancellationToken)
+                    await MaybeConfirmSelectAsync(cancellationToken)
                         .ConfigureAwait(false);
                 }
                 catch (OperationCanceledException)
@@ -465,6 +463,14 @@ await c.HandleCommandAsync(cmd)
             }
         }
 
+        private static void AssertResultIsTrue(bool result)
+        {
+            if (false == result)
+            {
+                throw new InvalidOperationException(InternalConstants.BugFound);
+            }
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         protected ValueTask ModelSendAsync<T>(in T method, CancellationToken cancellationToken) where T : struct, IOutgoingAmqpMethod
         {
@@ -978,8 +984,7 @@ await ModelSendAsync(in method, k.CancellationToken)
                         await ModelSendAsync(in method, k.CancellationToken)
                             .ConfigureAwait(false);
 
-                        bool result = await k;
-                        Debug.Assert(result);
+                        AssertResultIsTrue(await k);
                     }
                     catch
                     {
@@ -1108,9 +1113,7 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                 try
                 {
-                    bool result = await k;
-                    Debug.Assert(result);
-                    return;
+                    AssertResultIsTrue(await k);
                 }
                 catch (OperationCanceledException)
                 {
@@ -1143,9 +1146,7 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                 try
                 {
-                    bool result = await k;
-                    Debug.Assert(result);
-                    return;
+                    AssertResultIsTrue(await k);
                 }
                 catch (OperationCanceledException)
                 {
@@ -1187,9 +1188,7 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                     try
                     {
-                        bool result = await k;
-                        Debug.Assert(result);
-                        return;
+                        AssertResultIsTrue(await k);
                     }
                     catch (OperationCanceledException)
                     {
@@ -1240,9 +1239,7 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                     try
                     {
-                        bool result = await k;
-                        Debug.Assert(result);
-                        return;
+                        AssertResultIsTrue(await k);
                     }
                     catch (OperationCanceledException)
                     {
@@ -1286,8 +1283,7 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                     try
                     {
-                        bool result = await k;
-                        Debug.Assert(result);
+                        AssertResultIsTrue(await k);
                     }
                     catch (OperationCanceledException)
                     {
@@ -1332,8 +1328,7 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                     try
                     {
-                        bool result = await k;
-                        Debug.Assert(result);
+                        AssertResultIsTrue(await k);
                     }
                     catch (OperationCanceledException)
                     {
@@ -1456,8 +1451,7 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                     try
                     {
-                        bool result = await k;
-                        Debug.Assert(result);
+                        AssertResultIsTrue(await k);
                     }
                     catch (OperationCanceledException)
                     {
@@ -1587,9 +1581,7 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                 try
                 {
-                    bool result = await k;
-                    Debug.Assert(result);
-                    return;
+                    AssertResultIsTrue(await k);
                 }
                 catch (OperationCanceledException)
                 {
@@ -1621,9 +1613,7 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                 try
                 {
-                    bool result = await k;
-                    Debug.Assert(result);
-                    return;
+                    AssertResultIsTrue(await k);
                 }
                 catch (OperationCanceledException)
                 {
@@ -1655,9 +1645,7 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                 try
                 {
-                    bool result = await k;
-                    Debug.Assert(result);
-                    return;
+                    AssertResultIsTrue(await k);
                 }
                 catch (OperationCanceledException)
                 {
@@ -1689,9 +1677,7 @@ await ModelSendAsync(in method, k.CancellationToken)
 
                 try
                 {
-                    bool result = await k;
-                    Debug.Assert(result);
-                    return;
+                    AssertResultIsTrue(await k);
                 }
                 catch (OperationCanceledException)
                 {
diff --git a/projects/Test/Integration/TestFloodPublishing.cs b/projects/Test/Integration/TestFloodPublishing.cs

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public async ValueTask BasicPublishAsync<TProperties>(string exchange, string ro`
`52`	`52`	`try`
`53`	`53`	`{`
`54`	`54`	`publisherConfirmationInfo =`
`55`		`- await MaybeStartPublisherConfirmationTracking(cancellationToken)`
	`55`	`+ await MaybeStartPublisherConfirmationTrackingAsync(cancellationToken)`
`56`	`56`	`.ConfigureAwait(false);`
`57`	`57`
`58`	`58`	`await MaybeEnforceFlowControlAsync(cancellationToken)`
`@@ -93,7 +93,7 @@ await ModelSendAsync(in cmd, in props, body, cancellationToken)`
`93`	`93`	`}`
`94`	`94`	`finally`
`95`	`95`	`{`
`96`		`- await MaybeEndPublisherConfirmationTracking(publisherConfirmationInfo, cancellationToken)`
	`96`	`+ await MaybeEndPublisherConfirmationTrackingAsync(publisherConfirmationInfo, cancellationToken)`
`97`	`97`	`.ConfigureAwait(false);`
`98`	`98`	`}`
`99`	`99`	`}`
`@@ -107,7 +107,7 @@ public async ValueTask BasicPublishAsync<TProperties>(CachedString exchange, Cac`
`107`	`107`	`try`
`108`	`108`	`{`
`109`	`109`	`publisherConfirmationInfo =`
`110`		`- await MaybeStartPublisherConfirmationTracking(cancellationToken)`
	`110`	`+ await MaybeStartPublisherConfirmationTrackingAsync(cancellationToken)`
`111`	`111`	`.ConfigureAwait(false);`
`112`	`112`
`113`	`113`	`await MaybeEnforceFlowControlAsync(cancellationToken)`
`@@ -148,7 +148,7 @@ await ModelSendAsync(in cmd, in props, body, cancellationToken)`
`148`	`148`	`}`
`149`	`149`	`finally`
`150`	`150`	`{`
`151`		`- await MaybeEndPublisherConfirmationTracking(publisherConfirmationInfo, cancellationToken)`
	`151`	`+ await MaybeEndPublisherConfirmationTrackingAsync(publisherConfirmationInfo, cancellationToken)`
`152`	`152`	`.ConfigureAwait(false);`
`153`	`153`	`}`
`154`	`154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,6 @@`
`32`	`32`	`using System;`
`33`	`33`	`using System.Collections.Concurrent;`
`34`	`34`	`using System.Collections.Generic;`
`35`		`-using System.Diagnostics;`
`36`	`35`	`using System.Runtime.CompilerServices;`
`37`	`36`	`using System.Text;`
`38`	`37`	`using System.Threading;`
`@@ -126,7 +125,7 @@ private void ConfigurePublisherConfirmations(bool publisherConfirmationsEnabled,`
`126`	`125`	`_outstandingPublisherConfirmationsRateLimiter = outstandingPublisherConfirmationsRateLimiter;`
`127`	`126`	`}`
`128`	`127`
`129`		`- private async Task MaybeConfirmSelect(CancellationToken cancellationToken)`
	`128`	`+ private async Task MaybeConfirmSelectAsync(CancellationToken cancellationToken)`
`130`	`129`	`{`
`131`	`130`	`if (_publisherConfirmationsEnabled)`
`132`	`131`	`{`
`@@ -148,13 +147,14 @@ private async Task MaybeConfirmSelect(CancellationToken cancellationToken)`
`148`	`147`	`enqueued = Enqueue(k);`
`149`	`148`
`150`	`149`	`var method = new ConfirmSelect(false);`
	`150`	`+`
`151`	`151`	`await ModelSendAsync(in method, k.CancellationToken)`
`152`	`152`	`.ConfigureAwait(false);`
`153`	`153`
`154`		`- bool result = await k;`
`155`		`- Debug.Assert(result);`
`156`		`-`
`157`		`- return;`
	`154`	`+ if (false == await k)`
	`155`	`+ {`
	`156`	`+ throw new InvalidOperationException(InternalConstants.BugFound);`
	`157`	`+ }`
`158`	`158`	`}`
`159`	`159`	`finally`
`160`	`160`	`{`
`@@ -180,12 +180,14 @@ private void HandleAck(ulong deliveryTag, bool multiple)`
`180`	`180`	`{`
`181`	`181`	`if (multiple)`
`182`	`182`	`{`
`183`		`- foreach (KeyValuePair<ulong, TaskCompletionSource<bool>> pair in _confirmsTaskCompletionSources)`
	`183`	`+ foreach (KeyValuePair<ulong, TaskCompletionSource<bool>> pair in _confirmsTaskCompletionSources.ToArray())`
`184`	`184`	`{`
`185`	`185`	`if (pair.Key <= deliveryTag)`
`186`	`186`	`{`
`187`		`- pair.Value.SetResult(true);`
`188`		`- _confirmsTaskCompletionSources.Remove(pair.Key, out _);`
	`187`	`+ if (_confirmsTaskCompletionSources.TryRemove(pair.Key, out TaskCompletionSource<bool>? tcs))`
	`188`	`+ {`
	`189`	`+ tcs.SetResult(true);`
	`190`	`+ }`
`189`	`191`	`}`
`190`	`192`	`}`
`191`	`193`	`}`
`@@ -208,20 +210,22 @@ private void HandleNack(ulong deliveryTag, bool multiple, bool isReturn,`
`208`	`210`	`{`
`209`	`211`	`if (multiple)`
`210`	`212`	`{`
`211`		`- foreach (KeyValuePair<ulong, TaskCompletionSource<bool>> pair in _confirmsTaskCompletionSources)`
	`213`	`+ foreach (KeyValuePair<ulong, TaskCompletionSource<bool>> pair in _confirmsTaskCompletionSources.ToArray())`
`212`	`214`	`{`
`213`	`215`	`if (pair.Key <= deliveryTag)`
`214`	`216`	`{`
`215`		`- PublishException ex = PublishExceptionFactory.Create(isReturn, pair.Key,`
`216`		`- exchange, routingKey, replyCode, replyText);`
`217`		`- pair.Value.SetException(ex);`
`218`		`- _confirmsTaskCompletionSources.Remove(pair.Key, out _);`
	`217`	`+ if (_confirmsTaskCompletionSources.TryRemove(pair.Key, out TaskCompletionSource<bool>? tcs))`
	`218`	`+ {`
	`219`	`+ PublishException ex = PublishExceptionFactory.Create(isReturn, pair.Key,`
	`220`	`+ exchange, routingKey, replyCode, replyText);`
	`221`	`+ tcs.SetException(ex);`
	`222`	`+ }`
`219`	`223`	`}`
`220`	`224`	`}`
`221`	`225`	`}`
`222`	`226`	`else`
`223`	`227`	`{`
`224`		`- if (_confirmsTaskCompletionSources.Remove(deliveryTag, out TaskCompletionSource<bool>? tcs))`
	`228`	`+ if (_confirmsTaskCompletionSources.TryRemove(deliveryTag, out TaskCompletionSource<bool>? tcs))`
`225`	`229`	`{`
`226`	`230`	`PublishException ex = PublishExceptionFactory.Create(isReturn, deliveryTag,`
`227`	`231`	`exchange, routingKey, replyCode, replyText);`
`@@ -289,7 +293,7 @@ await _confirmSemaphore.WaitAsync(reason.CancellationToken)`
`289`	`293`	`}`
`290`	`294`
`291`	`295`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`292`		`- private async Task<PublisherConfirmationInfo?> MaybeStartPublisherConfirmationTracking(CancellationToken cancellationToken)`
	`296`	`+ private async Task<PublisherConfirmationInfo?> MaybeStartPublisherConfirmationTrackingAsync(CancellationToken cancellationToken)`
`293`	`297`	`{`
`294`	`298`	`if (_publisherConfirmationsEnabled)`
`295`	`299`	`{`
`@@ -357,7 +361,7 @@ private bool MaybeHandleExceptionWithEnabledPublisherConfirmations(PublisherConf`
`357`	`361`	`}`
`358`	`362`
`359`	`363`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`360`		`- private async Task MaybeEndPublisherConfirmationTracking(PublisherConfirmationInfo? publisherConfirmationInfo,`
	`364`	`+ private async Task MaybeEndPublisherConfirmationTrackingAsync(PublisherConfirmationInfo? publisherConfirmationInfo,`
`361`	`365`	`CancellationToken cancellationToken)`
`362`	`366`	`{`
`363`	`367`	`if (_publisherConfirmationsEnabled)`
`@@ -388,6 +392,11 @@ private async Task MaybeEndPublisherConfirmationTracking(PublisherConfirmationIn`
`388`	`392`	`await publisherConfirmationInfo.MaybeWaitForConfirmationAsync(cancellationToken)`
`389`	`393`	`.ConfigureAwait(false);`
`390`	`394`	`}`
	`395`	`+ catch (OperationCanceledException)`
	`396`	`+ {`
	`397`	`+ _confirmsTaskCompletionSources.TryRemove(publisherConfirmationInfo.PublishSequenceNumber, out _);`
	`398`	`+ throw;`
	`399`	`+ }`
`391`	`400`	`finally`
`392`	`401`	`{`
`393`	`402`	`publisherConfirmationInfo.Dispose();`
Original file line number	Diff line number	Diff line change
`@@ -234,8 +234,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`234`	`234`	`.ConfigureAwait(false);`
`235`	`235`	`}`
`236`	`236`
`237`		`- bool result = await k;`
`238`		`- Debug.Assert(result);`
	`237`	`+ AssertResultIsTrue(await k);`
`239`	`238`
`240`	`239`	`await ConsumerDispatcher.WaitForShutdownAsync()`
`241`	`240`	`.ConfigureAwait(false);`
`@@ -387,10 +386,9 @@ await ModelSendAsync(in method, k.CancellationToken)`
`387`	`386`
`388`	`387`	`try`
`389`	`388`	`{`
`390`		`- bool result = await k;`
`391`		`- Debug.Assert(result);`
	`389`	`+ AssertResultIsTrue(await k);`
`392`	`390`
`393`		`- await MaybeConfirmSelect(cancellationToken)`
	`391`	`+ await MaybeConfirmSelectAsync(cancellationToken)`
`394`	`392`	`.ConfigureAwait(false);`
`395`	`393`	`}`
`396`	`394`	`catch (OperationCanceledException)`
`@@ -465,6 +463,14 @@ await c.HandleCommandAsync(cmd)`
`465`	`463`	`}`
`466`	`464`	`}`
`467`	`465`
	`466`	`+ private static void AssertResultIsTrue(bool result)`
	`467`	`+ {`
	`468`	`+ if (false == result)`
	`469`	`+ {`
	`470`	`+ throw new InvalidOperationException(InternalConstants.BugFound);`
	`471`	`+ }`
	`472`	`+ }`
	`473`	`+`
`468`	`474`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`469`	`475`	`protected ValueTask ModelSendAsync<T>(in T method, CancellationToken cancellationToken) where T : struct, IOutgoingAmqpMethod`
`470`	`476`	`{`
`@@ -978,8 +984,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`978`	`984`	`await ModelSendAsync(in method, k.CancellationToken)`
`979`	`985`	`.ConfigureAwait(false);`
`980`	`986`
`981`		`- bool result = await k;`
`982`		`- Debug.Assert(result);`
	`987`	`+ AssertResultIsTrue(await k);`
`983`	`988`	`}`
`984`	`989`	`catch`
`985`	`990`	`{`
`@@ -1108,9 +1113,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`1108`	`1113`
`1109`	`1114`	`try`
`1110`	`1115`	`{`
`1111`		`- bool result = await k;`
`1112`		`- Debug.Assert(result);`
`1113`		`- return;`
	`1116`	`+ AssertResultIsTrue(await k);`
`1114`	`1117`	`}`
`1115`	`1118`	`catch (OperationCanceledException)`
`1116`	`1119`	`{`
`@@ -1143,9 +1146,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`1143`	`1146`
`1144`	`1147`	`try`
`1145`	`1148`	`{`
`1146`		`- bool result = await k;`
`1147`		`- Debug.Assert(result);`
`1148`		`- return;`
	`1149`	`+ AssertResultIsTrue(await k);`
`1149`	`1150`	`}`
`1150`	`1151`	`catch (OperationCanceledException)`
`1151`	`1152`	`{`
`@@ -1187,9 +1188,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`1187`	`1188`
`1188`	`1189`	`try`
`1189`	`1190`	`{`
`1190`		`- bool result = await k;`
`1191`		`- Debug.Assert(result);`
`1192`		`- return;`
	`1191`	`+ AssertResultIsTrue(await k);`
`1193`	`1192`	`}`
`1194`	`1193`	`catch (OperationCanceledException)`
`1195`	`1194`	`{`
`@@ -1240,9 +1239,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`1240`	`1239`
`1241`	`1240`	`try`
`1242`	`1241`	`{`
`1243`		`- bool result = await k;`
`1244`		`- Debug.Assert(result);`
`1245`		`- return;`
	`1242`	`+ AssertResultIsTrue(await k);`
`1246`	`1243`	`}`
`1247`	`1244`	`catch (OperationCanceledException)`
`1248`	`1245`	`{`
`@@ -1286,8 +1283,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`1286`	`1283`
`1287`	`1284`	`try`
`1288`	`1285`	`{`
`1289`		`- bool result = await k;`
`1290`		`- Debug.Assert(result);`
	`1286`	`+ AssertResultIsTrue(await k);`
`1291`	`1287`	`}`
`1292`	`1288`	`catch (OperationCanceledException)`
`1293`	`1289`	`{`
`@@ -1332,8 +1328,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`1332`	`1328`
`1333`	`1329`	`try`
`1334`	`1330`	`{`
`1335`		`- bool result = await k;`
`1336`		`- Debug.Assert(result);`
	`1331`	`+ AssertResultIsTrue(await k);`
`1337`	`1332`	`}`
`1338`	`1333`	`catch (OperationCanceledException)`
`1339`	`1334`	`{`
`@@ -1456,8 +1451,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`1456`	`1451`
`1457`	`1452`	`try`
`1458`	`1453`	`{`
`1459`		`- bool result = await k;`
`1460`		`- Debug.Assert(result);`
	`1454`	`+ AssertResultIsTrue(await k);`
`1461`	`1455`	`}`
`1462`	`1456`	`catch (OperationCanceledException)`
`1463`	`1457`	`{`
`@@ -1587,9 +1581,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`1587`	`1581`
`1588`	`1582`	`try`
`1589`	`1583`	`{`
`1590`		`- bool result = await k;`
`1591`		`- Debug.Assert(result);`
`1592`		`- return;`
	`1584`	`+ AssertResultIsTrue(await k);`
`1593`	`1585`	`}`
`1594`	`1586`	`catch (OperationCanceledException)`
`1595`	`1587`	`{`
`@@ -1621,9 +1613,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`1621`	`1613`
`1622`	`1614`	`try`
`1623`	`1615`	`{`
`1624`		`- bool result = await k;`
`1625`		`- Debug.Assert(result);`
`1626`		`- return;`
	`1616`	`+ AssertResultIsTrue(await k);`
`1627`	`1617`	`}`
`1628`	`1618`	`catch (OperationCanceledException)`
`1629`	`1619`	`{`
`@@ -1655,9 +1645,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`1655`	`1645`
`1656`	`1646`	`try`
`1657`	`1647`	`{`
`1658`		`- bool result = await k;`
`1659`		`- Debug.Assert(result);`
`1660`		`- return;`
	`1648`	`+ AssertResultIsTrue(await k);`
`1661`	`1649`	`}`
`1662`	`1650`	`catch (OperationCanceledException)`
`1663`	`1651`	`{`
`@@ -1689,9 +1677,7 @@ await ModelSendAsync(in method, k.CancellationToken)`
`1689`	`1677`
`1690`	`1678`	`try`
`1691`	`1679`	`{`
`1692`		`- bool result = await k;`
`1693`		`- Debug.Assert(result);`
`1694`		`- return;`
	`1680`	`+ AssertResultIsTrue(await k);`
`1695`	`1681`	`}`
`1696`	`1682`	`catch (OperationCanceledException)`
`1697`	`1683`	`{`