úÎz,t&R      !"#$%&'()*+,-./0123456789:;<= > ? @ A B C D E F G H I J K L M N O P Q NoneE)simple wrapper for adding a % at the end.join lines togethermake lists into lines in text.convenience function for debug&Capture output and err of an IO actionNoneHMFMutation operation representing translation from one fn to another fn.8MuOp constructor used to specify mutation transformation The function  applies on a MuOP7 determining if transformation is between same values. A wrapper over mkMpRShow a specified mutation  The function  O pairs up the given element with all elements of the second list, and applies  on them.  The function  S pairs up all elements of first list with all elements of second list and applies  between them.  The function   accepts two values, and returns a function that if given a value equal to first, returns second we handle x ~~> x separatelySGuardedRhs instance for MutableTLiteral instance for MutableUExp instance for MutableVExp instance for MutableWQOp instance for MutableXQName instance for MutableYName instance for MutableZMuOp instance for Show[\]^_`ab R STUVWXYZ  a`_^]\[b R STUVWXYZNoneHM Tapply a mutating function on a piece of code one at a time like somewhere (from so) The function ò does two filters. For the first, it removes spurious transformations like "Int 1 ~~> Int 1". Secondly, it tries to apply the transformation to the given program on some element if it does not succeed, then we discard that transformation.    None/Interface to be implemented by a test frameworkSummary of a test runWas the test run a successWas the test run a failure*Was the test run neither (gaveup/timedout)Summary of test runHolding mutant informationWrapper for interpreter output   Nonec*Datatype to hold results of the entire runVGiven the list of tests suites to check, run one test suite at a time on all mutants.d!Run one test suite on all mutantseXGiven the filename, modulename, test to evaluate, evaluate, and return result as a pair. et = I.runInterpreter (evalMethod "Examples/QuickCheckTest.hs" "quickCheckResult idEmp")fSummarize the entire runcghijklmnopqrstdefcghijklmnopqrstdef Safe-Inferred The + function generates subsets of a given sizeThe Q function produces all possible pairings, and applies the given function to eachThe / function lazily generates filenames of mutantsThe V function replaces first matching element in a list given old and new values as a pairThe U function takes a random generator and chooses a random sample subset of given size./Wrapper around sample providing the random seedThe ` function takes a random generator, and a fraction and returns subset of size given by fraction The  8 function removes element at index specified from a list!The !: function swaps two elements in a list given their indices"The "J generates a list of lists where each element has been swapped by another#%Generate a random seed from the time.$Otake a function of two args producing a monadic result, and apply it to a pair  !"#$  !"#$  !"#$  !"#$None%all available operators&comparison operators [" ","", " =","=", "/=", "=="]all available operators'!predicates ["pred", "id", "succ"]all available operators(&binary arithmetic ["+", "-", "*", "/"]all available operators)Kfunctions on lists ["sum", "product", "maximum", "minimum", "head", "last"]all available operatorsu'wrapper to produce Function from String%&'()u%&'()&'()%%&'()uNone *+Enumeration of different kinds of mutations/íThe configuration options if 1 is provided, all mutants are selected for that kind, and 0 ensures that no mutants are picked for that kind. Any fraction in between causes that many mutants to be picked randomly from the available pool16Mutation operators on operator or function replacement22Mutate pattern matches for functions? for example 'first [] = Nothing first (x:_) = Just x is mutated to 'first (x:_) = Just x first [] = Nothing3AMutates integer values by +1 or -1 or by replacing it with 0 or 14negate if conditions, that is if True then 1 else 0becomes if (not True) then 1 else 053negate guarded booleans in case statements, that is &case v of True -> 1 otherwise -> 0becomes *case v of (not True) -> 1 otherwise -> 06&Maximum number of mutants to generate.7aGeneration mode, can be traditional (firstOrder) and higher order (higher order is experimental)85The knob controlling if we want first order mutation.;The default configuration<MgetSample returns the fraction in config corresponding to the enum passed in*+,-./0123456789:;<*+,-./0123456789:;<8:9/01234567;*.-,+<*.-,+/012345678:9;< NoneHIM=The =D function is a wrapper to genMutantsWith with standard configuraton>The >À function takes configuration function to mutate, filename the function is defined in, and produces mutants in the same directory as the filename, and returns the number of mutants produced.?_Wrapper around sampleF that returns correct sampling ratios according to configuration passed.@The @œ takes the function name to mutate, source where it is defined, and a sampling function, and returns the mutated sources selected using sampling function.A9Replace old function definition with a new one in the ASTB)Fetch the function definition from moduleC£Higher order mutation of a function's code using a bunch of mutation operators (In all the three mutate functions, we assume working with functions declaration.)DgFirst and higher order mutation. The third argument specifies whether it's first order or higher orderE”Given a function, generate all mutants after applying applying op once (op might be applied at different places). E.g.: if the operator is (op = " "==e ">") and there are two instances of "<" in the AST, then it will return two AST with each replaced.F9is the parsed expression the function we are looking for?G~Generate all operators for permutating pattern matches in a function. We don't deal with permutating guards and case for now.HUGenerates transformations that removes one pattern match from a function definition.I)Generate sub-arrays with one less elementJReturns the AST from the fileKSet the declaration in a moduleLÿçFor valops, unlike functions, we specify how any given literal value might change. So we take a predicate specifying how to recognize the literal value, a list of mappings specifying how the literal can change, and the AST, and recurse over the AST looking for literals that match our predicate. When we find any, we apply the given list of mappings to them, and produce a MuOp mapping between the original value and transformed value. This list of MuOp mappings are then returned.MtLook for literal values in AST, and return applicable MuOp transforms. Unfortunately booleans are not handled here.NConvert Boolean LiteralsO&Negating boolean in if/else statementsPNegating boolean in Guards=>?@ABCDEFGHIJKLMNOP=>?@ABCDEFGHIJKLMNOP=>?@ABCDEFGHIJKLMNOP=>?@ABCDEFGHIJKLMNOP NoneQPerform mutation analysisQQQQv    !"#$%&'()*+,-./01234567899:;<=>?@ABCDE F G H I J K L M N O P Q R S T U V W X Y Z[\]^_`abcdefghijklmnolpqrsttuvwxyz{|}MuCheck-0.2.1.0Test.MuCheck.Utils.PrintTest.MuCheck.MuOpTest.MuCheck.Utils.SybTest.MuCheck.TestAdapterTest.MuCheck.InterpreterTest.MuCheck.Utils.CommonTest.MuCheck.OperatorsTest.MuCheck.ConfigTest.MuCheck.Mutation Test.MuCheck./.showASshowAtt catchOutputMutable==>MuOpsamemkMpMuOp==>**==>*~~>once relevantOps Summarizable testSummary isSuccess isFailureisOtherSummaryMutantInterpreterOutputevaluateMutantschoosecoupling genFileNames replaceFstsamplerSamplesampleFremEltswapElts genSwapped genRandomSeedcurryMallOps comparatorspredNums binAriths arithListsMuVarsMutateNegateGuardsMutateNegateIfElse MutateValuesMutatePatternMatchConfigmuOpsdoMutatePatternMatchesdoMutateValuesdoNegateIfElsedoNegateGuards maxNumMutantsgenModeGenerationModeFirstAndHigherOrderFirstOrderOnly defaultConfig getSample genMutantsgenMutantsWithsamplergenMutantsForSrc replaceDefgetFuncmutatesmutatesNmutate isFunctionD permMatchesremoveOnePMatch removeOneElem getASTFromStrputDecls selectValOps selectLitOps selectBLitOpsselectIfElseBoolNegOpsselectGuardedBoolNegOpsmucheckshowM$fMutableGuardedRhs$fMutableLiteral $fMutableDecl $fMutableExp $fMutableQOp$fMutableQName $fMutableName $fShowMuOpGLDEQOQNNapplyTSSumrunCodeOnMutants evalMethodmultipleCheckSummarytssumNumMutants tssumAlive tssumErrorstssumLogTSumtsumNumMutants tsumLoadError tsumNotKilled tsumKilled tsumOtherstsumLog mySummaryFnvarfn