renamed some units, added TMycAtomicStack

Test/MycTests.dpr

@@ -16,7 +16,8 @@ uses
   {$ENDIF }
   DUnitX.TestFramework,
   TestSignals in 'TestSignals.pas',
-  TestHeap in 'TestHeap.pas';
+  TestSList in 'TestSList.pas',
+  TestStack in 'TestStack.pas';
 
 { keep comment here to protect the following conditional from being removed by the IDE when adding a unit }
 {$IFNDEF TESTINSIGHT}

Test/MycTests.dproj

@@ -106,7 +106,8 @@
             <MainSource>MainSource</MainSource>
         </DelphiCompile>
         <DCCReference Include="TestSignals.pas"/>
-        <DCCReference Include="TestHeap.pas"/>
+        <DCCReference Include="TestSList.pas"/>
+        <DCCReference Include="TestStack.pas"/>
         <BuildConfiguration Include="Base">
             <Key>Base</Key>
         </BuildConfiguration>

Test/TestSList.pas

@@ -1,10 +1,10 @@
-unit TestHeap;
+unit TestSList;
 
 interface
 
 uses
   DUnitX.TestFramework,
-  Myc.Heap,         // The unit to be tested. TSListEntry and PSListEntry are expected from here.
+  Myc.Core.Atomic,         // The unit to be tested. TSListEntry and PSListEntry are expected from here.
   System.SysUtils,  // For NativeUInt, FillChar, Format static class, etc.
   System.SyncObjs,  // TInterlocked
   Winapi.Windows,   // For general Windows API types if needed by Myc.Heap for TSListHeader.
@@ -19,7 +19,7 @@ type
   end;
 
   [TestFixture]
-  TMycTestHeap = class
+  TMycTestSList = class
   private
     const TestAlignmentMask = 15; // Corresponds to AlignmentBoundary = 16 in Myc.Heap.pas
 
@@ -53,10 +53,6 @@ type
     [Test]
     [Timeout(30000)] // Timeout in milliseconds
     procedure TestTSList_ParallelPushPop;
-
-    // Sample method (can be removed if not needed)
-    [Test]
-    procedure Test1;
   end;
 
 implementation
@@ -68,40 +64,40 @@ uses
 
 // --- Helper Implementations (static) ---
 
-class function TMycTestHeap.CreateTestListItem(ID: Integer): PTestListItem;
+class function TMycTestSList.CreateTestListItem(ID: Integer): PTestListItem;
 begin
-  Myc.Heap.GetMemAligned(Result, SizeOf(TTestListItem));
+  GetMemAligned(Result, SizeOf(TTestListItem));
   Assert.IsNotNull(Result, Format('Failed to allocate memory for TestListItem ID %d', [ID]));
   FillChar(Result^, SizeOf(TTestListItem), 0);
   Result.ID := ID;
 end;
 
-class procedure TMycTestHeap.FreeTestListItem(var Item: PTestListItem);
+class procedure TMycTestSList.FreeTestListItem(var Item: PTestListItem);
 var
   tempPtr: Pointer;
 begin
   if Item <> nil then
   begin
     tempPtr := Item;
-    Myc.Heap.FreeMemAligned(tempPtr);
+    FreeMemAligned(tempPtr);
     Item := nil;
   end;
 end;
 
 // --- Fixture Setup/TearDown ---
 
-procedure TMycTestHeap.Setup;
+procedure TMycTestSList.Setup;
 begin
   Randomize;
 end;
 
-procedure TMycTestHeap.TearDown;
+procedure TMycTestSList.TearDown;
 begin
 end;
 
 // --- Alignment Stress Test Implementation ---
 
-procedure TMycTestHeap.TestStressAlignmentAndDataIntegrity;
+procedure TMycTestSList.TestStressAlignmentAndDataIntegrity;
 const
   NumIterations = 300000;
   MaxBlockSize = 1024 * 4;
@@ -112,8 +108,6 @@ var
   bytePtr: System.PByte; // Variable renamed from pByte
   j: System.NativeUInt;
   fillValue: Byte;
-  isNilAfterFreeExpected: Boolean;
-  originalPtrBeforeFree: Pointer;
 begin
   for i := 1 to NumIterations do
   begin
@@ -131,7 +125,7 @@ begin
 
     ptr := nil;
     try
-      Myc.Heap.GetMemAligned(ptr, sizeToAllocate);
+      GetMemAligned(ptr, sizeToAllocate);
       if sizeToAllocate = 0 then
       begin
         Assert.IsTrue(True, Format('Zero-size allocation processed (Iteration %d). Pointer: %p', [i, ptr]));
@@ -162,14 +156,14 @@ begin
         end;
       end;
     finally
-      Myc.Heap.FreeMemAligned(ptr);
+      FreeMemAligned(ptr);
     end;
   end;
 end;
 
 // --- TSList Single-Threaded Test Implementations ---
 
-procedure TMycTestHeap.TestTSList_CreateAndFree;
+procedure TMycTestSList.TestTSList_CreateAndFree;
 var
   sListPtr: PSList;
 begin
@@ -179,7 +173,7 @@ begin
   sListPtr.Free;
 end;
 
-procedure TMycTestHeap.TestTSList_PushPopSingleEntry;
+procedure TMycTestSList.TestTSList_PushPopSingleEntry;
 var
   sListPtr: PSList;
   item1: PTestListItem;
@@ -188,7 +182,7 @@ var
 begin
   sListPtr := TSList.Create;
   Assert.IsNotNull(sListPtr);
-  item1 := TMycTestHeap.CreateTestListItem(101);
+  item1 := TMycTestSList.CreateTestListItem(101);
   Assert.IsNotNull(item1);
   sListPtr.Push(@item1.ListEntry);
   Assert.AreEqual(1, sListPtr.QueryDepth, 'Depth should be 1 after one push.');
@@ -198,11 +192,11 @@ begin
   Assert.AreEqual(NativeUInt(item1), NativeUInt(poppedItem), 'Popped item should be the same as pushed item.');
   Assert.AreEqual(item1.ID, poppedItem.ID, 'Popped item ID mismatch.');
   Assert.AreEqual(0, sListPtr.QueryDepth, 'Depth should be 0 after popping the item.');
-  TMycTestHeap.FreeTestListItem(item1);
+  TMycTestSList.FreeTestListItem(item1);
   sListPtr.Free;
 end;
 
-procedure TMycTestHeap.TestTSList_PushPopMultipleEntries_LIFO;
+procedure TMycTestSList.TestTSList_PushPopMultipleEntries_LIFO;
 const
   NumItems = 5;
 var
@@ -216,7 +210,7 @@ begin
   Assert.IsNotNull(sListPtr);
   for i := 1 to NumItems do
   begin
-    items[i] := TMycTestHeap.CreateTestListItem(200 + i);
+    items[i] := TMycTestSList.CreateTestListItem(200 + i);
     sListPtr.Push(@items[i].ListEntry);
     Assert.AreEqual(i, sListPtr.QueryDepth, Format('Depth should be %d after %d pushes.', [i,i]));
   end;
@@ -234,12 +228,12 @@ begin
   Assert.AreEqual(0, sListPtr.QueryDepth, 'Depth should be 0 after all items are popped.');
   for i := 1 to NumItems do
   begin
-    TMycTestHeap.FreeTestListItem(items[i]);
+    TMycTestSList.FreeTestListItem(items[i]);
   end;
   sListPtr.Free;
 end;
 
-procedure TMycTestHeap.TestTSList_QueryDepth;
+procedure TMycTestSList.TestTSList_QueryDepth;
 var
   sListPtr: PSList;
   item1, item2: PTestListItem;
@@ -247,22 +241,22 @@ begin
   sListPtr := TSList.Create;
   Assert.IsNotNull(sListPtr);
   Assert.AreEqual(0, sListPtr.QueryDepth, 'Initial depth should be 0.');
-  item1 := TMycTestHeap.CreateTestListItem(301);
+  item1 := TMycTestSList.CreateTestListItem(301);
   sListPtr.Push(@item1.ListEntry);
   Assert.AreEqual(1, sListPtr.QueryDepth, 'Depth should be 1 after one push.');
-  item2 := TMycTestHeap.CreateTestListItem(302);
+  item2 := TMycTestSList.CreateTestListItem(302);
   sListPtr.Push(@item2.ListEntry);
   Assert.AreEqual(2, sListPtr.QueryDepth, 'Depth should be 2 after two pushes.');
   sListPtr.Pop;
   Assert.AreEqual(1, sListPtr.QueryDepth, 'Depth should be 1 after one pop.');
   sListPtr.Pop;
   Assert.AreEqual(0, sListPtr.QueryDepth, 'Depth should be 0 after two pops.');
-  TMycTestHeap.FreeTestListItem(item1);
-  TMycTestHeap.FreeTestListItem(item2);
+  TMycTestSList.FreeTestListItem(item1);
+  TMycTestSList.FreeTestListItem(item2);
   sListPtr.Free;
 end;
 
-procedure TMycTestHeap.TestTSList_PopFromEmptyList;
+procedure TMycTestSList.TestTSList_PopFromEmptyList;
 var
   sListPtr: PSList;
   poppedInternalListEntry: PSListEntry;
@@ -277,7 +271,7 @@ begin
 end;
 
 // --- TSList Parallel Access Test Implementation ---
-procedure TMycTestHeap.TestTSList_ParallelPushPop;
+procedure TMycTestSList.TestTSList_ParallelPushPop;
 const
   NumThreads = 12;
   OperationsPerThread = 50000;
@@ -325,7 +319,7 @@ begin
           if actionRand < 0.5 then // Attempt to Push
           begin
             itemID := TInterlocked.Increment(globalItemID); // TInterlocked from System.SysUtils or System
-            item := TMycTestHeap.CreateTestListItem(itemID);
+            item := TMycTestSList.CreateTestListItem(itemID);
             if item <> nil then
             begin
               sharedSList.Push(@item.ListEntry);
@@ -343,7 +337,7 @@ begin
               pushLogResult := poppedIDs.PushItem(item.ID); // Use PushItem for TThreadedQueue
               Assert.AreEqual(TWaitResult.wrSignaled, pushLogResult,
                 Format('Failed to push item ID %d to poppedIDs logging queue.', [item.ID]));
-              TMycTestHeap.FreeTestListItem(item);
+              TMycTestSList.FreeTestListItem(item);
             end;
           end;
           if j mod (OperationsPerThread div 10) = 0 then // Occasional sleep
@@ -373,7 +367,7 @@ begin
     waitResult := poppedIDs.PushItem(remainingItem.ID); // Use PushItem
     Assert.AreEqual(TWaitResult.wrSignaled, waitResult,
         Format('Failed to push remaining item ID %d to poppedIDs logging queue during drain.', [remainingItem.ID]));
-    TMycTestHeap.FreeTestListItem(remainingItem);
+    TMycTestSList.FreeTestListItem(remainingItem);
   end;
 
   Assert.AreEqual(0, sharedSList.QueryDepth, 'TSList should be empty after all operations and draining.');
@@ -425,12 +419,6 @@ begin
   poppedIDs.Free;
 end;
 
-// --- Existing Sample Test ---
-procedure TMycTestHeap.Test1;
-begin
-  // Example: Assert.IsTrue(True, 'Test1 passed');
-end;
-
 initialization
-  TDUnitX.RegisterTestFixture(TMycTestHeap);
+  TDUnitX.RegisterTestFixture(TMycTestSList);
 end.

Test/TestSignals.pas

@@ -3,8 +3,7 @@ unit TestSignals;
 interface
 
 uses
-  DUnitX.TestFramework,
-  Myc.Atomic;
+  DUnitX.TestFramework;
 
 type
   [TestFixture]

Test/TestStack.pas

@@ -0,0 +1,368 @@
+unit TestStack;
+
+interface
+
+uses
+  DUnitX.TestFramework;
+
+type
+  // Helper record type for testing generic capabilities
+  TTestRecord = record
+    ID: Integer;
+    Name: string;
+    Value: Double;
+  end;
+
+  [TestFixture]
+  TMycTestStackTests = class(TObject) // Changed class name for clarity
+  public
+    // Setup and TearDown are often not strictly necessary for tests
+    // involving managed records as local variables, as their
+    // Initialize/Finalize are handled automatically.
+    [Setup]
+    procedure Setup;
+    [TearDown]
+    procedure TearDown;
+
+    // --- Tests for TMycAtomicStack<Integer> ---
+    [Test]
+    procedure TestInteger_PopOnEmpty_ReturnsDefault;
+    [Test]
+    procedure TestInteger_TryPopOnEmpty_ReturnsFalseAndDefault;
+    [Test]
+    procedure TestInteger_PushOne_PopOne_CorrectValue;
+    [Test]
+    procedure TestInteger_PushThree_PopThree_LIFO_Order;
+    [Test]
+    procedure TestInteger_TryPopWithItems_ReturnsTrueAndCorrectValue;
+    [Test]
+    procedure TestInteger_PushPopMixed_MaintainsIntegrity;
+    [Test]
+    procedure TestInteger_StressTest_ManyItems;
+
+    // --- Tests for TMycAtomicStack<string> ---
+    [Test]
+    procedure TestString_PopOnEmpty_ReturnsDefault;
+    [Test]
+    procedure TestString_TryPopOnEmpty_ReturnsFalseAndDefault;
+    [Test]
+    procedure TestString_PushOne_PopOne_CorrectValue;
+    [Test]
+    procedure TestString_PushThree_PopThree_LIFO_Order;
+    [Test]
+    procedure TestString_HandleEmptyAndNilStrings;
+
+    // --- Tests for TMycAtomicStack<TTestRecord> ---
+    [Test]
+    procedure TestRecord_PopOnEmpty_ReturnsDefault;
+    [Test]
+    procedure TestRecord_TryPopOnEmpty_ReturnsFalseAndDefault;
+    [Test]
+    procedure TestRecord_PushOne_PopOne_CorrectValue;
+    [Test]
+    procedure TestRecord_PushThree_PopThree_LIFO_Order;
+
+  end;
+
+implementation
+
+uses
+  System.SysUtils, // For Default() if not implicitly available via DUnitX/Generics
+  Myc.Core.Atomic; // The unit containing TMycAtomicStack
+
+procedure TMycTestStackTests.Setup;
+begin
+  // No specific setup needed per test if stack is local variable in methods.
+end;
+
+procedure TMycTestStackTests.TearDown;
+begin
+  // No specific teardown needed per test.
+end;
+
+// --- Helper Methods ---
+
+function AreRecordsEqual(const Rec1, Rec2: TTestRecord): Boolean;
+begin
+  Result := (Rec1.ID = Rec2.ID) and (Rec1.Name = Rec2.Name) and (Rec1.Value = Rec2.Value);
+end;
+
+function TestRecordToString(const Rec: TTestRecord): string;
+begin
+  Result := Format('ID: %d, Name: "%s", Value: %f', [Rec.ID, Rec.Name, Rec.Value]);
+end;
+
+// --- Tests for TMycAtomicStack<Integer> ---
+
+[Test]
+procedure TMycTestStackTests.TestInteger_PopOnEmpty_ReturnsDefault;
+var
+  stack: TMycAtomicStack<Integer>;
+  value: Integer;
+begin
+  // Initialize is called automatically for managed record 'stack'
+  value := stack.Pop;
+  Assert.AreEqual(Default(Integer), value, 'Pop on empty integer stack should return Default(Integer).');
+  // Finalize is called automatically when 'stack' goes out of scope
+end;
+
+[Test]
+procedure TMycTestStackTests.TestInteger_TryPopOnEmpty_ReturnsFalseAndDefault;
+var
+  stack: TMycAtomicStack<Integer>;
+  value: Integer;
+  success: Boolean;
+begin
+  value := 123; // Non-default initial value to check if TryPop modifies it
+  success := stack.TryPop(value);
+  Assert.IsFalse(success, 'TryPop on empty integer stack should return False.');
+  Assert.AreEqual(Default(Integer), value, 'Item from TryPop on empty integer stack should be Default(Integer).');
+end;
+
+[Test]
+procedure TMycTestStackTests.TestInteger_PushOne_PopOne_CorrectValue;
+var
+  stack: TMycAtomicStack<Integer>;
+  pushedValue: Integer;
+  poppedValue: Integer;
+  success: Boolean;
+begin
+  pushedValue := 100;
+  stack.Push(pushedValue);
+
+  poppedValue := stack.Pop;
+  Assert.AreEqual(pushedValue, poppedValue, 'Popped value does not match pushed value.');
+
+  // Stack should be empty now
+  success := stack.TryPop(poppedValue);
+  Assert.IsFalse(success, 'Stack should be empty after popping the only item.');
+end;
+
+[Test]
+procedure TMycTestStackTests.TestInteger_PushThree_PopThree_LIFO_Order;
+var
+  stack: TMycAtomicStack<Integer>;
+  val1, val2, val3: Integer;
+begin
+  val1 := 1;
+  val2 := 2;
+  val3 := 3;
+
+  stack.Push(val1);
+  stack.Push(val2);
+  stack.Push(val3);
+
+  Assert.AreEqual(val3, stack.Pop, '1st Pop: Expected val3 (LIFO).');
+  Assert.AreEqual(val2, stack.Pop, '2nd Pop: Expected val2 (LIFO).');
+  Assert.AreEqual(val1, stack.Pop, '3rd Pop: Expected val1 (LIFO).');
+
+  Assert.IsFalse(stack.TryPop(val1), 'Stack should be empty after popping all items.');
+end;
+
+[Test]
+procedure TMycTestStackTests.TestInteger_TryPopWithItems_ReturnsTrueAndCorrectValue;
+var
+  stack: TMycAtomicStack<Integer>;
+  pushedValue: Integer;
+  poppedValue: Integer;
+  success: Boolean;
+begin
+  pushedValue := 77;
+  stack.Push(pushedValue);
+
+  success := stack.TryPop(poppedValue);
+  Assert.IsTrue(success, 'TryPop should return True when stack is not empty.');
+  Assert.AreEqual(pushedValue, poppedValue, 'TryPop: Popped value does not match pushed value.');
+
+  success := stack.TryPop(poppedValue);
+  Assert.IsFalse(success, 'Stack should be empty after TryPop on the only item.');
+end;
+
+[Test]
+procedure TMycTestStackTests.TestInteger_PushPopMixed_MaintainsIntegrity;
+var
+  stack: TMycAtomicStack<Integer>;
+  value: Integer;
+begin
+  stack.Push(10);
+  stack.Push(20);
+  Assert.AreEqual(20, stack.Pop, 'Pop 20'); // Stack: 10
+  stack.Push(30);                             // Stack: 10, 30
+  Assert.AreEqual(30, stack.Pop, 'Pop 30'); // Stack: 10
+  stack.Push(40);                             // Stack: 10, 40
+  Assert.AreEqual(40, stack.Pop, 'Pop 40'); // Stack: 10
+  Assert.AreEqual(10, stack.Pop, 'Pop 10'); // Stack: empty
+
+  Assert.IsFalse(stack.TryPop(value), 'Stack should be empty after all operations.');
+end;
+
+[Test]
+procedure TMycTestStackTests.TestInteger_StressTest_ManyItems;
+var
+  stack: TMycAtomicStack<Integer>;
+  i: Integer;
+  count: Integer;
+begin
+  count := 10000;
+  for i := 1 to count do
+  begin
+    stack.Push(i);
+  end;
+
+  for i := count downto 1 do
+  begin
+    Assert.AreEqual(i, stack.Pop, Format('Stress test: Popped value mismatch for item %d.', [i]));
+  end;
+
+  Assert.IsFalse(stack.TryPop(i), 'Stack should be empty after stress test.');
+end;
+
+
+// --- Tests for TMycAtomicStack<string> ---
+
+[Test]
+procedure TMycTestStackTests.TestString_PopOnEmpty_ReturnsDefault;
+var
+  stack: TMycAtomicStack<string>;
+  value: string;
+begin
+  value := stack.Pop;
+  Assert.AreEqual(Default(string), value, 'Pop on empty string stack should return Default(string) (nil).');
+end;
+
+[Test]
+procedure TMycTestStackTests.TestString_TryPopOnEmpty_ReturnsFalseAndDefault;
+var
+  stack: TMycAtomicStack<string>;
+  value: string;
+  success: Boolean;
+begin
+  value := 'not nil';
+  success := stack.TryPop(value);
+  Assert.IsFalse(success, 'TryPop on empty string stack should return False.');
+  Assert.AreEqual(Default(string), value, 'Item from TryPop on empty string stack should be Default(string) (nil).');
+end;
+
+[Test]
+procedure TMycTestStackTests.TestString_PushOne_PopOne_CorrectValue;
+var
+  stack: TMycAtomicStack<string>;
+  pushedValue: string;
+  poppedValue: string;
+begin
+  pushedValue := 'Hello Delphi';
+  stack.Push(pushedValue);
+
+  poppedValue := stack.Pop;
+  Assert.AreEqual(pushedValue, poppedValue, 'String Pop: Popped value does not match pushed value.');
+  Assert.IsFalse(stack.TryPop(poppedValue), 'Stack should be empty.');
+end;
+
+[Test]
+procedure TMycTestStackTests.TestString_PushThree_PopThree_LIFO_Order;
+var
+  stack: TMycAtomicStack<string>;
+  s1, s2, s3: string;
+begin
+  s1 := 'first';
+  s2 := 'second';
+  s3 := 'third';
+
+  stack.Push(s1);
+  stack.Push(s2);
+  stack.Push(s3);
+
+  Assert.AreEqual(s3, stack.Pop, 'String LIFO: Expected s3.');
+  Assert.AreEqual(s2, stack.Pop, 'String LIFO: Expected s2.');
+  Assert.AreEqual(s1, stack.Pop, 'String LIFO: Expected s1.');
+  Assert.IsFalse(stack.TryPop(s1), 'Stack should be empty.');
+end;
+
+[Test]
+procedure TMycTestStackTests.TestString_HandleEmptyAndNilStrings;
+var
+  stack: TMycAtomicStack<string>;
+  poppedValue: string;
+begin
+  stack.Push(''); // Empty string
+  stack.Push(Default(string)); // Nil string
+  stack.Push('actual string');
+
+  Assert.AreEqual('actual string', stack.Pop, 'Pop "actual string"');
+  Assert.AreEqual(Default(string), stack.Pop, 'Pop nil string');
+  Assert.AreEqual('', stack.Pop, 'Pop empty string');
+  Assert.IsFalse(stack.TryPop(poppedValue), 'Stack should be empty.');
+end;
+
+// --- Tests for TMycAtomicStack<TTestRecord> ---
+
+[Test]
+procedure TMycTestStackTests.TestRecord_PopOnEmpty_ReturnsDefault;
+var
+  stack: TMycAtomicStack<TTestRecord>;
+  value: TTestRecord;
+begin
+  value := stack.Pop;
+  Assert.IsTrue(AreRecordsEqual(Default(TTestRecord), value),
+    Format('Pop on empty record stack should return Default(TTestRecord). Got %s', [TestRecordToString(value)]));
+end;
+
+[Test]
+procedure TMycTestStackTests.TestRecord_TryPopOnEmpty_ReturnsFalseAndDefault;
+var
+  stack: TMycAtomicStack<TTestRecord>;
+  value: TTestRecord;
+  success: Boolean;
+begin
+  value.ID := -1; // Non-default
+  success := stack.TryPop(value);
+  Assert.IsFalse(success, 'TryPop on empty record stack should return False.');
+  Assert.IsTrue(AreRecordsEqual(Default(TTestRecord), value),
+     Format('Item from TryPop on empty record stack should be Default(TTestRecord). Got %s', [TestRecordToString(value)]));
+end;
+
+[Test]
+procedure TMycTestStackTests.TestRecord_PushOne_PopOne_CorrectValue;
+var
+  stack: TMycAtomicStack<TTestRecord>;
+  pushedValue: TTestRecord;
+  poppedValue: TTestRecord;
+begin
+  pushedValue.ID := 1;
+  pushedValue.Name := 'Test Record 1';
+  pushedValue.Value := 3.14;
+  stack.Push(pushedValue);
+
+  poppedValue := stack.Pop;
+  Assert.IsTrue(AreRecordsEqual(pushedValue, poppedValue),
+    Format('Record Pop: Popped value (%s) does not match pushed value (%s).', [TestRecordToString(poppedValue), TestRecordToString(pushedValue)]));
+  Assert.IsFalse(stack.TryPop(poppedValue), 'Stack should be empty.');
+end;
+
+[Test]
+procedure TMycTestStackTests.TestRecord_PushThree_PopThree_LIFO_Order;
+var
+  stack: TMycAtomicStack<TTestRecord>;
+  r1, r2, r3: TTestRecord;
+  popped: TTestRecord;
+begin
+  r1.ID := 1; r1.Name := 'R1'; r1.Value := 1.0;
+  r2.ID := 2; r2.Name := 'R2'; r2.Value := 2.0;
+  r3.ID := 3; r3.Name := 'R3'; r3.Value := 3.0;
+
+  stack.Push(r1);
+  stack.Push(r2);
+  stack.Push(r3);
+
+  popped := stack.Pop;
+  Assert.IsTrue(AreRecordsEqual(r3, popped), Format('Record LIFO: Expected r3, got %s', [TestRecordToString(popped)]));
+  popped := stack.Pop;
+  Assert.IsTrue(AreRecordsEqual(r2, popped), Format('Record LIFO: Expected r2, got %s', [TestRecordToString(popped)]));
+  popped := stack.Pop;
+  Assert.IsTrue(AreRecordsEqual(r1, popped), Format('Record LIFO: Expected r1, got %s', [TestRecordToString(popped)]));
+  Assert.IsFalse(stack.TryPop(popped), 'Stack should be empty.');
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(TMycTestStackTests);
+end.