author | sr |
Mon, 18 Sep 2017 11:50:50 +0200 | |
changeset 1701 | 48849326905a |
parent 1596 | 77e41a57cda0 |
child 1709 | 1377a649bd18 |
permissions | -rw-r--r-- |
1447 | 1 |
"{ Package: 'stx:goodies/regression' }" |
310 | 2 |
|
3 |
"{ NameSpace: RegressionTests }" |
|
4 |
||
5 |
TestCase subclass:#SmallIntegerTest |
|
6 |
instanceVariableNames:'' |
|
7 |
classVariableNames:'' |
|
8 |
poolDictionaries:'' |
|
1074 | 9 |
category:'tests-Regression-Numbers' |
310 | 10 |
! |
11 |
||
12 |
||
619
f918fa22ad81
Circumvent compiler error about div by zero
Stefan Vogel <sv@exept.de>
parents:
364
diff
changeset
|
13 |
!SmallIntegerTest class methodsFor:'others'! |
f918fa22ad81
Circumvent compiler error about div by zero
Stefan Vogel <sv@exept.de>
parents:
364
diff
changeset
|
14 |
|
f918fa22ad81
Circumvent compiler error about div by zero
Stefan Vogel <sv@exept.de>
parents:
364
diff
changeset
|
15 |
version_CVS |
f918fa22ad81
Circumvent compiler error about div by zero
Stefan Vogel <sv@exept.de>
parents:
364
diff
changeset
|
16 |
^ '$Header$' |
f918fa22ad81
Circumvent compiler error about div by zero
Stefan Vogel <sv@exept.de>
parents:
364
diff
changeset
|
17 |
! ! |
f918fa22ad81
Circumvent compiler error about div by zero
Stefan Vogel <sv@exept.de>
parents:
364
diff
changeset
|
18 |
|
310 | 19 |
!SmallIntegerTest methodsFor:'tests-arithmetic'! |
20 |
||
1347 | 21 |
testBitShift |
1447 | 22 |
#( |
23 |
(1 1 2) |
|
24 |
(1 2 4) |
|
25 |
(1 3 8) |
|
26 |
(1 7 16r080) |
|
27 |
(1 8 16r100) |
|
28 |
(1 15 16r08000) |
|
29 |
(1 16 16r10000) |
|
30 |
(1 17 16r20000) |
|
31 |
(1 30 16r040000000) |
|
32 |
(1 31 16r080000000) |
|
33 |
(1 32 16r100000000) |
|
34 |
(1 33 16r200000000) |
|
1347 | 35 |
|
1447 | 36 |
(1 62 16r04000000000000000) |
37 |
(1 63 16r08000000000000000) |
|
38 |
(1 64 16r10000000000000000) |
|
39 |
(1 65 16r20000000000000000) |
|
1347 | 40 |
|
1447 | 41 |
(1 126 16r040000000000000000000000000000000) |
42 |
(1 127 16r080000000000000000000000000000000) |
|
43 |
(1 128 16r100000000000000000000000000000000) |
|
44 |
(1 129 16r200000000000000000000000000000000) |
|
1347 | 45 |
|
1447 | 46 |
(16r10 1 16r20) |
47 |
(16r10 2 16r40) |
|
48 |
(16r10 3 16r80) |
|
49 |
(16r10 7 16r0800) |
|
50 |
(16r10 8 16r1000) |
|
51 |
(16r10 15 16r080000) |
|
52 |
(16r10 16 16r100000) |
|
53 |
(16r10 17 16r200000) |
|
54 |
(16r10 30 16r0400000000) |
|
55 |
(16r10 31 16r0800000000) |
|
56 |
(16r10 32 16r1000000000) |
|
57 |
(16r10 33 16r2000000000) |
|
1347 | 58 |
|
1447 | 59 |
(16r10 62 16r040000000000000000) |
60 |
(16r10 63 16r080000000000000000) |
|
61 |
(16r10 64 16r100000000000000000) |
|
62 |
(16r10 65 16r200000000000000000) |
|
1347 | 63 |
|
1447 | 64 |
(16r10 126 16r0400000000000000000000000000000000) |
65 |
(16r10 127 16r0800000000000000000000000000000000) |
|
66 |
(16r10 128 16r1000000000000000000000000000000000) |
|
67 |
(16r10 129 16r2000000000000000000000000000000000) |
|
1347 | 68 |
) triplesDo:[:val :cnt :expected | |
1447 | 69 |
|rslt1 rslt2| |
70 |
||
71 |
rslt1 := val bitShift:cnt. |
|
72 |
self assert:(rslt1 = expected). |
|
73 |
expected class == SmallInteger ifTrue:[ |
|
74 |
self assert:(rslt1 == expected) |
|
75 |
]. |
|
76 |
rslt2 := rslt1 bitShift:cnt negated. |
|
77 |
self assert:(rslt2 = val). |
|
78 |
val class == SmallInteger ifTrue:[ |
|
79 |
self assert:(rslt2 == val) |
|
80 |
]. |
|
1347 | 81 |
]. |
82 |
! |
|
83 |
||
84 |
testBitShiftNegative |
|
1447 | 85 |
#( |
86 |
(-1 1 -2) |
|
87 |
(-1 2 -4) |
|
88 |
(-1 3 -8) |
|
89 |
(-1 7 -16r080) |
|
90 |
(-1 8 -16r100) |
|
91 |
(-1 15 -16r08000) |
|
92 |
(-1 16 -16r10000) |
|
93 |
(-1 17 -16r20000) |
|
94 |
(-1 30 -16r040000000) |
|
95 |
(-1 31 -16r080000000) |
|
96 |
(-1 32 -16r100000000) |
|
97 |
(-1 33 -16r200000000) |
|
1347 | 98 |
|
1447 | 99 |
(-1 62 -16r04000000000000000) |
100 |
(-1 63 -16r08000000000000000) |
|
101 |
(-1 64 -16r10000000000000000) |
|
102 |
(-1 65 -16r20000000000000000) |
|
1347 | 103 |
|
1447 | 104 |
(-1 126 -16r040000000000000000000000000000000) |
105 |
(-1 127 -16r080000000000000000000000000000000) |
|
106 |
(-1 128 -16r100000000000000000000000000000000) |
|
107 |
(-1 129 -16r200000000000000000000000000000000) |
|
1347 | 108 |
|
1447 | 109 |
(-16r10 1 -16r20) |
110 |
(-16r10 2 -16r40) |
|
111 |
(-16r10 3 -16r80) |
|
112 |
(-16r10 7 -16r0800) |
|
113 |
(-16r10 8 -16r1000) |
|
114 |
(-16r10 15 -16r080000) |
|
115 |
(-16r10 16 -16r100000) |
|
116 |
(-16r10 17 -16r200000) |
|
117 |
(-16r10 30 -16r0400000000) |
|
118 |
(-16r10 31 -16r0800000000) |
|
119 |
(-16r10 32 -16r1000000000) |
|
120 |
(-16r10 33 -16r2000000000) |
|
1347 | 121 |
|
1447 | 122 |
(-16r10 62 -16r040000000000000000) |
123 |
(-16r10 63 -16r080000000000000000) |
|
124 |
(-16r10 64 -16r100000000000000000) |
|
125 |
(-16r10 65 -16r200000000000000000) |
|
1347 | 126 |
|
1447 | 127 |
(-16r10 126 -16r0400000000000000000000000000000000) |
128 |
(-16r10 127 -16r0800000000000000000000000000000000) |
|
129 |
(-16r10 128 -16r1000000000000000000000000000000000) |
|
130 |
(-16r10 129 -16r2000000000000000000000000000000000) |
|
1347 | 131 |
) triplesDo:[:val :cnt :expected | |
1447 | 132 |
|rslt1 rslt2| |
133 |
||
134 |
rslt1 := val bitShift:cnt. |
|
135 |
self assert:(rslt1 = expected). |
|
136 |
expected class == SmallInteger ifTrue:[ |
|
137 |
self assert:(rslt1 == expected) |
|
138 |
]. |
|
139 |
rslt2 := rslt1 bitShift:cnt negated. |
|
140 |
self assert:(rslt2 = val). |
|
141 |
val class == SmallInteger ifTrue:[ |
|
142 |
self assert:(rslt2 == val) |
|
143 |
]. |
|
1347 | 144 |
]. |
145 |
! |
|
146 |
||
310 | 147 |
testDivide |
1447 | 148 |
|zero _1 _2 _3 _4 _m2 _m4| |
619
f918fa22ad81
Circumvent compiler error about div by zero
Stefan Vogel <sv@exept.de>
parents:
364
diff
changeset
|
149 |
|
1447 | 150 |
"circumvent compiler error about division by zero" |
151 |
zero := 0. |
|
619
f918fa22ad81
Circumvent compiler error about div by zero
Stefan Vogel <sv@exept.de>
parents:
364
diff
changeset
|
152 |
|
1447 | 153 |
self assert: 2 / 1 = 2. |
154 |
self assert: (3 / 2) isFraction. |
|
155 |
self assert: 4 / 2 = 2. |
|
156 |
self assert: 4 / -2 = -2. |
|
157 |
self assert: -4 / 2 = -2. |
|
158 |
self assert: -4 / -2 = 2. |
|
159 |
self should: [ 1 / zero ] raise: ZeroDivide. |
|
1223
708a62eac280
class: RegressionTests::SmallIntegerTest
Claus Gittinger <cg@exept.de>
parents:
1074
diff
changeset
|
160 |
|
1447 | 161 |
_1 := 1. |
162 |
_2 := 2. |
|
163 |
_3 := 3. |
|
164 |
_4 := 4. |
|
165 |
_m2 := -2. |
|
166 |
_m4 := -4. |
|
1223
708a62eac280
class: RegressionTests::SmallIntegerTest
Claus Gittinger <cg@exept.de>
parents:
1074
diff
changeset
|
167 |
|
1447 | 168 |
self assert: _2 / _1 = _2. |
169 |
self assert: (_3 / _2) isFraction. |
|
170 |
self assert: _4 / _2 = 2. |
|
171 |
self assert: _4 / _m2 = -2. |
|
172 |
self assert: _m4 / _2 = -2. |
|
173 |
self assert: _m4 / _m2 = 2. |
|
364 | 174 |
! |
175 |
||
176 |
testMultiply |
|
177 |
|i ii| |
|
178 |
||
1447 | 179 |
#( |
180 |
16r3fff |
|
181 |
16r7fff |
|
182 |
16rffff |
|
183 |
16r3fffffff |
|
184 |
16r7fffffff |
|
185 |
16rffffffff |
|
186 |
16r20000000 |
|
187 |
16r40000000 |
|
188 |
16r80000000 |
|
189 |
16r100000000 |
|
190 |
16r20000001 |
|
191 |
16r40000001 |
|
192 |
16r80000001 |
|
193 |
16r100000001 |
|
1223
708a62eac280
class: RegressionTests::SmallIntegerTest
Claus Gittinger <cg@exept.de>
parents:
1074
diff
changeset
|
194 |
|
1447 | 195 |
"/ for 64 bit machines: |
196 |
16r3fffffffffffffff |
|
197 |
16r7fffffffffffffff |
|
198 |
16rffffffffffffffff |
|
199 |
16r2000000000000000 |
|
200 |
16r4000000000000000 |
|
201 |
16r8000000000000000 |
|
202 |
16r10000000000000000 |
|
203 |
16r2000000000000001 |
|
204 |
16r4000000000000001 |
|
205 |
16r8000000000000001 |
|
206 |
16r10000000000000001 |
|
364 | 207 |
) do:[:x | |
1447 | 208 |
i := x. |
209 |
ii := i * i. |
|
210 |
self assert:((ii / i) = i). |
|
211 |
i class == SmallInteger ifTrue:[ |
|
212 |
self assert:((ii / i) == i). |
|
213 |
]. |
|
364 | 214 |
|
1447 | 215 |
i := x negated. |
216 |
ii := i * i. |
|
217 |
self assert:((ii / i) = i). |
|
218 |
i class == SmallInteger ifTrue:[ |
|
219 |
self assert:((ii / i) == i). |
|
220 |
]. |
|
364 | 221 |
]. |
222 |
! |
|
223 |
||
224 |
testNegation |
|
1596 | 225 |
|i iN iNN iNNN| |
364 | 226 |
|
1447 | 227 |
#( |
1596 | 228 |
16r1fffffff |
229 |
16r3fffffff |
|
230 |
16r7fffffff |
|
231 |
16rffffffff |
|
232 |
16r20000000 |
|
233 |
16r40000000 |
|
234 |
16r80000000 |
|
235 |
16r100000000 |
|
236 |
16r20000001 |
|
237 |
16r40000001 |
|
238 |
16r80000001 |
|
239 |
16r100000001 |
|
1223
708a62eac280
class: RegressionTests::SmallIntegerTest
Claus Gittinger <cg@exept.de>
parents:
1074
diff
changeset
|
240 |
|
1596 | 241 |
"/ for 64bit machines: |
242 |
16r3fffffffffffffff |
|
243 |
16r7fffffffffffffff |
|
244 |
16rffffffffffffffff |
|
245 |
16r2000000000000000 |
|
246 |
16r4000000000000000 |
|
247 |
16r8000000000000000 |
|
248 |
16r10000000000000000 |
|
249 |
16r2000000000000001 |
|
250 |
16r4000000000000001 |
|
251 |
16r8000000000000001 |
|
252 |
16r10000000000000001 |
|
364 | 253 |
) do:[:x | |
1596 | 254 |
i := x. |
255 |
iN := i negated. |
|
256 |
iNN := iN negated. |
|
257 |
iNNN := iNN negated. |
|
258 |
self assert:(i = iNN). |
|
259 |
i class == SmallInteger ifTrue:[ |
|
260 |
self assert:(i == iNN). |
|
261 |
]. |
|
262 |
self assert:(iN = iNNN). |
|
263 |
iN class == SmallInteger ifTrue:[ |
|
264 |
self assert:(iN == iNNN). |
|
265 |
]. |
|
364 | 266 |
]. |
1306 | 267 |
self assert:(SmallInteger maxVal negated class == SmallInteger). |
268 |
self assert:(SmallInteger maxVal negated negated == SmallInteger maxVal). |
|
1447 | 269 |
|
1306 | 270 |
self assert:(SmallInteger maxVal negated -1 == SmallInteger minVal). |
271 |
self assert:(SmallInteger minVal negated negated class == SmallInteger). |
|
1596 | 272 |
|
273 |
"Modified: / 28-02-2017 / 16:42:04 / cg" |
|
310 | 274 |
! ! |
275 |
||
276 |
!SmallIntegerTest methodsFor:'tests-class protocol'! |
|
277 |
||
278 |
testBasicNew |
|
1447 | 279 |
self should: [SmallInteger basicNew] raise: TestResult error. |
310 | 280 |
! |
281 |
||
282 |
testMaxVal |
|
283 |
"/ the original code did not check for pointer-size; |
|
284 |
||
285 |
Smalltalk isSmalltalkX ifTrue:[ |
|
1447 | 286 |
SmallInteger maxBytes == 4 ifTrue:[ |
287 |
self should: [SmallInteger maxVal = 16r3FFFFFFF]. |
|
288 |
self should: [SmallInteger maxVal == 16r3FFFFFFF]. |
|
289 |
] ifFalse:[ |
|
290 |
self should: [SmallInteger maxVal = 16r3FFFFFFFFFFFFFFF]. |
|
291 |
self should: [SmallInteger maxVal == 16r3FFFFFFFFFFFFFFF]. |
|
292 |
]. |
|
310 | 293 |
] ifFalse:[ |
1447 | 294 |
self should: [SmallInteger maxVal = 16r3FFFFFFF]. |
310 | 295 |
] |
296 |
! |
|
297 |
||
1347 | 298 |
testMaxValPointerSizeConsistency |
299 |
SmallInteger maxBytes == 4 ifTrue:[ |
|
1447 | 300 |
self assert: ((SmallInteger maxBits == 31) or:[SmallInteger maxBits == 32]). |
301 |
self assert: (ExternalAddress pointerSize == 4). |
|
1347 | 302 |
] ifFalse:[ |
1447 | 303 |
self assert: ((SmallInteger maxBits == 63) or:[SmallInteger maxBits == 64]). |
304 |
self assert: (ExternalAddress pointerSize == 8). |
|
1347 | 305 |
] |
306 |
! |
|
307 |
||
310 | 308 |
testMinVal |
309 |
"/ the original code did not check for pointer-size; |
|
310 |
||
311 |
Smalltalk isSmalltalkX ifTrue:[ |
|
1447 | 312 |
SmallInteger maxBytes == 4 ifTrue:[ |
313 |
self should: [SmallInteger minVal = -16r40000000]. |
|
314 |
self should: [SmallInteger minVal == -16r40000000]. |
|
315 |
] ifFalse:[ |
|
316 |
self should: [SmallInteger minVal = -16r4000000000000000]. |
|
317 |
self should: [SmallInteger minVal == -16r4000000000000000]. |
|
318 |
]. |
|
310 | 319 |
] ifFalse:[ |
1447 | 320 |
self should: [SmallInteger minVal = -16r40000000]. |
310 | 321 |
] |
322 |
! |
|
323 |
||
324 |
testNew |
|
1447 | 325 |
self should: [SmallInteger new] raise: TestResult error. |
310 | 326 |
! ! |
327 |
||
328 |
!SmallIntegerTest class methodsFor:'documentation'! |
|
329 |
||
330 |
version |
|
331 |
^ '$Header$' |
|
332 |
! ! |
|
1074 | 333 |