Adding PHP spreadsheet unit tests, various fixes along the way

jstest/spreadsheet/CellValueTests.js

 		value = CellValue.fromValue('foo');
 		this.assertEqual(CellValue.TYPE_STRING, value.type);
 		this.assertEqual('foo', value.formattedValue);
-		value = CellValue.fromValue('123');
+		value = CellValue.fromValue('0123456');
 		this.assertEqual(CellValue.TYPE_STRING, value.type);
-		this.assertEqual('123', value.formattedValue);
+		this.assertEqual('0123456', value.formattedValue);
 	}
 
 	test_fromValue_formula() {

php/spreadsheet.php

 		}
 		$evaled = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
 		for ($i = 0; $i < count($evaled) - 1; $i += 2) {
-			$test = $evaled[$i].booleanValue();
+			$test = $evaled[$i]->booleanValue();
 			if ($test === null) {
 				throw new CellEvaluationException("IFS expects a boolean for argument " . ($i + 1));
 			}
 			throw new CellEvaluationException("NOT expects one argument");
 		}
 		$evaled = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
-		$b = $evaled[0].booleanValue();
+		$b = $evaled[0]->booleanValue();
 		if ($b === null) {
 			throw new CellEvaluationException("NOT expects boolean argument");
 		}
 		$val = $evaled[0];
 		$places = count($evaled) > 1 ? $evaled[1]->value : 0;
 		$divider = pow(10.0, $places);
-		$newValue = round($val->value * $divider) / $divider;
+		$newValue = floor($val->value * $divider + 0.5) / $divider;
 		return CellValue::fromValue($newValue, $val->type);
 	}
 
 		if ($text === null || $search === null || $replace === null) {
 			throw new CellEvaluationException("SUBSTITUTE expects 3 string arguments");
 		}
-		$result = str_replace($search, $replace, $text);
+		$result = str_ireplace($search, $replace, $text);
 		return CellValue::fromValue($result);
 	}
 
 	 * not be altered on that axis.
 	 *
 	 * Examples:
-	 * - C6.transpose(A5, A9) = C10  (A9-A5 = +4 rows, C6 + 4 rows = C10)
-	 * - C6.transpose(A5, B9) = D10  (B9-A5 = +4 rows +1 cols, C6 + 4 rows + 1
+	 * - C6->transpose(A5, A9) = C10  (A9-A5 = +4 rows, C6 + 4 rows = C10)
+	 * - C6->transpose(A5, B9) = D10  (B9-A5 = +4 rows +1 cols, C6 + 4 rows + 1
 	 *   col = D10)
-	 * - C$6.transpose(A5, A9) = C6  (A9-A5 = +4 rows, but row is fixed, so
+	 * - C$6->transpose(A5, A9) = C6  (A9-A5 = +4 rows, but row is fixed, so
 	 *   still C6)
-	 * - B.transpose(A5, A9) = B9  (A9-A4 = +4 rows, B has no row so last row
+	 * - B->transpose(A5, A9) = B9  (A9-A4 = +4 rows, B has no row so last row
 	 *   used = B9)
-	 * - A1.transpose(C3, A1) = null (out of bounds)
+	 * - A1->transpose(C3, A1) = null (out of bounds)
 	 * 
 	 * @param CellAddress $relativeFrom  original address of the formula
 	 * @param CellAddress $relativeTo  address where the formula is being
 	 * 
 	 * Example:
 	 * ```
-	 * foreach (range.cellsIn(grid) as $addressString => $cell) {
+	 * foreach ($range->cellsIn($grid) as $addressString => $cell) {
 	 *     ...
 	 * }
 	 * ```
 	 * @return object iterable object
 	 */
 	public function cellsIn(SpreadsheetGrid $grid): Iterator {
-		$minCol = $this->minColumnIndex;
-		$maxCol = $this->maxColumnIndex;
-		$minRow = $this->minRowIndex;
-		$maxRow = $this->maxRowIndex;
-		if ($minRow === -1) {
-			$minRow = 0;
-		}
-		if ($maxRow === -1) {
-			$maxRow = $grid->rowCount - 1;
-		}
-		$maxCol = min($maxCol, $grid->columnCount);
+		$minCol = max(0, $this->minColumnIndex);
+		$maxCol = $this->maxColumnIndex < 0 ? $grid->columnCount - 1 : min($this->maxColumnIndex, $grid->columnCount - 1);
+		$minRow = max(0, $this->minRowIndex);
+		$maxRow = $this->maxRowIndex < 0 ? $grid->rowCount - 1 : min($this->maxRowIndex, $grid->rowCount - 1);
 		return new class($grid, $minCol, $maxCol, $minRow, $maxRow) implements Iterator {
 			private SpreadsheetGrid $grid;
 			private int $minCol;
 
 	/**
 	 * Constructs a cell value explicitly. Values are not validated. Consider
-	 * using `.fromCellString()` or `.fromValue()` to populate values more
+	 * using `->fromCellString()` or `->fromValue()` to populate values more
 	 * intelligently and consistently.
 	 */
 	public function __construct(
 			}
 			return new CellValue('#ERROR', $value->getMessage(), CellValue::TYPE_ERROR);
 		}
-		if (is_bool($value)) {
+		if (gettype($value) === 'boolean') {
 			$formatted = CellValue::formatType($value, CellValue::TYPE_BOOLEAN, 0);
 			return new CellValue($formatted, $value, CellValue::TYPE_BOOLEAN);
 		}
-		if (is_numeric($value)) {
+		if (gettype($value) === 'integer') {
+			$resolvedType = $type ?? CellValue::TYPE_NUMBER;
+			$resolvedDecimals = 0;
+			$formatted = CellValue::formatType($value, $resolvedType, $resolvedDecimals);
+			return new CellValue($formatted, $value, $resolvedType, $resolvedDecimals);
+		}
+		if (gettype($value) === 'double') {
 			$resolvedType = $type ?? CellValue::TYPE_NUMBER;
 			$resolvedDecimals = ($decimals !== null) ? $decimals :
 				($resolvedType === CellValue::TYPE_CURRENCY ? 2 :
 			$wholes = mb_eregi_replace(',', '', $groups[1]);
 			$this->type = CellValue::TYPE_NUMBER;
 			$this->decimals = 0;
-			$this->value = floatval($wholes);
+			$this->value = intval($wholes);
 			$this->formattedValue = CellValue::formatNumber($this->value, $this->decimals);
 			return;
 		}
 	 */
 	public function modulo($b) {
 		return self::binaryNumericOperation($this, $b, '%', function($aVal, $bVal) {
-			if ($bVal === 0) throw new CellEvaluationException("Division by zero", '#NAN');
-			return $aVal % $bVal;
+			if ($bVal == 0) throw new CellEvaluationException("Division by zero", '#NAN');
+			if (gettype($aVal) === 'integer' && gettype($bVal) === 'integer') {
+				return $aVal % $bVal;
+			}
+			return fmod($aVal, $bVal);
 		});
 	}
 

phptest/spreadsheet/CellAddressRangeTests.php

+<?php
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+
+require_once __DIR__ . '/../../php/markdown.php';
+require_once __DIR__ . '/../../php/spreadsheet.php';
+
+final class CellAddressRangeTests extends TestCase {
+	public function test_iterator() {
+		$grid = new SpreadsheetGrid(3, 4);
+		$range = new CellAddressRange(new CellAddress(0, 0), new CellAddress(2, 3));
+		$visited = [];
+		$sanity = 100;
+		foreach ($range->cellsIn($grid) as $address_string => $cell) {
+			array_push($visited, $address_string);
+			if ($sanity-- < 0) break;
+		}
+		$actual = implode(',', $visited);
+		$expected = 'A1,A2,A3,A4,B1,B2,B3,B4,C1,C2,C3,C4';
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_iterator_column() {
+		$grid = new SpreadsheetGrid(3, 4);
+		$range = new CellAddressRange(new CellAddress(1, -1), new CellAddress(2, -1));
+		$visited = [];
+		$sanity = 100;
+		foreach ($range->cellsIn($grid) as $address_string => $cell) {
+			array_push($visited, $address_string);
+			if ($sanity-- < 0) break;
+		}
+		$actual = implode(',', $visited);
+		$expected = 'B1,B2,B3,B4,C1,C2,C3,C4';
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_iterator_beyondBounds() {
+		$grid = new SpreadsheetGrid(3, 4);
+		$range = new CellAddressRange(new CellAddress(0, 1), new CellAddress(9, 9));
+		$visited = [];
+		$sanity = 100;
+		foreach ($range->cellsIn($grid) as $address_string => $cell) {
+			array_push($visited, $address_string);
+			if ($sanity-- < 0) break;
+		}
+		$actual = implode(',', $visited);
+		$expected = 'A2,A3,A4,B2,B3,B4,C2,C3,C4';
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_iterator_outOfBounds() {
+		$grid = new SpreadsheetGrid(3, 4);
+		$range = new CellAddressRange(new CellAddress(5, 0), new CellAddress(5, 9));
+		$visited = [];
+		$sanity = 100;
+		foreach ($range->cellsIn($grid) as $address_string => $cell) {
+			array_push($visited, $address_string);
+			if ($sanity-- < 0) break;
+		}
+		$actual = implode(',', $visited);
+		$expected = '';
+		$this->assertSame($expected, $actual);
+	}
+}
+?>

phptest/spreadsheet/CellValueTests.php

+<?php
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+
+require_once __DIR__ . '/../../php/markdown.php';
+require_once __DIR__ . '/../../php/spreadsheet.php';
+
+final class CellValueTests extends TestCase {
+	public function test_fromCellString_blank() {
+		$value = CellValue::fromCellString('');
+		$this->assertSame(CellValue::TYPE_BLANK, $value->type);
+		$this->assertSame('', $value->formattedValue);
+		$this->assertSame(null, $value->value);
+		$value = CellValue::fromCellString(' ');
+		$this->assertSame(CellValue::TYPE_BLANK, $value->type);
+		$this->assertSame('', $value->formattedValue);
+		$this->assertSame(null, $value->value);
+	}
+
+	public function test_fromCellString_number() {
+		$value = CellValue::fromCellString('123');
+		$this->assertSame(CellValue::TYPE_NUMBER, $value->type);
+		$this->assertSame('123', $value->formattedValue);
+		$this->assertEqualsWithDelta(123, $value->value, 0.000_001);
+		$this->assertSame(0, $value->decimals);
+		$value = CellValue::fromCellString('-0');
+		$this->assertSame(CellValue::TYPE_NUMBER, $value->type);
+		$this->assertSame('0', $value->formattedValue);
+		$this->assertEqualsWithDelta(0, $value->value, 0.000_001);
+		$this->assertSame(0, $value->decimals);
+		$value = CellValue::fromCellString('1,234');
+		$this->assertSame(CellValue::TYPE_NUMBER, $value->type);
+		$this->assertSame('1,234', $value->formattedValue);
+		$this->assertEqualsWithDelta(1234, $value->value, 0.000_001);
+		$this->assertSame(0, $value->decimals);
+		$value = CellValue::fromCellString('-1,234,567.89');
+		$this->assertSame(CellValue::TYPE_NUMBER, $value->type);
+		$this->assertSame('-1,234,567.89', $value->formattedValue);
+		$this->assertEqualsWithDelta(-1234567.89, $value->value, 0.000_001);
+		$this->assertSame(2, $value->decimals);
+	}
+
+	public function test_fromCellString_percent() {
+		$value = CellValue::fromCellString('123%');
+		$this->assertSame(CellValue::TYPE_PERCENT, $value->type);
+		$this->assertSame('123%', $value->formattedValue);
+		$this->assertEqualsWithDelta(1.23, $value->value, 0.000_001);
+		$this->assertSame(0, $value->decimals);
+		$value = CellValue::fromCellString('-12.3%');
+		$this->assertSame(CellValue::TYPE_PERCENT, $value->type);
+		$this->assertSame('-12.3%', $value->formattedValue);
+		$this->assertEqualsWithDelta(-0.123, $value->value, 0.000_001);
+		$this->assertSame(1, $value->decimals);
+	}
+
+	public function test_fromCellString_currency() {
+		$value = CellValue::fromCellString('$123');
+		$this->assertSame(CellValue::TYPE_CURRENCY, $value->type);
+		$this->assertSame('$123', $value->formattedValue);
+		$this->assertEqualsWithDelta(123, $value->value, 0.000_001);
+		$this->assertSame(0, $value->decimals);
+		$value = CellValue::fromCellString('-$12.34');
+		$this->assertSame(CellValue::TYPE_CURRENCY, $value->type);
+		$this->assertSame('-$12.34', $value->formattedValue);
+		$this->assertEqualsWithDelta(-12.34, $value->value, 0.000_001);
+		$this->assertSame(2, $value->decimals);
+	}
+
+	public function test_fromCellString_boolean() {
+		$value = CellValue::fromCellString('true');
+		$this->assertSame(CellValue::TYPE_BOOLEAN, $value->type);
+		$this->assertSame('TRUE', $value->formattedValue);
+		$this->assertSame(true, $value->value);
+		$value = CellValue::fromCellString('false');
+		$this->assertSame(CellValue::TYPE_BOOLEAN, $value->type);
+		$this->assertSame('FALSE', $value->formattedValue);
+		$this->assertSame(false, $value->value);
+	}
+
+	public function test_fromCellString_string() {
+		$value = CellValue::fromCellString('some text');
+		$this->assertSame(CellValue::TYPE_STRING, $value->type);
+		$this->assertSame('some text', $value->formattedValue);
+		$this->assertSame('some text', $value->value);
+		$value = CellValue::fromCellString("'0123");
+		$this->assertSame(CellValue::TYPE_STRING, $value->type);
+		$this->assertSame('0123', $value->formattedValue);
+		$this->assertSame('0123', $value->value);
+		$value = CellValue::fromCellString("'=123");
+		$this->assertSame(CellValue::TYPE_STRING, $value->type);
+		$this->assertSame('=123', $value->formattedValue);
+		$this->assertSame('=123', $value->value);
+	}
+
+	public function test_fromCellString_formula() {
+		$value = CellValue::fromCellString('=A*B');
+		$this->assertSame(CellValue::TYPE_FORMULA, $value->type);
+		$this->assertSame('=A*B', $value->formattedValue);
+		$this->assertSame('=A*B', $value->value);
+		$value = CellValue::fromCellString('=MAX(A, 3)');
+		$this->assertSame(CellValue::TYPE_FORMULA, $value->type);
+		$this->assertSame('=MAX(A, 3)', $value->formattedValue);
+		$this->assertSame('=MAX(A, 3)', $value->value);
+	}
+
+	public function test_fromValue_null() {
+		$value = CellValue::fromValue(null);
+		$this->assertSame(CellValue::TYPE_BLANK, $value->type);
+	}
+
+	public function test_fromValue_number() {
+		$value = CellValue::fromValue(123);
+		$this->assertSame(CellValue::TYPE_NUMBER, $value->type);
+		$this->assertSame('123', $value->formattedValue);
+		$value = CellValue::fromValue(3.141592);
+		$this->assertSame(CellValue::TYPE_NUMBER, $value->type);
+		$this->assertSame('3.141592', $value->formattedValue);
+		$value = CellValue::fromValue(123456789);
+		$this->assertSame(CellValue::TYPE_NUMBER, $value->type);
+		$this->assertSame('123,456,789', $value->formattedValue);
+	}
+
+	public function test_fromValue_boolean() {
+		$value = CellValue::fromValue(true);
+		$this->assertSame(CellValue::TYPE_BOOLEAN, $value->type);
+		$this->assertSame('TRUE', $value->formattedValue);
+		$value = CellValue::fromValue(false);
+		$this->assertSame(CellValue::TYPE_BOOLEAN, $value->type);
+		$this->assertSame('FALSE', $value->formattedValue);
+	}
+
+	public function test_fromValue_string() {
+		$value = CellValue::fromValue('foo');
+		$this->assertSame(CellValue::TYPE_STRING, $value->type);
+		$this->assertSame('foo', $value->formattedValue);
+		$value = CellValue::fromValue('0123456');
+		$this->assertSame(CellValue::TYPE_STRING, $value->type);
+		$this->assertSame('0123456', $value->formattedValue);
+	}
+
+	public function test_fromValue_formula() {
+		$value = CellValue::fromValue('=A*B');
+		$this->assertSame(CellValue::TYPE_FORMULA, $value->type);
+		$this->assertSame('=A*B', $value->formattedValue);
+	}
+
+	private function assertSameCellValue(CellValue $expected, CellValue $actual) {
+		$this->assertSame($expected->formattedValue, $actual->formattedValue);
+		$this->assertSame($expected->value, $actual->value);
+		$this->assertSame($expected->type, $actual->type);
+		$this->assertSame($expected->decimals, $actual->decimals);
+	}
+
+	public function test_operation_add() {
+		$a = CellValue::fromValue(3);
+		$b = CellValue::fromValue(4);
+		$actual = $a->add($b);
+		$expected = new CellValue('7', 7, CellValue::TYPE_NUMBER, 0);
+		$this->assertSameCellValue($expected, $actual);
+
+		$a = CellValue::fromCellString('100%');
+		$b = CellValue::fromCellString('50%');
+		$actual = $a->add($b);
+		$expected = new CellValue('150%', 1.5, CellValue::TYPE_PERCENT, 0);
+		$this->assertSameCellValue($expected, $actual);
+
+		$a = CellValue::fromCellString('$123');
+		$b = CellValue::fromCellString('$321');
+		$actual = $a->add($b);
+		$expected = new CellValue('$444.00', 444.0, CellValue::TYPE_CURRENCY, 2);
+		$this->assertSameCellValue($expected, $actual);
+	}
+
+	public function test_operation_subtract() {
+		$a = CellValue::fromValue(9);
+		$b = CellValue::fromValue(4);
+		$actual = $a->subtract($b);
+		$expected = new CellValue('5', 5, CellValue::TYPE_NUMBER, 0);
+		$this->assertSameCellValue($expected, $actual);
+
+		$a = CellValue::fromCellString('100%');
+		$b = CellValue::fromCellString('50%');
+		$actual = $a->subtract($b);
+		$expected = new CellValue('50%', 0.5, CellValue::TYPE_PERCENT, 0);
+		$this->assertSameCellValue($expected, $actual);
+
+		$a = CellValue::fromCellString('$321');
+		$b = CellValue::fromCellString('$123');
+		$actual = $a->subtract($b);
+		$expected = new CellValue('$198.00', 198.0, CellValue::TYPE_CURRENCY, 2);
+		$this->assertSameCellValue($expected, $actual);
+	}
+
+	public function test_operation_multiply() {
+		$a = CellValue::fromValue(3);
+		$b = CellValue::fromValue(4);
+		$actual = $a->multiply($b);
+		$expected = new CellValue('12', 12, CellValue::TYPE_NUMBER, 0);
+		$this->assertSameCellValue($expected, $actual);
+
+		$a = CellValue::fromCellString('150%');
+		$b = CellValue::fromCellString('50%');
+		$actual = $a->multiply($b);
+		$expected = new CellValue('75%', 0.75, CellValue::TYPE_PERCENT, 0);
+		$this->assertSameCellValue($expected, $actual);
+
+		$a = CellValue::fromCellString('$321');
+		$b = CellValue::fromCellString('50%');
+		$actual = $a->multiply($b);
+		$expected = new CellValue('$160.50', 160.50, CellValue::TYPE_CURRENCY, 2);
+		$this->assertSameCellValue($expected, $actual);
+	}
+
+	public function test_operation_divide() {
+		$a = CellValue::fromValue(12);
+		$b = CellValue::fromValue(4);
+		$actual = $a->divide($b);
+		$expected = new CellValue('3', 3, CellValue::TYPE_NUMBER, 0);
+		$this->assertSameCellValue($expected, $actual);
+
+		$a = CellValue::fromCellString('150%');
+		$b = CellValue::fromCellString('50%');
+		$actual = $a->divide($b);
+		$expected = new CellValue('300%', 3.0, CellValue::TYPE_PERCENT, 0);
+		$this->assertSameCellValue($expected, $actual);
+
+		$a = CellValue::fromCellString('$321');
+		$b = CellValue::fromCellString('200%');
+		$actual = $a->divide($b);
+		$expected = new CellValue('$160.50', 160.50, CellValue::TYPE_CURRENCY, 2);
+		$this->assertSameCellValue($expected, $actual);
+	}
+
+	public function test_operation_modulo() {
+		$a = CellValue::fromValue(7);
+		$b = CellValue::fromValue(4);
+		$actual = $a->modulo($b);
+		$expected = new CellValue('3', 3, CellValue::TYPE_NUMBER, 0);
+		$this->assertSameCellValue($expected, $actual);
+
+		$a = CellValue::fromCellString('175%');
+		$b = CellValue::fromCellString('50%');
+		$actual = $a->modulo($b);
+		$expected = new CellValue('25%', 0.25, CellValue::TYPE_PERCENT, 0);
+		$this->assertSameCellValue($expected, $actual);
+
+		$a = CellValue::fromCellString('$327');
+		$b = CellValue::fromCellString('$20');
+		$actual = $a->modulo($b);
+		$expected = new CellValue('$7.00', 7.00, CellValue::TYPE_CURRENCY, 2);
+		$this->assertSameCellValue($expected, $actual);
+	}
+
+	public function test_operation_unaryNot() {
+		$this->assertSameCellValue(CellValue::fromValue(false), CellValue::fromValue(true)->not());
+		$this->assertSameCellValue(CellValue::fromValue(true), CellValue::fromValue(false)->not());
+	}
+
+	public function test_operation_comparators() {
+		$a = CellValue::fromValue(3);
+		$b = CellValue::fromValue(4);
+		$t = CellValue::fromValue(true);
+		$f = CellValue::fromValue(false);
+
+		$this->assertSameCellValue($t, $a->lt($b));
+		$this->assertSameCellValue($t, $a->lte($b));
+		$this->assertSameCellValue($f, $a->gt($b));
+		$this->assertSameCellValue($f, $a->gte($b));
+		$this->assertSameCellValue($f, $a->eq($b));
+		$this->assertSameCellValue($t, $a->neq($b));
+
+		$this->assertSameCellValue($f, $b->lt($a));
+		$this->assertSameCellValue($f, $b->lte($a));
+		$this->assertSameCellValue($t, $b->gt($a));
+		$this->assertSameCellValue($t, $b->gte($a));
+		$this->assertSameCellValue($f, $b->eq($a));
+		$this->assertSameCellValue($t, $b->neq($a));
+
+		$this->assertSameCellValue($f, $a->lt($a));
+		$this->assertSameCellValue($t, $a->lte($a));
+		$this->assertSameCellValue($f, $a->gt($a));
+		$this->assertSameCellValue($t, $a->gte($a));
+		$this->assertSameCellValue($t, $a->eq($a));
+		$this->assertSameCellValue($f, $a->neq($a));
+	}
+
+	public function test_operation_concatenate() {
+		$a = CellValue::fromValue('abc');
+		$b = CellValue::fromValue('xyz');
+		$actual = $a->concatenate($b);
+		$expected = CellValue::fromValue('abcxyz');
+		$this->assertSameCellValue($expected, $actual);
+	}
+}
+?>

phptest/spreadsheet/ExpressionSetTests.php

+<?php
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+
+require_once __DIR__ . '/../../php/markdown.php';
+require_once __DIR__ . '/../../php/spreadsheet.php';
+
+final class ExpressionSetTests extends TestCase {
+	private function assertSameCellValue(CellValue $expected, CellValue $actual) {
+		$this->assertSame($expected->formattedValue, $actual->formattedValue);
+		if (gettype($expected->value) === 'double' && gettype($actual->value) === 'double') {
+			$this->assertEqualsWithDelta($expected->value, $actual->value, 0.000_001);
+		} else {
+			$this->assertSame($expected->value, $actual->value);
+		}
+		$this->assertSame($expected->type, $actual->type);
+		$this->assertSame($expected->decimals, $actual->decimals);
+	}
+
+	public function test_simpleMath() {
+		$grid = new SpreadsheetGrid(1, 1);
+		$grid->cells[0][0]->originalValue = CellValue::fromCellString('=7*3');
+		$expressionSet = new CellExpressionSet($grid);
+		$expressionSet->calculateCells();
+		$expected = CellValue::fromValue(21);
+		$actual = $grid->cells[0][0]->outputValue;
+		$this->assertSameCellValue($expected, $actual);
+	}
+
+	public function test_reference() {
+		$grid = new SpreadsheetGrid(3, 1);
+		$grid->cells[0][0]->originalValue = CellValue::fromValue(123);
+		$grid->cells[1][0]->originalValue = CellValue::fromValue(3);
+		$grid->cells[2][0]->originalValue = CellValue::fromCellString('=A1*B1');
+		$expressionSet = new CellExpressionSet($grid);
+		$expressionSet->calculateCells();
+		$expected = CellValue::fromValue(369);
+		$actual = $grid->cells[2][0]->outputValue;
+		$this->assertSameCellValue($expected, $actual);
+	}
+
+	public function test_infixPriority() {
+		$grid = new SpreadsheetGrid(1, 1);
+		$grid->cells[0][0]->originalValue = CellValue::fromCellString('=4*9/3+7-4');
+		$expressionSet = new CellExpressionSet($grid);
+		$expressionSet->calculateCells();
+		$expected = CellValue::fromValue(15);
+		$actual = $grid->cells[0][0]->outputValue;
+		$this->assertSameCellValue($expected, $actual);
+	}
+
+	public function test_filledFormula() {
+		$grid = new SpreadsheetGrid(3, 3);
+		$grid->cells[0][0]->originalValue = CellValue::fromValue(4);
+		$grid->cells[1][0]->originalValue = CellValue::fromValue(5);
+		$grid->cells[2][0]->originalValue = CellValue::fromCellString('=A1*B1 FILL');
+		$grid->cells[0][1]->originalValue = CellValue::fromValue(6);
+		$grid->cells[1][1]->originalValue = CellValue::fromValue(7);
+		$grid->cells[0][2]->originalValue = CellValue::fromValue(8);
+		$grid->cells[1][2]->originalValue = CellValue::fromValue(9);
+		$expressionSet = new CellExpressionSet($grid);
+		$expressionSet->calculateCells();
+		$this->assertSameCellValue(CellValue::fromValue(20), $grid->cells[2][0]->outputValue);
+		$this->assertSameCellValue(CellValue::fromValue(42), $grid->cells[2][1]->outputValue);
+		$this->assertSameCellValue(CellValue::fromValue(72), $grid->cells[2][2]->outputValue);
+	}
+
+	public function test_dependencies() {
+		$grid = new SpreadsheetGrid(2, 4);
+		$grid->cells[0][0]->originalValue = CellValue::fromValue(1);
+		$grid->cells[1][0]->originalValue = CellValue::fromCellString('=A1+B2');
+		$grid->cells[0][1]->originalValue = CellValue::fromValue(2);
+		$grid->cells[1][1]->originalValue = CellValue::fromCellString('=A2+B3');
+		$grid->cells[0][2]->originalValue = CellValue::fromValue(3);
+		$grid->cells[1][2]->originalValue = CellValue::fromCellString('=A3+B4');
+		$grid->cells[0][3]->originalValue = CellValue::fromValue(4);
+		$grid->cells[1][3]->originalValue = CellValue::fromCellString('=A4');
+		$expressionSet = new CellExpressionSet($grid);
+		$expressionSet->calculateCells();
+		$this->assertSameCellValue(CellValue::fromValue(10), $grid->cells[1][0]->outputValue);
+		$this->assertSameCellValue(CellValue::fromValue(9), $grid->cells[1][1]->outputValue);
+		$this->assertSameCellValue(CellValue::fromValue(7), $grid->cells[1][2]->outputValue);
+		$this->assertSameCellValue(CellValue::fromValue(4), $grid->cells[1][3]->outputValue);
+	}
+
+	private function test_simple_formula($expected, $formula) {
+		$grid = new SpreadsheetGrid(1, 1);
+		$grid->cells[0][0]->originalValue = CellValue::fromCellString($formula);
+		$expressionSet = new CellExpressionSet($grid);
+		$expressionSet->calculateCells();
+		$actual = $grid->cells[0][0]->outputValue;
+		$exp = ($expected instanceof CellValue) ? $expected : CellValue::fromValue($expected);
+		$this->assertSameCellValue($exp, $actual);
+	}
+
+	public function test_func_abs() {
+		$this->test_simple_formula(3, '=ABS(-3)');
+		$this->test_simple_formula(4, '=ABS(4)');
+	}
+
+	public function test_func_and() {
+		$this->test_simple_formula(false, '=AND(FALSE, FALSE)');
+		$this->test_simple_formula(false, '=AND(FALSE, TRUE)');
+		$this->test_simple_formula(false, '=AND(TRUE, FALSE)');
+		$this->test_simple_formula(true, '=AND(TRUE, TRUE)');
+		$this->test_simple_formula(true, '=AND(TRUE, TRUE, TRUE, TRUE)');
+		$this->test_simple_formula(false, '=AND(TRUE, TRUE, TRUE, FALSE)');
+	}
+
+	public function test_func_average() {
+		$this->test_simple_formula(4, '=AVERAGE(4, 6, 2, 4)');
+		$this->test_simple_formula(4, '=AVERAGE(4, 6, 2, "foo", 4)');
+	}
+
+	public function test_func_ceiling() {
+		$this->test_simple_formula(4.0, '=CEILING(3.1)');
+		$this->test_simple_formula(3.0, '=CEILING(3)');
+		$this->test_simple_formula(-3.0, '=CEILING(-3.1)');
+	}
+
+	public function test_func_exp() {
+		$this->test_simple_formula(2.718281828459045, '=EXP(1)');
+	}
+
+	public function test_func_floor() {
+		$this->test_simple_formula(3.0, '=FLOOR(3.1)');
+		$this->test_simple_formula(3.0, '=FLOOR(3)');
+		$this->test_simple_formula(-4.0, '=FLOOR(-3.1)');
+	}
+
+	public function test_func_if() {
+		$this->test_simple_formula(6, '=IF(FALSE, 4, 6)');
+		$this->test_simple_formula(4, '=IF(TRUE, 4, 6)');
+	}
+
+	public function test_func_ifs() {
+		$this->test_simple_formula(1, '=IFS(TRUE, 1, FALSE, 2, FALSE, 3, FALSE, 4, 5)');
+		$this->test_simple_formula(2, '=IFS(FALSE, 1, TRUE, 2, FALSE, 3, FALSE, 4, 5)');
+		$this->test_simple_formula(3, '=IFS(FALSE, 1, FALSE, 2, TRUE, 3, FALSE, 4, 5)');
+		$this->test_simple_formula(4, '=IFS(FALSE, 1, FALSE, 2, FALSE, 3, TRUE, 4, 5)');
+		$this->test_simple_formula(5, '=IFS(FALSE, 1, FALSE, 2, FALSE, 3, FALSE, 4, 5)');
+	}
+
+	public function test_func_ln() {
+		$this->test_simple_formula(1.0, '=LN(2.718281828459045)');
+	}
+
+	public function test_func_log() {
+		$this->test_simple_formula(3.0, '=LOG(1000, 10)');
+		$this->test_simple_formula(6.0, '=LOG(64, 2)');
+	}
+
+	public function test_func_lower() {
+		$this->test_simple_formula('mixed', '=LOWER("MiXeD")');
+	}
+
+	public function test_func_max() {
+		$this->test_simple_formula(8, '=MAX(4, 8, 5, 2)');
+	}
+
+	public function test_func_min() {
+		$this->test_simple_formula(2, '=MIN(4, 8, 5, 2)');
+	}
+
+	public function test_func_mod() {
+		$this->test_simple_formula(1, '=MOD(37, 4)');
+	}
+
+	public function test_func_not() {
+		$this->test_simple_formula(false, '=NOT(TRUE)');
+		$this->test_simple_formula(true, '=NOT(FALSE)');
+	}
+
+	public function test_func_or() {
+		$this->test_simple_formula(false, '=OR(FALSE, FALSE)');
+		$this->test_simple_formula(true, '=OR(FALSE, TRUE)');
+		$this->test_simple_formula(true, '=OR(TRUE, FALSE)');
+		$this->test_simple_formula(true, '=OR(TRUE, TRUE)');
+		$this->test_simple_formula(true, '=OR(FALSE, FALSE, FALSE, TRUE)');
+	}
+
+	public function test_func_power() {
+		$this->test_simple_formula(8, '=POWER(2, 3)');
+	}
+
+	public function test_func_round() {
+		$this->test_simple_formula(3.0, '=ROUND(3.1)');
+		$this->test_simple_formula(4.0, '=ROUND(3.5)');
+		$this->test_simple_formula(4.0, '=ROUND(4)');
+		$this->test_simple_formula(-3.0, '=ROUND(-3.1)');
+		$this->test_simple_formula(-3.0, '=ROUND(-3.5)');
+		$this->test_simple_formula(-4.0, '=ROUND(-3.9)');
+		$this->test_simple_formula(3.1, '=ROUND(3.1415926535, 1)');
+		$this->test_simple_formula(3.14, '=ROUND(3.1415926535, 2)');
+		$this->test_simple_formula(30.0, '=ROUND(31.415926535, -1)');
+	}
+
+	public function test_func_sqrt() {
+		$this->test_simple_formula(4.0, '=SQRT(16)');
+	}
+
+	public function test_func_substitute() {
+		$this->test_simple_formula('cot sot on the mot', '=SUBSTITUTE("cat sat on the mat", "at", "ot")');
+		$this->test_simple_formula('cot sot on the mot', '=SUBSTITUTE("cAt saT on the mat", "at", "ot")');
+		$this->test_simple_formula('cot sot on the mot', '=SUBSTITUTE("c.*t s.*t on the m.*t", ".*t", "ot")');
+	}
+
+	public function test_func_sum() {
+		$this->test_simple_formula(15, '=SUM(1, 2, 3, 4, 5)');
+	}
+
+	public function test_func_upper() {
+		$this->test_simple_formula('MIXED', '=UPPER("mIxEd")');
+	}
+
+	public function test_func_xor() {
+		$this->test_simple_formula(false, '=XOR(FALSE, FALSE)');
+		$this->test_simple_formula(true, '=XOR(FALSE, TRUE)');
+		$this->test_simple_formula(true, '=XOR(TRUE, FALSE)');
+		$this->test_simple_formula(false, '=XOR(TRUE, TRUE)');
+		$this->test_simple_formula(true, '=XOR(FALSE, FALSE, TRUE)');
+		$this->test_simple_formula(false, '=XOR(TRUE, FALSE, TRUE)');
+	}
+
+	public function test_format() {
+		$this->test_simple_formula(new CellValue('2.718', 2.718281828459045, 'number', 3), '=2.718281828459045 ; number 3');
+		$this->test_simple_formula(new CellValue('271.83%', 2.718281828459045, 'percent', 2), '=2.718281828459045 ; percent 2');
+		$this->test_simple_formula(new CellValue('$2.72', 2.718281828459045, 'currency', 2), '=2.718281828459045 ; currency 2');
+	}
+}
+?>

phptest/spreadsheet/SpreadsheetMarkdownIntegrationTests.php

+<?php
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+
+require_once __DIR__ . '/../../php/markdown.php';
+require_once __DIR__ . '/../../php/spreadsheet.php';
+
+final class SpreadsheetMarkdownIntegrationTests extends TestCase {
+	private ?Markdown $parser;
+
+	protected function setUp(): void {
+		$this->parser = new Markdown(array_merge(Markdown::allReaders(), [ new MDSpreadsheetReader() ]));
+	}
+
+	private function md(string $markdown): string {
+		return $this->normalizeWhitespace($this->parser->toHTML($markdown));
+	}
+
+	private function normalizeWhitespace(string $str): string {
+		$str = mb_eregi_replace('\\s+', ' ', $str);
+		$str = mb_eregi_replace('>\\s+<', '><', $str);
+		return trim($str);
+	}
+
+	public function test_integration() {
+		$markdown = "| A | B | C |\n| --- | --- | --- |\n| 3 | 4 | =A*B |";
+		$expected = '<table><thead>' .
+			'<tr><th>A</th><th>B</th><th>C</th></tr>' .
+			'</thead><tbody><tr>' .
+			'<td class="spreadsheet-type-number" data-numeric-value="3" data-string-value="3">3</td>' .
+			'<td class="spreadsheet-type-number" data-numeric-value="4" data-string-value="4">4</td>' .
+			'<td class="calculated spreadsheet-type-number" data-numeric-value="12" data-string-value="12">12</td>' .
+			'</tr></tbody></table>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_bailOut() {
+		// If no formulas found table isn't modified
+		$markdown = "| A | B | C |\n| --- | --- | --- |\n| 3 | 4 | A*B |";
+		$expected = '<table><thead>' .
+			'<tr><th>A</th><th>B</th><th>C</th></tr>' .
+			'</thead><tbody><tr>' .
+			'<td>3</td>' .
+			'<td>4</td>' .
+			'<td>A*B</td>' .
+			'</tr></tbody></table>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_observedError1() {
+		// Saw "Uncaught Error: columnIndex must be number, got string" from this
+		$markdown = "| Unit Price | Qty | Subtotal |\n| ---: | ---: | ---: |\n| $1.23 | 2 | =A*B FILL |\n| $4.99 | 6 | |\n| Total | | =SUM(C:C) |";
+		$expected = '<table><thead><tr>' .
+			'<th style="text-align: right;">Unit Price</th>' .
+			'<th style="text-align: right;">Qty</th>' .
+			'<th>Subtotal</th>' .
+			'</tr></thead><tbody><tr>' .
+			'<td class="spreadsheet-type-currency" style="text-align: right;" data-numeric-value="1.23" data-string-value="1.23">$1.23</td>' .
+			'<td class="spreadsheet-type-number" style="text-align: right;" data-numeric-value="2" data-string-value="2">2</td>' .
+			'<td class="calculated spreadsheet-type-currency" data-numeric-value="2.46" data-string-value="2.46">$2.46</td>' .
+			'</tr><tr>' .
+			'<td class="spreadsheet-type-currency" style="text-align: right;" data-numeric-value="4.99" data-string-value="4.99">$4.99</td>' .
+			'<td class="spreadsheet-type-number" style="text-align: right;" data-numeric-value="6" data-string-value="6">6</td>' .
+			'<td class="calculated spreadsheet-type-currency" data-numeric-value="29.94" data-string-value="29.94">$29.94</td>' .
+			'</tr><tr>' .
+			'<td class="spreadsheet-type-string" style="text-align: right;" data-string-value="Total">Total</td>' .
+			'<td class="spreadsheet-type-blank" style="text-align: right;" data-numeric-value="0" data-string-value=""></td>' .
+			'<td class="calculated spreadsheet-type-currency" data-numeric-value="32.4" data-string-value="32.4">$32.40</td>' .
+			'</tr></tbody></table>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+}
+?>

runphptests.sh

 	phptest/TokenTests.php \
 	phptest/InlineTests.php \
 	phptest/BlockTests.php \
+	phptest/spreadsheet/CellAddressRangeTests.php \
+	phptest/spreadsheet/CellValueTests.php \
+	phptest/spreadsheet/ExpressionSetTests.php \
+	phptest/spreadsheet/SpreadsheetMarkdownIntegrationTests.php