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

Changed UnitTests for further improvements on testing

Browse Source
This commit is contained in:
Andreas Müller
2025-02-05 20:46:13 +01:00
parent 980dab22f3
commit 5b8a2a8af1
18 changed files with 582 additions and 951 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
AMWD.Protocols.Modbus.Tests/Common/Contracts/ModbusClientBaseTest.cs
View File

@@ -105,16 +105,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Contracts
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowExceptionOnNullConnection() public void ShouldThrowExceptionOnNullConnection()
{ {
// Arrange // Arrange
IModbusConnection connection = null; IModbusConnection connection = null;
// Act // Act + Assert
new ModbusClientBaseWrapper(connection); Assert.ThrowsException<ArgumentNullException>(() => new ModbusClientBaseWrapper(connection));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
@@ -155,31 +152,25 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Contracts
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public async Task ShouldAssertDisposed() public async Task ShouldAssertDisposed()
{ {
// Arrange // Arrange
var client = GetClient(); var client = GetClient();
client.Dispose(); client.Dispose();
// Act // Act + Assert
await client.ReadCoilsAsync(UNIT_ID, START_ADDRESS, READ_COUNT); await Assert.ThrowsExceptionAsync<ObjectDisposedException>(() => client.ReadCoilsAsync(UNIT_ID, START_ADDRESS, READ_COUNT));
// Assert - ObjectDisposedException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldAssertProtocolSet() public async Task ShouldAssertProtocolSet()
{ {
// Arrange // Arrange
var client = GetClient(); var client = GetClient();
client.Protocol = null; client.Protocol = null;
// Act // Act + Assert
await client.ReadCoilsAsync(UNIT_ID, START_ADDRESS, READ_COUNT); await Assert.ThrowsExceptionAsync<ArgumentNullException>(() => client.ReadCoilsAsync(UNIT_ID, START_ADDRESS, READ_COUNT));
// Assert - ArgumentNullException
} }
#endregion Common/Connection/Assertions #endregion Common/Connection/Assertions

56
AMWD.Protocols.Modbus.Tests/Common/Extensions/ModbusDecimalExtensionsTest.cs
View File

@@ -41,20 +41,16 @@
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullOnGetSingle() public void ShouldThrowNullOnGetSingle()
{ {
// Arrange // Arrange
HoldingRegister[] registers = null; HoldingRegister[] registers = null;
// Act // Act + Assert
registers.GetSingle(0); Assert.ThrowsException<ArgumentNullException>(() => registers.GetSingle(0));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetSingleForLength() public void ShouldThrowArgumentOnGetSingleForLength()
{ {
// Arrange // Arrange
@@ -63,16 +59,13 @@
new() { Address = 101, HighByte = 0x01, LowByte = 0x02 } new() { Address = 101, HighByte = 0x01, LowByte = 0x02 }
}; };
// Act // Act + Assert
registers.GetSingle(0); Assert.ThrowsException<ArgumentException>(() => registers.GetSingle(0));
// Assert - ArgumentException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(1)] [DataRow(1)]
[DataRow(-1)] [DataRow(-1)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeOnGetSingle(int startIndex) public void ShouldThrowArgumentOutOfRangeOnGetSingle(int startIndex)
{ {
// Arrange // Arrange
@@ -82,14 +75,11 @@
new() { Address = 100, HighByte = 0x03, LowByte = 0x04 } new() { Address = 100, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetSingle(startIndex); Assert.ThrowsException<ArgumentOutOfRangeException>(() => registers.GetSingle(startIndex));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetSingleForType() public void ShouldThrowArgumentOnGetSingleForType()
{ {
// Arrange // Arrange
@@ -99,10 +89,8 @@
new InputRegister { Address = 101, HighByte = 0x03, LowByte = 0x04 } new InputRegister { Address = 101, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetSingle(0); Assert.ThrowsException<ArgumentException>(() => registers.GetSingle(0));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -145,20 +133,16 @@
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullOnGetDouble() public void ShouldThrowNullOnGetDouble()
{ {
// Arrange // Arrange
HoldingRegister[] registers = null; HoldingRegister[] registers = null;
// Act // Act + Assert
registers.GetDouble(0); Assert.ThrowsException<ArgumentNullException>(() => registers.GetDouble(0));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetDoubleForLength() public void ShouldThrowArgumentOnGetDoubleForLength()
{ {
// Arrange // Arrange
@@ -169,16 +153,13 @@
new() { Address = 102, HighByte = 0x7A, LowByte = 0xE1 } new() { Address = 102, HighByte = 0x7A, LowByte = 0xE1 }
}; };
// Act // Act + Assert
registers.GetDouble(0); Assert.ThrowsException<ArgumentException>(() => registers.GetDouble(0));
// Assert - ArgumentException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(1)] [DataRow(1)]
[DataRow(-1)] [DataRow(-1)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeOnGetDouble(int startIndex) public void ShouldThrowArgumentOutOfRangeOnGetDouble(int startIndex)
{ {
// Arrange // Arrange
@@ -190,14 +171,11 @@
new() { Address = 103, HighByte = 0x47, LowByte = 0xAE } new() { Address = 103, HighByte = 0x47, LowByte = 0xAE }
}; };
// Act // Act + Assert
registers.GetDouble(startIndex); Assert.ThrowsException<ArgumentOutOfRangeException>(() => registers.GetDouble(startIndex));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetDoubleForType() public void ShouldThrowArgumentOnGetDoubleForType()
{ {
// Arrange // Arrange
@@ -209,10 +187,8 @@
new InputRegister { Address = 103, HighByte = 0x47, LowByte = 0xAE } new InputRegister { Address = 103, HighByte = 0x47, LowByte = 0xAE }
}; };
// Act // Act + Assert
registers.GetDouble(0); Assert.ThrowsException<ArgumentException>(() => registers.GetDouble(0));
// Assert - ArgumentException
} }
#endregion Modbus to value #endregion Modbus to value

42
AMWD.Protocols.Modbus.Tests/Common/Extensions/ModbusExtensionsTest.cs
View File

@@ -30,16 +30,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Extensions
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullOnGetBoolean() public void ShouldThrowNullOnGetBoolean()
{ {
// Arrange // Arrange
Coil coil = null; Coil coil = null;
// Act // Act + Assert
coil.GetBoolean(); Assert.ThrowsException<ArgumentNullException>(() => coil.GetBoolean());
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -95,35 +92,28 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Extensions
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullOnString() public void ShouldThrowNullOnString()
{ {
// Arrange // Arrange
HoldingRegister[] list = null; HoldingRegister[] list = null;
// Act // Act + Assert
list.GetString(2); Assert.ThrowsException<ArgumentNullException>(() => list.GetString(2));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnStringForEmptyList() public void ShouldThrowArgumentOnStringForEmptyList()
{ {
// Arrange // Arrange
var registers = Array.Empty<HoldingRegister>(); var registers = Array.Empty<HoldingRegister>();
// Act // Act + Assert
registers.GetString(2); Assert.ThrowsException<ArgumentException>(() => registers.GetString(2));
// Assert - ArgumentException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(1)] [DataRow(1)]
[DataRow(-1)] [DataRow(-1)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeOnString(int startIndex) public void ShouldThrowArgumentOutOfRangeOnString(int startIndex)
{ {
// Arrange // Arrange
@@ -133,14 +123,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Extensions
new() { Address = 2, HighByte = 67, LowByte = 0 } new() { Address = 2, HighByte = 67, LowByte = 0 }
}; };
// Act // Act + Assert
registers.GetString(2, startIndex); Assert.ThrowsException<ArgumentOutOfRangeException>(() => registers.GetString(2, startIndex));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnStringForMixedTypes() public void ShouldThrowArgumentOnStringForMixedTypes()
{ {
// Arrange // Arrange
@@ -150,10 +137,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Extensions
new InputRegister { Address = 2, HighByte = 67, LowByte = 0 } new InputRegister { Address = 2, HighByte = 67, LowByte = 0 }
}; };
// Act // Act + Assert
registers.GetString(2); Assert.ThrowsException<ArgumentException>(() => registers.GetString(2));
// Assert - ArgumentException
} }
#endregion Modbus to value #endregion Modbus to value
@@ -272,16 +257,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Extensions
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullOnGetString() public void ShouldThrowNullOnGetString()
{ {
// Arrange // Arrange
string str = null; string str = null;
// Act // Act + Assert
_ = str.ToRegisters(100).ToArray(); Assert.ThrowsException<ArgumentNullException>(() => str.ToRegisters(100).ToArray());
// Assert - ArgumentNullException
} }
#endregion Value to Modbus #endregion Value to Modbus

96
AMWD.Protocols.Modbus.Tests/Common/Extensions/ModbusSignedExtensionsTest.cs
View File

@@ -32,31 +32,23 @@
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullForGetSByte() public void ShouldThrowNullForGetSByte()
{ {
// Arrange // Arrange
HoldingRegister register = null; HoldingRegister register = null;
// Act // Act + Assert
register.GetSByte(); Assert.ThrowsException<ArgumentNullException>(() => register.GetSByte());
// Assert - ArgumentNullException
Assert.Fail();
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentForGetSByte() public void ShouldThrowArgumentForGetSByte()
{ {
// Arrange // Arrange
var obj = new Coil(); var obj = new Coil();
// Act // Act + Assert
obj.GetSByte(); Assert.ThrowsException<ArgumentException>(() => obj.GetSByte());
// Assert - ArgumentException
Assert.Fail();
} }
[TestMethod] [TestMethod]
@@ -86,31 +78,23 @@
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullForGetInt16() public void ShouldThrowNullForGetInt16()
{ {
// Arrange // Arrange
HoldingRegister register = null; HoldingRegister register = null;
// Act // Act + Assert
register.GetInt16(); Assert.ThrowsException<ArgumentNullException>(() => register.GetInt16());
// Assert - ArgumentNullException
Assert.Fail();
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentForGetInt16() public void ShouldThrowArgumentForGetInt16()
{ {
// Arrange // Arrange
var obj = new Coil(); var obj = new Coil();
// Act // Act + Assert
obj.GetInt16(); Assert.ThrowsException<ArgumentException>(() => obj.GetInt16());
// Assert - ArgumentException
Assert.Fail();
} }
[TestMethod] [TestMethod]
@@ -149,21 +133,16 @@
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullOnGetInt32() public void ShouldThrowNullOnGetInt32()
{ {
// Arrange // Arrange
HoldingRegister[] registers = null; HoldingRegister[] registers = null;
// Act // Act + Assert
registers.GetInt32(0); Assert.ThrowsException<ArgumentNullException>(() => registers.GetInt32(0));
// Assert - ArgumentNullException
Assert.Fail();
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetInt32ForLength() public void ShouldThrowArgumentOnGetInt32ForLength()
{ {
// Arrange // Arrange
@@ -172,17 +151,13 @@
new HoldingRegister { Address = 101, HighByte = 0x01, LowByte = 0x02 } new HoldingRegister { Address = 101, HighByte = 0x01, LowByte = 0x02 }
}; };
// Act // Act + Assert
registers.GetInt32(0); Assert.ThrowsException<ArgumentException>(() => registers.GetInt32(0));
// Assert - ArgumentException
Assert.Fail();
} }
[DataTestMethod] [DataTestMethod]
[DataRow(1)] [DataRow(1)]
[DataRow(-1)] [DataRow(-1)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeOnGetInt32(int startIndex) public void ShouldThrowArgumentOutOfRangeOnGetInt32(int startIndex)
{ {
// Arrange // Arrange
@@ -192,15 +167,11 @@
new HoldingRegister { Address = 100, HighByte = 0x03, LowByte = 0x04 } new HoldingRegister { Address = 100, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetInt32(startIndex); Assert.ThrowsException<ArgumentOutOfRangeException>(() => registers.GetInt32(startIndex));
// Assert - ArgumentOutOfRangeException
Assert.Fail();
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetInt32ForType() public void ShouldThrowArgumentOnGetInt32ForType()
{ {
// Arrange // Arrange
@@ -210,11 +181,8 @@
new InputRegister { Address = 101, HighByte = 0x03, LowByte = 0x04 } new InputRegister { Address = 101, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetInt32(0); Assert.ThrowsException<ArgumentException>(() => registers.GetInt32(0));
// Assert - ArgumentException
Assert.Fail();
} }
[TestMethod] [TestMethod]
@@ -257,21 +225,16 @@
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullOnGetInt64() public void ShouldThrowNullOnGetInt64()
{ {
// Arrange // Arrange
HoldingRegister[] registers = null; HoldingRegister[] registers = null;
// Act // Act + Assert
registers.GetInt64(0); Assert.ThrowsException<ArgumentNullException>(() => registers.GetInt64(0));
// Assert - ArgumentNullException
Assert.Fail();
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetInt64ForLength() public void ShouldThrowArgumentOnGetInt64ForLength()
{ {
// Arrange // Arrange
@@ -282,17 +245,13 @@
new HoldingRegister { Address = 103, HighByte = 0x03, LowByte = 0x04 } new HoldingRegister { Address = 103, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetInt64(0); Assert.ThrowsException<ArgumentException>(() => registers.GetInt64(0));
// Assert - ArgumentException
Assert.Fail();
} }
[DataTestMethod] [DataTestMethod]
[DataRow(1)] [DataRow(1)]
[DataRow(-1)] [DataRow(-1)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeOnGetInt64(int startIndex) public void ShouldThrowArgumentOutOfRangeOnGetInt64(int startIndex)
{ {
// Arrange // Arrange
@@ -304,15 +263,11 @@
new HoldingRegister { Address = 103, HighByte = 0x03, LowByte = 0x04 } new HoldingRegister { Address = 103, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetInt64(startIndex); Assert.ThrowsException<ArgumentOutOfRangeException>(() => registers.GetInt64(startIndex));
// Assert - ArgumentOutOfRangeException
Assert.Fail();
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetInt64ForType() public void ShouldThrowArgumentOnGetInt64ForType()
{ {
// Arrange // Arrange
@@ -324,11 +279,8 @@
new InputRegister { Address = 103, HighByte = 0x03, LowByte = 0x04 } new InputRegister { Address = 103, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetInt64(0); Assert.ThrowsException<ArgumentException>(() => registers.GetInt64(0));
// Assert - ArgumentException
Assert.Fail();
} }
#endregion Modbus to value #endregion Modbus to value

86
AMWD.Protocols.Modbus.Tests/Common/Extensions/ModbusUnsignedExtensionsTest.cs
View File

@@ -32,29 +32,23 @@
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullForGetByte() public void ShouldThrowNullForGetByte()
{ {
// Arrange // Arrange
HoldingRegister register = null; HoldingRegister register = null;
// Act // Act + Assert
register.GetByte(); Assert.ThrowsException<ArgumentNullException>(() => register.GetByte());
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentForGetByte() public void ShouldThrowArgumentForGetByte()
{ {
// Arrange // Arrange
var obj = new Coil(); var obj = new Coil();
// Act // Act + Assert
obj.GetByte(); Assert.ThrowsException<ArgumentException>(() => obj.GetByte());
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -84,29 +78,23 @@
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullForGetUInt16() public void ShouldThrowNullForGetUInt16()
{ {
// Arrange // Arrange
HoldingRegister register = null; HoldingRegister register = null;
// Act // Act + Assert
register.GetUInt16(); Assert.ThrowsException<ArgumentNullException>(() => register.GetUInt16());
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentForGetUInt16() public void ShouldThrowArgumentForGetUInt16()
{ {
// Arrange // Arrange
var obj = new Coil(); var obj = new Coil();
// Act // Act + Assert
obj.GetUInt16(); Assert.ThrowsException<ArgumentException>(() => obj.GetUInt16());
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -145,21 +133,16 @@
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullOnGetUInt32() public void ShouldThrowNullOnGetUInt32()
{ {
// Arrange // Arrange
HoldingRegister[] registers = null; HoldingRegister[] registers = null;
// Act // Act + Assert
registers.GetUInt32(0); Assert.ThrowsException<ArgumentNullException>(() => registers.GetUInt32(0));
// Assert - ArgumentNullException
Assert.Fail();
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetUInt32ForLength() public void ShouldThrowArgumentOnGetUInt32ForLength()
{ {
// Arrange // Arrange
@@ -168,16 +151,13 @@
new() { Address = 101, HighByte = 0x01, LowByte = 0x02 } new() { Address = 101, HighByte = 0x01, LowByte = 0x02 }
}; };
// Act // Act + Assert
registers.GetUInt32(0); Assert.ThrowsException<ArgumentException>(() => registers.GetUInt32(1));
// Assert - ArgumentException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(1)] [DataRow(1)]
[DataRow(-1)] [DataRow(-1)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeOnGetUInt32(int startIndex) public void ShouldThrowArgumentOutOfRangeOnGetUInt32(int startIndex)
{ {
// Arrange // Arrange
@@ -187,14 +167,11 @@
new() { Address = 100, HighByte = 0x03, LowByte = 0x04 } new() { Address = 100, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetUInt32(startIndex); Assert.ThrowsException<ArgumentOutOfRangeException>(() => registers.GetUInt32(startIndex));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetUInt32ForType() public void ShouldThrowArgumentOnGetUInt32ForType()
{ {
// Arrange // Arrange
@@ -204,10 +181,8 @@
new InputRegister { Address = 101, HighByte = 0x03, LowByte = 0x04 } new InputRegister { Address = 101, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetUInt32(0); Assert.ThrowsException<ArgumentException>(() => registers.GetUInt32(0));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -250,21 +225,16 @@
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowNullOnGetUInt64() public void ShouldThrowNullOnGetUInt64()
{ {
// Arrange // Arrange
HoldingRegister[] registers = null; HoldingRegister[] registers = null;
// Act // Act + Assert
registers.GetUInt64(0); Assert.ThrowsException<ArgumentNullException>(() => registers.GetUInt64(0));
// Assert - ArgumentNullException
Assert.Fail();
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetUInt64ForLength() public void ShouldThrowArgumentOnGetUInt64ForLength()
{ {
// Arrange // Arrange
@@ -275,16 +245,13 @@
new() { Address = 103, HighByte = 0x03, LowByte = 0x04 } new() { Address = 103, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetUInt64(0); Assert.ThrowsException<ArgumentException>(() => registers.GetUInt64(0));
// Assert - ArgumentException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(1)] [DataRow(1)]
[DataRow(-1)] [DataRow(-1)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeOnGetUInt64(int startIndex) public void ShouldThrowArgumentOutOfRangeOnGetUInt64(int startIndex)
{ {
// Arrange // Arrange
@@ -296,14 +263,11 @@
new() { Address = 103, HighByte = 0x03, LowByte = 0x04 } new() { Address = 103, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetUInt64(startIndex); Assert.ThrowsException<ArgumentOutOfRangeException>(() => registers.GetUInt64(startIndex));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOnGetUInt64ForType() public void ShouldThrowArgumentOnGetUInt64ForType()
{ {
// Arrange // Arrange
@@ -315,10 +279,8 @@
new InputRegister { Address = 103, HighByte = 0x03, LowByte = 0x04 } new InputRegister { Address = 103, HighByte = 0x03, LowByte = 0x04 }
}; };
// Act // Act + Assert
registers.GetUInt64(0); Assert.ThrowsException<ArgumentException>(() => registers.GetUInt64(0));
// Assert - ArgumentException
} }
#endregion Modbus to value #endregion Modbus to value

239
AMWD.Protocols.Modbus.Tests/Common/Protocols/AsciiProtocolTest.cs
View File

@@ -32,29 +32,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(2001)] [DataRow(2001)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadCoils(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadCoils(int count)
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeReadCoils(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadCoils(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadCoils() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadCoils()
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeReadCoils(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadCoils(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -88,7 +82,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadCoils() public void ShouldThrowExceptionOnDeserializeReadCoils()
{ {
// Arrange // Arrange
@@ -98,10 +91,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
_ = protocol.DeserializeReadCoils(responseBytes); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadCoils(responseBytes));
// Assert - ModbusException
} }
#endregion Read Coils #endregion Read Coils
@@ -129,29 +120,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(2001)] [DataRow(2001)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadDiscreteInputs(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadDiscreteInputs(int count)
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeReadDiscreteInputs(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDiscreteInputs(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadDiscreteInputs() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadDiscreteInputs()
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeReadDiscreteInputs(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDiscreteInputs(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -185,7 +170,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDiscreteInputs() public void ShouldThrowExceptionOnDeserializeReadDiscreteInputs()
{ {
// Arrange // Arrange
@@ -195,10 +179,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.DeserializeReadDiscreteInputs(responseBytes); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDiscreteInputs(responseBytes));
// Assert - ModbusException
} }
#endregion Read Discrete Inputs #endregion Read Discrete Inputs
@@ -226,29 +208,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(2001)] [DataRow(2001)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadHoldingRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadHoldingRegisters(int count)
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeReadHoldingRegisters(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadHoldingRegisters(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadHoldingRegisters() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadHoldingRegisters()
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeReadHoldingRegisters(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadHoldingRegisters(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -276,7 +252,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadHoldingRegisters() public void ShouldThrowExceptionOnDeserializeReadHoldingRegisters()
{ {
// Arrange // Arrange
@@ -286,10 +261,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.DeserializeReadHoldingRegisters(responseBytes); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadHoldingRegisters(responseBytes));
// Assert - ModbusException
} }
#endregion Read Holding Registers #endregion Read Holding Registers
@@ -317,29 +290,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(2001)] [DataRow(2001)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadInputRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadInputRegisters(int count)
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeReadInputRegisters(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadInputRegisters(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadInputRegisters() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadInputRegisters()
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeReadInputRegisters(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadInputRegisters(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -367,7 +334,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadInputRegisters() public void ShouldThrowExceptionOnDeserializeReadInputRegisters()
{ {
// Arrange // Arrange
@@ -377,10 +343,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.DeserializeReadInputRegisters(responseBytes); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadInputRegisters(responseBytes));
// Assert - ModbusException
} }
#endregion Read Input Registers #endregion Read Input Registers
@@ -410,16 +374,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeExceptionForCategoryOnSerializeReadDeviceIdentification() public void ShouldThrowOutOfRangeExceptionForCategoryOnSerializeReadDeviceIdentification()
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeReadDeviceIdentification(UNIT_ID, (ModbusDeviceIdentificationCategory)10, ModbusDeviceIdentificationObject.ProductCode); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDeviceIdentification(UNIT_ID, (ModbusDeviceIdentificationCategory)10, ModbusDeviceIdentificationObject.ProductCode));
// Assert - ArgumentOutOfRangeException
} }
[DataTestMethod] [DataTestMethod]
@@ -449,7 +410,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForMeiType() public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForMeiType()
{ {
// Arrange // Arrange
@@ -459,12 +419,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.DeserializeReadDeviceIdentification(responseBytes); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDeviceIdentification(responseBytes));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForCategory() public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForCategory()
{ {
// Arrange // Arrange
@@ -474,8 +433,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.DeserializeReadDeviceIdentification(responseBytes); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDeviceIdentification(responseBytes));
} }
#endregion Read Device Identification #endregion Read Device Identification
@@ -502,16 +461,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteSingleCoil() public void ShouldThrowArgumentNullOnSerializeWriteSingleCoil()
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeWriteSingleCoil(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteSingleCoil(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -557,16 +513,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteSingleHoldingRegister() public void ShouldThrowArgumentNullOnSerializeWriteSingleHoldingRegister()
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeWriteSingleHoldingRegister(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteSingleHoldingRegister(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -619,22 +572,18 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteMultipleCoils() public void ShouldThrowArgumentNullOnSerializeWriteMultipleCoils()
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(1969)] [DataRow(1969)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleCoils(int count) public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleCoils(int count)
{ {
// Arrange // Arrange
@@ -644,14 +593,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleCoils() public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleCoils()
{ {
// Arrange // Arrange
@@ -662,14 +608,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleCoils() public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleCoils()
{ {
// Arrange // Arrange
@@ -680,10 +623,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -732,22 +673,18 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteMultipleHoldingRegisters() public void ShouldThrowArgumentNullOnSerializeWriteMultipleHoldingRegisters()
{ {
// Arrange // Arrange
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(124)] [DataRow(124)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleHoldingRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleHoldingRegisters(int count)
{ {
// Arrange // Arrange
@@ -757,14 +694,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleHoldingRegisters() public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleHoldingRegisters()
{ {
// Arrange // Arrange
@@ -775,14 +709,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleHoldingRegisters() public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleHoldingRegisters()
{ {
// Arrange // Arrange
@@ -793,10 +724,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -898,7 +827,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForMissingHeaderOnValidateResponse() public void ShouldThrowForMissingHeaderOnValidateResponse()
{ {
// Arrange // Arrange
@@ -907,12 +835,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
AddTrailer(ref response); AddTrailer(ref response);
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForMissingTrailerOnValidateResponse() public void ShouldThrowForMissingTrailerOnValidateResponse()
{ {
// Arrange // Arrange
@@ -920,12 +847,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
string response = $":{UNIT_ID:X2}010100"; string response = $":{UNIT_ID:X2}010100";
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForUnitIdOnValidateResponse() public void ShouldThrowForUnitIdOnValidateResponse()
{ {
// Arrange // Arrange
@@ -934,12 +860,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
AddTrailer(ref response); AddTrailer(ref response);
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForLrcOnValidateResponse() public void ShouldThrowForLrcOnValidateResponse()
{ {
// Arrange // Arrange
@@ -947,12 +872,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
string response = $":{UNIT_ID:X2}010001FF00XX\r\n"; string response = $":{UNIT_ID:X2}010001FF00XX\r\n";
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForFunctionCodeOnValidateResponse() public void ShouldThrowForFunctionCodeOnValidateResponse()
{ {
// Arrange // Arrange
@@ -961,12 +885,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
AddTrailer(ref response); AddTrailer(ref response);
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForErrorOnValidateResponse() public void ShouldThrowForErrorOnValidateResponse()
{ {
// Arrange // Arrange
@@ -975,8 +898,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
AddTrailer(ref response); AddTrailer(ref response);
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)));
} }
[DataTestMethod] [DataTestMethod]
@@ -984,7 +907,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataRow(0x02)] [DataRow(0x02)]
[DataRow(0x03)] [DataRow(0x03)]
[DataRow(0x04)] [DataRow(0x04)]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForReadLengthOnValidateResponse(int fn) public void ShouldThrowForReadLengthOnValidateResponse(int fn)
{ {
// Arrange // Arrange
@@ -993,8 +915,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
AddTrailer(ref response); AddTrailer(ref response);
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)));
} }
[DataTestMethod] [DataTestMethod]
@@ -1002,7 +924,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataRow(0x06)] [DataRow(0x06)]
[DataRow(0x0F)] [DataRow(0x0F)]
[DataRow(0x10)] [DataRow(0x10)]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForWriteLengthOnValidateResponse(int fn) public void ShouldThrowForWriteLengthOnValidateResponse(int fn)
{ {
// Arrange // Arrange
@@ -1011,8 +932,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
AddTrailer(ref response); AddTrailer(ref response);
var protocol = new AsciiProtocol(); var protocol = new AsciiProtocol();
// Act // Act + Assert
protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(Encoding.ASCII.GetBytes(request), Encoding.ASCII.GetBytes(response)));
} }
[TestMethod] [TestMethod]
@@ -1033,58 +954,46 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataRow("")] [DataRow("")]
[DataRow(" ")] [DataRow(" ")]
[DataRow("\t")] [DataRow("\t")]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionForMessageOnLrc(string msg) public void ShouldThrowArgumentNullExceptionForMessageOnLrc(string msg)
{ {
// Arrange // Arrange
// Act // Act + Assert
AsciiProtocol.LRC(msg); Assert.ThrowsException<ArgumentNullException>(() => AsciiProtocol.LRC(msg));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(-1)] [DataRow(-1)]
[DataRow(4)] [DataRow(4)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeExceptionForStartOnLrc(int start) public void ShouldThrowArgumentOutOfRangeExceptionForStartOnLrc(int start)
{ {
// Arrange // Arrange
string msg = "0207"; string msg = "0207";
// Act // Act + Assert
AsciiProtocol.LRC(msg, start); Assert.ThrowsException<ArgumentOutOfRangeException>(() => AsciiProtocol.LRC(msg, start));
// Assert - ArgumentOutOfRangeException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(5)] [DataRow(5)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeExceptionForLengthOnLrc(int length) public void ShouldThrowArgumentOutOfRangeExceptionForLengthOnLrc(int length)
{ {
// Arrange // Arrange
string msg = "0207"; string msg = "0207";
// Act // Act + Assert
AsciiProtocol.LRC(msg, 0, length); Assert.ThrowsException<ArgumentOutOfRangeException>(() => AsciiProtocol.LRC(msg, 0, length));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForMessageLengthOnLrc() public void ShouldThrowArgumentExceptionForMessageLengthOnLrc()
{ {
// Arrange // Arrange
string msg = "0207"; string msg = "0207";
// Act // Act + Assert
AsciiProtocol.LRC(msg); Assert.ThrowsException<ArgumentException>(() => AsciiProtocol.LRC(msg));
// Assert - ArgumentException
} }
#endregion Validation #endregion Validation

206
AMWD.Protocols.Modbus.Tests/Common/Protocols/RtuOverTcpProtocolTest.cs
View File

@@ -55,29 +55,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(2001)] [DataRow(2001)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadCoils(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadCoils(int count)
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeReadCoils(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadCoils(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadCoils() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadCoils()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeReadCoils(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadCoils(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -106,16 +100,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadCoils() public void ShouldThrowExceptionOnDeserializeReadCoils()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.DeserializeReadCoils([0x00, 0x01, 0x00, 0x00, 0x00, 0x08, UNIT_ID, 0x01, 0x02, 0xCD, 0x6B, 0x05, 0x00, 0x00]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadCoils([0x00, 0x01, 0x00, 0x00, 0x00, 0x08, UNIT_ID, 0x01, 0x02, 0xCD, 0x6B, 0x05, 0x00, 0x00]));
// Assert - ModbusException
} }
#endregion Read Coils #endregion Read Coils
@@ -166,29 +157,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(2001)] [DataRow(2001)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadDiscreteInputs(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadDiscreteInputs(int count)
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeReadDiscreteInputs(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDiscreteInputs(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadDiscreteInputs() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadDiscreteInputs()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeReadDiscreteInputs(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDiscreteInputs(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -217,16 +202,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDiscreteInputs() public void ShouldThrowExceptionOnDeserializeReadDiscreteInputs()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.DeserializeReadDiscreteInputs([0x00, 0x01, 0x00, 0x00, 0x00, 0x08, UNIT_ID, 0x02, 0x02, 0xCD, 0x6B, 0x05, 0x00, 0x00]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDiscreteInputs([0x00, 0x01, 0x00, 0x00, 0x00, 0x08, UNIT_ID, 0x02, 0x02, 0xCD, 0x6B, 0x05, 0x00, 0x00]));
// Assert - ModbusException
} }
#endregion Read Discrete Inputs #endregion Read Discrete Inputs
@@ -277,29 +259,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(126)] [DataRow(126)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadHoldingRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadHoldingRegisters(int count)
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeReadHoldingRegisters(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadHoldingRegisters(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadHoldingRegisters() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadHoldingRegisters()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeReadHoldingRegisters(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadHoldingRegisters(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -323,16 +299,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadHoldingRegisters() public void ShouldThrowExceptionOnDeserializeReadHoldingRegisters()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.DeserializeReadHoldingRegisters([0x00, 0x01, 0x00, 0x00, 0x00, 0x07, UNIT_ID, 0x03, 0x04, 0x02, 0x2B, 0x00, 0x00]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadHoldingRegisters([0x00, 0x01, 0x00, 0x00, 0x00, 0x08, UNIT_ID, 0x03, 0x04, 0x02, 0x2B, 0x00, 0x00]));
// Assert - ModbusException
} }
#endregion Read Holding Registers #endregion Read Holding Registers
@@ -383,29 +356,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(126)] [DataRow(126)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadInputRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadInputRegisters(int count)
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeReadInputRegisters(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadInputRegisters(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadInputRegisters() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadInputRegisters()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeReadInputRegisters(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadInputRegisters(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -429,16 +396,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadInputRegisters() public void ShouldThrowExceptionOnDeserializeReadInputRegisters()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.DeserializeReadInputRegisters([0x00, 0x01, 0x00, 0x00, 0x00, 0x07, UNIT_ID, 0x04, 0x04, 0x02, 0x2B, 0x00, 0x00]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadInputRegisters([0x00, 0x01, 0x00, 0x00, 0x00, 0x08, UNIT_ID, 0x04, 0x04, 0x02, 0x2B, 0x00, 0x00]));
// Assert - ModbusException
} }
#endregion Read Input Registers #endregion Read Input Registers
@@ -493,16 +457,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeExceptionForCategoryOnSerializeReadDeviceIdentification() public void ShouldThrowOutOfRangeExceptionForCategoryOnSerializeReadDeviceIdentification()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeReadDeviceIdentification(UNIT_ID, (ModbusDeviceIdentificationCategory)10, ModbusDeviceIdentificationObject.ProductCode); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDeviceIdentification(UNIT_ID, (ModbusDeviceIdentificationCategory)10, ModbusDeviceIdentificationObject.ProductCode));
// Assert - ArgumentOutOfRangeException
} }
[DataTestMethod] [DataTestMethod]
@@ -529,27 +490,25 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForMeiType() public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForMeiType()
{ {
// Arrange // Arrange
byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x05, UNIT_ID, 0x2B, 0x0D, 0x00, 0x00]; byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x05, UNIT_ID, 0x2B, 0x0D, 0x00, 0x00];
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.DeserializeReadDeviceIdentification(response); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDeviceIdentification(response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForCategory() public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForCategory()
{ {
// Arrange // Arrange
byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x06, UNIT_ID, 0x2B, 0x0E, 0x08, 0x00, 0x00]; byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x06, UNIT_ID, 0x2B, 0x0E, 0x08, 0x00, 0x00];
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.DeserializeReadDeviceIdentification(response); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDeviceIdentification(response));
} }
#endregion Read Device Identification #endregion Read Device Identification
@@ -600,16 +559,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteSingleCoil() public void ShouldThrowArgumentNullOnSerializeWriteSingleCoil()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteSingleCoil(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteSingleCoil(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -676,16 +632,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteSingleHoldingRegister() public void ShouldThrowArgumentNullOnSerializeWriteSingleHoldingRegister()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteSingleHoldingRegister(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteSingleHoldingRegister(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -765,22 +718,18 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteMultipleCoils() public void ShouldThrowArgumentNullOnSerializeWriteMultipleCoils()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(1969)] [DataRow(1969)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleCoils(int count) public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleCoils(int count)
{ {
// Arrange // Arrange
@@ -790,14 +739,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleCoils() public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleCoils()
{ {
// Arrange // Arrange
@@ -808,14 +754,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleCoils() public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleCoils()
{ {
// Arrange // Arrange
@@ -826,10 +769,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -908,22 +849,18 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteMultipleHoldingRegisters() public void ShouldThrowArgumentNullOnSerializeWriteMultipleHoldingRegisters()
{ {
// Arrange // Arrange
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(124)] [DataRow(124)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleHoldingRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleHoldingRegisters(int count)
{ {
// Arrange // Arrange
@@ -933,14 +870,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleHoldingRegisters() public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleHoldingRegisters()
{ {
// Arrange // Arrange
@@ -951,14 +885,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleHoldingRegisters() public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleHoldingRegisters()
{ {
// Arrange // Arrange
@@ -969,10 +900,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -1065,7 +994,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0x00, 0x00)] [DataRow(0x00, 0x00)]
[DataRow(0x01, 0x01)] [DataRow(0x01, 0x01)]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForTransactionIdOnValidateResponse(int hi, int lo) public void ShouldThrowForTransactionIdOnValidateResponse(int hi, int lo)
{ {
// Arrange // Arrange
@@ -1074,14 +1002,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
SetCrc(response); SetCrc(response);
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0x00, 0x01)] [DataRow(0x00, 0x01)]
[DataRow(0x01, 0x00)] [DataRow(0x01, 0x00)]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForProtocolIdOnValidateResponse(int hi, int lo) public void ShouldThrowForProtocolIdOnValidateResponse(int hi, int lo)
{ {
// Arrange // Arrange
@@ -1090,12 +1017,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
SetCrc(response); SetCrc(response);
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForFollowingBytesOnValidateResponse() public void ShouldThrowForFollowingBytesOnValidateResponse()
{ {
// Arrange // Arrange
@@ -1104,12 +1030,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
SetCrc(response); SetCrc(response);
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForUnitIdOnValidateResponse() public void ShouldThrowForUnitIdOnValidateResponse()
{ {
// Arrange // Arrange
@@ -1118,12 +1043,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
SetCrc(response); SetCrc(response);
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForFunctionCodeOnValidateResponse() public void ShouldThrowForFunctionCodeOnValidateResponse()
{ {
// Arrange // Arrange
@@ -1132,12 +1056,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
SetCrc(response); SetCrc(response);
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForModbusErrorOnValidateResponse() public void ShouldThrowForModbusErrorOnValidateResponse()
{ {
// Arrange // Arrange
@@ -1146,14 +1069,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
SetCrc(response); SetCrc(response);
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0x59, 0x6C)] [DataRow(0x59, 0x6C)]
[DataRow(0x58, 0x6B)] [DataRow(0x58, 0x6B)]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForCrcOnValidateResponse(int hi, int lo) public void ShouldThrowForCrcOnValidateResponse(int hi, int lo)
{ {
// Arrange // Arrange
@@ -1161,8 +1083,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x06, UNIT_ID, 0x01, 0x01, 0x00, (byte)hi, (byte)lo]; byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x06, UNIT_ID, 0x01, 0x01, 0x00, (byte)hi, (byte)lo];
var protocol = new RtuOverTcpProtocol(); var protocol = new RtuOverTcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
#endregion Validation #endregion Validation

222
AMWD.Protocols.Modbus.Tests/Common/Protocols/RtuProtocolTest.cs
View File

@@ -43,29 +43,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(2001)] [DataRow(2001)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadCoils(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadCoils(int count)
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeReadCoils(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadCoils(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadCoils() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadCoils()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeReadCoils(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadCoils(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -94,16 +88,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadCoils() public void ShouldThrowExceptionOnDeserializeReadCoils()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
_ = protocol.DeserializeReadCoils([UNIT_ID, 0x01, 0x02, 0xCD, 0x6B, 0x05, 0x00, 0x00]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadCoils([UNIT_ID, 0x01, 0x02, 0xCD, 0x6B, 0x05, 0x00, 0x00]));
// Assert - ModbusException
} }
#endregion Read Coils #endregion Read Coils
@@ -142,29 +133,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(2001)] [DataRow(2001)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadDiscreteInputs(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadDiscreteInputs(int count)
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeReadDiscreteInputs(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDiscreteInputs(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadDiscreteInputs() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadDiscreteInputs()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeReadDiscreteInputs(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDiscreteInputs(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -193,16 +178,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDiscreteInputs() public void ShouldThrowExceptionOnDeserializeReadDiscreteInputs()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
_ = protocol.DeserializeReadDiscreteInputs([UNIT_ID, 0x02, 0x02, 0xCD, 0x6B, 0x05, 0x00, 0x00]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDiscreteInputs([UNIT_ID, 0x02, 0x02, 0xCD, 0x6B, 0x05, 0x00, 0x00]));
// Assert - ModbusException
} }
#endregion Read Discrete Inputs #endregion Read Discrete Inputs
@@ -241,29 +223,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(126)] [DataRow(126)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadHoldingRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadHoldingRegisters(int count)
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeReadHoldingRegisters(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadHoldingRegisters(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadHoldingRegisters() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadHoldingRegisters()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeReadHoldingRegisters(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadHoldingRegisters(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -287,16 +263,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadHoldingRegisters() public void ShouldThrowExceptionOnDeserializeReadHoldingRegisters()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.DeserializeReadHoldingRegisters([UNIT_ID, 0x03, 0x04, 0x02, 0x2B, 0x00, 0x00]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadHoldingRegisters([UNIT_ID, 0x03, 0x04, 0x02, 0x2B, 0x00, 0x00]));
// Assert - ModbusException
} }
#endregion Read Holding Registers #endregion Read Holding Registers
@@ -335,29 +308,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(126)] [DataRow(126)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadInputRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadInputRegisters(int count)
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeReadInputRegisters(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadInputRegisters(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadInputRegisters() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadInputRegisters()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeReadInputRegisters(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadInputRegisters(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -381,16 +348,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadInputRegisters() public void ShouldThrowExceptionOnDeserializeReadInputRegisters()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.DeserializeReadInputRegisters([UNIT_ID, 0x04, 0x04, 0x02, 0x2B, 0x00, 0x00]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadInputRegisters([UNIT_ID, 0x04, 0x04, 0x02, 0x2B, 0x00, 0x00]));
// Assert - ModbusException
} }
#endregion Read Input Registers #endregion Read Input Registers
@@ -433,16 +397,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeExceptionForCategoryOnSerializeReadDeviceIdentification() public void ShouldThrowOutOfRangeExceptionForCategoryOnSerializeReadDeviceIdentification()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeReadDeviceIdentification(UNIT_ID, (ModbusDeviceIdentificationCategory)10, ModbusDeviceIdentificationObject.ProductCode); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDeviceIdentification(UNIT_ID, (ModbusDeviceIdentificationCategory)10, ModbusDeviceIdentificationObject.ProductCode));
// Assert - ArgumentOutOfRangeException
} }
[DataTestMethod] [DataTestMethod]
@@ -469,27 +430,25 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForMeiType() public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForMeiType()
{ {
// Arrange // Arrange
byte[] response = [UNIT_ID, 0x2B, 0x0D, 0x00, 0x00]; byte[] response = [UNIT_ID, 0x2B, 0x0D, 0x00, 0x00];
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.DeserializeReadDeviceIdentification(response); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDeviceIdentification(response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForCategory() public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForCategory()
{ {
// Arrange // Arrange
byte[] response = [UNIT_ID, 0x2B, 0x0E, 0x08, 0x00, 0x00]; byte[] response = [UNIT_ID, 0x2B, 0x0E, 0x08, 0x00, 0x00];
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.DeserializeReadDeviceIdentification(response); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDeviceIdentification(response));
} }
#endregion Read Device Identification #endregion Read Device Identification
@@ -528,16 +487,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteSingleCoil() public void ShouldThrowArgumentNullOnSerializeWriteSingleCoil()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeWriteSingleCoil(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteSingleCoil(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -592,16 +548,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteSingleHoldingRegister() public void ShouldThrowArgumentNullOnSerializeWriteSingleHoldingRegister()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeWriteSingleHoldingRegister(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteSingleHoldingRegister(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -669,22 +622,18 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteMultipleCoils() public void ShouldThrowArgumentNullOnSerializeWriteMultipleCoils()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(1969)] [DataRow(1969)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleCoils(int count) public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleCoils(int count)
{ {
// Arrange // Arrange
@@ -694,14 +643,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleCoils() public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleCoils()
{ {
// Arrange // Arrange
@@ -712,14 +658,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleCoils() public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleCoils()
{ {
// Arrange // Arrange
@@ -730,10 +673,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -800,22 +741,18 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteMultipleHoldingRegisters() public void ShouldThrowArgumentNullOnSerializeWriteMultipleHoldingRegisters()
{ {
// Arrange // Arrange
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(124)] [DataRow(124)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleHoldingRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleHoldingRegisters(int count)
{ {
// Arrange // Arrange
@@ -825,14 +762,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleHoldingRegisters() public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleHoldingRegisters()
{ {
// Arrange // Arrange
@@ -843,14 +777,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleHoldingRegisters() public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleHoldingRegisters()
{ {
// Arrange // Arrange
@@ -861,10 +792,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -1105,7 +1034,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForUnitIdOnValidateResponse() public void ShouldThrowForUnitIdOnValidateResponse()
{ {
// Arrange // Arrange
@@ -1114,14 +1042,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
SetCrc(response); SetCrc(response);
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0x57, 0x6C)] [DataRow(0x57, 0x6C)]
[DataRow(0x58, 0x6B)] [DataRow(0x58, 0x6B)]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForCrcOnValidateResponse(int hi, int lo) public void ShouldThrowForCrcOnValidateResponse(int hi, int lo)
{ {
// Arrange // Arrange
@@ -1129,12 +1056,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
byte[] response = [UNIT_ID, 0x01, 0x01, 0x00, (byte)hi, (byte)lo]; byte[] response = [UNIT_ID, 0x01, 0x01, 0x00, (byte)hi, (byte)lo];
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForFunctionCodeOnValidateResponse() public void ShouldThrowForFunctionCodeOnValidateResponse()
{ {
// Arrange // Arrange
@@ -1143,12 +1069,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
SetCrc(response); SetCrc(response);
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForErrorOnValidateResponse() public void ShouldThrowForErrorOnValidateResponse()
{ {
// Arrange // Arrange
@@ -1157,8 +1082,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
SetCrc(response); SetCrc(response);
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[DataTestMethod] [DataTestMethod]
@@ -1166,7 +1091,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataRow(0x02)] [DataRow(0x02)]
[DataRow(0x03)] [DataRow(0x03)]
[DataRow(0x04)] [DataRow(0x04)]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForReadLengthOnValidateResponse(int fn) public void ShouldThrowForReadLengthOnValidateResponse(int fn)
{ {
// Arrange // Arrange
@@ -1175,8 +1099,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
SetCrc(response); SetCrc(response);
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[DataTestMethod] [DataTestMethod]
@@ -1184,7 +1108,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataRow(0x06)] [DataRow(0x06)]
[DataRow(0x0F)] [DataRow(0x0F)]
[DataRow(0x10)] [DataRow(0x10)]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForWriteLengthOnValidateResponse(int fn) public void ShouldThrowForWriteLengthOnValidateResponse(int fn)
{ {
// Arrange // Arrange
@@ -1193,8 +1116,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
SetCrc(response); SetCrc(response);
var protocol = new RtuProtocol(); var protocol = new RtuProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[TestMethod] [TestMethod]
@@ -1217,43 +1140,36 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(null)] [DataRow(null)]
[DataRow(new byte[0])] [DataRow(new byte[0])]
[ExpectedException(typeof(ArgumentNullException))]
public void ShuldThrowArgumentNullExceptionForBytesOnCrc16(byte[] bytes) public void ShuldThrowArgumentNullExceptionForBytesOnCrc16(byte[] bytes)
{ {
// Act // Arrange
_ = RtuProtocol.CRC16(bytes);
// Assert - ArgumentNullException // Act + Assert
Assert.ThrowsException<ArgumentNullException>(() => RtuProtocol.CRC16(bytes));
} }
[DataTestMethod] [DataTestMethod]
[DataRow(-1)] [DataRow(-1)]
[DataRow(10)] [DataRow(10)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeForStartOnCrc16(int start) public void ShouldThrowArgumentOutOfRangeForStartOnCrc16(int start)
{ {
// Arrange // Arrange
byte[] bytes = Encoding.UTF8.GetBytes("0123456789"); byte[] bytes = Encoding.UTF8.GetBytes("0123456789");
// Act // Act + Assert
_ = RtuProtocol.CRC16(bytes, start); Assert.ThrowsException<ArgumentOutOfRangeException>(() => RtuProtocol.CRC16(bytes, start));
// Assert - ArgumentOutOfRangeException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(11)] [DataRow(11)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeForLengthOnCrc16(int length) public void ShouldThrowArgumentOutOfRangeForLengthOnCrc16(int length)
{ {
// Arrange // Arrange
byte[] bytes = Encoding.UTF8.GetBytes("0123456789"); byte[] bytes = Encoding.UTF8.GetBytes("0123456789");
// Act // Act + Assert
_ = RtuProtocol.CRC16(bytes, 0, length); Assert.ThrowsException<ArgumentOutOfRangeException>(() => RtuProtocol.CRC16(bytes, 0, length));
// Assert - ArgumentOutOfRangeException
} }
#endregion Validation #endregion Validation

201
AMWD.Protocols.Modbus.Tests/Common/Protocols/TcpProtocolTest.cs
View File

@@ -53,29 +53,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(2001)] [DataRow(2001)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadCoils(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadCoils(int count)
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeReadCoils(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadCoils(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadCoils() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadCoils()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeReadCoils(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadCoils(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -104,16 +98,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadCoils() public void ShouldThrowExceptionOnDeserializeReadCoils()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
var coils = protocol.DeserializeReadCoils([0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x2A, 0x01, 0x02, 0xCD, 0x6B, 0x05]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadCoils([0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x2A, 0x01, 0x02, 0xCD, 0x6B, 0x05]));
// Assert - ModbusException
} }
#endregion Read Coils #endregion Read Coils
@@ -162,29 +153,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(2001)] [DataRow(2001)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadDiscreteInputs(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadDiscreteInputs(int count)
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeReadDiscreteInputs(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDiscreteInputs(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadDiscreteInputs() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadDiscreteInputs()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeReadDiscreteInputs(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDiscreteInputs(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -213,16 +198,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDiscreteInputs() public void ShouldThrowExceptionOnDeserializeReadDiscreteInputs()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.DeserializeReadDiscreteInputs([0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x2A, 0x02, 0x03, 0xCD, 0x6B]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDiscreteInputs([0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x2A, 0x02, 0x03, 0xCD, 0x6B]));
// Assert - ModbusException
} }
#endregion Read Discrete Inputs #endregion Read Discrete Inputs
@@ -271,29 +253,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(126)] [DataRow(126)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadHoldingRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadHoldingRegisters(int count)
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeReadHoldingRegisters(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadHoldingRegisters(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadHoldingRegisters() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadHoldingRegisters()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeReadHoldingRegisters(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadHoldingRegisters(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -317,16 +293,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadHoldingRegisters() public void ShouldThrowExceptionOnDeserializeReadHoldingRegisters()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.DeserializeReadHoldingRegisters([0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x2A, 0x03, 0x04, 0x02, 0x2B]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadHoldingRegisters([0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x2A, 0x03, 0x04, 0x02, 0x2B]));
// Assert - ModbusException
} }
#endregion Read Holding Registers #endregion Read Holding Registers
@@ -375,29 +348,23 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(126)] [DataRow(126)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeReadInputRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeReadInputRegisters(int count)
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeReadInputRegisters(UNIT_ID, 19, (ushort)count); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadInputRegisters(UNIT_ID, 19, (ushort)count));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadInputRegisters() public void ShouldThrowOutOfRangeForStartingAddressOnSerializeReadInputRegisters()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeReadInputRegisters(UNIT_ID, ushort.MaxValue, 2); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadInputRegisters(UNIT_ID, ushort.MaxValue, 2));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -421,16 +388,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadInputRegisters() public void ShouldThrowExceptionOnDeserializeReadInputRegisters()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.DeserializeReadInputRegisters([0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x2A, 0x04, 0x04, 0x02, 0x2B]); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadInputRegisters([0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x2A, 0x04, 0x04, 0x02, 0x2B]));
// Assert - ModbusException
} }
#endregion Read Input Registers #endregion Read Input Registers
@@ -483,16 +447,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeExceptionOnSerializeReadDeviceIdentification() public void ShouldThrowOutOfRangeExceptionOnSerializeReadDeviceIdentification()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeReadDeviceIdentification(UNIT_ID, (ModbusDeviceIdentificationCategory)10, ModbusDeviceIdentificationObject.ProductCode); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeReadDeviceIdentification(UNIT_ID, (ModbusDeviceIdentificationCategory)10, ModbusDeviceIdentificationObject.ProductCode));
// Assert - ArgumentOutOfRangeException
} }
[DataTestMethod] [DataTestMethod]
@@ -519,27 +480,25 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForMeiType() public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForMeiType()
{ {
// Arrange // Arrange
byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x0D, 0x2A, 0x2B, 0x0D]; byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x0D, 0x2A, 0x2B, 0x0D];
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.DeserializeReadDeviceIdentification(response); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDeviceIdentification(response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForCategory() public void ShouldThrowExceptionOnDeserializeReadDeviceIdentificationForCategory()
{ {
// Arrange // Arrange
byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x0D, 0x2A, 0x2B, 0x0E, 0x08]; byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x0D, 0x2A, 0x2B, 0x0E, 0x08];
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.DeserializeReadDeviceIdentification(response); Assert.ThrowsException<ModbusException>(() => protocol.DeserializeReadDeviceIdentification(response));
} }
#endregion Read Device Identification #endregion Read Device Identification
@@ -588,16 +547,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteSingleCoil() public void ShouldThrowArgumentNullOnSerializeWriteSingleCoil()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteSingleCoil(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteSingleCoil(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -662,16 +618,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteSingleHoldingRegister() public void ShouldThrowArgumentNullOnSerializeWriteSingleHoldingRegister()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteSingleHoldingRegister(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteSingleHoldingRegister(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -749,22 +702,18 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteMultipleCoils() public void ShouldThrowArgumentNullOnSerializeWriteMultipleCoils()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(1969)] [DataRow(1969)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleCoils(int count) public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleCoils(int count)
{ {
// Arrange // Arrange
@@ -774,14 +723,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleCoils() public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleCoils()
{ {
// Arrange // Arrange
@@ -792,14 +738,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleCoils() public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleCoils()
{ {
// Arrange // Arrange
@@ -810,10 +753,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleCoils(UNIT_ID, coils); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleCoils(UNIT_ID, coils));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -890,22 +831,18 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnSerializeWriteMultipleHoldingRegisters() public void ShouldThrowArgumentNullOnSerializeWriteMultipleHoldingRegisters()
{ {
// Arrange // Arrange
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, null); Assert.ThrowsException<ArgumentNullException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, null));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(124)] [DataRow(124)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleHoldingRegisters(int count) public void ShouldThrowOutOfRangeForCountOnSerializeWriteMultipleHoldingRegisters(int count)
{ {
// Arrange // Arrange
@@ -915,14 +852,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentOutOfRangeException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleHoldingRegisters() public void ShouldThrowArgumentExceptionForDuplicateEntryOnSerializeMultipleHoldingRegisters()
{ {
// Arrange // Arrange
@@ -933,14 +867,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleHoldingRegisters() public void ShouldThrowArgumentExceptionForGapInAddressOnSerializeMultipleHoldingRegisters()
{ {
// Arrange // Arrange
@@ -951,10 +882,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
}; };
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers); Assert.ThrowsException<ArgumentException>(() => protocol.SerializeWriteMultipleHoldingRegisters(UNIT_ID, registers));
// Assert - ArgumentException
} }
[TestMethod] [TestMethod]
@@ -1045,7 +974,6 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
[DataTestMethod] [DataTestMethod]
[DataRow(0x00, 0x00)] [DataRow(0x00, 0x00)]
[DataRow(0x01, 0x01)] [DataRow(0x01, 0x01)]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForTransactionIdOnValidateResponse(int hi, int lo) public void ShouldThrowForTransactionIdOnValidateResponse(int hi, int lo)
{ {
// Arrange // Arrange
@@ -1053,14 +981,13 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x2A, 0x01, 0x01, 0x00]; byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x2A, 0x01, 0x01, 0x00];
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0x00, 0x01)] [DataRow(0x00, 0x01)]
[DataRow(0x01, 0x00)] [DataRow(0x01, 0x00)]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForProtocolIdOnValidateResponse(int hi, int lo) public void ShouldThrowForProtocolIdOnValidateResponse(int hi, int lo)
{ {
// Arrange // Arrange
@@ -1068,12 +995,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x2A, 0x01, 0x01, 0x00]; byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x2A, 0x01, 0x01, 0x00];
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForFollowingBytesOnValidateResponse() public void ShouldThrowForFollowingBytesOnValidateResponse()
{ {
// Arrange // Arrange
@@ -1081,12 +1007,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x2A, 0x01, 0x01, 0x00]; byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x2A, 0x01, 0x01, 0x00];
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForUnitIdOnValidateResponse() public void ShouldThrowForUnitIdOnValidateResponse()
{ {
// Arrange // Arrange
@@ -1094,12 +1019,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x2B, 0x01, 0x01, 0x00]; byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x2B, 0x01, 0x01, 0x00];
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForFunctionCodeOnValidateResponse() public void ShouldThrowForFunctionCodeOnValidateResponse()
{ {
// Arrange // Arrange
@@ -1107,12 +1031,11 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x2A, 0x02, 0x01, 0x00]; byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x2A, 0x02, 0x01, 0x00];
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ModbusException))]
public void ShouldThrowForModbusErrorOnValidateResponse() public void ShouldThrowForModbusErrorOnValidateResponse()
{ {
// Arrange // Arrange
@@ -1120,8 +1043,8 @@ namespace AMWD.Protocols.Modbus.Tests.Common.Protocols
byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x2A, 0x81, 0x01]; byte[] response = [0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x2A, 0x81, 0x01];
var protocol = new TcpProtocol(); var protocol = new TcpProtocol();
// Act // Act + Assert
protocol.ValidateResponse(request, response); Assert.ThrowsException<ModbusException>(() => protocol.ValidateResponse(request, response));
} }
#endregion Validation #endregion Validation

21
AMWD.Protocols.Modbus.Tests/Serial/ModbusRtuProxyTest.cs
View File

@@ -144,49 +144,40 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionOnCreateInstanceForClient() public void ShouldThrowArgumentNullExceptionOnCreateInstanceForClient()
{ {
// Arrange // Arrange
// Act // Act + Assert
new ModbusRtuProxy(null, "some-port"); Assert.ThrowsException<ArgumentNullException>(() => new ModbusRtuProxy(null, "some-port"));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(null)] [DataRow(null)]
[DataRow("")] [DataRow("")]
[DataRow(" ")] [DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionOnCreateInstanceForPortName(string portName) public void ShouldThrowArgumentNullExceptionOnCreateInstanceForPortName(string portName)
{ {
// Arrange // Arrange
var connection = new Mock<IModbusConnection>(); var connection = new Mock<IModbusConnection>();
var clientMock = new Mock<ModbusClientBase>(connection.Object); var clientMock = new Mock<ModbusClientBase>(connection.Object);
// Act // Act + Assert
new ModbusRtuProxy(clientMock.Object, portName); Assert.ThrowsException<ArgumentNullException>(() => new ModbusRtuProxy(clientMock.Object, portName));
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(null)] [DataRow(null)]
[DataRow("")] [DataRow("")]
[DataRow(" ")] [DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullExceptionOnMissingPortName(string portName) public async Task ShouldThrowArgumentNullExceptionOnMissingPortName(string portName)
{ {
// Arrange // Arrange
using var proxy = GetProxy(); using var proxy = GetProxy();
_serialPortMock.Setup(m => m.PortName).Returns(portName); _serialPortMock.Setup(m => m.PortName).Returns(portName);
// Act // Act + Assert
await proxy.StartAsync(); await Assert.ThrowsExceptionAsync<ArgumentNullException>(() => proxy.StartAsync());
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]

212
AMWD.Protocols.Modbus.Tests/Serial/ModbusSerialConnectionTest.cs
View File

@@ -94,58 +94,46 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
[DataRow(null)] [DataRow(null)]
[DataRow("")] [DataRow("")]
[DataRow(" ")] [DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionOnCreate(string portName) public void ShouldThrowArgumentNullExceptionOnCreate(string portName)
{ {
// Arrange // Arrange
// Act // Act + Assert
using var test = new ModbusSerialClient(portName); Assert.ThrowsException<ArgumentNullException>(() => new ModbusSerialClient(portName));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public async Task ShouldThrowDisposedExceptionOnInvokeAsync() public async Task ShouldThrowDisposedExceptionOnInvokeAsync()
{ {
// Arrange // Arrange
var connection = GetConnection(); var connection = GetConnection();
connection.Dispose(); connection.Dispose();
// Act // Act + Assert
await connection.InvokeAsync(null, null); await Assert.ThrowsExceptionAsync<ObjectDisposedException>(() => connection.InvokeAsync(null, null));
// Assert - OjbectDisposedException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(null)] [DataRow(null)]
[DataRow(new byte[0])] [DataRow(new byte[0])]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullExceptionForMissingRequestOnInvokeAsync(byte[] request) public async Task ShouldThrowArgumentNullExceptionForMissingRequestOnInvokeAsync(byte[] request)
{ {
// Arrange // Arrange
var connection = GetConnection(); var connection = GetConnection();
// Act // Act + Assert
await connection.InvokeAsync(request, null); await Assert.ThrowsExceptionAsync<ArgumentNullException>(() => connection.InvokeAsync(request, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullExceptionForMissingValidationOnInvokeAsync() public async Task ShouldThrowArgumentNullExceptionForMissingValidationOnInvokeAsync()
{ {
// Arrange // Arrange
byte[] request = new byte[1]; byte[] request = new byte[1];
var connection = GetConnection(); var connection = GetConnection();
// Act // Act + Assert
await connection.InvokeAsync(request, null); await Assert.ThrowsExceptionAsync<ArgumentNullException>(() => connection.InvokeAsync(request, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -176,10 +164,8 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
_serialPortMock.VerifyNoOtherCalls(); _serialPortMock.VerifyNoOtherCalls();
} }
[DataTestMethod] [TestMethod]
[DataRow(false)] public async Task ShouldOpenAndCloseOnInvokeAsyncOnLinuxNotModifyingDriver()
[DataRow(true)]
public async Task ShouldOpenAndCloseOnInvokeAsync(bool modifyDriver)
{ {
// Arrange // Arrange
_alwaysOpen = false; _alwaysOpen = false;
@@ -193,8 +179,9 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
_serialLineResponseQueue.Enqueue(expectedResponse); _serialLineResponseQueue.Enqueue(expectedResponse);
var connection = GetSerialConnection(); var connection = GetSerialConnection();
connection.GetType().GetField("_isLinux", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(connection, true);
connection.IdleTimeout = TimeSpan.FromMilliseconds(200); connection.IdleTimeout = TimeSpan.FromMilliseconds(200);
connection.DriverEnabledRS485 = modifyDriver; connection.DriverEnabledRS485 = false;
// Act // Act
var response = await connection.InvokeAsync(request, validation); var response = await connection.InvokeAsync(request, validation);
@@ -213,11 +200,134 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
_serialPortMock.Verify(c => c.ResetRS485DriverStateFlags(), Times.Exactly(2)); _serialPortMock.Verify(c => c.ResetRS485DriverStateFlags(), Times.Exactly(2));
_serialPortMock.Verify(c => c.Open(), Times.Once); _serialPortMock.Verify(c => c.Open(), Times.Once);
if (modifyDriver) _serialPortMock.Verify(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()), Times.Once);
{ _serialPortMock.Verify(ns => ns.ReadAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()), Times.Once);
_serialPortMock.Verify(c => c.GetRS485DriverStateFlags(), Times.Once);
_serialPortMock.Verify(c => c.ChangeRS485DriverStateFlags(It.IsAny<RS485Flags>()), Times.Once); _serialPortMock.VerifyNoOtherCalls();
} }
[TestMethod]
public async Task ShouldOpenAndCloseOnInvokeAsyncOnLinuxModifyingDriver()
{
// Arrange
_alwaysOpen = false;
_isOpenQueue.Enqueue(false);
_isOpenQueue.Enqueue(true);
_isOpenQueue.Enqueue(true);
byte[] request = [1, 2, 3];
byte[] expectedResponse = [9, 8, 7];
var validation = new Func<IReadOnlyList<byte>, bool>(_ => true);
_serialLineResponseQueue.Enqueue(expectedResponse);
var connection = GetSerialConnection();
connection.GetType().GetField("_isLinux", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(connection, true);
connection.IdleTimeout = TimeSpan.FromMilliseconds(200);
connection.DriverEnabledRS485 = true;
// Act
var response = await connection.InvokeAsync(request, validation);
await Task.Delay(500);
// Assert
Assert.IsNotNull(response);
CollectionAssert.AreEqual(expectedResponse, response.ToArray());
CollectionAssert.AreEqual(request, _serialLineRequestCallbacks.First());
_serialPortMock.VerifyGet(c => c.ReadTimeout, Times.Once);
_serialPortMock.Verify(c => c.IsOpen, Times.Exactly(3));
_serialPortMock.Verify(c => c.Close(), Times.Exactly(2));
_serialPortMock.Verify(c => c.ResetRS485DriverStateFlags(), Times.Exactly(2));
_serialPortMock.Verify(c => c.Open(), Times.Once);
_serialPortMock.Verify(c => c.GetRS485DriverStateFlags(), Times.Once);
_serialPortMock.Verify(c => c.ChangeRS485DriverStateFlags(It.IsAny<RS485Flags>()), Times.Once);
_serialPortMock.Verify(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()), Times.Once);
_serialPortMock.Verify(ns => ns.ReadAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()), Times.Once);
_serialPortMock.VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldOpenAndCloseOnInvokeAsyncOnOtherOsNotModifyingDriver()
{
// Arrange
_alwaysOpen = false;
_isOpenQueue.Enqueue(false);
_isOpenQueue.Enqueue(true);
_isOpenQueue.Enqueue(true);
byte[] request = [1, 2, 3];
byte[] expectedResponse = [9, 8, 7];
var validation = new Func<IReadOnlyList<byte>, bool>(_ => true);
_serialLineResponseQueue.Enqueue(expectedResponse);
var connection = GetSerialConnection();
connection.GetType().GetField("_isLinux", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(connection, false);
connection.IdleTimeout = TimeSpan.FromMilliseconds(200);
connection.DriverEnabledRS485 = false;
// Act
var response = await connection.InvokeAsync(request, validation);
await Task.Delay(500);
// Assert
Assert.IsNotNull(response);
CollectionAssert.AreEqual(expectedResponse, response.ToArray());
CollectionAssert.AreEqual(request, _serialLineRequestCallbacks.First());
_serialPortMock.VerifyGet(c => c.ReadTimeout, Times.Once);
_serialPortMock.Verify(c => c.IsOpen, Times.Exactly(3));
_serialPortMock.Verify(c => c.Close(), Times.Exactly(2));
_serialPortMock.Verify(c => c.ResetRS485DriverStateFlags(), Times.Exactly(2));
_serialPortMock.Verify(c => c.Open(), Times.Once);
_serialPortMock.Verify(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()), Times.Once);
_serialPortMock.Verify(ns => ns.ReadAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()), Times.Once);
_serialPortMock.VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldOpenAndCloseOnInvokeAsyncOnOtherOsModifyingDriver()
{
// Arrange
_alwaysOpen = false;
_isOpenQueue.Enqueue(false);
_isOpenQueue.Enqueue(true);
_isOpenQueue.Enqueue(true);
byte[] request = [1, 2, 3];
byte[] expectedResponse = [9, 8, 7];
var validation = new Func<IReadOnlyList<byte>, bool>(_ => true);
_serialLineResponseQueue.Enqueue(expectedResponse);
var connection = GetSerialConnection();
connection.GetType().GetField("_isLinux", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(connection, false);
connection.IdleTimeout = TimeSpan.FromMilliseconds(200);
connection.DriverEnabledRS485 = true;
// Act
var response = await connection.InvokeAsync(request, validation);
await Task.Delay(500);
// Assert
Assert.IsNotNull(response);
CollectionAssert.AreEqual(expectedResponse, response.ToArray());
CollectionAssert.AreEqual(request, _serialLineRequestCallbacks.First());
_serialPortMock.VerifyGet(c => c.ReadTimeout, Times.Once);
_serialPortMock.Verify(c => c.IsOpen, Times.Exactly(3));
_serialPortMock.Verify(c => c.Close(), Times.Exactly(2));
_serialPortMock.Verify(c => c.ResetRS485DriverStateFlags(), Times.Exactly(2));
_serialPortMock.Verify(c => c.Open(), Times.Once);
_serialPortMock.Verify(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()), Times.Once); _serialPortMock.Verify(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()), Times.Once);
_serialPortMock.Verify(ns => ns.ReadAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()), Times.Once); _serialPortMock.Verify(ns => ns.ReadAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()), Times.Once);
@@ -226,7 +336,6 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(EndOfStreamException))]
public async Task ShouldThrowEndOfStreamExceptionOnInvokeAsync() public async Task ShouldThrowEndOfStreamExceptionOnInvokeAsync()
{ {
// Arrange // Arrange
@@ -235,10 +344,8 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
var connection = GetConnection(); var connection = GetConnection();
// Act // Act + Assert
var response = await connection.InvokeAsync(request, validation); await Assert.ThrowsExceptionAsync<EndOfStreamException>(() => connection.InvokeAsync(request, validation));
// Assert - EndOfStreamException
} }
[TestMethod] [TestMethod]
@@ -320,7 +427,6 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(TaskCanceledException))]
public async Task ShouldThrowTaskCancelledExceptionForDisposeOnInvokeAsync() public async Task ShouldThrowTaskCancelledExceptionForDisposeOnInvokeAsync()
{ {
// Arrange // Arrange
@@ -332,16 +438,16 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
.Setup(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>())) .Setup(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()))
.Returns(Task.Delay(100)); .Returns(Task.Delay(100));
// Act // Act + Assert
var task = connection.InvokeAsync(request, validation); await Assert.ThrowsExceptionAsync<TaskCanceledException>(async () =>
connection.Dispose(); {
await task; var task = connection.InvokeAsync(request, validation);
connection.Dispose();
// Assert - TaskCancelledException await task;
});
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(TaskCanceledException))]
public async Task ShouldThrowTaskCancelledExceptionForCancelOnInvokeAsync() public async Task ShouldThrowTaskCancelledExceptionForCancelOnInvokeAsync()
{ {
// Arrange // Arrange
@@ -354,12 +460,13 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
.Setup(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>())) .Setup(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()))
.Returns(Task.Delay(100)); .Returns(Task.Delay(100));
// Act // Act + Assert
var task = connection.InvokeAsync(request, validation, cts.Token); await Assert.ThrowsExceptionAsync<TaskCanceledException>(async () =>
cts.Cancel(); {
await task; var task = connection.InvokeAsync(request, validation, cts.Token);
cts.Cancel();
// Assert - TaskCancelledException await task;
});
} }
[TestMethod] [TestMethod]
@@ -375,7 +482,7 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
var connection = GetConnection(); var connection = GetConnection();
_serialPortMock _serialPortMock
.Setup(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>())) .Setup(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()))
.Callback<byte[], CancellationToken>((req, _) => _serialLineRequestCallbacks.Add(req.ToArray())) .Callback<byte[], CancellationToken>((req, _) => _serialLineRequestCallbacks.Add([.. req]))
.Returns(Task.Delay(100)); .Returns(Task.Delay(100));
// Act // Act
@@ -418,7 +525,7 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
var connection = GetConnection(); var connection = GetConnection();
_serialPortMock _serialPortMock
.Setup(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>())) .Setup(ns => ns.WriteAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()))
.Callback<byte[], CancellationToken>((req, _) => _serialLineRequestCallbacks.Add(req.ToArray())) .Callback<byte[], CancellationToken>((req, _) => _serialLineRequestCallbacks.Add([.. req]))
.Returns(Task.Delay(100)); .Returns(Task.Delay(100));
// Act // Act
@@ -489,9 +596,6 @@ namespace AMWD.Protocols.Modbus.Tests.Serial
(connectionField.GetValue(connection) as SerialPortWrapper)?.Dispose(); (connectionField.GetValue(connection) as SerialPortWrapper)?.Dispose();
connectionField.SetValue(connection, _serialPortMock.Object); connectionField.SetValue(connection, _serialPortMock.Object);
// Set unit test mode
connection.GetType().GetField("_isUnitTest", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(connection, true);
return connection; return connection;
} }
} }

13
AMWD.Protocols.Modbus.Tests/Tcp/ModbusTcpClientTest.cs
View File

@@ -162,5 +162,18 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
_tcpConnectionMock.VerifyNoOtherCalls(); _tcpConnectionMock.VerifyNoOtherCalls();
} }
[TestMethod]
public void ShouldPrintCleanString()
{
// Arrange
using var client = new ModbusTcpClient(_tcpConnectionMock.Object);
// Act
string str = client.ToString();
// Assert
SnapshotAssert.AreEqual(str);
}
} }
} }

81
AMWD.Protocols.Modbus.Tests/Tcp/ModbusTcpConnectionTest.cs
View File

@@ -80,31 +80,25 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
[DataRow(null)] [DataRow(null)]
[DataRow("")] [DataRow("")]
[DataRow(" ")] [DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionForInvalidHostname(string hostname) public void ShouldThrowArgumentNullExceptionForInvalidHostname(string hostname)
{ {
// Arrange // Arrange
var connection = GetTcpConnection(); var connection = GetTcpConnection();
// Act // Act + Assert
connection.Hostname = hostname; Assert.ThrowsException<ArgumentNullException>(() => connection.Hostname = hostname);
// Assert - ArgumentNullException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(0)] [DataRow(0)]
[DataRow(65536)] [DataRow(65536)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeExceptionForInvalidPort(int port) public void ShouldThrowArgumentOutOfRangeExceptionForInvalidPort(int port)
{ {
// Arrange // Arrange
var connection = GetTcpConnection(); var connection = GetTcpConnection();
// Act // Act + Assert
connection.Port = port; Assert.ThrowsException<ArgumentOutOfRangeException>(() => connection.Port = port);
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -119,46 +113,37 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public async Task ShouldThrowDisposedExceptionOnInvokeAsync() public async Task ShouldThrowDisposedExceptionOnInvokeAsync()
{ {
// Arrange // Arrange
var connection = GetConnection(); var connection = GetConnection();
connection.Dispose(); connection.Dispose();
// Act // Act + Assert
await connection.InvokeAsync(null, null); await Assert.ThrowsExceptionAsync<ObjectDisposedException>(() => connection.InvokeAsync(null, null));
// Assert - OjbectDisposedException
} }
[DataTestMethod] [DataTestMethod]
[DataRow(null)] [DataRow(null)]
[DataRow(new byte[0])] [DataRow(new byte[0])]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullExceptionForMissingRequestOnInvokeAsync(byte[] request) public async Task ShouldThrowArgumentNullExceptionForMissingRequestOnInvokeAsync(byte[] request)
{ {
// Arrange // Arrange
var connection = GetConnection(); var connection = GetConnection();
// Act // Act + Assert
await connection.InvokeAsync(request, null); await Assert.ThrowsExceptionAsync<ArgumentNullException>(() => connection.InvokeAsync(request, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullExceptionForMissingValidationOnInvokeAsync() public async Task ShouldThrowArgumentNullExceptionForMissingValidationOnInvokeAsync()
{ {
// Arrange // Arrange
byte[] request = new byte[1]; byte[] request = new byte[1];
var connection = GetConnection(); var connection = GetConnection();
// Act // Act + Assert
await connection.InvokeAsync(request, null); await Assert.ThrowsExceptionAsync<ArgumentNullException>(() => connection.InvokeAsync(request, null));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -235,7 +220,6 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(EndOfStreamException))]
public async Task ShouldThrowEndOfStreamExceptionOnInvokeAsync() public async Task ShouldThrowEndOfStreamExceptionOnInvokeAsync()
{ {
// Arrange // Arrange
@@ -244,14 +228,11 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
var connection = GetConnection(); var connection = GetConnection();
// Act // Act + Assert
var response = await connection.InvokeAsync(request, validation); await Assert.ThrowsExceptionAsync<EndOfStreamException>(() => connection.InvokeAsync(request, validation));
// Assert - EndOfStreamException
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ApplicationException))]
public async Task ShouldThrowApplicationExceptionWhenHostNotResolvableOnInvokeAsync() public async Task ShouldThrowApplicationExceptionWhenHostNotResolvableOnInvokeAsync()
{ {
// Arrange // Arrange
@@ -264,10 +245,8 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
var connection = GetConnection(); var connection = GetConnection();
connection.GetType().GetField("_hostname", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(connection, ""); connection.GetType().GetField("_hostname", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(connection, "");
// Act // Act + Assert
var response = await connection.InvokeAsync(request, validation); await Assert.ThrowsExceptionAsync<ApplicationException>(() => connection.InvokeAsync(request, validation));
// Assert - ApplicationException
} }
[TestMethod] [TestMethod]
@@ -351,8 +330,7 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(TaskCanceledException))] public async Task ShouldThrowTaskCanceledExceptionForDisposeOnInvokeAsync()
public async Task ShouldThrowTaskCancelledExceptionForDisposeOnInvokeAsync()
{ {
// Arrange // Arrange
byte[] request = [1, 2, 3]; byte[] request = [1, 2, 3];
@@ -363,17 +341,17 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
.Setup(ns => ns.WriteAsync(It.IsAny<ReadOnlyMemory<byte>>(), It.IsAny<CancellationToken>())) .Setup(ns => ns.WriteAsync(It.IsAny<ReadOnlyMemory<byte>>(), It.IsAny<CancellationToken>()))
.Returns(new ValueTask(Task.Delay(100))); .Returns(new ValueTask(Task.Delay(100)));
// Act // Act + Assert
var task = connection.InvokeAsync(request, validation); await Assert.ThrowsExceptionAsync<TaskCanceledException>(async () =>
connection.Dispose(); {
await task; var task = connection.InvokeAsync(request, validation);
connection.Dispose();
// Assert - TaskCancelledException await task;
});
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(TaskCanceledException))] public async Task ShouldThrowTaskCanceledExceptionForCancelOnInvokeAsync()
public async Task ShouldThrowTaskCancelledExceptionForCancelOnInvokeAsync()
{ {
// Arrange // Arrange
byte[] request = [1, 2, 3]; byte[] request = [1, 2, 3];
@@ -385,12 +363,13 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
.Setup(ns => ns.WriteAsync(It.IsAny<ReadOnlyMemory<byte>>(), It.IsAny<CancellationToken>())) .Setup(ns => ns.WriteAsync(It.IsAny<ReadOnlyMemory<byte>>(), It.IsAny<CancellationToken>()))
.Returns(new ValueTask(Task.Delay(100))); .Returns(new ValueTask(Task.Delay(100)));
// Act // Act + Assert
var task = connection.InvokeAsync(request, validation, cts.Token); await Assert.ThrowsExceptionAsync<TaskCanceledException>(async () =>
cts.Cancel(); {
await task; var task = connection.InvokeAsync(request, validation, cts.Token);
cts.Cancel();
// Assert - TaskCancelledException await task;
});
} }
[TestMethod] [TestMethod]

15
AMWD.Protocols.Modbus.Tests/Tcp/ModbusTcpProxyTest.cs
View File

@@ -157,15 +157,12 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionOnCreateInstanceForClient() public void ShouldThrowArgumentNullExceptionOnCreateInstanceForClient()
{ {
// Arrange // Arrange
// Act // Act + Assert
new ModbusTcpProxy(null, IPAddress.Loopback); Assert.ThrowsException<ArgumentNullException>(() => new ModbusTcpProxy(null, IPAddress.Loopback));
// Assert - ArgumentNullException
} }
[TestMethod] [TestMethod]
@@ -212,17 +209,14 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
} }
[TestMethod] [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeExceptionForInvalidTimeout() public void ShouldThrowArgumentOutOfRangeExceptionForInvalidTimeout()
{ {
// Arrange // Arrange
_connectClient = false; _connectClient = false;
using var proxy = GetProxy(); using var proxy = GetProxy();
// Act // Act + Assert
proxy.ReadWriteTimeout = TimeSpan.FromSeconds(-3); Assert.ThrowsException<ArgumentOutOfRangeException>(() => proxy.ReadWriteTimeout = TimeSpan.FromSeconds(-3));
// Assert - ArgumentOutOfRangeException
} }
[TestMethod] [TestMethod]
@@ -886,6 +880,7 @@ namespace AMWD.Protocols.Modbus.Tests.Tcp
Assert.AreEqual(ModbusDeviceIdentificationObject.VendorName, objectId); Assert.AreEqual(ModbusDeviceIdentificationObject.VendorName, objectId);
CollectionAssert.AreEqual(expectedResponse, _responseBytesCallbacks.First()); CollectionAssert.AreEqual(expectedResponse, _responseBytesCallbacks.First());
SnapshotAssert.AreEqual(_clientDeviceIdentificationResponse.ToString());
} }
[TestMethod] [TestMethod]

2
AMWD.Protocols.Modbus.Tests/Tcp/Snapshots/ModbusTcpClientTest/ShouldPrintCleanString.snap.bin Normal file
View File

@@ -0,0 +1,2 @@
TCP Client 127.0.0.1
Port: 502

9
AMWD.Protocols.Modbus.Tests/Tcp/Snapshots/ModbusTcpProxyTest/ShouldReadDeviceIdentification.snap.bin Normal file
View File

@@ -0,0 +1,9 @@
DeviceIdentification
VendorName: VendorName
ProductCode: ProductCode
MajorMinorRevision: MajorMinorRevision
VendorUrl:
ProductName:
ModelName:
UserApplicationName:
IsIndividualAccessAllowed: False

4
CHANGELOG.md
View File

@@ -7,7 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## [Unreleased] ## [Unreleased]
_nothing changed yet_ ### Changed
- Async methods do not return on captured context anymore (`Task.ConfigureAwait(false)`).
## [v0.4.0] (2025-01-29) ## [v0.4.0] (2025-01-29)

7
README.md
View File

@@ -2,9 +2,12 @@
Here you can find a basic implementation of the Modbus protocol. Here you can find a basic implementation of the Modbus protocol.
![NuGet Version](https://shields.io/nuget/v/AMWD.Protocols.Modbus.Common?style=flat&logo=nuget)
![Test Coverage](https://git.am-wd.de/am-wd/amwd.protocols.modbus/badges/main/coverage.svg?style=flat)
## Overview ## Overview
The project is divided into four parts. The project is divided into multiple parts.
To be mentioned at the beginning: To be mentioned at the beginning:
Only the clients are build very modular to fit any requirement reached on the first implementation back in 2018 ([see here]). Only the clients are build very modular to fit any requirement reached on the first implementation back in 2018 ([see here]).
@@ -35,7 +38,7 @@ It uses a specific TCP connection implementation and plugs all things from the C
--- ---
Published under [MIT License] (see [choose a license]) Published under [MIT License] (see [choose a license])
[![Buy me a Coffee](https://shields.am-wd.de/badge/PayPal-Buy_me_a_Coffee-yellow?style=flat&logo=paypal)](https://link.am-wd.de/donate) [![Buy me a Coffee](https://shields.io/badge/PayPal-Buy_me_a_Coffee-yellow?style=flat&logo=paypal)](https://link.am-wd.de/donate)
[![built with Codeium](https://codeium.com/badges/main)](https://link.am-wd.de/codeium) [![built with Codeium](https://codeium.com/badges/main)](https://link.am-wd.de/codeium)