am-wd/AMWD.Protocols.Modbus
1
0
Fork 0
Code Issues Actions Activity

Moving structure as preparation for docs

Browse Source
This commit is contained in:
Andreas Müller
2025-08-06 21:05:47 +02:00
parent 885079ae70
commit 799a014b15
117 changed files with 629 additions and 664 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
test/AMWD.Protocols.Modbus.Tests/Common/Models/CoilTest.cs Normal file
View File

@@ -0,0 +1,108 @@
namespace AMWD.Protocols.Modbus.Tests.Common.Models
{
[TestClass]
public class CoilTest
{
[TestMethod]
public void ShouldSuccessfulCompare()
{
// Arrange
var coil1 = new Coil { Address = 123, Value = true };
var coil2 = new Coil { Address = 123, Value = true };
// Act
bool success = coil1.Equals(coil2);
// Assert
Assert.IsTrue(success);
}
[TestMethod]
public void ShouldFailOnInstanceComparing()
{
// Arrange
var coil1 = new Coil { Address = 123, Value = true };
var coil2 = new { Address = 123, HighByte = 0xFF };
// Act
bool success = coil1.Equals(coil2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnTypeComparing()
{
// Arrange
var coil1 = new Coil { Address = 123, Value = true };
var coil2 = new DiscreteInput { Address = 123, HighByte = 0xFF };
// Act
bool success = coil1.Equals(coil2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnAddressComparing()
{
// Arrange
var coil1 = new Coil { Address = 123, Value = true };
var coil2 = new Coil { Address = 321, HighByte = 0xFF };
// Act
bool success = coil1.Equals(coil2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnHighByteComparing()
{
// Arrange
var coil1 = new Coil { Address = 123, Value = true };
var coil2 = new Coil { Address = 123, HighByte = 0x00 };
// Act
bool success = coil1.Equals(coil2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnLowByteComparing()
{
// Arrange
var coil1 = new Coil { Address = 123, Value = true };
var coil2 = new Coil { Address = 123, HighByte = 0xFF, LowByte = 0xFF };
// Act
bool success = coil1.Equals(coil2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
[DataRow(0xFF)]
[DataRow(0x00)]
public void ShouldPrintPrettyString(int highByte)
{
// Arrange
var coil = new Coil { Address = 123, HighByte = (byte)highByte, LowByte = 0x00 };
// Act
string str = coil.ToString();
// Assert
if (highByte > 0)
Assert.AreEqual("Coil #123 | ON", str);
else
Assert.AreEqual("Coil #123 | OFF", str);
}
}
}

108
test/AMWD.Protocols.Modbus.Tests/Common/Models/DiscreteInputTest.cs Normal file
View File

@@ -0,0 +1,108 @@
namespace AMWD.Protocols.Modbus.Tests.Common.Models
{
[TestClass]
public class DiscreteInputTest
{
[TestMethod]
public void ShouldSuccessfulCompare()
{
// Arrange
var input1 = new DiscreteInput { Address = 123, HighByte = 0xFF, LowByte = 0x00 };
var input2 = new DiscreteInput { Address = 123, HighByte = 0xFF, LowByte = 0x00 };
// Act
bool success = input1.Equals(input2);
// Assert
Assert.IsTrue(success);
}
[TestMethod]
public void ShouldFailOnInstanceComparing()
{
// Arrange
var coil1 = new Coil { Address = 123, Value = true };
var coil2 = new { Address = 123, HighByte = 0xFF };
// Act
bool success = coil1.Equals(coil2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnTypeComparing()
{
// Arrange
var input1 = new DiscreteInput { Address = 123, HighByte = 0xFF, LowByte = 0x00 };
var input2 = new Coil { Address = 123, HighByte = 0xFF, LowByte = 0x00 };
// Act
bool success = input1.Equals(input2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnAddressComparing()
{
// Arrange
var input1 = new DiscreteInput { Address = 123, HighByte = 0xFF, LowByte = 0x00 };
var input2 = new DiscreteInput { Address = 321, HighByte = 0xFF, LowByte = 0x00 };
// Act
bool success = input1.Equals(input2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnHighByteComparing()
{
// Arrange
var input1 = new DiscreteInput { Address = 123, HighByte = 0xFF, LowByte = 0x00 };
var input2 = new DiscreteInput { Address = 123, HighByte = 0x00, LowByte = 0x00 };
// Act
bool success = input1.Equals(input2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnLowByteComparing()
{
// Arrange
var input1 = new DiscreteInput { Address = 123, HighByte = 0xFF, LowByte = 0x00 };
var input2 = new DiscreteInput { Address = 123, HighByte = 0xFF, LowByte = 0xFF };
// Act
bool success = input1.Equals(input2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
[DataRow(0xFF)]
[DataRow(0x00)]
public void ShouldPrintPrettyString(int highByte)
{
// Arrange
var input = new DiscreteInput { Address = 123, HighByte = (byte)highByte, LowByte = 0x00 };
// Act
string str = input.ToString();
// Assert
if (highByte > 0)
Assert.AreEqual("Discrete Input #123 | ON", str);
else
Assert.AreEqual("Discrete Input #123 | OFF", str);
}
}
}

117
test/AMWD.Protocols.Modbus.Tests/Common/Models/HoldingRegisterTest.cs Normal file
View File

@@ -0,0 +1,117 @@
namespace AMWD.Protocols.Modbus.Tests.Common.Models
{
[TestClass]
public class HoldingRegisterTests
{
[TestMethod]
public void ShouldSuccessfulCompare()
{
// Arrange
var register1 = new HoldingRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new HoldingRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsTrue(success);
}
[TestMethod]
public void ShouldFailOnInstanceComparing()
{
// Arrange
var register1 = new HoldingRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnTypeComparing()
{
// Arrange
var register1 = new HoldingRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new InputRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnAddressComparing()
{
// Arrange
var register1 = new HoldingRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new HoldingRegister { Address = 321, HighByte = 0xBE, LowByte = 0xEF };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnHighByteComparing()
{
// Arrange
var register1 = new HoldingRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new HoldingRegister { Address = 123, HighByte = 0xBD, LowByte = 0xEF };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnLowByteComparing()
{
// Arrange
var register1 = new HoldingRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new HoldingRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEE };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldPrintPrettyString()
{
// Arrange
var register = new HoldingRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
// Act
string str = register.ToString();
// Assert
Assert.AreEqual("Holding Register #123 | 48879 | HI: BE, LO: EF", str);
}
[TestMethod]
public void ShouldSetByValue()
{
// Arrange
var register = new HoldingRegister { Address = 123 };
// Act
register.Value = 48879;
// Assert
Assert.AreEqual(0xBE, register.HighByte);
Assert.AreEqual(0xEF, register.LowByte);
}
}
}

103
test/AMWD.Protocols.Modbus.Tests/Common/Models/InputRegisterTest.cs Normal file
View File

@@ -0,0 +1,103 @@
namespace AMWD.Protocols.Modbus.Tests.Common.Models
{
[TestClass]
public class InputRegisterTests
{
[TestMethod]
public void ShouldSuccessfulCompare()
{
// Arrange
var register1 = new InputRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new InputRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsTrue(success);
}
[TestMethod]
public void ShouldFailOnInstanceComparing()
{
// Arrange
var register1 = new InputRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnTypeComparing()
{
// Arrange
var register1 = new InputRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new HoldingRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnAddressComparing()
{
// Arrange
var register1 = new InputRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new InputRegister { Address = 321, HighByte = 0xBE, LowByte = 0xEF };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnHighByteComparing()
{
// Arrange
var register1 = new InputRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new InputRegister { Address = 123, HighByte = 0xBD, LowByte = 0xEF };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldFailOnLowByteComparing()
{
// Arrange
var register1 = new InputRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
var register2 = new InputRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEE };
// Act
bool success = register1.Equals(register2);
// Assert
Assert.IsFalse(success);
}
[TestMethod]
public void ShouldPrintPrettyString()
{
// Arrange
var register = new InputRegister { Address = 123, HighByte = 0xBE, LowByte = 0xEF };
// Act
string str = register.ToString();
// Assert
Assert.AreEqual("Input Register #123 | 48879 | HI: BE, LO: EF", str);
}
}
}

287
test/AMWD.Protocols.Modbus.Tests/Common/Models/ModbusDeviceTest.cs Normal file
View File

@@ -0,0 +1,287 @@
using AMWD.Protocols.Modbus.Common.Models;
using System.Reflection;
namespace AMWD.Protocols.Modbus.Tests.Common.Models
{
[TestClass]
public class ModbusDeviceTest
{
[TestMethod]
public void ShouldAllowMultipleDispose()
{
// Arrange
var device = new ModbusDevice(123);
// Act
device.Dispose();
device.Dispose();
// Assert - no exception
}
[TestMethod]
public void ShouldAssertDisposed()
{
// Arrange
var device = new ModbusDevice(123);
device.Dispose();
// Act
try
{
device.GetCoil(111);
Assert.Fail();
}
catch (ObjectDisposedException)
{ }
try
{
device.SetCoil(new Coil { Address = 222 });
Assert.Fail();
}
catch (ObjectDisposedException)
{ }
try
{
device.GetDiscreteInput(111);
Assert.Fail();
}
catch (ObjectDisposedException)
{ }
try
{
device.SetDiscreteInput(new DiscreteInput { Address = 222 });
Assert.Fail();
}
catch (ObjectDisposedException)
{ }
try
{
device.GetHoldingRegister(111);
Assert.Fail();
}
catch (ObjectDisposedException)
{ }
try
{
device.SetHoldingRegister(new HoldingRegister { Address = 222 });
Assert.Fail();
}
catch (ObjectDisposedException)
{ }
try
{
device.GetInputRegister(111);
Assert.Fail();
}
catch (ObjectDisposedException)
{ }
try
{
device.SetInputRegister(new InputRegister { Address = 222 });
Assert.Fail();
}
catch (ObjectDisposedException)
{ }
}
[TestMethod]
public void ShouldGetCoil()
{
// Arrange
var device = new ModbusDevice(123);
((HashSet<ushort>)device.GetType()
.GetField("_coils", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device))
.Add(333);
// Act
var coilFalse = device.GetCoil(111);
var coilTrue = device.GetCoil(333);
// Assert
Assert.AreEqual(111, coilFalse.Address);
Assert.IsFalse(coilFalse.Value);
Assert.AreEqual(333, coilTrue.Address);
Assert.IsTrue(coilTrue.Value);
}
[TestMethod]
public void ShouldSetCoil()
{
// Arrange
var device = new ModbusDevice(123);
((HashSet<ushort>)device.GetType()
.GetField("_coils", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device))
.Add(333);
// Act
device.SetCoil(new Coil { Address = 111, Value = true });
device.SetCoil(new Coil { Address = 333, Value = false });
// Assert
ushort[] coils = ((HashSet<ushort>)device.GetType()
.GetField("_coils", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device)).ToArray();
Assert.AreEqual(1, coils.Length);
Assert.AreEqual(111, coils.First());
}
[TestMethod]
public void ShouldGetDiscreteInput()
{
// Arrange
var device = new ModbusDevice(123);
((HashSet<ushort>)device.GetType()
.GetField("_discreteInputs", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device))
.Add(333);
// Act
var inputFalse = device.GetDiscreteInput(111);
var inputTrue = device.GetDiscreteInput(333);
// Assert
Assert.AreEqual(111, inputFalse.Address);
Assert.IsFalse(inputFalse.Value);
Assert.AreEqual(333, inputTrue.Address);
Assert.IsTrue(inputTrue.Value);
}
[TestMethod]
public void ShouldSetDiscreteInput()
{
// Arrange
var device = new ModbusDevice(123);
((HashSet<ushort>)device.GetType()
.GetField("_discreteInputs", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device))
.Add(333);
// Act
device.SetDiscreteInput(new DiscreteInput { Address = 111, HighByte = 0xFF });
device.SetDiscreteInput(new DiscreteInput { Address = 333, HighByte = 0x00 });
// Assert
ushort[] discreteInputs = ((HashSet<ushort>)device.GetType()
.GetField("_discreteInputs", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device)).ToArray();
Assert.AreEqual(1, discreteInputs.Length);
Assert.AreEqual(111, discreteInputs.First());
}
[TestMethod]
public void ShouldGetHoldingRegister()
{
// Arrange
var device = new ModbusDevice(123);
((Dictionary<ushort, ushort>)device.GetType()
.GetField("_holdingRegisters", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device))
.Add(333, 42);
// Act
var zeroRegister = device.GetHoldingRegister(111);
var valueRegister = device.GetHoldingRegister(333);
// Assert
Assert.AreEqual(111, zeroRegister.Address);
Assert.AreEqual(0, zeroRegister.Value);
Assert.AreEqual(0x00, zeroRegister.HighByte);
Assert.AreEqual(0x00, zeroRegister.LowByte);
Assert.AreEqual(333, valueRegister.Address);
Assert.AreEqual(42, valueRegister.Value);
Assert.AreEqual(0x00, valueRegister.HighByte);
Assert.AreEqual(0x2A, valueRegister.LowByte);
}
[TestMethod]
public void ShouldSetHoldingRegister()
{
// Arrange
var device = new ModbusDevice(123);
((Dictionary<ushort, ushort>)device.GetType()
.GetField("_holdingRegisters", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device))
.Add(333, 42);
// Act
device.SetHoldingRegister(new HoldingRegister { Address = 333, Value = 0 });
device.SetHoldingRegister(new HoldingRegister { Address = 111, Value = 42 });
// Assert
var registers = ((Dictionary<ushort, ushort>)device.GetType()
.GetField("_holdingRegisters", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device))
.ToDictionary(x => x.Key, x => x.Value);
Assert.AreEqual(1, registers.Count);
Assert.AreEqual(111, registers.First().Key);
Assert.AreEqual(42, registers.First().Value);
}
[TestMethod]
public void ShouldGetInputRegister()
{
// Arrange
var device = new ModbusDevice(123);
((Dictionary<ushort, ushort>)device.GetType()
.GetField("_inputRegisters", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device))
.Add(333, 42);
// Act
var zeroRegister = device.GetInputRegister(111);
var valueRegister = device.GetInputRegister(333);
// Assert
Assert.AreEqual(111, zeroRegister.Address);
Assert.AreEqual(0, zeroRegister.Value);
Assert.AreEqual(0x00, zeroRegister.HighByte);
Assert.AreEqual(0x00, zeroRegister.LowByte);
Assert.AreEqual(333, valueRegister.Address);
Assert.AreEqual(42, valueRegister.Value);
Assert.AreEqual(0x00, valueRegister.HighByte);
Assert.AreEqual(0x2A, valueRegister.LowByte);
}
[TestMethod]
public void ShouldSetInputRegister()
{
// Arrange
var device = new ModbusDevice(123);
((Dictionary<ushort, ushort>)device.GetType()
.GetField("_inputRegisters", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device))
.Add(333, 42);
// Act
device.SetInputRegister(new InputRegister { Address = 333, LowByte = 0 });
device.SetInputRegister(new InputRegister { Address = 111, LowByte = 42 });
// Assert
var registers = ((Dictionary<ushort, ushort>)device.GetType()
.GetField("_inputRegisters", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(device))
.ToDictionary(x => x.Key, x => x.Value);
Assert.AreEqual(1, registers.Count);
Assert.AreEqual(111, registers.First().Key);
Assert.AreEqual(42, registers.First().Value);
}
}
}