h$      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                       Safe-Inferred Safe-Inferred '(/>  Safe-Inferred#$/58> sydtestIn nanosecondssydtestA 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.3sydtest!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.5sydtestRead the golden test output, " if there is no golden output yet.6sydtestProduce the current output7sydtestWrite golden output8sydtest)Compare golden output with current outputThe first argument is the current output, the second is the golden output:sydtestThe argument from  aroundAll;sydtestThe argument from around<sydtestRunning the test, safelyHsydtestTime 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.>  &%$(#'" !)*10/-.,+23487659<;:=>?@ABCDEFGH>9<;:=>?@ABCD348765EF2)*10/-.,+G&%$(#'" !H  None #$8) ksydtest*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$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 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 1111111111None- 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)345678345678 Safe-Inferred5.E Safe-Inferred #$'(/0567>?5xsydtestA tree of testsThis 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 (TestDefM is a monad.)5In practice, all of these three parameters should be () at the top level.When you're just using sydtest and not writing a library for sydtest, you probably don't even want to concern yourself with this type.sydtest Define a testsydtestDefine a pending testsydtestGroup tests using a descriptionsydtest;Control the level of parallelism for a given group of testssydtestControl the execution order randomisation for a given group of tests sydtestThe description of the testsydtestHow the test can be run given a function that provides the resourcessydtestThe description of the testsydtest"The reason why the test is pendingsydtestThe descriptionsydtest*The function that wraps running the tests.sydtestThe function to run (once), beforehand, to produce the outer resource.sydtestThe function that provides the outer resource (once), around the tests.sydtestThe function that provides the new outer resource (once), using the old outer resource.sydtestThe function to run (once), afterwards, using all outer resources.sydtestThe level of parallelismsydtest!The execution order randomisation##  Safe-Inferred  /5?67   None #$'(/567>?9sydtestThe 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 hspec   None '(/>?T6sydtestDeclare 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 NoneVsydtest3Define 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 None[FsydtestFor defining a part of a test suite in 'ReaderT IO' instead of in .This way you can write this: spec :: Spec spec = around withConnectionPool $ it "can read what it writes" $ \pool -> let person = Person { name = "Dave", age = 25 } i <- runSqlPool (insert person) pool person' <- runSqlPool (get i) pool person' `shouldBe` personlike this instead: spec :: Spec spec = around withConnectionPool $ eit "can read what it writes" $ do let person = Person { name = "Dave", age = 25 } i <- runDB $ insert person person' <- runDB $ get i liftIO $ person' `shouldBe` person runDB :: ReaderT ConnectionPool IO a -> IO aNote that you use  with a property test. In that case you would have to write it like this: spec :: Spec spec = around withConnectionPool $ it "can read what it writes" $ \pool -> do forAllValid $ \person -> withTestEnv pool $ do i <- runDB $ insert person person' <- runDB $ get i liftIO $ person' `shouldBe` personsydtest/Helper function to run a property test with an env. withTestEnv = flip runReaderTNone '(/>?gY 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  None '(/>?se sydtestRun a custom action before every spec item, to set up an inner resource inner.sydtestRun a custom action before every spec item without setting up any inner resources.sydtestRun a custom action before every spec item, to set up an inner resource newInner& using the previously set up resource oldInnersydtestRun 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 resourcessydtestRun a custom action after every spec item, using the inner resource c.sydtestRun a custom action after every spec item without using any inner resources.sydtestRun 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 .sydtestRun 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.sydtestRun 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 .sydtestRun 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.sydtestThe 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?@ABCDEFGH345678)*+,.-/019:;< !"#$%&'(()*+,-./01234567899:;<=>?@ABCDDEFGHIJKLMMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                      &sydtest-0.2.0.0-A77DsOekMCr5KV8bG8WOv1Test.SydTest.Syd.HList Test.Syd.RunTest.Syd.OptParseTest.Syd.ExpectationTest.Syd.Def.GoldenTest.Syd.SpecForestTest.Syd.SpecDefTest.Syd.Runner.WrappersTest.Syd.Def.TestDefMTest.Syd.Def.SpecifyTest.Syd.Def.ScenarioTest.Syd.Def.EnvTest.Syd.Def.AroundAllTest.Syd.Def.AroundTest.Syd.Def.SetupFunc Test.Syd.PathTest.Syd.ModifyTest.Syd.OutputTest.Syd.Runner.SynchronousTest.Syd.Runner.AsynchronousTest.Syd.Runner Paths_sydtestaround_ aroundAll_ Test.Syd.Def'pretty-show-1.10-KoCV1zEW9bj1zBOK0T05RLText.Show.PrettyppShow HContainsgetElemHListHNilHCons $fHContains:a$fHContains:a0$fHContains:a1$fHContainslHList$fHContains[]()Timed timedValue timedTime GoldenCaseGoldenNotFound GoldenStarted GoldenReset AssertionNotEqualButShouldHaveBeenEqualEqualButShouldNotHaveBeenEqual%PredicateSucceededButShouldHaveFailed%PredicateFailedButShouldHaveSucceededExpectationFailedContext TestStatus TestPassed TestFailed TestRunResulttestRunResultStatustestRunResultExceptiontestRunResultNumTeststestRunResultNumShrinkstestRunResultFailingInputstestRunResultLabelstestRunResultClassestestRunResultTablestestRunResultGoldenCasetestRunResultExtraInfoTestRunSettingstestRunSettingSeedtestRunSettingMaxSuccesstestRunSettingMaxSizetestRunSettingMaxDiscardRatiotestRunSettingMaxShrinkstestRunSettingGoldenStarttestRunSettingGoldenResetTest GoldenTestgoldenTestReadgoldenTestProducegoldenTestWritegoldenTestCompareIsTestArg1Arg2runTestrunPureTestWithArg applyWrapper2runIOTestWithArgmakeQuickCheckArgsrunPropertyTestWithArgaroundProperty aroundProp aroundRoserunGoldenTestWithArgexceptionHandlersdefaultTestRunSettingstimeItT$fExceptionAssertion $fIsTest-> $fIsTest->0 $fIsTestIO $fIsTest->1 $fIsTest->2$fIsTestGoldenTest $fIsTest->3 $fIsTest->4$fIsTestProperty $fIsTest->5 $fIsTest->6 $fIsTestIO0 $fIsTest->7 $fIsTest->8 $fIsTestBool $fShowTimed $fEqTimed$fGenericTimed$fFunctorTimed$fShowTestRunResult$fEqTestRunResult$fGenericTestRunResult$fShowGoldenCase$fEqGoldenCase$fGenericGoldenCase$fShowAssertion $fEqAssertion$fGenericAssertion$fShowTestStatus$fEqTestStatus$fGenericTestStatus$fShowTestRunSettings$fGenericTestRunSettingsFlagsflagConfigFileflagSeedflagRandomiseExecutionOrder flagThreadsflagMaxSuccess flagMaxSizeflagMaxDiscardflagMaxShrinksflagGoldenStartflagGoldenReset flagColour flagFilter flagFailFastflagIterations Environment envConfigFileenvSeedenvRandomiseExecutionOrder envThreads envMaxSize envMaxSuccess envMaxDiscard envMaxShrinksenvGoldenStartenvGoldenReset envColour envFilter envFailFast envIterations Configuration configSeedconfigRandomiseExecutionOrder configThreads configMaxSizeconfigMaxSuccessconfigMaxDiscardconfigMaxShrinksconfigGoldenStartconfigGoldenReset configColour configFilterconfigFailFastconfigIterations Iterations OneIteration ContinuousThreads SynchronousByCapabilities AsynchronousSettings settingSeedsettingRandomiseExecutionOrdersettingThreadssettingMaxSuccesssettingMaxSizesettingMaxDiscardsettingMaxShrinkssettingGoldenStartsettingGoldenReset settingColour settingFiltersettingFailFastsettingIterations getSettingsdefaultSettingscombineToSettingsgetConfigurationdefaultConfigFilegetEnvironmentenvironmentParsergetFlagsprefs_ flagsParser parseFlags$fYamlSchemaThreads$fYamlSchemaIterations$fYamlSchemaConfiguration$fFromJSONConfiguration $fShowFlags $fEqFlags$fGenericFlags$fShowEnvironment$fEqEnvironment$fGenericEnvironment$fShowConfiguration$fEqConfiguration$fGenericConfiguration$fShowSettings $fEqSettings$fGenericSettings$fShowIterations$fEqIterations$fGenericIterations $fShowThreads $fEqThreads$fGenericThreadsSelector ExpectationshouldBe shouldNotBe shouldSatisfyshouldSatisfyNamedshouldNotSatisfyshouldNotSatisfyNamed shouldReturnshouldNotReturnshouldStartWith shouldEndWith shouldContainstringShouldBe textShouldBe%stringsNotEqualButShouldHaveBeenEqual#textsNotEqualButShouldHaveBeenEqual)bytestringsNotEqualButShouldHaveBeenEqualexpectationFailurecontext shouldThrow anyException anyErrorCall errorCallanyIOExceptionanyArithExceptionpureGoldenByteStringFilegoldenByteStringFilepureGoldenLazyByteStringFilegoldenLazyByteStringFilepureGoldenByteStringBuilderFilegoldenByteStringBuilderFilepureGoldenTextFilegoldenTextFilepureGoldenStringFilegoldenStringFilegoldenShowInstancegoldenPrettyShowInstance goldenContextSpecTree SpecifyNode PendingNode DescribeNode SubForestNode SpecForestflattenSpecForestflattenSpecTree$fTraversableSpecTree$fFoldableSpecTree$fFunctorSpecTreeTestSuiteStatstestSuiteStatSuccessestestSuiteStatFailurestestSuiteStatPendingtestSuiteStatSumTimetestSuiteStatLongestTime ResultTree ResultForestExecutionOrderRandomisationRandomiseExecutionOrderDoNotRandomiseExecutionOrder ParallelismParallel Sequential SpecDefTreeDefSpecifyNodeDefPendingNodeDefDescribeNode DefWrapNodeDefBeforeAllNodeDefAroundAllNodeDefAroundAllWithNodeDefAfterAllNodeDefParallelismNodeDefRandomisationNode SpecDefForestTestTree TestForestTDef testDefValtestDefCallStackcomputeTestSuiteStatsshouldExitFail$fTraversableSpecDefTree$fFoldableSpecDefTree$fFunctorSpecDefTree$fMonoidTestSuiteStats$fSemigroupTestSuiteStats$fShowTestSuiteStats$fEqTestSuiteStats $fFunctorTDef$fFoldableTDef$fTraversableTDefNextContinueStop extractNext failFastNextapplySimpleWrapperapplySimpleWrapper'applySimpleWrapper''applySimpleWrapper2 $fFunctorNextTestDefM unTestDefMTestDefSpecMSpecWithSpec execTestDefM runTestDefMtoTestRunSettingsfilterTestForestrandomiseTestForest$fFunctorTestDefM$fApplicativeTestDefM$fMonadTestDefM$fMonadIOTestDefM$$fMonadReaderTestRunSettingsTestDefM$fMonadWriter[]TestDefM$fMonadState()TestDefMdescribe xdescribeitxitspecifyxspecify itWithOuter xitWithOuterspecifyWithOuterxspecifyWithOuter itWithBoth xitWithBothspecifyWithBothxspecifyWithBoth itWithAll xitWithAllspecifyWithAllxspecifyWithAllproppending pendingWith scenarioDirscenarioDirRecureit withTestEnv beforeAll beforeAll_ beforeAllWithafterAll afterAll' afterAll_ aroundAll aroundAllWithwrapRWSTbeforebefore_ beforeWith beforeWith'afterafter_around aroundWith aroundWith' SetupFunc unSetupFuncbracketSetupFunc setupAroundsetupAroundWithsetupAroundWith'setupAroundAllsetupAroundAllWith$fMonadIOSetupFunc$fMonadSetupFunc$fApplicativeSetupFunc$fFunctorSetupFunc tempDirSpectempDirSetupFunc#tempBinaryFileWithContentsSetupFuncmodifyRunSettingsmodifyMaxSuccessmodifyMaxDiscardRatio modifyMaxSizemodifyMaxShrinks sequentialparallelwithParallelismrandomiseExecutionOrderdoNotRandomiseExecutionOrderwithExecutionOrderRandomisationprintOutputSpecForestrenderResultReportoutputResultReportoutputFailuresHeaderoutputFailuresWithHeading outputStatsoutputTestsHeader outputHeaderoutputSpecForestoutputSpecTreeoutputDescribeLineoutputSpecifyLines labelsChunks classesChunks tablesChunksoutputPendingLinesoutputFailureLabels commaListoutputFailureClassesoutputGoldenCase spacingChunk testFailedoutputFailuresoutputAssertionoutputEqualityAssertionFailedoutputNotEqualAssertionFailed%outputPredicateSuccessAssertionFailed"outputPredicateFailAssertionFailedmContextChunks stringChunksindexed outputFailure statusColourstatusCheckMarkresultForestWidthspecForestWidthpadding paddingSizeorangedarkRedrunSpecForestSynchronously/runSpecForestInterleavedWithOutputSynchronously HandleTree HandleForestrunSpecForestAsynchronously0runSpecForestInterleavedWithOutputAsynchronouslymakeHandleForestrunnerprinterwaiter sydTestResult sydTestOncesydTestIterationssydTest sydTestWithrunIOversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNamebase GHC.MaybeNothing GHC.Conc.IO threadDelay text-1.2.3.2Data.Text.InternalText4yamlparse-applicative-0.1.0.4-ADJGAZ3W5NH48KD8N5bpQFYamlParse.Applicative.IOreadConfigFilereadFirstConfigFileMaybeghc-prim GHC.Classes==GHC.BaseStringGHC.Showshowbytestring-0.10.10.0Data.ByteString.Internal ByteString GHC.TypesIOControl.Exception.BasebracketControl.Monad.IO.ClassliftIOMonadIO