S7 netPlus的各种通信测试

#region Using
using System;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using S7.Net.UnitTest.Helpers;
using S7.Net.Types;
using S7.UnitTest.Helpers;
using System.Threading.Tasks;
using System.Threading;
using System.Security.Cryptography;


#if NET5_0_OR_GREATER
using System.Buffers;
#endif

#endregion

/**
 * About the tests:
 * ---------------------------------------------------------------------------
 * The tests were written to show how to use this library to read and write
 * different types of values, how to box and unbox values and of course to
 * address some of the bugs of the library.
 * These tests are not meant to cover 100% the code, but to check that once a
 * variable is written, it stores the correct value.
 * ----------------------------------------------------------------------------
 * The plc used for the tests is the S7 "server" provided by Snap7 opensource
 * library, that you can get for free here:http://snap7.sourceforge.net/
 * The implementation of the server will not be discussed here, but there are
 * some issues with the interop that cause the server, and unit test, to fail
 * under some circumstances, like "click on Run all tests" too much.
 * This doesn't mean that S7.Net has bugs, but that the implementation of the
 * server has problems.
 *
 */

//Tests for Async Methods

namespace S7.Net.UnitTest
{
   
   
    public partial class S7NetTests
    {
   
   
        #region Tests
        [TestMethod]
        public async Task Test_Async_Connection()
        {
   
   
            if (plc.IsConnected == false)
            {
   
   
                await plc.OpenAsync();
            }
        }

        /// <summary>
        /// Read/Write a single Int16 or UInt16 with a single request.
        /// Test that writing a UInt16 (ushort) and reading it gives the correct value.
        /// Test also that writing a Int16 (short) and reading it gives the correct value.
        /// </summary>
        [TestMethod]
        public async Task Test_Async_WriteAndReadInt16Variable()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            // To write a ushort i don't need any cast, only unboxing must be done
            ushort val = 40000;
            await plc.WriteAsync("DB1.DBW0", val);
            ushort result = (ushort)await plc.ReadAsync("DB1.DBW0");
            Assert.AreEqual(val, result, "A ushort goes from 0 to 64512");

            // To write a short i need to convert it to UShort, then i need to reconvert the readed value to get
            // the negative sign back
            // Depending if i'm writing on a DWORD or on a DEC, i will see ushort or short value in the plc
            short value = -100;
            Assert.IsTrue(plc.IsConnected, "After connecting, IsConnected must be set to true");
            await plc.WriteAsync("DB1.DBW0", value.ConvertToUshort());
            short result2 = ((ushort)await plc.ReadAsync("DB1.DBW0")).ConvertToShort();
            Assert.AreEqual(value, result2, "A short goes from -32767 to 32766");
        }

        /// <summary>
        /// Read/Write a single Int32 or UInt32 with a single request.
        /// Test that writing a UInt32 (uint) and reading it gives the correct value.
        /// Test also that writing a Int32 (int) and reading it gives the correct value.
        /// </summary>
        [TestMethod]
        public async Task Test_Async_WriteAndReadInt32Variable()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            // To write a uint I don't need any cast, only unboxing must be done
            int val = 1000;
            await plc.WriteAsync("DB1.DBD40", val);
            int result = ((uint)await plc.ReadAsync("DB1.DBD40")).ConvertToInt();
            Assert.AreEqual(val, result);

            // To write a int I need to convert it to uint, then I need to reconvert the readed value to get
            // the negative sign back
            // Depending if I'm writing on a DBD or on a LONG, I will see uint or int value in the plc
            int value = -60000;
            await plc.WriteAsync("DB1.DBD60", value);
            int result2 = ((uint)await plc.ReadAsync("DB1.DBD60")).ConvertToInt();
            Assert.AreEqual(value, result2);
        }

        /// <summary>
        /// Read/Write a single REAL with a single request.
        /// Test that writing a float and reading it gives the correct value.
        /// </summary>
        [TestMethod]
        public async Task Test_Async_WriteAndReadRealVariables()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            // Reading and writing a float is quite complicated, because it needs to be converted to DWord before the write,
            // then reconvert to float after the read. Float values can contain only 7 digits, so no precision is lost.
            float val2 = 1234567;
            await plc.WriteAsync("DB1.DBD40", val2.ConvertToUInt());
            float result2 = ((uint)await plc.ReadAsync("DB1.DBD40")).ConvertToFloat();
            Assert.AreEqual(val2, result2);

            float val3 = 12.34567f;
            await plc.WriteAsync("DB1.DBD40", val3.ConvertToUInt());
            float result3 = ((uint)await plc.ReadAsync("DB1.DBD40")).ConvertToFloat();
            Assert.AreEqual(val3, result3);
        }

        /// <summary>
        /// Write/Read a large amount of data to test PDU max
        /// </summary>
        [TestMethod]
        public async Task Test_Async_WriteLargeByteArray()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            var randomEngine = new Random();
            var data = new byte[8192];
            var db = 2;
            randomEngine.NextBytes(data);

            await plc.WriteBytesAsync(DataType.DataBlock, db, 0, data);

            var readData = await plc.ReadBytesAsync(DataType.DataBlock, db, 0, data.Length);

            CollectionAssert.AreEqual(data, readData);
        }

#if NET5_0_OR_GREATER

        /// <summary>
        /// Write/Read a large amount of data to test PDU max
        /// </summary>
        [TestMethod]
        public async Task Test_Async_WriteLargeByteArrayWithMemory()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            var randomEngine = new Random();
            using var dataOwner = MemoryPool<byte>.Shared.Rent(8192);
            var data = dataOwner.Memory.Slice(0, 8192);
            var db = 2;
            randomEngine.NextBytes(data.Span);

            await plc.WriteBytesAsync(DataType.DataBlock, db, 0, data);

            using var readDataOwner = MemoryPool<byte>.Shared.Rent(data.Length);
            var readData = readDataOwner.Memory.Slice(0, data.Length);
            await plc.ReadBytesAsync(readData, DataType.DataBlock, db, 0);

            CollectionAssert.AreEqual(data.ToArray(), readData.ToArray());
        }

#endif

        /// <summary>
        /// Read/Write a class that has the same properties of a DB with the same field in the same order
        /// </summary>
        [TestMethod]
        public async Task Test_Async_ReadAndWriteClass()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            TestClass tc = new TestClass
            {
   
   
                BitVariable00 = true,
                BitVariable10 = true,
                DIntVariable = -100000,
                IntVariable = -15000,
                LRealVariable = -154.789,
                RealVariable = -154.789f,
                DWordVariable = 850,
                WStringVariable = "ÄÜÉÊéà",
                StringVariable = "Hallo"
            };

            await plc.WriteClassAsync(tc, DB2);
            TestClass tc2 = new TestClass();
            // Values that are read from a class are stored inside the class itself, that is passed by reference
            await plc.ReadClassAsync(tc2, DB2);
            Assert.AreEqual(tc.BitVariable00, tc2.BitVariable00);
            Assert.AreEqual(tc.BitVariable10, tc2.BitVariable10);
            Assert.AreEqual(tc.DIntVariable, tc2.DIntVariable);
            Assert.AreEqual(tc.IntVariable, tc2.IntVariable);
            Assert.AreEqual(tc.LRealVariable, tc2.LRealVariable);
            Assert.AreEqual(tc.RealVariable, tc2.RealVariable);
            Assert.AreEqual(tc.DWordVariable, tc2.DWordVariable);
            Assert.AreEqual(tc.WStringVariable, tc2.WStringVariable);
            Assert.AreEqual(tc.StringVariable, tc2.StringVariable);
        }

        [TestMethod]
        public async Task Test_Async_ReadAndWriteNestedClass()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            TestClassWithNestedClass tc = new TestClassWithNestedClass
            {
   
   
                BitVariable00 = true,
                BitVariable01 = new TestClassInnerWithBool {
   
    BitVariable00 = true },
                ByteVariable02 = new TestClassInnerWithByte {
   
    ByteVariable00 = 128 },
                BitVariable03 = true,
                ShortVariable04 = new TestClassInnerWithShort {
   
    ShortVarialbe00 = -15000 }
            };

            await plc.WriteClassAsync(tc, DB4);
            TestClassWithNestedClass tc2 = new TestClassWithNestedClass();
            // Values that are read from a class are stored inside the class itself, that is passed by reference
            await plc.ReadClassAsync(tc2, DB4);
            Assert.AreEqual(tc.BitVariable00, tc2.BitVariable00);
            Assert.AreEqual(tc.BitVariable01.BitVariable00, tc2.BitVariable01.BitVariable00);
            Assert.AreEqual(tc.ByteVariable02.ByteVariable00, tc2.ByteVariable02.ByteVariable00);
            Assert.AreEqual(tc.BitVariable03, tc2.BitVariable03);
            Assert.AreEqual(tc.ShortVariable04.ShortVarialbe00, tc2.ShortVariable04.ShortVarialbe00);
        }

        /// <summary>
        /// Read/Write a struct that has the same properties of a DB with the same field in the same order
        /// </summary>
        [TestMethod]
        public async Task Test_Async_ReadAndWriteStruct()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            TestStruct tc = new TestStruct
            {
   
   
                BitVariable00 = true,
                BitVariable10 = true,
                DIntVariable = -100000,
                IntVariable = -15000,
                LRealVariable = -154.789,
                RealVariable = -154.789f,
                DWordVariable = 850,
                WStringVariable = "ÄÜÉÊéà",
                StringVariable = "Hallo"
            };
            plc.WriteStruct(tc, DB2);
            // Values that are read from a struct are stored in a new struct, returned by the funcion ReadStruct
            TestStruct tc2 = (TestStruct)await plc.ReadStructAsync(typeof(TestStruct), DB2);
            Assert.AreEqual(tc.BitVariable00, tc2.BitVariable00);
            Assert.AreEqual(tc.BitVariable10, tc2.BitVariable10);
            Assert.AreEqual(tc.DIntVariable, tc2.DIntVariable);
            Assert.AreEqual(tc.IntVariable, tc2.IntVariable);
            Assert.AreEqual(tc.LRealVariable, tc2.LRealVariable);
            Assert.AreEqual(tc.RealVariable, tc2.RealVariable);
            Assert.AreEqual(tc.DWordVariable, tc2.DWordVariable);
            Assert.AreEqual(tc.WStringVariable, tc2.WStringVariable);
            Assert.AreEqual(tc.StringVariable, tc2.StringVariable);
        }

        /// <summary>
        /// Read/Write a struct that has the same properties of a DB with the same field in the same order
        /// </summary>
        [TestMethod]
        public async Task Test_Async_ReadAndWriteLongStruct()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            TestLongStruct tc = new TestLongStruct
            {
   
   
                IntVariable0 = 0,
                IntVariable1 = 1,
                IntVariable10 = 10,
                IntVariable11 = 11,
                IntVariable20 = 20,
                IntVariable21 = 21,
                IntVariable30 = 30,
                IntVariable31 = 31,
                IntVariable40 = 40,
                IntVariable41 = 41,
                IntVariable50 = 50,
                IntVariable51 = 51,
                IntVariable60 = 60,
                IntVariable61 = 61,
                IntVariable70 = 70,
                IntVariable71 = 71,
                IntVariable80 = 80,
                IntVariable81 = 81,
                IntVariable90 = 90,
                IntVariable91 = 91,
                IntVariable100 = 100,
                IntVariable101 = 101,
                IntVariable110 = 200,
                IntVariable111 = 201
            };
            plc.WriteStruct(tc, DB2);
            // Values that are read from a struct are stored in a new struct, returned by the funcion ReadStruct
            TestLongStruct tc2 = (TestLongStruct)await plc.ReadStructAsync(typeof(TestLongStruct), DB2);
            Assert.AreEqual(tc.IntVariable0, tc2.IntVariable0);
            Assert.AreEqual(tc.IntVariable1, tc2.IntVariable1);
            Assert.AreEqual(tc.IntVariable10, tc2.IntVariable10);
            Assert.AreEqual(tc.IntVariable11, tc2.IntVariable11);
            Assert.AreEqual(tc.IntVariable20, tc2.IntVariable20);
            Assert.AreEqual(tc.IntVariable21, tc2.IntVariable21);
            Assert.AreEqual(tc.IntVariable30, tc2.IntVariable30);
            Assert.AreEqual(tc.IntVariable31, tc2.IntVariable31);
            Assert.AreEqual(tc.IntVariable40, tc2.IntVariable40);
            Assert.AreEqual(tc.IntVariable41, tc2.IntVariable41);
            Assert.AreEqual(tc.IntVariable50, tc2.IntVariable50);
            Assert.AreEqual(tc.IntVariable51, tc2.IntVariable51);
            Assert.AreEqual(tc.IntVariable60, tc2.IntVariable60);
            Assert.AreEqual(tc.IntVariable61, tc2.IntVariable61);
            Assert.AreEqual(tc.IntVariable70, tc2.IntVariable70);
            Assert.AreEqual(tc.IntVariable71, tc2.IntVariable71);
            Assert.AreEqual(tc.IntVariable80, tc2.IntVariable80);
            Assert.AreEqual(tc.IntVariable81, tc2.IntVariable81);
            Assert.AreEqual(tc.IntVariable90, tc2.IntVariable90);
            Assert.AreEqual(tc.IntVariable91, tc2.IntVariable91);
            Assert.AreEqual(tc.IntVariable100, tc2.IntVariable100);
            Assert.AreEqual(tc.IntVariable101, tc2.IntVariable101);
            Assert.AreEqual(tc.IntVariable110, tc2.IntVariable110);
            Assert.AreEqual(tc.IntVariable111, tc2.IntVariable111);
        }

        /// <summary>
        /// Read/Write a class that has the same properties of a DB with the same field in the same order
        /// </summary>
        [TestMethod]
        public async Task Test_Async_ReadAndWriteLongClass()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            TestLongClass tc = new TestLongClass
            {
   
   
                IntVariable0 = 0,
                IntVariable1 = 1,
                IntVariable10 = 10,
                IntVariable11 = 11,
                IntVariable20 = 20,
                IntVariable21 = 21,
                IntVariable30 = 30,
                IntVariable31 = 31,
                IntVariable40 = 40,
                IntVariable41 = 41,
                IntVariable50 = 50,
                IntVariable51 = 51,
                IntVariable60 = 60,
                IntVariable61 = 61,
                IntVariable70 = 70,
                IntVariable71 = 71,
                IntVariable80 = 80,
                IntVariable81 = 81,
                IntVariable90 = 90,
                IntVariable91 = 91,
                IntVariable100 = 100,
                IntVariable101 = 101,
                IntVariable110 = 200,
                IntVariable111 = 201
            };
            await plc.WriteClassAsync(tc, DB2);
            // Values that are read from a struct are stored in a new struct, returned by the funcion ReadStruct
            TestLongClass tc2 = new TestLongClass();
            await plc.ReadClassAsync(tc2, DB2);
            Assert.AreEqual(tc.IntVariable0, tc2.IntVariable0);
            Assert.AreEqual(tc.IntVariable1, tc2.IntVariable1);
            Assert.AreEqual(tc.IntVariable10, tc2.IntVariable10);
            Assert.AreEqual(tc.IntVariable11, tc2.IntVariable11);
            Assert.AreEqual(tc.IntVariable20, tc2.IntVariable20);
            Assert.AreEqual(tc.IntVariable21, tc2.IntVariable21);
            Assert.AreEqual(tc.IntVariable30, tc2.IntVariable30);
            Assert.AreEqual(tc.IntVariable31, tc2.IntVariable31);
            Assert.AreEqual(tc.IntVariable40, tc2.IntVariable40);
            Assert.AreEqual(tc.IntVariable41, tc2.IntVariable41);
            Assert.AreEqual(tc.IntVariable50, tc2.IntVariable50);
            Assert.AreEqual(tc.IntVariable51, tc2.IntVariable51);
            Assert.AreEqual(tc.IntVariable60, tc2.IntVariable60);
            Assert.AreEqual(tc.IntVariable61, tc2.IntVariable61);
            Assert.AreEqual(tc.IntVariable70, tc2.IntVariable70);
            Assert.AreEqual(tc.IntVariable71, tc2.IntVariable71);
            Assert.AreEqual(tc.IntVariable80, tc2.IntVariable80);
            Assert.AreEqual(tc.IntVariable81, tc2.IntVariable81);
            Assert.AreEqual(tc.IntVariable90, tc2.IntVariable90);
            Assert.AreEqual(tc.IntVariable91, tc2.IntVariable91);
            Assert.AreEqual(tc.IntVariable100, tc2.IntVariable100);
            Assert.AreEqual(tc.IntVariable101, tc2.IntVariable101);
            Assert.AreEqual(tc.IntVariable110, tc2.IntVariable110);
            Assert.AreEqual(tc.IntVariable111, tc2.IntVariable111);
        }

        /// <summary>
        /// Tests that a read and a write on addresses bigger than 8192 are executed correctly
        /// </summary>
        [TestMethod]
        public async Task Test_Async_WriteAndReadInt16VariableAddress8192()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            // To write a ushort i don't need any cast, only unboxing must be done
            ushort val = 8192;
            await plc.WriteAsync("DB2.DBW8192", val);
            ushort result = (ushort)await plc.ReadAsync("DB2.DBW8192");
            Assert.AreEqual(val, result, "A ushort goes from 0 to 64512");

            // To write a short i need to convert it to UShort, then i need to reconvert the readed value to get
            // the negative sign back
            // Depending if i'm writing on a DWORD or on a DEC, i will see ushort or short value in the plc
            short value = -8192;
            Assert.IsTrue(plc.IsConnected, "After connecting, IsConnected must be set to true");
            await plc.WriteAsync("DB2.DBW8192", value.ConvertToUshort());
            short result2 = ((ushort)await plc.ReadAsync("DB2.DBW8192")).ConvertToShort();
            Assert.AreEqual(value, result2, "A short goes from -32767 to 32766");
        }

        /// <summary>
        /// Tests that a read and a write on addresses bigger than 8192 are executed correctly
        /// </summary>
        [TestMethod]
        public async Task Test_Async_WriteAndReadInt16VariableAddress16384()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");

            // To write a ushort i don't need any cast, only unboxing must be done
            ushort val = 16384;
            await plc.WriteAsync("DB2.DBW16384", val);
            ushort result = (ushort)await plc.ReadAsync("DB2.DBW16384");
            Assert.AreEqual(val, result, "A ushort goes from 0 to 64512");

            // To write a short i need to convert it to UShort, then i need to reconvert the readed value to get
            // the negative sign back
            // Depending if i'm writing on a DWORD or on a DEC, i will see ushort or short value in the plc
            short value = -16384;
            Assert.IsTrue(plc.IsConnected, "After connecting, IsConnected must be set to true");
            await plc.WriteAsync("DB2.DBW16384", value.ConvertToUshort());
            short result2 = ((ushort)await plc.ReadAsync("DB2.DBW16384")).ConvertToShort();
            Assert.AreEqual(value, result2, "A short goes from -32767 to 32766");
        }

        [TestMethod]
        public async Task Test_Async_ReadMultipleBytes()
        {
   
   
            Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");
            bool val = true;
            await plc.WriteAsync("DB2.DBX0.5", val);
            bool result = (bool)await plc.ReadAsync("DB2.DBX0.5");
            Assert.AreEqual(val, result);

            ushort val1 = 16384;
            await plc.WriteAsync("DB2.DBW16384", val1);
            ushort result1 = (ushort)await plc.ReadAsync("DB2.DBW16384");
            Assert.AreEqual(val1, result1, "A ushort goes from 0 to 64512");

            bool val2 = true;
            await plc.WriteAsync("DB2.DBX8192.7", val2);
            bool result2 = (bool)await plc.ReadAsync("DB2.DBX8192.7");
            Assert.AreEqual(val2, result2);

            ushort val3 = 129;
            await plc.WriteAsync("DB2.DBW16", val3);
            ushort result3 = (ushort)await plc.ReadAsync("DB2.DBW16");
            Assert.AreEqual(val3, result3, "A ushort goes from 0 to 64512");

            byte[] val4 = new byte[] {
   
    0x12,