h&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                           Safe-Inferred  Safe-Inferred )*1 8 Safe-Inferred"%&18; sydtestIn nanosecondssydtestAn exception with context.?We wrap an existentially qualified exception here, instead of , so that we can unwrap it. (For some unknown reason, that doesn't work otherwise.)sydtestA special exception that sydtest knows about and can display nicely in the error outputThis is exported outwards so that you can define golden tests for custom types.You will probably not want to use this directly in everyday tests, use shouldBe or a similar function instead.?sydtest!A golden test for output of type a.The purpose of a golden test is to ensure that the output of a certain process does not change even over time.Golden tests can also be used to show how the output of a certain process changes over time and force code reviewers to review the diff that they see in the PR.This works by saving a golden output in the repository somewhere, committing it, and then compare that golden output to the output that is currently being produced. You can use `--golden-reset` to have sydtest update the golden output by writing the current output.AsydtestRead the golden test output, " if there is no golden output yet.BsydtestProduce the current outputCsydtestWrite golden outputDsydtest)Compare golden output with current outputThe first argument is the current output, the second is the golden outputFsydtestThe argument from  aroundAllGsydtestThe argument from aroundHsydtestRunning the test, safelyWsydtestTime an action and return the result as well as how long it took in seconds.This function does not use the timeit package because that package uses CPU time instead of system time. That means that any waiting, like with  would not be counted.8Note that this does not evaluate the result, on purpose.sydtestTotal examplessydtestExample numbersydtestTotal examplessydtestExample numbersydtest Time it took  ! "#$%&/.-1,0+)(*'2435=<;9:876>?DCBA@EHGFIJKLMNOPQRSTUVWEHGFIJKLMNOP?DCBA@QR>5=<;9:876S243&/.-1,0+)(*'#$%! "TUVW   Safe-Inferred"%&;&sydtest*The flags that are common across commands.sydtest+What we find in the configuration variable.Do nothing clever here, just represent the relevant parts of the environment. For example, use , not  SqliteConfig.sydtest+What we find in the configuration variable.Do nothing clever here, just represent the configuration file. For example, use 'Maybe FilePath', not 'Path Abs File'.Use  or  to read a configuration.sydtest&Don't report any progress, the defaultsydtestReport progresssydtest$Run the test suite once, the defaultsydtestRun the test suite for the given number of iterations, or until we can find flakinesssydtestRun the test suite over and over, until we can find some flakinesssydtest One threadsydtestAs many threads as getNumCapabilities tells you you havesydtestA given number of threadssydtest&Test suite definition and run settingssydtest,The seed to use for deterministic randomnesssydtestAssert that computation returns the given value (according to ).sydtest>Assert that computation returns the given value (according to ).sydtest/Assert that the given list has the given prefixsydtest/Assert that the given list has the given suffixsydtest.Assert that the given list has the given infixsydtestAssert that the given list contains all elements from the other given list and only them, perhaps in a different order.sydtestAssert that two s are equal according to .Note that using function could mess up the colours in your terminal if the Texts contain ANSI codes. In that case you may want to  your values first or use  instead.sydtestAssert that two s are equal according to .Note that using function could mess up the colours in your terminal if the Texts contain ANSI codes. In that case you may want to  your values first or use  instead.sydtestAn assertion that says two &s should have been equal according to .Note that using function could mess up the colours in your terminal if the Texts contain ANSI codes. In that case you may want to  your values first or use  instead.sydtestAn assertion that says two &s should have been equal according to .Note that using function could mess up the colours in your terminal if the Texts contain ANSI codes. In that case you may want to  your values first or use  instead.sydtestAn assertion that says two &s should have been equal according to .sydtestMake a test failNote that this is mostly backward compatible, but it has return type a instead of () because execution will not continue beyond this function. In this way it is not entirely backward compatible with hspec because now there could be an ambiguous type error.sydtestAnnotate a given action with a context, for contextual assertionsThis is a completely different function from the function with the same name in hspec. In hspec, context is a synonym for describe, but in sydtest, context is used for contextual failures.sydtestAssert that a given IO action throws an exception that matches the given exception 1111111111 Safe-Inferred3 sydtestTest that the given bytestring is the same as what we find in the given golden file.sydtestTest that the produced bytestring is the same as what we find in the given golden file.sydtestTest that the given lazy bytestring is the same as what we find in the given golden file.Note: This converts the lazy bytestring to a strict bytestring first.sydtestTest that the produced bytestring is the same as what we find in the given golden file.Note: This converts the lazy bytestring to a strict bytestring first.sydtestTest that the given lazy bytestring is the same as what we find in the given golden file.=Note: This converts the builder to a strict bytestring first.sydtestTest that the produced bytestring is the same as what we find in the given golden file.=Note: This converts the builder to a strict bytestring first.sydtestTest that the given text is the same as what we find in the given golden file.sydtestTest that the produced text is the same as what we find in the given golden file.sydtestTest that the given string is the same as what we find in the given golden file.sydtestTest that the produced string is the same as what we find in the given golden file.sydtestTest that the show instance has not changed for the given value.sydtestTest that the show instance has not changed for the given value, via .sydtestThe golden test context for adding context to a golden test assertion: goldenTestCompare = \actual expected -> if actual == expected then Nothing else Just $ Context (stringsNotEqualButShouldHaveBeenEqual actual expected) (goldenContext fp)?@ABCD?@ABCD Safe-Inferred84[ Safe-Inferred"%&)*1289:;>  Safe-Inferred 18=    Safe-Inferred?sydtestRun a single test.Run the test up to  maxRetries times. Finish as soon as the test passes once, or when we run out of retries.sydtestHow to report test progresssydtestExternal resourcessydtestTest definitionsydtest Max retriessydtestFlakiness modesydtestExpectation modesydtest Test resultsydtestHow to report test progresssydtestExternal resourcessydtestTest definitionsydtest Max retriessydtestExpectation mode  Safe-Inferred%&)*189:;EsydtestThe test definition monadThis type has three parameters:outers: A type-level list of the outer resources. These are resources that are prived once, around a group of tests. (This is the type of the results of  aroundAll.)inner: The inner resource. This is a resource that is set up around every test, and even every example of a property test. (This is the type of the result of around.)result: The result ( is a monad.)5In practice, all of these three parameters should be () at the top level.sydtest%A synonym for a test suite definitionsydtest'A synonym for easy migration from hspecsydtest'A synonym for easy migration from hspecsydtest'A synonym for easy migration from hspecsydtestGet the path of describe strings upwards.Note that using this function makes tests less movable, depending on what you do with these strings. For example, if you use these strings to define the path to a golden test file, then that path will change if you move the tests somewhere else. This combines unfortunately with the way sydtest-discover makes the module name part of this path. Indeed: moving your tests to another module will change their path as well, if you use sydtest-discover. Also note that while test forests can be randomised, their description path upwards will not, because of how trees are structured.  Safe-Inferred)*1`zsydtestDeclare a test groupExample usage: describe "addition" $ do it "adds 3 to 5 to result in 8" $ 3 + 5 `shouldBe` 8 it "adds 4 to 7 to result in 11" $ 4 + 7 `shouldBe` 11sydtestDeclare a testNote: Don't look at the type signature unless you really have to, just follow the examples.Example usage:Tests without resources Pure test describe "addition" $ it "adds 3 to 5 to result in 8" $ 3 + 5 == 8IO test describe "readFile and writeFile" $ it "reads back what it wrote for this example" $ do let cts = "hello world" let fp = "test.txt" writeFile fp cts cts' <- readFile fp cts' `shouldBe` ctsPure Property test describe "sort" $ it "is idempotent" $ forAllValid $ \ls -> sort (sort ls) `shouldBe` (sort (ls :: [Int]))IO Property test describe "readFile and writeFile" $ it "reads back what it wrote for any example" $ do forAllValid $ \fp -> forAllValid $ \cts -> do writeFile fp cts cts' <- readFile fp cts' `shouldBe` ctsTests with an inner resource Pure test i + 5 == 8IO testThis test sets up a temporary directory as an inner resource, and makes it available to each test in the group below. let setUpTempDir func = withSystemTempDir $ \tempDir -> func tempDir in around setUpTempDir describe "readFile and writeFile" $ it "reads back what it wrote for this example" $ \tempDir -> do let cts = "hello world" let fp = tempDir "test.txt" writeFile fp cts cts' <- readFile fp cts' `shouldBe` ctsPure property test i * 5 == 5 * 3IO property test let setUpTempDir func = withSystemTempDir $ \tempDir -> func tempDir in around setUpTempDir describe "readFile and writeFile" $ it "reads back what it wrote for this example" $ \tempDir -> property $ \cts -> do let fp = tempDir "test.txt" writeFile fp cts cts' <- readFile fp cts' `shouldBe` ctssydtestA synonym for sydtestA synonym for sydtest*Declare a test that uses an outer resourceExample usage:Tests with an outer resource Pure test i + 5 == 8IO testThis test sets up a temporary directory as an inner resource, and makes it available to each test in the group below. let setUpTempDir func = withSystemTempDir $ \tempDir -> func tempDir in aroundAll setUpTempDir describe "readFile and writeFile" $ itWithOuter "reads back what it wrote for this example" $ \tempDir -> do let cts = "hello world" let fp = tempDir "test.txt" writeFile fp cts cts' <- readFile fp cts' `shouldBe` ctsPure property test i * 5 == 5 * 3IO property test let setUpTempDir func = withSystemTempDir $ \tempDir -> func tempDir in aroundAll setUpTempDir describe "readFile and writeFile" $ itWithouter "reads back what it wrote for this example" $ \tempDir -> property $ \cts -> do let fp = tempDir "test.txt" writeFile fp cts cts' <- readFile fp cts' `shouldBe` ctssydtestA synonym for sydtestA synonym for sydtest i + j == 8IO testThis test sets up a temporary directory as an inner resource, and makes it available to each test in the group below. let setUpTempDir func = withSystemTempDir $ \tempDir -> func tempDir in aroundAll setUpTempDir describe "readFile and writeFile" $ before (pure "hello world") $ itWithBoth "reads back what it wrote for this example" $ \tempDir cts -> do let fp = tempDir "test.txt" writeFile fp cts cts' <- readFile fp cts' `shouldBe` ctsPure property test i * j == 5 * 3IO property test let setUpTempDir func = withSystemTempDir $ \tempDir -> func tempDir in aroundAll setUpTempDir describe "readFile and writeFile" $ before (pure "test.txt") $ itWithBoth "reads back what it wrote for this example" $ \tempDir fileName -> property $ \cts -> do let fp = tempDir fileName writeFile fp cts cts' <- readFile fp cts' `shouldBe` ctssydtestA synonym for sydtestA synonym for sydtest,Declare a test that uses all outer resourcesYou will most likely never need this function, but in case you do: Note that this will always require a type annotation, along with the GADTs and ScopedTypeVariables extensions. Example usage beforeAll (pure 'a') $ beforeAll (pure 5) $ itWithAll "example" $ \(HCons c (HCons i HNil) :: HList '[Char, Int]) () -> (c, i) `shouldeBe` ('a', 5)sydtestA synonym for sydtestA synonym for sydtest6Convenience function for backwards compatibility with hspec prop s p = it s $ property psydtest-Declare a test that has not been written yet.sydtestDeclare a test that has not been written yet for the given reason.sydtestThe test group descriptionsydtestThe description of the testsydtestThe test itselfsydtestThe description of the testsydtestThe test itselfsydtestThe description of the testsydtestThe test itselfsydtestThe description of the testsydtestThe test itself  Safe-Inferredbsydtest3Define a test for each file in the given directory.Example:  scenarioDir "test_resources/even" $ \fp -> it "contains an even number" $ do s <- readFile fp n <- readIO s (n :: Int) `shouldSatisfy` evensydtestDefine a test for each file in the given directory, recursively.Example:  scenarioDirRecur "test_resources/odd" $ \fp -> it "contains an odd number" $ do s <- readFile fp n <- readIO s (n :: Int) `shouldSatisfy` odd Safe-Inferred)*1o sydtestRun a custom action before all spec items in a group, to set up an outer resource a.sydtestRun a custom action before all spec items in a group without setting up any outer resources.sydtestRun a custom action before all spec items in a group, to set up an outer resource b by using the outer resource a.sydtestRun a custom action after all spec items, using the outer resource a.sydtestRun a custom action after all spec items, using all the outer resources.sydtestRun a custom action after all spec items without using any outer resources.sydtestRun a custom action before and/or after all spec items in group, to provide access to a resource a.See the FOOTGUN note in the docs for around_.sydtestRun a custom action before and/or after all spec items in a group without accessing any resources.FOOTGUNThis combinator gives the programmer a lot of power. In fact, it gives the programmer enough power to break the test framework. Indeed, you can provide a wrapper function that just _doesn't_ run the function like this: spec :: Spec spec = do let don'tDo :: IO () -> IO () don'tDo _ = pure () aroundAll_ don'tDo $ do it "should pass" True5During execution, you'll then get an error like this: 0thread blocked indefinitely in an MVar operation#The same problem exists when using .Something even more pernicious goes wrong when you run the given action more than once like this: spec :: Spec spec = do let doTwice :: IO () -> IO () doTwice f = f >> f aroundAll_ doTwice $ do it "should pass" TrueIn this case, the test will "just work", but it will be executed twice even if the output reports that it only passed once.Note: If you're interested in fixing this, talk to me, but only after GHC has gotten impredicative types because that will likely be a requirement.sydtestRun a custom action before and/or after all spec items in a group to provide access to a resource a while using a resource bSee the FOOTGUN note in the docs for around_.sydtest%Declare a node in the spec def forest sydtestThe function to run (once), beforehand, to produce the outer resource.sydtest'The function to run (once), beforehand.sydtestThe function to run (once), beforehand, to produce a new outer resource while using a previous outer resourcesydtestThe function to run (once), afterwards, using the outer resource.sydtestThe function to run (once), afterwards, using all outer resources.sydtest'The function to run (once), afterwards.sydtestThe function that provides the outer resource (once), around the tests.sydtest*The function that wraps running the tests.sydtestThe function that provides the new outer resource (once), using the old outer resource.sydtestThe wrapper node   Safe-Inferred")*1R sydtestRun a custom action before every spec item, to set up an inner resource inner.2Note that this function turns off shrinking. See 1https://github.com/nick8325/quickcheck/issues/331sydtestRun a custom action before every spec item without setting up any inner resources.2Note that this function turns off shrinking. See 1https://github.com/nick8325/quickcheck/issues/331sydtestRun a custom action before every spec item, to set up an inner resource newInner& using the previously set up resource oldInner2Note that this function turns off shrinking. See 1https://github.com/nick8325/quickcheck/issues/331sydtestRun a custom action before every spec item, to set up an inner resource newInner& using the previously set up resource oldInner+ and potentially any of the outer resources2Note that this function turns off shrinking. See 1https://github.com/nick8325/quickcheck/issues/331sydtestRun a custom action after every spec item, using the inner resource c.2Note that this function turns off shrinking. See 1https://github.com/nick8325/quickcheck/issues/331sydtestRun a custom action after every spec item without using any inner resources.2Note that this function turns off shrinking. See 1https://github.com/nick8325/quickcheck/issues/331sydtestRun a custom action before and/or after every spec item, to provide access to an inner resource c.See the FOOTGUN note in the docs for .2Note that this function turns off shrinking. See 1https://github.com/nick8325/quickcheck/issues/331sydtestRun a custom action before and/or after every spec item without accessing any inner resources.It is important that the wrapper function that you provide runs the action that it gets _exactly once_.FOOTGUNThis combinator gives the programmer a lot of power. In fact, it gives the programmer enough power to break the test framework. Indeed, you can provide a wrapper function that just _doesn't_ run the function like this: spec :: Spec spec = do let don'tDo :: IO () -> IO () don'tDo _ = pure () around_ don'tDo $ do it "should pass" True5During execution, you'll then get an error like this: 0thread blocked indefinitely in an MVar operation#The same problem exists when using .The same thing will go wrong if you run the given action more than once like this: spec :: Spec spec = do let doTwice :: IO () -> IO () doTwice f = f >> f around_ doTwice $ do it "should pass" TrueNote: If you're interested in fixing this, talk to me, but only after GHC has gotten impredicative types because that will likely be a requirement.2Note that this function turns off shrinking. See 1https://github.com/nick8325/quickcheck/issues/331sydtestRun a custom action before and/or after every spec item, to provide access to an inner resource c while using the inner resource d.See the FOOTGUN note in the docs for .2Note that this function turns off shrinking. See 1https://github.com/nick8325/quickcheck/issues/331sydtestRun a custom action around every spec item, to provide access to an inner resource newInner while using the inner resource oldInner" and any outer resource available.2Note that this function turns off shrinking. See 1https://github.com/nick8325/quickcheck/issues/331sydtestThe function to run before every test, to produce the inner resourcesydtest%The function to run before every testsydtest>The function to run after every test, using the inner resourcesydtest$The function to run after every testsydtest?@ABCDEFGHFGIJKLMNOPQRSTUVW?@ABCD" !5678:9;<=EFGH !"#$%&'()*++,-./01234567889:;<=>?@ABCCDEFGHIJKLMNOPQQRSTUVWXYZZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                           'sydtest-0.12.0.1-43vbXzKJM6mAKH6iYcAgYWTest.SydTest.Syd.HList Test.Syd.RunTest.Syd.OptParseTest.Syd.ExpectationTest.Syd.Def.GoldenTest.Syd.SpecForestTest.Syd.SpecDefTest.Syd.Runner.WrappersTest.Syd.Runner.SingleTest.Syd.Def.TestDefMTest.Syd.Def.SpecifyTest.Syd.Def.ScenarioTest.Syd.Def.AroundAllTest.Syd.Def.AroundTest.Syd.Def.SetupFunc Test.Syd.PathTest.Syd.Modify$Test.Syd.Runner.Synchronous.SeparateTest.Syd.Output'Test.Syd.Runner.Synchronous.InterleavedTest.Syd.Runner.AsynchronousTest.Syd.Runner Paths_sydtestaround_ aroundAll_ Test.Syd.DefTest.Syd.Runner.Synchronous'pretty-show-1.10-6lSSyJ47f2OEwIxxs0u6jpText.Show.PrettypPrintppShow HContainsgetElemHListHNilHCons $fHContains:a$fHContains:a0$fHContains:a1$fHContainslHList$fHContains[]()Timed timedValue timedTimeProgressProgressTestStartingProgressExampleStartingProgressExampleDoneProgressTestDoneProgressReporter GoldenCaseGoldenNotFound GoldenStarted GoldenReset Contextual AssertionNotEqualButShouldHaveBeenEqualEqualButShouldNotHaveBeenEqual%PredicateSucceededButShouldHaveFailed%PredicateFailedButShouldHaveSucceededExpectationFailedContext TestStatus TestPassed TestFailed TestRunResulttestRunResultStatustestRunResultExceptiontestRunResultNumTeststestRunResultNumShrinkstestRunResultFailingInputstestRunResultLabelstestRunResultClassestestRunResultTablestestRunResultGoldenCasetestRunResultExtraInfo SeedSetting RandomSeed FixedSeedTestRunSettingstestRunSettingSeedtestRunSettingMaxSuccesstestRunSettingMaxSizetestRunSettingMaxDiscardRatiotestRunSettingMaxShrinkstestRunSettingGoldenStarttestRunSettingGoldenResetTest GoldenTestgoldenTestReadgoldenTestProducegoldenTestWritegoldenTestCompareIsTestArg1Arg2runTestrunPureTestWithArg applyWrapper2runIOTestWithArgmakeQuickCheckArgsrunPropertyTestWithArgaroundProperty aroundProp aroundRoserunGoldenTestWithArgexceptionHandlersdefaultTestRunSettingsaddContextToExceptionnoProgressReporterreportProgresstimeItT$fHasCodecSeedSetting$fExceptionAssertion$fExceptionContextual$fShowContextual $fIsTestFUN $fIsTestFUN0 $fIsTestIO $fIsTestFUN1 $fIsTestFUN2$fIsTestGoldenTest $fIsTestFUN3 $fIsTestFUN4$fIsTestProperty $fIsTestFUN5$fIsTestReaderT $fIsTestFUN6 $fIsTestFUN7 $fIsTestIO0 $fIsTestFUN8 $fIsTestFUN9 $fIsTestBool $fShowTimed $fEqTimed$fGenericTimed$fFunctorTimed$fShowProgress $fEqProgress$fGenericProgress$fShowTestRunResult$fGenericTestRunResult$fShowGoldenCase$fEqGoldenCase$fGenericGoldenCase$fShowAssertion $fEqAssertion$fGenericAssertion$fShowTestStatus$fEqTestStatus$fGenericTestStatus$fShowTestRunSettings$fEqTestRunSettings$fGenericTestRunSettings$fShowSeedSetting$fEqSeedSetting$fGenericSeedSettingFlagsflagConfigFileflagSeedflagRandomiseExecutionOrder flagThreads flagMaxSizeflagMaxSuccessflagMaxDiscardflagMaxShrinksflagGoldenStartflagGoldenReset flagColour flagFilter flagFailFastflagIterations flagRetriesflagFailOnFlakyflagReportProgress flagDebug Environment envConfigFileenvSeedenvRandomiseExecutionOrder envThreads envMaxSize envMaxSuccess envMaxDiscard envMaxShrinksenvGoldenStartenvGoldenReset envColour envFilter envFailFast envIterations envRetriesenvFailOnFlakyenvReportProgressenvDebug Configuration configSeedconfigRandomiseExecutionOrder configThreads configMaxSizeconfigMaxSuccessconfigMaxDiscardconfigMaxShrinksconfigGoldenStartconfigGoldenReset configColour configFilterconfigFailFastconfigIterations configRetriesconfigFailOnFlakyconfigReportProgress configDebugReportProgressReportNoProgress Iterations OneIteration ContinuousThreads SynchronousByCapabilities AsynchronousSettings settingSeedsettingRandomiseExecutionOrdersettingThreadssettingMaxSuccesssettingMaxSizesettingMaxDiscardsettingMaxShrinkssettingGoldenStartsettingGoldenReset settingColour settingFiltersettingFailFastsettingIterationssettingRetriessettingFailOnFlakysettingReportProgress settingDebug getSettingsdefaultSettingsdefaultRetriesderiveTerminalCapababilitiesdetectTerminalCapabilitiescombineToSettingsgetConfigurationdefaultConfigFiledefaultEnvironmentgetEnvironmentenvironmentParserseedSettingEnvironmentParsergetFlagsprefs_ flagsParser defaultFlags parseFlagsseedSettingFlags doubleSwitch$fHasCodecThreads$fHasCodecIterations$fHasCodecConfiguration $fShowFlags $fEqFlags$fGenericFlags$fShowEnvironment$fEqEnvironment$fGenericEnvironment$fShowConfiguration$fEqConfiguration$fGenericConfiguration$fShowSettings $fEqSettings$fGenericSettings$fShowReportProgress$fReadReportProgress$fEqReportProgress$fGenericReportProgress$fShowIterations$fReadIterations$fEqIterations$fGenericIterations $fShowThreads $fReadThreads $fEqThreads$fGenericThreadsSelector ExpectationshouldBe shouldNotBe shouldSatisfyshouldSatisfyNamedshouldNotSatisfyshouldNotSatisfyNamed shouldReturnshouldNotReturnshouldStartWith shouldEndWith shouldContainshouldMatchListstringShouldBe textShouldBe%stringsNotEqualButShouldHaveBeenEqual#textsNotEqualButShouldHaveBeenEqual)bytestringsNotEqualButShouldHaveBeenEqualexpectationFailurecontext shouldThrow anyException anyErrorCall errorCallanyIOExceptionanyArithExceptionpureGoldenByteStringFilegoldenByteStringFilepureGoldenLazyByteStringFilegoldenLazyByteStringFilepureGoldenByteStringBuilderFilegoldenByteStringBuilderFilepureGoldenTextFilegoldenTextFilepureGoldenStringFilegoldenStringFilegoldenShowInstancegoldenPrettyShowInstance goldenContextSpecTree SpecifyNode PendingNode DescribeNode SubForestNode SpecForestflattenSpecForestflattenSpecTree$fTraversableSpecTree$fFoldableSpecTree$fFunctorSpecTree TestRunReporttestRunReportExpectationModetestRunReportRawResultstestRunReportFlakinessModeTestSuiteStatstestSuiteStatSuccessestestSuiteStatExamplestestSuiteStatFailurestestSuiteStatFlakyTeststestSuiteStatPendingtestSuiteStatSumTimetestSuiteStatLongestTime ResultTree ResultForestExpectationMode ExpectPassing ExpectFailing FlakinessMode MayNotBeFlaky MayBeFlakyExecutionOrderRandomisationRandomiseExecutionOrderDoNotRandomiseExecutionOrder ParallelismParallel Sequential SpecDefTreeDefSpecifyNodeDefPendingNodeDefDescribeNode DefWrapNodeDefBeforeAllNodeDefAroundAllNodeDefAroundAllWithNodeDefAfterAllNodeDefParallelismNodeDefRandomisationNodeDefRetriesNodeDefFlakinessNodeDefExpectationNode SpecDefForestTestTree TestForestTDef testDefValtestDefCallStackfilterTestForestrandomiseTestForestmarkSpecForestAsPendingcomputeTestSuiteStatsshouldExitFailtestRunReportReportedRuntestRunReportFailedtestRunReportStatus testStatusMatchesExpectationModetestRunReportExamplestestRunResultExamplestestRunReportWasFlakytestRunReportRetries$fTraversableSpecDefTree$fFoldableSpecDefTree$fFunctorSpecDefTree$fMonoidTestSuiteStats$fSemigroupTestSuiteStats$fShowTestRunReport$fGenericTestRunReport$fShowTestSuiteStats$fEqTestSuiteStats$fShowExpectationMode$fEqExpectationMode$fGenericExpectationMode$fShowFlakinessMode$fEqFlakinessMode$fGenericFlakinessMode!$fShowExecutionOrderRandomisation$fEqExecutionOrderRandomisation$$fGenericExecutionOrderRandomisation$fShowParallelism$fEqParallelism$fGenericParallelism $fFunctorTDef$fFoldableTDef$fTraversableTDefNextContinueStop extractNext failFastNextapplySimpleWrapperapplySimpleWrapper'applySimpleWrapper''applySimpleWrapper2 $fFunctorNextrunSingleTestWithFlakinessMode TestDefEnvtestDefEnvDescriptionPathtestDefEnvTestRunSettingsTestDefM unTestDefMTestDefSpecMSpecWithSpec execTestDefM runTestDefMgetTestDescriptionPathtoTestRunSettings$fFunctorTestDefM$fApplicativeTestDefM$fMonadTestDefM$fMonadIOTestDefM$fMonadReaderTestDefEnvTestDefM$fMonadWriter[]TestDefM$fShowTestDefEnv$fEqTestDefEnv$fGenericTestDefEnvdescribe xdescribeitxitspecifyxspecify itWithOuter xitWithOuterspecifyWithOuterxspecifyWithOuter itWithBoth xitWithBothspecifyWithBothxspecifyWithBoth itWithAll xitWithAllspecifyWithAllxspecifyWithAllproppending pendingWith scenarioDirscenarioDirRecur beforeAll beforeAll_ beforeAllWithafterAll afterAll' afterAll_ aroundAll aroundAllWith wrapForestbeforebefore_ beforeWith beforeWith'afterafter_around aroundWith aroundWith' SetupFunc unSetupFuncbracketSetupFunc setupAroundsetupAroundWithsetupAroundWith'setupAroundAllsetupAroundAllWith$fMonadIOSetupFunc$fMonadSetupFunc$fApplicativeSetupFunc$fFunctorSetupFunc tempDirSpectempDirSetupFunc#tempBinaryFileWithContentsSetupFuncmodifyRunSettingsmodifyMaxSuccessmodifyMaxDiscardRatio modifyMaxSizemodifyMaxShrinks sequentialparallelwithParallelismdoNotRandomiseExecutionOrderrandomiseExecutionOrderwithExecutionOrderRandomisation modifyRetrieswithoutRetries withRetriesflaky flakyWithnotFlakypotentiallyFlakypotentiallyFlakyWith withFlakiness expectPassing expectFailingwithExpectationModerunSpecForestSynchronouslyprintOutputSpecForestrenderResultReportoutputResultReportoutputFailuresHeaderoutputFailuresWithHeading outputStatsoutputTestsHeader outputHeaderoutputSpecForestoutputSpecTreeoutputDescribeLineoutputSpecifyLinesexampleNrChunk timeChunkFor retriesChunks labelsChunks classesChunks tablesChunksoutputPendingLinesoutputFailureLabels commaListoutputFailureClassesoutputGoldenCase spacingChunkoutputFailuresoutputSomeExceptionoutputAssertionoutputEqualityAssertionFailedoutputNotEqualAssertionFailed%outputPredicateSuccessAssertionFailed"outputPredicateFailAssertionFailedmContextChunks stringChunksindexed statusColourstatusCheckMarkresultForestWidthspecForestWidthpadding paddingSizeorangedarkRed/runSpecForestInterleavedWithOutputSynchronouslyrunSpecForestAsynchronously0runSpecForestInterleavedWithOutputAsynchronously sydTestResult sydTestOncesydTestIterationssetPseudorandomnesssydTest sydTestWithrunIOversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirbaseGHC.Exception.Type SomeException GHC.MaybeNothing GHC.Conc.IO threadDelay text-1.2.5.0Data.Text.InternalText.autodocodec-yaml-0.2.0.2-2kiBmH0bSpLDNt2ozLqETAutodocodec.Yaml.IOreadYamlConfigFilereadFirstYamlConfigFileMaybeghc-prim GHC.Classes==Text.Show.ValueValueGHC.Showshowbytestring-0.11.3.1Data.ByteString.Internal ByteStringrunSingleTestWithRetriesControl.Exception.BasebracketControl.Monad.IO.ClassliftIOMonadIO