phi

module Test.Data.Map where


import Test.QuickCheck (TestGroup(..), TestResult, quickCheck)
import Prelude
import Data.Map as M

propMapPutGet :: M.Map Integer String -> Integer -> String -> Boolean
propMapPutGet m k v = let m1 = M.put k v m
                          v1 = M.get k m1
                      in v == v1

propMapPutMember :: M.Map Integer String -> Integer -> String -> Boolean
propMapPutMember m k v = let m1 = M.put k v m
                      in M.member k m1

propMapFilter :: M.Map Integer Integer -> Integer -> Boolean
propMapFilter m v = let m1 = M.filter (\(k,_) -> k > v) m
                        vs = map (\k -> k > v) $ map fst $  M.toList m1
                    in foldl (&&) true vs


propMapMerge :: M.Map Integer Integer -> Boolean
propMapMerge m1 = M.merge m1 m1 == m1

propMapFTList :: M.Map Integer Integer -> Boolean
propMapFTList m = M.fromList (M.toList m) == m

propMapMap :: M.Map Integer Integer -> (Integer -> Integer) -> Boolean
propMapMap m1 f = let l1 = M.toList m1
                      lf = \(k,v) -> (k, f v)
                      lf1 = \(k,v) -> f v
                  in M.fromList (map lf l1) == M.mapWithKey lf1 m1

propInsert :: M.Map Integer Integer -> Integer -> Integer -> Boolean
propInsert m k v = M.insert k v m == M.insert k v (M.insert k v m)

propEq :: M.Map Integer Integer -> Boolean
propEq x = x == x

baseMap :: M.Map Integer Integer
baseMap = M.fromList [(1,2),(2,3),(3,4)]

test :: TestGroup (Integer -> IO TestResult)
test = Exe [ quickCheck "put_get "     propMapPutGet
           , quickCheck "put_member "  propMapPutMember
           , quickCheck "map "        propMapMap
           , quickCheck "isEmpty_empty" (M.isEmpty M.empty)
           , quickCheck "singleton" (M.singleton 1 2 == M.fromList [(1,2)])
           , quickCheck "isKey"     (M.isKey 1 baseMap)
           , quickCheck "insert"    (M.insert 1 3 baseMap == M.fromList [(1,3),(2,3),(3,4)])
           , quickCheck "prop_insert"    propInsert
           , quickCheck "get"       (M.get 1 baseMap == 2)
           , quickCheck "lookup_Just"    (M.lookup 1 baseMap == Just 2)
           , quickCheck "lookup_Nothing"    (M.lookup 10 baseMap == Nothing)
           , quickCheck "map"          (M.mapWithKey (\(k,v) -> v+1) baseMap == M.fromList [(1,3),(2,4),(3,5)])
           , quickCheck "member_true"  (M.member 1 baseMap == true)
           , quickCheck "member_false"  (M.member 10 baseMap == false)
           , quickCheck "not_member"  (M.notMember 10 baseMap == true)
           , quickCheck "update"      (M.update 1 10 baseMap == M.fromList [(1,10),(2,3),(3,4)])
           , quickCheck "updateWith"  (M.updateWith 1 (\x -> x+1) baseMap == M.fromList [(1,3),(2,3),(3,4)])
           , quickCheck "updateWithInit"  (M.updateWithInit 10 (\x -> x+1) 10 baseMap == M.fromList [(1,2),(2,3),(3,4),(10,10)])
           , quickCheck "take"          (case M.take 1 baseMap of
                                            Just (2, v) -> v == M.fromList [(2,3),(3,4)]
                                            _  -> error "error happened"
                                        )
           , quickCheck "delete"     (M.delete 1 baseMap == M.fromList [(2,3),(3,4)])
           , quickCheck "size"       (M.size baseMap == 3)
           , quickCheck "filter"     propMapFilter
           , quickCheck "merge "      propMapMerge
           -- , quickCheck "assocs "      (M.assocs baseMap == [(1,3),(2,3),(3,4)])
           , quickCheck "keys "      (M.keys baseMap == [1,2,3])
           , quickCheck "valuse "    (M.values baseMap == [2,3,4])
           , quickCheck "fromList_toList "     propMapFTList
           , quickCheck "eq"         propEq
           , quickCheck "show"       (show baseMap == "[(1, 2), (2, 3), (3, 4)]")
           , quickCheck "ord"        (baseMap < M.fromList [(2, 1), (2, 3), (3, 4)])
           ]