h$      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                        None5?HMock*A value together with its source location.HMock?Annotates a value with its source location from the call stack.HMock Formats a   to include its source location.HMockReturns all ways to choose one element from a list, and the corresponding remaining list.HMock3Checks if one sequence is a subsequence of another.None  HMock Fetches the  of a . HMock Creates a 0 for a plain variable without a kind annotation. HMock:Gets the unapplied top-level name from a type application.HMockSubstitutes a " for all occurrences of the given .HMock2Makes variable substitutions from the given table.HMockSplits a function type into a list of bound type vars, context, parameter types, and return value type.HMockGets all free type variable s in the given .HMock Produces a  that gives all given variable s all of the given class s.HMockCulls the given binders and constraints to choose only those that apply to free variables in the given type.HMockAttempts to unify the given types by constructing a table of substitutions for the variables of the left type that obtain the right one.HMockRemoves all module names from s in the given value, so that it will pretty-print more cleanly.HMockDetermines if there is a polytype nested anywhere in the given type. Top-level quantification doesn't count.HMockDetermines if this is a polytype, including top-level quantification.HMock9Attempts to produce sufficient constraints for the given ' to be an instance of the given class .HMockSimplifies a context with complex types (requiring FlexibleContexts) to try to obtain one with all constraints applied to variables.HMock&Remove instance context from a method.Some GHC versions report class members including the instance context (for example, show :: Show a => a -> String , instead of show :: a -> String). This looks for the instance context, and substitutes if needed to eliminate it.   Safe-Inferred '(/>U HMock A class for ? subclasses whose methods can be mocked. This class augments ; with a setup method that is run before HMock touches the  subclass for the first time. The default implementation does nothing, but you can derive your own instances that add setup behavior.HMockA base class for  subclasses whose methods can be mocked. You usually want to generate this instance using , , , or . It's just boilerplate.HMockAn action that is performed. This data type will have one constructor for each method.HMockA specification for matching actions. The actual arguments should be replaced with predicates. HMockGets a text description of an , for use in error messages.!HMockGets a text description of a , for use in error messages."HMockAttempts to match an  with a .#HMockThe result of matching a  a with an  b. Because the types should already guarantee that the methods match, all that's left is to match arguments.$HMock?No match. The int is the number of arguments that don't match.%HMock8Match. Stores a witness to the equality of return types.  !"#%$  !"#%$ Safe-Inferred'(/{&HMockA rule for matching a method and responding to it when it matches.1The method may be matched by providing either an  to match exactly, or a =. Exact matching is only available when all method argumentsA &< may have zero or more responses, which are attached using   and  $. If there are no responses for a &, then there must be a default response for that action, and it is used. If more than one response is added, the rule will perform the responses in order, repeating the last response if there are additional matches.Example:   $ GetLine_    "hello"  5 (GetLine prompt) -> "The prompt was " ++ prompt   "quit" (HMockA way to match an entire action, using conditions that might depend on the relationship between arguments.+HMockDisplays a WholeMethodMatcher. The predicate isn't showable, but we can at least indicate whether there is one present.&'()*+()*+&' Safe-Inferred3 ,HMock?An acceptable range of number of times for something to happen.3A multiplicity can have a lower and an upper bound.-HMock.Checks whether a certain number satisfies the ,..HMockA , that means exactly once.meetsMultiplicity once 0FalsemeetsMultiplicity once 1TruemeetsMultiplicity once 2False/HMockA , that means any number of times. >>> meetsMultiplicity anyMultiplicity 0 True >>> meetsMultiplicity anyMultiplicity 1 True >>> meetsMultiplicity anyMultiplicity 10 True0HMockA ,% that means at least this many times.meetsMultiplicity (atLeast 2) 1FalsemeetsMultiplicity (atLeast 2) 2TruemeetsMultiplicity (atLeast 2) 3True1HMockA ,$ that means at most this many times.meetsMultiplicity (atMost 2) 1TruemeetsMultiplicity (atMost 2) 2TruemeetsMultiplicity (atMost 2) 3False2HMockA , that means any number in this interval, endpoints included. For example, 2 2 3 means 2 or 3 times, while 2 n n is equivalent to n.!meetsMultiplicity (between 2 3) 1False!meetsMultiplicity (between 2 3) 2True!meetsMultiplicity (between 2 3) 3True!meetsMultiplicity (between 2 3) 4False3HMockChecks whether a ,* is capable of matching any number at all. feasible onceTrue feasible 0Truefeasible (once - 2)False4HMock9This is an incomplete instance, provided for convenience.meetsMultiplicity 5 4FalsemeetsMultiplicity 5 5Truebetween 4 6 - between 1 2 2 to 5 times,-./0123,-3./012None(3$V 7HMockA higher-level intermediate form of an ExpectSet suitable for communication with the user. Chains of binary operators are collected into sequences to be displayed in lists rather than arbitrary nesting.?HMockA set of expected steps and their responses. This is the "core" language of expectations for HMock. It's based roughly on Svenningsson, Svensson, Smallbone, Arts, Norell, and Hughes' Expressive Semantics of Mocking. However, there are a few small adjustments. We have two repetition operators which respectively represent general repetition with interleaving, and consecutive repetition. We also attach arbitrary multiplicities to repetition.GHMockChecks whether an ExpectSet is in an "accepting" state. In other words, is it okay for the test to end here? If False, then there are still expectations that must be satisfied before the test can succeed.HHMockComputes the live steps of the ExpectSet. In other words: which individual steps can be matched right now, and what are the remaining expectations in each case?IHMockPerforms a complete simplification of the ExpectSet. This could be slow, but we intend to do it only for error messages, so it need not be very fast.JHMock(Get a list of all steps mentioned by an ?. This is used to determine which classes need to be initialized before adding an expectation.KHMockCollects an ExpectSet into the intermediate form for display. It's assumed that the expression was simplified before this operation.LHMockConverts a set of expectations into a string that summarizes them, with the given prefix (used to indent).MHMockReduces a set of expectations to the minimum steps that would be required to satisfy the entire set. This weeds out unnecessary information before reporting that there were unmet expectations at the end of the test.7>=<;:98?FEDCBA@GHIJKLM?FEDCBA@GHIJ7>=<;:98KLMNone ?['2PHMockA predicate, which tests values and either accepts or rejects them. This is similar to a -> , but also has a + instance to describe what it is checking.Ps are used to define which arguments a general matcher should accept.THMockA P that accepts anything at all.accept anything "foo"Trueaccept anything undefinedTrueUHMockA P# that accepts only the given value.accept (eq "foo") "foo"Trueaccept (eq "foo") "bar"FalseVHMockA P+ that accepts anything but the given value.accept (neq "foo") "foo"Falseaccept (neq "foo") "bar"TrueWHMockA P4 that accepts anything greater than the given value.accept (gt 5) 4Falseaccept (gt 5) 5Falseaccept (gt 5) 6TrueXHMockA P that accepts anything greater than or equal to the given value.accept (geq 5) 4Falseaccept (geq 5) 5Trueaccept (geq 5) 6TrueYHMockA P1 that accepts anything less than the given value.accept (lt 5) 4Trueaccept (lt 5) 5Falseaccept (lt 5) 6FalseZHMockA P= that accepts anything less than or equal to the given value.accept (leq 5) 4Trueaccept (leq 5) 5Trueaccept (leq 5) 6False[HMockA P that accepts  values of  x, where x matches the given child P."accept (just (eq "value")) NothingFalse)accept (just (eq "value")) (Just "value")True/accept (just (eq "value")) (Just "wrong value")False\HMockA P that accepts an  value of  x, where x matches the given child P.)accept (left (eq "value")) (Left "value")True*accept (left (eq "value")) (Right "value")False/accept (left (eq "value")) (Left "wrong value")False]HMockA P that accepts an  value of  x, where x matches the given child P.+accept (right (eq "value")) (Right "value")True1accept (right (eq "value")) (Right "wrong value")False*accept (right (eq "value")) (Left "value")False^HMockA P that accepts pairs whose elements satisfy the corresponding child Ps.2accept (zipP (eq "foo") (eq "bar")) ("foo", "bar")True2accept (zipP (eq "foo") (eq "bar")) ("bar", "foo")False_HMockA P that accepts 3-tuples whose elements satisfy the corresponding child Ps.accept (zip3P (eq "foo") (eq "bar") (eq "qux")) ("foo", "bar", "qux")Trueaccept (zip3P (eq "foo") (eq "bar") (eq "qux")) ("qux", "bar", "foo")False`HMockA P that accepts 3-tuples whose elements satisfy the corresponding child Ps.7accept (zip4P (eq 1) (eq 2) (eq 3) (eq 4)) (1, 2, 3, 4)True7accept (zip4P (eq 1) (eq 2) (eq 3) (eq 4)) (4, 3, 2, 1)FalseaHMockA P that accepts 3-tuples whose elements satisfy the corresponding child Ps.accept (zip5P (eq 1) (eq 2) (eq 3) (eq 4) (eq 5)) (1, 2, 3, 4, 5)Trueaccept (zip5P (eq 1) (eq 2) (eq 3) (eq 4) (eq 5)) (5, 4, 3, 2, 1)FalsebHMockA P8 that accepts anything accepted by both of its children.'accept (lt "foo" `andP` gt "bar") "eta"True'accept (lt "foo" `andP` gt "bar") "quz"False)accept (lt "foo" `andP` gt "bar") "alpha"FalsecHMockA P: that accepts anything accepted by either of its children.&accept (lt "bar" `orP` gt "foo") "eta"False&accept (lt "bar" `orP` gt "foo") "quz"True(accept (lt "bar" `orP` gt "foo") "alpha"TruedHMockA P that inverts another P, accepting whatever its child rejects, and rejecting whatever its child accepts.(accept (notP (eq "negative")) "positive"True(accept (notP (eq "negative")) "negative"FalseeHMockA P9 that accepts sequences that start with the given prefix.$accept (startsWith "fun") "fungible"True$accept (startsWith "gib") "fungible"FalsefHMockA P7 that accepts sequences that end with the given suffix.!accept (endsWith "ow") "crossbow"True"accept (endsWith "ow") "trebuchet"FalsegHMockA P that accepts sequences that contain the given (consecutive) substring.accept (hasSubstr "i") "team"False$accept (hasSubstr "i") "partnership"TruehHMockA P that accepts sequences that contain the given (not necessarily consecutive) subsequence..accept (hasSubsequence [1..5]) [1, 2, 3, 4, 5]Trueaccept (hasSubsequence [1..5]) [0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0]True/accept (hasSubsequence [1..5]) [2, 3, 5, 7, 11]FalseiHMock Transforms a P on 8s or string-like types to match without regard to case.5accept (caseInsensitive startsWith "foo") "FOOTBALL!"True1accept (caseInsensitive endsWith "ball") "soccer"False)accept (caseInsensitive eq "time") "TIME"True2accept (caseInsensitive gt "NOTHING") "everything"FalsejHMockA P that accepts s or string-like values matching a regular expression. The expression must match the entire argument.You should not use i j, because regular expression syntax itself is still case-sensitive even when the text you are matching is not. Instead, use k.'accept (matchesRegex "x{2,5}y?") "xxxy"True&accept (matchesRegex "x{2,5}y?") "xyy"False)accept (matchesRegex "x{2,5}y?") "wxxxyz"FalsekHMockA P that accepts s or string-like values matching a regular expression in a case-insensitive way. The expression must match the entire argument.You should use this instead of i j, because regular expression syntax itself is still case-sensitive even when the text you are matching is not.6accept (matchesCaseInsensitiveRegex "x{2,5}y?") "XXXY"True5accept (matchesCaseInsensitiveRegex "x{2,5}y?") "XYY"False8accept (matchesCaseInsensitiveRegex "x{2,5}y?") "WXXXYZ"FalselHMockA P that accepts s or string-like values containing a match for a regular expression. The expression need not match the entire argument.You should not use i l, because regular expression syntax itself is still case-sensitive even when the text you are matching is not. Instead, use m.(accept (containsRegex "x{2,5}y?") "xxxy"True'accept (containsRegex "x{2,5}y?") "xyy"False*accept (containsRegex "x{2,5}y?") "wxxxyz"TruemHMockA P that accepts s or string-like values containing a match for a regular expression in a case-insensitive way. The expression need match the entire argument.You should use this instead of i l, because regular expression syntax itself is still case-sensitive even when the text you are matching is not.7accept (containsCaseInsensitiveRegex "x{2,5}y?") "XXXY"True6accept (containsCaseInsensitiveRegex "x{2,5}y?") "XYY"False9accept (containsCaseInsensitiveRegex "x{2,5}y?") "WXXXYZ"TruenHMockA P$ that accepts empty data structures.accept isEmpty []Trueaccept isEmpty [1, 2, 3]Falseaccept isEmpty ""Trueaccept isEmpty "gas tank"FalseoHMockA P( that accepts non-empty data structures.accept nonEmpty []Falseaccept nonEmpty [1, 2, 3]Trueaccept nonEmpty ""Falseaccept nonEmpty "gas tank"TruepHMockA P that accepts data structures whose number of elements match the child P.#accept (sizeIs (lt 3)) ['a' .. 'f']False#accept (sizeIs (lt 3)) ['a' .. 'b']TrueqHMockA P that accepts data structures whose contents each match the corresponding P& in the given list, in the same order..accept (elemsAre [lt 3, lt 4, lt 5]) [2, 3, 4]True1accept (elemsAre [lt 3, lt 4, lt 5]) [2, 3, 4, 5]False/accept (elemsAre [lt 3, lt 4, lt 5]) [2, 10, 4]FalserHMockA P that accepts data structures whose contents each match the corresponding P! in the given list, in any order.7accept (unorderedElemsAre [eq 1, eq 2, eq 3]) [1, 2, 3]True7accept (unorderedElemsAre [eq 1, eq 2, eq 3]) [2, 3, 1]True:accept (unorderedElemsAre [eq 1, eq 2, eq 3]) [1, 2, 3, 4]False4accept (unorderedElemsAre [eq 1, eq 2, eq 3]) [1, 3]FalsesHMockA P that accepts data structures whose elements each match the child P.accept (each (gt 5)) [4, 5, 6]Falseaccept (each (gt 5)) [6, 7, 8]Trueaccept (each (gt 5)) []TruetHMockA P that accepts data structures which contain at least one element matching the child P."accept (contains (gt 5)) [3, 4, 5]False"accept (contains (gt 5)) [4, 5, 6]Trueaccept (contains (gt 5)) []FalseuHMockA P that accepts data structures which contain an element satisfying each of the child Ps. u [p1, p2, ..., pn] is equivalent to t p1 `b` t p2 `b` ... `b` t pn.8accept (containsAll [eq "foo", eq "bar"]) ["bar", "foo"]True1accept (containsAll [eq "foo", eq "bar"]) ["foo"]False?accept (containsAll [eq "foo", eq "bar"]) ["foo", "bar", "qux"]TruevHMockA P that accepts data structures whose elements all satisfy at least one of the child Ps. v [p1, p2, ..., pn] is equivalent to s (p1 `c` p2 `c` ... `c` pn).9accept (containsOnly [eq "foo", eq "bar"]) ["foo", "foo"]True9accept (containsOnly [eq "foo", eq "bar"]) ["foo", "bar"]True9accept (containsOnly [eq "foo", eq "bar"]) ["foo", "qux"]FalsewHMockA P that accepts map-like structures which contain a key matching the child P.8accept (containsKey (eq "foo")) [("foo", 1), ("bar", 2)]True8accept (containsKey (eq "foo")) [("bar", 1), ("qux", 2)]FalsexHMockA P that accepts map-like structures which contain a key/value pair matched by the given child P,s (one for the key, and one for the value).accept (containsEntry (eq "foo") (gt 10)) [("foo", 12), ("bar", 5)]Trueaccept (containsEntry (eq "foo") (gt 10)) [("foo", 5), ("bar", 12)]False7accept (containsEntry (eq "foo") (gt 10)) [("bar", 12)]FalseyHMockA P that accepts map-like structures whose keys are exactly those matched by the given list of Ps, in any order.accept (keysAre [eq "a", eq "b", eq "c"]) [("a", 1), ("b", 2), ("c", 3)]Trueaccept (keysAre [eq "a", eq "b", eq "c"]) [("c", 1), ("b", 2), ("a", 3)]True>accept (keysAre [eq "a", eq "b", eq "c"]) [("a", 1), ("c", 3)]Falseaccept (keysAre [eq "a", eq "b"]) [("a", 1), ("b", 2), ("c", 3)]FalsezHMockA P that accepts map-like structures whose entries are exactly those matched by the given list of P pairs, in any order.accept (entriesAre [(eq 1, eq 2), (eq 3, eq 4)]) [(1, 2), (3, 4)]Trueaccept (entriesAre [(eq 1, eq 2), (eq 3, eq 4)]) [(3, 4), (1, 2)]Trueaccept (entriesAre [(eq 1, eq 2), (eq 3, eq 4)]) [(1, 4), (3, 2)]Falseaccept (entriesAre [(eq 1, eq 2), (eq 3, eq 4)]) [(1, 2), (3, 4), (5, 6)]False{HMockA P that accepts values of  types that are close to the given number. The expected precision is scaled based on the target value, so that reasonable rounding error is accepted but grossly inaccurate results are not.The following naive use of U fails due to rounding:*accept (eq 1.0) (sum (replicate 100 0.01))FalseThe solution is to use {/, which accounts for rounding error. However, { doesn't accept results that are far enough off that they likely arise from incorrect calculations instead of rounding error.0accept (approxEq 1.0) (sum (replicate 100 0.01))True4accept (approxEq 1.0) (sum (replicate 100 0.009999))False|HMockA P$ that accepts finite numbers of any  type.accept finite 1.0Trueaccept finite (0 / 0)Falseaccept finite (1 / 0)False}HMockA P& that accepts infinite numbers of any  type.accept infinite 1.0Falseaccept infinite (0 / 0)Falseaccept infinite (1 / 0)True~HMockA P that accepts NaN values of any  type.accept nAn 1.0Falseaccept nAn (0 / 0)Trueaccept nAn (1 / 0)FalseHMockA conversion from a ->  to P3. This is a fallback that can be used to build a P that checks anything at all. However, its description will be less helpful than standard Ps.accept (is even) 3Falseaccept (is even) 4TrueHMock)A Template Haskell splice that acts like , but receives a quoted expression at compile time and has a more helpful description for error messages.accept $(qIs [| even |]) 3Falseaccept $(qIs [| even |]) 4Trueshow $(qIs [| even |])"even"HMockA combinator to lift a P to work on a property or computed value of the original value.accept (with abs (gt 5)) (-6)Trueaccept (with abs (gt 5)) (-5)False*accept (with reverse (eq "olleh")) "hello"True,accept (with reverse (eq "olleh")) "goodbye"FalseHMock)A Template Haskell splice that acts like , but receives a quoted typed expression at compile time and has a more helpful description for error messages.'accept ($(qWith [| abs |]) (gt 5)) (-6)True'accept ($(qWith [| abs |]) (gt 5)) (-5)False4accept ($(qWith [| reverse |]) (eq "olleh")) "hello"True6accept ($(qWith [| reverse |]) (eq "olleh")) "goodbye"False show ($(qWith [| abs |]) (gt 5)) "abs: > 5"HMockA Template Haskell splice that turns a quoted pattern into a predicate that accepts values that match the pattern.-accept $(qMatch [p| Just (Left _) |]) NothingFalse5accept $(qMatch [p| Just (Left _) |]) (Just (Left 5))True6accept $(qMatch [p| Just (Left _) |]) (Just (Right 5))False#show $(qMatch [p| Just (Left _) |])"Just (Left _)"HMock Converts a P to a new type. Typically used with visible type application, as in the examples below.%accept (typed @String anything) "foo"True,accept (typed @String (sizeIs (gt 5))) "foo"False+accept (typed @String anything) (42 :: Int)False5PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~5PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  Safe-Inferred>^uHMock9Class for things that can be expected. This is includes &s, but also bare s and s with no explicit response.HMock;Converts an expectable to a Rule that means the same thing.HMockAttaches a response to an expectation. This is a flexible response, which can look at arguments, do things in the base monad, set up more expectations, etc. A matching  is passed to the response.HMockAttaches a return value to an expectation. This is more convenient than  in the common case where you just want to return a known result. e  r means the same thing as e   ( r).&(*&(*11  Safe-Inferred-/n HMockType class for contexts in which one can build expectations. Notably, this includes  7, which expects actions to be performed during a test.The methods of this class represent the user-facing API for build your execution plan for mocks.HMockCreates an expectation that an action is performed once per given response (or exactly once if there is no response).    do   ReadFile "foo.txt"   "lorem ipsum"   "oops, the file changed out from under me!" callCodeUnderTest In this example,  must be called exactly twice by the tested code, and will return "lorem ipsum" the first time, but something different the second time.HMockCreates an expectation that an action is performed some number of times.     do   MakeList  ( 2) ! CheckList "Cindy Lou Who"   "nice" callCodeUnderTest HMockSpecifies a response if a matching action is performed, but doesn't expect anything. This is equivalent to  , but shorter."In this example, the later use of  overrides earlier uses, but only for calls that match its conditions.     do   ReadFile_ anything   "tlhIngan maH!"   ReadFile "config.txt"  ( "lang: klingon" callCodeUnderTest HMockCreates a sequential expectation. Other actions can still happen during the sequence, but these specific expectations must be met in this order.   [   MoveForward,   TurnRight,   MoveForward ] Beware of using  too often. It is appropriate when the property you are testing is that the order of effects is correct. If that's not the purpose of the test, consider adding several independent expectations, instead. This avoids over-asserting, and keeps your tests less brittle.HMockCombines multiple expectations, which can occur in any order. Most of the time, you can achieve the same thing by expecting each separately, but this can be combined in complex expectations to describe more complex ordering constraints.If ambiguity checking is disabled, the choice is left-biased, so earlier options are preferred over ambiguous later options.   [  [   AdjustMirrors,  ! FastenSeatBelt ],   StartCar ] HMockCombines multiple expectations, requiring exactly one of them to occur. If ambiguity checking is disabled, the choice is left-biased, so earlier options are preferred over ambiguous later options.   [  $ ApplyForJob,  $ ApplyForUniversity ] HMockCreates a parent expectation that the child expectation will happen a certain number of times. Unlike , the child expectation can be arbitrarily complex and span multiple actions. Also unlike , each new execution will restart response sequences for rules with more than one response.Different occurrences of the child can be interleaved. If ambiguity checking is disabled, progressing on an existing occurrence is preferred over starting a new occurrence when it's ambiguous.HMockCreates a parent expectation that the child expectation will happen a certain number of times. Unlike , the child expectation can be arbitrarily complex and span multiple actions. Also unlike , each new execution will restart response sequences for rules with more than one response.Different occurrences of the child must happen consecutively, with one finishing before the next begins.HMockAll constraints needed to mock a method with the given class, name, base monad, and return type.HMock3The number of times the action should be performed.HMockThe action and its response.   None'(/qHMockNewtype wrapper to make the type of ExpectSet conform to the ExpectContext class. The "return type" a is a phantom.HMock A single step of an expectation.HMockA Rule that contains only a single response. This is the target for desugaring the multi-response rule format.HMockExpands a Rule into an expectation. The expected multiplicity will be one if there are no responses; otherwise one call is expected per response.HMockExpands a Rule into an expectation, given a target multiplicity. It is an error if there are too many responses for the multiplicity. If there are too few responses, the last response will be repeated.  None '(>vsHMockMonad for setting up a mockable class. Note that even though the type looks that way, this is *not* a monad transformer. It's a very restricted environment that can only be used to set up defaults for a class.HMock$Monad transformer for running mocks.HMock1This type class defines a shared API between the  and  monads.HMockRuns a  action in this monad.HMockFull state of a mock.HMockInitializes a new + with the given parent. If the parent is  , then a new root state is made.HMock7Gets a list of all states, starting with the innermost.HMockGets the root state.HMockRuns a setup action with the root state, rather than the current one.HMockRun an STM action in HMock Runs class initialization for a # class, if it hasn't been run yet.HMock0Runs class initialization for all uninitialized  classes in the given ?.HMock(Applies a function to the base monad of .HMockAdds an expectation to the  for the given ?., interleaved with any existing expectations. None '(> HMockRuns a test in the " monad, handling all of the mocks.HMockRuns a test in the  monad. The test can unlift other MockT pieces to the base monad while still acting on the same set of expectations. This can be useful for testing concurrency or similar mechanisms. test =   inMockT -> do   ...     inMockT firstThread     inMockT secondThread 3This is a low-level primitive. Consider using the unliftio package for higher level implementations of multithreading and other primitives.HMockStarts a nested block within . The nested block has its own set of expectations, which must be fulfilled before the end of the block.Beware: use of  might signify that you are doing too much in a single test. Consider splitting large tests into a separate test for each case.HMockStarts a nested block within . The nested block has its own set of expectations, which must be fulfilled before the end of the block. It can unlift other MockT pieces to the base monad while still acting on the same set of expectations. This can be useful for testing concurrency or similar mechanisms.Beware: use of  might signify that you are doing too much in a single test. Consider splitting large tests into a separate test for each case.HMock1Sets whether to check for ambiguous actions. If , then actions that match expectations in more than one way will fail. If , then the most recently added action will take precedence. This defaults to .HMock Fetches a  that describes the current set of outstanding expectations. This is sometimes useful for debugging test code. The exact format is not specified.HMockVerifies that all mock expectations are satisfied. If there is a nested block in effect, only the expectations of that nested block are verified You normally don't need to do this, because it happens automatically at the end of your test or nested block. However, it's occasionally useful to check expectations early.Beware: use of  might signify that you are doing too much in a single test. Consider splitting large tests into a separate test for each case.HMockAdds a handler for unexpected actions. Matching calls will not fail, but will use a default response instead. The rule passed in must have zero or one responses: if there is a response,  (m   r) is equivalent to  m >>  (m   r).The difference between  and ( is subtle, but comes down to ambiguity: is not an expectation, so it cannot be ambiguous. It only has an effect if no true expectation matches, regardless of when the expectations were added. adds an expectation, so if another expectation is in effect at the same time, a call to the method is ambiguous. If ambiguity checking is enabled, the method will throw an error; otherwise, the more recently added of the two expectations is used.HMockSets a default action for *expected* matching calls. The new default only applies to calls for which an expectation exists, but it lacks an explicit response. The rule passed in must have exactly one response.HMockAdds a side-effect, which happens whenever a matching call occurs, in addition to the usual response. The return value is entirely ignored.Be warned: using side effects makes it easy to break abstraction boundaries. Be aware that there may be other uses of a method besides the one which you intend to intercept here. If possible, add the desired behavior to the response for the matching expectation instead.   NoneHMockImplements a method in a  monad by delegating to the mock framework. If the method is called unexpectedly, an exception will be thrown. However, an expected invocation without a specified response will return the default value.HMockImplements a method in a  monad by delegating to the mock framework. If the method is called unexpectedly, an exception will be thrown. However, an expected invocation without a specified response will return undefined. This can be used in place of & when the return type has no default.None /HMockCustom options for deriving a  class.HMockSuffix to add to  and  names. Defaults to "".HMockWhether to warn about limitations of the generated mocks. This is mostly useful temporarily for finding out why generated code doesn't match your expectations. Defaults to .HMockDefine all instances necessary to use HMock with the given class. Equivalent to both  and .If MyClass is a class and myMethod is one of its methods, then  MyClass generates all of the following:If MyClass is a class and myMethod is one of its methods, then  MyClass$ generates everything generated by , as well as a  instance that does no setup.HMockDefine all instances necessary to use HMock with the given constraint type, which should be a class applied to zero or more type arguments. Equivalent to both  and .See 0 for a list of what is generated by this splice.HMockDefine all instances necessary to use HMock with the given class. This is like 1, but with the ability to specify custom options.See 0 for a list of what is generated by this splice.HMockDefine all instances necessary to use HMock with the given constraint type, which should be a class applied to zero or more type arguments. This is like 1, but with the ability to specify custom options.See 0 for a list of what is generated by this splice.HMockDefines almost all instances necessary to use HMock with the given class. Equivalent to both  and .HMockDefines almost all instances necessary to use HMock with the given constraint type, which should be a class applied to zero or more type arguments. Equivalent to both  and .HMockDefines almost all instances necessary to use HMock with the given class. This is like 1, but with the ability to specify custom options.HMockDefines almost all instances necessary to use HMock with the given constraint type, which should be a class applied to zero or more type arguments. This is like 2, but with the ability to specify custom options.HMock Defines the  instance for the given class.If MyClass is a class and myMethod is one of its methods, then  MyClass$ generates everything generated by , as well as a  instance that does no setup.HMock Defines the  instance for the given constraint type, which should be a class applied to zero or more type arguments.See 0 for a list of what is generated by this splice.HMock Defines the . instance for the given class. This is like 1, but with the ability to specify custom options.See 0 for a list of what is generated by this splice.HMock Defines the  instance for the given constraint type, which should be a class applied to zero or more type arguments. This is like 1, but with the ability to specify custom options.See 0 for a list of what is generated by this splice.HMock Defines the  instance for the given class.If MyClass is a class and myMethod is one of its methods, then  MyClass generates all of the following:A  MyClass instance.An associated type  MyClass, with a constructor MyMethod.An associated type  MyClass, with a constructor  MyMethod_.An  instance for  MyClass which matches an exact set of arguments, if and only if all of myMethod's arguments have  and  instances.HMock Defines the  instance for the given constraint type, which should be a class applied to zero or more type arguments.See 0 for a list of what is generated by this splice.HMock Defines the . instance for the given class. This is like 1, but with the ability to specify custom options.See 0 for a list of what is generated by this splice.HMock Defines the  instance for the given constraint type, which should be a class applied to zero or more type arguments. This is like 1, but with the ability to specify custom options.See 0 for a list of what is generated by this splice.HMock+Defines an instance of the given class for  m$, delegating all of its methods to  to be handled by HMock.This may only be used if all members of the class are mockable methods. If the class contains some unmockable methods, associated types, or other members, you will need to define this instance yourself, delegating the mockable methods as follows: instance MyClass ( m) where myMethod x y =  (MyMethod x y) ... HMock5Defines an instance of the given constraint type for  m$, delegating all of its methods to  to be handled by HMock. The type should be a class applied to zero or more type arguments.See , for restrictions on the use of this splice.HMock+Defines an instance of the given class for  m$, delegating all of its methods to ( to be handled by HMock. This is like 1, but with the ability to specify custom options.See , for restrictions on the use of this splice.HMock5Defines an instance of the given constraint type for  m$, delegating all of its methods to  to be handled by HMock. The type should be a class applied to zero or more type arguments. This is like 1, but with the ability to specify custom options.See , for restrictions on the use of this splice.None>*"! #%$&(*,-./0123PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmmnopqrstuvwxyz{|}~                                         $HMock-0.3.0.0-1sHkZrXKyY6IAb3UljTMbKTest.HMock.Internal.StateTest.HMock.Internal.UtilTest.HMock.Internal.THTest.HMock.MockableTest.HMock.Internal.RuleTest.HMock.MultiplicityTest.HMock.Internal.ExpectSetTest.HMock.PredicatesTest.HMock.RuleTest.HMock.ExpectContextTest.HMock.Internal.StepTest.HMock.MockTTest.HMock.MockMethod Test.HMock.TH makeMockablemakeMockableBasederiveMockablederiveMockableBase|->|=>expect Test.HMockanythingMockTrunMockTatLeastanyMultiplicityTest.HMock.ExpectableControl.ConcurrentforkIO expectAny MockSetupLocatedLoclocatewithLocchoicesisSubsequenceOf $fEqLocated $fOrdLocated$fFunctorLocatedtvNamebindVar unappliedName substTypeVar substTypeVars splitType freeTypeVars constrainVarsrelevantContext unifyTypesremoveModNameshasNestedPolyType hasPolyTyperesolveInstancesimplifyContextlocalizeMemberMockable setupMockable MockableBaseActionMatcher showAction showMatcher matchAction MatchResultNoMatchMatchRule:=>WholeMethodMatcher JustMatcherSuchThatshowWholeMatcher MultiplicitymeetsMultiplicityonceatMostbetweenfeasible$fNumMultiplicity$fShowMultiplicity$fEqMultiplicity CollectedSet CollectedStepCollectedNothingCollectedSequenceCollectedInterleaveCollectedChoiceCollectedMultiCollectedConsecutive ExpectSet ExpectStep ExpectNothingExpectSequenceExpectInterleave ExpectEither ExpectMultiExpectConsecutive satisfied liveStepssimplifygetStepscollectformatExpectSetexcess$fShowExpectSet $fEqExpectSet Predicate showPredicateaccepteqneqgtgeqltleqjustleftrightzipPzip3Pzip4Pzip5PandPorPnotP startsWithendsWith hasSubstrhasSubsequencecaseInsensitive matchesRegexmatchesCaseInsensitiveRegex containsRegexcontainsCaseInsensitiveRegexisEmptynonEmptysizeIselemsAreunorderedElemsAreeachcontains containsAll containsOnly containsKey containsEntrykeysAre entriesAreapproxEqfiniteinfinitenAnisqIswithqWithqMatchtyped$fShowPredicate ExpectabletoRule'$fExpectableclsnamemrWholeMethodMatcher$fExpectableclsnamemrMatcher$fExpectableclsnamemrRule ExpectContextexpectN inSequence inAnyOrderanyOftimesconsecutiveTimesMockableMethodExpectedunwrapExpectedStep SingleRule:-> expandRuleexpandRepeatRule $fShowStep$fExpectContextExpected MockContext fromMockSetupunMockT unMockSetup MockState mockExpectSet mockDefaultsmockAllowUnexpectedmockSideEffectsmockCheckAmbiguity mockClasses mockParent initMockState allStates rootStaterunInRootState mockSetupSTMinitClassIfNeededinitClassesAsNeededmapMockT expectThisSet$fExpectContextMockT$fMonadReaderrMockT$fMonadTransMockT$fMockContextMockT$fMockContextMockSetup$fFunctorMockT$fApplicativeMockT $fMonadMockT$fMonadFailMockT$fMonadIOMockT$fMonadStatesMockT$fMonadWriterwMockT$fMonadRWSrwsMockT$fMonadErroreMockT$fMonadContMockT$fMonadBasebMockT$fMonadCatchMockT$fMonadMaskMockT$fMonadThrowMockT$fMonadUnliftIOMockT$fFunctorMockSetup$fApplicativeMockSetup$fMonadMockSetup withMockT nestMockTwithNestedMockTsetAmbiguityCheckdescribeExpectationsverifyExpectationsallowUnexpected byDefaultwhenever mockMethodmockDefaultlessMethodMockableOptions mockSuffix mockVerbosemakeMockableTypemakeMockableWithOptionsmakeMockableTypeWithOptionsmakeMockableBaseTypemakeMockableBaseWithOptionsmakeMockableBaseTypeWithOptionsderiveMockableTypederiveMockableWithOptionsderiveMockableTypeWithOptionsderiveMockableBaseTypederiveMockableBaseWithOptions!deriveMockableBaseTypeWithOptionsderiveForMockTderiveTypeForMockTderiveForMockTWithOptionsderiveTypeForMockTWithOptions$fDefaultMockableOptions$fShowInstance $fShowMethodbaseGHC.BaseStringtemplate-haskellLanguage.Haskell.TH.SyntaxName TyVarBndrType Language.Haskell.TH.Lib.InternalCxtQMonadghc-prim GHC.TypesBoolGHC.ShowShow GHC.MaybeMaybeJust Data.EitherEitherLeftRight GHC.Float RealFloatconstreturn$ System.IOreadFileNothingControl.Monad.IO.ClassliftIOTrueFalse GHC.ClassesEq