Michael Schimmel
270 lines
11 KiB
ObjectPascal
270 lines
11 KiB
ObjectPascal
unit TestDataRecord;
|
|
|
|
interface
|
|
|
|
uses
|
|
DunitX.TestFramework,
|
|
System.SysUtils,
|
|
System.DateUtils,
|
|
System.Rtti,
|
|
Myc.Data.Records;
|
|
|
|
type
|
|
// A record that contains all supported data types for testing
|
|
TMyTestRecord = record
|
|
MyInteger: Integer;
|
|
MyInt64: Int64;
|
|
MySingle: Single;
|
|
MyDouble: Double;
|
|
MyString: string;
|
|
MyTimestamp: TDateTime;
|
|
MyRecord: TDataRecord;
|
|
end;
|
|
|
|
// A simple record to be nested inside another
|
|
TNestedTestRecord = record
|
|
NestedValue: Integer;
|
|
NestedString: string;
|
|
end;
|
|
|
|
// A record that contains another record field of type TDataRecord
|
|
TOuterTestRecord = record
|
|
OuterValue: Integer;
|
|
MyNestedRecord: TDataRecord;
|
|
end;
|
|
|
|
[TestFixture]
|
|
TTestDataRecord = class(TObject)
|
|
public
|
|
[Test]
|
|
[IgnoreMemoryLeaks]
|
|
procedure TestLayoutCreation;
|
|
|
|
[Test]
|
|
[IgnoreMemoryLeaks]
|
|
procedure TestCreateFromInstanceAndGetValue;
|
|
|
|
[Test]
|
|
[IgnoreMemoryLeaks]
|
|
procedure TestSetValueAndGetValue;
|
|
|
|
[Test]
|
|
// [IgnoreMemoryLeaks]
|
|
procedure TestNestedDataRecord;
|
|
|
|
[Test]
|
|
// [IgnoreMemoryLeaks]
|
|
procedure TestInternalRecordAssignment;
|
|
|
|
[Test]
|
|
// [IgnoreMemoryLeaks]
|
|
procedure TestNestedSetValueAndGetValue;
|
|
end;
|
|
|
|
implementation
|
|
|
|
{ TTestDataRecord }
|
|
|
|
procedure TTestDataRecord.TestLayoutCreation;
|
|
var
|
|
layout: TDataRecord.TLayout;
|
|
idx: Integer;
|
|
begin
|
|
// Test: Create layout from a record type
|
|
layout := TDataRecord.TLayout.FromRecord<TMyTestRecord>;
|
|
|
|
// Assert: Check field count
|
|
Assert.IsTrue(Length(layout.Fields) = 7, 'Layout should have 7 fields');
|
|
|
|
// Assert: Check specific fields for correct type mapping
|
|
idx := layout.IndexOf('MyTimestamp');
|
|
Assert.IsTrue(idx > -1, 'Field MyTimestamp not found');
|
|
Assert.AreEqual(TDataRecord.TFieldType.dfTimestamp, layout.Fields[idx].FieldType, 'MyTimestamp should be mapped to dfTimestamp');
|
|
|
|
idx := layout.IndexOf('MyInteger');
|
|
Assert.IsTrue(idx > -1, 'Field MyInteger not found');
|
|
Assert.AreEqual(TDataRecord.TFieldType.dfInteger, layout.Fields[idx].FieldType, 'MyInteger should be mapped to dfInteger');
|
|
|
|
idx := layout.IndexOf('MyString');
|
|
Assert.IsTrue(idx > -1, 'Field MyString not found');
|
|
Assert.AreEqual(TDataRecord.TFieldType.dfString, layout.Fields[idx].FieldType, 'MyString should be mapped to dfString');
|
|
|
|
idx := layout.IndexOf('MySingle');
|
|
Assert.IsTrue(idx > -1, 'Field MySingle not found');
|
|
Assert.AreEqual(TDataRecord.TFieldType.dfFloat, layout.Fields[idx].FieldType, 'MySingle should be mapped to dfFloat');
|
|
|
|
idx := layout.IndexOf('MyRecord');
|
|
Assert.IsTrue(idx > -1, 'Field MyRecord not found');
|
|
Assert.AreEqual(TDataRecord.TFieldType.dfRecord, layout.Fields[idx].FieldType, 'MyRecord should be mapped to dfRecord');
|
|
end;
|
|
|
|
procedure TTestDataRecord.TestCreateFromInstanceAndGetValue;
|
|
var
|
|
srcRecord: TMyTestRecord;
|
|
dataRecord: TDataRecord;
|
|
begin
|
|
// Setup: Create and populate a source record
|
|
srcRecord.MyInteger := 12345;
|
|
srcRecord.MyInt64 := 9876543210;
|
|
srcRecord.MySingle := 123.456;
|
|
srcRecord.MyDouble := 789.012345;
|
|
srcRecord.MyString := 'Hello Delphi!';
|
|
srcRecord.MyTimestamp := EncodeDateTime(2024, 7, 19, 10, 30, 0, 0);
|
|
srcRecord.MyRecord := default(TDataRecord); // Not testing nested here
|
|
|
|
// Test: Create a TDataRecord from the source record instance
|
|
dataRecord := TDataRecord.FromRecord<TMyTestRecord>(srcRecord);
|
|
|
|
// Assert: Retrieve each value and check for correctness
|
|
Assert.AreEqual(srcRecord.MyInt64, dataRecord.GetValue<Int64>('MyInt64'), 'Int64 value mismatch');
|
|
Assert.AreEqual(srcRecord.MyInteger, dataRecord.GetValue<Integer>('MyInteger'), 'Integer value mismatch');
|
|
Assert.AreEqual(srcRecord.MyString, dataRecord.GetValue<string>('MyString'), 'String value mismatch');
|
|
Assert.AreEqual(srcRecord.MyTimestamp, dataRecord.GetValue<TDateTime>('MyTimestamp'), 'TDateTime value mismatch');
|
|
|
|
// Assert: Check float values with a tolerance for precision differences
|
|
Assert.AreEqual(srcRecord.MySingle, dataRecord.GetValue<Single>('MySingle'), 1e-6, 'Single value mismatch');
|
|
Assert.AreEqual(srcRecord.MyDouble, dataRecord.GetValue<Double>('MyDouble'), 1e-9, 'Double value mismatch');
|
|
|
|
// Assert: Test type promotion (reading an Integer as Int64)
|
|
Assert.IsTrue(srcRecord.MyInteger = dataRecord.GetValue<Int64>('MyInteger'), 'Integer to Int64 promotion failed');
|
|
end;
|
|
|
|
procedure TTestDataRecord.TestSetValueAndGetValue;
|
|
var
|
|
dataRecord: TDataRecord;
|
|
testInt: Integer;
|
|
testInt64: Int64;
|
|
testSingle: Single;
|
|
testDouble: Double;
|
|
testString: string;
|
|
testTimestamp: TDateTime;
|
|
begin
|
|
// Setup: Create an empty TDataRecord with the layout of TMyTestRecord
|
|
dataRecord := TDataRecord.FromRecord<TMyTestRecord>;
|
|
|
|
// Setup: Define test values
|
|
testInt := 54321;
|
|
testInt64 := 12345678901;
|
|
testSingle := 987.654;
|
|
testDouble := 543.210987;
|
|
testString := 'Testing SetValue';
|
|
testTimestamp := Now;
|
|
|
|
// Test: Set values for each field by name
|
|
dataRecord.SetValue<Integer>('MyInteger', testInt);
|
|
dataRecord.SetValue<Int64>('MyInt64', testInt64);
|
|
dataRecord.SetValue<Single>('MySingle', testSingle);
|
|
dataRecord.SetValue<Double>('MyDouble', testDouble);
|
|
dataRecord.SetValue<string>('MyString', testString);
|
|
dataRecord.SetValue<TDateTime>('MyTimestamp', testTimestamp);
|
|
|
|
// Assert: Retrieve the values and check if they match what was set
|
|
Assert.AreEqual(testInt, dataRecord.GetValue<Integer>('MyInteger'), 'SetValue failed for Integer');
|
|
Assert.AreEqual(testInt64, dataRecord.GetValue<Int64>('MyInt64'), 'SetValue failed for Int64');
|
|
Assert.AreEqual(testString, dataRecord.GetValue<string>('MyString'), 'SetValue failed for String');
|
|
Assert.AreEqual(testTimestamp, dataRecord.GetValue<TDateTime>('MyTimestamp'), 'SetValue failed for TDateTime');
|
|
|
|
Assert.AreEqual(testSingle, dataRecord.GetValue<Single>('MySingle'), 1e-6, 'SetValue failed for Single');
|
|
Assert.AreEqual(testDouble, dataRecord.GetValue<Double>('MyDouble'), 1e-9, 'SetValue failed for Double');
|
|
end;
|
|
|
|
procedure TTestDataRecord.TestNestedDataRecord;
|
|
var
|
|
nestedSrc: TNestedTestRecord;
|
|
nestedDataRecord: TDataRecord;
|
|
outerSrc: TOuterTestRecord;
|
|
mainDataRecord: TDataRecord;
|
|
retrievedNestedRecord: TDataRecord;
|
|
begin
|
|
// Setup: Create the nested record and convert it to a TDataRecord
|
|
nestedSrc.NestedValue := 999;
|
|
const str = 'Nested Record Test';
|
|
nestedSrc.NestedString := str;
|
|
nestedDataRecord := TDataRecord.FromRecord<TNestedTestRecord>(nestedSrc);
|
|
|
|
// Setup: Create the outer record containing the nested TDataRecord
|
|
outerSrc.OuterValue := 111;
|
|
outerSrc.MyNestedRecord := nestedDataRecord;
|
|
|
|
// Test: Create the main TDataRecord from the outer record instance
|
|
mainDataRecord := TDataRecord.FromRecord<TOuterTestRecord>(outerSrc);
|
|
|
|
// Assert: Retrieve the nested record and check its contents
|
|
retrievedNestedRecord := mainDataRecord.GetValue<TDataRecord>('MyNestedRecord');
|
|
|
|
Assert.IsNotNull(retrievedNestedRecord.Layout.Fields, 'Nested record layout should not be nil');
|
|
Assert.IsTrue(Length(retrievedNestedRecord.Layout.Fields) = 2, 'Nested record should have 2 fields');
|
|
|
|
// Assert values within the nested record
|
|
Assert.AreEqual(999, retrievedNestedRecord.GetValue<Integer>('NestedValue'), 'Nested integer value mismatch');
|
|
Assert.AreEqual(str, retrievedNestedRecord.GetValue<string>('NestedString'), 'Nested string value mismatch');
|
|
|
|
// Assert value in the outer record
|
|
Assert.AreEqual(111, mainDataRecord.GetValue<Integer>('OuterValue'), 'Outer integer value mismatch');
|
|
end;
|
|
|
|
procedure TTestDataRecord.TestInternalRecordAssignment;
|
|
var
|
|
nestedSrc: TNestedTestRecord;
|
|
nestedDataRecord: TDataRecord;
|
|
outerSrc: TOuterTestRecord;
|
|
mainDataRecord: TDataRecord;
|
|
retrievedNestedRecord: TDataRecord;
|
|
begin
|
|
// Setup: Create the nested record and convert it to a TDataRecord
|
|
const str = 'Nested Record Test';
|
|
nestedSrc.NestedString := str;
|
|
nestedDataRecord := TDataRecord.FromRecord<TNestedTestRecord>(nestedSrc);
|
|
|
|
// Setup: Create the outer record containing the nested TDataRecord
|
|
outerSrc.MyNestedRecord := nestedDataRecord;
|
|
|
|
// Place a record on the heap. FAILS: This erases the nested record data!! -- Fixed 25.07.2025!
|
|
TDataRecord.FromRecord<TOuterTestRecord>(outerSrc);
|
|
|
|
// Test: Create the main TDataRecord from the outer record instance
|
|
mainDataRecord := TDataRecord.FromRecord<TOuterTestRecord>(outerSrc);
|
|
|
|
// Assert: Retrieve the nested record and check its contents
|
|
retrievedNestedRecord := mainDataRecord.GetValue<TDataRecord>('MyNestedRecord');
|
|
|
|
// Assert values within the nested record
|
|
Assert.AreEqual(str, retrievedNestedRecord.GetValue<string>('NestedString'), 'Nested string value mismatch');
|
|
end;
|
|
|
|
procedure TTestDataRecord.TestNestedSetValueAndGetValue;
|
|
var
|
|
outerRecord: TDataRecord;
|
|
nestedRecord: TDataRecord;
|
|
retrievedNestedRecord: TDataRecord;
|
|
begin
|
|
// Setup: Create an empty TDataRecord for the outer structure
|
|
outerRecord := TDataRecord.FromRecord<TOuterTestRecord>;
|
|
|
|
// Setup: Create a TDataRecord for the nested structure and populate it
|
|
nestedRecord := TDataRecord.FromRecord<TNestedTestRecord>;
|
|
nestedRecord.SetValue<Integer>('NestedValue', 888);
|
|
nestedRecord.SetValue<string>('NestedString', 'Manual Nested Set');
|
|
|
|
// Test: Set the nested record and another value in the outer record
|
|
outerRecord.SetValue<Integer>('OuterValue', 222);
|
|
outerRecord.SetValue<TDataRecord>('MyNestedRecord', nestedRecord);
|
|
|
|
// Assert: Retrieve the nested record and check its contents
|
|
retrievedNestedRecord := outerRecord.GetValue<TDataRecord>('MyNestedRecord');
|
|
Assert.IsNotNull(retrievedNestedRecord.Layout.Fields, 'Retrieved nested record layout should not be nil');
|
|
Assert.IsTrue(Length(retrievedNestedRecord.Layout.Fields) = 2, 'Retrieved nested record should have 2 fields');
|
|
|
|
Assert.AreEqual(888, retrievedNestedRecord.GetValue<Integer>('NestedValue'), 'Nested integer check failed after SetValue');
|
|
Assert
|
|
.AreEqual('Manual Nested Set', retrievedNestedRecord.GetValue<string>('NestedString'), 'Nested string check failed after SetValue');
|
|
|
|
// Assert: Check the outer value as well
|
|
Assert.AreEqual(222, outerRecord.GetValue<Integer>('OuterValue'), 'Outer value check failed after SetValue');
|
|
end;
|
|
|
|
initialization
|
|
TDUnitX.RegisterTestFixture(TTestDataRecord);
|
|
|
|
end.
|