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 qualified Data.List
   9 import qualified Data.Map
  10
  11 import qualified Hcompta.Model as Model
  12 import qualified Hcompta.Model.Account as Account
  13 import qualified Hcompta.Model.Amount as Amount
  14 import qualified Hcompta.Model.Amount.Quantity as Quantity
  15 import qualified Hcompta.Model.Transaction as Transaction
  16 import qualified Hcompta.Model.Transaction.Posting as Posting
  17 import           Hcompta.Model.Transaction.Posting (Posting)
  18 import qualified Hcompta.Calc         as Calc
  19 import qualified Hcompta.Calc.Balance as Calc.Balance
  20
  21 main :: IO ()
  22 main = defaultMain $ hUnitTestToTests test_Hcompta
  23
  24 test_Hcompta :: Test
  25 test_Hcompta =
  26         TestList
  27          [ "Model" ~: TestList
  28                  [ "Account" ~: TestList
  29                          [ "fold" ~: TestList
  30                                  [ "[] = []" ~:
  31                                         (reverse $ Account.fold [] (:) []) ~?= []
  32                                  , "[A] = [[A]]" ~:
  33                                         (reverse $ Account.fold ["A"] (:) []) ~?= [["A"]]
  34                                  , "[A, B] = [[A], [A, B]]" ~:
  35                                         (reverse $ Account.fold ["A", "B"] (:) []) ~?= [["A"], ["A", "B"]]
  36                                  , "[A, B, C] = [[A], [A, B], [A, B, C]]" ~:
  37                                         (reverse $ Account.fold ["A", "B", "C"] (:) []) ~?= [["A"], ["A", "B"], ["A", "B", "C"]]
  38                                  ]
  39                          , "chomp" ~: TestList
  40                                  [ "[] = []" ~:
  41                                         Account.chomp [] ~?= []
  42                                  , "[A] = []" ~:
  43                                         Account.chomp ["A"] ~?= []
  44                                  , "[A, B] = [A]" ~:
  45                                         Account.chomp ["A", "B"] ~?= ["A"]
  46                                  , "[A, B, C] = [A, B]" ~:
  47                                         Account.chomp ["A", "B", "C"] ~?= ["A", "B"]
  48                                  ]
  49                          ]
  50                  ]
  51          , "Calc" ~: TestList
  52                  [ "Balance" ~: TestList
  53                          [ "posting" ~: TestList
  54                                  [ "[A+$1] = A+$1 & $+1" ~:
  55                                          (Calc.Balance.posting
  56                                                  Posting.nil
  57                                                          { Posting.account=["A"]
  58                                                          , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
  59                                                          }
  60                                                  Calc.Balance.nil)
  61                                          ~?=
  62                                          Calc.Balance.Balance
  63                                                  { Calc.Balance.by_account =
  64                                                         Data.Map.fromList
  65                                                          [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
  66                                                  , Calc.Balance.by_unit =
  67                                                         Data.Map.fromList $
  68                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
  69                                                         [ Calc.Balance.Sum_by_Unit
  70                                                          { Calc.Balance.amount = Amount.usd $ 1
  71                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
  72                                                                  [["A"]]
  73                                                          }
  74                                                         ]
  75                                                  }
  76                                  , "[A+$1, A-$1] = {A+$0, $+0}" ~:
  77                                          (Data.List.foldl
  78                                                  (flip Calc.Balance.posting)
  79                                                  Calc.Balance.nil
  80                                                  [ Posting.nil
  81                                                          { Posting.account=["A"]
  82                                                          , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
  83                                                          }
  84                                                  , Posting.nil
  85                                                          { Posting.account=["A"]
  86                                                          , Posting.amounts=Amount.from_List [ Amount.usd $ -1 ]
  87                                                          }
  88                                                  ])
  89                                          ~?=
  90                                          Calc.Balance.Balance
  91                                                  { Calc.Balance.by_account =
  92                                                         Data.Map.fromList
  93                                                          [ (["A"], Amount.from_List [ Amount.usd $ 0 ]) ]
  94                                                  , Calc.Balance.by_unit =
  95                                                         Data.Map.fromList $
  96                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
  97                                                         [ Calc.Balance.Sum_by_Unit
  98                                                          { Calc.Balance.amount = Amount.usd $ 0
  99                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 100                                                                  [["A"]]
 101                                                          }
 102                                                         ]
 103                                                  }
 104                                  , "[A+$1, A-€1] = {A+$1-€1, $+1 €-1}" ~:
 105                                          (Data.List.foldl
 106                                                  (flip Calc.Balance.posting)
 107                                                  Calc.Balance.nil
 108                                                  [ Posting.nil
 109                                                          { Posting.account=["A"]
 110                                                          , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
 111                                                          }
 112                                                  , Posting.nil
 113                                                          { Posting.account=["A"]
 114                                                          , Posting.amounts=Amount.from_List [ Amount.eur $ -1 ]
 115                                                          }
 116                                                  ])
 117                                          ~?=
 118                                          Calc.Balance.Balance
 119                                                  { Calc.Balance.by_account =
 120                                                         Data.Map.fromList
 121                                                          [ (["A"], Amount.from_List [ Amount.usd $ 1, Amount.eur $ -1 ]) ]
 122                                                  , Calc.Balance.by_unit =
 123                                                         Data.Map.fromList $
 124                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 125                                                         [ Calc.Balance.Sum_by_Unit
 126                                                          { Calc.Balance.amount = Amount.usd $ 1
 127                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 128                                                                  [["A"]]
 129                                                          }
 130                                                         , Calc.Balance.Sum_by_Unit
 131                                                          { Calc.Balance.amount = Amount.eur $ -1
 132                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 133                                                                  [["A"]]
 134                                                          }
 135                                                         ]
 136                                                  }
 137                                  , "[A+$1, B-$1] = {A+$1 B-$1, $+0}" ~:
 138                                          (Data.List.foldl
 139                                                  (flip Calc.Balance.posting)
 140                                                  Calc.Balance.nil
 141                                                  [ Posting.nil
 142                                                          { Posting.account=["A"]
 143                                                          , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
 144                                                          }
 145                                                  , Posting.nil
 146                                                          { Posting.account=["B"]
 147                                                          , Posting.amounts=Amount.from_List [ Amount.usd $ -1 ]
 148                                                          }
 149                                                  ])
 150                                          ~?=
 151                                          Calc.Balance.Balance
 152                                                  { Calc.Balance.by_account =
 153                                                         Data.Map.fromList
 154                                                          [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
 155                                                          , (["B"], Amount.from_List [ Amount.usd $ -1 ])
 156                                                          ]
 157                                                  , Calc.Balance.by_unit =
 158                                                         Data.Map.fromList $
 159                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 160                                                         [ Calc.Balance.Sum_by_Unit
 161                                                          { Calc.Balance.amount = Amount.usd $ 0
 162                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 163                                                                  [["A"], ["B"]]
 164                                                          }
 165                                                         ]
 166                                                  }
 167                                  , "[A+$1+€2, A-$1-€2] = {A+$0+€0, $+0 €+0}" ~:
 168                                          (Data.List.foldl
 169                                                  (flip Calc.Balance.posting)
 170                                                  Calc.Balance.nil
 171                                                  [ Posting.nil
 172                                                          { Posting.account=["A"]
 173                                                          , Posting.amounts=Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2 ]
 174                                                          }
 175                                                  , Posting.nil
 176                                                          { Posting.account=["A"]
 177                                                          , Posting.amounts=Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2 ]
 178                                                          }
 179                                                  ])
 180                                          ~?=
 181                                          Calc.Balance.Balance
 182                                                  { Calc.Balance.by_account =
 183                                                         Data.Map.fromList
 184                                                          [ (["A"], Amount.from_List [ Amount.usd $ 0, Amount.eur $ 0 ])
 185                                                          ]
 186                                                  , Calc.Balance.by_unit =
 187                                                         Data.Map.fromList $
 188                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 189                                                         [ Calc.Balance.Sum_by_Unit
 190                                                          { Calc.Balance.amount = Amount.usd $ 0
 191                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 192                                                                  [["A"]]
 193                                                          }
 194                                                         , Calc.Balance.Sum_by_Unit
 195                                                          { Calc.Balance.amount = Amount.eur $ 0
 196                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 197                                                                  [["A"]]
 198                                                          }
 199                                                         ]
 200                                                  }
 201                                  , "[A+$1+€2+£3, B-$1-2€-£3] = {A+$1+€2+£3 B-$1-€2-£3, $+0 €+0 £+0}" ~:
 202                                          (Data.List.foldl
 203                                                  (flip Calc.Balance.posting)
 204                                                  Calc.Balance.nil
 205                                                  [ Posting.nil
 206                                                          { Posting.account=["A"]
 207                                                          , Posting.amounts=Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2, Amount.gbp $ 3 ]
 208                                                          }
 209                                                  , Posting.nil
 210                                                          { Posting.account=["B"]
 211                                                          , Posting.amounts=Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ]
 212                                                          }
 213                                                  ])
 214                                          ~?=
 215                                          Calc.Balance.Balance
 216                                                  { Calc.Balance.by_account =
 217                                                         Data.Map.fromList
 218                                                          [ (["A"], Amount.from_List [ Amount.usd $  1, Amount.eur $  2, Amount.gbp $  3 ])
 219                                                          , (["B"], Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ])
 220                                                          ]
 221                                                  , Calc.Balance.by_unit =
 222                                                         Data.Map.fromList $
 223                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 224                                                         [ Calc.Balance.Sum_by_Unit
 225                                                          { Calc.Balance.amount = Amount.usd $ 0
 226                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 227                                                                  [["A"], ["B"]]
 228                                                          }
 229                                                         , Calc.Balance.Sum_by_Unit
 230                                                          { Calc.Balance.amount = Amount.eur $ 0
 231                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 232                                                                  [["A"], ["B"]]
 233                                                          }
 234                                                         , Calc.Balance.Sum_by_Unit
 235                                                          { Calc.Balance.amount = Amount.gbp $ 0
 236                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 237                                                                  [["A"], ["B"]]
 238                                                          }
 239                                                         ]
 240                                                  }
 241                                  ]
 242                          , "union" ~: TestList
 243                                  [ "nil nil = nil" ~:
 244                                          Calc.Balance.union
 245                                                  Calc.Balance.nil
 246                                                  Calc.Balance.nil
 247                                          ~?=
 248                                          Calc.Balance.nil
 249                                  , "{A+$1, $+1} {A+$1, $+1} = {A+$2, $+2}" ~:
 250                                          Calc.Balance.union
 251                                                  (Calc.Balance.Balance
 252                                                          { Calc.Balance.by_account =
 253                                                                 Data.Map.fromList
 254                                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
 255                                                          , Calc.Balance.by_unit =
 256                                                                 Data.Map.fromList $
 257                                                                 Data.List.map Calc.Balance.assoc_by_amount_unit $
 258                                                                 [ Calc.Balance.Sum_by_Unit
 259                                                                  { Calc.Balance.amount = Amount.usd $ 1
 260                                                                  , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 261                                                                          [["A"]]
 262                                                                  }
 263                                                                 ]
 264                                                          })
 265                                                  (Calc.Balance.Balance
 266                                                          { Calc.Balance.by_account =
 267                                                                 Data.Map.fromList
 268                                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
 269                                                          , Calc.Balance.by_unit =
 270                                                                 Data.Map.fromList $
 271                                                                 Data.List.map Calc.Balance.assoc_by_amount_unit $
 272                                                                 [ Calc.Balance.Sum_by_Unit
 273                                                                  { Calc.Balance.amount = Amount.usd $ 1
 274                                                                  , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 275                                                                          [["A"]]
 276                                                                  }
 277                                                                 ]
 278                                                          })
 279                                          ~?=
 280                                          Calc.Balance.Balance
 281                                                  { Calc.Balance.by_account =
 282                                                         Data.Map.fromList
 283                                                          [ (["A"], Amount.from_List [ Amount.usd $ 2 ]) ]
 284                                                  , Calc.Balance.by_unit =
 285                                                         Data.Map.fromList $
 286                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 287                                                         [ Calc.Balance.Sum_by_Unit
 288                                                          { Calc.Balance.amount = Amount.usd $ 2
 289                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 290                                                                  [["A"]]
 291                                                          }
 292                                                         ]
 293                                                  }
 294                                  , "{A+$1, $+1} {B+$1, $+1} = {A+$1 B+$1, $+2}" ~:
 295                                          Calc.Balance.union
 296                                                  (Calc.Balance.Balance
 297                                                          { Calc.Balance.by_account =
 298                                                                 Data.Map.fromList
 299                                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
 300                                                          , Calc.Balance.by_unit =
 301                                                                 Data.Map.fromList $
 302                                                                 Data.List.map Calc.Balance.assoc_by_amount_unit $
 303                                                                 [ Calc.Balance.Sum_by_Unit
 304                                                                  { Calc.Balance.amount = Amount.usd $ 1
 305                                                                  , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 306                                                                          [["A"]]
 307                                                                  }
 308                                                                 ]
 309                                                          })
 310                                                  (Calc.Balance.Balance
 311                                                          { Calc.Balance.by_account =
 312                                                                 Data.Map.fromList
 313                                                                  [ (["B"], Amount.from_List [ Amount.usd $ 1 ]) ]
 314                                                          , Calc.Balance.by_unit =
 315                                                                 Data.Map.fromList $
 316                                                                 Data.List.map Calc.Balance.assoc_by_amount_unit $
 317                                                                 [ Calc.Balance.Sum_by_Unit
 318                                                                  { Calc.Balance.amount = Amount.usd $ 1
 319                                                                  , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 320                                                                          [["B"]]
 321                                                                  }
 322                                                                 ]
 323                                                          })
 324                                          ~?=
 325                                          Calc.Balance.Balance
 326                                                  { Calc.Balance.by_account =
 327                                                         Data.Map.fromList
 328                                                          [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
 329                                                          , (["B"], Amount.from_List [ Amount.usd $ 1 ]) ]
 330                                                  , Calc.Balance.by_unit =
 331                                                         Data.Map.fromList $
 332                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 333                                                         [ Calc.Balance.Sum_by_Unit
 334                                                          { Calc.Balance.amount = Amount.usd $ 2
 335                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 336                                                                  [["A"], ["B"]]
 337                                                          }
 338                                                         ]
 339                                                  }
 340                                  , "{A+$1, $+1} {B+€1, €+1} = {A+$1 B+€1, $+1 €+1}" ~:
 341                                          Calc.Balance.union
 342                                                  (Calc.Balance.Balance
 343                                                          { Calc.Balance.by_account =
 344                                                                 Data.Map.fromList
 345                                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
 346                                                          , Calc.Balance.by_unit =
 347                                                                 Data.Map.fromList $
 348                                                                 Data.List.map Calc.Balance.assoc_by_amount_unit $
 349                                                                 [ Calc.Balance.Sum_by_Unit
 350                                                                  { Calc.Balance.amount = Amount.usd $ 1
 351                                                                  , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 352                                                                          [["A"]]
 353                                                                  }
 354                                                                 ]
 355                                                          })
 356                                                  (Calc.Balance.Balance
 357                                                          { Calc.Balance.by_account =
 358                                                                 Data.Map.fromList
 359                                                                  [ (["B"], Amount.from_List [ Amount.eur $ 1 ]) ]
 360                                                          , Calc.Balance.by_unit =
 361                                                                 Data.Map.fromList $
 362                                                                 Data.List.map Calc.Balance.assoc_by_amount_unit $
 363                                                                 [ Calc.Balance.Sum_by_Unit
 364                                                                  { Calc.Balance.amount = Amount.eur $ 1
 365                                                                  , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 366                                                                          [["B"]]
 367                                                                  }
 368                                                                 ]
 369                                                          })
 370                                          ~?=
 371                                          Calc.Balance.Balance
 372                                                  { Calc.Balance.by_account =
 373                                                         Data.Map.fromList
 374                                                          [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
 375                                                          , (["B"], Amount.from_List [ Amount.eur $ 1 ]) ]
 376                                                  , Calc.Balance.by_unit =
 377                                                         Data.Map.fromList $
 378                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 379                                                         [ Calc.Balance.Sum_by_Unit
 380                                                          { Calc.Balance.amount = Amount.usd $ 1
 381                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 382                                                                  [["A"]]
 383                                                          }
 384                                                         , Calc.Balance.Sum_by_Unit
 385                                                          { Calc.Balance.amount = Amount.eur $ 1
 386                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 387                                                                  [["B"]]
 388                                                          }
 389                                                         ]
 390                                                  }
 391                                  ]
 392                          , "expand" ~: TestList
 393                                  [ "nil_By_Account = nil_By_Account" ~:
 394                                          Calc.Balance.expand
 395                                                  Calc.Balance.nil_By_Account
 396                                          ~?=
 397                                          (Calc.Balance.Expanded $
 398                                                 Calc.Balance.nil_By_Account)
 399                                  , "A+$1 = A+$1" ~:
 400                                          Calc.Balance.expand
 401                                                 (Data.Map.fromList
 402                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ])
 403                                          ~?=
 404                                          (Calc.Balance.Expanded $
 405                                                 Data.Map.fromList
 406                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ])
 407                                  , "A/A+$1 = A+$1 A/A+$1" ~:
 408                                          Calc.Balance.expand
 409                                                 (Data.Map.fromList
 410                                                  [ (["A", "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"], Amount.from_List [ Amount.usd $ 1 ]) ])
 416                                  , "A/B+$1 = A+$1 A/B+$1" ~:
 417                                          Calc.Balance.expand
 418                                                 (Data.Map.fromList
 419                                                  [ (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
 420                                          ~?=
 421                                          (Calc.Balance.Expanded $
 422                                                 Data.Map.fromList
 423                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
 424                                                  , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
 425                                  , "A/B/C+$1 = A+$1 A/B+$1 A/B/C+$1" ~:
 426                                          Calc.Balance.expand
 427                                                 (Data.Map.fromList
 428                                                  [ (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ]) ])
 429                                          ~?=
 430                                          (Calc.Balance.Expanded $
 431                                                 Data.Map.fromList
 432                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
 433                                                  , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
 434                                                  , (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ]) ])
 435                                  , "A+$1 A/B+$1 = A+$2 A/B+$1" ~:
 436                                          Calc.Balance.expand
 437                                                 (Data.Map.fromList
 438                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
 439                                                  , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
 440                                          ~?=
 441                                          (Calc.Balance.Expanded $
 442                                                 Data.Map.fromList
 443                                                  [ (["A"], Amount.from_List [ Amount.usd $ 2 ])
 444                                                  , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
 445                                  , "A+$1 A/B+$1 B/A+$1 = A+$2 A/B+$1 B/A+$1" ~:
 446                                          Calc.Balance.expand
 447                                                 (Data.Map.fromList
 448                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
 449                                                  , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
 450                                                  , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
 451                                          ~?=
 452                                          (Calc.Balance.Expanded $
 453                                                 Data.Map.fromList
 454                                                  [ (["A"], Amount.from_List [ Amount.usd $ 2 ])
 455                                                  , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
 456                                                  , (["B"], Amount.from_List [ Amount.usd $ 1 ])
 457                                                  , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
 458                                  , "A+$1 A/B+$1 B/A+$1 = A+$2 A/B+$1 B/A+$1" ~:
 459                                          Calc.Balance.expand
 460                                                 (Data.Map.fromList
 461                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
 462                                                  , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
 463                                                  , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
 464                                          ~?=
 465                                          (Calc.Balance.Expanded $
 466                                                 Data.Map.fromList
 467                                                  [ (["A"], Amount.from_List [ Amount.usd $ 2 ])
 468                                                  , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
 469                                                  , (["B"], Amount.from_List [ Amount.usd $ 1 ])
 470                                                  , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
 471                                  ]
 472                          , "is_equilibrated" ~: TestList
 473                                  [ "nil = True" ~: TestCase $
 474                                                 (@=?) True $
 475                                                 Calc.Balance.is_equilibrated $
 476                                                 Calc.Balance.nil
 477                                  , "{A+$0, $+0} = True" ~: TestCase $
 478                                                 (@=?) True $
 479                                                 Calc.Balance.is_equilibrated $
 480                                                 Calc.Balance.Balance
 481                                                  { Calc.Balance.by_account =
 482                                                         Data.Map.fromList
 483                                                          [ (["A"], Amount.from_List [ Amount.usd $ 0 ])
 484                                                          ]
 485                                                  , Calc.Balance.by_unit =
 486                                                         Data.Map.fromList $
 487                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 488                                                         [ Calc.Balance.Sum_by_Unit
 489                                                          { Calc.Balance.amount = Amount.usd $ 0
 490                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 491                                                                  [["A"]]
 492                                                          }
 493                                                         ]
 494                                                  }
 495                                  , "{A+$1, $+1} = False" ~: TestCase $
 496                                                 (@=?) False $
 497                                                 Calc.Balance.is_equilibrated $
 498                                                 Calc.Balance.Balance
 499                                                  { Calc.Balance.by_account =
 500                                                         Data.Map.fromList
 501                                                          [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
 502                                                          ]
 503                                                  , Calc.Balance.by_unit =
 504                                                         Data.Map.fromList $
 505                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 506                                                         [ Calc.Balance.Sum_by_Unit
 507                                                          { Calc.Balance.amount = Amount.usd $ 1
 508                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 509                                                                  [["A"]]
 510                                                          }
 511                                                         ]
 512                                                  }
 513                                  , "{A+$0+€0, $0 €+0} = True" ~: TestCase $
 514                                                 (@=?) True $
 515                                                 Calc.Balance.is_equilibrated $
 516                                                 Calc.Balance.Balance
 517                                                  { Calc.Balance.by_account =
 518                                                         Data.Map.fromList
 519                                                          [ (["A"], Amount.from_List [ Amount.usd $ 0, Amount.eur $ 0 ])
 520                                                          ]
 521                                                  , Calc.Balance.by_unit =
 522                                                         Data.Map.fromList $
 523                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 524                                                         [ Calc.Balance.Sum_by_Unit
 525                                                          { Calc.Balance.amount = Amount.usd $ 0
 526                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 527                                                                  [["A"]]
 528                                                          }
 529                                                         , Calc.Balance.Sum_by_Unit
 530                                                          { Calc.Balance.amount = Amount.eur $ 0
 531                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 532                                                                  [["A"]]
 533                                                          }
 534                                                         ]
 535                                                  }
 536                                  , "{A+$1, B-$1, $+0} = True" ~: TestCase $
 537                                                 (@=?) True $
 538                                                 Calc.Balance.is_equilibrated $
 539                                                 Calc.Balance.Balance
 540                                                  { Calc.Balance.by_account =
 541                                                         Data.Map.fromList
 542                                                          [ (["A"], Amount.from_List [ Amount.usd $  1 ])
 543                                                          , (["B"], Amount.from_List [ Amount.usd $ -1 ])
 544                                                          ]
 545                                                  , Calc.Balance.by_unit =
 546                                                         Data.Map.fromList $
 547                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 548                                                         [ Calc.Balance.Sum_by_Unit
 549                                                          { Calc.Balance.amount = Amount.usd $ 0
 550                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 551                                                                  [["A"], ["B"]]
 552                                                          }
 553                                                         ]
 554                                                  }
 555                                  , "{A+$1 B, $+1} = True" ~: TestCase $
 556                                                 (@=?) True $
 557                                                 Calc.Balance.is_equilibrated $
 558                                                  Calc.Balance.Balance
 559                                                          { Calc.Balance.by_account =
 560                                                                 Data.Map.fromList
 561                                                                  [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
 562                                                                  , (["B"], Amount.from_List [])
 563                                                                  ]
 564                                                          , Calc.Balance.by_unit =
 565                                                                 Data.Map.fromList $
 566                                                                 Data.List.map Calc.Balance.assoc_by_amount_unit $
 567                                                                 [ Calc.Balance.Sum_by_Unit
 568                                                                  { Calc.Balance.amount = Amount.usd $ 1
 569                                                                  , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 570                                                                          [["A"]]
 571                                                                  }
 572                                                                 ]
 573                                                          }
 574                                  , "{A+$1 B+€1, $+1 €+1} = 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.eur $ 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 $ 1
 588                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 589                                                                  [["A"]]
 590                                                          }
 591                                                         , Calc.Balance.Sum_by_Unit
 592                                                          { Calc.Balance.amount = Amount.eur $ 1
 593                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 594                                                                  [["B"]]
 595                                                          }
 596                                                         ]
 597                                                  }
 598                                  , "{A+$1 B-$1+€1, $+0 €+1} = True" ~: TestCase $
 599                                                 (@=?) True $
 600                                                 Calc.Balance.is_equilibrated $
 601                                                 Calc.Balance.Balance
 602                                                  { Calc.Balance.by_account =
 603                                                         Data.Map.fromList
 604                                                          [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
 605                                                          , (["B"], Amount.from_List [ Amount.usd $ -1, Amount.eur $ 1 ])
 606                                                          ]
 607                                                  , Calc.Balance.by_unit =
 608                                                         Data.Map.fromList $
 609                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 610                                                         [ Calc.Balance.Sum_by_Unit
 611                                                          { Calc.Balance.amount = Amount.usd $ 0
 612                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 613                                                                  [["A"], ["B"]]
 614                                                          }
 615                                                         , Calc.Balance.Sum_by_Unit
 616                                                          { Calc.Balance.amount = Amount.eur $ 1
 617                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 618                                                                  [["B"]]
 619                                                          }
 620                                                         ]
 621                                                  }
 622                                  , "{A+$1+€2+£3 B-$1-€2-£3, $+0 €+0 £+0} = True" ~: TestCase $
 623                                                 (@=?) True $
 624                                                 Calc.Balance.is_equilibrated $
 625                                                 Calc.Balance.Balance
 626                                                  { Calc.Balance.by_account =
 627                                                         Data.Map.fromList
 628                                                          [ (["A"], Amount.from_List [ Amount.usd $  1, Amount.eur $  2, Amount.gbp $  3 ])
 629                                                          , (["B"], Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ])
 630                                                          ]
 631                                                  , Calc.Balance.by_unit =
 632                                                         Data.Map.fromList $
 633                                                         Data.List.map Calc.Balance.assoc_by_amount_unit $
 634                                                         [ Calc.Balance.Sum_by_Unit
 635                                                          { Calc.Balance.amount = Amount.usd $ 0
 636                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 637                                                                  [["A"], ["B"]]
 638                                                          }
 639                                                         , Calc.Balance.Sum_by_Unit
 640                                                          { Calc.Balance.amount = Amount.eur $ 0
 641                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 642                                                                  [["A"], ["B"]]
 643                                                          }
 644                                                         , Calc.Balance.Sum_by_Unit
 645                                                          { Calc.Balance.amount = Amount.gbp $ 0
 646                                                          , Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
 647                                                                  [["A"], ["B"]]
 648                                                          }
 649                                                         ]
 650                                                  }
 651                                  ]
 652                          ]
 653                  ]
 654          ]