alex
/
PhpSpreadsheet
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

This commit is contained in:
MarkBaker 2019-07-25 21:03:47 +02:00
parent 7502320ce3 aaf996a165
commit 13149b7ea7
72 changed files with 2699 additions and 2595 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1009
tests/PhpSpreadsheetTests/Calculation/EngineeringTest.php
View File

File diff suppressed because it is too large Load Diff

8
tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/DayTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/HourTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/MinuteTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/MonthTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/SecondTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/TimeValueTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/DateTime/YearTest.php
View File

@ -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);
}

33
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BesselITest.php Normal file
View File

@ -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';
}
}

33
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BesselJTest.php Normal file
View File

@ -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';
}
}

33
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BesselKTest.php Normal file
View File

@ -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';
}
}

33
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BesselYTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2DecTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2HexTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2OctTest.php Normal file
View File

@ -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';
}
}

32
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BitAndTest.php Normal file
View File

@ -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';
}
}

32
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BitLShiftTest.php Normal file
View File

@ -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';
}
}

32
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BitOrTest.php Normal file
View File

@ -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';
}
}

32
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BitRShiftTest.php Normal file
View File

@ -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';
}
}

32
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/BitXorTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ComplexTest.php Normal file
View File

@ -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';
}
}

55
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ConvertUoMTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2BinTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2HexTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2OctTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/DeltaTest.php Normal file
View File

@ -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';
}
}

33
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ErfCTest.php Normal file
View File

@ -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';
}
}

33
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ErfPreciseTest.php Normal file
View File

@ -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';
}
}

33
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ErfTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/GeStepTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2BinTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2DecTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2OctTest.php Normal file
View File

@ -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';
}
}

34
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImAbsTest.php Normal file
View File

@ -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';
}
}

34
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImArgumentTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImConjugateTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImCosTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImCoshTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImCotTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImCscTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImCschTest.php Normal file
View File

@ -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';
}
}

48
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImDivTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImExpTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImLnTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImLog10Test.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImLog2Test.php Normal file
View File

@ -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';
}
}

48
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImPowerTest.php Normal file
View File

@ -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';
}
}

48
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImProductTest.php Normal file
View File

@ -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';
}
}

34
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImRealTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSecTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSechTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSinTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSinhTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSqrtTest.php Normal file
View File

@ -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';
}
}

48
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSubTest.php Normal file
View File

@ -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';
}
}

48
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImSumTest.php Normal file
View File

@ -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';
}
}

49
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImTanTest.php Normal file
View File

@ -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';
}
}

34
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ImaginaryTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2BinTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2DecTest.php Normal file
View File

@ -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';
}
}

31
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2HexTest.php Normal file
View File

@ -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';
}
}

28
tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/ParseComplexTest.php Normal file
View File

@ -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']);
}
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/EvenTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/FactDoubleTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/FactTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/IntTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/OddTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/SignTest.php
View File

@ -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);
}

5
tests/PhpSpreadsheetTests/Calculation/Functions/MathTrig/SqrtPiTest.php
View File

@ -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);
}

39
tests/data/Calculation/DateTime/WEEKNUM.php
View File

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

165
tests/data/Calculation/Engineering/BESSELI.php
View File

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

1909
tests/data/Calculation/Engineering/COMPLEX.php
View File

File diff suppressed because it is too large Load Diff