Eliminate Mocking from Row/Column/Cell Iterator Tests (#2352)

Mocking is not needed for these tests.

Co-authored-by: Adrien Crivelli <adrien.crivelli@gmail.com>

tests/PhpSpreadsheetTests/Worksheet/ColumnCellIteratorTest.php

@@ -3,100 +3,122 @@
 namespace PhpOffice\PhpSpreadsheetTests\Worksheet;
 
 use PhpOffice\PhpSpreadsheet\Cell\Cell;
+use PhpOffice\PhpSpreadsheet\Exception as Except;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PhpOffice\PhpSpreadsheet\Worksheet\ColumnCellIterator;
 use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
-use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 
 class ColumnCellIteratorTest extends TestCase
 {
-    /**
-     * @var Worksheet&MockObject
-     */
-    private $mockWorksheet;
+    private const CELL_VALUES =
+        [
+            [110, 210, 310, 410, 510, 610, 710],
+            [120, 220, 320, 420, 520, 620],
+            [130, 230, 330, 430, 530, 630],
+            [140, 240, 340, 440, 540, 640],
+            [150, 250, 350, 450, 550, 650],
+            [160, null, 360, null, 560],
+        ];
 
-    /**
-     * @var Cell&MockObject
-     */
-    private $mockCell;
-
-    protected function setUp(): void
+    private static function getPopulatedSheet(Spreadsheet $spreadsheet): Worksheet
     {
-        $this->mockCell = $this->getMockBuilder(Cell::class)
-            ->disableOriginalConstructor()
-            ->getMock();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->fromArray(self::CELL_VALUES);
 
-        $this->mockWorksheet = $this->getMockBuilder(Worksheet::class)
-            ->disableOriginalConstructor()
-            ->getMock();
-
-        $this->mockWorksheet->expects(self::any())
-            ->method('getHighestRow')
-            ->willReturn(5);
-        $this->mockWorksheet->expects(self::any())
-            ->method('getCellByColumnAndRow')
-            ->willReturn($this->mockCell);
+        return $sheet;
     }
 
     public function testIteratorFullRange(): void
     {
-        $iterator = new ColumnCellIterator($this->mockWorksheet, 'A');
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new ColumnCellIterator($sheet, 'A');
         $ColumnCellIndexResult = 1;
         self::assertEquals($ColumnCellIndexResult, $iterator->key());
 
+        $values = [];
         foreach ($iterator as $key => $ColumnCell) {
+            self::assertNotNull($ColumnCell);
+            $values[] = $ColumnCell->getValue();
             self::assertEquals($ColumnCellIndexResult++, $key);
             self::assertInstanceOf(Cell::class, $ColumnCell);
         }
+        $transposed = array_map(null, ...self::CELL_VALUES);
+        self::assertSame($transposed[0], $values);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testIteratorStartEndRange(): void
     {
-        $iterator = new ColumnCellIterator($this->mockWorksheet, 'A', 2, 4);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new ColumnCellIterator($sheet, 'A', 2, 4);
         $ColumnCellIndexResult = 2;
         self::assertEquals($ColumnCellIndexResult, $iterator->key());
 
+        $values = [];
         foreach ($iterator as $key => $ColumnCell) {
+            self::assertNotNull($ColumnCell);
+            $values[] = $ColumnCell->getValue();
             self::assertEquals($ColumnCellIndexResult++, $key);
             self::assertInstanceOf(Cell::class, $ColumnCell);
         }
+        self::assertSame([120, 130, 140], $values);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testIteratorSeekAndPrev(): void
     {
-        $iterator = new ColumnCellIterator($this->mockWorksheet, 'A', 2, 4);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new ColumnCellIterator($sheet, 'A', 2, 4);
         $columnIndexResult = 4;
         $iterator->seek(4);
         self::assertEquals($columnIndexResult, $iterator->key());
 
-        for ($i = 1; $i < $columnIndexResult - 1; ++$i) {
+        $values = [];
+        while ($iterator->valid()) {
+            $current = $iterator->current();
+            self::assertNotNull($current);
+            $cell = $current->getCoordinate();
+            $values[] = $sheet->getCell($cell)->getValue();
             $iterator->prev();
-            self::assertEquals($columnIndexResult - $i, $iterator->key());
         }
+        self::assertSame([140, 130, 120], $values);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testSeekOutOfRange(): void
     {
-        $this->expectException(\PhpOffice\PhpSpreadsheet\Exception::class);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $this->expectException(Except::class);
         $this->expectExceptionMessage('Row 1 is out of range');
-        $iterator = new ColumnCellIterator($this->mockWorksheet, 'A', 2, 4);
+        $iterator = new ColumnCellIterator($sheet, 'A', 2, 4);
         $iterator->seek(1);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testSeekNotExisting(): void
     {
-        $this->expectException(\PhpOffice\PhpSpreadsheet\Exception::class);
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $this->expectException(Except::class);
         $this->expectExceptionMessage('Cell does not exist');
 
-        $iterator = new ColumnCellIterator($this->mockWorksheet, 'A', 2, 4);
+        $iterator = new ColumnCellIterator($sheet, 'A', 2, 4);
         $iterator->setIterateOnlyExistingCells(true);
         $iterator->seek(2);
     }
 
-    public function testPrevOutOfRange(): void
+    public function xtestPrevOutOfRange(): void
     {
-        $iterator = new ColumnCellIterator($this->mockWorksheet, 'A', 2, 4);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new ColumnCellIterator($sheet, 'A', 2, 4);
         $iterator->prev();
         self::assertFalse($iterator->valid());
+        $spreadsheet->disconnectWorksheets();
     }
 }

tests/PhpSpreadsheetTests/Worksheet/ColumnIteratorTest.php

@@ -2,72 +2,92 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Worksheet;
 
+use PhpOffice\PhpSpreadsheet\Exception as Except;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PhpOffice\PhpSpreadsheet\Worksheet\Column;
 use PhpOffice\PhpSpreadsheet\Worksheet\ColumnIterator;
 use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
-use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 
 class ColumnIteratorTest extends TestCase
 {
-    /**
-     * @var Worksheet&MockObject
-     */
-    private $mockWorksheet;
+    private const CELL_VALUES =
+        [
+            [110, 210, 310, 410, 510, 610],
+            [120, 220, 320, 420, 520, 620],
+            [130, null, 330, null, 530],
+        ];
 
-    protected function setUp(): void
+    private static function getPopulatedSheet(Spreadsheet $spreadsheet): Worksheet
     {
-        $this->mockWorksheet = $this->getMockBuilder(Worksheet::class)
-            ->disableOriginalConstructor()
-            ->getMock();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->fromArray(self::CELL_VALUES);
 
-        $this->mockWorksheet->expects(self::any())
-            ->method('getHighestColumn')
-            ->willReturn('E');
+        return $sheet;
     }
 
     public function testIteratorFullRange(): void
     {
-        $iterator = new ColumnIterator($this->mockWorksheet);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new ColumnIterator($sheet);
         $columnIndexResult = 'A';
         self::assertEquals($columnIndexResult, $iterator->key());
 
+        $counter = 0;
         foreach ($iterator as $key => $column) {
+            ++$counter;
             self::assertEquals($columnIndexResult++, $key);
             self::assertInstanceOf(Column::class, $column);
         }
+        self::assertCount($counter, self::CELL_VALUES[0]);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testIteratorStartEndRange(): void
     {
-        $iterator = new ColumnIterator($this->mockWorksheet, 'B', 'D');
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new ColumnIterator($sheet, 'B', 'D');
         $columnIndexResult = 'B';
         self::assertEquals($columnIndexResult, $iterator->key());
 
+        $counter = 0;
         foreach ($iterator as $key => $column) {
+            ++$counter;
             self::assertEquals($columnIndexResult++, $key);
             self::assertInstanceOf(Column::class, $column);
         }
+        self::assertSame(3, $counter);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testIteratorSeekAndPrev(): void
     {
-        $ranges = range('A', 'E');
-        $iterator = new ColumnIterator($this->mockWorksheet, 'B', 'D');
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new ColumnIterator($sheet, 'B', 'D');
         $columnIndexResult = 'D';
         $iterator->seek('D');
         self::assertEquals($columnIndexResult, $iterator->key());
 
-        for ($i = 1; $i < array_search($columnIndexResult, $ranges); ++$i) {
+        $counter = 0;
+        while ($iterator->valid() !== false) {
+            ++$counter;
+            self::assertEquals($columnIndexResult, $iterator->key(), "counter $counter");
+            // https://stackoverflow.com/questions/37027277/decrement-character-with-php
+            $columnIndexResult = chr(ord($columnIndexResult) - 1);
             $iterator->prev();
-            $expectedResult = $ranges[array_search($columnIndexResult, $ranges) - $i];
-            self::assertEquals($expectedResult, $iterator->key());
         }
+        self::assertSame(3, $counter);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testIteratorResetStart(): void
     {
-        $iterator = new ColumnIterator($this->mockWorksheet, 'B', 'D');
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new ColumnIterator($sheet, 'B', 'D');
         $iterator->resetStart('E');
 
         $key = $iterator->key();
@@ -79,28 +99,38 @@ class ColumnIteratorTest extends TestCase
             $lastColumn = $iterator->key();
         }
         self::assertSame('F', $lastColumn);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testSeekOutOfRange(): void
     {
-        $this->expectException(\PhpOffice\PhpSpreadsheet\Exception::class);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $this->expectException(Except::class);
 
-        $iterator = new ColumnIterator($this->mockWorksheet, 'B', 'D');
+        $iterator = new ColumnIterator($sheet, 'B', 'D');
         $iterator->seek('A');
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testPrevOutOfRange(): void
     {
-        $iterator = new ColumnIterator($this->mockWorksheet, 'B', 'D');
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new ColumnIterator($sheet, 'B', 'D');
         $iterator->prev();
         self::assertFalse($iterator->valid());
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testResetStartOutOfRange(): void
     {
-        $this->expectException(\PhpOffice\PhpSpreadsheet\Exception::class);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $this->expectException(Except::class);
 
-        $iterator = new ColumnIterator($this->mockWorksheet, 'B', 'D');
+        $iterator = new ColumnIterator($sheet, 'B', 'D');
         $iterator->resetStart('H');
+        $spreadsheet->disconnectWorksheets();
     }
 }

tests/PhpSpreadsheetTests/Worksheet/ColumnTest.php

@@ -2,49 +2,42 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Worksheet;
 
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PhpOffice\PhpSpreadsheet\Worksheet\Column;
 use PhpOffice\PhpSpreadsheet\Worksheet\ColumnCellIterator;
-use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
-use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 
 class ColumnTest extends TestCase
 {
-    /**
-     * @var Worksheet&MockObject
-     */
-    private $mockWorksheet;
-
-    protected function setUp(): void
-    {
-        $this->mockWorksheet = $this->getMockBuilder(Worksheet::class)
-            ->disableOriginalConstructor()
-            ->getMock();
-        $this->mockWorksheet->expects(self::any())
-            ->method('getHighestRow')
-            ->willReturn(5);
-    }
-
     public function testInstantiateColumnDefault(): void
     {
-        $column = new Column($this->mockWorksheet);
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $column = new Column($sheet);
         self::assertInstanceOf(Column::class, $column);
         $columnIndex = $column->getColumnIndex();
         self::assertEquals('A', $columnIndex);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testInstantiateColumnSpecified(): void
     {
-        $column = new Column($this->mockWorksheet, 'E');
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $column = new Column($sheet, 'E');
         self::assertInstanceOf(Column::class, $column);
         $columnIndex = $column->getColumnIndex();
         self::assertEquals('E', $columnIndex);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testGetCellIterator(): void
     {
-        $column = new Column($this->mockWorksheet);
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $column = new Column($sheet);
         $cellIterator = $column->getCellIterator();
         self::assertInstanceOf(ColumnCellIterator::class, $cellIterator);
+        $spreadsheet->disconnectWorksheets();
     }
 }

tests/PhpSpreadsheetTests/Worksheet/RowCellIteratorTest.php

@@ -3,105 +3,125 @@
 namespace PhpOffice\PhpSpreadsheetTests\Worksheet;
 
 use PhpOffice\PhpSpreadsheet\Cell\Cell;
+use PhpOffice\PhpSpreadsheet\Exception as Except;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PhpOffice\PhpSpreadsheet\Worksheet\RowCellIterator;
 use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
-use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 
 class RowCellIteratorTest extends TestCase
 {
-    /**
-     * @var Worksheet&MockObject
-     */
-    private $mockWorksheet;
+    private const CELL_VALUES =
+        [
+            [110, 120, 130, 140, 150, 160, 170],
+            [210, 220, 230, 240, 250],
+            [310, 320, 330, 340, 350, 360],
+            [410, 420, 430, 440, 450],
+            [510, 520, 530, 540, 550, 560],
+            [610, 620, 630, 640, 650],
+        ];
 
-    /**
-     * @var Cell&MockObject
-     */
-    private $mockCell;
-
-    protected function setUp(): void
+    private static function getPopulatedSheet(Spreadsheet $spreadsheet): Worksheet
     {
-        $this->mockCell = $this->getMockBuilder(Cell::class)
-            ->disableOriginalConstructor()
-            ->getMock();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->fromArray(self::CELL_VALUES);
 
-        $this->mockWorksheet = $this->getMockBuilder(Worksheet::class)
-            ->disableOriginalConstructor()
-            ->getMock();
-
-        $this->mockWorksheet->expects(self::any())
-            ->method('getHighestColumn')
-            ->willReturn('E');
-        $this->mockWorksheet->expects(self::any())
-            ->method('getCellByColumnAndRow')
-            ->willReturn($this->mockCell);
+        return $sheet;
     }
 
     public function testIteratorFullRange(): void
     {
-        $iterator = new RowCellIterator($this->mockWorksheet);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new RowCellIterator($sheet);
         $RowCellIndexResult = 'A';
         self::assertEquals($RowCellIndexResult, $iterator->key());
 
+        $values = [];
         foreach ($iterator as $key => $RowCell) {
+            self::assertNotNull($RowCell);
+            $values[] = $RowCell->getValue();
             self::assertEquals($RowCellIndexResult++, $key);
             self::assertInstanceOf(Cell::class, $RowCell);
         }
+        self::assertSame(self::CELL_VALUES[0], $values);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testIteratorStartEndRange(): void
     {
-        $iterator = new RowCellIterator($this->mockWorksheet, 2, 'B', 'D');
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new RowCellIterator($sheet, 2, 'B', 'D');
         $RowCellIndexResult = 'B';
         self::assertEquals($RowCellIndexResult, $iterator->key());
 
+        $values = [];
         foreach ($iterator as $key => $RowCell) {
+            self::assertNotNull($RowCell);
+            $values[] = $RowCell->getValue();
             self::assertEquals($RowCellIndexResult++, $key);
             self::assertInstanceOf(Cell::class, $RowCell);
         }
+        self::assertSame([220, 230, 240], $values);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testIteratorSeekAndPrev(): void
     {
-        $ranges = range('A', 'E');
-        $iterator = new RowCellIterator($this->mockWorksheet, 2, 'B', 'D');
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new RowCellIterator($sheet, 2, 'B', 'D');
         $RowCellIndexResult = 'D';
         $iterator->seek('D');
         self::assertEquals($RowCellIndexResult, $iterator->key());
 
-        for ($i = 1; $i < array_search($RowCellIndexResult, $ranges); ++$i) {
+        $values = [];
+        while ($iterator->valid()) {
+            $current = $iterator->current();
+            self::assertNotNull($current);
+            $cell = $current->getCoordinate();
+            $values[] = $sheet->getCell($cell)->getValue();
             $iterator->prev();
-            $expectedResult = $ranges[array_search($RowCellIndexResult, $ranges) - $i];
-            self::assertEquals($expectedResult, $iterator->key());
         }
+        self::assertSame([240, 230, 220], $values);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testSeekOutOfRange(): void
     {
-        $this->expectException(\PhpOffice\PhpSpreadsheet\Exception::class);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $this->expectException(Except::class);
         $this->expectExceptionMessage('Column A is out of range');
 
-        $iterator = new RowCellIterator($this->mockWorksheet, 2, 'B', 'D');
+        $iterator = new RowCellIterator($sheet, 2, 'B', 'D');
         self::assertFalse($iterator->getIterateOnlyExistingCells());
         self::assertEquals(2, $iterator->getCurrentColumnIndex());
         $iterator->seek('A');
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testSeekNotExisting(): void
     {
-        $this->expectException(\PhpOffice\PhpSpreadsheet\Exception::class);
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $this->expectException(Except::class);
         $this->expectExceptionMessage('Cell does not exist');
 
-        $iterator = new RowCellIterator($this->mockWorksheet, 2, 'B', 'D');
+        $iterator = new RowCellIterator($sheet, 2, 'B', 'D');
         $iterator->setIterateOnlyExistingCells(true);
         $iterator->seek('B');
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testPrevOutOfRange(): void
     {
-        $iterator = new RowCellIterator($this->mockWorksheet, 2, 'B', 'D');
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new RowCellIterator($sheet, 2, 'B', 'D');
         $iterator->prev();
         self::assertFalse($iterator->valid());
+        $spreadsheet->disconnectWorksheets();
     }
 }

tests/PhpSpreadsheetTests/Worksheet/RowIteratorTest.php

@@ -2,70 +2,94 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Worksheet;
 
+use PhpOffice\PhpSpreadsheet\Exception as Except;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PhpOffice\PhpSpreadsheet\Worksheet\Row;
 use PhpOffice\PhpSpreadsheet\Worksheet\RowIterator;
 use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
-use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 
 class RowIteratorTest extends TestCase
 {
-    /**
-     * @var Worksheet&MockObject
-     */
-    private $mockWorksheet;
+    private const CELL_VALUES =
+        [
+            [110, 120, 130],
+            [210, 220],
+            [310, 320, 330],
+            [410, 420],
+            [510, 520, 530],
+            [610, 620],
+        ];
 
-    protected function setUp(): void
+    private static function getPopulatedSheet(Spreadsheet $spreadsheet): Worksheet
     {
-        $this->mockWorksheet = $this->getMockBuilder(Worksheet::class)
-            ->disableOriginalConstructor()
-            ->getMock();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->fromArray(self::CELL_VALUES);
 
-        $this->mockWorksheet->expects(self::any())
-            ->method('getHighestRow')
-            ->willReturn(5);
+        return $sheet;
     }
 
     public function testIteratorFullRange(): void
     {
-        $iterator = new RowIterator($this->mockWorksheet);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new RowIterator($sheet);
         $rowIndexResult = 1;
         self::assertEquals($rowIndexResult, $iterator->key());
 
+        $counter = 0;
         foreach ($iterator as $key => $row) {
+            ++$counter;
             self::assertEquals($rowIndexResult++, $key);
             self::assertInstanceOf(Row::class, $row);
         }
+        self::assertCount($counter, self::CELL_VALUES);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testIteratorStartEndRange(): void
     {
-        $iterator = new RowIterator($this->mockWorksheet, 2, 4);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new RowIterator($sheet, 2, 4);
         $rowIndexResult = 2;
         self::assertEquals($rowIndexResult, $iterator->key());
 
+        $counter = 0;
         foreach ($iterator as $key => $row) {
+            ++$counter;
             self::assertEquals($rowIndexResult++, $key);
             self::assertInstanceOf(Row::class, $row);
         }
+        self::assertSame(3, $counter);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testIteratorSeekAndPrev(): void
     {
-        $iterator = new RowIterator($this->mockWorksheet, 2, 4);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new RowIterator($sheet, 2, 4);
         $columnIndexResult = 4;
         $iterator->seek(4);
         self::assertEquals($columnIndexResult, $iterator->key());
 
-        for ($i = 1; $i < $columnIndexResult - 1; ++$i) {
+        $counter = 0;
+        while ($iterator->valid() !== false) {
+            ++$counter;
+            self::assertEquals($columnIndexResult, $iterator->key());
+            --$columnIndexResult;
             $iterator->prev();
-            self::assertEquals($columnIndexResult - $i, $iterator->key());
         }
+        self::assertSame(3, $counter);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testIteratorResetStart(): void
     {
-        $iterator = new RowIterator($this->mockWorksheet, 2, 4);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new RowIterator($sheet, 2, 4);
         $iterator->resetStart(5);
 
         $key = $iterator->key();
@@ -77,28 +101,35 @@ class RowIteratorTest extends TestCase
             $lastRow = $iterator->key();
         }
         self::assertSame(6, $lastRow);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testSeekOutOfRange(): void
     {
-        $this->expectException(\PhpOffice\PhpSpreadsheet\Exception::class);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $this->expectException(Except::class);
 
-        $iterator = new RowIterator($this->mockWorksheet, 2, 4);
+        $iterator = new RowIterator($sheet, 2, 4);
         $iterator->seek(1);
     }
 
     public function testPrevOutOfRange(): void
     {
-        $iterator = new RowIterator($this->mockWorksheet, 2, 4);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $iterator = new RowIterator($sheet, 2, 4);
         $iterator->prev();
         self::assertFalse($iterator->valid());
     }
 
     public function testResetStartOutOfRange(): void
     {
-        $this->expectException(\PhpOffice\PhpSpreadsheet\Exception::class);
+        $spreadsheet = new Spreadsheet();
+        $sheet = self::getPopulatedSheet($spreadsheet);
+        $this->expectException(Except::class);
 
-        $iterator = new RowIterator($this->mockWorksheet, 2, 4);
+        $iterator = new RowIterator($sheet, 2, 4);
         $iterator->resetStart(10);
     }
 }

tests/PhpSpreadsheetTests/Worksheet/RowTest.php

@@ -2,49 +2,42 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Worksheet;
 
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PhpOffice\PhpSpreadsheet\Worksheet\Row;
 use PhpOffice\PhpSpreadsheet\Worksheet\RowCellIterator;
-use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
-use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 
 class RowTest extends TestCase
 {
-    /**
-     * @var Worksheet&MockObject
-     */
-    private $mockWorksheet;
-
-    protected function setUp(): void
-    {
-        $this->mockWorksheet = $this->getMockBuilder(Worksheet::class)
-            ->disableOriginalConstructor()
-            ->getMock();
-        $this->mockWorksheet->expects(self::any())
-            ->method('getHighestColumn')
-            ->willReturn('E');
-    }
-
     public function testInstantiateRowDefault(): void
     {
-        $row = new Row($this->mockWorksheet);
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $row = new Row($sheet);
         self::assertInstanceOf(Row::class, $row);
         $rowIndex = $row->getRowIndex();
         self::assertEquals(1, $rowIndex);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testInstantiateRowSpecified(): void
     {
-        $row = new Row($this->mockWorksheet, 5);
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $row = new Row($sheet, 5);
         self::assertInstanceOf(Row::class, $row);
         $rowIndex = $row->getRowIndex();
         self::assertEquals(5, $rowIndex);
+        $spreadsheet->disconnectWorksheets();
     }
 
     public function testGetCellIterator(): void
     {
-        $row = new Row($this->mockWorksheet);
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $row = new Row($sheet);
         $cellIterator = $row->getCellIterator();
         self::assertInstanceOf(RowCellIterator::class, $cellIterator);
+        $spreadsheet->disconnectWorksheets();
     }
 }