unit TestNotifier;

interface

uses
    DUnitX.TestFramework,
    System.SysUtils, // For EAssertionFailed, EAccessViolation
    Myc.Core.Notifier;

type
    // Dummy interface and class for testing
    IMyTestInterface = interface(IInterface)
        ['{7A8C1A01-1C6B-4A7A-B9D8-28E6A8D02A0F}']
        // Unique GUID
        procedure Foo;
        function GetValue: Integer;
    end;

    TMyTestReceiver = class(TInterfacedObject, IMyTestInterface)
    private
        FValue: Integer;
        FCallCount: Integer;
    public
        constructor Create(AValue: Integer);
        procedure Foo;
        function GetValue: Integer;
        property CallCount: Integer read FCallCount write FCallCount;
    end;

    [TestFixture]
    TMycTestNotifierTests = class
    private
        FNotifier: TMycNotifyList<IMyTestInterface>;
    public
        [Setup]
        procedure Setup;
        [TearDown]
        procedure TearDown;

        [Test]
        procedure Test01_DestroyExecutesWithoutErrors;
        [Test]
        procedure Test02_NotifyOnFinalizedLockedEmptyListExecutesWithoutErrors;
        [Test]
        procedure Test03_UnadviseAllOnFinalizedLockedEmptyListExecutesWithoutErrors;
        [Test]
        procedure Test04_AdviseUnadviseBasicFunctionality;
        [Test]
        procedure Test05_NotifyCallsAdvisedItemsAndCanRemoveThem;
    end;

implementation

{ TMyTestReceiver }

constructor TMyTestReceiver.Create(AValue: Integer);
begin
    inherited Create;
    FValue := AValue;
    FCallCount := 0;
end;

procedure TMyTestReceiver.Foo;
begin
    Inc(FCallCount);
end;

function TMyTestReceiver.GetValue: Integer;
begin
    Result := FValue;
end;

{ TMycTestNotifierTests }

procedure TMycTestNotifierTests.Setup;
begin
    FNotifier.Create;
    // FNotifier's internal FFirst is now 1 (unlocked, not finalized)
end;

procedure TMycTestNotifierTests.TearDown;
begin
    // DUnitX creates a new test fixture instance for each test method.
    // Setup re-initializes FNotifier. FNotifier is a record, so its lifetime is managed
    // by the fixture. If it were an object managing external unmanaged resources,
    // Destroy would be critical here. Given Destroy's issues, we rely on Setup.
end;

// Test for: Correct execution of Destroy without assertion failures.
// With current buggy code, this test will FAIL due to EAssertionFailed in Destroy.
procedure TMycTestNotifierTests.Test01_DestroyExecutesWithoutErrors;
begin
    // This call is expected to succeed without raising EAssertionFailed or other exceptions
    // if TMycNotifyList.Destroy is implemented correctly.
    FNotifier.Destroy;
    Assert.IsTrue(True, 'FNotifier.Destroy completed without raising an exception.');
end;

// Test for: Correct execution of Notify on an empty, locked, and finalized list.
// It should not cause an Access Violation or call the predicate.
// With current buggy code, this test will FAIL due to an Access Violation.
procedure TMycTestNotifierTests.Test02_NotifyOnFinalizedLockedEmptyListExecutesWithoutErrors;
var
    predicateCallCount: Integer;
    dummyPredicate: TPredicate<IMyTestInterface>;
begin
    predicateCallCount := 0;
    dummyPredicate :=
                    function(Item: IMyTestInterface): Boolean
                    begin
                        Inc(predicateCallCount);
                        Result := True;
                    end;

    FNotifier.Lock;
    Assert.IsTrue(FNotifier.IsLocked, 'Notifier should be locked.');

    //    FNotifier.Finalize; // Internally, FFirst becomes 2 (locked & finalized state bits) if it was 0 after Lock
    //    Assert.IsTrue( FNotifier.IsFinalized, 'Notifier should be finalized.' );

    // In a corrected Notifier, this call should not cause an AV and not call the predicate.
    FNotifier.Notify(dummyPredicate);
    Assert.AreEqual(0, predicateCallCount, 'Notify predicate should not have been called for an empty, finalized list.');
    Assert.IsTrue(True, 'FNotifier.Notify on finalized locked empty list completed without AV.');

    if FNotifier.IsLocked then // Release lock for subsequent operations or cleanup
    begin
        FNotifier.Release;
    end;
end;

// Test for: Correct execution of UnadviseAll on an empty, locked, and finalized list.
// It should not cause an Access Violation.
// With current buggy code, this test will FAIL due to an Access Violation.
procedure TMycTestNotifierTests.Test03_UnadviseAllOnFinalizedLockedEmptyListExecutesWithoutErrors;
begin
    FNotifier.Lock;
    Assert.IsTrue(FNotifier.IsLocked, 'Notifier should be locked.');

    //    FNotifier.Finalize; // FFirst becomes 2 internally
    //    Assert.IsTrue( FNotifier.IsFinalized, 'Notifier should be finalized.' );

    // In a corrected Notifier, this call should not cause an AV.
    FNotifier.UnadviseAll;
    Assert.IsTrue(True, 'FNotifier.UnadviseAll on finalized locked empty list completed without AV.');

    if FNotifier.IsLocked then // Release lock
    begin
        FNotifier.Release;
    end;
end;

// Test for: Basic Advise/Unadvise functionality (assumed to use FList).
// This test should PASS with the current code if FList handling is correct.
procedure TMycTestNotifierTests.Test04_AdviseUnadviseBasicFunctionality;
var
    tag1, tag2: TMycNotifyList<IMyTestInterface>.TTag;
    receiver1, receiver2: IMyTestInterface;
begin
    receiver1 := TMyTestReceiver.Create(1);
    receiver2 := TMyTestReceiver.Create(2);

    FNotifier.Lock;
    try
        tag1 := FNotifier.Advise(receiver1);
        Assert.AreNotEqual(TMycNotifyList<IMyTestInterface>.TTag(nil), tag1, 'Tag1 should not be nil.');
        FNotifier.Unadvise(tag1);

        tag1 := FNotifier.Advise(receiver1);
        Assert.AreNotEqual(TMycNotifyList<IMyTestInterface>.TTag(nil), tag1, 'Tag1 should not be nil.');

        tag2 := FNotifier.Advise(receiver2);
        Assert.AreNotEqual(TMycNotifyList<IMyTestInterface>.TTag(nil), tag2, 'Tag2 should not be nil.');
        Assert.AreNotEqual(tag1, tag2, 'Tag1 and Tag2 should be different.');

        FNotifier.Unadvise(tag1);
        FNotifier.Unadvise(tag2);

        // Re-add and unadvise in different order
        tag1 := FNotifier.Advise(receiver1);
        tag2 := FNotifier.Advise(receiver2);
        Assert.AreNotEqual(TMycNotifyList<IMyTestInterface>.TTag(nil), tag1);
        Assert.AreNotEqual(TMycNotifyList<IMyTestInterface>.TTag(nil), tag2);
        FNotifier.Unadvise(tag2);
        FNotifier.Unadvise(tag1);

    finally
        FNotifier.Release;
    end;
    Assert.IsFalse(FNotifier.IsLocked, 'Notifier should be unlocked.');
end;

// Test for: Notify calls advised items and can remove items based on the predicate.
// This test should PASS with the current code if FList handling in Notify is correct.
procedure TMycTestNotifierTests.Test05_NotifyCallsAdvisedItemsAndCanRemoveThem;
var
    rcv1, rcv2, rcv3: TMyTestReceiver;
    itemsProcessedCount: Integer;
begin
    rcv1 := TMyTestReceiver.Create(10); // Keep
    rcv2 := TMyTestReceiver.Create(20); // Remove
    rcv3 := TMyTestReceiver.Create(30); // Keep

    FNotifier.Lock;
    try
        FNotifier.Advise(rcv1);
        FNotifier.Advise(rcv2);
        FNotifier.Advise(rcv3);

        itemsProcessedCount := 0;
        FNotifier.Notify(
                        function(Item: IMyTestInterface): Boolean
                        begin
                            Inc(itemsProcessedCount);
                            TMyTestReceiver(Item).Foo;
                            Result := Item.GetValue <> 20; // Remove item with value 20
                        end
        );

        Assert.AreEqual(3, itemsProcessedCount, 'Notify predicate called for all 3 items.');
        Assert.AreEqual(1, rcv1.CallCount, 'Receiver1 called once.');
        Assert.AreEqual(1, rcv2.CallCount, 'Receiver2 called once (before removal).');
        Assert.AreEqual(1, rcv3.CallCount, 'Receiver3 called once.');

        // Reset counts and check again
        rcv1.CallCount := 0;
        rcv2.CallCount := 0; // Should remain 0 as it's removed
        rcv3.CallCount := 0;
        itemsProcessedCount := 0;

        FNotifier.Notify(
                        function(Item: IMyTestInterface): Boolean
                        begin
                            Inc(itemsProcessedCount);
                            TMyTestReceiver(Item).Foo;
                            Result := True; // Keep remaining
                        end
        );
        Assert.AreEqual(2, itemsProcessedCount, 'Notify predicate called for 2 remaining items.');
        Assert.AreEqual(1, rcv1.CallCount, 'Receiver1 called again.');
        Assert.AreEqual(0, rcv2.CallCount, 'Receiver2 (removed) not called again.');
        Assert.AreEqual(1, rcv3.CallCount, 'Receiver3 called again.');

    finally
        FNotifier.Release;
    end;

    // Cleanup remaining items (rcv1, rcv3)
    FNotifier.Lock;
    try
        // This UnadviseAll should work on the remaining FList items.
        // If the list becomes empty in a way that FFirst is misconfigured, it might still fail.
        FNotifier.UnadviseAll;
    finally
        FNotifier.Release;
    end;
end;

initialization

    TDUnitX.RegisterTestFixture(TMycTestNotifierTests);

end.