renamed Semaphore to Latch

Test/MycTests.dpr

@@ -20,7 +20,7 @@ uses
   TestStack in 'TestStack.pas' {/TestNotifier_Threading in 'TestNotifier_Threading.pas',},
   TestNotifier_Threading in 'TestNotifier_Threading.pas' {/TestNotifier_ChaosStress in 'TestNotifier_ChaosStress.pas',},
   TestNotifier_ChaosStress in 'TestNotifier_ChaosStress.pas',
-  TestSignals_Semapore in 'TestSignals_Semapore.pas',
+  TestSignals_Latch in 'TestSignals_Latch.pas',
   Myc.Core.Tasks in '..\Src\Myc.Core.Tasks.pas',
   TestTasks in 'TestTasks.pas';
 

Test/MycTests.dproj

@@ -114,7 +114,7 @@
             <Form>/TestNotifier_ChaosStress in &apos;TestNotifier_ChaosStress.pas&apos;,</Form>
         </DCCReference>
         <DCCReference Include="TestNotifier_ChaosStress.pas"/>
-        <DCCReference Include="TestSignals_Semapore.pas"/>
+        <DCCReference Include="TestSignals_Latch.pas"/>
         <DCCReference Include="..\Src\Myc.Core.Tasks.pas"/>
         <DCCReference Include="TestTasks.pas"/>
         <BuildConfiguration Include="Base">

Test/TestSignals_Latch.pas

@@ -0,0 +1,376 @@
+unit TestSignals_Latch;
+
+interface
+
+uses
+  DUnitX.TestFramework,
+  Myc.Signals, // Unit under test, using TMycLatch static members
+  System.SysUtils,
+  System.StrUtils;
+
+type
+  // Helper class to mock a subscriber.
+  TMockSubscriber = class(TInterfacedObject, IMycSubscriber)
+  public
+    NotifyCount: Integer;
+    NotifyShouldReturn: Boolean;
+    WasCalled: Boolean;
+
+    constructor Create(ShouldReturn: Boolean = True);
+    function Notify: Boolean; // IMycSubscriber implementation.
+  end;
+
+  [TestFixture]
+  TTestMycLatch = class(TObject)
+  public
+    [Setup]
+    procedure Setup;
+    [TearDown]
+    procedure TearDown;
+
+    // --- Category 1: Basic Counter and State Functionality (Parameterized) ---
+    [TestCase('InitialPositive', '1,False')]
+    [TestCase('InitialZero', '0,True')] // TMycLatch.CreateLatch(0) will return TMycLatch.Null
+    [TestCase('InitialNegative', '-1,True')] // TMycLatch.CreateLatch(-1) will return TMycLatch.Null
+    [TestCase('InitialLargePositive', '5,False')]
+    procedure TestCreate_InitialState(InitialCount: Integer; ExpectedIsSet: Boolean);
+
+    [TestCase('DecrementPositiveToZero', '1,False,True')]
+    [TestCase('DecrementPositiveToPositive', '2,True,False')]
+    [TestCase('DecrementZeroToNegative', '0,False,True')]
+    [TestCase('DecrementNegativeToNegative', '-1,False,True')]
+    procedure TestNotify_ReturnValueAndState_AfterOneNotify(InitialCount: Integer; ExpectedReturn: Boolean; ExpectedIsSet: Boolean);
+
+    [Test]
+    procedure TestNotify_DecrementsCounter_StateChanges;
+    [Test]
+    procedure TestNotify_MultipleNotifies_CounterBecomesNegativeAndStaysSet;
+
+    // --- Category 2: Notification to Subscribers ---
+    [Test]
+    procedure TestSubscriber_Single_IsNotifiedWhenLatchSet;
+    [Test]
+    procedure TestSubscriber_Multiple_AreNotifiedWhenLatchSet;
+    [Test]
+    procedure TestSubscriber_NotNotified_BeforeLatchSet;
+    [Test]
+    procedure TestSubscriber_NotifiedOnlyOnce_AfterLatchSet;
+    [Test]
+    procedure TestSubscribe_ToAlreadySetLatch_NotifiesImmediately;
+
+    // --- Category 3: Chaining and Cascading ---
+    [Test]
+    procedure TestChaining_A_Notifies_B;
+    [Test]
+    procedure TestCascade_A_Notifies_B_Notifies_C;
+    [Test]
+    procedure TestChaining_B_NeedsMultipleNotifiesFromA_WithSubscriberOnB;
+
+    // --- Category 4: Special Cases ---
+    [Test]
+    procedure TestInitiallySetLatch_NotifiesNewSubscriberImmediately;
+
+    [Test]
+    procedure TestUnsubscribe_SubscriberNotNotified;
+
+    // --- Category 5: Signal Loss / Counter Integrity ---
+    [Test]
+    procedure TestMultipleTriggersNoSubscriber_StateCorrectForLaterSubscriber;
+  end;
+
+implementation
+
+{ TMockSubscriber }
+
+constructor TMockSubscriber.Create(ShouldReturn: Boolean = True);
+begin
+  inherited Create;
+  NotifyCount := 0;
+  NotifyShouldReturn := ShouldReturn;
+  WasCalled := False;
+end;
+
+function TMockSubscriber.Notify: Boolean;
+begin
+  Inc(NotifyCount);
+  WasCalled := True;
+  Result := NotifyShouldReturn;
+end;
+
+{ TTestMycLatch }
+
+procedure TTestMycLatch.Setup;
+begin
+  // Per-test setup code can go here (if any).
+end;
+
+procedure TTestMycLatch.TearDown;
+begin
+  // Per-test teardown code can go here (if any).
+end;
+
+procedure TTestMycLatch.TestCreate_InitialState(InitialCount: Integer; ExpectedIsSet: Boolean);
+var
+  latch: IMycLatch;
+begin
+  latch := TMycLatch.CreateLatch(InitialCount); // Changed to use TMycLatch.CreateLatch
+  Assert.AreEqual(ExpectedIsSet, latch.State.IsSet, 'Latch initial IsSet state mismatch.');
+end;
+
+procedure TTestMycLatch.TestNotify_ReturnValueAndState_AfterOneNotify(InitialCount: Integer; ExpectedReturn: Boolean; ExpectedIsSet: Boolean);
+var
+  latch: IMycLatch;
+  returnedValue: Boolean;
+begin
+  latch := TMycLatch.CreateLatch(InitialCount); // Changed to use TMycLatch.CreateLatch
+  returnedValue := latch.Notify;
+
+  Assert.AreEqual(ExpectedReturn, returnedValue, 'Unexpected return value from Latch.Notify call.');
+  Assert.AreEqual(ExpectedIsSet, latch.State.IsSet, 'Unexpected IsSet state after Latch.Notify call.');
+end;
+
+procedure TTestMycLatch.TestNotify_DecrementsCounter_StateChanges;
+var
+  latch: IMycLatch;
+begin
+  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  Assert.IsFalse(latch.State.IsSet, 'Latch should initially not be set.');
+  latch.Notify;
+  Assert.IsTrue(latch.State.IsSet, 'Latch should be set after Notify.');
+end;
+
+procedure TTestMycLatch.TestNotify_MultipleNotifies_CounterBecomesNegativeAndStaysSet;
+var
+  latch: IMycLatch;
+begin
+  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  latch.Notify;
+  Assert.IsTrue(latch.State.IsSet, 'Latch should be set after first Notify.');
+  latch.Notify;
+  Assert.IsTrue(latch.State.IsSet, 'Latch should remain set after second Notify.');
+end;
+
+procedure TTestMycLatch.TestSubscriber_Single_IsNotifiedWhenLatchSet;
+var
+  latch: IMycLatch;
+  mockSub: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  mockSub := TMockSubscriber.Create;
+  subscription := latch.State.Subscribe(mockSub);
+
+  Assert.IsFalse(latch.State.IsSet, 'Latch should initially not be set.');
+  Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should not have been notified yet (before latch set).');
+
+  latch.Notify;
+
+  Assert.IsTrue(latch.State.IsSet, 'Latch should be set after its Notify is called.');
+  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub should have been notified once when latch becomes set.');
+end;
+
+procedure TTestMycLatch.TestSubscriber_Multiple_AreNotifiedWhenLatchSet;
+var
+  latch: IMycLatch;
+  mockSub1, mockSub2, mockSub3: TMockSubscriber;
+  sub1, sub2, sub3: TMycSubscription;
+begin
+  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  mockSub1 := TMockSubscriber.Create;
+  mockSub2 := TMockSubscriber.Create;
+  mockSub3 := TMockSubscriber.Create;
+
+  sub1 := latch.State.Subscribe(mockSub1);
+  sub2 := latch.State.Subscribe(mockSub2);
+  sub3 := latch.State.Subscribe(mockSub3);
+
+  latch.Notify;
+
+  Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 notification count mismatch.');
+  Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 notification count mismatch.');
+  Assert.AreEqual(1, mockSub3.NotifyCount, 'MockSub3 notification count mismatch.');
+end;
+
+procedure TTestMycLatch.TestSubscriber_NotNotified_BeforeLatchSet;
+var
+  latch: IMycLatch;
+  mockSub: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  latch := TMycLatch.CreateLatch(2); // Changed to use TMycLatch.CreateLatch
+  mockSub := TMockSubscriber.Create;
+  subscription := latch.State.Subscribe(mockSub);
+
+  Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should not be notified upon subscription if latch is not set.');
+  latch.Notify;
+  Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should still not be notified as latch is not yet set.');
+end;
+
+procedure TTestMycLatch.TestSubscriber_NotifiedOnlyOnce_AfterLatchSet;
+var
+  latch: IMycLatch;
+  mockSub: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  mockSub := TMockSubscriber.Create;
+  subscription := latch.State.Subscribe(mockSub);
+
+  latch.Notify;
+  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub notify count should be 1 after latch set.');
+
+  latch.Notify;
+  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub notify count should remain 1 (not notified again as it was unadvised).');
+end;
+
+procedure TTestMycLatch.TestSubscribe_ToAlreadySetLatch_NotifiesImmediately;
+var
+  latch: IMycLatch;
+  mockSub1, mockSub2: TMockSubscriber;
+  subscription1, subscription2: TMycSubscription;
+begin
+  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  mockSub1 := TMockSubscriber.Create;
+  subscription1 := latch.State.Subscribe(mockSub1);
+  latch.Notify;
+
+  Assert.IsTrue(latch.State.IsSet, 'Latch should be set after initial trigger.');
+  Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 should have been notified once.');
+
+  mockSub2 := TMockSubscriber.Create;
+  subscription2 := latch.State.Subscribe(mockSub2);
+
+  Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 should be notified immediately upon subscribing to an already set latch.');
+
+  latch.Notify;
+  Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 notify count should remain 1.');
+  Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 notify count should remain 1 after re-triggering.');
+end;
+
+procedure TTestMycLatch.TestChaining_A_Notifies_B;
+var
+  latchA, latchB: IMycLatch;
+  mockSubForB: TMockSubscriber;
+  subHandle_B_listens_A, subHandle_Mock_listens_B: TMycSubscription;
+begin
+  latchA := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  latchB := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  mockSubForB := TMockSubscriber.Create;
+
+  subHandle_Mock_listens_B := latchB.State.Subscribe(mockSubForB);
+  subHandle_B_listens_A := latchA.State.Subscribe(latchB);
+
+  Assert.IsFalse(latchA.State.IsSet, 'LatchA initially not set.');
+  Assert.IsFalse(latchB.State.IsSet, 'LatchB initially not set.');
+  Assert.AreEqual(0, mockSubForB.NotifyCount, 'MockSubForB initially not notified.');
+
+  latchA.Notify;
+
+  Assert.IsTrue(latchA.State.IsSet, 'LatchA should be set after notify.');
+  Assert.IsTrue(latchB.State.IsSet, 'LatchB should be set after being notified by LatchA.');
+  Assert.AreEqual(1, mockSubForB.NotifyCount, 'MockSubForB should have been notified by LatchB.');
+end;
+
+procedure TTestMycLatch.TestCascade_A_Notifies_B_Notifies_C;
+var
+  latchA, latchB, latchC: IMycLatch;
+  mockSubForC: TMockSubscriber;
+  sub_Mock_C, sub_C_B, sub_B_A: TMycSubscription;
+begin
+  latchA := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  latchB := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  latchC := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  mockSubForC := TMockSubscriber.Create;
+
+  sub_Mock_C := latchC.State.Subscribe(mockSubForC);
+  sub_C_B    := latchB.State.Subscribe(latchC);
+  sub_B_A    := latchA.State.Subscribe(latchB);
+
+  latchA.Notify;
+
+  Assert.IsTrue(latchA.State.IsSet, 'LatchA state mismatch in cascade.');
+  Assert.IsTrue(latchB.State.IsSet, 'LatchB state mismatch in cascade.');
+  Assert.IsTrue(latchC.State.IsSet, 'LatchC state mismatch in cascade.');
+  Assert.AreEqual(1, mockSubForC.NotifyCount, 'MockSubForC notification count mismatch in cascade.');
+end;
+
+procedure TTestMycLatch.TestChaining_B_NeedsMultipleNotifiesFromA_WithSubscriberOnB;
+var
+  latchA, latchB: IMycLatch;
+  mockSubForB: TMockSubscriber;
+  sub_Mock_B, sub_B_A: TMycSubscription;
+begin
+  latchA := TMycLatch.CreateLatch(2); // Changed to use TMycLatch.CreateLatch
+  latchB := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  mockSubForB := TMockSubscriber.Create;
+
+  sub_Mock_B := latchB.State.Subscribe(mockSubForB);
+  sub_B_A    := latchA.State.Subscribe(latchB);
+
+  latchA.Notify;
+  Assert.IsFalse(latchA.State.IsSet, 'LatchA should not be set after first notify of two.');
+  Assert.IsFalse(latchB.State.IsSet, 'LatchB should not have been triggered yet by LatchA.');
+  Assert.AreEqual(0, mockSubForB.NotifyCount, 'MockSubForB should not have been notified yet.');
+
+  latchA.Notify;
+  Assert.IsTrue(latchA.State.IsSet, 'LatchA should be set after second notify.');
+  Assert.IsTrue(latchB.State.IsSet, 'LatchB should now be set by LatchA.');
+  Assert.AreEqual(1, mockSubForB.NotifyCount, 'MockSubForB should have been notified by LatchB.');
+end;
+
+procedure TTestMycLatch.TestInitiallySetLatch_NotifiesNewSubscriberImmediately;
+var
+  latch: IMycLatch;
+  mockSub: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  latch := TMycLatch.CreateLatch(0); // Changed to use TMycLatch.CreateLatch. Will return TMycLatch.Null.
+  mockSub := TMockSubscriber.Create;
+
+  subscription := latch.State.Subscribe(mockSub);
+
+  Assert.IsTrue(latch.State.IsSet, 'Latch IsSet property mismatch after creation with count 0.');
+  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub should be notified immediately upon subscribing to an already set latch.');
+end;
+
+procedure TTestMycLatch.TestUnsubscribe_SubscriberNotNotified;
+var
+  latch: IMycLatch;
+  mockSub: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  mockSub := TMockSubscriber.Create;
+
+  subscription := latch.State.Subscribe(mockSub);
+  subscription := Default(TMycSubscription); // Simulates leaving scope / destruction, calls Finalize for unsubscription.
+
+  latch.Notify;
+
+  Assert.AreEqual(0, mockSub.NotifyCount, 'Unsubscribed MockSub should not be notified.');
+end;
+
+procedure TTestMycLatch.TestMultipleTriggersNoSubscriber_StateCorrectForLaterSubscriber;
+var
+  latch: IMycLatch;
+  mockSub: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  latch := TMycLatch.CreateLatch(3); // Changed to use TMycLatch.CreateLatch
+
+  latch.Notify;
+  latch.Notify;
+  Assert.IsFalse(latch.State.IsSet, 'Latch should not be set yet after partial notifies.');
+
+  mockSub := TMockSubscriber.Create;
+  subscription := latch.State.Subscribe(mockSub);
+  Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should not be notified on subscribe if latch not yet set.');
+
+  latch.Notify;
+  Assert.IsTrue(latch.State.IsSet, 'Latch should now be set.');
+  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub should have been notified when latch becomes set.');
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(TTestMycLatch);
+end.

Test/TestSignals_Semapore.pas

@@ -1,390 +0,0 @@
-// TestSignals_Semapore.pas
-unit TestSignals_Semapore;
-
-interface
-
-uses
-  DUnitX.TestFramework,
-  Myc.Signals, // Unit under test
-  System.SysUtils,
-  System.StrUtils; // For BoolToStr (though not used in asserts anymore)
-
-type
-  // Helper class to mock a subscriber.
-  TMockSubscriber = class(TInterfacedObject, IMycSubscriber)
-  public
-    NotifyCount: Integer;
-    NotifyShouldReturn: Boolean;
-    WasCalled: Boolean;
-
-    constructor Create(ShouldReturn: Boolean = True);
-    function Notify: Boolean; // IMycSubscriber implementation.
-  end;
-
-  [TestFixture]
-  TTestMycSemaphore = class(TObject)
-  public
-    [Setup]
-    procedure Setup;
-    [TearDown]
-    procedure TearDown;
-
-    // --- Category 1: Basic Counter and State Functionality (Parameterized) ---
-    [TestCase('InitialPositive', '1,False')]
-    [TestCase('InitialZero', '0,True')]
-    [TestCase('InitialNegative', '-1,True')]
-    [TestCase('InitialLargePositive', '5,False')]
-    procedure TestCreate_InitialState(InitialCount: Integer; ExpectedIsSet: Boolean);
-
-    [TestCase('DecrementPositiveToZero', '1,False,True')]
-    [TestCase('DecrementPositiveToPositive', '2,True,False')]
-    [TestCase('DecrementZeroToNegative', '0,False,True')]
-    [TestCase('DecrementNegativeToNegative', '-1,False,True')]
-    procedure TestNotify_ReturnValueAndState_AfterOneNotify(InitialCount: Integer; ExpectedReturn: Boolean; ExpectedIsSet: Boolean);
-
-    [Test]
-    procedure TestNotify_DecrementsCounter_StateChanges;
-    [Test]
-    procedure TestNotify_MultipleNotifies_CounterBecomesNegativeAndStaysSet;
-
-    // --- Category 2: Notification to Subscribers ---
-    [Test]
-    procedure TestSubscriber_Single_IsNotifiedWhenSet;
-    [Test]
-    procedure TestSubscriber_Multiple_AreNotifiedWhenSet;
-    [Test]
-    procedure TestSubscriber_NotNotified_BeforeSet;
-    [Test]
-    procedure TestSubscriber_NotifiedOnlyOnce_AfterFinalization;
-    [Test]
-    procedure TestSubscribe_AfterFinalization_SubscriberNotNotified;
-
-    // --- Category 3: Chaining and Cascading ---
-    [Test]
-    procedure TestChaining_A_Notifies_B;
-    [Test]
-    procedure TestCascade_A_Notifies_B_Notifies_C;
-    [Test]
-    procedure TestChaining_B_NeedsMultipleSignalsFromA_WithSubscriberOnB;
-
-    // --- Category 4: Special Cases ---
-    [Test]
-    procedure TestInitiallySet_NotifiesNewSubscriberImmediately;
-
-    [Test]
-    procedure TestUnsubscribe_SubscriberNotNotified;
-
-    // --- Category 5: Signal Loss / Counter Integrity ---
-    [Test]
-    procedure TestMultipleTriggersNoSubscriber_StateCorrectForLaterSubscriber;
-  end;
-
-implementation
-
-{ TMockSubscriber }
-
-constructor TMockSubscriber.Create(ShouldReturn: Boolean = True);
-begin
-  inherited Create;
-  NotifyCount := 0;
-  NotifyShouldReturn := ShouldReturn;
-  WasCalled := False;
-end;
-
-function TMockSubscriber.Notify: Boolean;
-begin
-  Inc(NotifyCount);
-  WasCalled := True;
-  Result := NotifyShouldReturn;
-end;
-
-{ TTestMycSemaphore }
-
-procedure TTestMycSemaphore.Setup;
-begin
-  // Per-test setup code can go here (if any).
-end;
-
-procedure TTestMycSemaphore.TearDown;
-begin
-  // Per-test teardown code can go here (if any).
-end;
-
-procedure TTestMycSemaphore.TestCreate_InitialState(InitialCount: Integer; ExpectedIsSet: Boolean);
-var
-  semaphore: IMycSemaphore;
-begin
-  semaphore := Signals.CreateSemaphore(InitialCount);
-  Assert.AreEqual(ExpectedIsSet, semaphore.State.IsSet, 'Semaphore initial IsSet state mismatch.');
-end;
-
-procedure TTestMycSemaphore.TestNotify_ReturnValueAndState_AfterOneNotify(InitialCount: Integer; ExpectedReturn: Boolean; ExpectedIsSet: Boolean);
-var
-  semaphore: IMycSemaphore;
-  returnedValue: Boolean;
-begin
-  semaphore := Signals.CreateSemaphore(InitialCount);
-  returnedValue := semaphore.Notify;
-
-  Assert.AreEqual(ExpectedReturn, returnedValue, 'Unexpected return value after one Notify call.');
-  Assert.AreEqual(ExpectedIsSet, semaphore.State.IsSet, 'Unexpected IsSet state after one Notify call.');
-end;
-
-procedure TTestMycSemaphore.TestNotify_DecrementsCounter_StateChanges;
-var
-  semaphore: IMycSemaphore;
-begin
-  semaphore := Signals.CreateSemaphore(1);
-  Assert.IsFalse(semaphore.State.IsSet, 'Semaphore should initially not be set.');
-  semaphore.Notify;
-  Assert.IsTrue(semaphore.State.IsSet, 'Semaphore should be set after Notify.');
-end;
-
-procedure TTestMycSemaphore.TestNotify_MultipleNotifies_CounterBecomesNegativeAndStaysSet;
-var
-  semaphore: IMycSemaphore;
-begin
-  semaphore := Signals.CreateSemaphore(1);
-  semaphore.Notify;
-  Assert.IsTrue(semaphore.State.IsSet, 'Semaphore should be set after first Notify.');
-  semaphore.Notify;
-  Assert.IsTrue(semaphore.State.IsSet, 'Semaphore should remain set after second Notify.');
-end;
-
-procedure TTestMycSemaphore.TestSubscriber_Single_IsNotifiedWhenSet;
-var
-  semaphore: IMycSemaphore;
-  mockSub: TMockSubscriber;
-  subscription: TMycSubscription;
-begin
-  semaphore := Signals.CreateSemaphore(1);
-  mockSub := TMockSubscriber.Create;
-  subscription := semaphore.State.Subscribe(mockSub);
-
-  Assert.IsFalse(semaphore.State.IsSet, 'Semaphore should initially not be set.');
-  Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should not have been notified yet (before set).');
-
-  semaphore.Notify;
-
-  Assert.IsTrue(semaphore.State.IsSet, 'Semaphore should be set after its Notify is called.');
-  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub should have been notified once when semaphore becomes set.');
-end;
-
-procedure TTestMycSemaphore.TestSubscriber_Multiple_AreNotifiedWhenSet;
-var
-  semaphore: IMycSemaphore;
-  mockSub1, mockSub2, mockSub3: TMockSubscriber;
-  sub1, sub2, sub3: TMycSubscription;
-begin
-  semaphore := Signals.CreateSemaphore(1);
-  mockSub1 := TMockSubscriber.Create;
-  mockSub2 := TMockSubscriber.Create;
-  mockSub3 := TMockSubscriber.Create;
-
-  sub1 := semaphore.State.Subscribe(mockSub1);
-  sub2 := semaphore.State.Subscribe(mockSub2);
-  sub3 := semaphore.State.Subscribe(mockSub3);
-
-  semaphore.Notify;
-
-  Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 notification count mismatch.');
-  Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 notification count mismatch.');
-  Assert.AreEqual(1, mockSub3.NotifyCount, 'MockSub3 notification count mismatch.');
-end;
-
-procedure TTestMycSemaphore.TestSubscriber_NotNotified_BeforeSet;
-var
-  semaphore: IMycSemaphore;
-  mockSub: TMockSubscriber;
-  subscription: TMycSubscription;
-begin
-  semaphore := Signals.CreateSemaphore(2);
-  mockSub := TMockSubscriber.Create;
-  subscription := semaphore.State.Subscribe(mockSub);
-
-  Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should not be notified upon subscription if semaphore is not set.');
-  semaphore.Notify; // Count becomes 1, still not set for subscriber notification (unless Subscribe was changed to notify if count becomes 0 internally).
-  Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should still not be notified as semaphore is not yet set for subscribers.');
-end;
-
-procedure TTestMycSemaphore.TestSubscriber_NotifiedOnlyOnce_AfterFinalization;
-var
-  semaphore: IMycSemaphore;
-  mockSub: TMockSubscriber;
-  subscription: TMycSubscription;
-begin
-  semaphore := Signals.CreateSemaphore(1);
-  mockSub := TMockSubscriber.Create;
-  subscription := semaphore.State.Subscribe(mockSub);
-
-  semaphore.Notify; // Sets semaphore, notifies MockSub. Assumed TMycSignal's list is finalized by this action.
-  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub notify count should be 1 after first signal set.');
-
-  semaphore.Notify; // Trigger again.
-  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub notify count should remain 1 after re-triggering finalized signal.');
-end;
-
-procedure TTestMycSemaphore.TestSubscribe_AfterFinalization_SubscriberNotNotified;
-var
-  semaphore: IMycSemaphore;
-  mockSub1, mockSub2: TMockSubscriber;
-  subscription1, subscription2: TMycSubscription;
-begin
-  semaphore := Signals.CreateSemaphore(1);
-
-  mockSub1 := TMockSubscriber.Create;
-  subscription1 := semaphore.State.Subscribe(mockSub1);
-
-  semaphore.Notify; // Triggers semaphore. It becomes set.
-                    // Its TMycSignal part notifies mockSub1.
-                    // And its TMycSignal part is assumed to be finalized.
-
-  Assert.IsTrue(semaphore.State.IsSet, 'Semaphore should be set after initial trigger.');
-  Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 should have been notified once.');
-
-  // Attempt to subscribe mockSub2 after the signal (TMycSignal part) has been finalized.
-  mockSub2 := TMockSubscriber.Create;
-  subscription2 := semaphore.State.Subscribe(mockSub2);
-
-  // Current assertion in user-provided code expects mockSub2 to be notified.
-  // This implies that Myc.Signals.Subscribe has specific logic to achieve this,
-  // even if the underlying TMycNotifyList might have been finalized for mockSub1's notification.
-  Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 should be notified upon subscribing to an already set signal.');
-
-  semaphore.Notify; // Re-triggering the semaphore's count decrement.
-  Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 notify count should remain 1 (not notified again).');
-  // Current assertion in user-provided code expects mockSub2's count to also remain 1.
-  Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 notify count should remain 1 after re-triggering.');
-end;
-
-procedure TTestMycSemaphore.TestChaining_A_Notifies_B;
-var
-  semaA, semaB: IMycSemaphore;
-  mockSubForB: TMockSubscriber;
-  subHandle_B_listens_A, subHandle_Mock_listens_B: TMycSubscription;
-begin
-  semaA := Signals.CreateSemaphore(1);
-  semaB := Signals.CreateSemaphore(1);
-  mockSubForB := TMockSubscriber.Create;
-
-  subHandle_Mock_listens_B := semaB.State.Subscribe(mockSubForB);
-  subHandle_B_listens_A := semaA.State.Subscribe(semaB);
-
-  Assert.IsFalse(semaA.State.IsSet, 'SemaA initially not set.');
-  Assert.IsFalse(semaB.State.IsSet, 'SemaB initially not set.');
-  Assert.AreEqual(0, mockSubForB.NotifyCount, 'MockSubForB initially not notified.');
-
-  semaA.Notify;
-
-  Assert.IsTrue(semaA.State.IsSet, 'SemaA should be set after notify.');
-  Assert.IsTrue(semaB.State.IsSet, 'SemaB should be set after being notified by SemaA.');
-  Assert.AreEqual(1, mockSubForB.NotifyCount, 'MockSubForB should have been notified by SemaB.');
-end;
-
-procedure TTestMycSemaphore.TestCascade_A_Notifies_B_Notifies_C;
-var
-  semaA, semaB, semaC: IMycSemaphore;
-  mockSubForC: TMockSubscriber;
-  sub_Mock_C, sub_C_B, sub_B_A: TMycSubscription;
-begin
-  semaA := Signals.CreateSemaphore(1);
-  semaB := Signals.CreateSemaphore(1);
-  semaC := Signals.CreateSemaphore(1);
-  mockSubForC := TMockSubscriber.Create;
-
-  sub_Mock_C := semaC.State.Subscribe(mockSubForC);
-  sub_C_B    := semaB.State.Subscribe(semaC);
-  sub_B_A    := semaA.State.Subscribe(semaB);
-
-  semaA.Notify;
-
-  Assert.IsTrue(semaA.State.IsSet, 'SemaA state mismatch in cascade.');
-  Assert.IsTrue(semaB.State.IsSet, 'SemaB state mismatch in cascade.');
-  Assert.IsTrue(semaC.State.IsSet, 'SemaC state mismatch in cascade.');
-  Assert.AreEqual(1, mockSubForC.NotifyCount, 'MockSubForC notification count mismatch in cascade.');
-end;
-
-procedure TTestMycSemaphore.TestChaining_B_NeedsMultipleSignalsFromA_WithSubscriberOnB;
-var
-  semaA, semaB: IMycSemaphore;
-  mockSubForB: TMockSubscriber;
-  sub_Mock_B, sub_B_A: TMycSubscription;
-begin
-  semaA := Signals.CreateSemaphore(2);
-  semaB := Signals.CreateSemaphore(1);
-  mockSubForB := TMockSubscriber.Create;
-
-  sub_Mock_B := semaB.State.Subscribe(mockSubForB);
-  sub_B_A    := semaA.State.Subscribe(semaB);
-
-  semaA.Notify; // First trigger for SemaA
-  Assert.IsFalse(semaA.State.IsSet, 'SemaA should not be set after first trigger of two.');
-  Assert.IsFalse(semaB.State.IsSet, 'SemaB should not have been triggered yet by SemaA.');
-  Assert.AreEqual(0, mockSubForB.NotifyCount, 'MockSubForB should not have been notified yet.');
-
-  semaA.Notify; // Second trigger for SemaA
-  Assert.IsTrue(semaA.State.IsSet, 'SemaA should be set after second trigger.');
-  Assert.IsTrue(semaB.State.IsSet, 'SemaB should now be set by SemaA.');
-  Assert.AreEqual(1, mockSubForB.NotifyCount, 'MockSubForB should have been notified by SemaB.');
-end;
-
-procedure TTestMycSemaphore.TestInitiallySet_NotifiesNewSubscriberImmediately;
-var
-  semaphore: IMycSemaphore;
-  mockSub: TMockSubscriber;
-  subscription: TMycSubscription;
-begin
-  semaphore := Signals.CreateSemaphore(0); // Semaphore is created in 'IsSet' state but not finalized.
-  mockSub := TMockSubscriber.Create;
-
-  // Assumes TMycSignal.Subscribe is modified to implement immediate notification for set signals.
-  subscription := semaphore.State.Subscribe(mockSub);
-
-  Assert.IsTrue(semaphore.State.IsSet, 'Semaphore IsSet property mismatch after creation with count 0.');
-  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub should be notified immediately upon subscribing to an already set semaphore.');
-end;
-
-procedure TTestMycSemaphore.TestUnsubscribe_SubscriberNotNotified;
-var
-  semaphore: IMycSemaphore;
-  mockSub: TMockSubscriber;
-  subscription: TMycSubscription;
-begin
-  semaphore := Signals.CreateSemaphore(1);
-  mockSub := TMockSubscriber.Create;
-
-  subscription := semaphore.State.Subscribe(mockSub);
-  subscription := Default(TMycSubscription); // Simulates leaving scope / destruction, calls Finalize for unsubscription.
-
-  semaphore.Notify;
-
-  Assert.AreEqual(0, mockSub.NotifyCount, 'Unsubscribed MockSub should not be notified.');
-end;
-
-procedure TTestMycSemaphore.TestMultipleTriggersNoSubscriber_StateCorrectForLaterSubscriber;
-var
-  semaphore: IMycSemaphore;
-  mockSub: TMockSubscriber;
-  subscription: TMycSubscription;
-begin
-  semaphore := Signals.CreateSemaphore(3);
-
-  semaphore.Notify; // Count -> 2
-  semaphore.Notify; // Count -> 1
-  Assert.IsFalse(semaphore.State.IsSet, 'Semaphore should not be set yet after partial triggers.');
-
-  mockSub := TMockSubscriber.Create;
-  subscription := semaphore.State.Subscribe(mockSub);
-  // Assumes TMycSignal.Subscribe does not notify immediately if signal is not yet set.
-  Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should not be notified on subscribe if semaphore not yet set.');
-
-
-  semaphore.Notify; // Count -> 0, Semaphore becomes set and notifies mockSub
-  Assert.IsTrue(semaphore.State.IsSet, 'Semaphore should now be set.');
-  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub should have been notified when semaphore becomes set.');
-end;
-
-initialization
-  // Optional: Register test cases if not using automatic registration.
-  // TDUnitX.RegisterTestFixture(TTestMycSemaphore);
-end.

Test/TestTasks.pas

@@ -8,15 +8,15 @@ uses
     System.Classes,
     System.SyncObjs,
     Myc.Core.Tasks,
-    Myc.Signals, // For IMycSemaphore, Signals global
-    Myc.Core.Atomic; // If any atomic primitives are directly needed for test setup/assertion
+    Myc.Signals, // Uses TMycLatch.CreateLatch and TMycLatch.Null
+    Myc.Core.Atomic;
 
 type
     [TestFixture]
     TMycTaskFactoryTests = class(TObject)
     private
         FFactory: IMycTaskFactory;
-        procedure TestProcExecute(var executed: Boolean; signal: IMycSemaphore);
+        procedure TestProcExecute(var executed: Boolean; signal: IMycLatch); // Parameter type is IMycLatch
     public
         [Setup]
         procedure Setup;
@@ -51,19 +51,19 @@ implementation
 
 procedure TMycTaskFactoryTests.Setup;
 begin
-    FFactory := TMycTaskFactory.Create; // Creates the factory instance
+    FFactory := TMycTaskFactory.Create;
 end;
 
 procedure TMycTaskFactoryTests.TearDown;
 begin
     if Assigned(FFactory) then
     begin
-        FFactory.Teardown; // Explicitly teardown
+        FFactory.Teardown;
         FFactory := nil;
     end;
 end;
 
-procedure TMycTaskFactoryTests.TestProcExecute(var executed: Boolean; signal: IMycSemaphore);
+procedure TMycTaskFactoryTests.TestProcExecute(var executed: Boolean; signal: IMycLatch);
 begin
     executed := True;
     if Assigned(signal) then
@@ -77,7 +77,6 @@ begin
     Assert.IsNotNull(FFactory, 'Factory should be created');
     threadCount := FFactory.ThreadCount;
     Assert.AreEqual(TThread.ProcessorCount, threadCount, 'Thread count should match processor count');
-    // Teardown is implicitly tested by the [TearDown] method
 end;
 
 procedure TMycTaskFactoryTests.TestCreateThreadExecutesAndSignals;
@@ -87,102 +86,97 @@ var
     procWrapper: TProc;
 begin
     executed := False;
-    // Wrap the procedure to match TProc signature if TestProcExecute is used,
-    // or define an anonymous procedure directly.
     procWrapper := procedure
     begin
         executed := True;
     end;
 
-    threadState := FFactory.CreateThread(procWrapper);
+    threadState := FFactory.CreateThread(procWrapper); // CreateThread in TaskFactory now uses TMycLatch.CreateLatch
     Assert.IsNotNull(threadState, 'CreateThread should return a valid state object');
 
-    FFactory.WaitFor(threadState); // Wait for the thread to complete
+    FFactory.WaitFor(threadState);
     Assert.IsTrue(executed, 'Procedure in created thread should have executed');
 end;
 
 procedure TMycTaskFactoryTests.TestRunImmediateJob;
 var
     jobExecuted: Boolean;
-    jobCompletedSignal: IMycSemaphore;
+    jobCompletedLatch: IMycLatch;
 begin
     jobExecuted := False;
-    jobCompletedSignal := Signals.CreateSemaphore(1); // Semaphore to signal job completion
+    jobCompletedLatch := TMycLatch.CreateLatch(1); // Changed from Signals.CreateLatch
 
-    FFactory.Run(0, // StartCount = 0 for immediate execution
+    FFactory.Run(0,
         procedure
         begin
             jobExecuted := True;
-            jobCompletedSignal.Notify; // Signal completion
+            jobCompletedLatch.Notify;
         end);
 
-    FFactory.WaitFor(jobCompletedSignal.State); // Wait for the job to complete
+    FFactory.WaitFor(jobCompletedLatch.State);
     Assert.IsTrue(jobExecuted, 'Immediate job should have executed');
 end;
 
 procedure TMycTaskFactoryTests.TestRunDelayedJobExecutesAfterAllNotifies;
 var
     jobExecuted: Boolean;
-    jobCompletedSignal: IMycSemaphore;
+    jobCompletedLatch: IMycLatch;
     subscriber: IMycSubscriber;
     startCount: Integer;
 begin
     jobExecuted := False;
     startCount := 2;
-    jobCompletedSignal := Signals.CreateSemaphore(1);
+    jobCompletedLatch := TMycLatch.CreateLatch(1); // Changed from Signals.CreateLatch
 
     subscriber := FFactory.Run(startCount,
         procedure
         begin
             jobExecuted := True;
-            jobCompletedSignal.Notify;
+            jobCompletedLatch.Notify;
         end);
 
     Assert.IsNotNull(subscriber, 'Run should return a subscriber for delayed job');
-    // Corrected line:
-    Assert.AreNotEqual<IMycSubscriber>(Signals.Null, subscriber, 'Subscriber should not be Signals.Null for StartCount > 0');
+    // Use TMycLatch.Null for comparison
+    Assert.AreNotEqual<IMycSubscriber>(TMycLatch.Null, subscriber, 'Subscriber should not be TMycLatch.Null for StartCount > 0');
 
-    subscriber.Notify; // First notification
-    subscriber.Notify; // Second notification, job should now be enqueued
+    subscriber.Notify;
+    subscriber.Notify;
 
-    FFactory.WaitFor(jobCompletedSignal.State); // Wait for job completion
+    FFactory.WaitFor(jobCompletedLatch.State);
     Assert.IsTrue(jobExecuted, 'Delayed job should execute after all notifications');
 end;
 
 procedure TMycTaskFactoryTests.TestRunDelayedJobDoesNotExecutePrematurely;
 var
     jobExecuted: Boolean;
-    jobCompletedSignal: IMycSemaphore; // Not strictly needed here as job shouldn't run
+    jobCompletedLatch: IMycLatch;
     subscriber: IMycSubscriber;
     startCount: Integer;
-    dummyWaitSignal: IMycSemaphore;
+    dummyWaitLatch: IMycLatch;
 begin
     jobExecuted := False;
     startCount := 3;
-    jobCompletedSignal := Signals.CreateSemaphore(1); // For the job, if it were to run
-    dummyWaitSignal := Signals.CreateSemaphore(1);
+    jobCompletedLatch := TMycLatch.CreateLatch(1); // Changed from Signals.CreateLatch
+    dummyWaitLatch := TMycLatch.CreateLatch(1);    // Changed from Signals.CreateLatch
 
 
     subscriber := FFactory.Run(startCount,
         procedure
         begin
             jobExecuted := True;
-            jobCompletedSignal.Notify;
+            jobCompletedLatch.Notify;
         end);
 
     Assert.IsNotNull(subscriber, 'Run should return a subscriber for delayed job_P2');
 
-    subscriber.Notify; // First notification
+    subscriber.Notify;
     Assert.IsFalse(jobExecuted, 'Job should not execute after one notification_P2');
 
-    subscriber.Notify; // Second notification
+    subscriber.Notify;
     Assert.IsFalse(jobExecuted, 'Job should not execute after two notifications_P2');
 
-    // To give a very brief moment for any potential async execution attempt.
-    // This is not foolproof for catching race conditions but can help.
-    // A more robust way is harder without specific test hooks in the factory.
-    FFactory.Run(0, procedure begin dummyWaitSignal.Notify; end);
-    FFactory.WaitFor(dummyWaitSignal.State); // Ensures task queue is processed slightly
+    FFactory.Run(0, procedure begin dummyWaitLatch.Notify; end);
+    FFactory.WaitFor(dummyWaitLatch.State);
 
     Assert.IsFalse(jobExecuted, 'Job should still not have executed before third notify_P2');
 end;
@@ -190,18 +184,17 @@ end;
 
 procedure TMycTaskFactoryTests.TestWaitForAlreadySetState;
 var
-    alreadySetSignal: IMycSemaphore;
+    alreadySetLatch: IMycLatch;
     startTime, endTime: Cardinal;
 begin
-    alreadySetSignal := Signals.CreateSemaphore(0); // Count = 0 means it's already set
-    Assert.IsTrue(alreadySetSignal.State.IsSet, 'Signal should be initially set');
+    // TMycLatch.CreateLatch(0) will return TMycLatch.Null
+    alreadySetLatch := TMycLatch.CreateLatch(0); // Changed from Signals.CreateLatch
+    Assert.IsTrue(alreadySetLatch.State.IsSet, 'Latch should be initially set');
 
     startTime := TThread.GetTickCount;
-    FFactory.WaitFor(alreadySetSignal.State); // Should return immediately
+    FFactory.WaitFor(alreadySetLatch.State);
     endTime := TThread.GetTickCount;
 
-    // Check that WaitFor didn't block for a significant time
-    // Allow a small delta for processing, e.g., less than 50ms
     Assert.IsTrue((endTime - startTime) < 50, 'WaitFor on an already set state should not block significantly');
 end;
 
@@ -209,11 +202,11 @@ procedure TMycTaskFactoryTests.TestThreadInfoMethods;
 var
     inMainThreadInJob: Boolean;
     inWorkerThreadInJob: Boolean;
-    jobDoneSignal: IMycSemaphore;
+    jobDoneLatch: IMycLatch;
 begin
-    inMainThreadInJob := True;   // Default to a state that would fail the assert
-    inWorkerThreadInJob := False; // Default to a state that would fail the assert
-    jobDoneSignal := Signals.CreateSemaphore(1);
+    inMainThreadInJob := True;
+    inWorkerThreadInJob := False;
+    jobDoneLatch := TMycLatch.CreateLatch(1); // Changed from Signals.CreateLatch
 
     Assert.IsTrue(FFactory.InMainThread, 'Test method itself should be in main thread');
     Assert.IsFalse(FFactory.InWorkerThread, 'Test method itself should not be in a factory worker thread');
@@ -223,10 +216,10 @@ begin
         begin
             inMainThreadInJob := FFactory.InMainThread;
             inWorkerThreadInJob := FFactory.InWorkerThread;
-            jobDoneSignal.Notify;
+            jobDoneLatch.Notify;
         end);
 
-    FFactory.WaitFor(jobDoneSignal.State); // Wait for the job to complete and set flags
+    FFactory.WaitFor(jobDoneLatch.State);
 
     Assert.IsFalse(inMainThreadInJob, 'Job executed by factory should not be in main thread');
     Assert.IsTrue(inWorkerThreadInJob, 'Job executed by factory should be in a worker thread');
@@ -234,39 +227,35 @@ end;
 
 procedure TMycTaskFactoryTests.TestExceptionPropagationFromJob;
 var
-    jobDoneSignal: IMycSemaphore; // To ensure job has a chance to run
+    jobDoneLatch: IMycLatch;
 begin
-    jobDoneSignal := Signals.CreateSemaphore(1);
+    jobDoneLatch := TMycLatch.CreateLatch(1); // Changed from Signals.CreateLatch
 
     FFactory.Run(0,
         procedure
         var
-          dummy: Integer; // To avoid hint W1035 if no other code is in the proc
+          dummy: Integer;
         begin
-            dummy := 0; // Assign to avoid compiler warning if variable is unused
-            // Raise the specific nested exception type
+            dummy := 0;
             raise TMycTaskFactory.ETaskException.Create('Test Exception From Job');
-            // jobDoneSignal.Notify; // This line will not be reached
+            // jobDoneLatch.Notify; // This line will not be reached
         end);
 
-    // Give a brief moment for the job to be scheduled and potentially raise the exception.
-    // Run another dummy job to help process the queue and ensure the exception is set.
-    FFactory.Run(0, procedure begin jobDoneSignal.Notify; end);
-    FFactory.WaitFor(jobDoneSignal.State);
+    FFactory.Run(0, procedure begin jobDoneLatch.Notify; end);
+    FFactory.WaitFor(jobDoneLatch.State);
 
     Assert.WillRaise(
         procedure
         begin
-            (FFactory as TMycTaskFactory).HandleException; // This should re-raise the exception
+            (FFactory as TMycTaskFactory).HandleException;
         end,
-        TMycTaskFactory.ETaskException, // Correctly qualified exception type
+        TMycTaskFactory.ETaskException,
         'HandleException should re-raise the exception from the job'
     );
 
-    // Verify FException is cleared after being handled
     var noExceptionRaised: Boolean := True;
     try
-        (FFactory as TMycTaskFactory).HandleException; // Should not raise anything now
+        (FFactory as TMycTaskFactory).HandleException;
     except
         noExceptionRaised := False;
     end;
@@ -275,14 +264,14 @@ end;
 
 procedure TMycTaskFactoryTests.TestRunJobAfterFactoryTeardown;
 begin
-    FFactory.Teardown; // Explicitly teardown the factory
+    FFactory.Teardown;
 
     Assert.WillRaise(
         procedure
         begin
-            FFactory.Run(0, procedure begin end); // Attempt to run a job
+            FFactory.Run(0, procedure begin end);
         end,
-        TMycTaskFactory.ETaskException, // Expecting the factory's specific exception type
+        TMycTaskFactory.ETaskException,
         'Running a job on a torn-down factory should raise ETaskException'
     );
 end;
@@ -290,34 +279,31 @@ end;
 procedure TMycTaskFactoryTests.TestWaitForInWorkerThreadRaisesException;
 var
     exceptionCaughtInJob: Boolean;
-    jobDoneSignal: IMycSemaphore;
+    jobDoneLatch: IMycLatch;
     dummyStateToWaitFor: IMycState;
 begin
     exceptionCaughtInJob := False;
-    jobDoneSignal := Signals.CreateSemaphore(1);
-    dummyStateToWaitFor := Signals.CreateSemaphore(1).State; // A state that will never be set by this test logic
+    jobDoneLatch := TMycLatch.CreateLatch(1); // Changed from Signals.CreateLatch
+    dummyStateToWaitFor := TMycLatch.CreateLatch(1).State; // Changed from Signals.CreateLatch
 
     FFactory.Run(0,
         procedure
         begin
             try
-                FFactory.WaitFor(dummyStateToWaitFor); // This should raise ETaskException
+                FFactory.WaitFor(dummyStateToWaitFor);
             except
                 on E: TMycTaskFactory.ETaskException do
                 begin
-                    // Check message if needed: Assert.AreEqual('Waiting not allowed within tasks', E.Message);
                     exceptionCaughtInJob := True;
                 end;
-                // Else: Unexpected exception, test will fail by jobDoneSignal not being set or flag remaining false
             end;
-            jobDoneSignal.Notify; // Signal completion of the job's execution path
+            jobDoneLatch.Notify;
         end);
 
-    FFactory.WaitFor(jobDoneSignal.State); // Wait for the job to finish
+    FFactory.WaitFor(jobDoneLatch.State);
     Assert.IsTrue(exceptionCaughtInJob, 'WaitFor called within a worker thread job should raise ETaskException');
 end;
 
 initialization
-    // Register TestFixtures
     TDUnitX.RegisterTestFixture(TMycTaskFactoryTests);
 end.