Generic nonViolators for ReConditions (retry)

src/Refactoring-Core-Tests/ReClassHasSubclassesTest.class.st

@@ -1,24 +1,11 @@
 Class {
 	#name : 'ReClassHasSubclassesTest',
-	#superclass : 'TestCase',
-	#instVars : [
-		'model'
-	],
+	#superclass : 'ReClassesConditionTest',
 	#category : 'Refactoring-Core-Tests-Conditions',
 	#package : 'Refactoring-Core-Tests',
 	#tag : 'Conditions'
 }
 
-{ #category : 'tests' }
-ReClassHasSubclassesTest >> model [
-
-	^ model ifNil: [ model := RBNamespace onEnvironment: (RBClassEnvironment classes: {
-				   MyClassAlpha.
-				   MyClassBeta.
-				   MyClassBetaSibling.
-				   Object })]
-]
-
 { #category : 'tests' }
 ReClassHasSubclassesTest >> testClassDoesNotHaveSubclass [
 	| myClassBeta cond |
@@ -29,7 +16,9 @@ ReClassHasSubclassesTest >> testClassDoesNotHaveSubclass [
 		subclassesList: { #myClassAlpha . #Object }.
 
 	" MyClassAlpha is not a subclass of MyClassBeta "
-	self deny: cond check
+	self deny: cond check.
+	self assert: cond violators equals: { myClassBeta }.
+	self assert: cond nonViolators isEmpty
 ]
 
 { #category : 'tests' }
@@ -42,7 +31,9 @@ ReClassHasSubclassesTest >> testClassHasSubclass [
 		subclassesList: { #MyClassBeta . #MyClassBetaSibling }.
 
 	" MyClassBeta and MyClassBetaSibling ares subclasses of MyClassAlpha "
-	self assert: cond check
+	self assert: cond check.
+	self assert: cond violators isEmpty.
+	self assert: cond nonViolators equals: { myClassAlpha }
 ]
 
 { #category : 'tests' }

src/Refactoring-Core-Tests/ReClassesAreAbstractTest.class.st

@@ -0,0 +1,83 @@
+Class {
+	#name : 'ReClassesAreAbstractTest',
+	#superclass : 'ReClassesConditionTest',
+	#category : 'Refactoring-Core-Tests-Conditions',
+	#package : 'Refactoring-Core-Tests',
+	#tag : 'Conditions'
+}
+
+{ #category : 'tests' }
+ReClassesAreAbstractTest >> testClassIsAbstract [
+	| classNumber cond |
+	classNumber := self model classNamed: #Number.
+
+	cond := ReClassesAreAbstractCondition new 
+		classes: { classNumber }.
+
+	" Number is abstract"
+	self assert: cond check.
+	self assert: cond violators isEmpty.
+	self assert: cond nonViolators equals: { classNumber }
+]
+
+{ #category : 'tests' }
+ReClassesAreAbstractTest >> testClassIsAbstractWithMessage [
+	| classNumber cond |
+	classNumber := self model classNamed: #Number.
+
+	cond := ReClassesAreAbstractCondition new 
+		classes: { classNumber }.
+
+	self assert: cond errorString isEmpty
+]
+
+{ #category : 'tests' }
+ReClassesAreAbstractTest >> testNoClassIsAbstract [
+
+	| concrete cond |
+	concrete := self model classNamed: #Object.
+	cond := ReClassesAreAbstractCondition new classes: { concrete }.
+
+	self deny: cond check.
+	self assert: cond violators equals: { concrete }.
+	self assert: cond nonViolators isEmpty
+]
+
+{ #category : 'tests' }
+ReClassesAreAbstractTest >> testNoClassIsAbstractWithMessage [
+
+	| concrete cond |
+	concrete := self model classNamed: #Object.
+	cond := ReClassesAreAbstractCondition new classes: { concrete }.
+
+	self assert: ('*' , concrete name , '*' match: cond errorString)
+]
+
+{ #category : 'tests' }
+ReClassesAreAbstractTest >> testSomeClassesAreAbstract [
+
+	| abstract concrete cond |
+	abstract := self model classNamed: #Number.
+	concrete := self model classNamed: #Object.
+	cond := ReClassesAreAbstractCondition new classes: {
+			        abstract.
+			        concrete }.
+
+	self deny: cond check.
+	self assert: cond violators equals: { concrete }.
+	self assert: cond nonViolators equals: { abstract }
+]
+
+{ #category : 'tests' }
+ReClassesAreAbstractTest >> testSomeClassesAreAbstractWithMessage [
+
+	| abstract concrete cond |
+	abstract := self model classNamed: #Number.
+	concrete := self model classNamed: #Object.
+	cond := ReClassesAreAbstractCondition new classes: {
+			        abstract.
+			        concrete }.
+
+	self assert: ('*' , concrete name , '*' match: cond errorString).
+	self deny: ('*' , abstract name , '*' match: cond errorString)
+]

src/Refactoring-Core-Tests/ReClassesAreNotMetaClassConditionTest.class.st → src/Refactoring-Core-Tests/ReClassesAreNotMetaClassTest.class.st

@@ -2,22 +2,15 @@
 A ReClassesAreNotMetaClassConditionTest is a test class for testing the behavior of ReClassesAreNotMetaClassCondition
 "
 Class {
-	#name : 'ReClassesAreNotMetaClassConditionTest',
-	#superclass : 'TestCase',
+	#name : 'ReClassesAreNotMetaClassTest',
+	#superclass : 'ReClassesConditionTest',
 	#category : 'Refactoring-Core-Tests-Conditions',
 	#package : 'Refactoring-Core-Tests',
 	#tag : 'Conditions'
 }
 
-{ #category : 'accessing' }
-ReClassesAreNotMetaClassConditionTest >> model [
-
-	^ RBNamespace onEnvironment:
-		  (RBClassEnvironment classes: {MyClassARoot . MySubAccessingSuperclassState} )
-]
-
-{ #category : 'accessing' }
-ReClassesAreNotMetaClassConditionTest >> testClassIsAMetaclass [
+{ #category : 'tests' }
+ReClassesAreNotMetaClassTest >> testClassIsAMetaclass [
 
 	| myClassARoot cond |
 	myClassARoot := self model classNamed: #MyClassARoot.
@@ -27,11 +20,12 @@ ReClassesAreNotMetaClassConditionTest >> testClassIsAMetaclass [
 
 	self deny: cond check. 
 	self deny: cond violators isEmpty.
+	self assert: cond nonViolators isEmpty
 
 ]
 
-{ #category : 'accessing' }
-ReClassesAreNotMetaClassConditionTest >> testClassIsAMetaclassWithMessages [
+{ #category : 'tests' }
+ReClassesAreNotMetaClassTest >> testClassIsAMetaclassWithMessages [
 
 	| myClassARoot cond |
 	myClassARoot := self model classNamed: #MyClassARoot.
@@ -45,8 +39,8 @@ ReClassesAreNotMetaClassConditionTest >> testClassIsAMetaclassWithMessages [
 
 ]
 
-{ #category : 'accessing' }
-ReClassesAreNotMetaClassConditionTest >> testClassIsAMetaclassWithoutMessages [
+{ #category : 'tests' }
+ReClassesAreNotMetaClassTest >> testClassIsAMetaclassWithoutMessages [
 
 	| myClassARoot cond |
 	myClassARoot := self model classNamed: #MyClassARoot.
@@ -60,8 +54,8 @@ ReClassesAreNotMetaClassConditionTest >> testClassIsAMetaclassWithoutMessages [
 
 ]
 
-{ #category : 'accessing' }
-ReClassesAreNotMetaClassConditionTest >> testClassIsNotAMetaclass [
+{ #category : 'tests' }
+ReClassesAreNotMetaClassTest >> testClassIsNotAMetaclass [
 
 	| myClassARoot cond |
 	myClassARoot := self model classNamed: #MyClassARoot.
@@ -71,5 +65,6 @@ ReClassesAreNotMetaClassConditionTest >> testClassIsNotAMetaclass [
 
 	self assert: cond check. 
 	self assert: cond violators isEmpty.
+	self assert: cond nonViolators equals: { myClassARoot }
 
 ]

src/Refactoring-Core-Tests/ReClassesConditionTest.class.st

@@ -0,0 +1,25 @@
+Class {
+	#name : 'ReClassesConditionTest',
+	#superclass : 'TestCase',
+	#instVars : [
+		'model'
+	],
+	#category : 'Refactoring-Core-Tests-Conditions',
+	#package : 'Refactoring-Core-Tests',
+	#tag : 'Conditions'
+}
+
+{ #category : 'tests' }
+ReClassesConditionTest >> model [
+
+	^ model ifNil: [
+			  model := RBNamespace onEnvironment: (RBClassEnvironment classes: {
+						            MyClassAlpha.
+						            MyClassBeta.
+						            MyClassBetaSibling.
+						            MyClassARoot.
+						            MySubAccessingSuperclassState.
+						            MyClassB.
+						            Object.
+						            Number }) ]
+]

src/Refactoring-Core-Tests/ReClassesEmptyTest.class.st

@@ -0,0 +1,94 @@
+Class {
+	#name : 'ReClassesEmptyTest',
+	#superclass : 'ReClassesConditionTest',
+	#category : 'Refactoring-Core-Tests-Conditions',
+	#package : 'Refactoring-Core-Tests',
+	#tag : 'Conditions'
+}
+
+{ #category : 'tests' }
+ReClassesEmptyTest >> testClassIsEmpty [
+
+	| empty cond |
+	empty := self model classNamed: #MyClassB.
+
+	cond := ReClassesEmptyCondition new 
+		classes: { empty }.
+
+	self assert: cond check. 
+	self assert: cond violators isEmpty.
+	self assert: cond nonViolators equals: { empty }
+
+]
+
+{ #category : 'tests' }
+ReClassesEmptyTest >> testClassIsEmptyWithMessage [
+
+	| empty cond |
+	empty := self model classNamed: #MyClassB.
+
+	cond := ReClassesEmptyCondition new 
+		classes: { empty }.
+
+	self assert: cond errorString isEmpty
+
+]
+
+{ #category : 'tests' }
+ReClassesEmptyTest >> testClassIsNotEmpty [
+
+	| full cond |
+	full := self model classNamed: #MyClassAlpha.
+
+	cond := ReClassesEmptyCondition new 
+		classes: { full }.
+
+	self deny: cond check. 
+	self assert: cond violators equals: { full }.
+	self assert: cond nonViolators isEmpty
+
+]
+
+{ #category : 'tests' }
+ReClassesEmptyTest >> testClassIsNotEmptyWithMessage [
+
+	| full cond |
+	full := self model classNamed: #MyClassAlpha.
+
+	cond := ReClassesEmptyCondition new 
+		classes: { full }.
+
+	self assert: ('*' , full name , '*' match: cond errorString)
+
+]
+
+{ #category : 'tests' }
+ReClassesEmptyTest >> testSomeClassesAreEmpty [
+
+	| full empty cond |
+	full := self model classNamed: #MyClassAlpha.
+	empty := self model classNamed: #MyClassB.
+
+	cond := ReClassesEmptyCondition new 
+		classes: { full . empty }.
+
+	self deny: cond check. 
+	self assert: cond violators equals: { full }.
+	self assert: cond nonViolators equals: { empty }
+
+]
+
+{ #category : 'tests' }
+ReClassesEmptyTest >> testSomeClassesAreEmptyWithMessage [
+
+	| full empty cond |
+	full := self model classNamed: #MyClassAlpha.
+	empty := self model classNamed: #MyClassB.
+
+	cond := ReClassesEmptyCondition new 
+		classes: { full . empty }.
+
+	self assert: ('*' , full name , '*' match: cond errorString).
+	self deny: ('*' , empty name , '*' match: cond errorString).
+
+]