Repository Public
1import Foundation2import Testing3import SheetCore4@testable import Audit56@Suite struct DependencyTracerTests {7 /// A1=10, A2=20, A3=A1+A2, B1=A3*2, C1=SUM(A1:A3), D1=B1+C18 func model() -> ACBook {9 let b = ACBook()10 b.set("A1", "10"); b.set("A2", "20"); b.set("A3", "=A1+A2")11 b.set("B1", "=A3*2"); b.set("C1", "=SUM(A1:A3)"); b.set("D1", "=B1+C1")12 b.engine.recalculate()13 return b14 }1516 func edgeSet(_ g: DependencyGraph) -> Set<String> { Set(g.edges.map { $0.from + ">" + $0.to }) }1718 @Test func precedentsGraph() {19 let b = model()20 let g = DependencyTracer(engine: b.engine).precedents(sheet: 0, cell: b.ref("D1"), depth: 4)21 #expect(g.root == "Sheet1!D1" && g.direction == .precedents)22 #expect(Set(g.nodes.map(\.id)) == ["Sheet1!D1", "Sheet1!B1", "Sheet1!C1", "Sheet1!A3", "Sheet1!A1:A3", "Sheet1!A1", "Sheet1!A2"])23 #expect(edgeSet(g) == ["Sheet1!B1>Sheet1!D1", "Sheet1!C1>Sheet1!D1", "Sheet1!A3>Sheet1!B1", "Sheet1!A1:A3>Sheet1!C1",24 "Sheet1!A3>Sheet1!A1:A3", "Sheet1!A1>Sheet1!A3", "Sheet1!A2>Sheet1!A3"])25 #expect(!g.hasCycle && !g.isTruncated)26 let d1 = g.node("Sheet1!D1")!27 #expect(d1.formula == "=B1+C1" && d1.valuePreview == "120" && d1.depth == 0 && !d1.isRange && !d1.isError)28 #expect(g.node("Sheet1!A1")!.formula == nil && g.node("Sheet1!A1")!.valuePreview == "10")29 let range = g.node("Sheet1!A1:A3")!30 #expect(range.isRange && range.range == RangeRef(a1: "A1:A3")! && range.valuePreview == "3×1, 3 filled" && range.depth == 2)31 #expect(g.node("Sheet1!B1")!.depth == 1 && g.node("Sheet1!A3")!.depth == 2)32 #expect(Set(g.predecessors(of: "Sheet1!D1")) == ["Sheet1!B1", "Sheet1!C1"])33 #expect(g.successors(of: "Sheet1!A3").sorted() == ["Sheet1!A1:A3", "Sheet1!B1"])34 // layout: every edge goes from a lower layer to a higher one; no two nodes share a slot35 for e in g.edges { #expect(g.layout.positions[e.from]!.layer < g.layout.positions[e.to]!.layer, "\(e)") }36 let slots = g.layout.positions.values.map { "\($0.layer)/\($0.order)" }37 #expect(Set(slots).count == g.nodes.count)38 let coords = g.layout.positions.values.map { "\($0.x)/\($0.y)" }39 #expect(Set(coords).count == g.nodes.count)40 #expect(g.layout.positions["Sheet1!D1"]!.layer == g.layout.layers.count - 1)41 #expect(g.layout.positions["Sheet1!A1"]!.layer == 0 && g.layout.positions["Sheet1!A2"]!.layer == 0)42 #expect(g.layout.layers.flatMap { $0 }.count == g.nodes.count)43 #expect(g.layout.backEdges.isEmpty)44 #expect(g.layout.width == Double(g.layout.layers.count - 1) * 180)45 }4647 @Test func depthLimitAndTruncation() {48 let b = model()49 let g = DependencyTracer(engine: b.engine).precedents(sheet: 0, cell: b.ref("D1"), depth: 1)50 #expect(Set(g.nodes.map(\.id)) == ["Sheet1!D1", "Sheet1!B1", "Sheet1!C1"])51 #expect(g.node("Sheet1!B1")!.isTruncated && g.node("Sheet1!C1")!.isTruncated && !g.node("Sheet1!D1")!.isTruncated)52 let zero = DependencyTracer(engine: b.engine).precedents(sheet: 0, cell: b.ref("D1"), depth: 0)53 #expect(zero.nodes.count == 1 && zero.edges.isEmpty && zero.nodes[0].isTruncated)54 var opt = DependencyTracer.Options()55 opt.expandRangesUpTo = 056 let closed = DependencyTracer(engine: b.engine, options: opt).precedents(sheet: 0, cell: b.ref("C1"), depth: 5)57 #expect(Set(closed.nodes.map(\.id)) == ["Sheet1!C1", "Sheet1!A1:A3"])58 opt.maxNodes = 359 let capped = DependencyTracer(engine: b.engine, options: opt).precedents(sheet: 0, cell: b.ref("D1"), depth: 5)60 #expect(capped.nodes.count == 3 && capped.isTruncated)61 let constant = DependencyTracer(engine: b.engine).precedents(sheet: 0, cell: b.ref("A1"))62 #expect(constant.nodes.count == 1 && !constant.nodes[0].isTruncated)63 let bad = DependencyTracer(engine: b.engine).precedents(sheet: 9, cell: b.ref("A1"))64 #expect(bad.nodes.isEmpty)65 }6667 @Test func dependentsGraph() {68 let b = model()69 let g = DependencyTracer(engine: b.engine).dependents(sheet: 0, cell: b.ref("A1"), depth: 2)70 #expect(Set(g.nodes.map(\.id)) == ["Sheet1!A1", "Sheet1!A3", "Sheet1!C1", "Sheet1!B1", "Sheet1!D1"])71 #expect(edgeSet(g) == ["Sheet1!A1>Sheet1!A3", "Sheet1!A1>Sheet1!C1", "Sheet1!A3>Sheet1!B1", "Sheet1!A3>Sheet1!C1", "Sheet1!C1>Sheet1!D1"])72 #expect(g.node("Sheet1!B1")!.isTruncated) // B1 feeds D1 one level further73 #expect(!g.node("Sheet1!D1")!.isTruncated)74 for e in g.edges { #expect(g.layout.positions[e.from]!.layer < g.layout.positions[e.to]!.layer) }75 #expect(g.layout.positions["Sheet1!A1"]!.layer == 0)76 let both = DependencyTracer(engine: b.engine).neighbourhood(sheet: 0, cell: b.ref("A3"), depth: 1)77 #expect(Set(both.nodes.map(\.id)) == ["Sheet1!A3", "Sheet1!A1", "Sheet1!A2", "Sheet1!B1", "Sheet1!C1"])78 #expect(both.layout.positions["Sheet1!A3"]!.layer == 1)79 }8081 @Test func cyclesAndCrossSheet() {82 let b = ACBook(sheets: ["Sheet1", "Other"])83 b.set("A1", "=B1+1"); b.set("B1", "=A1+1")84 b.set("A1", "5", sheet: 1); b.set("C1", "=Other!A1*2"); b.set("C2", "=1/0")85 b.engine.recalculate()86 let g = DependencyTracer(engine: b.engine).precedents(sheet: 0, cell: b.ref("A1"), depth: 10)87 #expect(Set(g.nodes.map(\.id)) == ["Sheet1!A1", "Sheet1!B1"])88 #expect(g.hasCycle && g.layout.backEdges.count == 1 && g.edges.count == 2)89 #expect(g.nodes.allSatisfy { $0.isError })90 let x = DependencyTracer(engine: b.engine).precedents(sheet: 0, cell: b.ref("C1"))91 #expect(Set(x.nodes.map(\.id)) == ["Sheet1!C1", "Other!A1"])92 #expect(x.node("Other!A1")!.sheet == "Other" && x.node("Other!A1")!.sheetIndex == 1)93 let e = DependencyTracer(engine: b.engine).precedents(sheet: 0, cell: b.ref("C2"))94 #expect(e.nodes[0].isError && e.nodes[0].valuePreview == "#DIV/0!")95 }9697 @Test func layeredLayout() {98 func edge(_ a: String, _ b: String) -> DependencyEdge { DependencyEdge(from: a, to: b) }99 // diamond with a long edge: longest-path layering puts d below both b and c100 let l = DependencyTracer.layout(nodes: ["a", "b", "c", "d"], edges: [edge("a", "b"), edge("a", "c"), edge("b", "d"), edge("c", "d"), edge("a", "d")])101 #expect(l.layers == [["a"], ["b", "c"], ["d"]])102 #expect(l.positions["d"]!.layer == 2 && l.positions["a"]!.x == 0 && l.positions["d"]!.x == 360)103 #expect(l.positions["a"]!.y == 28) // centred against the two-node layer (spacing 56)104 #expect(l.height == 56 && l.width == 360)105 // barycentric ordering removes the crossing106 let x = DependencyTracer.layout(nodes: ["a", "b", "x", "y"], edges: [edge("a", "y"), edge("b", "x")])107 #expect(x.layers == [["a", "b"], ["y", "x"]])108 // chain a→b→c with c→a closing a cycle109 let c = DependencyTracer.layout(nodes: ["a", "b", "c"], edges: [edge("a", "b"), edge("b", "c"), edge("c", "a")])110 #expect(c.backEdges == [edge("c", "a")] && c.layers == [["a"], ["b"], ["c"]])111 let selfLoop = DependencyTracer.layout(nodes: ["a"], edges: [edge("a", "a")])112 #expect(selfLoop.backEdges.count == 1 && selfLoop.layers == [["a"]])113 let empty = DependencyTracer.layout(nodes: [], edges: [])114 #expect(empty.layers.isEmpty && empty.width == 0 && empty.height == 0)115 // a wider random DAG: all forward edges go down the layers, slots are unique116 var edges = [DependencyEdge]()117 let names = (0..<40).map { "n\($0)" }118 for i in 0..<40 { for j in [i + 1, i + 3, i + 7] where j < 40 && (i * 7 + j) % 3 != 0 { edges.append(edge(names[i], names[j])) } }119 let big = DependencyTracer.layout(nodes: names, edges: edges)120 for e in edges { #expect(big.positions[e.from]!.layer < big.positions[e.to]!.layer) }121 #expect(Set(big.positions.values.map { "\($0.layer)/\($0.order)" }).count == 40)122 #expect(big.backEdges.isEmpty)123 }124}125126@Suite struct FormulaExplainerTests {127 /// A1=10, A2=0, B1=5, B2=7, B3=8128 func model() -> ACBook {129 let b = ACBook()130 b.set("A1", "10"); b.set("A2", "0"); b.set("B1", "5"); b.set("B2", "7"); b.set("B3", "8")131 return b132 }133134 @Test func stepsInnermostFirstWithEvaluatorValues() {135 let b = model()136 b.set("C1", "=IF(A1>0, SUM(B1:B3)/A1, 0)")137 #expect(b.get("C1") == .number(2))138 let ex = FormulaExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("C1"))!139 #expect(ex.formula == "=IF(A1>0,SUM(B1:B3)/A1,0)" && ex.sheet == "Sheet1" && ex.cell == "C1")140 #expect(ex.steps.map(\.expression) == ["A1", "A1>0", "B1:B3", "SUM(B1:B3)", "SUM(B1:B3)/A1", "IF(A1>0,SUM(B1:B3)/A1,0)"])141 #expect(ex.steps.map(\.value.display) == ["10", "TRUE", "{5;7;8}", "20", "2", "2"])142 #expect(ex.steps.map(\.kind) == [.reference, .operator, .range, .function, .operator, .function])143 #expect(ex.steps.map(\.index) == [1, 2, 3, 4, 5, 6])144 #expect(ex.steps.map(\.depth) == [2, 1, 3, 2, 1, 0])145 #expect(ex.steps[3].value.number == 20 && ex.steps[1].value.type == "boolean" && ex.steps[2].value.rows == 3 && ex.steps[2].value.cols == 1)146 #expect(ex.steps[5].note?.contains("TRUE") == true)147 #expect(ex.result.number == 2 && !ex.isTruncated)148 // referenced cells carry their own values149 #expect(ex.steps[0].references.map(\.address) == ["Sheet1!A1"] && ex.steps[0].references[0].value.number == 10)150 #expect(ex.steps[4].references.map(\.address) == ["Sheet1!B1:B3", "Sheet1!A1"])151 #expect(ex.steps[4].references[0].value.display == "{5;7;8}")152 // the convenience entry point returns the same steps153 #expect(FormulaExplainer(engine: b.engine).steps(for: b.ref("C1"), sheet: 0) == ex.steps)154 #expect(FormulaExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("A1")) == nil)155 #expect(FormulaExplainer(engine: b.engine).steps(for: b.ref("Z9"), sheet: 0).isEmpty)156 // every step value is what the engine returns for that sub-expression157 for s in ex.steps { #expect(ExplainedValue(b.engine.evaluate("=" + s.expression, sheet: 0, at: b.ref("C1"))) == s.value) }158 }159160 @Test func untakenBranchesAreNotExpanded() {161 let b = model()162 b.set("C2", "=IF(A2>0, B1/A2, B2*B3)")163 let ex = FormulaExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("C2"))!164 #expect(ex.steps.map(\.expression) == ["A2", "A2>0", "B2", "B3", "B2*B3", "IF(A2>0,B1/A2,B2*B3)"])165 #expect(ex.steps.last?.value.number == 56)166 #expect(ex.steps.last?.note?.contains("FALSE") == true)167 b.set("C3", "=IFERROR(B1/A2, -1)")168 let fb = FormulaExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("C3"))!169 #expect(fb.steps.map(\.expression) == ["B1", "A2", "B1/A2", "IFERROR(B1/A2,-1)"])170 #expect(fb.steps[2].value.display == "#DIV/0!" && fb.steps[2].value.isError)171 #expect(fb.steps[3].value.number == -1 && fb.steps[3].note?.contains("fallback is used") == true)172 b.set("C4", "=IFERROR(B1/A1, B2/A2)")173 let ok = FormulaExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("C4"))!174 #expect(ok.steps.map(\.expression) == ["B1", "A1", "B1/A1", "IFERROR(B1/A1,B2/A2)"])175 #expect(ok.steps[3].value.number == 0.5 && ok.steps[3].note?.contains("not evaluated") == true)176 b.set("C5", "=IF(A2>0, 1)")177 let noElse = FormulaExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("C5"))!178 #expect(noElse.steps.last?.value.display == "FALSE")179 }180181 @Test func letBindingsDuplicatesAndOperators() {182 let b = model()183 b.set("D1", "=LET(x, A1*2, y, x+B1, y*y)")184 #expect(b.get("D1") == .number(625))185 let ex = FormulaExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("D1"))!186 #expect(ex.steps.map(\.expression) == ["A1", "A1*2", "x", "B1", "x+B1", "y", "y*y", "LET(x,A1*2,y,x+B1,y*y)"])187 #expect(ex.steps.map(\.value.number) == [10, 20, 20, 5, 25, 25, 625, 625])188 #expect(ex.steps[2].kind == .name && ex.steps[2].note == "Name defined by LET.")189 b.set("D2", "=(A1+B1)*(A1+B1)-A1%")190 let dup = FormulaExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("D2"))!191 #expect(dup.steps.map(\.expression) == ["A1", "B1", "A1+B1", "(A1+B1)*(A1+B1)", "A1%", "(A1+B1)*(A1+B1)-A1%"])192 #expect(dup.steps.map(\.value.number) == [10, 5, 15, 225, 0.1, 224.9])193 b.set("D3", "=-B2&\"x\"")194 let cat = FormulaExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("D3"))!195 #expect(cat.steps.map(\.value.display) == ["7", "-7", "\"-7x\""])196 b.set("D4", "=LAMBDA(v, v*2)(B3)+SUM(A1:INDEX(B:B,3))")197 let lam = FormulaExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("D4"))!198 #expect(lam.steps.first { $0.expression == "LAMBDA(v,v*2)(B3)" }?.value.number == 16)199 #expect(lam.steps.last?.value.number == 46)200 #expect(!lam.steps.contains { $0.expression == "v*2" || $0.expression == "v" })201 var limited = FormulaExplainer(engine: b.engine)202 limited.maxSteps = 2203 let cut = limited.explain(sheet: 0, cell: b.ref("D2"))!204 #expect(cut.steps.count == 2 && cut.isTruncated)205 let adHoc = FormulaExplainer(engine: b.engine).explain(formula: "=MAX(B1:B3)-MIN(B1:B3)", sheet: 0, at: b.ref("H1"))!206 #expect(adHoc.steps.map(\.value.display) == ["{5;7;8}", "8", "5", "3"])207 #expect(FormulaExplainer(engine: b.engine).explain(formula: "=MAX(", sheet: 0, at: b.ref("H1")) == nil)208 }209210 @Test func plainLanguageDescription() {211 let b = model()212 b.set("C1", "=IF(A1>0, SUM(B1:B3)/A1, 0)")213 let ex = FormulaExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("C1"))!214 #expect(ex.description == "Returns if A1 is greater than 0 then the sum of B1:B3 divided by A1, otherwise 0. Functions used: IF — Returns one value when the condition is true and another when it is false. SUM — Adds its arguments.")215 #expect(ex.functions.map(\.name) == ["IF", "SUM"])216 #expect(ex.functions[1].signature == "SUM(number1, [number2], …)" && ex.functions.allSatisfy { $0.isKnown })217 func d(_ f: String) -> String { FormulaExplainer.describe(try! FormulaParser.parse(f)) }218 #expect(d("=A1*(1+B1)") == "Returns A1 multiplied by (1 plus B1).")219 #expect(d("=-A1^2&\"m\"") == "Returns the negative of A1 raised to the power 2 joined with \"m\".")220 #expect(d("=A1<=B1") == "Returns A1 is at most B1.")221 #expect(d("=IFERROR(A1/B1,0)") == "Returns A1 divided by B1, or 0 if that is an error. Functions used: IFERROR — Returns the value, or the fallback when the value is an error.")222 #expect(d("=MAX(A1,B1,C1)-MIN(A1:C1)") == "Returns the largest value in A1, B1 and C1 minus the smallest value in A1:C1. Functions used: MAX — Largest number. MIN — Smallest number.")223 #expect(d("=FOO(A1,2)") == "Returns FOO(A1, 2). Functions used: FOO — not a known function.")224 #expect(d("=50%") == "Returns 50 percent.")225 #expect(d("=Sheet2!A1+TaxRate") == "Returns Sheet2!A1 plus TaxRate.")226 }227}228229@Suite struct ErrorExplainerTests {230 @Test func divisionByZeroIsTracedToItsOrigin() {231 let b = ACBook()232 b.set("A2", "0"); b.set("B1", "5")233 b.set("C2", "=B1/A2"); b.set("D2", "=C2+1"); b.set("E2", "=D2*2")234 #expect(b.get("E2") == .error(.div0))235 let ex = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("E2"))!236 #expect(ex.error == .div0 && ex.cell == "Sheet1!E2")237 #expect(ex.chain == ["Sheet1!E2", "Sheet1!D2", "Sheet1!C2"] && ex.originCell == "Sheet1!C2")238 #expect(ex.causes.count == 1)239 #expect(ex.causes[0].expression == "B1/A2")240 #expect(ex.causes[0].detail == "The denominator A2 evaluates to 0. Sheet1!A2 contains 0.")241 #expect(ex.causes[0].cells == ["Sheet1!A2"])242 #expect(ex.summary.hasPrefix("#DIV/0!") && ex.suggestion.contains("denominator"))243 // an empty denominator, itself the result of a formula244 b.set("G1", "=B1/(F1-F2)")245 let blank = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("G1"))!246 #expect(blank.chain == ["Sheet1!G1"])247 #expect(blank.causes[0].detail == "The denominator (F1-F2) evaluates to 0. Sheet1!F1 is empty; Sheet1!F2 is empty.")248 #expect(blank.causes[0].cells == ["Sheet1!F1", "Sheet1!F2"])249 b.set("G2", "=B1/F9")250 let empty = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("G2"))!251 #expect(empty.causes[0].detail == "The denominator F9 is empty (treated as 0). Sheet1!F9 is empty.")252 b.set("H1", "=A2"); b.set("G3", "=10/H1")253 let viaFormula = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("G3"))!254 #expect(viaFormula.causes[0].detail == "The denominator H1 evaluates to 0. Sheet1!H1 contains 0 (result of =A2).")255 // no error → nothing to explain256 #expect(ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("B1")) == nil)257 #expect(ErrorExplainer(engine: b.engine).explain(sheet: 5, cell: b.ref("B1")) == nil)258 // inside a taken IF branch, and through a range259 b.set("J1", "=IF(B1>0, SUM(C2:E2), 0)")260 let viaRange = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("J1"))!261 #expect(viaRange.chain == ["Sheet1!J1", "Sheet1!C2"] && viaRange.causes[0].expression == "B1/A2")262 b.set("J2", "=AVERAGE(K1:K3)")263 let avg = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("J2"))!264 #expect(avg.causes[0].detail.hasPrefix("AVERAGE found no numbers"))265 b.set("J3", "=A2^-1")266 #expect(ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("J3"))!.causes[0].detail.hasPrefix("0 is raised to a negative power"))267 }268269 @Test func otherErrorKinds() {270 let b = ACBook()271 b.setText("A1", "abc"); b.set("A2", "4")272 b.set("B1", "=A1*2")273 let v = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("B1"))!274 #expect(v.error == .value)275 #expect(v.causes[0].detail == "A1 is the text \"abc\", which cannot be used as a number with \"*\". Sheet1!A1 contains \"abc\".")276 #expect(v.causes[0].cells == ["Sheet1!A1"])277 b.set("B2", "=-A1")278 #expect(ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("B2"))!.causes[0].detail.hasPrefix("A1 is the text \"abc\""))279 b.set("B3", "=FOO(A2)+1")280 let n = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("B3"))!281 #expect(n.error == .name && n.causes[0].expression == "FOO(A2)" && n.causes[0].detail == "FOO is not a known function.")282 b.set("B4", "=A2*Unknown")283 #expect(ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("B4"))!.causes[0].detail == "The name \"Unknown\" is not defined (and is not a table).")284 b.set("B5", "=#REF!+A2")285 let r = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("B5"))!286 #expect(r.error == .ref && r.causes[0].detail.hasPrefix("The formula contains the literal #REF!"))287 b.set("B6", "=Nope!A1+1")288 #expect(ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("B6"))!.causes[0].detail == "The sheet \"Nope\" does not exist.")289 b.set("B7", "=NA()"); b.set("B8", "=B7+1")290 let na = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("B8"))!291 #expect(na.chain == ["Sheet1!B8", "Sheet1!B7"] && na.causes[0].detail.hasPrefix("NA() deliberately"))292 b.engine.set(sheet: 0, row: 9, col: 1, .value(.error(.num))) // B10 holds a typed-in error293 b.set("B11", "=B10*2")294 let typed = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("B11"))!295 #expect(typed.originCell == "Sheet1!B10" && typed.causes[0].detail.contains("typed in directly"))296 b.set("B12", "=SUM(1,ABS(1,2))")297 let arity = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("B12"))!298 #expect(arity.causes[0].expression == "ABS(1,2)" && arity.causes[0].detail.contains("received 2 arguments"))299 b.set("D1", "=E1+1"); b.set("E1", "=F1+1"); b.set("F1", "=D1+1")300 let c = ErrorExplainer(engine: b.engine).explain(sheet: 0, cell: b.ref("D1"))!301 #expect(c.error == .circular)302 #expect(Set(c.chain) == ["Sheet1!D1", "Sheet1!E1", "Sheet1!F1"])303 #expect(c.causes[0].detail == "These cells depend on each other in a loop.")304 for e in CellError.allCases {305 #expect(ErrorExplainer.meaning(e).hasPrefix(e.rawValue))306 #expect(!ErrorExplainer.suggestion(e).isEmpty)307 }308 }309}310