lmxopcua/tests/ZB.MOM.WW.LmxOpcUa.Tests/MxAccess/StaComThreadTests.cs

using System;
using System.Collections.Concurrent;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using Shouldly;
using Xunit;
using ZB.MOM.WW.LmxOpcUa.Host.MxAccess;

namespace ZB.MOM.WW.LmxOpcUa.Tests.MxAccess
{
    /// <summary>
    ///     Verifies the single-threaded apartment worker used to marshal COM calls for the MXAccess bridge.
    /// </summary>
    public class StaComThreadTests : IDisposable
    {
        [DllImport("user32.dll")]
        private static extern void PostQuitMessage(int nExitCode);

        private readonly StaComThread _thread;

        /// <summary>
        ///     Starts a fresh STA thread instance for each test.
        /// </summary>
        public StaComThreadTests()
        {
            _thread = new StaComThread();
            _thread.Start();
        }

        /// <summary>
        ///     Disposes the STA thread after each test.
        /// </summary>
        public void Dispose()
        {
            _thread.Dispose();
        }

        /// <summary>
        ///     Confirms that queued work runs on a thread configured for STA apartment state.
        /// </summary>
        [Fact]
        public async Task RunAsync_ExecutesOnStaThread()
        {
            var apartmentState = await _thread.RunAsync(() => Thread.CurrentThread.GetApartmentState());
            apartmentState.ShouldBe(ApartmentState.STA);
        }

        /// <summary>
        ///     Confirms that action delegates run to completion on the STA thread.
        /// </summary>
        [Fact]
        public async Task RunAsync_Action_Completes()
        {
            var executed = false;
            await _thread.RunAsync(() => executed = true);
            executed.ShouldBe(true);
        }

        /// <summary>
        ///     Confirms that function delegates can return results from the STA thread.
        /// </summary>
        [Fact]
        public async Task RunAsync_Func_ReturnsResult()
        {
            var result = await _thread.RunAsync(() => 42);
            result.ShouldBe(42);
        }

        /// <summary>
        ///     Confirms that exceptions thrown on the STA thread propagate back to the caller.
        /// </summary>
        [Fact]
        public async Task RunAsync_PropagatesException()
        {
            await Should.ThrowAsync<InvalidOperationException>(
                _thread.RunAsync(() => throw new InvalidOperationException("test error")));
        }

        /// <summary>
        ///     Confirms that disposing the STA thread stops it from accepting additional work.
        /// </summary>
        [Fact]
        public void Dispose_Stops_Thread()
        {
            var thread = new StaComThread();
            thread.Start();
            thread.IsRunning.ShouldBe(true);
            thread.Dispose();
            // After dispose, should not accept new work
            Should.Throw<ObjectDisposedException>(() => thread.RunAsync(() => { }).GetAwaiter().GetResult());
        }

        /// <summary>
        ///     Confirms that multiple queued work items all execute successfully on the STA thread.
        /// </summary>
        [Fact]
        public async Task MultipleWorkItems_ExecuteInOrder()
        {
            var results = new ConcurrentBag<int>();
            await Task.WhenAll(
                _thread.RunAsync(() => results.Add(1)),
                _thread.RunAsync(() => results.Add(2)),
                _thread.RunAsync(() => results.Add(3)));

            results.Count.ShouldBe(3);
        }

        /// <summary>
        ///     Confirms that after the message pump exits, subsequent RunAsync calls throw instead of hanging.
        /// </summary>
        [Fact]
        public async Task RunAsync_AfterPumpExit_ThrowsInsteadOfHanging()
        {
            // Kill the pump from inside by posting WM_QUIT
            await _thread.RunAsync(() => PostQuitMessage(0));
            await Task.Delay(100); // let pump exit

            _thread.IsRunning.ShouldBe(false);
            Should.Throw<InvalidOperationException>(() =>
                _thread.RunAsync(() => { }).GetAwaiter().GetResult());
        }
    }
}