]> Git — Sourcephile - comptalang.git/blob - lib/Test/Main.hs
sourcephile / git / comptalang.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
WIP : Format.Ledger.Read : Model.Transaction.Posting
[comptalang.git] / lib / Test / Main.hs
1 {-# LANGUAGE TupleSections #-}
2
3 import Prelude
4 import Test.HUnit
5 import Test.Framework.Providers.HUnit (hUnitTestToTests)
6 import Test.Framework.Runners.Console (defaultMain)
7
8 import Control.Applicative ((<*))
9 import qualified Data.List
10 import qualified Data.Map
11 import qualified Data.Either
12 import qualified Text.Parsec
13 import qualified Data.Decimal
14 import Data.Decimal (Decimal(..))
15
16 import qualified Hcompta.Model as Model
17 import qualified Hcompta.Model.Account as Account
18 import qualified Hcompta.Model.Amount as Amount
19 import qualified Hcompta.Model.Amount.Quantity as Quantity
20 import qualified Hcompta.Model.Amount.Style as Style
21 import qualified Hcompta.Model.Transaction as Transaction
22 import Hcompta.Model.Transaction (Posting)
23 import qualified Hcompta.Model.Transaction.Posting as Posting
24 import qualified Hcompta.Calc as Calc
25 import qualified Hcompta.Calc.Balance as Calc.Balance
26 import qualified Hcompta.Format.Ledger as Format.Ledger
27 import qualified Hcompta.Format.Ledger.Read as Format.Ledger.Read
28
29 main :: IO ()
30 main = defaultMain $ hUnitTestToTests test_Hcompta
31
32 test_Hcompta :: Test
33 test_Hcompta =
34 TestList
35 [ "Model" ~: TestList
36 [ "Account" ~: TestList
37 [ "fold" ~: TestList
38 [ "[] = []" ~:
39 (reverse $ Account.fold [] (:) []) ~?= []
40 , "[A] = [[A]]" ~:
41 (reverse $ Account.fold ["A"] (:) []) ~?= [["A"]]
42 , "[A, B] = [[A], [A, B]]" ~:
43 (reverse $ Account.fold ["A", "B"] (:) []) ~?= [["A"], ["A", "B"]]
44 , "[A, B, C] = [[A], [A, B], [A, B, C]]" ~:
45 (reverse $ Account.fold ["A", "B", "C"] (:) []) ~?= [["A"], ["A", "B"], ["A", "B", "C"]]
46 ]
47 , "ascending" ~: TestList
48 [ "[] = []" ~:
49 Account.ascending [] ~?= []
50 , "[A] = []" ~:
51 Account.ascending ["A"] ~?= []
52 , "[A, B] = [A]" ~:
53 Account.ascending ["A", "B"] ~?= ["A"]
54 , "[A, B, C] = [A, B]" ~:
55 Account.ascending ["A", "B", "C"] ~?= ["A", "B"]
56 ]
57 ]
58 ]
59 , "Calc" ~: TestList
60 [ "Balance" ~: TestList
61 [ "posting" ~: TestList
62 [ "[A+$1] = A+$1 & $+1" ~:
63 (Calc.Balance.posting
64 Posting.nil
65 { Posting.account=["A"]
66 , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
67 }
68 Calc.Balance.nil)
69 ~?=
70 Calc.Balance.Balance
71 { Calc.Balance.by_account =
72 Data.Map.fromList
73 [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
74 , Calc.Balance.by_unit =
75 Data.Map.fromList $
76 Data.List.map Calc.Balance.assoc_by_amount_unit $
77 [ Calc.Balance.Sum_by_Unit
78 { Calc.Balance.amount = Amount.usd $ 1
79 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
80 [["A"]]
81 }
82 ]
83 }
84 , "[A+$1, A-$1] = {A+$0, $+0}" ~:
85 (Data.List.foldl
86 (flip Calc.Balance.posting)
87 Calc.Balance.nil
88 [ Posting.nil
89 { Posting.account=["A"]
90 , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
91 }
92 , Posting.nil
93 { Posting.account=["A"]
94 , Posting.amounts=Amount.from_List [ Amount.usd $ -1 ]
95 }
96 ])
97 ~?=
98 Calc.Balance.Balance
99 { Calc.Balance.by_account =
100 Data.Map.fromList
101 [ (["A"], Amount.from_List [ Amount.usd $ 0 ]) ]
102 , Calc.Balance.by_unit =
103 Data.Map.fromList $
104 Data.List.map Calc.Balance.assoc_by_amount_unit $
105 [ Calc.Balance.Sum_by_Unit
106 { Calc.Balance.amount = Amount.usd $ 0
107 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
108 [["A"]]
109 }
110 ]
111 }
112 , "[A+$1, A-€1] = {A+$1-€1, $+1 €-1}" ~:
113 (Data.List.foldl
114 (flip Calc.Balance.posting)
115 Calc.Balance.nil
116 [ Posting.nil
117 { Posting.account=["A"]
118 , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
119 }
120 , Posting.nil
121 { Posting.account=["A"]
122 , Posting.amounts=Amount.from_List [ Amount.eur $ -1 ]
123 }
124 ])
125 ~?=
126 Calc.Balance.Balance
127 { Calc.Balance.by_account =
128 Data.Map.fromList
129 [ (["A"], Amount.from_List [ Amount.usd $ 1, Amount.eur $ -1 ]) ]
130 , Calc.Balance.by_unit =
131 Data.Map.fromList $
132 Data.List.map Calc.Balance.assoc_by_amount_unit $
133 [ Calc.Balance.Sum_by_Unit
134 { Calc.Balance.amount = Amount.usd $ 1
135 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
136 [["A"]]
137 }
138 , Calc.Balance.Sum_by_Unit
139 { Calc.Balance.amount = Amount.eur $ -1
140 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
141 [["A"]]
142 }
143 ]
144 }
145 , "[A+$1, B-$1] = {A+$1 B-$1, $+0}" ~:
146 (Data.List.foldl
147 (flip Calc.Balance.posting)
148 Calc.Balance.nil
149 [ Posting.nil
150 { Posting.account=["A"]
151 , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
152 }
153 , Posting.nil
154 { Posting.account=["B"]
155 , Posting.amounts=Amount.from_List [ Amount.usd $ -1 ]
156 }
157 ])
158 ~?=
159 Calc.Balance.Balance
160 { Calc.Balance.by_account =
161 Data.Map.fromList
162 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
163 , (["B"], Amount.from_List [ Amount.usd $ -1 ])
164 ]
165 , Calc.Balance.by_unit =
166 Data.Map.fromList $
167 Data.List.map Calc.Balance.assoc_by_amount_unit $
168 [ Calc.Balance.Sum_by_Unit
169 { Calc.Balance.amount = Amount.usd $ 0
170 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
171 [["A"], ["B"]]
172 }
173 ]
174 }
175 , "[A+$1+€2, A-$1-€2] = {A+$0+€0, $+0 €+0}" ~:
176 (Data.List.foldl
177 (flip Calc.Balance.posting)
178 Calc.Balance.nil
179 [ Posting.nil
180 { Posting.account=["A"]
181 , Posting.amounts=Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2 ]
182 }
183 , Posting.nil
184 { Posting.account=["A"]
185 , Posting.amounts=Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2 ]
186 }
187 ])
188 ~?=
189 Calc.Balance.Balance
190 { Calc.Balance.by_account =
191 Data.Map.fromList
192 [ (["A"], Amount.from_List [ Amount.usd $ 0, Amount.eur $ 0 ])
193 ]
194 , Calc.Balance.by_unit =
195 Data.Map.fromList $
196 Data.List.map Calc.Balance.assoc_by_amount_unit $
197 [ Calc.Balance.Sum_by_Unit
198 { Calc.Balance.amount = Amount.usd $ 0
199 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
200 [["A"]]
201 }
202 , Calc.Balance.Sum_by_Unit
203 { Calc.Balance.amount = Amount.eur $ 0
204 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
205 [["A"]]
206 }
207 ]
208 }
209 , "[A+$1+€2+£3, B-$1-2€-£3] = {A+$1+€2+£3 B-$1-€2-£3, $+0 €+0 £+0}" ~:
210 (Data.List.foldl
211 (flip Calc.Balance.posting)
212 Calc.Balance.nil
213 [ Posting.nil
214 { Posting.account=["A"]
215 , Posting.amounts=Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2, Amount.gbp $ 3 ]
216 }
217 , Posting.nil
218 { Posting.account=["B"]
219 , Posting.amounts=Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ]
220 }
221 ])
222 ~?=
223 Calc.Balance.Balance
224 { Calc.Balance.by_account =
225 Data.Map.fromList
226 [ (["A"], Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2, Amount.gbp $ 3 ])
227 , (["B"], Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ])
228 ]
229 , Calc.Balance.by_unit =
230 Data.Map.fromList $
231 Data.List.map Calc.Balance.assoc_by_amount_unit $
232 [ Calc.Balance.Sum_by_Unit
233 { Calc.Balance.amount = Amount.usd $ 0
234 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
235 [["A"], ["B"]]
236 }
237 , Calc.Balance.Sum_by_Unit
238 { Calc.Balance.amount = Amount.eur $ 0
239 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
240 [["A"], ["B"]]
241 }
242 , Calc.Balance.Sum_by_Unit
243 { Calc.Balance.amount = Amount.gbp $ 0
244 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
245 [["A"], ["B"]]
246 }
247 ]
248 }
249 ]
250 , "union" ~: TestList
251 [ "nil nil = nil" ~:
252 Calc.Balance.union
253 Calc.Balance.nil
254 Calc.Balance.nil
255 ~?=
256 Calc.Balance.nil
257 , "{A+$1, $+1} {A+$1, $+1} = {A+$2, $+2}" ~:
258 Calc.Balance.union
259 (Calc.Balance.Balance
260 { Calc.Balance.by_account =
261 Data.Map.fromList
262 [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
263 , Calc.Balance.by_unit =
264 Data.Map.fromList $
265 Data.List.map Calc.Balance.assoc_by_amount_unit $
266 [ Calc.Balance.Sum_by_Unit
267 { Calc.Balance.amount = Amount.usd $ 1
268 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
269 [["A"]]
270 }
271 ]
272 })
273 (Calc.Balance.Balance
274 { Calc.Balance.by_account =
275 Data.Map.fromList
276 [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
277 , Calc.Balance.by_unit =
278 Data.Map.fromList $
279 Data.List.map Calc.Balance.assoc_by_amount_unit $
280 [ Calc.Balance.Sum_by_Unit
281 { Calc.Balance.amount = Amount.usd $ 1
282 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
283 [["A"]]
284 }
285 ]
286 })
287 ~?=
288 Calc.Balance.Balance
289 { Calc.Balance.by_account =
290 Data.Map.fromList
291 [ (["A"], Amount.from_List [ Amount.usd $ 2 ]) ]
292 , Calc.Balance.by_unit =
293 Data.Map.fromList $
294 Data.List.map Calc.Balance.assoc_by_amount_unit $
295 [ Calc.Balance.Sum_by_Unit
296 { Calc.Balance.amount = Amount.usd $ 2
297 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
298 [["A"]]
299 }
300 ]
301 }
302 , "{A+$1, $+1} {B+$1, $+1} = {A+$1 B+$1, $+2}" ~:
303 Calc.Balance.union
304 (Calc.Balance.Balance
305 { Calc.Balance.by_account =
306 Data.Map.fromList
307 [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
308 , Calc.Balance.by_unit =
309 Data.Map.fromList $
310 Data.List.map Calc.Balance.assoc_by_amount_unit $
311 [ Calc.Balance.Sum_by_Unit
312 { Calc.Balance.amount = Amount.usd $ 1
313 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
314 [["A"]]
315 }
316 ]
317 })
318 (Calc.Balance.Balance
319 { Calc.Balance.by_account =
320 Data.Map.fromList
321 [ (["B"], Amount.from_List [ Amount.usd $ 1 ]) ]
322 , Calc.Balance.by_unit =
323 Data.Map.fromList $
324 Data.List.map Calc.Balance.assoc_by_amount_unit $
325 [ Calc.Balance.Sum_by_Unit
326 { Calc.Balance.amount = Amount.usd $ 1
327 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
328 [["B"]]
329 }
330 ]
331 })
332 ~?=
333 Calc.Balance.Balance
334 { Calc.Balance.by_account =
335 Data.Map.fromList
336 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
337 , (["B"], Amount.from_List [ Amount.usd $ 1 ]) ]
338 , Calc.Balance.by_unit =
339 Data.Map.fromList $
340 Data.List.map Calc.Balance.assoc_by_amount_unit $
341 [ Calc.Balance.Sum_by_Unit
342 { Calc.Balance.amount = Amount.usd $ 2
343 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
344 [["A"], ["B"]]
345 }
346 ]
347 }
348 , "{A+$1, $+1} {B+€1, €+1} = {A+$1 B+€1, $+1 €+1}" ~:
349 Calc.Balance.union
350 (Calc.Balance.Balance
351 { Calc.Balance.by_account =
352 Data.Map.fromList
353 [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
354 , Calc.Balance.by_unit =
355 Data.Map.fromList $
356 Data.List.map Calc.Balance.assoc_by_amount_unit $
357 [ Calc.Balance.Sum_by_Unit
358 { Calc.Balance.amount = Amount.usd $ 1
359 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
360 [["A"]]
361 }
362 ]
363 })
364 (Calc.Balance.Balance
365 { Calc.Balance.by_account =
366 Data.Map.fromList
367 [ (["B"], Amount.from_List [ Amount.eur $ 1 ]) ]
368 , Calc.Balance.by_unit =
369 Data.Map.fromList $
370 Data.List.map Calc.Balance.assoc_by_amount_unit $
371 [ Calc.Balance.Sum_by_Unit
372 { Calc.Balance.amount = Amount.eur $ 1
373 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
374 [["B"]]
375 }
376 ]
377 })
378 ~?=
379 Calc.Balance.Balance
380 { Calc.Balance.by_account =
381 Data.Map.fromList
382 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
383 , (["B"], Amount.from_List [ Amount.eur $ 1 ]) ]
384 , Calc.Balance.by_unit =
385 Data.Map.fromList $
386 Data.List.map Calc.Balance.assoc_by_amount_unit $
387 [ Calc.Balance.Sum_by_Unit
388 { Calc.Balance.amount = Amount.usd $ 1
389 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
390 [["A"]]
391 }
392 , Calc.Balance.Sum_by_Unit
393 { Calc.Balance.amount = Amount.eur $ 1
394 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
395 [["B"]]
396 }
397 ]
398 }
399 ]
400 , "expand" ~: TestList
401 [ "nil_By_Account = nil_By_Account" ~:
402 Calc.Balance.expand
403 Calc.Balance.nil_By_Account
404 ~?=
405 (Calc.Balance.Expanded $
406 Calc.Balance.nil_By_Account)
407 , "A+$1 = A+$1" ~:
408 Calc.Balance.expand
409 (Data.Map.fromList
410 [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ])
411 ~?=
412 (Calc.Balance.Expanded $
413 Data.Map.fromList
414 [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ])
415 , "A/A+$1 = A+$1 A/A+$1" ~:
416 Calc.Balance.expand
417 (Data.Map.fromList
418 [ (["A", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
419 ~?=
420 (Calc.Balance.Expanded $
421 Data.Map.fromList
422 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
423 , (["A", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
424 , "A/B+$1 = A+$1 A/B+$1" ~:
425 Calc.Balance.expand
426 (Data.Map.fromList
427 [ (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
428 ~?=
429 (Calc.Balance.Expanded $
430 Data.Map.fromList
431 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
432 , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
433 , "A/B/C+$1 = A+$1 A/B+$1 A/B/C+$1" ~:
434 Calc.Balance.expand
435 (Data.Map.fromList
436 [ (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ]) ])
437 ~?=
438 (Calc.Balance.Expanded $
439 Data.Map.fromList
440 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
441 , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
442 , (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ]) ])
443 , "A+$1 A/B+$1 = A+$2 A/B+$1" ~:
444 Calc.Balance.expand
445 (Data.Map.fromList
446 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
447 , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
448 ~?=
449 (Calc.Balance.Expanded $
450 Data.Map.fromList
451 [ (["A"], Amount.from_List [ Amount.usd $ 2 ])
452 , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
453 , "A+$1 A/B+$1 A/B/C+$1 = A+$3 A/B+$2 A/B/C+$1" ~:
454 Calc.Balance.expand
455 (Data.Map.fromList
456 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
457 , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
458 , (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ])
459 ])
460 ~?=
461 (Calc.Balance.Expanded $
462 Data.Map.fromList
463 [ (["A"], Amount.from_List [ Amount.usd $ 3 ])
464 , (["A", "B"], Amount.from_List [ Amount.usd $ 2 ])
465 , (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ])
466 ])
467 , "A+$1 A/B+$1 A/B/C+$1 A/B/C/D+$1 = A+$4 A/B+$3 A/B/C+$2 A/B/C/D+$1" ~:
468 Calc.Balance.expand
469 (Data.Map.fromList
470 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
471 , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
472 , (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ])
473 , (["A", "B", "C", "D"], Amount.from_List [ Amount.usd $ 1 ])
474 ])
475 ~?=
476 (Calc.Balance.Expanded $
477 Data.Map.fromList
478 [ (["A"], Amount.from_List [ Amount.usd $ 4 ])
479 , (["A", "B"], Amount.from_List [ Amount.usd $ 3 ])
480 , (["A", "B", "C"], Amount.from_List [ Amount.usd $ 2 ])
481 , (["A", "B", "C", "D"], Amount.from_List [ Amount.usd $ 1 ])
482 ])
483 , "A+$1 A/B+$1 B/A+$1 = A+$2 A/B+$1 B/A+$1" ~:
484 Calc.Balance.expand
485 (Data.Map.fromList
486 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
487 , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
488 , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
489 ~?=
490 (Calc.Balance.Expanded $
491 Data.Map.fromList
492 [ (["A"], Amount.from_List [ Amount.usd $ 2 ])
493 , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
494 , (["B"], Amount.from_List [ Amount.usd $ 1 ])
495 , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
496 , "A+$1 A/B+$1 B/A+$1 = A+$2 A/B+$1 B/A+$1" ~:
497 Calc.Balance.expand
498 (Data.Map.fromList
499 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
500 , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
501 , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
502 ~?=
503 (Calc.Balance.Expanded $
504 Data.Map.fromList
505 [ (["A"], Amount.from_List [ Amount.usd $ 2 ])
506 , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
507 , (["B"], Amount.from_List [ Amount.usd $ 1 ])
508 , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
509 ]
510 , "is_equilibrated" ~: TestList
511 [ "nil = True" ~: TestCase $
512 (@=?) True $
513 Calc.Balance.is_equilibrated $
514 Calc.Balance.nil
515 , "{A+$0, $+0} = True" ~: TestCase $
516 (@=?) True $
517 Calc.Balance.is_equilibrated $
518 Calc.Balance.Balance
519 { Calc.Balance.by_account =
520 Data.Map.fromList
521 [ (["A"], Amount.from_List [ Amount.usd $ 0 ])
522 ]
523 , Calc.Balance.by_unit =
524 Data.Map.fromList $
525 Data.List.map Calc.Balance.assoc_by_amount_unit $
526 [ Calc.Balance.Sum_by_Unit
527 { Calc.Balance.amount = Amount.usd $ 0
528 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
529 [["A"]]
530 }
531 ]
532 }
533 , "{A+$1, $+1} = False" ~: TestCase $
534 (@=?) False $
535 Calc.Balance.is_equilibrated $
536 Calc.Balance.Balance
537 { Calc.Balance.by_account =
538 Data.Map.fromList
539 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
540 ]
541 , Calc.Balance.by_unit =
542 Data.Map.fromList $
543 Data.List.map Calc.Balance.assoc_by_amount_unit $
544 [ Calc.Balance.Sum_by_Unit
545 { Calc.Balance.amount = Amount.usd $ 1
546 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
547 [["A"]]
548 }
549 ]
550 }
551 , "{A+$0+€0, $0 €+0} = True" ~: TestCase $
552 (@=?) True $
553 Calc.Balance.is_equilibrated $
554 Calc.Balance.Balance
555 { Calc.Balance.by_account =
556 Data.Map.fromList
557 [ (["A"], Amount.from_List [ Amount.usd $ 0, Amount.eur $ 0 ])
558 ]
559 , Calc.Balance.by_unit =
560 Data.Map.fromList $
561 Data.List.map Calc.Balance.assoc_by_amount_unit $
562 [ Calc.Balance.Sum_by_Unit
563 { Calc.Balance.amount = Amount.usd $ 0
564 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
565 [["A"]]
566 }
567 , Calc.Balance.Sum_by_Unit
568 { Calc.Balance.amount = Amount.eur $ 0
569 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
570 [["A"]]
571 }
572 ]
573 }
574 , "{A+$1, B-$1, $+0} = True" ~: TestCase $
575 (@=?) True $
576 Calc.Balance.is_equilibrated $
577 Calc.Balance.Balance
578 { Calc.Balance.by_account =
579 Data.Map.fromList
580 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
581 , (["B"], Amount.from_List [ Amount.usd $ -1 ])
582 ]
583 , Calc.Balance.by_unit =
584 Data.Map.fromList $
585 Data.List.map Calc.Balance.assoc_by_amount_unit $
586 [ Calc.Balance.Sum_by_Unit
587 { Calc.Balance.amount = Amount.usd $ 0
588 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
589 [["A"], ["B"]]
590 }
591 ]
592 }
593 , "{A+$1 B, $+1} = True" ~: TestCase $
594 (@=?) True $
595 Calc.Balance.is_equilibrated $
596 Calc.Balance.Balance
597 { Calc.Balance.by_account =
598 Data.Map.fromList
599 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
600 , (["B"], Amount.from_List [])
601 ]
602 , Calc.Balance.by_unit =
603 Data.Map.fromList $
604 Data.List.map Calc.Balance.assoc_by_amount_unit $
605 [ Calc.Balance.Sum_by_Unit
606 { Calc.Balance.amount = Amount.usd $ 1
607 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
608 [["A"]]
609 }
610 ]
611 }
612 , "{A+$1 B+€1, $+1 €+1} = True" ~: TestCase $
613 (@=?) True $
614 Calc.Balance.is_equilibrated $
615 Calc.Balance.Balance
616 { Calc.Balance.by_account =
617 Data.Map.fromList
618 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
619 , (["B"], Amount.from_List [ Amount.eur $ 1 ])
620 ]
621 , Calc.Balance.by_unit =
622 Data.Map.fromList $
623 Data.List.map Calc.Balance.assoc_by_amount_unit $
624 [ Calc.Balance.Sum_by_Unit
625 { Calc.Balance.amount = Amount.usd $ 1
626 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
627 [["A"]]
628 }
629 , Calc.Balance.Sum_by_Unit
630 { Calc.Balance.amount = Amount.eur $ 1
631 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
632 [["B"]]
633 }
634 ]
635 }
636 , "{A+$1 B-$1+€1, $+0 €+1} = True" ~: TestCase $
637 (@=?) True $
638 Calc.Balance.is_equilibrated $
639 Calc.Balance.Balance
640 { Calc.Balance.by_account =
641 Data.Map.fromList
642 [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
643 , (["B"], Amount.from_List [ Amount.usd $ -1, Amount.eur $ 1 ])
644 ]
645 , Calc.Balance.by_unit =
646 Data.Map.fromList $
647 Data.List.map Calc.Balance.assoc_by_amount_unit $
648 [ Calc.Balance.Sum_by_Unit
649 { Calc.Balance.amount = Amount.usd $ 0
650 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
651 [["A"], ["B"]]
652 }
653 , Calc.Balance.Sum_by_Unit
654 { Calc.Balance.amount = Amount.eur $ 1
655 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
656 [["B"]]
657 }
658 ]
659 }
660 , "{A+$1+€2+£3 B-$1-€2-£3, $+0 €+0 £+0} = True" ~: TestCase $
661 (@=?) True $
662 Calc.Balance.is_equilibrated $
663 Calc.Balance.Balance
664 { Calc.Balance.by_account =
665 Data.Map.fromList
666 [ (["A"], Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2, Amount.gbp $ 3 ])
667 , (["B"], Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ])
668 ]
669 , Calc.Balance.by_unit =
670 Data.Map.fromList $
671 Data.List.map Calc.Balance.assoc_by_amount_unit $
672 [ Calc.Balance.Sum_by_Unit
673 { Calc.Balance.amount = Amount.usd $ 0
674 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
675 [["A"], ["B"]]
676 }
677 , Calc.Balance.Sum_by_Unit
678 { Calc.Balance.amount = Amount.eur $ 0
679 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
680 [["A"], ["B"]]
681 }
682 , Calc.Balance.Sum_by_Unit
683 { Calc.Balance.amount = Amount.gbp $ 0
684 , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
685 [["A"], ["B"]]
686 }
687 ]
688 }
689 ]
690 ]
691 ]
692 , "Format" ~: TestList
693 [ "Ledger" ~: TestList
694 [ "Read" ~: TestList
695 [ "account_name" ~: TestList
696 [ "\"\" = Left" ~:
697 (Data.Either.rights $
698 [Text.Parsec.runParser
699 (Format.Ledger.Read.account_name <* Text.Parsec.eof)
700 () "" ""])
701 ~?=
702 []
703 , "\"A\" = Right \"A\"" ~:
704 (Data.Either.rights $
705 [Text.Parsec.runParser
706 (Format.Ledger.Read.account_name <* Text.Parsec.eof)
707 () "" "A"])
708 ~?=
709 ["A"]
710 , "\"AA\" = Right \"AA\"" ~:
711 (Data.Either.rights $
712 [Text.Parsec.runParser
713 (Format.Ledger.Read.account_name <* Text.Parsec.eof)
714 () "" "AA"])
715 ~?=
716 ["AA"]
717 , "\" \" = Left" ~:
718 (Data.Either.rights $
719 [Text.Parsec.runParser
720 (Format.Ledger.Read.account_name <* Text.Parsec.eof)
721 () "" " "])
722 ~?=
723 []
724 , "\":\" = Left" ~:
725 (Data.Either.rights $
726 [Text.Parsec.runParser
727 (Format.Ledger.Read.account_name <* Text.Parsec.eof)
728 () "" ":"])
729 ~?=
730 []
731 , "\"A:\" = Left" ~:
732 (Data.Either.rights $
733 [Text.Parsec.runParser
734 (Format.Ledger.Read.account_name <* Text.Parsec.eof)
735 () "" "A:"])
736 ~?=
737 []
738 , "\":A\" = Left" ~:
739 (Data.Either.rights $
740 [Text.Parsec.runParser
741 (Format.Ledger.Read.account_name <* Text.Parsec.eof)
742 () "" ":A"])
743 ~?=
744 []
745 , "\"A \" = Left" ~:
746 (Data.Either.rights $
747 [Text.Parsec.runParser
748 (Format.Ledger.Read.account_name <* Text.Parsec.eof)
749 () "" "A "])
750 ~?=
751 []
752 , "\"A A\" = Right \"A A\"" ~:
753 (Data.Either.rights $
754 [Text.Parsec.runParser
755 (Format.Ledger.Read.account_name <* Text.Parsec.eof)
756 () "" "A A"])
757 ~?=
758 ["A A"]
759 , "\"A \" = Left" ~:
760 (Data.Either.rights $
761 [Text.Parsec.runParser
762 (Format.Ledger.Read.account_name <* Text.Parsec.eof)
763 () "" "A "])
764 ~?=
765 []
766 , "\"A \\n\" = Left" ~:
767 (Data.Either.rights $
768 [Text.Parsec.runParser
769 (Format.Ledger.Read.account_name <* Text.Parsec.eof)
770 () "" "A \n"])
771 ~?=
772 []
773 ]
774 , "account" ~: TestList
775 [ "\"\" = Left" ~:
776 (Data.Either.rights $
777 [Text.Parsec.runParser
778 (Format.Ledger.Read.account <* Text.Parsec.eof)
779 () "" ""])
780 ~?=
781 []
782 , "\"A\" = Right [\"A\"]" ~:
783 (Data.Either.rights $
784 [Text.Parsec.runParser
785 (Format.Ledger.Read.account <* Text.Parsec.eof)
786 () "" "A"])
787 ~?=
788 [["A"]]
789 , "\"A:\" = Left" ~:
790 (Data.Either.rights $
791 [Text.Parsec.runParser
792 (Format.Ledger.Read.account <* Text.Parsec.eof)
793 () "" "A:"])
794 ~?=
795 []
796 , "\":A\" = Left" ~:
797 (Data.Either.rights $
798 [Text.Parsec.runParser
799 (Format.Ledger.Read.account <* Text.Parsec.eof)
800 () "" ":A"])
801 ~?=
802 []
803 , "\"A \" = Left" ~:
804 (Data.Either.rights $
805 [Text.Parsec.runParser
806 (Format.Ledger.Read.account <* Text.Parsec.eof)
807 () "" "A "])
808 ~?=
809 []
810 , "\" A\" = Left" ~:
811 (Data.Either.rights $
812 [Text.Parsec.runParser
813 (Format.Ledger.Read.account <* Text.Parsec.eof)
814 () "" " A"])
815 ~?=
816 []
817 , "\"A:B\" = Right [\"A\", \"B\"]" ~:
818 (Data.Either.rights $
819 [Text.Parsec.runParser
820 (Format.Ledger.Read.account <* Text.Parsec.eof)
821 () "" "A:B"])
822 ~?=
823 [["A", "B"]]
824 , "\"A:B:C\" = Right [\"A\", \"B\", \"C\"]" ~:
825 (Data.Either.rights $
826 [Text.Parsec.runParser
827 (Format.Ledger.Read.account <* Text.Parsec.eof)
828 () "" "A:B:C"])
829 ~?=
830 [["A", "B", "C"]]
831 , "\"Aa:Bbb:Cccc\" = Right [\"Aa\", \"Bbb\", \":Cccc\"]" ~:
832 (Data.Either.rights $
833 [Text.Parsec.runParser
834 (Format.Ledger.Read.account <* Text.Parsec.eof)
835 () "" "Aa:Bbb:Cccc"])
836 ~?=
837 [["Aa", "Bbb", "Cccc"]]
838 , "\"A a : B b b : C c c c\" = Right [\"A a \", \" B b b \", \": C c c c\"]" ~:
839 (Data.Either.rights $
840 [Text.Parsec.runParser
841 (Format.Ledger.Read.account <* Text.Parsec.eof)
842 () "" "A a : B b b : C c c c"])
843 ~?=
844 [["A a ", " B b b ", " C c c c"]]
845 , "\"A: :C\" = Right [\"A\", \" \", \"C\"]" ~:
846 (Data.Either.rights $
847 [Text.Parsec.runParser
848 (Format.Ledger.Read.account <* Text.Parsec.eof)
849 () "" "A: :C"])
850 ~?=
851 [["A", " ", "C"]]
852 , "\"A::C\" = Left" ~:
853 (Data.Either.rights $
854 [Text.Parsec.runParser
855 (Format.Ledger.Read.account <* Text.Parsec.eof)
856 () "" "A::C"])
857 ~?=
858 []
859 ]
860 , "amount" ~: TestList
861 [ "\"\" = Left" ~:
862 (Data.Either.rights $
863 [Text.Parsec.runParser
864 (Format.Ledger.Read.amount <* Text.Parsec.eof)
865 () "" ""])
866 ~?=
867 []
868 , "\"0\" = Right 0" ~:
869 (Data.Either.rights $
870 [Text.Parsec.runParser
871 (Format.Ledger.Read.amount <* Text.Parsec.eof)
872 () "" "0"])
873 ~?=
874 [Amount.nil
875 { Amount.quantity = Data.Decimal.Decimal 0 0
876 }]
877 , "\"00\" = Right 0" ~:
878 (Data.Either.rights $
879 [Text.Parsec.runParser
880 (Format.Ledger.Read.amount <* Text.Parsec.eof)
881 () "" "00"])
882 ~?=
883 [Amount.nil
884 { Amount.quantity = Data.Decimal.Decimal 0 0
885 }]
886 , "\"0.\" = Right 0." ~:
887 (Data.Either.rights $
888 [Text.Parsec.runParser
889 (Format.Ledger.Read.amount <* Text.Parsec.eof)
890 () "" "0."])
891 ~?=
892 [Amount.nil
893 { Amount.quantity = Data.Decimal.Decimal 0 0
894 , Amount.style =
895 Style.nil
896 { Style.fractioning = Just '.'
897 }
898 }]
899 , "\".0\" = Right 0.0" ~:
900 (Data.Either.rights $
901 [Text.Parsec.runParser
902 (Format.Ledger.Read.amount <* Text.Parsec.eof)
903 () "" ".0"])
904 ~?=
905 [Amount.nil
906 { Amount.quantity = Data.Decimal.Decimal 0 0
907 , Amount.style =
908 Style.nil
909 { Style.fractioning = Just '.'
910 , Style.precision = 1
911 }
912 }]
913 , "\"0,\" = Right 0," ~:
914 (Data.Either.rights $
915 [Text.Parsec.runParser
916 (Format.Ledger.Read.amount <* Text.Parsec.eof)
917 () "" "0,"])
918 ~?=
919 [Amount.nil
920 { Amount.quantity = Data.Decimal.Decimal 0 0
921 , Amount.style =
922 Style.nil
923 { Style.fractioning = Just ','
924 }
925 }]
926 , "\",0\" = Right 0,0" ~:
927 (Data.Either.rights $
928 [Text.Parsec.runParser
929 (Format.Ledger.Read.amount <* Text.Parsec.eof)
930 () "" ",0"])
931 ~?=
932 [Amount.nil
933 { Amount.quantity = Data.Decimal.Decimal 0 0
934 , Amount.style =
935 Style.nil
936 { Style.fractioning = Just ','
937 , Style.precision = 1
938 }
939 }]
940 , "\"0_\" = Left" ~:
941 (Data.Either.rights $
942 [Text.Parsec.runParser
943 (Format.Ledger.Read.amount <* Text.Parsec.eof)
944 () "" "0_"])
945 ~?=
946 []
947 , "\"_0\" = Left" ~:
948 (Data.Either.rights $
949 [Text.Parsec.runParser
950 (Format.Ledger.Read.amount <* Text.Parsec.eof)
951 () "" "_0"])
952 ~?=
953 []
954 , "\"0.0\" = Right 0.0" ~:
955 (Data.Either.rights $
956 [Text.Parsec.runParser
957 (Format.Ledger.Read.amount <* Text.Parsec.eof)
958 () "" "0.0"])
959 ~?=
960 [Amount.nil
961 { Amount.quantity = Data.Decimal.Decimal 0 0
962 , Amount.style =
963 Style.nil
964 { Style.fractioning = Just '.'
965 , Style.precision = 1
966 }
967 }]
968 , "\"00.00\" = Right 0.00" ~:
969 (Data.Either.rights $
970 [Text.Parsec.runParser
971 (Format.Ledger.Read.amount <* Text.Parsec.eof)
972 () "" "00.00"])
973 ~?=
974 [Amount.nil
975 { Amount.quantity = Data.Decimal.Decimal 0 0
976 , Amount.style =
977 Style.nil
978 { Style.fractioning = Just '.'
979 , Style.precision = 2
980 }
981 }]
982 , "\"0,0\" = Right 0,0" ~:
983 (Data.Either.rights $
984 [Text.Parsec.runParser
985 (Format.Ledger.Read.amount <* Text.Parsec.eof)
986 () "" "0,0"])
987 ~?=
988 [Amount.nil
989 { Amount.quantity = Data.Decimal.Decimal 0 0
990 , Amount.style =
991 Style.nil
992 { Style.fractioning = Just ','
993 , Style.precision = 1
994 }
995 }]
996 , "\"00,00\" = Right 0,00" ~:
997 (Data.Either.rights $
998 [Text.Parsec.runParser
999 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1000 () "" "00,00"])
1001 ~?=
1002 [Amount.nil
1003 { Amount.quantity = Data.Decimal.Decimal 0 0
1004 , Amount.style =
1005 Style.nil
1006 { Style.fractioning = Just ','
1007 , Style.precision = 2
1008 }
1009 }]
1010 , "\"0_0\" = Right 0" ~:
1011 (Data.Either.rights $
1012 [Text.Parsec.runParser
1013 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1014 () "" "0_0"])
1015 ~?=
1016 [Amount.nil
1017 { Amount.quantity = Data.Decimal.Decimal 0 0
1018 , Amount.style =
1019 Style.nil
1020 { Style.fractioning = Nothing
1021 , Style.grouping_integral = Just $ Style.Grouping '_' [1]
1022 , Style.precision = 0
1023 }
1024 }]
1025 , "\"00_00\" = Right 0" ~:
1026 (Data.Either.rights $
1027 [Text.Parsec.runParser
1028 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1029 () "" "00_00"])
1030 ~?=
1031 [Amount.nil
1032 { Amount.quantity = Data.Decimal.Decimal 0 0
1033 , Amount.style =
1034 Style.nil
1035 { Style.fractioning = Nothing
1036 , Style.grouping_integral = Just $ Style.Grouping '_' [2]
1037 , Style.precision = 0
1038 }
1039 }]
1040 , "\"0,000.00\" = Right 0,000.00" ~:
1041 (Data.Either.rights $
1042 [Text.Parsec.runParser
1043 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1044 () "" "0,000.00"])
1045 ~?=
1046 [Amount.nil
1047 { Amount.quantity = Data.Decimal.Decimal 0 0
1048 , Amount.style =
1049 Style.nil
1050 { Style.fractioning = Just '.'
1051 , Style.grouping_integral = Just $ Style.Grouping ',' [3]
1052 , Style.precision = 2
1053 }
1054 }]
1055 , "\"0.000,00\" = Right 0.000,00" ~:
1056 (Data.Either.rights $
1057 [Text.Parsec.runParser
1058 (Format.Ledger.Read.amount)
1059 () "" "0.000,00"])
1060 ~?=
1061 [Amount.nil
1062 { Amount.quantity = Data.Decimal.Decimal 0 0
1063 , Amount.style =
1064 Style.nil
1065 { Style.fractioning = Just ','
1066 , Style.grouping_integral = Just $ Style.Grouping '.' [3]
1067 , Style.precision = 2
1068 }
1069 }]
1070 , "\"1,000.00\" = Right 1,000.00" ~:
1071 (Data.Either.rights $
1072 [Text.Parsec.runParser
1073 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1074 () "" "1,000.00"])
1075 ~?=
1076 [Amount.nil
1077 { Amount.quantity = Data.Decimal.Decimal 0 1000
1078 , Amount.style =
1079 Style.nil
1080 { Style.fractioning = Just '.'
1081 , Style.grouping_integral = Just $ Style.Grouping ',' [3]
1082 , Style.precision = 2
1083 }
1084 }]
1085 , "\"1.000,00\" = Right 1.000,00" ~:
1086 (Data.Either.rights $
1087 [Text.Parsec.runParser
1088 (Format.Ledger.Read.amount)
1089 () "" "1.000,00"])
1090 ~?=
1091 [Amount.nil
1092 { Amount.quantity = Data.Decimal.Decimal 0 1000
1093 , Amount.style =
1094 Style.nil
1095 { Style.fractioning = Just ','
1096 , Style.grouping_integral = Just $ Style.Grouping '.' [3]
1097 , Style.precision = 2
1098 }
1099 }]
1100 , "\"1,000.00.\" = Left" ~:
1101 (Data.Either.rights $
1102 [Text.Parsec.runParser
1103 (Format.Ledger.Read.amount)
1104 () "" "1,000.00."])
1105 ~?=
1106 []
1107 , "\"1.000,00,\" = Left" ~:
1108 (Data.Either.rights $
1109 [Text.Parsec.runParser
1110 (Format.Ledger.Read.amount)
1111 () "" "1.000,00,"])
1112 ~?=
1113 []
1114 , "\"1,000.00_\" = Left" ~:
1115 (Data.Either.rights $
1116 [Text.Parsec.runParser
1117 (Format.Ledger.Read.amount)
1118 () "" "1,000.00_"])
1119 ~?=
1120 []
1121 , "\"12\" = Right 12" ~:
1122 (Data.Either.rights $
1123 [Text.Parsec.runParser
1124 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1125 () "" "123"])
1126 ~?=
1127 [Amount.nil
1128 { Amount.quantity = Data.Decimal.Decimal 0 123
1129 }]
1130 , "\"1.2\" = Right 1.2" ~:
1131 (Data.Either.rights $
1132 [Text.Parsec.runParser
1133 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1134 () "" "1.2"])
1135 ~?=
1136 [Amount.nil
1137 { Amount.quantity = Data.Decimal.Decimal 1 12
1138 , Amount.style =
1139 Style.nil
1140 { Style.fractioning = Just '.'
1141 , Style.precision = 1
1142 }
1143 }]
1144 , "\"1,2\" = Right 1,2" ~:
1145 (Data.Either.rights $
1146 [Text.Parsec.runParser
1147 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1148 () "" "1,2"])
1149 ~?=
1150 [Amount.nil
1151 { Amount.quantity = Data.Decimal.Decimal 1 12
1152 , Amount.style =
1153 Style.nil
1154 { Style.fractioning = Just ','
1155 , Style.precision = 1
1156 }
1157 }]
1158 , "\"12.23\" = Right 12.23" ~:
1159 (Data.Either.rights $
1160 [Text.Parsec.runParser
1161 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1162 () "" "12.34"])
1163 ~?=
1164 [Amount.nil
1165 { Amount.quantity = Data.Decimal.Decimal 2 1234
1166 , Amount.style =
1167 Style.nil
1168 { Style.fractioning = Just '.'
1169 , Style.precision = 2
1170 }
1171 }]
1172 , "\"12,23\" = Right 12,23" ~:
1173 (Data.Either.rights $
1174 [Text.Parsec.runParser
1175 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1176 () "" "12,34"])
1177 ~?=
1178 [Amount.nil
1179 { Amount.quantity = Data.Decimal.Decimal 2 1234
1180 , Amount.style =
1181 Style.nil
1182 { Style.fractioning = Just ','
1183 , Style.precision = 2
1184 }
1185 }]
1186 , "\"1_2\" = Right 1_2" ~:
1187 (Data.Either.rights $
1188 [Text.Parsec.runParser
1189 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1190 () "" "1_2"])
1191 ~?=
1192 [Amount.nil
1193 { Amount.quantity = Data.Decimal.Decimal 0 12
1194 , Amount.style =
1195 Style.nil
1196 { Style.grouping_integral = Just $ Style.Grouping '_' [1]
1197 , Style.precision = 0
1198 }
1199 }]
1200 , "\"1_23\" = Right 1_23" ~:
1201 (Data.Either.rights $
1202 [Text.Parsec.runParser
1203 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1204 () "" "1_23"])
1205 ~?=
1206 [Amount.nil
1207 { Amount.quantity = Data.Decimal.Decimal 0 123
1208 , Amount.style =
1209 Style.nil
1210 { Style.grouping_integral = Just $ Style.Grouping '_' [2]
1211 , Style.precision = 0
1212 }
1213 }]
1214 , "\"1_23_456\" = Right 1_23_456" ~:
1215 (Data.Either.rights $
1216 [Text.Parsec.runParser
1217 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1218 () "" "1_23_456"])
1219 ~?=
1220 [Amount.nil
1221 { Amount.quantity = Data.Decimal.Decimal 0 123456
1222 , Amount.style =
1223 Style.nil
1224 { Style.grouping_integral = Just $ Style.Grouping '_' [3, 2]
1225 , Style.precision = 0
1226 }
1227 }]
1228 , "\"1_23_456.7890_12345_678901\" = Right 1_23_456.7890_12345_678901" ~:
1229 (Data.Either.rights $
1230 [Text.Parsec.runParser
1231 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1232 () "" "1_23_456.7890_12345_678901"])
1233 ~?=
1234 [Amount.nil
1235 { Amount.quantity = Data.Decimal.Decimal 15 123456789012345678901
1236 , Amount.style =
1237 Style.nil
1238 { Style.fractioning = Just '.'
1239 , Style.grouping_integral = Just $ Style.Grouping '_' [3, 2]
1240 , Style.grouping_fractional = Just $ Style.Grouping '_' [4, 5, 6]
1241 , Style.precision = 15
1242 }
1243 }]
1244 , "\"123456_78901_2345.678_90_1\" = Right 123456_78901_2345.678_90_1" ~:
1245 (Data.Either.rights $
1246 [Text.Parsec.runParser
1247 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1248 () "" "123456_78901_2345.678_90_1"])
1249 ~?=
1250 [Amount.nil
1251 { Amount.quantity = Data.Decimal.Decimal 6 123456789012345678901
1252 , Amount.style =
1253 Style.nil
1254 { Style.fractioning = Just '.'
1255 , Style.grouping_integral = Just $ Style.Grouping '_' [4, 5, 6]
1256 , Style.grouping_fractional = Just $ Style.Grouping '_' [3, 2]
1257 , Style.precision = 6
1258 }
1259 }]
1260 , "\"$1\" = Right $1" ~:
1261 (Data.Either.rights $
1262 [Text.Parsec.runParser
1263 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1264 () "" "$1"])
1265 ~?=
1266 [Amount.nil
1267 { Amount.quantity = Data.Decimal.Decimal 0 1
1268 , Amount.style =
1269 Style.nil
1270 { Style.fractioning = Nothing
1271 , Style.grouping_integral = Nothing
1272 , Style.grouping_fractional = Nothing
1273 , Style.precision = 0
1274 , Style.unit_side = Just Style.Side_Left
1275 , Style.unit_spaced = Just False
1276 }
1277 , Amount.unit = "$"
1278 }]
1279 , "\"1$\" = Right 1$" ~:
1280 (Data.Either.rights $
1281 [Text.Parsec.runParser
1282 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1283 () "" "1$"])
1284 ~?=
1285 [Amount.nil
1286 { Amount.quantity = Data.Decimal.Decimal 0 1
1287 , Amount.style =
1288 Style.nil
1289 { Style.fractioning = Nothing
1290 , Style.grouping_integral = Nothing
1291 , Style.grouping_fractional = Nothing
1292 , Style.precision = 0
1293 , Style.unit_side = Just Style.Side_Right
1294 , Style.unit_spaced = Just False
1295 }
1296 , Amount.unit = "$"
1297 }]
1298 , "\"$ 1\" = Right $ 1" ~:
1299 (Data.Either.rights $
1300 [Text.Parsec.runParser
1301 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1302 () "" "$ 1"])
1303 ~?=
1304 [Amount.nil
1305 { Amount.quantity = Data.Decimal.Decimal 0 1
1306 , Amount.style =
1307 Style.nil
1308 { Style.fractioning = Nothing
1309 , Style.grouping_integral = Nothing
1310 , Style.grouping_fractional = Nothing
1311 , Style.precision = 0
1312 , Style.unit_side = Just Style.Side_Left
1313 , Style.unit_spaced = Just True
1314 }
1315 , Amount.unit = "$"
1316 }]
1317 , "\"1 $\" = Right 1 $" ~:
1318 (Data.Either.rights $
1319 [Text.Parsec.runParser
1320 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1321 () "" "1 $"])
1322 ~?=
1323 [Amount.nil
1324 { Amount.quantity = Data.Decimal.Decimal 0 1
1325 , Amount.style =
1326 Style.nil
1327 { Style.fractioning = Nothing
1328 , Style.grouping_integral = Nothing
1329 , Style.grouping_fractional = Nothing
1330 , Style.precision = 0
1331 , Style.unit_side = Just Style.Side_Right
1332 , Style.unit_spaced = Just True
1333 }
1334 , Amount.unit = "$"
1335 }]
1336 , "\"-$1\" = Right $-1" ~:
1337 (Data.Either.rights $
1338 [Text.Parsec.runParser
1339 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1340 () "" "-$1"])
1341 ~?=
1342 [Amount.nil
1343 { Amount.quantity = Data.Decimal.Decimal 0 (-1)
1344 , Amount.style =
1345 Style.nil
1346 { Style.fractioning = Nothing
1347 , Style.grouping_integral = Nothing
1348 , Style.grouping_fractional = Nothing
1349 , Style.precision = 0
1350 , Style.unit_side = Just Style.Side_Left
1351 , Style.unit_spaced = Just False
1352 }
1353 , Amount.unit = "$"
1354 }]
1355 , "\"\\\"4 2\\\"1\" = Right \\\"4 2\\\"1" ~:
1356 (Data.Either.rights $
1357 [Text.Parsec.runParser
1358 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1359 () "" "\"4 2\"1"])
1360 ~?=
1361 [Amount.nil
1362 { Amount.quantity = Data.Decimal.Decimal 0 1
1363 , Amount.style =
1364 Style.nil
1365 { Style.fractioning = Nothing
1366 , Style.grouping_integral = Nothing
1367 , Style.grouping_fractional = Nothing
1368 , Style.precision = 0
1369 , Style.unit_side = Just Style.Side_Left
1370 , Style.unit_spaced = Just False
1371 }
1372 , Amount.unit = "4 2"
1373 }]
1374 , "\"1\\\"4 2\\\"\" = Right 1\\\"4 2\\\"" ~:
1375 (Data.Either.rights $
1376 [Text.Parsec.runParser
1377 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1378 () "" "1\"4 2\""])
1379 ~?=
1380 [Amount.nil
1381 { Amount.quantity = Data.Decimal.Decimal 0 1
1382 , Amount.style =
1383 Style.nil
1384 { Style.fractioning = Nothing
1385 , Style.grouping_integral = Nothing
1386 , Style.grouping_fractional = Nothing
1387 , Style.precision = 0
1388 , Style.unit_side = Just Style.Side_Right
1389 , Style.unit_spaced = Just False
1390 }
1391 , Amount.unit = "4 2"
1392 }]
1393 , "\"$1.000,00\" = Right $1.000,00" ~:
1394 (Data.Either.rights $
1395 [Text.Parsec.runParser
1396 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1397 () "" "$1.000,00"])
1398 ~?=
1399 [Amount.nil
1400 { Amount.quantity = Data.Decimal.Decimal 0 1000
1401 , Amount.style =
1402 Style.nil
1403 { Style.fractioning = Just ','
1404 , Style.grouping_integral = Just $ Style.Grouping '.' [3]
1405 , Style.grouping_fractional = Nothing
1406 , Style.precision = 2
1407 , Style.unit_side = Just Style.Side_Left
1408 , Style.unit_spaced = Just False
1409 }
1410 , Amount.unit = "$"
1411 }]
1412 , "\"1.000,00$\" = Right 1.000,00$" ~:
1413 (Data.Either.rights $
1414 [Text.Parsec.runParser
1415 (Format.Ledger.Read.amount <* Text.Parsec.eof)
1416 () "" "1.000,00$"])
1417 ~?=
1418 [Amount.nil
1419 { Amount.quantity = Data.Decimal.Decimal 0 1000
1420 , Amount.style =
1421 Style.nil
1422 { Style.fractioning = Just ','
1423 , Style.grouping_integral = Just $ Style.Grouping '.' [3]
1424 , Style.grouping_fractional = Nothing
1425 , Style.precision = 2
1426 , Style.unit_side = Just Style.Side_Right
1427 , Style.unit_spaced = Just False
1428 }
1429 , Amount.unit = "$"
1430 }]
1431 ]
1432 ]
1433 ]
1434 ]
1435 ]
A language for accounting