tasty-discover 5.1.0 → 5.2.0

raw patch · 7 files changed

+347/−38 lines, 7 filesdep ~tasty-quickcheckPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: tasty-quickcheck

API changes (from Hackage documentation)

Files

• CHANGELOG.md +22/−0
• README.md +75/−2
• app/Main.hs +8/−1
• src/Test/Tasty/Discover.hs +72/−0
• tasty-discover.cabal +2/−1
• test/DiscoverTest.hs +97/−3
• test/Driver.hs +71/−31

@@ -18,6 +18,28 @@  ### Removed +# 5.2.0 [2025-10-25]++### Added+- `applySkips` function for skipping entire test trees with individual test visibility+  - Traverses test trees and replaces tests with skipped placeholders+  - Shows each test as `[SKIPPED]` in yellow when skip condition is met+  - Useful for platform-specific test suites with `Flavored (IO TestTree)`+  - Preserves test group structure while showing which tests would run+- Comprehensive platform expression tests covering all operators and edge cases+  - Added tests for `!darwin`, `!mingw32`, `!unix` negations+  - Added tests for complex AND/OR expressions+  - Added tests for edge cases like unknown platforms (freebsd)++### Changed+- Migrated release process to tag-triggered workflow+  - Release workflow now triggers when version tags (e.g., v5.2.0) are pushed+  - Removed automatic tag creation from CI+  - Updated release documentation to reflect tag-based process+- `--inplace` option now only overwrites file if content has changed+  - Prevents unnecessary file modification timestamps+  - Reduces build system churn when generated file is identical+ # 5.1.0 [2025-08-10]  ### Added

@@ -27,6 +27,7 @@ - [Contributing](#contributing) - [FAQ](#frequently-asked-questions) - [Maintenance](#maintenance)+- [Releasing](#releasing) - [Acknowledgements](#acknowledgements) - [AI Guidelines](AI_GUIDELINES.md) - [Coding Style](CODING_STYLE.md)@@ -400,14 +401,14 @@  ```haskell -- Platform filtering with test skipping-tasty_platformAndSkip :: TestTree  +tasty_platformAndSkip :: TestTree tasty_platformAndSkip = platform "linux" $ skip $ testCase "Linux test that's also skipped" $ do   -- This would only run on Linux, but it's also skipped   pure ()  -- Platform filtering with test groups tasty_platformGroup :: TestTree-tasty_platformGroup = platform "unix" $ testGroup "Unix-only tests" +tasty_platformGroup = platform "unix" $ testGroup "Unix-only tests"   [ testCase "Unix test 1" $ pure ()   , testCase "Unix test 2" $ pure ()   , testProperty "Unix property" $ \(x :: Int) -> x >= 0 || x < 0@@ -416,6 +417,41 @@  Platform filtering works by checking the current platform against the expression at runtime. If the expression evaluates to `False`, the test is automatically skipped using the same mechanism as the `skip` function. +#### Skipping entire test trees with `applySkips`++When you want to skip an entire test tree (such as a group of tests) and have each individual test show as `[SKIPPED]` in the output, use the `applySkips` function:++```haskell+import Test.Tasty.Discover (Flavored, flavored, platform, applySkips)++-- Skip an entire test group on Darwin+tasty_testTree_no_darwin :: Flavored (IO TestTree)+tasty_testTree_no_darwin =+  flavored (platform "!darwin") $ pure $+    applySkips $ testGroup "Non-Darwin group"+      [ testProperty "Test 1" $ \(x :: Int) -> x == x+      , testCase "Test 2" $ pure ()+      , testProperty "Test 3" $ \(x :: Int) -> x >= 0 || x < 0+      ]+```++On Darwin, this will display all tests as skipped in yellow:++```+Non-Darwin group+  Test 1 [SKIPPED]: OK+  Test 2 [SKIPPED]: OK+  Test 3 [SKIPPED]: OK+```++The `applySkips` function:+- Checks the `SkipTest` option (set by functions like `skip` or `platform`)+- Traverses the entire test tree and replaces each individual test with a skipped placeholder+- Preserves the test group structure+- Shows `[SKIPPED]` in yellow for each test++This is particularly useful for platform-specific test suites where you want to see which tests would run on other platforms, rather than hiding the entire group.+ ### Using skip and platform (guidelines)  TL;DR:@@ -661,6 +697,43 @@  [CHANGELOG.md]: https://github.com/haskell-works/tasty-discover/blob/main/CHANGELOG.md [tagged releases]: https://github.com/haskell-works/tasty-discover/releases++# Releasing++This project's release flow is automated via GitHub Actions and triggered by pushing version tags.++Release checklist:++1) Prepare notes+- Update `CHANGELOG.md`: move items from "Unreleased" to a new version section with the current date.++2) Bump version+- Edit `tasty-discover.cabal` and set `version:` to the new version (e.g., `5.x.y`).++3) Commit changes+- Commit the changes: `git commit -m "Release X.Y.Z"`+- Push the commit: `git push origin main`++4) Create and push tag+- Create a git tag: `git tag -a vX.Y.Z -m "Release version X.Y.Z"`+- Push the tag: `git push origin vX.Y.Z`++5) CI does the rest (automated)+- When the tag is pushed, GitHub Actions automatically:+  - Runs the full test suite+  - Validates the cabal project with `cabal check`+  - Builds source distributions (`cabal v2-sdist`)+  - Uploads to Hackage (requires repo secrets `HACKAGE_USER`/`HACKAGE_PASS`)+  - Creates a draft GitHub Release for the tag++6) Publish release+- Go to https://github.com/haskell-works/tasty-discover/releases+- Edit the draft GitHub Release notes if needed and publish++Notes:+- The workflow is defined in `.github/workflows/haskell.yml`.+- The release workflow only triggers on tags matching `v[0-9]+.[0-9]+.[0-9]+` (e.g., v5.2.0).+- Keep `tested-with` in the cabal file up to date with CI's GHC matrix.  # Deprecation Policy 

@@ -29,7 +29,14 @@           header <- readHeader src           let output = generateTestDriver config moduleName ingredients src tests           when (debug config) $ hPutStrLn stderr output-          when (inPlace config) $ writeFile src $ unlines $ header ++ [marker, output]+          -- Write in-place only when content differs (no temp file)+          when (inPlace config) $ do+            let newContent = unlines $ header ++ [marker, output]+            -- Strictly read the existing file so the handle is closed before we write (important on Windows)+            oldContent <- withFile src ReadMode $ \h -> do+              s <- hGetContents h+              length s `seq` return s+            when (oldContent /= newContent) $ writeFile src newContent           writeFile dst $             "{-# LINE " ++ show (length header + 2) ++ " " ++ show src ++ " #-}\n"             ++ output

@@ -12,17 +12,21 @@   , nameOf   , descriptionOf   , skip+  , applySkips   , platform   , evaluatePlatformExpression   ) where  import Data.Maybe import Data.Monoid+import System.Console.ANSI (Color(..), ColorIntensity(..), ConsoleLayer(..), SGR(..), setSGRCode) import System.Info (os) import Test.Tasty.Discover.TastyInfo (TastyInfo) import Test.Tasty.Discover.Internal.Config (SkipTest(..))  import qualified Test.Tasty as TT+import qualified Test.Tasty.Runners as TR+import qualified Test.Tasty.Providers as TP import qualified Test.Tasty.Discover.TastyInfo as TI  {- $skipPlatform@@ -153,6 +157,74 @@ -- @ skip :: TT.TestTree -> TT.TestTree skip = TT.adjustOption (const (SkipTest True))++-- | Transform a TestTree to apply skipping behavior throughout the entire tree.+--+-- This function wraps a TestTree so that when the 'SkipTest' option is set to 'True',+-- all individual tests within the tree are replaced with skipped placeholder tests.+-- This is useful when you want to conditionally skip an entire group of tests while+-- still showing each test as skipped in the output.+--+-- The function works by:+--+-- * Checking the 'SkipTest' option via 'TT.askOption'+-- * If skipping is enabled, using 'TT.foldTestTree' to traverse the tree and rebuild it with:+--+--     * All single tests replaced with test cases showing "[SKIPPED]"+--     * Test groups preserved with their structure intact+--     * Resources skipped (not acquired)+--+-- * If skipping is disabled, returning the tree unchanged+--+-- This is particularly useful in combination with 'platform' for platform-specific test suites:+--+-- @+-- tasty_testTree_no_darwin :: Flavored (IO TestTree)+-- tasty_testTree_no_darwin =+--   flavored (platform "!darwin") $ pure $ applySkips $ testGroup "Non-Darwin group"+--     [ testProperty "Test 1" $ \\(x :: Int) -> x == x+--     , testCase "Test 2" $ pure ()+--     ]+-- @+--+-- On Darwin, this will show:+--+-- @+-- Non-Darwin group+--   Test 1 [SKIPPED]: OK+--   Test 2 [SKIPPED]: OK+-- @+--+-- @since 5.1.0+-- | A simple test type for skipped tests+data SkippedTest = SkippedTest+  deriving stock (Show, Eq)++instance TP.IsTest SkippedTest where+  run _ _ _ = return $ TP.testPassed ""+  testOptions = return []++applySkips :: TT.TestTree -> TT.TestTree+applySkips tree = TT.askOption $ \(SkipTest shouldSkip) ->+  if shouldSkip+    then transformTree tree+    else tree+  where+    yellowText :: String -> String+    yellowText text = setSGRCode [SetColor Foreground Vivid Yellow] ++ text ++ setSGRCode [Reset]++    transformTree :: TT.TestTree -> TT.TestTree+    transformTree t = case TR.foldTestTree+      TR.TreeFold+        { TR.foldSingle = \_ testName _ -> [TP.singleTest (testName ++ " " ++ yellowText "[SKIPPED]") SkippedTest]+        , TR.foldGroup = \_ groupName trees -> [TT.testGroup groupName (concat trees)]+        , TR.foldResource = \_ _ _ -> []+        , TR.foldAfter = \_ _ _ trees -> trees+        }+      mempty+      t of+        [result] -> result+        results -> TT.testGroup "" results  -- | Conditionally run a test based on a platform expression. --

@@ -1,7 +1,7 @@ cabal-version: 3.0  name:                   tasty-discover-version:                5.1.0+version:                5.2.0 synopsis:               Test discovery for the tasty framework. description:            Automatic test discovery and runner for the tasty framework.                       @@ -80,6 +80,7 @@  library   import:               base, project-config+                      , ansi-terminal                       , containers                       , directory                       , filepath

@@ -3,6 +3,7 @@ {-# LANGUAGE ScopedTypeVariables #-}  {- HLINT ignore "Avoid reverse" -}+{- HLINT ignore "Redundant reverse" -}  module DiscoverTest where @@ -15,7 +16,7 @@ import Test.Hspec (shouldBe) import Test.Hspec.Core.Spec (Spec, describe, it) import Test.Tasty-import Test.Tasty.Discover (Flavored, flavored, skip, platform, evaluatePlatformExpression)+import Test.Tasty.Discover (Flavored, flavored, skip, platform, applySkips, evaluatePlatformExpression) import Test.Tasty.Golden import Test.Tasty.HUnit import Test.Tasty.QuickCheck hiding (Property, property)@@ -155,10 +156,46 @@ unit_platformExpression_not_linux =   evaluatePlatformExpression "!linux" "darwin" @?= True +unit_platformExpression_not_linux_false :: Assertion+unit_platformExpression_not_linux_false =+  evaluatePlatformExpression "!linux" "linux" @?= False++unit_platformExpression_not_darwin :: Assertion+unit_platformExpression_not_darwin =+  evaluatePlatformExpression "!darwin" "linux" @?= True++unit_platformExpression_not_darwin_false :: Assertion+unit_platformExpression_not_darwin_false =+  evaluatePlatformExpression "!darwin" "darwin" @?= False+ unit_platformExpression_not_windows :: Assertion unit_platformExpression_not_windows =   evaluatePlatformExpression "!windows" "linux" @?= True +unit_platformExpression_not_windows_false :: Assertion+unit_platformExpression_not_windows_false =+  evaluatePlatformExpression "!windows" "mingw32" @?= False++unit_platformExpression_not_mingw32 :: Assertion+unit_platformExpression_not_mingw32 =+  evaluatePlatformExpression "!mingw32" "linux" @?= True++unit_platformExpression_not_mingw32_false :: Assertion+unit_platformExpression_not_mingw32_false =+  evaluatePlatformExpression "!mingw32" "mingw32" @?= False++unit_platformExpression_not_unix :: Assertion+unit_platformExpression_not_unix =+  evaluatePlatformExpression "!unix" "mingw32" @?= True++unit_platformExpression_not_unix_false_linux :: Assertion+unit_platformExpression_not_unix_false_linux =+  evaluatePlatformExpression "!unix" "linux" @?= False++unit_platformExpression_not_unix_false_darwin :: Assertion+unit_platformExpression_not_unix_false_darwin =+  evaluatePlatformExpression "!unix" "darwin" @?= False+ -- Test conjunction (AND) unit_platformExpression_and_true :: Assertion unit_platformExpression_and_true =@@ -168,15 +205,43 @@ unit_platformExpression_and_false =   evaluatePlatformExpression "!windows & !darwin" "darwin" @?= False --- Test disjunction (OR)  +unit_platformExpression_and_false_windows :: Assertion+unit_platformExpression_and_false_windows =+  evaluatePlatformExpression "!windows & !darwin" "mingw32" @?= False++unit_platformExpression_and_both_positive :: Assertion+unit_platformExpression_and_both_positive =+  evaluatePlatformExpression "unix & !windows" "linux" @?= True++unit_platformExpression_and_both_positive_false :: Assertion+unit_platformExpression_and_both_positive_false =+  evaluatePlatformExpression "unix & !windows" "mingw32" @?= False++unit_platformExpression_and_three_terms :: Assertion+unit_platformExpression_and_three_terms =+  evaluatePlatformExpression "!windows & !darwin & !mingw32" "linux" @?= True++-- Test disjunction (OR) unit_platformExpression_or_true :: Assertion unit_platformExpression_or_true =   evaluatePlatformExpression "linux | darwin" "linux" @?= True +unit_platformExpression_or_true_darwin :: Assertion+unit_platformExpression_or_true_darwin =+  evaluatePlatformExpression "linux | darwin" "darwin" @?= True+ unit_platformExpression_or_false :: Assertion unit_platformExpression_or_false =   evaluatePlatformExpression "linux | darwin" "mingw32" @?= False +unit_platformExpression_or_windows_mingw32 :: Assertion+unit_platformExpression_or_windows_mingw32 =+  evaluatePlatformExpression "windows | linux" "mingw32" @?= True++unit_platformExpression_or_three_platforms :: Assertion+unit_platformExpression_or_three_platforms =+  evaluatePlatformExpression "linux | darwin | windows" "darwin" @?= True+ -- Test unix special case unit_platformExpression_unix_linux :: Assertion unit_platformExpression_unix_linux =@@ -208,6 +273,18 @@ unit_platformExpression_empty =   evaluatePlatformExpression "" "linux" @?= True  -- Should default to True on parse failure +unit_platformExpression_unknown_current :: Assertion+unit_platformExpression_unknown_current =+  evaluatePlatformExpression "linux" "freebsd" @?= False++unit_platformExpression_unix_freebsd :: Assertion+unit_platformExpression_unix_freebsd =+  evaluatePlatformExpression "unix" "freebsd" @?= False  -- unix only matches linux and darwin++unit_platformExpression_not_unix_freebsd :: Assertion+unit_platformExpression_not_unix_freebsd =+  evaluatePlatformExpression "!unix" "freebsd" @?= True  -- freebsd is not unix (in our definition)+ ------------------------------------------------------------------------------------------------ -- Platform-Specific Test Examples -- @@ -289,11 +366,28 @@   pure ()  -- You can also create platform-specific custom Property tests-tasty_platformProperty :: Flavored Property  +tasty_platformProperty :: Flavored Property tasty_platformProperty = flavored (platform "unix") $ property $ do   -- This hedgehog property only runs on Unix-like systems   x <- H.forAll $ G.int (R.linear 1 100)   x H.=== x++-- Helper function to make testProperty respect SkipTest option+testPropertySkippable :: Testable a => String -> a -> TestTree+testPropertySkippable name prop = askOption $ \(TD.SkipTest shouldSkip) ->+  if shouldSkip+    then testCase (name ++ " " ++ yellowText "[SKIPPED]") (pure ())+    else testProperty name prop+  where+    yellowText text = setSGRCode [SetColor Foreground Vivid Yellow] ++ text ++ setSGRCode [Reset]++tasty_testTree_no_darwin :: Flavored (IO TestTree)+tasty_testTree_no_darwin =+  flavored (platform "!darwin") $ pure $ applySkips $ testGroup "Non-Darwin group"+    [ testProperty "Always succeeds" $ \(x :: Int) -> x == x+    , testCase "Another test" $ pure ()+    , testProperty "Yet another" $ \(x :: Int) -> x >= 0 || x < 0+    ]  ------------------------------------------------------------------------------------------------ -- How to use the latest version of tasty-hedgehog

@@ -109,67 +109,107 @@    t31 <- testCase "platformExpression not linux" DiscoverTest.unit_platformExpression_not_linux -  t32 <- testCase "platformExpression not windows" DiscoverTest.unit_platformExpression_not_windows+  t32 <- testCase "platformExpression not linux false" DiscoverTest.unit_platformExpression_not_linux_false -  t33 <- testCase "platformExpression and true" DiscoverTest.unit_platformExpression_and_true+  t33 <- testCase "platformExpression not darwin" DiscoverTest.unit_platformExpression_not_darwin -  t34 <- testCase "platformExpression and false" DiscoverTest.unit_platformExpression_and_false+  t34 <- testCase "platformExpression not darwin false" DiscoverTest.unit_platformExpression_not_darwin_false -  t35 <- testCase "platformExpression or true" DiscoverTest.unit_platformExpression_or_true+  t35 <- testCase "platformExpression not windows" DiscoverTest.unit_platformExpression_not_windows -  t36 <- testCase "platformExpression or false" DiscoverTest.unit_platformExpression_or_false+  t36 <- testCase "platformExpression not windows false" DiscoverTest.unit_platformExpression_not_windows_false -  t37 <- testCase "platformExpression unix linux" DiscoverTest.unit_platformExpression_unix_linux+  t37 <- testCase "platformExpression not mingw32" DiscoverTest.unit_platformExpression_not_mingw32 -  t38 <- testCase "platformExpression unix darwin" DiscoverTest.unit_platformExpression_unix_darwin+  t38 <- testCase "platformExpression not mingw32 false" DiscoverTest.unit_platformExpression_not_mingw32_false -  t39 <- testCase "platformExpression unix windows" DiscoverTest.unit_platformExpression_unix_windows+  t39 <- testCase "platformExpression not unix" DiscoverTest.unit_platformExpression_not_unix -  t40 <- testCase "platformExpression complex1" DiscoverTest.unit_platformExpression_complex1+  t40 <- testCase "platformExpression not unix false linux" DiscoverTest.unit_platformExpression_not_unix_false_linux -  t41 <- testCase "platformExpression complex2" DiscoverTest.unit_platformExpression_complex2+  t41 <- testCase "platformExpression not unix false darwin" DiscoverTest.unit_platformExpression_not_unix_false_darwin -  t42 <- testCase "platformExpression unknown" DiscoverTest.unit_platformExpression_unknown+  t42 <- testCase "platformExpression and true" DiscoverTest.unit_platformExpression_and_true -  t43 <- testCase "platformExpression empty" DiscoverTest.unit_platformExpression_empty+  t43 <- testCase "platformExpression and false" DiscoverTest.unit_platformExpression_and_false -  t44 <- TD.tasty (TD.description "linuxOnly" <> TD.name "DiscoverTest.tasty_linuxOnly") DiscoverTest.tasty_linuxOnly+  t44 <- testCase "platformExpression and false windows" DiscoverTest.unit_platformExpression_and_false_windows -  t45 <- TD.tasty (TD.description "notWindows" <> TD.name "DiscoverTest.tasty_notWindows") DiscoverTest.tasty_notWindows+  t45 <- testCase "platformExpression and both positive" DiscoverTest.unit_platformExpression_and_both_positive -  t46 <- TD.tasty (TD.description "unixLike" <> TD.name "DiscoverTest.tasty_unixLike") DiscoverTest.tasty_unixLike+  t46 <- testCase "platformExpression and both positive false" DiscoverTest.unit_platformExpression_and_both_positive_false -  t47 <- TD.tasty (TD.description "complexPlatform1" <> TD.name "DiscoverTest.tasty_complexPlatform1") DiscoverTest.tasty_complexPlatform1+  t47 <- testCase "platformExpression and three terms" DiscoverTest.unit_platformExpression_and_three_terms -  t48 <- TD.tasty (TD.description "complexPlatform2" <> TD.name "DiscoverTest.tasty_complexPlatform2") DiscoverTest.tasty_complexPlatform2+  t48 <- testCase "platformExpression or true" DiscoverTest.unit_platformExpression_or_true -  t49 <- TD.tasty (TD.description "platformSpecific" <> TD.name "DiscoverTest.tasty_platformSpecific") DiscoverTest.tasty_platformSpecific+  t49 <- testCase "platformExpression or true darwin" DiscoverTest.unit_platformExpression_or_true_darwin -  t50 <- TD.tasty (TD.description "platformAndSkip" <> TD.name "DiscoverTest.tasty_platformAndSkip") DiscoverTest.tasty_platformAndSkip+  t50 <- testCase "platformExpression or false" DiscoverTest.unit_platformExpression_or_false -  t51 <- TD.tasty (TD.description "platformGroup" <> TD.name "DiscoverTest.tasty_platformGroup") DiscoverTest.tasty_platformGroup+  t51 <- testCase "platformExpression or windows mingw32" DiscoverTest.unit_platformExpression_or_windows_mingw32 -  t52 <- TD.tasty (TD.description "platformFlavored" <> TD.name "DiscoverTest.tasty_platformFlavored") DiscoverTest.tasty_platformFlavored+  t52 <- testCase "platformExpression or three platforms" DiscoverTest.unit_platformExpression_or_three_platforms -  t53 <- TD.tasty (TD.description "platformProperty" <> TD.name "DiscoverTest.tasty_platformProperty") DiscoverTest.tasty_platformProperty+  t53 <- testCase "platformExpression unix linux" DiscoverTest.unit_platformExpression_unix_linux -  t54 <- pure $ H.testPropertyNamed "reverse" (fromString "DiscoverTest.hprop_reverse") DiscoverTest.hprop_reverse+  t54 <- testCase "platformExpression unix darwin" DiscoverTest.unit_platformExpression_unix_darwin -  t55 <- TD.tasty (TD.description "goldenTest" <> TD.name "DiscoverTest.tasty_goldenTest") DiscoverTest.tasty_goldenTest+  t55 <- testCase "platformExpression unix windows" DiscoverTest.unit_platformExpression_unix_windows -  t56 <- pure $ QC.testProperty "subTest" ModulesGlob.Sub.OneTest.prop_subTest+  t56 <- testCase "platformExpression complex1" DiscoverTest.unit_platformExpression_complex1 -  t57 <- pure $ QC.testProperty "topLevelTest" ModulesGlob.TwoTest.prop_topLevelTest+  t57 <- testCase "platformExpression complex2" DiscoverTest.unit_platformExpression_complex2 -  t58 <- pure $ QC.testProperty "additionCommutative" SubMod.FooBaz.prop_additionCommutative+  t58 <- testCase "platformExpression unknown" DiscoverTest.unit_platformExpression_unknown -  t59 <- pure $ QC.testProperty "multiplationDistributiveOverAddition" SubMod.FooBaz.prop_multiplationDistributiveOverAddition+  t59 <- testCase "platformExpression empty" DiscoverTest.unit_platformExpression_empty -  t60 <- pure $ QC.testProperty "additionAssociative" SubMod.PropTest.prop_additionAssociative+  t60 <- testCase "platformExpression unknown current" DiscoverTest.unit_platformExpression_unknown_current -  t61 <- pure $ QC.testProperty "additionCommutative" SubMod.SubSubMod.PropTest.prop_additionCommutative+  t61 <- testCase "platformExpression unix freebsd" DiscoverTest.unit_platformExpression_unix_freebsd -  pure $ T.testGroup "test/Driver.hs" [t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19,t20,t21,t22,t23,t24,t25,t26,t27,t28,t29,t30,t31,t32,t33,t34,t35,t36,t37,t38,t39,t40,t41,t42,t43,t44,t45,t46,t47,t48,t49,t50,t51,t52,t53,t54,t55,t56,t57,t58,t59,t60,t61]+  t62 <- testCase "platformExpression not unix freebsd" DiscoverTest.unit_platformExpression_not_unix_freebsd++  t63 <- TD.tasty (TD.description "linuxOnly" <> TD.name "DiscoverTest.tasty_linuxOnly") DiscoverTest.tasty_linuxOnly++  t64 <- TD.tasty (TD.description "notWindows" <> TD.name "DiscoverTest.tasty_notWindows") DiscoverTest.tasty_notWindows++  t65 <- TD.tasty (TD.description "unixLike" <> TD.name "DiscoverTest.tasty_unixLike") DiscoverTest.tasty_unixLike++  t66 <- TD.tasty (TD.description "complexPlatform1" <> TD.name "DiscoverTest.tasty_complexPlatform1") DiscoverTest.tasty_complexPlatform1++  t67 <- TD.tasty (TD.description "complexPlatform2" <> TD.name "DiscoverTest.tasty_complexPlatform2") DiscoverTest.tasty_complexPlatform2++  t68 <- TD.tasty (TD.description "platformSpecific" <> TD.name "DiscoverTest.tasty_platformSpecific") DiscoverTest.tasty_platformSpecific++  t69 <- TD.tasty (TD.description "platformAndSkip" <> TD.name "DiscoverTest.tasty_platformAndSkip") DiscoverTest.tasty_platformAndSkip++  t70 <- TD.tasty (TD.description "platformGroup" <> TD.name "DiscoverTest.tasty_platformGroup") DiscoverTest.tasty_platformGroup++  t71 <- TD.tasty (TD.description "platformFlavored" <> TD.name "DiscoverTest.tasty_platformFlavored") DiscoverTest.tasty_platformFlavored++  t72 <- TD.tasty (TD.description "platformProperty" <> TD.name "DiscoverTest.tasty_platformProperty") DiscoverTest.tasty_platformProperty++  t73 <- TD.tasty (TD.description "testTree no darwin" <> TD.name "DiscoverTest.tasty_testTree_no_darwin") DiscoverTest.tasty_testTree_no_darwin++  t74 <- pure $ H.testPropertyNamed "reverse" (fromString "DiscoverTest.hprop_reverse") DiscoverTest.hprop_reverse++  t75 <- TD.tasty (TD.description "goldenTest" <> TD.name "DiscoverTest.tasty_goldenTest") DiscoverTest.tasty_goldenTest++  t76 <- pure $ QC.testProperty "subTest" ModulesGlob.Sub.OneTest.prop_subTest++  t77 <- pure $ QC.testProperty "topLevelTest" ModulesGlob.TwoTest.prop_topLevelTest++  t78 <- pure $ QC.testProperty "additionCommutative" SubMod.FooBaz.prop_additionCommutative++  t79 <- pure $ QC.testProperty "multiplationDistributiveOverAddition" SubMod.FooBaz.prop_multiplationDistributiveOverAddition++  t80 <- pure $ QC.testProperty "additionAssociative" SubMod.PropTest.prop_additionAssociative++  t81 <- pure $ QC.testProperty "additionCommutative" SubMod.SubSubMod.PropTest.prop_additionCommutative++  pure $ T.testGroup "test/Driver.hs" [t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19,t20,t21,t22,t23,t24,t25,t26,t27,t28,t29,t30,t31,t32,t33,t34,t35,t36,t37,t38,t39,t40,t41,t42,t43,t44,t45,t46,t47,t48,t49,t50,t51,t52,t53,t54,t55,t56,t57,t58,t59,t60,t61,t62,t63,t64,t65,t66,t67,t68,t69,t70,t71,t72,t73,t74,t75,t76,t77,t78,t79,t80,t81] ingredients :: [T.Ingredient] ingredients = T.defaultIngredients main :: IO ()