diff --git a/test/Test/Fold.hs b/test/Test/Fold.hs
--- a/test/Test/Fold.hs
+++ b/test/Test/Fold.hs
@@ -1,15 +1,28 @@
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE Unsafe #-}
+{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}
 
-module Test.Fold where
+module Test.Fold (tests) where
 
-import           Data.Proxy
-import           Hedgehog
-import qualified Hedgehog.Gen as Gen
+import safe "base" Control.Category (Category (id))
+import safe "base" Control.Monad ((=<<))
+import safe "base" Data.Bool (Bool)
+import safe "base" Data.Function (($))
+import safe "base" Data.Proxy (Proxy (Proxy))
+import safe "base" System.IO (IO)
+import safe "hedgehog" Hedgehog (Property, checkParallel, discover, forAll, property)
+import safe qualified "hedgehog" Hedgehog.Gen as Gen
+import safe "yaya" Yaya.Fold (Mu)
+import safe "yaya" Yaya.Fold.Common (size)
+import safe "yaya-hedgehog" Yaya.Hedgehog.Expr (Expr, genExpr, genMuExpr)
+import safe "yaya-hedgehog" Yaya.Hedgehog.Fold
+  ( law_cataCancel,
+    law_cataCompose,
+    law_cataRefl,
+  )
 
-import           Yaya.Fold
-import           Yaya.Fold.Common
-import           Yaya.Hedgehog.Expr
-import           Yaya.Hedgehog.Fold
+-- TODO: For some reason HLint is complaining that TemplateHaskell is unused.
+{-# HLINT ignore "Unused LANGUAGE pragma" #-}
 
 prop_muCataCancel :: Property
 prop_muCataCancel =
@@ -21,9 +34,9 @@
 
 prop_muCataCompose :: Property
 prop_muCataCompose =
-  property
-  $ law_cataCompose (Proxy :: Proxy (Mu Expr)) size id
-    =<< forAll (Gen.sized genMuExpr)
+  property $
+    law_cataCompose (Proxy :: Proxy (Mu Expr)) size id
+      =<< forAll (Gen.sized genMuExpr)
 
 tests :: IO Bool
-tests = checkParallel $$(discover)
+tests = checkParallel $$discover
diff --git a/test/Test/Fold/Common.hs b/test/Test/Fold/Common.hs
--- a/test/Test/Fold/Common.hs
+++ b/test/Test/Fold/Common.hs
@@ -1,19 +1,39 @@
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE Unsafe #-}
+{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}
 
-module Test.Fold.Common where
+module Test.Fold.Common (tests) where
 
-import           Hedgehog
-import qualified Hedgehog.Gen as Gen
+import safe "base" Control.Category (Category ((.)))
+import safe "base" Control.Monad ((=<<))
+import safe "base" Data.Bool (Bool)
+import safe "base" Data.Functor (Functor (fmap))
+import safe "base" Data.Ord (Ord ((<)))
+import safe "base" System.IO (IO)
+import safe "hedgehog" Hedgehog
+  ( Property,
+    assert,
+    checkParallel,
+    discover,
+    forAll,
+    property,
+  )
+import safe qualified "hedgehog" Hedgehog.Gen as Gen
+import safe "yaya" Yaya.Fold (Recursive (cata), zipAlgebras)
+import safe "yaya" Yaya.Fold.Common (height, size)
+import safe "yaya" Yaya.Pattern (uncurry)
+import safe "yaya-hedgehog" Yaya.Hedgehog.Expr (genMuExpr)
+import safe "base" Prelude (Integral (toInteger))
 
-import           Yaya.Fold
-import           Yaya.Fold.Common
-import           Yaya.Hedgehog.Expr
+-- TODO: For some reason HLint is complaining that TemplateHaskell is unused.
+{-# HLINT ignore "Unused LANGUAGE pragma" #-}
 
 prop_heightLtSize :: Property
 prop_heightLtSize =
   property
-  (assert . uncurry (<) . fmap toInteger . cata (zipAlgebras height size)
-   =<< forAll (Gen.sized genMuExpr))
+    ( assert . uncurry (<) . fmap toInteger . cata (zipAlgebras height size)
+        =<< forAll (Gen.sized genMuExpr)
+    )
 
 tests :: IO Bool
-tests = checkParallel $$(discover)
+tests = checkParallel $$discover
diff --git a/test/Test/Fold/Native.hs b/test/Test/Fold/Native.hs
new file mode 100644
--- /dev/null
+++ b/test/Test/Fold/Native.hs
@@ -0,0 +1,42 @@
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE Unsafe #-}
+{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}
+
+module Test.Fold.Native (tests) where
+
+import safe "base" Control.Category (Category (id))
+import safe "base" Control.Monad ((=<<))
+import safe "base" Data.Bool (Bool)
+import safe "base" Data.Function (($))
+import safe "base" Data.Proxy (Proxy (Proxy))
+import safe "base" System.IO (IO)
+import safe "hedgehog" Hedgehog (Property, checkParallel, discover, forAll, property)
+import safe qualified "hedgehog" Hedgehog.Gen as Gen
+import safe "yaya" Yaya.Fold.Common (size)
+import safe "yaya" Yaya.Fold.Native (Fix)
+import safe "yaya-hedgehog" Yaya.Hedgehog.Expr (Expr, genExpr, genFixExpr)
+import safe "yaya-hedgehog" Yaya.Hedgehog.Fold
+  ( law_cataCancel,
+    law_cataCompose,
+    law_cataRefl,
+  )
+
+-- TODO: For some reason HLint is complaining that TemplateHaskell is unused.
+{-# HLINT ignore "Unused LANGUAGE pragma" #-}
+
+prop_fixCataCancel :: Property
+prop_fixCataCancel =
+  property $ law_cataCancel size =<< forAll (genExpr (Gen.sized genFixExpr))
+
+prop_fixCataRefl :: Property
+prop_fixCataRefl =
+  property $ law_cataRefl =<< forAll (Gen.sized genFixExpr)
+
+prop_fixCataCompose :: Property
+prop_fixCataCompose =
+  property $
+    law_cataCompose (Proxy :: Proxy (Fix Expr)) size id
+      =<< forAll (Gen.sized genFixExpr)
+
+tests :: IO Bool
+tests = checkParallel $$discover
diff --git a/test/Test/Retrofit.hs b/test/Test/Retrofit.hs
--- a/test/Test/Retrofit.hs
+++ b/test/Test/Retrofit.hs
@@ -1,19 +1,23 @@
-{-# LANGUAGE DeriveTraversable
-           , TemplateHaskell #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE Unsafe #-}
 
 -- | The point of this module is that it should compile _without_ importing any
 --   other Yaya modules.
-module Test.Retrofit where
-
-import           Hedgehog
+module Test.Retrofit (tests) where
 
-import           Yaya.Retrofit
+import safe "base" Data.Bool (Bool)
+import safe "base" Data.Eq (Eq)
+import safe "base" Data.Int (Int)
+import safe "base" System.IO (IO)
+import safe "base" Text.Show (Show)
+import safe "hedgehog" Hedgehog (checkParallel, discover)
+import safe "yaya" Yaya.Retrofit (defaultRules, extractPatternFunctor)
 
 data DExpr
   = Lit Int
   | Add DExpr DExpr
   | Mult DExpr DExpr
-  deriving (Eq, Show)
+  deriving stock (Eq, Show)
 
 extractPatternFunctor defaultRules ''DExpr
 
@@ -28,4 +32,4 @@
 --   showsPrec = recursiveShowsPrec
 
 tests :: IO Bool
-tests = checkParallel $$(discover)
+tests = checkParallel $$discover
diff --git a/test/test.hs b/test/test.hs
--- a/test/test.hs
+++ b/test/test.hs
@@ -1,19 +1,10 @@
-import           Control.Monad
-import           System.Exit (exitFailure)
-import           System.IO (BufferMode(..), hSetBuffering, stdout, stderr)
+{-# LANGUAGE Unsafe #-}
 
-import qualified Test.Fold as Fold
-import qualified Test.Fold.Common as Fold.Common
-import qualified Test.Retrofit as Retrofit
+import safe "base" System.IO (IO)
+import safe "hedgehog" Hedgehog.Main (defaultMain)
+import qualified "this" Test.Fold as Fold
+import qualified "this" Test.Fold.Common as Fold.Common
+import qualified "this" Test.Retrofit as Retrofit
 
 main :: IO ()
-main = do
-  hSetBuffering stdout LineBuffering
-  hSetBuffering stderr LineBuffering
-
-  results <- sequence [ Fold.tests
-                      , Fold.Common.tests
-                      , Retrofit.tests
-                      ]
-
-  unless (and results) exitFailure
+main = defaultMain [Fold.tests, Fold.Common.tests, Retrofit.tests]
diff --git a/yaya-test.cabal b/yaya-test.cabal
--- a/yaya-test.cabal
+++ b/yaya-test.cabal
@@ -1,34 +1,175 @@
-name:                yaya-test
-version:             0.3.1.0
-synopsis:            Test suites for `yaya`.
-description:         This package should not be depended on by anything.
-homepage:            https://github.com/sellout/yaya#readme
-author:              Greg Pfeil
-maintainer:          greg@technomadic.org
-copyright:           2017 Greg Pfeil
-license:             AGPL-3
-license-file:        LICENSE
-category:            Recursion
-build-type:          Simple
-cabal-version:       >=1.10
+cabal-version:  3.0
 
-test-suite yaya-test
-  type:                exitcode-stdio-1.0
-  hs-source-dirs:      test
-  main-is:             test.hs
-  other-modules:       Test.Fold
-                     , Test.Fold.Common
-                     , Test.Retrofit
-  build-depends:       base >= 4.7 && < 5
-                     , deriving-compat
-                     , hedgehog
-                     , yaya >= 0.3.1
-                     , yaya-hedgehog >= 0.2.0
-  default-extensions:  LambdaCase
-                     , MultiParamTypeClasses
-  ghc-options:         -threaded -rtsopts -with-rtsopts=-N -Wall
-  default-language:    Haskell2010
+name:        yaya-test
+version:     0.3.1.3
+synopsis:    Test suites for `yaya`.
+description: This package should not be depended on by anything.
+author:      Greg Pfeil <greg@technomadic.org>
+maintainer:  Greg Pfeil <greg@technomadic.org>
+copyright:   2017 Greg Pfeil
+homepage:    https://github.com/sellout/yaya#readme
+bug-reports: https://github.com/sellout/yaya/issues
+category:    Recursion
+build-type:  Simple
+license:     AGPL-3.0-or-later
+license-files:
+  LICENSE
+tested-with:
+  GHC == {
+--  GHCup   Nixpkgs
+    8.6.1,
+    8.8.1,  8.8.4,
+    8.10.1,
+    9.0.1,
+    9.2.1,
+    9.4.1,  9.4.8,
+    9.6.1,
+            9.8.1
+  }
 
 source-repository head
-  type:     git
+  type: git
   location: https://github.com/sellout/yaya
+
+-- This mimics the GHC2021 extension
+-- (https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/control.html?highlight=doandifthenelse#extension-GHC2021),
+-- but supporting compilers back to GHC 7.10. If the oldest supported compiler
+-- is GHC 9.2, then this stanza can be removed and `import: GHC2021` can be
+-- replaced by `default-language: GHC2021`.
+common GHC2021
+  default-language: Haskell2010
+  default-extensions:
+    BangPatterns
+    BinaryLiterals
+    ConstraintKinds
+    DeriveDataTypeable
+    DeriveGeneric
+    -- DeriveLift -- uncomment if the oldest supported version is GHC 8.10.1+
+    DeriveTraversable
+    DerivingStrategies
+    DoAndIfThenElse
+    EmptyCase
+    ExistentialQuantification
+    FlexibleContexts
+    FlexibleInstances
+    GADTSyntax
+    GeneralizedNewtypeDeriving
+    HexFloatLiterals
+    -- ImportQualifiedPost -- uncomment if the oldest supported version is GHC 8.10.1+
+    InstanceSigs
+    LambdaCase
+    MagicHash
+    MonadComprehensions
+    MonomorphismRestriction
+    MultiParamTypeClasses
+    NamedFieldPuns
+    NamedWildCards
+    NumericUnderscores
+    PolyKinds
+    PostfixOperators
+    RankNTypes
+    ScopedTypeVariables
+    StandaloneDeriving
+    -- StandaloneKindSignatures -- uncomment if the oldest supported version is GHC 8.10.1+
+    TupleSections
+    TypeApplications
+    TypeOperators
+    UnicodeSyntax
+    NoExplicitNamespaces
+
+common defaults
+  import: GHC2021
+  build-depends:
+    base ^>= {4.12.0, 4.13.0, 4.14.0, 4.15.0, 4.16.0, 4.17.0, 4.18.0, 4.19.0},
+  ghc-options:
+    -Weverything
+    -- Type inference good.
+    -Wno-missing-local-signatures
+    -- Warns even when `Unsafe` is explicit, not inferred. See
+    -- https://gitlab.haskell.org/ghc/ghc/-/issues/16689
+    -Wno-unsafe
+    -- TODO: prune these warnings
+    -Wno-all-missed-specialisations
+    -fpackage-trust
+    -trust base
+  if impl(ghc < 8.8.1)
+    ghc-options:
+      -- This used to warn even when `Safe` was explicit.
+      -Wno-safe
+  if impl(ghc >= 8.10.1)
+    ghc-options:
+      -- If we didn’t allow inferred-safe imports, nothing would be `Safe`.
+      -Wno-inferred-safe-imports
+      -- We support GHC versions without qualified-post.
+      -Wno-prepositive-qualified-module
+      -- `-trust` triggers this warning when applied to transitive dependencies.
+      -Wno-unused-packages
+  if impl(ghc >= 9.2.1)
+    ghc-options:
+      -- We support GHC versions without kind signatures.
+      -Wno-missing-kind-signatures
+  if impl(ghc >= 9.8.1)
+    ghc-options:
+      -- We support GHC versions without kind signatures.
+      -Wno-missing-poly-kind-signatures
+      -- Inference good.
+      -Wno-missing-role-annotations
+  default-extensions:
+    DefaultSignatures
+    ExplicitNamespaces
+    FunctionalDependencies
+    LiberalTypeSynonyms
+    -- replace with `LexicalNegation` if the oldest supported version is GHC 9.0.1+
+    NegativeLiterals
+    PackageImports
+    ParallelListComp
+    -- QualifiedDo - uncomment if the oldest supported version is GHC 9.0.1+
+    RecursiveDo
+    -- RequiredTypeArguments - uncomment if the oldest supported version is GHC 9.10.1+
+    RoleAnnotations
+    StrictData
+    TemplateHaskellQuotes
+    TransformListComp
+    NoGeneralizedNewtypeDeriving
+    NoImplicitPrelude
+    NoMonomorphismRestriction
+    NoPatternGuards
+    NoTypeApplications
+
+test-suite yaya-test
+  import: defaults
+  type: exitcode-stdio-1.0
+  hs-source-dirs:
+    test
+  main-is: test.hs
+  other-modules:
+    Test.Fold
+    Test.Fold.Common
+    Test.Fold.Native
+    Test.Retrofit
+  build-depends:
+    deriving-compat,
+    hedgehog,
+    yaya >= 0.5.0,
+    yaya-hedgehog >= 0.2.0,
+  ghc-options:
+    -rtsopts
+    -threaded
+    -trust adjunctions
+    -trust array
+    -trust base-orphans
+    -trust binary
+    -trust bytestring
+    -trust containers
+    -trust distributive
+    -trust exceptions
+    -trust ghc-prim
+    -trust profunctors
+    -trust semigroupoids
+    -trust stm
+    -trust text
+    -trust transformers-compat
+    -with-rtsopts=-N
+  if impl(ghc < 9.6)
+    ghc-options:
+      -trust foldable1-classes-compat