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.