"{ 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 ).
ExternalAddress pointerSize == 8 ifTrue:[
self assert: ( (self doPlus1_a:SmallInteger maxVal) = 4611686018427387904).
self assert: ( (self doPlus1_a:SmallInteger minVal) = -4611686018427387903 ).
] ifFalse:[
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 ).
ExternalAddress pointerSize == 8 ifTrue:[
self assert: ( (self doPlus1_b:SmallInteger maxVal) = 4611686018427387904).
self assert: ( (self doPlus1_b:SmallInteger minVal) = -4611686018427387903 ).
] ifFalse:[
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_16r80000000
^ 16r80000000
!
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'!
doCompare:a againstEqual:b
self assert:(a < b) not.
self assert:(a <= b).
self assert:(a = b).
self assert:(a ~= b) not.
self assert:(a > b) not.
self assert:(a >= b).
self assert:(a perform:#< with:b) not.
self assert:(a perform:#<= with:b).
self assert:(a perform:#= with:b).
self assert:(a perform:#~= with:b) not.
self assert:(a perform:#> with:b) not.
self assert:(a perform:#>= with:b).
"
self basicNew doCompare:12 againstEqual:12
"
!
doCompare:a againstGreater:b
self assert:(a < b).
self assert:(a <= b).
self assert:(a = b) not.
self assert:(a ~= b).
self assert:(a == b) not.
self assert:(a ~~ b).
self assert:(a > b) not.
self assert:(a >= b) not.
self assert:(a perform:#< with:b).
self assert:(a perform:#<= with:b).
self assert:(a perform:#= with:b) not.
self assert:(a perform:#~= with:b).
self assert:(a perform:#== with:b) not.
self assert:(a perform:#~~ with:b).
self assert:(a perform:#> with:b) not.
self assert:(a perform:#>= with:b) not.
"
self basicNew doCompare:12 againstGreater:16r80000000
"
!
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 testLargeBitOperations.
self testIntegerShifts.
self testEncodeDecode.
self testIntegerMisc.
self testInline1
"
self basicNew doTestAll
"
"Modified: / 31.10.2000 / 20:23:20 / cg"
!
testComparing
|a b|
a := 12.
b := 16r80000000.
self doCompare:a againstGreater:b.
a := 12.
b := 16r80000000.
self doCompare:a againstGreater:16r80000000.
a := 0.
self doCompare:a againstGreater:16r80000000.
a := -1.
self doCompare:a againstGreater:16r80000000.
a := 16r-80000000.
self doCompare:a againstGreater:16r80000000.
a := 16r-40000000.
self doCompare:a againstGreater:16r80000000.
a := 16r-40000000.
self doCompare:a againstGreater:16r40000000.
a := 16r-3FFFFFFF.
self doCompare:a againstGreater:16r3FFFFFFF.
a := 16r-40000000.
self doCompare:a againstGreater:16r3FFFFFFF.
a := 16r-3FFFFFFF.
self doCompare:a againstGreater:16r40000000.
"/ smallint-largeInt boundaries
a := 16r3FFFFFFE.
self doCompare:a againstEqual:16r3FFFFFFE.
a := 16r3FFFFFFE.
self doCompare:a againstGreater:16r3FFFFFFF.
a := 16r3FFFFFFE.
self doCompare:a againstGreater:16r40000000.
a := 16r3FFFFFFE.
self doCompare:a againstGreater:16r80000000.
a := 16r3FFFFFFE.
self doCompare:a againstGreater:16rFFFFFFFF.
a := 16r3FFFFFFF.
self doCompare:a againstEqual:16r3FFFFFFF.
a := 16r3FFFFFFF.
self doCompare:a againstGreater:16r40000000.
a := 16r3FFFFFFF.
self doCompare:a againstGreater:16r80000000.
a := 16r3FFFFFFF.
self doCompare:a againstGreater:16rFFFFFFFF.
a := 16r40000000.
self doCompare:a againstEqual:16r40000000.
a := 16r40000000.
self doCompare:a againstGreater:16r80000000.
a := 16r40000000.
self doCompare:a againstGreater:16rFFFFFFFF.
a := 16r7FFFFFFF.
self doCompare:a againstEqual:16r7FFFFFFF.
a := 16r7FFFFFFF.
self doCompare:a againstGreater:16r80000000.
a := 16r7FFFFFFF.
self doCompare:a againstGreater:16rFFFFFFFF.
a := 16r80000000.
self doCompare:a againstEqual:16r80000000.
a := 16r80000000.
self doCompare:a againstGreater:16rFFFFFFFF.
a := 16rFFFFFFFF.
self doCompare:a againstEqual:16rFFFFFFFF.
a := 16rFFFFFFFF.
self doCompare:a againstGreater:16r100000000.
"
self basicNew testComparing
"
!
testConstants
|t|
self assert:((t := self num_16r80000000) > 0).
self assert:((t := self num_16r80000000) = 16r80000000).
"
self basicNew testConstants
"
!
testDivision
|a b op rslt|
op := #//.
a := -1.
b := 8.
self assert:(-1 // 8 == -1).
self assert:(a // 8 == -1).
self assert:(-1 // b == -1).
self assert:(a // b == -1).
self assert:((rslt := -1 perform:op with: 8) == -1).
self assert:((rslt := a perform:op with: 8) == -1).
self assert:((rslt := -1 perform:op with: b) == -1).
self assert:((rslt := a perform:op with: b) == -1).
a := 1.
b := -8.
self assert:(1 // -8 == -1).
self assert:(a // -8 == -1).
self assert:(1 // b == -1).
self assert:(a // b == -1).
self assert:((rslt := 1 perform:op with: -8) == -1).
self assert:((rslt := a perform:op with: -8) == -1).
self assert:((rslt := 1 perform:op with: b) == -1).
self assert:((rslt := a perform:op with: b) == -1).
a := -1.
b := -8.
self assert:(-1 // -8 == 0).
self assert:(a // -8 == 0).
self assert:(-1 // b == 0).
self assert:(a // b == 0).
self assert:((rslt := -1 perform:op with: -8) == 0).
self assert:((rslt := a perform:op with: -8) == 0).
self assert:((rslt := -1 perform:op with: b) == 0).
self assert:((rslt := a perform:op with: b) == 0).
a := 1.
b := 8.
self assert:(1 // 8 == 0).
self assert:(a // 8 == 0).
self assert:(1 // b == 0).
self assert:(a // b == 0).
self assert:((rslt := 1 perform:op with: 8) == 0).
self assert:((rslt := a perform:op with: 8) == 0).
self assert:((rslt := 1 perform:op with: b) == 0).
self assert:((rslt := a perform:op with: b) == 0).
a := -16.
b := 8.
self assert:(-16 // 8 == -2).
self assert:(a // 8 == -2).
self assert:(-16 // b == -2).
self assert:(a // b == -2).
self assert:((rslt := -16 perform:op with: 8) == -2).
self assert:((rslt := a perform:op with: 8) == -2).
self assert:((rslt := -16 perform:op with: b) == -2).
self assert:((rslt := a perform:op with: b) == -2).
a := 16.
b := -8.
self assert:(16 // -8 == -2).
self assert:(a // -8 == -2).
self assert:(16 // b == -2).
self assert:(a // b == -2).
self assert:((rslt := 16 perform:op with: -8) == -2).
self assert:((rslt := a perform:op with: -8) == -2).
self assert:((rslt := 16 perform:op with: b) == -2).
self assert:((rslt := a perform:op with: b) == -2).
a := -16.
b := -8.
self assert:(-16 // -8 == 2).
self assert:(a // -8 == 2).
self assert:(-16 // b == 2).
self assert:(a // b == 2).
self assert:((rslt := -16 perform:op with: -8) == 2).
self assert:((rslt := a perform:op with: -8) == 2).
self assert:((rslt := -16 perform:op with: b) == 2).
self assert:((rslt := a perform:op with: b) == 2).
a := 16.
b := 8.
self assert:(16 // 8 == 2).
self assert:(a // 8 == 2).
self assert:(16 // b == 2).
self assert:(a // b == 2).
self assert:((rslt := 16 perform:op with: 8) == 2).
self assert:((rslt := a perform:op with: 8) == 2).
self assert:((rslt := 16 perform:op with: b) == 2).
self assert:((rslt := a perform:op with: b) == 2).
op := #quo:.
a := -1.
b := 8.
self assert:((rslt := -1 quo: 8) == 0).
self assert:((rslt := a quo: 8) == 0).
self assert:((rslt := -1 quo: b) == 0).
self assert:((rslt := a quo: b) == 0).
self assert:((rslt := -1 perform:op with: -8) == 0).
self assert:((rslt := a perform:op with: -8) == 0).
self assert:((rslt := -1 perform:op with: b) == 0).
self assert:((rslt := a perform:op with: b) == 0).
a := 1.
b := -8.
self assert:((rslt := 1 quo: -8) == 0).
self assert:((rslt := a quo: -8) == 0).
self assert:((rslt := 1 quo: b) == 0).
self assert:((rslt := a quo: b) == 0).
self assert:((rslt := 1 perform:op with: -8) == 0).
self assert:((rslt := a perform:op with: -8) == 0).
self assert:((rslt := 1 perform:op with: b) == 0).
self assert:((rslt := a perform:op with: b) == 0).
a := -1.
b := -8.
self assert:((rslt := -1 quo: -8) == 0).
self assert:((rslt := a quo: -8) == 0).
self assert:((rslt := -1 quo: b) == 0).
self assert:((rslt := a quo: b) == 0).
self assert:((rslt := -1 perform:op with: -8) == 0).
self assert:((rslt := a perform:op with: -8) == 0).
self assert:((rslt := -1 perform:op with: b) == 0).
self assert:((rslt := a perform:op with: b) == 0).
a := 1.
b := 8.
self assert:((rslt := 1 quo: 8) == 0).
self assert:((rslt := a quo: 8) == 0).
self assert:((rslt := 1 quo: b) == 0).
self assert:((rslt := a quo: b) == 0).
self assert:((rslt := 1 perform:op with: 8) == 0).
self assert:((rslt := a perform:op with: 8) == 0).
self assert:((rslt := 1 perform:op with: b) == 0).
self assert:((rslt := a perform:op with: b) == 0).
a := -16.
b := 8.
self assert:((rslt := -16 quo: 8) == -2).
self assert:((rslt := a quo: 8) == -2).
self assert:((rslt := -16 quo: b) == -2).
self assert:((rslt := a quo: b) == -2).
self assert:((rslt := -16 perform:op with: 8) == -2).
self assert:((rslt := a perform:op with: 8) == -2).
self assert:((rslt := -16 perform:op with: b) == -2).
self assert:((rslt := a perform:op with: b) == -2).
a := 16.
b := -8.
self assert:((rslt := 16 quo: -8) == -2).
self assert:((rslt := a quo: -8) == -2).
self assert:((rslt := 16 quo: b) == -2).
self assert:((rslt := a quo: b) == -2).
self assert:((rslt := 16 perform:op with: -8) == -2).
self assert:((rslt := a perform:op with: -8) == -2).
self assert:((rslt := 16 perform:op with: b) == -2).
self assert:((rslt := a perform:op with: b) == -2).
a := -16.
b := -8.
self assert:((rslt := -16 quo: -8) == 2).
self assert:((rslt := a quo: -8) == 2).
self assert:((rslt := -16 quo: b) == 2).
self assert:((rslt := a quo: b) == 2).
self assert:((rslt := -16 perform:op with: -8) == 2).
self assert:((rslt := a perform:op with: -8) == 2).
self assert:((rslt := -16 perform:op with: b) == 2).
self assert:((rslt := a perform:op with: b) == 2).
a := 16.
b := 8.
self assert:((rslt := 16 quo: 8) == 2).
self assert:((rslt := a quo: 8) == 2).
self assert:((rslt := 16 quo: b) == 2).
self assert:((rslt := a quo: b) == 2).
self assert:((rslt := 16 perform:op with: 8) == 2).
self assert:((rslt := a perform:op with: 8) == 2).
self assert:((rslt := 16 perform:op with: b) == 2).
self assert:((rslt := a perform:op with: b) == 2).
"
self basicNew testDivision
"
!
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"
!
testFactorial
"/ <testedMethods: #( (Integer >> #factorial) (Integer >> #*) ) >
self assert:(1 factorial = 1).
self assert:(2 factorial = 2).
self assert:(10 factorial = 3628800).
self assert:(11 factorial = 39916800).
"
self basicNew testFactorial
"
"Created: / 24-04-2010 / 13:52:23 / cg"
"Modified: / 27-04-2010 / 10:34:22 / cg"
!
testGCD
"/ <testedMethods: #( (Integer >> #gcd:) ) >
self assert:(9 gcd:6) = 3.
self assert:(6 gcd:9) = 3.
self assert:(2 gcd:0) = 2.
self assert:(0 gcd:2) = 2.
"
self basicNew testGCD
"
"Created: / 27-04-2010 / 09:49:31 / cg"
!
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 method's code."
|minVal maxVal maxValPlus1 minValMinus1 halfMin halfMax t|
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.
self assert:(SmallInteger maxBytes == ExternalAddress pointerSize).
"/ again, preventing inlining by compiler
self assert:(SmallInteger perform:#maxBytes) == (ExternalAddress perform:#pointerSize).
self assert:(SmallInteger perform:'maxBytes' asSymbol) == (ExternalAddress perform:'pointerSize' asSymbol).
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"
!
testIntegerMisc2
"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."
|n sel|
"/ fib is optional
(0 respondsTo:#fib) ifFalse:[^ self].
self assert:(0 fib == 0).
self assert:(1 fib == 1).
self assert:(2 fib == 1).
self assert:(3 fib == 2).
self assert:(4 fib == 3).
self assert:(5 fib == 5).
self assert:(6 fib == 8).
self assert:(7 fib == 13).
n := 0.
self assert:(n fib == 0).
n := 1.
self assert:(n fib == 1).
n := 2.
self assert:(n fib == 1).
n := 3.
self assert:(n fib == 2).
n := 4.
self assert:(n fib == 3).
n := 5.
self assert:(n fib == 5).
n := 6.
self assert:(n fib == 8).
n := 7.
self assert:(n fib == 13).
#(0 1 2 3 4 5 6 7)
with:#(0 1 1 2 3 5 8 13)
do:[:n :rslt |
self assert:(n fib == rslt).
].
"/ #(0 1 2 3 4 5 6 7)
"/ with:#(0 1 1 2 3 5 8 13)
"/ do:[:n :rslt |
"/ self assert:(n fib_recursive == rslt).
"/ ].
sel := #fib.
self assert:((0 perform:sel) == 0).
self assert:((1 perform:sel) == 1).
self assert:((2 perform:sel) == 1).
self assert:((3 perform:sel) == 2).
self assert:((4 perform:sel) == 3).
self assert:((5 perform:sel) == 5).
self assert:((6 perform:sel) == 8).
self assert:((7 perform:sel) == 13).
"
self basicNew testIntegerMisc2
"
!
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
"
!
testIntegerShifts4
"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."
|a|
a := 16r1234.
self assert:( ((a bitShift:-4) bitAnd:16rFF) == 16r23 ).
self assert:( ((a bitShift:-8) bitAnd:16rFF) == 16r12 ).
self assert:( ((a bitShift:-12) bitAnd:16rFF) == 16r1 ).
self assert:( ((a bitShift:-16) bitAnd:16rFF) == 0 ).
"/ should not shift in any sign bits ...
a := 16r1FFFFFFF.
self assert:( (a bitShift:-4) == 16r1FFFFFF ).
a := 16r3FFFFFFF.
self assert:( (a bitShift:-4) == 16r3FFFFFF ).
a := 16r7FFFFFFF.
self assert:( (a bitShift:-4) == 16r7FFFFFF ).
a := 16rFFFFFFFF.
self assert:( (a bitShift:-4) == 16rFFFFFFF ).
a := 16r1FFFFFFFF.
self assert:( (a bitShift:-4) == 16r1FFFFFFF ).
a := 16r1FFFFFFF.
self assert:( (a bitShift:-8) == 16r1FFFFF ).
a := 16r3FFFFFFF.
self assert:( (a bitShift:-8) == 16r3FFFFF ).
a := 16r7FFFFFFF.
self assert:( (a bitShift:-8) == 16r7FFFFF ).
a := 16rFFFFFFFF.
self assert:( (a bitShift:-8) == 16rFFFFFF ).
a := 16r1FFFFFFFF.
self assert:( (a bitShift:-8) == 16r1FFFFFF ).
"
self basicNew testIntegerShifts4
"
!
testIsPowerOfTwo
self assert:(1 isPowerOfTwo).
self assert:(2 isPowerOfTwo).
self assert:(4 isPowerOfTwo).
self assert:(3 isPowerOfTwo not).
"
self basicNew testIsPowerOfTwo
"
"Created: / 27-04-2010 / 10:35:36 / cg"
!
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"
!
testLargeBitOperations
"large bit operations test."
self assert:(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFF) hexPrintString = '2211'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFFFF) hexPrintString = '332211'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFFFFFF) hexPrintString = '44332211'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFFFFFFFF) hexPrintString = '5544332211'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFFFFFFFFFF) hexPrintString = '665544332211'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFFFFFFFFFFFF) hexPrintString = '77665544332211'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFFFFFFFFFFFFFF) hexPrintString = '8877665544332211'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFFFFFFFFFFFFFFFF) hexPrintString = '998877665544332211'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFFFFFFFFFFFFFFFFFF) hexPrintString = 'AA998877665544332211'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFFFFFFFFFFFFFFFFFFFF) hexPrintString = 'BBAA998877665544332211'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFFFFFFFFFFFFFFFFFFFFFF) hexPrintString = 'CCBBAA998877665544332211'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFF) hexPrintString = 'FFEEDDCCBBAA99887766554433FFFF'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFFFF) hexPrintString = 'FFEEDDCCBBAA998877665544FFFFFF'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFFFFFF) hexPrintString = 'FFEEDDCCBBAA9988776655FFFFFFFF'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFFFFFFFF) hexPrintString = 'FFEEDDCCBBAA99887766FFFFFFFFFF'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFFFFFFFFFF) hexPrintString = 'FFEEDDCCBBAA998877FFFFFFFFFFFF'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFFFFFFFFFFFF) hexPrintString = 'FFEEDDCCBBAA9988FFFFFFFFFFFFFF'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFFFFFFFFFFFFFF) hexPrintString = 'FFEEDDCCBBAA99FFFFFFFFFFFFFFFF'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFFFFFFFFFFFFFFFF) hexPrintString = 'FFEEDDCCBBAAFFFFFFFFFFFFFFFFFF'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFFFFFFFFFFFFFFFFFF) hexPrintString = 'FFEEDDCCBBFFFFFFFFFFFFFFFFFFFF'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFFFFFFFFFFFFFFFFFFFF) hexPrintString = 'FFEEDDCCFFFFFFFFFFFFFFFFFFFFFF'.
self assert:(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFFFFFFFFFFFFFFFFFFFFFF) hexPrintString = 'FFEEDDFFFFFFFFFFFFFFFFFFFFFFFF'.
Time millisecondsToRun:[
1000000 timesRepeat:[
(16rFFEEDDCCBBAA998877665544332211 bitAnd:16rFFFFFFFFFFFFFFFFFFFFFFFF)
]
].
"/ bitAnd inherited via Integer: 1638 1575 1576
"/ bitAnd tuned in largeInteger: 172 171 172
Time millisecondsToRun:[
1000000 timesRepeat:[
(16rFFEEDDCCBBAA998877665544332211 bitOr:16rFFFFFFFFFFFFFFFFFFFFFFFF)
]
].
"/ bitOr inherited via Integer: 1903 1856 1856
"
self basicNew testLargeBitOperations
"
"Modified: / 4.6.1999 / 15:26:55 / cg"
!
testLargeCompression1
|l nullBytes|
#(
#[ 1 ] 16r01
#[ 1 2 ] 16r0201
#[ 1 2 3] 16r030201
#[ 1 2 3 4] 16r04030201
) pairWiseDo:[:bytes :expected |
0 to:16 do:[:nNullBytes |
nullBytes := ByteArray new:nNullBytes withAll:0.
l := LargeInteger digitBytes:(bytes , nullBytes).
self assert:( l compressed == expected ).
].
].
#(
#[ 1 2 3 4 5] 16r0504030201
#[ 1 2 3 4 5 6] 16r060504030201
#[ 1 2 3 4 5 6 7] 16r07060504030201
#[ 1 2 3 4 5 6 7 8] 16r0807060504030201
) pairWiseDo:[:bytes :expected |
0 to:16 do:[:nNullBytes |
nullBytes := ByteArray new:nNullBytes withAll:0.
l := LargeInteger digitBytes:(bytes , nullBytes).
ExternalAddress pointerSize == 8 ifTrue:[
self assert:( l compressed == expected ).
] ifFalse:[
self assert:( l compressed = expected ).
]
]
].
#(
#[ 1 2 3 4 5 6 7 8 9] 16r090807060504030201
#[ 1 2 3 4 5 6 7 8 9 10] 16r0a090807060504030201
#[ 1 2 3 4 5 6 7 8 9 10 11] 16r0b0a090807060504030201
) pairWiseDo:[:bytes :expected |
0 to:16 do:[:nNullBytes |
nullBytes := ByteArray new:nNullBytes withAll:0.
l := LargeInteger digitBytes:(bytes , nullBytes).
self assert:( l compressed = expected ).
]
].
"
self basicNew testLargeCompression1
"
!
testLargeDivision
|t v a b|
"/ on a 64bit machine, this is actually a smallInteger!!
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)).
a := 40 factorial.
b := 39 factorial.
self assert:(a // 40 = b).
self assert:(a / 40 = b).
self assert:(a // b = 40).
self assert:(a // b = 40).
"
self basicNew testLargeDivision
"
"Modified: / 4.6.1999 / 23:54:57 / cg"
!
testLargeDivision2
|t|
t := 30 factorial.
self assert:(t printString = '265252859812191058636308480000000').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '26525285981219105863630848000000').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '2652528598121910586363084800000').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '265252859812191058636308480000').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '26525285981219105863630848000').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '2652528598121910586363084800').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '265252859812191058636308480').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '26525285981219105863630848').
self assert:(t \\ 10 == 8).
t := t // 10.
self assert:(t printString = '2652528598121910586363084').
self assert:(t \\ 10 == 4).
t := t // 10.
self assert:(t printString = '265252859812191058636308').
self assert:(t \\ 10 == 8).
t := t // 10.
self assert:(t printString = '26525285981219105863630').
self assert:(t \\ 10 == 0).
t := t // 10.
self assert:(t printString = '2652528598121910586363').
self assert:(t \\ 10 == 3).
t := 30 factorial.
self assert:(t printString = '265252859812191058636308480000000').
self assert:(t \\ 1000 == 0).
t := t // 1000.
self assert:(t printString = '265252859812191058636308480000').
self assert:(t \\ 1000 == 0).
t := t // 1000.
self assert:(t printString = '265252859812191058636308480').
self assert:(t \\ 1000 == 480).
t := t // 1000.
self assert:(t printString = '265252859812191058636308').
self assert:(t \\ 1000 == 308).
t := t // 1000.
self assert:(t printString = '265252859812191058636').
self assert:(t \\ 1000 == 636).
t := t // 1000.
self assert:(t printString = '265252859812191058').
self assert:(t \\ 1000 == 058).
t := t // 1000.
self assert:(t printString = '265252859812191').
self assert:(t \\ 1000 == 191).
t := t // 1000.
self assert:(t printString = '265252859812').
self assert:(t \\ 1000 == 812).
t := t // 1000.
self assert:(t printString = '265252859').
self assert:(t \\ 1000 == 859).
t := t // 1000.
self assert:(t printString = '265252').
self assert:(t \\ 1000 == 252).
t := t // 1000.
self assert:(t == 265).
t := 30 factorial.
"Large // SmallInt division"
t := t // 30.
self assert:(t printString = 29 factorial printString).
t := t // 29.
self assert:(t printString = 28 factorial printString).
t := t // 28.
self assert:(t printString = 27 factorial printString).
t := t // 27.
self assert:(t printString = 26 factorial printString).
t := t // 26.
self assert:(t printString = 25 factorial printString).
t := t // 25.
self assert:(t printString = 24 factorial printString).
t := t // 24.
self assert:(t printString = 23 factorial printString).
t := t // 23.
self assert:(t printString = 22 factorial printString).
t := t // 22.
self assert:(t printString = 21 factorial printString).
t := t // 21.
self assert:(t printString = 20 factorial printString).
self assert:(t = 20 factorial).
t := 30 factorial.
t := t + 31 factorial.
t absSubtract:31 factorial.
self assert:(t compressed = 30 factorial).
"Large // Large division"
self assert:((30 factorial // 29 factorial) == 30).
self assert:((30 factorial * 31 // 30 // 31) = (29 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"
!
testLargeIntegerHelpers
|t1 t2|
"/ mul2
t1 := 16r12345678901234567890.
t2 := t1 deepCopy.
self assert:(t2 mul2 = (t1 * 2)).
t1 := 16r1234567890123456789012345678901234567890.
t2 := t1 deepCopy.
self assert:(t2 mul2 = (t1 * 2)).
t1 := 16r123456789012345678901234567890123456789012345678901234567890.
t2 := t1 deepCopy.
self assert:(t2 mul2 = (t1 * 2)).
t1 := 16r12345678901234567890123456789012345678901234567890123456789012345678901234567890.
t2 := t1 deepCopy.
self assert:(t2 mul2 = (t1 * 2)).
t1 := 10000 factorial.
t2 := t1 deepCopy.
self assert:(t2 mul2 = (t1 * 2)).
t1 := 16r123456789012345678901234567890123456789012345678901234567890.
t2 := t1 deepCopy.
self assert:(t2 mul2 = (t1 * 2)).
"/ t1 := 1000 factorial.
"/ t := Time millisecondsToRun:[ 100000 timesRepeat:[ t1 mul2. ] ].
"/ Transcript showCR:t.
"/ div2
t1 := 16r12345678901234567890.
t2 := t1 deepCopy.
t2 div2.
"/ do not compare t2 = t1 // x, because t2 may be unnormalized
self assert:(t2 printStringRadix:16) = ((t1 // 2) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 4) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 8) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 16) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 32) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 64) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 128) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 256) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 512) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 1024) printStringRadix:16).
t1 := 16r1234567890123456789012345678901234567890.
t2 := t1 deepCopy.
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 2) printStringRadix:16).
t1 := 16r123456789012345678901234567890123456789012345678901234567890.
t2 := t1 deepCopy.
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 2) printStringRadix:16).
t1 := 16r12345678901234567890123456789012345678901234567890123456789012345678901234567890.
t2 := t1 deepCopy.
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 2) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 4) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 8) printStringRadix:16).
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 16) printStringRadix:16).
t1 := 10000 factorial.
t2 := t1 deepCopy.
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 2) printStringRadix:16).
t1 := 16r123456789012345678901234567890123456789012345678901234567890.
t2 := t1 deepCopy.
t2 div2.
self assert:(t2 printStringRadix:16) = ((t1 // 2) printStringRadix:16).
t1 := 12345678901234567890.
t2 := t1 divMod:1000.
self assert:(t2 at:1) = 12345678901234567.
self assert:(t2 at:2) = 890.
"
self basicNew testLargeIntegerHelpers
"
"Modified: / 20.5.1999 / 09:41:19 / cg"
!
testLargeMultiplication
|t1 t2|
"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').
t1 := 100000000. "/ small
t2 := 100000000000000000. "/ large on 32bit; small on 64bt machines
self assert:(t1 * t2) = 10000000000000000000000000.
self assert:(t2 * t1) = 10000000000000000000000000.
t1 := 100000000. "/ small
t2 := 1000000000000000000. "/ large on 32bit; small on 64bt machines
self assert:(t1 * t2) = 100000000000000000000000000.
self assert:(t2 * t1) = 100000000000000000000000000.
t1 := 100000000. "/ small
t2 := 10000000000000000000. "/ large
self assert:(t1 * t2) = 1000000000000000000000000000.
self assert:(t2 * t1) = 1000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 100000000000000000000. "/ large
self assert:(t1 * t2) = 10000000000000000000000000000.
self assert:(t2 * t1) = 10000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 1000000000000000000000. "/ large
self assert:(t1 * t2) = 100000000000000000000000000000.
self assert:(t2 * t1) = 100000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 10000000000000000000000. "/ large
self assert:(t1 * t2) = 1000000000000000000000000000000.
self assert:(t2 * t1) = 1000000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 100000000000000000000000. "/ large
self assert:(t1 * t2) = 10000000000000000000000000000000.
self assert:(t2 * t1) = 10000000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 1000000000000000000000000. "/ large
self assert:(t1 * t2) = 100000000000000000000000000000000.
self assert:(t2 * t1) = 100000000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 10000000000000000000000000. "/ large
self assert:(t1 * t2) = 1000000000000000000000000000000000.
self assert:(t2 * t1) = 1000000000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 100000000000000000000000000. "/ large
self assert:(t1 * t2) = 10000000000000000000000000000000000.
self assert:(t2 * t1) = 10000000000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 1000000000000000000000000000. "/ large
self assert:(t1 * t2) = 100000000000000000000000000000000000.
self assert:(t2 * t1) = 100000000000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 10000000000000000000000000000. "/ large
self assert:(t1 * t2) = 1000000000000000000000000000000000000.
self assert:(t2 * t1) = 1000000000000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 100000000000000000000000000000. "/ large
self assert:(t1 * t2) = 10000000000000000000000000000000000000.
self assert:(t2 * t1) = 10000000000000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 1000000000000000000000000000000. "/ large
self assert:(t1 * t2) = 100000000000000000000000000000000000000.
self assert:(t2 * t1) = 100000000000000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 10000000000000000000000000000000. "/ large
self assert:(t1 * t2) = 1000000000000000000000000000000000000000.
self assert:(t2 * t1) = 1000000000000000000000000000000000000000.
t1 := 100000000. "/ small
t2 := 100000000000000000000000000000000. "/ large
self assert:(t1 * t2) = 10000000000000000000000000000000000000000.
self assert:(t2 * t1) = 10000000000000000000000000000000000000000.
"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 assert:((16rFFFFFFFFFFFF * 16rFFFFFFFFFF) hexPrintString = 'FFFFFFFFFEFF0000000001').
self assert:((16rFFFFFFFFFFFFFF * 16rFFFFFFFFFF) hexPrintString = 'FFFFFFFFFEFFFF0000000001').
self assert:((t1 := 16rFFFFFFFFFFFFFFFF * 16rFFFFFFFFFF) hexPrintString = 'FFFFFFFFFEFFFFFF0000000001').
self assert:((16rFFFFFFFFFFFFFFFFFF * 16rFFFFFFFFFF) hexPrintString = 'FFFFFFFFFEFFFFFFFF0000000001').
self assert:((16rFFFFFFFFFFFFFFFFFFFF * 16rFFFFFFFFFF) hexPrintString = 'FFFFFFFFFEFFFFFFFFFF0000000001').
self assert:((16rFFFFFFFFFFFFFFFFFFFFFF * 16rFFFFFFFFFF) hexPrintString = 'FFFFFFFFFEFFFFFFFFFFFF0000000001').
self assert:((16rFFFFFFFFFFFF * 16rFFFFFFFFFFFF) hexPrintString = 'FFFFFFFFFFFE000000000001').
self assert:((16rFFFFFFFFFFFFFF * 16rFFFFFFFFFFFFFF) hexPrintString = 'FFFFFFFFFFFFFE00000000000001').
self assert:((t2 := (t1 := 16rFFFFFFFFFFFFFFFF * 16rFFFFFFFFFFFFFFFF) hexPrintString) = 'FFFFFFFFFFFFFFFE0000000000000001').
self assert:((16rFFFFFFFFFFFFFFFF * 16rFFFFFFFFFFFFFFFF) hexPrintString = 'FFFFFFFFFFFFFFFE0000000000000001').
self assert:((16rFFFFFFFFFFFFFFFFFF * 16rFFFFFFFFFFFFFFFFFF) hexPrintString = 'FFFFFFFFFFFFFFFFFE000000000000000001').
self assert:((16rFFFFFFFFFFFFFFFFFFFF * 16rFFFFFFFFFFFFFFFFFFFF) hexPrintString = 'FFFFFFFFFFFFFFFFFFFE00000000000000000001').
self assert:((16rFFFFFFFFFFFFFFFFFFFFFF * 16rFFFFFFFFFFFFFFFFFFFFFF) hexPrintString = 'FFFFFFFFFFFFFFFFFFFFFE0000000000000000000001').
t1 := 699697179634740272935560322271216335182775596927422865716399200802062765682314102885264570100200211251370690926108604161579425545019863369232209949922751354278329212124724267803033599595114924195721823679025053720850308776953208134469115885358619139670731195605237506312288263327925364912720266772715929600.
self assert:(t1 printString = '699697179634740272935560322271216335182775596927422865716399200802062765682314102885264570100200211251370690926108604161579425545019863369232209949922751354278329212124724267803033599595114924195721823679025053720850308776953208134469115885358619139670731195605237506312288263327925364912720266772715929600').
self assert:((t1 * t1) = 489576143188809998144298426641311496989165214458056165805143410866108690058261346129614030084813851082564698610174813898740525406243367146120734370570458429364167811695064904353093506532695086211301649001517008746471464304183710723162864634442619484210170532881759249266026059786349673031239277666195699357198366128286910123306594912484590029738722281929300359929462301099981920256369394887701755497894820998573896950238852994224811101315810851671448056042419257789317787959570728520197146733902575090480065597582292177085754523686580725860228636039424698638422538988050350726807943014483010988455057592156160000).
self assert:((t1 * t1) printString = '489576143188809998144298426641311496989165214458056165805143410866108690058261346129614030084813851082564698610174813898740525406243367146120734370570458429364167811695064904353093506532695086211301649001517008746471464304183710723162864634442619484210170532881759249266026059786349673031239277666195699357198366128286910123306594912484590029738722281929300359929462301099981920256369394887701755497894820998573896950238852994224811101315810851671448056042419257789317787959570728520197146733902575090480065597582292177085754523686580725860228636039424698638422538988050350726807943014483010988455057592156160000').
#(
16rFF
16rFFFF
16rFFFFFF
16rFFFFFFFF
16rFFFFFFFFFF
16rFFFFFFFFFFFF
16rFFFFFFFFFFFFFF
16rFFFFFFFFFFFFFFFF
16rFFFFFFFFFFFFFFFFFF
16rFFFFFFFFFFFFFFFFFFFF
16rFFFFFFFFFFFFFFFFFFFFFF
16rFFFFFFFFFFFFFFFFFFFFFFFF
) do:[:eachFactor1 |
#(
16rFF
16rFFFF
16rFFFFFF
16rFFFFFFFF
16rFFFFFFFFFF
16rFFFFFFFFFFFF
16rFFFFFFFFFFFFFF
16rFFFFFFFFFFFFFFFF
16rFFFFFFFFFFFFFFFFFF
16rFFFFFFFFFFFFFFFFFFFF
16rFFFFFFFFFFFFFFFFFFFFFF
16rFFFFFFFFFFFFFFFFFFFFFFFF
) do:[:eachFactor2 |
|t3|
t1 := (eachFactor1 * eachFactor2).
t2 := (eachFactor2 * eachFactor1).
self assert:(t1 = t2).
t1 = 20203181441155852828228393631745 ifTrue:[
eachFactor1 = 1099511627775 ifTrue:[
self halt
]].
self assert:(t1 / eachFactor1) = eachFactor2.
self assert:(t1 / eachFactor2) = eachFactor1.
t3 := (eachFactor1 asLargeInteger * eachFactor2 asLargeInteger).
self assert: t1 = t3.
].
].
"
self basicNew testLargeMultiplication
"
"Modified: / 02-12-2013 / 15:45:39 / cg"
!
testLargeMultiplicationHelpers1
|t1 t2 r|
t1 := LargeInteger digitBytes:#[ 16r00 16rE1 16rF5 16r05 ].
t2 := LargeInteger digitBytes:#[ 16r00 16r00 16r40 16rB2 16rBA 16rC9 16rE0 16r19 16r1E 16r02].
r := t1 absMul:t2.
self assert:(r printString = '1000000000000000000000000000000').
self assert:(r hexPrintString = 'C9F2C9CD04674EDEA40000000').
t1 := LargeInteger digitBytes:#[ 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF].
t2 := LargeInteger digitBytes:#[ 16rFF 16rFF 16rFF 16rFF 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = 'FFFFFFFEFFFFFFFF00000001').
t1 := LargeInteger digitBytes:#[ 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF].
t2 := LargeInteger digitBytes:#[ 16rFF 16rFF 16rFF 16rFF 16rFF 0 0 0].
r := t1 absMul:t2.
self assert:(r printString = '20282409603633223678774030106625').
self assert:(r hexPrintString = 'FFFFFFFFFEFFFFFF0000000001').
t1 := LargeInteger digitBytes:#[ 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF].
t2 := LargeInteger digitBytes:#[ 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF 0 0].
r := t1 absMul:t2.
self assert:(r printString = '5192296858534809181504947642957825').
self assert:(r hexPrintString = 'FFFFFFFFFFFEFFFF000000000001').
t1 := LargeInteger digitBytes:#[ 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF].
t2 := LargeInteger digitBytes:#[ 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF 16rFF 0].
r := t1 absMul:t2.
self assert:(r printString = '1329227995784915854385005392532865025').
self assert:(r hexPrintString = 'FFFFFFFFFFFFFEFF00000000000001').
"
self basicNew testLargeMultiplicationHelpers1
"
"Modified: / 02-12-2013 / 18:33:33 / cg"
!
testLargeMultiplicationHelpers2
|t1 t2 r|
"/ testing internal multiplication method
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '12100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '1412100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10 11].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '161412100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10 11 12].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '18161412100E0C0A08060402').
"/ --------
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '12100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '1412100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10 11].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '161412100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10 11 12].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '18161412100E0C0A08060402').
"/ --------
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '12100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0 ].
r := t1 absMul:t2.
self assert:(r hexPrintString = '1412100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10 11].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '161412100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10 11 12].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '18161412100E0C0A08060402').
"/ --------
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '12100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '1412100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10 11].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '161412100E0C0A08060402').
t1 := LargeInteger digitBytes:#[ 1 2 3 4 5 6 7 8 9 10 11 12].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '18161412100E0C0A08060402').
"/ ==================0
t1 := LargeInteger digitBytes:#[ 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '202020202020300').
t1 := LargeInteger digitBytes:#[ 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '202020202020300').
t1 := LargeInteger digitBytes:#[ 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '202020202020300').
t1 := LargeInteger digitBytes:#[ 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '202020202020300').
"/ ---------
t1 := LargeInteger digitBytes:#[ 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '20202020202030000').
t1 := LargeInteger digitBytes:#[ 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '20202020202030000').
t1 := LargeInteger digitBytes:#[ 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '20202020202030000').
t1 := LargeInteger digitBytes:#[ 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '20202020202030000').
"/ ---------
t1 := LargeInteger digitBytes:#[ 0 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '2020202020203000000').
t1 := LargeInteger digitBytes:#[ 0 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '2020202020203000000').
t1 := LargeInteger digitBytes:#[ 0 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '2020202020203000000').
t1 := LargeInteger digitBytes:#[ 0 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '2020202020203000000').
"/ ---------
t1 := LargeInteger digitBytes:#[ 0 0 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '202020202020300000000').
t1 := LargeInteger digitBytes:#[ 0 0 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '202020202020300000000').
t1 := LargeInteger digitBytes:#[ 0 0 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '202020202020300000000').
t1 := LargeInteger digitBytes:#[ 0 0 0 128 1 1 1 1 1 1 1].
t2 := LargeInteger digitBytes:#[ 2 0 0 0 0 0 0 0 0 0 0].
r := t1 absMul:t2.
self assert:(r hexPrintString = '202020202020300000000').
"
self basicNew testLargeMultiplicationHelpers2
"
"Modified: / 02-12-2013 / 15:45:39 / cg"
!
testLargeSubtraction1
|a1 a2 a b1 b2 b c1 c2 c|
"/ on 32bit machines - these lead to smallint overflow
self assert:((2770568 + 2770568) printString = '5541136').
self assert:((2770568 - 2770568) printString = '0').
self assert:((2770568 negated + 2770568 negated) printString = '-5541136').
self assert:((5541136 negated - 2770568 negated) printString = '-2770568').
"Large - small subtraction"
self assert:((2770568900 + 2770568900) printString = '5541137800').
self assert:((2770568900 - 2770568900) printString = '0').
self assert:((2770568900 negated + 2770568900 negated) printString = '-5541137800').
self assert:((5541137800 negated - 2770568900 negated) printString = '-2770568900').
self assert:((2770568900 negated - 5541137800 negated) printString = '2770568900').
a1 := -2770568900. a2 := 59049.
a := (a1 / a2) negated.
b1 := -5872025600. b2 := 59049.
b := (b1 / b2) negated.
c1 := 344606300. c2 := 6561.
c := (c1 / c2) negated.
self assert:(a - b closeTo: c).
self assert:((a - b) asFloat closeTo: c asFloat).
self assert:((a asFloat - b) closeTo: c asFloat).
self assert:((a - b asFloat) closeTo: c asFloat).
a := -10.
b := -12.
self assert:(a - b = 2).
a := -10000000.
b := -12000000.
self assert:(a - b = 2000000).
a := -100000000000000.
b := -120000000000000.
self assert:(a - b = 20000000000000).
"smallInteger - largeInteger"
self assert:(-1000000000 - -2000000000 = 1000000000).
"largeInteger - smallInteger"
self assert:(-2000000000 - -1000000000 = -1000000000).
a := 40 factorial.
b := 39 factorial.
self assert:(a - b + b = a).
"
self basicNew testLargeSubtraction1
"
"Modified: / 27.11.1999 / 16:41:54 / cg"
!
testLargeSubtraction2
"/ on 64bit machines - these lead to smallint overflow
self assert:((16r3FFFFFFFFFFFFFFF negated - 1 - 1) printString = '-4611686018427387905').
"
self basicNew testLargeSubtraction2
"
!
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"
!
testModulu
|a b op|
op := #\\.
a := -1.
b := 8.
self assert:(-1 \\ 8 == 7).
self assert:(a \\ 8 == 7).
self assert:(-1 \\ b == 7).
self assert:(a \\ b == 7).
self assert:((-1 perform:op with: 8) == 7).
self assert:((a perform:op with: 8) == 7).
self assert:((-1 perform:op with: b) == 7).
self assert:((a perform:op with: b) == 7).
a := 1.
b := -8.
self assert:(1 \\ -8 == -7).
self assert:(a \\ -8 == -7).
self assert:(1 \\ b == -7).
self assert:(a \\ b == -7).
self assert:((1 perform:op with: -8) == -7).
self assert:((a perform:op with: -8) == -7).
self assert:((1 perform:op with: b) == -7).
self assert:((a perform:op with: b) == -7).
a := -1.
b := -8.
self assert:(-1 \\ -8 == -1).
self assert:(a \\ -8 == -1).
self assert:(-1 \\ b == -1).
self assert:(a \\ b == -1).
self assert:((-1 perform:op with: -8) == -1).
self assert:((a perform:op with: -8) == -1).
self assert:((-1 perform:op with: b) == -1).
self assert:((a perform:op with: b) == -1).
a := 1.
b := 8.
self assert:(1 \\ 8 == 1).
self assert:(a \\ 8 == 1).
self assert:(1 \\ b == 1).
self assert:(a \\ b == 1).
self assert:((1 perform:op with: 8) == 1).
self assert:((a perform:op with: 8) == 1).
self assert:((1 perform:op with: b) == 1).
self assert:((a perform:op with: b) == 1).
a := -17.
b := 8.
self assert:(-17 \\ 8 == 7).
self assert:(a \\ 8 == 7).
self assert:(-17 \\ b == 7).
self assert:(a \\ b == 7).
self assert:((-17 perform:op with: 8) == 7).
self assert:((a perform:op with: 8) == 7).
self assert:((-17 perform:op with: b) == 7).
self assert:((a perform:op with: b) == 7).
a := 17.
b := -8.
self assert:(17 \\ -8 == -7).
self assert:(a \\ -8 == -7).
self assert:(17 \\ b == -7).
self assert:(a \\ b == -7).
self assert:((17 perform:op with: -8) == -7).
self assert:((a perform:op with: -8) == -7).
self assert:((17 perform:op with: b) == -7).
self assert:((a perform:op with: b) == -7).
a := -17.
b := -8.
self assert:(-17 \\ -8 == -1).
self assert:(a \\ -8 == -1).
self assert:(-17 \\ b == -1).
self assert:(a \\ b == -1).
self assert:((-17 perform:op with: -8) == -1).
self assert:((a perform:op with: -8) == -1).
self assert:((-17 perform:op with: b) == -1).
self assert:((a perform:op with: b) == -1).
a := 17.
b := 8.
self assert:(17 \\ 8 == 1).
self assert:(a \\ 8 == 1).
self assert:(17 \\ b == 1).
self assert:(a \\ b == 1).
self assert:((17 perform:op with: 8) == 1).
self assert:((a perform:op with: 8) == 1).
self assert:((17 perform:op with: b) == 1).
self assert:((a perform:op with: b) == 1).
op := #rem:.
a := -1.
b := 8.
self assert:((-1 rem: 8) == -1).
self assert:((a rem: 8) == -1).
self assert:((-1 rem: b) == -1).
self assert:((a rem: b) == -1).
self assert:((-1 perform:op with: -8) == -1).
self assert:((a perform:op with: -8) == -1).
self assert:((-1 perform:op with: b) == -1).
self assert:((a perform:op with: b) == -1).
a := 1.
b := -8.
self assert:((1 rem: -8) == 1).
self assert:((a rem: -8) == 1).
self assert:((1 rem: b) == 1).
self assert:((a rem: b) == 1).
self assert:((1 perform:op with: -8) == 1).
self assert:((a perform:op with: -8) == 1).
self assert:((1 perform:op with: b) == 1).
self assert:((a perform:op with: b) == 1).
a := -1.
b := -8.
self assert:((-1 rem: -8) == -1).
self assert:((a rem: -8) == -1).
self assert:((-1 rem: b) == -1).
self assert:((a rem: b) == -1).
self assert:((-1 perform:op with: -8) == -1).
self assert:((a perform:op with: -8) == -1).
self assert:((-1 perform:op with: b) == -1).
self assert:((a perform:op with: b) == -1).
a := 1.
b := 8.
self assert:((1 rem: 8) == 1).
self assert:((a rem: 8) == 1).
self assert:((1 rem: b) == 1).
self assert:((a rem: b) == 1).
self assert:((1 perform:op with: 8) == 1).
self assert:((a perform:op with: 8) == 1).
self assert:((1 perform:op with: b) == 1).
self assert:((a perform:op with: b) == 1).
a := -17.
b := 8.
self assert:((-17 rem: 8) == -1).
self assert:((a rem: 8) == -1).
self assert:((-17 rem: b) == -1).
self assert:((a rem: b) == -1).
self assert:((-17 perform:op with: -8) == -1).
self assert:((a perform:op with: -8) == -1).
self assert:((-17 perform:op with: b) == -1).
self assert:((a perform:op with: b) == -1).
a := 17.
b := -8.
self assert:((17 rem: -8) == 1).
self assert:((a rem: -8) == 1).
self assert:((17 rem: b) == 1).
self assert:((a rem: b) == 1).
self assert:((17 perform:op with: -8) == 1).
self assert:((a perform:op with: -8) == 1).
self assert:((17 perform:op with: b) == 1).
self assert:((a perform:op with: b) == 1).
a := -17.
b := -8.
self assert:((-17 rem: -8) == -1).
self assert:((a rem: -8) == -1).
self assert:((-17 rem: b) == -1).
self assert:((a rem: b) == -1).
self assert:((-17 perform:op with: -8) == -1).
self assert:((a perform:op with: -8) == -1).
self assert:((-17 perform:op with: b) == -1).
self assert:((a perform:op with: b) == -1).
a := 17.
b := 8.
self assert:((17 rem: 8) == 1).
self assert:((a rem: 8) == 1).
self assert:((17 rem: b) == 1).
self assert:((a rem: b) == 1).
self assert:((17 perform:op with: 8) == 1).
self assert:((a perform:op with: 8) == 1).
self assert:((17 perform:op with: b) == 1).
self assert:((a perform:op with: b) == 1).
"
self basicNew testModulu
"
!
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:(1000000000000000000 printString = '1000000000000000000').
self assert:(10000000000000000000 printString = '10000000000000000000').
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:(16rFFFFFFFFFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFFFFFFFFFF').
self assert:(16rFFFFFFFFFFFFFFFFFFFFFF hexPrintString = 'FFFFFFFFFFFFFFFFFFFFFF').
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 assert:(126 printString) = '126'.
self assert:(127 printString) = '127'.
self assert:(128 printString) = '128'.
self assert:(255 printString) = '255'.
self assert:(256 printString) = '256'.
self assert:(257 printString) = '257'.
self assert:(32767 printString) = '32767'.
self assert:(32768 printString) = '32768'.
self assert:(32769 printString) = '32769'.
self assert:(65535 printString) = '65535'.
self assert:(65536 printString) = '65536'.
self assert:(65537 printString) = '65537'.
self assert:(2147483647 printString) = '2147483647'.
self assert:(2147483648 printString) = '2147483648'.
self assert:(2147483649 printString) = '2147483649'.
self assert:(4294967295 printString) = '4294967295'.
self assert:(4294967296 printString) = '4294967296'.
self assert:(4294967297 printString) = '4294967297'.
self assert:(127 printStringRadix:16) = '7F'.
self assert:(123 printStringRadix:12) = 'A3'.
self assert:(123 printStringRadix:10) = '123'.
self assert:(123 printStringRadix:8 ) = '173'.
self assert:(123 printStringRadix:3 ) = '11120'.
self assert:(123 printStringRadix:2 ) = '1111011'.
self should:[ 123 printStringRadix:1 ] raise:Error.
"
self basicNew testPrinting1
"
"Modified: / 26.10.1999 / 22:01:35 / stefan"
!
testReading1
|t|
self assert:((Integer readFrom:'4865804016353280000') printString = '4865804016353280000').
self assert:((Integer readFrom:'4294967295') printString = '4294967295').
self assert:((Integer readFrom:'4294967295') = 4294967295).
self assert:((Integer readFrom:'4294967296') printString = '4294967296').
self assert:((Integer readFrom:'4294967296') = 4294967296).
self assert:((Integer readFrom:'4294967297') printString = '4294967297').
self assert:((Integer readFrom:'4294967297') = 4294967297).
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 methodsFor:'tests-class protocol'!
testCreationFromBytes1
"self run: #testCreationFromBytes1"
" it is illegal for a LargeInteger to be less than SmallInteger maxVal."
" here we test that Integer>>byte!!byte2:byte3:byte4: reconstructs SmallInteger maxVal as an instance of SmallInteger. "
| maxSmallInt hexString
byte1 byte2 byte3 byte4
byte5 byte6 byte7 byte8
builtInteger builtIntegerH builtIntegerL|
maxSmallInt := SmallInteger maxVal.
hexString := maxSmallInt printStringHex.
ExternalAddress pointerSize == 8 ifTrue:[
self assert: hexString size = 16.
byte8 := Integer readFrom: (hexString copyFrom: 1 to: 2) base: 16.
byte7 := Integer readFrom: (hexString copyFrom: 3 to: 4) base: 16.
byte6 := Integer readFrom: (hexString copyFrom: 5 to: 6) base: 16.
byte5 := Integer readFrom: (hexString copyFrom: 7 to: 8) base: 16.
byte4 := Integer readFrom: (hexString copyFrom: 9 to: 10) base: 16.
byte3 := Integer readFrom: (hexString copyFrom: 11 to: 12) base: 16.
byte2 := Integer readFrom: (hexString copyFrom: 13 to: 14) base: 16.
byte1 := Integer readFrom: (hexString copyFrom: 15 to: 16) base: 16.
builtIntegerH := Integer byte1: byte5 byte2: byte6 byte3: byte7 byte4: byte8.
builtIntegerL := Integer byte1: byte1 byte2: byte2 byte3: byte3 byte4: byte4.
builtInteger := (builtIntegerH bitShift:32) bitOr:builtIntegerL.
self assert: builtInteger = maxSmallInt.
] ifFalse:[
self assert: hexString size = 8.
byte4 := Integer readFrom: (hexString copyFrom: 1 to: 2) base: 16.
byte3 := Integer readFrom: (hexString copyFrom: 3 to: 4) base: 16.
byte2 := Integer readFrom: (hexString copyFrom: 5 to: 6) base: 16.
byte1 := Integer readFrom: (hexString copyFrom: 7 to: 8) base: 16.
builtInteger := Integer byte1: byte1 byte2: byte2 byte3: byte3 byte4: byte4.
self assert: builtInteger = maxSmallInt.
].
self assert: builtInteger class = SmallInteger
! !
!IntegerTest methodsFor:'tests-concrete bugs'!
a_rack:rack subrack:subr board:slot port:port channel:chn typeId:aTypeOrSymbol
"create an Idn from the given arguments
"
|hgEnc typ idn
eqEnc "{ Class:SmallInteger }"
oid "{ Class:SmallInteger }"
IDN|
IDN := self class.
eqEnc := rack.
eqEnc > 0 ifFalse:[
eqEnc < 0 ifTrue:[idn := #Dontcare]
ifFalse:[port == 256 ifTrue:[idn := #NWNode]
ifFalse:[ idn := #Unspecified ]].
^ idn
].
eqEnc >= 255 ifTrue:[ "/ is a logical resource
eqEnc > 255 ifTrue:[ ^ #Unspecified ].
slot == 0 ifTrue:[
subr == 1 ifTrue:[ ^ #ConnectManager ].
subr == 2 ifTrue:[ ^ #ClockManager ].
].
oid := 4. "/ logical resource
] ifFalse:[
oid := 2. "/ equipment
].
hgEnc := 0.
typ := aTypeOrSymbol.
subr ~~ 0 ifTrue:[
subr > 16r0f ifTrue:[ ^ #Unspecified ].
eqEnc := eqEnc bitOr:(subr bitShift: 8).
slot ~~ 0 ifTrue:[
slot > 16rff ifTrue:[ ^ #Unspecified ].
eqEnc := eqEnc bitOr:(slot bitShift:12).
port ~~ 0 ifTrue:[
port > 16rff ifTrue:[ ^ #Unspecified ].
eqEnc := eqEnc bitOr:(port bitShift:20).
chn ~~ 0 ifTrue:[
chn > 16rfff ifTrue:[ ^ #Unspecified ].
oid := 3.
typ := aTypeOrSymbol ? 0.
hgEnc := chn.
]
]
]
].
typ notNil ifTrue:[
typ isSymbol ifTrue:[
typ := 0
].
hgEnc := hgEnc bitOr:(typ bitShift:12).
hgEnc := hgEnc bitOr:(oid bitShift:20).
].
^ #ok.
"
self basicNew rack:1 subrack:3 board:5 port:33 channel:8 typeId:7
"
!
rack:rack subrack:subr board:slot port:port channel:chn typeId:aTypeOrSymbol
"create an Idn from the given arguments
"
|hgEnc typ idn
eqEnc "{ Class:SmallInteger }"
oid "{ Class:SmallInteger }"|
eqEnc := rack.
"/ eqEnc > 0 ifFalse:[
"/ eqEnc < 0 ifTrue:[idn := IDN Dontcare]
"/ ifFalse:[port == 256 ifTrue:[idn := IDN NWNode]
"/ ifFalse:[ idn := IDN Unspecified ]].
"/
"/ ^ self fromIdn:idn
"/ ].
"/ eqEnc >= 255 ifTrue:[ "/ is a logical resource
"/ eqEnc > 255 ifTrue:[ ^ self fromIdn:(IDN Unspecified) ].
"/
"/ slot == 0 ifTrue:[
"/ subr == 1 ifTrue:[ ^ self fromIdn:(IDN ConnectManager) ].
"/ subr == 2 ifTrue:[ ^ self fromIdn:(IDN ClockManager) ].
"/ ].
"/ oid := 4. "/ logical resource
"/ ] ifFalse:[
"/ oid := 2. "/ equipment
"/ ].
"/ hgEnc := 0.
"/ typ := aTypeOrSymbol.
subr ~~ 0 ifTrue:[
subr > 16r0f ifTrue:[ ^ nil "self fromIdn:(IDN Unspecified)" ].
eqEnc := eqEnc bitOr:(subr bitShift: 8).
slot ~~ 0 ifTrue:[
slot > 16rff ifTrue:[ ^ nil "self fromIdn:(IDN Unspecified)" ].
eqEnc := eqEnc bitOr:(slot bitShift:12).
port ~~ 0 ifTrue:[
port > 16rff ifTrue:[ ^ self fromIdn:(IDN Unspecified) ].
eqEnc := eqEnc bitOr:(port bitShift:20).
chn ~~ 0 ifTrue:[
chn > 16rfff ifTrue:[ ^ self fromIdn:(IDN Unspecified) ].
oid := 3.
typ := aTypeOrSymbol ? 0.
hgEnc := chn.
]
]
]
].
typ notNil ifTrue:[
typ isSymbol ifTrue:[
typ := (MDT::MDTCType asNumberType:typ) ? 0
].
hgEnc := hgEnc bitOr:(typ bitShift:12).
hgEnc := hgEnc bitOr:(oid bitShift:20).
].
^ self basicNew eqEncode:eqEnc hgEncode:hgEnc.
"
self basicNew rack:1 subrack:3 board:5 port:33 channel:8 typeId:7
"
!
test_gcdBug1
| theBase theMersenne theRest theGcd theOldRest theOldGcd |
theBase := 2.
132 to: 135 do:
[: theOrder |
false "<<<< here i replaced some piece of code by false just to
reproduce the error without having to ship all my code >>>>"
ifFalse: [
theRest := ((theBase raisedTo: theOrder) - 1) / (theBase - 1).
30 to: 67 "theOrder - 1" do:
[:theFactorOrder |
"/Transcript show:theOrder; space.
"/Transcript showCR:theFactorOrder.
(theOrder \\ theFactorOrder) = 0
ifTrue: [ "<<<< is a divisor of the order >>>>"
theFactorOrder = 131 ifTrue: ['131 ist kein Teiler von 132'
halt].
(theOrder / theFactorOrder) isFraction
ifTrue: [
self halt "Fehler!!" "<<<<<<<<< dieser Code wird
nicht ausgeführt!!!!!! >>>>>"
].
theMersenne := ((theBase raisedTo: theFactorOrder) - 1) /
(theBase - 1).
theGcd := theRest gcd: theMersenne.
[theGcd > 1]
whileTrue: [
theFactorOrder > 129 ifTrue: [self halt]."< no halt!! >"
theOldRest := theRest asString.
theOldGcd := theGcd asString.
theRest := theRest / theGcd.
theGcd := theGcd gcd: theRest. "<<<<<<<<< ERROR
>>>>>>>"
((theRest \\ theGcd) ~= 0) ifTrue: [self halt].
(theRest / theGcd) isFraction ifTrue: [self halt.].
].
].
].
theRest = 1 ifTrue: [ "<<<< there is no prime factor of order
theOrder >>>>"
theOrder halt
].
].
].
"
self new test_gcdBug1
"
"Modified: / 27-04-2010 / 00:02:02 / cg"
!
test_gcdBug2
| theBase theMersenne theRest theGcd theOldRest theOldGcd |
theBase := 2.
132 to: 135 do:
[: theOrder |
false "<<<< here i replaced some piece of code by false just to
reproduce the error without having to ship all my code >>>>"
ifFalse: [
theRest := ((theBase raisedTo: theOrder) - 1) / (theBase - 1).
60 to: 67 "theOrder - 1" do:
[:theFactorOrder |
"/Transcript show:theOrder; space.
"/Transcript showCR:theFactorOrder.
(theOrder \\ theFactorOrder) = 0
ifTrue: [ "<<<< is a divisor of the order >>>>"
theFactorOrder = 131 ifTrue: ['131 ist kein Teiler von 132'
halt].
(theOrder / theFactorOrder) isFraction
ifTrue: [
self halt "Fehler!!" "<<<<<<<<< dieser Code wird
nicht ausgeführt!!!!!! >>>>>"
].
theMersenne := ((theBase raisedTo: theFactorOrder) - 1) /
(theBase - 1).
theGcd := theRest gcd: theMersenne.
[theGcd > 1]
whileTrue: [
theFactorOrder > 129 ifTrue: [self halt]."< no halt!! >"
theOldRest := theRest asString.
theOldGcd := theGcd asString.
theRest := theRest / theGcd.
theGcd := theGcd gcd: theRest. "<<<<<<<<< ERROR
>>>>>>>"
((theRest \\ theGcd) ~= 0) ifTrue: [self halt].
(theRest / theGcd) isFraction ifTrue: [self halt.].
].
].
].
theRest = 1 ifTrue: [ "<<<< there is no prime factor of order
theOrder >>>>"
theOrder halt
].
].
].
"
self new test_gcdBug2
"
"Modified: / 27-04-2010 / 00:02:09 / cg"
!
test_gcdBug3
| theBase theMersenne theRest theGcd theOldRest theOldGcd |
theBase := 2.
132 to: 135 do:
[: theOrder |
false "<<<< here i replaced some piece of code by false just to
reproduce the error without having to ship all my code >>>>"
ifFalse: [
theRest := ((theBase raisedTo: theOrder) - 1) / (theBase - 1).
2 to:theOrder - 1 do:
[:theFactorOrder |
"/Transcript show:theOrder; space.
"/Transcript showCR:theFactorOrder.
(theOrder \\ theFactorOrder) = 0
ifTrue: [ "<<<< is a divisor of the order >>>>"
theFactorOrder = 131 ifTrue: ['131 ist kein Teiler von 132'
halt].
(theOrder / theFactorOrder) isFraction
ifTrue: [
self halt "Fehler!!" "<<<<<<<<< dieser Code wird
nicht ausgeführt!!!!!! >>>>>"
].
theMersenne := ((theBase raisedTo: theFactorOrder) - 1) /
(theBase - 1).
theGcd := theRest gcd: theMersenne.
[theGcd > 1]
whileTrue: [
theFactorOrder > 129 ifTrue: [self halt]."< no halt!! >"
theOldRest := theRest asString.
theOldGcd := theGcd asString.
theRest := theRest / theGcd.
theGcd := theGcd gcd: theRest. "<<<<<<<<< ERROR
>>>>>>>"
((theRest \\ theGcd) ~= 0) ifTrue: [self halt].
(theRest / theGcd) isFraction ifTrue: [self halt.].
].
].
].
theRest = 1 ifTrue: [ "<<<< there is no prime factor of order
theOrder >>>>"
theOrder halt
].
].
].
"
self new test_gcdBug2
"
"Modified: / 27-04-2010 / 00:02:15 / cg"
! !
!IntegerTest class methodsFor:'documentation'!
version
^ '$Header$'
!
version_CVS
^ '$Header$'
! !