AntDeviceCollection Update (#36)

* Remove Dispose call in critical log scenario

The line `Dispose();  // clear the channels` was removed from the method where a critical log message is generated if `ChannelId` is null. This change ensures that the code will no longer call the `Dispose` method to clear the channels in this scenario.

* Refactor AntDeviceCollection and add SendMessageChannel

- Made `AntDeviceCollection` a partial class.
- Added `_sendMessageChannel` field to `AntDeviceCollection`.
- Simplified `AntDeviceCollection` constructor by removing async initialization.
- Added `StartScanning` method to initialize ANT radio and channels.
- Renamed `Channel_ChannelResponse` to `MessageHandler` and updated it.
- Refactored `CreateAntDevice` to use `_sendMessageChannel`.
- Updated `AntPlus.csproj` to version `5.0.0.0`.
- Added `SendMessageChannel` class to manage multiple ANT channels.
- Implemented async data sending and channel management in `SendMessageChannel`.

* Refactor tests and add new logging verifications

Refactored test classes to use mock loggers and updated test methods to be asynchronous. Added new tests for logging critical messages and warnings. Introduced a new `SendMessageChannelTests` class to verify `NotImplementedException` and concurrent method invocations.

* Add release notes and documentation for versions 5.0.0.0 and 1.1.1.0

Updated `AntPlus.csproj` to include new package release notes indicating breaking changes. The `AntDeviceCollection` constructor no longer initiates ANT device scanning; `StartScanning` must be called after instantiation.

Updated `AntPllusVersionHistory.aml` and `HostingExtensionsVersionHistory.aml` to include new list items with links to the new version history.

Updated `ContentLayout.content` to add new topics for versions 5.0.0.0 and 1.1.1.0, marking version 5.0.0.0 as selected.

Updated `Documentation.shfbproj` to re-add namespace summary items and include new entries for the version history files for versions 5.0.0.0 and 1.1.1.0.

Added new files `v5.0.0.0.aml` and `v1.1.1.0.aml` detailing the releases, including breaking changes, improvements, and a fix for a potential race condition.

Author: StephenHidem

AntPlus.Extensions.Hosting/AntCollection.cs

@@ -91,7 +91,6 @@ private void MessageHandler(object? sender, AntResponse e)
                     e.ChannelNumber,
                     (MessageId)e.ResponseId,
                     e.Payload != null ? BitConverter.ToString(e.Payload) : "Null");
-                Dispose();  // clear the channels
             }
         }
 

AntPlus.UnitTests/AntDeviceCollectionTests.cs

@@ -3,9 +3,12 @@
 using SmallEarthTech.AntPlus;
 using SmallEarthTech.AntPlus.DeviceProfiles;
 using SmallEarthTech.AntPlus.DeviceProfiles.AssetTracker;
+using SmallEarthTech.AntPlus.DeviceProfiles.BicyclePower;
 using SmallEarthTech.AntPlus.DeviceProfiles.BikeSpeedAndCadence;
+using SmallEarthTech.AntPlus.DeviceProfiles.FitnessEquipment;
 using SmallEarthTech.AntRadioInterface;
 using System;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -18,6 +21,8 @@ public class AntDeviceCollectionTests
 
         private Mock<IAntRadio> mockAntRadio;
         private Mock<IAntChannel> mockAntChannel;
+        private Mock<ILogger> mockLogger;
+        private Mock<ILoggerFactory> mockLoggerFactory;
 
         [TestInitialize]
         public void TestInitialize()
@@ -26,27 +31,28 @@ public void TestInitialize()
 
             mockAntRadio = mockRepository.Create<IAntRadio>();
             mockAntChannel = mockRepository.Create<IAntChannel>();
+            mockLogger = mockRepository.Create<ILogger>();
+            mockLoggerFactory = mockRepository.Create<ILoggerFactory>();
+            mockLoggerFactory.Setup(m => m.CreateLogger(It.IsAny<string>())).Returns(mockLogger.Object);
         }
 
         private AntDeviceCollection CreateAntDeviceCollection()
         {
-            IAntChannel[] mockChannels = new IAntChannel[8];
-            Array.Fill(mockChannels, mockAntChannel.Object);
-            mockAntRadio.Setup(r => r.InitializeContinuousScanMode().Result).Returns(mockChannels);
+            var mockChannels = new Mock<IAntChannel>[8];
+            Array.Fill(mockChannels, mockAntChannel);
+            mockAntRadio.Setup(r => r.InitializeContinuousScanMode()).ReturnsAsync(mockChannels.Select(m => m.Object).ToArray());
             AntDeviceCollection adc = new(
                 mockAntRadio.Object,
-                null,
-                3000);
-            Thread.Sleep(2000);     // allow time for background initialization task to complete
+                mockLoggerFactory.Object);
             return adc;
         }
 
         [TestMethod]
-        public void MultithreadedAdd_Collection_ExpectedCount()
+        public async Task MultithreadedAdd_Collection_ExpectedCount()
         {
             // Arrange
-            Mock<ILogger> mockLogger = new();
             var antDeviceCollection = CreateAntDeviceCollection();
+            await antDeviceCollection.StartScanning();
             int numberOfDevices = 16;
             using SemaphoreSlim semaphore = new(0, numberOfDevices);
             Task[] tasks = new Task[numberOfDevices];
@@ -71,11 +77,11 @@ public void MultithreadedAdd_Collection_ExpectedCount()
         }
 
         [TestMethod]
-        public void MultithreadedRemove_Collection_ExpectedCount()
+        public async Task MultithreadedRemove_Collection_ExpectedCount()
         {
             // Arrange
-            Mock<ILogger<UnknownDevice>> mockLogger = new();
             var antDeviceCollection = CreateAntDeviceCollection();
+            await antDeviceCollection.StartScanning();
             int numberOfDevices = 16;
             using SemaphoreSlim semaphore = new(0, numberOfDevices);
             Task[] tasks = new Task[numberOfDevices];
@@ -102,16 +108,16 @@ public void MultithreadedRemove_Collection_ExpectedCount()
 
         [TestMethod]
         [DataRow(HeartRate.DeviceClass, typeof(HeartRate))]
-        //[DataRow(BicyclePowerTests.DeviceClass, typeof(BicyclePowerTests))]       TODO: Fix this
+        [DataRow(BicyclePower.DeviceClass, typeof(StandardPowerSensor))]
         [DataRow(BikeSpeedSensor.DeviceClass, typeof(BikeSpeedSensor))]
         [DataRow(BikeCadenceSensor.DeviceClass, typeof(BikeCadenceSensor))]
         [DataRow(CombinedSpeedAndCadenceSensor.DeviceClass, typeof(CombinedSpeedAndCadenceSensor))]
-        //[DataRow(Equipment.DeviceClass, typeof(Treadmill))]       TODO: Fix this
+        [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))]
-        public void ChannelResponseEvent_Collection_ExpectedDeviceInCollection(byte deviceClass, Type deviceType)
+        public async Task ChannelResponseEvent_Collection_ExpectedDeviceInCollection(byte deviceClass, Type deviceType)
         {
             // Arrange
             byte[] id = new byte[4] { 1, 0, deviceClass, 0 };
@@ -120,6 +126,7 @@ public void ChannelResponseEvent_Collection_ExpectedDeviceInCollection(byte devi
             mockAntChannel.SetupRemove(m => m.ChannelResponse -= It.IsAny<EventHandler<AntResponse>>());
             var mockResponse = new MockResponse(cid, new byte[8]);
             var antDeviceCollection = CreateAntDeviceCollection();
+            await antDeviceCollection.StartScanning();
 
             // Act
             mockAntChannel.Raise(m => m.ChannelResponse += null, mockAntChannel.Object, mockResponse);
@@ -136,5 +143,82 @@ public MockResponse(ChannelId channelId, byte[] payload)
                 Payload = payload;
             }
         }
+
+        //[TestMethod]
+        //public async Task DeviceOffline_RemovesDeviceFromCollection()
+        //{
+        //    // Arrange
+        //    var antDeviceCollection = CreateAntDeviceCollection();
+        //    await antDeviceCollection.StartScanning();
+        //    Mock<AntDevice> antDevice = new(new ChannelId(1), mockAntChannel.Object, Mock.Of<ILogger>(), 50);
+        //    antDeviceCollection.Add(antDevice.Object);
+
+        //    // Act
+        //    antDevice.Raise(d => d.DeviceWentOffline += null, EventArgs.Empty);
+        //    //Thread.Sleep(100);
+
+        //    // Assert
+        //    Assert.AreEqual(0, antDeviceCollection.Count);
+        //}
+
+        [TestMethod]
+        public async Task MessageHandler_NullChannelId_LogsCritical()
+        {
+            // Arrange
+            var antDeviceCollection = CreateAntDeviceCollection();
+            await antDeviceCollection.StartScanning();
+            var response = new MockResponse(null, new byte[8]);
+
+            // Act
+            mockAntChannel.Raise(m => m.ChannelResponse += null, mockAntChannel.Object, response);
+
+            // Assert
+            mockLogger.Verify(
+                x => x.Log(
+                    LogLevel.Critical,
+                    It.IsAny<EventId>(),
+                    It.Is<It.IsAnyType>((v, t) => v.ToString().Contains("ChannelId or Payload is null")),
+                    It.IsAny<Exception>(),
+                    It.Is<Func<It.IsAnyType, Exception, string>>((v, t) => true)),
+                Times.Once);
+        }
+
+        [TestMethod]
+        public async Task MessageHandler_NullPayload_LogsCritical()
+        {
+            // Arrange
+            var antDeviceCollection = CreateAntDeviceCollection();
+            await antDeviceCollection.StartScanning();
+            var response = new MockResponse(new ChannelId(1), null);
+
+            // Act
+            mockAntChannel.Raise(m => m.ChannelResponse += null, mockAntChannel.Object, response);
+
+            // Assert
+            mockLogger.Verify(
+                x => x.Log(
+                    LogLevel.Critical,
+                    It.IsAny<EventId>(),
+                    It.Is<It.IsAnyType>((v, t) => v.ToString().Contains("ChannelId or Payload is null")),
+                    It.IsAny<Exception>(),
+                    It.Is<Func<It.IsAnyType, Exception, string>>((v, t) => true)),
+                Times.Once);
+        }
+
+        //[TestMethod]
+        //public void CreateAntDevice_ValidChannelId_CreatesCorrectDevice()
+        //{
+        //    // Arrange
+        //    var antDeviceCollection = CreateAntDeviceCollection();
+        //    var channelId = new ChannelId(1) { DeviceType = HeartRate.DeviceClass };
+        //    var dataPage = new byte[8];
+
+        //    // Act
+        //    var device = antDeviceCollection.CreateAntDevice(channelId, dataPage);
+
+        //    // Assert
+        //    Assert.IsInstanceOfType(device, typeof(HeartRate));
+        //}
+
     }
 }

AntPlus.UnitTests/DeviceProfiles/BicyclePower/CrankTorqueFrequencySensorTests.cs

@@ -1,4 +1,4 @@
-using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Logging;
 using Moq;
 using SmallEarthTech.AntPlus.DeviceProfiles.BicyclePower;
 using SmallEarthTech.AntRadioInterface;
@@ -14,21 +14,24 @@ public class CrankTorqueFrequencySensorTests
 
         private readonly ChannelId mockChannelId = new(0);
         private Mock<IAntChannel> mockAntChannel;
-        private Mock<NullLoggerFactory> mockLogger;
+        private Mock<ILogger> mockLogger;
+        private Mock<ILoggerFactory> mockLoggerFactory;
 
         [TestInitialize]
         public void TestInitialize()
         {
             mockRepository = new MockRepository(MockBehavior.Strict);
 
             mockAntChannel = mockRepository.Create<IAntChannel>(MockBehavior.Loose);
-            mockLogger = mockRepository.Create<NullLoggerFactory>(MockBehavior.Loose);
+            mockLogger = mockRepository.Create<ILogger>(MockBehavior.Loose);
+            mockLoggerFactory = mockRepository.Create<ILoggerFactory>();
+            mockLoggerFactory.Setup(m => m.CreateLogger(It.IsAny<string>())).Returns(mockLogger.Object);
         }
 
         private CrankTorqueFrequencySensor CreateCrankTorqueFrequencySensor()
         {
             byte[] page = new byte[8] { (byte)BicyclePower.DataPage.CrankTorqueFrequency, 0, 0, 0, 0, 0, 0, 0 };
-            return BicyclePower.GetBicyclePowerSensor(page, mockChannelId, mockAntChannel.Object, mockLogger.Object, 2000) as CrankTorqueFrequencySensor;
+            return BicyclePower.GetBicyclePowerSensor(page, mockChannelId, mockAntChannel.Object, mockLoggerFactory.Object, 2000) as CrankTorqueFrequencySensor;
         }
 
         [TestMethod]
@@ -130,5 +133,57 @@ public async Task SaveSerialNumberToFlash_Message_MessageFormatCorrect()
             Assert.AreEqual(MessagingReturnCode.Pass, result);
             mockRepository.VerifyAll();
         }
+
+        [TestMethod]
+        public void Parse_UnknownDataPage_LogsWarning()
+        {
+            // Arrange
+            var crankTorqueFrequencySensor = CreateCrankTorqueFrequencySensor();
+            byte[] dataPage = new byte[8] { 0xFF, 0, 0, 0, 0, 0, 0, 0 };
+
+            // Act
+            crankTorqueFrequencySensor.Parse(dataPage);
+
+            // Assert
+            mockLogger.Verify(
+                m => m.Log(
+                    LogLevel.Warning,
+                    It.IsAny<EventId>(),
+                    It.Is<It.IsAnyType>((v, t) => v.ToString().Contains("Unknown data page")),
+                    null,
+                    It.IsAny<Func<It.IsAnyType, Exception, string>>()),
+                Times.Once);
+        }
+
+        [TestMethod]
+        public void ParseCTFMessage_SameUpdateEventCountAndTorqueTicks_NoCalculations()
+        {
+            // Arrange
+            var crankTorqueFrequencySensor = CreateCrankTorqueFrequencySensor();
+            byte[] dataPage = new byte[8] { 0x20, 0x01, 0x00, 0x64, 0x07, 0xD0, 0, 0x01 };
+
+            // Act
+            crankTorqueFrequencySensor.Parse(dataPage);
+            crankTorqueFrequencySensor.Parse(dataPage);
+
+            // Assert
+            Assert.AreEqual(60, crankTorqueFrequencySensor.Cadence);
+            Assert.AreEqual(0.1, crankTorqueFrequencySensor.Torque);
+            Assert.AreEqual(0.628, crankTorqueFrequencySensor.Power, 0.001);
+        }
+
+        [TestMethod]
+        public void ParseCalibrationMessage_UnknownCTFDefinedId_NoAction()
+        {
+            // Arrange
+            var crankTorqueFrequencySensor = CreateCrankTorqueFrequencySensor();
+            byte[] dataPage = new byte[8] { 0x01, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x11, 0x22 };
+
+            // Act
+            crankTorqueFrequencySensor.Parse(dataPage);
+
+            // Assert
+            // No exception should be thrown
+        }
     }
 }

AntPlus.UnitTests/SendMessageChannelTests.cs

@@ -0,0 +1,109 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using SmallEarthTech.AntPlus;
+using SmallEarthTech.AntRadioInterface;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace AntPlus.UnitTests
+{
+    [TestClass]
+    public class SendMessageChannelTests
+    {
+        private readonly Mock<IAntChannel> _mockChannel;
+        private readonly object _sendMessageChannel;
+
+        public SendMessageChannelTests()
+        {
+            _mockChannel = new Mock<IAntChannel>();
+            Type sendMessageChannelType = typeof(AntDeviceCollection).GetNestedType("SendMessageChannel", BindingFlags.NonPublic)!;
+            _sendMessageChannel = Activator.CreateInstance(sendMessageChannelType, new[] { _mockChannel.Object, _mockChannel.Object, _mockChannel.Object }, Mock.Of<ILogger<AntDeviceCollection>>())!;
+        }
+
+        [TestMethod]
+        public void AllMethods_ThrowNotImplementedException()
+        {
+            var methods = new (string MethodName, object[] Parameters)[]
+            {
+                ("AssignChannel", new object[] { ChannelType.BaseSlaveReceive, (byte)0, (uint)500 }),
+                ("AssignChannelExt", new object[] { ChannelType.BaseSlaveReceive, (byte)0, ChannelTypeExtended.AdvFastStart, (uint)500 }),
+                ("CloseChannel", new object[] { (uint)500 }),
+                ("ConfigFrequencyAgility", new object[] { (byte)0, (byte)0, (byte)0, (uint)500 }),
+                ("Dispose", new object[] { }),
+                ("IncludeExcludeListAddChannel", new object[] { new ChannelId(0), (byte)0, (uint)500 }),
+                ("IncludeExcludeListConfigure", new object[] { (byte)0, true, (uint)500 }),
+                ("OpenChannel", new object[] { (uint)500 }),
+                ("RequestChannelID", new object[] { (uint)500 }),
+                ("RequestStatus", new object[] { (uint)500 }),
+                ("SendAcknowledgedData", new object[] { new byte[0], (uint)500 }),
+                ("SendAcknowledgedDataAsync", new object[] { new byte[0], (uint)500 }),
+                ("SendBroadcastData", new object[] { new byte[0] }),
+                ("SendBurstTransfer", new object[] { new byte[0], (uint)500 }),
+                ("SendBurstTransferAsync", new object[] { new byte[0], (uint)500 }),
+                ("SendExtAcknowledgedData", new object[] { new ChannelId(0), new byte[0], (uint)500 }),
+                ("SendExtBroadcastData", new object[] { new ChannelId(0), new byte[0] }),
+                ("SendExtBurstTransfer", new object[] { new ChannelId(0), new byte[0], (uint)500 }),
+                ("SendExtBurstTransferAsync", new object[] { new ChannelId(0), new byte[0], (uint)500 }),
+                ("SetChannelFreq", new object[] { (byte)0, (uint)500 }),
+                ("SetChannelID", new object[] { new ChannelId(0), (uint)500 }),
+                ("SetChannelID_UsingSerial", new object[] { new ChannelId(0), (uint)500 }),
+                ("SetChannelPeriod", new object[] { (ushort)0, (uint)500 }),
+                ("SetChannelSearchTimeout", new object[] { (byte)0, (uint)500 }),
+                ("SetChannelTransmitPower", new object[] { TransmitPower.Tx0DB, (uint)500 }),
+                ("SetLowPrioritySearchTimeout", new object[] { (byte)0, (uint)500 }),
+                ("SetProximitySearch", new object[] { (byte)0, (uint)500 }),
+                ("SetSearchThresholdRSSI", new object[] { (byte)0, (uint)500 }),
+                ("UnassignChannel", new object[] { (uint)500 })
+            };
+
+            foreach (var method in methods)
+            {
+                var methodInfo = _sendMessageChannel.GetType().GetMethod(method.MethodName);
+                Assert.IsNotNull(methodInfo);
+
+                var exception = Assert.ThrowsException<TargetInvocationException>(() => methodInfo.Invoke(_sendMessageChannel, method.Parameters));
+                Assert.IsInstanceOfType(exception.InnerException, typeof(NotImplementedException));
+            }
+
+            var propertyInfo = _sendMessageChannel.GetType().GetProperty("ChannelNumber");
+            Assert.IsNotNull(propertyInfo);
+
+            var propertyException = Assert.ThrowsException<TargetInvocationException>(() => propertyInfo.GetGetMethod()!.Invoke(_sendMessageChannel, null));
+            Assert.IsInstanceOfType(propertyException.InnerException, typeof(NotImplementedException));
+        }
+
+        [TestMethod]
+        public async Task SendExtAcknowledgedDataAsync_InvokesMethodMultipleTimesAndReturnsPass()
+        {
+            var channelId = new ChannelId(0);
+            var data = new byte[0];
+            var ackWaitTime = 500U;
+            var messagingReturnCode = MessagingReturnCode.Pass;
+
+            _mockChannel.Setup(c => c.SendExtAcknowledgedDataAsync(channelId, data, ackWaitTime))
+                        .ReturnsAsync(messagingReturnCode);
+
+            var methodInfo = _sendMessageChannel.GetType().GetMethod("SendExtAcknowledgedDataAsync");
+            Assert.IsNotNull(methodInfo);
+
+            // Act
+            var tasks = new List<Task<MessagingReturnCode>>();
+            for (int i = 0; i < 16; i++)
+            {
+                tasks.Add((Task<MessagingReturnCode>)methodInfo.Invoke(_sendMessageChannel, new object[] { channelId, data, ackWaitTime })!);
+            }
+
+            var results = await Task.WhenAll(tasks);
+
+            // Assert
+            foreach (var result in results)
+            {
+                Assert.AreEqual(messagingReturnCode, result);
+            }
+            _mockChannel.Verify(c => c.SendExtAcknowledgedDataAsync(channelId, data, ackWaitTime), Times.Exactly(tasks.Count));
+        }
+
+    }
+}