Use QuickCheck Fun throughout property and strictness tests.

TODO: Fix pInsertWithKeyStrict.

[ci skip]

Author: m-renaud

tests/HashMapProperties.hs

@@ -17,14 +17,17 @@ import qualified Data.HashMap.Strict as HM
 import qualified Data.HashMap.Lazy as HM
 #endif
 import qualified Data.Map as M
-import Test.QuickCheck (Arbitrary, Property, (==>), (===))
-import Test.QuickCheck.Function (Fun, apply)
+import Test.QuickCheck (Arbitrary, CoArbitrary, Property, (==>), (===))
+import Test.QuickCheck.Function (Fun, Function(function), apply, functionMap)
 import Test.Framework (Test, defaultMain, testGroup)
 import Test.Framework.Providers.QuickCheck2 (testProperty)
 
 -- Key type that generates more hash collisions.
 newtype Key = K { unK :: Int }
-            deriving (Arbitrary, Eq, Ord, Read, Show)
+            deriving (Arbitrary, CoArbitrary, Eq, Ord, Read, Show)
+
+instance Function Key where
+    function = functionMap unK K
 
 instance Hashable Key where
     hashWithSalt salt k = hashWithSalt salt (unK k) `mod` 20
@@ -153,9 +156,9 @@ pInsertWith f k =
   M.insertWith f' k 1 `eq_` HM.insertWith f' k 1
   where f' = curry . apply $ f
 
-pInsertWithKey :: Fun (Int, Int, Int) Int -> Key -> [(Key, Int)] -> Bool
+pInsertWithKey :: Fun (Key, (Int, Int)) Int -> Key -> [(Key, Int)] -> Bool
 pInsertWithKey f k = M.insertWithKey f' k 1 `eq_` HM.insertWithKey f' k 1
-  where f' k' v1 v2 = apply f (unK k', v1, v2)
+  where f' = curry . curry (apply f)
 
 pAdjust :: Key -> [(Key, Int)] -> Bool
 pAdjust k = M.adjust succ k `eq_` HM.adjust succ k

tests/Strictness.hs

@@ -7,7 +7,7 @@ import Data.Hashable (Hashable(hashWithSalt))
 import Test.ChasingBottoms.IsBottom
 import Test.Framework (Test, defaultMain, testGroup)
 import Test.Framework.Providers.QuickCheck2 (testProperty)
-import Test.QuickCheck (Arbitrary(arbitrary), Property, (===), (.&&.))
+import Test.QuickCheck (Arbitrary(arbitrary), CoArbitrary, Property, (===), (.&&.))
 import Test.QuickCheck.Function
 import Test.QuickCheck.Poly (A)
 import Data.Maybe (fromMaybe, isJust)
@@ -25,7 +25,10 @@ import qualified Data.HashMap.Strict as HM
 
 -- Key type that generates more hash collisions.
 newtype Key = K { unK :: Int }
-            deriving (Arbitrary, Eq, Ord, Show)
+            deriving (Arbitrary, CoArbitrary, Eq, Ord, Show)
+
+instance Function Key where
+  function = functionMap unK K
 
 instance Hashable Key where
     hashWithSalt salt k = hashWithSalt salt (unK k) `mod` 20
@@ -71,23 +74,25 @@ pInsertKeyStrict v m = isBottom $ HM.insert bottom v m
 pInsertValueStrict :: Key -> HashMap Key Int -> Bool
 pInsertValueStrict k m = isBottom $ HM.insert k bottom m
 
-pInsertWithKeyStrict :: (Int -> Int -> Int) -> Int -> HashMap Key Int -> Bool
-pInsertWithKeyStrict f v m = isBottom $ HM.insertWith f bottom v m
+pInsertWithKeyStrict :: Fun (Int, Int) Int -> Int -> HashMap Key Int -> Bool
+pInsertWithKeyStrict f v m =
+  isBottom $ HM.insertWith (curry . apply $ f) bottom v m
 
-pInsertWithValueStrict :: (Int -> Int -> Int) -> Key -> Int -> HashMap Key Int
+pInsertWithValueStrict :: Fun (Int, Int) Int -> Key -> Int -> HashMap Key Int
                        -> Bool
 pInsertWithValueStrict f k v m
     | HM.member k m = isBottom $ HM.insertWith (const2 bottom) k v m
-    | otherwise     = isBottom $ HM.insertWith f k bottom m
+    | otherwise     = isBottom $ HM.insertWith (curry . apply $ f) k bottom m
 
-pInsertWithKeyKeyStrict :: (Key -> Int -> Int -> Int) -> Int -> HashMap Key Int -> Bool
-pInsertWithKeyKeyStrict f v m = isBottom $ HM.insertWithKey f bottom v m
+pInsertWithKeyKeyStrict :: Fun (Key, (Int, Int)) Int -> Int -> HashMap Key Int -> Bool
+pInsertWithKeyKeyStrict f v m =
+  isBottom $ HM.insertWithKey (curry . curry (apply f)) bottom v m
 
-pInsertWithKeyValueStrict :: (Key -> Int -> Int -> Int) -> Key -> Int -> HashMap Key Int
+pInsertWithKeyValueStrict :: Fun (Key, (Int, Int)) Int -> Key -> Int -> HashMap Key Int
                           -> Bool
 pInsertWithKeyValueStrict f k v m
     | HM.member k m = isBottom $ HM.insertWithKey (const2 bottom) k v m
-    | otherwise     = isBottom $ HM.insertWithKey f k bottom m
+    | otherwise     = isBottom $ HM.insertWithKey (curry . curry (apply f)) k bottom m
 
 pFromListKeyStrict :: Bool
 pFromListKeyStrict = isBottom $ HM.fromList [(undefined :: Key, 1 :: Int)]