#450 - Make Tag testable without devices.

Author: sebastian-zitzelsberger

src/libplctag.Tests/MyUdt.cs

@@ -0,0 +1,11 @@
+using System.Runtime.InteropServices;
+
+namespace libplctag.Tests
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 4)]
+    public struct MyUdt
+    {
+        public short shortField;
+        public int intField;
+    }
+}

src/libplctag.Tests/StructMarshallingExtensions.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace libplctag.Tests
+{
+    public static class StructMarshallingExtensions
+    {
+        /// <summary>
+        /// Converts a blittable struct to a byte array.
+        /// </summary>
+        public static byte[] ToByteArray<T>(this T value) where T : struct
+        {
+            byte[] bytes = new byte[Marshal.SizeOf<T>()];
+            MemoryMarshal.Write(bytes, ref value); // zero-allocation, fast
+            return bytes;
+        }
+
+        /// <summary>
+        /// Reads a blittable struct from a byte array.
+        /// </summary>
+        public static T ToStruct<T>(this byte[] bytes) where T : struct
+        {
+            if (bytes.Length < Marshal.SizeOf<T>())
+                throw new ArgumentException($"Byte array too small for struct {typeof(T)}");
+
+            return MemoryMarshal.Read<T>(bytes);
+        }
+    }
+}

src/libplctag.Tests/TagExtensions.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace libplctag.Tests
+{
+    public static class TagExtensions
+    {
+        public static T GetValue<T>(this Tag tag) where T : struct
+        {
+            byte[] buffer = tag.GetBuffer();
+            GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+
+            try
+            {
+                //ToInt64 is used because it's assumed the code will compile and run on 64-bit platform.
+                //If it's going to run on a 32-platform, ToInt32 should be used.
+                T retVal = Marshal.PtrToStructure<T>(new IntPtr(handle.AddrOfPinnedObject().ToInt64()))!;
+
+                return (retVal);
+            }
+            finally
+            {
+                handle.Free();
+            }
+        }
+    }
+}

src/libplctag.Tests/TagTests.cs

@@ -0,0 +1,94 @@
+using FluentAssertions;
+using libplctag.NativeImport;
+using Moq;
+using System;
+using System.Net;
+using System.Runtime.InteropServices;
+using Xunit;
+
+namespace libplctag.Tests
+{
+    public class TagTests : IDisposable
+    {
+        private const int TimeoutInMilliSeconds = 1000;
+        private readonly MockRepository _mockRepository;
+        private readonly Mock<INative> _iNativeMock;
+        private readonly Tag _underTest;
+
+
+        public TagTests()
+        {
+            _mockRepository = new MockRepository(MockBehavior.Strict);
+            _iNativeMock = _mockRepository.Create<INative>();
+            _underTest = new Tag(_iNativeMock.Object);
+            _underTest.Timeout = TimeSpan.FromMilliseconds(TimeoutInMilliSeconds);
+        }
+
+        [Fact]
+        public void TagCanBeInitialized()
+        {
+            // ARRANGE
+            int nativeTagHandle = 1;
+            GivenTagCanBeInitializedWithHandle(nativeTagHandle);
+
+            // ACT
+            _underTest.Initialize();
+
+
+            // ASSERT
+            _underTest.IsInitialized.Should().BeTrue();
+            _underTest.NativeTagHandle.Should().Be(nativeTagHandle);
+        }
+
+        private void GivenTagCanBeInitializedWithHandle(int nativeTagHandle)
+        {
+            _iNativeMock.Setup(native => native.plc_tag_create_ex(
+                    It.IsAny<string>(),
+                    It.IsAny<plctag.callback_func_ex>(),
+                    IntPtr.Zero,
+                    TimeoutInMilliSeconds))
+                .Returns(nativeTagHandle);
+        }
+
+
+        [Fact]
+        public void TagForMyUdtShouldReturnMockedValue()
+        {
+            // ARRANGE
+            int nativeTagHandle = 1;
+            MyUdt expectedValue = new() { intField = 1, shortField = 2 };
+            _underTest.ElementSize = Marshal.SizeOf(typeof(MyUdt));
+
+            GivenTagCanBeInitializedWithHandle(nativeTagHandle);
+            GivenMarshalledDataIsReturnedInBuffer(nativeTagHandle, expectedValue);
+            
+            // ACT
+            _underTest.Initialize();
+            MyUdt currentTagValue = _underTest.GetValue<MyUdt>();
+
+            // ASSERT
+            currentTagValue.Should().Be(expectedValue);
+        }
+
+        private void GivenMarshalledDataIsReturnedInBuffer<T>(int nativeTagHandle, T expectedData) where T : struct
+        {
+            byte[] byteData = expectedData.ToByteArray();
+            int size = Marshal.SizeOf(typeof(T));
+
+            _iNativeMock.Setup(native => native.plc_tag_get_size(nativeTagHandle)).Returns(size);
+            _iNativeMock.Setup(native => native.plc_tag_get_raw_bytes(nativeTagHandle, 0, It.IsAny<byte[]>(), size))
+                .Returns((int)Status.Ok)
+                .Callback((int tag, int start_offset, byte[] buffer, int buffer_length) =>
+                {
+                    Array.Copy(byteData, buffer, byteData.Length);
+                });
+        }
+
+
+        public void Dispose()
+        {
+            _mockRepository.VerifyAll();
+            GC.SuppressFinalize(this);
+        }
+    }
+}

src/libplctag.Tests/libplctag.Tests.csproj

@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="8.6.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
     <PackageReference Include="Moq" Version="4.20.70" />
     <PackageReference Include="xunit" Version="2.9.0" />
@@ -24,4 +25,8 @@
     <ProjectReference Include="..\libplctag\libplctag.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Remove="LogixString.cs" />
+  </ItemGroup>
+
 </Project>

src/libplctag/INative.cs

@@ -16,7 +16,7 @@
 
 namespace libplctag
 {
-    interface INative
+    public interface INative
     {
         int plc_tag_abort(int tag);
         int plc_tag_check_lib_version(int req_major, int req_minor, int req_patch);