"{ Package: 'exept:regression' }"
"{ NameSpace: RegressionTests }"
TestCase subclass:#IntegerTest
instanceVariableNames:''
classVariableNames:''
poolDictionaries:''
category:'Tests-Regression'
!
!IntegerTest methodsFor:'misc'!
doMul0_a:arg
^ arg * 0
"
(self doMul0_a:0) == 0
(self doMul0_a:1) == 0
(self doMul0_a:SmallInteger maxVal) == 0
(self doMul0_a:SmallInteger minVal) == 0
"
"Created: / 9.6.1999 / 15:50:48 / cg"
!
doMul1_a:arg
^ arg * 1
"
(self doMul1_a:0) == 0
(self doMul1_a:1) == 1
(self doMul1_a:SmallInteger maxVal) == SmallInteger maxVal
(self doMul1_a:SmallInteger minVal) == SmallInteger minVal
"
"Created: / 9.6.1999 / 15:49:09 / cg"
!
doMul2_a:arg
^ arg * 2
"
(self doMul2_a:0) == 0
(self doMul2_a:1) == 2
(self doMul2_a:SmallInteger maxVal) = (SmallInteger maxVal + SmallInteger maxVal)
(self doMul2_a:SmallInteger minVal) = (SmallInteger minVal + SmallInteger minVal)
"
"Modified: / 9.6.1999 / 16:57:20 / cg"
!
doMul3_a:arg
^ arg * 3
"
(self doMul3_a:0) == 0
(self doMul3_a:1) == 3
(self doMul3_a:-1) == -3
(self doMul3_a:10000) == 30000
(self doMul3_a:SmallInteger maxVal) = (SmallInteger maxVal + SmallInteger maxVal + SmallInteger maxVal)
(self doMul3_a:SmallInteger minVal) = (SmallInteger minVal + SmallInteger minVal + SmallInteger minVal)
"
"Created: / 9.6.1999 / 16:57:47 / cg"
"Modified: / 9.6.1999 / 17:35:34 / cg"
!
doMul4_a:arg
^ arg * 4
"
(self doMul4_a:0) == 0
(self doMul4_a:1) == 4
(self doMul4_a:-1) == -4
(self doMul4_a:10000) == 40000
(self doMul4_a:SmallInteger maxVal//4) == 4611686018427387900
(self doMul4_a:SmallInteger maxVal//4+1) = 4611686018427387904
"
"Created: / 9.6.1999 / 16:57:47 / cg"
"Modified: / 9.6.1999 / 17:37:36 / cg"
!
doMul5_a:arg
^ arg * 5
"
(self doMul5_a:0) == 0
(self doMul5_a:1) == 5
(self doMul5_a:-1) == -5
(self doMul5_a:10000) == 50000
(self doMul5_a:SmallInteger maxVal//5) == 4611686018427387900
(self doMul5_a:SmallInteger maxVal//4+1) = 4611686018427387905
"
"Created: / 9.6.1999 / 17:38:17 / cg"
!
doMulM1_a:arg
^ arg * -1
"
(self doMulM1_a:0) == 0
(self doMulM1_a:1) == -1
(self doMulM1_a:SmallInteger maxVal) == (SmallInteger minVal + 1)
(self doMulM1_a:SmallInteger minVal) = (SmallInteger maxVal + 1)
"
"Modified: / 9.6.1999 / 16:54:02 / cg"
!
doPlus1_a:arg
^ arg + 1
"
(self doPlus1_a:SmallInteger maxVal) = 1073741824
"
!
doPlus1_b:arg
^ arg perform:#+ with:1
"
(self doPlus1_b:SmallInteger maxVal) == 1073741824
"
!
testMul0
self assert: ( (self doMul0_a:0) == 0 ).
self assert: ( (self doMul0_a:1) == 0 ).
self assert: ( (self doMul0_a:SmallInteger maxVal) == 0 ).
self assert: ( (self doMul0_a:SmallInteger minVal) == 0 ).
self assert: ( (self doMul0_a:SmallInteger maxVal+1) == 0 ).
self assert: ( (self doMul0_a:SmallInteger minVal-1) == 0 ).
"
self basicNew testMul0
"
"Created: / 9.6.1999 / 15:50:48 / cg"
!
testMul1
self assert: ( (self doMul1_a:0) == 0 ).
self assert: ( (self doMul1_a:1) == 1 ).
self assert: ( (self doMul1_a:SmallInteger maxVal) == SmallInteger maxVal ).
self assert: ( (self doMul1_a:SmallInteger minVal) == SmallInteger minVal ).
self assert: ( (self doMul1_a:SmallInteger maxVal+1) = (SmallInteger maxVal+1) ).
self assert: ( (self doMul1_a:SmallInteger minVal-1) = (SmallInteger minVal-1) ).
"
self basicNew testMul1
"
!
testMul2
self assert: ( (self doMul2_a:0) == 0 ).
self assert: ( (self doMul2_a:1) == 2 ).
self assert: ( (self doMul2_a:SmallInteger maxVal) = (SmallInteger maxVal + SmallInteger maxVal) ).
self assert: ( (self doMul2_a:SmallInteger minVal) = (SmallInteger minVal + SmallInteger minVal) ).
self assert: ( (self doMul2_a:SmallInteger maxVal+1) = ((SmallInteger maxVal+1)+(SmallInteger maxVal+1)) ).
self assert: ( (self doMul2_a:SmallInteger minVal-1) = ((SmallInteger minVal-1)+(SmallInteger minVal-1)) ).
"
self basicNew testMul2
"
"Modified: / 9.6.1999 / 16:57:20 / cg"
!
testMul3
self assert: ( (self doMul3_a:0) == 0 ).
self assert: ( (self doMul3_a:1) == 3 ).
self assert: ( (self doMul3_a:-1) == -3 ).
self assert: ( (self doMul3_a:10000) == 30000 ).
self assert: ( (self doMul3_a:SmallInteger maxVal) = (SmallInteger maxVal + SmallInteger maxVal + SmallInteger maxVal) ).
self assert: ( (self doMul3_a:SmallInteger minVal) = (SmallInteger minVal + SmallInteger minVal + SmallInteger minVal) ).
"
self basicNew testMul3
"
!
testMul4
self assert: ( (self doMul4_a:0) == 0 ).
self assert: ( (self doMul4_a:1) == 4 ).
self assert: ( (self doMul4_a:-1) == -4 ).
self assert: ( (self doMul4_a:10000) == 40000 ).
self assert: ( (self doMul4_a:SmallInteger maxVal) = (SmallInteger maxVal + SmallInteger maxVal + SmallInteger maxVal + SmallInteger maxVal) ).
self assert: ( (self doMul4_a:SmallInteger minVal) = (SmallInteger minVal + SmallInteger minVal + SmallInteger minVal + SmallInteger minVal) ).
self assert: ( (self doMul4_a:SmallInteger maxVal+1//4) = (SmallInteger maxVal + 1) ).
self assert: ( (self doMul4_a:SmallInteger minVal//4) = (SmallInteger minVal) ).
"
self basicNew testMul4
"
!
testMul5
self assert: ( (self doMul5_a:0) == 0 ).
self assert: ( (self doMul5_a:1) == 5 ).
self assert: ( (self doMul5_a:-1) == -5 ).
self assert: ( (self doMul5_a:10000) == 50000 ).
self assert: ( (self doMul5_a:SmallInteger maxVal) = (SmallInteger maxVal + SmallInteger maxVal + SmallInteger maxVal + SmallInteger maxVal + SmallInteger maxVal) ).
self assert: ( (self doMul5_a:SmallInteger minVal) = (SmallInteger minVal + SmallInteger minVal + SmallInteger minVal + SmallInteger minVal + SmallInteger minVal) ).
"
self basicNew testMul5
"
!
testMulM1
self assert: ( (self doMulM1_a:0) == 0 ).
self assert: ( (self doMulM1_a:1) == -1 ).
self assert: ( (self doMulM1_a:-1) == 1 ).
self assert: ( (self doMulM1_a:10000) == -10000 ).
self assert: ( (self doMulM1_a:SmallInteger maxVal) = (SmallInteger minVal + 1) ).
self assert: ( (self doMulM1_a:SmallInteger minVal) = (SmallInteger maxVal + 1) ).
"
self basicNew testMulM1
"
!
testPlus1
self assert: ( (self doPlus1_a:0) = 1 ).
self assert: ( (self doPlus1_a:1) = 2 ).
self assert: ( (self doPlus1_a:-1) = 0 ).
self assert: ( (self doPlus1_a:SmallInteger maxVal) = 1073741824).
self assert: ( (self doPlus1_a:SmallInteger minVal) = -1073741823 ).
"
self basicNew testPlus1
"
!
testPlus1perform
self assert: ( (self doPlus1_b:0) = 1 ).
self assert: ( (self doPlus1_b:1) = 2 ).
self assert: ( (self doPlus1_b:-1) = 0 ).
self assert: ( (self doPlus1_b:SmallInteger maxVal) = 1073741824).
self assert: ( (self doPlus1_b:SmallInteger minVal) = -1073741823 ).
"
self basicNew testPlus1perform
"
! !
!IntegerTest methodsFor:'private'!
absPlusOneOf:arg
|local1|
local1 := arg.
^ local1 abs + 1
"
self absPlusOneOf:-1
self absPlusOneOf:-1.0
"
"Created: / 31.10.2000 / 20:21:52 / cg"
!
alwaysTrue
^ true.
!
checkIsInteger:arg
^ arg isInteger
!
doConstantIntegerShift
"arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|flags|
flags := self flagsSlot.
self alwaysTrue ifFalse:[self halt].
^ flags bitShift:-1.
"
self testIntegerShifts3
"
"Created: / 6.6.1999 / 14:47:51 / cg"
"Modified: / 9.6.1999 / 17:49:57 / cg"
!
flagsSlot
"arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
^ 2.
"
self testIntegerShifts3
"
"Created: / 6.6.1999 / 14:47:51 / cg"
"Modified: / 9.6.1999 / 17:49:57 / cg"
!
num_00000000000007FFF
^ 16r00000000000007FFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:34:12 / cg"
!
num_00000000000008000
^ 16r00000000000008000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:39:32 / cg"
!
num_0000000000000FFFF
^ 16r0000000000000FFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:34:26 / cg"
!
num_00000000000010000
^ 16r00000000000010000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:34:31 / cg"
!
num_00000000000100000
^ 16r00000000000100000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:34:36 / cg"
!
num_000000000007FFFFF
^ 16r000000000007FFFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:37:48 / cg"
!
num_00000000000800000
^ 16r00000000000800000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:39:43 / cg"
!
num_00000000000FFFFFF
^ 16r00000000000FFFFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:37:52 / cg"
!
num_00000000001000000
^ 16r00000000001000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:34:42 / cg"
!
num_0000000000FFF0000
^ 16r0000000000FFF0000
"self num_0000000000FFF0000 hexPrintString"
"Created: / 4.6.1999 / 17:44:26 / cg"
"Modified: / 4.6.1999 / 18:40:47 / cg"
!
num_00000000010000000
^ 16r00000000010000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:34:46 / cg"
!
num_0000000007FFFFFFF
^ 16r0000000007FFFFFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:37:31 / cg"
!
num_00000000080000000
^ 16r00000000080000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:39:56 / cg"
!
num_000000000FFFFFFFF
^ 16r000000000FFFFFFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:36:16 / cg"
!
num_00000000100000000
^ 16r00000000100000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:34:51 / cg"
!
num_00000001000000000
^ 16r00000001000000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:34:57 / cg"
!
num_0000000FFFFFFFFFF
^ 16r0000000FFFFFFFFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:41:08 / cg"
!
num_00000010000000000
^ 16r00000010000000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:35:03 / cg"
!
num_00000100000000000
^ 16r00000100000000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:35:07 / cg"
!
num_00000FFFFFFFFFF00
^ 16r00000FFFFFFFFFF00
"self num_00000FFFFFFFFFF00"
"Created: / 4.6.1999 / 17:44:26 / cg"
"Modified: / 4.6.1999 / 17:46:20 / cg"
!
num_00000FFFFFFFFFF80
^ 16r00000FFFFFFFFFF80
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:44:23 / cg"
!
num_00000FFFFFFFFFFC0
^ 16r00000FFFFFFFFFFC0
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:44:20 / cg"
!
num_00000FFFFFFFFFFE0
^ 16r00000FFFFFFFFFFE0
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:44:16 / cg"
!
num_00000FFFFFFFFFFF0
^ 16r00000FFFFFFFFFFF0
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:44:12 / cg"
!
num_00000FFFFFFFFFFF8
^ 16r00000FFFFFFFFFFF8
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:44:09 / cg"
!
num_00000FFFFFFFFFFFC
^ 16r00000FFFFFFFFFFFC
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:44:05 / cg"
!
num_00000FFFFFFFFFFFE
^ 16r00000FFFFFFFFFFFE
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:45:12 / cg"
!
num_00000FFFFFFFFFFFF
^ 16r00000FFFFFFFFFFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:41:22 / cg"
!
num_00001000000000000
^ 16r00001000000000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:35:13 / cg"
!
num_00010000000000000
^ 16r00010000000000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:35:18 / cg"
!
num_000FFFFFFFFFFFFFF
^ 16r000FFFFFFFFFFFFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:41:26 / cg"
!
num_00100000000000000
^ 16r00100000000000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:35:22 / cg"
!
num_01000000000000000
^ 16r01000000000000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:35:27 / cg"
!
num_0FFFFFFFFFFFFFFFF
^ 16r0FFFFFFFFFFFFFFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:41:30 / cg"
!
num_10000000000000000
^ 16r10000000000000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 15:35:32 / cg"
!
num_1FFFFFFFFFFFFFFFF
^ 16r1FFFFFFFFFFFFFFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:41:51 / cg"
!
num_20000000000000000
^ 16r20000000000000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:40:26 / cg"
!
num_3FFFFFFFFFFFFFFFF
^ 16r3FFFFFFFFFFFFFFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:42:07 / cg"
!
num_40000000000000000
^ 16r40000000000000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:40:29 / cg"
!
num_7FFFFFFFFFFFFFFFF
^ 16r7FFFFFFFFFFFFFFFF
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:42:24 / cg"
!
num_80000000000000000
^ 16r80000000000000000
"Modified: / 4.6.1999 / 15:29:31 / cg"
"Created: / 4.6.1999 / 17:40:33 / cg"
!
num_smallInt_maxVal
^ SmallInteger maxVal
"self num_smallInt_maxVal"
"Modified: / 4.6.1999 / 17:33:22 / cg"
!
num_smallInt_minVal
^ SmallInteger minVal
"self num_smallInt_minVal"
"Created: / 4.6.1999 / 16:26:05 / cg"
"Modified: / 4.6.1999 / 17:34:31 / cg"
! !
!IntegerTest methodsFor:'tests'!
doTestAll
"general conversion & arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
self testInteger1.
self testILC.
self testSmallIntegerArithmetic.
self testLiteralNumbers.
self testLargeAddition.
self testLargeMultiplication.
self testLargeDivision.
self testIntegerShifts.
self testEncodeDecode.
self testIntegerMisc.
self testInline1
"
self basicNew doTestAll
"
"Modified: / 31.10.2000 / 20:23:20 / cg"
!
testEncodeDecode
self assert:(1 encodeAsBCD hexPrintString = '1').
self assert:(12 encodeAsBCD hexPrintString = '12').
self assert:(123 encodeAsBCD hexPrintString = '123').
self assert:(1234 encodeAsBCD hexPrintString = '1234').
self assert:(12345 encodeAsBCD hexPrintString = '12345').
self assert:(123456 encodeAsBCD hexPrintString = '123456').
self assert:(1234567 encodeAsBCD hexPrintString = '1234567').
self assert:(12345678 encodeAsBCD hexPrintString = '12345678').
self assert:(123456789 encodeAsBCD hexPrintString = '123456789').
self assert:(1234567890 encodeAsBCD hexPrintString = '1234567890').
self assert:(12345678901 encodeAsBCD hexPrintString = '12345678901').
self assert:(123456789012 encodeAsBCD hexPrintString = '123456789012').
self assert:(1234567890123 encodeAsBCD hexPrintString = '1234567890123').
self assert:(12345678901234 encodeAsBCD hexPrintString = '12345678901234').
self assert:(123456789012345 encodeAsBCD hexPrintString = '123456789012345').
self assert:(1234567890123456 encodeAsBCD hexPrintString = '1234567890123456').
self assert:(12345678901234567 encodeAsBCD hexPrintString = '12345678901234567').
self assert:(123456789012345678 encodeAsBCD hexPrintString = '123456789012345678').
self assert:(1234567890123456789 encodeAsBCD hexPrintString = '1234567890123456789').
self assert:(12345678901234567890 encodeAsBCD hexPrintString = '12345678901234567890').
self assert:(4611686018427387902 encodeAsBCD hexPrintString = '4611686018427387902').
self assert:(4611686018427387903 encodeAsBCD hexPrintString = '4611686018427387903').
self assert:(4611686018427387904 encodeAsBCD hexPrintString = '4611686018427387904').
self assert:(16r1 decodeFromBCD = 1).
self assert:(16r12 decodeFromBCD = 12).
self assert:(16r123 decodeFromBCD = 123).
self assert:(16r1234 decodeFromBCD = 1234).
self assert:(16r12345 decodeFromBCD = 12345).
self assert:(16r123456 decodeFromBCD = 123456).
self assert:(16r1234567 decodeFromBCD = 1234567).
self assert:(16r12345678 decodeFromBCD = 12345678).
self assert:(16r123456789 decodeFromBCD = 123456789).
self assert:(16r1234567890 decodeFromBCD = 1234567890).
self assert:(16r12345678901 decodeFromBCD = 12345678901).
self assert:(16r123456789012 decodeFromBCD = 123456789012).
self assert:(16r1000000000000 decodeFromBCD = 1000000000000).
self assert:(16r0000500000000 decodeFromBCD = 500000000).
self assert:(16r1234500000000 decodeFromBCD = 1234500000000).
self assert:(16r1234567890000 decodeFromBCD = 1234567890000).
self assert:(16r1234567890123 decodeFromBCD = 1234567890123).
self assert:(16r12345678901234 decodeFromBCD = 12345678901234).
self assert:(16r123456789012345 decodeFromBCD = 123456789012345).
self assert:(16r1234567890123456 decodeFromBCD = 1234567890123456).
self assert:(16r12345678901234567 decodeFromBCD = 12345678901234567).
self assert:(16r123456789012345678 decodeFromBCD = 123456789012345678).
self assert:(16r1234567890123456789 decodeFromBCD = 1234567890123456789).
self assert:(16r12345678901234567890 decodeFromBCD = 12345678901234567890).
self assert:(16r4611686018427387902 decodeFromBCD = 4611686018427387902).
self assert:(16r4611686018427387903 decodeFromBCD = 4611686018427387903).
self assert:(16r4611686018427387904 decodeFromBCD = 4611686018427387904).
"
self basicNew testEncodeDecode
"
"Modified: / 26.10.1999 / 22:01:35 / stefan"
!
testILC
"inline-cache"
self assert:((self checkIsInteger:1) == true).
self assert:((self checkIsInteger:nil) == false).
self assert:((self checkIsInteger:1) == true).
self assert:((self checkIsInteger:nil) == false).
self assert:((self checkIsInteger:0) == true).
self assert:((self checkIsInteger:nil) == false).
self assert:((self checkIsInteger:0) == true).
self assert:((self checkIsInteger:nil) == false).
"
self basicNew testILC
"
"Created: / 6.6.1999 / 14:47:51 / cg"
"Modified: / 9.6.1999 / 17:49:57 / cg"
!
testInline1
"inlined tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
self assert:( (self absPlusOneOf:1) = 2 ).
self assert:( (self absPlusOneOf:-1) = 2 ).
self assert:( (self absPlusOneOf:1.0) = 2 ).
self assert:( (self absPlusOneOf:-1.0) = 2 ).
"
self basicNew testInline1
"
"Created: / 31.10.2000 / 20:22:48 / cg"
"Modified: / 31.10.2000 / 20:23:06 / cg"
!
testInteger1
"general conversion & arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|minVal maxVal maxValPlus1 minValMinus1 halfMin halfMax t t1 t2|
minVal := SmallInteger perform:('minVal' asSymbol).
maxVal := SmallInteger perform:('maxVal' asSymbol).
self assert:(minVal == self num_smallInt_minVal).
self assert:(maxVal == self num_smallInt_maxVal).
self assert:(minVal == SmallInteger minVal).
self assert:(maxVal == SmallInteger maxVal).
t := SmallInteger perform:('maxBytes' asSymbol).
self assert:(t == SmallInteger maxBytes).
t := SmallInteger perform:('maxBits' asSymbol).
self assert:(t == SmallInteger maxBits).
self testPrinting1.
SmallInteger maxBytes == 4 ifTrue:[
self assert:(minVal hexPrintString = '-40000000').
self assert:(maxVal hexPrintString = '3FFFFFFF').
self assert:(minVal == -1073741824).
self assert:(maxVal == 1073741823).
maxValPlus1 := 1073741824.
minValMinus1 := -1073741825.
self assert:(minValMinus1 hexPrintString = '-40000001').
self assert:(maxValPlus1 hexPrintString = '40000000').
halfMin := -16r20000000.
halfMax := 16r20000000.
].
SmallInteger maxBytes == 8 ifTrue:[
self assert:(minVal hexPrintString = '-4000000000000000').
self assert:(maxVal hexPrintString = '3FFFFFFFFFFFFFFF').
self assert:(minVal == -4611686018427387904).
self assert:(maxVal == 4611686018427387903).
maxValPlus1 := 4611686018427387904.
minValMinus1 := -4611686018427387905.
self assert:(minValMinus1 hexPrintString = '-4000000000000001').
self assert:(maxValPlus1 hexPrintString = '4000000000000000').
halfMin := -16r2000000000000000.
halfMax := 16r2000000000000000.
].
"arithmetic overFlow checks"
"/ self assert:((maxVal + 1) inspect.maxValPlus1 inspect. true).
self assert:((maxVal perform:'+' asSymbol with:1) = maxValPlus1).
self assert:((maxVal + 1) = maxValPlus1).
self assert:((minVal perform:'-' asSymbol with:1) = minValMinus1).
self assert:((minVal - 1) = minValMinus1).
self assert:((halfMax perform:'+' asSymbol with:halfMax) = maxValPlus1).
self assert:((halfMax + halfMax) = maxValPlus1).
self assert:((halfMin perform:'+' asSymbol with:halfMin) == minVal).
self assert:((halfMin + halfMin) == minVal).
self assert:((halfMax perform:'*' asSymbol with:2) = maxValPlus1).
self assert:((halfMax * 2) = maxValPlus1).
self assert:((halfMin perform:'*' asSymbol with:2) == minVal).
self assert:((halfMin * 2) == minVal).
self assert:((maxValPlus1 perform:'//' asSymbol with:2) == halfMax).
self assert:((maxValPlus1 // 2) == halfMax).
self assert:((halfMax perform:'bitShift:' asSymbol with:1) = maxValPlus1).
self assert:((halfMin perform:'bitShift:' asSymbol with:1) == minVal).
self assert:((halfMax bitShift:1) = maxValPlus1).
self assert:((halfMin bitShift:1) == minVal).
"LargeInt op -> SmallInt result"
t := maxVal + 1.
self assert:(t - 1 == maxVal).
t := minVal - 1.
self assert:(t + 1 == minVal).
"
self basicNew testInteger1
"
"Modified: / 6.6.1999 / 14:46:11 / cg"
!
testIntegerMisc
"misc tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|n1 n2 s|
n1 := 100000.
n2 := n1 negated.
s := 1.
self assert:(n1 printString = '100000').
self assert:(n1 negated printString = '-100000').
self assert:((n1 perform:'negated' asSymbol) printString = '-100000').
self assert:(n1 negated abs printString = '100000').
self assert:((n1 perform:'negated' asSymbol) abs printString = '100000').
self assert:(n1 abs negated printString = '-100000').
self assert:((n1 perform:'abs' asSymbol) negated printString = '-100000').
n1 := SmallInteger maxVal.
self assert:(n1 negated class == SmallInteger).
self assert:((n1 perform:'negated' asSymbol) class == SmallInteger).
n1 := SmallInteger minVal.
self assert:(n1 negated class == LargeInteger).
self assert:((n1 perform:'negated' asSymbol) class == LargeInteger).
n1 := SmallInteger minVal negated - 1.
self assert:(n1 negated class == SmallInteger).
self assert:((n1 perform:'negated' asSymbol) class == SmallInteger).
self assert:(n1 == SmallInteger maxVal).
"
self basicNew testIntegerMisc
"
"Created: / 6.6.1999 / 14:47:51 / cg"
"Modified: / 9.6.1999 / 17:49:57 / cg"
!
testIntegerShifts
"arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
self testIntegerShifts1.
self testIntegerShifts2.
self assert:(
(((0 to:64) collect:[:s | 1 bitShift:s])
collect:[:n | n highBit]) = (1 to:65)
).
1 to:10000 do:[:s |
self assert:( (1 bitShift:s) highBit == (s+1) )
].
1 to:10000 do:[:s |
self assert:( ((1 bitShift:s) - 1) highBit == s )
].
"
self basicNew testIntegerShifts
"
"Created: / 6.6.1999 / 14:47:51 / cg"
"Modified: / 9.6.1999 / 17:49:57 / cg"
!
testIntegerShifts1
"arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|n1 n2 s|
n1 := 100000.
n2 := n1 negated.
s := 1.
self assert:(n1 printString = '100000').
self assert:(n2 printString = '-100000').
self assert:((n1 bitShift:s) printString = '200000').
self assert:((n1 bitShift:1) printString = '200000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '200000').
self assert:((n1 perform:'bitShift:' asSymbol with:1) printString = '200000').
s := s + 1.
self assert:((n1 bitShift:s) printString = '400000').
self assert:((n1 bitShift:2) printString = '400000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '400000').
self assert:((n1 perform:'bitShift:' asSymbol with:2) printString = '400000').
s := s + 1.
self assert:((n1 bitShift:s) printString = '800000').
self assert:((n1 bitShift:3) printString = '800000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '800000').
self assert:((n1 perform:'bitShift:' asSymbol with:3) printString = '800000').
s := s + 1.
self assert:((n1 bitShift:s) printString = '1600000').
self assert:((n1 bitShift:4) printString = '1600000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '1600000').
self assert:((n1 perform:'bitShift:' asSymbol with:4) printString = '1600000').
s := s + 1.
self assert:((n1 bitShift:s) printString = '3200000').
self assert:((n1 bitShift:5) printString = '3200000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '3200000').
self assert:((n1 perform:'bitShift:' asSymbol with:5) printString = '3200000').
s := s + 1.
self assert:((n1 bitShift:s) printString = '6400000').
self assert:((n1 bitShift:6) printString = '6400000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '6400000').
self assert:((n1 perform:'bitShift:' asSymbol with:6) printString = '6400000').
s := s + 1.
self assert:((n1 bitShift:s) printString = '12800000').
self assert:((n1 bitShift:7) printString = '12800000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '12800000').
self assert:((n1 perform:'bitShift:' asSymbol with:7) printString = '12800000').
"
self basicNew testIntegerShifts1
"
"Created: / 6.6.1999 / 14:47:51 / cg"
"Modified: / 9.6.1999 / 17:49:57 / cg"
!
testIntegerShifts2
"arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|n1 s|
n1 := 12800000.
s := -1.
self assert:((n1 bitShift:s) printString = '6400000').
self assert:((n1 bitShift:-1) printString = '6400000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '6400000').
self assert:((n1 perform:'bitShift:' asSymbol with:-1) printString = '6400000').
s := s - 1.
self assert:((n1 bitShift:s) printString = '3200000').
self assert:((n1 bitShift:-2) printString = '3200000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '3200000').
self assert:((n1 perform:'bitShift:' asSymbol with:-2) printString = '3200000').
s := s - 1.
self assert:((n1 bitShift:s) printString = '1600000').
self assert:((n1 bitShift:-3) printString = '1600000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '1600000').
self assert:((n1 perform:'bitShift:' asSymbol with:-3) printString = '1600000').
s := s - 1.
self assert:((n1 bitShift:s) printString = '800000').
self assert:((n1 bitShift:-4) printString = '800000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '800000').
self assert:((n1 perform:'bitShift:' asSymbol with:-4) printString = '800000').
s := s - 1.
self assert:((n1 bitShift:s) printString = '400000').
self assert:((n1 bitShift:-5) printString = '400000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '400000').
self assert:((n1 perform:'bitShift:' asSymbol with:-5) printString = '400000').
s := s - 1.
self assert:((n1 bitShift:s) printString = '200000').
self assert:((n1 bitShift:-6) printString = '200000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '200000').
self assert:((n1 perform:'bitShift:' asSymbol with:-6) printString = '200000').
s := s - 1.
self assert:((n1 bitShift:s) printString = '100000').
self assert:((n1 bitShift:-7) printString = '100000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '100000').
self assert:((n1 perform:'bitShift:' asSymbol with:-7) printString = '100000').
s := s - 1.
self assert:((n1 bitShift:s) printString = '50000').
self assert:((n1 bitShift:-8) printString = '50000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '50000').
self assert:((n1 perform:'bitShift:' asSymbol with:-8) printString = '50000').
s := s - 1.
self assert:((n1 bitShift:s) printString = '25000').
self assert:((n1 bitShift:-9) printString = '25000').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '25000').
self assert:((n1 perform:'bitShift:' asSymbol with:-9) printString = '25000').
s := s - 1.
self assert:((n1 bitShift:s) printString = '12500').
self assert:((n1 bitShift:-10) printString = '12500').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '12500').
self assert:((n1 perform:'bitShift:' asSymbol with:-10) printString = '12500').
s := s - 1.
self assert:((n1 bitShift:s) printString = '6250').
self assert:((n1 bitShift:-11) printString = '6250').
self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '6250').
self assert:((n1 perform:'bitShift:' asSymbol with:-11) printString = '6250').
"
self basicNew testIntegerShifts2
"
"Created: / 6.6.1999 / 14:47:51 / cg"
"Modified: / 9.6.1999 / 17:49:57 / cg"
!
testIntegerShifts3
"arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
self assert:( self doConstantIntegerShift == 1).
"
self basicNew testIntegerShifts3
"
!
testLargeAddition
"general conversion & arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|s n1 n2 x|
"Large + Large addition"
self testReading1.
self assert:((20 factorial + 20 factorial) printString = '4865804016353280000').
self assert:((20 factorial + 1) printString = '2432902008176640001').
self assert:((20 factorial + 1000) printString = '2432902008176641000').
"Large + Small addition"
self testLargeAddition1.
"Large + Large addition"
self testLargeAddition2.
"Large - small subtraction"
self testLargeAddition3.
"
self basicNew testLargeAddition
"
"Modified: / 4.6.1999 / 15:26:55 / cg"
!
testLargeAddition1
"general conversion & arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|s n1 n2 x|
"Large + Small addition"
n1 := 16r3FFFFFFF. n2 := 1.
self assert:((n1 + n2 ) hexPrintString = '40000000').
self assert:((n1 perform:'+' asSymbol with:n2 ) hexPrintString = '40000000').
n1 := 16r3FFFFFFFF. n2 := 1.
self assert:((n1 + n2 ) hexPrintString = '400000000').
self assert:((n1 perform:'+' asSymbol with:n2 ) hexPrintString = '400000000').
n1 := 16r3FFFFFFFFF. n2 := 1.
self assert:((n1 + n2 ) hexPrintString = '4000000000').
self assert:((n1 perform:'+' asSymbol with:n2 ) hexPrintString = '4000000000').
n1 := 16r3FFFFFFFFFF. n2 := 1.
self assert:((n1 + n2 ) hexPrintString = '40000000000').
self assert:((n1 perform:'+' asSymbol with:n2 ) hexPrintString = '40000000000').
n1 := 16r3FFFFFFFFFFF. n2 := 1.
self assert:((n1 + n2 ) hexPrintString = '400000000000').
self assert:((n1 perform:'+' asSymbol with:n2 ) hexPrintString = '400000000000').
n1 := 16r3FFFFFFFFFFFF. n2 := 1.
self assert:((n1 + n2 ) hexPrintString = '4000000000000').
self assert:((n1 perform:'+' asSymbol with:n2 ) hexPrintString = '4000000000000').
n1 := 16r3FFFFFFFFFFFFF. n2 := 1.
self assert:((n1 + n2 ) hexPrintString = '40000000000000').
self assert:((n1 perform:'+' asSymbol with:n2 ) hexPrintString = '40000000000000').
n1 := 16r3FFFFFFFFFFFFFF. n2 := 1.
self assert:((n1 + n2 ) hexPrintString = '400000000000000').
self assert:((n1 perform:'+' asSymbol with:n2 ) hexPrintString = '400000000000000').
n1 := 16r3FFFFFFFFFFFFFFF. n2 := 1.
self assert:((n1 + n2 ) hexPrintString = '4000000000000000').
self assert:((n1 perform:'+' asSymbol with:n2 ) hexPrintString = '4000000000000000').
"
self basicNew testLargeAddition1
"
"Modified: / 4.6.1999 / 15:26:55 / cg"
!
testLargeAddition2
"general conversion & arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|s n1 n2 x|
"Large + Large addition"
n1 := 16r100000000. n2 := 16r7FFFFFFF.
self assert:((n1 - n2 ) hexPrintString = '80000001').
self assert:((16r100000000 - n2 ) hexPrintString = '80000001').
self assert:((n1 - 16r7FFFFFFF ) hexPrintString = '80000001').
self assert:((16r100000000 - 16r7FFFFFFF ) hexPrintString = '80000001').
self assert:((n1 perform:'-' asSymbol with:n2 ) hexPrintString = '80000001').
self assert:((16r100000000 perform:'-' asSymbol with:n2 ) hexPrintString = '80000001').
self assert:((n1 perform:'-' asSymbol with:16r7FFFFFFF ) hexPrintString = '80000001').
self assert:((16r100000000 perform:'-' asSymbol with:16r7FFFFFFF ) hexPrintString = '80000001').
n1 := 16r100000000. n2 := 16r80000000.
self assert:((n1 - n2 ) hexPrintString = '80000000').
self assert:((16r100000000 - n2 ) hexPrintString = '80000000').
self assert:((n1 - 16r80000000 ) hexPrintString = '80000000').
self assert:((16r100000000 - 16r80000000 ) hexPrintString = '80000000').
self assert:((n1 perform:'-' asSymbol with:n2 ) hexPrintString = '80000000').
self assert:((16r100000000 perform:'-' asSymbol with:n2 ) hexPrintString = '80000000').
self assert:((n1 perform:'-' asSymbol with:16r80000000 ) hexPrintString = '80000000').
self assert:((16r100000000 perform:'-' asSymbol with:16r80000000 ) hexPrintString = '80000000').
n1 := 16r100000000. n2 := 16rFFFFFFFF.
self assert:((n1 - n2 ) hexPrintString = '1').
self assert:((16r100000000 - n2 ) hexPrintString = '1').
self assert:((x := n1 - 16rFFFFFFFF) == 1).
self assert:((n1 - 16rFFFFFFFF ) hexPrintString = '1').
self assert:((16r100000000 - 16rFFFFFFFF ) hexPrintString = '1').
self assert:((n1 perform:'-' asSymbol with:n2 ) hexPrintString = '1').
self assert:((16r100000000 perform:'-' asSymbol with:n2 ) hexPrintString = '1').
self assert:((n1 perform:'-' asSymbol with:16rFFFFFFFF ) hexPrintString = '1').
self assert:((16r100000000 perform:'-' asSymbol with:16rFFFFFFFF ) hexPrintString = '1').
n1 := 16r100000000. n2 := 1.
self assert:((n1 - n2) hexPrintString = 'FFFFFFFF').
self assert:((n1 - n2) hexPrintString = 'FFFFFFFF').
self assert:((16r100000000 - n2) hexPrintString = 'FFFFFFFF').
self assert:((n1 - 1) hexPrintString = 'FFFFFFFF').
self assert:((16r100000000 - 1) hexPrintString = 'FFFFFFFF').
self assert:((n1 perform:'-' asSymbol with:n2) hexPrintString = 'FFFFFFFF').
self assert:((16r100000000 perform:'-' asSymbol with:n2) hexPrintString = 'FFFFFFFF').
self assert:((n1 perform:'-' asSymbol with:1) hexPrintString = 'FFFFFFFF').
self assert:((16r100000000 perform:'-' asSymbol with:1) hexPrintString = 'FFFFFFFF').
n1 := 16r100000000. n2 := 16r10000000.
self assert:((n1 - n2) hexPrintString = 'F0000000').
self assert:((16r100000000 - n2) hexPrintString = 'F0000000').
self assert:((n1 - 16r10000000) hexPrintString = 'F0000000').
self assert:((16r100000000 - 16r10000000) hexPrintString = 'F0000000').
self assert:((n1 perform:'-' asSymbol with:n2) hexPrintString = 'F0000000').
self assert:((16r100000000 perform:'-' asSymbol with:n2) hexPrintString = 'F0000000').
self assert:((n1 perform:'-' asSymbol with:16r10000000) hexPrintString = 'F0000000').
self assert:((16r100000000 perform:'-' asSymbol with:16r10000000) hexPrintString = 'F0000000').
"
self basicNew testLargeAddition2
"
!
testLargeAddition3
"general conversion & arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|s n1 n2 x|
"Large - small subtraction"
self assert:((20 factorial + 20 factorial - 1) printString = '4865804016353279999').
self assert:((20 factorial - 10 factorial + 3628800) printString = '2432902008176640000').
self assert:((20 factorial - 11 factorial + 39916800) printString = '2432902008176640000').
self assert:((20 factorial - 12 factorial + 479001600) printString = '2432902008176640000').
self assert:((20 factorial - 13 factorial + 6227020800) printString = '2432902008176640000').
self assert:((20 factorial - 14 factorial + 87178291200) printString = '2432902008176640000').
self assert:((20 factorial - 15 factorial + 1307674368000) printString = '2432902008176640000').
self assert:((20 factorial - 16 factorial + 20922789888000) printString = '2432902008176640000').
self assert:((20 factorial + 10 factorial - 3628800) printString = '2432902008176640000').
self assert:(1000 factorial printString = '402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000').
n1 := n2 := 1.
self assert:((1000 factorial + n1 - n2) = 1000 factorial).
n1 := n2 := 1000.
self assert:((1000 factorial + n1 - n2) = 1000 factorial).
n1 := n2 := 16rFFFFFFFF.
self assert:((1000 factorial + n1 - n2) = 1000 factorial).
n1 := n2 := 16rFFFFFFFFFFFF.
self assert:((1000 factorial + n1 - n2) = 1000 factorial).
n1 := n2 := 16rFFFFFFFFFFFFFFFF.
self assert:((1000 factorial + n1 - n2) = 1000 factorial).
n1 := n2 := 1000 factorial.
self assert:((1000 factorial + n1 - n2) = 1000 factorial).
"
self basicNew testLargeAddition3
"
"Modified: / 27.11.1999 / 16:41:54 / cg"
!
testLargeDivision
|t v|
t := 20 factorial.
self assert:(t printString = '2432902008176640000').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '243290200817664000').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '24329020081766400').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '2432902008176640').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '243290200817664').
self assert:(t \\ 10 == 4).
t := t // 10.
self assert:(t printString = '24329020081766').
self assert:(t \\ 10 == 6).
t := t // 10.
self assert:(t printString = '2432902008176').
self assert:(t \\ 10 == 6).
t := t // 10.
self assert:(t printString = '243290200817').
self assert:(t \\ 10 == 7).
t := t // 10.
self assert:(t printString = '24329020081').
self assert:(t \\ 10 == 1).
t := t // 10.
self assert:(t printString = '2432902008').
self assert:(t \\ 10 == 8).
t := t // 10.
self assert:(t printString = '243290200').
self assert:(t \\ 10 == 0).
t := 20 factorial.
self assert:(t printString = '2432902008176640000').
self assert:(t \\ 1000 == 0).
t := t // 1000.
self assert:(t printString = '2432902008176640').
self assert:(t \\ 1000 == 640).
t := t // 1000.
self assert:(t printString = '2432902008176').
self assert:(t \\ 1000 == 176).
t := t // 1000.
self assert:(t printString = '2432902008').
self assert:(t \\ 1000 == 8).
t := t // 1000.
self assert:(t printString = '2432902').
self assert:(t \\ 1000 == 902).
t := t // 1000.
self assert:(t printString = '2432').
self assert:(t \\ 1000 == 432).
t := t // 1000.
self assert:(t == 2).
self assert:(t \\ 1000 == 2).
t := 20 factorial.
"Large // SmallInt division"
t := t // 20.
self assert:(t printString = 19 factorial printString).
t := t // 19.
self assert:(t printString = 18 factorial printString).
t := t // 18.
self assert:(t printString = 17 factorial printString).
t := t // 17.
self assert:(t printString = 16 factorial printString).
t := t // 16.
self assert:(t printString = 15 factorial printString).
t := t // 15.
self assert:(t printString = 14 factorial printString).
t := t // 14.
self assert:(t printString = 13 factorial printString).
t := t // 13.
self assert:(t printString = 12 factorial printString).
t := t // 12.
self assert:(t printString = 11 factorial printString).
t := t // 11.
self assert:(t printString = 10 factorial printString).
self assert:(t == 10 factorial).
t := 20 factorial.
t := t + 21 factorial.
t absSubtract:21 factorial.
self assert:(t compressed = 20 factorial).
self assert:(
[
|v|
v := 100 factorial copy.
v absSubtract:99 factorial.
v compressed = (100 factorial - 99 factorial).
] value).
"Large // Large division"
self assert:((20 factorial // 19 factorial) == 20).
self assert:((20 factorial * 21 // 20 // 21) = (19 factorial)).
self assert:((10000 factorial // 9999 factorial) == 10000).
self assert:((10000 factorial // 9999 factorial) == (10000 factorial / 9999 factorial)).
"
self basicNew testLargeDivision
"
"Modified: / 4.6.1999 / 23:54:57 / cg"
!
testLargeMultiplication
|t1|
"multiplication"
t1 := 100.
self assert:(t1 * t1 == 10000).
self assert:((t1 perform:'*' asSymbol with:t1) == 10000).
self assert:((t1 * t1) printString = '10000').
self assert:((t1 perform:'*' asSymbol with:t1) printString = '10000').
t1 := 1000.
self assert:(t1 * t1 == 1000000).
self assert:((t1 perform:'*' asSymbol with:t1) == 1000000).
self assert:((t1 * t1) printString = '1000000').
self assert:((t1 perform:'*' asSymbol with:t1) printString = '1000000').
t1 := 10000.
self assert:(t1 * t1 == 100000000).
self assert:((t1 perform:'*' asSymbol with:t1) == 100000000).
self assert:((t1 * t1) printString = '100000000').
self assert:((t1 perform:'*' asSymbol with:t1) printString = '100000000').
t1 := 100000.
SmallInteger maxBytes == 4 ifTrue:[
self assert:(t1 * t1 = 10000000000).
self assert:((t1 perform:'*' asSymbol with:t1) = 10000000000).
].
SmallInteger maxBytes == 8 ifTrue:[
self assert:(t1 * t1 == 10000000000).
self assert:((t1 perform:'*' asSymbol with:t1) == 10000000000).
].
self assert:((t1 * t1) printString = '10000000000').
self assert:((t1 perform:'*' asSymbol with:t1) printString = '10000000000').
t1 := 1000000.
self assert:((t1 * t1) printString = '1000000000000').
self assert:((t1 perform:'*' asSymbol with:t1) printString = '1000000000000').
t1 := 10000000.
self assert:((t1 * t1) printString = '100000000000000').
self assert:((t1 perform:'*' asSymbol with:t1) printString = '100000000000000').
t1 := 100000000.
self assert:((t1 * t1) printString = '10000000000000000').
self assert:((t1 perform:'*' asSymbol with:t1) printString = '10000000000000000').
t1 := 1000000000.
self assert:((t1 * t1) printString = '1000000000000000000').
self assert:((t1 perform:'*' asSymbol with:t1) printString = '1000000000000000000').
"Large * SmallInt multiplication"
self assert:(10 factorial printString = '3628800').
self assert:(20 factorial printString = '2432902008176640000').
self assert:(100 factorial printString = '93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000').
self assert:(1000 factorial printString = '402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000').
"Large * Large multiplication"
self assert:((16r3FFF * 16r3FFF) hexPrintString = 'FFF8001').
self assert:((16r7FFF * 16r7FFF) hexPrintString = '3FFF0001').
self assert:((16rFFFF * 16rFFFF) hexPrintString = 'FFFE0001').
self assert:((16r3FFFFF * 16r3FFFFF) hexPrintString = 'FFFFF800001').
self assert:((16r7FFFFF * 16r7FFFFF) hexPrintString = '3FFFFF000001').
self assert:((16rFFFFFF * 16rFFFFFF) hexPrintString = 'FFFFFE000001').
self assert:((16r3FFFFFFF * 16r3FFFFFFF) hexPrintString = 'FFFFFFF80000001').
self assert:((16r7FFFFFFF * 16r7FFFFFFF) hexPrintString = '3FFFFFFF00000001').
self assert:((16rFFFFFFFF * 16rFFFFFFFF) hexPrintString = 'FFFFFFFE00000001').
self assert:((16r3FFFFFFFFF * 16r3FFFFFFFFF) hexPrintString = 'FFFFFFFFF8000000001').
self assert:((16r7FFFFFFFFF * 16r7FFFFFFFFF) hexPrintString = '3FFFFFFFFF0000000001').
self assert:((16rFFFFFFFFFF * 16rFFFFFFFFFF) hexPrintString = 'FFFFFFFFFE0000000001').
self assert:((20 factorial * 20 factorial) printString = '5919012181389927685417441689600000000').
"
self basicNew testLargeMultiplication
"
"Modified: / 20.5.1999 / 09:41:19 / cg"
!
testLiteralNumbers
self assert:(self num_00000000000010000 hexPrintString = '10000').
self assert:(self num_00000000000100000 hexPrintString = '100000').
self assert:(self num_00000000001000000 hexPrintString = '1000000').
self assert:(self num_00000000010000000 hexPrintString = '10000000').
self assert:(self num_00000000100000000 hexPrintString = '100000000').
self assert:(self num_00000001000000000 hexPrintString = '1000000000').
self assert:(self num_00000010000000000 hexPrintString = '10000000000').
self assert:(self num_00000100000000000 hexPrintString = '100000000000').
self assert:(self num_00001000000000000 hexPrintString = '1000000000000').
self assert:(self num_00010000000000000 hexPrintString = '10000000000000').
self assert:(self num_00100000000000000 hexPrintString = '100000000000000').
self assert:(self num_01000000000000000 hexPrintString = '1000000000000000').
self assert:(self num_10000000000000000 hexPrintString = '10000000000000000').
self assert:(self num_00000000000007FFF hexPrintString = '7FFF').
self assert:(self num_00000000000008000 hexPrintString = '8000').
self assert:(self num_0000000000000FFFF hexPrintString = 'FFFF').
self assert:(self num_000000000007FFFFF hexPrintString = '7FFFFF').
self assert:(self num_00000000000800000 hexPrintString = '800000').
self assert:(self num_00000000000FFFFFF hexPrintString = 'FFFFFF').
self assert:(self num_0000000007FFFFFFF hexPrintString = '7FFFFFFF').
self assert:(self num_00000000080000000 hexPrintString = '80000000').
self assert:(self num_000000000FFFFFFFF hexPrintString = 'FFFFFFFF').
self assert:(self num_0000000FFFFFFFFFF hexPrintString = 'FFFFFFFFFF').
self assert:(self num_00000FFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFF').
self assert:(self num_000FFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFFF').
self assert:(self num_0FFFFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFFFFF').
self assert:(self num_1FFFFFFFFFFFFFFFF hexPrintString = '1FFFFFFFFFFFFFFFF').
self assert:(self num_20000000000000000 hexPrintString = '20000000000000000').
self assert:(self num_3FFFFFFFFFFFFFFFF hexPrintString = '3FFFFFFFFFFFFFFFF').
self assert:(self num_40000000000000000 hexPrintString = '40000000000000000').
self assert:(self num_7FFFFFFFFFFFFFFFF hexPrintString = '7FFFFFFFFFFFFFFFF').
self assert:(self num_80000000000000000 hexPrintString = '80000000000000000').
self assert:(self num_00000FFFFFFFFFFFE hexPrintString = 'FFFFFFFFFFFE').
self assert:(self num_00000FFFFFFFFFFFC hexPrintString = 'FFFFFFFFFFFC').
self assert:(self num_00000FFFFFFFFFFF8 hexPrintString = 'FFFFFFFFFFF8').
self assert:(self num_00000FFFFFFFFFFF0 hexPrintString = 'FFFFFFFFFFF0').
self assert:(self num_00000FFFFFFFFFFE0 hexPrintString = 'FFFFFFFFFFE0').
self assert:(self num_00000FFFFFFFFFFC0 hexPrintString = 'FFFFFFFFFFC0').
self assert:(self num_00000FFFFFFFFFF80 hexPrintString = 'FFFFFFFFFF80').
self assert:(self num_00000FFFFFFFFFF00 hexPrintString = 'FFFFFFFFFF00').
self assert:(self num_0000000000FFF0000 hexPrintString = 'FFF0000').
"
self basicNew testLiteralNumbers
"
"Modified: / 4.6.1999 / 18:41:09 / cg"
!
testPrinting1
self assert:(10 printString = '10').
self assert:(100 printString = '100').
self assert:(1000 printString = '1000').
self assert:(10000 printString = '10000').
self assert:(100000 printString = '100000').
self assert:(1000000 printString = '1000000').
self assert:(10000000 printString = '10000000').
self assert:(100000000 printString = '100000000').
self assert:(1000000000 printString = '1000000000').
self assert:(10000000000 printString = '10000000000').
self assert:(100000000000 printString = '100000000000').
self assert:(1000000000000 printString = '1000000000000').
self assert:(10000000000000 printString = '10000000000000').
self assert:(100000000000000 printString = '100000000000000').
self assert:(1000000000000000 printString = '1000000000000000').
self assert:(10000000000000000 printString = '10000000000000000').
self assert:(100000000000000000 printString = '100000000000000000').
self assert:(16rF hexPrintString = 'F').
self assert:(16rFF hexPrintString = 'FF').
self assert:(16rFFF hexPrintString = 'FFF').
self assert:(16rFFFF hexPrintString = 'FFFF').
self assert:(16rFFFFF hexPrintString = 'FFFFF').
self assert:(16rFFFFFF hexPrintString = 'FFFFFF').
self assert:(16rFFFFFFF hexPrintString = 'FFFFFFF').
self assert:(16rFFFFFFFF hexPrintString = 'FFFFFFFF').
self assert:(16rFFFFFFFFF hexPrintString = 'FFFFFFFFF').
self assert:(16rFFFFFFFFFF hexPrintString = 'FFFFFFFFFF').
self assert:(16rFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFF').
self assert:(16rFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFF').
self assert:(16rFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFF').
self assert:(16rFFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFFF').
self assert:(16rFFFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFFFF').
self assert:(16rFFFFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFFFFF').
self assert:(16rFFFFFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFFFFFF').
self assert:(16rFFFFFFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFFFFFFF').
self assert:(16rFFFFFFFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFFFFFFFF').
self assert:(16rFFFFFFFFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFFFFFFFFF').
self assert:(16r10 hexPrintString = '10').
self assert:(16r100 hexPrintString = '100').
self assert:(16r1000 hexPrintString = '1000').
self assert:(16r10000 hexPrintString = '10000').
self assert:(16r100000 hexPrintString = '100000').
self assert:(16r1000000 hexPrintString = '1000000').
self assert:(16r10000000 hexPrintString = '10000000').
self assert:(16r100000000 hexPrintString = '100000000').
self assert:(16r1000000000 hexPrintString = '1000000000').
self assert:(16r10000000000 hexPrintString = '10000000000').
self assert:(16r100000000000 hexPrintString = '100000000000').
self assert:(16r1000000000000 hexPrintString = '1000000000000').
self assert:(16r10000000000000 hexPrintString = '10000000000000').
self assert:(16r100000000000000 hexPrintString = '100000000000000').
self assert:(16r1000000000000000 hexPrintString = '1000000000000000').
self assert:(16r10000000000000000 hexPrintString = '10000000000000000').
self assert:(16r100000000000000000 hexPrintString = '100000000000000000').
"
self basicNew testPrinting1
"
"Modified: / 26.10.1999 / 22:01:35 / stefan"
!
testReading1
|t|
self assert:((Integer readFrom:'4865804016353280000') printString = '4865804016353280000').
self assert:((Integer readFrom:'FFFFFFFF' radix:16) hexPrintString = 'FFFFFFFF').
self assert:((Integer readFrom:'FFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFF').
self assert:((Integer readFrom:'FFFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFFF').
self assert:((Integer readFrom:'FFFFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFFFF').
self assert:((Integer readFrom:'FFFFFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFFFFF').
self assert:((Integer readFrom:'FFFFFFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFFFFFF').
self assert:((Integer readFrom:'FFFFFFFFFFFFFF' radix:16) hexPrintString = 'FFFFFFFFFFFFFF').
self assert:((Integer readFrom:'10000000' radix:16) hexPrintString = '10000000').
self assert:((Integer readFrom:'100000000' radix:16) hexPrintString = '100000000').
self assert:((Integer readFrom:'1000000000' radix:16) hexPrintString = '1000000000').
self assert:((Integer readFrom:'10000000000' radix:16) hexPrintString = '10000000000').
self assert:((Integer readFrom:'100000000000' radix:16) hexPrintString = '100000000000').
self assert:((Integer readFrom:'1000000000000' radix:16) hexPrintString = '1000000000000').
self assert:((Integer readFrom:'10000000000000' radix:16) hexPrintString = '10000000000000').
t := Integer readFrom:'FFFFFFFF' radix:16.
self assert:((t + 1) hexPrintString = '100000000').
t := Integer readFrom:'FFFFFFFFF' radix:16.
self assert:((t + 1) hexPrintString = '1000000000').
t := Integer readFrom:'FFFFFFFFFF' radix:16.
self assert:((t + 1) hexPrintString = '10000000000').
t := Integer readFrom:'FFFFFFFFFFF' radix:16.
self assert:((t + 1) hexPrintString = '100000000000').
t := Integer readFrom:'10000000' radix:16.
self assert:((t + 1) hexPrintString = '10000001').
t := Integer readFrom:'100000000' radix:16.
self assert:((t + 1) hexPrintString = '100000001').
t := Integer readFrom:'1000000000' radix:16.
self assert:((t + 1) hexPrintString = '1000000001').
t := Integer readFrom:'10000000000' radix:16.
self assert:((t + 1) hexPrintString = '10000000001').
"
self basicNew testReading1
"
!
testSmallIntegerArithmetic
"arithmetic tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|s n1 n2 t|
"/ test division and modulu ...
self assert:(1 printString = '1').
self assert:(10 printString = '10').
self assert:(100 printString = '100').
self assert:(1000 printString = '1000').
self assert:(10000 printString = '10000').
self assert:(100000 printString = '100000').
"addition with overflow"
SmallInteger maxBytes == 4 ifTrue:[
n1 := 16r3FFFFFFF.
n2 := -16r40000000.
] ifFalse:[
n1 := 16r3FFFFFFFFFFFFFFF.
n2 := -16r4000000000000000.
].
self assert:(n1 class == SmallInteger).
self assert:(n2 class == SmallInteger).
self assert:((n1 + 1) class == LargeInteger).
t := n1 + 1.
self assert:((t - 1) class == SmallInteger).
self assert:((n2 - 1) class == LargeInteger).
t := n2 - 1.
self assert:((t + 1) class == SmallInteger).
self assert:((n1 negated) class == SmallInteger).
self assert:((n2 negated) class == LargeInteger).
self assert:((n1 perform:'negated' asSymbol) class == SmallInteger).
self assert:((n2 perform:'negated' asSymbol) class == LargeInteger).
self assert:((n1 abs == n1)).
self assert:((n2 abs = n2 negated)).
self assert:((n1 perform:'abs' asSymbol) == n1).
self assert:((n2 perform:'abs' asSymbol) = n2 negated).
self testSmallIntegerMultiplication1.
self testSmallIntegerMultiplication1b.
self testSmallIntegerMultiplication2.
self testSmallIntegerDivision1.
"
self basicNew testSmallIntegerArithmetic
"
"Created: / 6.6.1999 / 14:47:51 / cg"
"Modified: / 9.6.1999 / 17:49:57 / cg"
!
testSmallIntegerDivision1
"division tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|s n1 n2 t|
n1 := 1000.
"/ truncation towards...
"/ ... negative infinity
n2 := 3.
self assert:((n1 // n2) == 333).
self assert:((n1 // n2) printString = '333').
self assert:((n1 perform:'//' asSymbol with:n2) == 333).
n2 := -3.
self assert:((n1 // n2) == -334).
self assert:((n1 // n2) printString = '-334').
self assert:((n1 perform:'//' asSymbol with:n2) == -334).
n2 := 3600000.
self assert:((n1 // n2) == 0).
self assert:((n1 // n2) printString = '0').
self assert:((n1 perform:'//' asSymbol with:n2) == 0).
n2 := -3600000.
self assert:((n1 // n2) == -1).
self assert:((n1 // n2) printString = '-1').
self assert:((n1 perform:'//' asSymbol with:n2) == -1).
"/ ... zero
n2 := 3.
self assert:((n1 quo: n2) == 333).
self assert:((n1 quo: n2) printString = '333').
self assert:((n1 perform:'quo:' asSymbol with:n2) == 333).
n2 := -3.
self assert:((n1 quo: n2) == -333).
self assert:((n1 quo: n2) printString = '-333').
self assert:((n1 perform:'quo:' asSymbol with:n2) == -333).
n2 := 3600000.
self assert:((n1 quo: n2) == 0).
self assert:((n1 quo: n2) printString = '0').
self assert:((n1 perform:'quo:' asSymbol with:n2) == 0).
n2 := -3600000.
self assert:((n1 quo: n2) == 0).
self assert:((n1 quo: n2) printString = '0').
self assert:((n1 perform:'quo:' asSymbol with:n2) == 0).
"
self basicNew testSmallIntegerDivision1
"
"Modified: / 9.6.1999 / 17:47:56 / cg"
"Created: / 9.6.1999 / 17:49:45 / cg"
!
testSmallIntegerMultiplication1
"multiply tests (var * const).
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|s n1 n2 t|
n1 := 100000.
n2 := n1 negated.
self assert:(n1 printString = '100000').
self assert:(n2 printString = '-100000').
self assert:((n1 * 0) printString = '0').
self assert:((n1 perform:'*' asSymbol with:0) printString = '0').
self assert:((n1 * 1) printString = '100000').
self assert:((n1 perform:'*' asSymbol with:1) printString = '100000').
self assert:((n2 * 1) printString = '-100000').
self assert:((n2 perform:'*' asSymbol with:1) printString = '-100000').
self assert:((n1 * -1) printString = '-100000').
self assert:((n1 perform:'*' asSymbol with:-1) printString = '-100000').
self assert:((n2 * -1) printString = '100000').
self assert:((n2 perform:'*' asSymbol with:-1) printString = '100000').
self assert:((n1 * 2) printString = '200000').
self assert:((n1 perform:'*' asSymbol with:2) printString = '200000').
self assert:((n1 * 3) printString = '300000').
self assert:((n1 perform:'*' asSymbol with:3) printString = '300000').
self assert:((n1 * 4) printString = '400000').
self assert:((n1 perform:'*' asSymbol with:4) printString = '400000').
self assert:((n1 * 5) printString = '500000').
self assert:((n1 perform:'*' asSymbol with:5) printString = '500000').
self assert:((n1 * 6) printString = '600000').
self assert:((n1 perform:'*' asSymbol with:6) printString = '600000').
self assert:((n1 * 7) printString = '700000').
self assert:((n1 perform:'*' asSymbol with:7) printString = '700000').
self assert:((n1 * 8) printString = '800000').
self assert:((n1 perform:'*' asSymbol with:8) printString = '800000').
self assert:((n1 * 9) printString = '900000').
self assert:((n1 perform:'*' asSymbol with:9) printString = '900000').
self assert:((n1 * 10) printString = '1000000').
self assert:((n1 perform:'*' asSymbol with:10) printString = '1000000').
self assert:((n1 * 11) printString = '1100000').
self assert:((n1 perform:'*' asSymbol with:11) printString = '1100000').
self assert:((n1 * 12) printString = '1200000').
self assert:((n1 perform:'*' asSymbol with:12) printString = '1200000').
self assert:((n1 * 13) printString = '1300000').
self assert:((n1 perform:'*' asSymbol with:13) printString = '1300000').
self assert:((n1 * 14) printString = '1400000').
self assert:((n1 perform:'*' asSymbol with:14) printString = '1400000').
self assert:((n1 * 15) printString = '1500000').
self assert:((n1 perform:'*' asSymbol with:15) printString = '1500000').
self assert:((n1 * 16) printString = '1600000').
self assert:((n1 perform:'*' asSymbol with:16) printString = '1600000').
n1 := 1.
n2 := 10.
self assert:((n1 * n2) printString = '10').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '100').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '1000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '10000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '100000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100000').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '1000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000000').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '10000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000000').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '100000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100000000').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '1000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000000000').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '10000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000000000').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '100000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100000000000').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '1000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000000000000').
n2 := n2 * 10.
self assert:((n1 * n2) printString = '10000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000000000000').
n1 := 1.
n2 := 10.
self assert:((n1 * n2) printString = '10').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '100').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '1000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '10000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '100000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100000').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '1000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000000').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '10000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000000').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '100000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100000000').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '1000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000000000').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '10000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000000000').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '100000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100000000000').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '1000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000000000000').
n1 := n1 * 10.
self assert:((n1 * n2) printString = '10000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000000000000').
n1 := 10.
n2 := 10.
self assert:((n1 * n2) printString = '100').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '10000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '1000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000000').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '100000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100000000').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '10000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000000000').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '1000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000000000000').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '100000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100000000000000').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '10000000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000000000000000').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '1000000000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000000000000000000').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '100000000000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100000000000000000000').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '10000000000000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '10000000000000000000000').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '1000000000000000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '1000000000000000000000000').
n1 := n1 * 10.
n2 := n2 * 10.
self assert:((n1 * n2) printString = '100000000000000000000000000').
self assert:((n1 perform:'*' asSymbol with:n2) printString = '100000000000000000000000000').
"
self basicNew testSmallIntegerMultiplication1
"
"Modified: / 9.6.1999 / 17:47:56 / cg"
"Created: / 9.6.1999 / 17:49:45 / cg"
!
testSmallIntegerMultiplication1b
"multiply tests (const * var).
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|s n1 n2 t|
n1 := 100000.
n2 := n1 negated.
self assert:((0 * n1) printString = '0').
self assert:((0 perform:'*' asSymbol with:n1) printString = '0').
self assert:((1 * n1) printString = '100000').
self assert:((1 perform:'*' asSymbol with:n1) printString = '100000').
self assert:((1 * n2) printString = '-100000').
self assert:((1 perform:'*' asSymbol with:n2) printString = '-100000').
self assert:((-1 * n1) printString = '-100000').
self assert:((-1 perform:'*' asSymbol with:n1) printString = '-100000').
self assert:((-1 * n2) printString = '100000').
self assert:((-1 perform:'*' asSymbol with:n2) printString = '100000').
self assert:((2 * n1) printString = '200000').
self assert:((2 perform:'*' asSymbol with:n1) printString = '200000').
self assert:((3 * n1) printString = '300000').
self assert:((3 perform:'*' asSymbol with:n1) printString = '300000').
self assert:((4 * n1) printString = '400000').
self assert:((4 perform:'*' asSymbol with:n1) printString = '400000').
self assert:((5 * n1) printString = '500000').
self assert:((5 perform:'*' asSymbol with:n1) printString = '500000').
self assert:((6 * n1) printString = '600000').
self assert:((6 perform:'*' asSymbol with:n1) printString = '600000').
self assert:((7 * n1) printString = '700000').
self assert:((7 perform:'*' asSymbol with:n1) printString = '700000').
self assert:((8 * n1) printString = '800000').
self assert:((8 perform:'*' asSymbol with:n1) printString = '800000').
self assert:((9 * n1) printString = '900000').
self assert:((9 perform:'*' asSymbol with:n1) printString = '900000').
self assert:((10 * n1) printString = '1000000').
self assert:((10 perform:'*' asSymbol with:n1) printString = '1000000').
self assert:((11 * n1) printString = '1100000').
self assert:((11 perform:'*' asSymbol with:n1) printString = '1100000').
"
self basicNew testSmallIntegerMultiplication1b
"
"Modified: / 9.6.1999 / 17:47:56 / cg"
"Created: / 9.6.1999 / 17:49:45 / cg"
!
testSmallIntegerMultiplication2
"multiply tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|s n1 n2 t|
n1 := 100000.
n2 := n1 negated.
self assert:((n1 * 2) printString = '200000').
self assert:((n1 perform:'*' asSymbol with:2) printString = '200000').
self assert:((n1 * 3) printString = '300000').
self assert:((n1 perform:'*' asSymbol with:3) printString = '300000').
self assert:((n1 * 4) printString = '400000').
self assert:((n1 perform:'*' asSymbol with:4) printString = '400000').
self assert:((n1 * 5) printString = '500000').
self assert:((n1 perform:'*' asSymbol with:5) printString = '500000').
self assert:((n1 * 6) printString = '600000').
self assert:((n1 perform:'*' asSymbol with:6) printString = '600000').
self assert:((n1 * 7) printString = '700000').
self assert:((n1 perform:'*' asSymbol with:7) printString = '700000').
self assert:((n1 * 8) printString = '800000').
self assert:((n1 perform:'*' asSymbol with:8) printString = '800000').
self assert:((n1 * 9) printString = '900000').
self assert:((n1 perform:'*' asSymbol with:9) printString = '900000').
self assert:((n1 * 10) printString = '1000000').
self assert:((n1 perform:'*' asSymbol with:10) printString = '1000000').
self assert:((n1 * 11) printString = '1100000').
self assert:((n1 perform:'*' asSymbol with:11) printString = '1100000').
self assert:((n1 * 12) printString = '1200000').
self assert:((n1 perform:'*' asSymbol with:12) printString = '1200000').
self assert:((n1 * 13) printString = '1300000').
self assert:((n1 perform:'*' asSymbol with:13) printString = '1300000').
self assert:((n1 * 14) printString = '1400000').
self assert:((n1 perform:'*' asSymbol with:14) printString = '1400000').
self assert:((n1 * 15) printString = '1500000').
self assert:((n1 perform:'*' asSymbol with:15) printString = '1500000').
self assert:((n1 * 16) printString = '1600000').
self assert:((n1 perform:'*' asSymbol with:16) printString = '1600000').
self assert:((n1 * 17) printString = '1700000').
self assert:((n1 perform:'*' asSymbol with:17) printString = '1700000').
self assert:((n1 * 18) printString = '1800000').
self assert:((n1 perform:'*' asSymbol with:18) printString = '1800000').
self assert:((n1 * 19) printString = '1900000').
self assert:((n1 perform:'*' asSymbol with:19) printString = '1900000').
"
self basicNew testSmallIntegerMultiplication2
"
"Modified: / 9.6.1999 / 17:47:56 / cg"
"Created: / 9.6.1999 / 17:49:45 / cg"
!
testSmallIntegerMultiplication3
"multiply tests.
Notice, the arithmetic tests are both performed via regular sends
and via constructed performs. The reason is to test both inlined
JIT-compiler code AND the regular methods code."
|s n1 n2 t|
n1 := 16rFFFF.
n2 := n1 negated.
self assert:((n1 * 2) printString = '131070').
self assert:((n1 perform:'*' asSymbol with:2) printString = '131070').
self assert:((n2 * 2) printString = '-131070').
self assert:((n2 perform:'*' asSymbol with:2) printString = '-131070').
n1 := 16rFFFFFF.
n2 := n1 negated.
self assert:((n1 * 2) printString = '33554430').
self assert:((n1 perform:'*' asSymbol with:2) printString = '33554430').
self assert:((n2 * 2) printString = '-33554430').
self assert:((n2 perform:'*' asSymbol with:2) printString = '-33554430').
n1 := 16r3FFFFFFF.
n2 := n1 negated.
self assert:((n1 * 2) printString = '2147483646').
self assert:((n1 perform:'*' asSymbol with:2) printString = '2147483646').
self assert:((n2 * 2) printString = '-2147483646').
self assert:((n2 perform:'*' asSymbol with:2) printString = '-2147483646').
SmallInteger maxBytes == 4 ifTrue:[
n1 := 16r3FFFFFFF.
] ifFalse:[
n1 := 16r3FFFFFFFFFFFFFFF.
].
self assert:(n1 class == SmallInteger).
self assert:((n1 * 2) class == LargeInteger).
self assert:((n1 perform:'*' asSymbol with:2) class == LargeInteger).
n1 := SmallInteger maxVal // 11.
self assert:((n1 * 11) class == SmallInteger).
n1 := n1 + 1.
self assert:((n1 * 11) class == LargeInteger).
"
self basicNew testSmallIntegerMultiplication3
"
"Modified: / 9.6.1999 / 17:47:56 / cg"
"Created: / 9.6.1999 / 17:49:45 / cg"
! !
!IntegerTest class methodsFor:'documentation'!
version
^ '$Header$'
! !