[EXPERIMENTAL] Syntactic and Semantic Mutations

BaselineOfRanger/BaselineOfRanger.class.st

@@ -1,16 +1,22 @@
 Class {
-	#name : #BaselineOfRanger,
-	#superclass : #BaselineOf,
-	#category : #BaselineOfRanger
+	#name : 'BaselineOfRanger',
+	#superclass : 'BaselineOf',
+	#category : 'BaselineOfRanger',
+	#package : 'BaselineOfRanger'
 }
 
-{ #category : #baselines }
+{ #category : 'baselines' }
 BaselineOfRanger >> baseline: spec [
 
 	<baseline>
 	spec for: #common do: [
+		spec
+			baseline: 'VMMaker'
+			with: [ spec repository: 'github://evref-inria/pharo-vm:ranger2' ].
 		spec
 			baseline: 'Minizinc'
 			with: [ spec repository: 'github://tesonep/pharo-minizinc:main' ].
-		spec package: 'Ranger' with: [ spec requires: #( 'Minizinc' ) ] ]
+		spec baseline: 'NeoJSON' with: [ spec repository: 'github://svenvc/NeoJSON/repository' ].
+		spec package: 'Ranger' with: [ spec requires: #( 'Minizinc' ) ].
+		spec package: 'Ranger-Exploring' with: [ spec requires: #( 'Ranger' ) ] ]
 ]

BaselineOfRanger/package.st

@@ -1 +1 @@
-Package { #name : #BaselineOfRanger }
+Package { #name : 'BaselineOfRanger' }

Ranger-Exploring/CompilerCoverageCollector.class.st

@@ -0,0 +1,152 @@
+Class {
+	#name : 'CompilerCoverageCollector',
+	#superclass : 'DTCoverageCollector',
+	#category : 'Ranger-Exploring-Collector',
+	#package : 'Ranger-Exploring',
+	#tag : 'Collector'
+}
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> backendClasses [
+
+	^ { CogAbstractInstruction }, CogAbstractInstruction withAllSubclasses
+]
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> compilerBackendCoverage: result [
+
+	^ self backendClasses inject: Dictionary new into: [ :dict :class |
+		dict at: (class name) put: (self coveredMethod: result from: class).
+		dict
+	]
+]
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> compilerCoverage: result [
+
+	| dict |
+	dict := Dictionary new.
+	dict at: 'Covered nodes' put: (result nodes size).
+	dict at: 'Percentage of covered nodes' put: (result nodes size * 100) / result collector nodes size.
+	dict at: 'Frontend' put: (self compilerFrontendCoverage: result).
+	dict at: 'Backend' put: (self compilerBackendCoverage: result).
+	dict at: 'Node paths' put: (self nodePathsFrom: result).
+
+	^ dict
+]
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> compilerFrontendCoverage: result [
+
+	^ self frontendClasses inject: Dictionary new into: [ :dict :class |
+		dict at: (class name) put: (self coveredMethod: result from: class).
+		dict
+	]
+]
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> compilerMethods [
+
+	^  (
+			Cogit methods,
+			SimpleStackBasedCogit methods, "Used in the rest of Concolic tests"
+			StackToRegisterMappingCogit methods "Used in RAStackToRegisterMappingCogitTest"
+		), "Frontend" (
+			(CogAbstractInstruction withAllSubclasses flatCollect: #methods) difference: (
+				CogOutOfLineLiteralsX64Compiler methods, CogInLineLiteralsARMCompiler methods,
+				CogOutOfLineLiteralsARMv8Compiler methods, CogX64Compiler methods,
+				CogMIPSELCompiler methods, CogICacheFlushingIA32Compiler methods,
+				CogInLineLiteralsX64Compiler methods, CogARMv8Compiler methods
+			)
+		) "Backend"
+]
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> coveredMethod: result from: aClass [
+
+	| totalCoveredMethods unCoveredMethods partiallyCoveredMethods unCoveredPercentage partiallyPercentage |
+
+	unCoveredMethods := result uncoveredMethods select: [ :m | m methodClass = aClass ].
+	partiallyCoveredMethods := result partiallyCoveredMethods select: [ :m | m methodClass = aClass ].
+
+	totalCoveredMethods := aClass methods difference: (unCoveredMethods , partiallyCoveredMethods).
+	unCoveredPercentage := ((unCoveredMethods size / aClass methods size) * 100) asFloat.
+	partiallyPercentage := ((partiallyCoveredMethods size / aClass methods size) * 100) asFloat.
+
+	^ (OrderedCollection newFromArray: {
+		'TotalCoveredPercentage' -> (100 - (unCoveredPercentage + partiallyPercentage)).
+		'UncoveredPercentage' -> unCoveredPercentage.
+		'PartiallyCoveredPercentage' -> partiallyPercentage.
+
+		'TotalCoveredMethods' -> (totalCoveredMethods collect: #name).
+		'UncoveredMethods' -> (unCoveredMethods collect: #name).
+		'PartiallyCoveredMethods' -> (partiallyCoveredMethods collect: #name).
+	}) asDictionary.
+]
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> frontendClasses [
+
+	^ { Cogit . SimpleStackBasedCogit . StackToRegisterMappingCogit }
+]
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> generateCompilerCoverage: result [
+
+	self generateCompilerCoverage: result at: 'CompilerCoverage.json'
+]
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> generateCompilerCoverage: result at: fileName [ 
+
+    | tempDict jsonString  writeStream |
+
+    tempDict := self compilerCoverage: result.
+
+    jsonString := NeoJSONWriter toStringPretty: tempDict.
+
+    writeStream := fileName asFileReference createFile writeStream.
+    writeStream nextPutAll: jsonString.
+    writeStream close
+]
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> generateCompilerCoverage: result withFails: fails at: fileName [
+
+	| tempDict jsonString writeStream |
+	tempDict := self compilerCoverage: result.
+
+	tempDict at: 'Fails' put: fails.
+
+	jsonString := NeoJSONWriter toStringPretty: tempDict.
+
+	writeStream := fileName asFileReference createFile writeStream.
+	writeStream nextPutAll: jsonString.
+	writeStream close
+]
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> measure: block [
+
+	^ CoverageCollector new methods: self compilerMethods; runOn: block
+]
+
+{ #category : 'as yet unclassified' }
+CompilerCoverageCollector class >> nodePathsFrom: result [
+
+	^ result nodes inject: Dictionary new into: [ :dict :node |
+		  | methodName path |
+		  methodName := node methodNode compiledMethod name.
+		  path := node path.
+		  dict
+			  at: methodName
+			  ifPresent: [ (dict at: methodName) add: path ]
+			  ifAbsentPut: [ OrderedCollection new add: path; yourself ].
+		  dict ]
+]
+
+{ #category : 'initialization' }
+CompilerCoverageCollector >> initialize [ 
+
+	self methods: self class compilerMethods
+]

Ranger-Exploring/CoverageCollectorBugTest.class.st

@@ -0,0 +1,52 @@
+Class {
+	#name : 'CoverageCollectorBugTest',
+	#superclass : 'TestCase',
+	#instVars : [
+		'collector'
+	],
+	#category : 'Ranger-Exploring-Collector',
+	#package : 'Ranger-Exploring',
+	#tag : 'Collector'
+}
+
+{ #category : 'as yet unclassified' }
+CoverageCollectorBugTest >> setUp [
+	super setUp.
+
+	collector := CoverageCollector new.
+]
+
+{ #category : 'as yet unclassified' }
+CoverageCollectorBugTest >> testCoverFirstBlockBehaviorOfAmethodWithMultipleReturnBlocks [
+
+	| target result |
+
+	target := TestClassToCover new.
+
+	collector methods: TestClassToCover methods.
+	result := collector runOn: [
+		target aMethodWithTwoReturnBlocks: true returnWithIter: 0
+	].
+
+	self assert: (result percentage) equals: 50.
+	self assert: (result partiallyCoveredMethods first) equals: TestClassToCover methods first.
+
+]
+
+{ #category : 'as yet unclassified' }
+CoverageCollectorBugTest >> testCoverSecondBlockBehaviorOfAmethodWithMultipleReturnBlocks [
+
+	| target result statements |
+
+	target := TestClassToCover new.
+
+	collector methods: TestClassToCover methods.
+	result := collector runOn: [
+		target aMethodWithTwoReturnBlocks: false returnWithIter: 5
+	].
+
+	statements := TestClassToCover methods first ast body allStatements.
+	self assert: (result percentage) equals: 50.
+	self assert: (result partiallyCoveredMethods first) equals: TestClassToCover methods first.
+
+]