mht-siemens/solution/tests/PlcVanguard.Core.Tests/UnitTest1.cs

using Microsoft.Extensions.Logging.Abstractions;
using PlcVanguard.Core.Data;
using PlcVanguard.Core.State;

namespace PlcVanguard.Core.Tests;

public class MemAddressTests
{
    [Fact]
    public void Parse_ValidInput_ParsesCorrectly()
    {
        var addr = new MemAddress("DB701.DBD142");

        Assert.Equal(701, addr.DbNum);
        Assert.Equal("D", addr.TipoMem);
        Assert.Equal(142, addr.IndiceMem);
    }

    [Fact]
    public void Parse_InvalidInput_ReturnsDefaults()
    {
        var addr = new MemAddress("invalid");

        Assert.Equal(0, addr.DbNum);
        Assert.Equal("", addr.TipoMem);
        Assert.Equal(0, addr.IndiceMem);
    }

    [Fact]
    public void Parse_NullInput_ReturnsDefaults()
    {
        var addr = new MemAddress(null!);

        Assert.Equal(0, addr.DbNum);
    }
}

public class StateManagerTests
{
    private readonly StateManager _manager;

    public StateManagerTests()
    {
        _manager = new StateManager(NullLogger<StateManager>.Instance);
    }

    [Fact]
    public void InitialState_IsNotConnected()
    {
        Assert.False(_manager.IsConnected);
    }

    [Fact]
    public void SetValueAndGet_ReturnsCorrectValue()
    {
        _manager.SetValue("DB100.Counter1", 42.5);
        var value = _manager.GetValue("DB100.Counter1");

        Assert.Equal(42.5, value);
    }

    [Fact]
    public void GetValue_NonexistentArea_ReturnsNull()
    {
        var value = _manager.GetValue("NonExistent");
        Assert.Null(value);
    }

    [Fact]
    public void GetSnapshot_ReturnsCopyOfValues()
    {
        _manager.SetValue("C1", 1.0);
        _manager.SetValue("C2", 2.0);

        var snapshot = _manager.GetSnapshot();

        Assert.Equal(2, snapshot.Count);
        Assert.Equal(1.0, snapshot["C1"]);
        Assert.Equal(2.0, snapshot["C2"]);
    }

    [Fact]
    public void UpdateConnectionState_UpdatesFlag()
    {
        _manager.UpdateConnectionState(true);
        Assert.True(_manager.IsConnected);

        _manager.UpdateConnectionState(false);
        Assert.False(_manager.IsConnected);
    }

    [Fact]
    public void SetConfiguredParameters_StoresAllParams()
    {
        var parameterList = new Dictionary<string, string>
        {
            { "key1", "value1" },
            { "key2", "value2" }
        };

        _manager.SetConfiguredParameters(parameterList);
        var stored = _manager.ConfiguredParameters;

        Assert.Equal(2, stored.Count);
        Assert.Equal("value1", stored["key1"]);
        Assert.Equal("value2", stored["key2"]);
    }

    [Fact]
    public void SetValue_TriggerValueChangedEvent()
    {
        var triggered = false;
        string? capturedKey = null;
        double capturedOld = 0, capturedNew = 0;

        _manager.ValueChanged += (_, e) =>
        {
            triggered = true;
            capturedKey = e.AreaId;
            capturedOld = e.OldValue;
            capturedNew = e.NewValue;
        };

        _manager.SetValue("DB100.Counter1", 10.0);
        _manager.SetValue("DB100.Counter1", 20.5);

        Assert.True(triggered);
        Assert.Equal("DB100.Counter1", capturedKey);
        Assert.Equal(10.0, capturedOld);
        Assert.Equal(20.5, capturedNew);
    }

    [Fact]
    public void ConnectionStateChangedEvent_TriggeredOnStateChange()
    {
        var triggered = false;
        bool? capturedState = null;

        _manager.ConnectionStateChanged += (_, e) =>
        {
            triggered = true;
            capturedState = e.IsConnected;
        };

        _manager.IsConnected = true;
        Assert.True(triggered);
        Assert.True(capturedState);

        triggered = false;
        _manager.IsConnected = false;
        Assert.True(triggered);
        Assert.False(capturedState);
    }

    [Fact]
    public void ValueChangedEvent_FirstSetValue_FromZero()
    {
        double capturedOld = -1;

        _manager.ValueChanged += (_, e) =>
        {
            capturedOld = e.OldValue;
        };

        _manager.SetValue("DB100.Counter1", 99.9);

        Assert.Equal(0.0, capturedOld);
    }
}