Notifier & Tests added

2025-05-25 14:37:57 +02:00
parent 46264ea041
commit 10ef4cbcf2
8 changed files with 1320 additions and 930 deletions
@@ -0,0 +1,262 @@
+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.