Moving structure as preparation for docs

2025-08-06 21:05:47 +02:00
parent 885079ae70
commit 799a014b15
117 changed files with 629 additions and 664 deletions
--- a/test/AMWD.Protocols.Modbus.Tests/Common/Extensions/ModbusUnsignedExtensionsTest.cs
+++ b/test/AMWD.Protocols.Modbus.Tests/Common/Extensions/ModbusUnsignedExtensionsTest.cs
@@ -0,0 +1,428 @@
+namespace AMWD.Protocols.Modbus.Tests.Common.Extensions
+{
+	[TestClass]
+	public class ModbusUnsignedExtensionsTest
+	{
+		#region Modbus to value
+
+		[TestMethod]
+		public void ShouldGetByteOnHoldingRegister()
+		{
+			// Arrange
+			var register = new HoldingRegister { Address = 1, HighByte = 0x02, LowByte = 0x10 };
+
+			// Act
+			byte b = register.GetByte();
+
+			// Assert
+			Assert.AreEqual(16, b);
+		}
+
+		[TestMethod]
+		public void ShouldGetByteOnInputRegister()
+		{
+			// Arrange
+			var register = new InputRegister { Address = 1, HighByte = 0x02, LowByte = 0x10 };
+
+			// Act
+			byte b = register.GetByte();
+
+			// Assert
+			Assert.AreEqual(16, b);
+		}
+
+		[TestMethod]
+		public void ShouldThrowNullForGetByte()
+		{
+			// Arrange
+			HoldingRegister register = null;
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentNullException>(() => register.GetByte());
+		}
+
+		[TestMethod]
+		public void ShouldThrowArgumentForGetByte()
+		{
+			// Arrange
+			var obj = new Coil();
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentException>(() => obj.GetByte());
+		}
+
+		[TestMethod]
+		public void ShouldGetUInt16OnHoldingRegister()
+		{
+			// Arrange
+			var register = new HoldingRegister { Address = 1, HighByte = 0x02, LowByte = 0x10 };
+
+			// Act
+			ushort us = register.GetUInt16();
+
+			// Assert
+			Assert.AreEqual(528, us);
+		}
+
+		[TestMethod]
+		public void ShouldGetUInt16OnInputRegister()
+		{
+			// Arrange
+			var register = new InputRegister { Address = 1, HighByte = 0x02, LowByte = 0x10 };
+
+			// Act
+			ushort us = register.GetUInt16();
+
+			// Assert
+			Assert.AreEqual(528, us);
+		}
+
+		[TestMethod]
+		public void ShouldThrowNullForGetUInt16()
+		{
+			// Arrange
+			HoldingRegister register = null;
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentNullException>(() => register.GetUInt16());
+		}
+
+		[TestMethod]
+		public void ShouldThrowArgumentForGetUInt16()
+		{
+			// Arrange
+			var obj = new Coil();
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentException>(() => obj.GetUInt16());
+		}
+
+		[TestMethod]
+		public void ShouldGetUInt32()
+		{
+			// Arrange
+			var registers = new HoldingRegister[]
+			{
+				new(),
+				new() { Address = 100, HighByte = 0x01, LowByte = 0x02 },
+				new() { Address = 101, HighByte = 0x03, LowByte = 0x04 }
+			};
+
+			// Act
+			uint ui = registers.GetUInt32(1);
+
+			// Assert
+			Assert.AreEqual(16909060u, ui);
+		}
+
+		[TestMethod]
+		public void ShouldGetUInt32ReversedRegisters()
+		{
+			// Arrange
+			var registers = new HoldingRegister[]
+			{
+				new() { Address = 101, HighByte = 0x01, LowByte = 0x02 },
+				new() { Address = 100, HighByte = 0x03, LowByte = 0x04 }
+			};
+
+			// Act
+			uint ui = registers.GetUInt32(0, reverseRegisterOrder: true);
+
+			// Assert
+			Assert.AreEqual(16909060u, ui);
+		}
+
+		[TestMethod]
+		public void ShouldThrowNullOnGetUInt32()
+		{
+			// Arrange
+			HoldingRegister[] registers = null;
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentNullException>(() => registers.GetUInt32(0));
+		}
+
+		[TestMethod]
+		public void ShouldThrowArgumentOnGetUInt32ForLength()
+		{
+			// Arrange
+			var registers = new HoldingRegister[]
+			{
+				new() { Address = 101, HighByte = 0x01, LowByte = 0x02 }
+			};
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentException>(() => registers.GetUInt32(1));
+		}
+
+		[TestMethod]
+		[DataRow(1)]
+		[DataRow(-1)]
+		public void ShouldThrowArgumentOutOfRangeOnGetUInt32(int startIndex)
+		{
+			// Arrange
+			var registers = new HoldingRegister[]
+			{
+				new() { Address = 101, HighByte = 0x01, LowByte = 0x02 },
+				new() { Address = 100, HighByte = 0x03, LowByte = 0x04 }
+			};
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => registers.GetUInt32(startIndex));
+		}
+
+		[TestMethod]
+		public void ShouldThrowArgumentOnGetUInt32ForType()
+		{
+			// Arrange
+			var registers = new ModbusObject[]
+			{
+				new HoldingRegister { Address = 100, HighByte = 0x01, LowByte = 0x02 },
+				new InputRegister { Address = 101, HighByte = 0x03, LowByte = 0x04 }
+			};
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentException>(() => registers.GetUInt32(0));
+		}
+
+		[TestMethod]
+		public void ShouldGetUInt64()
+		{
+			// Arrange
+			var registers = new HoldingRegister[]
+			{
+				new(),
+				new() { Address = 100, HighByte = 0x00, LowByte = 0x00 },
+				new() { Address = 101, HighByte = 0x00, LowByte = 0x00 },
+				new() { Address = 102, HighByte = 0x01, LowByte = 0x02 },
+				new() { Address = 103, HighByte = 0x03, LowByte = 0x04 }
+			};
+
+			// Act
+			ulong ul = registers.GetUInt64(1);
+
+			// Assert
+			Assert.AreEqual(16909060ul, ul);
+		}
+
+		[TestMethod]
+		public void ShouldGetUInt64ReversedRegisters()
+		{
+			// Arrange
+			var registers = new HoldingRegister[]
+			{
+				new() { Address = 103, HighByte = 0x00, LowByte = 0x00 },
+				new() { Address = 102, HighByte = 0x00, LowByte = 0x00 },
+				new() { Address = 101, HighByte = 0x01, LowByte = 0x02 },
+				new() { Address = 100, HighByte = 0x03, LowByte = 0x04 }
+			};
+
+			// Act
+			ulong ul = registers.GetUInt64(0, reverseRegisterOrder: true);
+
+			// Assert
+			Assert.AreEqual(16909060ul, ul);
+		}
+
+		[TestMethod]
+		public void ShouldThrowNullOnGetUInt64()
+		{
+			// Arrange
+			HoldingRegister[] registers = null;
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentNullException>(() => registers.GetUInt64(0));
+		}
+
+		[TestMethod]
+		public void ShouldThrowArgumentOnGetUInt64ForLength()
+		{
+			// Arrange
+			var registers = new HoldingRegister[]
+			{
+				new() { Address = 101, HighByte = 0x00, LowByte = 0x00 },
+				new() { Address = 102, HighByte = 0x01, LowByte = 0x02 },
+				new() { Address = 103, HighByte = 0x03, LowByte = 0x04 }
+			};
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentException>(() => registers.GetUInt64(0));
+		}
+
+		[TestMethod]
+		[DataRow(1)]
+		[DataRow(-1)]
+		public void ShouldThrowArgumentOutOfRangeOnGetUInt64(int startIndex)
+		{
+			// Arrange
+			var registers = new HoldingRegister[]
+			{
+				new() { Address = 100, HighByte = 0x00, LowByte = 0x00 },
+				new() { Address = 101, HighByte = 0x00, LowByte = 0x00 },
+				new() { Address = 102, HighByte = 0x01, LowByte = 0x02 },
+				new() { Address = 103, HighByte = 0x03, LowByte = 0x04 }
+			};
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => registers.GetUInt64(startIndex));
+		}
+
+		[TestMethod]
+		public void ShouldThrowArgumentOnGetUInt64ForType()
+		{
+			// Arrange
+			var registers = new ModbusObject[]
+			{
+				new HoldingRegister { Address = 100, HighByte = 0x00, LowByte = 0x00 },
+				new InputRegister { Address = 101, HighByte = 0x00, LowByte = 0x00 },
+				new HoldingRegister { Address = 102, HighByte = 0x01, LowByte = 0x02 },
+				new InputRegister { Address = 103, HighByte = 0x03, LowByte = 0x04 }
+			};
+
+			// Act + Assert
+			Assert.ThrowsExactly<ArgumentException>(() => registers.GetUInt64(0));
+		}
+
+		#endregion Modbus to value
+
+		#region Value to Modbus
+
+		[TestMethod]
+		public void ShouldConvertByte()
+		{
+			// Arrange
+			byte b = 123;
+
+			// Act
+			var register = b.ToRegister(321);
+
+			// Assert
+			Assert.IsNotNull(register);
+			Assert.AreEqual(321, register.Address);
+			Assert.AreEqual(0, register.HighByte);
+			Assert.AreEqual(123, register.LowByte);
+		}
+
+		[TestMethod]
+		public void ShouldConvertUInt16()
+		{
+			// Arrange
+			ushort us = 1000;
+
+			// Act
+			var register = us.ToRegister(123);
+
+			// Assert
+			Assert.IsNotNull(register);
+			Assert.AreEqual(123, register.Address);
+			Assert.AreEqual(0x03, register.HighByte);
+			Assert.AreEqual(0xE8, register.LowByte);
+		}
+
+		[TestMethod]
+		public void ShouldConvertUInt32()
+		{
+			// Arrange
+			uint ui = 75000;
+
+			// Act
+			var registers = ui.ToRegister(5).ToList();
+
+			// Assert
+			Assert.IsNotNull(registers);
+			Assert.AreEqual(2, registers.Count);
+
+			Assert.AreEqual(5, registers[0].Address);
+			Assert.AreEqual(0x00, registers[0].HighByte);
+			Assert.AreEqual(0x01, registers[0].LowByte);
+
+			Assert.AreEqual(6, registers[1].Address);
+			Assert.AreEqual(0x24, registers[1].HighByte);
+			Assert.AreEqual(0xF8, registers[1].LowByte);
+		}
+
+		[TestMethod]
+		public void ShouldConvertUInt32Reversed()
+		{
+			// Arrange
+			uint ui = 75000;
+
+			// Act
+			var registers = ui.ToRegister(5, reverseRegisterOrder: true).ToList();
+
+			// Assert
+			Assert.IsNotNull(registers);
+			Assert.AreEqual(2, registers.Count);
+
+			Assert.AreEqual(6, registers[0].Address);
+			Assert.AreEqual(0x00, registers[0].HighByte);
+			Assert.AreEqual(0x01, registers[0].LowByte);
+
+			Assert.AreEqual(5, registers[1].Address);
+			Assert.AreEqual(0x24, registers[1].HighByte);
+			Assert.AreEqual(0xF8, registers[1].LowByte);
+		}
+
+		[TestMethod]
+		public void ShouldConvertUInt64()
+		{
+			// Arrange
+			ulong ul = 75000;
+
+			// Act
+			var registers = ul.ToRegister(10).ToList();
+
+			// Assert
+			Assert.IsNotNull(registers);
+			Assert.AreEqual(4, registers.Count);
+
+			Assert.AreEqual(10, registers[0].Address);
+			Assert.AreEqual(0x00, registers[0].HighByte);
+			Assert.AreEqual(0x00, registers[0].LowByte);
+
+			Assert.AreEqual(11, registers[1].Address);
+			Assert.AreEqual(0x00, registers[1].HighByte);
+			Assert.AreEqual(0x00, registers[1].LowByte);
+
+			Assert.AreEqual(12, registers[2].Address);
+			Assert.AreEqual(0x00, registers[2].HighByte);
+			Assert.AreEqual(0x01, registers[2].LowByte);
+
+			Assert.AreEqual(13, registers[3].Address);
+			Assert.AreEqual(0x24, registers[3].HighByte);
+			Assert.AreEqual(0xF8, registers[3].LowByte);
+		}
+
+		[TestMethod]
+		public void ShouldConvertUInt64Reversed()
+		{
+			// Arrange
+			ulong ul = 75000;
+
+			// Act
+			var registers = ul.ToRegister(10, reverseRegisterOrder: true).ToList();
+
+			// Assert
+			Assert.IsNotNull(registers);
+			Assert.AreEqual(4, registers.Count);
+
+			Assert.AreEqual(13, registers[0].Address);
+			Assert.AreEqual(0x00, registers[0].HighByte);
+			Assert.AreEqual(0x00, registers[0].LowByte);
+
+			Assert.AreEqual(12, registers[1].Address);
+			Assert.AreEqual(0x00, registers[1].HighByte);
+			Assert.AreEqual(0x00, registers[1].LowByte);
+
+			Assert.AreEqual(11, registers[2].Address);
+			Assert.AreEqual(0x00, registers[2].HighByte);
+			Assert.AreEqual(0x01, registers[2].LowByte);
+
+			Assert.AreEqual(10, registers[3].Address);
+			Assert.AreEqual(0x24, registers[3].HighByte);
+			Assert.AreEqual(0xF8, registers[3].LowByte);
+		}
+
+		#endregion Value to Modbus
+	}
+}