PhpOffice\PhpSpreadsheetTests\CellTest

Complexity

Total Complexity

42

Size/Duplication

Total Lines	311
Duplicated Lines	29.26 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	providerRangeBoundaries()	0	4	1
A	providerRangeDimension()	0	4	1
A	providerGetRangeBoundaries()	0	4	1
A	providerExtractAllCellReferencesInRange()	0	4	1
A	testRangeBoundaries()	0	5	1
A	testRangeDimension()	0	5	1
A	testGetRangeBoundaries()	0	5	1
A	testExtractAllCellReferencesInRange()	0	5	1
A	testColumnIndexFromString()	0	5	1
A	providerColumnString()	0	4	1
A	testColumnIndexFromStringTooLong()	13	13	2
A	testColumnIndexFromStringTooShort()	13	13	2
A	testStringFromColumnIndex()	0	5	1
A	providerColumnIndex()	0	4	1
A	testCoordinateFromString()	0	5	1
A	providerCoordinates()	0	4	1
A	testCoordinateFromStringWithRangeAddress()	13	13	2
A	testCoordinateFromStringWithEmptyAddress()	13	13	2
A	testCoordinateFromStringWithInvalidAddress()	13	13	2
A	testAbsoluteCoordinateFromString()	0	5	1
A	providerAbsoluteCoordinates()	0	4	1
A	testAbsoluteCoordinateFromStringWithRangeAddress()	13	13	2
A	testAbsoluteReferenceFromString()	0	5	1
A	providerAbsoluteReferences()	0	4	1
A	testAbsoluteReferenceFromStringWithRangeAddress()	13	13	2
A	testSplitRange()	0	11	3
A	providerSplitRange()	0	4	1
A	testBuildRange()	0	5	1
A	providerBuildRange()	0	4	1
A	testBuildRangeInvalid()	0	9	2
A	testMergeRangesInCollection()	0	5	1
A	providerMergeRangesInCollection()	0	4	1

<?php

namespace PhpOffice\PhpSpreadsheetTests;

use PhpOffice\PhpSpreadsheet\Cell;
use PhpOffice\PhpSpreadsheet\Exception;
use PHPUnit_Framework_TestCase;

class CellTest extends PHPUnit_Framework_TestCase
{
    /**
     * @dataProvider providerColumnString
     *
     * @param mixed $expectedResult
     */
    public function testColumnIndexFromString($expectedResult, ...$args)
    {
        $result = Cell::columnIndexFromString(...$args);

$args is of type array<integer,?>, but the function expects a string.

        $this->assertEquals($expectedResult, $result);
    }

    public function providerColumnString()
    {
        return require 'data/ColumnString.php';
    }

    public function testColumnIndexFromStringTooLong()

This method seems to be duplicated in your project.

    {
        $cellAddress = 'ABCD';
        try {
            Cell::columnIndexFromString($cellAddress);
        } catch (\Exception $e) {
            $this->assertInstanceOf(Exception::class, $e);
            $this->assertEquals($e->getMessage(), 'Column string index can not be longer than 3 characters');

            return;
        }
        $this->fail('An expected exception has not been raised.');
    }

    public function testColumnIndexFromStringTooShort()

This method seems to be duplicated in your project.

    {
        $cellAddress = '';
        try {
            Cell::columnIndexFromString($cellAddress);
        } catch (\Exception $e) {
            $this->assertInstanceOf(Exception::class, $e);
            $this->assertEquals($e->getMessage(), 'Column string index can not be empty');

            return;
        }
        $this->fail('An expected exception has not been raised.');
    }

    /**
     * @dataProvider providerColumnIndex
     *
     * @param mixed $expectedResult
     */
    public function testStringFromColumnIndex($expectedResult, ...$args)
    {
        $result = Cell::stringFromColumnIndex(...$args);

$args is of type array<integer,?>, but the function expects a integer.

        $this->assertEquals($expectedResult, $result);
    }

    public function providerColumnIndex()
    {
        return require 'data/ColumnIndex.php';
    }

    /**
     * @dataProvider providerCoordinates
     *
     * @param mixed $expectedResult
     */
    public function testCoordinateFromString($expectedResult, ...$args)
    {
        $result = Cell::coordinateFromString(...$args);

$args is of type array<integer,?>, but the function expects a string.

        $this->assertEquals($expectedResult, $result);
    }

    public function providerCoordinates()
    {
        return require 'data/CellCoordinates.php';
    }

    public function testCoordinateFromStringWithRangeAddress()

This method seems to be duplicated in your project.

    {
        $cellAddress = 'A1:AI2012';
        try {
            Cell::coordinateFromString($cellAddress);
        } catch (\Exception $e) {
            $this->assertInstanceOf(Exception::class, $e);
            $this->assertEquals($e->getMessage(), 'Cell coordinate string can not be a range of cells');

            return;
        }
        $this->fail('An expected exception has not been raised.');
    }

    public function testCoordinateFromStringWithEmptyAddress()

This method seems to be duplicated in your project.

    {
        $cellAddress = '';
        try {
            Cell::coordinateFromString($cellAddress);
        } catch (\Exception $e) {
            $this->assertInstanceOf(Exception::class, $e);
            $this->assertEquals($e->getMessage(), 'Cell coordinate can not be zero-length string');

            return;
        }
        $this->fail('An expected exception has not been raised.');
    }

    public function testCoordinateFromStringWithInvalidAddress()

This method seems to be duplicated in your project.

    {
        $cellAddress = 'AI';
        try {
            Cell::coordinateFromString($cellAddress);
        } catch (\Exception $e) {
            $this->assertInstanceOf(Exception::class, $e);
            $this->assertEquals($e->getMessage(), 'Invalid cell coordinate ' . $cellAddress);

            return;
        }
        $this->fail('An expected exception has not been raised.');
    }

    /**
     * @dataProvider providerAbsoluteCoordinates
     *
     * @param mixed $expectedResult
     */
    public function testAbsoluteCoordinateFromString($expectedResult, ...$args)
    {
        $result = Cell::absoluteCoordinate(...$args);

$args is of type array<integer,?>, but the function expects a string.

        $this->assertEquals($expectedResult, $result);
    }

    public function providerAbsoluteCoordinates()
    {
        return require 'data/CellAbsoluteCoordinate.php';
    }

    public function testAbsoluteCoordinateFromStringWithRangeAddress()

This method seems to be duplicated in your project.

    {
        $cellAddress = 'A1:AI2012';
        try {
            Cell::absoluteCoordinate($cellAddress);
        } catch (\Exception $e) {
            $this->assertInstanceOf(Exception::class, $e);
            $this->assertEquals($e->getMessage(), 'Cell coordinate string can not be a range of cells');

            return;
        }
        $this->fail('An expected exception has not been raised.');
    }

    /**
     * @dataProvider providerAbsoluteReferences
     *
     * @param mixed $expectedResult
     */
    public function testAbsoluteReferenceFromString($expectedResult, ...$args)
    {
        $result = Cell::absoluteReference(...$args);

$args is of type array<integer,?>, but the function expects a string.

        $this->assertEquals($expectedResult, $result);
    }

    public function providerAbsoluteReferences()
    {
        return require 'data/CellAbsoluteReference.php';
    }

    public function testAbsoluteReferenceFromStringWithRangeAddress()

This method seems to be duplicated in your project.

    {
        $cellAddress = 'A1:AI2012';
        try {
            Cell::absoluteReference($cellAddress);
        } catch (\Exception $e) {
            $this->assertInstanceOf(Exception::class, $e);
            $this->assertEquals($e->getMessage(), 'Cell coordinate string can not be a range of cells');

            return;
        }
        $this->fail('An expected exception has not been raised.');
    }

    /**
     * @dataProvider providerSplitRange
     *
     * @param mixed $expectedResult
     */
    public function testSplitRange($expectedResult, ...$args)
    {
        $result = Cell::splitRange(...$args);

$args is of type array<integer,?>, but the function expects a string.

        foreach ($result as $key => $split) {
            if (!is_array($expectedResult[$key])) {
                $this->assertEquals($expectedResult[$key], $split[0]);
            } else {
                $this->assertEquals($expectedResult[$key], $split);
            }
        }
    }

    public function providerSplitRange()
    {
        return require 'data/CellSplitRange.php';
    }

    /**
     * @dataProvider providerBuildRange
     *
     * @param mixed $expectedResult
     */
    public function testBuildRange($expectedResult, ...$args)
    {
        $result = Cell::buildRange(...$args);
        $this->assertEquals($expectedResult, $result);
    }

    public function providerBuildRange()
    {
        return require 'data/CellBuildRange.php';
    }

    /**
     * @expectedException \TypeError
     */
    public function testBuildRangeInvalid()
    {
        if (PHP_MAJOR_VERSION < 7) {
            $this->markTestSkipped('Cannot catch type hinting error with PHP 5.6');
        }

        $cellRange = '';
        Cell::buildRange($cellRange);

$cellRange is of type string, but the function expects a array.

    }

    /**
     * @dataProvider providerRangeBoundaries
     *
     * @param mixed $expectedResult
     */
    public function testRangeBoundaries($expectedResult, ...$args)
    {
        $result = Cell::rangeBoundaries(...$args);

$args is of type array<integer,?>, but the function expects a string.

        $this->assertEquals($expectedResult, $result);
    }

    public function providerRangeBoundaries()
    {
        return require 'data/CellRangeBoundaries.php';
    }

    /**
     * @dataProvider providerRangeDimension
     *
     * @param mixed $expectedResult
     */
    public function testRangeDimension($expectedResult, ...$args)
    {
        $result = Cell::rangeDimension(...$args);

$args is of type array<integer,?>, but the function expects a string.

        $this->assertEquals($expectedResult, $result);
    }

    public function providerRangeDimension()
    {
        return require 'data/CellRangeDimension.php';
    }

    /**
     * @dataProvider providerGetRangeBoundaries
     *
     * @param mixed $expectedResult
     */
    public function testGetRangeBoundaries($expectedResult, ...$args)
    {
        $result = Cell::getRangeBoundaries(...$args);

$args is of type array<integer,?>, but the function expects a string.

        $this->assertEquals($expectedResult, $result);
    }

    public function providerGetRangeBoundaries()
    {
        return require 'data/CellGetRangeBoundaries.php';
    }

    /**
     * @dataProvider providerExtractAllCellReferencesInRange
     *
     * @param mixed $expectedResult
     */
    public function testExtractAllCellReferencesInRange($expectedResult, ...$args)
    {
        $result = Cell::extractAllCellReferencesInRange(...$args);

$args is of type array<integer,?>, but the function expects a string.

        $this->assertEquals($expectedResult, $result);
    }

    public function providerExtractAllCellReferencesInRange()
    {
        return require 'data/CellExtractAllCellReferencesInRange.php';
    }

    /**
     * @dataProvider providerMergeRangesInCollection
     *
     * @param mixed $expectedResult
     */
    public function testMergeRangesInCollection($expectedResult, ...$args)
    {
        $result = Cell::mergeRangesInCollection(...$args);
        $this->assertEquals($expectedResult, $result);
    }

    public function providerMergeRangesInCollection()
    {
        return require 'data/CellMergeRangesInCollection.php';
    }
}