unit TestDataTypes; interface uses DUnitX.TestFramework; type [TestFixture] TMyTestObject = class public [Test] procedure TestCreateRecords; [Test] procedure TestTuples; [Test] procedure TestArrays; [Test] procedure TestTexts; [Test] procedure TestTimestamps; [Test] procedure TestEnums; [Test] procedure TestAsString; end; implementation uses System.SysUtils, Myc.Data.Types; { TMyTestObject } procedure TMyTestObject.TestCreateRecords; var intType: IDataType; floatType: IDataType; personType1, personType2, otherType: IDataRecordType; personValue: IDataValue; idValue: IDataOrdinalValue; floatValue: IDataFloatValue; begin // --- 1. Setup: Define base types and a record structure --- intType := TDataType.Ordinal; floatType := TDataType.Float; // --- 2. Test Type Creation and Caching --- personType1 := TDataType.RecordOf([TRecordField.Create('ID', intType), TRecordField.Create('Value', floatType)]); // Assertions for the created type Assert.IsNotNull(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.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.AreEqual(0, personType1.IndexOf('ID'), 'IndexOf ID should be 0'); Assert.AreEqual(1, personType1.IndexOf('Value'), 'IndexOf Value should be 1'); Assert.AreEqual('Record', 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'); // 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'); // --- 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'); // Access by index idValue := TDataValue(TDataValue(personValue).AsRecord.Items[0]).AsOrdinal; Assert.AreEqual(Int64(123), idValue.Value, 'Value at index 0 is incorrect'); floatValue := TDataValue(TDataValue(personValue).AsRecord.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; Assert.AreEqual(45.67, floatValue.Value, 'Value accessed by name is incorrect'); // --- 4. Test Validation and Error Handling --- // Test for duplicate field names during type creation Assert.WillRaise( procedure begin TDataType.RecordOf([TRecordField.Create('ID', intType), TRecordField.Create('ID', floatType)]); end, EArgumentException, 'Duplicate field names should raise an exception' ); // Test for wrong number of items during value creation Assert.WillRaise( procedure begin personType1.CreateValue([TDataValue.FromOrdinal(99)]); end, EArgumentException, 'Wrong number of items should raise exception' ); // Test for wrong item type during value creation Assert.WillRaise( procedure begin // Passing Float instead of Integer for the first item personType1.CreateValue([TDataValue.FromFloat(1.0), TDataValue.FromFloat(2.0)]); end, EArgumentException, 'Wrong item type should raise exception' ); end; procedure TMyTestObject.TestTuples; var intValue: IDataValue; floatValue: IDataValue; tuple1, tuple2, tuple3: IDataTupleValue; type1, type2, type3: IDataType; begin // --- 1. Setup: Create some values --- intValue := TDataValue.FromOrdinal(123); floatValue := TDataValue.FromFloat(45.67); // --- 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'); // --- 3. Test Singleton Type Behavior --- // Create more tuples with different structures tuple2 := TDataValue.FromTuple([TDataValue.FromOrdinal(99), TDataValue.FromFloat(1.1)]); tuple3 := TDataValue.FromTuple([intValue]); // Access the DataType via the underlying interface type1 := tuple1.DataType; type2 := tuple2.DataType; type3 := tuple3.DataType; Assert.IsNotNull(type1, 'DataType interface should be accessible'); Assert.AreEqual('Tuple', type1.Name, 'The type name for all tuples should be Tuple'); // The core test: All tuples, regardless of their content, must share the exact same singleton type object. Assert.AreSame(type1, type2, 'All tuple types should be the same singleton instance'); Assert.AreSame(type1, type3, 'All tuple types should be the same singleton instance'); end; procedure TMyTestObject.TestArrays; var intType: IDataType; floatType: IDataType; intArrayType1, intArrayType2, floatArrayType: IDataArrayType; arrayValue: IDataArrayValue; v1, v2: IDataValue; begin // --- 1. Setup --- intType := TDataType.Ordinal; floatType := TDataType.Float; // --- 2. Test Type Creation and Caching --- intArrayType1 := TDataType.ArrayOfType(intType); Assert.IsNotNull(intArrayType1, 'ArrayType should be created'); Assert.AreSame(intType, intArrayType1.ElementType, 'ElementType should be Integer'); Assert.AreEqual('Array', intArrayType1.Name, 'Type name should be Array'); // Test caching intArrayType2 := TDataType.ArrayOfType(intType); Assert.AreSame(intArrayType1, intArrayType2, 'Array types should be cached'); // Test uniqueness floatArrayType := TDataType.ArrayOfType(floatType); Assert.AreNotSame(intArrayType1, floatArrayType, 'Different element types should result in different array types'); Assert.AreEqual('Array', floatArrayType.Name, 'Type name should be Array'); // --- 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'); // 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'); // --- 4. Test Validation and Error Handling --- // Test creating an array with a nil element type Assert.WillRaise(procedure begin TDataType.ArrayOfType(nil); end, EArgumentException, 'Nil element type should raise an exception'); // Test creating a value with an incorrect element type (homogeneity check) Assert.WillRaise( procedure begin // Try to add a float value to an Array intArrayType1.CreateValue([v1, TDataValue.FromFloat(3.14)]); end, EArgumentException, 'Wrong element type should raise an exception' ); end; procedure TMyTestObject.TestTexts; var textType: IDataTextType; textValue1, textValue2: IDataTextValue; 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'); // --- 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.AreEqual('Hello World', textValue1.Value, 'Value should be ''Hello World'''); // Test another text value textValue2 := TDataValue.FromText('Delphi'); Assert.AreEqual('Delphi', textValue2.Value, 'Value should be ''Delphi'''); // --- 3. Test AsText casting --- dataValue := TDataValue.FromText('Test Text'); Assert.AreEqual('Test Text', TDataValue(dataValue).AsText.Value, 'AsText should return correct value'); // Test invalid cast dataValue := TDataValue.FromOrdinal(123); Assert .WillRaise(procedure begin TDataValue(dataValue).AsText; end, EInvalidCast, 'Casting non-text to AsText should raise EInvalidCast'); end; procedure TMyTestObject.TestTimestamps; var tsType: IDataTimestampType; tsValue1, tsValue2: IDataTimestampValue; 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'); // --- 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.AreEqual(now, tsValue1.Value, 'Value should be the same'); // Test another text value tsValue2 := TDataValue.FromTimestamp(Date); Assert.AreEqual(Date, tsValue2.Value, 'Value should be the same'); // --- 3. Test AsTimestamp casting --- dataValue := TDataValue.FromTimestamp(now); Assert.AreEqual(now, TDataValue(dataValue).AsTimestamp.Value, 'AsTimestamp should return correct value'); // Test invalid cast dataValue := TDataValue.FromOrdinal(123); Assert.WillRaise( procedure begin TDataValue(dataValue).AsTimestamp; end, EInvalidCast, 'Casting non-timestamp to AsTimestamp should raise EInvalidCast' ); end; procedure TMyTestObject.TestEnums; var colorType: IDataEnumType; red, green, blue: IDataEnumValue; 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.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'); Assert.AreEqual('Blue', colorType.Identifiers[2], 'Identifier at index 2 should be Blue'); Assert.AreEqual(1, colorType.IndexOf('Green'), 'IndexOf Green should be 1'); Assert.AreEqual(-1, colorType.IndexOf('Yellow'), 'IndexOf Yellow should be -1'); // --- 2. Test Value Creation and Access --- red := colorType.CreateValue(0); green := colorType.CreateValue('Green'); blue := TDataValue(colorType.CreateValue(2)).AsEnum; Assert.IsNotNull(red, 'EnumValue from index should be created'); Assert.AreSame(colorType, 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.IsNotNull(green, 'EnumValue from identifier should be created'); Assert.AreSame(colorType, 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(2, blue.Value, 'Value of Blue should be 2'); // --- 3. Test Validation and Error Handling --- // Test creating a type with duplicate identifiers Assert.WillRaise( procedure begin TDataType.EnumOf('Fails', ['A', 'B', 'A']); end, EArgumentException, 'Duplicate identifiers should raise an exception' ); // Test creating a value with an invalid index Assert.WillRaise(procedure begin colorType.CreateValue(3); end, EArgumentException, 'Invalid index should raise an exception'); Assert.WillRaise(procedure begin colorType.CreateValue(-1); end, EArgumentException, 'Negative index should raise an exception'); // Test creating a value with an unknown identifier Assert.WillRaise( procedure begin colorType.CreateValue('Yellow'); end, EArgumentException, 'Unknown identifier should raise an exception' ); 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; now: TDateTime; begin // Ordinal ordinalValue := TDataValue.FromOrdinal(123); Assert.AreEqual('123', ordinalValue.AsString, 'Ordinal AsString incorrect'); // Float floatValue := TDataValue.FromFloat(45.67); Assert.AreEqual(FloatToStr(45.67), floatValue.AsString, 'Float AsString incorrect'); // Text textValue := TDataValue.FromText('Hello'); Assert.AreEqual('Hello', textValue.AsString, 'Text AsString incorrect'); // Timestamp now := System.Sysutils.Now; tsValue := TDataValue.FromTimestamp(now); Assert.AreEqual(DateTimeToStr(now), 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'); // Array intArrayType := TDataType.ArrayOfType(TDataType.Ordinal); arrayValue := intArrayType.CreateValue([TDataValue.FromOrdinal(1), TDataValue.FromOrdinal(2)]); Assert.AreEqual('[1, 2]', 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('', recordValue.AsString, 'Record AsString incorrect'); // Tuple tupleValue := TDataValue.FromTuple([TDataValue.FromOrdinal(10), TDataValue.FromText('Tuple')]); Assert.AreEqual('(10, Tuple)', tupleValue.AsString, 'Tuple AsString incorrect'); end; initialization TDUnitX.RegisterTestFixture(TMyTestObject); end.