[squeak-dev] The Trunk: KernelTests-fbs.256.mcz
commits at source.squeak.org
commits at source.squeak.org
Tue Nov 5 19:09:28 UTC 2013
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.!
More information about the Squeak-dev
mailing list
|