Unit tests and fixes for all spreadsheet functions

js/spreadsheet.js

 
 class CellExpressionOperation {
 	/** Arg is int or float */
-	static Number = new this('Number');
+	static Number = new CellExpressionOperation('Number');
 	/** Arg is string without quotes */
-	static String = new this('String');
+	static String = new CellExpressionOperation('String');
 	/** Arg is bool */
-	static Boolean = new this('Boolean');
+	static Boolean = new CellExpressionOperation('Boolean');
 	/** Arg is reference address (e.g. "A5") */
-	static Reference = new this('Reference');
+	static Reference = new CellExpressionOperation('Reference');
 	/** Args are start and end addresses (e.g. "A5", "C7") */
-	static Range = new this('Range');
+	static Range = new CellExpressionOperation('Range');
 
 	/** Args are two operand CellExpressions. */
-	static Add = new this('Add');
+	static Add = new CellExpressionOperation('Add');
 	/** Args are two operand CellExpressions */
-	static Subtract = new this('Subtract');
+	static Subtract = new CellExpressionOperation('Subtract');
 	/** Args are two operand CellExpressions */
-	static Multiply = new this('Multiply');
+	static Multiply = new CellExpressionOperation('Multiply');
 	/** Args are two operand CellExpressions */
-	static Divide = new this('Divide');
+	static Divide = new CellExpressionOperation('Divide');
 
 	/** Args are two operand CellExpressions. */
-	static Concatenate = new this('Concatenate');
+	static Concatenate = new CellExpressionOperation('Concatenate');
 
 	/** Arg is operand expression */
-	static UnaryMinus = new this('UnaryMinus');
+	static UnaryMinus = new CellExpressionOperation('UnaryMinus');
 
 	/** Args are two operand CellExpressions. */
-	static GreaterThan = new this('GreaterThan');
+	static GreaterThan = new CellExpressionOperation('GreaterThan');
 	/** Args are two operand CellExpressions. */
-	static GreaterThanEqual = new this('GreaterThanEqual');
+	static GreaterThanEqual = new CellExpressionOperation('GreaterThanEqual');
 	/** Args are two operand CellExpressions. */
-	static LessThan = new this('LessThan');
+	static LessThan = new CellExpressionOperation('LessThan');
 	/** Args are two operand CellExpressions. */
-	static LessThanEqual = new this('LessThanEqual');
+	static LessThanEqual = new CellExpressionOperation('LessThanEqual');
 	/** Args are two operand CellExpressions. */
-	static Equal = new this('Equal');
+	static Equal = new CellExpressionOperation('Equal');
 	/** Args are two operand CellExpressions. */
-	static Unequal = new this('Unequal');
+	static Unequal = new CellExpressionOperation('Unequal');
 
 	/** Arg is operand expression. */
-	static UnaryNot = new this('UnaryNot');
+	static UnaryNot = new CellExpressionOperation('UnaryNot');
 
 	/** Args are 0+ CellExpressions */
-	static Function = new this('Function');
+	static Function = new CellExpressionOperation('Function');
 
+	/** @type {string} */
 	name;
 
 	constructor(name) {
 	}
 
 	toString() {
-		return this.name;
+		return `${this.constructor.name}.${this.name}`;
 	}
 
 	equals(other) {
 				cell.isCalculated = true;
 				if (result instanceof CellValue) {
 					cell.outputValue = result;
-				} else if (Array.isArray(result) && result.length == 1) {
-					cell.outputValue = result[0];
+					requeueCount = 0;
+				} else if (Array.isArray(result)) {
+					if (result.length == 1) {
+						cell.outputValue = result[0];
+						requeueCount = 0;
+					} else {
+						throw new CellEvaluationException(`Expression resolved to ${result.length} values, single value expected`);
+					}
 				} else {
-					throw new CellEvaluationException("Expression did not resolve to a single value");
+					throw new CellEvaluationException(`Expression resolved to ${result && result.constructor ? result.constructor.name : typeof result}, expected CellValue`);
 				}
 			} catch (e) {
 				if (e instanceof CellDependencyException) {
 					throw new CellEvaluationException(`No cell at ${refAddress.name}`, '#REF');
 				}
 				if (cell.outputValue === null) {
-					throw new CellDependencyException(`Need calculated value for ${refAddress.name} to evaluate`);
+					throw new CellDependencyException(`Need calculated value for ${refAddress} to evaluate`);
 				}
 				return cell.outputValue;
 			}
 			case CellExpressionOperation.Function:
 				return this.#callFunction(expr.qualifier, expr.arguments, address);
 		}
-		console.warn(`Unhandled operation ${expr.op.name}`);
+		throw new CellSyntaxException(`Unhandled operation ${expr.op.name}`);
 	}
 
 	/**
 			throw new CellEvaluationException("IFS expects an odd number of arguments");
 		}
 		const evaled = args.map((arg) => this.#evaluate(arg, address));
-		for (var i = 0; i < evaled.length; i += 2) {
+		for (var i = 0; i < evaled.length - 1; i += 2) {
 			const test = evaled[i].booleanValue();
 			if (test === null) {
 				throw new CellEvaluationException(`IFS expects a boolean for argument ${i + 1}`);
 	 * @returns {CellValue}
 	 */
 	#funcMax(args, address) {
-		const maxValue = null;
+		var maxValue = null;
 		const flattened = this.#flattenedNumericArguments('MAX', args, address);
 		if (flattened.length == 0) {
 			throw new CellEvaluationException("MAX requires at least one numeric argument");
 	#funcRound(args, address) {
 		const evaled = this.#assertNumericArguments('ROUND', 1, 2, args, address);
 		const val = evaled[0];
-		const places = sizeof(evaled) > 1 ? evaled[1].value : 0;
+		const places = evaled.length > 1 ? evaled[1].value : 0;
 		const divider = Math.pow(10.0, places);
 		const newValue = Math.round(val.value * divider) / divider;
 		return CellValue.fromValue(newValue, val.type);
 		if (text === null || search === null || replace === null) {
 			throw new CellEvaluationException("SUBSTITUTE expects 3 string arguments");
 		}
-		const result = text.replace(new RegExp(RegExp.escape(search), 'gi'), replace);
+		const result = text.replaceAll(search, replace);
 		return CellValue.fromValue(result);
 	}
 
 			}
 			result = (result === null) ? b : (result ^ b);
 		}
-		return CellValue.fromValue(result);
+		return CellValue.fromValue(result != 0);
 	}
 }
 
 		}
 	}
 
+	#clone() {
+		const cp = new CellExpression();
+		cp.op = this.op;
+		cp.arguments = this.arguments.slice();
+		cp.qualifier = this.qualifier;
+		cp.outputType = this.outputType;
+		cp.outputDecimals = this.outputDecimals;
+		cp.fillRanges = this.fillRanges !== null ? this.fillRanges.slice() : null;
+		cp.location = this.location;
+		return cp;
+	}
+
 	/**
 	 * @param {CellAddress} start
 	 * @param {CellAddress} end
 	 * @returns {CellExpression|null}
 	 */
 	transpose(start, end) {
-		var transposed = structuredClone(this);
+		var transposed = this.#clone(); // structuredClone makes a mess of typing
 		transposed.arguments = [];
 		for (const argument of this.arguments) {
 			if (argument instanceof CellExpression) {
 	 */
 	static expressionToTokens(text) {
 		var tokens = [];
-		var pos = 0;
+		var pos = [0];
 		this.#skipWhitespace(text, pos);
-		if (text.substring(pos, pos + 1) == '=') {
+		if (text.substring(pos[0], pos[0] + 1) == '=') {
 			// Ignore equals
-			pos++;
+			pos[0]++;
 		}
 		this.#skipWhitespace(text, pos);
 		var l = text.length;
-		while (pos < l) {
+		while (pos[0] < l) {
 			tokens.push(this.#readNextToken(text, pos));
 			this.#skipWhitespace(text, pos);
 		}
 	 * @returns {string|null}
 	 */
 	static #readChars(text, pos, charTest, minimumLength = null, maximumLength = null) {
-		var p = [ pos[0] ];
+		var p = pos[0];
 		const l = text.length;
 		var s = '';
 		var sl = 0;
-		while (p[0] < l && (maximumLength === null || sl < maximumLength)) {
-			ch = text.substring(p[0], p[0] + 1);
+		while (p < l && (maximumLength === null || sl < maximumLength)) {
+			const ch = text.substring(p, p + 1);
 			if (!charTest(ch)) break;
 			s += ch;
 			sl++;
-			p[0]++;
+			p++;
+		}
+		if (p < l && charTest(text.substring(p, p + 1))) {
+			return null;
 		}
 		if (minimumLength !== null && sl < minimumLength) {
 			return null;
 		}
-		pos[0] = p[0];
+		pos[0] = p;
 		return s;
 	}
 
 		if (start != end) return null;
 		if (!tokens[start].type.isPotentialAddress()) return null;
 		const ref = tokens[start].content.toUpperCase();
-		const refAddress = new CellAddress(ref, address);
+		const refAddress = CellAddress.fromString(ref, address, true);
 		return new CellExpression(CellExpressionOperation.Reference, [ refAddress ]);
 	}
 
 				const op = tokens[i].type.name;
 				const priority = opPriorities[op] ?? false;
 				if (priority === false) continue;
-				console.error(`Found infix candidate at ${i} for ${op} priority ${priority}`);
+				//console.info(`Found infix candidate at ${i} for ${op} priority ${priority}`);
 				candidates.push({ priority: priority, i: i });
 			}
 		}
-		candidates.sort((a, b) => {
-			if (a.priority < b.priority) return 1;
-			if (a.priority > b.priority) return -1;
-			return 0;
-		});
+		candidates.sort((a, b) => a.priority - b.priority);
 		var bestCandidate = null;
+		var operand1, operand2;
 		for (const candidate of candidates) {
 			try {
 				i = candidate.i;
-				const operand1 = this.#tryExpression(tokens, start, i - 1, address);
+				operand1 = this.#tryExpression(tokens, start, i - 1, address);
 				if (operand1 === null) continue;
-				const operand2 = this.#tryExpression(tokens, i + 1, end, address);
+				operand2 = this.#tryExpression(tokens, i + 1, end, address);
 				if (operand2 === null) continue;
 				bestCandidate = candidate;
 				break;
 			}
 		}
 		if (bestCandidate === null) {
-			console.error("No best candidate found");
+			//console.info("No best candidate found");
 			return null;
 		}
 		i = bestCandidate.i;
-		console.error(`Best candidate at token ${i}, priority ${bestCandidate.priority}`);
+		//console.info(`Best candidate at token ${i}, priority ${bestCandidate.priority}`);
 		switch (tokens[bestCandidate.i].type) {
 			case CellExpressionTokenType.Plus:
 				return new CellExpression(CellExpressionOperation.Add, [ operand1, operand2 ]);
 	/**
 	 * @type {string}
 	 */
-	get name() { this.#name; }
+	get name() { return this.#name; }
 
 	#isColumnFixed = false;
 	/** 
 	 */
 	get columnIndex() { return this.#columnIndex; };
 
+	/**
+	 * Letter code for the column.
+	 * @type {string}
+	 */
+	get columnLetter() { return CellAddress.#columnIndexToLetters(this.#columnIndex); }
+
 	#isRowFixed = false;
 	/**
 	 * Whether the row should remain unchanged when transposed. This is
 	get rowIndex() { return this.#rowIndex; }
 
 	/**
+	 * One-based row number. This is the human-facing row number.
+	 */
+	get rowNumber() { return this.#rowIndex + 1; }
+
+	/**
 	 * Whether this address has both a definite column and row.
 	 * @type {boolean}
 	 */
 	 *   during transpositions. Denoted with a `$` in front of the row digits.
 	 */
 	constructor(columnIndex, rowIndex, isColumnFixed=false, isRowFixed=false) {
+		if (typeof columnIndex != 'number') {
+			throw new Error(`columnIndex must be number, got ${typeof columnIndex}`);
+		}
+		if (typeof rowIndex != 'number') {
+			throw new Error(`rowIndex must be number, got ${typeof rowIndex}`);
+		}
 		this.#columnIndex = columnIndex;
 		this.#rowIndex = rowIndex;
 		this.#isColumnFixed = isColumnFixed;
 		this.#isRowFixed = isRowFixed;
-		this.#name = (isColumnFixed && columnIndex >= 0 ? '$' : '') +
-			CellAddress.#columnIndexToLetters(columnIndex) +
-			(isRowFixed && rowIndex >= 0 ? '$' : '') +
-			(rowIndex >= 0) ? `${rowIndex + 1}` : '';
+		this.#name = CellAddress.#formatAddress(columnIndex, rowIndex, isColumnFixed, isRowFixed);
 	}
 
 	/**
 	 * @returns {boolean}
 	 */
 	static isAddress(text) {
-		return this.fromAddress(text) != null;
+		return this.fromString(text) != null;
 	}
 
 	/**
 		if (!relativeFrom.isResolved || !relativeTo.isResolved) {
 			throw new CellEvaluationException("Can only transpose to and from resolved addresses");
 		}
-		newColumnIndex = this.columnIndex;
+		var newColumnIndex = this.columnIndex;
 		if (!this.isColumnFixed) {
-			columnDelta = relativeTo.columnIndex - relativeFrom.columnIndex;
+			const columnDelta = relativeTo.columnIndex - relativeFrom.columnIndex;
 			newColumnIndex += columnDelta;
 		}
-		newRowIndex = this.rowIndex;
+		var newRowIndex = this.rowIndex;
 		if (!this.isResolved && resolveToRow) {
 			newRowIndex = relativeFrom.rowIndex;
 		}
 		if (newRowIndex != -1 && !this.isRowAbsolute) {
-			rowDelta = relativeTo.rowIndex - relativeFrom.rowIndex;
+			const rowDelta = relativeTo.rowIndex - relativeFrom.rowIndex;
 			newRowIndex += rowDelta;
 		}
 		if (newColumnIndex < 0 || newRowIndex < 0) return null;
 	 * Converts column letters (e.g. `A`, `C`, `AA`) to a 0-based column index.
 	 * Assumes a validated well-formed column letter or else behavior is undefined.
 	 *
-	 * @param {string} letter
+	 * @param {string} letters
 	 * @returns {number} column index
 	 */
-	static #lettersToColumnIndex(letter) {
+	static #lettersToColumnIndex(letters) {
 		const ACodepoint = 'A'.codePointAt(0);
 		var columnIndex = 0;
 		for (var i = letters.length - 1; i >= 0; i--) {
 		return letters;
 	}
 
+	static #formatAddress(columnIndex, rowIndex, isColumnFixed, isRowFixed) {
+		var addr = '';
+		if (isColumnFixed && columnIndex >= 0) addr += '$';
+		if (columnIndex >= 0) addr += this.#columnIndexToLetters(columnIndex);
+		if (isRowFixed && rowIndex >= 0) addr += '$';
+		if (rowIndex >= 0) addr += `${rowIndex + 1}`;
+		return addr;
+	}
+
 	/**
 	 * @param {string} address - cell address string
 	 * @param {CellAddress|null} relativeTo - address to resolve relative addresses against
 	 * @returns {object} iterable object
 	 */
 	cellsIn(table) {
-		const minCol = Math.max(1, this.minColumnIndex);
-		const maxCol = Math.min(this.maxColumnIndex, table.columnCount - 1);
-		const minRow = Math.max(1, this.minRowIndex);
-		const maxRow = Math.min(this.maxRowIndex, table.rowCount - 1);
+		const minCol = this.minColumnIndex < 0 ? 0 : this.minColumnIndex;
+		const maxCol = this.maxColumnIndex < 0 ? table.columnCount - 1 : Math.min(this.maxColumnIndex, table.columnCount - 1);
+		const minRow = this.minRowIndex < 0 ? 0 : this.minRowIndex;
+		const maxRow = this.maxRowIndex < 0 ? table.rowCount - 1 : Math.min(this.maxRowIndex, table.rowCount - 1);
 		const iterable = {};
 		iterable[Symbol.iterator] = function() {
 			var currentCol = minCol;
 		// -- Properties -----
 
 	/**
+	 * A blank value.
+	 * @type {CellValue}
+	 */
+	static BLANK = new CellValue('', null, CellValue.TYPE_BLANK);
+
+	/**
 	 * Type of value. One of the `TYPE_` constants.
 	 * @type {string}
 	 */
 		}
 		if (value instanceof Error) {
 			if (value instanceof CellException) {
-				return new CellValue(value.getErrorSymbol(), value.getMessage(), CellValue.TYPE_ERROR);
+				return new CellValue(value.errorSymbol, value.message, CellValue.TYPE_ERROR);
 			}
-			return new CellValue('#ERROR', value.getMessage(), CellValue.TYPE_ERROR);
+			return new CellValue('#ERROR', value.message, CellValue.TYPE_ERROR);
 		}
 		if (typeof value == 'boolean') {
 			const formatted = CellValue.formatType(value, CellValue.TYPE_BOOLEAN, 0);
 	 * @returns {string}
 	 */
 	static #formatNumber(value, decimals) {
-		return (value).toLocaleString(undefined, { minimumFractionDigits: decimals });
+		return (value).toLocaleString(undefined, { minimumFractionDigits: decimals, maximumFractionDigits: decimals });
 	}
 
 	/**
 	 * @returns {string}
 	 */
 	static #formatCurrency(dollars, decimals) {
-		var s = (dollars).toLocaleString(undefined, { minimumFractionDigits: decimals });
+		var s = (dollars).toLocaleString(undefined, { minimumFractionDigits: decimals, maximumFractionDigits: decimals });
 		if (s.startsWith('-')) {
 			return '-$' + s.substring(1);
 		}
 	 */
 	static #formatPercent(value, decimals) {
 		const dec = value * 100.0;
-		return (dec).toLocaleString(undefined, { minimumFractionDigits: decimals }) + '%';
+		return (dec).toLocaleString(undefined, { minimumFractionDigits: decimals, maximumFractionDigits: decimals }) + '%';
 	}
 
 	/**
 			return CellValue.#autodecimals(value.value);
 		}
 		if (typeof value == 'number') {
-			var s = `${Math.abs(value)}`;
+			var s = (value).toLocaleString(undefined, { maximumFractionDigits: maxDigits });
 			if (/\./.exec(s) === null) return 0;
-			if (s.endsWith('.0')) return 0;
-			const parts = s.split('.');
-			const whole = parts[0];
-			var fraction = parts[1];
-			if (fraction.endsWith('99')) {
-				// More than one 9 at the end points to floating point rounding. Lop em off.
-				fraction = fraction.replace(/[9]+$/, '');
-			}
+			var fraction = s.split('.')[1];
 			return Math.min(maxDigits, fraction.length);
 		}
 		return 0;
 	/**
 	 * @type {MDTableCellBlock|null}
 	 */
-	block;
+	block = null;
 
 	/**
-	 * @type {CellValue|null}
+	 * @type {CellValue}
 	 */
-	originalValue;
+	originalValue = CellValue.BLANK;
 
 	/**
 	 * @type {CellValue|null}
 	isCalculated = false;
 
 	/** @type {CellExpression|null} */
-	parsedExpression;
+	parsedExpression = null;
 
 	/**
 	 * @type {CellValue|null}

testjs.html

 				assertFalse(test, failMessage=null) {
 					if (test) this.fail(failMessage || `expected false, got ${test}`);
 				}
-				assertEqual(a, b, floatDifferenceRatio=0.0, failMessage=null) {
+				assertEqual(a, b, floatDifferenceRatio=0.000001, failMessage=null) {
 					if (MDUtils.equal(a, b, floatDifferenceRatio)) return;
 					const aVal = (typeof a == 'string') ? `"${a}"` : `${a}`;
 					const bVal = (typeof b == 'string') ? `"${b}"` : `${b}`;
 					// InlineTests,
 					// BlockTests,
 					CellValueTests,
+					CellAddressRangeTests,
+					ExpressionSetTests,
 				];
 				TestClassRunner.runAll(testClasses);
 			}
 					this.assertEqual(result, expected);
 				}
 
+				test_operation_unaryNot() {
+					this.assertEqual(CellValue.fromValue(true).not(), CellValue.fromValue(false));
+					this.assertEqual(CellValue.fromValue(false).not(), CellValue.fromValue(true));
+				}
+
 				test_operation_comparators() {
 					const a = CellValue.fromValue(3);
 					const b = CellValue.fromValue(4);
 					this.assertEqual(result, expected);
 				}
 			}
+
+			class CellAddressRangeTests extends BaseTest {
+				test_iterator() {
+					const grid = new SpreadsheetGrid(3, 4);
+					let range = new CellAddressRange(new CellAddress(0, 0), new CellAddress(2, 3));
+					var visited = [];
+					var sanity = 100;
+					for (const address of range.cellsIn(grid)) {
+						visited.push(address.name);
+						if (sanity-- < 0) break;
+					}
+					const result = visited.join(',');
+					const expected = 'A1,A2,A3,A4,B1,B2,B3,B4,C1,C2,C3,C4';
+					this.assertEqual(result, expected);
+				}
+
+				test_iterator_column() {
+					const grid = new SpreadsheetGrid(3, 4);
+					let range = new CellAddressRange(new CellAddress(1, -1), new CellAddress(2, -1));
+					var visited = [];
+					var sanity = 100;
+					for (const address of range.cellsIn(grid)) {
+						visited.push(address.name);
+						if (sanity-- < 0) break;
+					}
+					const result = visited.join(',');
+					const expected = 'B1,B2,B3,B4,C1,C2,C3,C4';
+					this.assertEqual(result, expected);
+				}
+
+				test_iterator_beyondBounds() {
+					const grid = new SpreadsheetGrid(3, 4);
+					let range = new CellAddressRange(new CellAddress(0, 1), new CellAddress(9, 9));
+					var visited = [];
+					var sanity = 100;
+					for (const address of range.cellsIn(grid)) {
+						visited.push(address.name);
+						if (sanity-- < 0) break;
+					}
+					const result = visited.join(',');
+					const expected = 'A2,A3,A4,B2,B3,B4,C2,C3,C4';
+					this.assertEqual(result, expected);
+				}
+
+				test_iterator_outOfBounds() {
+					const grid = new SpreadsheetGrid(3, 4);
+					let range = new CellAddressRange(new CellAddress(5, 0), new CellAddress(5, 9));
+					var visited = [];
+					var sanity = 100;
+					for (const address of range.cellsIn(grid)) {
+						visited.push(address.name);
+						if (sanity-- < 0) break;
+					}
+					const result = visited.join(',');
+					const expected = '';
+					this.assertEqual(result, expected);
+				}
+			}
+
+			class ExpressionSetTests extends BaseTest {
+				test_simpleMath() {
+					const grid = new SpreadsheetGrid(1, 1);
+					grid.cells[0][0].originalValue = CellValue.fromCellString('=7*3');
+					const expressionSet = new CellExpressionSet(grid);
+					expressionSet.calculateCells();
+					const expected = CellValue.fromValue(21);
+					this.assertEqual(grid.cells[0][0].outputValue, expected);
+				}
+
+				test_reference() {
+					const 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');
+					const expressionSet = new CellExpressionSet(grid);
+					expressionSet.calculateCells();
+					const expected = CellValue.fromValue(369);
+					this.assertEqual(grid.cells[2][0].outputValue, expected);
+				}
+
+				test_infixPriority() {
+					const grid = new SpreadsheetGrid(1, 1);
+					grid.cells[0][0].originalValue = CellValue.fromCellString('=4*9/3+7-4');
+					const expressionSet = new CellExpressionSet(grid);
+					expressionSet.calculateCells();
+					const expected = CellValue.fromValue(15);
+					this.assertEqual(grid.cells[0][0].outputValue, expected);
+				}
+
+				test_filledFormula() {
+					const 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);
+					const expressionSet = new CellExpressionSet(grid);
+					expressionSet.calculateCells();
+					this.assertEqual(grid.cells[2][0].outputValue, CellValue.fromValue(20));
+					this.assertEqual(grid.cells[2][1].outputValue, CellValue.fromValue(42));
+					this.assertEqual(grid.cells[2][2].outputValue, CellValue.fromValue(72));
+				}
+
+				test_dependencies() {
+					const 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');
+					const expressionSet = new CellExpressionSet(grid);
+					expressionSet.calculateCells();
+					this.assertEqual(grid.cells[1][0].outputValue, CellValue.fromValue(10));
+					this.assertEqual(grid.cells[1][1].outputValue, CellValue.fromValue(9));
+					this.assertEqual(grid.cells[1][2].outputValue, CellValue.fromValue(7));
+					this.assertEqual(grid.cells[1][3].outputValue, CellValue.fromValue(4));
+				}
+
+				_test_simple_formula(formula, expected) {
+					const grid = new SpreadsheetGrid(1, 1);
+					grid.cells[0][0].originalValue = CellValue.fromCellString(formula);
+					const expressionSet = new CellExpressionSet(grid);
+					expressionSet.calculateCells();
+					const result = grid.cells[0][0].outputValue;
+					const exp = (expected instanceof CellValue) ? expected : CellValue.fromValue(expected);
+					this.assertEqual(result.type, exp.type);
+					this.assertEqual(result.decimals, exp.decimals);
+					this.assertEqual(result.formattedValue, exp.formattedValue);
+					this.assertEqual(result.value, exp.value);
+				}
+
+				test_func_abs() {
+					this._test_simple_formula('=ABS(-3)', 3);
+					this._test_simple_formula('=ABS(4)', 4);
+				}
+
+				test_func_and() {
+					this._test_simple_formula('=AND(FALSE, FALSE)', false);
+					this._test_simple_formula('=AND(FALSE, TRUE)', false);
+					this._test_simple_formula('=AND(TRUE, FALSE)', false);
+					this._test_simple_formula('=AND(TRUE, TRUE)', true);
+				}
+
+				test_func_average() {
+					this._test_simple_formula('=AVERAGE(4, 6, 2, 4)', 4);
+				}
+
+				test_func_ceiling() {
+					this._test_simple_formula('=CEILING(3.1)', 4);
+					this._test_simple_formula('=CEILING(3)', 3);
+					this._test_simple_formula('=CEILING(-3.1)', -3);
+				}
+
+				test_func_exp() {
+					this._test_simple_formula('=EXP(1)', 2.718281828459045);
+				}
+
+				test_func_floor() {
+					this._test_simple_formula('=FLOOR(3.1)', 3);
+					this._test_simple_formula('=FLOOR(3)', 3);
+					this._test_simple_formula('=FLOOR(-3.1)', -4);
+				}
+
+				test_func_if() {
+					this._test_simple_formula('=IF(FALSE, 4, 6)', 6);
+					this._test_simple_formula('=IF(TRUE, 4, 6)', 4);
+				}
+
+				test_func_ifs() {
+					this._test_simple_formula('=IFS(TRUE, 1, FALSE, 2, FALSE, 3, FALSE, 4, 5)', 1);
+					this._test_simple_formula('=IFS(FALSE, 1, TRUE, 2, FALSE, 3, FALSE, 4, 5)', 2);
+					this._test_simple_formula('=IFS(FALSE, 1, FALSE, 2, TRUE, 3, FALSE, 4, 5)', 3);
+					this._test_simple_formula('=IFS(FALSE, 1, FALSE, 2, FALSE, 3, TRUE, 4, 5)', 4);
+					this._test_simple_formula('=IFS(FALSE, 1, FALSE, 2, FALSE, 3, FALSE, 4, 5)', 5);
+				}
+
+				test_func_ln() {
+					this._test_simple_formula('=LN(2.718281828459045)', 1);
+				}
+
+				test_func_log() {
+					this._test_simple_formula('=LOG(1000, 10)', 3);
+				}
+
+				test_func_lower() {
+					this._test_simple_formula('=LOWER("MiXeD")', 'mixed');
+				}
+
+				test_func_max() {
+					this._test_simple_formula('=MAX(4, 8, 5, 2)', 8);
+				}
+
+				test_func_min() {
+					this._test_simple_formula('=MIN(4, 8, 5, 2)', 2);
+				}
+
+				test_func_mod() {
+					this._test_simple_formula('=MOD(37, 4)', 1);
+				}
+
+				test_func_not() {
+					this._test_simple_formula('=NOT(TRUE)', false);
+					this._test_simple_formula('=NOT(FALSE)', true);
+				}
+
+				test_func_or() {
+					this._test_simple_formula('=OR(FALSE, FALSE)', false);
+					this._test_simple_formula('=OR(FALSE, TRUE)', true);
+					this._test_simple_formula('=OR(TRUE, FALSE)', true);
+					this._test_simple_formula('=OR(TRUE, TRUE)', true);
+					this._test_simple_formula('=OR(FALSE, FALSE, FALSE, TRUE)', true);
+				}
+
+				test_func_power() {
+					this._test_simple_formula('=POWER(2, 3)', 8);
+				}
+
+				test_func_round() {
+					this._test_simple_formula('=ROUND(3.1)', 3);
+					this._test_simple_formula('=ROUND(3.5)', 4);
+					this._test_simple_formula('=ROUND(4)', 4);
+					this._test_simple_formula('=ROUND(-3.1)', -3);
+					this._test_simple_formula('=ROUND(-3.5)', -3);
+					this._test_simple_formula('=ROUND(-3.9)', -4);
+				}
+
+				test_func_sqrt() {
+					this._test_simple_formula('=SQRT(16)', 4);
+				}
+
+				test_func_substitute() {
+					this._test_simple_formula('=SUBSTITUTE("cat sat on the mat", "at", "ot")', 'cot sot on the mot');
+				}
+
+				test_func_sum() {
+					this._test_simple_formula('=SUM(1, 2, 3, 4, 5)', 15);
+				}
+
+				test_func_upper() {
+					this._test_simple_formula('=UPPER("mIxEd")', 'MIXED');
+				}
+
+				test_func_xor() {
+					this._test_simple_formula('=XOR(FALSE, FALSE)', false);
+					this._test_simple_formula('=XOR(FALSE, TRUE)', true);
+					this._test_simple_formula('=XOR(TRUE, FALSE)', true);
+					this._test_simple_formula('=XOR(TRUE, TRUE)', false);
+					this._test_simple_formula('=XOR(FALSE, FALSE, TRUE)', true);
+					this._test_simple_formula('=XOR(TRUE, FALSE, TRUE)', false);
+				}
+
+				test_format() {
+					this._test_simple_formula('=2.718281828459045 ; number 3', new CellValue('2.718', 2.718281828459045, 'number', 3));
+					this._test_simple_formula('=2.718281828459045 ; percent 2', new CellValue('271.83%', 2.718281828459045, 'percent', 2));
+					this._test_simple_formula('=2.718281828459045 ; currency 2', new CellValue('$2.72', 2.718281828459045, 'currency', 2));
+				}
+			}
 		</script>
 	</head>
 	<body>