Data/TreeMap/Strict/Test.hs

   1 {-# LANGUAGE NamedFieldPuns #-}
   2 {-# LANGUAGE OverloadedStrings #-}
   3 {-# LANGUAGE ScopedTypeVariables #-}
   4 {-# LANGUAGE TupleSections #-}
   5 module Strict.Test where
   6
   7 import Data.Function (($), id, const)
   8 import Data.Int (Int)
   9 import qualified Data.Map.Strict as Map
  10 import Data.Monoid ((<>))
  11 import qualified Data.Strict.Maybe as Strict
  12 import Prelude (Integer, undefined)
  13 import Test.Tasty
  14 import Test.Tasty.HUnit
  15
  16 import Data.TreeMap.Strict ((<|))
  17 import qualified Data.TreeMap.Strict as TreeMap
  18
  19
  20 tests :: TestTree
  21 tests = testGroup "Strict"
  22  [ testGroup "insert"
  23          [ testCase "[] 0" $
  24                         TreeMap.insert const ((0::Int)<|[]) () TreeMap.empty
  25                  @?= (TreeMap.TreeMap $ Map.fromList [ (0::Int, TreeMap.leaf ()) ])
  26          , testCase "[] 0/1" $
  27                         TreeMap.insert const ((0::Int)<|[1]) () TreeMap.empty
  28                  @?=
  29                         (TreeMap.TreeMap $
  30                         Map.fromList
  31                          [ (0::Int, TreeMap.Node
  32                                  { TreeMap.node_value = Strict.Nothing
  33                                  , TreeMap.node_size = 1
  34                                  , TreeMap.node_descendants =
  35                                         TreeMap.singleton ((1::Int)<|[]) ()
  36                                  })
  37                          ])
  38          ]
  39  , testGroup "map_by_depth_first"
  40          [ testCase "[0, 0/1, 0/1/2, 1, 1/2/3]" $
  41                         TreeMap.map_by_depth_first
  42                          (\descendants value ->
  43                                 Map.foldl'
  44                                  (\acc v -> (<>) acc $
  45                                         Strict.fromMaybe undefined $
  46                                         TreeMap.node_value v
  47                                  )
  48                                  (Strict.fromMaybe [] value)
  49                                  (TreeMap.nodes descendants)
  50                          )
  51                         (TreeMap.from_List const
  52                          [ ((0::Integer)<|[], [0::Integer])
  53                          , (0<|[1], [0,1])
  54                          , (0<|[1,2], [0,1,2])
  55                          , (1<|[], [1])
  56                          , (1<|[2,3], [1,2,3])
  57                          ])
  58                  @?=
  59                         TreeMap.from_List const
  60                          [ ((0::Integer)<|[], [0,0,1,0,1,2])
  61                          , (0<|[1], [0,1,0,1,2])
  62                          , (0<|[1,2], [0,1,2])
  63                          , (1<|[], [1,1,2,3])
  64                          , (1<|[2], [1,2,3])
  65                          , (1<|[2,3], [1,2,3])
  66                          ]
  67          , testCase "[0/0]" $
  68                         TreeMap.map_by_depth_first
  69                          (\descendants value ->
  70                                 Map.foldl'
  71                                  (\acc v -> (<>) acc $
  72                                         Strict.fromMaybe undefined $
  73                                         TreeMap.node_value v
  74                                  )
  75                                  (Strict.fromMaybe [] value)
  76                                  (TreeMap.nodes descendants)
  77                          )
  78                         (TreeMap.from_List const
  79                          [ ((0::Integer)<|[0], [0::Integer,0])
  80                          ])
  81                  @?=
  82                         TreeMap.from_List const
  83                          [ ((0::Integer)<|[], [0,0])
  84                          , (0<|[0], [0,0])
  85                          ]
  86          ]
  87  , testGroup "flatten"
  88          [ testCase "[0, 0/1, 0/1/2]" $
  89                         TreeMap.flatten id
  90                         (TreeMap.from_List const
  91                          [ ((0::Integer)<|[], ())
  92                          , (0<|[1], ())
  93                          , (0<|[1,2], ())
  94                          ])
  95                  @?=
  96                         Map.fromList
  97                          [ ((0::Integer)<|[], ())
  98                          , (0<|[1], ())
  99                          , (0<|[1,2], ())
 100                          ]
 101          , testCase "[1, 1/2, 1/22, 1/2/3, 1/2/33, 11, 11/2, 11/2/3, 11/2/33]" $
 102                         TreeMap.flatten id
 103                         (TreeMap.from_List const
 104                          [ ((1::Integer)<|[], ())
 105                          , (1<|[2], ())
 106                          , (1<|[22], ())
 107                          , (1<|[2,3], ())
 108                          , (1<|[2,33], ())
 109                          , (11<|[], ())
 110                          , (11<|[2], ())
 111                          , (11<|[2,3], ())
 112                          , (11<|[2,33], ())
 113                          ])
 114                  @?=
 115                         Map.fromList
 116                          [ ((1::Integer)<|[], ())
 117                          , (1<|[2], ())
 118                          , (1<|[22], ())
 119                          , (1<|[2,3], ())
 120                          , (1<|[2,33], ())
 121                          , (11<|[], ())
 122                          , (11<|[2], ())
 123                          , (11<|[2,3], ())
 124                          , (11<|[2,33], ())
 125                          ]
 126          ]
 127  , testGroup "find_along"
 128          [ testCase "0/1/2/3 [0, 0/1, 0/1/2, 0/1/2/3]" $
 129                         TreeMap.find_along
 130                          (0<|[1,2,3])
 131                         (TreeMap.from_List const
 132                          [ ((0::Integer)<|[], [0])
 133                          , (0<|[1], [0,1])
 134                          , (0<|[1,2], [0,1,2])
 135                          , (0<|[1,2,3], [0,1,2,3])
 136                          ])
 137                  @?=
 138                         [ [0::Integer]
 139                         , [0,1]
 140                         , [0,1,2]
 141                         , [0,1,2,3]
 142                         ]
 143          , testCase "0/1/2/3 [0, 0/1]" $
 144                         TreeMap.find_along
 145                          (0<|[1,2,3])
 146                         (TreeMap.from_List const
 147                          [ ((0::Integer)<|[], [0])
 148                          , (0<|[1], [0,1])
 149                          ])
 150                  @?=
 151                         [ [0::Integer]
 152                         , [0,1]
 153                         ]
 154          ]
 155  ]