"{ Package: 'stx:goodies/regression' }"

"{ NameSpace: RegressionTests }"

TestCase subclass:#SmallIntegerTest

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'tests-Regression-Numbers'

!

!SmallIntegerTest class methodsFor:'others'!

version_CVS

    ^ '$Header$'

! !

!SmallIntegerTest methodsFor:'tests-arithmetic'!

testBitShift

    #(

	(1 1 2)

	(1 2 4)

	(1 3 8)

	(1 7 16r080)

	(1 8 16r100)

	(1 15 16r08000)

	(1 16 16r10000)

	(1 17 16r20000)

	(1 30 16r040000000)

	(1 31 16r080000000)

	(1 32 16r100000000)

	(1 33 16r200000000)

	(1 62 16r04000000000000000)

	(1 63 16r08000000000000000)

	(1 64 16r10000000000000000)

	(1 65 16r20000000000000000)

	(1 126 16r040000000000000000000000000000000)

	(1 127 16r080000000000000000000000000000000)

	(1 128 16r100000000000000000000000000000000)

	(1 129 16r200000000000000000000000000000000)

	(16r10 1 16r20)

	(16r10 2 16r40)

	(16r10 3 16r80)

	(16r10 7 16r0800)

	(16r10 8 16r1000)

	(16r10 15 16r080000)

	(16r10 16 16r100000)

	(16r10 17 16r200000)

	(16r10 30 16r0400000000)

	(16r10 31 16r0800000000)

	(16r10 32 16r1000000000)

	(16r10 33 16r2000000000)

	(16r10 62 16r040000000000000000)

	(16r10 63 16r080000000000000000)

	(16r10 64 16r100000000000000000)

	(16r10 65 16r200000000000000000)

	(16r10 126 16r0400000000000000000000000000000000)

	(16r10 127 16r0800000000000000000000000000000000)

	(16r10 128 16r1000000000000000000000000000000000)

	(16r10 129 16r2000000000000000000000000000000000)

    ) triplesDo:[:val :cnt :expected |

	|rslt1 rslt2|

	rslt1 := val bitShift:cnt.

	self assert:(rslt1 = expected).

	expected class == SmallInteger ifTrue:[

	    self assert:(rslt1 == expected)

	].

	rslt2 := rslt1 bitShift:cnt negated.

	self assert:(rslt2 = val).

	val class == SmallInteger ifTrue:[

	    self assert:(rslt2 == val)

	].

    ].

!

testBitShiftNegative

    #(

        (-1 1 -2)

        (-1 2 -4)

        (-1 3 -8)

        (-1 7 16r-080)

        (-1 8 16r-100)

        (-1 15 16r-08000)

        (-1 16 16r-10000)

        (-1 17 16r-20000)

        (-1 30 16r-040000000)

        (-1 31 16r-080000000)

        (-1 32 16r-100000000)

        (-1 33 16r-200000000)

        (-1 62 16r-04000000000000000)

        (-1 63 16r-08000000000000000)

        (-1 64 16r-10000000000000000)

        (-1 65 16r-20000000000000000)

        (-1 126 16r-040000000000000000000000000000000)

        (-1 127 16r-080000000000000000000000000000000)

        (-1 128 16r-100000000000000000000000000000000)

        (-1 129 16r-200000000000000000000000000000000)

        (16r-10 1 16r-20)

        (16r-10 2 16r-40)

        (16r-10 3 16r-80)

        (16r-10 7 16r-0800)

        (16r-10 8 16r-1000)

        (16r-10 15 16r-080000)

        (16r-10 16 16r-100000)

        (16r-10 17 16r-200000)

        (16r-10 30 16r-0400000000)

        (16r-10 31 16r-0800000000)

        (16r-10 32 16r-1000000000)

        (16r-10 33 16r-2000000000)

        (16r-10 62 16r-040000000000000000)

        (16r-10 63 16r-080000000000000000)

        (16r-10 64 16r-100000000000000000)

        (16r-10 65 16r-200000000000000000)

        (16r-10 126 16r-0400000000000000000000000000000000)

        (16r-10 127 16r-0800000000000000000000000000000000)

        (16r-10 128 16r-1000000000000000000000000000000000)

        (16r-10 129 16r-2000000000000000000000000000000000)

    ) triplesDo:[:val :cnt :expected |

        |rslt1 rslt2|

        rslt1 := val bitShift:cnt.

        self assert:(rslt1 = expected).

        expected class == SmallInteger ifTrue:[

            self assert:(rslt1 == expected)

        ].

        rslt2 := rslt1 bitShift:cnt negated.

        self assert:(rslt2 = val).

        val class == SmallInteger ifTrue:[

            self assert:(rslt2 == val)

        ].

    ].

    "Modified (format): / 19-09-2017 / 16:29:36 / stefan"

!

testDivide

        |zero us1 us2 us3 us4 usm2 usm4|

        "circumvent compiler error about division by zero"

        zero := 0.

        self assert: 2 / 1 = 2.

        self assert: (3 / 2) isFraction.

        self assert: 4 / 2 = 2.

        self assert: 4 / -2 = -2.

        self assert: -4 / 2 = -2.

        self assert: -4 / -2 = 2.

        self should: [ 1 / zero ] raise: ZeroDivide.

        us1 := 1.

        us2 := 2.

        us3 := 3.

        us4 := 4.

        usm2 := -2.

        usm4 := -4.

        self assert: us2 / us1 = us2.

        self assert: (us3 / us2) isFraction.

        self assert: us4 / us2 = 2.

        self assert: us4 / usm2 = -2.

        self assert: usm4 / us2 = -2.

        self assert: usm4 / usm2 = 2.

!

testMultiply

    |i ii|

    #(

	16r3fff

	16r7fff

	16rffff

	16r3fffffff

	16r7fffffff

	16rffffffff

	16r20000000

	16r40000000

	16r80000000

	16r100000000

	16r20000001

	16r40000001

	16r80000001

	16r100000001

	"/ for 64 bit machines:

	16r3fffffffffffffff

	16r7fffffffffffffff

	16rffffffffffffffff

	16r2000000000000000

	16r4000000000000000

	16r8000000000000000

	16r10000000000000000

	16r2000000000000001

	16r4000000000000001

	16r8000000000000001

	16r10000000000000001

    ) do:[:x |

	i := x.

	ii := i * i.

	self assert:((ii / i) = i).

	i class == SmallInteger ifTrue:[

	    self assert:((ii / i) == i).

	].

	i := x negated.

	ii := i * i.

	self assert:((ii / i) = i).

	i class == SmallInteger ifTrue:[

	    self assert:((ii / i) == i).

	].

    ].

!

testNegation

    |i iN iNN iNNN|

    #(

        16r1fffffff

        16r3fffffff

        16r7fffffff

        16rffffffff

        16r20000000

        16r40000000

        16r80000000

        16r100000000

        16r20000001

        16r40000001

        16r80000001

        16r100000001

        "/ for 64bit machines:

        16r3fffffffffffffff

        16r7fffffffffffffff

        16rffffffffffffffff

        16r2000000000000000

        16r4000000000000000

        16r8000000000000000

        16r10000000000000000

        16r2000000000000001

        16r4000000000000001

        16r8000000000000001

        16r10000000000000001

    ) do:[:x |

        i := x.

        iN := i negated.

        iNN := iN negated.

        iNNN := iNN negated.

        self assert:(i = iNN).

        i class == SmallInteger ifTrue:[

            self assert:(i == iNN).

        ].

        self assert:(iN = iNNN).

        iN class == SmallInteger ifTrue:[

            self assert:(iN == iNNN).

        ].

    ].

    self assert:(SmallInteger maxVal negated class == SmallInteger).

    self assert:(SmallInteger maxVal negated negated == SmallInteger maxVal).

    self assert:(SmallInteger maxVal negated -1 == SmallInteger minVal).

    self assert:(SmallInteger minVal negated negated class == SmallInteger).

    "Modified: / 28-02-2017 / 16:42:04 / cg"

! !

!SmallIntegerTest methodsFor:'tests-class protocol'!

testBasicNew

    self should: [SmallInteger basicNew] raise: TestResult error.

!

testMaxVal

    "/ the original code did not check for pointer-size;

    Smalltalk isSmalltalkX ifTrue:[

	SmallInteger maxBytes == 4 ifTrue:[

	    self should: [SmallInteger maxVal = 16r3FFFFFFF].

	    self should: [SmallInteger maxVal == 16r3FFFFFFF].

	] ifFalse:[

	    self should: [SmallInteger maxVal = 16r3FFFFFFFFFFFFFFF].

	    self should: [SmallInteger maxVal == 16r3FFFFFFFFFFFFFFF].

	].

    ] ifFalse:[

	self should: [SmallInteger maxVal = 16r3FFFFFFF].

    ]

!

testMaxValPointerSizeConsistency

    SmallInteger maxBytes == 4 ifTrue:[

	self assert: ((SmallInteger maxBits == 31) or:[SmallInteger maxBits == 32]).

	self assert: (ExternalAddress pointerSize == 4).

    ] ifFalse:[

	self assert: ((SmallInteger maxBits == 63) or:[SmallInteger maxBits == 64]).

	self assert: (ExternalAddress pointerSize == 8).

    ]

!

testMinVal

    "/ the original code did not check for pointer-size;

    Smalltalk isSmalltalkX ifTrue:[

        SmallInteger maxBytes == 4 ifTrue:[

            self should: [SmallInteger minVal = 16r-40000000].

            self should: [SmallInteger minVal == 16r-40000000].

        ] ifFalse:[

            self should: [SmallInteger minVal = 16r-4000000000000000].

            self should: [SmallInteger minVal == 16r-4000000000000000].

        ].

    ] ifFalse:[

        self should: [SmallInteger minVal = 16r-40000000].

    ]

    "Modified (format): / 19-09-2017 / 16:29:45 / stefan"

!

testNew

    self should: [SmallInteger new] raise: TestResult error.

! !

!SmallIntegerTest class methodsFor:'documentation'!

version

    ^ '$Header$'

! !