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

"{ NameSpace: RegressionTests }"

TestCase subclass:#SmallIntegerTest

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'tests-Regression-Numbers'

!

!SmallIntegerTest methodsFor:'tests-arithmetic'!

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-bit fiddling'!

testBitCount

     1 to:1000000 do:[:n |

        self assert:(n bitCount = ((n printStringRadix:2) occurrencesOf:$1))

     ].

     #( 16r00000000

        16r00010000 16r00100000 16r01000000 16r10000000

        16r00020000 16r00200000 16r02000000 16r20000000

        16r00040000 16r00400000 16r04000000 16r40000000

        16r00080000 16r00800000 16r08000000 16r80000000

        16rFFFFFFFF 16r7FFFFFFF 16r3FFFFFFF 16r1FFFFFFF

        16rEEEEEEEE 16r7EEEEEEE 16r3EEEEEEE 16r1EEEEEEE

        16rDDDDDDDD 16r7DDDDDDD 16r3DDDDDDD 16r1DDDDDDD

        16rCCCCCCCC 16r7CCCCCCC 16r3CCCCCCC 16r1CCCCCCC

        16r8000000000010000 16r8000000000100000 16r8000000001000000 16r8000000010000000

        16r8000000000020000 16r8000000000200000 16r8000000002000000 16r8000000020000000

        16r8000000000040000 16r8000000000400000 16r8000000004000000 16r8000000040000000

        16r8000000000080000 16r8000000000800000 16r8000000008000000 16r8000000080000000

        16r80000000FFFFFFFF 16r800000007FFFFFFF 16r800000003FFFFFFF 16r800000001FFFFFFF

        16r80000000EEEEEEEE 16r800000007EEEEEEE 16r800000003EEEEEEE 16r800000001EEEEEEE

        16r80000000DDDDDDDD 16r800000007DDDDDDD 16r800000003DDDDDDD 16r800000001DDDDDDD

        16r80000000CCCCCCCC 16r800000007CCCCCCC 16r800000003CCCCCCC 16r800000001CCCCCCC

        16rFFFFFFFFFFFFFFFF 16r7FFFFFFFFFFFFFFF 16r3FFFFFFFFFFFFFFF 16r1FFFFFFFFFFFFFFF

     ) do:[:n |

        self assert:(n bitCount = ((n printStringRadix:2) occurrencesOf:$1))

     ].

    "Created: / 20-03-2019 / 12:43:06 / Claus Gittinger"

!

testBitReversed

    #( 

        2r10000000 2r00000001

        2r01000000 2r00000010

        2r00100000 2r00000100

        2r00010000 2r00001000

        2r00001000 2r00010000

        2r00000100 2r00100000

        2r00000010 2r01000000

        2r00000001 2r10000000

        "/ high bits are to be ignored (i.e. clear) 

        2r100000001 2r10000000

        2r110000000 2r00000001

    )

    pairWiseDo:[:in :expected |

        self assert:(in bitReversed8 == expected)

    ].

    #( 

        2r1000000000000000 2r0000000000000001

        2r0100000000000000 2r0000000000000010

        2r0010000000000000 2r0000000000000100

        2r0001000000000000 2r0000000000001000

        2r0000100000000000 2r0000000000010000

        2r0000010000000000 2r0000000000100000

        2r0000001000000000 2r0000000001000000

        2r0000000100000000 2r0000000010000000

        2r0000000010000000 2r0000000100000000

        2r0000000001000000 2r0000001000000000

        2r0000000000100000 2r0000010000000000

        2r0000000000010000 2r0000100000000000

        2r0000000000001000 2r0001000000000000

        2r0000000000000100 2r0010000000000000

        2r0000000000000010 2r0100000000000000

        2r0000000000000001 2r1000000000000000

        "/ high bits are to be ignored (i.e. clear) 

        2r10000000000000001 2r1000000000000000

        2r11000000000000000 2r0000000000000001

    )

    pairWiseDo:[:in :expected |

        self assert:(in bitReversed16 == expected)

    ].

    #( 

        2r10000000000000000000000000000000 2r00000000000000000000000000000001

        2r01000000000000000000000000000000 2r00000000000000000000000000000010

        2r00100000000000000000000000000000 2r00000000000000000000000000000100

        2r00010000000000000000000000000000 2r00000000000000000000000000001000

        2r00001000000000000000000000000000 2r00000000000000000000000000010000

        2r00000100000000000000000000000000 2r00000000000000000000000000100000

        2r00000010000000000000000000000000 2r00000000000000000000000001000000

        2r00000001000000000000000000000000 2r00000000000000000000000010000000

        2r00000000100000000000000000000000 2r00000000000000000000000100000000

        2r00000000010000000000000000000000 2r00000000000000000000001000000000

        2r00000000001000000000000000000000 2r00000000000000000000010000000000

        2r00000000000100000000000000000000 2r00000000000000000000100000000000

        2r00000000000010000000000000000000 2r00000000000000000001000000000000

        2r00000000000001000000000000000000 2r00000000000000000010000000000000

        2r00000000000000100000000000000000 2r00000000000000000100000000000000

        2r00000000000000010000000000000000 2r00000000000000001000000000000000

        2r00000000000000001000000000000000 2r00000000000000010000000000000000

        2r00000000000000000100000000000000 2r00000000000000100000000000000000

        2r00000000000000000010000000000000 2r00000000000001000000000000000000

        2r00000000000000000001000000000000 2r00000000000010000000000000000000

        2r00000000000000000000100000000000 2r00000000000100000000000000000000

        2r00000000000000000000010000000000 2r00000000001000000000000000000000

        2r00000000000000000000001000000000 2r00000000010000000000000000000000

        2r00000000000000000000000100000000 2r00000000100000000000000000000000

        2r00000000000000000000000010000000 2r00000001000000000000000000000000

        2r00000000000000000000000001000000 2r00000010000000000000000000000000

        2r00000000000000000000000000100000 2r00000100000000000000000000000000

        2r00000000000000000000000000010000 2r00001000000000000000000000000000

        2r00000000000000000000000000001000 2r00010000000000000000000000000000

        2r00000000000000000000000000000100 2r00100000000000000000000000000000

        2r00000000000000000000000000000010 2r01000000000000000000000000000000

        2r00000000000000000000000000000001 2r10000000000000000000000000000000

        "/ high bits are to be ignored (i.e. clear) 

        2r100000000000000000000000000000001 2r10000000000000000000000000000000

        2r110000000000000000000000000000000 2r00000000000000000000000000000001

    )

    pairWiseDo:[:in :expected |

        self assert:(in bitReversed32 = expected)

    ].

    "Created: / 24-03-2019 / 13:13:28 / Claus Gittinger"

!

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"

!

testParity

     self assert:(1 parityOdd).

     self assert:(2 parityOdd).

     self assert:(3 parityOdd not).

     self assert:(16r20000000 parityOdd).

     self assert:(16r30000000 parityOdd not).

     self assert:(16r40000000 parityOdd).

     self assert:(16r50000000 parityOdd not).

     self assert:(16rFFFFFFFF parityOdd not).

     self assert:(16r2000000000000000 parityOdd).

     self assert:(16r3000000000000000 parityOdd not).

     self assert:(16r4000000000000000 parityOdd).

     self assert:(16r5000000000000000 parityOdd not).

     self assert:(16rFFFFFFFFFFFFFFFF parityOdd not).

     self assert:(16r200000000000000000000000 parityOdd).

     self assert:(16r300000000000000000000000 parityOdd not).

     self assert:(16r400000000000000000000000 parityOdd).

     self assert:(16r500000000000000000000000 parityOdd not).

     self assert:(16rFFFFFFFFFFFFFFFFFFFFFFFF parityOdd not).

    "Created: / 20-03-2019 / 13:38:42 / Claus Gittinger"

! !

!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: Error.

    "Modified (comment): / 20-03-2019 / 14:57:12 / Claus Gittinger"

! !

!SmallIntegerTest class methodsFor:'documentation'!

version

    ^ '$Header$'

!

version_CVS

    ^ '$Header$'

! !