h&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm nopqrstuvwxy z { | } ~                                                                    Safe-Inferred6^ tastyThe exception thrown by  to terminate a thread.tasty"An asynchronous action spawned by  or . Asynchronous actions are executed in a separate thread, and operations are provided for waiting for asynchronous actions to complete and obtaining their results (see e.g. ).tasty Returns the " of the thread running the given .tasty2Spawn an asynchronous action in a separate thread.tastySpawn an asynchronous action in a separate thread, and pass its Async handle to the supplied function. When the function returns or throws an exception,  is called on the Async. withAsync action inner = mask $ \restore -> do a <- async (restore action) restore (inner a) `finally` uninterruptibleCancel aThis is a useful variant of  that ensures an Async( is never left running unintentionally.Note: a reference to the child thread is kept alive until the call to  returns, so nesting many  calls requires linear memory.tastyWait for an asynchronous action to complete, and return its value. If the asynchronous action threw an exception, then the exception is re-thrown by . wait = atomically . waitSTMtastyWait for an asynchronous action to complete, and return either Left e# if the action raised an exception e, or Right a if it returned a value a. %waitCatch = atomically . waitCatchSTMtasty A version of , that can be used inside an STM transaction.tasty A version of , that can be used inside an STM transaction.tasty.Cancel an asynchronous action by throwing the AsyncCancelled' exception to it, and waiting for the ' thread to quit. Has no effect if the  has already completed. cancel a = throwTo (asyncThreadId a) AsyncCancelled <* waitCatch a Note that ) will not terminate until the thread the , refers to has terminated. This means that  will block for as long said thread blocks when receiving an asynchronous exception.For example, it could block if:It's executing a foreign call, and thus cannot receive the asynchronous exception;It's executing some cleanup handler after having received the exception, and the handler is blocking.tastyCancel an asynchronous actionThis is a variant of , but it is not interruptible.tastyRun two IO actions concurrently, and return both results. If either action throws an exception at any time, then the other action is (led, and the exception is re-thrown by . concurrently left right = withAsync left $ \a -> withAsync right $ \b -> waitBoth a b Safe-Inferred )*6tastyThe purpose of this data type is to capture the dictionary corresponding to a particular option.tasty;A set of options. Only one option of each type can be kept.If some option has not been explicitly set, the default value is used.tasty+An option is a data type that inhabits the  type class.tasty:The value to use if the option was not supplied explicitlytasty some singleUnaryOpThis is not done by default because in some cases allowing repeating prefix or postfix operators is not desirable.If you want to have an operator that is a prefix of another operator in the table, use the following (or similar) wrapper instead of plain : op n = (lexeme . try) (string n <* notFollowedBy punctuationChar) takes care of all the complexity involved in building an expression parser. Here is an example of an expression parser that handles prefix signs, postfix increment and basic arithmetic: expr = makeExprParser term table "expression" term = parens expr <|> integer "term" table = [ [ prefix "-" negate , prefix "+" id ] , [ postfix "++" (+1) ] , [ binary "*" (*) , binary "/" div ] , [ binary "+" (+) , binary "-" (-) ] ] binary name f = InfixL (f <$ symbol name) prefix name f = Prefix (f <$ symbol name) postfix name f = Postfix (f <$ symbol name)tastyaddPrecLevel p ops. adds the ability to parse operators in table ops to parser p.tastypTerm prefix term postfix parses a term surrounded by optional prefix and postfix unary operators. Parsers prefix and postfix$ are allowed to fail, in this case  is used.tastypInfixN op p x' parses non-associative infix operator op, then term with parser p5, then returns result of the operator application on x and the term.tastypInfixL op p x( parses left-associative infix operator op, then term with parser p5, then returns result of the operator application on x and the term.tastypInfixR op p x) parses right-associative infix operator op, then term with parser p6, then returns result of the operator application on x and the term.tasty/Parse the first separator of a ternary operatortastyA helper to separate various operators (binary, unary, and according to associativity) and return them in a tuple.tasty Term parsertastyOperator table, see tastyResulting expression parser Safe-Inferred6;-tastynumber of fields(tastynth field of the path, where 1 is the outermost group name and 0 is the whole test name, using . (dot) as a separator+tastyan ERE token by itself, like foo but not like $1 ~ foo0/.-,+)('%$#! &*"0/.-,+)('%$#! &*" Safe-Inferred6-4tasty44 Safe-Inferred63 tasty'Whether a parser is unary or non-unary. This roughly corresponds to the  unary_expr and non_unary_expr7 non-terminals in the awk grammar. (Why roughly? See expr2.)9tasty A separate 98 data type ensures that we don't forget to skip spaces.:tasty Run a parsertastyAn awk ERE token such as foo>. No special characters are recognized at the moment, except @ as an escape character for /@ and itself.tastyBuilt-in functionstastyAtomic expressionstastyArguments to unary operators: atomic expressions and field expressionstastyArithmetic expressions.Unlike awk, non-unary expressions disallow unary operators everywhere, not just in the leading position, to avoid extra complexity in makeExprParser.For example, the expression 1 3 + -4is valid in awk because 3 + -40 is non-unary, but we disallow it here because makeExprParser) does not allow us to distinguish it from 1 -4 + 3which is ambiguous.tasty1Expressions that may include string concatenationtasty3Everything with lower precedence than concatenation;tastyThe awk-like expression parser<tastyParse an awk expression:tasty text to parse56789:;<9:5678;< Safe-Inferred(64tastyThe  is 5 if the source of the string allows it to be numericFtastyEvaluate an awk expressionGtastyRun the M" monad with a given list of fields"The field list should not include $0 ; it's calculated automatically.tastypatterntastystringDEFGDFGE Safe-Inferred64DIJKLMNO Safe-Inferred68hPtasty)Timeout to be applied to individual testsQtasty9 is the original representation of the timeout (such as "0.5m"!), so that we can print it back.  is the number of microseconds.Stasty4Number of parallel threads to use for running tests.Note that this is not included in W. Instead, it's automatically included in the options for any   ingredient by  , because the way test reporters are handled already involves parallelism. Other ingredients may also choose to include this option.tasty should typically provide more information about the failure.tasty?The short description printed in the test run summary, usually OK or FAIL.tasty-How long it took to run the test, in seconds.tasty:An action that prints additional information about a test.This is similar to 7 except it can produce colorful/formatted output; see "Test.Tasty.Providers.ConsoleFormat..This can be used instead of or in addition to .Usually this is set to `, which does nothing.tastyTime in seconds. Used to measure how long the tests took to run.tastyOutcome of a test runNote: this is isomorphic to  . You can use the  generic-maybe package to exploit that.tastytest succeededtastytest failed because of the tastyIf a test failed,  describes whytastytest provider indicated failure of the code to test, either because the tested code returned wrong results, or raised an exceptiontastythe test code itself raised an exception. Typical cases include missing example input or output files.;Usually, providers do not have to implement this, as their {' method may simply raise an exception.tasty%test didn't complete in allotted timetasty;a dependency of this test failed, so this test was skipped.tasty for a passed test,  for a failed one.tastyShortcut for creating a  that indicates exceptiontasty2Create a named group of test cases or other groupstastyLike , but accepts the pattern as a syntax tree instead of a string. Useful for generating a test tree programmatically.Exampleswhether to run the tests even if some of the dependencies failtasty the patterntasty'the subtree that depends on other teststasty1the subtree annotated with dependency informationtasty>whether to run the tests even if some of the dependencies failtasty the patterntasty'the subtree that depends on other teststasty1the subtree annotated with dependency informationtasty%the algebra (i.e. how to fold a tree)tastyinitial optionstastythe tree to fold6glkjihmsrqpontvuwxyz|{}~  Safe-Inferred6^tasty Convert a test to a leaf of the mtasty of a passed testtasty of a failed testtasty- of a failed test with custom details printertastydescription (may be empty)tasty descriptiontasty descriptiontastydetails printermyz{|}~z{|}~ym Safe-Inferred6_tastyMonoid generated by  ()8Starting from GHC 8.6, a similar type is available from  Data.Monoid4. This type is nevertheless kept for compatibility.tastyMonoid generated by  Safe-Inferred6estastyThis exception is thrown when the program receives a signal, assuming  was called.The * field contains the signal number, as in . We don't use that type synonym, however, because it's not available on non-UNIXes.tastyCatch possible exceptions that may arise when evaluating a string. For normal (total) strings, this is a no-op.This function should be used to display messages generated by the test suite (such as test result descriptions). See e.g. 2https://github.com/UnkindPartition/tasty/issues/25tastyForce elements of a list ( 2https://ro-che.info/articles/2015-05-28-force-list)tastyInstall signal handlers so that e.g. the cursor is restored if the test suite is killed by SIGTERM. Upon a signal, a = will be thrown to the thread that has executed this action./This function is called automatically from the  defaultMain* family of functions. You only need to call it explicitly if you call  yourself.This function does nothing on non-UNIX systems or when compiled with GHC older than 7.6.tastyMeasure the time taken by an  action to runtastyGet monotonic timeWarning: This is not the system time, but a monotonically increasing time that facilitates reliable measurement of time differences. Safe-Inferred6ptasty1Exceptions related to dependencies between tests.tastyTest dependencies form a loop. In other words, test A cannot start until test B finishes, and test B cannot start until test A finishes.tastyTraversal type used in tastyDependencies of a testtastyMapping from test numbers (starting from 0) to their status variables.This is what an ingredient uses to analyse and display progress, and to detect when tests finish.tastyCurrent status of a testtasty test has not started running yettastytest is being runtasty!test finished with a given resulttasty'Execute a test taking care of resourcestastyTurn a test tree into a list of actions to run tests coupled with variables to watch them.tastyTake care of the dependencies.Return  if there is a dependency cycle.tastyUsed to create the IO action which is passed in a WithResource nodetastyRun a resource finalizer.2This function is called from two different places: 9A test thread, which is the last one to use the resource.;The main thread, if an exception (e.g. Ctrl-C) is received.Therefore, it is possible that this function is called multiple times concurrently on the same finalizer.This function should be run with async exceptions masked, and the restore function should be passed as an argument.tastyStart running the tests (in background, in parallel) and pass control to the callback.2Once the callback returns, stop running the tests.8The number of test running threads is determined by the S option.tastyLike  (which also masks its finalizers), but pass the restore action to the finalizer.tastythe action to execute the test, which takes a progress callback as a parametertastyvariable to write status totastyoptional timeout to applytasty+initializers (to be executed in this order)tasty)finalizers (to be executed in this order)tasty#A callback. First, it receives the  through which it can observe the execution of tests in real time. Typically (but not necessarily), it waits until all the tests are finished.After this callback returns, the test-running threads (if any) are terminated and all resources acquired by tests are released.3The callback must return another callback (of type  ->  a) which additionally can report and/or record the total time taken by the test suite. This time includes the time taken to run all resource initializers and finalizers, which is why it is more accurate than what could be measured from inside the first callback.tastycomputation to run firsttasty>computation to run afterward (even if an exception was raised)tasty,returns the value from the first computation  Safe-Inferred6~tastys make your test suite tasty.Ingredients represent different actions that you can perform on your test suite. One obvious ingredient that you want to include is one that runs tests and reports the progress and results.Another standard ingredient is one that simply prints the names of all tests.Similar to test providers (see z), every ingredient may specify which options it cares about, so that those options are presented to the user if the ingredient is included in the test suite.1An ingredient can choose, typically based on the #, whether to run. That's what the  is for. The first ingredient that agreed to run does its work, and the remaining ingredients are ignored. Thus, the order in which you arrange the ingredients may matter.Usually, the ingredient which runs the tests is unconditional and thus should be placed last in the list. Other ingredients usually run only if explicitly requested via an option. Their relative order thus doesn't matter.That's all you need to know from an (advanced) user perspective. Read on if you want to create a new ingredient.#There are two kinds of ingredients.The first kind is -. If the ingredient that agrees to run is a =, then tasty will automatically launch the tests and pass a  to the ingredient. All the ingredient needs to do then is to process the test results and probably report them to the user in some way (hence the name). is the second kind of ingredient. It is typically used for test management purposes (such as listing the test names), although it can also be used for running tests (but, unlike , it has to launch the tests manually if it wants them to be run). It is therefore more general than . # is provided just for convenience.The function's result should indicate whether all the tests passed.In the  case, it's up to the ingredient author to decide what the result should be. When no tests are run, the result should probably be . Sometimes, even if some tests run and fail, it still makes sense to return .tastyFor the explanation on how the callback works, see the documentation for .tastyTry to run an .7If the ingredient refuses to run (usually based on the ), the function returns .For a , this function automatically starts running the tests in the background.tastyRun the first  that agrees to be run.#If no one accepts the task, return .. This is usually a sign of misconfiguration.tasty?Return the options which are relevant for the given ingredient.=Note that this isn't the same as simply pattern-matching on . E.g. options for a  automatically include S.tastyLike &, but folds over multiple ingredients.tastyAll the options relevant for this test suite. This includes the options for the test tree and ingredients, and the core options.tasty Compose two  ingredients which are then executed in parallel. This can be useful if you want to have two reporters active at the same time, e.g., one which prints to the console and one which writes the test results to a file.(Be aware that it is not possible to use  with a , it only works for  ingredients. Safe-Inferred6jtasty(Search the environment for given optionstasty>Search the environment for all options relevant for this suite Safe-Inferred6tastyThis option, when set to 8, specifies that we should run in the list tests modetasty)Obtain the list of all tests in the suitetasty;The ingredient that provides the test listing functionality  Safe-Inferred6ItastyThis ingredient doesn't do anything apart from registering additional options.(The option values can be accessed using !. None 6tastyBy default, when the option --hide-successes is given and the output goes to an ANSI-capable terminal, we employ some ANSI terminal tricks to display the name of the currently running test and then erase it if it succeeds.These tricks sometimes fail, however@in particular, when the test names happen to be longer than the width of the terminal window. See 3https://github.com/UnkindPartition/tasty/issues/152 3https://github.com/UnkindPartition/tasty/issues/250When that happens, this option can be used to disable the tricks. In that case, the test name will be printed only once the test fails. tastyWhen to use color on the outputtasty3Only if stdout is an ANSI color supporting terminaltastyReport only failed tests.At the moment, this option only works globally. As an argument to ", it does nothing.tasty2Do not print test results (see README for details) tasty:Track the number of tests that were run and failures of a m or sub-tree.tastyNumber of active tests (e.g., that match the pattern specified on the commandline), inactive tests are not counted.tasty#Number of active tests that failed. tasty is an intermediary between output formatting and output printing. It lets us have several different printing modes (normal; print failures only; quiet).tastyName of a test, an action that prints the test name, and an action that renders the result of the action.tastyName of a test group, an action that prints the heading of a test group and the  for that test group.tasty5Inactive test (e.g. not matching the current pattern)tasty Two sets of  on the same level tasty Build the  for a m and . The colors7 ImplicitParam controls whether the output is colored. tastyFold function for the  tree into a .tastycomputeStatistics computes a summary  for a given state of the . Useful in combination with printStatistics tastyprintStatistics reports test success/failure statistics and time it took to run. The , results is intended to be filled in by the  callback. The colors9 ImplicitParam controls whether coloured output is used. tastyprintStatisticsNoTime. reports test success/failure statistics The colors8 ImplicitParam controls whether coloured output is used.tasty Wait until1all tests have finished successfully, and return , or)at least one test has failed, and return tastyA simple console UItastyA simple console UI with a hook to postprocess results, depending on their names and external conditions (e. g., its previous outcome, stored in a file). Names are listed in reverse order: from test's own name to a name of the outermost test group. tastyuseColor when isTerm, decides if colors should be used, where isTerm indicates whether stdout is a terminal device.tasty=Compute the amount of space needed to align "OK"s and "FAIL"stastyCompute the length/width of the string as it would appear in a monospace terminal. This takes into account that even in a @mono@space font, not all characters actually have the same width, in particular, most CJK characters have twice the same as Western characters.(This only works properly on Unix at the moment; on Windows, the function treats every character as width-1 like #$ does.)tasty?Run action with console configured for a specific output formatThis function does not apply any output formats if colors are disabled at command line or console detection.Can be used by providers that wish to provider specific result details printing, while re-using the tasty formats and coloring logic.tastyControl color outputtastyEliminator for test cases. The IO () prints the testname. The  IO Result3 blocks until the test is finished, returning it's . The Result -> IO ()& function prints the formatted output.tasty Eliminator for test groups. The IO ()$ prints the test group's name. The b) is the result of folding the test group.tastyThe  TestOutput being rendered.tastyThe  StatusMap received by the tasty lookaheadtasty%list of (pre-intercalated) test namestastycurrent pattern, if anytasty:name of current test, represented as a list of group namestastyvanilla result  Safe-Inferred6N  % Safe-Inferred6tastyGenerate a command line parser from a list of option descriptions, alongside any related warning messages.tastyThe command line parser for the test suite, alongside any related warnings.tasty?Parse the command-line and environment options passed to tasty.-Useful if you need to get the options before & is called.Once within the test tree, ! should be used instead.:The arguments to this function should be the same as for 1. If you don't use any custom ingredients, pass '.tastyParse the command line arguments and run the tests using the provided ingredient list.+When the tests finish, this function calls  with the exit code that indicates whether any tests have failed. See & for details. Safe-Inferred6 DIJKLMNOSTUWghijklmnopqrswx}~mnopqrsghijklwx}~STUWIJLMKDNO Safe-Inferred6tasty.List of the default ingredients. This is what  uses.At the moment it consists of  and .tasty3Parse the command line arguments and run the tests.+When the tests finish, this function calls () with the exit code that indicates whether any tests have failed. Most external systems (stack, cabal, travis-ci, jenkins etc.) rely on the exit code to detect whether the tests pass. If you want to do something else after  returns, you need to catch the exception and then re-throw it. Example: import Test.Tasty import Test.Tasty.HUnit import System.Exit import Control.Exception test = testCase "Test 1" (2 @?= 3) main = defaultMain test `catch` (\e -> do if e == ExitSuccess then putStrLn "Yea" else putStrLn "Nay" throwIO e)tasty:Locally adjust the option value for the given test subtreetasty7Locally set the option value for the given test subtreetasty5Customize the test tree based on the run-time optionstastyAcquire the resource to run this test (sub)tree and release it afterwardstastyinitialize the resourcetastyfree the resourcetasty a is an action which returns the acquired resource. Despite it being an  action, the resource it returns will be acquired only once and shared across all the tests in the tree.PQRVmtuvyymPQRVtuv*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsstuvwxyyz{{|}~`                                                          %%%%'&"!                 ()"tasty-1.4.3-ArbL0exQAwC9ASqcryB3P1Test.Tasty.OptionsTest.Tasty.Patterns.TypesTest.Tasty.Patterns.PrinterTest.Tasty.Patterns.ParserTest.Tasty.Patterns.EvalTest.Tasty.Runners Test.Tasty"Test.Tasty.Providers.ConsoleFormatTest.Tasty.ProvidersTest.Tasty.IngredientsTest.Tasty.Ingredients.Basic&Test.Tasty.Ingredients.ConsoleReporterControl.Concurrent.AsyncTest.Tasty.ParallelTest.Tasty.Patterns.ExprText.Megaparsec.Char.LexersymbolTest.Tasty.PatternsTest.Tasty.Options.Core TestReporteringredientOptionstestFailedDetailsresultDetailsPrinterTest.Tasty.CoreDependencyLoopTest.Tasty.Runners.ReducersTest.Tasty.Runners.UtilstryIngredientsTest.Tasty.RunTest.Tasty.Options.Env Test.Tasty.Ingredients.ListTests'Test.Tasty.Ingredients.IncludingOptions askOption localOption Data.ListlengthTest.Tasty.CmdLine defaultMaindefaultIngredients System.ExitexitWithOptionDescriptionOption OptionSetIsOption defaultValue parseValue optionName optionHelpshowDefaultValueoptionCLParser setOption lookupOption changeOption singleOptionuniqueOptionDescriptions flagCLParsermkFlagCLParsermkOptionCLParsersafeRead safeReadBool$fMonoidOptionSet$fSemigroupOptionSetExprIntLitNFAddSubNegNotAndLTGTLEGEEQNEOrConcatMatchNoMatchField StringLitIfERE ToUpperFn ToLowerFnLengthFnMatchFnSubstrFn $fShowExpr$fEqExpr $fGenericExpr printAwkExpr ParseResultSuccessInvalid AmbiguousParser runParserexpr parseAwkExpr$fEqParseResult$fShowParseResult$fFunctorParser$fApplicativeParser$fAlternativeParser $fMonadParser$fMonadPlusParserPathasBeval withFields $fShowValue TestPattern noPattern parseExprparseTestPattern exprMatchestestPatternMatchesTimeout NoTimeout NumThreads getNumThreads mkTimeout coreOptionsResultDetailsPrinterConsoleFormatPrinter ConsoleFormatconsoleIntensitycolorIntensitycolornoResultDetails failFormatinfoFailFormatokFormat infoOkFormat skippedFormat$fShowResultDetailsPrinterTreeFold foldSingle foldGroup foldResource foldAfterTestTree SingleTest TestGroupPlusTestOptions WithResource AskOptionsAfterDependencyType AllSucceed AllFinish ResourceSpecTestNameIsTestrun testOptionsProgress progressTextprogressPercentResult resultOutcomeresultDescriptionresultShortDescription resultTimeTimeOutcomeFailure FailureReason TestFailedTestThrewException TestTimedOut TestDepFailedresultSuccessful testGroupafter_after trivialFold foldTestTree singleTest testPassed testFailedApgetApp Traversal getTraversalSignalException formatMessage forceElementsinstallSignalHandlerstimedgetTimeDependencyException StatusMapStatus NotStarted ExecutingDonelaunchTestTree Ingredient TestManageringredientsOptions suiteOptionscomposeReporters ListTests testsNames listingTestsincludingOptions AnsiTricks getAnsiTricksUseColorNeverAlwaysAuto HideSuccessesQuiet Statistics statTotal statFailures TestOutput PrintTest PrintHeadingSkipSeqbuildTestOutputfoldTestOutputcomputeStatisticsprintStatisticsprintStatisticsNoTimeconsoleTestReporterconsoleTestReporterWithHookuseColorwithConsoleFormat$fMonoidTestOutput$fSemigroupTestOutput$fMonoidStatistics$fSemigroupStatistics$fIsOptionQuiet$fIsOptionHideSuccesses$fIsOptionUseColor$fIsOptionAnsiTricks$fMonoidMaximum$fSemigroupMaximum $fEqUseColor $fOrdUseColor$fEqHideSuccesses$fOrdHideSuccesses $fEqQuiet $fOrdQuiet optionParsersuiteOptionParser parseOptionsdefaultMainWithIngredients adjustOption withResourceAsyncCancelledcancelAsyncasync withAsyncwait asyncThreadIdbase GHC.Conc.SyncThreadIduninterruptibleCancel waitCatchwaitSTM waitCatchSTM concurrently GHC.MaybeNothingJust4optparse-applicative-0.17.0.0-Fu7EooesEeZLlVqBFYQxjKOptions.Applicative.BuildervalueshowDefaultWithghc-prim GHC.TypesBool ActionStatusAction ActionReady ActionSkip ActionWait runInParallelfindBool actionStatus actionRun actionSkipOperatorInfixNInfixLInfixRPrefixPostfixTernRmakeExprParser addPrecLevelpTermGHC.BaseidpInfixNpInfixLpInfixRpTernRsplitOpUnarypatPbuiltinexpr0expr1expr2expr3expr4VSTruematchString ghc-bignumGHC.Num.IntegerInteger onlyPositiveGHC.ShowShowIO ResourceErrorMaybeFalseexceptionResultmempty treeOptionsUseOutsideOfTestUnexpectedStateNotRunningTestsliftA2<>*>Foreign.C.TypesCInt unix-2.7.2.2System.Posix.SignalsSignalTrcreateTestActionsDeps executeTest resolveDeps getResourcedestroyResourcefinallyRestoreControl.Exception.Basefinally tryIngredient getEnvOptionssuiteEnvOptionsMonoidstatusMapResultcomputeAlignment stringWidthappendPatternIfTestFailed