| author | Claus Gittinger <cg@exept.de> |
| Wed, 02 Jun 1999 12:48:57 +0200 | |
| changeset 14 | bbcc61e38aaf |
| parent 13 | 45a348a410e8 |
| child 15 | 99df9ea7f146 |
| 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 |
|
| 13 | 136 |
"Large - Large addition" |
137 |
||
138 |
self test:[(16r100000000 - 16r7FFFFFFF ) hexPrintString = '80000001']. |
|
139 |
self test:[(16r100000000 - 16r80000000 ) hexPrintString = '80000000']. |
|
140 |
self test:[(16r100000000 - 16rFFFFFFFF ) hexPrintString = '1']. |
|
| 14 | 141 |
self test:[(16r100000000 - 1 ) hexPrintString = 'FFFFFFFF']. |
142 |
self test:[(16r100000000 - 16r10000000 ) hexPrintString = 'F0000000']. |
|
|
12
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 |
"Large - small subtraction" |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
145 |
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
|
146 |
self test:[(20 factorial - 10 factorial + 3628800) printString = '2432902008176640000']. |
| 14 | 147 |
self test:[(20 factorial - 11 factorial + 39916800) printString = '2432902008176640000']. |
148 |
self test:[(20 factorial - 12 factorial + 479001600) printString = '2432902008176640000']. |
|
149 |
self test:[(20 factorial - 13 factorial + 6227020800) printString = '2432902008176640000']. |
|
150 |
self test:[(20 factorial - 14 factorial + 87178291200) printString = '2432902008176640000']. |
|
151 |
self test:[(20 factorial - 15 factorial + 1307674368000) printString = '2432902008176640000']. |
|
152 |
self test:[(20 factorial - 16 factorial + 20922789888000) printString = '2432902008176640000']. |
|
| 13 | 153 |
self test:[(20 factorial + 10 factorial - 3628800) printString = '2432902008176640000']. |
|
12
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
154 |
|
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
155 |
" |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
156 |
self testLargeAddition |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
157 |
" |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
158 |
|
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
159 |
"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
|
160 |
! |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
161 |
|
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
162 |
testLargeDivision |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
163 |
|t| |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
164 |
|
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
165 |
t := 20 factorial. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
166 |
|
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
167 |
"Large // SmallInt division" |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
168 |
t := t // 20. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
169 |
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
|
170 |
t := t // 19. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
171 |
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
|
172 |
t := t // 18. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
173 |
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
|
174 |
t := t // 17. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
175 |
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
|
176 |
t := t // 16. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
177 |
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
|
178 |
t := t // 15. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
179 |
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
|
180 |
t := t // 14. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
181 |
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
|
182 |
t := t // 13. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
183 |
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
|
184 |
t := t // 12. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
185 |
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
|
186 |
t := t // 11. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
187 |
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
|
188 |
self test:[t == 10 factorial]. |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
189 |
|
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
190 |
"Large // Large division" |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
191 |
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
|
192 |
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
|
193 |
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
|
194 |
|
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
195 |
" |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
196 |
self testLargeDivision |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
197 |
" |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
198 |
|
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
199 |
"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
|
200 |
! |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
201 |
|
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
202 |
testLargeMultiplication |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
203 |
|t1| |
|
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
204 |
|
| 3 | 205 |
"multiplication" |
206 |
t1 := 100. |
|
207 |
self test:[t1 * t1 == 10000]. |
|
| 10 | 208 |
self test:[(t1 perform:'*' asSymbol with:t1) == 10000]. |
| 11 | 209 |
self test:[(t1 * t1) printString = '10000']. |
210 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '10000']. |
|
211 |
||
| 3 | 212 |
t1 := 1000. |
213 |
self test:[t1 * t1 == 1000000]. |
|
| 10 | 214 |
self test:[(t1 perform:'*' asSymbol with:t1) == 1000000]. |
| 11 | 215 |
self test:[(t1 * t1) printString = '1000000']. |
216 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '1000000']. |
|
217 |
||
| 3 | 218 |
t1 := 10000. |
219 |
self test:[t1 * t1 == 100000000]. |
|
| 10 | 220 |
self test:[(t1 perform:'*' asSymbol with:t1) == 100000000]. |
| 11 | 221 |
self test:[(t1 * t1) printString = '100000000']. |
222 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '100000000']. |
|
223 |
||
| 3 | 224 |
t1 := 100000. |
225 |
SmallInteger maxBytes == 4 ifTrue:[ |
|
| 10 | 226 |
self test:[t1 * t1 = 10000000000]. |
227 |
self test:[(t1 perform:'*' asSymbol with:t1) = 10000000000]. |
|
| 3 | 228 |
]. |
229 |
SmallInteger maxBytes == 8 ifTrue:[ |
|
230 |
self test:[t1 * t1 == 10000000000]. |
|
| 10 | 231 |
self test:[(t1 perform:'*' asSymbol with:t1) == 10000000000]. |
| 3 | 232 |
]. |
| 4 | 233 |
|
| 11 | 234 |
self test:[(t1 * t1) printString = '10000000000']. |
| 4 | 235 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '10000000000']. |
| 11 | 236 |
|
| 3 | 237 |
t1 := 1000000. |
238 |
self test:[(t1 * t1) printString = '1000000000000']. |
|
| 11 | 239 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '1000000000000']. |
240 |
||
| 3 | 241 |
t1 := 10000000. |
242 |
self test:[(t1 * t1) printString = '100000000000000']. |
|
| 11 | 243 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '100000000000000']. |
244 |
||
| 3 | 245 |
t1 := 100000000. |
246 |
self test:[(t1 * t1) printString = '10000000000000000']. |
|
| 11 | 247 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '10000000000000000']. |
248 |
||
| 3 | 249 |
t1 := 1000000000. |
250 |
self test:[(t1 * t1) printString = '1000000000000000000']. |
|
| 11 | 251 |
self test:[(t1 perform:'*' asSymbol with:t1) printString = '1000000000000000000']. |
252 |
||
| 2 | 253 |
|
| 3 | 254 |
"Large * SmallInt multiplication" |
255 |
self test:[10 factorial printString = '3628800']. |
|
256 |
self test:[20 factorial printString = '2432902008176640000']. |
|
257 |
self test:[100 factorial printString = '93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000']. |
|
258 |
self test:[1000 factorial printString = '402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000']. |
|
| 2 | 259 |
|
| 3 | 260 |
"Large * Large multiplication" |
261 |
self test:[(20 factorial * 20 factorial) printString = '5919012181389927685417441689600000000']. |
|
| 7 | 262 |
|
263 |
" |
|
|
12
29d0f2e59dcb
splitted into smaller methods to avoid JIT-bail-out
Claus Gittinger <cg@exept.de>
parents:
11
diff
changeset
|
264 |
self testLargeMultiplication |
| 7 | 265 |
" |
| 10 | 266 |
|
| 11 | 267 |
"Modified: / 20.5.1999 / 09:41:19 / cg" |
| 7 | 268 |
! |
269 |
||
270 |
testPrinting1 |
|
271 |
self test:[10 printString = '10']. |
|
272 |
self test:[100 printString = '100']. |
|
273 |
self test:[1000 printString = '1000']. |
|
274 |
self test:[10000 printString = '10000']. |
|
275 |
self test:[100000 printString = '100000']. |
|
276 |
self test:[1000000 printString = '1000000']. |
|
277 |
self test:[10000000 printString = '10000000']. |
|
278 |
self test:[100000000 printString = '100000000']. |
|
279 |
self test:[1000000000 printString = '1000000000']. |
|
280 |
self test:[10000000000 printString = '10000000000']. |
|
281 |
self test:[100000000000 printString = '100000000000']. |
|
282 |
self test:[1000000000000 printString = '1000000000000']. |
|
283 |
self test:[10000000000000 printString = '10000000000000']. |
|
284 |
self test:[100000000000000 printString = '100000000000000']. |
|
285 |
self test:[1000000000000000 printString = '1000000000000000']. |
|
286 |
self test:[10000000000000000 printString = '10000000000000000']. |
|
287 |
self test:[100000000000000000 printString = '100000000000000000']. |
|
288 |
||
289 |
" |
|
290 |
self testPrinting1 |
|
291 |
" |
|
292 |
! |
|
293 |
||
294 |
testReading1 |
|
295 |
|t| |
|
296 |
||
| 5 | 297 |
self test:[(Integer readFrom:'4865804016353280000') printString = '4865804016353280000']. |
298 |
self test:[(Integer readFrom:'FFFFFFFF' radix:16) hexPrintString = 'FFFFFFFF']. |
|
299 |
self test:[(Integer readFrom:'FFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFF']. |
|
300 |
self test:[(Integer readFrom:'FFFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFFF']. |
|
301 |
self test:[(Integer readFrom:'FFFFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFFFF']. |
|
302 |
self test:[(Integer readFrom:'FFFFFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFFFFF']. |
|
303 |
||
304 |
self test:[(Integer readFrom:'10000000' radix:16) hexPrintString = '10000000']. |
|
305 |
self test:[(Integer readFrom:'100000000' radix:16) hexPrintString = '100000000']. |
|
306 |
self test:[(Integer readFrom:'1000000000' radix:16) hexPrintString = '1000000000']. |
|
307 |
self test:[(Integer readFrom:'10000000000' radix:16) hexPrintString = '10000000000']. |
|
308 |
self test:[(Integer readFrom:'100000000000' radix:16) hexPrintString = '100000000000']. |
|
309 |
||
310 |
t := Integer readFrom:'FFFFFFFF' radix:16. |
|
311 |
self test:[(t + 1) hexPrintString = '100000000']. |
|
312 |
t := Integer readFrom:'FFFFFFFFF' radix:16. |
|
313 |
self test:[(t + 1) hexPrintString = '1000000000']. |
|
314 |
t := Integer readFrom:'FFFFFFFFFF' radix:16. |
|
315 |
self test:[(t + 1) hexPrintString = '10000000000']. |
|
316 |
t := Integer readFrom:'FFFFFFFFFFF' radix:16. |
|
317 |
self test:[(t + 1) hexPrintString = '100000000000']. |
|
318 |
||
319 |
t := Integer readFrom:'10000000' radix:16. |
|
320 |
self test:[(t + 1) hexPrintString = '10000001']. |
|
321 |
t := Integer readFrom:'100000000' radix:16. |
|
322 |
self test:[(t + 1) hexPrintString = '100000001']. |
|
323 |
t := Integer readFrom:'1000000000' radix:16. |
|
324 |
self test:[(t + 1) hexPrintString = '1000000001']. |
|
325 |
t := Integer readFrom:'10000000000' radix:16. |
|
326 |
self test:[(t + 1) hexPrintString = '10000000001']. |
|
327 |
||
| 2 | 328 |
" |
| 7 | 329 |
self testReading1 |
| 2 | 330 |
" |
331 |
! ! |
|
332 |
||
333 |
!IntegerTest class methodsFor:'documentation'! |
|
334 |
||
335 |
version |
|
336 |
^ '$Header$' |
|
337 |
! ! |