diff --git a/src/Manifest-Tests/BuilderManifestTest.class.st b/src/Manifest-Tests/BuilderManifestTest.class.st
index 2962ebffa69..2a915b6daf0 100644
--- a/src/Manifest-Tests/BuilderManifestTest.class.st
+++ b/src/Manifest-Tests/BuilderManifestTest.class.st
@@ -40,54 +40,49 @@ BuilderManifestTest >> tearDown [
 
 { #category : #tests }
 BuilderManifestTest >> testAddAllFalsePositive [
-	
-	| manifestBuilder array|
-	
-	array := {MFClassA. MFClassB  }.
-	manifestBuilder := TheManifestBuilder of: MFClassA .
-	manifestBuilder  installFalsePositiveOf: 'test' version: 0.
-	
-	self deny: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [:each| each = MFClassA]).
-	self deny: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [:each| each = MFClassB]).
-	
-	manifestBuilder addAllFalsePositive: array of: 'test' version: 0. 
-	
-	self assert: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [:each| each = MFClassA]).
-	self assert: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [:each| each = MFClassB]).
-	
-	manifestBuilder addAllFalsePositive: array of: 'test' version: 0. 
-	
-	self assert:  (manifestBuilder manifest ruletestV0FalsePositive size = 2).
-	
-	manifestBuilder removeAllFalsePositive: array of: 'test' version: 0. 
-	
-	self deny: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [:each| each = MFClassA]).
-	self deny: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [:each| each = MFClassB]).
-	
+	| manifestBuilder array |
+	array := {MFClassA . MFClassB}.
+	manifestBuilder := TheManifestBuilder of: MFClassA.
+	manifestBuilder installFalsePositiveOf: 'test' version: 0.
+
+	self deny: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassA ]).
+	self deny: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassB ]).
+
+	manifestBuilder addAllFalsePositive: array of: 'test' version: 0.
+
+	self assert: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassA ]).
+	self assert: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassB ]).
+
+	manifestBuilder addAllFalsePositive: array of: 'test' version: 0.
+
+	self assert: manifestBuilder manifest ruletestV0FalsePositive size equals: 2.
+
+	manifestBuilder removeAllFalsePositive: array of: 'test' version: 0.
+
+	self deny: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassA ]).
+	self deny: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassB ])
+
 	"manifestBuilder manifest class removeSelector: (manifestBuilder selectorFalsePositiveOf: 'test' version: 0)"
 ]
 
 { #category : #tests }
 BuilderManifestTest >> testAddAllToDo [
-	
-	| manifestBuilder array|
-	
-	array := {MFClassA. MFClassB  }.
-	manifestBuilder := TheManifestBuilder of: MFClassA .
-	manifestBuilder  installToDoOf: 'test' version: 0.
-	
-	self deny: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [:each| each = MFClassA]).
-	self deny: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [:each| each = MFClassB]).
-	
-	manifestBuilder addAllToDo: array of: 'test' version: 0. 
-	
-	self assert: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [:each| each = MFClassA]).
-	self assert: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [:each| each = MFClassB]).
-	
-	manifestBuilder addAllToDo: array of: 'test' version: 0. 
-	
-	self assert:  (manifestBuilder manifest ruletestV0TODO size = 2).
+	| manifestBuilder array |
+	array := {MFClassA . MFClassB}.
+	manifestBuilder := TheManifestBuilder of: MFClassA.
+	manifestBuilder installToDoOf: 'test' version: 0.
+
+	self deny: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassA ]).
+	self deny: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassB ]).
+
+	manifestBuilder addAllToDo: array of: 'test' version: 0.
+
+	self assert: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassA ]).
+	self assert: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassB ]).
+
+	manifestBuilder addAllToDo: array of: 'test' version: 0.
 
+	self assert: manifestBuilder manifest ruletestV0TODO size equals: 2
 ]
 
 { #category : #tests }
@@ -183,37 +178,33 @@ BuilderManifestTest >> testAddToDo [
 { #category : #tests }
 BuilderManifestTest >> testCleanUpFP [
 	| manifestBuilder |
-	
-	manifestBuilder := TheManifestBuilder of: MFClassA. .
-	MFClassA compile:  'foo'.
+	manifestBuilder := TheManifestBuilder of: MFClassA.
+	MFClassA compile: 'foo'.
 	manifestBuilder installFalsePositiveOf: 'test' version: 0.
-	manifestBuilder addFalsePositive: (MFClassA>>#foo) of:  'test' version: 0. 
-	
-	self assert: (manifestBuilder containsFalsePositive: (MFClassA>>#foo) onRule: 'test' version: 0).
-	
+	manifestBuilder addFalsePositive: MFClassA >> #foo of: 'test' version: 0.
+
+	self assert: (manifestBuilder containsFalsePositive: MFClassA >> #foo onRule: 'test' version: 0).
+
 	MFClassA removeSelector: #foo.
 	manifestBuilder cleanUp.
-	
-	self assert: ((manifestBuilder falsePositiveOf: 'test' version: 0 ) size = 0) .
 
+	self assert: (manifestBuilder falsePositiveOf: 'test' version: 0) size equals: 0
 ]
 
 { #category : #tests }
 BuilderManifestTest >> testCleanUpTD [
 	| manifestBuilder |
-	
-	manifestBuilder := TheManifestBuilder of: MFClassA. .
-	MFClassA compile:  'foo'.
+	manifestBuilder := TheManifestBuilder of: MFClassA.
+	MFClassA compile: 'foo'.
 	manifestBuilder installToDoOf: 'test' version: 0.
-	manifestBuilder addToDo: (MFClassA>>#foo) of: 'test' version: 0. 
-	
-	self assert: (manifestBuilder containsToDo: (MFClassA>>#foo) onRule: 'test' version: 0).
-	
+	manifestBuilder addToDo: MFClassA >> #foo of: 'test' version: 0.
+
+	self assert: (manifestBuilder containsToDo: MFClassA >> #foo onRule: 'test' version: 0).
+
 	MFClassA removeSelector: #foo.
 	manifestBuilder cleanUp.
-	
-	self assert: ((manifestBuilder toDoOf: 'test' version: 0 ) size = 0) .
 
+	self assert: (manifestBuilder toDoOf: 'test' version: 0) size equals: 0
 ]
 
 { #category : #tests }
@@ -387,42 +378,34 @@ BuilderManifestTest >> testIsFalsePositive [
 
 { #category : #tests }
 BuilderManifestTest >> testResetFalsePositive [
-	
-	| manifestBuilder array|
-	
-	array := {MFClassA. MFClassB  }.
-	manifestBuilder := TheManifestBuilder of: MFClassA .
-	manifestBuilder  installFalsePositiveOf: 'test' version: 0.
-	
-	manifestBuilder addAllFalsePositive: array of: 'test' version: 0. 
-	
-	self assert: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [:each| each = MFClassA]).
-	self assert: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [:each| each = MFClassB]).
-	
-	manifestBuilder resetFalsePositiveOf: 'test' version: 0. 
-	
-	self assert:  (manifestBuilder manifest ruletestV0FalsePositive size = 0).
-	
-	
+	| manifestBuilder array |
+	array := {MFClassA . MFClassB}.
+	manifestBuilder := TheManifestBuilder of: MFClassA.
+	manifestBuilder installFalsePositiveOf: 'test' version: 0.
+
+	manifestBuilder addAllFalsePositive: array of: 'test' version: 0.
+
+	self assert: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassA ]).
+	self assert: ((manifestBuilder falsePositiveOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassB ]).
+
+	manifestBuilder resetFalsePositiveOf: 'test' version: 0.
+
+	self assert: manifestBuilder manifest ruletestV0FalsePositive size equals: 0
 ]
 
 { #category : #tests }
 BuilderManifestTest >> testResetToDo [
-	
-	| manifestBuilder array|
-	
-	array := {MFClassA. MFClassB  }.
-	manifestBuilder := TheManifestBuilder of: MFClassA .
-	manifestBuilder  installToDoOf: 'test' version: 0.
-	
-	manifestBuilder addAllToDo: array of: 'test' version: 0. 
-	
-	self assert: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [:each| each = MFClassA]).
-	self assert: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [:each| each = MFClassB]).
-	
-	manifestBuilder resetToDoOf: 'test' version: 0. 
-	
-	self assert:  (manifestBuilder manifest ruletestV0TODO size = 0).
-	
-	
+	| manifestBuilder array |
+	array := {MFClassA . MFClassB}.
+	manifestBuilder := TheManifestBuilder of: MFClassA.
+	manifestBuilder installToDoOf: 'test' version: 0.
+
+	manifestBuilder addAllToDo: array of: 'test' version: 0.
+
+	self assert: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassA ]).
+	self assert: ((manifestBuilder toDoOf: 'test' version: 0) anySatisfy: [ :each | each = MFClassB ]).
+
+	manifestBuilder resetToDoOf: 'test' version: 0.
+
+	self assert: manifestBuilder manifest ruletestV0TODO size equals: 0
 ]
diff --git a/src/Manifest-Tests/SmalllintManifestCheckerTest.class.st b/src/Manifest-Tests/SmalllintManifestCheckerTest.class.st
index 8fa9e9be65b..795c1fe6c38 100644
--- a/src/Manifest-Tests/SmalllintManifestCheckerTest.class.st
+++ b/src/Manifest-Tests/SmalllintManifestCheckerTest.class.st
@@ -54,22 +54,18 @@ SmalllintManifestCheckerTest >> tearDown [
 
 { #category : #tests }
 SmalllintManifestCheckerTest >> testCriticsOf [
-
 	| rule critiques |
 	rule := ReRuleManager visibleRuleClasses collect: #new.
-	checker 
+	checker
 		rule: rule;
 		environment: self package asEnvironment;
-		run. 
-	
+		run.
+
 	critiques := checker criticsOf: GRTemporaryNeitherReadNorWrittenRule new.
-	
-	self assert: critiques size  = 3.
-	self assert: (critiques anySatisfy: [ :each |
-		each sourceAnchor entity = (MFClassB>>#method3)]).
-	self assert: (critiques anySatisfy: [ :each |
-		each sourceAnchor entity = (MFClassA>>#method)]).
 
+	self assert: critiques size equals: 3.
+	self assert: (critiques anySatisfy: [ :each | each sourceAnchor entity = (MFClassB >> #method3) ]).
+	self assert: (critiques anySatisfy: [ :each | each sourceAnchor entity = (MFClassA >> #method) ])
 ]
 
 { #category : #tests }
diff --git a/src/Metacello-TestsCore/MetacelloCommonVersionNumberTestCase.class.st b/src/Metacello-TestsCore/MetacelloCommonVersionNumberTestCase.class.st
index ba09fcf85f5..9c12c3c1172 100644
--- a/src/Metacello-TestsCore/MetacelloCommonVersionNumberTestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloCommonVersionNumberTestCase.class.st
@@ -50,39 +50,37 @@ MetacelloCommonVersionNumberTestCase >> testAlphaNumericVersion4 [
 
 { #category : #'tests version increment/decrement' }
 MetacelloCommonVersionNumberTestCase >> testIncrementDecrementVersion [
-  | version |
-  version := self defaultVersion1.
-  self assert: version incrementMajorVersion asString = '2.0.0'.
-  self assert: version decrementMajorVersion asString = '1.0.0'.
-  self assert: version incrementMinorVersion asString = '1.1.0'.
-  self assert: version decrementMinorVersion asString = '1.0.0'.
-  self assert: version incrementPatchVersion asString = '1.0.1'.
-  self assert: version decrementPatchVersion asString = '1.0.0'
+	| version |
+	version := self defaultVersion1.
+	self assert: version incrementMajorVersion asString equals: '2.0.0'.
+	self assert: version decrementMajorVersion asString equals: '1.0.0'.
+	self assert: version incrementMinorVersion asString equals: '1.1.0'.
+	self assert: version decrementMinorVersion asString equals: '1.0.0'.
+	self assert: version incrementPatchVersion asString equals: '1.0.1'.
+	self assert: version decrementPatchVersion asString equals: '1.0.0'
 ]
 
 { #category : #'tests version increment/decrement' }
 MetacelloCommonVersionNumberTestCase >> testIncrementDecrementVersionNumber [
-  | version |
-  version := self defaultVersion1.
-  self assert: version incrementMinorVersionNumber asString = '1.0.1'.
-  self assert: version decrementMinorVersionNumber asString = '1.0.0'
+	| version |
+	version := self defaultVersion1.
+	self assert: version incrementMinorVersionNumber asString equals: '1.0.1'.
+	self assert: version decrementMinorVersionNumber asString equals: '1.0.0'
 ]
 
 { #category : #tests }
 MetacelloCommonVersionNumberTestCase >> testVersion01 [
-
-	self assert: ((self versionClass fromString: '1.1.1') versionString = '1.1.1')
+	self assert: (self versionClass fromString: '1.1.1') versionString equals: '1.1.1'
 ]
 
 { #category : #tests }
 MetacelloCommonVersionNumberTestCase >> testVersion02 [
-
 	| v1 v2 |
 	v1 := self versionClass fromString: '1.1.1'.
 	v2 := self versionClass fromString: '1.0.0'.
-	self assert: (v1 = v1).	
-	self assert: (v2 = v2).
-	self assert: (v1 > v2)
+	self assert: v1 equals: v1.
+	self assert: v2 equals: v2.
+	self assert: v1 > v2
 ]
 
 { #category : #tests }
@@ -103,26 +101,20 @@ MetacelloCommonVersionNumberTestCase >> testVersion14 [
 
 { #category : #tests }
 MetacelloCommonVersionNumberTestCase >> testVersion22 [
-
-	self assert: (MetacelloVersionNumber fromString: '3.0.0') collapseZeros size = 1.
-	self assert: (MetacelloVersionNumber fromString: '3.0.0') = (MetacelloVersionNumber fromString: '3.0').
-	self assert: (MetacelloVersionNumber fromString: '3.0') = (MetacelloVersionNumber fromString: '3.0.0').
-
-
+	self assert: (MetacelloVersionNumber fromString: '3.0.0') collapseZeros size equals: 1.
+	self assert: (MetacelloVersionNumber fromString: '3.0.0') equals: (MetacelloVersionNumber fromString: '3.0').
+	self assert: (MetacelloVersionNumber fromString: '3.0') equals: (MetacelloVersionNumber fromString: '3.0.0')
 ]
 
 { #category : #tests }
 MetacelloCommonVersionNumberTestCase >> testVersion23 [
-
-	self assert: (MetacelloVersionNumber fromString: '3.0.0.-rc.1') = (MetacelloVersionNumber fromString: '3.0.0-rc.1').
+	self assert: (MetacelloVersionNumber fromString: '3.0.0.-rc.1') equals: (MetacelloVersionNumber fromString: '3.0.0-rc.1').
 	self assert: (MetacelloVersionNumber fromString: '3.0') > (MetacelloVersionNumber fromString: '3.0-rc.1').
 	self assert: (MetacelloVersionNumber fromString: '3') > (MetacelloVersionNumber fromString: '3-rc.1').
-	self assert: (MetacelloVersionNumber fromString: '3.-rc.1') = (MetacelloVersionNumber fromString: '3.0.0-rc.1').
-	self assert: (MetacelloVersionNumber fromString: '3.0.-rc.1') = (MetacelloVersionNumber fromString: '3.0.0-rc.1').
+	self assert: (MetacelloVersionNumber fromString: '3.-rc.1') equals: (MetacelloVersionNumber fromString: '3.0.0-rc.1').
+	self assert: (MetacelloVersionNumber fromString: '3.0.-rc.1') equals: (MetacelloVersionNumber fromString: '3.0.0-rc.1').
 	self assert: (MetacelloVersionNumber fromString: '3') > (MetacelloVersionNumber fromString: '3.0-rc.1').
-	self assert: (MetacelloVersionNumber fromString: '3.0') > (MetacelloVersionNumber fromString: '3.0.0-rc.1').
-
-
+	self assert: (MetacelloVersionNumber fromString: '3.0') > (MetacelloVersionNumber fromString: '3.0.0-rc.1')
 ]
 
 { #category : #tests }
diff --git a/src/Metacello-TestsCore/MetacelloCoreIssue125TestCase.class.st b/src/Metacello-TestsCore/MetacelloCoreIssue125TestCase.class.st
index 15d15f2e0dd..f8b800aef9e 100644
--- a/src/Metacello-TestsCore/MetacelloCoreIssue125TestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloCoreIssue125TestCase.class.st
@@ -66,12 +66,12 @@ MetacelloCoreIssue125TestCase >> projectWith: projectAttributes [
 
 { #category : #tests }
 MetacelloCoreIssue125TestCase >> testForDoListAtrribute1Active [
-  "https://github.com/dalehenrich/metacello-work/issues/125"
+	"https://github.com/dalehenrich/metacello-work/issues/125"
 
-  | project version expected actual |
-  project := self projectWith: #(#'attribute1').
-  version := project version: '3.0-baseline'.
-  expected := 'spec blessing: #''baseline''.
+	| project version expected actual |
+	project := self projectWith: #(#attribute1).
+	version := project version: '3.0-baseline'.
+	expected := 'spec blessing: #''baseline''.
 spec preLoadDoIt: #''preloadForCore''.
 spec postLoadDoIt: #''postloadForCore:package:''.
 spec 
@@ -92,18 +92,18 @@ spec
 spec 
 	group: ''Core'' with: #(''Example Project'' );
 	group: ''Core'' with: #(''Extra Project'' ).'.
-  actual := version spec printString.
-  self assert: expected = actual
+	actual := version spec printString.
+	self assert: expected equals: actual
 ]
 
 { #category : #tests }
 MetacelloCoreIssue125TestCase >> testForDoListAtrribute2Active [
-  "https://github.com/dalehenrich/metacello-work/issues/125"
+	"https://github.com/dalehenrich/metacello-work/issues/125"
 
-  | project version expected actual |
-  project := self projectWith: #(#'attribute2').
-  version := project version: '3.0-baseline'.
-  expected := 'spec blessing: #''baseline''.
+	| project version expected actual |
+	project := self projectWith: #(#attribute2).
+	version := project version: '3.0-baseline'.
+	expected := 'spec blessing: #''baseline''.
 spec preLoadDoIt: #''preloadForCore''.
 spec postLoadDoIt: #''postloadForCore:package:''.
 spec 
@@ -124,18 +124,18 @@ spec
 spec 
 	group: ''Core'' with: #(''Example Project'' );
 	group: ''Core'' with: #(''Extra Project'' ).'.
-  actual := version spec printString.
-  self assert: expected = actual
+	actual := version spec printString.
+	self assert: expected equals: actual
 ]
 
 { #category : #tests }
 MetacelloCoreIssue125TestCase >> testForDoListAttribute1Atrribute2Active [
-  "https://github.com/dalehenrich/metacello-work/issues/125"
+	"https://github.com/dalehenrich/metacello-work/issues/125"
 
-  | project version expected actual |
-  project := self projectWith: #(#'attribute1' #'attribute2').
-  version := project version: '3.0-baseline'.
-  expected := 'spec blessing: #''baseline''.
+	| project version expected actual |
+	project := self projectWith: #(#attribute1 #attribute2).
+	version := project version: '3.0-baseline'.
+	expected := 'spec blessing: #''baseline''.
 spec preLoadDoIt: #''preloadForCore''.
 spec postLoadDoIt: #''postloadForCore:package:''.
 spec 
@@ -164,18 +164,18 @@ spec
 	group: ''Core'' with: #(''Example Project'' );
 	group: ''Core'' with: #(''Extra Project'' );
 	group: ''Core'' with: #(''Extra Project'' ).'.
-  actual := version spec printString.
-  self assert: expected = actual
+	actual := version spec printString.
+	self assert: expected equals: actual
 ]
 
 { #category : #tests }
 MetacelloCoreIssue125TestCase >> testForDoListNotActive [
-  "https://github.com/dalehenrich/metacello-work/issues/125"
+	"https://github.com/dalehenrich/metacello-work/issues/125"
 
-  | project version expected actual |
-  project := self projectWith: #().
-  version := project version: '3.0-baseline'.
-  expected := 'spec blessing: #''baseline''.
+	| project version expected actual |
+	project := self projectWith: #().
+	version := project version: '3.0-baseline'.
+	expected := 'spec blessing: #''baseline''.
 spec preLoadDoIt: #''preloadForCore''.
 spec postLoadDoIt: #''postloadForCore:package:''.
 spec project: ''Example Project'' with: [
@@ -186,6 +186,6 @@ spec project: ''Example Project'' with: [
 			postLoadDoIt: #''postloadForProject'';
 			loads: #(''core'' ) ].
 spec group: ''Core'' with: #(''Example Project'' ).'.
-  actual := version spec printString.
-  self assert: expected = actual
+	actual := version spec printString.
+	self assert: expected equals: actual
 ]
diff --git a/src/Metacello-TestsCore/MetacelloCoreSymbolicVersionTest.class.st b/src/Metacello-TestsCore/MetacelloCoreSymbolicVersionTest.class.st
index db17225090d..cad245cf70d 100644
--- a/src/Metacello-TestsCore/MetacelloCoreSymbolicVersionTest.class.st
+++ b/src/Metacello-TestsCore/MetacelloCoreSymbolicVersionTest.class.st
@@ -70,48 +70,48 @@ MetacelloCoreSymbolicVersionTest >> stableVersion: spec [
 
 { #category : #tests }
 MetacelloCoreSymbolicVersionTest >> testBasicBleedingEdgeVersion [
-    | project version expected actual |
-    project := self projectWith: #(#'platformVersion1.x').
-    version := project version: #'bleedingEdge'.
-    expected := 'spec blessing: #''baseline''.
+	| project version expected actual |
+	project := self projectWith: #(#'platformVersion1.x').
+	version := project version: #bleedingEdge.
+	expected := 'spec blessing: #''baseline''.
 spec project: ''Example Project'' with: [
 		spec
 			className: ''MetacelloExampleProjectConfig'';
 			versionString: ''1.0-baseline'';
 			preLoadDoIt: #''preloadForProject'';
 			postLoadDoIt: #''postloadForProject'' ].'.
-    actual := version spec printString.
-    self assert: expected = actual
+	actual := version spec printString.
+	self assert: expected equals: actual
 ]
 
 { #category : #tests }
 MetacelloCoreSymbolicVersionTest >> testBasicStableVersion [
-    | project version expected actual |
-    project := self projectWith: #(#'platformVersion1.x').
-    version := project version: #'stable'.
-    expected := 'spec blessing: #''release''.
+	| project version expected actual |
+	project := self projectWith: #(#'platformVersion1.x').
+	version := project version: #stable.
+	expected := 'spec blessing: #''release''.
 spec project: ''Example Project'' with: [
 		spec
 			className: ''MetacelloExampleProjectConfig'';
 			versionString: ''1.0-baseline'';
 			preLoadDoIt: #''preloadForProject'';
 			postLoadDoIt: #''postloadForProject'' ].'.
-    actual := version spec printString.
-    self assert: expected = actual
+	actual := version spec printString.
+	self assert: expected equals: actual
 ]
 
 { #category : #tests }
 MetacelloCoreSymbolicVersionTest >> testBleedingEdgeMethod [
-    | project |
-    project := self projectWith: #(#'platformVersion1.x').
-    self assert: (project version: #'bleedingEdge') = project bleedingEdge
+	| project |
+	project := self projectWith: #(#'platformVersion1.x').
+	self assert: (project version: #bleedingEdge) equals: project bleedingEdge
 ]
 
 { #category : #tests }
 MetacelloCoreSymbolicVersionTest >> testStableVersionMethod [
-    | project |
-    project := self projectWith: #(#'platformVersion1.x').
-    self assert: (project version: #'stable') = project stableVersion
+	| project |
+	project := self projectWith: #(#'platformVersion1.x').
+	self assert: (project version: #stable) equals: project stableVersion
 ]
 
 { #category : #versions }
diff --git a/src/Metacello-TestsCore/MetacelloCoreVersionQueryTestCase.class.st b/src/Metacello-TestsCore/MetacelloCoreVersionQueryTestCase.class.st
index c45fb8dab65..ef8e0336949 100644
--- a/src/Metacello-TestsCore/MetacelloCoreVersionQueryTestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloCoreVersionQueryTestCase.class.st
@@ -86,53 +86,53 @@ MetacelloCoreVersionQueryTestCase >> projectWith: projectAttributes [
 
 { #category : #tests }
 MetacelloCoreVersionQueryTestCase >> testBaseline10Groups [
-    | project version expected list |
-    project := self project.
-    version := project version: '1.0-baseline'.
-    expected := #('Core' 'Tests' 'Recursive').
-    list := version groups.
-    self assert: list size = expected size.
-    list do: [ :pkg | self assert: (expected includes: pkg name) ]
+	| project version expected list |
+	project := self project.
+	version := project version: '1.0-baseline'.
+	expected := #('Core' 'Tests' 'Recursive').
+	list := version groups.
+	self assert: list size equals: expected size.
+	list do: [ :pkg | self assert: (expected includes: pkg name) ]
 ]
 
 { #category : #tests }
 MetacelloCoreVersionQueryTestCase >> testBaseline10Projects [
-    | project version expected list |
-    project := self project.
-    version := project version: '1.0-baseline'.
-    expected := #('UTF8').
-    list := version projects.
-    self assert: list size = expected size.
-    list do: [ :pkg | self assert: (expected includes: pkg name) ]
+	| project version expected list |
+	project := self project.
+	version := project version: '1.0-baseline'.
+	expected := #('UTF8').
+	list := version projects.
+	self assert: list size equals: expected size.
+	list do: [ :pkg | self assert: (expected includes: pkg name) ]
 ]
 
 { #category : #tests }
 MetacelloCoreVersionQueryTestCase >> testBaseline10ResolveToLoadableSpecs01 [
-    | project version expected list |
-    project := self project.
-    version := project version: '1.0-baseline'.
-    expected := #('UTF8').
-    list := version resolveToLoadableSpecs: #('UTF8').
-    self assert: list size = expected size.
-    list do: [ :pkg | self assert: (expected includes: pkg name) ].
-    expected := #('UTF8').
-    list := version resolveToLoadableSpecs: #('Recursive').
-    self assert: list size = expected size.
-    list do: [ :pkg | self assert: (expected includes: pkg name) ]
+	| project version expected list |
+	project := self project.
+	version := project version: '1.0-baseline'.
+	expected := #('UTF8').
+	list := version resolveToLoadableSpecs: #('UTF8').
+	self assert: list size equals: expected size.
+	list do: [ :pkg | self assert: (expected includes: pkg name) ].
+	expected := #('UTF8').
+	list := version resolveToLoadableSpecs: #('Recursive').
+	self assert: list size equals: expected size.
+	list do: [ :pkg | self assert: (expected includes: pkg name) ]
 ]
 
 { #category : #tests }
 MetacelloCoreVersionQueryTestCase >> testDifference [
-    | project expected fromVersionString toVersionString report actual |
-    project := self project.
-    fromVersionString := '1.1-baseline'.
-    toVersionString := '2.0-baseline'.
-    report := (project version: fromVersionString) difference: (project version: toVersionString).
-    report
-        from: fromVersionString;
-        to: toVersionString;
-        configuration: 'Test Configuration'.
-    expected := 'Test Configuration ''1.1-baseline'' to ''2.0-baseline''
+	| project expected fromVersionString toVersionString report actual |
+	project := self project.
+	fromVersionString := '1.1-baseline'.
+	toVersionString := '2.0-baseline'.
+	report := (project version: fromVersionString) difference: (project version: toVersionString).
+	report
+		from: fromVersionString;
+		to: toVersionString;
+		configuration: 'Test Configuration'.
+	expected := 'Test Configuration ''1.1-baseline'' to ''2.0-baseline''
 	Additions:
 		UTF9
 			'''' to ''1.0-baseline''
@@ -143,6 +143,6 @@ MetacelloCoreVersionQueryTestCase >> testDifference [
 		UTF7
 			''1.0-baseline'' to ''''
 '.
-    actual := report printString.
-    self assert: expected = actual
+	actual := report printString.
+	self assert: expected equals: actual
 ]
diff --git a/src/Metacello-TestsCore/MetacelloGroupSpecTestCase.class.st b/src/Metacello-TestsCore/MetacelloGroupSpecTestCase.class.st
index 0f0f5bdfed9..5bb18b8a23e 100644
--- a/src/Metacello-TestsCore/MetacelloGroupSpecTestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloGroupSpecTestCase.class.st
@@ -22,23 +22,20 @@ MetacelloGroupSpecTestCase >> testGroupMergeSpec [
 
 { #category : #tests }
 MetacelloGroupSpecTestCase >> testGroupSpec [
-    | group |
-    group := self groupSpec
-        name: 'Platform';
-        includes: 'Core';
-        yourself.
-    self assert: group name = 'Platform'.
-    self assert: (group includes includes: 'Core').
-    group := self groupSpec
-        name: 'Platform';
-        includes: #('Core');
-        yourself.
-    self assert: group name = 'Platform'.
-    self assert: (group includes includes: 'Core').
-    self should: [ group requires: #() ] raise: Error.
-    self should: [ group answers: #() ] raise: Error.
-    group
-        projectDo: [ :ignored | self assert: false ]
-        packageDo: [ :ignored | self assert: false ]
-        groupDo: [ :grp | self assert: group == grp ]
+	| group |
+	group := self groupSpec
+		name: 'Platform';
+		includes: 'Core';
+		yourself.
+	self assert: group name equals: 'Platform'.
+	self assert: (group includes includes: 'Core').
+	group := self groupSpec
+		name: 'Platform';
+		includes: #('Core');
+		yourself.
+	self assert: group name equals: 'Platform'.
+	self assert: (group includes includes: 'Core').
+	self should: [ group requires: #() ] raise: Error.
+	self should: [ group answers: #() ] raise: Error.
+	group projectDo: [ :ignored | self assert: false ] packageDo: [ :ignored | self assert: false ] groupDo: [ :grp | self assert: group identicalTo: grp ]
 ]
diff --git a/src/Metacello-TestsCore/MetacelloPackagesSpecTestCase.class.st b/src/Metacello-TestsCore/MetacelloPackagesSpecTestCase.class.st
index 76ede6b3e35..fa43ea41ffd 100644
--- a/src/Metacello-TestsCore/MetacelloPackagesSpecTestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloPackagesSpecTestCase.class.st
@@ -50,102 +50,95 @@ MetacelloPackagesSpecTestCase >> testAddGroupB [
 
 { #category : #tests }
 MetacelloPackagesSpecTestCase >> testAddProjectA [
-    "used by MetacelloAbstractVersionConstructor>>project:overrides:"
+	"used by MetacelloAbstractVersionConstructor>>project:overrides:"
 
-    | packages project projectReferenceSpec |
-    packages := self packagesSpec.
-    packages
-        add:
-            (self projectSpec
-                name: 'Project';
-                className: 'ConfigurationOfProjectA';
-                versionString: #'stable';
-                loads: #('MyPackage' 'MyTests');
-                preLoadDoIt: #'preLoadDoItB';
-                postLoadDoIt: #'postLoadDoItB';
-                yourself).
-    packages
-        add:
-            (self projectSpec
-                name: 'Project';
-                className: 'ConfigurationOfProject';
-                versionString: '1.0';
-                operator: #'<';
-                loads: #('MyPackage');
-                preLoadDoIt: #'preLoadDoIt';
-                postLoadDoIt: #'postLoadDoIt';
-                yourself).
-    projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
-    self assert: projectReferenceSpec projectName = 'Project'.
-    self assert: projectReferenceSpec versionString = '1.0'.
-    self should: [ projectReferenceSpec includes: #() ] raise: Error.
-    self should: [ projectReferenceSpec requires: #() ] raise: Error.
-    self should: [ projectReferenceSpec answers: #() ] raise: Error.
-    projectReferenceSpec
-        projectDo: [ :prjct | self assert: projectReferenceSpec == prjct ]
-        packageDo: [ :ignored | self assert: false ]
-        groupDo: [ :ignored | self assert: false ].
-    project := projectReferenceSpec referencedSpec.
-    self assert: project name = 'Project'.
-    self assert: project className = 'ConfigurationOfProject'.
-    self assert: project versionString = '1.0'.
-    self assert: project operator == #'<'.
-    self assert: project loads = #('MyPackage').
-    self assert: project preLoadDoIt value == #'preLoadDoIt'.
-    self assert: project postLoadDoIt value == #'postLoadDoIt'.
-    project
-        projectDo: [ :prjct | self assert: project == prjct ]
-        packageDo: [ :ignored | self assert: false ]
-        groupDo: [ :ignored | self assert: false ]
+	| packages project projectReferenceSpec |
+	packages := self packagesSpec.
+	packages
+		add:
+			(self projectSpec
+				name: 'Project';
+				className: 'ConfigurationOfProjectA';
+				versionString: #stable;
+				loads: #('MyPackage' 'MyTests');
+				preLoadDoIt: #preLoadDoItB;
+				postLoadDoIt: #postLoadDoItB;
+				yourself).
+	packages
+		add:
+			(self projectSpec
+				name: 'Project';
+				className: 'ConfigurationOfProject';
+				versionString: '1.0';
+				operator: #<;
+				loads: #('MyPackage');
+				preLoadDoIt: #preLoadDoIt;
+				postLoadDoIt: #postLoadDoIt;
+				yourself).
+	projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
+	self assert: projectReferenceSpec projectName equals: 'Project'.
+	self assert: projectReferenceSpec versionString equals: '1.0'.
+	self should: [ projectReferenceSpec includes: #() ] raise: Error.
+	self should: [ projectReferenceSpec requires: #() ] raise: Error.
+	self should: [ projectReferenceSpec answers: #() ] raise: Error.
+	projectReferenceSpec
+		projectDo: [ :prjct | self assert: projectReferenceSpec identicalTo: prjct ]
+		packageDo: [ :ignored | self assert: false ]
+		groupDo: [ :ignored | self assert: false ].
+	project := projectReferenceSpec referencedSpec.
+	self assert: project name equals: 'Project'.
+	self assert: project className equals: 'ConfigurationOfProject'.
+	self assert: project versionString equals: '1.0'.
+	self assert: project operator identicalTo: #<.
+	self assert: project loads equals: #('MyPackage').
+	self assert: project preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: project postLoadDoIt value identicalTo: #postLoadDoIt.
+	project projectDo: [ :prjct | self assert: project identicalTo: prjct ] packageDo: [ :ignored | self assert: false ] groupDo: [ :ignored | self assert: false ]
 ]
 
 { #category : #tests }
 MetacelloPackagesSpecTestCase >> testAddProjectB [
-    "used by MetacelloAbstractVersionConstructor>>project:overrides:"
+	"used by MetacelloAbstractVersionConstructor>>project:overrides:"
 
-    | packages project projectReferenceSpec |
-    packages := self packagesSpec.
-    packages
-        add:
-            {(self projectSpec
-                name: 'Project';
-                className: 'ConfigurationOfProjectA';
-                versionString: #'stable';
-                loads: #('MyPackage' 'MyTests');
-                preLoadDoIt: #'preLoadDoItB';
-                postLoadDoIt: #'postLoadDoItB';
-                yourself).
-            (self projectSpec
-                name: 'Project';
-                className: 'ConfigurationOfProject';
-                versionString: '1.0';
-                operator: #'<';
-                loads: #('MyPackage');
-                preLoadDoIt: #'preLoadDoIt';
-                postLoadDoIt: #'postLoadDoIt';
-                yourself)}.
-    projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
-    self assert: projectReferenceSpec projectName = 'Project'.
-    self assert: projectReferenceSpec versionString = '1.0'.
-    self should: [ projectReferenceSpec includes: #() ] raise: Error.
-    self should: [ projectReferenceSpec requires: #() ] raise: Error.
-    self should: [ projectReferenceSpec answers: #() ] raise: Error.
-    projectReferenceSpec
-        projectDo: [ :prjct | self assert: projectReferenceSpec == prjct ]
-        packageDo: [ :ignored | self assert: false ]
-        groupDo: [ :ignored | self assert: false ].
-    project := projectReferenceSpec referencedSpec.
-    self assert: project name = 'Project'.
-    self assert: project className = 'ConfigurationOfProject'.
-    self assert: project versionString = '1.0'.
-    self assert: project operator == #'<'.
-    self assert: project loads = #('MyPackage').
-    self assert: project preLoadDoIt value == #'preLoadDoIt'.
-    self assert: project postLoadDoIt value == #'postLoadDoIt'.
-    project
-        projectDo: [ :prjct | self assert: project == prjct ]
-        packageDo: [ :ignored | self assert: false ]
-        groupDo: [ :ignored | self assert: false ]
+	| packages project projectReferenceSpec |
+	packages := self packagesSpec.
+	packages
+		add:
+			{(self projectSpec
+				name: 'Project';
+				className: 'ConfigurationOfProjectA';
+				versionString: #stable;
+				loads: #('MyPackage' 'MyTests');
+				preLoadDoIt: #preLoadDoItB;
+				postLoadDoIt: #postLoadDoItB;
+				yourself) . (self projectSpec
+				name: 'Project';
+				className: 'ConfigurationOfProject';
+				versionString: '1.0';
+				operator: #<;
+				loads: #('MyPackage');
+				preLoadDoIt: #preLoadDoIt;
+				postLoadDoIt: #postLoadDoIt;
+				yourself)}.
+	projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
+	self assert: projectReferenceSpec projectName equals: 'Project'.
+	self assert: projectReferenceSpec versionString equals: '1.0'.
+	self should: [ projectReferenceSpec includes: #() ] raise: Error.
+	self should: [ projectReferenceSpec requires: #() ] raise: Error.
+	self should: [ projectReferenceSpec answers: #() ] raise: Error.
+	projectReferenceSpec
+		projectDo: [ :prjct | self assert: projectReferenceSpec identicalTo: prjct ]
+		packageDo: [ :ignored | self assert: false ]
+		groupDo: [ :ignored | self assert: false ].
+	project := projectReferenceSpec referencedSpec.
+	self assert: project name equals: 'Project'.
+	self assert: project className equals: 'ConfigurationOfProject'.
+	self assert: project versionString equals: '1.0'.
+	self assert: project operator identicalTo: #<.
+	self assert: project loads equals: #('MyPackage').
+	self assert: project preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: project postLoadDoIt value identicalTo: #postLoadDoIt.
+	project projectDo: [ :prjct | self assert: project identicalTo: prjct ] packageDo: [ :ignored | self assert: false ] groupDo: [ :ignored | self assert: false ]
 ]
 
 { #category : #tests }
@@ -182,36 +175,36 @@ MetacelloPackagesSpecTestCase >> testCopyToGroup [
 
 { #category : #tests }
 MetacelloPackagesSpecTestCase >> testCopyToProject [
-    "used by MetacelloAbstractVersionConstructor>>project:copyFrom:with:"
+	"used by MetacelloAbstractVersionConstructor>>project:copyFrom:with:"
 
-    | packages project referenceSpec |
-    packages := self packagesSpec.
-    packages
-        add:
-            (self projectSpec
-                name: 'Project';
-                className: 'ConfigurationOfProjectA';
-                versionString: #'stable';
-                loads: #('MyPackage' 'MyTests');
-                preLoadDoIt: #'preLoadDoItB';
-                postLoadDoIt: #'postLoadDoItB';
-                yourself).
-    project := self projectSpec
-        name: 'ProjectCopy';
-        yourself.
-    referenceSpec := self project projectReferenceSpec
-        name: 'ProjectCopy';
-        projectReference: project;
-        yourself.
-    packages copy: 'Project' to: referenceSpec.
-    project := (packages packageNamed: 'ProjectCopy' ifAbsent: [ self assert: false ]) referencedSpec.
-    self assert: project name = 'ProjectCopy'.
-    self assert: project className = 'ConfigurationOfProjectA'.
-    self assert: project versionString = #'stable'.
-    self assert: project operator == #'>='.
-    self assert: project loads = #('MyPackage' 'MyTests').
-    self assert: project preLoadDoIt value == #'preLoadDoItB'.
-    self assert: project postLoadDoIt value == #'postLoadDoItB'
+	| packages project referenceSpec |
+	packages := self packagesSpec.
+	packages
+		add:
+			(self projectSpec
+				name: 'Project';
+				className: 'ConfigurationOfProjectA';
+				versionString: #stable;
+				loads: #('MyPackage' 'MyTests');
+				preLoadDoIt: #preLoadDoItB;
+				postLoadDoIt: #postLoadDoItB;
+				yourself).
+	project := self projectSpec
+		name: 'ProjectCopy';
+		yourself.
+	referenceSpec := self project projectReferenceSpec
+		name: 'ProjectCopy';
+		projectReference: project;
+		yourself.
+	packages copy: 'Project' to: referenceSpec.
+	project := (packages packageNamed: 'ProjectCopy' ifAbsent: [ self assert: false ]) referencedSpec.
+	self assert: project name equals: 'ProjectCopy'.
+	self assert: project className equals: 'ConfigurationOfProjectA'.
+	self assert: project versionString equals: #stable.
+	self assert: project operator identicalTo: #>=.
+	self assert: project loads equals: #('MyPackage' 'MyTests').
+	self assert: project preLoadDoIt value identicalTo: #preLoadDoItB.
+	self assert: project postLoadDoIt value identicalTo: #postLoadDoItB
 ]
 
 { #category : #tests }
@@ -262,98 +255,92 @@ MetacelloPackagesSpecTestCase >> testMergeGroupB [
 
 { #category : #tests }
 MetacelloPackagesSpecTestCase >> testMergeProjectA [
-    "used by MetacelloAbstractVersionConstructor>>project:with:"
+	"used by MetacelloAbstractVersionConstructor>>project:with:"
 
-    | packages project projectReferenceSpec referenceSpec |
-    packages := self packagesSpec.
-    project := self projectSpec
-        name: 'Project';
-        className: 'ConfigurationOfProjectA';
-        versionString: #'stable';
-        loads: #('MyPackage' 'MyTests');
-        preLoadDoIt: #'preLoadDoItB';
-        postLoadDoIt: #'postLoadDoItB';
-        yourself.
-    referenceSpec := self project projectReferenceSpec
-        name: project name;
-        projectReference: project;
-        yourself.
-    packages add: referenceSpec.
-    project := self projectSpec
-        name: 'Project';
-        className: 'ConfigurationOfProject';
-        versionString: '1.0';
-        operator: #'<';
-        loads: #('MyPackage');
-        preLoadDoIt: #'preLoadDoIt';
-        postLoadDoIt: #'postLoadDoIt';
-        yourself.
-    referenceSpec := self project projectReferenceSpec
-        name: project name;
-        projectReference: project;
-        yourself.
-    packages merge: referenceSpec.
-    projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
-    project := projectReferenceSpec referencedSpec.
-    self assert: project name = 'Project'.
-    self assert: project className = 'ConfigurationOfProject'.
-    self assert: project versionString = '1.0'.
-    self assert: project operator == #'<'.
-    self assert: project loads = #('MyPackage').
-    self assert: project preLoadDoIt value == #'preLoadDoIt'.
-    self assert: project postLoadDoIt value == #'postLoadDoIt'.
-    project
-        projectDo: [ :prjct | self assert: project == prjct ]
-        packageDo: [ :ignored | self assert: false ]
-        groupDo: [ :ignored | self assert: false ]
+	| packages project projectReferenceSpec referenceSpec |
+	packages := self packagesSpec.
+	project := self projectSpec
+		name: 'Project';
+		className: 'ConfigurationOfProjectA';
+		versionString: #stable;
+		loads: #('MyPackage' 'MyTests');
+		preLoadDoIt: #preLoadDoItB;
+		postLoadDoIt: #postLoadDoItB;
+		yourself.
+	referenceSpec := self project projectReferenceSpec
+		name: project name;
+		projectReference: project;
+		yourself.
+	packages add: referenceSpec.
+	project := self projectSpec
+		name: 'Project';
+		className: 'ConfigurationOfProject';
+		versionString: '1.0';
+		operator: #<;
+		loads: #('MyPackage');
+		preLoadDoIt: #preLoadDoIt;
+		postLoadDoIt: #postLoadDoIt;
+		yourself.
+	referenceSpec := self project projectReferenceSpec
+		name: project name;
+		projectReference: project;
+		yourself.
+	packages merge: referenceSpec.
+	projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
+	project := projectReferenceSpec referencedSpec.
+	self assert: project name equals: 'Project'.
+	self assert: project className equals: 'ConfigurationOfProject'.
+	self assert: project versionString equals: '1.0'.
+	self assert: project operator identicalTo: #<.
+	self assert: project loads equals: #('MyPackage').
+	self assert: project preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: project postLoadDoIt value identicalTo: #postLoadDoIt.
+	project projectDo: [ :prjct | self assert: project identicalTo: prjct ] packageDo: [ :ignored | self assert: false ] groupDo: [ :ignored | self assert: false ]
 ]
 
 { #category : #tests }
 MetacelloPackagesSpecTestCase >> testMergeProjectB [
-    "used by MetacelloAbstractVersionConstructor>>project:with:"
+	"used by MetacelloAbstractVersionConstructor>>project:with:"
 
-    | packages project projectReferenceSpec referenceSpec |
-    packages := self packagesSpec.
-    project := self projectSpec
-        name: 'Project';
-        className: 'ConfigurationOfProjectA';
-        versionString: #'stable';
-        loads: #('MyPackage' 'MyTests');
-        preLoadDoIt: #'preLoadDoItB';
-        postLoadDoIt: #'postLoadDoItB';
-        yourself.
-    referenceSpec := self project projectReferenceSpec
-        name: project name;
-        projectReference: project;
-        yourself.
-    packages add: referenceSpec.
-    project := self projectSpec
-        name: 'Project';
-        className: 'ConfigurationOfProject';
-        versionString: '1.0';
-        operator: #'<';
-        loads: #('MyPackage');
-        preLoadDoIt: #'preLoadDoIt';
-        postLoadDoIt: #'postLoadDoIt';
-        yourself.
-    referenceSpec := self project projectReferenceSpec
-        name: project name;
-        projectReference: project;
-        yourself.
-    packages merge: {referenceSpec}.
-    projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
-    project := projectReferenceSpec referencedSpec.
-    self assert: project name = 'Project'.
-    self assert: project className = 'ConfigurationOfProject'.
-    self assert: project versionString = '1.0'.
-    self assert: project operator == #'<'.
-    self assert: project loads = #('MyPackage').
-    self assert: project preLoadDoIt value == #'preLoadDoIt'.
-    self assert: project postLoadDoIt value == #'postLoadDoIt'.
-    project
-        projectDo: [ :prjct | self assert: project == prjct ]
-        packageDo: [ :ignored | self assert: false ]
-        groupDo: [ :ignored | self assert: false ]
+	| packages project projectReferenceSpec referenceSpec |
+	packages := self packagesSpec.
+	project := self projectSpec
+		name: 'Project';
+		className: 'ConfigurationOfProjectA';
+		versionString: #stable;
+		loads: #('MyPackage' 'MyTests');
+		preLoadDoIt: #preLoadDoItB;
+		postLoadDoIt: #postLoadDoItB;
+		yourself.
+	referenceSpec := self project projectReferenceSpec
+		name: project name;
+		projectReference: project;
+		yourself.
+	packages add: referenceSpec.
+	project := self projectSpec
+		name: 'Project';
+		className: 'ConfigurationOfProject';
+		versionString: '1.0';
+		operator: #<;
+		loads: #('MyPackage');
+		preLoadDoIt: #preLoadDoIt;
+		postLoadDoIt: #postLoadDoIt;
+		yourself.
+	referenceSpec := self project projectReferenceSpec
+		name: project name;
+		projectReference: project;
+		yourself.
+	packages merge: {referenceSpec}.
+	projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
+	project := projectReferenceSpec referencedSpec.
+	self assert: project name equals: 'Project'.
+	self assert: project className equals: 'ConfigurationOfProject'.
+	self assert: project versionString equals: '1.0'.
+	self assert: project operator identicalTo: #<.
+	self assert: project loads equals: #('MyPackage').
+	self assert: project preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: project postLoadDoIt value identicalTo: #postLoadDoIt.
+	project projectDo: [ :prjct | self assert: project identicalTo: prjct ] packageDo: [ :ignored | self assert: false ] groupDo: [ :ignored | self assert: false ]
 ]
 
 { #category : #tests }
@@ -457,72 +444,72 @@ MetacelloPackagesSpecTestCase >> testRemoveGroupC [
 
 { #category : #tests }
 MetacelloPackagesSpecTestCase >> testRemoveProjectA [
-    "used by MetacelloAbstractVersionConstructor>>removeProject:"
+	"used by MetacelloAbstractVersionConstructor>>removeProject:"
 
-    | packages project projectReferenceSpec removed |
-    packages := self packagesSpec.
-    packages
-        add:
-            (self projectSpec
-                name: 'Project';
-                className: 'ConfigurationOfProject';
-                versionString: '1.0';
-                operator: #'<';
-                loads: #('MyPackage');
-                preLoadDoIt: #'preLoadDoIt';
-                postLoadDoIt: #'postLoadDoIt';
-                yourself).
-    projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
-    project := projectReferenceSpec referencedSpec.
-    self assert: project name = 'Project'.
-    self assert: project className = 'ConfigurationOfProject'.
-    self assert: project versionString = '1.0'.
-    self assert: project operator == #'<'.
-    self assert: project loads = #('MyPackage').
-    self assert: project preLoadDoIt value == #'preLoadDoIt'.
-    self assert: project postLoadDoIt value == #'postLoadDoIt'.
-    packages
-        remove:
-            (self projectReferenceSpec
-                name: 'Project';
-                yourself).
-    removed := false.
-    packages packageNamed: 'Project' ifAbsent: [ removed := true ].
-    self assert: removed
+	| packages project projectReferenceSpec removed |
+	packages := self packagesSpec.
+	packages
+		add:
+			(self projectSpec
+				name: 'Project';
+				className: 'ConfigurationOfProject';
+				versionString: '1.0';
+				operator: #<;
+				loads: #('MyPackage');
+				preLoadDoIt: #preLoadDoIt;
+				postLoadDoIt: #postLoadDoIt;
+				yourself).
+	projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
+	project := projectReferenceSpec referencedSpec.
+	self assert: project name equals: 'Project'.
+	self assert: project className equals: 'ConfigurationOfProject'.
+	self assert: project versionString equals: '1.0'.
+	self assert: project operator identicalTo: #<.
+	self assert: project loads equals: #('MyPackage').
+	self assert: project preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: project postLoadDoIt value identicalTo: #postLoadDoIt.
+	packages
+		remove:
+			(self projectReferenceSpec
+				name: 'Project';
+				yourself).
+	removed := false.
+	packages packageNamed: 'Project' ifAbsent: [ removed := true ].
+	self assert: removed
 ]
 
 { #category : #tests }
 MetacelloPackagesSpecTestCase >> testRemoveProjectB [
-    "used by MetacelloAbstractVersionConstructor>>removeProject:"
+	"used by MetacelloAbstractVersionConstructor>>removeProject:"
 
-    | packages project projectReferenceSpec removed |
-    packages := self packagesSpec.
-    packages
-        add:
-            (self projectSpec
-                name: 'Project';
-                className: 'ConfigurationOfProject';
-                versionString: '1.0';
-                operator: #'<';
-                loads: #('MyPackage');
-                preLoadDoIt: #'preLoadDoIt';
-                postLoadDoIt: #'postLoadDoIt';
-                yourself).
-    projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
-    project := projectReferenceSpec referencedSpec.
-    self assert: project name = 'Project'.
-    self assert: project className = 'ConfigurationOfProject'.
-    self assert: project versionString = '1.0'.
-    self assert: project operator == #'<'.
-    self assert: project loads = #('MyPackage').
-    self assert: project preLoadDoIt value == #'preLoadDoIt'.
-    self assert: project postLoadDoIt value == #'postLoadDoIt'.
-    packages
-        remove:
-            {(self projectReferenceSpec
-                name: 'Project';
-                yourself)}.
-    removed := false.
-    packages packageNamed: 'Project' ifAbsent: [ removed := true ].
-    self assert: removed
+	| packages project projectReferenceSpec removed |
+	packages := self packagesSpec.
+	packages
+		add:
+			(self projectSpec
+				name: 'Project';
+				className: 'ConfigurationOfProject';
+				versionString: '1.0';
+				operator: #<;
+				loads: #('MyPackage');
+				preLoadDoIt: #preLoadDoIt;
+				postLoadDoIt: #postLoadDoIt;
+				yourself).
+	projectReferenceSpec := packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
+	project := projectReferenceSpec referencedSpec.
+	self assert: project name equals: 'Project'.
+	self assert: project className equals: 'ConfigurationOfProject'.
+	self assert: project versionString equals: '1.0'.
+	self assert: project operator identicalTo: #<.
+	self assert: project loads equals: #('MyPackage').
+	self assert: project preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: project postLoadDoIt value identicalTo: #postLoadDoIt.
+	packages
+		remove:
+			{(self projectReferenceSpec
+				name: 'Project';
+				yourself)}.
+	removed := false.
+	packages packageNamed: 'Project' ifAbsent: [ removed := true ].
+	self assert: removed
 ]
diff --git a/src/Metacello-TestsCore/MetacelloProjectReferenceSpecTestCase.class.st b/src/Metacello-TestsCore/MetacelloProjectReferenceSpecTestCase.class.st
index a078ca1140a..0a864c5550f 100644
--- a/src/Metacello-TestsCore/MetacelloProjectReferenceSpecTestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloProjectReferenceSpecTestCase.class.st
@@ -6,53 +6,53 @@ Class {
 
 { #category : #tests }
 MetacelloProjectReferenceSpecTestCase >> testProjectReferenceMergeSpec [
-    | projectReferenceA projectReferenceB projectReference project |
-    projectReferenceA := self projectReferenceSpec
-        name: 'Project';
-        projectReference:
-                (self projectSpec
-                        name: 'Project';
-                        className: 'ConfigurationOfProjectA';
-                        versionString: #'stable';
-                        yourself);
-        yourself.
-    projectReferenceB := self projectReferenceSpec
-        name: 'Project';
-        projectReference:
-                (self projectSpec
-                        name: 'Project';
-                        className: 'ConfigurationOfProjectB';
-                        versionString: '1.0';
-                        yourself);
-        yourself.
-    projectReference := projectReferenceA mergeSpec: projectReferenceB.
-    self assert: projectReference name = 'Project'.
-    self assert: projectReference projectName = 'Project'.
-    project := projectReference projectReference.
-    self assert: project className = 'ConfigurationOfProjectB'.
-    self assert: project versionString = '1.0'
+	| projectReferenceA projectReferenceB projectReference project |
+	projectReferenceA := self projectReferenceSpec
+		name: 'Project';
+		projectReference:
+			(self projectSpec
+				name: 'Project';
+				className: 'ConfigurationOfProjectA';
+				versionString: #stable;
+				yourself);
+		yourself.
+	projectReferenceB := self projectReferenceSpec
+		name: 'Project';
+		projectReference:
+			(self projectSpec
+				name: 'Project';
+				className: 'ConfigurationOfProjectB';
+				versionString: '1.0';
+				yourself);
+		yourself.
+	projectReference := projectReferenceA mergeSpec: projectReferenceB.
+	self assert: projectReference name equals: 'Project'.
+	self assert: projectReference projectName equals: 'Project'.
+	project := projectReference projectReference.
+	self assert: project className equals: 'ConfigurationOfProjectB'.
+	self assert: project versionString equals: '1.0'
 ]
 
 { #category : #tests }
 MetacelloProjectReferenceSpecTestCase >> testProjectReferenceSpec [
-    | projectReference project |
-    projectReference := self projectReferenceSpec
-        name: 'Project';
-        projectReference:
-                (project := self projectSpec
-                        name: 'Project';
-                        className: 'ConfigurationOfProjectA';
-                        versionString: #'stable';
-                        yourself);
-        yourself.
-    self assert: projectReference name = 'Project'.
-    self assert: projectReference projectName = 'Project'.
-    self assert: projectReference projectReference == project.
-    self should: [ projectReference includes: #() ] raise: Error.
-    self should: [ projectReference requires: #() ] raise: Error.
-    self should: [ projectReference answers: #() ] raise: Error.
-    projectReference
-        projectDo: [ :prjct | self assert: projectReference == prjct ]
-        packageDo: [ :ignored | self assert: false ]
-        groupDo: [ :ignored | self assert: false ]
+	| projectReference project |
+	projectReference := self projectReferenceSpec
+		name: 'Project';
+		projectReference:
+			(project := self projectSpec
+				name: 'Project';
+				className: 'ConfigurationOfProjectA';
+				versionString: #stable;
+				yourself);
+		yourself.
+	self assert: projectReference name equals: 'Project'.
+	self assert: projectReference projectName equals: 'Project'.
+	self assert: projectReference projectReference identicalTo: project.
+	self should: [ projectReference includes: #() ] raise: Error.
+	self should: [ projectReference requires: #() ] raise: Error.
+	self should: [ projectReference answers: #() ] raise: Error.
+	projectReference
+		projectDo: [ :prjct | self assert: projectReference identicalTo: prjct ]
+		packageDo: [ :ignored | self assert: false ]
+		groupDo: [ :ignored | self assert: false ]
 ]
diff --git a/src/Metacello-TestsCore/MetacelloProjectSpecTestCase.class.st b/src/Metacello-TestsCore/MetacelloProjectSpecTestCase.class.st
index 288e2887777..f050c96a373 100644
--- a/src/Metacello-TestsCore/MetacelloProjectSpecTestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloProjectSpecTestCase.class.st
@@ -6,64 +6,61 @@ Class {
 
 { #category : #tests }
 MetacelloProjectSpecTestCase >> testProjectMergeSpec [
-    | projectA projectB project |
-    projectA := self projectSpec
-        name: 'Project';
-        className: 'ConfigurationOfProject';
-        versionString: '1.0';
-        loads: #('MyPackage');
-        preLoadDoIt: #'preLoadDoIt';
-        postLoadDoIt: #'postLoadDoIt';
-        yourself.
-    projectB := self projectSpec
-        name: 'Project';
-        className: 'ConfigurationOfProjectB';
-        versionString: #'stable';
-        operator: #'<';
-        loads: #('MyPackage' 'MyTests');
-        preLoadDoIt: #'preLoadDoItB';
-        postLoadDoIt: #'postLoadDoItB';
-        yourself.
-    project := projectA mergeSpec: projectB.
-    self assert: project name = 'Project'.
-    self assert: project className = 'ConfigurationOfProjectB'.
-    self assert: project versionString = #'stable'.
-    self assert: project operator == #'<'.
-    self assert: project loads = #('MyPackage' 'MyTests').
-    self assert: project preLoadDoIt value == #'preLoadDoItB'.
-    self assert: project postLoadDoIt value == #'postLoadDoItB'
+	| projectA projectB project |
+	projectA := self projectSpec
+		name: 'Project';
+		className: 'ConfigurationOfProject';
+		versionString: '1.0';
+		loads: #('MyPackage');
+		preLoadDoIt: #preLoadDoIt;
+		postLoadDoIt: #postLoadDoIt;
+		yourself.
+	projectB := self projectSpec
+		name: 'Project';
+		className: 'ConfigurationOfProjectB';
+		versionString: #stable;
+		operator: #<;
+		loads: #('MyPackage' 'MyTests');
+		preLoadDoIt: #preLoadDoItB;
+		postLoadDoIt: #postLoadDoItB;
+		yourself.
+	project := projectA mergeSpec: projectB.
+	self assert: project name equals: 'Project'.
+	self assert: project className equals: 'ConfigurationOfProjectB'.
+	self assert: project versionString equals: #stable.
+	self assert: project operator identicalTo: #<.
+	self assert: project loads equals: #('MyPackage' 'MyTests').
+	self assert: project preLoadDoIt value identicalTo: #preLoadDoItB.
+	self assert: project postLoadDoIt value identicalTo: #postLoadDoItB
 ]
 
 { #category : #tests }
 MetacelloProjectSpecTestCase >> testProjectSpec [
-    | project |
-    project := self projectSpec.
-    project
-        name: 'Project';
-        className: 'ConfigurationOfProject';
-        versionString: '1.0';
-        versionString: #'stable';
-        operator: #'<';
-        operator: nil;
-        loads: 'MyPackage';
-        loads: #('MyPackage' 'MyTests');
-        preLoadDoIt: #'preLoadDoIt';
-        postLoadDoIt: #'postLoadDoIt';
-        yourself.
-    self assert: project name = 'Project'.
-    self assert: project className = 'ConfigurationOfProject'.
-    self assert: project versionString = #'stable'.
-    self assert: project operator == #'>='.
-    self assert: project loads = #('MyPackage' 'MyTests').
-    self assert: project preLoadDoIt value == #'preLoadDoIt'.
-    self assert: project postLoadDoIt value == #'postLoadDoIt'.
-    self should: [ project includes: #() ] raise: Error.
-    self should: [ project requires: #() ] raise: Error.
-    self should: [ project answers: #() ] raise: Error.
-    project
-        projectDo: [ :prjct | self assert: project == prjct ]
-        packageDo: [ :ignored | self assert: false ]
-        groupDo: [ :ignored | self assert: false ].
-    self should: [ project preLoadDoIt: '' ] raise: Error.
-    self should: [ project postLoadDoIt: '' ] raise: Error
+	| project |
+	project := self projectSpec.
+	project
+		name: 'Project';
+		className: 'ConfigurationOfProject';
+		versionString: '1.0';
+		versionString: #stable;
+		operator: #<;
+		operator: nil;
+		loads: 'MyPackage';
+		loads: #('MyPackage' 'MyTests');
+		preLoadDoIt: #preLoadDoIt;
+		postLoadDoIt: #postLoadDoIt;
+		yourself.
+	self assert: project name equals: 'Project'.
+	self assert: project className equals: 'ConfigurationOfProject'.
+	self assert: project versionString equals: #stable.
+	self assert: project operator identicalTo: #>=.
+	self assert: project loads equals: #('MyPackage' 'MyTests').
+	self assert: project preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: project postLoadDoIt value identicalTo: #postLoadDoIt.
+	self should: [ project includes: #() ] raise: Error.
+	self should: [ project requires: #() ] raise: Error.
+	self should: [ project answers: #() ] raise: Error.
+	project projectDo: [ :prjct | self assert: project identicalTo: prjct ] packageDo: [ :ignored | self assert: false ] groupDo: [ :ignored | self assert: false ].
+	self should: [ project preLoadDoIt: '' ] raise: Error.
+	self should: [ project postLoadDoIt: '' ] raise: Error
 ]
diff --git a/src/Metacello-TestsCore/MetacelloSemanticVersionNumberTestCase.class.st b/src/Metacello-TestsCore/MetacelloSemanticVersionNumberTestCase.class.st
index 24f745ca6ed..57fc1e14341 100644
--- a/src/Metacello-TestsCore/MetacelloSemanticVersionNumberTestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloSemanticVersionNumberTestCase.class.st
@@ -15,9 +15,9 @@ MetacelloSemanticVersionNumberTestCase >> sampleVersionStrings [
 
 { #category : #tests }
 MetacelloSemanticVersionNumberTestCase >> testEqualityComparison [
-    self deny: '1.0.0+-' asMetacelloSemanticVersionNumber = '1.0.0--' asMetacelloSemanticVersionNumber.
-    self sampleVersionStrings
-        do: [ :versionString | self assert: versionString asMetacelloSemanticVersionNumber = versionString asMetacelloSemanticVersionNumber ]
+	self deny: '1.0.0+-' asMetacelloSemanticVersionNumber equals: '1.0.0--' asMetacelloSemanticVersionNumber.
+	self sampleVersionStrings
+		do: [ :versionString | self assert: versionString asMetacelloSemanticVersionNumber equals: versionString asMetacelloSemanticVersionNumber ]
 ]
 
 { #category : #'test matching' }
@@ -48,9 +48,9 @@ MetacelloSemanticVersionNumberTestCase >> testLessThanComparison [
 
 { #category : #tests }
 MetacelloSemanticVersionNumberTestCase >> testPrinting [
-    | x vrsn |
-    self sampleVersionStrings
-        do: [ :versionString | self assert: versionString = (x := (vrsn := versionString asMetacelloSemanticVersionNumber) printString) ]
+	| x vrsn |
+	self sampleVersionStrings
+		do: [ :versionString | self assert: versionString equals: (x := (vrsn := versionString asMetacelloSemanticVersionNumber) printString) ]
 ]
 
 { #category : #tests }
@@ -152,15 +152,12 @@ MetacelloSemanticVersionNumberTestCase >> testVersion09 [
 
 { #category : #tests }
 MetacelloSemanticVersionNumberTestCase >> testVersion10 [
-    | x y |
-    self
-        assert:
-            (x := (({(self versionClass fromString: '1.0.0').
-            (self versionClass fromString: '0.7.0').
-            (self versionClass fromString: '0.8.0').
-            (self versionClass fromString: '0.9.0').
-            (self versionClass fromString: '1.0.1')} sort: [ :a :b | a <= b ]) collect: [ :each | each versionString ])
-                asArray) = (y := #('0.7.0' '0.8.0' '0.9.0' '1.0.0' '1.0.1'))
+	| x y |
+	self
+		assert:
+			(x := (({(self versionClass fromString: '1.0.0') . (self versionClass fromString: '0.7.0') . (self versionClass fromString: '0.8.0').
+			(self versionClass fromString: '0.9.0') . (self versionClass fromString: '1.0.1')} sort: [ :a :b | a <= b ]) collect: [ :each | each versionString ]) asArray)
+		equals: (y := #('0.7.0' '0.8.0' '0.9.0' '1.0.0' '1.0.1'))
 ]
 
 { #category : #tests }
diff --git a/src/Metacello-TestsCore/MetacelloStackCacheTestCase.class.st b/src/Metacello-TestsCore/MetacelloStackCacheTestCase.class.st
index bb9c017d080..dca629c3697 100644
--- a/src/Metacello-TestsCore/MetacelloStackCacheTestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloStackCacheTestCase.class.st
@@ -102,44 +102,37 @@ MetacelloStackCacheTestCase >> mixedStackCall [
 
 { #category : #tests }
 MetacelloStackCacheTestCase >> testCacheNil [
-
 	| x |
-	self assert: (x := self cacheNil) == nil
+	self assert: (x := self cacheNil) identicalTo: nil
 ]
 
 { #category : #tests }
 MetacelloStackCacheTestCase >> testCachedReturn [
-
 	| x |
-	self assert: (x := self cachedReturnOfValue) == 6
+	self assert: (x := self cachedReturnOfValue) identicalTo: 6
 ]
 
 { #category : #tests }
 MetacelloStackCacheTestCase >> testClearCache [
-
-	MetacelloPlatform current 
+	MetacelloPlatform current
 		stackCacheFor: #cached
-		at: #key 
-		doing: [:cache | | value |
+		at: #key
+		doing: [ :cache | 
+			| value |
 			cache at: #x put: 1.
-			self assert: (cache at: #x ifAbsent: []) == 1.
+			self assert: (cache at: #x ifAbsent: [  ]) identicalTo: 1.
 			MetacelloClearStackCacheNotification signal.
-			self assert: (cache at: #x ifAbsent: []) == nil ]
-
+			self assert: (cache at: #x ifAbsent: [  ]) identicalTo: nil ]
 ]
 
 { #category : #tests }
 MetacelloStackCacheTestCase >> testCollectionCacheKey [
-
 	| x |
-	self assert: 
-		(Array with: self class with: (Array with: 'faux' with: 'foobar'))
-			= (Array with: self class with: (Array with: 'faux' with: 'foobar')).
-	self deny: 
-		(Array with: self class with: (Array with: 'faux' with: 'foobar'))
-			= (Array with: self class with: (Array with: 'faux' with: 'foobar' with: 'foobaz')).
-	self assert: (x := self collectionCacheKey) == 6.
-
+	self assert: (Array with: self class with: (Array with: 'faux' with: 'foobar')) equals: (Array with: self class with: (Array with: 'faux' with: 'foobar')).
+	self
+		deny: (Array with: self class with: (Array with: 'faux' with: 'foobar'))
+		equals: (Array with: self class with: (Array with: 'faux' with: 'foobar' with: 'foobaz')).
+	self assert: (x := self collectionCacheKey) identicalTo: 6
 ]
 
 { #category : #tests }
@@ -168,60 +161,56 @@ MetacelloStackCacheTestCase >> testDefaultDictionary [
 
 { #category : #tests }
 MetacelloStackCacheTestCase >> testDirectReturn [
-
 	| x |
-	self assert: (x := self directReturnOfValue) == 6
+	self assert: (x := self directReturnOfValue) identicalTo: 6
 ]
 
 { #category : #tests }
 MetacelloStackCacheTestCase >> testMixedStack [
-
 	| x |
-	self assert: (x := self mixedStack) == 4
+	self assert: (x := self mixedStack) identicalTo: 4
 ]
 
 { #category : #tests }
 MetacelloStackCacheTestCase >> testPrimeStackCache [
-
 	| cached collection cacheNil direct mixed mixedStack block defaultDictionary |
 	defaultDictionary := Dictionary new.
-	block := [ 
-		cached := Dictionary new.
-		collection := Dictionary new.
-		cacheNil := Dictionary new.
-		direct := Dictionary new.
-		mixed := Dictionary new.
-		mixedStack := Dictionary new.
-		MetacelloPlatform current useStackCacheDuring: [ :dict | self cachedReturnOfValue ] defaultDictionary: cached.
-		MetacelloPlatform current useStackCacheDuring: [ :dict | self collectionCacheKey ] defaultDictionary: collection.
-		MetacelloPlatform current useStackCacheDuring: [ :dict | self cacheNil ] defaultDictionary: cacheNil.
-		MetacelloPlatform current useStackCacheDuring: [ :dict | self directReturnOfValue ] defaultDictionary: direct.
-		MetacelloPlatform current useStackCacheDuring: [ :dict | self mixedStack ] defaultDictionary: mixed.
-		MetacelloPlatform current useStackCacheDuring: [ :dict | self mixedStackCall ] defaultDictionary: mixedStack ].	
+	block := [ cached := Dictionary new.
+	collection := Dictionary new.
+	cacheNil := Dictionary new.
+	direct := Dictionary new.
+	mixed := Dictionary new.
+	mixedStack := Dictionary new.
+	MetacelloPlatform current useStackCacheDuring: [ :dict | self cachedReturnOfValue ] defaultDictionary: cached.
+	MetacelloPlatform current useStackCacheDuring: [ :dict | self collectionCacheKey ] defaultDictionary: collection.
+	MetacelloPlatform current useStackCacheDuring: [ :dict | self cacheNil ] defaultDictionary: cacheNil.
+	MetacelloPlatform current useStackCacheDuring: [ :dict | self directReturnOfValue ] defaultDictionary: direct.
+	MetacelloPlatform current useStackCacheDuring: [ :dict | self mixedStack ] defaultDictionary: mixed.
+	MetacelloPlatform current useStackCacheDuring: [ :dict | self mixedStackCall ] defaultDictionary: mixedStack ].
 
 	"Test without priming stack cache ... each defaultDictionary is used independently"
 	block value.
-	self assert: ((cached at: #cached) at: #key) == 6.
-	self assert: ((collection at: #collection) at: #x) == 6.
-	self assert: ((cacheNil at: #cacheNil) at: #key) == nil.
-	self assert: ((direct at: #direct) at: #x) == 6.
-	self assert: ((mixed at: #cached) at: #key) == 6.
-	self assert: ((mixed at: #mixed) at: #x) == 4.
-	self assert: ((mixed at: #mixedStack) at: #x) == 4.
-	self assert: ((mixed at: #direct) at: #x) == 6.
-	self assert: ((mixedStack at: #cached) at: #key) == 6.
-	self assert: ((mixedStack at: #mixedStack) at: #x) == 4.	
+	self assert: ((cached at: #cached) at: #key) identicalTo: 6.
+	self assert: ((collection at: #collection) at: #x) identicalTo: 6.
+	self assert: ((cacheNil at: #cacheNil) at: #key) identicalTo: nil.
+	self assert: ((direct at: #direct) at: #x) identicalTo: 6.
+	self assert: ((mixed at: #cached) at: #key) identicalTo: 6.
+	self assert: ((mixed at: #mixed) at: #x) identicalTo: 4.
+	self assert: ((mixed at: #mixedStack) at: #x) identicalTo: 4.
+	self assert: ((mixed at: #direct) at: #x) identicalTo: 6.
+	self assert: ((mixedStack at: #cached) at: #key) identicalTo: 6.
+	self assert: ((mixedStack at: #mixedStack) at: #x) identicalTo: 4.
 
 	"Prime stack cache with defaultDictionary .... all values should be stored there instead of individual defaults."
 	MetacelloPlatform current primeStackCacheWith: defaultDictionary doing: block.
-	self assert: ((defaultDictionary at: #cached) at: #key) == 6.
-	self assert: ((defaultDictionary at: #collection) at: #x) == 6.
-	self assert: ((defaultDictionary at: #cacheNil) at: #key) == nil.
-	self assert: ((defaultDictionary at: #direct) at: #x) == 6.
-	self assert: ((defaultDictionary at: #cached) at: #key) == 6.
-	self assert: ((defaultDictionary at: #mixed) at: #x) == 4.
-	self assert: ((defaultDictionary at: #mixedStack) at: #x) == 4.
-	self assert: ((defaultDictionary at: #direct) at: #x) == 6.
-	self assert: ((defaultDictionary at: #cached) at: #key) == 6.
-	self assert: ((defaultDictionary at: #mixedStack) at: #x) == 4
+	self assert: ((defaultDictionary at: #cached) at: #key) identicalTo: 6.
+	self assert: ((defaultDictionary at: #collection) at: #x) identicalTo: 6.
+	self assert: ((defaultDictionary at: #cacheNil) at: #key) identicalTo: nil.
+	self assert: ((defaultDictionary at: #direct) at: #x) identicalTo: 6.
+	self assert: ((defaultDictionary at: #cached) at: #key) identicalTo: 6.
+	self assert: ((defaultDictionary at: #mixed) at: #x) identicalTo: 4.
+	self assert: ((defaultDictionary at: #mixedStack) at: #x) identicalTo: 4.
+	self assert: ((defaultDictionary at: #direct) at: #x) identicalTo: 6.
+	self assert: ((defaultDictionary at: #cached) at: #key) identicalTo: 6.
+	self assert: ((defaultDictionary at: #mixedStack) at: #x) identicalTo: 4
 ]
diff --git a/src/Metacello-TestsCore/MetacelloValueHolderSpecTestCase.class.st b/src/Metacello-TestsCore/MetacelloValueHolderSpecTestCase.class.st
index b623e6c582f..28192770735 100644
--- a/src/Metacello-TestsCore/MetacelloValueHolderSpecTestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloValueHolderSpecTestCase.class.st
@@ -6,22 +6,22 @@ Class {
 
 { #category : #tests }
 MetacelloValueHolderSpecTestCase >> testValueHolderMergeSpec [
-    | valueHolderA valueHolderB valueHolder |
-    valueHolderA := self valueHolderSpec
-        value: 'an Object';
-        yourself.
-    valueHolderB := self valueHolderSpec
-        value: 1.1;
-        yourself.
-    valueHolder := valueHolderA mergeSpec: valueHolderB.
-    self assert: valueHolder value = 1.1
+	| valueHolderA valueHolderB valueHolder |
+	valueHolderA := self valueHolderSpec
+		value: 'an Object';
+		yourself.
+	valueHolderB := self valueHolderSpec
+		value: 1.1;
+		yourself.
+	valueHolder := valueHolderA mergeSpec: valueHolderB.
+	self assert: valueHolder value equals: 1.1
 ]
 
 { #category : #tests }
 MetacelloValueHolderSpecTestCase >> testValueHolderSpec [
-    | valueHolder |
-    valueHolder := self valueHolderSpec
-        value: 'an Object';
-        yourself.
-    self assert: valueHolder value = 'an Object'
+	| valueHolder |
+	valueHolder := self valueHolderSpec
+		value: 'an Object';
+		yourself.
+	self assert: valueHolder value equals: 'an Object'
 ]
diff --git a/src/Metacello-TestsCore/MetacelloVersionNumberTestCase.class.st b/src/Metacello-TestsCore/MetacelloVersionNumberTestCase.class.st
index 2de71c4a6c8..19947997117 100644
--- a/src/Metacello-TestsCore/MetacelloVersionNumberTestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloVersionNumberTestCase.class.st
@@ -24,29 +24,27 @@ MetacelloVersionNumberTestCase >> testApproxVersion03 [
 
 { #category : #tests }
 MetacelloVersionNumberTestCase >> testCollapseZeros [
-
-	self assert: (MetacelloVersionNumber fromString: '1.0-beta.24.0.1') collapseZeros printString = '1-beta.24.0.1'.
-	self assert: (MetacelloVersionNumber fromString: '1.0-beta.24.0.0.1') collapseZeros printString = '1-beta.24.0.0.1'.
-	self assert: (MetacelloVersionNumber fromString: '1.0.0-beta.24.0.0.1') collapseZeros printString = '1-beta.24.0.0.1'.
-
+	self assert: (MetacelloVersionNumber fromString: '1.0-beta.24.0.1') collapseZeros printString equals: '1-beta.24.0.1'.
+	self assert: (MetacelloVersionNumber fromString: '1.0-beta.24.0.0.1') collapseZeros printString equals: '1-beta.24.0.0.1'.
+	self assert: (MetacelloVersionNumber fromString: '1.0.0-beta.24.0.0.1') collapseZeros printString equals: '1-beta.24.0.0.1'
 ]
 
 { #category : #'tests version increment/decrement' }
 MetacelloVersionNumberTestCase >> testIncrementDecrementVersionNumber [
-  | version |
-  super testIncrementDecrementVersionNumber.
-  version := '1' asMetacelloVersionNumber.
-  self assert: version incrementMinorVersionNumber asString = '2'.
-  self assert: version decrementMinorVersionNumber asString = '1'.
-  version := '1.0' asMetacelloVersionNumber.
-  self assert: version incrementMinorVersionNumber asString = '1.1'.
-  self assert: version decrementMinorVersionNumber asString = '1.0'.
-  version := '1.0.0' asMetacelloVersionNumber.
-  self assert: version incrementMinorVersionNumber asString = '1.0.1'.
-  self assert: version decrementMinorVersionNumber asString = '1.0.0'.
-  version := '1.0.0.0' asMetacelloVersionNumber.
-  self assert: version incrementMinorVersionNumber asString = '1.0.0.1'.
-  self assert: version decrementMinorVersionNumber asString = '1.0.0.0'
+	| version |
+	super testIncrementDecrementVersionNumber.
+	version := '1' asMetacelloVersionNumber.
+	self assert: version incrementMinorVersionNumber asString equals: '2'.
+	self assert: version decrementMinorVersionNumber asString equals: '1'.
+	version := '1.0' asMetacelloVersionNumber.
+	self assert: version incrementMinorVersionNumber asString equals: '1.1'.
+	self assert: version decrementMinorVersionNumber asString equals: '1.0'.
+	version := '1.0.0' asMetacelloVersionNumber.
+	self assert: version incrementMinorVersionNumber asString equals: '1.0.1'.
+	self assert: version decrementMinorVersionNumber asString equals: '1.0.0'.
+	version := '1.0.0.0' asMetacelloVersionNumber.
+	self assert: version incrementMinorVersionNumber asString equals: '1.0.0.1'.
+	self assert: version decrementMinorVersionNumber asString equals: '1.0.0.0'
 ]
 
 { #category : #'test matching' }
@@ -145,15 +143,12 @@ MetacelloVersionNumberTestCase >> testVersion09 [
 
 { #category : #tests }
 MetacelloVersionNumberTestCase >> testVersion10 [
-
 	| x y |
-	self assert: ((x := (({
-		self versionClass fromString: '1.0'.
-		self versionClass fromString: '0.7'.
-		self versionClass fromString: '0.8'.
-		self versionClass fromString: '0.9'.
-		self versionClass fromString: '1.0.1'
-	} sort: [:a :b | a <= b ]) collect: [:each | each versionString ]) asArray) = (y := #( '0.7' '0.8' '0.9' '1.0' '1.0.1')))
+	self
+		assert:
+			(x := (({(self versionClass fromString: '1.0') . (self versionClass fromString: '0.7') . (self versionClass fromString: '0.8').
+			(self versionClass fromString: '0.9') . (self versionClass fromString: '1.0.1')} sort: [ :a :b | a <= b ]) collect: [ :each | each versionString ]) asArray)
+		equals: (y := #('0.7' '0.8' '0.9' '1.0' '1.0.1'))
 ]
 
 { #category : #tests }
@@ -196,14 +191,12 @@ MetacelloVersionNumberTestCase >> testVersion16 [
 
 { #category : #tests }
 MetacelloVersionNumberTestCase >> testVersion17 [
-
-	self assert: ((self versionClass fromString: '1.0') = (self versionClass fromString: '1.0.0')).
-	self assert: ((self versionClass fromString: '1') = (self versionClass fromString: '1.0')).
-	self assert: ((self versionClass fromString: '1') > (self versionClass fromString: '1-0')).
-	self assert: ((self versionClass fromString: '1') > (self versionClass fromString: '1.0-beta.0')).
-	self assert: ((self versionClass fromString: '1') > (self versionClass fromString: '1-beta.0')).
-	self assert: ((self versionClass fromString: '1') > (self versionClass fromString: '1-beta')).
-
+	self assert: (self versionClass fromString: '1.0') equals: (self versionClass fromString: '1.0.0').
+	self assert: (self versionClass fromString: '1') equals: (self versionClass fromString: '1.0').
+	self assert: (self versionClass fromString: '1') > (self versionClass fromString: '1-0').
+	self assert: (self versionClass fromString: '1') > (self versionClass fromString: '1.0-beta.0').
+	self assert: (self versionClass fromString: '1') > (self versionClass fromString: '1-beta.0').
+	self assert: (self versionClass fromString: '1') > (self versionClass fromString: '1-beta')
 ]
 
 { #category : #tests }
@@ -223,29 +216,21 @@ MetacelloVersionNumberTestCase >> testVersion19 [
 
 { #category : #tests }
 MetacelloVersionNumberTestCase >> testVersion20 [
-
-	self assert: (MetacelloVersionNumber fromString: '') printString = ''.
-
+	self assert: (MetacelloVersionNumber fromString: '') printString equals: ''
 ]
 
 { #category : #tests }
 MetacelloVersionNumberTestCase >> testVersion21 [
-
 	self deny: (MetacelloVersionNumber fromString: '') > (MetacelloVersionNumber fromString: '0').
 	self assert: (MetacelloVersionNumber fromString: '') < (MetacelloVersionNumber fromString: '0').
-	self assert: (MetacelloVersionNumber fromString: '') = (MetacelloVersionNumber fromString: '').
-
-
+	self assert: (MetacelloVersionNumber fromString: '') equals: (MetacelloVersionNumber fromString: '')
 ]
 
 { #category : #tests }
 MetacelloVersionNumberTestCase >> testVersion24 [
-
 	self assert: (MetacelloVersionNumber fromString: '3.0.3.-rc.1') ~= (MetacelloVersionNumber fromString: '3.0.0.3-rc.1').
-	self assert: (MetacelloVersionNumber fromString: '1.0.0.1.0.0') = (MetacelloVersionNumber fromString: '1.0.0.1').
-	self assert: (MetacelloVersionNumber fromString: '1.0.0.1') ~= (MetacelloVersionNumber fromString: '1..1').
-
-
+	self assert: (MetacelloVersionNumber fromString: '1.0.0.1.0.0') equals: (MetacelloVersionNumber fromString: '1.0.0.1').
+	self assert: (MetacelloVersionNumber fromString: '1.0.0.1') ~= (MetacelloVersionNumber fromString: '1..1')
 ]
 
 { #category : #private }
diff --git a/src/Metacello-TestsCore/MetacelloVersionSpecTestCase.class.st b/src/Metacello-TestsCore/MetacelloVersionSpecTestCase.class.st
index 5792426eaeb..22d3f3f2918 100644
--- a/src/Metacello-TestsCore/MetacelloVersionSpecTestCase.class.st
+++ b/src/Metacello-TestsCore/MetacelloVersionSpecTestCase.class.st
@@ -6,77 +6,77 @@ Class {
 
 { #category : #tests }
 MetacelloVersionSpecTestCase >> testVersionMergeSpec [
-    | versionA versionB version |
-    versionA := self versionSpec
-        blessing: #'baseline';
-        versionString: '1.0';
-        description: 'A description';
-        author: 'dkh';
-        timestamp: '1/24/2012 09:59';
-        preLoadDoIt: #'preLoadDoIt';
-        postLoadDoIt: #'postLoadDoIt';
-        yourself.
-    versionB := self versionSpec
-        blessing: #'release';
-        versionString: '1.1';
-        description: 'A FULL description';
-        author: 'DaleHenrichs';
-        timestamp: '1/24/2012 10:22';
-        preLoadDoIt: #'preLoadDoItB';
-        postLoadDoIt: #'postLoadDoItB';
-        yourself.
-    version := versionA mergeSpec: versionB.
-    self assert: version blessing value = #'release'.
-    self assert: version versionString value = '1.1'.
-    self assert: version description value = 'A FULL description'.
-    self assert: version author value = 'DaleHenrichs'.
-    self assert: version timestamp value = '1/24/2012 10:22'.
-    self assert: version preLoadDoIt value == #'preLoadDoItB'.
-    self assert: version postLoadDoIt value == #'postLoadDoItB'
+	| versionA versionB version |
+	versionA := self versionSpec
+		blessing: #baseline;
+		versionString: '1.0';
+		description: 'A description';
+		author: 'dkh';
+		timestamp: '1/24/2012 09:59';
+		preLoadDoIt: #preLoadDoIt;
+		postLoadDoIt: #postLoadDoIt;
+		yourself.
+	versionB := self versionSpec
+		blessing: #release;
+		versionString: '1.1';
+		description: 'A FULL description';
+		author: 'DaleHenrichs';
+		timestamp: '1/24/2012 10:22';
+		preLoadDoIt: #preLoadDoItB;
+		postLoadDoIt: #postLoadDoItB;
+		yourself.
+	version := versionA mergeSpec: versionB.
+	self assert: version blessing value equals: #release.
+	self assert: version versionString value equals: '1.1'.
+	self assert: version description value equals: 'A FULL description'.
+	self assert: version author value equals: 'DaleHenrichs'.
+	self assert: version timestamp value equals: '1/24/2012 10:22'.
+	self assert: version preLoadDoIt value identicalTo: #preLoadDoItB.
+	self assert: version postLoadDoIt value identicalTo: #postLoadDoItB
 ]
 
 { #category : #tests }
 MetacelloVersionSpecTestCase >> testVersionSpec [
-    | version |
-    version := self versionSpec
-        blessing: #'baseline';
-        versionString: '1.0';
-        description: 'A description';
-        author: 'dkh';
-        timestamp: '1/24/2012 09:59';
-        preLoadDoIt: #'preLoadDoIt';
-        postLoadDoIt: #'postLoadDoIt';
-        yourself.
-    self assert: version blessing value = #'baseline'.
-    self assert: version versionString value = '1.0'.
-    self assert: version description value = 'A description'.
-    self assert: version author value = 'dkh'.
-    self assert: version timestamp value = '1/24/2012 09:59'.
-    self assert: version preLoadDoIt value == #'preLoadDoIt'.
-    self assert: version postLoadDoIt value == #'postLoadDoIt'.
-    self should: [ version preLoadDoIt: '' ] raise: Error.
-    self should: [ version postLoadDoIt: '' ] raise: Error
+	| version |
+	version := self versionSpec
+		blessing: #baseline;
+		versionString: '1.0';
+		description: 'A description';
+		author: 'dkh';
+		timestamp: '1/24/2012 09:59';
+		preLoadDoIt: #preLoadDoIt;
+		postLoadDoIt: #postLoadDoIt;
+		yourself.
+	self assert: version blessing value equals: #baseline.
+	self assert: version versionString value equals: '1.0'.
+	self assert: version description value equals: 'A description'.
+	self assert: version author value equals: 'dkh'.
+	self assert: version timestamp value equals: '1/24/2012 09:59'.
+	self assert: version preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: version postLoadDoIt value identicalTo: #postLoadDoIt.
+	self should: [ version preLoadDoIt: '' ] raise: Error.
+	self should: [ version postLoadDoIt: '' ] raise: Error
 ]
 
 { #category : #tests }
 MetacelloVersionSpecTestCase >> testVersionSpecCreateVersion [
-    | spec version |
-    spec := self versionSpec
-        blessing: #'baseline';
-        versionString: '1.0';
-        description: 'A description';
-        author: 'dkh';
-        timestamp: '1/24/2012 09:59';
-        preLoadDoIt: #'preLoadDoIt';
-        postLoadDoIt: #'postLoadDoIt';
-        yourself.
-    version := spec createVersion.
-    self assert: version class == spec versionClass.
-    self assert: version spec == spec.
-    self assert: version versionNumber asString = '1.0'.
-    self assert: version blessing = #'baseline'.
-    self assert: version versionString = '1.0'.
-    self assert: version description = 'A description'.
-    self assert: version author = 'dkh'.
-    self assert: version timestamp = '1/24/2012 09:59'
+	| spec version |
+	spec := self versionSpec
+		blessing: #baseline;
+		versionString: '1.0';
+		description: 'A description';
+		author: 'dkh';
+		timestamp: '1/24/2012 09:59';
+		preLoadDoIt: #preLoadDoIt;
+		postLoadDoIt: #postLoadDoIt;
+		yourself.
+	version := spec createVersion.
+	self assert: version class identicalTo: spec versionClass.
+	self assert: version spec identicalTo: spec.
+	self assert: version versionNumber asString equals: '1.0'.
+	self assert: version blessing equals: #baseline.
+	self assert: version versionString equals: '1.0'.
+	self assert: version description equals: 'A description'.
+	self assert: version author equals: 'dkh'.
+	self assert: version timestamp equals: '1/24/2012 09:59'
 ]
diff --git a/src/Metacello-TestsMCCore/MetacelloMCPackagesSpecTestCase.class.st b/src/Metacello-TestsMCCore/MetacelloMCPackagesSpecTestCase.class.st
index f8e6297a8d7..7cc225d61cd 100644
--- a/src/Metacello-TestsMCCore/MetacelloMCPackagesSpecTestCase.class.st
+++ b/src/Metacello-TestsMCCore/MetacelloMCPackagesSpecTestCase.class.st
@@ -11,72 +11,71 @@ MetacelloMCPackagesSpecTestCase >> projectClass [
 
 { #category : #tests }
 MetacelloMCPackagesSpecTestCase >> testAddPackageA [
-    "used by MetacelloAbstractVersionConstructor>>package: and MetacelloAbstractVersionConstructor>>package:overrides:"
+	"used by MetacelloAbstractVersionConstructor>>package: and MetacelloAbstractVersionConstructor>>package:overrides:"
 
-    | packages package |
-    packages := self packagesSpec.
-    packages
-        add:
-            (self packageSpec
-                name: 'Package';
-                requires: 'AnotherPackage';
-                includes: 'IncludedPackage';
-                answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
-                file: 'Package-dkh.1';
-                preLoadDoIt: #'preLoadDoIt';
-                postLoadDoIt: #'postLoadDoIt';
-                yourself).
-    packages
-        add:
-            (self packageSpec
-                name: 'Package';
-                requires: 'AndAnotherPackage';
-                includes: 'AndIncludedPackage';
-                answers: #(#('postload' 'postload answer'));
-                file: 'Package-dkh.2';
-                yourself).
-    package := packages packageNamed: 'Package' ifAbsent: [ self assert: false ].
-    self assert: package name = 'Package'.
-    self assert: package requires = #('AndAnotherPackage').
-    self assert: package includes = #('AndIncludedPackage').
-    self assert: package answers = #(#('postload' 'postload answer')).
-    self assert: package file = 'Package-dkh.2'.
-    self assert: package preLoadDoIt value == nil.
-    self assert: package postLoadDoIt value == nil
+	| packages package |
+	packages := self packagesSpec.
+	packages
+		add:
+			(self packageSpec
+				name: 'Package';
+				requires: 'AnotherPackage';
+				includes: 'IncludedPackage';
+				answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
+				file: 'Package-dkh.1';
+				preLoadDoIt: #preLoadDoIt;
+				postLoadDoIt: #postLoadDoIt;
+				yourself).
+	packages
+		add:
+			(self packageSpec
+				name: 'Package';
+				requires: 'AndAnotherPackage';
+				includes: 'AndIncludedPackage';
+				answers: #(#('postload' 'postload answer'));
+				file: 'Package-dkh.2';
+				yourself).
+	package := packages packageNamed: 'Package' ifAbsent: [ self assert: false ].
+	self assert: package name equals: 'Package'.
+	self assert: package requires equals: #('AndAnotherPackage').
+	self assert: package includes equals: #('AndIncludedPackage').
+	self assert: package answers equals: #(#('postload' 'postload answer')).
+	self assert: package file equals: 'Package-dkh.2'.
+	self assert: package preLoadDoIt value identicalTo: nil.
+	self assert: package postLoadDoIt value identicalTo: nil
 ]
 
 { #category : #tests }
 MetacelloMCPackagesSpecTestCase >> testAddPackageB [
-    "used by MetacelloAbstractVersionConstructor>>package: and MetacelloAbstractVersionConstructor>>package:overrides:"
+	"used by MetacelloAbstractVersionConstructor>>package: and MetacelloAbstractVersionConstructor>>package:overrides:"
 
-    | packages package |
-    packages := self packagesSpec.
-    packages
-        add:
-            {(self packageSpec
-                name: 'Package';
-                requires: 'AnotherPackage';
-                includes: 'IncludedPackage';
-                answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
-                file: 'Package-dkh.1';
-                preLoadDoIt: #'preLoadDoIt';
-                postLoadDoIt: #'postLoadDoIt';
-                yourself).
-            (self packageSpec
-                name: 'Package';
-                requires: 'AndAnotherPackage';
-                includes: 'AndIncludedPackage';
-                answers: #(#('postload' 'postload answer'));
-                file: 'Package-dkh.2';
-                yourself)}.
-    package := packages packageNamed: 'Package' ifAbsent: [ self assert: false ].
-    self assert: package name = 'Package'.
-    self assert: package requires = #('AndAnotherPackage').
-    self assert: package includes = #('AndIncludedPackage').
-    self assert: package answers = #(#('postload' 'postload answer')).
-    self assert: package file = 'Package-dkh.2'.
-    self assert: package preLoadDoIt value == nil.
-    self assert: package postLoadDoIt value == nil
+	| packages package |
+	packages := self packagesSpec.
+	packages
+		add:
+			{(self packageSpec
+				name: 'Package';
+				requires: 'AnotherPackage';
+				includes: 'IncludedPackage';
+				answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
+				file: 'Package-dkh.1';
+				preLoadDoIt: #preLoadDoIt;
+				postLoadDoIt: #postLoadDoIt;
+				yourself) . (self packageSpec
+				name: 'Package';
+				requires: 'AndAnotherPackage';
+				includes: 'AndIncludedPackage';
+				answers: #(#('postload' 'postload answer'));
+				file: 'Package-dkh.2';
+				yourself)}.
+	package := packages packageNamed: 'Package' ifAbsent: [ self assert: false ].
+	self assert: package name equals: 'Package'.
+	self assert: package requires equals: #('AndAnotherPackage').
+	self assert: package includes equals: #('AndIncludedPackage').
+	self assert: package answers equals: #(#('postload' 'postload answer')).
+	self assert: package file equals: 'Package-dkh.2'.
+	self assert: package preLoadDoIt value identicalTo: nil.
+	self assert: package postLoadDoIt value identicalTo: nil
 ]
 
 { #category : #tests }
@@ -107,111 +106,107 @@ MetacelloMCPackagesSpecTestCase >> testAddPackageD [
 
 { #category : #tests }
 MetacelloMCPackagesSpecTestCase >> testCopyToPackage [
-    "not currently used by MetacelloAbstractVersionConstructor"
+	"not currently used by MetacelloAbstractVersionConstructor"
 
-    | packages package |
-    packages := self packagesSpec.
-    packages
-        add:
-            (self packageSpec
-                name: 'Package';
-                requires: 'AnotherPackage';
-                includes: 'IncludedPackage';
-                answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
-                file: 'Package-dkh.1';
-                preLoadDoIt: #'preLoadDoIt';
-                postLoadDoIt: #'postLoadDoIt';
-                yourself).
-    packages
-        copy: 'Package'
-        to:
-            (self packageSpec
-                name: 'PackageCopy';
-                yourself).
-    package := packages packageNamed: 'PackageCopy' ifAbsent: [ self assert: false ].
-    self assert: package name = 'PackageCopy'.
-    self assert: package requires = #('AnotherPackage').
-    self assert: package includes = #('IncludedPackage').
-    self assert: package answers = #(#('preload' 'preload answer') #('postload' 'postload answer')).
-    self assert: package file = 'Package-dkh.1'.
-    self assert: package preLoadDoIt value == #'preLoadDoIt'.
-    self assert: package postLoadDoIt value == #'postLoadDoIt'
+	| packages package |
+	packages := self packagesSpec.
+	packages
+		add:
+			(self packageSpec
+				name: 'Package';
+				requires: 'AnotherPackage';
+				includes: 'IncludedPackage';
+				answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
+				file: 'Package-dkh.1';
+				preLoadDoIt: #preLoadDoIt;
+				postLoadDoIt: #postLoadDoIt;
+				yourself).
+	packages
+		copy: 'Package'
+		to:
+			(self packageSpec
+				name: 'PackageCopy';
+				yourself).
+	package := packages packageNamed: 'PackageCopy' ifAbsent: [ self assert: false ].
+	self assert: package name equals: 'PackageCopy'.
+	self assert: package requires equals: #('AnotherPackage').
+	self assert: package includes equals: #('IncludedPackage').
+	self assert: package answers equals: #(#('preload' 'preload answer') #('postload' 'postload answer')).
+	self assert: package file equals: 'Package-dkh.1'.
+	self assert: package preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: package postLoadDoIt value identicalTo: #postLoadDoIt
 ]
 
 { #category : #tests }
 MetacelloMCPackagesSpecTestCase >> testMergePackageA [
-    "used by MetacelloAbstractVersionConstructor>>package:with:"
+	"used by MetacelloAbstractVersionConstructor>>package:with:"
 
-    | packages package |
-    packages := self packagesSpec.
-    packages
-        add:
-            (self packageSpec
-                name: 'Package';
-                requires: 'AnotherPackage';
-                includes: 'IncludedPackage';
-                answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
-                file: 'Package-dkh.1';
-                preLoadDoIt: #'preLoadDoIt';
-                postLoadDoIt: #'postLoadDoIt';
-                yourself).
-    packages
-        merge:
-            (self packageSpec
-                name: 'Package';
-                requires: 'AndAnotherPackage';
-                includes: 'AndIncludedPackage';
-                answers: #(#('xpostload' 'xpostload answer'));
-                file: 'Package-dkh.2';
-                yourself).
-    package := packages packageNamed: 'Package' ifAbsent: [ self assert: false ].
-    self assert: package name = 'Package'.
-    self assert: package requires = #('AnotherPackage' 'AndAnotherPackage').
-    self assert: package includes = #('IncludedPackage' 'AndIncludedPackage').
-    self
-        assert:
-            package answers = #(#('preload' 'preload answer') #('postload' 'postload answer') #('xpostload' 'xpostload answer')).
-    self assert: package file = 'Package-dkh.2'.
-    self assert: package preLoadDoIt value == #'preLoadDoIt'.
-    self assert: package postLoadDoIt value == #'postLoadDoIt'
+	| packages package |
+	packages := self packagesSpec.
+	packages
+		add:
+			(self packageSpec
+				name: 'Package';
+				requires: 'AnotherPackage';
+				includes: 'IncludedPackage';
+				answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
+				file: 'Package-dkh.1';
+				preLoadDoIt: #preLoadDoIt;
+				postLoadDoIt: #postLoadDoIt;
+				yourself).
+	packages
+		merge:
+			(self packageSpec
+				name: 'Package';
+				requires: 'AndAnotherPackage';
+				includes: 'AndIncludedPackage';
+				answers: #(#('xpostload' 'xpostload answer'));
+				file: 'Package-dkh.2';
+				yourself).
+	package := packages packageNamed: 'Package' ifAbsent: [ self assert: false ].
+	self assert: package name equals: 'Package'.
+	self assert: package requires equals: #('AnotherPackage' 'AndAnotherPackage').
+	self assert: package includes equals: #('IncludedPackage' 'AndIncludedPackage').
+	self assert: package answers equals: #(#('preload' 'preload answer') #('postload' 'postload answer') #('xpostload' 'xpostload answer')).
+	self assert: package file equals: 'Package-dkh.2'.
+	self assert: package preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: package postLoadDoIt value identicalTo: #postLoadDoIt
 ]
 
 { #category : #tests }
 MetacelloMCPackagesSpecTestCase >> testMergePackageB [
-    "used by MetacelloAbstractVersionConstructor>>package:with:"
+	"used by MetacelloAbstractVersionConstructor>>package:with:"
 
-    | packages package |
-    packages := self packagesSpec.
-    packages
-        add:
-            (self packageSpec
-                name: 'Package';
-                requires: 'AnotherPackage';
-                includes: 'IncludedPackage';
-                answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
-                file: 'Package-dkh.1';
-                preLoadDoIt: #'preLoadDoIt';
-                postLoadDoIt: #'postLoadDoIt';
-                yourself).
-    packages
-        merge:
-            {(self packageSpec
-                name: 'Package';
-                requires: 'AndAnotherPackage';
-                includes: 'AndIncludedPackage';
-                answers: #(#('xpostload' 'xpostload answer'));
-                file: 'Package-dkh.2';
-                yourself)}.
-    package := packages packageNamed: 'Package' ifAbsent: [ self assert: false ].
-    self assert: package name = 'Package'.
-    self assert: package requires = #('AnotherPackage' 'AndAnotherPackage').
-    self assert: package includes = #('IncludedPackage' 'AndIncludedPackage').
-    self
-        assert:
-            package answers = #(#('preload' 'preload answer') #('postload' 'postload answer') #('xpostload' 'xpostload answer')).
-    self assert: package file = 'Package-dkh.2'.
-    self assert: package preLoadDoIt value == #'preLoadDoIt'.
-    self assert: package postLoadDoIt value == #'postLoadDoIt'
+	| packages package |
+	packages := self packagesSpec.
+	packages
+		add:
+			(self packageSpec
+				name: 'Package';
+				requires: 'AnotherPackage';
+				includes: 'IncludedPackage';
+				answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
+				file: 'Package-dkh.1';
+				preLoadDoIt: #preLoadDoIt;
+				postLoadDoIt: #postLoadDoIt;
+				yourself).
+	packages
+		merge:
+			{(self packageSpec
+				name: 'Package';
+				requires: 'AndAnotherPackage';
+				includes: 'AndIncludedPackage';
+				answers: #(#('xpostload' 'xpostload answer'));
+				file: 'Package-dkh.2';
+				yourself)}.
+	package := packages packageNamed: 'Package' ifAbsent: [ self assert: false ].
+	self assert: package name equals: 'Package'.
+	self assert: package requires equals: #('AnotherPackage' 'AndAnotherPackage').
+	self assert: package includes equals: #('IncludedPackage' 'AndIncludedPackage').
+	self assert: package answers equals: #(#('preload' 'preload answer') #('postload' 'postload answer') #('xpostload' 'xpostload answer')).
+	self assert: package file equals: 'Package-dkh.2'.
+	self assert: package preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: package postLoadDoIt value identicalTo: #postLoadDoIt
 ]
 
 { #category : #tests }
diff --git a/src/Metacello-TestsMCCore/MetacelloMCProjectSpecTestCase.class.st b/src/Metacello-TestsMCCore/MetacelloMCProjectSpecTestCase.class.st
index fe39aba69be..f7df3a1944f 100644
--- a/src/Metacello-TestsMCCore/MetacelloMCProjectSpecTestCase.class.st
+++ b/src/Metacello-TestsMCCore/MetacelloMCProjectSpecTestCase.class.st
@@ -11,55 +11,55 @@ MetacelloMCProjectSpecTestCase >> projectClass [
 
 { #category : #tests }
 MetacelloMCProjectSpecTestCase >> testMCProjectMergeSpec [
-    | projectA projectB project repository |
-    projectA := self projectSpec
-        name: 'Project';
-        projectPackage: self project packageSpec;
-        className: 'ConfigurationOfProject';
-        repository: 'http://example.com/repository' username: 'dkh' password: 'password';
-        repository: '/opt/gemstone/repository';
-        yourself.
-    projectB := self projectSpec
-        name: 'Project';
-        projectPackage: self project packageSpec;
-        className: 'ConfigurationOfProjectB';
-        repository: 'http://example.com/repository' username: 'DaleHenrichs' password: 'secret';
-        repository: '/opt/gemstone/repo';
-        yourself.
-    project := projectA mergeSpec: projectB.
-    self assert: project name = 'Project'.
-    self assert: project className = 'ConfigurationOfProjectB'.
-    self assert: project projectPackage name = project className.
-    self assert: project projectPackage file = project className.
-    repository := project repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'directory'.
-    repository := project repositories map at: '/opt/gemstone/repo' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'directory'.
-    repository := project repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'http'.
-    self assert: repository username = 'DaleHenrichs'.
-    self assert: repository password = 'secret'
+	| projectA projectB project repository |
+	projectA := self projectSpec
+		name: 'Project';
+		projectPackage: self project packageSpec;
+		className: 'ConfigurationOfProject';
+		repository: 'http://example.com/repository' username: 'dkh' password: 'password';
+		repository: '/opt/gemstone/repository';
+		yourself.
+	projectB := self projectSpec
+		name: 'Project';
+		projectPackage: self project packageSpec;
+		className: 'ConfigurationOfProjectB';
+		repository: 'http://example.com/repository' username: 'DaleHenrichs' password: 'secret';
+		repository: '/opt/gemstone/repo';
+		yourself.
+	project := projectA mergeSpec: projectB.
+	self assert: project name equals: 'Project'.
+	self assert: project className equals: 'ConfigurationOfProjectB'.
+	self assert: project projectPackage name equals: project className.
+	self assert: project projectPackage file equals: project className.
+	repository := project repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'directory'.
+	repository := project repositories map at: '/opt/gemstone/repo' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'directory'.
+	repository := project repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'DaleHenrichs'.
+	self assert: repository password equals: 'secret'
 ]
 
 { #category : #tests }
 MetacelloMCProjectSpecTestCase >> testMCProjectSpec [
-    | project repository |
-    project := self projectSpec.
-    project
-        name: 'Project';
-        projectPackage: self project packageSpec;
-        className: 'ConfigurationOfProject';
-        repository: 'http://example.com/repository' username: 'dkh' password: 'password';
-        repository: '/opt/gemstone/repository';
-        yourself.
-    self assert: project name = 'Project'.
-    self assert: project className = 'ConfigurationOfProject'.
-    self assert: project projectPackage name = project className.
-    self assert: project projectPackage file = project className.
-    repository := project repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'directory'.
-    repository := project repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'http'.
-    self assert: repository username = 'dkh'.
-    self assert: repository password = 'password'
+	| project repository |
+	project := self projectSpec.
+	project
+		name: 'Project';
+		projectPackage: self project packageSpec;
+		className: 'ConfigurationOfProject';
+		repository: 'http://example.com/repository' username: 'dkh' password: 'password';
+		repository: '/opt/gemstone/repository';
+		yourself.
+	self assert: project name equals: 'Project'.
+	self assert: project className equals: 'ConfigurationOfProject'.
+	self assert: project projectPackage name equals: project className.
+	self assert: project projectPackage file equals: project className.
+	repository := project repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'directory'.
+	repository := project repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'dkh'.
+	self assert: repository password equals: 'password'
 ]
diff --git a/src/Metacello-TestsMCCore/MetacelloMCVersionSpecTestCase.class.st b/src/Metacello-TestsMCCore/MetacelloMCVersionSpecTestCase.class.st
index 0ee1ae925f9..49fceb69278 100644
--- a/src/Metacello-TestsMCCore/MetacelloMCVersionSpecTestCase.class.st
+++ b/src/Metacello-TestsMCCore/MetacelloMCVersionSpecTestCase.class.st
@@ -11,172 +11,150 @@ MetacelloMCVersionSpecTestCase >> projectClass [
 
 { #category : #tests }
 MetacelloMCVersionSpecTestCase >> testMCVersionMergeSpec [
-    | versionA versionB version repository package group projectReferenceSpec |
-    versionA := self versionSpec
-        blessing: #'baseline';
-        versionString: '1.0';
-        repository: 'http://example.com/repository' username: 'dkh' password: 'password';
-        repository: '/opt/gemstone/repository';
-        yourself.
-    versionA packages
-        merge:
-                (self packageSpec
-                        name: 'Package';
-                        requires: 'AnotherPackage';
-                        yourself);
-        merge:
-                (self groupSpec
-                        name: 'Platform';
-                        includes: 'Core';
-                        yourself);
-        merge:
-                (self projectReferenceSpec
-                        name: 'Project';
-                        projectReference:
-                                (self projectSpec
-                                        name: 'Project';
-                                        projectPackage: self project packageSpec;
-                                        className: 'ConfigurationOfProjectA';
-                                        repository: 'http://example.com/repository'
-                                            username: 'dkh'
-                                            password: 'password';
-                                        repository: '/opt/gemstone/repository';
-                                        yourself));
-        yourself.
-    versionB := self versionSpec
-        blessing: #'release';
-        versionString: '1.1';
-        repository: 'http://example.com/repository' username: 'DaleHenrichs' password: 'secret';
-        repository: '/opt/gemstone/repo';
-        yourself.
-    versionB packages
-        merge:
-                (self packageSpec
-                        name: 'Package';
-                        requires: 'AndAnotherPackage';
-                        yourself);
-        merge:
-                (self groupSpec
-                        name: 'Platform';
-                        includes: 'Tests';
-                        yourself);
-        merge:
-                (self projectReferenceSpec
-                        name: 'Project';
-                        projectReference:
-                                (self projectSpec
-                                        name: 'Project';
-                                        projectPackage: self project packageSpec;
-                                        className: 'ConfigurationOfProjectA';
-                                        repository: 'http://example.com/repository'
-                                            username: 'DaleHenrichs'
-                                            password: 'secret';
-                                        repository: '/opt/gemstone/repo';
-                                        yourself));
-        yourself.
-    version := versionA mergeSpec: versionB.
-    self assert: version blessing value = #'release'.
-    self assert: version versionString value = '1.1'.
-    repository := version repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'directory'.
-    repository := version repositories map at: '/opt/gemstone/repo' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'directory'.
-    repository := version repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'http'.
-    self assert: repository username = 'DaleHenrichs'.
-    self assert: repository password = 'secret'.
-    package := version packages packageNamed: 'Package' ifAbsent: [ self assert: false ].
-    self assert: package name = 'Package'.
-    projectReferenceSpec := version packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
-    self assert: projectReferenceSpec projectName = 'Project'.
-    repository := projectReferenceSpec repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'directory'.
-    repository := projectReferenceSpec repositories map at: '/opt/gemstone/repo' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'directory'.
-    repository := projectReferenceSpec repositories map
-        at: 'http://example.com/repository'
-        ifAbsent: [ self assert: false ].
-    self assert: repository type = 'http'.
-    self assert: repository username = 'DaleHenrichs'.
-    self assert: repository password = 'secret'.
-    group := version packages packageNamed: 'Platform' ifAbsent: [ self assert: false ].
-    self assert: (group includes includes: 'Core').
-    self assert: (group includes includes: 'Tests')
+	| versionA versionB version repository package group projectReferenceSpec |
+	versionA := self versionSpec
+		blessing: #baseline;
+		versionString: '1.0';
+		repository: 'http://example.com/repository' username: 'dkh' password: 'password';
+		repository: '/opt/gemstone/repository';
+		yourself.
+	versionA packages
+		merge:
+			(self packageSpec
+				name: 'Package';
+				requires: 'AnotherPackage';
+				yourself);
+		merge:
+			(self groupSpec
+				name: 'Platform';
+				includes: 'Core';
+				yourself);
+		merge:
+			(self projectReferenceSpec
+				name: 'Project';
+				projectReference:
+					(self projectSpec
+						name: 'Project';
+						projectPackage: self project packageSpec;
+						className: 'ConfigurationOfProjectA';
+						repository: 'http://example.com/repository' username: 'dkh' password: 'password';
+						repository: '/opt/gemstone/repository';
+						yourself));
+		yourself.
+	versionB := self versionSpec
+		blessing: #release;
+		versionString: '1.1';
+		repository: 'http://example.com/repository' username: 'DaleHenrichs' password: 'secret';
+		repository: '/opt/gemstone/repo';
+		yourself.
+	versionB packages
+		merge:
+			(self packageSpec
+				name: 'Package';
+				requires: 'AndAnotherPackage';
+				yourself);
+		merge:
+			(self groupSpec
+				name: 'Platform';
+				includes: 'Tests';
+				yourself);
+		merge:
+			(self projectReferenceSpec
+				name: 'Project';
+				projectReference:
+					(self projectSpec
+						name: 'Project';
+						projectPackage: self project packageSpec;
+						className: 'ConfigurationOfProjectA';
+						repository: 'http://example.com/repository' username: 'DaleHenrichs' password: 'secret';
+						repository: '/opt/gemstone/repo';
+						yourself));
+		yourself.
+	version := versionA mergeSpec: versionB.
+	self assert: version blessing value equals: #release.
+	self assert: version versionString value equals: '1.1'.
+	repository := version repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'directory'.
+	repository := version repositories map at: '/opt/gemstone/repo' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'directory'.
+	repository := version repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'DaleHenrichs'.
+	self assert: repository password equals: 'secret'.
+	package := version packages packageNamed: 'Package' ifAbsent: [ self assert: false ].
+	self assert: package name equals: 'Package'.
+	projectReferenceSpec := version packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
+	self assert: projectReferenceSpec projectName equals: 'Project'.
+	repository := projectReferenceSpec repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'directory'.
+	repository := projectReferenceSpec repositories map at: '/opt/gemstone/repo' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'directory'.
+	repository := projectReferenceSpec repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'DaleHenrichs'.
+	self assert: repository password equals: 'secret'.
+	group := version packages packageNamed: 'Platform' ifAbsent: [ self assert: false ].
+	self assert: (group includes includes: 'Core').
+	self assert: (group includes includes: 'Tests')
 ]
 
 { #category : #tests }
 MetacelloMCVersionSpecTestCase >> testMCVersionSpec [
-  | version projectReferenceSpec group package repository |
-  version := self versionSpec
-    blessing: #'baseline';
-    versionString: '1.0';
-    repository: 'http://example.com/repository'
-      username: 'dkh'
-      password: 'password';
-    repository: '/opt/gemstone/repository';
-    yourself.
-  version packages
-    add:
-        (self packageSpec
-            name: 'Package';
-            requires: 'AnotherPackage';
-            includes: 'IncludedPackage';
-            answers:
-                #(#('preload' 'preload answer') #('postload' 'postload answer'));
-            file: 'Package-dkh.1';
-            preLoadDoIt: #'preLoadDoIt';
-            postLoadDoIt: #'postLoadDoIt';
-            yourself);
-    add:
-        (self packageSpec
-            name: 'AnotherPackage';
-            yourself);
-    add:
-        (self packageSpec
-            name: 'IncludedPackage';
-            yourself);
-    add:
-        (self groupSpec
-            name: 'Platform';
-            includes: 'Core';
-            yourself);
-    add:
-        (self projectSpec
-            name: 'Project';
-            className: 'ConfigurationOfProjectA';
-            versionString: #'stable';
-            loads: #('MyPackage' 'MyTests');
-            preLoadDoIt: #'preLoadDoItB';
-            postLoadDoIt: #'postLoadDoItB';
-            yourself);
-    yourself.
-  self assert: version blessing value = #'baseline'.
-  self assert: version versionString value = '1.0'.
-  repository := version repositories map
-    at: '/opt/gemstone/repository'
-    ifAbsent: [ self assert: false ].
-  self assert: repository type = 'directory'.
-  repository := version repositories map
-    at: 'http://example.com/repository'
-    ifAbsent: [ self assert: false ].
-  self assert: repository type = 'http'.
-  self assert: repository username = 'dkh'.
-  self assert: repository password = 'password'.
-  package := version packages
-    packageNamed: 'Package'
-    ifAbsent: [ self assert: false ].
-  self assert: package name = 'Package'.
-  group := version packages
-    packageNamed: 'Platform'
-    ifAbsent: [ self assert: false ].
-  self assert: (group includes includes: 'Core').
-  projectReferenceSpec := version packages
-    packageNamed: 'Project'
-    ifAbsent: [ self assert: false ].
-  self assert: projectReferenceSpec projectName = 'Project'.
-  self assert: projectReferenceSpec versionString = #'stable'.
-  version
-    projectDo: [ :prjct | prjct == projectReferenceSpec ]
-    packageDo: [ :pkg | pkg == package ]
-    groupDo: [ :grp | grp == group ]
+	| version projectReferenceSpec group package repository |
+	version := self versionSpec
+		blessing: #baseline;
+		versionString: '1.0';
+		repository: 'http://example.com/repository' username: 'dkh' password: 'password';
+		repository: '/opt/gemstone/repository';
+		yourself.
+	version packages
+		add:
+			(self packageSpec
+				name: 'Package';
+				requires: 'AnotherPackage';
+				includes: 'IncludedPackage';
+				answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
+				file: 'Package-dkh.1';
+				preLoadDoIt: #preLoadDoIt;
+				postLoadDoIt: #postLoadDoIt;
+				yourself);
+		add:
+			(self packageSpec
+				name: 'AnotherPackage';
+				yourself);
+		add:
+			(self packageSpec
+				name: 'IncludedPackage';
+				yourself);
+		add:
+			(self groupSpec
+				name: 'Platform';
+				includes: 'Core';
+				yourself);
+		add:
+			(self projectSpec
+				name: 'Project';
+				className: 'ConfigurationOfProjectA';
+				versionString: #stable;
+				loads: #('MyPackage' 'MyTests');
+				preLoadDoIt: #preLoadDoItB;
+				postLoadDoIt: #postLoadDoItB;
+				yourself);
+		yourself.
+	self assert: version blessing value equals: #baseline.
+	self assert: version versionString value equals: '1.0'.
+	repository := version repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'directory'.
+	repository := version repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'dkh'.
+	self assert: repository password equals: 'password'.
+	package := version packages packageNamed: 'Package' ifAbsent: [ self assert: false ].
+	self assert: package name equals: 'Package'.
+	group := version packages packageNamed: 'Platform' ifAbsent: [ self assert: false ].
+	self assert: (group includes includes: 'Core').
+	projectReferenceSpec := version packages packageNamed: 'Project' ifAbsent: [ self assert: false ].
+	self assert: projectReferenceSpec projectName equals: 'Project'.
+	self assert: projectReferenceSpec versionString equals: #stable.
+	version projectDo: [ :prjct | prjct == projectReferenceSpec ] packageDo: [ :pkg | pkg == package ] groupDo: [ :grp | grp == group ]
 ]
diff --git a/src/Metacello-TestsMCCore/MetacelloPackageSpecTestCase.class.st b/src/Metacello-TestsMCCore/MetacelloPackageSpecTestCase.class.st
index 4697d0ee436..cdefd68a97b 100644
--- a/src/Metacello-TestsMCCore/MetacelloPackageSpecTestCase.class.st
+++ b/src/Metacello-TestsMCCore/MetacelloPackageSpecTestCase.class.st
@@ -11,73 +11,71 @@ MetacelloPackageSpecTestCase >> projectClass [
 
 { #category : #tests }
 MetacelloPackageSpecTestCase >> testPackageMergeSpec [
-    | packageA packageB package repository |
-    packageA := self packageSpec
-        name: 'Package';
-        name: 'Package';
-        requires: 'AnotherPackage';
-        includes: 'IncludedPackage';
-        answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
-        file: 'Package-dkh.1';
-        preLoadDoIt: #'preLoadDoIt';
-        postLoadDoIt: #'postLoadDoIt';
-        repository: 'http://example.com/repository' username: 'dkh' password: 'password';
-        repository: '/opt/gemstone/repository';
-        yourself.
-    packageB := self packageSpec
-        name: 'Package';
-        requires: 'AndAnotherPackage';
-        includes: 'AndIncludedPackage';
-        answers: #(#('xpostload' 'xpostload answer'));
-        file: 'Package-dkh.2';
-        repository: 'http://example.com/repository' username: 'DaleHenrichs' password: 'secret';
-        repository: '/opt/gemstone/repo';
-        yourself.
-    package := packageA mergeSpec: packageB.
-    self assert: package name = 'Package'.
-    self assert: package requires = #('AnotherPackage' 'AndAnotherPackage').
-    self assert: package includes = #('IncludedPackage' 'AndIncludedPackage').
-    self
-        assert:
-            package answers = #(#('preload' 'preload answer') #('postload' 'postload answer') #('xpostload' 'xpostload answer')).
-    self assert: package file = 'Package-dkh.2'.
-    self assert: package preLoadDoIt value == #'preLoadDoIt'.
-    self assert: package postLoadDoIt value == #'postLoadDoIt'.
-    repository := package repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'directory'.
-    repository := package repositories map at: '/opt/gemstone/repo' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'directory'.
-    repository := package repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'http'.
-    self assert: repository username = 'DaleHenrichs'.
-    self assert: repository password = 'secret'
+	| packageA packageB package repository |
+	packageA := self packageSpec
+		name: 'Package';
+		name: 'Package';
+		requires: 'AnotherPackage';
+		includes: 'IncludedPackage';
+		answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
+		file: 'Package-dkh.1';
+		preLoadDoIt: #preLoadDoIt;
+		postLoadDoIt: #postLoadDoIt;
+		repository: 'http://example.com/repository' username: 'dkh' password: 'password';
+		repository: '/opt/gemstone/repository';
+		yourself.
+	packageB := self packageSpec
+		name: 'Package';
+		requires: 'AndAnotherPackage';
+		includes: 'AndIncludedPackage';
+		answers: #(#('xpostload' 'xpostload answer'));
+		file: 'Package-dkh.2';
+		repository: 'http://example.com/repository' username: 'DaleHenrichs' password: 'secret';
+		repository: '/opt/gemstone/repo';
+		yourself.
+	package := packageA mergeSpec: packageB.
+	self assert: package name equals: 'Package'.
+	self assert: package requires equals: #('AnotherPackage' 'AndAnotherPackage').
+	self assert: package includes equals: #('IncludedPackage' 'AndIncludedPackage').
+	self assert: package answers equals: #(#('preload' 'preload answer') #('postload' 'postload answer') #('xpostload' 'xpostload answer')).
+	self assert: package file equals: 'Package-dkh.2'.
+	self assert: package preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: package postLoadDoIt value identicalTo: #postLoadDoIt.
+	repository := package repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'directory'.
+	repository := package repositories map at: '/opt/gemstone/repo' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'directory'.
+	repository := package repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'DaleHenrichs'.
+	self assert: repository password equals: 'secret'
 ]
 
 { #category : #tests }
 MetacelloPackageSpecTestCase >> testPackageSpec [
-    | package repository |
-    package := self packageSpec
-        name: 'Package';
-        requires: 'AnotherPackage';
-        includes: 'IncludedPackage';
-        answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
-        file: 'Package-dkh.1';
-        preLoadDoIt: #'preLoadDoIt';
-        postLoadDoIt: #'postLoadDoIt';
-        repository: 'http://example.com/repository' username: 'dkh' password: 'password';
-        repository: '/opt/gemstone/repository';
-        yourself.
-    self assert: package name = 'Package'.
-    self assert: package requires = #('AnotherPackage').
-    self assert: package includes = #('IncludedPackage').
-    self assert: package answers = #(#('preload' 'preload answer') #('postload' 'postload answer')).
-    self assert: package file = 'Package-dkh.1'.
-    self assert: package preLoadDoIt value == #'preLoadDoIt'.
-    self assert: package postLoadDoIt value == #'postLoadDoIt'.
-    repository := package repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'directory'.
-    repository := package repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository type = 'http'.
-    self assert: repository username = 'dkh'.
-    self assert: repository password = 'password'
+	| package repository |
+	package := self packageSpec
+		name: 'Package';
+		requires: 'AnotherPackage';
+		includes: 'IncludedPackage';
+		answers: #(#('preload' 'preload answer') #('postload' 'postload answer'));
+		file: 'Package-dkh.1';
+		preLoadDoIt: #preLoadDoIt;
+		postLoadDoIt: #postLoadDoIt;
+		repository: 'http://example.com/repository' username: 'dkh' password: 'password';
+		repository: '/opt/gemstone/repository';
+		yourself.
+	self assert: package name equals: 'Package'.
+	self assert: package requires equals: #('AnotherPackage').
+	self assert: package includes equals: #('IncludedPackage').
+	self assert: package answers equals: #(#('preload' 'preload answer') #('postload' 'postload answer')).
+	self assert: package file equals: 'Package-dkh.1'.
+	self assert: package preLoadDoIt value identicalTo: #preLoadDoIt.
+	self assert: package postLoadDoIt value identicalTo: #postLoadDoIt.
+	repository := package repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'directory'.
+	repository := package repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'dkh'.
+	self assert: repository password equals: 'password'
 ]
diff --git a/src/Metacello-TestsMCCore/MetacelloRepositoriesSpecTestCase.class.st b/src/Metacello-TestsMCCore/MetacelloRepositoriesSpecTestCase.class.st
index a7626061b9f..d49cce3b2f8 100644
--- a/src/Metacello-TestsMCCore/MetacelloRepositoriesSpecTestCase.class.st
+++ b/src/Metacello-TestsMCCore/MetacelloRepositoriesSpecTestCase.class.st
@@ -11,100 +11,100 @@ MetacelloRepositoriesSpecTestCase >> projectClass [
 
 { #category : #tests }
 MetacelloRepositoriesSpecTestCase >> testAddA [
-    | repositories repository |
-    repositories := self repositoriesSpec.
-    repositories
-        add:
-                (self repositorySpec
-                        description: 'http://example.com/repository';
-                        username: 'dkh';
-                        password: 'password';
-                        yourself);
-        add:
-                (self repositorySpec
-                        description: 'http://example.com/repository';
-                        username: 'DaleHenrichs';
-                        password: 'secret';
-                        yourself).
-    repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository description = 'http://example.com/repository'.
-    self assert: repository type = 'http'.
-    self assert: repository username = 'DaleHenrichs'.
-    self assert: repository password = 'secret'
+	| repositories repository |
+	repositories := self repositoriesSpec.
+	repositories
+		add:
+			(self repositorySpec
+				description: 'http://example.com/repository';
+				username: 'dkh';
+				password: 'password';
+				yourself);
+		add:
+			(self repositorySpec
+				description: 'http://example.com/repository';
+				username: 'DaleHenrichs';
+				password: 'secret';
+				yourself).
+	repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository description equals: 'http://example.com/repository'.
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'DaleHenrichs'.
+	self assert: repository password equals: 'secret'
 ]
 
 { #category : #tests }
 MetacelloRepositoriesSpecTestCase >> testAddB [
-    | repositories repository |
-    repositories := self repositoriesSpec.
-    repositories
-        add:
-                (self repositorySpec
-                        description: 'http://example.com/repository';
-                        username: 'dkh';
-                        password: 'password';
-                        yourself);
-        add: '/opt/gemstone/repository'.
-    repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository description = 'http://example.com/repository'.
-    self assert: repository type = 'http'.
-    self assert: repository username = 'dkh'.
-    self assert: repository password = 'password'.
-    repository := repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
-    self assert: repository description = '/opt/gemstone/repository'.
-    self assert: repository type = 'directory'
+	| repositories repository |
+	repositories := self repositoriesSpec.
+	repositories
+		add:
+			(self repositorySpec
+				description: 'http://example.com/repository';
+				username: 'dkh';
+				password: 'password';
+				yourself);
+		add: '/opt/gemstone/repository'.
+	repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository description equals: 'http://example.com/repository'.
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'dkh'.
+	self assert: repository password equals: 'password'.
+	repository := repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
+	self assert: repository description equals: '/opt/gemstone/repository'.
+	self assert: repository type equals: 'directory'
 ]
 
 { #category : #tests }
 MetacelloRepositoriesSpecTestCase >> testAddC [
-    | repositories repository |
-    repositories := self repositoriesSpec.
-    repositories add: #('http://example.com/repository' '/opt/gemstone/repository').
-    repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository description = 'http://example.com/repository'.
-    self assert: repository type = 'http'.
-    repository := repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
-    self assert: repository description = '/opt/gemstone/repository'.
-    self assert: repository type = 'directory'
+	| repositories repository |
+	repositories := self repositoriesSpec.
+	repositories add: #('http://example.com/repository' '/opt/gemstone/repository').
+	repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository description equals: 'http://example.com/repository'.
+	self assert: repository type equals: 'http'.
+	repository := repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
+	self assert: repository description equals: '/opt/gemstone/repository'.
+	self assert: repository type equals: 'directory'
 ]
 
 { #category : #tests }
 MetacelloRepositoriesSpecTestCase >> testAddE [
-    | repositories repository |
-    repositories := self repositoriesSpec.
-    repositories
-        repository: 'http://example.com/repository' username: 'dkh' password: 'password';
-        repository: '/opt/gemstone/repository'.
-    repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository description = 'http://example.com/repository'.
-    self assert: repository type = 'http'.
-    repository := repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
-    self assert: repository description = '/opt/gemstone/repository'.
-    self assert: repository type = 'directory'
+	| repositories repository |
+	repositories := self repositoriesSpec.
+	repositories
+		repository: 'http://example.com/repository' username: 'dkh' password: 'password';
+		repository: '/opt/gemstone/repository'.
+	repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository description equals: 'http://example.com/repository'.
+	self assert: repository type equals: 'http'.
+	repository := repositories map at: '/opt/gemstone/repository' ifAbsent: [ self assert: false ].
+	self assert: repository description equals: '/opt/gemstone/repository'.
+	self assert: repository type equals: 'directory'
 ]
 
 { #category : #tests }
 MetacelloRepositoriesSpecTestCase >> testAddF [
-    | repositories repository |
-    repositories := self repositoriesSpec.
-    repositories
-        repository:
-                (self repositorySpec
-                        description: 'http://example.com/repository';
-                        username: 'dkh';
-                        password: 'password';
-                        yourself);
-        repository:
-                (self repositorySpec
-                        description: 'http://example.com/repository';
-                        username: 'DaleHenrichs';
-                        password: 'secret';
-                        yourself).
-    repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository description = 'http://example.com/repository'.
-    self assert: repository type = 'http'.
-    self assert: repository username = 'DaleHenrichs'.
-    self assert: repository password = 'secret'
+	| repositories repository |
+	repositories := self repositoriesSpec.
+	repositories
+		repository:
+			(self repositorySpec
+				description: 'http://example.com/repository';
+				username: 'dkh';
+				password: 'password';
+				yourself);
+		repository:
+			(self repositorySpec
+				description: 'http://example.com/repository';
+				username: 'DaleHenrichs';
+				password: 'secret';
+				yourself).
+	repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository description equals: 'http://example.com/repository'.
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'DaleHenrichs'.
+	self assert: repository password equals: 'secret'
 ]
 
 { #category : #tests }
@@ -131,72 +131,71 @@ MetacelloRepositoriesSpecTestCase >> testCopyTo [
 
 { #category : #tests }
 MetacelloRepositoriesSpecTestCase >> testMergeA [
-    | repositories repository |
-    repositories := self repositoriesSpec.
-    repositories
-        add:
-                (self repositorySpec
-                        description: 'http://example.com/repository';
-                        username: 'dkh';
-                        password: 'password';
-                        yourself);
-        merge:
-                (self repositorySpec
-                        description: 'http://example.com/repository';
-                        username: 'DaleHenrichs';
-                        password: 'secret';
-                        yourself).
-    repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository description = 'http://example.com/repository'.
-    self assert: repository type = 'http'.
-    self assert: repository username = 'DaleHenrichs'.
-    self assert: repository password = 'secret'
+	| repositories repository |
+	repositories := self repositoriesSpec.
+	repositories
+		add:
+			(self repositorySpec
+				description: 'http://example.com/repository';
+				username: 'dkh';
+				password: 'password';
+				yourself);
+		merge:
+			(self repositorySpec
+				description: 'http://example.com/repository';
+				username: 'DaleHenrichs';
+				password: 'secret';
+				yourself).
+	repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository description equals: 'http://example.com/repository'.
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'DaleHenrichs'.
+	self assert: repository password equals: 'secret'
 ]
 
 { #category : #tests }
 MetacelloRepositoriesSpecTestCase >> testMergeB [
-    | repositories repository |
-    repositories := self repositoriesSpec.
-    repositories
-        add:
-                (self repositorySpec
-                        description: 'http://example.com/repository';
-                        username: 'dkh';
-                        password: 'password';
-                        yourself);
-        merge: 'http://example.com/repository'.
-    repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository description = 'http://example.com/repository'.
-    self assert: repository type = 'http'.
-    self assert: repository username = 'dkh'.
-    self assert: repository password = 'password'
+	| repositories repository |
+	repositories := self repositoriesSpec.
+	repositories
+		add:
+			(self repositorySpec
+				description: 'http://example.com/repository';
+				username: 'dkh';
+				password: 'password';
+				yourself);
+		merge: 'http://example.com/repository'.
+	repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository description equals: 'http://example.com/repository'.
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'dkh'.
+	self assert: repository password equals: 'password'
 ]
 
 { #category : #tests }
 MetacelloRepositoriesSpecTestCase >> testMergeC [
-    | repositories repository |
-    repositories := self repositoriesSpec.
-    repositories
-        add:
-                (self repositorySpec
-                        description: 'http://example.com/repository';
-                        username: 'dkh';
-                        password: 'password';
-                        yourself);
-        merge:
-                {(self repositorySpec
-                        description: 'http://example.com/repository';
-                        password: 'secret';
-                        yourself).
-                    (self repositorySpec
-                        description: 'http://example.com/repository';
-                        username: 'DaleHenrichs';
-                        yourself)}.
-    repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
-    self assert: repository description = 'http://example.com/repository'.
-    self assert: repository type = 'http'.
-    self assert: repository username = 'DaleHenrichs'.
-    self assert: repository password = 'secret'
+	| repositories repository |
+	repositories := self repositoriesSpec.
+	repositories
+		add:
+			(self repositorySpec
+				description: 'http://example.com/repository';
+				username: 'dkh';
+				password: 'password';
+				yourself);
+		merge:
+			{(self repositorySpec
+				description: 'http://example.com/repository';
+				password: 'secret';
+				yourself) . (self repositorySpec
+				description: 'http://example.com/repository';
+				username: 'DaleHenrichs';
+				yourself)}.
+	repository := repositories map at: 'http://example.com/repository' ifAbsent: [ self assert: false ].
+	self assert: repository description equals: 'http://example.com/repository'.
+	self assert: repository type equals: 'http'.
+	self assert: repository username equals: 'DaleHenrichs'.
+	self assert: repository password equals: 'secret'
 ]
 
 { #category : #tests }
diff --git a/src/Metacello-TestsMCCore/MetacelloRepositorySpecTestCase.class.st b/src/Metacello-TestsMCCore/MetacelloRepositorySpecTestCase.class.st
index ae5db38bcb1..26d6036861e 100644
--- a/src/Metacello-TestsMCCore/MetacelloRepositorySpecTestCase.class.st
+++ b/src/Metacello-TestsMCCore/MetacelloRepositorySpecTestCase.class.st
@@ -11,46 +11,46 @@ MetacelloRepositorySpecTestCase >> projectClass [
 
 { #category : #tests }
 MetacelloRepositorySpecTestCase >> testRepositoryMergeSpec [
-    | repositoryA repositoryB repository |
-    repositoryA := self repositorySpec
-        description: '/opt/gemstone/repository';
-        username: 'dkh';
-        password: 'password';
-        type: 'directory';
-        yourself.
-    repositoryB := self repositorySpec
-        description: 'http://example.com/repository';
-        password: 'secret';
-        yourself.
-    repository := repositoryA mergeSpec: repositoryB.
-    self assert: repository description = 'http://example.com/repository'.
-    self assert: repository username = 'dkh'.
-    self assert: repository password = 'secret'.
-    self assert: repository type = 'http'
+	| repositoryA repositoryB repository |
+	repositoryA := self repositorySpec
+		description: '/opt/gemstone/repository';
+		username: 'dkh';
+		password: 'password';
+		type: 'directory';
+		yourself.
+	repositoryB := self repositorySpec
+		description: 'http://example.com/repository';
+		password: 'secret';
+		yourself.
+	repository := repositoryA mergeSpec: repositoryB.
+	self assert: repository description equals: 'http://example.com/repository'.
+	self assert: repository username equals: 'dkh'.
+	self assert: repository password equals: 'secret'.
+	self assert: repository type equals: 'http'
 ]
 
 { #category : #tests }
 MetacelloRepositorySpecTestCase >> testRepositorySpec [
-    | repository |
-    repository := self repositorySpec
-        description: '/opt/gemstone/repository';
-        username: 'dkh';
-        password: 'password';
-        type: 'directory';
-        yourself.
-    self assert: repository name = repository description.
-    self assert: repository description = '/opt/gemstone/repository'.
-    self assert: repository username = 'dkh'.
-    self assert: repository password = 'password'.
-    self assert: repository type = 'directory'.
-    repository := self repositorySpec
-        description: '/opt/gemstone/repository';
-        yourself.
-    self assert: repository description = '/opt/gemstone/repository'.
-    self assert: repository type = 'directory'.
-    repository := self repositorySpec
-        description: 'http://example.com/repository';
-        yourself.
-    self assert: repository description = 'http://example.com/repository'.
-    self assert: repository type = 'http'
+	| repository |
+	repository := self repositorySpec
+		description: '/opt/gemstone/repository';
+		username: 'dkh';
+		password: 'password';
+		type: 'directory';
+		yourself.
+	self assert: repository name equals: repository description.
+	self assert: repository description equals: '/opt/gemstone/repository'.
+	self assert: repository username equals: 'dkh'.
+	self assert: repository password equals: 'password'.
+	self assert: repository type equals: 'directory'.
+	repository := self repositorySpec
+		description: '/opt/gemstone/repository';
+		yourself.
+	self assert: repository description equals: '/opt/gemstone/repository'.
+	self assert: repository type equals: 'directory'.
+	repository := self repositorySpec
+		description: 'http://example.com/repository';
+		yourself.
+	self assert: repository description equals: 'http://example.com/repository'.
+	self assert: repository type equals: 'http'
 ]
diff --git a/src/Metacello-TestsPlatform/MetacelloRepositorySqueakCommonTestCase.class.st b/src/Metacello-TestsPlatform/MetacelloRepositorySqueakCommonTestCase.class.st
index a04b2f600b8..233aa445181 100644
--- a/src/Metacello-TestsPlatform/MetacelloRepositorySqueakCommonTestCase.class.st
+++ b/src/Metacello-TestsPlatform/MetacelloRepositorySqueakCommonTestCase.class.st
@@ -125,109 +125,94 @@ MetacelloRepositorySqueakCommonTestCase >> tearDown [
 
 { #category : #tests }
 MetacelloRepositorySqueakCommonTestCase >> testAsRepositorySpecFor [
-    | project testBlock |
-    project := self project.
-    testBlock := [ :pkg :expectedType1 :expectedType2 | 
-    | repoSpec1 repo repoSpec2 |
-    repoSpec1 := pkg repositorySpecs first.
-    self assert: repoSpec1 type = expectedType1.
-    repo := repoSpec1 createRepository.
-    repoSpec2 := repo asRepositorySpecFor: project.
-    self assert: repoSpec2 type = expectedType2.
-    expectedType1 = expectedType2
-        ifTrue: [ self assert: repoSpec1 description = repoSpec2 description ]
-        ifFalse: [ 
-            "special case for standard directory type that defaults to MCServerDirectoryRepository"
-            self
-                assert:
-                    (repoSpec1 description copyFrom: 'server://' size + 1 to: repoSpec1 description size) = repoSpec2 description ] ].
-    testBlock
-        value: ((project version: '1.0-baseline') packageNamed: 'Example-Core')
-        value: 'directory'
-        value: 'directory'.
-    testBlock value: ((project version: '1.3-baseline') packageNamed: 'Example-Core') value: 'ftp' value: 'ftp'.
-    testBlock value: ((project version: '1.4-baseline') packageNamed: 'Example-Core') value: 'http' value: 'http'.
-    testBlock
-        value: ((project version: '1.5-baseline') packageNamed: 'Example-Core')
-        value: 'dictionary'
-        value: 'dictionary'
+	| project testBlock |
+	project := self project.
+	testBlock := [ :pkg :expectedType1 :expectedType2 | 
+	| repoSpec1 repo repoSpec2 |
+	repoSpec1 := pkg repositorySpecs first.
+	self assert: repoSpec1 type equals: expectedType1.
+	repo := repoSpec1 createRepository.
+	repoSpec2 := repo asRepositorySpecFor: project.
+	self assert: repoSpec2 type equals: expectedType2.
+	expectedType1 = expectedType2
+		ifTrue: [ self assert: repoSpec1 description equals: repoSpec2 description ]
+		ifFalse:
+			[ "special case for standard directory type that defaults to MCServerDirectoryRepository" self assert: (repoSpec1 description copyFrom: 'server://' size + 1 to: repoSpec1 description size) equals: repoSpec2 description ] ].
+	testBlock value: ((project version: '1.0-baseline') packageNamed: 'Example-Core') value: 'directory' value: 'directory'.
+	testBlock value: ((project version: '1.3-baseline') packageNamed: 'Example-Core') value: 'ftp' value: 'ftp'.
+	testBlock value: ((project version: '1.4-baseline') packageNamed: 'Example-Core') value: 'http' value: 'http'.
+	testBlock value: ((project version: '1.5-baseline') packageNamed: 'Example-Core') value: 'dictionary' value: 'dictionary'
 ]
 
 { #category : #tests }
 MetacelloRepositorySqueakCommonTestCase >> testDictionaryRepository [
-    | project pkg repoSpec repo |
-    project := self project.
-    pkg := (project version: '1.5-baseline') packageNamed: 'Example-Core'.
-    repoSpec := pkg repositorySpecs first.
-    self assert: repoSpec type = 'dictionary'.
-    repo := repoSpec createRepository.
-    self assert: repo class == MCDictionaryRepository.
-    self assert: repo dictionary == (testingEnvironment at: #'Metacello_Platform_Test_GlobalDictionary') dictionary
+	| project pkg repoSpec repo |
+	project := self project.
+	pkg := (project version: '1.5-baseline') packageNamed: 'Example-Core'.
+	repoSpec := pkg repositorySpecs first.
+	self assert: repoSpec type equals: 'dictionary'.
+	repo := repoSpec createRepository.
+	self assert: repo class identicalTo: MCDictionaryRepository.
+	self assert: repo dictionary identicalTo: (testingEnvironment at: #Metacello_Platform_Test_GlobalDictionary) dictionary
 ]
 
 { #category : #tests }
 MetacelloRepositorySqueakCommonTestCase >> testDirectoryRepository [
-    | project pkg repoSpec repo |
-    project := self project.
-    pkg := (project version: '1.0-baseline') packageNamed: 'Example-Core'.
-    repoSpec := pkg repositorySpecs first.
-    self assert: repoSpec type = 'directory'.
-    repo := repoSpec createRepository.
-    self assert: repo class == MCDirectoryRepository.
-    self assert: repo description = self directoryForPlatform
+	| project pkg repoSpec repo |
+	project := self project.
+	pkg := (project version: '1.0-baseline') packageNamed: 'Example-Core'.
+	repoSpec := pkg repositorySpecs first.
+	self assert: repoSpec type equals: 'directory'.
+	repo := repoSpec createRepository.
+	self assert: repo class identicalTo: MCDirectoryRepository.
+	self assert: repo description equals: self directoryForPlatform
 ]
 
 { #category : #tests }
 MetacelloRepositorySqueakCommonTestCase >> testFileTreeRepository [
-  "must create repository against an existing directory"
-
-  | project pkg repoSpec repo fileUtils workingDir tempDir repoDir |
-  fileUtils := MCFileTreeFileUtils current.
-  workingDir := fileUtils default.
-  tempDir := fileUtils directoryFromPath: 'temp' relativeTo: workingDir.
-  [ 
-  fileUtils ensureDirectoryExists: tempDir.
-  repoDir := fileUtils directoryFromPath: 'repo' relativeTo: tempDir.
-  fileUtils ensureDirectoryExists: repoDir.
-  project := self project.
-  pkg := (project version: '1.6-baseline') packageNamed: 'Example-Core'.
-  repoSpec := pkg repositorySpecs first.
-  self assert: repoSpec type = 'filetree'.
-  repo := repoSpec createRepository.
-  self
-    assert: repo class == (testingEnvironment at: #'MCFileTreeRepository' ifAbsent: [  ]).
-  Transcript cr; show: 'testFileTreeRepository: ', (fileUtils directoryFromPath: 'temp/repo' relativeTo: fileUtils default) fullName.
-  self
-    assert:
-      repo description  = ('filetree://' , (fileUtils directoryFromPath: 'temp/repo' relativeTo: fileUtils default) fullName )]
-    ensure: [ 
-      (fileUtils directoryExists: tempDir)
-        ifTrue: [ fileUtils deleteAll: tempDir ] ]
-
-
+	"must create repository against an existing directory"
+
+	| project pkg repoSpec repo fileUtils workingDir tempDir repoDir |
+	fileUtils := MCFileTreeFileUtils current.
+	workingDir := fileUtils default.
+	tempDir := fileUtils directoryFromPath: 'temp' relativeTo: workingDir.
+	[ fileUtils ensureDirectoryExists: tempDir.
+	repoDir := fileUtils directoryFromPath: 'repo' relativeTo: tempDir.
+	fileUtils ensureDirectoryExists: repoDir.
+	project := self project.
+	pkg := (project version: '1.6-baseline') packageNamed: 'Example-Core'.
+	repoSpec := pkg repositorySpecs first.
+	self assert: repoSpec type equals: 'filetree'.
+	repo := repoSpec createRepository.
+	self assert: repo class identicalTo: (testingEnvironment at: #MCFileTreeRepository ifAbsent: [  ]).
+	Transcript
+		cr;
+		show: 'testFileTreeRepository: ' , (fileUtils directoryFromPath: 'temp/repo' relativeTo: fileUtils default) fullName.
+	self assert: repo description equals: 'filetree://' , (fileUtils directoryFromPath: 'temp/repo' relativeTo: fileUtils default) fullName ]
+		ensure: [ (fileUtils directoryExists: tempDir) ifTrue: [ fileUtils deleteAll: tempDir ] ]
 ]
 
 { #category : #tests }
 MetacelloRepositorySqueakCommonTestCase >> testFtpRepository [
-    | project pkg repoSpec repo |
-    project := self project.
-    pkg := (project version: '1.3-baseline') packageNamed: 'Example-Core'.
-    repoSpec := pkg repositorySpecs first.
-    self assert: repoSpec type = 'ftp'.
-    repo := repoSpec createRepository.
-    self assert: repo class == MCFtpRepository.
-    self assert: repo host = 'ftp.example.com'.
-    self assert: repo directory = 'examples'
+	| project pkg repoSpec repo |
+	project := self project.
+	pkg := (project version: '1.3-baseline') packageNamed: 'Example-Core'.
+	repoSpec := pkg repositorySpecs first.
+	self assert: repoSpec type equals: 'ftp'.
+	repo := repoSpec createRepository.
+	self assert: repo class identicalTo: MCFtpRepository.
+	self assert: repo host equals: 'ftp.example.com'.
+	self assert: repo directory equals: 'examples'
 ]
 
 { #category : #tests }
 MetacelloRepositorySqueakCommonTestCase >> testHttpRepository [
-    | project pkg repoSpec repo |
-    project := self project.
-    pkg := (project version: '1.4-baseline') packageNamed: 'Example-Core'.
-    repoSpec := pkg repositorySpecs first.
-    self assert: repoSpec type = 'http'.
-    repo := repoSpec createRepository.
-    self assert: repo class == MCHttpRepository.
-    self assert: repo description = 'http://example.com/examples'
+	| project pkg repoSpec repo |
+	project := self project.
+	pkg := (project version: '1.4-baseline') packageNamed: 'Example-Core'.
+	repoSpec := pkg repositorySpecs first.
+	self assert: repoSpec type equals: 'http'.
+	repo := repoSpec createRepository.
+	self assert: repo class identicalTo: MCHttpRepository.
+	self assert: repo description equals: 'http://example.com/examples'
 ]
diff --git a/src/Metacello-TestsReference/MetacelloReferenceTestCase.class.st b/src/Metacello-TestsReference/MetacelloReferenceTestCase.class.st
index 38134542616..9545d81a550 100644
--- a/src/Metacello-TestsReference/MetacelloReferenceTestCase.class.st
+++ b/src/Metacello-TestsReference/MetacelloReferenceTestCase.class.st
@@ -104,12 +104,11 @@ spec
 
 { #category : #testing }
 MetacelloReferenceTestCase >> testReferenceConfig [
-
 	| spec map string expected |
 	spec := (MetacelloReferenceConfig project version: '1.0-baseline') spec.
 	map := spec packages map.
 	string := self conditionResult: (map at: 'Example-AddOn') printString.
-   	expected := 'spec 
+	expected := 'spec 
 	name: ''Example-AddOn'';
 	requires: #(''Example-Core'' ''UI Support'' );
 	includes: #(''Example-UI'' );
@@ -118,18 +117,24 @@ MetacelloReferenceTestCase >> testReferenceConfig [
 	repository: ''http://www.example.com/or'' username: ''foo'' password: ''bar'';
 	preLoadDoIt: #''preloadForAddOn'';
 	postLoadDoIt: #''postloadForAddOn''.'.
-	self assert: string = expected.
+	self assert: string equals: expected.
 
 	string := (map at: 'Example-Core') printString.
-  	self assert: string = 'spec name: ''Example-Core'''.
-	
+	self assert: string equals: 'spec name: ''Example-Core'''.
+
 	string := (map at: 'Example-TestsUI') printString.
-  	self assert: string =  'spec 
+	self
+		assert: string
+		equals:
+			'spec 
 	name: ''Example-TestsUI'';
 	requires: #(''Example-UI'' ).'.
 
 	string := (map at: 'UI Support') printString.
-  	self assert: string = 'spec 
+	self
+		assert: string
+		equals:
+			'spec 
 	name: ''UI Support'';
 	projectReference: [
 		spec
@@ -137,22 +142,19 @@ MetacelloReferenceTestCase >> testReferenceConfig [
 			versionString: ''1.0.1'';
 			operator: #''>='';
 			loads: #(''UI-Core'' ''UI-Tests'' );
-			repository: ''http://www.example.com/r'' username: ''foo'' password: ''bar'' ].'.
-
+			repository: ''http://www.example.com/r'' username: ''foo'' password: ''bar'' ].'
 ]
 
 { #category : #testing }
 MetacelloReferenceTestCase >> testReferenceConfigPrintString [
-
 	| version string expected x y |
 	version := MetacelloReferenceConfig project version: '1.0-baseline'.
 	string := self conditionResult: version spec printString.
 	expected := self expectedPrintString.
-	1 to: string size do: [: i |
+	1 to: string size do: [ :i | 
 		(i > expected size or: [ (string at: i) ~= (expected at: i) ])
-			ifTrue: [ 
-				x := string copyFrom: ((i- 25) max: 1) to: ((i + 25) min: string size).
-				y := expected copyFrom: (((i- 25) max: 1) min: expected size) to: ((i + 25) min: expected size).
-				(Array with: x with: y) "halt" ]].
-	self assert: string = expected
+			ifTrue: [ x := string copyFrom: (i - 25 max: 1) to: (i + 25 min: string size).
+				y := expected copyFrom: ((i - 25 max: 1) min: expected size) to: (i + 25 min: expected size).
+				Array with: x with: y	"halt" ] ].
+	self assert: string equals: expected
 ]
diff --git a/src/Monticello-Tests/MCAncestryTest.class.st b/src/Monticello-Tests/MCAncestryTest.class.st
index 573e753ed1b..4bb48ff530c 100644
--- a/src/Monticello-Tests/MCAncestryTest.class.st
+++ b/src/Monticello-Tests/MCAncestryTest.class.st
@@ -53,27 +53,20 @@ MCAncestryTest >> testCommonAncestors [
 MCAncestryTest >> testDescendants [
 	| c1 a1 b3 q1 q2 c2 |
 	c1 := self tree.
-	a1 := self treeFrom: #(a1 (('00'))).
-	b3 := self treeFrom: #(b3
-				((b2
-					((b1
-						((b0
-							(('00')))))))
-				(a1
-					(('00'))))).
+	a1 := self treeFrom: #(a1 #(#('00'))).
+	b3 := self treeFrom: #(b3 #(#(b2 #(#(b1 #(#(b0 #(#('00'))))))) #(a1 #(#('00'))))).
 	q1 := MCWorkingAncestry new addAncestor: a1.
 	q2 := MCWorkingAncestry new addAncestor: q1.
-	self assert: (q2 commonAncestorWith: b3) = a1.
-	self assert: (b3 commonAncestorWith: q2) = a1.
-	self assert: (q2 commonAncestorWith: c1) = a1.
-	self assert: (c1 commonAncestorWith: q2) = a1.
+	self assert: (q2 commonAncestorWith: b3) equals: a1.
+	self assert: (b3 commonAncestorWith: q2) equals: a1.
+	self assert: (q2 commonAncestorWith: c1) equals: a1.
+	self assert: (c1 commonAncestorWith: q2) equals: a1.
 	q1 addStepChild: c1.
-	self assert: (q2 commonAncestorWith: c1) = q1.
-	self assert: (c1 commonAncestorWith: q2) = q1.
+	self assert: (q2 commonAncestorWith: c1) equals: q1.
+	self assert: (c1 commonAncestorWith: q2) equals: q1.
 	c2 := MCWorkingAncestry new addAncestor: c1.
-	self assert: (q2 commonAncestorWith: c2) = q1.
-	self assert: (c2 commonAncestorWith: q2) = q1.
-
+	self assert: (q2 commonAncestorWith: c2) equals: q1.
+	self assert: (c2 commonAncestorWith: q2) equals: q1
 ]
 
 { #category : #tests }
diff --git a/src/Monticello-Tests/MCAnnouncementTest.class.st b/src/Monticello-Tests/MCAnnouncementTest.class.st
index 188901afb55..bf2ebd89039 100644
--- a/src/Monticello-Tests/MCAnnouncementTest.class.st
+++ b/src/Monticello-Tests/MCAnnouncementTest.class.st
@@ -6,20 +6,18 @@ Class {
 
 { #category : #tests }
 MCAnnouncementTest >> testMCVersionSaved [
-
 	| announcements version repository |
 	version := self mockVersion.
 	repository := MCDictionaryRepository new.
 	announcements := OrderedCollection new.
 
-	SystemAnnouncer uniqueInstance weak	
-		when: MCVersionSaved send: #add: to: announcements.
+	SystemAnnouncer uniqueInstance weak when: MCVersionSaved send: #add: to: announcements.
 
 	repository storeVersion: version.
-	
+
 	SystemAnnouncer uniqueInstance unsubscribe: announcements.
-	
+
 	self assert: announcements size equals: 1.
-	self assert: announcements anyOne version == version.
-	self assert: announcements anyOne repository == repository.
+	self assert: announcements anyOne version identicalTo: version.
+	self assert: announcements anyOne repository identicalTo: repository
 ]
diff --git a/src/Monticello-Tests/MCClassDefinitionTest.class.st b/src/Monticello-Tests/MCClassDefinitionTest.class.st
index 9d39af78f1a..13add050d8e 100644
--- a/src/Monticello-Tests/MCClassDefinitionTest.class.st
+++ b/src/Monticello-Tests/MCClassDefinitionTest.class.st
@@ -110,17 +110,15 @@ MCClassDefinitionTest >> testEquals [
 MCClassDefinitionTest >> testEqualsSensitivity [
 	| message a b defA args defB |
 	message := self creationMessage.
-	a := #(ClassA SuperA CategoryA #(iVarA) #(CVarA) #(PoolA) #(ciVarA)
-			typeA 'A comment' 'A').
-	b := #(ClassB SuperB CategoryB #(iVarB) #(CVarB) #(PoolB) #(ciVarB)
-			typeB 'B comment' 'B').
-	
+	a := #(ClassA SuperA CategoryA #(iVarA) #(CVarA) #(PoolA) #(ciVarA) typeA 'A comment' 'A').
+	b := #(ClassB SuperB CategoryB #(iVarB) #(CVarB) #(PoolB) #(ciVarB) typeB 'B comment' 'B').
+
 	defA := message valueWithArguments: a.
-	1 to: 8 do: [:index |
-				args := a copy.
-				args at: index put: (b at: index).
-				defB := message valueWithArguments: args.
-				self deny: defA = defB.]
+	1 to: 8 do: [ :index | 
+		args := a copy.
+		args at: index put: (b at: index).
+		defB := message valueWithArguments: args.
+		self deny: defA equals: defB ]
 ]
 
 { #category : #tests }
diff --git a/src/Monticello-Tests/MCMethodDefinitionTest.class.st b/src/Monticello-Tests/MCMethodDefinitionTest.class.st
index debaa44fed3..629bfc4b568 100644
--- a/src/Monticello-Tests/MCMethodDefinitionTest.class.st
+++ b/src/Monticello-Tests/MCMethodDefinitionTest.class.st
@@ -113,11 +113,10 @@ MCMethodDefinitionTest >> testPartiallyRevertOverrideMethod [
 	self class compile: 'override ^ 4' classified: self mockOverrideMethodCategory.
 	definition := (RGMethodDefinition realClass: self class selector: #override) asMCMethodDefinition.
 	self assert: definition isOverrideMethod.
-	self assert: self override = 4.
+	self assert: self override equals: 4.
 	definition unload.
-	self assert: self override = 2.
-	self assert: (RGMethodDefinition realClass: self class selector: #override) category = '*foobarbaz'.
-	
+	self assert: self override equals: 2.
+	self assert: (RGMethodDefinition realClass: self class selector: #override) category equals: '*foobarbaz'
 ]
 
 { #category : #testing }
@@ -127,8 +126,8 @@ MCMethodDefinitionTest >> testRevertOldMethod [
 	definition := (RGMethodDefinition realClass: Object selector: #yourself) asMCMethodDefinition.
 	changeRecord := definition overridenMethodOrNil.
 	self assert: changeRecord notNil.
-	self assert: changeRecord category = 'accessing'.
-	changeRecord fileIn.
+	self assert: changeRecord category equals: 'accessing'.
+	changeRecord fileIn
 ]
 
 { #category : #testing }
@@ -137,9 +136,8 @@ MCMethodDefinitionTest >> testRevertOverrideMethod [
 	self class compile: 'override ^ 2' classified: self mockOverrideMethodCategory.
 	definition := (RGMethodDefinition realClass: self class selector: #override) asMCMethodDefinition.
 	self assert: definition isOverrideMethod.
-	self assert: self override = 2.
+	self assert: self override equals: 2.
 	definition unload.
-	self assert: self override = 1.
-	self assert: (RGMethodDefinition realClass: self class selector: #override) category = 'mocks'.
-	
+	self assert: self override equals: 1.
+	self assert: (RGMethodDefinition realClass: self class selector: #override) category equals: 'mocks'
 ]
diff --git a/src/Monticello-Tests/MCOrganizationTest.class.st b/src/Monticello-Tests/MCOrganizationTest.class.st
index 47f3a341d1e..5467e2c963d 100644
--- a/src/Monticello-Tests/MCOrganizationTest.class.st
+++ b/src/Monticello-Tests/MCOrganizationTest.class.st
@@ -15,27 +15,27 @@ MCOrganizationTest >> testLoadAndUnload [
 
 { #category : #tests }
 MCOrganizationTest >> testReordering [
-	|dec cats newCats |
+	| dec cats newCats |
 	dec := MCOrganizationDefinition categories: #(A B C).
 	cats := #(X Y B Z C A Q).
 	newCats := dec reorderCategories: cats original: #(B C A).
-	self assert: newCats asArray = #(X Y A B C Z Q).
+	self assert: newCats asArray equals: #(X Y A B C Z Q)
 ]
 
 { #category : #tests }
 MCOrganizationTest >> testReorderingWithNoCategoriesInVersion [
-	|dec cats newCats |
+	| dec cats newCats |
 	dec := MCOrganizationDefinition categories: #().
 	cats := #(X Y B Z C A Q).
 	newCats := dec reorderCategories: cats original: #().
-	self assert: newCats asArray = cats.
+	self assert: newCats asArray equals: cats
 ]
 
 { #category : #tests }
 MCOrganizationTest >> testReorderingWithRemovals [
-	|dec cats newCats |
+	| dec cats newCats |
 	dec := MCOrganizationDefinition categories: #(A B C).
 	cats := #(X Y B Z C A Q).
 	newCats := dec reorderCategories: cats original: #(Y B C A Q).
-	self assert: newCats asArray = #(X A B C Z).
+	self assert: newCats asArray equals: #(X A B C Z)
 ]
diff --git a/src/Monticello-Tests/MCPackageManagerTest.class.st b/src/Monticello-Tests/MCPackageManagerTest.class.st
index 97974ac7d84..55d671cef41 100644
--- a/src/Monticello-Tests/MCPackageManagerTest.class.st
+++ b/src/Monticello-Tests/MCPackageManagerTest.class.st
@@ -74,23 +74,20 @@ MCPackageManagerTest >> testManagersForCategoryDo [
 		and a method extension with the protocol '*renraku'.
 		MCPackageManager>>methodModified: should only mark 'Renraku' as modified,
 		not 'Renraku-Help'"
+
 	| managers |
 	self assert: (MCPackageManager registry includesKey: mcPackage1).
 	self assert: (MCPackageManager registry includesKey: mcPackage2).
-	
+
 	managers := OrderedCollection new.
-	MCPackageManager
-		managersForCategory: mcPackage1 name
-		do: [ :manager | managers add: manager ].
-		
+	MCPackageManager managersForCategory: mcPackage1 name do: [ :manager | managers add: manager ].
+
 	self assert: managers size equals: 1.
-	self assert: managers first package == mcPackage1.
-	
+	self assert: managers first package identicalTo: mcPackage1.
+
 	managers := OrderedCollection new.
-	MCPackageManager
-		managersForCategory: mcPackage2 name
-		do: [ :manager | managers add: manager ].
-		
+	MCPackageManager managersForCategory: mcPackage2 name do: [ :manager | managers add: manager ].
+
 	self assert: managers size equals: 1.
-	self assert: managers first package == mcPackage2
+	self assert: managers first package identicalTo: mcPackage2
 ]
diff --git a/src/Monticello-Tests/MCPatchTest.class.st b/src/Monticello-Tests/MCPatchTest.class.st
index f36db837275..4c8e5ab0b8c 100644
--- a/src/Monticello-Tests/MCPatchTest.class.st
+++ b/src/Monticello-Tests/MCPatchTest.class.st
@@ -26,8 +26,7 @@ MCPatchTest >> tearDown [
 
 { #category : #tests }
 MCPatchTest >> testPatchContents [
-	self assert: patch operations size = 1.
+	self assert: patch operations size equals: 1.
 	self assert: patch operations first isModification.
-	self assert: patch operations first definition selector = #one.
-
+	self assert: patch operations first definition selector equals: #one
 ]
diff --git a/src/Monticello-Tests/MCRepositoryTest.class.st b/src/Monticello-Tests/MCRepositoryTest.class.st
index 728b7485815..ccde39fbbbe 100644
--- a/src/Monticello-Tests/MCRepositoryTest.class.st
+++ b/src/Monticello-Tests/MCRepositoryTest.class.st
@@ -81,8 +81,7 @@ MCRepositoryTest >> snapshotAt: aVersionInfo [
 MCRepositoryTest >> testAddAndLoad [
 	| node |
 	node := self addVersionWithSnapshot: self snapshot1 name: 'rev1'.
-	self assert: (self snapshotAt: node) = self snapshot1.
-
+	self assert: (self snapshotAt: node) equals: self snapshot1
 ]
 
 { #category : #tests }
@@ -156,8 +155,8 @@ MCRepositoryTest >> testStoreAndLoad [
 	| node node2 |
 	node := self saveSnapshot1.
 	node2 := self saveSnapshot2.
-	self assert: (self snapshotAt: node) = self snapshot1.
-	self assert: (self snapshotAt: node2) = self snapshot2.
+	self assert: (self snapshotAt: node) equals: self snapshot1.
+	self assert: (self snapshotAt: node2) equals: self snapshot2
 ]
 
 { #category : #building }
diff --git a/src/Monticello-Tests/MCScannerTest.class.st b/src/Monticello-Tests/MCScannerTest.class.st
index 2f5e5b239ee..35f03a14480 100644
--- a/src/Monticello-Tests/MCScannerTest.class.st
+++ b/src/Monticello-Tests/MCScannerTest.class.st
@@ -21,7 +21,7 @@ MCScannerTest >> test2 [
 
 { #category : #tests }
 MCScannerTest >> test3 [
-	self assert: (MCScanner scan: '(a #b c)' readStream) = #(a #b c)
+	self assert: (MCScanner scan: '(a #b c)' readStream) equals: #(a #b c)
 ]
 
 { #category : #tests }
diff --git a/src/Monticello-Tests/MCSortingTest.class.st b/src/Monticello-Tests/MCSortingTest.class.st
index d9db51ecc59..72f76acbe5e 100644
--- a/src/Monticello-Tests/MCSortingTest.class.st
+++ b/src/Monticello-Tests/MCSortingTest.class.st
@@ -46,19 +46,12 @@ MCSortingTest >> sortKeyFor: aDefinition [
 
 { #category : #tests }
 MCSortingTest >> testConsistentSorting [
-	| definitions shuffledAndSorted|
-	definitions :=
-		{self methodNamed: #a class: #A meta: false.
-		self methodNamed: #a class: #A meta: true.
-		self methodNamed: #a class: #B meta: false.
-		self methodNamed: #b class: #A meta: false.
-		self methodNamed: #b class: #B meta: false.
-		self classNamed: #A.
-		self classNamed: #B}.
-	shuffledAndSorted :=
-		(1 to: 100) collect: [:ea | self sortDefinitions: definitions shuffled].
-	self assert: shuffledAndSorted asSet size = 1.
-
+	| definitions shuffledAndSorted |
+	definitions := {(self methodNamed: #a class: #A meta: false) . (self methodNamed: #a class: #A meta: true).
+	(self methodNamed: #a class: #B meta: false) . (self methodNamed: #b class: #A meta: false) . (self methodNamed: #b class: #B meta: false).
+	(self classNamed: #A) . (self classNamed: #B)}.
+	shuffledAndSorted := (1 to: 100) collect: [ :ea | self sortDefinitions: definitions shuffled ].
+	self assert: shuffledAndSorted asSet size equals: 1
 ]
 
 { #category : #tests }
@@ -74,6 +67,5 @@ MCSortingTest >> testSortOrder [
 	bB := self methodNamed: #b class: #B meta: false.
 	A := self classNamed: #A.
 	B := self classNamed: #B.
-	self assert: (self sortDefinitions: {aA. aAm. cAm. aB. bAm. bA. bB. A. cA. B})
-					= {A. aAm. bAm. cAm. aA. bA. cA. B. aB.  bB}
+	self assert: (self sortDefinitions: {aA . aAm . cAm . aB . bAm . bA . bB . A . cA . B}) equals: {A . aAm . bAm . cAm . aA . bA . cA . B . aB . bB}
 ]
diff --git a/src/Monticello-Tests/MCWorkingCopyTest.class.st b/src/Monticello-Tests/MCWorkingCopyTest.class.st
index 6fbb00229b1..23d4292ac86 100644
--- a/src/Monticello-Tests/MCWorkingCopyTest.class.st
+++ b/src/Monticello-Tests/MCWorkingCopyTest.class.st
@@ -129,36 +129,35 @@ MCWorkingCopyTest >> testBackport [
 	| inst base final backported ancestry |
 	inst := self mockInstanceA.
 	base := self snapshot.
-	
-	self assert: inst one = 1.
-	
+
+	self assert: inst one equals: 1.
+
 	self change: #one toReturn: 2.
 	self change: #two toReturn: 3.
-	
+
 	final := self snapshot.
-	[workingCopy backportChangesTo: base info]
+	[ workingCopy backportChangesTo: base info ]
 		on: MCChangeSelectionRequest
-		do: [:e | e resume: e patch].
-		
-	self assert: inst one = 2.
-	self assert: inst two = 3.
+		do: [ :e | e resume: e patch ].
+
+	self assert: inst one equals: 2.
+	self assert: inst two equals: 3.
 	ancestry := workingCopy ancestry.
-	self assert: ancestry ancestors size = 1.
-	self assert: ancestry ancestors first = base info.
-	self assert: ancestry stepChildren size = 1.
-	self assert: ancestry stepChildren first = final info.
-	
+	self assert: ancestry ancestors size equals: 1.
+	self assert: ancestry ancestors first equals: base info.
+	self assert: ancestry stepChildren size equals: 1.
+	self assert: ancestry stepChildren first equals: final info.
+
 	backported := self snapshot.
-	[workingCopy backportChangesTo: base info]
+	[ workingCopy backportChangesTo: base info ]
 		on: MCChangeSelectionRequest
-		do: [:e | e resume: e patch].
-		
+		do: [ :e | e resume: e patch ].
+
 	ancestry := workingCopy ancestry.
-	self assert: ancestry ancestors size = 1.
-	self assert: ancestry ancestors first = base info.
-	self assert: ancestry stepChildren size = 1.
-	self assert: ancestry stepChildren first = backported info.
-	
+	self assert: ancestry ancestors size equals: 1.
+	self assert: ancestry ancestors first equals: base info.
+	self assert: ancestry stepChildren size equals: 1.
+	self assert: ancestry stepChildren first equals: backported info
 ]
 
 { #category : #tests }
@@ -183,21 +182,20 @@ MCWorkingCopyTest >> testDoubleRepeatedMerge [
 	self merge: motherA2.
 	self merge: motherB2.
 	inst := self mockInstanceA.
-	self assert: inst a = 'a2'.
-	self assert: inst b = 'b2'.
-	self assert: inst c = 'c1'.
-	self assert: inst d = 'd1'
+	self assert: inst a equals: 'a2'.
+	self assert: inst b equals: 'b2'.
+	self assert: inst c equals: 'c1'.
+	self assert: inst d equals: 'd1'
 ]
 
 { #category : #tests }
 MCWorkingCopyTest >> testMergeIntoImageWithNoChanges [
 	| base revB revA1 |
-
 	self change: #a toReturn: 'a'.
 	base := self snapshot.
 	self change: #b toReturn: 'b'.
 	revB := self snapshot.
-	
+
 	self load: base.
 	self change: #a toReturn: 'a1'.
 	revA1 := self snapshot.
@@ -206,24 +204,21 @@ MCWorkingCopyTest >> testMergeIntoImageWithNoChanges [
 	self snapshot.
 	self merge: revB.
 
-	self assert: (workingCopy ancestors size = 2)
-	
+	self assert: workingCopy ancestors size equals: 2
 ]
 
 { #category : #tests }
 MCWorkingCopyTest >> testMergeIntoUnmodifiedImage [
 	| base revA |
-
 	base := self snapshot.
 	self change: #a toReturn: 'a1'.
 	revA := self snapshot.
-	
+
 	self load: base.
 
 	self merge: revA.
 
-	self assert: (workingCopy ancestors size = 1)
-	
+	self assert: workingCopy ancestors size equals: 1
 ]
 
 { #category : #tests }
@@ -258,15 +253,14 @@ MCWorkingCopyTest >> testOptimizedLoad [
 	inst := self mockInstanceA.
 	base := self snapshot.
 	self change: #one toReturn: 2.
-	self assert: inst one = 2.
+	self assert: inst one equals: 2.
 	diffy := self snapshot asDiffAgainst: base.
 	self deny: diffy canOptimizeLoading.
 	self load: base.
-	self assert: inst one = 1.
+	self assert: inst one equals: 1.
 	self assert: diffy canOptimizeLoading.
 	self load: diffy.
-	self assert: inst one = 2.
-
+	self assert: inst one equals: 2
 ]
 
 { #category : #tests }
@@ -289,80 +283,81 @@ MCWorkingCopyTest >> testRepeatedMerge [
 	self change: #truth toReturn: false.
 	self snapshot.
 	inst := self mockInstanceA.
-	self assert: inst one = 1.
-	self assert: inst two = 2.
+	self assert: inst one equals: 1.
+	self assert: inst two equals: 2.
 	self merge: mother1.
-	self assert: inst one = 2.
-	self assert: inst two = 2.
+	self assert: inst one equals: 2.
+	self assert: inst two equals: 2.
 	self change: #one toReturn: 7.
-	self assert: inst one = 7.
-	self assert: inst two = 2.
+	self assert: inst one equals: 7.
+	self assert: inst two equals: 2.
 	self merge: mother2.
-	self assert: inst one = 7.
-	self assert: inst two = 3
+	self assert: inst one equals: 7.
+	self assert: inst two equals: 3
 ]
 
 { #category : #tests }
 MCWorkingCopyTest >> testRepositoryFallback [
 	| version |
 	version := self snapshot.
-	self assert: (repositoryGroup versionWithInfo: version info) == version.
+	self assert: (repositoryGroup versionWithInfo: version info) identicalTo: version.
 	versions removeKey: version info.
 	versions2 at: version info put: version.
-	self assert: ( repositoryGroup versionWithInfo: version info) == version.
+	self assert: (repositoryGroup versionWithInfo: version info) identicalTo: version.
 	versions2 removeKey: version info.
-	self should: [repositoryGroup versionWithInfo: version info] raise: Error.
+	self should: [ repositoryGroup versionWithInfo: version info ] raise: Error
 ]
 
 { #category : #tests }
 MCWorkingCopyTest >> testSelectiveBackport [
 	| inst base intermediate final |
 	inst := self mockInstanceA.
-	base :=  self snapshot.
-	self assert: inst one = 1.
+	base := self snapshot.
+	self assert: inst one equals: 1.
 	self change: #one toReturn: 2.
 	intermediate := self snapshot.
 	self change: #two toReturn: 3.
 	final := self snapshot.
-	[workingCopy backportChangesTo: base info]
+	[ workingCopy backportChangesTo: base info ]
 		on: MCChangeSelectionRequest
-		do: [:e | | patch selected |
+		do: [ :e | 
+			| patch selected |
 			patch := e patch.
-			selected := patch operations select: [:ea | ea definition selector = #two].
-			e resume: (MCPatch operations: selected)]. 
-	self assert: inst one = 1.
-	self assert: inst two = 3.
-	self assert: workingCopy ancestry ancestors size = 1.
-	self assert: workingCopy ancestry ancestors first = base info.
-	self assert: workingCopy ancestry stepChildren size = 1.
-	self assert: workingCopy ancestry stepChildren first = final info
+			selected := patch operations select: [ :ea | ea definition selector = #two ].
+			e resume: (MCPatch operations: selected) ].
+	self assert: inst one equals: 1.
+	self assert: inst two equals: 3.
+	self assert: workingCopy ancestry ancestors size equals: 1.
+	self assert: workingCopy ancestry ancestors first equals: base info.
+	self assert: workingCopy ancestry stepChildren size equals: 1.
+	self assert: workingCopy ancestry stepChildren first equals: final info
 ]
 
 { #category : #tests }
 MCWorkingCopyTest >> testSimpleMerge [
 	| mother base inst |
 	inst := self mockInstanceA.
-	base :=  self snapshot.
+	base := self snapshot.
 	self change: #one toReturn: 2.
-	mother :=  self snapshot.
+	mother := self snapshot.
 	self load: base.
 	self change: #two toReturn: 3.
 	self snapshot.
-	self assert: inst one = 1.
-	self assert: inst two = 3.
-	
+	self assert: inst one equals: 1.
+	self assert: inst two equals: 3.
+
 	self merge: mother.
-	self assert: inst one = 2.
-	self assert: inst two = 3.
+	self assert: inst one equals: 2.
+	self assert: inst two equals: 3
 ]
 
 { #category : #tests }
 MCWorkingCopyTest >> testSnapshotAndLoad [
 	| base inst |
 	inst := self mockInstanceA.
-	base :=  self snapshot.
+	base := self snapshot.
 	self change: #one toReturn: 2.
-	self assert: inst one = 2.
+	self assert: inst one equals: 2.
 	self load: base.
-	self assert: inst one = 1.
+	self assert: inst one equals: 1
 ]
diff --git a/src/Monticello-Tests/RPackageCategorySynchronisationTest.class.st b/src/Monticello-Tests/RPackageCategorySynchronisationTest.class.st
index 78b7d404561..e980c3cda6b 100644
--- a/src/Monticello-Tests/RPackageCategorySynchronisationTest.class.st
+++ b/src/Monticello-Tests/RPackageCategorySynchronisationTest.class.st
@@ -20,70 +20,66 @@ RPackageCategorySynchronisationTest >> testAddCategoryCreatesPackage [
 { #category : #'tests - operations on categories' }
 RPackageCategorySynchronisationTest >> testAddCategoryIsAlreadyAPackageDoesNotCreatePackage [
 	"test that when we add a category corresponding to an existing package, we do not create a second package"
-	
-	|tmpPackage|
-	
-	self flag: #pharoTodo. "To be removed when Categories are kicked out"
-	
+
+	| tmpPackage |
+	self flag: #pharoTodo.	"To be removed when Categories are kicked out"
+
 	self addXCategory.
 	tmpPackage := self organizer packageNamed: #XXXXX.
 	self addXCategory.
-	self assert: tmpPackage =  (self organizer packageNamed: #XXXXX)
-		
+	self assert: tmpPackage equals: (self organizer packageNamed: #XXXXX)
 ]
 
 { #category : #'tests - operations on categories' }
 RPackageCategorySynchronisationTest >> testRenameCategoryAlsoRenameAllExtensionProtocols [
 	"test that when we rename a category, all corresponding extension protocols in the system are renamed"
-		
-	|XPackage YPackage ZPackage classInY classInZ| 
+
+	| XPackage YPackage ZPackage classInY classInZ |
 	self addXCategory.
 	self addYCategory.
 	self addZCategory.
 	XPackage := self organizer packageNamed: #XXXXX.
 	YPackage := self organizer packageNamed: #YYYYY.
 	ZPackage := self organizer packageNamed: #ZZZZZ.
-	
+
 	classInY := self createNewClassNamed: 'ClassInYPackage' inCategory: 'YYYYY'.
-	classInZ := self createNewClassNamed: 'ClassInZPackage' inCategory: 'ZZZZZ'. 
-	
-	self createMethodNamed:  'extensionFromXInClassInY'  inClass: classInY   inCategory: '*XXXXX'. 
-	self createMethodNamed:  'longNameExtensionFromXInClassInY'  inClass: classInY   inCategory: '*XXXXX-subcategory'.     
-	self createMethodNamed:  'extensionFromXInClassInZ'  inClass: classInZ   inCategory: '*XXXXX'.     
-	    
+	classInZ := self createNewClassNamed: 'ClassInZPackage' inCategory: 'ZZZZZ'.
+
+	self createMethodNamed: 'extensionFromXInClassInY' inClass: classInY inCategory: '*XXXXX'.
+	self createMethodNamed: 'longNameExtensionFromXInClassInY' inClass: classInY inCategory: '*XXXXX-subcategory'.
+	self createMethodNamed: 'extensionFromXInClassInZ' inClass: classInZ inCategory: '*XXXXX'.
+
 	Smalltalk organization renameCategory: 'XXXXX' toBe: 'NewCategoryName'.
-	
-	self assert: (XPackage name = 'NewCategoryName').
-	self assert: (classInY >> #extensionFromXInClassInY) category = '*NewCategoryName'.
-	self assert: (classInY >> #longNameExtensionFromXInClassInY) category = '*NewCategoryName'.
-	self assert: (classInZ >> #extensionFromXInClassInZ) category = '*NewCategoryName'.
+
+	self assert: XPackage name equals: 'NewCategoryName'.
+	self assert: (classInY >> #extensionFromXInClassInY) category equals: '*NewCategoryName'.
+	self assert: (classInY >> #longNameExtensionFromXInClassInY) category equals: '*NewCategoryName'.
+	self assert: (classInZ >> #extensionFromXInClassInZ) category equals: '*NewCategoryName'
 ]
 
 { #category : #'tests - operations on categories' }
 RPackageCategorySynchronisationTest >> testRenameCategoryChangeTheNameOfThePackage [
 	"test that when we rename a category, the RPackage corresponding is updated with this new name"
-	
-	|XPackage| 
+
+	| XPackage |
 	self addXCategory.
 	XPackage := self organizer packageNamed: #XXXXX.
-	
+
 	Smalltalk organization renameCategory: 'XXXXX' toBe: 'YYYYY'.
-	self assert: (XPackage name = 'YYYYY').
+	self assert: XPackage name equals: 'YYYYY'
 ]
 
 { #category : #'tests - operations on categories' }
 RPackageCategorySynchronisationTest >> testRenameCategoryUpdateTheOrganizer [
 	"test that when we rename a category, the organizer dictionary is update with this new name, so that we can access the package with this new name as key"
 
-	|XPackage| 
-	
-	
+	| XPackage |
 	self addXCategory.
-	
+
 	XPackage := self organizer packageNamed: #XXXXX.
 	Smalltalk organization renameCategory: 'XXXXX' toBe: 'YYYYY'.
-	self assert: (self organizer packageNamed: 'YYYYY' asSymbol) = XPackage.
-	self deny: (self organizer includesPackageNamed: #XXXXX).
+	self assert: (self organizer packageNamed: 'YYYYY' asSymbol) equals: XPackage.
+	self deny: (self organizer includesPackageNamed: #XXXXX)
 ]
 
 { #category : #'tests - operations on categories' }
diff --git a/src/Monticello-Tests/RPackageClassesSynchronisationTest.class.st b/src/Monticello-Tests/RPackageClassesSynchronisationTest.class.st
index 15d725d3319..cfa7d06aba9 100644
--- a/src/Monticello-Tests/RPackageClassesSynchronisationTest.class.st
+++ b/src/Monticello-Tests/RPackageClassesSynchronisationTest.class.st
@@ -76,57 +76,56 @@ RPackageClassesSynchronisationTest >> testRecategorizeClassRaisesClassRepackaged
 { #category : #'tests - recategorizing class' }
 RPackageClassesSynchronisationTest >> testRecategorizeClassRegisterTheClassInTheBestMatchPackage [
 	"test that when we recategorize a class, the new package in which it is defined include it"
-	
-	|XPackage  YPackage class|
+
+	| XPackage YPackage class |
 	self addXCategory.
 	self addXMatchCategory.
 	self addYCategory.
-	
+
 	XPackage := self organizer packageNamed: #XXXXX.
 	YPackage := self organizer packageNamed: #YYYYY.
-	
+
 	class := self createNewClassNamed: 'NewClass' inCategory: 'YYYYY'.
-	
-	class category: 'XXXXX-YYYY'.
-	self assert: (self organizer packageOf: class) = XPackage. 
-	self deny: (self organizer packageOf: class) = YPackage.
 
+	class category: 'XXXXX-YYYY'.
+	self assert: (self organizer packageOf: class) equals: XPackage.
+	self deny: (self organizer packageOf: class) equals: YPackage
 ]
 
 { #category : #'tests - recategorizing class' }
 RPackageClassesSynchronisationTest >> testRecategorizeClassRegisterTheClassInTheExactMatchPackage [
 	"test that when we recategorize a class, the new package in which it is defined include it"
-	
-	|XPackage YPackage class|
+
+	| XPackage YPackage class |
 	self addXCategory.
 	self addXMatchCategory.
 	self addYCategory.
 	XPackage := self organizer packageNamed: #XXXXX.
 	YPackage := self organizer packageNamed: #YYYYY.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'YYYYY'.
-	
+
 	class category: 'XXXXX'.
-	
-	self assert: (self organizer packageOf: class) = XPackage. 
-	self deny: (self organizer packageOf: class) = YPackage.		
+
+	self assert: (self organizer packageOf: class) equals: XPackage.
+	self deny: (self organizer packageOf: class) equals: YPackage
 ]
 
 { #category : #'tests - recategorizing class' }
 RPackageClassesSynchronisationTest >> testRecategorizeClassRegisterTheClassInTheMatchingPackage [
 	"test that when we recategorize a class, the new package in which it is defined include it"
-	
-	|XPackage YPackage class|
+
+	| XPackage YPackage class |
 	self addXCategory.
 	self addYCategory.
-	
+
 	XPackage := self organizer packageNamed: #XXXXX.
 	YPackage := self organizer packageNamed: #YYYYY.
-	
+
 	class := self createNewClassNamed: 'NewClass' inCategory: 'YYYYY'.
-	
+
 	class category: 'XXXXX'.
-	self deny: (self organizer packageOf: class) = YPackage. 
-	self assert: (self organizer packageOf: class) = XPackage.
+	self deny: (self organizer packageOf: class) equals: YPackage.
+	self assert: (self organizer packageOf: class) equals: XPackage
 ]
 
 { #category : #'tests - recategorizing class' }
@@ -249,19 +248,19 @@ RPackageClassesSynchronisationTest >> testRecategorizeClassWithMetaClassMethodsR
 { #category : #'tests - recategorizing class' }
 RPackageClassesSynchronisationTest >> testRecategorizeClassWithUnexistingPackageNameRegisterTheClassInANewPackage [
 	"test that when we recategorize a class in category not yet registered in RPackage, a new rPackage is created with the class inside"
-	
-	|XPackage YPackage class|
+
+	| XPackage YPackage class |
 	self addXCategory.
 	XPackage := self organizer packageNamed: #XXXXX.
-	
+
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
-	self assert: (self organizer packageOf: class) = XPackage. 
-	
+	self assert: (self organizer packageOf: class) equals: XPackage.
+
 	class category: 'YYYYY'.
 	YPackage := self organizer packageNamed: #YYYYY.
-	
-	self assert: (self organizer packageOf: class) equals: YPackage. 
-	self deny: (self organizer packageOf: class) = XPackage.
+
+	self assert: (self organizer packageOf: class) equals: YPackage.
+	self deny: (self organizer packageOf: class) equals: XPackage
 ]
 
 { #category : #'tests - removing classes' }
@@ -420,16 +419,16 @@ RPackageClassesSynchronisationTest >> testRenameClassUpdateOrganizerClassExtendi
 { #category : #'tests - operations on classes' }
 RPackageClassesSynchronisationTest >> testRenameClassUpdateOrganizerClassPackageMapping [
 	"test that when we rename a class, the classPackage dictionary of the organizer is updated with the new name, so that we can access the package when specifying the new name"
-	
+
 	| XPackage class |
 	self addXYCategory.
 	XPackage := self organizer packageNamed: #XXXXX.
 	class := self createNewClassNamed: 'RPackageOldStubClass' inCategory: 'XXXXX'.
-	
+
 	class rename: 'RPackageNewStubClass'.
-	
-	self assert: ((self organizer packageOfClassNamed: 'RPackageNewStubClass' asSymbol) = XPackage). 
-	self assert: ((self organizer packageOfClassNamed: 'RPackageOldStubClass' asSymbol) = nil).
+
+	self assert: (self organizer packageOfClassNamed: 'RPackageNewStubClass' asSymbol) equals: XPackage.
+	self assert: (self organizer packageOfClassNamed: 'RPackageOldStubClass' asSymbol) equals: nil
 ]
 
 { #category : #'tests - operations on protocols' }
@@ -449,17 +448,17 @@ RPackageClassesSynchronisationTest >> testReorganizeClassByAddingExtensionProtoc
 { #category : #'tests - operations on protocols' }
 RPackageClassesSynchronisationTest >> testReorganizeClassByAddingNewProtocolDoesNothing [
 	"test that when we reoganized a class by adding a category, nothing change from  RPackage point of vue."
-	
-	|XPackage class| 
+
+	| XPackage class |
 	self addXCategory.
 	XPackage := self organizer packageNamed: #XXXXX.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
-	self createMethodNamed: 'newMethod' inClass: class inCategory: 'xxxxx'.  
+	self createMethodNamed: 'newMethod' inClass: class inCategory: 'xxxxx'.
 	class organization addCategory: 'accessing' before: nil.
-	
+
 	self assert: (XPackage includesClass: class).
 	self assert: (XPackage includesDefinedSelector: #newMethod ofClass: class).
-	self assert: (XPackage extensionMethods size = 0).
+	self assert: XPackage extensionMethods size equals: 0
 ]
 
 { #category : #'tests - operations on protocols' }
diff --git a/src/Monticello-Tests/RPackageExtensionMethodsSynchronisationTest.class.st b/src/Monticello-Tests/RPackageExtensionMethodsSynchronisationTest.class.st
index 6a81d6d9643..ec40b823352 100644
--- a/src/Monticello-Tests/RPackageExtensionMethodsSynchronisationTest.class.st
+++ b/src/Monticello-Tests/RPackageExtensionMethodsSynchronisationTest.class.st
@@ -10,43 +10,42 @@ Class {
 { #category : #'we are not sure' }
 RPackageExtensionMethodsSynchronisationTest >> testAddMethodInExtensionCategoryBestMatchingNameAddMethodToTheExtendingPackage [
 	"test that when we add a method  in an extension category ( beginning with*) that enlarge a package name (for example *mondrian-accessing for Mondrian), this method is added to the corresponding extending package"
-	
-	| class XPackage YPackage |
 
+	| class XPackage YPackage |
 	self addXYCategory.
 	self addXMatchCategory.
-	
+
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX-YYYY'.
-	
+
 	XPackage := self organizer packageNamed: #XXXXX.
 	YPackage := self organizer packageNamed: #YYYYY.
-	
+
 	class := self createNewClassNamed: 'NewClass' inCategory: 'YYYYY'.
 
-	self createMethodNamed: #newMethod inClass:  class inCategory: '*XXXXX-YYYY'.
+	self createMethodNamed: #newMethod inClass: class inCategory: '*XXXXX-YYYY'.
 
 	self deny: (YPackage includesDefinedSelector: #newMethod ofClass: class).
 	self assert: (XPackage includesExtensionSelector: #newMethod ofClass: class).
 
-	self assert: ((class >> #newMethod) packageFromOrganizer: self organizer ) = XPackage
+	self assert: (class >> #newMethod packageFromOrganizer: self organizer) equals: XPackage
 ]
 
 { #category : #'we are not sure' }
 RPackageExtensionMethodsSynchronisationTest >> testAddMethodInExtensionCategoryMatchingNameAddMethodToTheExtendingPackage [
 	"test that when we add a method  in an extension category ( beginning with*) that enlarge a package name (for example *mondrian-accessing for Mondrian), this method is added to the corresponding extending package"
-	
-	| class XPackage YPackage|
+
+	| class XPackage YPackage |
 	self addXYCategory.
 	XPackage := self organizer packageNamed: #XXXXX.
 	YPackage := self organizer packageNamed: #YYYYY.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
 
-	self createMethodNamed: #newMethod inClass:  class inCategory: '*YYYYY-subcategory'.
+	self createMethodNamed: #newMethod inClass: class inCategory: '*YYYYY-subcategory'.
 
 	self assert: (YPackage includesExtensionSelector: #newMethod ofClass: class).
 	self deny: (XPackage includesDefinedSelector: #newMethod ofClass: class).
 
-	self assert: ((class >> #newMethod) packageFromOrganizer: self organizer ) = YPackage
+	self assert: (class >> #newMethod packageFromOrganizer: self organizer) equals: YPackage
 ]
 
 { #category : #testing }
@@ -107,109 +106,108 @@ RPackageExtensionMethodsSynchronisationTest >> testAddMethodInExtensionCategoryN
 { #category : #'we are not sure' }
 RPackageExtensionMethodsSynchronisationTest >> testAddMethodInExtensionCategoryWithExactMatchAddMethodToTheExtendingPackage [
 	"test that when we add a method to a  class in an extension category ( beginning with *), this method is added to the corresponding extending package"
-	
-	| class firstPackage secondPackage|
-	self addXYCategory.		
+
+	| class firstPackage secondPackage |
+	self addXYCategory.
 	self addXMatchCategory.
-	
+
 	firstPackage := self organizer packageNamed: #XXXXX.
 	secondPackage := self organizer packageNamed: #YYYYY.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
-	
-	
+
+
 	self createMethodNamed: 'stubMethod' inClass: class inCategory: '*YYYYY'.
-	
+
 	self assert: (secondPackage includesExtensionSelector: #stubMethod ofClass: class).
 	self deny: (firstPackage includesDefinedSelector: #stubMethod ofClass: class).
-	
-	self assert: ((class >> #stubMethod) packageFromOrganizer: self organizer) = secondPackage
+
+	self assert: (class >> #stubMethod packageFromOrganizer: self organizer) equals: secondPackage
 ]
 
 { #category : #'tests - operations on methods' }
 RPackageExtensionMethodsSynchronisationTest >> testModifyMethodByChangingCode [
 	"test that when we modify the code of a method, everything work well: NOTHING SHOULD HAPPEN REGARDING THE PACKAGING"
-	
+
 	| class firstPackage |
 	self addXCategory.
 	firstPackage := self organizer packageNamed: #XXXXX.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
-	self createMethodNamed: 'stubMethod' inClass:  class inCategory: 'classic category'.
+	self createMethodNamed: 'stubMethod' inClass: class inCategory: 'classic category'.
 
 	class compile: 'stubMethod ^22222222222'.
-	
+
 	"nothing should change"
-	self assert: (class >> #stubMethod) category = 'classic category'. 
+	self assert: (class >> #stubMethod) category equals: 'classic category'.
 	self assert: (firstPackage includesDefinedSelector: #stubMethod ofClass: class).
 	self deny: (firstPackage includesExtensionSelector: #stubMethod ofClass: class).
-	self assert: ((class >> #stubMethod) packageFromOrganizer: self organizer ) = firstPackage.
+	self assert: (class >> #stubMethod packageFromOrganizer: self organizer) equals: firstPackage
 ]
 
 { #category : #'tests - operations on methods' }
 RPackageExtensionMethodsSynchronisationTest >> testMoveClassInPackageWithExtensionsOnClass [
 	"Move a class in package XXXXX (with extensions from YYYY) to package YYYYY."
-	
-	| class secondPackage|
+
+	| class secondPackage |
 	self addXYCategory.
 	secondPackage := self organizer packageNamed: #YYYYY.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
-	self createMethodNamed: 'stubMethod' inClass:  class inCategory: secondPackage methodCategoryPrefix.
+	self createMethodNamed: 'stubMethod' inClass: class inCategory: secondPackage methodCategoryPrefix.
 
 	secondPackage addClass: class.
-	
+
 	"Everything should now be in second package (and not listed as an extension)."
-	self assert: (class >> #stubMethod) category = Protocol defaultName. 
+	self assert: (class >> #stubMethod) category equals: Protocol defaultName.
 	self assert: (secondPackage includesDefinedSelector: #stubMethod ofClass: class).
 	self deny: (secondPackage includesExtensionSelector: #stubMethod ofClass: class).
-	self assert: ((class >> #stubMethod) packageFromOrganizer: self organizer ) = secondPackage.
+	self assert: (class >> #stubMethod packageFromOrganizer: self organizer) equals: secondPackage
 ]
 
 { #category : #'tests - operations on methods' }
 RPackageExtensionMethodsSynchronisationTest >> testMoveClassInPackageWithExtensionsOnClass2 [
 	"Move a class in package XXXXX (with extensions from XXXX) to package YYYYY."
-	
-	| class secondPackage|
+
+	| class secondPackage |
 	self addXYCategory.
 	secondPackage := self organizer packageNamed: #YYYYY.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
-	self createMethodNamed: 'stubMethod' inClass:  class inCategory: '*XXXXX'.
+	self createMethodNamed: 'stubMethod' inClass: class inCategory: '*XXXXX'.
 
 	secondPackage addClass: class.
-	
+
 	"Everything should now be in second package (and not listed as an extension)."
-	self assert: (class >> #stubMethod) category = Protocol defaultName. 
+	self assert: (class >> #stubMethod) category equals: Protocol defaultName.
 	self assert: (secondPackage includesDefinedSelector: #stubMethod ofClass: class).
 	self deny: (secondPackage includesExtensionSelector: #stubMethod ofClass: class).
-	self assert: ((class >> #stubMethod) packageFromOrganizer: self organizer ) = secondPackage.
+	self assert: (class >> #stubMethod packageFromOrganizer: self organizer) equals: secondPackage
 ]
 
 { #category : #'tests - operations on methods' }
 RPackageExtensionMethodsSynchronisationTest >> testMoveClassInPackageWithExtensionsOnClassAndBack [
 	"Move a class in package XXXXX (with extensions from YYYY) to package YYYYY."
-	
-	| class firstPackage secondPackage|
+
+	| class firstPackage secondPackage |
 	self addXYCategory.
-	firstPackage := self organizer  packageNamed: #XXXXX.
+	firstPackage := self organizer packageNamed: #XXXXX.
 	secondPackage := self organizer packageNamed: #YYYYY.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
-	self createMethodNamed: 'stubMethod' inClass:  class inCategory: secondPackage methodCategoryPrefix.
+	self createMethodNamed: 'stubMethod' inClass: class inCategory: secondPackage methodCategoryPrefix.
 
 	secondPackage addClass: class.
-	
+
 	"Everything should now be in second package (and not listed as an extension, but instead as 'as yet unclassified')."
 
-	self assert: (class >> #stubMethod) category = Protocol defaultName. 
+	self assert: (class >> #stubMethod) category equals: Protocol defaultName.
 	self assert: (secondPackage includesDefinedSelector: #stubMethod ofClass: class).
 	self deny: (secondPackage includesExtensionSelector: #stubMethod ofClass: class).
-	self assert: ((class >> #stubMethod) packageFromOrganizer: self organizer ) = secondPackage.
-	
+	self assert: (class >> #stubMethod packageFromOrganizer: self organizer) equals: secondPackage.
+
 	"Moving back, we should not see the extension reappear."
 
 	firstPackage addClass: class.
-	
-	self assert: (class >> #stubMethod) category = Protocol defaultName. 
+
+	self assert: (class >> #stubMethod) category equals: Protocol defaultName.
 	self assert: (firstPackage includesDefinedSelector: #stubMethod ofClass: class).
 	self deny: (secondPackage includesExtensionSelector: #stubMethod ofClass: class)
-
 ]
 
 { #category : #'tests - operations on methods' }
diff --git a/src/Monticello-Tests/RPackageMethodsSynchronisationTest.class.st b/src/Monticello-Tests/RPackageMethodsSynchronisationTest.class.st
index e4dbb629403..aae935ac12a 100644
--- a/src/Monticello-Tests/RPackageMethodsSynchronisationTest.class.st
+++ b/src/Monticello-Tests/RPackageMethodsSynchronisationTest.class.st
@@ -26,97 +26,96 @@ RPackageMethodsSynchronisationTest >> testAddMethodInClassicCategoryAddMethodToT
 { #category : #'tests - operations on methods' }
 RPackageMethodsSynchronisationTest >> testAddMethodInClassicCategoryAddMethodToTheParentPackageOfItsTrait [
 	"test that when we add a method to a  trait in a classic category (*not beginning with *), this method is added to the parent package of the class"
-	
-	|tmpPackage trait|
+
+	| tmpPackage trait |
 	self addXCategory.
 
 	tmpPackage := self organizer packageNamed: #XXXXX.
 	trait := self createNewTraitNamed: 'NewClass' inCategory: 'XXXXX'.
 
-	self createMethodNamed: 'stubMethod' inClass:  trait inCategory: 'classic category'.
+	self createMethodNamed: 'stubMethod' inClass: trait inCategory: 'classic category'.
 
 	self assert: (trait package includesDefinedSelector: #stubMethod ofClass: trait).
-	self assert: ((trait >> #stubMethod) packageFromOrganizer: self organizer ) = trait package
+	self assert: (trait >> #stubMethod packageFromOrganizer: self organizer) equals: trait package
 ]
 
 { #category : #'tests - operations on methods' }
 RPackageMethodsSynchronisationTest >> testModifyMethodByMovingFromClassicCategoryToClassicCategoryDoesNothing [
 	"test that when we move a method from a classic category (not begining with *) to another classic category , the packaging keeps the same"
-	
+
 	| class firstPackage |
 	self addXCategory.
 	firstPackage := self organizer packageNamed: #XXXXX.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
-	self createMethodNamed: 'stubMethod' inClass:  class inCategory: 'classic category'.
+	self createMethodNamed: 'stubMethod' inClass: class inCategory: 'classic category'.
 
 	"this we do"
 	class organization classify: #stubMethod under: 'new category'.
 
 	"this we check"
-	self assert: (class >> #stubMethod) category = 'new category'. 
+	self assert: (class >> #stubMethod) category equals: 'new category'.
 	self assert: (firstPackage includesDefinedSelector: #stubMethod ofClass: class).
 	self deny: (firstPackage includesExtensionSelector: #stubMethod ofClass: class).
-	self assert: ((class >> #stubMethod) packageFromOrganizer: self organizer ) = firstPackage
+	self assert: (class >> #stubMethod packageFromOrganizer: self organizer) equals: firstPackage
 ]
 
 { #category : #'tests - operations on methods' }
 RPackageMethodsSynchronisationTest >> testModifyMethodByMovingFromClassicCategoryToExtensionCategoryMoveItFromClassPackageToExtendingPackage [
 	"test that when we move a method from a classic category (not begining with *) to an extension category , the method is moved from the parent package of the class to the extending package"
-	
-	| class firstPackage secondPackage|
-	self addXYCategory. 
-	firstPackage := self organizer  packageNamed: #XXXXX.
-	secondPackage := self organizer  packageNamed: #YYYYY.
+
+	| class firstPackage secondPackage |
+	self addXYCategory.
+	firstPackage := self organizer packageNamed: #XXXXX.
+	secondPackage := self organizer packageNamed: #YYYYY.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
-	self createMethodNamed: 'stubMethod' inClass:  class inCategory: 'classic category'.
+	self createMethodNamed: 'stubMethod' inClass: class inCategory: 'classic category'.
 
-	class organization classify: #stubMethod under: '*yyyyy'.	
+	class organization classify: #stubMethod under: '*yyyyy'.
 	self deny: (firstPackage includesDefinedSelector: #stubMethod ofClass: class).
 	self assert: (secondPackage includesExtensionSelector: #stubMethod ofClass: class).
-	self assert: ((class >> #stubMethod) packageFromOrganizer: self organizer ) = secondPackage.
-	
+	self assert: (class >> #stubMethod packageFromOrganizer: self organizer) equals: secondPackage.
+
 	class organization classify: #stubMethod under: '*yyyyy-subcategory'.
 	self deny: (firstPackage includesDefinedSelector: #stubMethod ofClass: class).
 	self assert: (secondPackage includesExtensionSelector: #stubMethod ofClass: class).
-	self assert: ((class >> #stubMethod) packageFromOrganizer: self organizer ) = secondPackage.
+	self assert: (class >> #stubMethod packageFromOrganizer: self organizer) equals: secondPackage
 ]
 
 { #category : #'tests - operations on methods' }
 RPackageMethodsSynchronisationTest >> testModifyMethodByMovingFromExtensionCategoryToClassicCategoryMoveItFromExtendingPackageToClassPackage [
-
 	"test that when we move a method from an extension category ( begining with *) to a classic category , the method is moved from the extending package to the parent package of the class"
-	
-	| class firstPackage secondPackage|
+
+	| class firstPackage secondPackage |
 	self addXYCategory.
-	
-	firstPackage := self organizer  packageNamed: #XXXXX.
-	secondPackage := self organizer  packageNamed: #YYYYY.
+
+	firstPackage := self organizer packageNamed: #XXXXX.
+	secondPackage := self organizer packageNamed: #YYYYY.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
-	self createMethodNamed: 'stubMethod' inClass:  class inCategory: '*yyyyy'.
+	self createMethodNamed: 'stubMethod' inClass: class inCategory: '*yyyyy'.
 
 	class organization classify: #stubMethod under: 'classic category'.
 	self assert: (firstPackage includesDefinedSelector: #stubMethod ofClass: class).
 	self deny: (secondPackage includesExtensionSelector: #stubMethod ofClass: class).
-	self assert: ((class >> #stubMethod) packageFromOrganizer: self organizer ) = firstPackage.
+	self assert: (class >> #stubMethod packageFromOrganizer: self organizer) equals: firstPackage
 ]
 
 { #category : #'tests - operations on methods' }
 RPackageMethodsSynchronisationTest >> testModifyMethodByMovingFromExtensionCategoryToExtensionCategoryMoveItFromExtendingPackageToSecondExtendingPackage [
 	"test that when we move a method from an extension category ( begining with *) to another extending package , the method is moved from the extending package to the other extending package"
-	
-	| class XPackage YPackage ZPackage|
+
+	| class XPackage YPackage ZPackage |
 	self addXYZCategory.
-	XPackage := self organizer  packageNamed: #XXXXX.
-	YPackage := self organizer  packageNamed: #YYYYY.
-	ZPackage := self organizer  packageNamed: #ZZZZZ.
+	XPackage := self organizer packageNamed: #XXXXX.
+	YPackage := self organizer packageNamed: #YYYYY.
+	ZPackage := self organizer packageNamed: #ZZZZZ.
 	class := self createNewClassNamed: 'NewClass' inCategory: 'XXXXX'.
-	self createMethodNamed: #newMethod inClass:  class inCategory: '*yyyyy'.
+	self createMethodNamed: #newMethod inClass: class inCategory: '*yyyyy'.
 
 	class organization classify: #newMethod under: '*zzzzz'.
 	self deny: (XPackage includesDefinedSelector: #newMethod ofClass: class).
 	self deny: (YPackage includesExtensionSelector: #newMethod ofClass: class).
 	self assert: (ZPackage includesExtensionSelector: #newMethod ofClass: class).
-	self assert: ((class >> #newMethod) packageFromOrganizer: self organizer ) = ZPackage.
+	self assert: (class >> #newMethod packageFromOrganizer: self organizer) equals: ZPackage
 ]
 
 { #category : #'tests - operations on methods' }
diff --git a/src/MonticelloGUI-Tests/MCSnapshotBrowserTest.class.st b/src/MonticelloGUI-Tests/MCSnapshotBrowserTest.class.st
index f0c3040d7eb..b3ec90f6d13 100644
--- a/src/MonticelloGUI-Tests/MCSnapshotBrowserTest.class.st
+++ b/src/MonticelloGUI-Tests/MCSnapshotBrowserTest.class.st
@@ -268,7 +268,7 @@ MCSnapshotBrowserTest >> testComment [
 
 { #category : #testing }
 MCSnapshotBrowserTest >> testFourColumns [
-	self assert: self listMorphs size = 4.
+	self assert: self listMorphs size equals: 4
 ]
 
 { #category : #testing }
diff --git a/src/Multilingual-Tests/ByteTextConverterTest.class.st b/src/Multilingual-Tests/ByteTextConverterTest.class.st
index 2b9377e644a..873706b5a02 100644
--- a/src/Multilingual-Tests/ByteTextConverterTest.class.st
+++ b/src/Multilingual-Tests/ByteTextConverterTest.class.st
@@ -11,52 +11,48 @@ Class {
 ByteTextConverterTest >> testConversionToFrom [
 	"Non regresson test for http://code.google.com/p/pharo/issues/detail?id=986"
 
-	self assert: (('äöü' convertToEncoding: 'mac-roman') convertFromEncoding: 'mac-roman') = 'äöü'
+	self assert: (('äöü' convertToEncoding: 'mac-roman') convertFromEncoding: 'mac-roman') equals: 'äöü'
 ]
 
 { #category : #testing }
 ByteTextConverterTest >> testLatin2ToUnicodeConversion [
-        | latin2Characters utfCodePoints decodingStream unicodeString |
-
-        latin2Characters := #[16rBE 16rFD 16rE1 16rC8] asString.
+	| latin2Characters utfCodePoints decodingStream unicodeString |
+	latin2Characters := #[16rBE 16rFD 16rE1 16rC8] asString.
 	utfCodePoints := #(16r017E 16rFD 16rE1 16r010C).
-	
+
 	"Converters assume that characters you want to put/get from a stream are Unicode characters"
 	"So our source is a string of latin 2"
-	decodingStream := (MultiByteBinaryOrTextStream 
-                with:  latin2Characters 
-                encoding: 'ISO-8859-2') reset.
+	decodingStream := (MultiByteBinaryOrTextStream with: latin2Characters encoding: 'ISO-8859-2') reset.
 	unicodeString := decodingStream contents.
 	"our sourcelatin2 string contains characters outside latin1"
 	self assert: unicodeString isWideString.
-	self assert: (unicodeString at: 1) charCode = (utfCodePoints at: 1) .
-	self assert: (unicodeString at: 2) charCode = (utfCodePoints at: 2) .
-	self assert: (unicodeString at: 3) charCode = (utfCodePoints at: 3) .
-	self assert: (unicodeString at: 4) charCode = (utfCodePoints at: 4) .
+	self assert: (unicodeString at: 1) charCode equals: (utfCodePoints at: 1).
+	self assert: (unicodeString at: 2) charCode equals: (utfCodePoints at: 2).
+	self assert: (unicodeString at: 3) charCode equals: (utfCodePoints at: 3).
+	self assert: (unicodeString at: 4) charCode equals: (utfCodePoints at: 4)
 ]
 
 { #category : #testing }
 ByteTextConverterTest >> testUnicodeToLatin2Conversion [
-        | latin2Bytes internalString encodingStream encodedBytes  |
-
-        latin2Bytes := #[16rBE 16rFD 16rE1 16rC8] .
-	internalString := String streamContents: [:s | 
-		s nextPut: 16r017E asCharacter;
-		   nextPut: 16rFD asCharacter;
-		  nextPut: 16rE1 asCharacter;
-		  nextPut: 16r010C asCharacter].
+	| latin2Bytes internalString encodingStream encodedBytes |
+	latin2Bytes := #[16rBE 16rFD 16rE1 16rC8].
+	internalString := String
+		streamContents: [ :s | 
+			s
+				nextPut: 16r017E asCharacter;
+				nextPut: 16rFD asCharacter;
+				nextPut: 16rE1 asCharacter;
+				nextPut: 16r010C asCharacter ].
 	"Converters assume that characters you want to put/get from a stream are Unicode characters"
 	"So we use a stream with an encoder, then put the internalString to it"
-	encodingStream := (MultiByteBinaryOrTextStream 
-                with:  String new 
-                encoding: 'ISO-8859-2') reset.
+	encodingStream := (MultiByteBinaryOrTextStream with: String new encoding: 'ISO-8859-2') reset.
 	encodingStream nextPutAll: internalString.
 	"the encoded string in the stream does not contain any characters > 255"
 	encodedBytes := encodingStream binary reset contents.
-	
-	
-	self assert: (encodedBytes at: 1)  = (latin2Bytes at: 1) .
-	self assert: (encodedBytes at: 2)  = (latin2Bytes at: 2) .
-	self assert: (encodedBytes at: 3)  = (latin2Bytes at: 3) .
-	self assert: (encodedBytes at: 4)  = (latin2Bytes at: 4) .
+
+
+	self assert: (encodedBytes at: 1) equals: (latin2Bytes at: 1).
+	self assert: (encodedBytes at: 2) equals: (latin2Bytes at: 2).
+	self assert: (encodedBytes at: 3) equals: (latin2Bytes at: 3).
+	self assert: (encodedBytes at: 4) equals: (latin2Bytes at: 4)
 ]
diff --git a/src/Multilingual-Tests/EUCTextConverterTest.class.st b/src/Multilingual-Tests/EUCTextConverterTest.class.st
index 8b480dddff4..515f1ecb4c7 100644
--- a/src/Multilingual-Tests/EUCTextConverterTest.class.st
+++ b/src/Multilingual-Tests/EUCTextConverterTest.class.st
@@ -9,33 +9,29 @@ Class {
 
 { #category : #testing }
 EUCTextConverterTest >> testEUCJP [
-
-	| encodingName halfwidthKatakanaLetterKa cjkUnifiedIdeograph6CB4 cjkUnifiedIdeograph50BA
-	  encodedHalfwidthKatakanaLetterKa encodedCJKUnifiedIdeograph6CB4 encodedCJKUnifiedIdeograph50BA
-	  japaneseInJapanese |
-
+	| encodingName halfwidthKatakanaLetterKa cjkUnifiedIdeograph6CB4 cjkUnifiedIdeograph50BA encodedHalfwidthKatakanaLetterKa encodedCJKUnifiedIdeograph6CB4 encodedCJKUnifiedIdeograph50BA japaneseInJapanese |
 	encodingName := 'euc-jp'.
 
 	"Example characters taken from: http://www.sljfaq.org/afaq/encodings.html#encodings-EUC-JP"
 	halfwidthKatakanaLetterKa := Character codePoint: 16rFF76.
 	cjkUnifiedIdeograph6CB4 := Character codePoint: 16r6CB3.
 	cjkUnifiedIdeograph50BA := Character codePoint: 16r50BA.
-	
+
 	encodedHalfwidthKatakanaLetterKa := #[16r8E 16rB6].
 	encodedCJKUnifiedIdeograph6CB4 := #[16rB2 16rCF].
 	encodedCJKUnifiedIdeograph50BA := #[16r8F 16rB2 16rB0].
 
-	self assert: ((String with: cjkUnifiedIdeograph6CB4) convertToEncoding: encodingName) asByteArray = encodedCJKUnifiedIdeograph6CB4.
+	self assert: ((String with: cjkUnifiedIdeograph6CB4) convertToEncoding: encodingName) asByteArray equals: encodedCJKUnifiedIdeograph6CB4.
 	"EUCJPTextConverter does not currently support encoding the characters defined in the JIS-X-0201 and JIS-X-0212 standards:"
-	self assert: ((String with: halfwidthKatakanaLetterKa) convertToEncoding: encodingName) asByteArray = #[].
-	self assert: ((String with: cjkUnifiedIdeograph50BA) convertToEncoding: encodingName) asByteArray = #[].
+	self assert: ((String with: halfwidthKatakanaLetterKa) convertToEncoding: encodingName) asByteArray equals: #[].
+	self assert: ((String with: cjkUnifiedIdeograph50BA) convertToEncoding: encodingName) asByteArray equals: #[].
 
-	self assert: (encodedCJKUnifiedIdeograph6CB4 asString convertFromEncoding: encodingName) = (String with: cjkUnifiedIdeograph6CB4).
+	self assert: (encodedCJKUnifiedIdeograph6CB4 asString convertFromEncoding: encodingName) equals: (String with: cjkUnifiedIdeograph6CB4).
 	"EUCJPTextConverter does not currently support decoding the representations that start with the 8E and 8F markers:"
-	self assert: (encodedHalfwidthKatakanaLetterKa asString convertFromEncoding: encodingName) = (String new).
-	self assert: (encodedCJKUnifiedIdeograph50BA asString convertFromEncoding: encodingName) = (String new).
+	self assert: (encodedHalfwidthKatakanaLetterKa asString convertFromEncoding: encodingName) equals: String new.
+	self assert: (encodedCJKUnifiedIdeograph50BA asString convertFromEncoding: encodingName) equals: String new.
 
 
 	japaneseInJapanese := #(16r65E5 16r672C 16r8A9E) collect: [ :codePoint | Character codePoint: codePoint ] as: String.
-	((japaneseInJapanese convertToEncoding: encodingName) convertFromEncoding: encodingName) = japaneseInJapanese.
+	((japaneseInJapanese convertToEncoding: encodingName) convertFromEncoding: encodingName) = japaneseInJapanese
 ]
diff --git a/src/Multilingual-Tests/UTF8TextConverterTest.class.st b/src/Multilingual-Tests/UTF8TextConverterTest.class.st
index e4d353a170c..00eb9210b22 100644
--- a/src/Multilingual-Tests/UTF8TextConverterTest.class.st
+++ b/src/Multilingual-Tests/UTF8TextConverterTest.class.st
@@ -10,13 +10,18 @@ Class {
 { #category : #testing }
 UTF8TextConverterTest >> testNextPutAllStartingAt [
 	"Test that non-ascii ByteString characters are converted correctly when using next:putAll:startingAt:"
-	|converter stream source|
+
+	| converter stream source |
 	converter := UTF8TextConverter new.
 	stream := (String new: 10) writeStream.
-	source := 'abcdefågh'. "Notice å at 7, which is a non-ascii character in latin1-range, hence ByteString encoded"
-converter next: 5 putAll: source startingAt: 5 toStream: stream.
-"C3A5 is twobyte utf8-encoding of å"
-self assert: stream contents asByteArray = #[16r65 16r66 16rC3 16rA5 16r67 16r68] 
+	source := 'abcdefågh'.	"Notice å at 7, which is a non-ascii character in latin1-range, hence ByteString encoded"
+	converter
+		next: 5
+		putAll: source
+		startingAt: 5
+		toStream: stream.
+	"C3A5 is twobyte utf8-encoding of å"
+	self assert: stream contents asByteArray equals: #[16r65 16r66 16rC3 16rA5 16r67 16r68]
 ]
 
 { #category : #testing }
@@ -24,14 +29,12 @@ UTF8TextConverterTest >> testPutSingle2ByteEncodedCharacter [
 	| actual |
 	"Test that the utf8-encoded bytes are stored when stream is ascii.
 	(In the case of internal writeStreams, that its destination is a String)"
-	actual := String streamContents: [ :stream |
-		| converter |
-		converter := UTF8TextConverter new.
-		converter
-			nextPut: $ç
-			toStream: stream ].
-	self assert: actual asByteArray = #[2r11000011  2r10100111]
-	
+	actual := String
+		streamContents: [ :stream | 
+			| converter |
+			converter := UTF8TextConverter new.
+			converter nextPut: $ç toStream: stream ].
+	self assert: actual asByteArray equals: #[2r11000011 2r10100111]
 ]
 
 { #category : #testing }
@@ -39,14 +42,12 @@ UTF8TextConverterTest >> testPutSingle3ByteEncodedCharacter [
 	| actual |
 	"Test that the utf8-encoded bytes are stored when stream is ascii.
 	(In the case of internal writeStreams, that its destination is a String)"
-	actual := String streamContents: [ :stream |
-		| converter |
-		converter := UTF8TextConverter new.
-		converter
-			nextPut: (Unicode value: 16r20AC)
-			toStream: stream ].
-	self assert: actual asByteArray = #[2r11100010 2r10000010 2r10101100]
-	
+	actual := String
+		streamContents: [ :stream | 
+			| converter |
+			converter := UTF8TextConverter new.
+			converter nextPut: (Unicode value: 16r20AC) toStream: stream ].
+	self assert: actual asByteArray equals: #[2r11100010 2r10000010 2r10101100]
 ]
 
 { #category : #testing }
@@ -54,14 +55,12 @@ UTF8TextConverterTest >> testPutSingle4ByteEncodedCharacter [
 	| actual |
 	"Test that the utf8-encoded bytes are stored when stream is ascii.
 	(In the case of internal writeStreams, that its destination is a String)"
-	actual := String streamContents: [ :stream |
-		| converter |
-		converter := UTF8TextConverter new.
-		converter
-			nextPut: (Unicode value: 16r24B62)
-			toStream: stream ].
-	self assert: actual asByteArray = #[2r11110000 2r10100100 2r10101101 2r10100010]
-	
+	actual := String
+		streamContents: [ :stream | 
+			| converter |
+			converter := UTF8TextConverter new.
+			converter nextPut: (Unicode value: 16r24B62) toStream: stream ].
+	self assert: actual asByteArray equals: #[2r11110000 2r10100100 2r10101101 2r10100010]
 ]
 
 { #category : #testing }
@@ -69,14 +68,11 @@ UTF8TextConverterTest >> testPutSingleCharacterBinary [
 	| actual |
 	"Test that the raw 8/32bit representations of Characters/WideCharacters are stored when stream is binary.
 	(In the case of internal writeStreams, that its destination is a ByteArray)"
-	actual := ByteArray streamContents: [ :stream |
-		| converter |
-		converter := UTF8TextConverter new.
-		converter
-			nextPut: $a
-			toStream: stream.
-		converter
-			nextPut: (Unicode value: 16r20AC)
-			toStream: stream ].
-	self assert: actual = #[97 0 0 16r20 16rAC]
+	actual := ByteArray
+		streamContents: [ :stream | 
+			| converter |
+			converter := UTF8TextConverter new.
+			converter nextPut: $a toStream: stream.
+			converter nextPut: (Unicode value: 16r20AC) toStream: stream ].
+	self assert: actual equals: #[97 0 0 16r20 16rAC]
 ]