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