Repository Public MIT
1// ORIX Calc2// File: Packages/ORIXFeatureFinancial/Tests/ORIXFeatureFinancialTests/FinancialModelTests.swift3// Description: Tests of the Financial environment's state logic — keypad/register machine, section models, demo values, persistence round trips.4//5// Author: Simon-Pierre Boucher6// Contact: contact@spboucher.ai7import Foundation8import Testing9import ORIXFinancial10import ORIXNumerics11import ORIXUI12@testable import ORIXFeatureFinancial1314private func close(_ a: Double, _ b: Double, _ tol: Double = 1e-9) -> Bool { abs(a - b) <= tol * max(1, abs(b)) }1516@MainActor @Suite struct TVMKeypadTests {17 private func type(_ m: TVMModel, _ keys: String...) { for k in keys { m.press(k) } }1819 @Test func typingBuildsTheEntry() {20 let m = TVMModel()21 type(m, "1", "2", ".", "5")22 #expect(m.entry == "12.5")23 #expect(m.entryValue == 12.5)24 m.press(".")25 #expect(m.entry == "12.5", "a second decimal point is ignored")26 m.press("back")27 #expect(m.entry == "12.")28 #expect(m.entryValue == 12)29 }3031 @Test func leadingZerosAndDecimalStart() {32 let m = TVMModel()33 type(m, "0", "0", "7")34 #expect(m.entry == "7")35 m.press("clear")36 m.press(".")37 #expect(m.entry == "0.")38 m.press("5")39 #expect(m.entryValue == 0.5)40 }4142 @Test func signChangeTogglesAndWorksBeforeDigits() {43 let m = TVMModel()44 m.press("sign")45 #expect(m.entry == "-")46 #expect(m.entryValue == nil)47 type(m, "4", "2")48 #expect(m.entryValue == -42)49 m.press("sign")50 #expect(m.entryValue == 42)51 m.press("sign"); m.press(".")52 #expect(m.entry == "-42.")53 }5455 @Test func thousandKeyAndLengthLimit() {56 let m = TVMModel()57 m.press("000")58 #expect(m.entry == "", "000 needs a number first")59 type(m, "3", "0", "0", "000")60 #expect(m.entryValue == 300_000)61 for _ in 0..<30 { m.press("9") }62 #expect(m.entry.filter(\.isNumber).count == TVMModel.maxEntryLength)63 }6465 @Test func tappingARegisterStoresTheEntry() {66 let m = TVMModel()67 type(m, "3", "0", "0")68 #expect(m.tapRegister(.n) == nil)69 #expect(m.state.n == 300)70 #expect(m.entry == "")71 #expect(m.lastStored == .n)72 // Nothing typed: nothing is stored and a hint is shown.73 m.tapRegister(.pv)74 #expect(m.state.pv == nil)75 #expect(m.message == TVMModel.hint)76 }7778 @Test func cptThenRegisterSolvesTheCanadianMortgage() throws {79 let m = TVMModel()80 m.state.py = 12; m.state.cy = 281 type(m, "3", "0", "0"); m.tapRegister(.n)82 type(m, "5"); m.tapRegister(.iy)83 type(m, "3", "0", "0", "000"); m.tapRegister(.pv)84 type(m, "0"); m.tapRegister(.fv)85 m.press("cpt")86 #expect(m.cptArmed)87 let entry = try #require(m.tapRegister(.pmt))88 #expect(!m.cptArmed)89 #expect(m.solved == .pmt)90 #expect(abs(entry.value - (-1744.81495511)) < 1e-6)91 #expect((m.state.pmt.map { ($0 * 100).rounded() / 100 }) == -1744.81)92 #expect(entry.input.contains("→ PMT"))93 #expect(m.result?.verification.isVerified == true)94 let s = try #require(m.summary)95 #expect(close(s.effectiveAnnualRate, 0.050625, 1e-12))96 #expect(close(s.totalPayments, entry.value * 300))97 #expect(close(s.netInterest, -(300_000 + entry.value * 300)))98 #expect(s.netInterest > 0)99 }100101 @Test func cptTogglesAndClearDisarms() {102 let m = TVMModel()103 m.press("cpt"); #expect(m.cptArmed)104 m.press("cpt"); #expect(!m.cptArmed)105 m.press("cpt"); m.press("clear")106 #expect(!m.cptArmed)107 }108109 @Test func missingInputsAreExplained() {110 let m = TVMModel()111 m.state.pv = 1000112 #expect(m.solve(.pmt) == nil)113 #expect(m.message?.title == "Missing inputs")114 #expect(m.message?.text.contains("N and I/Y") == true)115 m.state.pv = nil; m.state.n = 10; m.state.iy = 5116 #expect(m.solve(.fv) == nil)117 #expect(m.message?.text.contains("non-zero amount") == true)118 #expect(m.result == nil)119 }120121 @Test func noSolutionAndEditingInvalidateTheResult() {122 let m = TVMModel()123 m.state = TVMState(n: 10, iy: nil, pv: 1000, pmt: 100, fv: 0, py: 1, cy: 1)124 #expect(m.solve(.iy) == nil, "same-sign amounts have no rate")125 #expect(m.message?.kind == .error)126 m.state.pmt = -150127 #expect(m.solve(.iy) != nil)128 #expect(m.result != nil)129 m.state.formMode = true130 #expect(m.result != nil, "switching the entry mode keeps the result")131 m.state.pv = 2000132 #expect(m.result == nil, "a changed input removes the stale result")133 }134135 @Test func clearTVMKeepsThePaymentSettings() {136 let m = TVMModel()137 m.loadDemo()138 m.state.begin = true139 m.clearTVM()140 #expect(m.state.n == nil && m.state.iy == nil && m.state.pv == nil && m.state.pmt == nil && m.state.fv == nil)141 #expect(m.state.py == 12 && m.state.cy == 2 && m.state.begin)142 #expect(m.result == nil)143 }144}145146@MainActor @Suite struct CashFlowModelTests {147 @Test func listEditing() {148 let m = CashFlowModel()149 m.state.rows = [FlowRow(amount: 1, count: 2), FlowRow(amount: 2, count: 3)]150 let first = m.state.rows[0].id, second = m.state.rows[1].id151 #expect(m.periodRange(of: second) == 3...5)152 m.duplicate(first)153 #expect(m.state.rows.map(\.amount) == [1, 1, 2])154 #expect(Set(m.state.rows.map(\.id)).count == 3)155 m.move(second, by: -1)156 #expect(m.state.rows.map(\.amount) == [1, 2, 1])157 m.move(second, by: -5)158 #expect(m.state.rows.map(\.amount) == [1, 2, 1], "an impossible move is ignored")159 m.move(fromOffsets: IndexSet(integer: 0), toOffset: 3)160 #expect(m.state.rows.map(\.amount) == [2, 1, 1])161 m.addRow()162 #expect(m.state.rows.count == 4)163 for r in m.state.rows { m.delete(r.id) }164 #expect(m.state.rows.count == 1, "the list never becomes empty")165 }166167 @Test func demoMatchesTheEngine() throws {168 let m = CashFlowModel()169 m.loadDemo()170 let r = try #require(m.result)171 let series = CashFlowSeries(initial: -50_000, groups: [CashFlowGroup(amount: 12_000, count: 5), CashFlowGroup(amount: 20_000)])172 #expect(close(r.npv.value, try series.npv(rate: 0.10)))173 #expect(close(r.nfv, try series.nfv(rate: 0.10)))174 #expect(r.flows.count == 7)175 guard case .unique(let irr) = r.irr.outcome else { Issue.record("expected a unique IRR"); return }176 #expect(close(irr, try series.irr().uniqueRate()))177 #expect(abs(try series.npv(rate: irr)) < 1e-6)178 #expect(r.mirr != nil && r.payback != nil && r.discountedPayback != nil && r.profitabilityIndex != nil)179 #expect(r.profile.count == 81)180 #expect(r.profile.first!.rate <= irr && r.profile.last!.rate >= irr, "the profile covers the IRR")181 }182183 @Test func multipleIRRsAreAllReported() throws {184 var s = CashFlowState()185 s.initial = -1000; s.rows = [FlowRow(amount: 2300), FlowRow(amount: -1320)]; s.ratePct = 12186 let r = try CashFlowModel.compute(s)187 guard case .multiple(let rates) = r.irr.outcome else { Issue.record("expected several IRRs"); return }188 #expect(rates.count == 2)189 #expect(close(rates[0], 0.10, 1e-7) && close(rates[1], 0.20, 1e-7))190 }191192 @Test func missingInputsGiveMessagesAndEditingClearsTheResult() {193 let m = CashFlowModel()194 #expect(m.calculate() == nil)195 #expect(m.message?.title == "Check the inputs")196 m.state.initial = -100197 #expect(m.calculate() == nil)198 #expect(m.message?.text.contains("C1") == true)199 m.state.rows[0].amount = 120200 #expect(m.calculate() != nil)201 m.state.ratePct = 5202 #expect(m.result == nil)203 }204}205206@MainActor @Suite struct LoanModelTests {207 @Test func canadianMortgageReference() throws {208 var s = LoanState()209 s.principal = 300_000; s.ratePct = 5; s.amortYears = 25210 let r = try LoanModel.compute(s, convention: .canadianFixed)211 #expect(r.payment.payment == 1744.81)212 #expect(r.base.rows.count == 300)213 #expect(r.base.isPaidOff)214 #expect(r.scenario == nil && r.term == nil)215 #expect(r.yearly.count == 25)216 #expect(close(r.yearly.reduce(0) { $0 + $1.interest }, r.base.totalInterest, 1e-9))217 #expect(r.yearly.last?.balance == 0)218 let us = try LoanModel.compute(s, convention: .usMonthly)219 #expect(us.payment.payment == 1753.77, "US monthly compounding gives a different payment")220 }221222 @Test func demoHasTermPrepaymentRefinanceAndAffordability() throws {223 let m = LoanModel()224 m.defaultConvention = .usMonthly225 m.loadDemo()226 let r = try #require(m.result)227 #expect(m.convention == .canadianFixed, "an explicit convention wins over the Settings default")228 #expect(r.payment.payment == 1744.81)229 #expect(r.term?.paymentsInTerm == 60)230 let saved = try #require(r.interestSaved), periods = try #require(r.periodsSaved)231 #expect(saved > 0 && periods > 0)232 #expect(r.active.totalPrepayments == 10_000)233 let refi = try #require(m.refinance)234 #expect(refi.currentPayment == 1744.81)235 #expect(refi.newPayment < refi.currentPayment)236 #expect(refi.simpleBreakEvenMonths != nil)237 let aff = try #require(m.affordability)238 #expect(aff.maxLoan > 0 && close(aff.maxPurchasePrice, aff.maxLoan + 60_000))239 #expect(m.message == nil && m.refinanceMessage == nil && m.affordabilityMessage == nil)240 }241242 @Test func conventionFollowsTheDefaultUntilChosen() {243 let m = LoanModel()244 m.defaultConvention = .usMonthly245 #expect(m.convention == .usMonthly)246 m.state.convention = .canadianVariable247 m.defaultConvention = .canadianFixed248 #expect(m.convention == .canadianVariable)249 #expect(FinancialScreen.convention(for: .canada) == .canadianFixed)250 #expect(FinancialScreen.convention(for: .unitedStates) == .usMonthly)251 }252253 @Test func rateChangePoliciesAndAcceleratedPayments() throws {254 var s = LoanState()255 s.principal = 200_000; s.ratePct = 4; s.amortYears = 20256 s.rateChanges = [RateRow(period: 61, ratePct: 6, keepPayment: false)]257 let recalc = try LoanModel.compute(s, convention: .canadianVariable)258 #expect(recalc.scenario?.rows.count == 240, "recalculating keeps the end date")259 #expect((recalc.interestSaved ?? 0) < 0)260 s.rateChanges[0].keepPayment = true261 let keep = try LoanModel.compute(s, convention: .canadianVariable)262 #expect((keep.scenario?.rows.count ?? 0) > 240, "keeping the payment lengthens the loan")263 s.rateChanges = []; s.frequency = .acceleratedBiweekly264 let fast = try LoanModel.compute(s, convention: .canadianVariable)265 #expect(fast.payoffYears < 20)266 }267268 @Test func csvHasOneLinePerPayment() throws {269 var s = LoanState()270 s.principal = 10_000; s.ratePct = 6; s.amortYears = 1271 let r = try LoanModel.compute(s, convention: .usMonthly)272 let lines = LoanModel.csv(r.base).split(separator: "\r\n")273 #expect(lines.count == 13)274 #expect(lines[0] == "Period,Payment,Interest,Principal,Prepayment,Balance,Annual rate")275 #expect(lines[1].hasPrefix("1,860.66,50.00,810.66,0.00,9189.34"))276 #expect(lines[12].hasSuffix(",0.00,0.060000"))277 }278279 @Test func errorsAreReportedAndInputsClearResults() {280 let m = LoanModel()281 #expect(m.calculate() == nil)282 #expect(m.message?.text == "Enter the loan amount.")283 m.state.principal = 100_000; m.state.ratePct = 5; m.state.amortYears = 25284 #expect(m.calculate() != nil)285 m.state.yearly = true; m.state.tab = .scenarios286 #expect(m.result != nil, "view-only settings keep the result")287 m.addPrepayment()288 #expect(m.result == nil)289 #expect(m.calculate() == nil)290 #expect(m.message?.text.contains("Prepayment 1") == true)291 }292}293294@MainActor @Suite struct BondInvestOptionTests {295 @Test func bondDemoReproducesTheReferencePrice() throws {296 let m = BondModel()297 m.loadDemo()298 let o = try #require(m.output)299 #expect(abs(o.result.cleanPrice - 94.63436) < 5e-6)300 #expect(close(o.result.yield, 0.065, 1e-12))301 #expect(o.yieldToCall != nil && o.callNote == nil)302 #expect(o.curve.count == 61)303 // The tangent touches the curve at the current yield and has the slope −Dmod · dirty.304 #expect(close(o.tangent[1].price, o.result.cleanPrice))305 let slope = (o.tangent[2].price - o.tangent[0].price) / (o.tangent[2].yield - o.tangent[0].yield)306 #expect(close(slope, -o.result.modifiedDuration * o.result.dirtyPrice, 1e-9))307 // Solving the yield back from the price returns the yield.308 var s = m.state309 s.solveFor = .yield; s.cleanPrice = o.result.cleanPrice310 #expect(close(try BondModel.compute(s).result.yield, 0.065, 1e-9))311 }312313 @Test func simpleBondModeAndCallNote() throws {314 var s = BondState()315 s.mode = .simple; s.couponPct = 6; s.periods = 20; s.yieldPct = 6; s.callEnabled = true316 let o = try BondModel.compute(s)317 #expect(close(o.result.cleanPrice, 100, 1e-10), "a bond priced at its coupon rate is at par")318 #expect(o.result.accruedInterest == 0)319 #expect(o.callNote != nil)320 s.periods = 2.5321 #expect(throws: FinancialError.self) { try BondModel.compute(s) }322 }323324 @Test func everyInvestmentCalculatorComputesInTheDemo() throws {325 let m = InvestModel()326 m.loadDemo()327 for tool in InvestTool.allCases {328 var s = m.state329 s.tool = tool330 let o = try InvestModel.compute(s)331 #expect(!o.lines.isEmpty, "\(tool)")332 #expect(o.lines.allSatisfy { $0.value.isFinite }, "\(tool)")333 #expect(!o.explanation.title.isEmpty)334 }335 var s = m.state336 s.tool = .cagr337 #expect(close(try InvestModel.compute(s).lines[0].value, pow(1.95, 1.0 / 7) - 1, 1e-12))338 s.tool = .perpetuity339 #expect(close(try InvestModel.compute(s).lines[0].value, 25_000))340 s.tool = .growingPerpetuity341 #expect(close(try InvestModel.compute(s).lines[0].value, 50))342 s.tool = .timeWeighted343 #expect(close(try InvestModel.compute(s).lines[0].value, 1.05 * (118_000.0 / 115_000) - 1, 1e-12))344 s.tool = .annuity; s.begin = true345 let due = try InvestModel.compute(s).lines[0].value346 s.begin = false347 #expect(close(due, try InvestModel.compute(s).lines[0].value * 1.005, 1e-12))348 }349350 @Test func investmentErrorsNameTheMissingField() {351 let m = InvestModel()352 #expect(m.calculate() == nil)353 #expect(m.message?.text == "Enter “Beginning value”.")354 m.state.tool = .growingPerpetuity355 m.state.set(.growingPerpetuity, "payment", 1); m.state.set(.growingPerpetuity, "rate", 3); m.state.set(.growingPerpetuity, "growth", 5)356 #expect(m.calculate() == nil)357 #expect(m.message?.kind == .error)358 }359360 @Test func optionDemoReproducesHull() throws {361 let m = OptionModel()362 m.loadDemo()363 let p = try #require(m.pricing)364 #expect(abs(p.selected.price - 4.7594) < 5e-5)365 #expect(abs(p.otherPrice - 0.8086) < 5e-5)366 let iv = try #require(m.implied)367 #expect(abs(iv.volatility - 0.20) < 1e-3)368 #expect(m.parity?.holds == true, "model prices satisfy parity")369 let s = try #require(m.strategy)370 #expect(s.breakEvens.count == 2 && close(s.breakEvens[0], 86) && close(s.breakEvens[1], 114))371 #expect(s.maxProfit == 4 && s.maxLoss == -6)372 #expect(s.curve.first!.price < 80 && s.curve.last!.price > 120)373 }374375 @Test func parityViolationAndBoundsAreReported() {376 let m = OptionModel()377 m.loadDemo()378 m.state.parityCall = 6379 #expect(m.parity == nil, "editing a quote removes the stale check")380 m.checkParity()381 #expect(m.parity?.holds == false)382 m.state.marketPrice = 0.5383 m.calculateImplied()384 #expect(m.implied == nil)385 #expect(m.impliedMessage?.title == "Price outside no-arbitrage bounds")386 }387388 @Test func binomialRunsOffMainAndCanBeCancelled() async throws {389 let m = OptionModel()390 m.loadDemo()391 m.state.kind = .put; m.state.style = .american; m.state.steps = 400392 let entry = try #require(await m.runBinomial())393 guard case .done(let r) = m.binomial else { Issue.record("expected a finished tree"); return }394 #expect(r.steps == 400 && r.earlyExercisePremium > 0)395 #expect(r.price > r.blackScholesEuropeanReference, "an American put is worth more than the European one")396 #expect(entry.label.contains("American"))397398 // A run that is cancelled while in flight must not publish its result.399 m.state.steps = 3000400 async let pending = m.runBinomial()401 await Task.yield()402 m.cancelBinomial()403 #expect(await pending == nil)404 guard case .idle = m.binomial else { Issue.record("a cancelled run must leave the phase idle"); return }405406 m.state.spot = nil407 #expect(await m.runBinomial() == nil)408 guard case .failed = m.binomial else { Issue.record("expected a failure message"); return }409 }410}411412@MainActor @Suite struct SensitivityAndStoreTests {413 @Test func everySweepComputesFromTheDemoInputs() throws {414 let store = FinancialStore()415 store.loadDemo()416 #expect(store.sensitivity.output != nil)417 for kind in SensitivityKind.allCases {418 store.sensitivity.state.kind = kind419 let request = store.sensitivityRequest420 #expect(request.lower < request.upper)421 let limits = store.sensitivityLimits422 #expect(request.lower >= limits.lowerBound && request.upper <= limits.upperBound)423 let o = try Studio.compute(request).get()424 #expect(o.points.count == Studio.pointCount, "\(kind)")425 #expect(o.table().count == 9)426 #expect(o.current != nil, "\(kind): the current input lies in the default range")427 }428 // The mortgage sweep passes through the reference payment at 5%.429 store.sensitivity.state.kind = .mortgageRate430 let o = try Studio.compute(store.sensitivityRequest).get()431 #expect(o.nearest(to: 5.0)?.y == 1744.81)432 #expect(o.points.first!.y < o.points.last!.y)433 }434435 @Test func rangesAreClampedAndIncompleteSourcesAreExplained() {436 let store = FinancialStore()437 let failure = Studio.compute(store.sensitivityRequest)438 guard case .failure(let m) = failure else { Issue.record("an empty loan cannot be swept"); return }439 #expect(m.title == "Complete the Loans section first")440 store.sensitivity.apply(failure)441 #expect(store.sensitivity.output == nil && store.sensitivity.message != nil)442443 store.sensitivity.setRange(RangeState(lower: 50, upper: -3), limits: 0...20)444 let r = store.sensitivityRange(.mortgageRate)445 #expect(r.lower >= 0 && r.upper <= 20 && r.lower < r.upper)446 store.sensitivity.resetRange()447 #expect(store.sensitivity.state.ranges.isEmpty)448 }449450 @Test func snapshotRoundTripsThroughJSON() throws {451 let store = FinancialStore()452 store.loadDemo()453 store.section = .bond454 store.sensitivity.state.kind = .optionSpot455 store.sensitivity.setRange(RangeState(lower: 30, upper: 60), limits: store.sensitivityLimits)456 let snapshot = store.snapshot457 let data = try JSONEncoder().encode(snapshot)458 let decoded = try JSONDecoder().decode(FinancialSnapshot.self, from: data)459 #expect(decoded == snapshot)460461 let other = FinancialStore()462 other.restore(decoded)463 #expect(other.snapshot == snapshot)464 #expect(other.section == .bond)465 #expect(other.tvm.result == nil, "results are recomputed, never restored")466 #expect(other.tvm.solve(.pmt) != nil)467 #expect((other.tvm.state.pmt.map { ($0 * 100).rounded() / 100 }) == -1744.81)468 }469470 @Test func damagedSnapshotKeepsTheReadableSections() throws {471 let json = #"{"section":"loan","tvm":{"n":12,"py":12,"cy":12,"begin":false,"formMode":true},"loan":"garbage","unknown":1}"#472 let s = try JSONDecoder().decode(FinancialSnapshot.self, from: Data(json.utf8))473 #expect(s.section == .loan)474 #expect(s.tvm.n == 12 && s.tvm.formMode)475 #expect(s.loan == LoanState())476 }477478 @Test func savedModelPayloadsRoundTrip() throws {479 let store = FinancialStore()480 store.loadDemo()481 let other = FinancialStore()482 for section in FinancialSection.allCases {483 guard section.savedKind != nil else {484 #expect(store.payload(for: section) == nil)485 continue486 }487 let payload = try #require(store.payload(for: section))488 #expect(other.open(payload, in: section), "\(section)")489 }490 #expect(other.tvm.state == store.tvm.state)491 #expect(other.cashflow.state == store.cashflow.state)492 #expect(other.loan.state == store.loan.state)493 #expect(other.bond.state == store.bond.state)494 #expect(other.option.state == store.option.state)495 #expect(!other.open(Data("not json".utf8), in: .loan))496 #expect(FinancialSection.tvm.savedKind == "financial.tvm")497 }498499 @Test func demoComputesEverySectionWithoutError() {500 let store = FinancialStore()501 store.loadDemo()502 #expect(store.tvm.result != nil && store.tvm.message == nil)503 #expect(store.cashflow.result != nil && store.cashflow.message == nil)504 #expect(store.loan.result != nil && store.loan.refinance != nil && store.loan.affordability != nil)505 #expect(store.bond.output != nil && store.bond.message == nil)506 #expect(store.invest.output != nil && store.invest.message == nil)507 #expect(store.option.pricing != nil && store.option.implied != nil && store.option.parity != nil && store.option.strategy != nil)508 #expect(store.sensitivity.output != nil && store.sensitivity.message == nil)509 }510511 @Test func stateAndNamedModelsPersistThroughTheAppModel() throws {512 let app = AppModel(inMemory: true)513 let store = FinancialStore()514 store.loadDemo()515 store.section = .option516 app.saveState(store.snapshot, key: FinancialStore.stateKey)517 app.saveState(store.snapshot, key: FinancialStore.stateKey)518 let loaded = try #require(app.loadState(FinancialSnapshot.self, key: FinancialStore.stateKey))519 #expect(loaded == store.snapshot)520521 let payload = try #require(store.payload(for: .loan))522 let id = app.saveModel(kind: "financial.loan", title: "Demo mortgage", payload: payload)523 let saved = app.savedModels(kind: "financial.loan")524 #expect(saved.map(\.title) == ["Demo mortgage"])525 let fresh = FinancialStore()526 #expect(fresh.open(saved[0].payload, in: .loan))527 #expect(fresh.loan.calculate()?.value == 1744.81)528 app.deleteModel(id)529 #expect(app.savedModels(kind: "financial.loan").isEmpty)530 }531532 @Test func messagesAreInPlainLanguage() {533 #expect(FinMessage(error: FinancialError.multipleIRR([0.1, 0.2])).text.contains("10.0000%, 20.0000%"))534 #expect(FinMessage(error: FinancialError.noSolution("x")).title == "No solution")535 #expect(FinMessage(error: FinancialError.multipleSolutions(candidates: [1, 2], message: "m")).title == "More than one solution")536 #expect(FinMessage(error: FinancialError.invalidInput("Enter the rate.")).text == "Enter the rate.")537 }538}539