Type System

Src/Data/TestDataTypes.pas

@@ -51,12 +51,12 @@ uses
 
 procedure TMyTestObject.TestRecords;
 var
-    intType: IDataType;
-    floatType: IDataType;
-    personType1, personType2, otherType: IDataRecordType;
-    personValue: IDataValue;
-    idValue: IDataOrdinalValue;
-    floatValue: IDataFloatValue;
+    intType: TDataOrdinalType;
+    floatType: TDataFloatType;
+    personType1, personType2, otherType: TDataRecordType;
+    personValue: TDataRecordValue;
+    idValue: TDataOrdinalValue;
+    floatValue: TDataFloatValue;
 begin
     // This test covers the optimized implementation for 2 fields.
     // --- 1. Setup: Define base types and a record structure ---
@@ -67,38 +67,38 @@ begin
     personType1 := TDataType.RecordOf([TRecordField.Create('ID', intType), TRecordField.Create('Value', floatType)]);
 
     // Assertions for the created type
-    Assert.IsNotNull(personType1, 'RecordType should be created');
+    Assert.IsNotNull(IDataRecordType(personType1), 'RecordType should be created');
     Assert.AreEqual(2, personType1.FieldCount, 'FieldCount should be 2');
     Assert.AreEqual('ID', personType1.Fields[0].Name, 'First field name should be ID');
-    Assert.AreSame(intType, personType1.Fields[0].DataType, 'First field type should be Integer');
+    Assert.AreSame(IDataType(intType), personType1.Fields[0].DataType, 'First field type should be Integer');
     Assert.AreEqual('Value', personType1.Fields[1].Name, 'Second field name should be Value');
-    Assert.AreSame(floatType, personType1.Fields[1].DataType, 'Second field type should be Float');
+    Assert.AreSame(IDataType(floatType), personType1.Fields[1].DataType, 'Second field type should be Float');
     Assert.AreEqual(0, personType1.IndexOf('ID'), 'IndexOf ID should be 0');
     Assert.AreEqual(1, personType1.IndexOf('Value'), 'IndexOf Value should be 1');
-    Assert.AreEqual('Record<ID: Integer, Value: Float>', personType1.Name, 'Type name should match expected format');
+    Assert.AreEqual('Record<ID: Integer, Value: Float>', TDataType(personType1).Name, 'Type name should match expected format');
 
     // Test if the same definition returns the same cached instance
     personType2 := TDataType.RecordOf([TRecordField.Create('ID', intType), TRecordField.Create('Value', floatType)]);
-    Assert.AreSame(personType1, personType2, 'Types should be cached and return the same instance');
+    Assert.AreSame(IDataRecordType(personType1), IDataRecordType(personType2), 'Types should be cached and return the same instance');
 
     // Test if a different definition returns a new instance
     otherType := TDataType.RecordOf([TRecordField.Create('ID', intType), TRecordField.Create('Data', floatType)]);
-    Assert.AreNotSame(personType1, otherType, 'Different definitions should result in different types');
+    Assert.AreNotSame(IDataRecordType(personType1), IDataRecordType(otherType), 'Different definitions should result in different types');
 
     // --- 3. Test Value Creation and Access ---
     personValue := personType1.CreateValue([TDataValue.FromOrdinal(123), TDataValue.FromFloat(45.67)]);
 
-    Assert.IsNotNull(TDataValue(personValue).AsRecord, 'RecordValue should be created');
-    Assert.AreSame(personType1, TDataValue(personValue).DataType, 'Value should have the correct data type');
+    Assert.IsNotNull(IDataRecordValue(personValue), 'RecordValue should be created');
+    Assert.AreSame(IDataRecordType(personType1), IDataRecordValue(personValue).DataType, 'Value should have the correct data type');
 
     // Access by index
-    idValue := TDataValue(TDataValue(personValue).AsRecord.Items[0]).AsOrdinal;
+    idValue := TDataValue(personValue.Items[0]).AsOrdinal;
     Assert.AreEqual(Int64(123), idValue.Value, 'Value at index 0 is incorrect');
-    floatValue := TDataValue(TDataValue(personValue).AsRecord.Items[1]).AsFloat;
+    floatValue := TDataValue(personValue.Items[1]).AsFloat;
     Assert.AreEqual(45.67, floatValue.Value, 'Value at index 1 is incorrect');
 
     // Access by name
-    floatValue := TDataValue(TDataValue(personValue).AsRecord.Items[personType1.IndexOf('Value')]).AsFloat;
+    floatValue := TDataValue(personValue.Items[personType1.IndexOf('Value')]).AsFloat;
     Assert.AreEqual(45.67, floatValue.Value, 'Value accessed by name is incorrect');
 
     // --- 4. Test Validation and Error Handling ---
@@ -130,8 +130,8 @@ end;
 
 procedure TMyTestObject.TestRecords_Generic;
 var
-    dataType: IDataRecordType;
-    dataValue: IDataRecordValue;
+    dataType: TDataRecordType;
+    dataValue: TDataRecordValue;
 begin
     // Test the generic implementation for records with > 2 fields.
     dataType :=
@@ -144,20 +144,20 @@ begin
         );
     dataValue := dataType.CreateValue([TDataValue.FromOrdinal(1), TDataValue.FromText('two'), TDataValue.FromFloat(3.0)]);
 
-    Assert.IsNotNull(dataValue, 'Generic record value should be created');
+    Assert.IsNotNull(IDataRecordValue(dataValue), 'Generic record value should be created');
     Assert.AreEqual(3, dataType.FieldCount, 'Generic record should have 3 fields');
     Assert.AreEqual(Int64(1), TDataValue(dataValue.Items[0]).AsOrdinal.Value, 'Field A is incorrect');
     Assert.AreEqual('two', TDataValue(dataValue.Items[1]).AsText.Value, 'Field B is incorrect');
     Assert.AreEqual(3.0, TDataValue(dataValue.Items[2]).AsFloat.Value, 'Field C is incorrect');
-    Assert.AreEqual('<A: 1, B: two, C: 3>', dataValue.AsString, 'Generic record AsString is incorrect');
+    Assert.AreEqual('<A: 1, B: two, C: 3>', IDataRecordValue(dataValue).AsString, 'Generic record AsString is incorrect');
 end;
 
 procedure TMyTestObject.TestTuples;
 var
-    intValue: IDataValue;
-    floatValue: IDataValue;
-    tuple1, tuple2, tuple3: IDataTupleValue;
-    type1, type2, type3: IDataType;
+    intValue: TDataOrdinalValue;
+    floatValue: TDataFloatValue;
+    tuple1, tuple2, tuple3: TDataTupleValue;
+    type1, type2, type3: IDataType; // Keep as interface to test AreSame on the raw interface pointer
 begin
     // This test covers optimized implementations for 1 and 2 elements.
     // --- 1. Setup: Create some values ---
@@ -167,10 +167,10 @@ begin
     // --- 2. Test Value Creation and basic properties ---
     tuple1 := TDataValue.FromTuple([intValue, floatValue]);
 
-    Assert.IsNotNull(tuple1, 'Tuple value should be created');
-    Assert.AreEqual(2, TDataValue(tuple1).AsTuple.ItemCount, 'ItemCount should be on the value');
-    Assert.AreSame(intValue, TDataValue(tuple1).AsTuple.Items[0], 'Item at index 0 is incorrect');
-    Assert.AreSame(floatValue, TDataValue(tuple1).AsTuple.Items[1], 'Item at index 1 is incorrect');
+    Assert.IsNotNull(IDataTupleValue(tuple1), 'Tuple value should be created');
+    Assert.AreEqual(2, tuple1.ItemCount, 'ItemCount should be on the value');
+    Assert.AreSame(IDataValue(intValue), tuple1.Items[0], 'Item at index 0 is incorrect');
+    Assert.AreSame(IDataValue(floatValue), tuple1.Items[1], 'Item at index 1 is incorrect');
 
     // --- 3. Test Singleton Type Behavior ---
     // Create more tuples with different structures
@@ -178,9 +178,9 @@ begin
     tuple3 := TDataValue.FromTuple([intValue]);
 
     // Access the DataType via the underlying interface
-    type1 := tuple1.DataType;
-    type2 := tuple2.DataType;
-    type3 := tuple3.DataType;
+    type1 := IDataValue(tuple1).DataType;
+    type2 := IDataValue(tuple2).DataType;
+    type3 := IDataValue(tuple3).DataType;
 
     Assert.IsNotNull(type1, 'DataType interface should be accessible');
     Assert.AreEqual('Tuple', type1.Name, 'The type name for all tuples should be Tuple');
@@ -192,7 +192,7 @@ end;
 
 procedure TMyTestObject.TestTuples_Generic;
 var
-    tupleValue: IDataTupleValue;
+    tupleValue: TDataTupleValue;
 begin
     // Test the generic implementation for tuples with > 5 elements.
     tupleValue :=
@@ -207,19 +207,20 @@ begin
             ]
         );
 
-    Assert.IsNotNull(tupleValue, 'Generic tuple value should be created');
+    Assert.IsNotNull(IDataTupleValue(tupleValue), 'Generic tuple value should be created');
     Assert.AreEqual(6, tupleValue.ItemCount, 'Generic tuple should have 6 items');
     Assert.AreEqual(Int64(6), TDataValue(tupleValue.Items[5]).AsOrdinal.Value, 'Last item is incorrect');
-    Assert.AreEqual('(1, 2, 3, 4, 5, 6)', tupleValue.AsString, 'Generic tuple AsString is incorrect');
+    Assert.AreEqual('(1, 2, 3, 4, 5, 6)', IDataTupleValue(tupleValue).AsString, 'Generic tuple AsString is incorrect');
 end;
 
 procedure TMyTestObject.TestArrays;
 var
-    intType: IDataType;
-    floatType: IDataType;
-    intArrayType1, intArrayType2, floatArrayType: IDataArrayType;
-    arrayValue: IDataArrayValue;
-    v1, v2: IDataValue;
+    intType: TDataOrdinalType;
+    floatType: TDataFloatType;
+    intArrayType1, intArrayType2: TDataArrayType;
+    floatArrayType: TDataArrayType;
+    arrayValue: TDataArrayValue;
+    v1, v2: TDataOrdinalValue;
 begin
     // --- 1. Setup ---
     intType := TDataType.Ordinal;
@@ -228,30 +229,34 @@ begin
     // --- 2. Test Type Creation and Caching ---
     intArrayType1 := TDataType.ArrayOf(intType);
 
-    Assert.IsNotNull(intArrayType1, 'ArrayType should be created');
-    Assert.AreSame(intType, intArrayType1.ElementType, 'ElementType should be Integer');
-    Assert.AreEqual('Array<Integer>', intArrayType1.Name, 'Type name should be Array<Integer>');
+    Assert.IsNotNull(IDataArrayType(intArrayType1), 'ArrayType should be created');
+    Assert.AreSame(IDataType(intType), intArrayType1.ElementType, 'ElementType should be Integer');
+    Assert.AreEqual('Array<Integer>', TDataType(intArrayType1).Name, 'Type name should be Array<Integer>');
 
     // Test caching
     intArrayType2 := TDataType.ArrayOf(intType);
-    Assert.AreSame(intArrayType1, intArrayType2, 'Array types should be cached');
+    Assert.AreSame(IDataArrayType(intArrayType1), IDataArrayType(intArrayType2), 'Array types should be cached');
 
     // Test uniqueness
     floatArrayType := TDataType.ArrayOf(floatType);
-    Assert.AreNotSame(intArrayType1, floatArrayType, 'Different element types should result in different array types');
-    Assert.AreEqual('Array<Float>', floatArrayType.Name, 'Type name should be Array<Float>');
+    Assert.AreNotSame(
+        IDataArrayType(intArrayType1),
+        IDataArrayType(floatArrayType),
+        'Different element types should result in different array types'
+    );
+    Assert.AreEqual('Array<Float>', TDataType(floatArrayType).Name, 'Type name should be Array<Float>');
 
     // --- 3. Test Value Creation and Access ---
     v1 := TDataValue.FromOrdinal(10);
     v2 := TDataValue.FromOrdinal(20);
     arrayValue := intArrayType1.CreateValue([v1, v2]);
 
-    Assert.IsNotNull(arrayValue, 'ArrayValue should be created');
-    Assert.AreEqual(2, TDataValue(arrayValue).AsArray.ElementCount, 'ElementCount should be 2');
+    Assert.IsNotNull(IDataArrayValue(arrayValue), 'ArrayValue should be created');
+    Assert.AreEqual(2, arrayValue.ElementCount, 'ElementCount should be 2');
 
     // Access items and check values
-    Assert.AreEqual(Int64(10), TDataValue(TDataValue(arrayValue).AsArray.Items[0]).AsOrdinal.Value, 'Item at index 0 is incorrect');
-    Assert.AreEqual(Int64(20), TDataValue(TDataValue(arrayValue).AsArray.Items[1]).AsOrdinal.Value, 'Item at index 1 is incorrect');
+    Assert.AreEqual(Int64(10), TDataValue(arrayValue.Items[0]).AsOrdinal.Value, 'Item at index 0 is incorrect');
+    Assert.AreEqual(Int64(20), TDataValue(arrayValue.Items[1]).AsOrdinal.Value, 'Item at index 1 is incorrect');
 
     // --- 4. Test Validation and Error Handling ---
     // Test creating an array with a nil element type
@@ -271,51 +276,51 @@ end;
 
 procedure TMyTestObject.TestArrays_OptimizedAndGeneric;
 var
-    arrayType: IDataArrayType;
-    empty1, empty2, single, generic: IDataArrayValue;
+    arrayType: TDataArrayType;
+    empty1, empty2, single, generic: TDataArrayValue;
 begin
     arrayType := TDataType.ArrayOf(TDataType.Ordinal);
 
     // Test optimized path for 0 elements (cached singleton per type)
     empty1 := arrayType.CreateValue([]);
     empty2 := arrayType.CreateValue([]);
-    Assert.IsNotNull(empty1, 'Empty array value should be created');
-    Assert.AreSame(empty1, empty2, 'Empty array value should be cached and reused');
+    Assert.IsNotNull(IDataArrayValue(empty1), 'Empty array value should be created');
+    Assert.AreSame(IDataArrayValue(empty1), IDataArrayValue(empty2), 'Empty array value should be cached and reused');
     Assert.AreEqual(0, empty1.ElementCount, 'Empty array should have 0 elements');
-    Assert.AreEqual('[]', empty1.AsString, 'Empty array AsString is incorrect');
+    Assert.AreEqual('[]', IDataArrayValue(empty1).AsString, 'Empty array AsString is incorrect');
 
     // Test optimized path for 1 element
     single := arrayType.CreateValue([TDataValue.FromOrdinal(42)]);
-    Assert.IsNotNull(single, 'Single element array should be created');
+    Assert.IsNotNull(IDataArrayValue(single), 'Single element array should be created');
     Assert.AreEqual(1, single.ElementCount, 'Single element array should have 1 element');
     Assert.AreEqual(Int64(42), TDataValue(single.Items[0]).AsOrdinal.Value, 'Single element value is incorrect');
-    Assert.AreEqual('[42]', single.AsString, 'Single element array AsString is incorrect');
+    Assert.AreEqual('[42]', IDataArrayValue(single).AsString, 'Single element array AsString is incorrect');
 
     // Test generic path for > 1 elements
     generic := arrayType.CreateValue([TDataValue.FromOrdinal(1), TDataValue.FromOrdinal(2), TDataValue.FromOrdinal(3)]);
-    Assert.IsNotNull(generic, 'Generic array should be created');
+    Assert.IsNotNull(IDataArrayValue(generic), 'Generic array should be created');
     Assert.AreEqual(3, generic.ElementCount, 'Generic array should have 3 elements');
-    Assert.AreEqual('[1, 2, 3]', generic.AsString, 'Generic array AsString is incorrect');
+    Assert.AreEqual('[1, 2, 3]', IDataArrayValue(generic).AsString, 'Generic array AsString is incorrect');
 end;
 
 procedure TMyTestObject.TestTexts;
 var
-    textType: IDataTextType;
-    textValue1, textValue2: IDataTextValue;
+    textType: TDataTextType;
+    textValue1, textValue2: TDataTextValue;
     dataValue: IDataValue;
 begin
     // --- 1. Test Type Creation ---
     textType := TDataType.Text;
 
-    Assert.IsNotNull(textType, 'TextType should be created');
-    Assert.AreEqual('Text', textType.Name, 'Type name should be Text');
-    Assert.AreEqual(dkText, textType.Kind, 'Type kind should be dkText');
+    Assert.IsNotNull(IDataTextType(textType), 'TextType should be created');
+    Assert.AreEqual('Text', TDataType(textType).Name, 'Type name should be Text');
+    Assert.AreEqual(dkText, TDataType(textType).Kind, 'Type kind should be dkText');
 
     // --- 2. Test Value Creation and Access ---
     textValue1 := TDataValue.FromText('Hello World');
 
-    Assert.IsNotNull(textValue1, 'TextValue should be created');
-    Assert.AreSame(textType, textValue1.DataType, 'Value should have the correct data type');
+    Assert.IsNotNull(IDataTextValue(textValue1), 'TextValue should be created');
+    Assert.AreSame(IDataType(textType), IDataTextValue(textValue1).DataType, 'Value should have the correct data type');
     Assert.AreEqual('Hello World', textValue1.Value, 'Value should be ''Hello World''');
 
     // Test another text value
@@ -334,65 +339,65 @@ end;
 
 procedure TMyTestObject.TestTexts_OptimizedEmpty;
 var
-    empty1, empty2: IDataTextValue;
+    empty1, empty2: TDataTextValue;
 begin
     // Test the singleton implementation for the empty string.
     empty1 := TDataValue.FromText('');
     empty2 := TDataValue.FromText('');
 
-    Assert.IsNotNull(empty1, 'Empty text value should be created');
-    Assert.AreSame(empty1, empty2, 'Empty text value should be a singleton');
+    Assert.IsNotNull(IDataTextValue(empty1), 'Empty text value should be created');
+    Assert.AreSame(IDataTextValue(empty1), IDataTextValue(empty2), 'Empty text value should be a singleton');
     Assert.AreEqual('', empty1.Value, 'Value of empty text should be empty');
-    Assert.AreEqual('', empty1.AsString, 'AsString of empty text should be empty');
+    Assert.AreEqual('', IDataTextValue(empty1).AsString, 'AsString of empty text should be empty');
 end;
 
 procedure TMyTestObject.TestFloats_OptimizedAndGeneric;
 var
-    zero1, zero2, nan1, nan2, generic: IDataFloatValue;
+    zero1, zero2, nan1, nan2, generic: TDataFloatValue;
 begin
     // Test singleton for 0.0
     zero1 := TDataValue.FromFloat(0.0);
     zero2 := TDataValue.FromFloat(0.0);
-    Assert.IsNotNull(zero1, 'Zero float should be created');
-    Assert.AreSame(zero1, zero2, 'Zero float should be a singleton');
+    Assert.IsNotNull(IDataFloatValue(zero1), 'Zero float should be created');
+    Assert.AreSame(IDataFloatValue(zero1), IDataFloatValue(zero2), 'Zero float should be a singleton');
     Assert.AreEqual(0.0, zero1.Value, 'Value of zero float is incorrect');
 
     // Test singleton for NaN
     nan1 := TDataValue.FromFloat(NaN);
     nan2 := TDataValue.FromFloat(NaN);
-    Assert.IsNotNull(nan1, 'NaN float should be created');
-    Assert.AreSame(nan1, nan2, 'NaN float should be a singleton');
+    Assert.IsNotNull(IDataFloatValue(nan1), 'NaN float should be created');
+    Assert.AreSame(IDataFloatValue(nan1), IDataFloatValue(nan2), 'NaN float should be a singleton');
     Assert.IsTrue(IsNaN(nan1.Value), 'Value of NaN float should be NaN');
-    Assert.AreEqual('NaN', nan1.AsString, 'NaN AsString is incorrect');
+    Assert.AreEqual('NaN', IDataFloatValue(nan1).AsString, 'NaN AsString is incorrect');
 
     // Test generic path
     generic := TDataValue.FromFloat(123.45);
-    Assert.IsNotNull(generic, 'Generic float should be created');
-    Assert.AreNotSame(zero1, generic, 'Generic float should not be the zero singleton');
-    Assert.AreNotSame(nan1, generic, 'Generic float should not be the NaN singleton');
+    Assert.IsNotNull(IDataFloatValue(generic), 'Generic float should be created');
+    Assert.AreNotSame(IDataFloatValue(zero1), IDataFloatValue(generic), 'Generic float should not be the zero singleton');
+    Assert.AreNotSame(IDataFloatValue(nan1), IDataFloatValue(generic), 'Generic float should not be the NaN singleton');
     Assert.AreEqual(123.45, generic.Value, 'Value of generic float is incorrect');
 end;
 
 procedure TMyTestObject.TestTimestamps;
 var
-    tsType: IDataTimestampType;
-    tsValue1, tsValue2: IDataTimestampValue;
+    tsType: TDataTimestampType;
+    tsValue1, tsValue2: TDataTimestampValue;
     dataValue: IDataValue;
     now: TDateTime;
 begin
     // --- 1. Test Type Creation ---
     tsType := TDataType.Timestamp;
 
-    Assert.IsNotNull(tsType, 'TimestampType should be created');
-    Assert.AreEqual('Timestamp', tsType.Name, 'Type name should be Timestamp');
-    Assert.AreEqual(dkTimestamp, tsType.Kind, 'Type kind should be dkTimestamp');
+    Assert.IsNotNull(IDataTimestampType(tsType), 'TimestampType should be created');
+    Assert.AreEqual('Timestamp', TDataType(tsType).Name, 'Type name should be Timestamp');
+    Assert.AreEqual(dkTimestamp, TDataType(tsType).Kind, 'Type kind should be dkTimestamp');
 
     // --- 2. Test Value Creation and Access ---
     now := System.Sysutils.Now;
     tsValue1 := TDataValue.FromTimestamp(now);
 
-    Assert.IsNotNull(tsValue1, 'TimestampValue should be created');
-    Assert.AreSame(tsType, tsValue1.DataType, 'Value should have the correct data type');
+    Assert.IsNotNull(IDataTimestampValue(tsValue1), 'TimestampValue should be created');
+    Assert.AreSame(IDataType(tsType), IDataTimestampValue(tsValue1).DataType, 'Value should have the correct data type');
     Assert.AreEqual(now, tsValue1.Value, 'Value should be the same');
 
     // Test another text value
@@ -414,15 +419,15 @@ end;
 
 procedure TMyTestObject.TestEnums;
 var
-    colorType: IDataEnumType;
-    red, green, blue: IDataEnumValue;
+    colorType: TDataEnumType;
+    red, green, blue: TDataEnumValue;
 begin
     // --- 1. Test Type Creation ---
     colorType := TDataType.EnumOf('Color', ['Red', 'Green', 'Blue']);
 
-    Assert.IsNotNull(colorType, 'EnumType should be created');
-    Assert.AreEqual('Color', colorType.Name, 'Name should be Color');
-    Assert.AreEqual(dkEnum, colorType.Kind, 'Kind should be dkEnum');
+    Assert.IsNotNull(IDataEnumType(colorType), 'EnumType should be created');
+    Assert.AreEqual('Color', TDataType(colorType).Name, 'Name should be Color');
+    Assert.AreEqual(dkEnum, TDataType(colorType).Kind, 'Kind should be dkEnum');
     Assert.AreEqual(3, colorType.IdentifierCount, 'IdentifierCount should be 3');
     Assert.AreEqual('Red', colorType.Identifiers[0], 'Identifier at index 0 should be Red');
     Assert.AreEqual('Green', colorType.Identifiers[1], 'Identifier at index 1 should be Green');
@@ -433,17 +438,17 @@ begin
     // --- 2. Test Value Creation and Access ---
     red := colorType.CreateValue(0);
     green := colorType.CreateValue('Green');
-    blue := TDataValue(colorType.CreateValue(2)).AsEnum;
+    blue := colorType.CreateValue(2);
 
-    Assert.IsNotNull(red, 'EnumValue from index should be created');
-    Assert.AreSame(colorType, red.DataType, 'Red should have the correct data type');
+    Assert.IsNotNull(IDataEnumValue(red), 'EnumValue from index should be created');
+    Assert.AreSame(IDataType(colorType), IDataEnumValue(red).DataType, 'Red should have the correct data type');
     Assert.AreEqual(0, red.Value, 'Value of Red should be 0');
-    Assert.AreEqual('Red', red.AsString, 'AsText of Red should be Red');
+    Assert.AreEqual('Red', IDataEnumValue(red).AsString, 'AsText of Red should be Red');
 
-    Assert.IsNotNull(green, 'EnumValue from identifier should be created');
-    Assert.AreSame(colorType, green.DataType, 'Green should have the correct data type');
+    Assert.IsNotNull(IDataEnumValue(green), 'EnumValue from identifier should be created');
+    Assert.AreSame(IDataType(colorType), IDataEnumValue(green).DataType, 'Green should have the correct data type');
     Assert.AreEqual(1, green.Value, 'Value of Green should be 1');
-    Assert.AreEqual('Green', green.AsString, 'AsText of Green should be Green');
+    Assert.AreEqual('Green', IDataEnumValue(green).AsString, 'AsText of Green should be Green');
 
     Assert.AreEqual(2, blue.Value, 'Value of Blue should be 2');
 
@@ -469,64 +474,64 @@ end;
 
 procedure TMyTestObject.TestAsString;
 var
-    ordinalValue: IDataOrdinalValue;
-    floatValue: IDataFloatValue;
-    textValue: IDataTextValue;
-    tsValue: IDataTimestampValue;
-    enumValue: IDataEnumValue;
-    arrayValue: IDataArrayValue;
-    recordValue: IDataRecordValue;
-    tupleValue: IDataTupleValue;
-    colorType: IDataEnumType;
-    personType: IDataRecordType;
-    intArrayType: IDataArrayType;
+    ordinalValue: TDataOrdinalValue;
+    floatValue: TDataFloatValue;
+    textValue: TDataTextValue;
+    tsValue: TDataTimestampValue;
+    enumValue: TDataEnumValue;
+    arrayValue: TDataArrayValue;
+    recordValue: TDataRecordValue;
+    tupleValue: TDataTupleValue;
+    colorType: TDataEnumType;
+    personType: TDataRecordType;
+    intArrayType: TDataArrayType;
     now: TDateTime;
 begin
     // Ordinal
     ordinalValue := TDataValue.FromOrdinal(123);
-    Assert.AreEqual('123', ordinalValue.AsString, 'Ordinal AsString incorrect');
+    Assert.AreEqual('123', IDataOrdinalValue(ordinalValue).AsString, 'Ordinal AsString incorrect');
 
     // Float
     floatValue := TDataValue.FromFloat(45.67);
-    Assert.AreEqual(FloatToStr(45.67), floatValue.AsString, 'Float AsString incorrect');
+    Assert.AreEqual(FloatToStr(45.67), IDataFloatValue(floatValue).AsString, 'Float AsString incorrect');
 
     // Text
     textValue := TDataValue.FromText('Hello');
-    Assert.AreEqual('Hello', textValue.AsString, 'Text AsString incorrect');
+    Assert.AreEqual('Hello', IDataTextValue(textValue).AsString, 'Text AsString incorrect');
 
     // Timestamp
     now := System.Sysutils.Now;
     tsValue := TDataValue.FromTimestamp(now);
-    Assert.AreEqual(DateTimeToStr(now), tsValue.AsString, 'Timestamp AsString incorrect');
+    Assert.AreEqual(DateTimeToStr(now), IDataTimestampValue(tsValue).AsString, 'Timestamp AsString incorrect');
 
     // Enum
     colorType := TDataType.EnumOf('Color', ['Red', 'Green', 'Blue']);
     enumValue := colorType.CreateValue('Green');
-    Assert.AreEqual('Green', enumValue.AsString, 'Enum AsString incorrect');
+    Assert.AreEqual('Green', IDataEnumValue(enumValue).AsString, 'Enum AsString incorrect');
 
     // Array
     intArrayType := TDataType.ArrayOf(TDataType.Ordinal);
     arrayValue := intArrayType.CreateValue([TDataValue.FromOrdinal(1), TDataValue.FromOrdinal(2)]);
-    Assert.AreEqual('[1, 2]', arrayValue.AsString, 'Array AsString incorrect');
+    Assert.AreEqual('[1, 2]', IDataArrayValue(arrayValue).AsString, 'Array AsString incorrect');
 
     // Record
     personType := TDataType.RecordOf([TRecordField.Create('ID', TDataType.Ordinal), TRecordField.Create('Name', TDataType.Text)]);
     recordValue := personType.CreateValue([TDataValue.FromOrdinal(1), TDataValue.FromText('Bob')]);
-    Assert.AreEqual('<ID: 1, Name: Bob>', recordValue.AsString, 'Record AsString incorrect');
+    Assert.AreEqual('<ID: 1, Name: Bob>', IDataRecordValue(recordValue).AsString, 'Record AsString incorrect');
 
     // Tuple
     tupleValue := TDataValue.FromTuple([TDataValue.FromOrdinal(10), TDataValue.FromText('Tuple')]);
-    Assert.AreEqual('(10, Tuple)', tupleValue.AsString, 'Tuple AsString incorrect');
+    Assert.AreEqual('(10, Tuple)', IDataTupleValue(tupleValue).AsString, 'Tuple AsString incorrect');
 end;
 
 procedure TMyTestObject.TestAsTValue;
 var
-    dataValue: IDataValue;
+    dataValue: IDataValue; // Keep as generic interface to test AsTValue
     tv, element: TValue;
     now: TDateTime;
-    colorType: IDataEnumType;
-    intArrayType: IDataArrayType;
-    personType: IDataRecordType;
+    colorType: TDataEnumType;
+    intArrayType: TDataArrayType;
+    personType: TDataRecordType;
 begin
     // --- Ordinal ---
     dataValue := TDataValue.FromOrdinal(123);
@@ -612,11 +617,13 @@ end;
 
 procedure TMyTestObject.TestMethods;
 var
-    ordinalType, textType: IDataType;
-    methodType1, methodType2, otherMethodType: IDataMethodType;
+    ordinalType: TDataOrdinalType;
+    textType: TDataTextType;
+    methodType1, methodType2, otherMethodType: TDataMethodType;
     myFunc: TMethodProc;
-    methodValue: IDataMethodValue;
-    inputValue, resultValue: IDataValue;
+    methodValue: TDataMethodValue;
+    inputValue: TDataOrdinalValue;
+    resultValue: IDataValue;
     tv: TValue;
 begin
     // --- 1. Setup: Define base types ---
@@ -627,27 +634,32 @@ begin
     methodType1 := TDataType.MethodOf(ordinalType, textType);
 
     // Assertions for the created type
-    Assert.IsNotNull(methodType1, 'MethodType should be created');
-    Assert.AreEqual(dkMethod, methodType1.Kind, 'Kind should be dkMethod');
-    Assert.AreSame(ordinalType, methodType1.ArgType, 'ArgType should be Ordinal');
-    Assert.AreSame(textType, methodType1.ResultType, 'ResultType should be Text');
-    Assert.AreEqual('Method<Integer -> Text>', methodType1.Name, 'Type name should match expected format');
+    Assert.IsNotNull(IDataMethodType(methodType1), 'MethodType should be created');
+    Assert.AreEqual(dkMethod, TDataType(methodType1).Kind, 'Kind should be dkMethod');
+    Assert.AreSame(IDataType(ordinalType), methodType1.ArgType, 'ArgType should be Ordinal');
+    Assert.AreSame(IDataType(textType), methodType1.ResultType, 'ResultType should be Text');
+    Assert.AreEqual('Method<Integer -> Text>', TDataType(methodType1).Name, 'Type name should match expected format');
 
     // Test if the same definition returns the same cached instance
     methodType2 := TDataType.MethodOf(ordinalType, textType);
-    Assert.AreSame(methodType1, methodType2, 'Method types should be cached and return the same instance');
+    Assert
+        .AreSame(IDataMethodType(methodType1), IDataMethodType(methodType2), 'Method types should be cached and return the same instance');
 
     // Test if a different definition returns a new instance
     otherMethodType := TDataType.MethodOf(textType, ordinalType);
-    Assert.AreNotSame(methodType1, otherMethodType, 'Different signatures should result in different types');
-    Assert.AreEqual('Method<Text -> Integer>', otherMethodType.Name, 'Name of other method type is incorrect');
+    Assert.AreNotSame(
+        IDataMethodType(methodType1),
+        IDataMethodType(otherMethodType),
+        'Different signatures should result in different types'
+    );
+    Assert.AreEqual('Method<Text -> Integer>', TDataType(otherMethodType).Name, 'Name of other method type is incorrect');
 
     // --- 3. Test Value Creation ---
     // Define a function that matches the signature Ordinal -> Text
     myFunc :=
         function(const AValue: IDataValue): IDataValue
         var
-            ordinalValue: IDataOrdinalValue;
+            ordinalValue: TDataOrdinalValue;
             val: Int64;
         begin
             ordinalValue := TDataValue(AValue).AsOrdinal;
@@ -656,8 +668,8 @@ begin
         end;
 
     methodValue := TDataValue.FromMethod(methodType1, myFunc);
-    Assert.IsNotNull(methodValue, 'MethodValue should be created');
-    Assert.AreSame(methodType1, methodValue.DataType, 'Value should have the correct data type');
+    Assert.IsNotNull(IDataMethodValue(methodValue), 'MethodValue should be created');
+    Assert.AreSame(IDataType(methodType1), IDataMethodValue(methodValue).DataType, 'Value should have the correct data type');
 
     // --- 4. Test Execution (Simulated) ---
     inputValue := TDataValue.FromOrdinal(42);
@@ -665,13 +677,13 @@ begin
     resultValue := methodValue.Value(inputValue);
 
     Assert.IsNotNull(resultValue, 'Execution result should not be nil');
-    Assert.AreSame(textType, resultValue.DataType, 'Result value should have Text type');
+    Assert.AreSame(IDataType(textType), resultValue.DataType, 'Result value should have Text type');
     Assert.AreEqual('42', TDataValue(resultValue).AsText.Value, 'Result value content is incorrect');
 
     // --- 5. Test AsString and AsTValue ---
-    Assert.AreEqual('<METHOD>', methodValue.AsString, 'Method AsString is incorrect');
+    Assert.AreEqual('<METHOD>', IDataMethodValue(methodValue).AsString, 'Method AsString is incorrect');
 
-    tv := methodValue.AsTValue;
+    tv := IDataMethodValue(methodValue).AsTValue;
     Assert.IsFalse(tv.IsEmpty, 'Method TValue should not be empty');
     Assert.AreEqual(tkInterface, tv.Kind, 'TValue kind for a TMethodProc should be tkInterface, as it is a reference-to-function');
     Assert.IsTrue(TypeInfo(TMethodProc) = tv.TypeInfo, 'TValue should hold TMethodProc type info');