The Trunk: KernelTests-fbs.256.mcz

Frank Shearar uploaded a new version of KernelTests to project The Trunk:
http://source.squeak.org/trunk/KernelTests-fbs.256.mcz

==================== Summary ====================

Name: KernelTests-fbs.256
Author: fbs
Time: 5 November 2013, 7:09:16.145 pm
UUID: 0bdb93b9-b1b6-574f-98bb-0aefc4fac4b1
Ancestors: KernelTests-cmm.255

More #shouldnt:raise: Error removals. ClassBuilderTest's makeFooSubclassOf: methods now return a thing rather than setting an instvar, because really. It's just easier to read, and side effects where unnecessary are bad.

=============== Diff against KernelTests-cmm.255 ===============

Item was changed:
  ----- Method: BehaviorTest>>testBehaviorSubclasses (in category 'tests') -----
  testBehaviorSubclasses
        "self run: #testBehaviorSubclasses"

        | b b2 |
        b := Behavior new.
        b superclass: OrderedCollection.
        b methodDictionary: MethodDictionary new.
+
-       self shouldnt: [b subclasses ] raise: Error.
-       self shouldnt: [b withAllSubclasses] raise: Error.
-       self shouldnt: [b allSubclasses] raise: Error.
        b2 := Behavior new.
        b2 superclass: b.
        b2 methodDictionary: MethodDictionary new.
+
        self assert: (b subclasses includes: b2).
+       self deny: (b subclasses includes: b).
+
+       self assert: (b withAllSubclasses includes: b).
+
+       self assert: (b allSubclasses includes: b2).!
-       self assert: (b withAllSubclasses includes: b).!

Item was changed:
  ----- Method: BlockClosureTest>>testCull (in category 'tests - evaluating') -----
  testCull
+       self assert: nil equals: ([ ] cull: 1).
+       self assert: 1 equals: ([ :x | ] cull: 1).
-
-       self shouldnt: [ [ ] cull: 1 ] raise: Error.
-       self shouldnt: [ [ :x | ] cull: 1 ] raise: Error.
        self should: [ [ :x :y | ] cull: 1 ] raise: Error.
        self should: [ [ :x :y :z | ] cull: 1 ] raise: Error.
        self should: [ [ :x :y :z :a | ] cull: 1 ] raise: Error.
        self should: [ [ :x :y :z :a :b | ] cull: 1 ] raise: Error.
        self assert: ([ 0 ] cull: 1) = 0.
        self assert: ([ :x | x ] cull: 1) = 1   !

Item was changed:
  ----- Method: BlockClosureTest>>testCullCull (in category 'tests - evaluating') -----
  testCullCull
+       self assert: nil equals: ([ ] cull: 1 cull: 2).
+       self assert: 1 equals: ([ :x | ] cull: 1 cull: 2).
+       self assert: 2 equals: ([ :x :y | ] cull: 1 cull: 2).
-
-       self shouldnt: [ [ ] cull: 1 cull: 2 ] raise: Error.
-       self shouldnt: [ [ :x | ] cull: 1 cull: 2 ] raise: Error.
-       self shouldnt: [ [ :x :y | ] cull: 1 cull: 2 ] raise: Error.
        self should: [ [ :x :y :z | ] cull: 1 cull: 2 ] raise: Error.
        self should: [ [ :x :y :z :a | ] cull: 1 cull: 2 ] raise: Error.
        self should: [ [ :x :y :z :a :b | ] cull: 1 cull: 2 ] raise: Error.
        self assert: ([ 0 ] cull: 1 cull: 2) = 0.
        self assert: ([ :x | x ] cull: 1 cull: 2) = 1.
        self assert: ([ :x :y | y ] cull: 1 cull: 2) = 2.       !

Item was changed:
  ----- Method: BlockClosureTest>>testCullCullCull (in category 'tests - evaluating') -----
  testCullCullCull
+       self assert: nil equals: ([ ] cull: 1 cull: 2 cull: 3).
+       self assert: 1 equals: ([ :x | ] cull: 1 cull: 2 cull: 3).
+       self assert: 2 equals: ([ :x :y | ] cull: 1 cull: 2 cull: 3).
+       self assert: 3 equals: ([ :x :y :z | ] cull: 1 cull: 2 cull: 3).
-
-       self shouldnt: [ [ ] cull: 1 cull: 2 cull: 3 ] raise: Error.
-       self shouldnt: [ [ :x | ] cull: 1 cull: 2 cull: 3 ] raise: Error.
-       self shouldnt: [ [ :x :y | ] cull: 1 cull: 2 cull: 3 ] raise: Error.
-       self shouldnt: [ [ :x :y :z | ] cull: 1 cull: 2 cull: 3 ] raise: Error.
        self should: [ [ :x :y :z :a | ] cull: 1 cull: 2 cull: 3 ] raise: Error.
        self should: [ [ :x :y :z :a :b | ] cull: 1 cull: 2 cull: 3 ] raise: Error.
        self assert: ([ 0 ] cull: 1 cull: 2 cull: 3) = 0.
        self assert: ([ :x | x ] cull: 1 cull: 2 cull: 3) = 1.
        self assert: ([ :x :y | y ] cull: 1 cull: 2 cull: 3) = 2.
        self assert: ([ :x :y :z | z ] cull: 1 cull: 2 cull: 3) = 3.    !

Item was changed:
  ----- Method: BlockClosureTest>>testCullCullCullCull (in category 'tests - evaluating') -----
  testCullCullCullCull
+       self assert: nil equals: ([ ] cull: 1 cull: 2 cull: 3 cull: 4).
+       self assert: 1 equals: ([ :x | ] cull: 1 cull: 2 cull: 3 cull: 4).
+       self assert: 2 equals: ([ :x :y | ] cull: 1 cull: 2 cull: 3 cull: 4).
+       self assert: 3 equals: ([ :x :y :z | ] cull: 1 cull: 2 cull: 3 cull: 4).
+       self assert: 4 equals: ([ :x :y :z :a | ] cull: 1 cull: 2 cull: 3 cull: 4).
-
-       self shouldnt: [ [ ] cull: 1 cull: 2 cull: 3 cull: 4 ] raise: Error.
-       self shouldnt: [ [ :x | ] cull: 1 cull: 2 cull: 3 cull: 4 ] raise: Error.
-       self shouldnt: [ [ :x :y | ] cull: 1 cull: 2 cull: 3 cull: 4 ] raise: Error.
-       self shouldnt: [ [ :x :y :z | ] cull: 1 cull: 2 cull: 3 cull: 4 ] raise: Error.
-       self shouldnt: [ [ :x :y :z :a | ] cull: 1 cull: 2 cull: 3 cull: 4 ] raise: Error.
        self should: [ [ :x :y :z :a :b | ] cull: 1 cull: 2 cull: 3 cull: 4 ] raise: Error.
        self assert: ([ 0 ] cull: 1 cull: 2 cull: 3 cull: 4) = 0.
        self assert: ([ :x | x ] cull: 1 cull: 2 cull: 3 cull: 4) = 1.
        self assert: ([ :x :y | y ] cull: 1 cull: 2 cull: 3 cull: 4) = 2.
        self assert: ([ :x :y :z | z ] cull: 1 cull: 2 cull: 3 cull: 4) = 3.
        self assert: ([ :x :y :z :a | a ] cull: 1 cull: 2 cull: 3 cull: 4) = 4.!

Item was changed:
  ----- Method: ClassBuilderTest>>makeByteVariableSubclassOf: (in category 'utilities') -----
  makeByteVariableSubclassOf: aClass
+       ^ aClass variableByteSubclass: self subClassName
-       subClass := aClass variableByteSubclass: self subClassName
                instanceVariableNames: ''
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses!

Item was changed:
  ----- Method: ClassBuilderTest>>makeIVarsSubclassOf: (in category 'utilities') -----
  makeIVarsSubclassOf: aClass
+       ^ aClass subclass: self subClassName
-       subClass := aClass subclass: self subClassName
                instanceVariableNames: 'var3 var4'
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses!

Item was changed:
  ----- Method: ClassBuilderTest>>makeNormalSubclassOf: (in category 'utilities') -----
  makeNormalSubclassOf: aClass
+       ^ aClass subclass: self subClassName
-       subClass := aClass subclass: self subClassName
                instanceVariableNames: ''
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses!

Item was changed:
  ----- Method: ClassBuilderTest>>makeVariableSubclassOf: (in category 'utilities') -----
  makeVariableSubclassOf: aClass
+       ^ aClass variableSubclass: self subClassName
-       subClass := aClass variableSubclass: self subClassName
                instanceVariableNames: ''
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses!

Item was changed:
  ----- Method: ClassBuilderTest>>makeWeakSubclassOf: (in category 'utilities') -----
  makeWeakSubclassOf: aClass
+       ^ aClass weakSubclass: self subClassName
-       subClass := aClass weakSubclass: self subClassName
                instanceVariableNames: ''
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses!

Item was changed:
  ----- Method: ClassBuilderTest>>makeWordVariableSubclassOf: (in category 'utilities') -----
  makeWordVariableSubclassOf: aClass
+       ^ aClass variableWordSubclass: self subClassName
-       subClass := aClass variableWordSubclass: self subClassName
                instanceVariableNames: ''
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses!

Item was changed:
  ----- Method: ClassBuilderTest>>testByteVariableSubclass (in category 'testing - format') -----
  testByteVariableSubclass
        "Ensure that the invariants for superclass/subclass format are preserved"
        baseClass := Object variableByteSubclass: self baseClassName
                instanceVariableNames: ''
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses.
        [

+       subClass := self makeNormalSubclassOf: baseClass.
-       self shouldnt:[self makeNormalSubclassOf: baseClass] raise: Error.
        self deny: (subClass isPointers).
        self assert: (subClass isVariable).
        self deny: (subClass isWeak).
        self assert: (subClass isBytes).
        subClass removeFromSystem.

        "pointer classes"
        self should:[self makeIVarsSubclassOf: baseClass] raise: Error.
        self should:[self makeVariableSubclassOf: baseClass] raise: Error.
        self should:[self makeWeakSubclassOf: baseClass] raise: Error.

        "bit classes"
+       subClass := self makeByteVariableSubclassOf: baseClass.
-       self shouldnt:[self makeByteVariableSubclassOf: baseClass] raise: Error.
        self deny: (subClass isPointers).
        self assert: (subClass isVariable).
        self deny: (subClass isWeak).
        self assert: (subClass isBytes).
        subClass removeFromSystem.

        self should:[self makeWordVariableSubclassOf: baseClass] raise: Error.

        ] ensure:[self cleanup].!

Item was changed:
  ----- Method: ClassBuilderTest>>testChangeToVariableSubclass (in category 'testing - format') -----
  testChangeToVariableSubclass
        "Ensure that the invariants for superclass/subclass format are preserved"
        baseClass := Object subclass: self baseClassName
                instanceVariableNames: ''
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses.
        [
+               baseClass := Object variableSubclass: self baseClassName
-               self shouldnt:[baseClass := Object variableSubclass: self baseClassName
                        instanceVariableNames: ''
                        classVariableNames: ''
                        poolDictionaries: ''
+                       category: self categoryNameForTemporaryClasses.
-                       category: self categoryNameForTemporaryClasses] raise: Error.

        ] ensure:[self cleanup].!

Item was changed:
  ----- Method: ClassBuilderTest>>testDuplicateClassVariableError (in category 'testing - reshape') -----
  testDuplicateClassVariableError
        baseClass := Object subclass: self baseClassName
                instanceVariableNames: ''
                classVariableNames: 'TestVar'
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses.

        self should:[
                subClass := baseClass subclass: self subClassName
                        instanceVariableNames: ''
                        classVariableNames: 'TestVar'
                        poolDictionaries: ''
                        category: self categoryNameForTemporaryClasses
        ] raise: DuplicateVariableError.

        [subClass := baseClass subclass: self subClassName
                        instanceVariableNames: ''
                        classVariableNames: 'TestVar'
                        poolDictionaries: ''
                        category: self categoryNameForTemporaryClasses
        ] on: DuplicateVariableError do:[:ex|
                self assert: ex superclass == baseClass.
                self assert: ex variable = 'TestVar'.
                ex resume.
        ].

+       baseClass := Object subclass: self baseClassName
+               instanceVariableNames: ''
+               classVariableNames: ''
+               poolDictionaries: ''
+               category: self categoryNameForTemporaryClasses.
-       self shouldnt:[
-               baseClass := Object subclass: self baseClassName
-                       instanceVariableNames: ''
-                       classVariableNames: ''
-                       poolDictionaries: ''
-                       category: self categoryNameForTemporaryClasses.
-       ] raise: Error.

        self should:[
                baseClass := Object subclass: self baseClassName
                        instanceVariableNames: ''
                        classVariableNames: 'TestVar'
                        poolDictionaries: ''
                        category: self categoryNameForTemporaryClasses.
        ] raise: DuplicateVariableError.

        [baseClass := Object subclass: self baseClassName
                        instanceVariableNames: ''
                        classVariableNames: 'TestVar'
                        poolDictionaries: ''
                        category: self categoryNameForTemporaryClasses.
        ] on: DuplicateVariableError do:[:ex|
                self assert: ex superclass == baseClass.
                self assert: ex variable = 'TestVar'.
                ex resume.
        ].!

Item was changed:
  ----- Method: ClassBuilderTest>>testDuplicateInstanceVariableError (in category 'testing - reshape') -----
  testDuplicateInstanceVariableError
        baseClass := Object subclass: self baseClassName
                instanceVariableNames: 'var'
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses.

        self should:[
                subClass := baseClass subclass: self subClassName
                        instanceVariableNames: 'var'
                        classVariableNames: ''
                        poolDictionaries: ''
                        category: self categoryNameForTemporaryClasses
        ] raise: DuplicateVariableError.

        [subClass := baseClass subclass: self subClassName
                        instanceVariableNames: 'var'
                        classVariableNames: ''
                        poolDictionaries: ''
                        category: self categoryNameForTemporaryClasses
        ] on: DuplicateVariableError do:[:ex|
                self assert: ex superclass == baseClass.
                self assert: ex variable = 'var'.
                ex resume.
        ].

+       baseClass := Object subclass: self baseClassName
+               instanceVariableNames: ''
+               classVariableNames: ''
+               poolDictionaries: ''
+               category: self categoryNameForTemporaryClasses.
-       self shouldnt:[
-               baseClass := Object subclass: self baseClassName
-                       instanceVariableNames: ''
-                       classVariableNames: ''
-                       poolDictionaries: ''
-                       category: self categoryNameForTemporaryClasses.
-       ] raise: Error.

        self should:[
                baseClass := Object subclass: self baseClassName
                        instanceVariableNames: 'var'
                        classVariableNames: ''
                        poolDictionaries: ''
                        category: self categoryNameForTemporaryClasses.
        ] raise: DuplicateVariableError.

        [baseClass := Object subclass: self baseClassName
                        instanceVariableNames: 'var'
                        classVariableNames: ''
                        poolDictionaries: ''
                        category: self categoryNameForTemporaryClasses.
        ] on: DuplicateVariableError do:[:ex|
                self assert: ex superclass == baseClass.
                self assert: ex variable = 'var'.
                ex resume.
        ].!

Item was changed:
  ----- Method: ClassBuilderTest>>testSubclass (in category 'testing - format') -----
  testSubclass
        "Ensure that the invariants for superclass/subclass format are preserved"
        baseClass := Object subclass: self baseClassName
                instanceVariableNames: ''
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses.
        [
+       subClass := self makeNormalSubclassOf: baseClass.
-       self shouldnt:[self makeNormalSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self deny: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

        "pointer classes"
+       subClass := self makeIVarsSubclassOf: baseClass.
-       self shouldnt:[self makeIVarsSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self deny: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

+       subClass := self makeVariableSubclassOf: baseClass.
-       self shouldnt:[self makeVariableSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert:(subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

+       subClass := self makeWeakSubclassOf: baseClass.
-       self shouldnt:[self makeWeakSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert:(subClass isVariable).
        self assert:(subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

        "bit classes"
+       subClass := self makeByteVariableSubclassOf: baseClass.
-       self shouldnt:[self makeByteVariableSubclassOf: baseClass] raise: Error.
        self deny: (subClass isPointers).
        self assert: (subClass isVariable).
        self deny: (subClass isWeak).
        self assert: (subClass isBytes).
        subClass removeFromSystem.

+       subClass := self makeWordVariableSubclassOf: baseClass.
-       self shouldnt:[self makeWordVariableSubclassOf: baseClass] raise: Error.
        self deny: (subClass isPointers).
        self assert: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.
        ] ensure:[self cleanup].!

Item was changed:
  ----- Method: ClassBuilderTest>>testSubclassWithInstanceVariables (in category 'testing - format') -----
  testSubclassWithInstanceVariables
        "Ensure that the invariants for superclass/subclass format are preserved"
        baseClass := Object subclass: self baseClassName
                instanceVariableNames: 'var1 var2'
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses.
        [
+       subClass := self makeNormalSubclassOf: baseClass.
-       self shouldnt:[self makeNormalSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self deny: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

        "pointer classes"
+       subClass := self makeIVarsSubclassOf: baseClass.
-       self shouldnt:[self makeIVarsSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self deny: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

+       subClass := self makeVariableSubclassOf: baseClass.
-       self shouldnt:[self makeVariableSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

+       subClass := self makeWeakSubclassOf: baseClass.
-       self shouldnt:[self makeWeakSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert: (subClass isVariable).
        self assert: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

        "bit classes"
        self should:[self makeByteVariableSubclassOf: baseClass] raise: Error.
        self should:[self makeWordVariableSubclassOf: baseClass] raise: Error.
        ] ensure:[self cleanup].!

Item was changed:
  ----- Method: ClassBuilderTest>>testVariableSubclass (in category 'testing - format') -----
  testVariableSubclass
        "Ensure that the invariants for superclass/subclass format are preserved"
        baseClass := Object variableSubclass: self baseClassName
                instanceVariableNames: ''
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses.
        [
        "pointer classes"
+       subClass := self makeNormalSubclassOf: baseClass.
-       self shouldnt:[self makeNormalSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

+       subClass := self makeIVarsSubclassOf: baseClass.
-       self shouldnt:[self makeIVarsSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

+       subClass := self makeVariableSubclassOf: baseClass.
-       self shouldnt:[self makeVariableSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

+       subClass := self makeWeakSubclassOf: baseClass.
-       self shouldnt:[self makeWeakSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert: (subClass isVariable).
        self assert: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

        "bit classes"
        self should:[self makeByteVariableSubclassOf: baseClass] raise: Error.
        self should:[self makeWordVariableSubclassOf: baseClass] raise: Error.
        ] ensure:[self cleanup].!

Item was changed:
  ----- Method: ClassBuilderTest>>testWeakSubclass (in category 'testing - format') -----
  testWeakSubclass
        "Ensure that the invariants for superclass/subclass format are preserved"
        baseClass := Object weakSubclass: self baseClassName
                instanceVariableNames: ''
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses.
        [
        "pointer classes"
+       subClass := self makeNormalSubclassOf: baseClass.
-       self shouldnt:[self makeNormalSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert: (subClass isVariable).
        self assert: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

+       subClass := self makeIVarsSubclassOf: baseClass.
-       self shouldnt:[self makeIVarsSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert: (subClass isVariable).
        self assert: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

+       subClass := self makeVariableSubclassOf: baseClass.
-       self shouldnt:[self makeVariableSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

+       subClass := self makeWeakSubclassOf: baseClass.
-       self shouldnt:[self makeWeakSubclassOf: baseClass] raise: Error.
        self assert: (subClass isPointers).
        self assert: (subClass isVariable).
        self assert: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

        "bit classes"
        self should:[self makeByteVariableSubclassOf: baseClass] raise: Error.
        self should:[self makeWordVariableSubclassOf: baseClass] raise: Error.
        ] ensure:[self cleanup].!

Item was changed:
  ----- Method: ClassBuilderTest>>testWordVariableSubclass (in category 'testing - format') -----
  testWordVariableSubclass
        "Ensure that the invariants for superclass/subclass format are preserved"
        baseClass := Object variableWordSubclass: self baseClassName
                instanceVariableNames: ''
                classVariableNames: ''
                poolDictionaries: ''
                category: self categoryNameForTemporaryClasses.
        [
+       subClass := self makeNormalSubclassOf: baseClass.
-       self shouldnt:[self makeNormalSubclassOf: baseClass] raise: Error.
        self deny: (subClass isPointers).
        self assert: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.

        "pointer classes"
        self should:[self makeIVarsSubclassOf: baseClass] raise: Error.
        self should:[self makeVariableSubclassOf: baseClass] raise: Error.
        self should:[self makeWeakSubclassOf: baseClass] raise: Error.

        "bit classes"
        self should:[self makeByteVariableSubclassOf: baseClass] raise: Error.
+       subClass := self makeWordVariableSubclassOf: baseClass.
-       self shouldnt:[self makeWordVariableSubclassOf: baseClass] raise: Error.
        self deny: (subClass isPointers).
        self assert: (subClass isVariable).
        self deny: (subClass isWeak).
        self deny: (subClass isBytes).
        subClass removeFromSystem.
-
        ] ensure:[self cleanup].!

Item was changed:
  ----- Method: ClassTest>>testCompileAll (in category 'testing - compiling') -----
  testCompileAll
+       "We expect this to succeed."
+       ClassTest compileAll.!
-
-       self shouldnt: [ClassTest compileAll] raise: Error.!

Item was changed:
  ----- Method: DateAndTimeTest>>testErrorWhenDayIsAfterMonthEnd (in category 'Tests') -----
  testErrorWhenDayIsAfterMonthEnd

        self
                should:
                        [DateAndTime
                                year: 2004
                                month: 2
                                day: 30]
+               raise: Error.!
-               raise: Error.
-
-       self
-               shouldnt:
-                       [DateAndTime
-                               year: 2004
-                               month: 2
-                               day: 29]
-               raise: Error.
-       !

Item was changed:
  ----- Method: DateAndTimeTest>>testErrorWhenDayIsBeforeMonthStart (in category 'Tests') -----
  testErrorWhenDayIsBeforeMonthStart

        self
                should:
                        [DateAndTime
                                year: 2004
                                month: 2
                                day: -1]
                raise: Error.

        self
                should:
                        [DateAndTime
                                year: 2004
                                month: 2
                                day: 0]
+               raise: Error.!
-               raise: Error.
-
-       self
-               shouldnt:
-                       [DateAndTime
-                               year: 2004
-                               month: 2
-                               day: 1]
-               raise: Error.
-       !

Item was changed:
  ----- Method: DelayTest>>testBounds (in category 'testing-limits') -----
  testBounds
        "self run: #testBounds"

        self should: [Delay forMilliseconds: -1] raise: Error.
+
+       "We expect these to succeed."
+       Delay forMilliseconds: SmallInteger maxVal + 1.
+       (Delay forMilliseconds: Float pi) wait. "Wait 3ms"
-       self shouldnt: [Delay forMilliseconds: SmallInteger maxVal + 1] raise: Error.
-       self shouldnt: [(Delay forMilliseconds: Float pi) wait] raise: Error. "Wait 3ms"
  !

Item was changed:
  ----- Method: DurationTest>>testAgo (in category 'testing') -----
  testAgo
-
-       self shouldnt: [10 hours ago] raise: Error.
-       self shouldnt: [0 seconds ago] raise: Error.
-       self shouldnt: [-5 days ago] raise: Error.
        self assert: ((10 minutes ago) isMemberOf: DateAndTime).
        self assert: ((10 weeks ago) < DateAndTime now).
+       self assert: ((-50 seconds ago) > DateAndTime now).
+       self assert: ((10 hours ago) < DateAndTime now).
+       self assert: (0 seconds ago - DateAndTime now < 1 second).!
-       self assert: ((-50 seconds ago) > DateAndTime now).!

Item was changed:
  ----- Method: DurationTest>>testFromNow (in category 'testing') -----
  testFromNow

+       self assert: ((10 seconds fromNow) > DateAndTime now).
+       self assert: ((0 days fromNow - DateAndTime now) < 1 second).
+       self assert: ((-1 weeks fromNow) < DateAndTime now).
-       self shouldnt: [10 seconds fromNow] raise: Error.
-       self shouldnt: [0 days fromNow] raise: Error.
-       self shouldnt: [-1 weeks fromNow] raise: Error.
        self assert: ((1000 milliSeconds fromNow) isMemberOf: DateAndTime).
        self assert: ((250 hours fromNow) > DateAndTime now).
        self assert: ((-50 minutes fromNow) < DateAndTime now).!

Item was changed:
  ----- Method: FloatTest>>testDegreeCos (in category 'tests - mathematical functions') -----
  testDegreeCos
-       self shouldnt: [ 45.0 degreeCos] raise: Error.
        "Following tests use approximate equality, because cosine are generally evaluated using inexact Floating point arithmetic"
        self assert: (45.0 degreeCos squared - 0.5) abs <= Float epsilon.
        self assert: (60.0 degreeCos - 0.5) abs <= Float epsilon.
        self assert: (120.0 degreeCos + 0.5) abs <= Float epsilon.
        -360.0 to: 360.0 do: [:i |
                self assert: (i degreeCos closeTo: i degreesToRadians cos)].

        "Following tests use strict equality which is a requested property of degreeCos"
        -10.0 to: 10.0 do: [:k |
                self assert: (k*360 + 90) degreeCos = 0.
                self assert: (k*360 - 90) degreeCos = 0.
                self assert: (k*360 + 180) degreeCos + 1 = 0.
                self assert: (k*360) degreeCos - 1 = 0.].!

Item was changed:
  ----- Method: FloatTest>>testDegreeSin (in category 'tests - mathematical functions') -----
  testDegreeSin
-       self shouldnt: [ 45.0 degreeSin] raise: Error.
        "Following tests use approximate equality, because sine are generally evaluated using inexact Floating point arithmetic"
        self assert: (45.0 degreeSin squared - 0.5) abs <= Float epsilon.
        self assert: (30.0 degreeSin - 0.5) abs <= Float epsilon.
        self assert: (-30.0 degreeSin + 0.5) abs <= Float epsilon.
        -360.0 to: 360.0 do: [:i |
                self assert: (i degreeSin closeTo: i degreesToRadians sin)].

        "Following tests use strict equality which is a requested property of degreeSin"
        -10.0 to: 10.0 do: [:k |
                self assert: (k*360 + 90) degreeSin - 1 = 0.
                self assert: (k*360 - 90) degreeSin + 1= 0.
                self assert: (k*360 + 180) degreeSin = 0.
                self assert: (k*360) degreeSin = 0.].!

Item was changed:
  ----- Method: FractionTest>>testDegreeCos (in category 'tests - mathematical functions') -----
  testDegreeCos
        "self run: #testDegreeCos"

-       self shouldnt: [ (4/3) degreeCos] raise: Error.
        -361/3 to: 359/3 do: [:i |
                self assert: (i degreeCos closeTo: i degreesToRadians cos)].!

Item was changed:
  ----- Method: FractionTest>>testDegreeSin (in category 'tests - mathematical functions') -----
  testDegreeSin
        "self run: #testDegreeSin"
+
-
-       self shouldnt: [ (4/3) degreeSin] raise: Error.
        -361/3 to: 359/3 do: [:i |
                self assert: (i degreeSin closeTo: i degreesToRadians sin)].!

Item was changed:
  ----- Method: InstVarRefLocatorTest>>testInstructions (in category 'tests') -----
  testInstructions
-
-
-
        Object methodDict do: [:method | | scanner printer end |
                scanner := InstructionStream on: method.
                printer := InstVarRefLocator new.
                end := scanner method endPC.

                [scanner pc <= end] whileTrue: [
+                       printer interpretNextInstructionUsing: scanner.
-                       self shouldnt: [printer interpretNextInstructionUsing: scanner] raise: Error.
                ].
        ].!

Item was changed:
  ----- Method: InstructionClientTest>>testInstructions (in category 'tests') -----
  testInstructions
        "just interpret all of methods of Object"

        | client |
        client := InstructionClient new.
        Object methodDict do: [:method |
+               | scanner |
+               scanner := (InstructionStream on: method).
+               [scanner pc <= method endPC] whileTrue: [
+                       scanner interpretNextInstructionFor: client]].
-                       | scanner |
-                       scanner := (InstructionStream on: method).
-                       [scanner pc <= method endPC] whileTrue: [
-                                       self shouldnt: [scanner interpretNextInstructionFor: client] raise: Error.
-                       ].
-       ].
  !

Item was changed:
  ----- Method: InstructionPrinterTest>>testInstructions (in category 'tests') -----
  testInstructions
        "just print all of methods of Object and see if no error accours"

        | printer |
        printer  := InstructionPrinter.
        Object methodDict do: [:method |
+               String streamContents: [:stream |
+                       (printer on: method) printInstructionsOn: stream]].
-                                       self shouldnt: [
-                                               String streamContents: [:stream |
-                                                       (printer on: method) printInstructionsOn: stream]] raise: Error.
-                       ].
  !

Item was changed:
  ----- Method: IntegerTest>>testDegreeCos (in category 'tests - mathematical functions') -----
  testDegreeCos
        "self run: #testDegreeCos"

-       self shouldnt: [ 45 degreeCos] raise: Error.
        "Following tests use approximate equality, because cosine are generally evaluated using inexact Floating point arithmetic"
        self assert: (45 degreeCos squared - (1/2)) abs <= Float epsilon.
        self assert: (60 degreeCos - (1/2)) abs <= Float epsilon.
        self assert: (120 degreeCos + (1/2)) abs <= Float epsilon.
        -360 to: 360 do: [:i |
                self assert: (i degreeCos closeTo: i degreesToRadians cos)].

        "Following tests use strict equality which is a requested property of degreeCos"
        -10 to: 10 do: [:k |
                self assert: (k*360 + 90) degreeCos = 0.
                self assert: (k*360 - 90) degreeCos = 0.
                self assert: (k*360 + 180) degreeCos + 1 = 0.
                self assert: (k*360) degreeCos - 1 = 0.].!

Item was changed:
  ----- Method: IntegerTest>>testDegreeSin (in category 'tests - mathematical functions') -----
  testDegreeSin
        "self run: #testDegreeSin"

-       self shouldnt: [ 45 degreeSin] raise: Error.
-
        "Following tests use approximate equality, because sine are generally evaluated using inexact Floating point arithmetic"
        self assert: (45 degreeSin squared - (1/2)) abs <= Float epsilon.
        self assert: (30 degreeSin - (1/2)) abs <= Float epsilon.
        self assert: (-30 degreeSin + (1/2)) abs <= Float epsilon.
        -360 to: 360 do: [:i |
                self assert: (i degreeSin closeTo: i degreesToRadians sin)].

        "Following tests use strict equality which is a requested property of degreeSin"
        -10 to: 10 do: [:k |
                self assert: (k*360 + 90) degreeSin - 1 = 0.
                self assert: (k*360 - 90) degreeSin + 1= 0.
                self assert: (k*360 + 180) degreeSin = 0.
                self assert: (k*360) degreeSin = 0].!

Item was changed:
  ----- Method: MethodPragmaTest>>testReformat (in category 'testing-printing-reformating') -----
  testReformat
-
-
        self assert: (DisplayScreen class compiledMethodAt: #actualScreenDepth) getSource string = 'actualScreenDepth
        <primitive: ''primitiveScreenDepth''>
        ^ Display depth'.
-

-       self shouldnt: [ DisplayScreen class reformatMethodAt: #actualScreenDepth] raise: Error.
-
        self assert: (DisplayScreen class compiledMethodAt: #actualScreenDepth) getSource string = 'actualScreenDepth
        <primitive: ''primitiveScreenDepth''>
        ^ Display depth'.
  !

Item was changed:
  ----- Method: NumberTest>>testPrintShowingDecimalPlaces2 (in category 'tests') -----
  testPrintShowingDecimalPlaces2
        "This tests problems related to Float>>rounded and Float>>roundTo::
        - Float>>#rounded is inexact
        - Float>>#roundTo: might overflow"

        "5000000000000001.0 asTrueFraction = 5000000000000001.
        5000000000000001 highBit = 53.
        This number is represented exactly asFloat, it should print exactly"
        self assert: (5000000000000001.0 printShowingDecimalPlaces: 0) = '5000000000000001'.

        "50000000000001.25 asTrueFraction = (200000000000005/4).
        200000000000005 highBit = 48, 4 isPowerOfTwo,
        So this number is also represented exactly as Float, it should print exactly.
        Beware: (50000000000001.25 / 0.01) rounded exhibit the same problem as above."
        self assert: (50000000000001.25 printShowingDecimalPlaces: 2) = '50000000000001.25'.

        "This number is close to maximum float value"
+       self assert: '1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000' equals: (1.0e306 printShowingDecimalPlaces: 3).!
-       self shouldnt: [1.0e306 printShowingDecimalPlaces: 3] raise: Error.!

Item was changed:
  ----- Method: ObjectTest>>testAssert (in category 'tests - debugging') -----
  testAssert
+       Object assert: [true].
+       Object assert: true.
-
-       self shouldnt: [Object assert: [true]] raise: Error.
-       self shouldnt: [Object assert: true] raise: Error.
        self should: [Object assert: [false]] raise: AssertionFailure.
        self should: [Object assert: false] raise: AssertionFailure.!

Item was changed:
  ----- Method: ObjectTest>>testHaltIf (in category 'tests - testing') -----
  testHaltIf

        self should: [self haltIf: true] raise: Halt.
+       self haltIf: false.
-       self shouldnt: [self haltIf: false] raise: Halt.

        self should: [self haltIf: [true]] raise: Halt.
+       self haltIf: [false].
-       self shouldnt: [self haltIf: [false]] raise: Halt.

        self should: [self haltIf: #testHaltIf.] raise: Halt.
+       self haltIf: #teadfasdfltIf.
-       self shouldnt: [self haltIf: #teadfasdfltIf.] raise: Halt.

        self should: [self a] raise: Halt.
+       self a1.
-       self shouldnt: [self a1] raise: Halt.

        self should: [self haltIf: [:o | o class = self class]] raise: Halt.
+       self haltIf: [:o | o class ~= self class].
-       self shouldnt: [self haltIf: [:o | o class ~= self class]] raise: Halt.
  !

Item was changed:
  ----- Method: ProcessTest>>testAtomicSuspend (in category 'tests') -----
  testAtomicSuspend
        "Test atomic suspend of foreign processes"

        | list p sema |
        sema := Semaphore new.
        p := [sema wait] fork.
        Processor yield.
+       list := p suspendPrimitivelyOrFail.
-       self shouldnt: [list := p suspendPrimitivelyOrFail] raise: Error.
        self assert: list == sema.
  !

Item was changed:
  ----- Method: ProtoObjectTest>>testFlag (in category 'tests - testing') -----
  testFlag
+       "This should never throw an exception."
+       ProtoObject new flag: #hallo.!
-
-       self shouldnt: [ProtoObject new flag: #hallo] raise: Error.!