diff --git a/src/MuTalk-CI-Tests/MTCoveragePropagationPreparationTest.class.st b/src/MuTalk-CI-Tests/MTCoveragePropagationPreparationTest.class.st index b5f22b6..75f0f79 100644 --- a/src/MuTalk-CI-Tests/MTCoveragePropagationPreparationTest.class.st +++ b/src/MuTalk-CI-Tests/MTCoveragePropagationPreparationTest.class.st @@ -15,7 +15,8 @@ MTCoveragePropagationPreparationTest >> testWorking [ analysis := MTAnalysis new testClasses: { MTCIHelperTest }; classesToMutate: { MTCIHelper }; - budget: MTFreeBudget new. + budget: MTFreeBudget new; + logger: MTNullLogger new. analysis run. moreInfo := MTCoveragePropagationPreparation new diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index ed891f3..3c2bcff 100644 --- a/src/MuTalk-Model/MTAnalysis.class.st +++ b/src/MuTalk-Model/MTAnalysis.class.st @@ -65,7 +65,7 @@ MTAnalysis >> defaultBudget [ { #category : 'accessing - defaults' } MTAnalysis >> defaultLogger [ - ^ MTTranscriptLogger new + ^ MTProgressBarLogger new ] { #category : 'accessing - defaults' } @@ -117,23 +117,26 @@ MTAnalysis >> generalResult [ { #category : 'running' } MTAnalysis >> generateCoverageAnalysis [ - logger logStartCoverageAnalysis. + logger logStartCoverageAnalysis: testCases size. coverageAnalysisResult := (MTCoverageAnalysis for: methodsToMutate running: testCases) run; - result + result. + logger logEndCoverageAnalysis ] { #category : 'running' } MTAnalysis >> generateMutations [ - logger logStartMutationGeneration. + logger logStartMutationGeneration: self methodSize. ^ mutations ifNil: [ mutations := mutantGenerationStrategy mutationsFor: self loggingIn: logger. - logger logTotalNumberOfMutations: mutations. + logger + logTotalNumberOfMutations: mutations; + logEndMutationGeneration. mutations ] ] @@ -141,18 +144,22 @@ MTAnalysis >> generateMutations [ MTAnalysis >> generateResults [ mutantResults := OrderedCollection new. - logger logStartMutationEvaluation. + logger logStartMutationEvaluation: mutations. mutations do: [ :aMutation | (budget exceedsBudgetOn: mutantResults fromTotalMutations: mutations) ifTrue: [ ^ mutantResults ]. - logger logStartEvaluating: aMutation. + logger logStartEvaluating: aMutation with: testCases size. + mutantResults add: ((MTMutantEvaluation for: aMutation using: testCases following: testSelectionStrategy andConsidering: self coverageAnalysisResult) - valueStoppingOnError: stopOnErrorOrFail) ]. + valueStoppingOnError: stopOnErrorOrFail). + logger logEndEvaluating ]. + + logger logEndMutationEvaluation. logger logEnd. ^ mutantResults ] @@ -161,7 +168,10 @@ MTAnalysis >> generateResults [ MTAnalysis >> initialTestRun [ "Runs all tests once and filters them" - testCases do: [ :aTestCase | aTestCase run ]. + | results | + logger logStartInitialTestRun: testCases size. + results := testCases collect: [ :aTestCase | aTestCase run ]. + logger logEndInitialTestRun. "The test filter is initialized lazily here because the default one needs the run time of tests, so the initial test run must be executed first" testCases := self testFilter filterTests: testCases. @@ -198,6 +208,12 @@ MTAnalysis >> logger: anObject [ logger := anObject ] +{ #category : 'as yet unclassified' } +MTAnalysis >> methodSize [ + + ^ (self modelClasses flatCollect: #methods) size +] + { #category : 'accessing' } MTAnalysis >> methodsToMutate [ @@ -292,16 +308,23 @@ MTAnalysis >> run [ those classes) and execute all mutants in the set of testClases. We obtain a result for each mutant generated" - self initialTestRun. - - "The budget is started after the initial test run because the default one needs the run time of tests" - budget start. - logger logAnalysisStartFor: self. - elapsedTime := [ - self generateCoverageAnalysis. - self generateMutations. - self generateResults ] timeToRun + logger logAnalysisStart. + self initialTestRun. + self startBudget. + [ + self generateCoverageAnalysis. + self generateMutations. + self generateResults ] timeToRun ] ensure: [ + logger release ] +] + +{ #category : 'starting' } +MTAnalysis >> startBudget [ + "The budget is initialized here because the default one needs the run time of tests, so the initial test run must be executed first" + + budget ifNil: [ budget := self defaultBudget ]. + budget start ] { #category : 'accessing' } diff --git a/src/MuTalk-Model/MTAnalysisLogger.class.st b/src/MuTalk-Model/MTAnalysisLogger.class.st index 6eab09e..ee5a9ca 100644 --- a/src/MuTalk-Model/MTAnalysisLogger.class.st +++ b/src/MuTalk-Model/MTAnalysisLogger.class.st @@ -7,7 +7,7 @@ Class { } { #category : 'logging' } -MTAnalysisLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ +MTAnalysisLogger >> logAnalysisStart [ self subclassResponsibility ] @@ -17,6 +17,36 @@ MTAnalysisLogger >> logEnd [ ^ self subclassResponsibility ] +{ #category : 'logging' } +MTAnalysisLogger >> logEndCoverageAnalysis [ + + ^ self subclassResponsibility +] + +{ #category : 'logging' } +MTAnalysisLogger >> logEndEvaluating [ + + self subclassResponsibility +] + +{ #category : 'logging' } +MTAnalysisLogger >> logEndInitialTestRun [ + + self subclassResponsibility +] + +{ #category : 'logging' } +MTAnalysisLogger >> logEndMutationEvaluation [ + + self subclassResponsibility +] + +{ #category : 'logging' } +MTAnalysisLogger >> logEndMutationGeneration [ + + self subclassResponsibility +] + { #category : 'logging' } MTAnalysisLogger >> logNumberOfGeneratedMutations: aNumber [ @@ -35,24 +65,31 @@ MTAnalysisLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutan ] { #category : 'logging' } -MTAnalysisLogger >> logStartCoverageAnalysis [ +MTAnalysisLogger >> logStartCoverageAnalysis: testSize [ ^ self subclassResponsibility ] { #category : 'logging' } -MTAnalysisLogger >> logStartEvaluating: aMethodMutation [ +MTAnalysisLogger >> logStartEvaluating: aMethodMutation with: testSize [ + + self subclassResponsibility +] + +{ #category : 'logging' } +MTAnalysisLogger >> logStartInitialTestRun: testSize [ + self subclassResponsibility ] { #category : 'logging' } -MTAnalysisLogger >> logStartMutationEvaluation [ +MTAnalysisLogger >> logStartMutationEvaluation: mutants [ ^ self subclassResponsibility ] { #category : 'logging' } -MTAnalysisLogger >> logStartMutationGeneration [ +MTAnalysisLogger >> logStartMutationGeneration: methodSize [ ^ self subclassResponsibility ] @@ -62,3 +99,16 @@ MTAnalysisLogger >> logTotalNumberOfMutations: mutations [ ^ self subclassResponsibility ] + +{ #category : 'private' } +MTAnalysisLogger >> methodNameOf: aCompiledMethod [ + + ^ aCompiledMethod methodClass name asString , '>>' + , aCompiledMethod selector printString +] + +{ #category : 'dependencies' } +MTAnalysisLogger >> release [ + + "Hook for subclasses. Called after the analysis is done, either because of success of exception/unwind" +] diff --git a/src/MuTalk-Model/MTFileLogger.class.st b/src/MuTalk-Model/MTFileLogger.class.st index 46b1728..152e5fc 100644 --- a/src/MuTalk-Model/MTFileLogger.class.st +++ b/src/MuTalk-Model/MTFileLogger.class.st @@ -39,3 +39,9 @@ MTFileLogger >> initializeToFileNamed: aString [ fileReference := aString asFileReference. self initialize ] + +{ #category : 'dependencies' } +MTFileLogger >> release [ + + stream close +] diff --git a/src/MuTalk-Model/MTMethodMutation.class.st b/src/MuTalk-Model/MTMethodMutation.class.st index 6b062a2..82a6468 100644 --- a/src/MuTalk-Model/MTMethodMutation.class.st +++ b/src/MuTalk-Model/MTMethodMutation.class.st @@ -175,6 +175,7 @@ MTMethodMutation >> printOn: aStream [ MTMethodMutation >> runMutantStoppingOnError: aBoolean in: anEvaluation [ | testResults brokenTests | + "1halt." [ EpMonitor disableDuring: [ testResults := [ diff --git a/src/MuTalk-Model/MTMutantGenerationStrategy.class.st b/src/MuTalk-Model/MTMutantGenerationStrategy.class.st index 56e6d98..f6d2d76 100644 --- a/src/MuTalk-Model/MTMutantGenerationStrategy.class.st +++ b/src/MuTalk-Model/MTMutantGenerationStrategy.class.st @@ -83,13 +83,11 @@ MTMutantGenerationStrategy >> mutationsFor: aMutationTestingAnalysis loggingIn: | mutations | mutations := OrderedCollection new. - (self methodsToMutateFrom: aMutationTestingAnalysis) - do: [ :aMethod | - mutations addAll: (self - mutationsFor: aMethod - usingAll: aMutationTestingAnalysis operators - logginIn: aLogger) ] - displayingProgress: 'Building Mutants'. + (self methodsToMutateFrom: aMutationTestingAnalysis) do: [ :aMethod | + mutations addAll: (self + mutationsFor: aMethod + usingAll: aMutationTestingAnalysis operators + logginIn: aLogger) ]. ^ mutantSelectionStrategy shuffleMutants: mutations ] diff --git a/src/MuTalk-Model/MTNullLogger.class.st b/src/MuTalk-Model/MTNullLogger.class.st index 0ee290d..22c6256 100644 --- a/src/MuTalk-Model/MTNullLogger.class.st +++ b/src/MuTalk-Model/MTNullLogger.class.st @@ -16,13 +16,43 @@ MTNullLogger class >> new [ ] { #category : 'logging' } -MTNullLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ +MTNullLogger >> logAnalysisStart [ ] { #category : 'logging' } MTNullLogger >> logEnd [ +] + +{ #category : 'logging' } +MTNullLogger >> logEndCoverageAnalysis [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logEndEvaluating [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logEndInitialTestRun [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logEndMutationEvaluation [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logEndMutationGeneration [ + + ] { #category : 'logging' } @@ -42,7 +72,7 @@ MTNullLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOpe ] { #category : 'logging' } -MTNullLogger >> logStartCoverageAnalysis [ +MTNullLogger >> logStartCoverageAnalysis: testSize [ ] @@ -52,7 +82,19 @@ MTNullLogger >> logStartEvaluating: aMethodMutation [ ] { #category : 'logging' } -MTNullLogger >> logStartMutationEvaluation [ +MTNullLogger >> logStartEvaluating: aMethodMutation with: testSize [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logStartInitialTestRun: testSize [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logStartMutationEvaluation: mutants [ ] @@ -61,6 +103,12 @@ MTNullLogger >> logStartMutationEvaluation [ MTNullLogger >> logStartMutationGeneration [ +] + +{ #category : 'logging' } +MTNullLogger >> logStartMutationGeneration: methodSize [ + + ] { #category : 'logging' } diff --git a/src/MuTalk-Model/MTProgressBarLogger.class.st b/src/MuTalk-Model/MTProgressBarLogger.class.st new file mode 100644 index 0000000..bd5822c --- /dev/null +++ b/src/MuTalk-Model/MTProgressBarLogger.class.st @@ -0,0 +1,224 @@ +Class { + #name : 'MTProgressBarLogger', + #superclass : 'MTAnalysisLogger', + #instVars : [ + 'mainJob', + 'testJob', + 'mutantJob', + 'methodJob' + ], + #category : 'MuTalk-Model-Logging', + #package : 'MuTalk-Model', + #tag : 'Logging' +} + +{ #category : 'initialization' } +MTProgressBarLogger >> initialize [ + + mainJob := Job new. + SystemVersion current major <= 10 ifTrue: [ + "Jobs need a block below P10 to have an owner?" + mainJob block: [ ]. + ]. + mainJob + min: 0; + max: 4. + mainJob title: 'Mutation Analysis: ' +] + +{ #category : 'initialization' } +MTProgressBarLogger >> initializeMethodJob: size [ + + methodJob := Job new + min: 0; + max: size; + yourself. + + SystemVersion current major <= 10 ifTrue: [ + "Jobs need a block below P10 to have an owner?" + methodJob block: [ ] ]. + + methodJob prepareForRunning +] + +{ #category : 'initialization' } +MTProgressBarLogger >> initializeMutantJob: size [ + + mutantJob := Job new + min: 0; + max: size; + yourself. + + SystemVersion current major <= 10 ifTrue: [ + "Jobs need a block below P10 to have an owner?" + mutantJob block: [ ] ]. + + mutantJob prepareForRunning +] + +{ #category : 'initialization' } +MTProgressBarLogger >> initializeTestJob: size [ + + testJob := Job new + min: 0; + max: size; + yourself. + + SystemVersion current major <= 10 ifTrue: [ + "Jobs need a block below P10 to have an owner?" + testJob block: [ ]. + ]. + + testJob prepareForRunning +] + +{ #category : 'logging' } +MTProgressBarLogger >> logAnalysisStart [ + + mainJob prepareForRunning +] + +{ #category : 'logging' } +MTProgressBarLogger >> logEnd [ + + mainJob title: 'Mutation Testing: Finished'. + mainJob cleanupAfterRunning. + mainJob := nil +] + +{ #category : 'logging' } +MTProgressBarLogger >> logEndCoverageAnalysis [ + + self testJob cleanupAfterRunning. + mainJob increment. + testJob := nil +] + +{ #category : 'logging' } +MTProgressBarLogger >> logEndEvaluating [ + + self testJob cleanupAfterRunning. + self mutantJob increment. + testJob := nil +] + +{ #category : 'logging' } +MTProgressBarLogger >> logEndInitialTestRun [ + + self testJob cleanupAfterRunning. + mainJob increment. + testJob := nil +] + +{ #category : 'logging' } +MTProgressBarLogger >> logEndMutationEvaluation [ + + self mutantJob cleanupAfterRunning. + mutantJob := nil. + mainJob increment +] + +{ #category : 'logging' } +MTProgressBarLogger >> logEndMutationGeneration [ + + self methodJob cleanupAfterRunning. + methodJob := nil. + mainJob increment +] + +{ #category : 'logging' } +MTProgressBarLogger >> logNumberOfGeneratedMutations: aNumber [ + + "[ :job | + aNumber < 2 + ifTrue: [ job title: aNumber asString , ' mutation generated' ] + ifFalse: [ job title: aNumber asString , ' mutations generated' ] ] + asJob run" +] + +{ #category : 'logging' } +MTProgressBarLogger >> logRunningTest: aTestCaseReference [ + + self testJob title: + 'Running mutated test: ' , aTestCaseReference testCase printString. + self testJob increment +] + +{ #category : 'logging' } +MTProgressBarLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ + + self methodJob title: + 'Generating mutations for ' , (self methodNameOf: aCompiledMethod) + , ' with operator: ' , aMutantOperator description. + self methodJob increment +] + +{ #category : 'logging' } +MTProgressBarLogger >> logStartCoverageAnalysis: testSize [ + + mainJob title: 'Mutation Testing: Starting coverage analysis'. + self initializeTestJob: testSize +] + +{ #category : 'logging' } +MTProgressBarLogger >> logStartEvaluating: aMethodMutation with: testSize [ + + self mutantJob title: 'Evaluating ' , aMethodMutation printString. + self initializeTestJob: testSize +] + +{ #category : 'logging' } +MTProgressBarLogger >> logStartInitialTestRun: testSize [ + + mainJob title: 'Mutation Testing: Initial test run'. + self initializeTestJob: testSize +] + +{ #category : 'logging' } +MTProgressBarLogger >> logStartMutationEvaluation: mutants [ + + mainJob title: 'Mutation Testing: Evaluating mutants'. + self initializeMutantJob: mutants size +] + +{ #category : 'logging' } +MTProgressBarLogger >> logStartMutationGeneration: methodSize [ + + mainJob title: 'Mutation Testing: Generating mutants'. + self initializeMethodJob: methodSize +] + +{ #category : 'logging' } +MTProgressBarLogger >> logTotalNumberOfMutations: mutations [ + + "[ :job | + job title: mutations size asString , ' total mutations generated' ] + asJob run" +] + +{ #category : 'accessing' } +MTProgressBarLogger >> methodJob [ + + ^ methodJob +] + +{ #category : 'accessing' } +MTProgressBarLogger >> mutantJob [ + + ^ mutantJob +] + +{ #category : 'dependencies' } +MTProgressBarLogger >> release [ + + methodJob ifNotNil: [ self methodJob cleanupAfterRunning ]. + mutantJob ifNotNil: [ self mutantJob cleanupAfterRunning ]. + testJob ifNotNil: [ self testJob cleanupAfterRunning ]. + mainJob ifNotNil: [ mainJob cleanupAfterRunning ] +] + +{ #category : 'accessing' } +MTProgressBarLogger >> testJob [ + + ^ testJob +] diff --git a/src/MuTalk-Model/MTStreamLogger.class.st b/src/MuTalk-Model/MTStreamLogger.class.st index aaa81c1..84bb8e5 100644 --- a/src/MuTalk-Model/MTStreamLogger.class.st +++ b/src/MuTalk-Model/MTStreamLogger.class.st @@ -23,10 +23,10 @@ MTStreamLogger >> initializeStream [ ] { #category : 'logging' } -MTStreamLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ +MTStreamLogger >> logAnalysisStart [ stream - nextPutAll: 'The analysis is starting...'; + nextPutAll: 'The analysis is starting'; cr ] @@ -38,6 +38,44 @@ MTStreamLogger >> logEnd [ close ] +{ #category : 'logging' } +MTStreamLogger >> logEndCoverageAnalysis [ + + stream + nextPutAll: 'Coverage analysis finished'; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logEndEvaluating [ + + +] + +{ #category : 'logging' } +MTStreamLogger >> logEndInitialTestRun [ + + stream + nextPutAll: 'Initial test run finished'; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logEndMutationEvaluation [ + + stream + nextPutAll: 'Mutant evaluation finished'; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logEndMutationGeneration [ + + stream + nextPutAll: 'Mutant generation finished'; + cr +] + { #category : 'logging' } MTStreamLogger >> logNumberOfGeneratedMutations: aNumber [ @@ -64,13 +102,13 @@ MTStreamLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantO stream nextPutAll: 'Generating mutations for '; nextPutAll: (self methodNameOf: aCompiledMethod); - nextPutAll: ' with operator:'; + nextPutAll: ' with operator:'; nextPutAll: aMutantOperator description; cr ] { #category : 'logging' } -MTStreamLogger >> logStartCoverageAnalysis [ +MTStreamLogger >> logStartCoverageAnalysis: testSize [ stream nextPutAll: 'Starting coverage analysis'; @@ -78,19 +116,27 @@ MTStreamLogger >> logStartCoverageAnalysis [ ] { #category : 'logging' } -MTStreamLogger >> logStartEvaluating: aMethodMutation [ +MTStreamLogger >> logStartEvaluating: aMethodMutation with: testSize [ stream - nextPutAll: 'Evaluating mutant of method '; - nextPutAll: (self methodNameOf: aMethodMutation originalMethod); - nextPutAll: ' with source:'; + nextPutAll: 'Evaluating '; + nextPutAll: aMethodMutation printString; + nextPutAll: ' with source:'; cr; nextPutAll: aMethodMutation modifiedSource; cr ] { #category : 'logging' } -MTStreamLogger >> logStartMutationEvaluation [ +MTStreamLogger >> logStartInitialTestRun: testSize [ + + stream + nextPutAll: 'Starting initial test run'; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logStartMutationEvaluation: mutants [ stream nextPutAll: 'Starting mutation evaluation'; @@ -98,7 +144,7 @@ MTStreamLogger >> logStartMutationEvaluation [ ] { #category : 'logging' } -MTStreamLogger >> logStartMutationGeneration [ +MTStreamLogger >> logStartMutationGeneration: methodSize [ stream nextPutAll: 'Starting mutation generation'; @@ -114,13 +160,6 @@ MTStreamLogger >> logTotalNumberOfMutations: mutations [ cr ] -{ #category : 'private' } -MTStreamLogger >> methodNameOf: aCompiledMethod [ - - ^ aCompiledMethod methodClass name asString , '>>' - , aCompiledMethod selector printString -] - { #category : 'accessing' } MTStreamLogger >> stream [ diff --git a/src/MuTalk-Model/MTTestCaseReference.class.st b/src/MuTalk-Model/MTTestCaseReference.class.st index 7e9346e..89db265 100644 --- a/src/MuTalk-Model/MTTestCaseReference.class.st +++ b/src/MuTalk-Model/MTTestCaseReference.class.st @@ -110,6 +110,7 @@ MTTestCaseReference >> resources [ { #category : 'evaluating' } MTTestCaseReference >> run [ + logger logRunningTest: self. lastTimeToRun := [ lastResult := self testCase run ] timeToRun. ^ lastResult ] diff --git a/src/MuTalk-Model/MTTestSuiteWrappedForCoverage.class.st b/src/MuTalk-Model/MTTestSuiteWrappedForCoverage.class.st index b41ebbf..a6c6693 100644 --- a/src/MuTalk-Model/MTTestSuiteWrappedForCoverage.class.st +++ b/src/MuTalk-Model/MTTestSuiteWrappedForCoverage.class.st @@ -21,10 +21,11 @@ MTTestSuiteWrappedForCoverage >> initializeFor: aCoverageAnalysis named: aString ] { #category : 'running' } -MTTestSuiteWrappedForCoverage >> run: aResult [ - self tests do: [:each |coverageAnalysis currentTest: each. - self changed: each. - each run: aResult. - coverageAnalysis currentTest: nil] - displayingProgress: 'Analysing Coverage'. +MTTestSuiteWrappedForCoverage >> run: aResult [ + + self tests do: [ :each | + coverageAnalysis currentTest: each. + self changed: each. + each run: aResult. + coverageAnalysis currentTest: nil ] ] diff --git a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st index 541c170..638b06f 100644 --- a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st +++ b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st @@ -18,7 +18,7 @@ MTMockAnalysisLogger >> initialize [ ] { #category : 'logging' } -MTMockAnalysisLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ +MTMockAnalysisLogger >> logAnalysisStart [ loggedStartAnalysis := true. ] @@ -26,6 +26,36 @@ MTMockAnalysisLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ MTMockAnalysisLogger >> logEnd [ +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logEndCoverageAnalysis [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logEndEvaluating [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logEndInitialTestRun [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logEndMutationEvaluation [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logEndMutationGeneration [ + + ] { #category : 'logging' } @@ -54,20 +84,45 @@ MTMockAnalysisLogger >> logStartCoverageAnalysis [ ] { #category : 'logging' } -MTMockAnalysisLogger >> logStartEvaluating: aMethodMutation [ - loggedEvaluationMutations add: aMethodMutation. +MTMockAnalysisLogger >> logStartCoverageAnalysis: testSize [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartEvaluating: aMethodMutation with: testSize [ + + loggedEvaluationMutations add: aMethodMutation +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartInitialTestRun: testSize [ + + ] { #category : 'logging' } MTMockAnalysisLogger >> logStartMutationEvaluation [ +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartMutationEvaluation: mutants [ + + ] { #category : 'logging' } MTMockAnalysisLogger >> logStartMutationGeneration [ +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartMutationGeneration: methodSize [ + + ] { #category : 'logging' }