SPB Git

Repository Public

FormulaTraceExplainTests.swift 20.5 KB 310 lines swift

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
Files main
Menu

Theme