Ensure that PublicAPI.Shipped.txt contains new signatures and method names.

lukebakken · danielmarbach · commit 4be03673c0e0 · 2024-09-19T11:18:57.000+02:00
Ensure code compiles.
diff --git a/projects/Benchmarks/ConsumerDispatching/AsyncBasicConsumerFake.cs b/projects/Benchmarks/ConsumerDispatching/AsyncBasicConsumerFake.cs
@@ -17,8 +17,9 @@ public AsyncBasicConsumerFake(ManualResetEventSlim autoResetEvent)
             _autoResetEvent = autoResetEvent;
         }
 
-        public Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey,
-            IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body)
+        public Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool redelivered,
+            string exchange, string routingKey, IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body,
+            CancellationToken cancellationToken = default)
         {
             if (Interlocked.Increment(ref _current) == Count)
             {
@@ -28,14 +29,16 @@ public Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool
             return Task.CompletedTask;
         }
 
-        public Task HandleBasicCancelAsync(string consumerTag) => Task.CompletedTask;
+        public Task HandleBasicCancelAsync(string consumerTag, CancellationToken cancellationToken = default) => Task.CompletedTask;
 
-        public Task HandleBasicCancelOkAsync(string consumerTag) => Task.CompletedTask;
+        public Task HandleBasicCancelOkAsync(string consumerTag, CancellationToken cancellationToken = default) => Task.CompletedTask;
 
-        public Task HandleBasicConsumeOkAsync(string consumerTag) => Task.CompletedTask;
+        public Task HandleBasicConsumeOkAsync(string consumerTag, CancellationToken cancellationToken = default) => Task.CompletedTask;
 
         public Task HandleChannelShutdownAsync(object channel, ShutdownEventArgs reason) => Task.CompletedTask;
 
+        public Task OnCancelAsync(string[] consumerTags, CancellationToken cancellationToken = default) => Task.CompletedTask;
+
         public IChannel Channel { get; }
     }
 }
diff --git a/projects/Benchmarks/Networking/Networking_BasicDeliver_Commons.cs b/projects/Benchmarks/Networking/Networking_BasicDeliver_Commons.cs
@@ -42,7 +42,9 @@ public CountingConsumer(IChannel channel, uint messageCount) : base(channel)
         }
 
         /// <inheritdoc />
-        public override Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body)
+        public override Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool redelivered,
+            string exchange, string routingKey, IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body,
+            CancellationToken cancellationToken = default)
         {
             if (Interlocked.Decrement(ref _remainingCount) == 0)
             {
diff --git a/projects/RabbitMQ.Client/PublicAPI.Shipped.txt b/projects/RabbitMQ.Client/PublicAPI.Shipped.txt
diff --git a/projects/RabbitMQ.Client/client/api/AsyncDefaultBasicConsumer.cs b/projects/RabbitMQ.Client/client/api/AsyncDefaultBasicConsumer.cs
@@ -57,7 +57,7 @@ public string[] ConsumerTags
         /// <param name="cancellationToken">The cancellation token.</param>
         public virtual Task HandleBasicCancelAsync(string consumerTag, CancellationToken cancellationToken = default)
         {
-            return OnCancelAsync(new []{ consumerTag }, cancellationToken);
+            return OnCancelAsync(new[] { consumerTag }, cancellationToken);
         }
 
         /// <summary>
@@ -67,7 +67,7 @@ public virtual Task HandleBasicCancelAsync(string consumerTag, CancellationToken
         /// <param name="cancellationToken">The cancellation token.</param>
         public virtual Task HandleBasicCancelOkAsync(string consumerTag, CancellationToken cancellationToken = default)
         {
-            return OnCancelAsync(new []{ consumerTag }, cancellationToken);
+            return OnCancelAsync(new[] { consumerTag }, cancellationToken);
         }
 
         /// <summary>
@@ -98,7 +98,7 @@ public virtual Task HandleBasicDeliverAsync(string consumerTag,
             string exchange,
             string routingKey,
             IReadOnlyBasicProperties properties,
-            ReadOnlyMemory<byte> body, 
+            ReadOnlyMemory<byte> body,
             CancellationToken cancellationToken = default)
         {
             // Nothing to do here.
@@ -118,14 +118,15 @@ public virtual Task HandleChannelShutdownAsync(object channel, ShutdownEventArgs
 
         /// <summary>
         /// Default implementation - overridable in subclasses.</summary>
-        /// <param name="consumerTags">The set of consumer tags that where cancelled</param>
+        /// <param name="consumerTags">The set of consumer tags that were cancelled</param>
         /// <param name="cancellationToken">The cancellation token.</param>
         /// <remarks>
         /// This default implementation simply sets the <see cref="IsRunning"/> property to false, and takes no further action.
         /// </remarks>
         protected virtual Task OnCancelAsync(string[] consumerTags, CancellationToken cancellationToken = default)
         {
             IsRunning = false;
+
             foreach (string consumerTag in consumerTags)
             {
                 _consumerTags.Remove(consumerTag);
diff --git a/projects/Test/Common/TestConnectionRecoveryBase.cs b/projects/Test/Common/TestConnectionRecoveryBase.cs
@@ -278,9 +278,10 @@ public AckingBasicConsumer(IChannel channel, ushort totalMessageCount, TaskCompl
             {
             }
 
-            public override Task PostHandleDeliveryAsync(ulong deliveryTag)
+            public override Task PostHandleDeliveryAsync(ulong deliveryTag,
+                CancellationToken cancellationToken = default)
             {
-                return Channel.BasicAckAsync(deliveryTag, false).AsTask();
+                return Channel.BasicAckAsync(deliveryTag, false, cancellationToken).AsTask();
             }
         }
 
@@ -291,9 +292,10 @@ public NackingBasicConsumer(IChannel channel, ushort totalMessageCount, TaskComp
             {
             }
 
-            public override Task PostHandleDeliveryAsync(ulong deliveryTag)
+            public override Task PostHandleDeliveryAsync(ulong deliveryTag,
+                CancellationToken cancellationToken = default)
             {
-                return Channel.BasicNackAsync(deliveryTag, false, false).AsTask();
+                return Channel.BasicNackAsync(deliveryTag, false, false, cancellationToken).AsTask();
             }
         }
 
@@ -304,9 +306,10 @@ public RejectingBasicConsumer(IChannel channel, ushort totalMessageCount, TaskCo
             {
             }
 
-            public override Task PostHandleDeliveryAsync(ulong deliveryTag)
+            public override Task PostHandleDeliveryAsync(ulong deliveryTag,
+                CancellationToken cancellationToken = default)
             {
-                return Channel.BasicRejectAsync(deliveryTag, false).AsTask();
+                return Channel.BasicRejectAsync(deliveryTag, false, cancellationToken).AsTask();
             }
         }
 
@@ -329,11 +332,12 @@ public override Task HandleBasicDeliverAsync(string consumerTag,
                 string exchange,
                 string routingKey,
                 IReadOnlyBasicProperties properties,
-                ReadOnlyMemory<byte> body)
+                ReadOnlyMemory<byte> body,
+                CancellationToken cancellationToken = default)
             {
                 try
                 {
-                    return PostHandleDeliveryAsync(deliveryTag);
+                    return PostHandleDeliveryAsync(deliveryTag, cancellationToken);
                 }
                 finally
                 {
@@ -345,7 +349,8 @@ public override Task HandleBasicDeliverAsync(string consumerTag,
                 }
             }
 
-            public virtual Task PostHandleDeliveryAsync(ulong deliveryTag)
+            public virtual Task PostHandleDeliveryAsync(ulong deliveryTag,
+                CancellationToken cancellationToken = default)
             {
                 return Task.CompletedTask;
             }
diff --git a/projects/Test/Integration/TestAsyncConsumer.cs b/projects/Test/Integration/TestAsyncConsumer.cs
@@ -780,29 +780,35 @@ public DefaultAsyncConsumer(IChannel channel, string logPrefix, ITestOutputHelpe
                 _output = output;
             }
 
-            public override Task HandleBasicCancelAsync(string consumerTag)
+            public override Task HandleBasicCancelAsync(string consumerTag,
+                CancellationToken cancellationToken = default)
             {
                 _output.WriteLine("[ERROR] {0} HandleBasicCancelAsync {1}", _logPrefix, consumerTag);
-                return base.HandleBasicCancelAsync(consumerTag);
+                return base.HandleBasicCancelAsync(consumerTag, cancellationToken);
             }
 
-            public override Task HandleBasicCancelOkAsync(string consumerTag)
+            public override Task HandleBasicCancelOkAsync(string consumerTag,
+                CancellationToken cancellationToken = default)
             {
                 _output.WriteLine("[ERROR] {0} HandleBasicCancelOkAsync {1}", _logPrefix, consumerTag);
-                return base.HandleBasicCancelOkAsync(consumerTag);
+                return base.HandleBasicCancelOkAsync(consumerTag, cancellationToken);
             }
 
-            public override Task HandleBasicConsumeOkAsync(string consumerTag)
+            public override Task HandleBasicConsumeOkAsync(string consumerTag,
+                CancellationToken cancellationToken = default)
             {
                 _output.WriteLine("[ERROR] {0} HandleBasicConsumeOkAsync {1}", _logPrefix, consumerTag);
-                return base.HandleBasicConsumeOkAsync(consumerTag);
+                return base.HandleBasicConsumeOkAsync(consumerTag, cancellationToken);
             }
 
             public override async Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool redelivered,
-                string exchange, string routingKey, IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body)
+                string exchange, string routingKey, IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body,
+                CancellationToken cancellationToken = default)
             {
                 _output.WriteLine("[ERROR] {0} HandleBasicDeliverAsync {1}", _logPrefix, consumerTag);
-                await base.HandleBasicDeliverAsync(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body);
+                await base.HandleBasicDeliverAsync(consumerTag, deliveryTag, redelivered,
+                    exchange, routingKey, properties, body,
+                    cancellationToken);
             }
 
             public override Task HandleChannelShutdownAsync(object channel, ShutdownEventArgs reason)
@@ -811,10 +817,11 @@ public override Task HandleChannelShutdownAsync(object channel, ShutdownEventArg
                 return base.HandleChannelShutdownAsync(channel, reason);
             }
 
-            public override Task OnCancelAsync(params string[] consumerTags)
+            protected override Task OnCancelAsync(string[] consumerTags,
+                CancellationToken cancellationToken = default)
             {
                 _output.WriteLine("[ERROR] {0} OnCancel {1}", _logPrefix, consumerTags[0]);
-                return base.OnCancelAsync(consumerTags);
+                return base.OnCancelAsync(consumerTags, cancellationToken);
             }
         }
     }
diff --git a/projects/Test/Integration/TestAsyncConsumerCancelNotify.cs b/projects/Test/Integration/TestAsyncConsumerCancelNotify.cs
@@ -30,6 +30,7 @@
 //---------------------------------------------------------------------------
 
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using RabbitMQ.Client;
 using RabbitMQ.Client.Events;
@@ -114,15 +115,16 @@ public CancelNotificationConsumer(IChannel channel, TestAsyncConsumerCancelNotif
                 }
             }
 
-            public override Task HandleBasicCancelAsync(string consumerTag)
+            public override Task HandleBasicCancelAsync(string consumerTag,
+                CancellationToken cancellationToken = default)
             {
                 if (!_eventMode)
                 {
                     _testClass._consumerTag = consumerTag;
                     _testClass._tcs.SetResult(true);
                 }
 
-                return base.HandleBasicCancelAsync(consumerTag);
+                return base.HandleBasicCancelAsync(consumerTag, cancellationToken);
             }
 
             private Task CancelledAsync(object sender, ConsumerEventArgs arg)
diff --git a/projects/Test/Integration/TestAsyncConsumerExceptions.cs b/projects/Test/Integration/TestAsyncConsumerExceptions.cs
@@ -136,7 +136,8 @@ public override Task HandleBasicDeliverAsync(string consumerTag,
                 string exchange,
                 string routingKey,
                 IReadOnlyBasicProperties properties,
-                ReadOnlyMemory<byte> body)
+                ReadOnlyMemory<byte> body,
+                CancellationToken cancellationToken = default)
             {
                 return Task.FromException(TestException);
             }
@@ -148,7 +149,8 @@ public ConsumerFailingOnCancel(IChannel channel) : base(channel)
             {
             }
 
-            public override Task HandleBasicCancelAsync(string consumerTag)
+            public override Task HandleBasicCancelAsync(string consumerTag,
+                CancellationToken cancellationToken = default)
             {
                 return Task.FromException(TestException);
             }
@@ -172,7 +174,8 @@ public ConsumerFailingOnConsumeOk(IChannel channel) : base(channel)
             {
             }
 
-            public override Task HandleBasicConsumeOkAsync(string consumerTag)
+            public override Task HandleBasicConsumeOkAsync(string consumerTag,
+                CancellationToken cancellationToken = default)
             {
                 return Task.FromException(TestException);
             }
@@ -184,7 +187,8 @@ public ConsumerFailingOnCancelOk(IChannel channel) : base(channel)
             {
             }
 
-            public override Task HandleBasicCancelOkAsync(string consumerTag)
+            public override Task HandleBasicCancelOkAsync(string consumerTag,
+                CancellationToken cancellationToken = default)
             {
                 return Task.FromException(TestException);
             }
diff --git a/projects/Test/Integration/TestAsyncConsumerOperationDispatch.cs b/projects/Test/Integration/TestAsyncConsumerOperationDispatch.cs
@@ -86,7 +86,8 @@ public CollectingConsumer(IChannel channel)
 
             public override Task HandleBasicDeliverAsync(string consumerTag,
                 ulong deliveryTag, bool redelivered, string exchange, string routingKey,
-                IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body)
+                IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body,
+                CancellationToken cancellationToken = default)
             {
                 // we test concurrent dispatch from the moment basic.delivery is returned.
                 // delivery tags have guaranteed ordering and we verify that it is preserved
@@ -98,7 +99,8 @@ public override Task HandleBasicDeliverAsync(string consumerTag,
                     s_counter.Signal();
                 }
 
-                return Channel.BasicAckAsync(deliveryTag: deliveryTag, multiple: false).AsTask();
+                return Channel.BasicAckAsync(deliveryTag: deliveryTag, multiple: false,
+                    cancellationToken: cancellationToken).AsTask();
             }
         }
 
diff --git a/projects/Test/Integration/TestMainLoop.cs b/projects/Test/Integration/TestMainLoop.cs
@@ -30,6 +30,7 @@
 //---------------------------------------------------------------------------
 
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using RabbitMQ.Client;
 using RabbitMQ.Client.Events;
@@ -62,7 +63,8 @@ public override Task HandleBasicDeliverAsync(string consumerTag,
                 string exchange,
                 string routingKey,
                 IReadOnlyBasicProperties properties,
-                ReadOnlyMemory<byte> body)
+                ReadOnlyMemory<byte> body,
+                CancellationToken cancellationToken = default)
             {
                 throw new Exception("I am a bad consumer");
             }
diff --git a/projects/Test/SequentialIntegration/TestConnectionBlocked.cs b/projects/Test/SequentialIntegration/TestConnectionBlocked.cs
@@ -66,7 +66,7 @@ public async Task TestConnectionBlockedNotification()
                 await UnblockAsync();
             };
 
-            _conn.ConnectionUnblockedAsync += (object sender, EventArgs ea) =>
+            _conn.ConnectionUnblockedAsync += (object sender, AsyncEventArgs ea) =>
             {
                 tcs.SetResult(true);
                 return Task.CompletedTask;
diff --git a/projects/Test/SequentialIntegration/TestConnectionBlockedChannelLeak.cs b/projects/Test/SequentialIntegration/TestConnectionBlockedChannelLeak.cs
@@ -88,7 +88,7 @@ public async Task TestConnectionBlockedChannelLeak_GH1573()
                 return Task.CompletedTask;
             };
 
-            _conn.ConnectionUnblockedAsync += (object sender, EventArgs ea) =>
+            _conn.ConnectionUnblockedAsync += (object sender, AsyncEventArgs ea) =>
             {
                 connectionUnblockedTcs.SetResult(true);
                 return Task.CompletedTask;

Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,9 @@ public AsyncBasicConsumerFake(ManualResetEventSlim autoResetEvent)`
`17`	`17`	`_autoResetEvent = autoResetEvent;`
`18`	`18`	`}`
`19`	`19`
`20`		`- public Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey,`
`21`		`- IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body)`
	`20`	`+ public Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool redelivered,`
	`21`	`+ string exchange, string routingKey, IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body,`
	`22`	`+ CancellationToken cancellationToken = default)`
`22`	`23`	`{`
`23`	`24`	`if (Interlocked.Increment(ref _current) == Count)`
`24`	`25`	`{`
`@@ -28,14 +29,16 @@ public Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool`
`28`	`29`	`return Task.CompletedTask;`
`29`	`30`	`}`
`30`	`31`
`31`		`- public Task HandleBasicCancelAsync(string consumerTag) => Task.CompletedTask;`
	`32`	`+ public Task HandleBasicCancelAsync(string consumerTag, CancellationToken cancellationToken = default) => Task.CompletedTask;`
`32`	`33`
`33`		`- public Task HandleBasicCancelOkAsync(string consumerTag) => Task.CompletedTask;`
	`34`	`+ public Task HandleBasicCancelOkAsync(string consumerTag, CancellationToken cancellationToken = default) => Task.CompletedTask;`
`34`	`35`
`35`		`- public Task HandleBasicConsumeOkAsync(string consumerTag) => Task.CompletedTask;`
	`36`	`+ public Task HandleBasicConsumeOkAsync(string consumerTag, CancellationToken cancellationToken = default) => Task.CompletedTask;`
`36`	`37`
`37`	`38`	`public Task HandleChannelShutdownAsync(object channel, ShutdownEventArgs reason) => Task.CompletedTask;`
`38`	`39`
	`40`	`+ public Task OnCancelAsync(string[] consumerTags, CancellationToken cancellationToken = default) => Task.CompletedTask;`
	`41`	`+`
`39`	`42`	`public IChannel Channel { get; }`
`40`	`43`	`}`
`41`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,9 @@ public CountingConsumer(IChannel channel, uint messageCount) : base(channel)`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`/// <inheritdoc />`
`45`		`- public override Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body)`
	`45`	`+ public override Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool redelivered,`
	`46`	`+ string exchange, string routingKey, IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body,`
	`47`	`+ CancellationToken cancellationToken = default)`
`46`	`48`	`{`
`47`	`49`	`if (Interlocked.Decrement(ref _remainingCount) == 0)`
`48`	`50`	`{`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public string[] ConsumerTags`
`57`	`57`	`/// <param name="cancellationToken">The cancellation token.</param>`
`58`	`58`	`public virtual Task HandleBasicCancelAsync(string consumerTag, CancellationToken cancellationToken = default)`
`59`	`59`	`{`
`60`		`- return OnCancelAsync(new []{ consumerTag }, cancellationToken);`
	`60`	`+ return OnCancelAsync(new[] { consumerTag }, cancellationToken);`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`/// <summary>`
`@@ -67,7 +67,7 @@ public virtual Task HandleBasicCancelAsync(string consumerTag, CancellationToken`
`67`	`67`	`/// <param name="cancellationToken">The cancellation token.</param>`
`68`	`68`	`public virtual Task HandleBasicCancelOkAsync(string consumerTag, CancellationToken cancellationToken = default)`
`69`	`69`	`{`
`70`		`- return OnCancelAsync(new []{ consumerTag }, cancellationToken);`
	`70`	`+ return OnCancelAsync(new[] { consumerTag }, cancellationToken);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`/// <summary>`
`@@ -98,7 +98,7 @@ public virtual Task HandleBasicDeliverAsync(string consumerTag,`
`98`	`98`	`string exchange,`
`99`	`99`	`string routingKey,`
`100`	`100`	`IReadOnlyBasicProperties properties,`
`101`		`- ReadOnlyMemory<byte> body,`
	`101`	`+ ReadOnlyMemory<byte> body,`
`102`	`102`	`CancellationToken cancellationToken = default)`
`103`	`103`	`{`
`104`	`104`	`// Nothing to do here.`
`@@ -118,14 +118,15 @@ public virtual Task HandleChannelShutdownAsync(object channel, ShutdownEventArgs`
`118`	`118`
`119`	`119`	`/// <summary>`
`120`	`120`	`/// Default implementation - overridable in subclasses.</summary>`
`121`		`- /// <param name="consumerTags">The set of consumer tags that where cancelled</param>`
	`121`	`+ /// <param name="consumerTags">The set of consumer tags that were cancelled</param>`
`122`	`122`	`/// <param name="cancellationToken">The cancellation token.</param>`
`123`	`123`	`/// <remarks>`
`124`	`124`	`/// This default implementation simply sets the <see cref="IsRunning"/> property to false, and takes no further action.`
`125`	`125`	`/// </remarks>`
`126`	`126`	`protected virtual Task OnCancelAsync(string[] consumerTags, CancellationToken cancellationToken = default)`
`127`	`127`	`{`
`128`	`128`	`IsRunning = false;`
	`129`	`+`
`129`	`130`	`foreach (string consumerTag in consumerTags)`
`130`	`131`	`{`
`131`	`132`	`_consumerTags.Remove(consumerTag);`
Original file line number	Diff line number	Diff line change
`@@ -278,9 +278,10 @@ public AckingBasicConsumer(IChannel channel, ushort totalMessageCount, TaskCompl`
`278`	`278`	`{`
`279`	`279`	`}`
`280`	`280`
`281`		`- public override Task PostHandleDeliveryAsync(ulong deliveryTag)`
	`281`	`+ public override Task PostHandleDeliveryAsync(ulong deliveryTag,`
	`282`	`+ CancellationToken cancellationToken = default)`
`282`	`283`	`{`
`283`		`- return Channel.BasicAckAsync(deliveryTag, false).AsTask();`
	`284`	`+ return Channel.BasicAckAsync(deliveryTag, false, cancellationToken).AsTask();`
`284`	`285`	`}`
`285`	`286`	`}`
`286`	`287`
`@@ -291,9 +292,10 @@ public NackingBasicConsumer(IChannel channel, ushort totalMessageCount, TaskComp`
`291`	`292`	`{`
`292`	`293`	`}`
`293`	`294`
`294`		`- public override Task PostHandleDeliveryAsync(ulong deliveryTag)`
	`295`	`+ public override Task PostHandleDeliveryAsync(ulong deliveryTag,`
	`296`	`+ CancellationToken cancellationToken = default)`
`295`	`297`	`{`
`296`		`- return Channel.BasicNackAsync(deliveryTag, false, false).AsTask();`
	`298`	`+ return Channel.BasicNackAsync(deliveryTag, false, false, cancellationToken).AsTask();`
`297`	`299`	`}`
`298`	`300`	`}`
`299`	`301`
`@@ -304,9 +306,10 @@ public RejectingBasicConsumer(IChannel channel, ushort totalMessageCount, TaskCo`
`304`	`306`	`{`
`305`	`307`	`}`
`306`	`308`
`307`		`- public override Task PostHandleDeliveryAsync(ulong deliveryTag)`
	`309`	`+ public override Task PostHandleDeliveryAsync(ulong deliveryTag,`
	`310`	`+ CancellationToken cancellationToken = default)`
`308`	`311`	`{`
`309`		`- return Channel.BasicRejectAsync(deliveryTag, false).AsTask();`
	`312`	`+ return Channel.BasicRejectAsync(deliveryTag, false, cancellationToken).AsTask();`
`310`	`313`	`}`
`311`	`314`	`}`
`312`	`315`
`@@ -329,11 +332,12 @@ public override Task HandleBasicDeliverAsync(string consumerTag,`
`329`	`332`	`string exchange,`
`330`	`333`	`string routingKey,`
`331`	`334`	`IReadOnlyBasicProperties properties,`
`332`		`- ReadOnlyMemory<byte> body)`
	`335`	`+ ReadOnlyMemory<byte> body,`
	`336`	`+ CancellationToken cancellationToken = default)`
`333`	`337`	`{`
`334`	`338`	`try`
`335`	`339`	`{`
`336`		`- return PostHandleDeliveryAsync(deliveryTag);`
	`340`	`+ return PostHandleDeliveryAsync(deliveryTag, cancellationToken);`
`337`	`341`	`}`
`338`	`342`	`finally`
`339`	`343`	`{`
`@@ -345,7 +349,8 @@ public override Task HandleBasicDeliverAsync(string consumerTag,`
`345`	`349`	`}`
`346`	`350`	`}`
`347`	`351`
`348`		`- public virtual Task PostHandleDeliveryAsync(ulong deliveryTag)`
	`352`	`+ public virtual Task PostHandleDeliveryAsync(ulong deliveryTag,`
	`353`	`+ CancellationToken cancellationToken = default)`
`349`	`354`	`{`
`350`	`355`	`return Task.CompletedTask;`
`351`	`356`	`}`
Original file line number	Diff line number	Diff line change
`@@ -780,29 +780,35 @@ public DefaultAsyncConsumer(IChannel channel, string logPrefix, ITestOutputHelpe`
`780`	`780`	`_output = output;`
`781`	`781`	`}`
`782`	`782`
`783`		`- public override Task HandleBasicCancelAsync(string consumerTag)`
	`783`	`+ public override Task HandleBasicCancelAsync(string consumerTag,`
	`784`	`+ CancellationToken cancellationToken = default)`
`784`	`785`	`{`
`785`	`786`	`_output.WriteLine("[ERROR] {0} HandleBasicCancelAsync {1}", _logPrefix, consumerTag);`
`786`		`- return base.HandleBasicCancelAsync(consumerTag);`
	`787`	`+ return base.HandleBasicCancelAsync(consumerTag, cancellationToken);`
`787`	`788`	`}`
`788`	`789`
`789`		`- public override Task HandleBasicCancelOkAsync(string consumerTag)`
	`790`	`+ public override Task HandleBasicCancelOkAsync(string consumerTag,`
	`791`	`+ CancellationToken cancellationToken = default)`
`790`	`792`	`{`
`791`	`793`	`_output.WriteLine("[ERROR] {0} HandleBasicCancelOkAsync {1}", _logPrefix, consumerTag);`
`792`		`- return base.HandleBasicCancelOkAsync(consumerTag);`
	`794`	`+ return base.HandleBasicCancelOkAsync(consumerTag, cancellationToken);`
`793`	`795`	`}`
`794`	`796`
`795`		`- public override Task HandleBasicConsumeOkAsync(string consumerTag)`
	`797`	`+ public override Task HandleBasicConsumeOkAsync(string consumerTag,`
	`798`	`+ CancellationToken cancellationToken = default)`
`796`	`799`	`{`
`797`	`800`	`_output.WriteLine("[ERROR] {0} HandleBasicConsumeOkAsync {1}", _logPrefix, consumerTag);`
`798`		`- return base.HandleBasicConsumeOkAsync(consumerTag);`
	`801`	`+ return base.HandleBasicConsumeOkAsync(consumerTag, cancellationToken);`
`799`	`802`	`}`
`800`	`803`
`801`	`804`	`public override async Task HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool redelivered,`
`802`		`- string exchange, string routingKey, IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body)`
	`805`	`+ string exchange, string routingKey, IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body,`
	`806`	`+ CancellationToken cancellationToken = default)`
`803`	`807`	`{`
`804`	`808`	`_output.WriteLine("[ERROR] {0} HandleBasicDeliverAsync {1}", _logPrefix, consumerTag);`
`805`		`- await base.HandleBasicDeliverAsync(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body);`
	`809`	`+ await base.HandleBasicDeliverAsync(consumerTag, deliveryTag, redelivered,`
	`810`	`+ exchange, routingKey, properties, body,`
	`811`	`+ cancellationToken);`
`806`	`812`	`}`
`807`	`813`
`808`	`814`	`public override Task HandleChannelShutdownAsync(object channel, ShutdownEventArgs reason)`
`@@ -811,10 +817,11 @@ public override Task HandleChannelShutdownAsync(object channel, ShutdownEventArg`
`811`	`817`	`return base.HandleChannelShutdownAsync(channel, reason);`
`812`	`818`	`}`
`813`	`819`
`814`		`- public override Task OnCancelAsync(params string[] consumerTags)`
	`820`	`+ protected override Task OnCancelAsync(string[] consumerTags,`
	`821`	`+ CancellationToken cancellationToken = default)`
`815`	`822`	`{`
`816`	`823`	`_output.WriteLine("[ERROR] {0} OnCancel {1}", _logPrefix, consumerTags[0]);`
`817`		`- return base.OnCancelAsync(consumerTags);`
	`824`	`+ return base.OnCancelAsync(consumerTags, cancellationToken);`
`818`	`825`	`}`
`819`	`826`	`}`
`820`	`827`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@`
`30`	`30`	`//---------------------------------------------------------------------------`
`31`	`31`
`32`	`32`	`using System.Linq;`
	`33`	`+using System.Threading;`
`33`	`34`	`using System.Threading.Tasks;`
`34`	`35`	`using RabbitMQ.Client;`
`35`	`36`	`using RabbitMQ.Client.Events;`
`@@ -114,15 +115,16 @@ public CancelNotificationConsumer(IChannel channel, TestAsyncConsumerCancelNotif`
`114`	`115`	`}`
`115`	`116`	`}`
`116`	`117`
`117`		`- public override Task HandleBasicCancelAsync(string consumerTag)`
	`118`	`+ public override Task HandleBasicCancelAsync(string consumerTag,`
	`119`	`+ CancellationToken cancellationToken = default)`
`118`	`120`	`{`
`119`	`121`	`if (!_eventMode)`
`120`	`122`	`{`
`121`	`123`	`_testClass._consumerTag = consumerTag;`
`122`	`124`	`_testClass._tcs.SetResult(true);`
`123`	`125`	`}`
`124`	`126`
`125`		`- return base.HandleBasicCancelAsync(consumerTag);`
	`127`	`+ return base.HandleBasicCancelAsync(consumerTag, cancellationToken);`
`126`	`128`	`}`
`127`	`129`
`128`	`130`	`private Task CancelledAsync(object sender, ConsumerEventArgs arg)`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,8 @@ public override Task HandleBasicDeliverAsync(string consumerTag,`
`136`	`136`	`string exchange,`
`137`	`137`	`string routingKey,`
`138`	`138`	`IReadOnlyBasicProperties properties,`
`139`		`- ReadOnlyMemory<byte> body)`
	`139`	`+ ReadOnlyMemory<byte> body,`
	`140`	`+ CancellationToken cancellationToken = default)`
`140`	`141`	`{`
`141`	`142`	`return Task.FromException(TestException);`
`142`	`143`	`}`
`@@ -148,7 +149,8 @@ public ConsumerFailingOnCancel(IChannel channel) : base(channel)`
`148`	`149`	`{`
`149`	`150`	`}`
`150`	`151`
`151`		`- public override Task HandleBasicCancelAsync(string consumerTag)`
	`152`	`+ public override Task HandleBasicCancelAsync(string consumerTag,`
	`153`	`+ CancellationToken cancellationToken = default)`
`152`	`154`	`{`
`153`	`155`	`return Task.FromException(TestException);`
`154`	`156`	`}`
`@@ -172,7 +174,8 @@ public ConsumerFailingOnConsumeOk(IChannel channel) : base(channel)`
`172`	`174`	`{`
`173`	`175`	`}`
`174`	`176`
`175`		`- public override Task HandleBasicConsumeOkAsync(string consumerTag)`
	`177`	`+ public override Task HandleBasicConsumeOkAsync(string consumerTag,`
	`178`	`+ CancellationToken cancellationToken = default)`
`176`	`179`	`{`
`177`	`180`	`return Task.FromException(TestException);`
`178`	`181`	`}`
`@@ -184,7 +187,8 @@ public ConsumerFailingOnCancelOk(IChannel channel) : base(channel)`
`184`	`187`	`{`
`185`	`188`	`}`
`186`	`189`
`187`		`- public override Task HandleBasicCancelOkAsync(string consumerTag)`
	`190`	`+ public override Task HandleBasicCancelOkAsync(string consumerTag,`
	`191`	`+ CancellationToken cancellationToken = default)`
`188`	`192`	`{`
`189`	`193`	`return Task.FromException(TestException);`
`190`	`194`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,8 @@ public CollectingConsumer(IChannel channel)`
`86`	`86`
`87`	`87`	`public override Task HandleBasicDeliverAsync(string consumerTag,`
`88`	`88`	`ulong deliveryTag, bool redelivered, string exchange, string routingKey,`
`89`		`- IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body)`
	`89`	`+ IReadOnlyBasicProperties properties, ReadOnlyMemory<byte> body,`
	`90`	`+ CancellationToken cancellationToken = default)`
`90`	`91`	`{`
`91`	`92`	`// we test concurrent dispatch from the moment basic.delivery is returned.`
`92`	`93`	`// delivery tags have guaranteed ordering and we verify that it is preserved`
`@@ -98,7 +99,8 @@ public override Task HandleBasicDeliverAsync(string consumerTag,`
`98`	`99`	`s_counter.Signal();`
`99`	`100`	`}`
`100`	`101`
`101`		`- return Channel.BasicAckAsync(deliveryTag: deliveryTag, multiple: false).AsTask();`
	`102`	`+ return Channel.BasicAckAsync(deliveryTag: deliveryTag, multiple: false,`
	`103`	`+ cancellationToken: cancellationToken).AsTask();`
`102`	`104`	`}`
`103`	`105`	`}`
`104`	`106`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ public async Task TestConnectionBlockedNotification()`
`66`	`66`	`await UnblockAsync();`
`67`	`67`	`};`
`68`	`68`
`69`		`- _conn.ConnectionUnblockedAsync += (object sender, EventArgs ea) =>`
	`69`	`+ _conn.ConnectionUnblockedAsync += (object sender, AsyncEventArgs ea) =>`
`70`	`70`	`{`
`71`	`71`	`tcs.SetResult(true);`
`72`	`72`	`return Task.CompletedTask;`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ public async Task TestConnectionBlockedChannelLeak_GH1573()`
`88`	`88`	`return Task.CompletedTask;`
`89`	`89`	`};`
`90`	`90`
`91`		`- _conn.ConnectionUnblockedAsync += (object sender, EventArgs ea) =>`
	`91`	`+ _conn.ConnectionUnblockedAsync += (object sender, AsyncEventArgs ea) =>`
`92`	`92`	`{`
`93`	`93`	`connectionUnblockedTcs.SetResult(true);`
`94`	`94`	`return Task.CompletedTask;`