Use tasty instead of test-framework

hashable.cabal

@@ -192,12 +192,12 @@ test-suite hashable-tests
     , ghc-prim
     , hashable
     , HUnit
-    , QuickCheck                  >=2.4.0.1
-    , random                      >=1.0      && <1.3
-    , test-framework              >=0.3.3
-    , test-framework-hunit
-    , test-framework-quickcheck2  >=0.2.9
-    , text                        >=0.11.0.5
+    , QuickCheck        >=2.4.0.1
+    , random            >=1.0      && <1.3
+    , tasty             ^>=1.5
+    , tasty-hunit       ^>=0.10.1
+    , tasty-quickcheck  ^>=0.10.3
+    , text              >=0.11.0.5
 
   if impl(ghc >=9.2)
     build-depends: os-string

tests/Main.hs

@@ -5,10 +5,10 @@ module Main (main) where
 
 import Properties (properties)
 import Regress (regressions)
-import Test.Framework (defaultMain, testGroup)
+import Test.Tasty (defaultMain, testGroup)
 
 main :: IO ()
-main = defaultMain [
-         testGroup "properties" properties
-       , testGroup "regressions" regressions
-       ]
+main = defaultMain $ testGroup "hashable"
+    [ testGroup "properties" properties
+    , testGroup "regressions" regressions
+    ]

tests/Properties.hs

@@ -24,14 +24,14 @@
 import GHC.ST (ST(..), runST)
 import GHC.Word (Word8(..))
 import Test.QuickCheck hiding ((.&.))
-import Test.Framework (Test, testGroup)
-import Test.Framework.Providers.QuickCheck2 (testProperty)
+import Test.Tasty (TestTree, testGroup)
+import Test.Tasty.QuickCheck (testProperty)
 import GHC.Generics
 
 import qualified Data.ByteString.Short as BS
 
 #if MIN_VERSION_filepath(1,4,100) && !(MIN_VERSION_filepath(1,5,0))
 import qualified "filepath" System.OsString.Internal.Types as FP
 #endif
 
 #ifdef MIN_VERSION_os_string
@@ -178,10 +178,10 @@
 -- Hashes of all product types of the same shapes should be the same.
 
 pProduct2 :: Int -> String -> Bool
 pProduct2 x y = hash (x, y) == hash (Product2 x y)
 
 pProduct3 :: Double -> Maybe Bool -> (Int, String) -> Bool
 pProduct3 x y z = hash (x, y, z) == hash (Product3 x y z)
 
 data Sum2 a b = S2a a | S2b b
                 deriving (Eq, Ord, Show, Generic)
@@ -225,7 +225,7 @@
 pLiftedHashed :: Int -> Hashed (Either Int String) -> Bool
 pLiftedHashed s h = hashWithSalt s h == hashWithSalt1 s h
 
-properties :: [Test]
+properties :: [TestTree]
 properties =
     [ testProperty "bernstein" pHash
     , testGroup "text"

tests/Regress.hs

@@ -4,14 +4,13 @@
 
 module Regress (regressions) where
 
-import qualified Test.Framework as F
+import Test.Tasty (TestTree, testGroup)
 import Control.Monad (when)
-import Test.Framework.Providers.HUnit (testCase)
-import Test.HUnit (Assertion, assertFailure, (@?=))
-import Test.Framework.Providers.QuickCheck2 (testProperty)
+import Test.Tasty.HUnit (testCase, Assertion, assertFailure, (@?=))
+import Test.Tasty.QuickCheck (testProperty)
 import GHC.Generics (Generic)
 import Data.List (nub)
 import Data.Fixed (Pico)
 import Data.Text (Text)
 import Data.ByteString (ByteString)
 
@@ -33,15 +32,15 @@
     | x == y    = assertFailure msg
     | otherwise = return ()
 
-regressions :: [F.Test]
+regressions :: [TestTree]
 regressions = [] ++
 #ifdef HAVE_MMAP
     Mmap.regressions ++
     [ testCase "Fixed" $ do
         (hash (1 :: Pico) == hash (2 :: Pico)) @?= False
     ] ++
 #endif
-    [ F.testGroup "Generic: sum of nullary constructors"
+    [ testGroup "Generic: sum of nullary constructors"
         [ testCase "0" $ nullaryCase 0 S0
         , testCase "1" $ nullaryCase 1 S1
         , testCase "2" $ nullaryCase 2 S2
@@ -72,7 +71,7 @@
 #endif
         hash ("hello world" :: Text) @?= expected
 #endif
-    , F.testGroup "concatenation"
+    , testGroup "concatenation"
         [ testCase "String" $ do
             let lhs, rhs :: (String, String)
                 lhs = ("foo", "bar")

tests/Regress/Mmap.hsc

@@ -14,8 +14,8 @@ import Foreign.C.Types (CInt(..), CSize(..))
 import Foreign.Ptr (Ptr, intPtrToPtr, nullPtr, plusPtr)
 import GHC.ForeignPtr (newForeignPtr_)
 import System.Posix.Types (COff(..))
-import Test.Framework (Test)
-import Test.Framework.Providers.HUnit (testCase)
+import Test.Tasty (TestTree)
+import Test.Tasty.HUnit (testCase)
 import qualified Data.ByteString as B
 
 withMapping :: (Ptr a -> Int -> IO ()) -> IO ()
@@ -43,7 +43,7 @@ hashNearPageBoundary =
     forM_ (B.tails bs0) $ \bs -> do
       evaluate (hash bs)
 
-regressions :: [Test]
+regressions :: [TestTree]
 regressions = [
    testCase "hashNearPageBoundary" hashNearPageBoundary
  ]