From 1c89e5590e9a52c2e4b9d30f81aa2a86cc90fb4f Mon Sep 17 00:00:00 2001 From: parallelbgls Date: Sat, 21 Jan 2017 11:29:24 +0800 Subject: [PATCH] Test Temp Update --- Tests/Modbus.Net.Tests/AddressMaker.cs | 42 +++- Tests/Modbus.Net.Tests/AddressTest.cs | 27 --- Tests/Modbus.Net.Tests/BaseTest.cs | 120 ++++++++++- Tests/Modbus.Net.Tests/CommunicationTest.cs | 191 ++++++++++++++---- .../Modbus.Net.Tests/Modbus.Net.Tests.csproj | 19 +- 5 files changed, 329 insertions(+), 70 deletions(-) delete mode 100644 Tests/Modbus.Net.Tests/AddressTest.cs diff --git a/Tests/Modbus.Net.Tests/AddressMaker.cs b/Tests/Modbus.Net.Tests/AddressMaker.cs index d9bbcfa..4ce4912 100644 --- a/Tests/Modbus.Net.Tests/AddressMaker.cs +++ b/Tests/Modbus.Net.Tests/AddressMaker.cs @@ -6,8 +6,48 @@ using System.Threading.Tasks; namespace Modbus.Net.Tests { - public class AddressMaker + public sealed class AddressMaker { + public TestAreas TestAreas { get; set; } + public TestAddresses TestAddresses { get; set; } + private AddressFormater AddressFormater { get; set; } + private AddressTranslator AddressTranslator { get; set; } + + public List MakeAddresses(string areaKey, string addressKey, bool isRead) + { + var combinedAddress = new List(); + + foreach (var area in TestAreas[areaKey]) + { + foreach (var address in TestAddresses[addressKey]) + { + for (double currentAddress = address.Item1, i = 0; + i < address.Item2; + currentAddress += + ValueHelper.Instance.ByteLength[address.Item3.FullName]/ + AddressTranslator.GetAreaByteLength(area), i++) + { + combinedAddress.Add(AddressFormater.FormatAddress(area, (int) currentAddress, (int) + ((currentAddress - (int) currentAddress)/ + (ValueHelper.Instance.ByteLength[address.Item3.FullName]/ + AddressTranslator.GetAreaByteLength(area))))); + } + } + } + + return combinedAddress.Select(p => + { + var translateAns = AddressTranslator.AddressTranslate(p, isRead); + return new AddressUnit() + { + Area = translateAns.AreaString, + Address = translateAns.Address, + SubAddress = translateAns.SubAddress, + Id = p, + CommunicationTag = p + }; + }).ToList(); + } } } diff --git a/Tests/Modbus.Net.Tests/AddressTest.cs b/Tests/Modbus.Net.Tests/AddressTest.cs deleted file mode 100644 index 2b6ad11..0000000 --- a/Tests/Modbus.Net.Tests/AddressTest.cs +++ /dev/null @@ -1,27 +0,0 @@ -using System; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace Modbus.Net.Tests -{ - [TestClass] - public class AddressTest - { - [TestMethod] - public void CombinerTest() - { - - } - - [TestMethod] - public void FormaterTest() - { - - } - - [TestMethod] - public void TranslatorTest() - { - - } - } -} diff --git a/Tests/Modbus.Net.Tests/BaseTest.cs b/Tests/Modbus.Net.Tests/BaseTest.cs index 12f75fe..061158a 100644 --- a/Tests/Modbus.Net.Tests/BaseTest.cs +++ b/Tests/Modbus.Net.Tests/BaseTest.cs @@ -1,4 +1,5 @@ using System; +using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; @@ -8,9 +9,9 @@ namespace Modbus.Net.Tests { public sealed class TestAddresses { - private Dictionary[]> Addresses { get; } = new Dictionary[]>(); + private Dictionary[]> Addresses { get; } - public Tuple[] this[string index] + public Tuple[] this[string index] { get { return Addresses[index]; } set @@ -25,11 +26,20 @@ namespace Modbus.Net.Tests } } } + + public TestAddresses(Dictionary[]> addresses) + { + Addresses = addresses.ToDictionary(address=>address.Key, address=>address.Value); + } + + public IEnumerable Keys => Addresses.Keys.AsEnumerable(); + + public IEnumerable[]> Values => Addresses.Values.AsEnumerable(); } public sealed class TestAreas { - private Dictionary Areas { get; } = new Dictionary(); + private Dictionary Areas { get; } public string[] this[string index] { @@ -46,5 +56,109 @@ namespace Modbus.Net.Tests } } } + + public TestAreas(Dictionary addresses) + { + Areas = addresses.ToDictionary(address => address.Key, address => address.Value); + } + + public IEnumerable Keys => Areas.Keys.AsEnumerable(); + + public IEnumerable Values => Areas.Values.AsEnumerable(); + } + + public sealed class BaseTest + { + public static TestAreas TestAreasModbus => new TestAreas(new Dictionary + { + { + "Coil",new []{"0X", "1X"} + }, + { + "Register", new [] {"3X", "4X"} + } + }); + + public static TestAddresses TestAddresses => new TestAddresses(new Dictionary[]> + { + { + "Coil.Single.Min", new [] + { + new Tuple(0, 1, typeof(bool)) + } + }, + { + "Coil.Single.Normal", new[] + { + new Tuple(100, 1, typeof(bool)) + } + }, + { + "Coil.Single.MaxOverFlow", new[] + { + new Tuple(100000, 1, typeof(bool)) + } + }, + { + "Coil.Multi.Normal", new[] + { + new Tuple(0, 30, typeof(bool)) + } + }, + { + "Register.Single.Short", new[] + { + new Tuple(0, 1, typeof(ushort)) + } + }, + { + "Register.Continus.Short", new[] + { + new Tuple(0, 10, typeof(ushort)) + } + }, + { + "Register.Continus.Byte", new[] + { + new Tuple(0, 10, typeof(byte)) + } + }, + { + "Register.Continus.Int", new[] + { + new Tuple(0, 10, typeof(uint)) + } + }, + { + "Register.Continus.Bit", new [] + { + new Tuple(0.5, 8, typeof(bool)) + } + }, + { + "Register.Duplicate.Short", new [] + { + new Tuple(0, 10, typeof(ushort)), + new Tuple(15, 25, typeof(ushort)), + new Tuple(50, 20, typeof(ushort)) + } + }, + { + "Register.Cross.Short", new [] + { + new Tuple(0, 10, typeof(ushort)), + new Tuple(5, 10, typeof(ushort)), + new Tuple(10, 10, typeof(ushort)) + } + }, + { + "Register.Duplicate.Multi", new [] + { + new Tuple(0, 10, typeof(byte)), + new Tuple(20, 10, typeof(byte)), + new Tuple(30, 16, typeof(bool)) + } + }, + }); } } diff --git a/Tests/Modbus.Net.Tests/CommunicationTest.cs b/Tests/Modbus.Net.Tests/CommunicationTest.cs index 9c6f520..a1a0742 100644 --- a/Tests/Modbus.Net.Tests/CommunicationTest.cs +++ b/Tests/Modbus.Net.Tests/CommunicationTest.cs @@ -1,62 +1,177 @@ using System; +using System.Collections.Generic; +using System.Threading.Tasks; using Microsoft.VisualStudio.TestTools.UnitTesting; +using Modbus.Net.Modbus; namespace Modbus.Net.Tests { [TestClass] public class CommunicationTest { - public void CommunicationInvoke(string addressFullName, int count) + protected AddressMaker AddressMaker = new AddressMaker() { + TestAreas = BaseTest.TestAreasModbus, + TestAddresses = BaseTest.TestAddresses + }; + protected BaseMachine Machine = new ModbusMachine(ModbusType.Tcp, "192.168.3.12", null, true, 2, 0); + + [TestMethod] + public async Task CoilSingle() + { + var addresses = AddressMaker.MakeAddresses("Coil", "Coil.Single.Normal", false); + Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator); + Machine.GetAddresses = addresses; + var ans = await Machine.SetDatasAsync(MachineSetDataType.Address, new Dictionary() + { + { + "0X 100", 1 + }, + { + "1X 100", 1 + } + }); + var addresses2 = AddressMaker.MakeAddresses("Coil", "Coil.Signle.Normal", true); + Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator); + Machine.GetAddresses = addresses2; + var ans2 = await Machine.GetDatasAsync(MachineGetDataType.Address); + Assert.AreEqual(ans2["0X 100"], 1); + Assert.AreEqual(ans2["1X 100"], 1); } [TestMethod] - public void CoilSingleRead() + public async Task CoilMuiltiRead() { + var addresses = AddressMaker.MakeAddresses("Coil", "Coil.Multi.Normal", false); + Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator); + Machine.GetAddresses = addresses; + var ans = await Machine.SetDatasAsync(MachineSetDataType.Address, new Dictionary() + { + { + "0X 3", 1 + }, + { + "0X 4", 1 + }, + { + "0X 16", 1 + }, + { + "0X 22", 1 + }, + { + "1X 3", 1 + }, + { + "1X 4", 1 + }, + { + "1X 16", 1 + }, + { + "1X 22", 1 + } + }); + var addresses2 = AddressMaker.MakeAddresses("Coil", "Coil.Multi.Normal", true); + Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator); + Machine.GetAddresses = addresses; + var ans2 = await Machine.GetDatasAsync(MachineGetDataType.Address); + Assert.AreEqual(ans2["0X 3"], 1); + Assert.AreEqual(ans2["0X 4"], 1); + Assert.AreEqual(ans2["0X 16"], 1); + Assert.AreEqual(ans2["0X 22"], 1); + Assert.AreEqual(ans2["0X 7"], 0); + Assert.AreEqual(ans2["0X 29"], 0); + Assert.AreEqual(ans2["1X 3"], 1); + Assert.AreEqual(ans2["1X 4"], 1); + Assert.AreEqual(ans2["1X 16"], 1); + Assert.AreEqual(ans2["1X 22"], 1); + Assert.AreEqual(ans2["1X 7"], 0); + Assert.AreEqual(ans2["1X 29"], 0); + } + + [TestMethod] + public async Task RegisterSingleRead() + { + var addresses = AddressMaker.MakeAddresses("Register", "Register.Single.Short", false); + Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator); + Machine.GetAddresses = addresses; + var ans = await Machine.SetDatasAsync(MachineSetDataType.Address, new Dictionary() + { + { + "3X 0", 32767 + }, + { + "4X 0", 32767 + } + }); + var addresses2 = AddressMaker.MakeAddresses("Register", "Register.Single.Short", true); + Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator); + Machine.GetAddresses = addresses; + var ans2 = await Machine.GetDatasAsync(MachineGetDataType.Address); + Assert.AreEqual(ans2["3X 0"], 32767); + Assert.AreEqual(ans2["4X 0"], 32767); } [TestMethod] - public void CoilMuiltiRead() + public async Task RegistertMultiRead() { + var addresses = AddressMaker.MakeAddresses("Register", "Register.Duplicate.Short", false); + Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator); + Machine.GetAddresses = addresses; + var ans = await Machine.SetDatasAsync(MachineSetDataType.Address, new Dictionary() + { + { + "3X 4", 17 + }, + { + "3X 7", 20 + }, + { + "3X 17", 5255 + }, + { + "3X 18", 3019 + }, + { + "3X 55", 192 + }, + { + "4X 4", 18 + }, + { + "4X 7", 21 + }, + { + "4X 17", 5256 + }, + { + "4X 18", 3020 + }, + { + "4X 55", 193 + } + }); + + var addresses2 = AddressMaker.MakeAddresses("Register", "Register.Duplicate.Short", true); + Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator); + Machine.GetAddresses = addresses; + var ans2 = await Machine.GetDatasAsync(MachineGetDataType.Address); + Assert.AreEqual(ans2["3X 4"], 17); + Assert.AreEqual(ans2["3X 7"], 20); + Assert.AreEqual(ans2["3X 17"], 5255); + Assert.AreEqual(ans2["3X 18"], 3019); + Assert.AreEqual(ans2["3X 55"], 192); + + Assert.AreEqual(ans2["4X 4"], 18); + Assert.AreEqual(ans2["4X 7"], 21); + Assert.AreEqual(ans2["4X 17"], 5256); + Assert.AreEqual(ans2["4X 18"], 3020); + Assert.AreEqual(ans2["4X 55"], 193); } - [TestMethod] - public void CoilSingleWrite() - { - - } - - [TestMethod] - public void CoilMuiltiWrite() - { - - } - - [TestMethod] - public void RegisterSingleRead() - { - - } - - [TestMethod] - public void RegistertMultiRead() - { - - } - - [TestMethod] - public void RegisterSingleWrite() - { - - } - - [TestMethod] - public void RegistertMultiWrite() - { - - } } } diff --git a/Tests/Modbus.Net.Tests/Modbus.Net.Tests.csproj b/Tests/Modbus.Net.Tests/Modbus.Net.Tests.csproj index f4aac55..2f16bed 100644 --- a/Tests/Modbus.Net.Tests/Modbus.Net.Tests.csproj +++ b/Tests/Modbus.Net.Tests/Modbus.Net.Tests.csproj @@ -53,11 +53,28 @@ - + + + {fdca72ba-6d06-4de0-b873-c11c4ac853ad} + Modbus.Net.Modbus + + + {97f5a329-357a-4813-baae-58e71cc6fa87} + Modbus.Net.OPC + + + {6258f9d9-0df4-497f-9f3b-6d2f6f752a21} + Modbus.Net.Siemens + + + {124ebef2-8960-4447-84cf-1d683b1ef7cc} + Modbus.Net + +