Minor Coverage Improvements

Author: oleibman

src/PhpSpreadsheet/Calculation/Calculation.php

@@ -1236,13 +1236,16 @@ private function internalParseFormula(string $formula, ?Cell $cell = null): bool
                     //     because at least the braces are paired up (at this stage in the formula)
                     // MS Excel allows this if the content is cell references; but doesn't allow actual values,
                     //    but at this point, we can't differentiate (so allow both)
-                    //return $this->raiseFormulaError('Formula Error: Unexpected ,');
+                    return $this->raiseFormulaError('Formula Error: Unexpected ,');
+                    /* The following code may be a better choice, but, with
+                       the other changes for this PR, I can no longer come up
+                       with a test case that gets here
                     $stack->push('Binary Operator', '∪');
 
                     ++$index;
                     $expectingOperator = false;
 
-                    continue;
+                    continue;*/
                 }
 
                 /** @var array<string, int> $d */

tests/PhpSpreadsheetTests/Cell/ConvertSpecialArrayTest.php

@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpOffice\PhpSpreadsheetTests\Cell;
+
+use PhpOffice\PhpSpreadsheet\Cell\Cell;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+
+class ConvertSpecialArrayTest extends TestCase
+{
+    /**
+     * @param mixed[] $expected
+     * @param mixed[] $inArray
+     */
+    #[DataProvider('providerSpecialArrays')]
+    public function testConvertSpecialArray(array $expected, array $inArray): void
+    {
+        $reflectionMethod = new ReflectionMethod(Cell::class, 'convertSpecialArray');
+        $result = $reflectionMethod->invokeArgs(null, [$inArray]);
+        self::assertSame($expected, $result);
+    }
+
+    public static function providerSpecialArrays(): array
+    {
+        return [
+            'expected form row index to array indexed by column' => [
+                [
+                    [1, 2],
+                    [3, 4],
+                ],
+                [
+                    1 => ['A' => 1, 'B' => 2],
+                    2 => ['A' => 3, 'B' => 4],
+                ],
+            ],
+            'standard array unchanged' => [
+                [
+                    1 => [1, 2],
+                    2 => [3, 4],
+                ],
+                [
+                    1 => [1, 2],
+                    2 => [3, 4],
+                ],
+            ],
+            'uses index 0 so unchanged' => [
+                [
+                    ['A' => 1, 'B' => 2],
+                    ['A' => 3, 'B' => 4],
+                ],
+                [
+                    ['A' => 1, 'B' => 2],
+                    ['A' => 3, 'B' => 4],
+                ],
+            ],
+        ];
+    }
+}