Fix bug with SendExtAcknowledgedDataAsync (#40)

* Update project files to target .NET 9 and upgrade packages

Updated various project files to target .NET 9.0 frameworks, including net9.0, net9.0-android, net9.0-windows10.0.26100.0, and net9.0-windows10.0.19041.0. Upgraded package versions across multiple projects, including Microsoft.Extensions.Hosting, Microsoft.Maui.Core, CommunityToolkit.Mvvm, Serilog.Extensions.Hosting, Serilog.Extensions.Logging, Google.Protobuf, Grpc.Net.Client, Grpc.Tools, and others. Replaced MSTest with xUnit in unit test projects.

* Migrate unit tests from MSTest to xUnit

The test framework has been switched from MSTest to xUnit. This includes:
- Replacing `[TestClass]` with the class declaration.
- Replacing `[TestInitialize]` with the class constructor.
- Replacing `[TestMethod]` with `[Fact]` and `[DataRow]` with `[Theory]` and `[InlineData]`.
- Updating `Assert` methods to xUnit equivalents.
- Changing `Mock` objects to `readonly` fields.
- Simplifying array initializations using array literals.
- Updating `using` directives to include xUnit.

* Refactor array instantiation in SendMessageChannelTests

Updated array instantiation to use Array.Empty<T>() instead of new T[0] or new object[] {}. This change affects various method calls and test setups, including Dispose, SendAcknowledgedData, SendAcknowledgedDataAsync, SendBroadcastData, SendBurstTransfer, SendBurstTransferAsync, SendExtAcknowledgedData, SendExtBroadcastData, SendExtBurstTransfer, and SendExtBurstTransferAsync. Also updated the data initialization and method invocation in SendExtAcknowledgedDataAsync_InvokesMethodMultipleTimesAndReturnsPass.

* Replace Frame with Border elements and update bindings

Replaced Frame elements with Border elements across multiple XAML files, updating properties such as BorderColor to Stroke, and adding Margin, Padding, and StrokeShape properties. Updated bindings to include x:DataType=RadioButton and x:DataType=Entry where applicable. Added event handlers and updated command parameter bindings in HomePage.xaml and HomePage.xaml.cs. Updated byte array initialization syntax in BicyclePowerViewModel.cs.

* Improve logging in SendMessageChannel and MauiProgram

Updated log message formatting for consistency in
`SendMessageChannel.cs` and added logging for timeout
results. Enhanced logging configuration in
`MauiProgram.cs` to set minimum level to Debug in DEBUG mode.

* Workaround to build the installer package.

* Refactor logging in SendMessageChannel and MauiProgram

Updated logging in SendMessageChannel.cs to remove Task ID from debug messages, focusing on busy flags and channel index. Added Serilog and its extensions to MauiAntGrpcClient.csproj for enhanced logging capabilities. Replaced the existing logging framework with Serilog in MauiProgram.cs, initializing it early and modifying the debug logging configuration to utilize Serilog.

* Update package versions and release notes

- Incremented assembly versions for Hosting (1.1.2.0) and AntPlus (5.0.1.0).
- Updated package release notes to reflect bug fixes related to ANT radio hardware.
- Added new version entries in AntPlus and Hosting Extensions version history files.
- Updated ContentLayout to include new version 5.0.1.0 and change visibility for version 3.1.0.0.
- Modified Documentation.shfbproj to reference new versions.
- Created new XML files for version 5.0.1.0 and 1.1.2.0 with detailed release notes.

Author: StephenHidem

AntPlus.Extensions.Hosting/Hosting.csproj

@@ -16,19 +16,19 @@
 	<EmbedUntrackedSources>true</EmbedUntrackedSources>
 	<PackageIcon>PackageLogo.png</PackageIcon>
 	<PackageReadmeFile>readme.md</PackageReadmeFile>
-	<PackageReleaseNotes>Fixed potential race condition sending multiple messages to multiple ANT devices managed by the AntCollection class.</PackageReleaseNotes>
+	<PackageReleaseNotes>Bugfix: Issue #39. Clears msssage in ANT radio hardware when SendExtAcknowledgedDataAsync timesout.</PackageReleaseNotes>
 	<PackageLicenseExpression>MIT</PackageLicenseExpression>
 	<IncludeSymbols>True</IncludeSymbols>
 	<SymbolPackageFormat>snupkg</SymbolPackageFormat>
-	<AssemblyVersion>1.1.1.0</AssemblyVersion>
+	<AssemblyVersion>1.1.2.0</AssemblyVersion>
 	<Version>$(VersionPrefix)$(AssemblyVersion)</Version>
 	<PackageProjectUrl>https://stephenhidem.github.io/AntPlus</PackageProjectUrl>
 	<RepositoryUrl>https://github.com/StephenHidem/AntPlus</RepositoryUrl>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.1" />
-    <PackageReference Include="Microsoft.Maui.Core" Version="8.0.91" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.2" />
+    <PackageReference Include="Microsoft.Maui.Core" Version="9.0.40" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

AntPlus.Extensions.Hosting/SendMessageChannel.cs

@@ -85,12 +85,20 @@ public Task<MessagingReturnCode> SendExtAcknowledgedDataAsync(ChannelId channelI
                     .ContinueWith(antecedent =>
                     {
                         int index = antecedent.Result;
-                        _logger.LogDebug("SendExtAcknowledgedDataAsync: channel index = {ChannelIndex}, channel ID = 0x{ChannelId:X8}, data = {Data}", index, channelId.Id, BitConverter.ToString(data));
+                        _logger.LogDebug("SendExtAcknowledgedDataAsync: Channel index = {ChannelIndex}, channel ID = 0x{ChannelId:X8}, data = {Data}", index, channelId.Id, BitConverter.ToString(data));
                         _channels[index].SendExtAcknowledgedDataAsync(channelId, data, ackWaitTime)
                         .ContinueWith(innerAntecedent =>
                         {
+                            _logger.LogDebug("SendExtAcknowledgedDataAsync: Channel index = {ChannelIndex}, channel ID = 0x{ChannelId:X8}, result = {Result}", index, channelId.Id, innerAntecedent.Result);
                             lock (_channelLock)
                             {
+                                // unassign then assign the channel to reset the channel if the result is timeout
+                                if (innerAntecedent.Result == MessagingReturnCode.Timeout)
+                                {
+                                    _channels[index].UnassignChannel(ackWaitTime);
+                                    _channels[index].AssignChannel(ChannelType.BaseSlaveReceive, 0, ackWaitTime);
+                                }
+
                                 // release the channel and notify this channel is available
                                 _busyFlags[index] = false;
                                 Monitor.Pulse(_channelLock);
@@ -120,10 +128,10 @@ private Task<int> GetAvailableChannelIndexAsync()
                         // find an available channel
                         while ((i = Array.FindIndex(_busyFlags, flag => !flag)) == -1)
                         {
-                            _logger.LogDebug("GetAvailableChannelIndexAsync: Task ID = {TaskId}, all channels are busy", Task.CurrentId);
+                            _logger.LogDebug("GetAvailableChannelIndexAsync: All channels are busy");
                             Monitor.Wait(_channelLock);
                         }
-                        _logger.LogDebug("GetAvailableChannelIndexAsync: Task ID = {TaskId}, _busyFlags = {BusyFlags}, channel index = {ChannelIndex}", Task.CurrentId, _busyFlags, i);
+                        _logger.LogDebug("GetAvailableChannelIndexAsync: _busyFlags = {BusyFlags}, channel index = {ChannelIndex}", _busyFlags, i);
                         _busyFlags[i] = true;
                     }
                     return i;

AntPlus.UnitTests/AntDeviceCollectionTests.cs

@@ -11,21 +11,20 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Xunit;
 
 namespace AntPlus.UnitTests
 {
-    [TestClass]
     public class AntDeviceCollectionTests
     {
-        private MockRepository mockRepository;
+        private readonly MockRepository mockRepository;
 
-        private Mock<IAntRadio> mockAntRadio;
-        private Mock<IAntChannel> mockAntChannel;
-        private Mock<ILogger> mockLogger;
-        private Mock<ILoggerFactory> mockLoggerFactory;
+        private readonly Mock<IAntRadio> mockAntRadio;
+        private readonly Mock<IAntChannel> mockAntChannel;
+        private readonly Mock<ILogger> mockLogger;
+        private readonly Mock<ILoggerFactory> mockLoggerFactory;
 
-        [TestInitialize]
-        public void TestInitialize()
+        public AntDeviceCollectionTests()
         {
             mockRepository = new MockRepository(MockBehavior.Loose);
 
@@ -47,7 +46,7 @@ private AntDeviceCollection CreateAntDeviceCollection()
             return adc;
         }
 
-        [TestMethod]
+        [Fact]
         public async Task MultithreadedAdd_Collection_ExpectedCount()
         {
             // Arrange
@@ -69,14 +68,14 @@ public async Task MultithreadedAdd_Collection_ExpectedCount()
 
             // Act
             semaphore.Release(numberOfDevices);
-            Task.WaitAll(tasks);
+            await Task.WhenAll(tasks);
 
             // Assert
-            Assert.AreEqual(numberOfDevices, antDeviceCollection.Count);
+            Assert.Equal(numberOfDevices, antDeviceCollection.Count);
             mockRepository.VerifyAll();
         }
 
-        [TestMethod]
+        [Fact]
         public async Task MultithreadedRemove_Collection_ExpectedCount()
         {
             // Arrange
@@ -99,28 +98,28 @@ public async Task MultithreadedRemove_Collection_ExpectedCount()
 
             // Act
             semaphore.Release(numberOfDevices);
-            Task.WaitAll(tasks);
+            await Task.WhenAll(tasks);
 
             // Assert
-            Assert.AreEqual(0, antDeviceCollection.Count);
+            Assert.Empty(antDeviceCollection);
             mockRepository.VerifyAll();
         }
 
-        [TestMethod]
-        [DataRow(HeartRate.DeviceClass, typeof(HeartRate))]
-        [DataRow(BicyclePower.DeviceClass, typeof(StandardPowerSensor))]
-        [DataRow(BikeSpeedSensor.DeviceClass, typeof(BikeSpeedSensor))]
-        [DataRow(BikeCadenceSensor.DeviceClass, typeof(BikeCadenceSensor))]
-        [DataRow(CombinedSpeedAndCadenceSensor.DeviceClass, typeof(CombinedSpeedAndCadenceSensor))]
-        [DataRow(FitnessEquipment.DeviceClass, typeof(UnknownDevice))]
-        [DataRow(MuscleOxygen.DeviceClass, typeof(MuscleOxygen))]
-        [DataRow(Geocache.DeviceClass, typeof(Geocache))]
-        [DataRow(Tracker.DeviceClass, typeof(Tracker))]
-        [DataRow(StrideBasedSpeedAndDistance.DeviceClass, typeof(StrideBasedSpeedAndDistance))]
+        [Theory]
+        [InlineData(HeartRate.DeviceClass, typeof(HeartRate))]
+        [InlineData(BicyclePower.DeviceClass, typeof(StandardPowerSensor))]
+        [InlineData(BikeSpeedSensor.DeviceClass, typeof(BikeSpeedSensor))]
+        [InlineData(BikeCadenceSensor.DeviceClass, typeof(BikeCadenceSensor))]
+        [InlineData(CombinedSpeedAndCadenceSensor.DeviceClass, typeof(CombinedSpeedAndCadenceSensor))]
+        [InlineData(FitnessEquipment.DeviceClass, typeof(UnknownDevice))]
+        [InlineData(MuscleOxygen.DeviceClass, typeof(MuscleOxygen))]
+        [InlineData(Geocache.DeviceClass, typeof(Geocache))]
+        [InlineData(Tracker.DeviceClass, typeof(Tracker))]
+        [InlineData(StrideBasedSpeedAndDistance.DeviceClass, typeof(StrideBasedSpeedAndDistance))]
         public async Task ChannelResponseEvent_Collection_ExpectedDeviceInCollection(byte deviceClass, Type deviceType)
         {
             // Arrange
-            byte[] id = new byte[4] { 1, 0, deviceClass, 0 };
+            byte[] id = [1, 0, deviceClass, 0];
             ChannelId cid = new(BitConverter.ToUInt32(id));
             mockAntChannel.SetupAdd(m => m.ChannelResponse += It.IsAny<EventHandler<AntResponse>>());
             mockAntChannel.SetupRemove(m => m.ChannelResponse -= It.IsAny<EventHandler<AntResponse>>());
@@ -131,8 +130,8 @@ public async Task ChannelResponseEvent_Collection_ExpectedDeviceInCollection(byt
             // Act
             mockAntChannel.Raise(m => m.ChannelResponse += null, mockAntChannel.Object, mockResponse);
 
-            Assert.AreEqual(1, antDeviceCollection.Count);
-            Assert.AreEqual(deviceType, antDeviceCollection[0].GetType());
+            Assert.Single(antDeviceCollection);
+            Assert.Equal(deviceType, antDeviceCollection[0].GetType());
         }
 
         class MockResponse : AntResponse
@@ -144,7 +143,7 @@ public MockResponse(ChannelId channelId, byte[] payload)
             }
         }
 
-        //[TestMethod]
+        //[Fact]
         //public async Task DeviceOffline_RemovesDeviceFromCollection()
         //{
         //    // Arrange
@@ -158,10 +157,10 @@ public MockResponse(ChannelId channelId, byte[] payload)
         //    //Thread.Sleep(100);
 
         //    // Assert
-        //    Assert.AreEqual(0, antDeviceCollection.Count);
+        //    Assert.Equal(0, antDeviceCollection.Count);
         //}
 
-        [TestMethod]
+        [Fact]
         public async Task MessageHandler_NullChannelId_LogsCritical()
         {
             // Arrange
@@ -183,7 +182,7 @@ public async Task MessageHandler_NullChannelId_LogsCritical()
                 Times.Once);
         }
 
-        [TestMethod]
+        [Fact]
         public async Task MessageHandler_NullPayload_LogsCritical()
         {
             // Arrange
@@ -205,7 +204,7 @@ public async Task MessageHandler_NullPayload_LogsCritical()
                 Times.Once);
         }
 
-        //[TestMethod]
+        //[Fact]
         //public void CreateAntDevice_ValidChannelId_CreatesCorrectDevice()
         //{
         //    // Arrange

AntPlus.UnitTests/AntDeviceTests.cs

@@ -4,29 +4,28 @@
 using SmallEarthTech.AntPlus.DeviceProfiles.AssetTracker;
 using SmallEarthTech.AntRadioInterface;
 using System.Threading;
+using Xunit;
 
 namespace AntPlus.UnitTests
 {
-    [TestClass]
     public class AntDeviceTests
     {
-        private MockRepository mockRepository;
+        private readonly MockRepository mockRepository;
 
-        private Mock<IAntChannel> mockAntChannel;
-        private Mock<ILogger<Tracker>> mockLogger;
+        private readonly Mock<IAntChannel> mockAntChannel;
+        private readonly Mock<ILogger<Tracker>> mockLogger;
 
-        [TestInitialize]
-        public void TestInitialize()
+        public AntDeviceTests()
         {
             mockRepository = new MockRepository(MockBehavior.Strict);
 
             mockAntChannel = mockRepository.Create<IAntChannel>();
             mockLogger = mockRepository.Create<ILogger<Tracker>>(MockBehavior.Loose);
         }
 
-        [TestMethod]
-        [DataRow((uint)0x0FFF0001, (uint)0x00000001)]
-        [DataRow((uint)0xFFFF0001, (uint)0x000F0001)]
+        [Theory]
+        [InlineData((uint)0x0FFF0001, (uint)0x00000001)]
+        [InlineData((uint)0xFFFF0001, (uint)0x000F0001)]
         public void Ctor_ChannelID_VerifyDeviceNumber(uint channelId, uint expectedDeviceNumber)
         {
             // Arrange
@@ -36,12 +35,12 @@ public void Ctor_ChannelID_VerifyDeviceNumber(uint channelId, uint expectedDevic
             Mock<AntDevice> antDevice = new(cid, mockAntChannel.Object, mockLogger.Object, (int)500);
 
             // Assert
-            Assert.AreEqual((uint)expectedDeviceNumber, antDevice.Object.ChannelId.DeviceNumber);
+            Assert.Equal((uint)expectedDeviceNumber, antDevice.Object.ChannelId.DeviceNumber);
         }
 
-        [TestMethod]
-        [DataRow((uint)0xFF81FFFF, (byte)0x01)]
-        [DataRow((uint)0xFFFFFFFF, (byte)0x7F)]
+        [Theory]
+        [InlineData(0xFF81FFFF, (byte)0x01)]
+        [InlineData(0xFFFFFFFF, (byte)0x7F)]
         public void Ctor_ChannelID_VerifyDeviceType(uint channelId, byte expectedDeviceType)
         {
             // Arrange
@@ -51,12 +50,12 @@ public void Ctor_ChannelID_VerifyDeviceType(uint channelId, byte expectedDeviceT
             Mock<AntDevice> antDevice = new(cid, mockAntChannel.Object, mockLogger.Object, (int)500);
 
             // Assert
-            Assert.AreEqual(expectedDeviceType, antDevice.Object.ChannelId.DeviceType);
+            Assert.Equal(expectedDeviceType, antDevice.Object.ChannelId.DeviceType);
         }
 
-        [TestMethod]
-        [DataRow((uint)0x00800000, true)]
-        [DataRow((uint)0xFF7FFFFF, false)]
+        [Theory]
+        [InlineData((uint)0x00800000, true)]
+        [InlineData((uint)0xFF7FFFFF, false)]
         public void Ctor_ChannelID_VerifyPairingBit(uint channelId, bool expectedResult)
         {
             // Arrange
@@ -66,12 +65,12 @@ public void Ctor_ChannelID_VerifyPairingBit(uint channelId, bool expectedResult)
             Mock<AntDevice> antDevice = new(cid, mockAntChannel.Object, mockLogger.Object, (int)500);
 
             // Assert
-            Assert.AreEqual(expectedResult, antDevice.Object.ChannelId.IsPairingBitSet);
+            Assert.Equal(expectedResult, antDevice.Object.ChannelId.IsPairingBitSet);
         }
 
-        [TestMethod]
-        [DataRow((uint)0x04000000, true)]
-        [DataRow((uint)0xFBFFFFFF, false)]
+        [Theory]
+        [InlineData((uint)0x04000000, true)]
+        [InlineData((uint)0xFBFFFFFF, false)]
         public void Ctor_ChannelID_VerifyAreGlobalPageUsed(uint channelId, bool expectedResult)
         {
             // Arrange
@@ -81,18 +80,18 @@ public void Ctor_ChannelID_VerifyAreGlobalPageUsed(uint channelId, bool expected
             Mock<AntDevice> antDevice = new(cid, mockAntChannel.Object, mockLogger.Object, (int)500);
 
             // Assert
-            Assert.AreEqual(expectedResult, antDevice.Object.ChannelId.AreGlobalDataPagesUsed);
+            Assert.Equal(expectedResult, antDevice.Object.ChannelId.AreGlobalDataPagesUsed);
         }
 
-        [TestMethod]
-        [DataRow((uint)0xF0FFFFFF, ChannelSharing.Reserved)]
-        [DataRow((uint)0xFCFFFFFF, ChannelSharing.Reserved)]
-        [DataRow((uint)0xF1FFFFFF, ChannelSharing.IndependentChannel)]
-        [DataRow((uint)0xFDFFFFFF, ChannelSharing.IndependentChannel)]
-        [DataRow((uint)0xF2FFFFFF, ChannelSharing.SharedChannelOneByteAddress)]
-        [DataRow((uint)0xFEFFFFFF, ChannelSharing.SharedChannelOneByteAddress)]
-        [DataRow((uint)0xF3FFFFFF, ChannelSharing.SharedChannelTwoByteAddress)]
-        [DataRow((uint)0xFFFFFFFF, ChannelSharing.SharedChannelTwoByteAddress)]
+        [Theory]
+        [InlineData((uint)0xF0FFFFFF, ChannelSharing.Reserved)]
+        [InlineData((uint)0xFCFFFFFF, ChannelSharing.Reserved)]
+        [InlineData((uint)0xF1FFFFFF, ChannelSharing.IndependentChannel)]
+        [InlineData((uint)0xFDFFFFFF, ChannelSharing.IndependentChannel)]
+        [InlineData((uint)0xF2FFFFFF, ChannelSharing.SharedChannelOneByteAddress)]
+        [InlineData((uint)0xFEFFFFFF, ChannelSharing.SharedChannelOneByteAddress)]
+        [InlineData((uint)0xF3FFFFFF, ChannelSharing.SharedChannelTwoByteAddress)]
+        [InlineData((uint)0xFFFFFFFF, ChannelSharing.SharedChannelTwoByteAddress)]
         public void Ctor_ChannelID_VerifyTransmissionType(uint channelId, ChannelSharing expectedTransmissionType)
         {
             // Arrange
@@ -102,10 +101,10 @@ public void Ctor_ChannelID_VerifyTransmissionType(uint channelId, ChannelSharing
             Mock<AntDevice> antDevice = new(cid, mockAntChannel.Object, mockLogger.Object, (int)500);
 
             // Assert
-            Assert.AreEqual(expectedTransmissionType, antDevice.Object.ChannelId.TransmissionType);
+            Assert.Equal(expectedTransmissionType, antDevice.Object.ChannelId.TransmissionType);
         }
 
-        [TestMethod]
+        [Fact]
         public void Timeout_Offline_ExpectedEventAndStatus()
         {
             // Arrange
@@ -118,8 +117,8 @@ public void Timeout_Offline_ExpectedEventAndStatus()
             Thread.Sleep(100);
 
             // Assert
-            Assert.IsTrue(offline == true);
-            Assert.IsTrue(antDevice.Object.Offline == true);
+            Assert.True(offline, "Event test");
+            Assert.True(antDevice.Object.Offline, "Device offline status");
         }
     }
 }

AntPlus.UnitTests/AntPlus.UnitTests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <Nullable>disable</Nullable>
 
     <IsPackable>false</IsPackable>
@@ -10,12 +10,15 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="Moq" Version="4.20.72" />
-    <PackageReference Include="MSTest.TestAdapter" Version="3.7.3" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.7.3" />
     <PackageReference Include="coverlet.collector" Version="6.0.4">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>