h$Q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                            Safe-Inferred '(/>  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-Inferred3g HMock?An acceptable range of number of times for something to happen.3A multiplicity can have a lower and an upper bound.HMockA  . value representing inconsistent expectations.HMock.Checks whether a certain number satisfies the  .HMockA   that means exactly once.meetsMultiplicity once 0FalsemeetsMultiplicity once 1TruemeetsMultiplicity once 2FalseHMockA   that means any number of times. >>> meetsMultiplicity anyMultiplicity 0 True >>> meetsMultiplicity anyMultiplicity 1 True >>> meetsMultiplicity anyMultiplicity 10 TrueHMockA  % that means at least this many times.meetsMultiplicity (atLeast 2) 1FalsemeetsMultiplicity (atLeast 2) 2TruemeetsMultiplicity (atLeast 2) 3TrueHMockA  $ that means at most this many times.meetsMultiplicity (atMost 2) 1TruemeetsMultiplicity (atMost 2) 2TruemeetsMultiplicity (atMost 2) 3FalseHMockA   that means any number in this interval, endpoints included. For example,  2 3 means 2 or 3 times, while  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) 4FalseHMockChecks whether a   includes zero in its range.exhaustable anyMultiplicityTrueexhaustable (atLeast 2)Falseexhaustable (atMost 3)Trueexhaustable (between 0 2)TrueHMockChecks whether a  * is capable of matching any number at all. feasible onceTrue feasible 0Truefeasible (once - 2)FalseHMock9This is an incomplete instance, provided for convenience.meetsMultiplicity 5 4FalsemeetsMultiplicity 5 5Truebetween 4 6 - between 1 2 2 to 5 times  None(3 HMockA 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.+HMockChecks 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.,HMockComputes 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?-HMockPerforms 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..HMock(Get a list of all steps mentioned by an #. This is used to determine which classes need to be initialized before adding an expectation./HMockCollects an ExpectSet into the intermediate form for display. It's assumed that the expression was simplified before this operation.0HMockConverts a set of expectations into a string that summarizes them, with the given prefix (used to indent).1HMockReduces 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."! #*)('&%$+,-./01#*)('&%$+,-."! /01None5?Z456789456789NoneLHMock&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.=>?@ABCDEFGHIJKL?=>@ABCEDFGIHJKLNone ?Qq4MHMockA 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.Predicates are used to define which arguments a general matcher should accept.QHMockA M that accepts anything at all.accept anything "foo"Trueaccept anything undefinedTrueRHMockA M# that accepts only the given value.accept (eq "foo") "foo"Trueaccept (eq "foo") "bar"FalseSHMockA M+ that accepts anything but the given value.accept (neq "foo") "foo"Falseaccept (neq "foo") "bar"TrueTHMockA M4 that accepts anything greater than the given value.accept (gt 5) 4Falseaccept (gt 5) 5Falseaccept (gt 5) 6TrueUHMockA M that accepts anything greater than or equal to the given value.accept (geq 5) 4Falseaccept (geq 5) 5Trueaccept (geq 5) 6TrueVHMockA M1 that accepts anything less than the given value.accept (lt 5) 4Trueaccept (lt 5) 5Falseaccept (lt 5) 6FalseWHMockA M= that accepts anything less than or equal to the given value.accept (leq 5) 4Trueaccept (leq 5) 5Trueaccept (leq 5) 6FalseXHMockA M that matches  values.accept true TrueTrueaccept true FalseFalseYHMockA M that matches  values.accept false TrueFalseaccept false FalseTrueZHMockA M that accepts  values of  x, where x matches the given child M."accept (just (eq "value")) NothingFalse)accept (just (eq "value")) (Just "value")True/accept (just (eq "value")) (Just "wrong value")False[HMockA M that accepts an  value of  x, where x matches the given child M.)accept (left (eq "value")) (Left "value")True*accept (left (eq "value")) (Right "value")False/accept (left (eq "value")) (Left "wrong value")False\HMockA M that accepts an  value of  x, where x matches the given child M.+accept (right (eq "value")) (Right "value")True1accept (right (eq "value")) (Right "wrong value")False*accept (right (eq "value")) (Left "value")False]HMockA M that accepts pairs whose elements satisfy the corresponding child  Predicates.2accept (zipP (eq "foo") (eq "bar")) ("foo", "bar")True2accept (zipP (eq "foo") (eq "bar")) ("bar", "foo")False^HMockA M that accepts 3-tuples whose elements satisfy the corresponding child Ms.accept (zip3P (eq "foo") (eq "bar") (eq "qux")) ("foo", "bar", "qux")Trueaccept (zip3P (eq "foo") (eq "bar") (eq "qux")) ("qux", "bar", "foo")False_HMockA M that accepts 3-tuples whose elements satisfy the corresponding child  Predicates.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)False`HMockA M that accepts 3-tuples whose elements satisfy the corresponding child  Predicates.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)FalseaHMockA M8 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"FalsebHMockA M: 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"TruecHMockA M that inverts another M, accepting whatever its child rejects, and rejecting whatever its child accepts.(accept (notP (eq "negative")) "positive"True(accept (notP (eq "negative")) "negative"FalsedHMockA M9 that accepts sequences that start with the given prefix.$accept (startsWith "fun") "fungible"True$accept (startsWith "gib") "fungible"FalseeHMockA M7 that accepts sequences that end with the given suffix.!accept (endsWith "ow") "crossbow"True"accept (endsWith "ow") "trebuchet"FalsefHMockA M that accepts sequences that contain the given (consecutive) substring.accept (hasSubstr "i") "team"False$accept (hasSubstr "i") "partnership"TruegHMockA M 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]FalsehHMock Transforms a M 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"FalseiHMockA M that accepts s or string-like values matching a regular expression. The expression must match the entire argument.You should not use h i, because regular expression syntax itself is still case-sensitive even when the text you are matching is not. Instead, use j.'accept (matchesRegex "x{2,5}y?") "xxxy"True&accept (matchesRegex "x{2,5}y?") "xyy"False)accept (matchesRegex "x{2,5}y?") "wxxxyz"FalsejHMockA M 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 h i, 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"FalsekHMockA M 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 h k, because regular expression syntax itself is still case-sensitive even when the text you are matching is not. Instead, use l.(accept (containsRegex "x{2,5}y?") "xxxy"True'accept (containsRegex "x{2,5}y?") "xyy"False*accept (containsRegex "x{2,5}y?") "wxxxyz"TruelHMockA M 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 h k, 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"TruemHMockA M$ that accepts empty data structures.accept isEmpty []Trueaccept isEmpty [1, 2, 3]Falseaccept isEmpty ""Trueaccept isEmpty "gas tank"FalsenHMockA M( that accepts non-empty data structures.accept nonEmpty []Falseaccept nonEmpty [1, 2, 3]Trueaccept nonEmpty ""Falseaccept nonEmpty "gas tank"TrueoHMockA M that accepts data structures whose number of elements match the child M.#accept (sizeIs (lt 3)) ['a' .. 'f']False#accept (sizeIs (lt 3)) ['a' .. 'b']TruepHMockA M that accepts data structures whose contents each match the corresponding M& 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]FalseqHMockA M that accepts data structures whose contents each match the corresponding M! 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]FalserHMockA M that accepts data structures whose elements each match the child M.accept (each (gt 5)) [4, 5, 6]Falseaccept (each (gt 5)) [6, 7, 8]Trueaccept (each (gt 5)) []TruesHMockA M that accepts data structures which contain at least one element matching the child M."accept (contains (gt 5)) [3, 4, 5]False"accept (contains (gt 5)) [4, 5, 6]Trueaccept (contains (gt 5)) []FalsetHMockA M that accepts data structures which contain an element satisfying each of the child predicates. t [p1, p2, ..., pn] is equivalent to s p1 `a` s p2 `a` ... `a` s 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"]TrueuHMockA M that accepts data structures whose elements all satisfy at least one of the child predicates. u [p1, p2, ..., pn] is equivalent to r (p1 `b` p2 `b` ... `b` 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"]FalsevHMockA M that accepts map-like structures which contain a key matching the child M.8accept (containsKey (eq "foo")) [("foo", 1), ("bar", 2)]True8accept (containsKey (eq "foo")) [("bar", 1), ("qux", 2)]FalsewHMockA M that accepts map-like structures which contain a key/value pair matched by the given child M,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)]FalsexHMockA M that accepts map-like structures whose keys are exactly those matched by the given list of  Predicates, 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)]FalseyHMockA M that accepts map-like structures whose entries are exactly those matched by the given list of M 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)]FalsezHMockA M 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 R fails due to rounding:*accept (eq 1.0) (sum (replicate 100 0.01))FalseThe solution is to use z/, which accounts for rounding error. However, z 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 M$ that accepts finite numbers of any  type.accept finite 1.0Trueaccept finite (0 / 0)Falseaccept finite (1 / 0)False|HMockA M& that accepts infinite numbers of any  type.accept infinite 1.0Falseaccept infinite (0 / 0)Falseaccept infinite (1 / 0)True}HMockA M that accepts NaN values of any  type.accept nAn 1.0Falseaccept nAn (0 / 0)Trueaccept nAn (1 / 0)False~HMockA conversion from a ->  to M3. This is a fallback that can be used to build a M that checks anything at all. However, its description will be less helpful than standard Ms.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 M 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 M 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)False7MNPOQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~7MNPOQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None'(-/23>hHMockType class for contexts in which it makes sense to express an expectation. Notably, this includes 7, which expects actions to be performed during a test.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.HMockAll constraints needed to mock a method with the given class, name, base monad, and return type.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" HMockSomething that can be expected. This type class covers a number of cases:Expecting an exact ."Expecting anything that matches a .Adding a return value (with ) or response (with ).HMockAttaches a response to an expectation. This is a very flexible response, which can look at arguments, do things in the base monad, set up more expectations, etc. The matching  is passed to the response, and is guaranteed to be a match so it's fine to just pattern match on the correct method.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).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.HMockCreates an expectation that an action is performed once per given response (or exactly once if there is no response). runMockT  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.  runMockT  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 whenever overrides earlier uses, but only for calls that match its conditions.  runMockT  do whenever  ReadFile_ anything  "tlhIngan maH!" whenever  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.   [  [   AdjustMirrors,  ! FastenSeatBelt ],   StartCar ] HMockCombines multiple expectations, requiring exactly one of them to occur.   [  $ 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. In case of ambiguity, progressing on an existing occurrence is preferred over starting a new occurrence.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.HMock3The number of times the action should be performed.HMockThe action and its response.11None '(>s HMock$Monad transformer for running mocks.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   ... liftIO  forkIO  inMockT firstThread liftIO  forkIO  inMockT secondThread 3This is a low-level primitive. Consider using the unliftio package for higher level implementations of multithreading and other primitives.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. You normally don't need to do this, because it happens automatically at the end of your test in . However, it's occasionally useful to check expectations in the middle of a test, such as before going on to the next stage.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.HMock2Changes the default response for matching actions.Without 5, actions with no explicit response will return the  value for the type, or * if the return type isn't an instance of .  replaces that with a new default response, also overriding any previous defaults. The rule passed in must have exactly one response.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 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.HMockThe action that was received.HMockThe action that was received.HMockDescriptions of the matchers that most closely matched, closest first.None>s MNOPQRSTUVWZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~MNOPQRSTUVWZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   NonepHMockCustom 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 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]]^_`abcdefghijklmnopqrstuvwxyz{|}~                        $HMock-0.1.0.0-2pjWfbmyqifEA1nappYcT4Test.HMock.Internal.MockTTest.HMock.Internal.Mockable Test.HMock.Internal.MultiplicityTest.HMock.Internal.ExpectSetTest.HMock.Internal.UtilTest.HMock.Internal.TH.UtilTest.HMock.Internal.PredicatesTest.HMock.Internal.ExpectableTest.HMock.Internal.TH Test.HMock.TH makeMockablemakeMockableBasederiveMockablederiveMockableBase Test.HMockanythingatLeastMockTMockable setupMockable MockableBaseActionMatcher showAction showMatcher matchAction MatchResultNoMatchMatch Multiplicity infeasible normalizemeetsMultiplicityonceanyMultiplicityatMostbetween exhaustablefeasible$fNumMultiplicity$fShowMultiplicity$fEqMultiplicity CollectedSet CollectedStepCollectedNothingCollectedSequenceCollectedInterleaveCollectedChoiceCollectedMultiCollectedConsecutive ExpectSet ExpectStep ExpectNothingExpectSequenceExpectInterleave ExpectEither ExpectMultiExpectConsecutive satisfied liveStepssimplifygetStepscollectformatExpectSetexcess$fShowExpectSet $fEqExpectSetLocatedLoclocatewithLocchoicesisSubsequenceOf $fEqLocated $fOrdLocated$fFunctorLocatedtvNamebindVar unappliedName substTypeVar substTypeVars splitType freeTypeVars constrainVarsrelevantContext unifyTypesremoveModNameshasNestedPolyType hasPolyTyperesolveInstancesimplifyContextlocalizeMember Predicate showPredicateaccepteqneqgtgeqltleqtruefalsejustleftrightzipPzip3Pzip4Pzip5PandPorPnotP startsWithendsWith hasSubstrhasSubsequencecaseInsensitive matchesRegexmatchesCaseInsensitiveRegex containsRegexcontainsCaseInsensitiveRegexisEmptynonEmptysizeIselemsAreunorderedElemsAreeachcontains containsAll containsOnly containsKey containsEntrykeysAre entriesAreapproxEqfiniteinfinitenAnisqIswithqWithqMatchtyped$fShowPredicateExpectedunwrapExpected ExpectContext fromExpectSetStep SingleRule:->MockableMethodRule:=> ExpectabletoRule|=>|-> expandRuleexpandRepeatRuleexpectexpectN expectAny inSequence inAnyOrderanyOftimesconsecutiveTimes$fExpectableclsnamemrMatcher$fExpectableclsnamemrRule $fShowStep$fExpectContextExpectedunMockT MockState mockExpectSet mockDefaults mockClasses initMockStatemapMockTinitClassIfNeededinitClassesAsNeededrunMockT withMockTdescribeExpectationsverifyExpectations byDefaultmockMethodImpl mockMethodmockDefaultlessMethod noMatchErrorpartialMatchError$fExpectContextMockT$fMonadReaderrMockT$fMonadTransMockT$fFunctorMockT$fApplicativeMockT $fMonadMockT$fMonadFailMockT$fMonadIOMockT$fMonadStatesMockT$fMonadWriterwMockT$fMonadRWSrwsMockT$fMonadErroreMockT$fMonadContMockT$fMonadBasebMockT$fMonadCatchMockT$fMonadMaskMockT$fMonadThrowMockT$fMonadUnliftIOMockTMockableOptions mockSuffix mockVerbosemakeMockableTypemakeMockableWithOptionsmakeMockableTypeWithOptionsmakeMockableBaseTypemakeMockableBaseWithOptionsmakeMockableBaseTypeWithOptionsderiveMockableTypederiveMockableWithOptionsderiveMockableTypeWithOptionsderiveMockableBaseTypederiveMockableBaseWithOptions!deriveMockableBaseTypeWithOptionsderiveForMockTderiveTypeForMockTderiveForMockTWithOptionsderiveTypeForMockTWithOptions$fDefaultMockableOptions$fShowInstance $fShowMethodbaseGHC.BaseMonadghc-prim GHC.TypesBoolGHC.ShowShowTrueFalse GHC.MaybeMaybeJust Data.EitherEitherLeftRightString GHC.Float RealFloatconstreturn$ System.IOreadFile1data-default-class-0.1.2.0-IIN1s3V8yfYEDHe5yjxXHVData.Default.ClassDefaultGHC.Err undefined GHC.ClassesEq