diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index 6fda740e..9a2ce9ad 100644 --- a/src/MuTalk-Model/MTAnalysis.class.st +++ b/src/MuTalk-Model/MTAnalysis.class.st @@ -60,7 +60,7 @@ MTAnalysis >> defaultBudget [ { #category : 'accessing - defaults' } MTAnalysis >> defaultLogger [ - ^ MTNullAnalysisLogger new + ^ MTNullLogger new ] { #category : 'accessing - defaults' } @@ -105,6 +105,7 @@ MTAnalysis >> generalResult [ { #category : 'running' } MTAnalysis >> generateCoverageAnalysis [ + logger logStartCoverageAnalysis. coverageAnalysisResult := (MTCoverageAnalysis for: self modelClasses running: testCases) @@ -115,16 +116,20 @@ MTAnalysis >> generateCoverageAnalysis [ { #category : 'running' } MTAnalysis >> generateMutations [ + logger logStartMutationGeneration. ^ mutations ifNil: [ mutations := mutantSelectionStrategy mutationsFor: self - loggingIn: logger ] + loggingIn: logger. + logger logTotalNumberOfMutations: mutations. + mutations ] ] { #category : 'running' } MTAnalysis >> generateResults [ mutantResults := OrderedCollection new. + logger logStartMutationEvaluation. mutations do: [ :aMutation | (budget exceedsBudgetOn: mutantResults fromTotalMutations: mutations) @@ -136,6 +141,7 @@ MTAnalysis >> generateResults [ following: testSelectionStrategy andConsidering: self coverageAnalysisResult) valueStoppingOnError: stopOnErrorOrFail) ]. + logger logEnd. ^ mutantResults ] @@ -173,6 +179,8 @@ MTAnalysis >> logger [ { #category : 'accessing' } MTAnalysis >> logger: anObject [ + testCases do: [ :testCaseReference | + testCaseReference logger: anObject ]. logger := anObject ] @@ -296,7 +304,7 @@ MTAnalysis >> testCasesFrom: aClassCollection [ MTAnalysis >> testCasesReferencesFrom: testClass [ ^ testClass buildSuite tests collect: [ :each | - MTTestCaseReference for: each ] + MTTestCaseReference for: each logger: logger ] ] { #category : 'accessing' } diff --git a/src/MuTalk-Model/MTAnalysisFileLogger.class.st b/src/MuTalk-Model/MTAnalysisFileLogger.class.st deleted file mode 100644 index 1684ba4d..00000000 --- a/src/MuTalk-Model/MTAnalysisFileLogger.class.st +++ /dev/null @@ -1,66 +0,0 @@ -Class { - #name : 'MTAnalysisFileLogger', - #superclass : 'MTAnalysisLogger', - #instVars : [ - 'fileReference' - ], - #category : 'MuTalk-Model-Logging', - #package : 'MuTalk-Model', - #tag : 'Logging' -} - -{ #category : 'instance creation' } -MTAnalysisFileLogger class >> toFileNamed: aString [ - ^self new initializeToFileNamed: aString. -] - -{ #category : 'initialize-release' } -MTAnalysisFileLogger >> initializeToFileNamed: aString [ - - fileReference := aString asFileReference -] - -{ #category : 'logging' } -MTAnalysisFileLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ - - self writeLineToFile: 'The analysis is starting...' -] - -{ #category : 'logging' } -MTAnalysisFileLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ - - self writeLineToFile: - 'Generating mutations for ' , (self methodNameOf: aCompiledMethod) - , ' With operator:' , aMutantOperator description -] - -{ #category : 'logging' } -MTAnalysisFileLogger >> logStartEvaluating: aMethodMutation [ - - | logStream | - logStream := WriteStream on: String new. - logStream - nextPutAll: 'Evaluating mutant of method '; - nextPutAll: (self methodNameOf: aMethodMutation originalMethod); - nextPutAll: ' With source:'. - logStream cr. - logStream nextPutAll: aMethodMutation modifiedSource. - self writeLineToFile: logStream contents -] - -{ #category : 'private' } -MTAnalysisFileLogger >> methodNameOf: aCompiledMethod [ - - ^ aCompiledMethod methodClass name asString , '>>' - , aCompiledMethod selector printString -] - -{ #category : 'private' } -MTAnalysisFileLogger >> writeLineToFile: aString [ - - fileReference writeStreamDo: [ :stream | - stream - setToEnd; - nextPutAll: aString; - cr ] -] diff --git a/src/MuTalk-Model/MTAnalysisLogger.class.st b/src/MuTalk-Model/MTAnalysisLogger.class.st index a814b5c2..6eab09e8 100644 --- a/src/MuTalk-Model/MTAnalysisLogger.class.st +++ b/src/MuTalk-Model/MTAnalysisLogger.class.st @@ -11,12 +11,54 @@ MTAnalysisLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ self subclassResponsibility ] +{ #category : 'logging' } +MTAnalysisLogger >> logEnd [ + + ^ self subclassResponsibility +] + +{ #category : 'logging' } +MTAnalysisLogger >> logNumberOfGeneratedMutations: aNumber [ + + ^ self subclassResponsibility +] + +{ #category : 'logging' } +MTAnalysisLogger >> logRunningTest: aTestCaseReference [ + + self subclassResponsibility +] + { #category : 'logging' } MTAnalysisLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ self subclassResponsibility ] +{ #category : 'logging' } +MTAnalysisLogger >> logStartCoverageAnalysis [ + + ^ self subclassResponsibility +] + { #category : 'logging' } MTAnalysisLogger >> logStartEvaluating: aMethodMutation [ self subclassResponsibility ] + +{ #category : 'logging' } +MTAnalysisLogger >> logStartMutationEvaluation [ + + ^ self subclassResponsibility +] + +{ #category : 'logging' } +MTAnalysisLogger >> logStartMutationGeneration [ + + ^ self subclassResponsibility +] + +{ #category : 'logging' } +MTAnalysisLogger >> logTotalNumberOfMutations: mutations [ + + ^ self subclassResponsibility +] diff --git a/src/MuTalk-Model/MTFileLogger.class.st b/src/MuTalk-Model/MTFileLogger.class.st new file mode 100644 index 00000000..46b17288 --- /dev/null +++ b/src/MuTalk-Model/MTFileLogger.class.st @@ -0,0 +1,41 @@ +Class { + #name : 'MTFileLogger', + #superclass : 'MTStreamLogger', + #instVars : [ + 'fileReference' + ], + #category : 'MuTalk-Model-Logging', + #package : 'MuTalk-Model', + #tag : 'Logging' +} + +{ #category : 'instance creation' } +MTFileLogger class >> toFileNamed: aString [ + + ^ self basicNew initializeToFileNamed: aString +] + +{ #category : 'accessing' } +MTFileLogger >> fileReference [ + + ^ fileReference +] + +{ #category : 'accessing' } +MTFileLogger >> fileReference: anObject [ + + fileReference := anObject +] + +{ #category : 'initialization' } +MTFileLogger >> initializeStream [ + + stream := fileReference writeStream +] + +{ #category : 'initialize-release' } +MTFileLogger >> initializeToFileNamed: aString [ + + fileReference := aString asFileReference. + self initialize +] diff --git a/src/MuTalk-Model/MTMutantSelectionStrategy.class.st b/src/MuTalk-Model/MTMutantSelectionStrategy.class.st index c6d27a8e..992b5c15 100644 --- a/src/MuTalk-Model/MTMutantSelectionStrategy.class.st +++ b/src/MuTalk-Model/MTMutantSelectionStrategy.class.st @@ -34,20 +34,27 @@ MTMutantSelectionStrategy >> mutationsFor: aMutationTestingAnalysis loggingIn: a ] { #category : 'generating' } -MTMutantSelectionStrategy >> mutationsFor: aMethod usingAll: aCollectionOfMutantOperators logginIn: aLogger [ +MTMutantSelectionStrategy >> mutationsFor: aMethod usingAll: aCollectionOfMutantOperators logginIn: aLogger [ + | parseTree | parseTree := aMethod parseTree. ^ aCollectionOfMutantOperators - inject: OrderedCollection new - into: [:mutations :anOperator | - aLogger logStartBuildingMutantionsFor: aMethod using: anOperator. - (aMethod ignoredMutationOperators includes: anOperator class) - ifFalse: [ mutations addAll: (anOperator mutationsFor: aMethod with: parseTree) ]. - mutations ] + inject: OrderedCollection new + into: [ :mutations :anOperator | + aLogger logStartBuildingMutantionsFor: aMethod using: anOperator. + (aMethod ignoredMutationOperators includes: anOperator class) + ifFalse: [ + | newMutations | + newMutations := anOperator + mutationsFor: aMethod + with: parseTree. + aLogger logNumberOfGeneratedMutations: newMutations size. + mutations addAll: newMutations ]. + mutations ] ] { #category : 'logging' } MTMutantSelectionStrategy >> nullLogger [ - ^ MTNullAnalysisLogger new. + ^ MTNullLogger new. ] diff --git a/src/MuTalk-Model/MTNullAnalysisLogger.class.st b/src/MuTalk-Model/MTNullAnalysisLogger.class.st deleted file mode 100644 index d78d2600..00000000 --- a/src/MuTalk-Model/MTNullAnalysisLogger.class.st +++ /dev/null @@ -1,28 +0,0 @@ -Class { - #name : 'MTNullAnalysisLogger', - #superclass : 'MTAnalysisLogger', - #classInstVars : [ - 'instance' - ], - #category : 'MuTalk-Model-Logging', - #package : 'MuTalk-Model', - #tag : 'Logging' -} - -{ #category : 'instance creation' } -MTNullAnalysisLogger class >> new [ - instance ifNil:[instance := super new.]. - ^instance. -] - -{ #category : 'logging' } -MTNullAnalysisLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ -] - -{ #category : 'logging' } -MTNullAnalysisLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ -] - -{ #category : 'logging' } -MTNullAnalysisLogger >> logStartEvaluating: aMethodMutation [ -] diff --git a/src/MuTalk-Model/MTNullLogger.class.st b/src/MuTalk-Model/MTNullLogger.class.st new file mode 100644 index 00000000..0ee290de --- /dev/null +++ b/src/MuTalk-Model/MTNullLogger.class.st @@ -0,0 +1,70 @@ +Class { + #name : 'MTNullLogger', + #superclass : 'MTAnalysisLogger', + #classInstVars : [ + 'instance' + ], + #category : 'MuTalk-Model-Logging', + #package : 'MuTalk-Model', + #tag : 'Logging' +} + +{ #category : 'instance creation' } +MTNullLogger class >> new [ + instance ifNil:[instance := super new.]. + ^instance. +] + +{ #category : 'logging' } +MTNullLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ +] + +{ #category : 'logging' } +MTNullLogger >> logEnd [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logNumberOfGeneratedMutations: aNumber [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logRunningTest: aTestCaseReference [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ +] + +{ #category : 'logging' } +MTNullLogger >> logStartCoverageAnalysis [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logStartEvaluating: aMethodMutation [ +] + +{ #category : 'logging' } +MTNullLogger >> logStartMutationEvaluation [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logStartMutationGeneration [ + + +] + +{ #category : 'logging' } +MTNullLogger >> logTotalNumberOfMutations: mutations [ + + +] diff --git a/src/MuTalk-Model/MTStreamLogger.class.st b/src/MuTalk-Model/MTStreamLogger.class.st new file mode 100644 index 00000000..aaa81c11 --- /dev/null +++ b/src/MuTalk-Model/MTStreamLogger.class.st @@ -0,0 +1,134 @@ +Class { + #name : 'MTStreamLogger', + #superclass : 'MTAnalysisLogger', + #instVars : [ + 'stream' + ], + #category : 'MuTalk-Model-Logging', + #package : 'MuTalk-Model', + #tag : 'Logging' +} + +{ #category : 'initialization' } +MTStreamLogger >> initialize [ + + super initialize. + self initializeStream +] + +{ #category : 'initialization' } +MTStreamLogger >> initializeStream [ + + ^ self subclassResponsibility +] + +{ #category : 'logging' } +MTStreamLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ + + stream + nextPutAll: 'The analysis is starting...'; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logEnd [ + + stream + nextPutAll: 'The analysis is finished'; + close +] + +{ #category : 'logging' } +MTStreamLogger >> logNumberOfGeneratedMutations: aNumber [ + + stream + nextPutAll: aNumber asString; + nextPutAll: (aNumber < 2 + ifTrue: [ ' mutation generated' ] + ifFalse: [ ' mutations generated' ]); + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logRunningTest: aTestCaseReference [ + + stream + nextPutAll: 'Running test: '; + nextPutAll: aTestCaseReference testCase printString; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ + + stream + nextPutAll: 'Generating mutations for '; + nextPutAll: (self methodNameOf: aCompiledMethod); + nextPutAll: ' with operator:'; + nextPutAll: aMutantOperator description; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logStartCoverageAnalysis [ + + stream + nextPutAll: 'Starting coverage analysis'; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logStartEvaluating: aMethodMutation [ + + stream + nextPutAll: 'Evaluating mutant of method '; + nextPutAll: (self methodNameOf: aMethodMutation originalMethod); + nextPutAll: ' with source:'; + cr; + nextPutAll: aMethodMutation modifiedSource; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logStartMutationEvaluation [ + + stream + nextPutAll: 'Starting mutation evaluation'; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logStartMutationGeneration [ + + stream + nextPutAll: 'Starting mutation generation'; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logTotalNumberOfMutations: mutations [ + + stream + nextPutAll: mutations size asString; + nextPutAll: ' total mutations generated'; + cr +] + +{ #category : 'private' } +MTStreamLogger >> methodNameOf: aCompiledMethod [ + + ^ aCompiledMethod methodClass name asString , '>>' + , aCompiledMethod selector printString +] + +{ #category : 'accessing' } +MTStreamLogger >> stream [ + + ^ stream +] + +{ #category : 'accessing' } +MTStreamLogger >> stream: anObject [ + + stream := anObject +] diff --git a/src/MuTalk-Model/MTTestCaseReference.class.st b/src/MuTalk-Model/MTTestCaseReference.class.st index c697ef97..7e9346e5 100644 --- a/src/MuTalk-Model/MTTestCaseReference.class.st +++ b/src/MuTalk-Model/MTTestCaseReference.class.st @@ -4,7 +4,8 @@ Class { #instVars : [ 'testCase', 'lastTimeToRun', - 'lastResult' + 'lastResult', + 'logger' ], #category : 'MuTalk-Model-Core', #package : 'MuTalk-Model', @@ -17,6 +18,12 @@ MTTestCaseReference class >> for: aTestCase [ ^ self new initializeFor: aTestCase ] +{ #category : 'instance creation' } +MTTestCaseReference class >> for: aTestCase logger: aLogger [ + + ^ self new initializeFor: aTestCase logger: aLogger +] + { #category : 'comparing' } MTTestCaseReference >> = anObject [ @@ -26,6 +33,12 @@ MTTestCaseReference >> = anObject [ ^ self selector = anObject selector ] +{ #category : 'defaults' } +MTTestCaseReference >> defaultLogger [ + + ^ MTNullLogger new +] + { #category : 'comparing' } MTTestCaseReference >> hash [ @@ -35,7 +48,15 @@ MTTestCaseReference >> hash [ { #category : 'initialize' } MTTestCaseReference >> initializeFor: aTestCase [ - testCase := aTestCase + testCase := aTestCase. + logger := self defaultLogger +] + +{ #category : 'initialize' } +MTTestCaseReference >> initializeFor: aTestCase logger: aLogger [ + + testCase := aTestCase. + logger := aLogger ] { #category : 'accessing' } @@ -56,6 +77,18 @@ MTTestCaseReference >> lastTimeToRun [ ^ lastTimeToRun ] +{ #category : 'accessing' } +MTTestCaseReference >> logger [ + + ^ logger +] + +{ #category : 'accessing' } +MTTestCaseReference >> logger: anObject [ + + logger := anObject +] + { #category : 'accessing' } MTTestCaseReference >> method [ @@ -84,6 +117,7 @@ MTTestCaseReference >> run [ { #category : 'evaluating' } MTTestCaseReference >> run: aTestResult [ + logger logRunningTest: self. ^ testCase run: aTestResult ] diff --git a/src/MuTalk-Model/MTTranscriptLogger.class.st b/src/MuTalk-Model/MTTranscriptLogger.class.st new file mode 100644 index 00000000..31f52a77 --- /dev/null +++ b/src/MuTalk-Model/MTTranscriptLogger.class.st @@ -0,0 +1,13 @@ +Class { + #name : 'MTTranscriptLogger', + #superclass : 'MTStreamLogger', + #category : 'MuTalk-Model-Logging', + #package : 'MuTalk-Model', + #tag : 'Logging' +} + +{ #category : 'initialization' } +MTTranscriptLogger >> initializeStream [ + + stream := Transcript +] diff --git a/src/MuTalk-Tests/MTAnalysisLoggerTest.class.st b/src/MuTalk-Tests/MTAnalysisLoggerTest.class.st index c5b65042..ea6e7752 100644 --- a/src/MuTalk-Tests/MTAnalysisLoggerTest.class.st +++ b/src/MuTalk-Tests/MTAnalysisLoggerTest.class.st @@ -9,7 +9,7 @@ Class { MTAnalysisLoggerTest >> testExecutingSimpleMutation [ | analysis logger operator | - logger := MTMockMTAnalysisLogger new. + logger := MTMockAnalysisLogger new. operator := MTReplacePlusWithMinusMutantOperator new. analysis := MTAnalysis new testClasses: diff --git a/src/MuTalk-Tests/MTAnalysisFileLoggerTest.class.st b/src/MuTalk-Tests/MTFileLoggerTest.class.st similarity index 74% rename from src/MuTalk-Tests/MTAnalysisFileLoggerTest.class.st rename to src/MuTalk-Tests/MTFileLoggerTest.class.st index 5b0f447e..c6bb1a1e 100644 --- a/src/MuTalk-Tests/MTAnalysisFileLoggerTest.class.st +++ b/src/MuTalk-Tests/MTFileLoggerTest.class.st @@ -1,12 +1,12 @@ Class { - #name : 'MTAnalysisFileLoggerTest', + #name : 'MTFileLoggerTest', #superclass : 'TestCase', #category : 'MuTalk-Tests', #package : 'MuTalk-Tests' } { #category : 'tests' } -MTAnalysisFileLoggerTest >> testLogFileExists [ +MTFileLoggerTest >> testLogFileExists [ | analysis logFileName logFile | logFileName := 'logFileForTest.txt'. @@ -14,7 +14,7 @@ MTAnalysisFileLoggerTest >> testLogFileExists [ analysis := MTAnalysis new classesToMutate: { MTAuxiliarClassForMTAnalysis }; testClasses: { MTAuxiliarClassForMTAnalysisTest }; - logger: (MTAnalysisFileLogger toFileNamed: logFileName). + logger: (MTFileLogger toFileNamed: logFileName). analysis run. diff --git a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st new file mode 100644 index 00000000..541c1707 --- /dev/null +++ b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st @@ -0,0 +1,94 @@ +Class { + #name : 'MTMockAnalysisLogger', + #superclass : 'MTAnalysisLogger', + #instVars : [ + 'loggedStartAnalysis', + 'loggedStartBuildingMutations', + 'loggedEvaluationMutations' + ], + #category : 'MuTalk-Tests', + #package : 'MuTalk-Tests' +} + +{ #category : 'initialization' } +MTMockAnalysisLogger >> initialize [ + loggedStartAnalysis := false. + loggedStartBuildingMutations := OrderedCollection new. + loggedEvaluationMutations := OrderedCollection new. +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ + loggedStartAnalysis := true. +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logEnd [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logNumberOfGeneratedMutations: aNumber [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logRunningTest: aTestCaseReference [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ + loggedStartBuildingMutations add:(Array with:aCompiledMethod with: aMutantOperator ). + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartCoverageAnalysis [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartEvaluating: aMethodMutation [ + loggedEvaluationMutations add: aMethodMutation. +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartMutationEvaluation [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartMutationGeneration [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logTotalNumberOfMutations: mutations [ + + +] + +{ #category : 'testing' } +MTMockAnalysisLogger >> loggedStartAnalysis [ + ^loggedStartAnalysis +] + +{ #category : 'testing' } +MTMockAnalysisLogger >> loggedStartBuildingMutationsFor: aCompiledMethod using: aMutantOperator [ + ^loggedStartBuildingMutations anySatisfy:[:array | (array at:1 ) = aCompiledMethod and:[(array at:2) = aMutantOperator ]] + +] + +{ #category : 'testing' } +MTMockAnalysisLogger >> loggedStartMutantEvaluationForMutationOf: aCompiledMethod [ + ^ loggedEvaluationMutations + anySatisfy: [:aMutation | aMutation originalMethod = aCompiledMethod] +] diff --git a/src/MuTalk-Tests/MTMockMTAnalysisLogger.class.st b/src/MuTalk-Tests/MTMockMTAnalysisLogger.class.st deleted file mode 100644 index 18ffd28b..00000000 --- a/src/MuTalk-Tests/MTMockMTAnalysisLogger.class.st +++ /dev/null @@ -1,57 +0,0 @@ -Class { - #name : 'MTMockMTAnalysisLogger', - #superclass : 'MTAnalysisLogger', - #instVars : [ - 'loggedStartAnalysis', - 'loggedStartBuildingMutations', - 'loggedEvaluationMutations' - ], - #category : 'MuTalk-Tests', - #package : 'MuTalk-Tests' -} - -{ #category : 'instance creation' } -MTMockMTAnalysisLogger class >> new [ - ^super new initialize. -] - -{ #category : 'initialization' } -MTMockMTAnalysisLogger >> initialize [ - loggedStartAnalysis := false. - loggedStartBuildingMutations := OrderedCollection new. - loggedEvaluationMutations := OrderedCollection new. -] - -{ #category : 'logging' } -MTMockMTAnalysisLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ - loggedStartAnalysis := true. -] - -{ #category : 'logging' } -MTMockMTAnalysisLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ - loggedStartBuildingMutations add:(Array with:aCompiledMethod with: aMutantOperator ). - - -] - -{ #category : 'logging' } -MTMockMTAnalysisLogger >> logStartEvaluating: aMethodMutation [ - loggedEvaluationMutations add: aMethodMutation. -] - -{ #category : 'testing' } -MTMockMTAnalysisLogger >> loggedStartAnalysis [ - ^loggedStartAnalysis -] - -{ #category : 'testing' } -MTMockMTAnalysisLogger >> loggedStartBuildingMutationsFor: aCompiledMethod using: aMutantOperator [ - ^loggedStartBuildingMutations anySatisfy:[:array | (array at:1 ) = aCompiledMethod and:[(array at:2) = aMutantOperator ]] - -] - -{ #category : 'testing' } -MTMockMTAnalysisLogger >> loggedStartMutantEvaluationForMutationOf: aCompiledMethod [ - ^ loggedEvaluationMutations - anySatisfy: [:aMutation | aMutation originalMethod = aCompiledMethod] -]