h$g!b      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU V W X Y Z [ \ ] ^ _ ` a b c d e f g h i jklmnopqrstuvwxyz{|}~                           Safe-Inferred5?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.None sHMock 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 .HMock9Attempts to produce sufficient constraints for the given  to be a satisfied constraint. The type should be a class applied to its type parameters.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 '(/> 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.HMockAn action to run and set up defaults for this class. The action will be run before HMock touches the class, either to add expectations or to delegate a method.By default, unexpected actions throw errors, and actions with no explicit default always return the default value of their return type, or  if there is none. You can change this on a per-class or per-test basis.;To change defaults on a per-class basis, you should use   and/or  ' to perform the setup you need here.:To change defaults on a per-test basis, you should use   and/or   directly from the test.HMockA base class for  subclasses whose methods can be mocked. You usually want to generate this instance using  ,  , or  , since 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 arg is explanations of mismatch.#HMock8Match. Stores a witness to the equality of return types.  !#"  !#" Safe-Inferred'(/D$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 True.HMockA *% that means at least this many times.meetsMultiplicity (atLeast 2) 1FalsemeetsMultiplicity (atLeast 2) 2TruemeetsMultiplicity (atLeast 2) 3True/HMockA *$ that means at most this many times.meetsMultiplicity (atMost 2) 1TruemeetsMultiplicity (atMost 2) 2TruemeetsMultiplicity (atMost 2) 3False0HMockA * that means any number in this interval, endpoints included. For example, 0 2 3 means 2 or 3 times, while 0 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) 4False1HMockChecks whether a ** is capable of matching any number at all. feasible onceTrue feasible 0Truefeasible (once - 2)False2HMock9This is an incomplete instance, provided for convenience.meetsMultiplicity 5 4FalsemeetsMultiplicity 5 5Truebetween 4 6 - between 1 2 2 to 5 times*+,-./01*+1,-./0None(3& 5HMockA 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.EHMockChecks 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.FHMockComputes 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?GHMockPerforms 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.HHMock(Get a list of all steps mentioned by an =. This is used to determine which classes need to be initialized before adding an expectation.IHMockCollects an ExpectSet into the intermediate form for display. It's assumed that the expression was simplified before this operation.JHMockConverts a set of expectations into a string that summarizes them, with the given prefix (used to indent).KHMockReduces 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.5<;:9876=DCBA@?>EFGHIJK=DCBA@?>EFGH5<;:9876IJK Safe-Inferred>) NHMock9Class for things that can be expected. This is includes $s, but also bare s and s with no explicit response.OHMock;Converts an expectable to a Rule that means the same thing.PHMockAttaches 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.QHMockAttaches a return value to an expectation. This is more convenient than P in the common case where you just want to return a known result. e Q r means the same thing as e P  ( r).$&(NOPQ$NOQP&(P1Q1  Safe-Inferred-/93 UHMockType 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.VHMockCreates an expectation that an action is performed once per given response (or exactly once if there is no response).    do V  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.WHMockCreates an expectation that an action is performed some number of times.     do V  MakeList W ( 2) ! CheckList "Cindy Lou Who"  Nice callCodeUnderTest XHMockSpecifies a response if a matching action is performed, but doesn't expect anything. This is equivalent to W , but shorter."In this example, the later use of X overrides earlier uses, but only for calls that match its conditions.     do X  ReadFile_ anything  "tlhIngan maH!" X  ReadFile "config.txt" ( "lang: klingon" callCodeUnderTest YHMockCreates a sequential expectation. Other actions can still happen during the sequence, but these specific expectations must be met in this order.  Y [ V  MoveForward, V  TurnRight, V  MoveForward ] Beware of using Y 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.ZHMockCombines 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 compound 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.  Y [ Z [ V  AdjustMirrors, V ! FastenSeatBelt ], V  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.  [ [ V $ ApplyForJob, V $ ApplyForUniversity ] \HMockCreates a parent expectation that the child expectation will happen a certain number of times. Unlike W, the child expectation can be arbitrarily complex and span multiple actions. Also unlike W, 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 W, the child expectation can be arbitrarily complex and span multiple actions. Also unlike W, 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.WHMock3The number of times the action should be performed.HMockThe action and its response. UVWXYZ[\]^ ^UVWXYZ[\] None'(/<_HMockNewtype wrapper to make the type of ExpectSet conform to the ExpectContext class. The "return type" a is a phantom.bHMock A single step of an expectation.dHMockA Rule that contains only a single response. This is the target for desugaring the multi-response rule format.fHMockExpands a Rule into an expectation. The expected multiplicity will be one if there are no responses; otherwise one call is expected per response.gHMockExpands 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. _`abcdefg debcfg_`aNone '(>BHMockMonad 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.jHMock1This type class defines a shared API between the  and  monads.kHMockRuns a  action in this monad.pHMockFull state of a mock.}HMock$The severity for a possible problem.~HMockFail the test.HMock'Print a message, but continue the test.HMockDon't do anything.HMockInitializes a new p+ 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.HMockMarks a method as "interesting". This can have implications for what happens to calls to that method.HMock-Determines whether a method is "interesting".HMock0Runs class initialization for all uninitialized  classes in the given =.HMock(Applies a function to the base monad of .HMockAdds an expectation to the p for the given =., interleaved with any existing expectations.HMock+Reports a potential problem with the given }.HMock2This instance allows you to add expectations from < actions. This is an unusual thing to do. Consider using   , instead.%nolmjkpq|{zyxwvutsr}~%}~pq|{zyxwvutsrnolmjk None '(>V 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.HMockSets the severity for ambiguous actions. An ambiguous action is one that matches expectations in more than one way. If this is not set to ~<, the most recently added expectation will take precedence.This defaults to .HMockSets the severity for uninteresting actions. An uninteresting action is one for which no expectations or other configuration have been added that mention the method at all. If this is not set to ~, then uninteresting methods are treated just like unexpected methods.Before you weaken this check, consider that the labeling of methods as "uninteresting" is non-compositional. A change in one part of your test can result in a formerly uninteresting action being considered interesting in a different part of the test.This defaults to ~.HMockSets the severity for unexpected actions. An unexpected action is one that doesn't match any expectations *and* isn't explicitly allowed by . If this is not set to ~+, the action returns its default response.This defaults to ~.HMockSets the severity for unmet expectations. An unmet expectation happens when an expectation is added, but either the test (or nesting level) ends or . is used before a matching action takes place.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.j}~}~j NoneYHMockImplements 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 /aHMockCustom options for deriving  and related instances.HMockWhether to generate a , instance with an empty setup. If this is &, you are responsible for providing a  instance. Defaults to . If this is &, you are responsible for providing a  instance as follows:  instance  MyClass where  _ = ... HMock-Whether to derive instances of the class for  or not. Defaults to .This option will cause a build error if some members of the class are unmockable or are not methods. In this case, you'll need to define this instance yourself, delegating the mockable methods as follows: instance MyClass ( m) where myMethod x y =  (MyMethod x y) ... 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 .HMockDefines all instances necessary to use HMock with the given type, using default options. The type should be a type class extending *, applied to zero or more type arguments.:This defines all of the following instances, if necessary: and the associated  and  types.N instances for the  type. with an empty setup.Instances of the provided application type class to allow unit tests to be run with the  monad transformer.HMockDefines all instances necessary to use HMock with the given type, using the provided options. The type should be a type class extending *, applied to zero or more type arguments.3This defines the following instances, if necessary: and the associated  and  types.N instances for the  type.If  is :  with an empty setup.If  is : Instances of the provided application type class to allow unit tests to be run with the  monad transformer.None>b= !#"$&(*+,-./01NOPQU]\[ZYXVW^j}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn o  p  q r s t u v w w x y y z { | } ~                            $HMock-0.5.0.0-IlrBPrOv5oh1dEs3nAWxQPTest.HMock.Internal.StateTest.HMock.Internal.UtilTest.HMock.Internal.THTest.HMock.MockableTest.HMock.Internal.RuleTest.HMock.MultiplicityTest.HMock.Internal.ExpectSetTest.HMock.RuleTest.HMock.ExpectContextTest.HMock.Internal.StepTest.HMock.MockTTest.HMock.MockMethod Test.HMock.THallowUnexpected byDefault makeMockablemakeMockableWithOptions|->|=>expect Test.HMockanythingMockTrunMockTatLeastanyMultiplicityTest.HMock.ExpectableControl.ConcurrentforkIO expectAny setupMockable MockSetupLocatedLoclocatewithLocchoices$fFunctorLocatedtvNamebindVar unappliedName substTypeVar substTypeVars splitType freeTypeVars constrainVarsrelevantContext unifyTypesremoveModNameshasNestedPolyType hasPolyTyperesolveInstanceresolveInstanceTypesimplifyContextlocalizeMemberMockable MockableBaseActionMatcher showAction showMatcher matchAction MatchResultNoMatchMatchRule:=>WholeMethodMatcher JustMatcherSuchThatshowWholeMatcher MultiplicitymeetsMultiplicityonceatMostbetweenfeasible$fNumMultiplicity$fShowMultiplicity$fEqMultiplicity CollectedSet CollectedStepCollectedNothingCollectedSequenceCollectedInterleaveCollectedChoiceCollectedMultiCollectedConsecutive ExpectSet ExpectStep ExpectNothingExpectSequenceExpectInterleave ExpectEither ExpectMultiExpectConsecutive satisfied liveStepssimplifygetStepscollectformatExpectSetexcess$fShowExpectSet $fEqExpectSet ExpectabletoRule'$fExpectableclsnamemrWholeMethodMatcher$fExpectableclsnamemrMatcher$fExpectableclsnamemrRule ExpectContextexpectN inSequence inAnyOrderanyOftimesconsecutiveTimesMockableMethodExpectedunwrapExpectedStep SingleRule:-> expandRuleexpandRepeatRule $fShowStep$fExpectContextExpected MockContext fromMockSetupunMockT unMockSetup MockState mockExpectSet mockDefaultsmockAllowUnexpectedmockSideEffectsmockAmbiguitySeveritymockUnexpectedSeveritymockUninterestingSeveritymockUnmetSeverity mockClassesmockInterestingMethods mockParentSeverityErrorWarningIgnore initMockState allStates rootStaterunInRootState mockSetupSTMinitClassIfNeededmarkInteresting isInterestinginitClassesAsNeededmapMockT expectThisSet reportFault$fExpectContextMockSetup$fMonadReaderrMockT$fMonadTransMockT$fExpectContextMockT$fMockContextMockT$fMockContextMockSetup$fFunctorMockT$fApplicativeMockT $fMonadMockT$fMonadFailMockT$fMonadIOMockT$fMonadStatesMockT$fMonadWriterwMockT$fMonadRWSrwsMockT$fMonadErroreMockT$fMonadContMockT$fMonadBasebMockT$fMonadCatchMockT$fMonadMaskMockT$fMonadThrowMockT$fMonadUnliftIOMockT$fFunctorMockSetup$fApplicativeMockSetup$fMonadMockSetup withMockT nestMockTwithNestedMockTsetAmbiguityChecksetUninterestingActionChecksetUnexpectedActionChecksetUnmetExpectationCheckdescribeExpectationsverifyExpectationswhenever mockMethodmockDefaultlessMethodMakeMockableOptionsmockEmptySetupmockDeriveForMockT mockSuffix mockVerbose$fDefaultMakeMockableOptions$fShowInstance $fShowMethodbaseGHC.BaseStringtemplate-haskellLanguage.Haskell.TH.SyntaxName TyVarBndrType Language.Haskell.TH.Lib.InternalCxtQMonadGHC.Err undefinedconstreturn$ System.IOreadFile GHC.MaybeNothingControl.Monad.IO.ClassliftIOghc-prim GHC.TypesFalseTrue