author | Claus Gittinger <cg@exept.de> |
Tue, 01 Jun 1999 17:32:21 +0200 | |
changeset 12 | 29d0f2e59dcb |
parent 11 | 30bdd5912a36 |
child 13 | 45a348a410e8 |
permissions | -rw-r--r-- |
2 | 1 |
Object subclass:#IntegerTest |
2 |
instanceVariableNames:'' |
|
3 |
classVariableNames:'' |
|
4 |
poolDictionaries:'' |
|
5 |
category:'Tests - Numbers' |
|
6 |
! |
|
7 |
||
8 |
||
4 | 9 |
!IntegerTest class methodsFor:'misc'! |
10 |
||
11 |
testPlus1_a:arg |
|
12 |
^ arg + 1 |
|
13 |
||
14 |
" |
|
15 |
(self testPlus1_a:SmallInteger maxVal) = 1073741824 |
|
16 |
" |
|
17 |
! |
|
18 |
||
19 |
testPlus1_b:arg |
|
20 |
^ arg perform:#+ with:1 |
|
21 |
||
22 |
" |
|
23 |
(self testPlus1_b:SmallInteger maxVal) == 1073741824 |
|
24 |
" |
|
25 |
! ! |
|
26 |
||
3 | 27 |
!IntegerTest class methodsFor:'private'! |
2 | 28 |
|
29 |
test:aBlock |
|
3 | 30 |
aBlock value == true ifFalse:[ |
2 | 31 |
self halt:'test failed' |
32 |
] |
|
33 |
! ! |
|
34 |
||
35 |
!IntegerTest class methodsFor:'tests'! |
|
36 |
||
37 |
test1 |
|
10 | 38 |
"general conversion & arithmetic tests. |
39 |
Notice, the arithmetic tests are both performed via regular sends |
|
40 |
and via constructed performs. The reason is to test both inlined |
|
41 |
JIT-compiler code AND the regular methods code." |
|
2 | 42 |
|
3 | 43 |
|minVal maxVal maxValPlus1 minValMinus1 halfMin halfMax t t1 t2| |
44 |
||
45 |
minVal := SmallInteger perform:('minVal' asSymbol). |
|
46 |
maxVal := SmallInteger perform:('maxVal' asSymbol). |
|
47 |
||
48 |
self test:[minVal == SmallInteger minVal]. |
|
49 |
self test:[maxVal == SmallInteger maxVal]. |
|
2 | 50 |
|
9 | 51 |
t := SmallInteger perform:('maxBytes' asSymbol). |
52 |
self test:[t == SmallInteger maxBytes]. |
|
53 |
t := SmallInteger perform:('maxBits' asSymbol). |
|
54 |
self test:[t == SmallInteger maxBits]. |
|
55 |
||
7 | 56 |
self testPrinting1. |
2 | 57 |
|
58 |
SmallInteger maxBytes == 4 ifTrue:[ |
|
3 | 59 |
self test:[minVal hexPrintString = '-40000000']. |
60 |
self test:[maxVal hexPrintString = '3FFFFFFF']. |
|
61 |
self test:[minVal == -1073741824]. |
|
62 |
self test:[maxVal == 1073741823]. |
|
2 | 63 |
maxValPlus1 := 1073741824. |
64 |
minValMinus1 := -1073741825. |
|
65 |
self test:[minValMinus1 hexPrintString = '-40000001']. |
|
66 |
self test:[maxValPlus1 hexPrintString = '40000000']. |
|
3 | 67 |
halfMin := -16r20000000. |
68 |
halfMax := 16r20000000. |
|
2 | 69 |
]. |
70 |
SmallInteger maxBytes == 8 ifTrue:[ |
|
3 | 71 |
self test:[minVal hexPrintString = '-4000000000000000']. |
72 |
self test:[maxVal hexPrintString = '3FFFFFFFFFFFFFFF']. |
|
73 |
self test:[minVal == -4611686018427387904]. |
|
74 |
self test:[maxVal == 4611686018427387903]. |
|
2 | 75 |
maxValPlus1 := 4611686018427387904. |
76 |
minValMinus1 := -4611686018427387905. |
|
77 |
self test:[minValMinus1 hexPrintString = '-4000000000000001']. |
|
78 |
self test:[maxValPlus1 hexPrintString = '4000000000000000']. |
|
3 | 79 |
halfMin := -16r2000000000000000. |
80 |
halfMax := 16r2000000000000000. |
|
2 | 81 |
]. |
82 |
||
83 |
"arithmetic overFlow checks" |
|
84 |
||
4 | 85 |
"/ self test:[(maxVal + 1) inspect.maxValPlus1 inspect. true]. |
6 | 86 |
self test:[(maxVal perform:'+' asSymbol with:1) = maxValPlus1]. |
87 |
self test:[(maxVal + 1) = maxValPlus1]. |
|
88 |
self test:[(minVal perform:'-' asSymbol with:1) = minValMinus1]. |
|
89 |
self test:[(minVal - 1) = minValMinus1]. |
|
3 | 90 |
|
6 | 91 |
self test:[(halfMax perform:'+' asSymbol with:halfMax) = maxValPlus1]. |
3 | 92 |
self test:[(halfMax + halfMax) = maxValPlus1]. |
6 | 93 |
self test:[(halfMin perform:'+' asSymbol with:halfMin) == minVal]. |
3 | 94 |
self test:[(halfMin + halfMin) == minVal]. |
6 | 95 |
self test:[(halfMax perform:'*' asSymbol with:2) = maxValPlus1]. |
3 | 96 |
self test:[(halfMax * 2) = maxValPlus1]. |
6 | 97 |
self test:[(halfMin perform:'*' asSymbol with:2) == minVal]. |
3 | 98 |
self test:[(halfMin * 2) == minVal]. |
6 | 99 |
self test:[(maxValPlus1 perform:'//' asSymbol with:2) == halfMax]. |
100 |
self test:[(maxValPlus1 // 2) == halfMax]. |
|
101 |
self test:[(halfMax perform:'bitShift:' asSymbol with:1) = maxValPlus1]. |
|
102 |
self test:[(halfMin perform:'bitShift:' asSymbol with:1) == minVal]. |
|
3 | 103 |
self test:[(halfMax bitShift:1) = maxValPlus1]. |
104 |
self test:[(halfMin bitShift:1) == minVal]. |
|
105 |
||
106 |
"LargeInt op -> SmallInt result" |
|
107 |
t := maxVal + 1. |
|
108 |
self test:[t - 1 == maxVal]. |
|
109 |
t := minVal - 1. |
|
110 |
self test:[t + 1 == minVal]. |
|
111 |
||
12
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
112 |
self testLargeMultiplication. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
113 |
self testLargeDivision. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
114 |
self testLargeAddition. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
115 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
116 |
" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
117 |
self test1 |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
118 |
" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
119 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
120 |
"Modified: / 20.5.1999 / 09:41:19 / cg" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
121 |
! |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
122 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
123 |
testLargeAddition |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
124 |
"general conversion & arithmetic tests. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
125 |
Notice, the arithmetic tests are both performed via regular sends |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
126 |
and via constructed performs. The reason is to test both inlined |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
127 |
JIT-compiler code AND the regular methods code." |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
128 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
129 |
"Large + Large addition" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
130 |
self testReading1. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
131 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
132 |
self test:[(20 factorial + 20 factorial) printString = '4865804016353280000']. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
133 |
self test:[(20 factorial + 1) printString = '2432902008176640001']. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
134 |
self test:[(20 factorial + 1000) printString = '2432902008176641000']. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
135 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
136 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
137 |
"Large - small subtraction" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
138 |
self test:[(20 factorial + 20 factorial - 1) printString = '4865804016353279999']. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
139 |
self test:[(20 factorial - 10 factorial + 3628800) printString = '2432902008176640000']. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
140 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
141 |
" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
142 |
self testLargeAddition |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
143 |
" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
144 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
145 |
"Modified: / 20.5.1999 / 09:41:19 / cg" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
146 |
! |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
147 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
148 |
testLargeDivision |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
149 |
|t| |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
150 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
151 |
t := 20 factorial. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
152 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
153 |
"Large // SmallInt division" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
154 |
t := t // 20. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
155 |
self test:[t printString = 19 factorial printString]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
156 |
t := t // 19. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
157 |
self test:[t printString = 18 factorial printString]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
158 |
t := t // 18. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
159 |
self test:[t printString = 17 factorial printString]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
160 |
t := t // 17. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
161 |
self test:[t printString = 16 factorial printString]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
162 |
t := t // 16. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
163 |
self test:[t printString = 15 factorial printString]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
164 |
t := t // 15. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
165 |
self test:[t printString = 14 factorial printString]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
166 |
t := t // 14. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
167 |
self test:[t printString = 13 factorial printString]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
168 |
t := t // 13. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
169 |
self test:[t printString = 12 factorial printString]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
170 |
t := t // 12. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
171 |
self test:[t printString = 11 factorial printString]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
172 |
t := t // 11. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
173 |
self test:[t printString = 10 factorial printString]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
174 |
self test:[t == 10 factorial]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
175 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
176 |
"Large // Large division" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
177 |
self test:[(10000 factorial / 9999 factorial) == 10000]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
178 |
self test:[(20 factorial / 19 factorial) == 20]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
179 |
self test:[(20 factorial * 21 / 20 / 21) = (19 factorial)]. |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
180 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
181 |
" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
182 |
self testLargeDivision |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
183 |
" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
184 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
185 |
"Modified: / 20.5.1999 / 09:41:19 / cg" |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
186 |
! |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
187 |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
188 |
testLargeMultiplication |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
189 |
|t1| |
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
190 |
|
3 | 191 |
"multiplication" |
192 |
t1 := 100. |
|
193 |
self test:[t1 * t1 == 10000]. |
|
10 | 194 |
self test:[(t1 perform:'*' asSymbol with:t1) == 10000]. |
11 | 195 |
self test:[(t1 * t1) printString = '10000']. |
196 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '10000']. |
|
197 |
||
3 | 198 |
t1 := 1000. |
199 |
self test:[t1 * t1 == 1000000]. |
|
10 | 200 |
self test:[(t1 perform:'*' asSymbol with:t1) == 1000000]. |
11 | 201 |
self test:[(t1 * t1) printString = '1000000']. |
202 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '1000000']. |
|
203 |
||
3 | 204 |
t1 := 10000. |
205 |
self test:[t1 * t1 == 100000000]. |
|
10 | 206 |
self test:[(t1 perform:'*' asSymbol with:t1) == 100000000]. |
11 | 207 |
self test:[(t1 * t1) printString = '100000000']. |
208 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '100000000']. |
|
209 |
||
3 | 210 |
t1 := 100000. |
211 |
SmallInteger maxBytes == 4 ifTrue:[ |
|
10 | 212 |
self test:[t1 * t1 = 10000000000]. |
213 |
self test:[(t1 perform:'*' asSymbol with:t1) = 10000000000]. |
|
3 | 214 |
]. |
215 |
SmallInteger maxBytes == 8 ifTrue:[ |
|
216 |
self test:[t1 * t1 == 10000000000]. |
|
10 | 217 |
self test:[(t1 perform:'*' asSymbol with:t1) == 10000000000]. |
3 | 218 |
]. |
4 | 219 |
|
11 | 220 |
self test:[(t1 * t1) printString = '10000000000']. |
4 | 221 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '10000000000']. |
11 | 222 |
|
3 | 223 |
t1 := 1000000. |
224 |
self test:[(t1 * t1) printString = '1000000000000']. |
|
11 | 225 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '1000000000000']. |
226 |
||
3 | 227 |
t1 := 10000000. |
228 |
self test:[(t1 * t1) printString = '100000000000000']. |
|
11 | 229 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '100000000000000']. |
230 |
||
3 | 231 |
t1 := 100000000. |
232 |
self test:[(t1 * t1) printString = '10000000000000000']. |
|
11 | 233 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '10000000000000000']. |
234 |
||
3 | 235 |
t1 := 1000000000. |
236 |
self test:[(t1 * t1) printString = '1000000000000000000']. |
|
11 | 237 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '1000000000000000000']. |
238 |
||
2 | 239 |
|
3 | 240 |
"Large * SmallInt multiplication" |
241 |
self test:[10 factorial printString = '3628800']. |
|
242 |
self test:[20 factorial printString = '2432902008176640000']. |
|
243 |
self test:[100 factorial printString = '93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000']. |
|
244 |
self test:[1000 factorial printString = '402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000']. |
|
2 | 245 |
|
3 | 246 |
"Large * Large multiplication" |
247 |
self test:[(20 factorial * 20 factorial) printString = '5919012181389927685417441689600000000']. |
|
7 | 248 |
|
249 |
" |
|
12
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
250 |
self testLargeMultiplication |
7 | 251 |
" |
10 | 252 |
|
11 | 253 |
"Modified: / 20.5.1999 / 09:41:19 / cg" |
7 | 254 |
! |
255 |
||
256 |
testPrinting1 |
|
257 |
self test:[10 printString = '10']. |
|
258 |
self test:[100 printString = '100']. |
|
259 |
self test:[1000 printString = '1000']. |
|
260 |
self test:[10000 printString = '10000']. |
|
261 |
self test:[100000 printString = '100000']. |
|
262 |
self test:[1000000 printString = '1000000']. |
|
263 |
self test:[10000000 printString = '10000000']. |
|
264 |
self test:[100000000 printString = '100000000']. |
|
265 |
self test:[1000000000 printString = '1000000000']. |
|
266 |
self test:[10000000000 printString = '10000000000']. |
|
267 |
self test:[100000000000 printString = '100000000000']. |
|
268 |
self test:[1000000000000 printString = '1000000000000']. |
|
269 |
self test:[10000000000000 printString = '10000000000000']. |
|
270 |
self test:[100000000000000 printString = '100000000000000']. |
|
271 |
self test:[1000000000000000 printString = '1000000000000000']. |
|
272 |
self test:[10000000000000000 printString = '10000000000000000']. |
|
273 |
self test:[100000000000000000 printString = '100000000000000000']. |
|
274 |
||
275 |
" |
|
276 |
self testPrinting1 |
|
277 |
" |
|
278 |
! |
|
279 |
||
280 |
testReading1 |
|
281 |
|t| |
|
282 |
||
5 | 283 |
self test:[(Integer readFrom:'4865804016353280000') printString = '4865804016353280000']. |
284 |
self test:[(Integer readFrom:'FFFFFFFF' radix:16) hexPrintString = 'FFFFFFFF']. |
|
285 |
self test:[(Integer readFrom:'FFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFF']. |
|
286 |
self test:[(Integer readFrom:'FFFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFFF']. |
|
287 |
self test:[(Integer readFrom:'FFFFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFFFF']. |
|
288 |
self test:[(Integer readFrom:'FFFFFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFFFFF']. |
|
289 |
||
290 |
self test:[(Integer readFrom:'10000000' radix:16) hexPrintString = '10000000']. |
|
291 |
self test:[(Integer readFrom:'100000000' radix:16) hexPrintString = '100000000']. |
|
292 |
self test:[(Integer readFrom:'1000000000' radix:16) hexPrintString = '1000000000']. |
|
293 |
self test:[(Integer readFrom:'10000000000' radix:16) hexPrintString = '10000000000']. |
|
294 |
self test:[(Integer readFrom:'100000000000' radix:16) hexPrintString = '100000000000']. |
|
295 |
||
296 |
t := Integer readFrom:'FFFFFFFF' radix:16. |
|
297 |
self test:[(t + 1) hexPrintString = '100000000']. |
|
298 |
t := Integer readFrom:'FFFFFFFFF' radix:16. |
|
299 |
self test:[(t + 1) hexPrintString = '1000000000']. |
|
300 |
t := Integer readFrom:'FFFFFFFFFF' radix:16. |
|
301 |
self test:[(t + 1) hexPrintString = '10000000000']. |
|
302 |
t := Integer readFrom:'FFFFFFFFFFF' radix:16. |
|
303 |
self test:[(t + 1) hexPrintString = '100000000000']. |
|
304 |
||
305 |
t := Integer readFrom:'10000000' radix:16. |
|
306 |
self test:[(t + 1) hexPrintString = '10000001']. |
|
307 |
t := Integer readFrom:'100000000' radix:16. |
|
308 |
self test:[(t + 1) hexPrintString = '100000001']. |
|
309 |
t := Integer readFrom:'1000000000' radix:16. |
|
310 |
self test:[(t + 1) hexPrintString = '1000000001']. |
|
311 |
t := Integer readFrom:'10000000000' radix:16. |
|
312 |
self test:[(t + 1) hexPrintString = '10000000001']. |
|
313 |
||
2 | 314 |
" |
7 | 315 |
self testReading1 |
2 | 316 |
" |
317 |
! ! |
|
318 |
||
319 |
!IntegerTest class methodsFor:'documentation'! |
|
320 |
||
321 |
version |
|
322 |
^ '$Header$' |
|
323 |
! ! |