use CancelAfter if possible

Author: smdn

tests/Smdn.Net.EchonetLite.Primitives/Smdn.Net.EchonetLite.Transport/EchonetLiteHandler.Receiving.cs

@@ -16,6 +16,8 @@ namespace Smdn.Net.EchonetLite.Transport;
 #pragma warning disable IDE0040
 partial class EchonetLiteHandlerTests {
 #pragma warning restore IDE0040
+  private const int TimeoutInMillisecondsForReceiveOperationExpectedToSucceed = 5_000;
+
   private class PseudoIncomingEchonetLiteHandler : EchonetLiteHandler {
     private readonly ConcurrentQueue<Func<IBufferWriter<byte>, CancellationToken, ValueTask<IPAddress>>> incomingActionQueue = new();
 
@@ -83,7 +85,8 @@ CancellationToken cancellationToken
   }
 
   [Test]
-  public async Task ReceiveCallback()
+  [CancelAfter(TimeoutInMillisecondsForReceiveOperationExpectedToSucceed)]
+  public async Task ReceiveCallback(CancellationToken cancellationToken)
   {
     var expectedFromAddress = IPAddress.Loopback;
     var expectedData = new byte[] { 0x01, 0x23 };
@@ -96,7 +99,7 @@ public async Task ReceiveCallback()
     var numberOfCallsToReceiveCallback = 0;
     Exception? exceptionOccurredInReceiveCallback = null;
 
-    handler.ReceiveCallback = async (address, data, cancellationToken) => {
+    handler.ReceiveCallback = async (address, data, ct) => {
       numberOfCallsToReceiveCallback++;
 
       try {
@@ -114,24 +117,23 @@ public async Task ReceiveCallback()
 
     Assert.That(handler.ReceiveCallback, Is.Not.Null);
 
-    handler.QueueIncomingAction((writer, cancellationToken) => {
+    handler.QueueIncomingAction((writer, ct) => {
       writer.Write(expectedData);
 
       return new(expectedFromAddress);
     });
 
-    using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-
-    await handler.WaitUntilConsumedAsync(cts.Token);
+    await handler.WaitUntilConsumedAsync(cancellationToken);
 
-    callsToReceiveCallbackEvent.Wait(cts.Token);
+    callsToReceiveCallbackEvent.Wait(cancellationToken);
 
     Assert.That(numberOfCallsToReceiveCallback, Is.EqualTo(1));
     Assert.That(exceptionOccurredInReceiveCallback, Is.Null);
   }
 
   [Test]
-  public async Task ReceiveCallback_Null()
+  [CancelAfter(TimeoutInMillisecondsForReceiveOperationExpectedToSucceed)]
+  public async Task ReceiveCallback_Null(CancellationToken cancellationToken)
   {
     var expectedFromAddress = IPAddress.Loopback;
     var expectedData = new byte[] { 0x01, 0x23 };
@@ -144,19 +146,18 @@ public async Task ReceiveCallback_Null()
 
     Assert.That(handler.ReceiveCallback, Is.Null);
 
-    handler.QueueIncomingAction((writer, cancellationToken) => {
+    handler.QueueIncomingAction((writer, ct) => {
       writer.Write(expectedData);
 
       return new(expectedFromAddress);
     });
 
-    using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-
-    await handler.WaitUntilConsumedAsync(cts.Token);
+    await handler.WaitUntilConsumedAsync(cancellationToken);
   }
 
   [Test]
-  public async Task ReceiveEchonetLiteAsync_ReceiveFromNullAddress()
+  [CancelAfter(TimeoutInMillisecondsForReceiveOperationExpectedToSucceed)]
+  public async Task ReceiveEchonetLiteAsync_ReceiveFromNullAddress(CancellationToken cancellationToken)
   {
     IPAddress nullFromAddress = null!;
     var expectedData = new byte[] { 0x01, 0x23 };
@@ -170,7 +171,7 @@ public async Task ReceiveEchonetLiteAsync_ReceiveFromNullAddress()
     var numberOfCallsToReceiveTaskExceptionHandler = 0;
     Exception? exceptionOccurredInReceiveEchonetLiteAsync = null;
 
-    handler.ReceiveCallback = (address, data, cancellationToken) => {
+    handler.ReceiveCallback = (address, data, ct) => {
       numberOfCallsToReceiveCallback++;
 
       return default;
@@ -186,26 +187,25 @@ public async Task ReceiveEchonetLiteAsync_ReceiveFromNullAddress()
     };
 
     handler.QueueIncomingAction(
-      (writer, cancellationToken) => {
+      (writer, ct) => {
         writer.Write(expectedData);
 
         return new(nullFromAddress); // return null as a remote address
       }
     );
 
-    using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+    await handler.WaitUntilConsumedAsync(cancellationToken);
 
-    await handler.WaitUntilConsumedAsync(cts.Token);
-
-    callsToReceiveTaskExceptionHandlerEvent.Wait(cts.Token);
+    callsToReceiveTaskExceptionHandlerEvent.Wait(cancellationToken);
 
     Assert.That(numberOfCallsToReceiveCallback, Is.Zero);
     Assert.That(numberOfCallsToReceiveTaskExceptionHandler, Is.EqualTo(1));
     Assert.That(exceptionOccurredInReceiveEchonetLiteAsync, Is.InstanceOf<InvalidOperationException>());
   }
 
   [Test]
-  public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveAsyncCore()
+  [CancelAfter(TimeoutInMillisecondsForReceiveOperationExpectedToSucceed)]
+  public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveAsyncCore(CancellationToken cancellationToken)
   {
     using var callsToReceiveTaskExceptionHandlerEvent = new ManualResetEventSlim(false);
     using var handler = new PseudoIncomingEchonetLiteHandler();
@@ -215,7 +215,7 @@ public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveAsyncCore()
     var numberOfCallsToReceiveCallback = 0;
     var numberOfCallsToReceiveTaskExceptionHandler = 0;
 
-    handler.ReceiveCallback = (address, data, cancellationToken) => {
+    handler.ReceiveCallback = (address, data, ct) => {
       numberOfCallsToReceiveCallback++;
 
       return default;
@@ -234,11 +234,9 @@ public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveAsyncCore()
       (writer, cancellationToken) => throw new NotImplementedException()
     );
 
-    using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-
-    await handler.WaitUntilConsumedAsync(cts.Token);
+    await handler.WaitUntilConsumedAsync(cancellationToken);
 
-    callsToReceiveTaskExceptionHandlerEvent.Wait(cts.Token);
+    callsToReceiveTaskExceptionHandlerEvent.Wait(cancellationToken);
 
     Assert.That(numberOfCallsToReceiveCallback, Is.Zero);
     Assert.That(numberOfCallsToReceiveTaskExceptionHandler, Is.EqualTo(1));
@@ -247,7 +245,7 @@ public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveAsyncCore()
     // following inputs must be processed successfully
     using var callsToReceiveCallbackEvent = new ManualResetEventSlim(false);
 
-    handler.ReceiveCallback = (address, data, cancellationToken) => {
+    handler.ReceiveCallback = (address, data, ct) => {
       numberOfCallsToReceiveCallback++;
 
       callsToReceiveCallbackEvent.Set();
@@ -263,15 +261,16 @@ public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveAsyncCore()
       }
     );
 
-    await handler.WaitUntilConsumedAsync(cts.Token);
+    await handler.WaitUntilConsumedAsync(cancellationToken);
 
-    callsToReceiveCallbackEvent.Wait(cts.Token);
+    callsToReceiveCallbackEvent.Wait(cancellationToken);
 
     Assert.That(numberOfCallsToReceiveCallback, Is.EqualTo(1));
   }
 
   [Test]
-  public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveCallback()
+  [CancelAfter(TimeoutInMillisecondsForReceiveOperationExpectedToSucceed)]
+  public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveCallback(CancellationToken cancellationToken)
   {
     var expectedFromAddress = IPAddress.Loopback;
     var expectedData = new byte[] { 0x01, 0x23 };
@@ -285,7 +284,7 @@ public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveCallback()
     var numberOfCallsToReceiveCallback = 0;
     var numberOfCallsToReceiveTaskExceptionHandler = 0;
 
-    handler.ReceiveCallback = (address, data, cancellationToken) => {
+    handler.ReceiveCallback = (address, data, ct) => {
       numberOfCallsToReceiveCallback++;
 
       throw new NotImplementedException();
@@ -307,11 +306,9 @@ public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveCallback()
       }
     );
 
-    using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-
-    await handler.WaitUntilConsumedAsync(cts.Token);
+    await handler.WaitUntilConsumedAsync(cancellationToken);
 
-    callsToReceiveTaskExceptionHandlerEvent.Wait(cts.Token);
+    callsToReceiveTaskExceptionHandlerEvent.Wait(cancellationToken);
 
     Assert.That(numberOfCallsToReceiveCallback, Is.EqualTo(1));
     Assert.That(numberOfCallsToReceiveTaskExceptionHandler, Is.EqualTo(1));
@@ -320,7 +317,7 @@ public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveCallback()
     // following inputs must be processed successfully
     using var callsToReceiveCallbackEvent = new ManualResetEventSlim(false);
 
-    handler.ReceiveCallback = (address, data, cancellationToken) => {
+    handler.ReceiveCallback = (address, data, ct) => {
       numberOfCallsToReceiveCallback++;
 
       callsToReceiveCallbackEvent.Set();
@@ -336,9 +333,9 @@ public async Task ReceiveEchonetLiteAsync_ExceptionOccurredInReceiveCallback()
       }
     );
 
-    await handler.WaitUntilConsumedAsync(cts.Token);
+    await handler.WaitUntilConsumedAsync(cancellationToken);
 
-    callsToReceiveCallbackEvent.Wait(cts.Token);
+    callsToReceiveCallbackEvent.Wait(cancellationToken);
 
     Assert.That(numberOfCallsToReceiveCallback, Is.EqualTo(2));
   }

tests/Smdn.Net.EchonetLite.Primitives/Smdn.Net.EchonetLite.Transport/EchonetLiteHandler.cs

@@ -186,15 +186,16 @@ public void SendAsync_CancellationRequested()
 
     handler.StartReceiving();
 
-    using var cts = new CancellationTokenSource();
-
-    cts.Cancel();
+    var cancellationToken = new CancellationToken(canceled: true);
 
     Assert.That(
-      async () => await handler.SendAsync(data: default, cancellationToken: cts.Token),
+      async () => await handler.SendAsync(
+        data: default,
+        cancellationToken: cancellationToken
+      ),
       Throws
         .InstanceOf<OperationCanceledException>()
-        .With.Property(nameof(OperationCanceledException.CancellationToken)).EqualTo(cts.Token)
+        .With.Property(nameof(OperationCanceledException.CancellationToken)).EqualTo(cancellationToken)
     );
   }
 
@@ -242,15 +243,17 @@ public void SendToAsync_CancellationRequested()
 
     handler.StartReceiving();
 
-    using var cts = new CancellationTokenSource();
-
-    cts.Cancel();
+    var cancellationToken = new CancellationToken(canceled: true);
 
     Assert.That(
-      async () => await handler.SendToAsync(remoteAddress: IPAddress.Loopback, data: default, cancellationToken: cts.Token),
+      async () => await handler.SendToAsync(
+        remoteAddress: IPAddress.Loopback,
+        data: default,
+        cancellationToken: cancellationToken
+      ),
       Throws
         .InstanceOf<OperationCanceledException>()
-        .With.Property(nameof(OperationCanceledException.CancellationToken)).EqualTo(cts.Token)
+        .With.Property(nameof(OperationCanceledException.CancellationToken)).EqualTo(cancellationToken)
     );
   }
 }

tests/Smdn.Net.EchonetLite.RouteB.Primitives/Smdn.Net.EchonetLite.RouteB.Transport/RouteBEchonetLiteHandler.cs

@@ -122,20 +122,23 @@ public void ConnectAsync_CancellationRequested()
   {
     using var handler = new PseudoRouteBEchonetLiteHandler();
     using var credential = new PseudoRouteBCredential();
-    using var cts = new CancellationTokenSource();
-
-    cts.Cancel();
 
     Assert.That(handler.IsReceiving, Is.False, $"{nameof(handler.IsReceiving)} before attempting connection");
 
     Assert.That(
-      async () => await handler.ConnectAsync(credential: credential, cancellationToken: cts.Token),
+      async () => await handler.ConnectAsync(
+        credential: credential,
+        cancellationToken: new(canceled: true)
+      ),
       Throws.InstanceOf<OperationCanceledException>()
     );
 
 #pragma warning disable CA2012
     Assert.That(
-      handler.ConnectAsync(credential: credential, cancellationToken: cts.Token).IsCanceled,
+      handler.ConnectAsync(
+        credential: credential,
+        cancellationToken: new(canceled: true)
+      ).IsCanceled,
       Is.True
     );
 #pragma warning restore CA2012
@@ -195,20 +198,18 @@ public async Task DisconnectAsync_CancellationRequested()
 
     await handler.ConnectAsync(credential: credential);
 
-    using var cts = new CancellationTokenSource();
-
-    cts.Cancel();
-
     Assert.That(handler.IsReceiving, Is.True, $"{nameof(handler.IsReceiving)} before attempting disconnection");
 
     Assert.That(
-      async () => await handler.DisconnectAsync(cancellationToken: cts.Token),
+      async () => await handler.DisconnectAsync(cancellationToken: new(canceled: true)),
       Throws.InstanceOf<OperationCanceledException>()
     );
 
 #pragma warning disable CA2012
     Assert.That(
-      handler.DisconnectAsync(cancellationToken: cts.Token).IsCanceled,
+      handler.DisconnectAsync(
+        cancellationToken: new(canceled: true)
+      ).IsCanceled,
       Is.True
     );
 #pragma warning restore CA2012

tests/Smdn.Net.EchonetLite/Smdn.Net.EchonetLite/EchonetClient.Events.cs

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2024 smdn <smdn@smdn.jp>
 // SPDX-License-Identifier: MIT
 using System.Net;
+using System.Threading;
 
 using NUnit.Framework;
 
@@ -16,7 +17,8 @@ public partial class EchonetClientEventsTests {
   [TestCase(ESV.SetGetServiceNotAvailable)]
   [TestCase(ESV.Inf)]
   [TestCase(ESV.InfC)]
-  public void InstanceListUpdating_InstanceListUpdated(ESV esv)
+  [CancelAfter(EchonetClientTests.TimeoutInMillisecondsForOperationExpectedToSucceed)]
+  public void InstanceListUpdating_InstanceListUpdated(ESV esv, CancellationToken cancellationToken)
   {
     var receiveFromAddress = IPAddress.Loopback;
     var handler = new ReceiveInstanceListEchonetLiteHandler(
@@ -47,13 +49,11 @@ public void InstanceListUpdating_InstanceListUpdated(ESV esv)
       Assert.That(e.Node.Address, Is.EqualTo(receiveFromAddress));
     };
 
-    using var cts = EchonetClientTests.CreateTimeoutCancellationTokenSourceForOperationExpectedToSucceed();
-
     Assert.That(
       async () => await handler.PerformReceivingAsync(
         receiveFromAddress: receiveFromAddress,
         esv: esv,
-        cancellationToken: cts.Token
+        cancellationToken: cancellationToken
       ),
       Throws.Nothing
     );