Michael Schimmel
440 lines
16 KiB
ObjectPascal
440 lines
16 KiB
ObjectPascal
unit TestNotifier_ChaosStress;
|
|
|
|
interface
|
|
|
|
uses
|
|
System.SysUtils,
|
|
System.Classes, // For TThread
|
|
System.SyncObjs, // For TInterlocked, TCriticalSection (needed by implementation)
|
|
System.Generics.Collections, // For TList<T>
|
|
System.Diagnostics, // For TStopwatch
|
|
DUnitX.TestFramework,
|
|
Myc.Core.Notifier; // Your unit
|
|
|
|
type
|
|
IMyStressTestInterface = interface(IInterface)
|
|
['{B8A3F7E1-47D9-4A9C-8C2B-035A1B568E7F}']
|
|
procedure Foo(NotificationType: Integer); // NotificationType for more detailed testing
|
|
function GetValue: Integer;
|
|
function GetNotificationCount: Integer;
|
|
function GetInstanceID: Integer;
|
|
function GetExpectedToBeAdvised: Boolean;
|
|
procedure SetExpectedToBeAdvised(const Value: Boolean);
|
|
property ExpectedToBeAdvised: Boolean read GetExpectedToBeAdvised write SetExpectedToBeAdvised;
|
|
end;
|
|
|
|
TMyStressReceiver = class(TInterfacedObject, IMyStressTestInterface)
|
|
private
|
|
FInstanceID: Integer;
|
|
FValue: Integer;
|
|
FNotificationCount: Integer;
|
|
FExpectedToBeAdvised: Boolean;
|
|
function GetExpectedToBeAdvised: Boolean;
|
|
procedure SetExpectedToBeAdvised(const Value: Boolean);
|
|
public
|
|
// For testing: flag to indicate if the thread that created this believes it's still advised
|
|
constructor Create(AInstanceID, AValue: Integer);
|
|
procedure Foo(NotificationType: Integer);
|
|
function GetValue: Integer;
|
|
function GetNotificationCount: Integer;
|
|
function GetInstanceID: Integer;
|
|
property ExpectedToBeAdvised: Boolean read GetExpectedToBeAdvised write SetExpectedToBeAdvised;
|
|
end;
|
|
|
|
// Record type to store an advised receiver and its tag
|
|
TAdvisedReceiverInfo = record
|
|
Tag: TMycNotifyList<IMyStressTestInterface>.TTag;
|
|
Receiver: IMyStressTestInterface;
|
|
end;
|
|
|
|
TMycNotifierChaosStressTests = class; // Forward declaration
|
|
|
|
TStressWorkerThread = class(TThread)
|
|
private
|
|
FOwnerFixture: TMycNotifierChaosStressTests;
|
|
FThreadID: Integer;
|
|
FIterations: Integer;
|
|
FError: Exception;
|
|
// List of receivers this thread has successfully advised and believes are still active
|
|
FMyAdvisedReceivers: TList<TAdvisedReceiverInfo>;
|
|
protected
|
|
procedure Execute; override;
|
|
public
|
|
constructor Create(AOwnerFixture: TMycNotifierChaosStressTests; AThreadID, AIterations: Integer);
|
|
destructor Destroy; override;
|
|
property Error: Exception read FError;
|
|
function GetAdvisedReceiverCountByThread: Integer;
|
|
// procedure GetMyExpectedLiveReceivers(AList: TList<TMyStressReceiver>); // Not strictly needed with current verification
|
|
end;
|
|
|
|
[TestFixture]
|
|
TMycNotifierChaosStressTests = class(TObject)
|
|
public
|
|
FNotifier: TMycNotifyList<IMyStressTestInterface>;
|
|
// List of all receivers ever created in this test run, for final verification
|
|
FAllReceiversCreated: TList<IMyStressTestInterface>;
|
|
FCriticalSectionForList: TCriticalSection; // To protect FAllReceiversCreated
|
|
FNextReceiverInstanceID: Integer; // Atomically incremented ID for receivers
|
|
|
|
[Setup]
|
|
procedure Setup;
|
|
[TearDown]
|
|
procedure TearDown;
|
|
|
|
[Test]
|
|
procedure Test_MixedOperations_Stress;
|
|
end;
|
|
|
|
implementation
|
|
|
|
// uses System.StrUtils; // Not needed anymore if IfThen is not used
|
|
|
|
{ TMyStressReceiver }
|
|
constructor TMyStressReceiver.Create(AInstanceID, AValue: Integer);
|
|
begin
|
|
inherited Create;
|
|
FInstanceID := AInstanceID;
|
|
FValue := AValue;
|
|
FNotificationCount := 0;
|
|
FExpectedToBeAdvised := False; // Initially not advised or expecting to be
|
|
end;
|
|
|
|
procedure TMyStressReceiver.Foo(NotificationType: Integer);
|
|
begin
|
|
TInterlocked.Increment(FNotificationCount); // Atomic increment
|
|
end;
|
|
|
|
function TMyStressReceiver.GetExpectedToBeAdvised: Boolean;
|
|
begin
|
|
Result := FExpectedToBeAdvised;
|
|
end;
|
|
|
|
function TMyStressReceiver.GetValue: Integer;
|
|
begin
|
|
Result := FValue;
|
|
end;
|
|
|
|
function TMyStressReceiver.GetNotificationCount: Integer;
|
|
begin
|
|
// Atomic read, ensuring visibility of changes from other threads if FNotificationCount was public
|
|
// For private field accessed by owner, direct read is fine if Notify is serialized.
|
|
// TInterlocked.Add(var Target, Value) returns Target+Value. For read: Target+0.
|
|
Result := TInterlocked.Add(FNotificationCount, 0);
|
|
end;
|
|
|
|
function TMyStressReceiver.GetInstanceID: Integer;
|
|
begin
|
|
Result := FInstanceID;
|
|
end;
|
|
|
|
procedure TMyStressReceiver.SetExpectedToBeAdvised(const Value: Boolean);
|
|
begin
|
|
FExpectedToBeAdvised := Value;
|
|
end;
|
|
|
|
{ TStressWorkerThread }
|
|
constructor TStressWorkerThread.Create(AOwnerFixture: TMycNotifierChaosStressTests; AThreadID, AIterations: Integer);
|
|
begin
|
|
inherited Create(True); // Creates the thread in a suspended state
|
|
FreeOnTerminate := False; // The test fixture will free the thread
|
|
FOwnerFixture := AOwnerFixture;
|
|
FThreadID := AThreadID;
|
|
FIterations := AIterations;
|
|
FError := nil;
|
|
FMyAdvisedReceivers := TList<TAdvisedReceiverInfo>.Create;
|
|
end;
|
|
|
|
destructor TStressWorkerThread.Destroy;
|
|
begin
|
|
FMyAdvisedReceivers.Free;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TStressWorkerThread.Execute;
|
|
var
|
|
i, op: Integer;
|
|
newReceiver: TMyStressReceiver;
|
|
tag: TMycNotifyList<IMyStressTestInterface>.TTag;
|
|
itemIndex: Integer;
|
|
advisedItemRec: TAdvisedReceiverInfo;
|
|
localInstanceID: Integer;
|
|
begin
|
|
inherited; // Important for TThread
|
|
try
|
|
for i := 1 to FIterations do
|
|
begin
|
|
if Terminated then
|
|
Break; // Respond to termination request
|
|
|
|
op := Random(100);
|
|
|
|
if op < 35 then // 35% chance to Advise
|
|
begin
|
|
localInstanceID := TInterlocked.Increment(FOwnerFixture.FNextReceiverInstanceID);
|
|
newReceiver := TMyStressReceiver.Create(localInstanceID, FThreadID * 10000 + i);
|
|
// newReceiver.ExpectedToBeAdvised is False by default, will be set to True by this thread upon successful advise.
|
|
|
|
FOwnerFixture.FCriticalSectionForList.Enter;
|
|
try
|
|
FOwnerFixture.FAllReceiversCreated.Add(newReceiver);
|
|
finally
|
|
FOwnerFixture.FCriticalSectionForList.Leave;
|
|
end;
|
|
|
|
FOwnerFixture.FNotifier.Lock;
|
|
try
|
|
tag := FOwnerFixture.FNotifier.Advise(newReceiver);
|
|
advisedItemRec.Tag := tag;
|
|
advisedItemRec.Receiver := newReceiver;
|
|
FMyAdvisedReceivers.Add(advisedItemRec);
|
|
newReceiver.ExpectedToBeAdvised := True; // This thread now expects it to be advised
|
|
finally
|
|
FOwnerFixture.FNotifier.Release;
|
|
end;
|
|
end
|
|
else if (op < 70) and (FMyAdvisedReceivers.Count > 0) then // 35% chance to Unadvise (if possible)
|
|
begin
|
|
itemIndex := Random(FMyAdvisedReceivers.Count);
|
|
advisedItemRec := FMyAdvisedReceivers[itemIndex];
|
|
|
|
FOwnerFixture.FNotifier.Lock;
|
|
try
|
|
FOwnerFixture.FNotifier.Unadvise(advisedItemRec.Tag);
|
|
advisedItemRec.Receiver.ExpectedToBeAdvised := False; // This thread no longer expects it to be advised
|
|
FMyAdvisedReceivers.Delete(itemIndex);
|
|
finally
|
|
FOwnerFixture.FNotifier.Release;
|
|
end;
|
|
end
|
|
else // 30% chance to Notify
|
|
begin
|
|
FOwnerFixture.FNotifier.Lock;
|
|
try
|
|
// if not FOwnerFixture.FNotifier.IsFinalized then // Don't notify if finalized
|
|
begin
|
|
FOwnerFixture.FNotifier.Notify(
|
|
function(Item: IMyStressTestInterface): Boolean
|
|
begin
|
|
Item.Foo(FThreadID); // Pass ThreadID as notification type for context
|
|
Result := True; // Keep item
|
|
end
|
|
);
|
|
end;
|
|
finally
|
|
FOwnerFixture.FNotifier.Release;
|
|
end;
|
|
end;
|
|
|
|
if (i mod 75 = 0) then
|
|
Sleep(0); // Yield occasionally to encourage context switching
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
FError := E; // Store the first error that occurred in the thread
|
|
end;
|
|
end;
|
|
|
|
function TStressWorkerThread.GetAdvisedReceiverCountByThread: Integer;
|
|
begin
|
|
Result := FMyAdvisedReceivers.Count;
|
|
end;
|
|
|
|
// Not strictly needed if main test iterates FAllReceiversCreated and checks ExpectedToBeAdvised flag
|
|
// procedure TStressWorkerThread.GetMyExpectedLiveReceivers(AList: TList<TMyStressReceiver>);
|
|
// var
|
|
// itemRec: TAdvisedReceiverInfo;
|
|
// begin
|
|
// AList.Clear;
|
|
// for itemRec in FMyAdvisedReceivers do
|
|
// begin
|
|
// AList.Add(itemRec.Receiver);
|
|
// end;
|
|
// end;
|
|
|
|
{ TMycNotifierChaosStressTests }
|
|
procedure TMycNotifierChaosStressTests.Setup;
|
|
begin
|
|
Randomize; // Initialize random number generator
|
|
FNotifier.Create;
|
|
FAllReceiversCreated := TList<IMyStressTestInterface>.Create;
|
|
FCriticalSectionForList := TCriticalSection.Create;
|
|
FNextReceiverInstanceID := 0;
|
|
end;
|
|
|
|
procedure TMycNotifierChaosStressTests.TearDown;
|
|
var
|
|
// receiver: TMyStressReceiver; // Not used directly in this simplified TearDown
|
|
i: Integer;
|
|
begin
|
|
// Attempt to shut down the Notifier cleanly.
|
|
try
|
|
FNotifier.Lock; // Lock for the cleanup process
|
|
try
|
|
// UnadviseAll should be safe if the IsFinalized guard is present
|
|
// and the FFirst state is not pathological.
|
|
// if not FNotifier.IsFinalized then
|
|
begin
|
|
FNotifier.UnadviseAll;
|
|
end;
|
|
finally
|
|
if FNotifier.IsLocked then // Only release if the lock is still held
|
|
FNotifier.Release;
|
|
end;
|
|
except
|
|
// Suppress errors during teardown to avoid interfering with other tests.
|
|
// In a real test environment, this would be logged.
|
|
end;
|
|
|
|
// FNotifier is a record field of the fixture and is "destroyed" with it when the fixture is destroyed.
|
|
// Setup reinitializes it for each test.
|
|
|
|
if Assigned(FAllReceiversCreated) then
|
|
begin
|
|
// ARC will handle TMyStressReceiver instances when the list is freed/cleared,
|
|
// as long as no other strong references exist.
|
|
// Setting list items to nil is good practice if the list itself isn't immediately freed.
|
|
for i := 0 to FAllReceiversCreated.Count - 1 do
|
|
FAllReceiversCreated[i] := nil; // Break reference cycles if any, allow ARC
|
|
FAllReceiversCreated.Free;
|
|
FAllReceiversCreated := nil;
|
|
end;
|
|
if Assigned(FCriticalSectionForList) then
|
|
begin
|
|
FCriticalSectionForList.Free;
|
|
FCriticalSectionForList := nil;
|
|
end;
|
|
end;
|
|
|
|
procedure TMycNotifierChaosStressTests.Test_MixedOperations_Stress;
|
|
const
|
|
NumThreads = 24; // Number of concurrent worker threads
|
|
IterationsPerThread = 2000; // Number of random operations per thread
|
|
var
|
|
threads: array of TStressWorkerThread;
|
|
i: Integer;
|
|
LThreadError: Exception;
|
|
totalExpectedLiveByThreadsAtEnd, actualLiveInNotifierAtEnd: Integer;
|
|
actualLiveReceiversInNotifier: TList<IMyStressTestInterface>; // Store interface type from Notify
|
|
receiver: IMyStressTestInterface;
|
|
found: Boolean;
|
|
stopwatch: TStopwatch;
|
|
begin
|
|
stopwatch := TStopwatch.StartNew;
|
|
|
|
SetLength(threads, NumThreads);
|
|
for i := 0 to NumThreads - 1 do
|
|
threads[i] := TStressWorkerThread.Create(Self, i + 1, IterationsPerThread);
|
|
|
|
for i := 0 to NumThreads - 1 do
|
|
threads[i].Start;
|
|
|
|
totalExpectedLiveByThreadsAtEnd := 0;
|
|
for i := 0 to NumThreads - 1 do
|
|
begin
|
|
threads[i].WaitFor;
|
|
LThreadError := threads[i].Error;
|
|
if Assigned(LThreadError) then
|
|
begin
|
|
// If an error occurred, Assert.IsNull would fail.
|
|
// The message can safely use LThreadError.Message here.
|
|
Assert.IsNull(LThreadError, 'Thread ' + threads[i].FThreadID.ToString + ' reported an error: ' + LThreadError.Message);
|
|
end
|
|
else
|
|
begin
|
|
// If no error, Assert.IsNull will pass. No custom message needed for success.
|
|
Assert.IsNull(LThreadError);
|
|
end;
|
|
totalExpectedLiveByThreadsAtEnd := totalExpectedLiveByThreadsAtEnd + threads[i].GetAdvisedReceiverCountByThread;
|
|
threads[i].Free;
|
|
end;
|
|
SetLength(threads, 0);
|
|
|
|
// --- Verification Phase ---
|
|
|
|
// 1. Get all items actually live in the notifier
|
|
actualLiveReceiversInNotifier := TList<IMyStressTestInterface>.Create;
|
|
try
|
|
FNotifier.Lock;
|
|
try
|
|
// if not FNotifier.IsFinalized then
|
|
begin
|
|
FNotifier.Notify(
|
|
function(Item: IMyStressTestInterface): Boolean
|
|
begin
|
|
actualLiveReceiversInNotifier.Add(Item);
|
|
Result := True;
|
|
end
|
|
);
|
|
end;
|
|
finally
|
|
FNotifier.Release;
|
|
end;
|
|
actualLiveInNotifierAtEnd := actualLiveReceiversInNotifier.Count;
|
|
|
|
// 2. Compare overall counts
|
|
Assert.AreEqual(
|
|
totalExpectedLiveByThreadsAtEnd,
|
|
actualLiveInNotifierAtEnd,
|
|
Format(
|
|
'Mismatch in live item count at end. Threads expected %d, Notifier has %d.',
|
|
[totalExpectedLiveByThreadsAtEnd, actualLiveInNotifierAtEnd]
|
|
)
|
|
);
|
|
|
|
// 3. Detailed check: Iterate all receivers ever created.
|
|
// Their 'ExpectedToBeAdvised' flag (last known state from its managing thread)
|
|
// should match their presence in 'actualLiveReceiversInNotifier'.
|
|
FCriticalSectionForList.Enter;
|
|
try
|
|
for receiver in FAllReceiversCreated do
|
|
begin
|
|
// Check if this receiver (by instance) is in the list of interfaces retrieved from Notify
|
|
found := False;
|
|
for var liveIntf in actualLiveReceiversInNotifier do
|
|
begin
|
|
if liveIntf = receiver then // Compare object instances
|
|
begin
|
|
found := True;
|
|
Break;
|
|
end;
|
|
end;
|
|
|
|
Assert.AreEqual(
|
|
receiver.ExpectedToBeAdvised,
|
|
found,
|
|
Format(
|
|
'Receiver ID %d: Thread expected it to be advised=%d, but its presence in Notifier is %d. NotificationCount=%d',
|
|
[receiver.GetInstanceID, Integer(receiver.ExpectedToBeAdvised), Integer(found), receiver.GetNotificationCount]
|
|
)
|
|
);
|
|
|
|
// Further checks on NotificationCount could be added if specific notification patterns were expected.
|
|
// For this chaos test, ensuring count is non-negative and consistent with advised state is a good start.
|
|
Assert.IsTrue(
|
|
receiver.GetNotificationCount >= 0,
|
|
Format(
|
|
'Receiver ID %d has non-positive notification count: %d',
|
|
[receiver.GetInstanceID, receiver.GetNotificationCount]
|
|
)
|
|
);
|
|
if found and (receiver.GetNotificationCount = 0) then
|
|
begin
|
|
// This might be okay if Notify calls were very sparse or the item was just added and not yet notified.
|
|
// For a long running stress test, one might expect > 0 if Notifies happened while it was live.
|
|
// Log.Debug(Format('Receiver ID %d found in notifier but has 0 notifications.', [receiver.GetInstanceID]));
|
|
end;
|
|
end;
|
|
finally
|
|
FCriticalSectionForList.Leave;
|
|
end;
|
|
finally
|
|
actualLiveReceiversInNotifier.Free;
|
|
end;
|
|
|
|
stopwatch.Stop;
|
|
end;
|
|
|
|
initialization
|
|
TDUnitX.RegisterTestFixture(TMycNotifierChaosStressTests);
|
|
end.
|