PhpSpreadsheet/tests/PhpSpreadsheetTests/Calculation/FinancialTest.php

<?php

namespace PhpOffice\PhpSpreadsheetTests\Calculation;

use PhpOffice\PhpSpreadsheet\Calculation\Financial;
use PhpOffice\PhpSpreadsheet\Calculation\Functions;
use PHPUnit\Framework\TestCase;

class FinancialTest extends TestCase
{
    protected function setUp(): void
    {
        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
    }

    /**
     * @dataProvider providerAMORDEGRC
     *
     * @param mixed $expectedResult
     */
    public function testAMORDEGRC($expectedResult, ...$args): void
    {
        $result = Financial::AMORDEGRC(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerAMORDEGRC()
    {
        return require 'tests/data/Calculation/Financial/AMORDEGRC.php';
    }

    /**
     * @dataProvider providerAMORLINC
     *
     * @param mixed $expectedResult
     */
    public function testAMORLINC($expectedResult, ...$args): void
    {
        $result = Financial::AMORLINC(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerAMORLINC()
    {
        return require 'tests/data/Calculation/Financial/AMORLINC.php';
    }

    /**
     * @dataProvider providerCOUPDAYBS
     *
     * @param mixed $expectedResult
     */
    public function testCOUPDAYBS($expectedResult, ...$args): void
    {
        $result = Financial::COUPDAYBS(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerCOUPDAYBS()
    {
        return require 'tests/data/Calculation/Financial/COUPDAYBS.php';
    }

    /**
     * @dataProvider providerCOUPDAYS
     *
     * @param mixed $expectedResult
     */
    public function testCOUPDAYS($expectedResult, ...$args): void
    {
        $result = Financial::COUPDAYS(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerCOUPDAYS()
    {
        return require 'tests/data/Calculation/Financial/COUPDAYS.php';
    }

    /**
     * @dataProvider providerCOUPDAYSNC
     *
     * @param mixed $expectedResult
     */
    public function testCOUPDAYSNC($expectedResult, ...$args): void
    {
        $result = Financial::COUPDAYSNC(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerCOUPDAYSNC()
    {
        return require 'tests/data/Calculation/Financial/COUPDAYSNC.php';
    }

    /**
     * @dataProvider providerCOUPNCD
     *
     * @param mixed $expectedResult
     */
    public function testCOUPNCD($expectedResult, ...$args): void
    {
        $result = Financial::COUPNCD(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerCOUPNCD()
    {
        return require 'tests/data/Calculation/Financial/COUPNCD.php';
    }

    /**
     * @dataProvider providerCOUPNUM
     *
     * @param mixed $expectedResult
     */
    public function testCOUPNUM($expectedResult, ...$args): void
    {
        $result = Financial::COUPNUM(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerCOUPNUM()
    {
        return require 'tests/data/Calculation/Financial/COUPNUM.php';
    }

    /**
     * @dataProvider providerCOUPPCD
     *
     * @param mixed $expectedResult
     */
    public function testCOUPPCD($expectedResult, ...$args): void
    {
        $result = Financial::COUPPCD(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerCOUPPCD()
    {
        return require 'tests/data/Calculation/Financial/COUPPCD.php';
    }

    /**
     * @dataProvider providerCUMIPMT
     *
     * @param mixed $expectedResult
     */
    public function testCUMIPMT($expectedResult, ...$args): void
    {
        $result = Financial::CUMIPMT(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerCUMIPMT()
    {
        return require 'tests/data/Calculation/Financial/CUMIPMT.php';
    }

    /**
     * @dataProvider providerCUMPRINC
     *
     * @param mixed $expectedResult
     */
    public function testCUMPRINC($expectedResult, ...$args): void
    {
        $result = Financial::CUMPRINC(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerCUMPRINC()
    {
        return require 'tests/data/Calculation/Financial/CUMPRINC.php';
    }

    /**
     * @dataProvider providerDB
     *
     * @param mixed $expectedResult
     */
    public function testDB($expectedResult, ...$args): void
    {
        $result = Financial::DB(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerDB()
    {
        return require 'tests/data/Calculation/Financial/DB.php';
    }

    /**
     * @dataProvider providerDDB
     *
     * @param mixed $expectedResult
     */
    public function testDDB($expectedResult, ...$args): void
    {
        $result = Financial::DDB(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerDDB()
    {
        return require 'tests/data/Calculation/Financial/DDB.php';
    }

    /**
     * @dataProvider providerDISC
     *
     * @param mixed $expectedResult
     */
    public function testDISC($expectedResult, ...$args): void
    {
        $result = Financial::DISC(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerDISC()
    {
        return require 'tests/data/Calculation/Financial/DISC.php';
    }

    /**
     * @dataProvider providerDOLLARDE
     *
     * @param mixed $expectedResult
     */
    public function testDOLLARDE($expectedResult, ...$args): void
    {
        $result = Financial::DOLLARDE(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerDOLLARDE()
    {
        return require 'tests/data/Calculation/Financial/DOLLARDE.php';
    }

    /**
     * @dataProvider providerDOLLARFR
     *
     * @param mixed $expectedResult
     */
    public function testDOLLARFR($expectedResult, ...$args): void
    {
        $result = Financial::DOLLARFR(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerDOLLARFR()
    {
        return require 'tests/data/Calculation/Financial/DOLLARFR.php';
    }

    /**
     * @dataProvider providerEFFECT
     *
     * @param mixed $expectedResult
     */
    public function testEFFECT($expectedResult, ...$args): void
    {
        $result = Financial::EFFECT(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerEFFECT()
    {
        return require 'tests/data/Calculation/Financial/EFFECT.php';
    }

    /**
     * @dataProvider providerFV
     *
     * @param mixed $expectedResult
     */
    public function testFV($expectedResult, ...$args): void
    {
        $result = Financial::FV(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerFV()
    {
        return require 'tests/data/Calculation/Financial/FV.php';
    }

    /**
     * @dataProvider providerFVSCHEDULE
     *
     * @param mixed $expectedResult
     */
    public function testFVSCHEDULE($expectedResult, ...$args): void
    {
        $result = Financial::FVSCHEDULE(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerFVSCHEDULE()
    {
        return require 'tests/data/Calculation/Financial/FVSCHEDULE.php';
    }

    /**
     * @dataProvider providerINTRATE
     *
     * @param mixed $expectedResult
     */
    public function testINTRATE($expectedResult, ...$args): void
    {
        $result = Financial::INTRATE(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerINTRATE()
    {
        return require 'tests/data/Calculation/Financial/INTRATE.php';
    }

    /**
     * @dataProvider providerIPMT
     *
     * @param mixed $expectedResult
     */
    public function testIPMT($expectedResult, ...$args): void
    {
        $result = Financial::IPMT(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerIPMT()
    {
        return require 'tests/data/Calculation/Financial/IPMT.php';
    }

    /**
     * @dataProvider providerIRR
     *
     * @param mixed $expectedResult
     */
    public function testIRR($expectedResult, ...$args): void
    {
        $result = Financial::IRR(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerIRR()
    {
        return require 'tests/data/Calculation/Financial/IRR.php';
    }

    /**
     * @dataProvider providerISPMT
     *
     * @param mixed $expectedResult
     */
    public function testISPMT($expectedResult, ...$args): void
    {
        $result = Financial::ISPMT(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerISPMT()
    {
        return require 'tests/data/Calculation/Financial/ISPMT.php';
    }

    /**
     * @dataProvider providerMIRR
     *
     * @param mixed $expectedResult
     */
    public function testMIRR($expectedResult, ...$args): void
    {
        $result = Financial::MIRR(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerMIRR()
    {
        return require 'tests/data/Calculation/Financial/MIRR.php';
    }

    /**
     * @dataProvider providerNOMINAL
     *
     * @param mixed $expectedResult
     */
    public function testNOMINAL($expectedResult, ...$args): void
    {
        $result = Financial::NOMINAL(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerNOMINAL()
    {
        return require 'tests/data/Calculation/Financial/NOMINAL.php';
    }

    /**
     * @dataProvider providerNPER
     *
     * @param mixed $expectedResult
     */
    public function testNPER($expectedResult, ...$args): void
    {
        $result = Financial::NPER(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerNPER()
    {
        return require 'tests/data/Calculation/Financial/NPER.php';
    }

    /**
     * @dataProvider providerNPV
     *
     * @param mixed $expectedResult
     */
    public function testNPV($expectedResult, ...$args): void
    {
        $result = Financial::NPV(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerNPV()
    {
        return require 'tests/data/Calculation/Financial/NPV.php';
    }

    /**
     * @dataProvider providerPRICE
     *
     * @param mixed $expectedResult
     */
    public function testPRICE($expectedResult, ...$args): void
    {
        $result = Financial::PRICE(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-7);
    }

    public function providerPRICE()
    {
        return require 'tests/data/Calculation/Financial/PRICE.php';
    }

    /**
     * @dataProvider providerPRICE3
     *
     * @param mixed $expectedResult
     */
    public function testPRICE3($expectedResult, ...$args): void
    {
        // These results (PRICE function with basis codes 2 and 3)
        // agree with published algorithm, LibreOffice, and Gnumeric.
        // They do not agree with Excel.
        $result = Financial::PRICE(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-7);
    }

    public function providerPRICE3()
    {
        return require 'tests/data/Calculation/Financial/PRICE3.php';
    }

    /**
     * @dataProvider providerPRICEDISC
     *
     * @param mixed $expectedResult
     */
    public function testPRICEDISC($expectedResult, array $args): void
    {
        $result = Financial::PRICEDISC(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerPRICEDISC()
    {
        return require 'tests/data/Calculation/Financial/PRICEDISC.php';
    }

    /**
     * @dataProvider providerPV
     *
     * @param mixed $expectedResult
     */
    public function testPV($expectedResult, array $args): void
    {
        $result = Financial::PV(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerPV()
    {
        return require 'tests/data/Calculation/Financial/PV.php';
    }

    /**
     * @dataProvider providerRATE
     *
     * @param mixed $expectedResult
     */
    public function testRATE($expectedResult, ...$args): void
    {
        $result = Financial::RATE(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerRATE()
    {
        return require 'tests/data/Calculation/Financial/RATE.php';
    }

    /**
     * @dataProvider providerXIRR
     *
     * @param mixed $expectedResult
     * @param mixed $message
     */
    public function testXIRR($expectedResult, $message, ...$args): void
    {
        $result = Financial::XIRR(...$args);
        if (is_numeric($result) && is_numeric($expectedResult)) {
            if ($expectedResult != 0) {
                $frac = $result / $expectedResult;
                if ($frac > 0.999999 && $frac < 1.000001) {
                    $result = $expectedResult;
                }
            }
        }
        self::assertEquals($expectedResult, $result, $message);
    }

    public function providerXIRR()
    {
        return require 'tests/data/Calculation/Financial/XIRR.php';
    }

    /**
     * @dataProvider providerXNPV
     *
     * @param mixed $expectedResult
     * @param mixed $message
     */
    public function testXNPV($expectedResult, $message, ...$args): void
    {
        $result = Financial::XNPV(...$args);
        if (is_numeric($result) && is_numeric($expectedResult)) {
            if ($expectedResult != 0) {
                $frac = $result / $expectedResult;
                if ($frac > 0.999999 && $frac < 1.000001) {
                    $result = $expectedResult;
                }
            }
        }
        self::assertEquals($expectedResult, $result, $message);
    }

    public function providerXNPV()
    {
        return require 'tests/data/Calculation/Financial/XNPV.php';
    }

    /**
     * @dataProvider providerPDURATION
     *
     * @param mixed $expectedResult
     */
    public function testPDURATION($expectedResult, array $args): void
    {
        $result = Financial::PDURATION(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerPDURATION()
    {
        return require 'tests/data/Calculation/Financial/PDURATION.php';
    }

    /**
     * @dataProvider providerRRI
     *
     * @param mixed $expectedResult
     */
    public function testRRI($expectedResult, array $args): void
    {
        $result = Financial::RRI(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerRRI()
    {
        return require 'tests/data/Calculation/Financial/RRI.php';
    }

    /**
     * @dataProvider providerSLN
     *
     * @param mixed $expectedResult
     */
    public function testSLN($expectedResult, array $args): void
    {
        $result = Financial::SLN(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerSLN()
    {
        return require 'tests/data/Calculation/Financial/SLN.php';
    }

    /**
     * @dataProvider providerSYD
     *
     * @param mixed $expectedResult
     */
    public function testSYD($expectedResult, array $args): void
    {
        $result = Financial::SYD(...$args);
        self::assertEqualsWithDelta($expectedResult, $result, 1E-8);
    }

    public function providerSYD()
    {
        return require 'tests/data/Calculation/Financial/SYD.php';
    }
}