Pyh      !"#$%&'()*+,-./0123456789:;<=>?@ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g 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 action0Capture output and err of an IO action to a fileRedirect out and err to handleNoneHMFMutation 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 mkMphShow 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 separatelyiGuardedRhs instance for MutablejLiteral instance for MutablekExp instance for MutablelExp instance for MutablemQOp instance for MutablenQName instance for MutableoName instance for MutablepMuOp instance for Show qrstuvwx h ijklmnop     wvutsrqx h ijklmnopNoneHMTapply 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*Datatype to hold results of the entire runNone+ /Interface to be implemented by a test framework(Summary of test suite on a single mutantWas the test run a successWas the test run a failure*Was the test run neither (gaveup/timedout)Summary of test runHolding test information Holding mutant information!Wrapper for interpreter output  !"#$  !"#$ !"#$  !"#$ Safe-Inferred %The %+ function generates subsets of a given size&The &Q function produces all possible pairings, and applies the given function to each'The 'V function replaces first matching element in a list given old and new values as a pair(The (U function takes a random generator and chooses a random sample subset of given size.)/Wrapper around sample providing the random seed*The *` 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 pair0 A simple hash %&'()*+,-./0 %&'()*+,-./0 %&'()*+,-./0 %&'()*+,-./0None+EU14Data type to hold results of a single test execution6GGiven the list of tests suites to check, run the test suite on mutants.8Run all tests on a mutanty/Stop mutant runs at the first sign of problems.9Run one single test on a mutant:XGiven the filename, modulename, test to evaluate, evaluate, and return result as a pair. et = I.runInterpreter (evalMethod "Examples/QuickCheckTest.hs" "quickCheckResult idEmp")z7Summarize the entire run. Passed results are per mutant 12345678y9:z 123456789: 6:8971543215432678y9:zNone;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 operators{'wrapper to produce Function from String;<=>?{;<=>?<=>?;;<=>?{ None @+Enumeration of different kinds of mutationsEThe 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 poolG6Mutation operators on operator or function replacementH2Mutate pattern matches for functions? for example 'first [] = Nothing first (x:_) = Just x is mutated to 'first (x:_) = Just x first [] = NothingIAMutates integer values by +1 or -1 or by replacing it with 0 or 1Jnegate if conditions, that is if True then 1 else 0becomes if (not True) then 1 else 0K3negate guarded booleans in case statements, that is &case v of True -> 1 otherwise -> 0becomes *case v of (not True) -> 1 otherwise -> 0L&Maximum number of mutants to generate.MaGeneration mode, can be traditional (firstOrder) and higher order (higher order is experimental)N5The knob controlling if we want first order mutation.QThe default configurationRMgetSample returns the fraction in config corresponding to the enum passed in@ABCDEFGHIJKLMNOPQR@ABCDEFGHIJKLMNOPQRNPOEFGHIJKLMQ@DCBAR@DCBAEFGHIJKLMNPOQR NoneHIMSThe SD function is a wrapper to genMutantsWith with standard configuratonTThe T 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.U_Wrapper around sampleF that returns correct sampling ratios according to configuration passed.VThe V takes the function name to mutate, source where it is defined, and a sampling function, and returns the mutated sources selected using sampling function.W9Replace old function definition with a new one in the ASTX)Fetch the function definition from moduleYHigher 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.)ZgFirst and higher order mutation. The third argument specifies whether it's first order or higher order[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.\9is the parsed expression the function we are looking for?]~Generate all operators for permutating pattern matches in a function. We don't deal with permutating guards and case for now.^UGenerates transformations that removes one pattern match from a function definition._)Generate sub-arrays with one less element`Returns the AST from the fileaSet the declaration in a modulebFor 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.ctLook for literal values in AST, and return applicable MuOp transforms. Unfortunately booleans are not handled here.dConvert Boolean Literalse&Negating boolean in if/else statementsfNegating boolean in GuardsSTUVWXYZ[\]^_`abcdefSTUVWXYZ[\]^_`abcdefSTUVWXYZ[\]^_`abcdefSTUVWXYZ[\]^_`abcdef NonegPerform mutation analysisgggg|   !"#$%&'(()*+,-./0123456789:;<=>?@ABCDEFGHI J K L M N O O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o pqrstuvwxyz{|}~MuCheck-0.3.0.0Test.MuCheck.Utils.PrintTest.MuCheck.MuOpTest.MuCheck.Utils.SybTest.MuCheck.AnalysisSummaryTest.MuCheck.TestAdapterTest.MuCheck.Utils.CommonTest.MuCheck.InterpreterTest.MuCheck.OperatorsTest.MuCheck.ConfigTest.MuCheck.Mutation Test.MuCheck./.showASshowAttcatchOutputStr catchOutputredirectToHandleMutable==>MuOpsamemkMpMuOp==>**==>*~~>once relevantOpsMAnalysisSummary maNumMutantsmaAlivemaKilledmaErrors$fShowMAnalysisSummary Summarizable testSummary isSuccess isFailureisOtherSummaryTestStrMutantInterpreterOutputIo_io_ioLogchoosecoupling replaceFstsamplerSamplesampleFremEltswapElts genSwapped genRandomSeedcurryMhash MutantSummary MSumOther MSumKilled MSumAlive MSumErrorevaluateMutantssummarizeResults evalMutantevalTest evalMethodallOps comparatorspredNums binAriths arithListsMuVarsMutateNegateGuardsMutateNegateIfElse MutateValuesMutatePatternMatchConfigmuOpsdoMutatePatternMatchesdoMutateValuesdoNegateIfElsedoNegateGuards maxNumMutantsgenModeGenerationModeFirstAndHigherOrderFirstOrderOnly defaultConfig getSample genMutantsgenMutantsWithsamplergenMutantsForSrc replaceDefgetFuncmutatesmutatesNmutate isFunctionD permMatchesremoveOnePMatch removeOneElem getASTFromStrputDecls selectValOps selectLitOps selectBLitOpsselectIfElseBoolNegOpsselectGuardedBoolNegOpsmucheckshowM$fMutableGuardedRhs$fMutableLiteral $fMutableDecl $fMutableExp $fMutableQOp$fMutableQName $fMutableName $fShowMuOpGLDEQOQNNapplystopFast fullSummaryvarfn