DataProvider

Src/Myc.Test.Trade.DataPoint.pas

@@ -14,7 +14,7 @@ type
     TTestTDataSeries = class(TObject)
     private
         FSeries: TDataSeries<TAskBidItem>;
-        procedure SetupSeriesWithData;
+        procedure SetupSeriesWithData(ItemCount: Integer = 10; MaxLookBack: Int64 = 0);
     public
         [Setup]
         procedure Setup;
@@ -46,6 +46,39 @@ type
         procedure TestIndexOfEmptySeries;
         [Test]
         procedure TestIndexOfSingleItemSeries;
+
+        // Tests for MaxLookback
+        [Test]
+        procedure TestCountIsCappedByMaxLookback_NoTrim;
+        [Test]
+        procedure TestCountIsCappedByMaxLookback_WithTrim;
+        [Test]
+        [IgnoreMemoryLeaks]
+        procedure TestLoopIsSafeWithMaxLookback;
+        [Test]
+        procedure TestIndexOfRespectsMaxLookback;
+
+        // Tests for bulk Add
+        [Test]
+        procedure TestBulkAddIncreasesCount;
+        [Test]
+        [IgnoreMemoryLeaks]
+        procedure TestBulkAddChronologicalAssertion_Internal;
+        [Test]
+        [IgnoreMemoryLeaks]
+        procedure TestBulkAddChronologicalAssertion_External;
+        [Test]
+        procedure TestBulkAddSpanningMultipleChunks;
+        [Test]
+        procedure TestBulkAddWithMaxLookback;
+
+        // Tests for TotalCount
+        [Test]
+        procedure TestTotalCountIncrementsCorrectly;
+        [Test]
+        procedure TestTotalCountIgnoresTrimming;
+        [Test]
+        procedure TestTotalCountResetsOnClear;
     end;
 
 implementation
@@ -63,24 +96,21 @@ begin
     FSeries := Default(TDataSeries<TAskBidItem>);
 end;
 
-procedure TTestTDataSeries.SetupSeriesWithData;
+procedure TTestTDataSeries.SetupSeriesWithData(ItemCount: Integer = 10; MaxLookBack: Int64 = 0);
 var
     i: Integer;
     DataPoint: TDataPoint<TAskBidItem>;
     baseTime: TDateTime;
 begin
-    FSeries := Default(TDataSeries<TAskBidItem>);
+    FSeries := TDataSeries<TAskBidItem>.Create( MaxLookBack );
     baseTime := EncodeDate(2020, 7, 7);
 
-    // Add 10 data points with increasing timestamps.
-    for i := 0 to 9 do
+    // Add data points with increasing timestamps.
+    for i := 0 to ItemCount - 1 do
     begin
         DataPoint := TDataPoint<TAskBidItem>.Create(baseTime + i, TAskBidItem.Create(i * 1.0, i * 1.0 + 0.1));
         FSeries.Add(DataPoint);
     end;
-    // Resulting state:
-    // Newest item: Time = baseTime + 9, Logical Index = 0
-    // Oldest item: Time = baseTime + 0, Logical Index = 9
 end;
 
 // Verifies that the test data setup helper works as expected.
@@ -271,6 +301,226 @@ begin
     Assert.AreEqual(Int64(-1), FSeries.IndexOf(testTime - 1), 'IndexOf for time before single item should be -1');
 end;
 
+procedure TTestTDataSeries.TestCountIsCappedByMaxLookback_NoTrim;
+begin
+    SetupSeriesWithData(500, 400); // Less than one chunk
+
+    // The public Count must now be the MaxLookback value, even though
+    // no chunk was freed and FCount is still 500 internally.
+    Assert.AreEqual(Int64(400), FSeries.Count, 'Public count should be capped by MaxLookback even if no chunk is freed');
+end;
+
+procedure TTestTDataSeries.TestCountIsCappedByMaxLookback_WithTrim;
+const
+    ITEMS_TO_ADD = 2000;
+    LOOKBACK_LIMIT = 900;
+begin
+    SetupSeriesWithData(ITEMS_TO_ADD, LOOKBACK_LIMIT);
+
+    // Internally, FCount will be 976 after one chunk is freed.
+    // The public Count should still be capped at the lookback limit.
+    Assert.AreEqual(Int64(LOOKBACK_LIMIT), FSeries.Count, 'Public count should be capped by MaxLookback after trimming');
+end;
+
+procedure TTestTDataSeries.TestLoopIsSafeWithMaxLookback;
+var
+    dummy: TDataPoint<TAskBidItem>;
+begin
+    SetupSeriesWithData(500, 400);
+    Assert.AreEqual(Int64(400), FSeries.Count, 'Pre-condition: Count must be capped at 400');
+
+    // This test proves that a standard loop based on the public Count is safe
+    // and will not access an invalid index.
+    Assert.WillNotRaise(
+        procedure
+        begin
+            for var i := 0 to FSeries.Count - 1 do
+            begin
+                dummy := FSeries[i];
+            end;
+        end,
+        nil,
+        'Looping up to the public Count should not raise an exception'
+    );
+
+    // Also test the assert when going one item beyond the public count
+    Assert.WillRaise(
+        procedure begin dummy := FSeries[400]; end,
+        EAssertionFailed,
+        'Accessing index at the limit of MaxLookback should raise an exception'
+    );
+end;
+
+procedure TTestTDataSeries.TestIndexOfRespectsMaxLookback;
+var
+    baseTime, searchTime: TDateTime;
+begin
+    SetupSeriesWithData(500, 400); // Items from baseTime+0 to baseTime+499
+    baseTime := EncodeDate(2020, 7, 7);
+
+    Assert.AreEqual(Int64(400), FSeries.Count, 'Pre-condition: Count must be 400');
+
+    // The oldest *physically present* item has a timestamp of baseTime+0.
+    // This item is at logical index 499, which is outside the MaxLookback range.
+    // IndexOf must not find it.
+    searchTime := baseTime; // Time of oldest physical item.
+    Assert.AreEqual(Int64(-1), FSeries.IndexOf(searchTime), 'IndexOf should not find items outside the MaxLookback range');
+
+    // The oldest *logically valid* item is at index 399.
+    // Its physical index is 500 - 399 - 1 = 100.
+    // Its timestamp is baseTime + 100.
+    searchTime := baseTime + 100;
+    Assert.AreEqual(Int64(399), FSeries.IndexOf(searchTime), 'IndexOf should find the oldest valid item at the edge of MaxLookback');
+end;
+
+procedure TTestTDataSeries.TestBulkAddIncreasesCount;
+var
+    newData: TArray<TDataPoint<TAskBidItem>>;
+    baseTime, newTime: TDateTime;
+    i: Integer;
+begin
+    SetupSeriesWithData(10);
+    baseTime := EncodeDate(2020, 7, 7);
+
+    SetLength(newData, 5);
+    for i := 0 to High(newData) do
+    begin
+        newTime := baseTime + 10 + i;
+        newData[i] := TDataPoint<TAskBidItem>.Create(newTime, TAskBidItem.Create(i, i));
+    end;
+
+    FSeries.Add(newData);
+
+    Assert.AreEqual(Int64(15), FSeries.Count, 'Count should be increased by the number of items in the bulk add');
+    Assert.AreEqual(baseTime + 10 + High(newData), FSeries.Time[0], 'Newest item should be the last item from the added array');
+end;
+
+procedure TTestTDataSeries.TestBulkAddChronologicalAssertion_Internal;
+var
+    newData: TArray<TDataPoint<TAskBidItem>>;
+begin
+    SetupSeriesWithData(10);
+    SetLength(newData, 2);
+    newData[0] := TDataPoint<TAskBidItem>.Create(Now + 1, TAskBidItem.Create(1, 1));
+    newData[1] := TDataPoint<TAskBidItem>.Create(Now, TAskBidItem.Create(2, 2)); // Not sorted
+
+    Assert.WillRaise(
+        procedure begin FSeries.Add(newData); end,
+        EAssertionFailed,
+        'Bulk Add should fail if the input array is not chronologically sorted'
+    );
+end;
+
+procedure TTestTDataSeries.TestBulkAddChronologicalAssertion_External;
+var
+    newData: TArray<TDataPoint<TAskBidItem>>;
+    olderTime: TDateTime;
+begin
+    SetupSeriesWithData(10); // Newest is baseTime + 9
+    olderTime := EncodeDate(2020, 7, 7) + 8;
+
+    SetLength(newData, 1);
+    newData[0] := TDataPoint<TAskBidItem>.Create(olderTime, TAskBidItem.Create(1, 1));
+
+    Assert.WillRaise(
+        procedure begin FSeries.Add(newData); end,
+        EAssertionFailed,
+        'Bulk Add should fail if its first item is older than the series last item'
+    );
+end;
+
+procedure TTestTDataSeries.TestBulkAddSpanningMultipleChunks;
+const
+    CHUNK_SIZE = 1024;
+var
+    newData: TArray<TDataPoint<TAskBidItem>>;
+    lastTimeBeforeAdd, firstNewTime, lastNewTime: TDateTime;
+    i: Integer;
+begin
+    SetupSeriesWithData(CHUNK_SIZE - 4); // Almost fill the first chunk
+    lastTimeBeforeAdd := FSeries.Time[0];
+
+    SetLength(newData, 8); // Add 8 items, which will span the chunk boundary
+    for i := 0 to High(newData) do
+    begin
+        newData[i] := TDataPoint<TAskBidItem>.Create(lastTimeBeforeAdd + 1 + i, TAskBidItem.Create(i, i));
+    end;
+
+    firstNewTime := newData[0].Time;
+    lastNewTime := newData[High(newData)].Time;
+
+    FSeries.Add(newData);
+    Assert.AreEqual(Int64(CHUNK_SIZE + 4), FSeries.Count, 'Count should be correct after spanning a chunk');
+    Assert.AreEqual(lastNewTime, FSeries.Time[0], 'Newest item should be correct');
+    Assert.AreEqual(firstNewTime, FSeries.Time[7], 'Oldest of the new items should be at the correct logical index');
+end;
+
+procedure TTestTDataSeries.TestBulkAddWithMaxLookback;
+var
+    newData: TArray<TDataPoint<TAskBidItem>>;
+    i: Integer;
+    baseTime: TDateTime;
+begin
+    SetupSeriesWithData(400, 500);
+    baseTime := FSeries.Time[0];
+
+    SetLength(newData, 200);
+    for i := 0 to High(newData) do
+    begin
+        newData[i] := TDataPoint<TAskBidItem>.Create(baseTime + 1 + i, TAskBidItem.Create(i, i));
+    end;
+
+    FSeries.Add(newData);
+
+    // Total items would be 600, but MaxLookback is 500.
+    // Trim does not free chunks (100 to remove < 1024).
+    // The public Count must be capped at 500.
+    Assert.AreEqual(Int64(500), FSeries.Count, 'Count should be capped by MaxLookback after bulk add');
+end;
+
+procedure TTestTDataSeries.TestTotalCountIncrementsCorrectly;
+var
+    newData: TArray<TDataPoint<TAskBidItem>>;
+    i: Integer;
+begin
+    FSeries := TDataSeries<TAskBidItem>.Create( 0 );
+    Assert.AreEqual(Int64(0), FSeries.TotalCount, 'TotalCount should be 0 on creation');
+
+    // Test single add
+    FSeries.Add(TDataPoint<TAskBidItem>.Create(Now, TAskBidItem.Create(1,1)));
+    Assert.AreEqual(Int64(1), FSeries.TotalCount, 'TotalCount should be 1 after single add');
+
+    // Test bulk add
+    SetLength(newData, 10);
+    for i := 0 to High(newData) do
+        newData[i] := TDataPoint<TAskBidItem>.Create(Now + 1 + i, TAskBidItem.Create(i,i));
+
+    FSeries.Add(newData);
+    Assert.AreEqual(Int64(11), FSeries.TotalCount, 'TotalCount should be 11 after bulk add');
+end;
+
+procedure TTestTDataSeries.TestTotalCountIgnoresTrimming;
+begin
+    // Create series with a lookback that will cause trimming
+    SetupSeriesWithData(20, 10);
+
+    // The visible count is capped by MaxLookback
+    Assert.AreEqual(Int64(10), FSeries.Count, 'Count should be capped by MaxLookback');
+    // The total count should reflect all items that were ever added
+    Assert.AreEqual(Int64(20), FSeries.TotalCount, 'TotalCount must not be affected by trimming');
+end;
+
+procedure TTestTDataSeries.TestTotalCountResetsOnClear;
+begin
+    SetupSeriesWithData(15);
+    Assert.IsTrue(FSeries.TotalCount > 0, 'Pre-condition: TotalCount should be greater than 0');
+
+    FSeries.Clear;
+
+    Assert.AreEqual(Int64(0), FSeries.TotalCount, 'TotalCount should be 0 after Clear');
+    Assert.AreEqual(Int64(0), FSeries.Count, 'Count should be 0 after Clear');
+end;
+
 initialization
     TDUnitX.RegisterTestFixture(TTestTDataSeries);
 end.