DayTest::tearDown() - Code Metrics - Inspection of "Refactor unit tests to ensure that assertions and..." - PHPOffice/PhpSpreadsheet - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#3448)

by Mark

created 2023-03-14 10:16 UTC

DayTest::tearDown() A

↳ Parent: DayTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	2
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\DateTime;

use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel\DateParts;
use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalculationException;
use PhpOffice\PhpSpreadsheet\Calculation\Functions;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Calculation\Functions\FormulaArguments;
use PHPUnit\Framework\TestCase;

class DayTest extends TestCase
{
    /**
     * @var string
     */
    private $compatibilityMode;

    protected function setUp(): void
    {
        parent::setUp();

        $this->compatibilityMode = Functions::getCompatibilityMode();
    }

    protected function tearDown(): void
    {
        parent::tearDown();

        Functions::setCompatibilityMode($this->compatibilityMode);
    }

    /**
     * @dataProvider providerDAY
     *
     * @param mixed $expectedResultExcel
     */
    public function testDirectCallToDAY($expectedResultExcel, ...$args): void
    {
        /** @scrutinizer ignore-call */
        $result = DateParts::day(...$args);
        self::assertSame($expectedResultExcel, $result);
    }

    /**
     * @dataProvider providerDAY
     *
     * @param mixed $expectedResultExcel
     */
    public function testDAYAsFormula($expectedResultExcel, ...$args): void
    {
        $arguments = new FormulaArguments(...$args);

        $calculation = Calculation::getInstance();
        $formula = "=DAY({$arguments})";

        $result = $calculation->_calculateFormulaValue($formula);
        self::assertSame($expectedResultExcel, $result);
    }

    /**
     * @dataProvider providerDAY
     *
     * @param mixed $expectedResult
     */
    public function testDAYInWorksheet($expectedResult, ...$args): void
    {
        $arguments = new FormulaArguments(...$args);

        $spreadsheet = new Spreadsheet();
        $worksheet = $spreadsheet->getActiveSheet();
        $argumentCells = $arguments->populateWorksheet($worksheet);
        $formula = "=DAY({$argumentCells})";

        $result = $worksheet->setCellValue('A1', $formula)
            ->getCell('A1')
            ->getCalculatedValue();
        self::assertSame($expectedResult, $result);

        $spreadsheet->disconnectWorksheets();
    }

    public function providerDAY(): array
    {
        return require 'tests/data/Calculation/DateTime/DAY.php';
    }

    /**
     * @dataProvider providerDAYOpenOffice
     *
     * @param mixed $expectedResultOpenOffice
     */
    public function testDirectCallToDAYOpenOffice($expectedResultOpenOffice, ...$args): void
    {
        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);

        /** @scrutinizer ignore-call */
        $result = DateParts::day(...$args);
        self::assertSame($expectedResultOpenOffice, $result);
    }

    /**
     * @dataProvider providerDAYOpenOffice
     *
     * @param mixed $expectedResultOpenOffice
     */
    public function testDAYAsFormulaOpenOffice($expectedResultOpenOffice, ...$args): void
    {
        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);

        $arguments = new FormulaArguments(...$args);

        $calculation = Calculation::getInstance();
        $formula = "=DAY({$arguments})";

        $result = $calculation->_calculateFormulaValue($formula);
        self::assertSame($expectedResultOpenOffice, $result);
    }

    public function providerDAYOpenOffice(): array
    {
        return require 'tests/data/Calculation/DateTime/DAYOpenOffice.php';
    }

    /**
     * @dataProvider providerUnhappyDAY
     */
    public function testDAYUnhappyPath(string $expectedException, ...$args): void
    {
        $arguments = new FormulaArguments(...$args);

        $spreadsheet = new Spreadsheet();
        $worksheet = $spreadsheet->getActiveSheet();
        $argumentCells = $arguments->populateWorksheet($worksheet);
        $formula = "=DAY({$argumentCells})";

        $this->expectException(CalculationException::class);
        $this->expectExceptionMessage($expectedException);
        $worksheet->setCellValue('A1', $formula)
            ->getCell('A1')
            ->getCalculatedValue();

        $spreadsheet->disconnectWorksheets();
    }

    public function providerUnhappyDAY(): array
    {
        return [
            ['Formula Error: Wrong number of arguments for DAY() function'],
        ];
    }

    public function testDirectCallToDAYWithNull(): void
    {
        $result = DateParts::day(null);
        self::assertSame(0, $result);
    }

    /**
     * @dataProvider providerDayArray
     */
    public function testDayArray(array $expectedResult, string $array): void
    {
        $calculation = Calculation::getInstance();

        $formula = "=DAY({$array})";
        $result = $calculation->_calculateFormulaValue($formula);
        self::assertEqualsWithDelta($expectedResult, $result, 1.0e-14);
    }

    public function providerDayArray(): array
    {
        return [
            'row vector' => [[[1, 12, 22]], '{"2022-01-01", "2022-06-12", "2023-07-22"}'],
            'column vector' => [[[1], [3], [6]], '{"2022-01-01"; "2022-01-03"; "2022-01-06"}'],
            'matrix' => [[[1, 10], [15, 31]], '{"2022-01-01", "2022-01-10"; "2022-08-15", "2022-12-31"}'],
        ];
    }
}


1			<?php
2
3			namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\DateTime;
4
5			use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
6			use PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel\DateParts;
7			use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalculationException;
8			use PhpOffice\PhpSpreadsheet\Calculation\Functions;
9			use PhpOffice\PhpSpreadsheet\Spreadsheet;
10			use PhpOffice\PhpSpreadsheetTests\Calculation\Functions\FormulaArguments;
11			use PHPUnit\Framework\TestCase;
12
13			class DayTest extends TestCase
14			{
15			/**
16			* @var string
17			*/
18			private $compatibilityMode;
19
20			protected function setUp(): void
21			{
22			parent::setUp();
23
24			$this->compatibilityMode = Functions::getCompatibilityMode();
25			}
26
27			protected function tearDown(): void
28			{
29			parent::tearDown();
30
31			Functions::setCompatibilityMode($this->compatibilityMode);
32			}
33
34			/**
35			* @dataProvider providerDAY
36			*
37			* @param mixed $expectedResultExcel
38			*/
39			public function testDirectCallToDAY($expectedResultExcel, ...$args): void
40			{
41			/** @scrutinizer ignore-call */
42			$result = DateParts::day(...$args);
43			self::assertSame($expectedResultExcel, $result);
44			}
45
46			/**
47			* @dataProvider providerDAY
48			*
49			* @param mixed $expectedResultExcel
50			*/
51			public function testDAYAsFormula($expectedResultExcel, ...$args): void
52			{
53			$arguments = new FormulaArguments(...$args);
54
55			$calculation = Calculation::getInstance();
56			$formula = "=DAY({$arguments})";
57
58			$result = $calculation->_calculateFormulaValue($formula);
59			self::assertSame($expectedResultExcel, $result);
60			}
61
62			/**
63			* @dataProvider providerDAY
64			*
65			* @param mixed $expectedResult
66			*/
67			public function testDAYInWorksheet($expectedResult, ...$args): void
68			{
69			$arguments = new FormulaArguments(...$args);
70
71			$spreadsheet = new Spreadsheet();
72			$worksheet = $spreadsheet->getActiveSheet();
73			$argumentCells = $arguments->populateWorksheet($worksheet);
74			$formula = "=DAY({$argumentCells})";
75
76			$result = $worksheet->setCellValue('A1', $formula)
77			->getCell('A1')
78			->getCalculatedValue();
79			self::assertSame($expectedResult, $result);
80
81			$spreadsheet->disconnectWorksheets();
82			}
83
84			public function providerDAY(): array
85			{
86			return require 'tests/data/Calculation/DateTime/DAY.php';
87			}
88
89			/**
90			* @dataProvider providerDAYOpenOffice
91			*
92			* @param mixed $expectedResultOpenOffice
93			*/
94			public function testDirectCallToDAYOpenOffice($expectedResultOpenOffice, ...$args): void
95			{
96			Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
97
98			/** @scrutinizer ignore-call */
99			$result = DateParts::day(...$args);
100			self::assertSame($expectedResultOpenOffice, $result);
101			}
102
103			/**
104			* @dataProvider providerDAYOpenOffice
105			*
106			* @param mixed $expectedResultOpenOffice
107			*/
108			public function testDAYAsFormulaOpenOffice($expectedResultOpenOffice, ...$args): void
109			{
110			Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
111
112			$arguments = new FormulaArguments(...$args);
113
114			$calculation = Calculation::getInstance();
115			$formula = "=DAY({$arguments})";
116
117			$result = $calculation->_calculateFormulaValue($formula);
118			self::assertSame($expectedResultOpenOffice, $result);
119			}
120
121			public function providerDAYOpenOffice(): array
122			{
123			return require 'tests/data/Calculation/DateTime/DAYOpenOffice.php';
124			}
125
126			/**
127			* @dataProvider providerUnhappyDAY
128			*/
129			public function testDAYUnhappyPath(string $expectedException, ...$args): void
130			{
131			$arguments = new FormulaArguments(...$args);
132
133			$spreadsheet = new Spreadsheet();
134			$worksheet = $spreadsheet->getActiveSheet();
135			$argumentCells = $arguments->populateWorksheet($worksheet);
136			$formula = "=DAY({$argumentCells})";
137
138			$this->expectException(CalculationException::class);
139			$this->expectExceptionMessage($expectedException);
140			$worksheet->setCellValue('A1', $formula)
141			->getCell('A1')
142			->getCalculatedValue();
143
144			$spreadsheet->disconnectWorksheets();
145			}
146
147			public function providerUnhappyDAY(): array
148			{
149			return [
150			['Formula Error: Wrong number of arguments for DAY() function'],
151			];
152			}
153
154			public function testDirectCallToDAYWithNull(): void
155			{
156			$result = DateParts::day(null);
157			self::assertSame(0, $result);
158			}
159
160			/**
161			* @dataProvider providerDayArray
162			*/
163			public function testDayArray(array $expectedResult, string $array): void
164			{
165			$calculation = Calculation::getInstance();
166
167			$formula = "=DAY({$array})";
168			$result = $calculation->_calculateFormulaValue($formula);
169			self::assertEqualsWithDelta($expectedResult, $result, 1.0e-14);
170			}
171
172			public function providerDayArray(): array
173			{
174			return [
175			'row vector' => [[[1, 12, 22]], '{"2022-01-01", "2022-06-12", "2023-07-22"}'],
176			'column vector' => [[[1], [3], [6]], '{"2022-01-01"; "2022-01-03"; "2022-01-06"}'],
177			'matrix' => [[[1, 10], [15, 31]], '{"2022-01-01", "2022-01-10"; "2022-08-15", "2022-12-31"}'],
178			];
179			}
180			}
181

PHPOffice / PhpSpreadsheet

Pull Request — master (#3448)

DayTest::tearDown() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like