From 453fe178820b1e8f2e58b06b1503a32cf36fd182 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Mon, 11 Mar 2024 12:32:22 +0100 Subject: [PATCH 01/13] refactor, add stream logger as superclass of file logger, and rename --- src/MuTalk-Model/MTAnalysis.class.st | 5 +- .../MTAnalysisFileLogger.class.st | 66 ------------------ src/MuTalk-Model/MTFileLogger.class.st | 29 ++++++++ .../MTMutantSelectionStrategy.class.st | 2 +- ...sLogger.class.st => MTNullLogger.class.st} | 10 +-- src/MuTalk-Model/MTStreamLogger.class.st | 69 +++++++++++++++++++ .../MTAnalysisFileLoggerTest.class.st | 2 +- 7 files changed, 108 insertions(+), 75 deletions(-) delete mode 100644 src/MuTalk-Model/MTAnalysisFileLogger.class.st create mode 100644 src/MuTalk-Model/MTFileLogger.class.st rename src/MuTalk-Model/{MTNullAnalysisLogger.class.st => MTNullLogger.class.st} (53%) create mode 100644 src/MuTalk-Model/MTStreamLogger.class.st diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index 1b80cc57..6f93fecc 100644 --- a/src/MuTalk-Model/MTAnalysis.class.st +++ b/src/MuTalk-Model/MTAnalysis.class.st @@ -27,7 +27,7 @@ MTAnalysis class >> defaultLogger [ self deprecated: 'This method will be removed in the next version of MuTalk. To create an instance of `MutationTestingAnalysis`, please refer to `MutationTestingAnalysisBuilder` instead.'. - ^ MTNullAnalysisLogger new + ^ MTNullLogger new ] { #category : 'defaults' } @@ -472,7 +472,7 @@ MTAnalysis >> defaultBudget [ { #category : 'defaults' } MTAnalysis >> defaultLogger [ - ^ MTNullAnalysisLogger new + ^ MTNullLogger new ] { #category : 'accessing - defaults' } @@ -547,6 +547,7 @@ MTAnalysis >> generateResults [ following: testSelectionStrategy andConsidering: self coverageAnalysisResult) valueStoppingOnError: stopOnErrorOrFail) ]. + logger logEnd. ^ mutantResults ] 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/MTFileLogger.class.st b/src/MuTalk-Model/MTFileLogger.class.st new file mode 100644 index 00000000..8a9b39bb --- /dev/null +++ b/src/MuTalk-Model/MTFileLogger.class.st @@ -0,0 +1,29 @@ +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 : '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..0bd11dfc 100644 --- a/src/MuTalk-Model/MTMutantSelectionStrategy.class.st +++ b/src/MuTalk-Model/MTMutantSelectionStrategy.class.st @@ -49,5 +49,5 @@ MTMutantSelectionStrategy >> mutationsFor: aMethod usingAll: aCollectionOfMutant { #category : 'logging' } MTMutantSelectionStrategy >> nullLogger [ - ^ MTNullAnalysisLogger new. + ^ MTNullLogger new. ] diff --git a/src/MuTalk-Model/MTNullAnalysisLogger.class.st b/src/MuTalk-Model/MTNullLogger.class.st similarity index 53% rename from src/MuTalk-Model/MTNullAnalysisLogger.class.st rename to src/MuTalk-Model/MTNullLogger.class.st index d78d2600..6fb9f508 100644 --- a/src/MuTalk-Model/MTNullAnalysisLogger.class.st +++ b/src/MuTalk-Model/MTNullLogger.class.st @@ -1,5 +1,5 @@ Class { - #name : 'MTNullAnalysisLogger', + #name : 'MTNullLogger', #superclass : 'MTAnalysisLogger', #classInstVars : [ 'instance' @@ -10,19 +10,19 @@ Class { } { #category : 'instance creation' } -MTNullAnalysisLogger class >> new [ +MTNullLogger class >> new [ instance ifNil:[instance := super new.]. ^instance. ] { #category : 'logging' } -MTNullAnalysisLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ +MTNullLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ ] { #category : 'logging' } -MTNullAnalysisLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ +MTNullLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ ] { #category : 'logging' } -MTNullAnalysisLogger >> logStartEvaluating: aMethodMutation [ +MTNullLogger >> logStartEvaluating: aMethodMutation [ ] diff --git a/src/MuTalk-Model/MTStreamLogger.class.st b/src/MuTalk-Model/MTStreamLogger.class.st new file mode 100644 index 00000000..515a8591 --- /dev/null +++ b/src/MuTalk-Model/MTStreamLogger.class.st @@ -0,0 +1,69 @@ +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 close +] + +{ #category : 'logging' } +MTStreamLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ + + stream + setToEnd; + nextPutAll: 'Generating mutations for '; + nextPutAll: (self methodNameOf: aCompiledMethod); + nextPutAll: ' with operator:'; + nextPutAll: aMutantOperator description; + cr +] + +{ #category : 'logging' } +MTStreamLogger >> logStartEvaluating: aMethodMutation [ + + stream + setToEnd; + nextPutAll: 'Evaluating mutant of method '; + nextPutAll: (self methodNameOf: aMethodMutation originalMethod); + nextPutAll: ' with source:'; + cr; + nextPutAll: aMethodMutation modifiedSource; + cr +] + +{ #category : 'private' } +MTStreamLogger >> methodNameOf: aCompiledMethod [ + + ^ aCompiledMethod methodClass name asString , '>>' + , aCompiledMethod selector printString +] diff --git a/src/MuTalk-Tests/MTAnalysisFileLoggerTest.class.st b/src/MuTalk-Tests/MTAnalysisFileLoggerTest.class.st index 5b0f447e..e4fa39dd 100644 --- a/src/MuTalk-Tests/MTAnalysisFileLoggerTest.class.st +++ b/src/MuTalk-Tests/MTAnalysisFileLoggerTest.class.st @@ -14,7 +14,7 @@ MTAnalysisFileLoggerTest >> testLogFileExists [ analysis := MTAnalysis new classesToMutate: { MTAuxiliarClassForMTAnalysis }; testClasses: { MTAuxiliarClassForMTAnalysisTest }; - logger: (MTAnalysisFileLogger toFileNamed: logFileName). + logger: (MTFileLogger toFileNamed: logFileName). analysis run. From 45d8beb5a4eac7d83bc0c1d26c26a8b922260ed5 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Mon, 11 Mar 2024 16:40:45 +0100 Subject: [PATCH 02/13] add transcript logger, accessors and fixes --- src/MuTalk-Model/MTAnalysisLogger.class.st | 6 ++++++ src/MuTalk-Model/MTFileLogger.class.st | 12 ++++++++++++ src/MuTalk-Model/MTNullLogger.class.st | 6 ++++++ src/MuTalk-Model/MTStreamLogger.class.st | 14 ++++++++++++-- src/MuTalk-Model/MTTranscriptLogger.class.st | 13 +++++++++++++ src/MuTalk-Tests/MTMockAnalysisLogger.class.st | 11 +++++++++++ 6 files changed, 60 insertions(+), 2 deletions(-) create mode 100644 src/MuTalk-Model/MTTranscriptLogger.class.st create mode 100644 src/MuTalk-Tests/MTMockAnalysisLogger.class.st diff --git a/src/MuTalk-Model/MTAnalysisLogger.class.st b/src/MuTalk-Model/MTAnalysisLogger.class.st index a814b5c2..3cf63b2e 100644 --- a/src/MuTalk-Model/MTAnalysisLogger.class.st +++ b/src/MuTalk-Model/MTAnalysisLogger.class.st @@ -11,6 +11,12 @@ MTAnalysisLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ self subclassResponsibility ] +{ #category : 'logging' } +MTAnalysisLogger >> logEnd [ + + ^ self subclassResponsibility +] + { #category : 'logging' } MTAnalysisLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ self subclassResponsibility diff --git a/src/MuTalk-Model/MTFileLogger.class.st b/src/MuTalk-Model/MTFileLogger.class.st index 8a9b39bb..46b17288 100644 --- a/src/MuTalk-Model/MTFileLogger.class.st +++ b/src/MuTalk-Model/MTFileLogger.class.st @@ -15,6 +15,18 @@ MTFileLogger class >> toFileNamed: aString [ ^ self basicNew initializeToFileNamed: aString ] +{ #category : 'accessing' } +MTFileLogger >> fileReference [ + + ^ fileReference +] + +{ #category : 'accessing' } +MTFileLogger >> fileReference: anObject [ + + fileReference := anObject +] + { #category : 'initialization' } MTFileLogger >> initializeStream [ diff --git a/src/MuTalk-Model/MTNullLogger.class.st b/src/MuTalk-Model/MTNullLogger.class.st index 6fb9f508..d8aea632 100644 --- a/src/MuTalk-Model/MTNullLogger.class.st +++ b/src/MuTalk-Model/MTNullLogger.class.st @@ -19,6 +19,12 @@ MTNullLogger class >> new [ MTNullLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ ] +{ #category : 'logging' } +MTNullLogger >> logEnd [ + + +] + { #category : 'logging' } MTNullLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ ] diff --git a/src/MuTalk-Model/MTStreamLogger.class.st b/src/MuTalk-Model/MTStreamLogger.class.st index 515a8591..ca9f18c8 100644 --- a/src/MuTalk-Model/MTStreamLogger.class.st +++ b/src/MuTalk-Model/MTStreamLogger.class.st @@ -40,7 +40,6 @@ MTStreamLogger >> logEnd [ MTStreamLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ stream - setToEnd; nextPutAll: 'Generating mutations for '; nextPutAll: (self methodNameOf: aCompiledMethod); nextPutAll: ' with operator:'; @@ -52,7 +51,6 @@ MTStreamLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantO MTStreamLogger >> logStartEvaluating: aMethodMutation [ stream - setToEnd; nextPutAll: 'Evaluating mutant of method '; nextPutAll: (self methodNameOf: aMethodMutation originalMethod); nextPutAll: ' with source:'; @@ -67,3 +65,15 @@ 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/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/MTMockAnalysisLogger.class.st b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st new file mode 100644 index 00000000..d2c27524 --- /dev/null +++ b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st @@ -0,0 +1,11 @@ +Class { + #name : 'MTMockAnalysisLogger', + #superclass : 'MTAnalysisLogger', + #instVars : [ + 'loggedStartAnalysis', + 'loggedStartBuildingMutations', + 'loggedEvaluationMutations' + ], + #category : 'MuTalk-Tests', + #package : 'MuTalk-Tests' +} From c83bd009e903cbc87a627ed4a38fa67f598ce206 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Mon, 11 Mar 2024 16:41:55 +0100 Subject: [PATCH 03/13] rename tests --- .../MTAnalysisLoggerTest.class.st | 2 +- ...est.class.st => MTFileLoggerTest.class.st} | 4 +- .../MTMockAnalysisLogger.class.st | 47 +++++++++++++++ .../MTMockMTAnalysisLogger.class.st | 57 ------------------- 4 files changed, 50 insertions(+), 60 deletions(-) rename src/MuTalk-Tests/{MTAnalysisFileLoggerTest.class.st => MTFileLoggerTest.class.st} (85%) delete mode 100644 src/MuTalk-Tests/MTMockMTAnalysisLogger.class.st 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 85% rename from src/MuTalk-Tests/MTAnalysisFileLoggerTest.class.st rename to src/MuTalk-Tests/MTFileLoggerTest.class.st index e4fa39dd..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'. diff --git a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st index d2c27524..c8075d7f 100644 --- a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st +++ b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st @@ -9,3 +9,50 @@ Class { #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 >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ + loggedStartBuildingMutations add:(Array with:aCompiledMethod with: aMutantOperator ). + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartEvaluating: aMethodMutation [ + loggedEvaluationMutations add: aMethodMutation. +] + +{ #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] -] From 09eb3691cf4504d9b1f418d1789bf02b310b8c49 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Wed, 13 Mar 2024 10:43:05 +0100 Subject: [PATCH 04/13] add test running log --- src/MuTalk-Model/MTAnalysis.class.st | 4 ++- src/MuTalk-Model/MTAnalysisLogger.class.st | 6 ++++ src/MuTalk-Model/MTNullLogger.class.st | 6 ++++ src/MuTalk-Model/MTStreamLogger.class.st | 9 +++++ src/MuTalk-Model/MTTestCaseReference.class.st | 33 +++++++++++++++++-- .../MTMockAnalysisLogger.class.st | 6 ++++ 6 files changed, 61 insertions(+), 3 deletions(-) diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index 6f93fecc..55005ec4 100644 --- a/src/MuTalk-Model/MTAnalysis.class.st +++ b/src/MuTalk-Model/MTAnalysis.class.st @@ -583,6 +583,8 @@ MTAnalysis >> logger [ { #category : 'accessing' } MTAnalysis >> logger: anObject [ + testCases do: [ :testCaseReference | + testCaseReference logger: anObject ]. logger := anObject ] @@ -699,7 +701,7 @@ MTAnalysis >> testCasesFrom: aClassCollection [ MTAnalysis >> testCasesReferencesFrom: testClass [ ^ testClass allTestSelectors collect: [ :each | - MTTestCaseReference for: each in: testClass ] + MTTestCaseReference for: each in: testClass logger: logger ] ] { #category : 'accessing' } diff --git a/src/MuTalk-Model/MTAnalysisLogger.class.st b/src/MuTalk-Model/MTAnalysisLogger.class.st index 3cf63b2e..6f35c09c 100644 --- a/src/MuTalk-Model/MTAnalysisLogger.class.st +++ b/src/MuTalk-Model/MTAnalysisLogger.class.st @@ -17,6 +17,12 @@ MTAnalysisLogger >> logEnd [ ^ self subclassResponsibility ] +{ #category : 'logging' } +MTAnalysisLogger >> logRunningTest: aTestCaseReference [ + + self subclassResponsibility +] + { #category : 'logging' } MTAnalysisLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ self subclassResponsibility diff --git a/src/MuTalk-Model/MTNullLogger.class.st b/src/MuTalk-Model/MTNullLogger.class.st index d8aea632..9b75a5a7 100644 --- a/src/MuTalk-Model/MTNullLogger.class.st +++ b/src/MuTalk-Model/MTNullLogger.class.st @@ -23,6 +23,12 @@ MTNullLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ MTNullLogger >> logEnd [ +] + +{ #category : 'logging' } +MTNullLogger >> logRunningTest: aTestCaseReference [ + + ] { #category : 'logging' } diff --git a/src/MuTalk-Model/MTStreamLogger.class.st b/src/MuTalk-Model/MTStreamLogger.class.st index ca9f18c8..c026a830 100644 --- a/src/MuTalk-Model/MTStreamLogger.class.st +++ b/src/MuTalk-Model/MTStreamLogger.class.st @@ -36,6 +36,15 @@ MTStreamLogger >> logEnd [ stream close ] +{ #category : 'logging' } +MTStreamLogger >> logRunningTest: aTestCaseReference [ + + stream + nextPutAll: 'Running test: '; + nextPutAll: aTestCaseReference testCase printString; + cr +] + { #category : 'logging' } MTStreamLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOperator [ diff --git a/src/MuTalk-Model/MTTestCaseReference.class.st b/src/MuTalk-Model/MTTestCaseReference.class.st index 7256b607..f4397c41 100644 --- a/src/MuTalk-Model/MTTestCaseReference.class.st +++ b/src/MuTalk-Model/MTTestCaseReference.class.st @@ -4,7 +4,8 @@ Class { #instVars : [ 'class', 'selector', - 'lastTimeToRun' + 'lastTimeToRun', + 'logger' ], #category : 'MuTalk-Model-Core', #package : 'MuTalk-Model', @@ -16,6 +17,12 @@ MTTestCaseReference class >> for: aSelector in: aClass [ ^self new initializeFor: aSelector in: aClass ] +{ #category : 'instance creation' } +MTTestCaseReference class >> for: aSelector in: aClass logger: aLogger [ + + ^ self new initializeFor: aSelector in: aClass logger: aLogger +] + { #category : 'instance creation' } MTTestCaseReference class >> forTestCase: aTestCase [ ^self for: aTestCase selector in: aTestCase class @@ -42,11 +49,31 @@ MTTestCaseReference >> initializeFor: aSelector in: aClass [ selector := aSelector. ] +{ #category : 'initialize' } +MTTestCaseReference >> initializeFor: aSelector in: aClass logger: aLogger [ + + class := aClass. + selector := aSelector. + logger := aLogger +] + { #category : 'accessing' } MTTestCaseReference >> lastTimeToRun [ ^ lastTimeToRun ] +{ #category : 'accessing' } +MTTestCaseReference >> logger [ + + ^ logger +] + +{ #category : 'accessing' } +MTTestCaseReference >> logger: anObject [ + + logger := anObject +] + { #category : 'accessing' } MTTestCaseReference >> method [ @@ -74,7 +101,9 @@ MTTestCaseReference >> run [ { #category : 'evaluating' } MTTestCaseReference >> run: aTestResult [ - ^self testCase run: aTestResult + + logger logRunningTest: self. + ^ self testCase run: aTestResult ] { #category : 'evaluating' } diff --git a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st index c8075d7f..2b23559c 100644 --- a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st +++ b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st @@ -26,6 +26,12 @@ MTMockAnalysisLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ MTMockAnalysisLogger >> logEnd [ +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logRunningTest: aTestCaseReference [ + + ] { #category : 'logging' } From 282adee5ee102dcdc668bdcca9a2698972d3a06a Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Wed, 13 Mar 2024 11:37:22 +0100 Subject: [PATCH 05/13] log for end of analysis & number of mutations generated --- src/MuTalk-Model/MTAnalysis.class.st | 3 ++- src/MuTalk-Model/MTAnalysisLogger.class.st | 12 ++++++++++ .../MTMutantSelectionStrategy.class.st | 21 ++++++++++------ src/MuTalk-Model/MTNullLogger.class.st | 12 ++++++++++ src/MuTalk-Model/MTStreamLogger.class.st | 24 ++++++++++++++++++- .../MTMockAnalysisLogger.class.st | 12 ++++++++++ 6 files changed, 75 insertions(+), 9 deletions(-) diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index 55005ec4..247fd933 100644 --- a/src/MuTalk-Model/MTAnalysis.class.st +++ b/src/MuTalk-Model/MTAnalysis.class.st @@ -527,7 +527,8 @@ MTAnalysis >> generateMutations [ ^ mutations ifNil: [ mutations := mutantSelectionStrategy mutationsFor: self - loggingIn: logger ] + loggingIn: logger. + logger logTotalNumberOfMutations: mutations size ] ] { #category : 'running' } diff --git a/src/MuTalk-Model/MTAnalysisLogger.class.st b/src/MuTalk-Model/MTAnalysisLogger.class.st index 6f35c09c..023ba1e5 100644 --- a/src/MuTalk-Model/MTAnalysisLogger.class.st +++ b/src/MuTalk-Model/MTAnalysisLogger.class.st @@ -17,6 +17,12 @@ MTAnalysisLogger >> logEnd [ ^ self subclassResponsibility ] +{ #category : 'logging' } +MTAnalysisLogger >> logNumberOfGeneratedMutations: aNumber [ + + ^ self subclassResponsibility +] + { #category : 'logging' } MTAnalysisLogger >> logRunningTest: aTestCaseReference [ @@ -32,3 +38,9 @@ MTAnalysisLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutan MTAnalysisLogger >> logStartEvaluating: aMethodMutation [ self subclassResponsibility ] + +{ #category : 'logging' } +MTAnalysisLogger >> logTotalNumberOfMutations: aNumber [ + + ^ self subclassResponsibility +] diff --git a/src/MuTalk-Model/MTMutantSelectionStrategy.class.st b/src/MuTalk-Model/MTMutantSelectionStrategy.class.st index 0bd11dfc..992b5c15 100644 --- a/src/MuTalk-Model/MTMutantSelectionStrategy.class.st +++ b/src/MuTalk-Model/MTMutantSelectionStrategy.class.st @@ -34,16 +34,23 @@ 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' } diff --git a/src/MuTalk-Model/MTNullLogger.class.st b/src/MuTalk-Model/MTNullLogger.class.st index 9b75a5a7..2e490afd 100644 --- a/src/MuTalk-Model/MTNullLogger.class.st +++ b/src/MuTalk-Model/MTNullLogger.class.st @@ -23,6 +23,12 @@ MTNullLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ MTNullLogger >> logEnd [ +] + +{ #category : 'logging' } +MTNullLogger >> logNumberOfGeneratedMutations: aNumber [ + + ] { #category : 'logging' } @@ -38,3 +44,9 @@ MTNullLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantOpe { #category : 'logging' } MTNullLogger >> logStartEvaluating: aMethodMutation [ ] + +{ #category : 'logging' } +MTNullLogger >> logTotalNumberOfMutations: aNumber [ + + +] diff --git a/src/MuTalk-Model/MTStreamLogger.class.st b/src/MuTalk-Model/MTStreamLogger.class.st index c026a830..40dd57f1 100644 --- a/src/MuTalk-Model/MTStreamLogger.class.st +++ b/src/MuTalk-Model/MTStreamLogger.class.st @@ -33,7 +33,20 @@ MTStreamLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ { #category : 'logging' } MTStreamLogger >> logEnd [ - stream close + 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' } @@ -68,6 +81,15 @@ MTStreamLogger >> logStartEvaluating: aMethodMutation [ cr ] +{ #category : 'logging' } +MTStreamLogger >> logTotalNumberOfMutations: aNumber [ + + stream + nextPutAll: aNumber asString; + nextPutAll: ' total mutations generated'; + cr +] + { #category : 'private' } MTStreamLogger >> methodNameOf: aCompiledMethod [ diff --git a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st index 2b23559c..bd36702f 100644 --- a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st +++ b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st @@ -26,6 +26,12 @@ MTMockAnalysisLogger >> logAnalysisStartFor: aMutationTestingAnalysis [ MTMockAnalysisLogger >> logEnd [ +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logNumberOfGeneratedMutations: aNumber [ + + ] { #category : 'logging' } @@ -46,6 +52,12 @@ MTMockAnalysisLogger >> logStartEvaluating: aMethodMutation [ loggedEvaluationMutations add: aMethodMutation. ] +{ #category : 'logging' } +MTMockAnalysisLogger >> logTotalNumberOfMutations: aNumber [ + + +] + { #category : 'testing' } MTMockAnalysisLogger >> loggedStartAnalysis [ ^loggedStartAnalysis From 5e36558a9e825e9239c31ee2c01a53e3d7e394b5 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Wed, 13 Mar 2024 12:06:22 +0100 Subject: [PATCH 06/13] add log at start of each phase of analysis --- src/MuTalk-Model/MTAnalysis.class.st | 14 +++++++---- src/MuTalk-Model/MTAnalysisLogger.class.st | 18 ++++++++++++++ src/MuTalk-Model/MTNullLogger.class.st | 18 ++++++++++++++ src/MuTalk-Model/MTStreamLogger.class.st | 24 +++++++++++++++++++ .../MTMockAnalysisLogger.class.st | 18 ++++++++++++++ 5 files changed, 87 insertions(+), 5 deletions(-) diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index 247fd933..f2676300 100644 --- a/src/MuTalk-Model/MTAnalysis.class.st +++ b/src/MuTalk-Model/MTAnalysis.class.st @@ -514,16 +514,19 @@ MTAnalysis >> generalResult [ { #category : 'running' } MTAnalysis >> generateCoverageAnalysis [ - coverageAnalysisResult := (MTCoverageAnalysis - for: self modelClasses - running: testCases) - run; - result + coverageAnalysisResult := MTCoverageAnalysis + for: self modelClasses + running: testCases. + logger logStartCoverageAnalysis. + coverageAnalysisResult + run; + result ] { #category : 'running' } MTAnalysis >> generateMutations [ + logger logStartMutationGeneration. ^ mutations ifNil: [ mutations := mutantSelectionStrategy mutationsFor: self @@ -537,6 +540,7 @@ MTAnalysis >> generateResults [ | tests | mutantResults := OrderedCollection new. tests := testFilter filterTests: testCases. + logger logStartMutationEvaluation. mutations do: [ :aMutation | (budget exceedsBudgetOn: mutantResults fromTotalMutations: mutations) diff --git a/src/MuTalk-Model/MTAnalysisLogger.class.st b/src/MuTalk-Model/MTAnalysisLogger.class.st index 023ba1e5..02a5b0c5 100644 --- a/src/MuTalk-Model/MTAnalysisLogger.class.st +++ b/src/MuTalk-Model/MTAnalysisLogger.class.st @@ -34,11 +34,29 @@ MTAnalysisLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutan 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: aNumber [ diff --git a/src/MuTalk-Model/MTNullLogger.class.st b/src/MuTalk-Model/MTNullLogger.class.st index 2e490afd..6defbebd 100644 --- a/src/MuTalk-Model/MTNullLogger.class.st +++ b/src/MuTalk-Model/MTNullLogger.class.st @@ -41,10 +41,28 @@ MTNullLogger >> logRunningTest: aTestCaseReference [ 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: aNumber [ diff --git a/src/MuTalk-Model/MTStreamLogger.class.st b/src/MuTalk-Model/MTStreamLogger.class.st index 40dd57f1..fba3832b 100644 --- a/src/MuTalk-Model/MTStreamLogger.class.st +++ b/src/MuTalk-Model/MTStreamLogger.class.st @@ -69,6 +69,14 @@ MTStreamLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aMutantO cr ] +{ #category : 'logging' } +MTStreamLogger >> logStartCoverageAnalysis [ + + stream + nextPutAll: 'Starting coverage analysis'; + cr +] + { #category : 'logging' } MTStreamLogger >> logStartEvaluating: aMethodMutation [ @@ -81,6 +89,22 @@ MTStreamLogger >> logStartEvaluating: aMethodMutation [ 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: aNumber [ diff --git a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st index bd36702f..59e73c93 100644 --- a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st +++ b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st @@ -45,6 +45,12 @@ MTMockAnalysisLogger >> logStartBuildingMutantionsFor: aCompiledMethod using: aM loggedStartBuildingMutations add:(Array with:aCompiledMethod with: aMutantOperator ). +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartCoverageAnalysis [ + + ] { #category : 'logging' } @@ -52,6 +58,18 @@ MTMockAnalysisLogger >> logStartEvaluating: aMethodMutation [ loggedEvaluationMutations add: aMethodMutation. ] +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartMutationEvaluation [ + + +] + +{ #category : 'logging' } +MTMockAnalysisLogger >> logStartMutationGeneration [ + + +] + { #category : 'logging' } MTMockAnalysisLogger >> logTotalNumberOfMutations: aNumber [ From 0e6bcaa5c88f7aafe58f2d72694bee939b707009 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Wed, 13 Mar 2024 14:39:47 +0100 Subject: [PATCH 07/13] fix --- src/MuTalk-Model/MTAnalysis.class.st | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index f2676300..f40efb29 100644 --- a/src/MuTalk-Model/MTAnalysis.class.st +++ b/src/MuTalk-Model/MTAnalysis.class.st @@ -531,7 +531,8 @@ MTAnalysis >> generateMutations [ mutations := mutantSelectionStrategy mutationsFor: self loggingIn: logger. - logger logTotalNumberOfMutations: mutations size ] + logger logTotalNumberOfMutations: mutations size. + mutations ] ] { #category : 'running' } From df3cd22e04935d82ba9e7fdef36cf07235b56792 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Wed, 13 Mar 2024 14:44:41 +0100 Subject: [PATCH 08/13] more fix --- src/MuTalk-Model/MTAnalysis.class.st | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index f40efb29..7b05f0c0 100644 --- a/src/MuTalk-Model/MTAnalysis.class.st +++ b/src/MuTalk-Model/MTAnalysis.class.st @@ -514,13 +514,12 @@ MTAnalysis >> generalResult [ { #category : 'running' } MTAnalysis >> generateCoverageAnalysis [ - coverageAnalysisResult := MTCoverageAnalysis - for: self modelClasses - running: testCases. logger logStartCoverageAnalysis. - coverageAnalysisResult - run; - result + coverageAnalysisResult := (MTCoverageAnalysis + for: self modelClasses + running: testCases) + run; + result ] { #category : 'running' } From bf47f0417e583ec1a7dd84ad67921593d6588926 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Wed, 13 Mar 2024 15:03:58 +0100 Subject: [PATCH 09/13] refactor logTotalNumberOfMutations to work with Time budget tests & add null logger as default logger for test case reference --- src/MuTalk-Model/MTAnalysis.class.st | 2 +- src/MuTalk-Model/MTAnalysisLogger.class.st | 2 +- src/MuTalk-Model/MTNullLogger.class.st | 2 +- src/MuTalk-Model/MTStreamLogger.class.st | 4 ++-- src/MuTalk-Model/MTTestCaseReference.class.st | 8 ++++++++ src/MuTalk-Tests/MTMockAnalysisLogger.class.st | 2 +- 6 files changed, 14 insertions(+), 6 deletions(-) diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index 7b05f0c0..dab8fac2 100644 --- a/src/MuTalk-Model/MTAnalysis.class.st +++ b/src/MuTalk-Model/MTAnalysis.class.st @@ -530,7 +530,7 @@ MTAnalysis >> generateMutations [ mutations := mutantSelectionStrategy mutationsFor: self loggingIn: logger. - logger logTotalNumberOfMutations: mutations size. + logger logTotalNumberOfMutations: mutations. mutations ] ] diff --git a/src/MuTalk-Model/MTAnalysisLogger.class.st b/src/MuTalk-Model/MTAnalysisLogger.class.st index 02a5b0c5..6eab09e8 100644 --- a/src/MuTalk-Model/MTAnalysisLogger.class.st +++ b/src/MuTalk-Model/MTAnalysisLogger.class.st @@ -58,7 +58,7 @@ MTAnalysisLogger >> logStartMutationGeneration [ ] { #category : 'logging' } -MTAnalysisLogger >> logTotalNumberOfMutations: aNumber [ +MTAnalysisLogger >> logTotalNumberOfMutations: mutations [ ^ self subclassResponsibility ] diff --git a/src/MuTalk-Model/MTNullLogger.class.st b/src/MuTalk-Model/MTNullLogger.class.st index 6defbebd..0ee290de 100644 --- a/src/MuTalk-Model/MTNullLogger.class.st +++ b/src/MuTalk-Model/MTNullLogger.class.st @@ -64,7 +64,7 @@ MTNullLogger >> logStartMutationGeneration [ ] { #category : 'logging' } -MTNullLogger >> logTotalNumberOfMutations: aNumber [ +MTNullLogger >> logTotalNumberOfMutations: mutations [ ] diff --git a/src/MuTalk-Model/MTStreamLogger.class.st b/src/MuTalk-Model/MTStreamLogger.class.st index fba3832b..aaa81c11 100644 --- a/src/MuTalk-Model/MTStreamLogger.class.st +++ b/src/MuTalk-Model/MTStreamLogger.class.st @@ -106,10 +106,10 @@ MTStreamLogger >> logStartMutationGeneration [ ] { #category : 'logging' } -MTStreamLogger >> logTotalNumberOfMutations: aNumber [ +MTStreamLogger >> logTotalNumberOfMutations: mutations [ stream - nextPutAll: aNumber asString; + nextPutAll: mutations size asString; nextPutAll: ' total mutations generated'; cr ] diff --git a/src/MuTalk-Model/MTTestCaseReference.class.st b/src/MuTalk-Model/MTTestCaseReference.class.st index f4397c41..a0fe21c9 100644 --- a/src/MuTalk-Model/MTTestCaseReference.class.st +++ b/src/MuTalk-Model/MTTestCaseReference.class.st @@ -37,6 +37,12 @@ MTTestCaseReference >> = anObject [ ^ self selector = anObject selector ] +{ #category : 'defaults' } +MTTestCaseReference >> defaultLogger [ + + ^ MTNullLogger new +] + { #category : 'comparing' } MTTestCaseReference >> hash [ @@ -45,8 +51,10 @@ MTTestCaseReference >> hash [ { #category : 'initialize' } MTTestCaseReference >> initializeFor: aSelector in: aClass [ + class := aClass. selector := aSelector. + logger := self defaultLogger ] { #category : 'initialize' } diff --git a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st index 59e73c93..541c1707 100644 --- a/src/MuTalk-Tests/MTMockAnalysisLogger.class.st +++ b/src/MuTalk-Tests/MTMockAnalysisLogger.class.st @@ -71,7 +71,7 @@ MTMockAnalysisLogger >> logStartMutationGeneration [ ] { #category : 'logging' } -MTMockAnalysisLogger >> logTotalNumberOfMutations: aNumber [ +MTMockAnalysisLogger >> logTotalNumberOfMutations: mutations [ ] From d8a6d0205aaa5ad90e00758c318f527f86eb7f84 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Thu, 14 Mar 2024 15:34:56 +0100 Subject: [PATCH 10/13] commit before merge --- src/MuTalk-Model/MTAnalysis.class.st | 13 +++++-------- src/MuTalk-Model/MTTestCaseReference.class.st | 4 +--- 2 files changed, 6 insertions(+), 11 deletions(-) diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index dab8fac2..4222e0c3 100644 --- a/src/MuTalk-Model/MTAnalysis.class.st +++ b/src/MuTalk-Model/MTAnalysis.class.st @@ -27,7 +27,7 @@ MTAnalysis class >> defaultLogger [ self deprecated: 'This method will be removed in the next version of MuTalk. To create an instance of `MutationTestingAnalysis`, please refer to `MutationTestingAnalysisBuilder` instead.'. - ^ MTNullLogger new + ^ MTAnalysisNullLogger new ] { #category : 'defaults' } @@ -469,7 +469,7 @@ MTAnalysis >> defaultBudget [ ^ MTFreeBudget new ] -{ #category : 'defaults' } +{ #category : 'accessing - defaults' } MTAnalysis >> defaultLogger [ ^ MTNullLogger new @@ -537,10 +537,7 @@ MTAnalysis >> generateMutations [ { #category : 'running' } MTAnalysis >> generateResults [ - | tests | mutantResults := OrderedCollection new. - tests := testFilter filterTests: testCases. - logger logStartMutationEvaluation. mutations do: [ :aMutation | (budget exceedsBudgetOn: mutantResults fromTotalMutations: mutations) @@ -548,7 +545,7 @@ MTAnalysis >> generateResults [ logger logStartEvaluating: aMutation. mutantResults add: ((MTMutantEvaluation for: aMutation - using: tests + using: testCases following: testSelectionStrategy andConsidering: self coverageAnalysisResult) valueStoppingOnError: stopOnErrorOrFail) ]. @@ -705,8 +702,8 @@ MTAnalysis >> testCasesFrom: aClassCollection [ { #category : 'tests' } MTAnalysis >> testCasesReferencesFrom: testClass [ - ^ testClass allTestSelectors collect: [ :each | - MTTestCaseReference for: each in: testClass logger: logger ] + ^ testClass buildSuite tests collect: [ :each | + MTTestCaseReference for: each ] ] { #category : 'accessing' } diff --git a/src/MuTalk-Model/MTTestCaseReference.class.st b/src/MuTalk-Model/MTTestCaseReference.class.st index a0fe21c9..67537c65 100644 --- a/src/MuTalk-Model/MTTestCaseReference.class.st +++ b/src/MuTalk-Model/MTTestCaseReference.class.st @@ -2,8 +2,7 @@ Class { #name : 'MTTestCaseReference', #superclass : 'Object', #instVars : [ - 'class', - 'selector', + 'testCase', 'lastTimeToRun', 'logger' ], @@ -110,7 +109,6 @@ MTTestCaseReference >> run [ { #category : 'evaluating' } MTTestCaseReference >> run: aTestResult [ - logger logRunningTest: self. ^ self testCase run: aTestResult ] From 71f340cdce8002d327cc3043e558bd396890af39 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Thu, 14 Mar 2024 15:37:59 +0100 Subject: [PATCH 11/13] another commit before merge --- src/MuTalk-Model/MTAnalysis.class.st | 5 ++--- src/MuTalk-Model/MTTestCaseReference.class.st | 13 ++----------- 2 files changed, 4 insertions(+), 14 deletions(-) diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index 4222e0c3..617f1526 100644 --- a/src/MuTalk-Model/MTAnalysis.class.st +++ b/src/MuTalk-Model/MTAnalysis.class.st @@ -27,7 +27,7 @@ MTAnalysis class >> defaultLogger [ self deprecated: 'This method will be removed in the next version of MuTalk. To create an instance of `MutationTestingAnalysis`, please refer to `MutationTestingAnalysisBuilder` instead.'. - ^ MTAnalysisNullLogger new + ^ MTNullAnalysisLogger new ] { #category : 'defaults' } @@ -472,7 +472,7 @@ MTAnalysis >> defaultBudget [ { #category : 'accessing - defaults' } MTAnalysis >> defaultLogger [ - ^ MTNullLogger new + ^ MTNullAnalysisLogger new ] { #category : 'accessing - defaults' } @@ -549,7 +549,6 @@ MTAnalysis >> generateResults [ following: testSelectionStrategy andConsidering: self coverageAnalysisResult) valueStoppingOnError: stopOnErrorOrFail) ]. - logger logEnd. ^ mutantResults ] diff --git a/src/MuTalk-Model/MTTestCaseReference.class.st b/src/MuTalk-Model/MTTestCaseReference.class.st index 67537c65..0e5fb0c5 100644 --- a/src/MuTalk-Model/MTTestCaseReference.class.st +++ b/src/MuTalk-Model/MTTestCaseReference.class.st @@ -3,8 +3,7 @@ Class { #superclass : 'Object', #instVars : [ 'testCase', - 'lastTimeToRun', - 'logger' + 'lastTimeToRun' ], #category : 'MuTalk-Model-Core', #package : 'MuTalk-Model', @@ -48,14 +47,6 @@ MTTestCaseReference >> hash [ ^ selector hash + class hash ] -{ #category : 'initialize' } -MTTestCaseReference >> initializeFor: aSelector in: aClass [ - - class := aClass. - selector := aSelector. - logger := self defaultLogger -] - { #category : 'initialize' } MTTestCaseReference >> initializeFor: aSelector in: aClass logger: aLogger [ @@ -109,7 +100,7 @@ MTTestCaseReference >> run [ { #category : 'evaluating' } MTTestCaseReference >> run: aTestResult [ - ^ self testCase run: aTestResult + ^ testCase run: aTestResult ] { #category : 'evaluating' } From 273609115d354f6ee50db523524f75138eaaa833 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Thu, 14 Mar 2024 15:39:00 +0100 Subject: [PATCH 12/13] another one --- src/MuTalk-Model/MTTestCaseReference.class.st | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/MuTalk-Model/MTTestCaseReference.class.st b/src/MuTalk-Model/MTTestCaseReference.class.st index 0e5fb0c5..bcf27254 100644 --- a/src/MuTalk-Model/MTTestCaseReference.class.st +++ b/src/MuTalk-Model/MTTestCaseReference.class.st @@ -3,7 +3,8 @@ Class { #superclass : 'Object', #instVars : [ 'testCase', - 'lastTimeToRun' + 'lastTimeToRun', + 'lastResult' ], #category : 'MuTalk-Model-Core', #package : 'MuTalk-Model', From ee48278a22e10380c6d598bd99e94a35f8630d45 Mon Sep 17 00:00:00 2001 From: Durieux Pol Date: Thu, 14 Mar 2024 15:57:01 +0100 Subject: [PATCH 13/13] revert and fix after merge --- src/MuTalk-Model/MTAnalysis.class.st | 6 ++++-- src/MuTalk-Model/MTTestCaseReference.class.st | 16 +++++++++------- 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/src/MuTalk-Model/MTAnalysis.class.st b/src/MuTalk-Model/MTAnalysis.class.st index 3c220cfb..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' } @@ -129,6 +129,7 @@ MTAnalysis >> generateMutations [ MTAnalysis >> generateResults [ mutantResults := OrderedCollection new. + logger logStartMutationEvaluation. mutations do: [ :aMutation | (budget exceedsBudgetOn: mutantResults fromTotalMutations: mutations) @@ -140,6 +141,7 @@ MTAnalysis >> generateResults [ following: testSelectionStrategy andConsidering: self coverageAnalysisResult) valueStoppingOnError: stopOnErrorOrFail) ]. + logger logEnd. ^ mutantResults ] @@ -302,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/MTTestCaseReference.class.st b/src/MuTalk-Model/MTTestCaseReference.class.st index a90dbf01..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', @@ -18,9 +19,9 @@ MTTestCaseReference class >> for: aTestCase [ ] { #category : 'instance creation' } -MTTestCaseReference class >> for: aSelector in: aClass logger: aLogger [ +MTTestCaseReference class >> for: aTestCase logger: aLogger [ - ^ self new initializeFor: aSelector in: aClass logger: aLogger + ^ self new initializeFor: aTestCase logger: aLogger ] { #category : 'comparing' } @@ -47,14 +48,14 @@ MTTestCaseReference >> hash [ { #category : 'initialize' } MTTestCaseReference >> initializeFor: aTestCase [ - testCase := aTestCase + testCase := aTestCase. + logger := self defaultLogger ] { #category : 'initialize' } -MTTestCaseReference >> initializeFor: aSelector in: aClass logger: aLogger [ +MTTestCaseReference >> initializeFor: aTestCase logger: aLogger [ - class := aClass. - selector := aSelector. + testCase := aTestCase. logger := aLogger ] @@ -116,6 +117,7 @@ MTTestCaseReference >> run [ { #category : 'evaluating' } MTTestCaseReference >> run: aTestResult [ + logger logRunningTest: self. ^ testCase run: aTestResult ]