diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -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 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -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 diff --git a/app/Main.hs b/app/Main.hs --- a/app/Main.hs +++ b/app/Main.hs @@ -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 diff --git a/src/Test/Tasty/Discover.hs b/src/Test/Tasty/Discover.hs --- a/src/Test/Tasty/Discover.hs +++ b/src/Test/Tasty/Discover.hs @@ -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. -- diff --git a/tasty-discover.cabal b/tasty-discover.cabal --- a/tasty-discover.cabal +++ b/tasty-discover.cabal @@ -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 diff --git a/test/DiscoverTest.hs b/test/DiscoverTest.hs --- a/test/DiscoverTest.hs +++ b/test/DiscoverTest.hs @@ -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 diff --git a/test/Driver.hs b/test/Driver.hs --- a/test/Driver.hs +++ b/test/Driver.hs @@ -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 ()