"{ 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$'
! !