Brummel/MycLib
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Scalar 64bit decimal type

Browse Source
This commit is contained in:
Michael Schimmel
2025-08-28 12:30:13 +02:00
parent bb0e2fd5af
commit f4b5882080
6 changed files with 523 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Test/MycTests.dpr
+4 -2
View File
@@ -35,9 +35,11 @@ uses
Myc.Data.Types.Void in '..\Src\Data\Myc.Data.Types.Void.pas',
Myc.Data.Types.Decimal in '..\Src\Data\Myc.Data.Types.Decimal.pas',
Myc.Ast in '..\Src\AST\Myc.Ast.pas',
TestAst in '..\Src\AST\TestAst.pas',
Myc.Data.Types.JSON in '..\Src\Data\Myc.Data.Types.JSON.pas',
TestDataTypes.JSON in '..\Src\Data\TestDataTypes.JSON.pas';
TestDataTypes.JSON in '..\Src\Data\TestDataTypes.JSON.pas',
Myc.Data.POD in '..\Src\Data\Myc.Data.POD.pas',
Myc.Data.Decimal in '..\Src\Data\Myc.Data.Decimal.pas',
TestDataDecimal in 'TestDataDecimal.pas';
{ keep comment here to protect the following conditional from being removed by the IDE when adding a unit }
{$IFNDEF TESTINSIGHT}
Test/MycTests.dproj
+9 -1
View File
@@ -136,9 +136,11 @@ $(PreBuildEvent)]]></PreBuildEvent>
<DCCReference Include="..\Src\Data\Myc.Data.Types.Void.pas"/>
<DCCReference Include="..\Src\Data\Myc.Data.Types.Decimal.pas"/>
<DCCReference Include="..\Src\AST\Myc.Ast.pas"/>
<DCCReference Include="..\Src\AST\TestAst.pas"/>
<DCCReference Include="..\Src\Data\Myc.Data.Types.JSON.pas"/>
<DCCReference Include="..\Src\Data\TestDataTypes.JSON.pas"/>
<DCCReference Include="..\Src\Data\Myc.Data.POD.pas"/>
<DCCReference Include="..\Src\Data\Myc.Data.Decimal.pas"/>
<DCCReference Include="TestDataDecimal.pas"/>
<BuildConfiguration Include="Base">
<Key>Base</Key>
</BuildConfiguration>
@@ -182,6 +184,12 @@ $(PreBuildEvent)]]></PreBuildEvent>
<Overwrite>true</Overwrite>
</Platform>
</DeployFile>
<DeployFile LocalName="..\Src\Data\Myc.Data.POD.pas" Configuration="Debug" Class="ProjectFile">
<Platform Name="Win64">
<RemoteDir>.\</RemoteDir>
<Overwrite>true</Overwrite>
</Platform>
</DeployFile>
<DeployFile LocalName="Win64\Debug\MycTests.exe" Configuration="Debug" Class="ProjectOutput">
<Platform Name="Win64">
<RemoteName>MycTests.exe</RemoteName>
Test/TestDataDecimal.pas
+224
View File
@@ -0,0 +1,224 @@
unit TestDataDecimal;
interface
uses
Myc.Data.Decimal,
DUnitX.TestFramework;
type
[TestFixture]
TTestDecimal = class
public
[TestCase('Positive Numbers Add', '100,0,200,0,300,0')]
[TestCase('Negative Numbers Add', '-100,0,-200,0,-300,0')]
[TestCase('Mixed Numbers Add', '-100,0,200,0,100,0')]
[TestCase('Zero Add', '0,0,0,0,0,0')]
[Test]
procedure TestAdd(const AValue1, AScale1, AValue2, AScale2: Int64; const AResultValue, AResultScale: Int64);
[TestCase('Positive Numbers Subtract', '300,0,200,0,100,0')]
[TestCase('Negative Numbers Subtract', '-300,0,-200,0,-100,0')]
[TestCase('Mixed Numbers Subtract', '100,0,200,0,-100,0')]
[TestCase('Zero Subtract', '0,0,0,0,0,0')]
[Test]
procedure TestSubtract(const AValue1, AScale1, AValue2, AScale2: Int64; const AResultValue, AResultScale: Int64);
[TestCase('Positive Numbers Multiply', '10,1,20,1,20,1')]
[TestCase('Negative Numbers Multiply', '-10,1,-20,1,20,1')]
[TestCase('Mixed Numbers Multiply', '-10,1,20,1,-20,1')]
[TestCase('Zero Multiply', '10,1,0,1,0,1')]
[Test]
procedure TestMultiply(const AValue1, AScale1, AValue2, AScale2: Int64; const AResultValue, AResultScale: Int64);
[TestCase('Positive Numbers Divide', '400,2,20,2,2000,2')]
[TestCase('Negative Numbers Divide', '-400,2,-20,2,2000,2')]
[TestCase('Mixed Numbers Divide', '-400,2,20,2,-2000,2')]
[TestCase('Zero Divide', '0,2,20,2,0,2')]
[Test]
procedure TestDivide(const AValue1, AScale1, AValue2, AScale2: Int64; const AResultValue, AResultScale: Int64);
[TestCase('Equality', '100,1,100,1')]
[Test]
procedure TestEqual(const AValue1, AScale1, AValue2, AScale2: Int64);
[TestCase('Inequality', '100,1,200,1')]
[TestCase('Inequality Different Scale', '100,1,100,2')]
[Test]
procedure TestNotEqual(const AValue1, AScale1, AValue2, AScale2: Int64);
[Test]
procedure TestImplicitConversion;
[Test]
procedure TestExplicitConversionToInt64;
[Test]
procedure TestExplicitConversionToDouble;
[TestCase('Scale 0', '0')]
[TestCase('Scale 4', '4')]
[TestCase('Scale 7 (Max)', '7')]
[Test]
procedure TestMinMaxValues(AScaleValue: Integer);
[TestCase('Upscale', '12345,2,4,1234500')]
[TestCase('Downscale (truncation)', '1234567,4,2,12345')]
[TestCase('Same Scale', '-555,3,3,-555')]
[TestCase('Upscale Negative', '-987,1,3,-98700')]
[Test]
procedure TestRescaleConstructor(AValue, AScale, ANewScale, AExpectedValue: Int64);
[Test]
procedure TestRescaleOverflow;
end;
implementation
uses
System.SysUtils;
const
// Expected boundary values for a 61-bit signed integer
MIN_VALUE_61BIT: Int64 = -(1 shl 60);
MAX_VALUE_61BIT: Int64 = (1 shl 60) - 1;
{ TTestDecimal }
procedure TTestDecimal.TestAdd(const AValue1, AScale1, AValue2, AScale2: Int64; const AResultValue, AResultScale: Int64);
var
d1, d2, d3: TDecimal64;
begin
d1 := TDecimal64.Create(AValue1, TScale(AScale1));
d2 := TDecimal64.Create(AValue2, TScale(AScale2));
d3 := d1 + d2;
Assert.AreEqual(d3.GetValue, AResultValue, 'Value mismatch');
Assert.AreEqual(d3.GetScale, TScale(AResultScale), 'Scale mismatch');
end;
procedure TTestDecimal.TestSubtract(const AValue1, AScale1, AValue2, AScale2: Int64; const AResultValue, AResultScale: Int64);
var
d1, d2, d3: TDecimal64;
begin
d1 := TDecimal64.Create(AValue1, TScale(AScale1));
d2 := TDecimal64.Create(AValue2, TScale(AScale2));
d3 := d1 - d2;
Assert.AreEqual(d3.GetValue, AResultValue, 'Value mismatch');
Assert.AreEqual(d3.GetScale, TScale(AResultScale), 'Scale mismatch');
end;
procedure TTestDecimal.TestMultiply(const AValue1, AScale1, AValue2, AScale2: Int64; const AResultValue, AResultScale: Int64);
var
d1, d2, d3: TDecimal64;
begin
d1 := TDecimal64.Create(AValue1, TScale(AScale1));
d2 := TDecimal64.Create(AValue2, TScale(AScale2));
d3 := d1 * d2;
Assert.AreEqual(d3.GetValue, AResultValue, 'Value mismatch');
Assert.AreEqual(d3.GetScale, TScale(AResultScale), 'Scale mismatch');
end;
procedure TTestDecimal.TestDivide(const AValue1, AScale1, AValue2, AScale2: Int64; const AResultValue, AResultScale: Int64);
var
d1, d2, d3: TDecimal64;
begin
d1 := TDecimal64.Create(AValue1, TScale(AScale1));
d2 := TDecimal64.Create(AValue2, TScale(AScale2));
d3 := d1 / d2;
Assert.AreEqual(d3.GetValue, AResultValue, 'Value mismatch');
Assert.AreEqual(d3.GetScale, TScale(AResultScale), 'Scale mismatch');
end;
procedure TTestDecimal.TestEqual(const AValue1, AScale1, AValue2, AScale2: Int64);
var
d1, d2: TDecimal64;
begin
d1 := TDecimal64.Create(AValue1, TScale(AScale1));
d2 := TDecimal64.Create(AValue2, TScale(AScale2));
Assert.IsTrue(d1 = d2, 'Values should be equal');
end;
procedure TTestDecimal.TestNotEqual(const AValue1, AScale1, AValue2, AScale2: Int64);
var
d1, d2: TDecimal64;
begin
d1 := TDecimal64.Create(AValue1, TScale(AScale1));
d2 := TDecimal64.Create(AValue2, TScale(AScale2));
Assert.IsFalse(d1 = d2, 'Values should not be equal');
end;
procedure TTestDecimal.TestImplicitConversion;
var
intValue: Int64;
decimalValue: TDecimal64;
begin
intValue := 12345;
decimalValue := intValue;
Assert.AreEqual(decimalValue.GetValue, intValue, 'Implicit conversion from Int64 failed');
Assert.AreEqual(decimalValue.GetScale, TScale(0), 'Implicit conversion should have scale 0');
end;
procedure TTestDecimal.TestExplicitConversionToInt64;
var
decimalValue: TDecimal64;
intValue: Int64;
begin
decimalValue := TDecimal64.Create(98765, TScale(3));
intValue := Int64(decimalValue);
Assert.AreEqual(intValue, Int64(98765), 'Explicit conversion to Int64 failed');
end;
procedure TTestDecimal.TestExplicitConversionToDouble;
var
decimalValue: TDecimal64;
doubleValue: Double;
begin
decimalValue := TDecimal64.Create(12345, TScale(3));
doubleValue := Double(decimalValue);
Assert.AreEqual(doubleValue, 12.345, 0.000001, 'Explicit conversion to Double failed');
end;
procedure TTestDecimal.TestMinMaxValues(AScaleValue: Integer);
var
minDec, maxDec: TDecimal64;
scale: TScale;
begin
scale := TScale(AScaleValue);
// Test MaxValue
maxDec := TDecimal64.MaxValue(scale);
Assert.AreEqual(scale, maxDec.GetScale, 'MaxValue scale mismatch');
Assert.AreEqual(MAX_VALUE_61BIT, maxDec.GetValue, 'MaxValue value mismatch');
// Test MinValue
minDec := TDecimal64.MinValue(scale);
Assert.AreEqual(scale, minDec.GetScale, 'MinValue scale mismatch');
Assert.AreEqual(MIN_VALUE_61BIT, minDec.GetValue, 'MinValue value mismatch');
end;
procedure TTestDecimal.TestRescaleConstructor(AValue, AScale, ANewScale, AExpectedValue: Int64);
var
d1, d2: TDecimal64;
begin
d1 := TDecimal64.Create(AValue, TScale(AScale));
d2 := TDecimal64.Create(d1, TScale(ANewScale));
Assert.AreEqual(TScale(ANewScale), d2.GetScale, 'New scale was not set correctly.');
Assert.AreEqual(AExpectedValue, d2.GetValue, 'Rescaled value is incorrect.');
end;
procedure TTestDecimal.TestRescaleOverflow;
var
d1: TDecimal64;
begin
// Create a value that is just over the overflow threshold for a multiplication by 10
d1 := TDecimal64.Create((MAX_VALUE_61BIT div 10) + 1, 0);
// Expect an EOverflow when scaling up from 0 to 1
Assert.WillRaise(procedure begin TDecimal64.Create(d1, 1); end, EOverflow, 'EOverflow was expected on rescale.');
end;
initialization
TDUnitX.RegisterTestFixture(TTestDecimal);
end.