Merge remote-tracking branch 'origin/master'

tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/DayTest.php

@@ -21,16 +21,16 @@ class DayTest extends TestCase
      *
      * @param mixed $expectedResultExcel
      * @param mixed $expectedResultOpenOffice
-     * @param $dateValue
+     * @param $dateTimeValue
      */
-    public function testDAY($expectedResultExcel, $expectedResultOpenOffice, $dateValue)
+    public function testDAY($expectedResultExcel, $expectedResultOpenOffice, $dateTimeValue)
     {
-        $resultExcel = DateTime::DAYOFMONTH($dateValue);
+        $resultExcel = DateTime::DAYOFMONTH($dateTimeValue);
         $this->assertEquals($expectedResultExcel, $resultExcel, '', 1E-8);
 
         Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
 
-        $resultOpenOffice = DateTime::DAYOFMONTH($dateValue);
+        $resultOpenOffice = DateTime::DAYOFMONTH($dateTimeValue);
         $this->assertEquals($expectedResultOpenOffice, $resultOpenOffice, '', 1E-8);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/HourTest.php

@@ -20,10 +20,11 @@ class HourTest extends TestCase
      * @dataProvider providerHOUR
      *
      * @param mixed $expectedResult
+     * @param $dateTimeValue
      */
-    public function testHOUR($expectedResult, ...$args)
+    public function testHOUR($expectedResult, $dateTimeValue)
     {
-        $result = DateTime::HOUROFDAY(...$args);
+        $result = DateTime::HOUROFDAY($dateTimeValue);
         $this->assertEquals($expectedResult, $result, '', 1E-8);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/MinuteTest.php

@@ -20,10 +20,11 @@ class MinuteTest extends TestCase
      * @dataProvider providerMINUTE
      *
      * @param mixed $expectedResult
+     * @param $dateTimeValue
      */
-    public function testMINUTE($expectedResult, ...$args)
+    public function testMINUTE($expectedResult, $dateTimeValue)
     {
-        $result = DateTime::MINUTE(...$args);
+        $result = DateTime::MINUTE($dateTimeValue);
         $this->assertEquals($expectedResult, $result, '', 1E-8);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/MonthTest.php

@@ -20,10 +20,11 @@ class MonthTest extends TestCase
      * @dataProvider providerMONTH
      *
      * @param mixed $expectedResult
+     * @param $dateTimeValue
      */
-    public function testMONTH($expectedResult, ...$args)
+    public function testMONTH($expectedResult, $dateTimeValue)
     {
-        $result = DateTime::MONTHOFYEAR(...$args);
+        $result = DateTime::MONTHOFYEAR($dateTimeValue);
         $this->assertEquals($expectedResult, $result, '', 1E-8);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/SecondTest.php

@@ -20,10 +20,11 @@ class SecondTest extends TestCase
      * @dataProvider providerSECOND
      *
      * @param mixed $expectedResult
+     * @param $dateTimeValue
      */
-    public function testSECOND($expectedResult, ...$args)
+    public function testSECOND($expectedResult, $dateTimeValue)
     {
-        $result = DateTime::SECOND(...$args);
+        $result = DateTime::SECOND($dateTimeValue);
         $this->assertEquals($expectedResult, $result, '', 1E-8);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/TimeValueTest.php

@@ -20,10 +20,11 @@ class TimeValueTest extends TestCase
      * @dataProvider providerTIMEVALUE
      *
      * @param mixed $expectedResult
+     * @param $timeValue
      */
-    public function testTIMEVALUE($expectedResult, ...$args)
+    public function testTIMEVALUE($expectedResult, $timeValue)
     {
-        $result = DateTime::TIMEVALUE(...$args);
+        $result = DateTime::TIMEVALUE($timeValue);
         $this->assertEquals($expectedResult, $result, '', 1E-8);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/YearTest.php

@@ -20,10 +20,11 @@ class YearTest extends TestCase
      * @dataProvider providerYEAR
      *
      * @param mixed $expectedResult
+     * @param $dateTimeValue
      */
-    public function testYEAR($expectedResult, ...$args)
+    public function testYEAR($expectedResult, $dateTimeValue)
     {
-        $result = DateTime::YEAR(...$args);
+        $result = DateTime::YEAR($dateTimeValue);
         $this->assertEquals($expectedResult, $result, '', 1E-8);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BesselITest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class BesselITest extends TestCase
+{
+    const BESSEL_PRECISION = 1E-8;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBESSELI
+     *
+     * @param mixed $expectedResult
+     */
+    public function testBESSELI($expectedResult, ...$args)
+    {
+        $result = Engineering::BESSELI(...$args);
+        $this->assertEquals($expectedResult, $result, '', self::BESSEL_PRECISION);
+    }
+
+    public function providerBESSELI()
+    {
+        return require 'data/Calculation/Engineering/BESSELI.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BesselJTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class BesselJTest extends TestCase
+{
+    const BESSEL_PRECISION = 1E-8;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBESSEJ
+     *
+     * @param mixed $expectedResult
+     */
+    public function testBESSELJ($expectedResult, ...$args)
+    {
+        $result = Engineering::BESSELJ(...$args);
+        $this->assertEquals($expectedResult, $result, '', self::BESSEL_PRECISION);
+    }
+
+    public function providerBESSEJ()
+    {
+        return require 'data/Calculation/Engineering/BESSELJ.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BesselKTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class BesselKTest extends TestCase
+{
+    const BESSEL_PRECISION = 1E-8;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBESSELK
+     *
+     * @param mixed $expectedResult
+     */
+    public function testBESSELK($expectedResult, ...$args)
+    {
+        $result = Engineering::BESSELK(...$args);
+        $this->assertEquals($expectedResult, $result, '', self::BESSEL_PRECISION);
+    }
+
+    public function providerBESSELK()
+    {
+        return require 'data/Calculation/Engineering/BESSELK.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BesselYTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class BesselYTest extends TestCase
+{
+    const BESSEL_PRECISION = 1E-8;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBESSELY
+     *
+     * @param mixed $expectedResult
+     */
+    public function testBESSELY($expectedResult, ...$args)
+    {
+        $result = Engineering::BESSELY(...$args);
+        $this->assertEquals($expectedResult, $result, '', self::BESSEL_PRECISION);
+    }
+
+    public function providerBESSELY()
+    {
+        return require 'data/Calculation/Engineering/BESSELY.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2DecTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Bin2DecTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBIN2DEC
+     *
+     * @param mixed $expectedResult
+     */
+    public function testBIN2DEC($expectedResult, ...$args)
+    {
+        $result = Engineering::BINTODEC(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerBIN2DEC()
+    {
+        return require 'data/Calculation/Engineering/BIN2DEC.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2HexTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Bin2HexTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBIN2HEX
+     *
+     * @param mixed $expectedResult
+     */
+    public function testBIN2HEX($expectedResult, ...$args)
+    {
+        $result = Engineering::BINTOHEX(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerBIN2HEX()
+    {
+        return require 'data/Calculation/Engineering/BIN2HEX.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2OctTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Bin2OctTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBIN2OCT
+     *
+     * @param mixed $expectedResult
+     */
+    public function testBIN2OCT($expectedResult, ...$args)
+    {
+        $result = Engineering::BINTOOCT(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerBIN2OCT()
+    {
+        return require 'data/Calculation/Engineering/BIN2OCT.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BitAndTest.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class BitAndTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBITAND
+     *
+     * @param mixed $expectedResult
+     * @param mixed[] $args
+     */
+    public function testBITAND($expectedResult, array $args)
+    {
+        $result = Engineering::BITAND(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerBITAND()
+    {
+        return require 'data/Calculation/Engineering/BITAND.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BitLShiftTest.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class BitLShiftTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBITLSHIFT
+     *
+     * @param mixed $expectedResult
+     * @param mixed[] $args
+     */
+    public function testBITLSHIFT($expectedResult, array $args)
+    {
+        $result = Engineering::BITLSHIFT(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerBITLSHIFT()
+    {
+        return require 'data/Calculation/Engineering/BITLSHIFT.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BitOrTest.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class BitOrTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBITOR
+     *
+     * @param mixed $expectedResult
+     * @param mixed[] $args
+     */
+    public function testBITOR($expectedResult, array $args)
+    {
+        $result = Engineering::BITOR(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerBITOR()
+    {
+        return require 'data/Calculation/Engineering/BITOR.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BitRShiftTest.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class BitRShiftTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBITRSHIFT
+     *
+     * @param mixed $expectedResult
+     * @param mixed[] $args
+     */
+    public function testBITRSHIFT($expectedResult, array $args)
+    {
+        $result = Engineering::BITRSHIFT(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerBITRSHIFT()
+    {
+        return require 'data/Calculation/Engineering/BITRSHIFT.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BitXorTest.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class BitXorTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerBITXOR
+     *
+     * @param mixed $expectedResult
+     * @param mixed[] $args
+     */
+    public function testBITXOR($expectedResult, array $args)
+    {
+        $result = Engineering::BITXOR(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerBITXOR()
+    {
+        return require 'data/Calculation/Engineering/BITXOR.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ComplexTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class ComplexTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerCOMPLEX
+     *
+     * @param mixed $expectedResult
+     */
+    public function testCOMPLEX($expectedResult, ...$args)
+    {
+        $result = Engineering::COMPLEX(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerCOMPLEX()
+    {
+        return require 'data/Calculation/Engineering/COMPLEX.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ConvertUoMTest.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class ConvertUoMTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    public function testGetConversionGroups()
+    {
+        $result = Engineering::getConversionGroups();
+        $this->assertIsArray($result);
+    }
+
+    public function testGetConversionGroupUnits()
+    {
+        $result = Engineering::getConversionGroupUnits();
+        $this->assertIsArray($result);
+    }
+
+    public function testGetConversionGroupUnitDetails()
+    {
+        $result = Engineering::getConversionGroupUnitDetails();
+        $this->assertIsArray($result);
+    }
+
+    public function testGetConversionMultipliers()
+    {
+        $result = Engineering::getConversionMultipliers();
+        $this->assertIsArray($result);
+    }
+
+    /**
+     * @dataProvider providerCONVERTUOM
+     *
+     * @param mixed $expectedResult
+     */
+    public function testCONVERTUOM($expectedResult, ...$args)
+    {
+        $result = Engineering::CONVERTUOM(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerCONVERTUOM()
+    {
+        return require 'data/Calculation/Engineering/CONVERTUOM.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2BinTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Dec2BinTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerDEC2BIN
+     *
+     * @param mixed $expectedResult
+     */
+    public function testDEC2BIN($expectedResult, ...$args)
+    {
+        $result = Engineering::DECTOBIN(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerDEC2BIN()
+    {
+        return require 'data/Calculation/Engineering/DEC2BIN.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2HexTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Dec2HexTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerDEC2HEX
+     *
+     * @param mixed $expectedResult
+     */
+    public function testDEC2HEX($expectedResult, ...$args)
+    {
+        $result = Engineering::DECTOHEX(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerDEC2HEX()
+    {
+        return require 'data/Calculation/Engineering/DEC2HEX.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2OctTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Dec2OctTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerDEC2OCT
+     *
+     * @param mixed $expectedResult
+     */
+    public function testDEC2OCT($expectedResult, ...$args)
+    {
+        $result = Engineering::DECTOOCT(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerDEC2OCT()
+    {
+        return require 'data/Calculation/Engineering/DEC2OCT.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/DeltaTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class DeltaTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerDELTA
+     *
+     * @param mixed $expectedResult
+     */
+    public function testDELTA($expectedResult, ...$args)
+    {
+        $result = Engineering::DELTA(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerDELTA()
+    {
+        return require 'data/Calculation/Engineering/DELTA.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ErfCTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class ErfCTest extends TestCase
+{
+    const ERF_PRECISION = 1E-12;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerERFC
+     *
+     * @param mixed $expectedResult
+     */
+    public function testERFC($expectedResult, ...$args)
+    {
+        $result = Engineering::ERFC(...$args);
+        $this->assertEquals($expectedResult, $result, '', self::ERF_PRECISION);
+    }
+
+    public function providerERFC()
+    {
+        return require 'data/Calculation/Engineering/ERFC.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ErfPreciseTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class ErfPreciseTest extends TestCase
+{
+    const ERF_PRECISION = 1E-12;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerERFPRECISE
+     *
+     * @param mixed $expectedResult
+     */
+    public function testERFPRECISE($expectedResult, ...$args)
+    {
+        $result = Engineering::ERFPRECISE(...$args);
+        $this->assertEquals($expectedResult, $result, '', self::ERF_PRECISION);
+    }
+
+    public function providerERFPRECISE()
+    {
+        return require 'data/Calculation/Engineering/ERFPRECISE.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ErfTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class ErfTest extends TestCase
+{
+    const ERF_PRECISION = 1E-12;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerERF
+     *
+     * @param mixed $expectedResult
+     */
+    public function testERF($expectedResult, ...$args)
+    {
+        $result = Engineering::ERF(...$args);
+        $this->assertEquals($expectedResult, $result, '', self::ERF_PRECISION);
+    }
+
+    public function providerERF()
+    {
+        return require 'data/Calculation/Engineering/ERF.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/GeStepTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class GeStepTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerGESTEP
+     *
+     * @param mixed $expectedResult
+     */
+    public function testGESTEP($expectedResult, ...$args)
+    {
+        $result = Engineering::GESTEP(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerGESTEP()
+    {
+        return require 'data/Calculation/Engineering/GESTEP.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2BinTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Hex2BinTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerHEX2BIN
+     *
+     * @param mixed $expectedResult
+     */
+    public function testHEX2BIN($expectedResult, ...$args)
+    {
+        $result = Engineering::HEXTOBIN(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerHEX2BIN()
+    {
+        return require 'data/Calculation/Engineering/HEX2BIN.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2DecTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Hex2DecTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerHEX2DEC
+     *
+     * @param mixed $expectedResult
+     */
+    public function testHEX2DEC($expectedResult, ...$args)
+    {
+        $result = Engineering::HEXTODEC(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerHEX2DEC()
+    {
+        return require 'data/Calculation/Engineering/HEX2DEC.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2OctTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Hex2OctTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerHEX2OCT
+     *
+     * @param mixed $expectedResult
+     */
+    public function testHEX2OCT($expectedResult, ...$args)
+    {
+        $result = Engineering::HEXTOOCT(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerHEX2OCT()
+    {
+        return require 'data/Calculation/Engineering/HEX2OCT.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImAbsTest.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class ImAbsTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerIMABS
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMABS($expectedResult, $value)
+    {
+        $result = Engineering::IMABS($value);
+        $this->assertEquals($expectedResult, $result, '', self::COMPLEX_PRECISION);
+    }
+
+    public function providerIMABS()
+    {
+        return require 'data/Calculation/Engineering/IMABS.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImArgumentTest.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class ImArgumentTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerIMARGUMENT
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMARGUMENT($expectedResult, $value)
+    {
+        $result = Engineering::IMARGUMENT($value);
+        $this->assertEquals($expectedResult, $result, '', self::COMPLEX_PRECISION);
+    }
+
+    public function providerIMARGUMENT()
+    {
+        return require 'data/Calculation/Engineering/IMARGUMENT.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImConjugateTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImConjugateTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMCONJUGATE
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMCONJUGATE($expectedResult, $value)
+    {
+        $result = Engineering::IMCONJUGATE($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMCONJUGATE()
+    {
+        return require 'data/Calculation/Engineering/IMCONJUGATE.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImCosTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImCosTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMCOS
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMCOS($expectedResult, $value)
+    {
+        $result = Engineering::IMCOS($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMCOS()
+    {
+        return require 'data/Calculation/Engineering/IMCOS.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImCoshTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImCoshTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMCOSH
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMCOSH($expectedResult, $value)
+    {
+        $result = Engineering::IMCOSH($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMCOSH()
+    {
+        return require 'data/Calculation/Engineering/IMCOSH.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImCotTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImCotTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMCOT
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMCOT($expectedResult, $value)
+    {
+        $result = Engineering::IMCOT($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMCOT()
+    {
+        return require 'data/Calculation/Engineering/IMCOT.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImCscTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImCscTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMCSC
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMCSC($expectedResult, $value)
+    {
+        $result = Engineering::IMCSC($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMCSC()
+    {
+        return require 'data/Calculation/Engineering/IMCSC.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImCschTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImCschTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMCSCH
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMCSCH($expectedResult, $value)
+    {
+        $result = Engineering::IMCSCH($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMCSCH()
+    {
+        return require 'data/Calculation/Engineering/IMCSCH.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImDivTest.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImDivTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMDIV
+     *
+     * @param mixed $expectedResult
+     */
+    public function testIMDIV($expectedResult, ...$args)
+    {
+        $result = Engineering::IMDIV(...$args);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMDIV()
+    {
+        return require 'data/Calculation/Engineering/IMDIV.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImExpTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImExpTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMEXP
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMEXP($expectedResult, $value)
+    {
+        $result = Engineering::IMEXP($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMEXP()
+    {
+        return require 'data/Calculation/Engineering/IMEXP.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImLnTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImLnTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMLN
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMLN($expectedResult, $value)
+    {
+        $result = Engineering::IMLN($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMLN()
+    {
+        return require 'data/Calculation/Engineering/IMLN.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImLog10Test.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImLog10Test extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMLOG10
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMLOG10($expectedResult, $value)
+    {
+        $result = Engineering::IMLOG10($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMLOG10()
+    {
+        return require 'data/Calculation/Engineering/IMLOG10.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImLog2Test.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImLog2Test extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMLOG2
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMLOG2($expectedResult, $value)
+    {
+        $result = Engineering::IMLOG2($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMLOG2()
+    {
+        return require 'data/Calculation/Engineering/IMLOG2.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImPowerTest.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImPowerTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMPOWER
+     *
+     * @param mixed $expectedResult
+     */
+    public function testIMPOWER($expectedResult, ...$args)
+    {
+        $result = Engineering::IMPOWER(...$args);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMPOWER()
+    {
+        return require 'data/Calculation/Engineering/IMPOWER.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImProductTest.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImProductTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMPRODUCT
+     *
+     * @param mixed $expectedResult
+     */
+    public function testIMPRODUCT($expectedResult, ...$args)
+    {
+        $result = Engineering::IMPRODUCT(...$args);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMPRODUCT()
+    {
+        return require 'data/Calculation/Engineering/IMPRODUCT.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImRealTest.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class ImRealTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerIMREAL
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMREAL($expectedResult, $value)
+    {
+        $result = Engineering::IMREAL($value);
+        $this->assertEquals($expectedResult, $result, '', self::COMPLEX_PRECISION);
+    }
+
+    public function providerIMREAL()
+    {
+        return require 'data/Calculation/Engineering/IMREAL.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSecTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImSecTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMSEC
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMSEC($expectedResult, $value)
+    {
+        $result = Engineering::IMSEC($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMSEC()
+    {
+        return require 'data/Calculation/Engineering/IMSEC.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSechTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImSechTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMSECH
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMSECH($expectedResult, $value)
+    {
+        $result = Engineering::IMSECH($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMSECH()
+    {
+        return require 'data/Calculation/Engineering/IMSECH.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSinTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImSinTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMSIN
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMSIN($expectedResult, $value)
+    {
+        $result = Engineering::IMSIN($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMSIN()
+    {
+        return require 'data/Calculation/Engineering/IMSIN.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSinhTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImSinhTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMSINH
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMSINH($expectedResult, $value)
+    {
+        $result = Engineering::IMSINH($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMSINH()
+    {
+        return require 'data/Calculation/Engineering/IMSINH.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSqrtTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImSqrtTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMSQRT
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMSQRT($expectedResult, $value)
+    {
+        $result = Engineering::IMSQRT($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMSQRT()
+    {
+        return require 'data/Calculation/Engineering/IMSQRT.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSubTest.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImSubTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMSUB
+     *
+     * @param mixed $expectedResult
+     */
+    public function testIMSUB($expectedResult, ...$args)
+    {
+        $result = Engineering::IMSUB(...$args);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMSUB()
+    {
+        return require 'data/Calculation/Engineering/IMSUB.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSumTest.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImSumTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMSUM
+     *
+     * @param mixed $expectedResult
+     */
+    public function testIMSUM($expectedResult, ...$args)
+    {
+        $result = Engineering::IMSUM(...$args);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMSUM()
+    {
+        return require 'data/Calculation/Engineering/IMSUM.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImTanTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheetTests\Custom\ComplexAssert;
+use PHPUnit\Framework\TestCase;
+
+class ImTanTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    /**
+     * @var ComplexAssert
+     */
+    protected $complexAssert;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->complexAssert = new ComplexAssert();
+    }
+
+    public function tearDown()
+    {
+        $this->complexAssert = null;
+    }
+
+    /**
+     * @dataProvider providerIMTAN
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMTAN($expectedResult, $value)
+    {
+        $result = Engineering::IMTAN($value);
+        $this->assertTrue(
+            $this->complexAssert->assertComplexEquals($expectedResult, $result, self::COMPLEX_PRECISION),
+            $this->complexAssert->getErrorMessage()
+        );
+    }
+
+    public function providerIMTAN()
+    {
+        return require 'data/Calculation/Engineering/IMTAN.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImaginaryTest.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class ImaginaryTest extends TestCase
+{
+    const COMPLEX_PRECISION = 1E-8;
+
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerIMAGINARY
+     *
+     * @param mixed $expectedResult
+     * @param mixed $value
+     */
+    public function testIMAGINARY($expectedResult, $value)
+    {
+        $result = Engineering::IMAGINARY($value);
+        $this->assertEquals($expectedResult, $result, '', self::COMPLEX_PRECISION);
+    }
+
+    public function providerIMAGINARY()
+    {
+        return require 'data/Calculation/Engineering/IMAGINARY.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2BinTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Oct2BinTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerOCT2BIN
+     *
+     * @param mixed $expectedResult
+     */
+    public function testOCT2BIN($expectedResult, ...$args)
+    {
+        $result = Engineering::OCTTOBIN(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerOCT2BIN()
+    {
+        return require 'data/Calculation/Engineering/OCT2BIN.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2DecTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Oct2DecTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerOCT2DEC
+     *
+     * @param mixed $expectedResult
+     */
+    public function testOCT2DEC($expectedResult, ...$args)
+    {
+        $result = Engineering::OCTTODEC(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerOCT2DEC()
+    {
+        return require 'data/Calculation/Engineering/OCT2DEC.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2HexTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class Oct2HexTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    /**
+     * @dataProvider providerOCT2HEX
+     *
+     * @param mixed $expectedResult
+     */
+    public function testOCT2HEX($expectedResult, ...$args)
+    {
+        $result = Engineering::OCTTOHEX(...$args);
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function providerOCT2HEX()
+    {
+        return require 'data/Calculation/Engineering/OCT2HEX.php';
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ParseComplexTest.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PHPUnit\Framework\TestCase;
+
+class ParseComplexTest extends TestCase
+{
+    public function setUp()
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+    }
+
+    public function testParseComplex()
+    {
+        [$real, $imaginary, $suffix] = [1.23e-4, 5.67e+8, 'j'];
+
+        $result = Engineering::parseComplex('1.23e-4+5.67e+8j');
+        $this->assertArrayHasKey('real', $result);
+        $this->assertEquals($real, $result['real']);
+        $this->assertArrayHasKey('imaginary', $result);
+        $this->assertEquals($imaginary, $result['imaginary']);
+        $this->assertArrayHasKey('suffix', $result);
+        $this->assertEquals($suffix, $result['suffix']);
+    }
+}

tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/EvenTest.php

@@ -17,10 +17,11 @@ class EvenTest extends TestCase
      * @dataProvider providerEVEN
      *
      * @param mixed $expectedResult
+     * @param $value
      */
-    public function testEVEN($expectedResult, ...$args)
+    public function testEVEN($expectedResult, $value)
     {
-        $result = MathTrig::EVEN(...$args);
+        $result = MathTrig::EVEN($value);
         $this->assertEquals($expectedResult, $result, '', 1E-12);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/FactDoubleTest.php

@@ -17,10 +17,11 @@ class FactDoubleTest extends TestCase
      * @dataProvider providerFACTDOUBLE
      *
      * @param mixed $expectedResult
+     * @param $value
      */
-    public function testFACTDOUBLE($expectedResult, ...$args)
+    public function testFACTDOUBLE($expectedResult, $value)
     {
-        $result = MathTrig::FACTDOUBLE(...$args);
+        $result = MathTrig::FACTDOUBLE($value);
         $this->assertEquals($expectedResult, $result, '', 1E-12);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/FactTest.php

@@ -17,10 +17,11 @@ class FactTest extends TestCase
      * @dataProvider providerFACT
      *
      * @param mixed $expectedResult
+     * @param $value
      */
-    public function testFACT($expectedResult, ...$args)
+    public function testFACT($expectedResult, $value)
     {
-        $result = MathTrig::FACT(...$args);
+        $result = MathTrig::FACT($value);
         $this->assertEquals($expectedResult, $result, '', 1E-12);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/IntTest.php

@@ -17,10 +17,11 @@ class IntTest extends TestCase
      * @dataProvider providerINT
      *
      * @param mixed $expectedResult
+     * @param $value
      */
-    public function testINT($expectedResult, ...$args)
+    public function testINT($expectedResult, $value)
     {
-        $result = MathTrig::INT(...$args);
+        $result = MathTrig::INT($value);
         $this->assertEquals($expectedResult, $result);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/OddTest.php

@@ -17,10 +17,11 @@ class OddTest extends TestCase
      * @dataProvider providerODD
      *
      * @param mixed $expectedResult
+     * @param $value
      */
-    public function testODD($expectedResult, ...$args)
+    public function testODD($expectedResult, $value)
     {
-        $result = MathTrig::ODD(...$args);
+        $result = MathTrig::ODD($value);
         $this->assertEquals($expectedResult, $result, '', 1E-12);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/SignTest.php

@@ -17,10 +17,11 @@ class SignTest extends TestCase
      * @dataProvider providerSIGN
      *
      * @param mixed $expectedResult
+     * @param $value
      */
-    public function testSIGN($expectedResult, ...$args)
+    public function testSIGN($expectedResult, $value)
     {
-        $result = MathTrig::SIGN(...$args);
+        $result = MathTrig::SIGN($value);
         $this->assertEquals($expectedResult, $result, '', 1E-12);
     }
 

tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/SqrtPiTest.php

@@ -17,10 +17,11 @@ class SqrtPiTest extends TestCase
      * @dataProvider providerSQRTPI
      *
      * @param mixed $expectedResult
+     * @param $value
      */
-    public function testSQRTPI($expectedResult, ...$args)
+    public function testSQRTPI($expectedResult, $value)
     {
-        $result = MathTrig::SQRTPI(...$args);
+        $result = MathTrig::SQRTPI($value);
         $this->assertEquals($expectedResult, $result, '', 1E-12);
     }
 

tests/data/Calculation/DateTime/WEEKNUM.php

@@ -3,53 +3,43 @@
 return [
     [
         52,
-        '21-Dec-2000',
+        '21-Dec-2000', 1,
-        1,
     ],
     [
         1,
-        '2000-01-01',
+        '2000-01-01', 1,
-        1,
     ],
     [
         2,
-        '2000-01-02',
+        '2000-01-02', 1,
-        1,
     ],
     [
         1,
-        '2000-01-01',
+        '2000-01-01', 2,
-        2,
     ],
     [
         2,
-        '2000-01-03',
+        '2000-01-03', 2,
-        2,
     ],
     [
         1,
-        '1995-01-01',
+        '1995-01-01', 1,
-        1,
     ],
     [
         1,
-        '1995-01-07',
+        '1995-01-07', 1,
-        1,
     ],
     [
         2,
-        '1995-01-08',
+        '1995-01-08', 1,
-        1,
     ],
     [
         1,
-        '1995-01-01',
+        '1995-01-01', 2,
-        2,
     ],
     [
         2,
-        '1995-01-02',
+        '1995-01-02', 2,
-        2,
     ],
     [
         28,
@@ -57,18 +47,15 @@ return [
     ],
     [
         '#VALUE!',
-        '3/7/1977',
+        '3/7/1977', 'A',
-        'A',
     ],
     [
         '#NUM!',
-        '3/7/1977',
+        '3/7/1977', 0,
-        0,
     ],
     [
         '#VALUE!',
-        'Invalid',
+        'Invalid', 1,
-        1,
     ],
     [
         '#NUM!',

tests/data/Calculation/Engineering/BESSELI.php

@@ -3,277 +3,222 @@
 return [
     [
         '#NUM!',
-        1.5,
+        1.5, -1,
-        -1,
     ],
     [
         2.249E-5,
-        -1,
+        -1, 6,
-        6,
     ],
     [
         0.0,
-        0,
+        0, 3,
-        3,
     ],
     [
         4.8807925900000004,
-        3,
+        3, 0,
-        0,
     ],
     [
         0.00027146000000000001,
-        1,
+        1, 5,
-        5,
     ],
     [
         0.98166642999999998,
-        1.5,
+        1.5, 1,
-        1,
     ],
     [
         0.33783461999999997,
-        -1.5,
+        -1.5, 2.5,
-        2.5,
     ],
     [
         0.0,
-        -1.5,
+        -1.5, 14.99,
-        14.99,
     ],
     [
         0.0,
-        1,
+        1, 30,
-        30,
     ],
     [
         2.51671625,
-        2.5,
+        2.5, 1,
-        1,
     ],
     [
         2.51671625,
-        2.5,
+        2.5, 1.5,
-        1.5,
     ],
     [
         -2.51671625,
-        -2.5,
+        -2.5, 1.5,
-        1.5,
     ],
     [
         6.20583492,
-        3.5,
+        3.5, 1,
-        1,
     ],
     [
         0.0073673699999999998,
-        0.69999999999999996,
+        0.69999999999999996, 3,
-        3,
     ],
     [
         3.8320120499999999,
-        3.5,
+        3.5, 2,
-        2,
     ],
     [
         '#VALUE!',
-        1.5,
+        1.5, 'XYZ',
-        'XYZ',
     ],
     [
         '#VALUE!',
-        'ABC',
+        'ABC', 3,
-        3,
     ],
     [
         -1030.9147225199999,
-        -9,
+        -9, 1,
-        1,
     ],
     [
         -6.20583492,
-        -3.5,
+        -3.5, 1,
-        1,
     ],
     [
         -0.39288151999999998,
-        -0.73499999999999999,
+        -0.73499999999999999, 1,
-        1,
     ],
     [
         0.0,
-        0,
+        0, 1,
-        1,
     ],
     [
         0.01750268,
-        0.035000000000000003,
+        0.035000000000000003, 1,
-        1,
     ],
     [
         0.56515910000000003,
-        1,
+        1, 1,
-        1,
     ],
     [
         0.98166642999999998,
-        1.5,
+        1.5, 1,
-        1,
     ],
     [
         2.51671625,
-        2.5,
+        2.5, 1,
-        1,
     ],
     [
         6.20583492,
-        3.5,
+        3.5, 1,
-        1,
     ],
     [
         864.49619395000002,
-        -9,
+        -9, 2,
-        2,
     ],
     [
         3.8320120499999999,
-        -3.5,
+        -3.5, 2,
-        2,
     ],
     [
         0.070619940000000006,
-        -0.73499999999999999,
+        -0.73499999999999999, 2,
-        2,
     ],
     [
         0.0,
-        0,
+        0, 2,
-        2,
     ],
     [
         0.00015313999999999999,
-        0.035000000000000003,
+        0.035000000000000003, 2,
-        2,
     ],
     [
         0.10825973,
-        0.90000000000000002,
+        0.90000000000000002, 2,
-        2,
     ],
     [
         0.13574766999999999,
-        1,
+        1, 2,
-        2,
     ],
     [
         0.60327242999999997,
-        1.8999999999999999,
+        1.8999999999999999, 2,
-        2,
     ],
     [
         1.2764661500000001,
-        2.5,
+        2.5, 2,
-        2,
     ],
     [
         3.8320120499999999,
-        3.5,
+        3.5, 2,
-        2,
     ],
     [
         6.4221893799999998,
-        4,
+        4, 2,
-        2,
     ],
     [
         8.8999999999999995E-7,
-        0.035000000000000003,
+        0.035000000000000003, 3,
-        3,
     ],
     [
         0.0073673699999999998,
-        0.69999999999999996,
+        0.69999999999999996, 3,
-        3,
     ],
     [
         0.0154285,
-        0.89000000000000001,
+        0.89000000000000001, 3,
-        3,
     ],
     [
         3.3372757800000001,
-        4,
+        4, 3,
-        3,
     ],
     [
         0.50472435999999998,
-        4,
+        4, 5,
-        5,
     ],
     [
         2.8410000000000001E-5,
-        1.5,
+        1.5, 7,
-        7,
     ],
     [
         0.00013237000000000001,
-        3,
+        3, 9,
-        9,
     ],
     [
         7.3782034300000001,
-        -3.5,
+        -3.5, 0,
-        0,
     ],
     [
         1.6467231899999999,
-        -1.5,
+        -1.5, 0,
-        0,
     ],
     [
         1.0,
-        0,
+        0, 0,
-        0,
     ],
     [
         1.26606588,
-        1,
+        1, 0,
-        0,
     ],
     [
         1.6467231899999999,
-        1.5,
+        1.5, 0,
-        0,
     ],
     [
         3.2898391400000002,
-        2.5,
+        2.5, 0,
-        0,
     ],
     [
         7.3782034300000001,
-        3.5,
+        3.5, 0,
-        0,
     ],
     [
         '#NUM!',
-        -3.5,
+        -3.5, -1,
-        -1,
     ],
     [
         '#VALUE!',
-        true,
+        true, 1,
-        1,
     ],
     [
         '#VALUE!',
-        1,
+        1, true,
-        true,
     ],
     [
         104777847.71856035,
-        21,
+        21, 2,
-        2,
     ],
 ];