Michael Schimmel
211 lines
7.4 KiB
ObjectPascal
211 lines
7.4 KiB
ObjectPascal
unit TestDataArray;
|
|
|
|
interface
|
|
|
|
uses
|
|
System.SysUtils,
|
|
DUnitX.TestFramework,
|
|
Myc.Data.Series;
|
|
|
|
type
|
|
[TestFixture]
|
|
TMyTestObject = class
|
|
private
|
|
function GenerateData(Count: Integer): TArray<Integer>;
|
|
public
|
|
[Test]
|
|
[TestCase('Small_NoSlide', '100, -1')]
|
|
[TestCase('Small_WithSlide', '100, 50')]
|
|
[TestCase('Medium_NoSlide_CrossChunk', '1500, -1')]
|
|
[TestCase('Medium_WithSlide_CrossChunk', '2500, 1500')]
|
|
[TestCase('Large_ExactSlide', '5000, 1024')]
|
|
procedure TestChunkArray_CreateFromArray(const DataSize, MaxCount: Integer);
|
|
|
|
[Test]
|
|
procedure TestChunkArray_Add_And_Slide;
|
|
|
|
[Test]
|
|
procedure TestChunkArray_Copy_IsIndependent;
|
|
|
|
[Test]
|
|
procedure TestSeries_CreationAndIndexing;
|
|
|
|
[Test]
|
|
procedure TestSeries_Add_And_Copy;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses
|
|
System.Generics.Collections;
|
|
|
|
{ TMyTestObject }
|
|
|
|
function TMyTestObject.GenerateData(Count: Integer): TArray<Integer>;
|
|
var
|
|
i: Integer;
|
|
begin
|
|
SetLength(Result, Count);
|
|
for i := 0 to Count - 1 do
|
|
Result[i] := i;
|
|
end;
|
|
|
|
procedure TMyTestObject.TestChunkArray_Add_And_Slide;
|
|
var
|
|
arr: TChunkArray<Integer>;
|
|
newData: TArray<Integer>;
|
|
begin
|
|
// Test sliding with single additions
|
|
arr := TChunkArray<Integer>.CreateFromArray([], 5); // MaxCount = 5
|
|
|
|
arr.Add(10, 5); // arr = [10]
|
|
Assert.AreEqual(1, arr.Count);
|
|
Assert.AreEqual(10, arr[0]);
|
|
|
|
arr.Add(20, 5); // arr = [10, 20]
|
|
arr.Add(30, 5); // arr = [10, 20, 30]
|
|
arr.Add(40, 5); // arr = [10, 20, 30, 40]
|
|
arr.Add(50, 5); // arr = [10, 20, 30, 40, 50]
|
|
Assert.AreEqual(5, arr.Count);
|
|
Assert.AreEqual(10, arr[0]);
|
|
Assert.AreEqual(50, arr[4]);
|
|
|
|
// Now, slide the window
|
|
arr.Add(60, 5); // arr becomes [20, 30, 40, 50, 60]
|
|
Assert.AreEqual(5, arr.Count, 'Count should remain at MaxCount');
|
|
Assert.AreEqual(20, arr[0], 'First item should be slided out');
|
|
Assert.AreEqual(60, arr[4], 'Last item should be the new one');
|
|
|
|
// Test sliding with array addition
|
|
arr := TChunkArray<Integer>.CreateFromArray([1, 2, 3], 5); // arr = [1, 2, 3], MaxCount = 5
|
|
newData := [4, 5, 6, 7];
|
|
arr.Add(newData, 5); // arr becomes [3, 4, 5, 6, 7]
|
|
Assert.AreEqual(5, arr.Count, 'Count should be MaxCount after adding array');
|
|
Assert.AreEqual(3, arr[0]);
|
|
Assert.AreEqual(7, arr[4]);
|
|
end;
|
|
|
|
procedure TMyTestObject.TestChunkArray_Copy_IsIndependent;
|
|
const
|
|
DATA_SIZE = 3000; // Approx 3 chunks
|
|
MAX_COUNT_COPY = 1500; // Partial copy
|
|
var
|
|
original, fullCopy, partialCopy: TChunkArray<Integer>;
|
|
data: TArray<Integer>;
|
|
i: Integer;
|
|
begin
|
|
data := GenerateData(DATA_SIZE);
|
|
original := TChunkArray<Integer>.CreateFromArray(data, -1);
|
|
|
|
// 1. Test full copy
|
|
fullCopy := original.Copy(-1);
|
|
Assert.AreEqual(original.Count, fullCopy.Count, 'Full copy count should match original');
|
|
for i := 0 to original.Count - 1 do
|
|
Assert.AreEqual(original[i], fullCopy[i], 'Full copy item should match original');
|
|
|
|
// 2. Test partial copy
|
|
partialCopy := original.Copy(MAX_COUNT_COPY);
|
|
Assert.AreEqual(MAX_COUNT_COPY, partialCopy.Count, 'Partial copy should have MaxCount items');
|
|
for i := 0 to partialCopy.Count - 1 do
|
|
// The partial copy contains the LAST items of the original
|
|
Assert.AreEqual(original[i + (DATA_SIZE - MAX_COUNT_COPY)], partialCopy[i], 'Partial copy item should match last part of original');
|
|
|
|
// 3. Test independence after modification
|
|
// Add an item to original. This modifies its last chunk.
|
|
original.Add(9999, -1);
|
|
Assert.AreEqual(DATA_SIZE + 1, original.Count, 'Original count should increment');
|
|
|
|
// Verify the full copy is unchanged.
|
|
Assert.AreEqual(DATA_SIZE, fullCopy.Count, 'Full copy count should NOT change');
|
|
Assert.AreNotEqual(9999, fullCopy[fullCopy.Count - 1], 'Last item of full copy should NOT be the new item');
|
|
Assert.AreEqual(data[DATA_SIZE - 1], fullCopy[fullCopy.Count - 1], 'Last item of full copy should be original last item');
|
|
|
|
// Verify the partial copy is unchanged.
|
|
Assert.AreEqual(MAX_COUNT_COPY, partialCopy.Count, 'Partial copy count should NOT change');
|
|
end;
|
|
|
|
procedure TMyTestObject.TestChunkArray_CreateFromArray(const DataSize, MaxCount: Integer);
|
|
var
|
|
data, expectedData: TArray<Integer>;
|
|
arr: TChunkArray<Integer>;
|
|
effectiveCount: Integer;
|
|
i: Integer;
|
|
begin
|
|
data := GenerateData(DataSize);
|
|
arr := TChunkArray<Integer>.CreateFromArray(data, MaxCount);
|
|
|
|
if (MaxCount < 0) or (MaxCount >= DataSize) then
|
|
effectiveCount := DataSize
|
|
else
|
|
effectiveCount := MaxCount;
|
|
|
|
Assert.AreEqual(effectiveCount, arr.Count, 'Count should match effective count');
|
|
|
|
if effectiveCount = 0 then
|
|
exit;
|
|
|
|
// We only expect the last 'effectiveCount' items from the original data
|
|
SetLength(expectedData, effectiveCount);
|
|
TArray.Copy<Integer>(data, expectedData, DataSize - effectiveCount, 0, effectiveCount);
|
|
|
|
for i := 0 to effectiveCount - 1 do
|
|
Assert.AreEqual(expectedData[i], arr.Items[i], 'Item at index should be correct');
|
|
end;
|
|
|
|
procedure TMyTestObject.TestSeries_Add_And_Copy;
|
|
var
|
|
original, copy: TSeries<Integer>;
|
|
begin
|
|
// 1. Create and add
|
|
original := TSeries<Integer>.CreateFromArray([1, 2, 3], 5); // Lookback = 5
|
|
Assert.AreEqual(Int64(3), original.TotalCount);
|
|
|
|
original.Add(4, 5); // Series: [4, 3, 2, 1]
|
|
original.Add(5, 5); // Series: [5, 4, 3, 2, 1]
|
|
Assert.AreEqual(5, original.Count, 'Count should be 5');
|
|
Assert.AreEqual(Int64(5), original.TotalCount, 'TotalCount should be 5');
|
|
Assert.AreEqual(5, original[0], 'Index 0 should be 5');
|
|
|
|
// 2. Test sliding
|
|
original.Add(6, 5); // Series: [6, 5, 4, 3, 2]
|
|
Assert.AreEqual(5, original.Count, 'Count should remain 5 after slide');
|
|
Assert.AreEqual(Int64(6), original.TotalCount, 'TotalCount should be 6');
|
|
Assert.AreEqual(6, original[0], 'Index 0 should be 6');
|
|
Assert.AreEqual(2, original[4], 'Last item should be 2');
|
|
|
|
// 3. Test copy
|
|
copy := original.Copy();
|
|
Assert.AreEqual(5, copy.Count, 'Copy count should match original count');
|
|
Assert.AreEqual(Int64(5), copy.TotalCount, 'Copy TotalCount should match its own count, not original TotalCount');
|
|
Assert.AreEqual(6, copy[0], 'Copy should have same data');
|
|
|
|
// 4. Test independence
|
|
original.Add(7, 5);
|
|
Assert.AreEqual(7, original[0], 'Original should be updated');
|
|
Assert.AreEqual(6, copy[0], 'Copy should NOT be updated');
|
|
end;
|
|
|
|
procedure TMyTestObject.TestSeries_CreationAndIndexing;
|
|
var
|
|
series: TSeries<Integer>;
|
|
data: TArray<Integer>;
|
|
begin
|
|
data := [10, 20, 30, 40, 50];
|
|
series := TSeries<Integer>.CreateFromArray(data, -1);
|
|
|
|
Assert.AreEqual(5, series.Count, 'Series count should be 5');
|
|
Assert.AreEqual(Int64(5), series.TotalCount, 'Series total count should be 5');
|
|
|
|
// Test reversed indexing
|
|
Assert.AreEqual(50, series[0], 'Index 0 should be the last element');
|
|
Assert.AreEqual(40, series[1], 'Index 1 should be the second to last element');
|
|
Assert.AreEqual(30, series[2]);
|
|
Assert.AreEqual(20, series[3]);
|
|
Assert.AreEqual(10, series[4], 'Last index should be the first element');
|
|
end;
|
|
|
|
initialization
|
|
TDUnitX.RegisterTestFixture(TMyTestObject);
|
|
|
|
end.
|