--- a/RegressionTests__IntegerTest.st	Sat Aug 31 10:17:27 2019 +0200
+++ b/RegressionTests__IntegerTest.st	Sat Aug 31 11:47:14 2019 +0200
@@ -735,45 +735,6 @@
     "Modified: / 31.10.2000 / 20:23:20 / cg"
 !
 
-testBinco
-     self assert: (10 binomialCoefficient:5) = (10 factorial / (5 factorial * 5 factorial)).
-     self assert: (100 binomialCoefficient:78) = (100 factorial / (78 factorial * (100-78) factorial)).
-     self assert: (1000 binomialCoefficient:5) = (1000 factorial / (5 factorial * (1000-5) factorial)).
-     self assert: (10000 binomialCoefficient:78) = (10000 factorial / (78 factorial * (10000-78) factorial)).
-
-    "
-     self basicNew testBinco
-    "
-!
-
-testByteSwap
-    "/ <testedMethods: #( (Integer >> #byteSwapped32) (Integer >> #byteSwapped64)) >
-
-    self assert:(16r1122 byteSwapped16) = 16r2211.
-    self assert:(16r2211 byteSwapped16) = 16r1122.
-
-    self assert:(16r11223344 byteSwapped32) = 16r44332211.
-    self assert:(16r44332211 byteSwapped32) = 16r11223344.
-
-    self assert:(16r11223344 byteSwapped64) = 16r4433221100000000.
-    self assert:(16r44332211 byteSwapped64) = 16r1122334400000000.
-
-    self assert:(16r8877665544332211 byteSwapped64) = 16r1122334455667788.
-    self assert:(16r1122334455667788 byteSwapped64) = 16r8877665544332211.
-
-    "/ higher bits are ignored!!
-    self assert:(16r33441122 byteSwapped16) = 16r2211.
-
-    self assert:(16r9911223344 byteSwapped32) = 16r44332211.
-    self assert:(16r8877665544332211 byteSwapped32) = 16r11223344.
-    self assert:(16r998877665544332211 byteSwapped64) = 16r1122334455667788.
-    self assert:(16r991122334455667788 byteSwapped64) = 16r8877665544332211.
-
-    "
-     self basicNew testByteSwap
-    "
-!
-
 testComparing
     |a b|
 
@@ -884,6 +845,813 @@
     "
 !
 
+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 class == SmallInteger).
+    self assert:(maxVal class == SmallInteger).
+
+    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 := 16r-20000000.
+        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 := 16r-2000000000000000.
+        halfMax := 16r2000000000000000.
+    ].
+    
+    self assert:(minValMinus1 class == LargeInteger).
+    self assert:(maxValPlus1 class == LargeInteger).
+
+    "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: / 19-09-2017 / 16:27:24 / stefan"
+    "Modified: / 10-10-2017 / 12:13:02 / 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 class == SmallInteger).
+    "/ Transcript showCR:n1 printString.
+    "/ Transcript showCR:n1 negated printString.
+    "/ Transcript showCR:n1 negated class printString.
+    self assert:(n1 negated class == LargeInteger).
+    self assert:((n1 perform:'negated' asSymbol) class == LargeInteger).
+
+    n1 := SmallInteger maxVal.
+    self assert:(n1 negated negated class == SmallInteger).
+    self assert:(((n1 perform:'negated' asSymbol) perform:'negated' asSymbol) class == SmallInteger).
+
+    n1 := SmallInteger minVal.
+    self assert:(n1 negated negated class == SmallInteger).
+    self assert:(((n1 perform:'negated' asSymbol) perform:'negated' asSymbol) class == SmallInteger).
+
+    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
+    "
+!
+
+testLargeCompare
+    "compare tests"
+
+    #(
+        ( 16r3fffffff 16r40000000 #less )
+        ( 16r40000000 16r3fffffff #greater )
+        ( 16r40000000 16r40000000 #equal )
+
+        ( 16r40000000 16r40000001 #less )
+        ( 16r40000001 16r40000000 #greater )
+        ( 16r40000001 16r40000001 #equal )
+        
+        ( 16r3fffffffffffffff 16r4000000000000000 #less )
+        ( 16r4000000000000000 16r3fffffffffffffff #greater )
+        ( 16r4000000000000000 16r4000000000000000 #equal )
+
+        ( 16r4000000000000000 16r4000000000000001 #less )
+        ( 16r4000000000000001 16r4000000000000000 #greater )
+        ( 16r4000000000000001 16r4000000000000001 #equal )
+
+        ( 16r3fffffffffffffffffffffff 16r400000000000000000000000 #less )
+        ( 16r400000000000000000000000 16r3fffffffffffffffffffffff #greater )
+        ( 16r400000000000000000000000 16r400000000000000000000000 #equal )
+
+        ( 16r400000000000000000000000 16r400000000000000000000001 #less )
+        ( 16r400000000000000000000001 16r400000000000000000000000 #greater )
+        ( 16r400000000000000000000001 16r400000000000000000000001 #equal )
+
+        ( 16r3fffffff 16r400000000000 #less )
+        ( 16r400000000000 16r3fffffff #greater )
+
+        ( 16r40000000 16r400000000001 #less )
+        ( 16r400000000001 16r40000000 #greater )
+
+        ( 16r3fffffffffffffff 16r40000000000000000000 #less )
+        ( 16r40000000000000000000 16r3fffffffffffffff #greater )
+
+        ( 16r4000000000000000 16r40000000000000000001 #less )
+        ( 16r40000000000000000001 16r4000000000000000 #greater )
+
+        ( 16r3fffffffffffffffffffffff 16r400000000000000000000000 #less )
+        ( 16r400000000000000000000000 16r3fffffffffffffffffffffff #greater )
+        ( 16r400000000000000000000000 16r400000000000000000000000 #equal )
+
+        ( 16r400000000000000000000000 16r400000000000000000000001 #less )
+        ( 16r400000000000000000000001 16r400000000000000000000000 #greater )
+        ( 16r400000000000000000000001 16r400000000000000000000001 #equal )
+    ) do:[:triple |
+        |v1 v2 expected rslt|
+        
+        v1 := triple at:1.
+        v2 := triple at:2.
+        expected := triple at:3.
+        expected == #less ifTrue:[
+            self assert:(v1 < v2).
+            self assert:(v1 <= v2).
+            self assert:(v1 > v2) not.
+            self assert:(v1 >= v2) not.
+            self assert:(v1 = v2) not.
+            self assert:(v1 ~= v2).
+        ].    
+        expected == #greater ifTrue:[
+            self assert:(v1 > v2).
+            self assert:(v1 >= v2).
+            self assert:(v1 < v2) not.
+            self assert:(v1 <= v2) not.
+            self assert:(v1 = v2) not.
+            self assert:(v1 ~= v2).
+        ].    
+        expected == #equal ifTrue:[
+            self assert:(v1 > v2) not.
+            self assert:(v1 >= v2).
+            self assert:(v1 < v2) not.
+            self assert:(v1 <= v2).
+            self assert:(v1 = v2).
+            self assert:(v1 ~= v2) not.
+        ].    
+    ].
+    self assert:(100 factorial < 101 factorial).
+    self assert:(100 factorial > 100 factorial negated).
+    
+    "
+     self basicNew testLargeCompare
+    "
+!
+
+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
+    "
+!
+
+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"
+!
+
+testLargeIntegerHelpers2
+    |t1 r|
+
+    "/ absSubtract:
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r00ffffffffffffffff.
+    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == true).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r010000000000000000.
+    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == false).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r00ffffffffffffffffff.
+    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == true).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r01000000000000000000.
+    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == false).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffff.
+    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == true).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r0100000000000000000000.
+    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == false).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffffff.
+    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == true).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r010000000000000000000000.
+    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == false).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffffffff.
+    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == true).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r01000000000000000000000000.
+    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == false).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffffffffff.
+    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == true).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r0100000000000000000000000000.
+    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == false).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffffffffffff.
+    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == true).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r010000000000000000000000000000.
+    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == false).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffffffffffffff.
+    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == true).
+
+    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
+    r := t1 absDestructiveSubtract:16r01000000000000000000000000000000.
+    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
+    self assert:(r == false).
+    "
+     self basicNew testLargeIntegerHelpers2
+    "
+!
+
+testLargeIntegerHelpers3
+    "/ absDivMod:
+
+     self assert:(9000000000000000000 absDivMod: 4000) = #(2250000000000000 0).
+     self assert:(-9000000000000000000 absDivMod: 4000) = #(2250000000000000 0).
+     self assert:(9000000000000000000 absDivMod: -4000) = #(2250000000000000 0).
+     self assert:(-9000000000000000000 absDivMod: -4000) = #(2250000000000000 0).
+
+     self assert:(9000000000000000001 absDivMod: 4000) = #(2250000000000000 1).
+     self assert:(-9000000000000000001 absDivMod: 4000) = #(2250000000000000 1).
+     self assert:(9000000000000000001 absDivMod: -4000) = #(2250000000000000 1).
+     self assert:(-9000000000000000001 absDivMod: -4000) = #(2250000000000000 1).
+
+     self assert:(9000000000000000000 absDivMod: 40000) = #(225000000000000 0).
+     self assert:(-9000000000000000000 absDivMod: 40000) = #(225000000000000 0).
+     self assert:(9000000000000000000 absDivMod: -40000) = #(225000000000000 0).
+     self assert:(-9000000000000000000 absDivMod: -40000) = #(225000000000000 0).
+
+     self assert:(9000000000000000000 absDivMod: 400000) = #(22500000000000 0).
+     self assert:(-9000000000000000000 absDivMod: 400000) = #(22500000000000 0).
+     self assert:(9000000000000000000 absDivMod: -400000) = #(22500000000000 0).
+     self assert:(-9000000000000000000 absDivMod: -400000) = #(22500000000000 0).
+
+     self assert:(9000000000000000000 absDivMod: 4000000) = #(2250000000000 0).
+     self assert:(-9000000000000000000 absDivMod: 4000000) = #(2250000000000 0).
+     self assert:(9000000000000000000 absDivMod: -4000000) = #(2250000000000 0).
+     self assert:(-9000000000000000000 absDivMod: -4000000) = #(2250000000000 0).
+
+     self assert:(9000000000000000000 absDivMod: 40000000) = #(225000000000 0).
+     self assert:(-9000000000000000000 absDivMod: 40000000) = #(225000000000 0).
+     self assert:(9000000000000000000 absDivMod: -40000000) = #(225000000000 0).
+     self assert:(-9000000000000000000 absDivMod: -40000000) = #(225000000000 0).
+
+     self assert:(9000000000000000000 absDivMod: 400000000) = #(22500000000 0).
+     self assert:(-9000000000000000000 absDivMod: 400000000) = #(22500000000 0).
+     self assert:(9000000000000000000 absDivMod: -400000000) = #(22500000000 0).
+     self assert:(-9000000000000000000 absDivMod: -400000000) = #(22500000000 0).
+
+     self assert:(9000000000000000000 absDivMod: 4000000000) = #(2250000000 0).
+     self assert:(-9000000000000000000 absDivMod: 4000000000) = #(2250000000 0).
+     self assert:(9000000000000000000 absDivMod: -4000000000) = #(2250000000 0).
+     self assert:(-9000000000000000000 absDivMod: -4000000000) = #(2250000000 0).
+
+     self assert:(9000000000000000000 absDivMod: 40000000000) = #(225000000 0).
+     self assert:(-9000000000000000000 absDivMod: 40000000000) = #(225000000 0).
+     self assert:(9000000000000000000 absDivMod: -40000000000) = #(225000000 0).
+     self assert:(-9000000000000000000 absDivMod: -40000000000) = #(225000000 0).
+
+     self assert:(9000000000000000000 absDivMod: 400000000000) = #(22500000 0).
+     self assert:(-9000000000000000000 absDivMod: 400000000000) = #(22500000 0).
+     self assert:(9000000000000000000 absDivMod: -400000000000) = #(22500000 0).
+     self assert:(-9000000000000000000 absDivMod: -400000000000) = #(22500000 0).
+
+     self assert:(9000000000000000000 absDivMod: 4000000000000) = #(2250000 0).
+     self assert:(-9000000000000000000 absDivMod: 4000000000000) = #(2250000 0).
+     self assert:(9000000000000000000 absDivMod: -4000000000000) = #(2250000 0).
+     self assert:(-9000000000000000000 absDivMod: -4000000000000) = #(2250000 0).
+
+     self assert:(9000000000000000000 absDivMod: 40000000000000) = #(225000 0).
+     self assert:(-9000000000000000000 absDivMod: 40000000000000) = #(225000 0).
+     self assert:(9000000000000000000 absDivMod: -40000000000000) = #(225000 0).
+     self assert:(-9000000000000000000 absDivMod: -40000000000000) = #(225000 0).
+
+     self assert:(9000000000000000000 absDivMod: 400000000000000) = #(22500 0).
+     self assert:(-9000000000000000000 absDivMod: 400000000000000) = #(22500 0).
+     self assert:(9000000000000000000 absDivMod: -400000000000000) = #(22500 0).
+     self assert:(-9000000000000000000 absDivMod: -400000000000000) = #(22500 0).
+
+     self assert:(9000000000000000000 absDivMod: 4000000000000000) = #(2250 0).
+     self assert:(-9000000000000000000 absDivMod: 4000000000000000) = #(2250 0).
+     self assert:(9000000000000000000 absDivMod: -4000000000000000) = #(2250 0).
+     self assert:(-9000000000000000000 absDivMod: -4000000000000000) = #(2250 0).
+
+     self assert:(9000000000000000000 absDivMod: 4000000000000000000) = #(2 1000000000000000000).
+     self assert:(-9000000000000000000 absDivMod: 4000000000000000000) = #(2 1000000000000000000).
+     self assert:(9000000000000000000 absDivMod: -4000000000000000000) = #(2 1000000000000000000).
+     self assert:(-9000000000000000000 absDivMod: -4000000000000000000) = #(2 1000000000000000000).
+
+    "
+     self basicNew testLargeIntegerHelpers3
+    "
+!
+
+testLargeIntegerHelpers4
+    "/ absDivMod:
+
+     self assert:(9000000000000000000 absMod: 4000) = 0.
+     self assert:(-9000000000000000000 absMod: 4000) = 0.
+     self assert:(9000000000000000000 absMod: -4000) = 0.
+     self assert:(-9000000000000000000 absMod: -4000) = 0.
+
+     self assert:(9000000000000000001 absMod: 4000) = 1.
+     self assert:(-9000000000000000001 absMod: 4000) = 1.
+     self assert:(9000000000000000001 absMod: -4000) = 1.
+     self assert:(-9000000000000000001 absMod: -4000) = 1.
+
+     self assert:(9000000000000000000 absMod: 40000) = 0.
+     self assert:(-9000000000000000000 absMod: 40000) = 0.
+     self assert:(9000000000000000000 absMod: -40000) = 0.
+     self assert:(-9000000000000000000 absMod: -40000) = 0.
+
+     self assert:(9000000000000000000 absMod: 400000) = 0.
+     self assert:(-9000000000000000000 absMod: 400000) = 0.
+     self assert:(9000000000000000000 absMod: -400000) = 0.
+     self assert:(-9000000000000000000 absMod: -400000) = 0.
+
+     self assert:(9000000000000000000 absMod: 4000000) = 0.
+     self assert:(-9000000000000000000 absMod: 4000000) = 0.
+     self assert:(9000000000000000000 absMod: -4000000) = 0.
+     self assert:(-9000000000000000000 absMod: -4000000) = 0.
+
+     self assert:(9000000000000000000 absMod: 40000000) = 0.
+     self assert:(-9000000000000000000 absMod: 40000000) = 0.
+     self assert:(9000000000000000000 absMod: -40000000) = 0.
+     self assert:(-9000000000000000000 absMod: -40000000) = 0.
+
+     self assert:(9000000000000000000 absMod: 400000000) = 0.
+     self assert:(-9000000000000000000 absMod: 400000000) = 0.
+     self assert:(9000000000000000000 absMod: -400000000) = 0.
+     self assert:(-9000000000000000000 absMod: -400000000) = 0.
+
+     self assert:(9000000000000000000 absMod: 4000000000) = 0.
+     self assert:(-9000000000000000000 absMod: 4000000000) = 0.
+     self assert:(9000000000000000000 absMod: -4000000000) = 0.
+     self assert:(-9000000000000000000 absMod: -4000000000) = 0.
+
+     self assert:(9000000000000000000 absMod: 40000000000) = 0.
+     self assert:(-9000000000000000000 absMod: 40000000000) = 0.
+     self assert:(9000000000000000000 absMod: -40000000000) = 0.
+     self assert:(-9000000000000000000 absMod: -40000000000) = 0.
+
+     self assert:(9000000000000000000 absMod: 400000000000) = 0.
+     self assert:(-9000000000000000000 absMod: 400000000000) = 0.
+     self assert:(9000000000000000000 absMod: -400000000000) = 0.
+     self assert:(-9000000000000000000 absMod: -400000000000) = 0.
+
+     self assert:(9000000000000000000 absMod: 4000000000000) = 0.
+     self assert:(-9000000000000000000 absMod: 4000000000000) = 0.
+     self assert:(9000000000000000000 absMod: -4000000000000) = 0.
+     self assert:(-9000000000000000000 absMod: -4000000000000) = 0.
+
+     self assert:(9000000000000000000 absMod: 40000000000000) = 0.
+     self assert:(-9000000000000000000 absMod: 40000000000000) = 0.
+     self assert:(9000000000000000000 absMod: -40000000000000) = 0.
+     self assert:(-9000000000000000000 absMod: -40000000000000) = 0.
+
+     self assert:(9000000000000000000 absMod: 400000000000000) = 0.
+     self assert:(-9000000000000000000 absMod: 400000000000000) = 0.
+     self assert:(9000000000000000000 absMod: -400000000000000) = 0.
+     self assert:(-9000000000000000000 absMod: -400000000000000) = 0.
+
+     self assert:(9000000000000000000 absMod: 4000000000000000) = 0.
+     self assert:(-9000000000000000000 absMod: 4000000000000000) = 0.
+     self assert:(9000000000000000000 absMod: -4000000000000000) = 0.
+     self assert:(-9000000000000000000 absMod: -4000000000000000) = 0.
+
+     self assert:(9000000000000000000 absMod: 4000000000000000000) = 1000000000000000000.
+     self assert:(-9000000000000000000 absMod: 4000000000000000000) = 1000000000000000000.
+     self assert:(9000000000000000000 absMod: -4000000000000000000) = 1000000000000000000.
+     self assert:(-9000000000000000000 absMod: -4000000000000000000) = 1000000000000000000.
+
+    "
+     self basicNew testLargeIntegerHelpers4
+    "
+
+    "Created: / 05-07-2017 / 16:15:30 / cg"
+!
+
+testMiscMath
+    self assert:(2 raisedTo:2) == 4.
+    self assert:(2 raisedTo:2.0) = 4.0.
+    self assert:(2 raisedTo:100) = 1267650600228229401496703205376.
+    
+    self assert:(((2 raisedTo:100) log:2) isAlmostEqualTo:100 nEpsilon:1) 
+         message:('(2^100)log2 is %1' bindWith:((2 raisedTo:100) log:2)).
+    self assert:(((2 raisedTo:100) integerLog2) == 100)
+         message:('(2^100)integerLog2 is %1' bindWith:((2 raisedTo:100) integerLog2)).
+
+    self assert:(((10 raisedTo:100) integerLog10) == 100)
+         message:('(10^100)integerLog10 is %1' bindWith:((10 raisedTo:100) integerLog10)).
+
+    "/ currently, integerLog10 does not work with largeInts
+    "/ self assert:(((10 raisedTo:1000) integerLog10) == 1000).
+
+    "
+     self basicNew testMiscMath
+    "
+
+    "Created: / 02-07-2017 / 00:52:25 / cg"
+    "Modified (comment): / 02-07-2017 / 14:39:26 / cg"
+    "Modified: / 22-07-2019 / 12:44:41 / Claus Gittinger"
+!
+
+testMiscMath2
+    self assert:(10000000000000000000000001 isPrime) not.
+    self assert:(76 factorial + 1) isPrime not.
+
+    "/ Would take far too long with fallback implementation.
+    PrimeNumberGenerator notNil ifTrue:[
+        self assert:(77 factorial + 1) isPrime.
+        self assert:(872 factorial + 1) isPrime.
+        self assert:(1000 factorial + 1) isPrime not.
+    ].
+
+    "
+    Time millisecondsToRun:[
+        1000000 factorial.
+    ].
+    "
+
+    "
+     self basicNew testMiscMath2
+    "
+
+    "Created: / 05-07-2017 / 16:18:54 / cg"
+    "Modified (comment): / 26-07-2017 / 12:48:11 / mawalch"
+! !
+
+!IntegerTest methodsFor:'tests-arithmetic'!
+
 testDivision1
     |a b op rslt|
 
@@ -1404,727 +2172,6 @@
     "Created: / 26-02-2016 / 20:21:47 / cg"
 !
 
-testEncodeDecode
-    self assert:(1 encodeAsBCD hexPrintString = '1').
-    self assert:(12 encodeAsBCD hexPrintString = '12').
-    self assert:(123 encodeAsBCD hexPrintString = '123').
-    self assert:(1234 encodeAsBCD hexPrintString = '1234').
-    self assert:(12345 encodeAsBCD hexPrintString = '12345').
-    self assert:(123456 encodeAsBCD hexPrintString = '123456').
-    self assert:(1234567 encodeAsBCD hexPrintString = '1234567').
-    self assert:(12345678 encodeAsBCD hexPrintString = '12345678').
-    self assert:(123456789 encodeAsBCD hexPrintString = '123456789').
-    self assert:(1234567890 encodeAsBCD hexPrintString = '1234567890').
-    self assert:(12345678901 encodeAsBCD hexPrintString = '12345678901').
-    self assert:(123456789012 encodeAsBCD hexPrintString = '123456789012').
-    self assert:(1234567890123 encodeAsBCD hexPrintString = '1234567890123').
-    self assert:(12345678901234 encodeAsBCD hexPrintString = '12345678901234').
-    self assert:(123456789012345 encodeAsBCD hexPrintString = '123456789012345').
-    self assert:(1234567890123456 encodeAsBCD hexPrintString = '1234567890123456').
-    self assert:(12345678901234567 encodeAsBCD hexPrintString = '12345678901234567').
-    self assert:(123456789012345678 encodeAsBCD hexPrintString = '123456789012345678').
-    self assert:(1234567890123456789 encodeAsBCD hexPrintString = '1234567890123456789').
-    self assert:(12345678901234567890 encodeAsBCD hexPrintString = '12345678901234567890').
-    self assert:(4611686018427387902 encodeAsBCD hexPrintString = '4611686018427387902').
-    self assert:(4611686018427387903 encodeAsBCD hexPrintString = '4611686018427387903').
-    self assert:(4611686018427387904 encodeAsBCD hexPrintString = '4611686018427387904').
-
-    self assert:(16r1 decodeFromBCD = 1).
-    self assert:(16r12 decodeFromBCD = 12).
-    self assert:(16r123 decodeFromBCD = 123).
-    self assert:(16r1234 decodeFromBCD = 1234).
-    self assert:(16r12345 decodeFromBCD = 12345).
-    self assert:(16r123456 decodeFromBCD = 123456).
-    self assert:(16r1234567 decodeFromBCD = 1234567).
-    self assert:(16r12345678 decodeFromBCD = 12345678).
-    self assert:(16r123456789 decodeFromBCD = 123456789).
-    self assert:(16r1234567890 decodeFromBCD = 1234567890).
-    self assert:(16r12345678901 decodeFromBCD = 12345678901).
-    self assert:(16r123456789012 decodeFromBCD = 123456789012).
-    self assert:(16r1000000000000 decodeFromBCD = 1000000000000).
-    self assert:(16r0000500000000 decodeFromBCD = 500000000).
-    self assert:(16r1234500000000 decodeFromBCD = 1234500000000).
-    self assert:(16r1234567890000 decodeFromBCD = 1234567890000).
-
-    self assert:(16r1234567890123 decodeFromBCD = 1234567890123).
-    self assert:(16r12345678901234 decodeFromBCD = 12345678901234).
-    self assert:(16r123456789012345 decodeFromBCD = 123456789012345).
-    self assert:(16r1234567890123456 decodeFromBCD = 1234567890123456).
-    self assert:(16r12345678901234567 decodeFromBCD = 12345678901234567).
-    self assert:(16r123456789012345678 decodeFromBCD = 123456789012345678).
-    self assert:(16r1234567890123456789 decodeFromBCD = 1234567890123456789).
-    self assert:(16r12345678901234567890 decodeFromBCD = 12345678901234567890).
-    self assert:(16r4611686018427387902 decodeFromBCD = 4611686018427387902).
-    self assert:(16r4611686018427387903 decodeFromBCD = 4611686018427387903).
-    self assert:(16r4611686018427387904 decodeFromBCD = 4611686018427387904).
-
-    "
-     self basicNew testEncodeDecode
-    "
-
-    "Modified: / 26.10.1999 / 22:01:35 / stefan"
-!
-
-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 assert:(12 factorial = 479001600).
-    self assert:(13 factorial digitBytes = #[0 204 40 115 1]).
-    self assert:(13 factorial = 6227020800).
-    self assert:(14 factorial digitBytes = #[0 40 59 76 20]).
-    self assert:(14 factorial = 87178291200).
-    self assert:(15 factorial digitBytes = #[0 88 119 119 48 1]).
-    self assert:(15 factorial = 1307674368000).
-    self assert:(16 factorial digitBytes = #[0 128 117 119 7 19]).
-    self assert:(16 factorial = 20922789888000).
-    self assert:(17 factorial digitBytes = #[0 128 205 238 126 67 1]).
-    self assert:(17 factorial = 355687428096000).
-    self assert:(18 factorial digitBytes = #[0 0 115 202 236 190 22]).
-    self assert:(18 factorial = 6402373705728000).
-    self assert:(19 factorial digitBytes = #[0 0 137 6 147 43 176 1]).
-    self assert:(19 factorial = 121645100408832000).
-    self assert:(20 factorial digitBytes = #[0 0 180 130 124 103 195 33]).
-    self assert:(20 factorial = 2432902008176640000).
-    self assert:(50 factorial = 30414093201713378043612608166064768844377641568960512000000000000).
-
-    "
-     self basicNew testFactorial
-    "
-
-    "Created: / 24-04-2010 / 13:52:23 / cg"
-    "Modified: / 26-02-2016 / 15:43:16 / 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 assert:(20 factorial gcd:(5*6*7)) = (5*6*7).
-    self assert:(20 factorial gcd:(20 factorial / 20)) = (19 factorial).
-
-    "
-     self basicNew testGCD
-    "
-
-    "Created: / 27-04-2010 / 09:49:31 / cg"
-!
-
-testHighBitLowBit
-    self assert:( 2r0 highBit == 0).
-    self assert:( 2r1 highBit == 1).
-    self assert:( 2r10 highBit == 2).  
-    self assert:( 2r100 highBit == 3).  
-    self assert:( 2r1000 highBit == 4).  
-    self assert:( 16r10 highBit == 5).
-    self assert:( 16r100 highBit == 9).
-    self assert:( 16r1000 highBit == 13).
-    self assert:( 16r10000 highBit == 17).
-    self assert:( 16r100000 highBit == 21).
-    self assert:( 16r1000000 highBit == 25).
-    self assert:( 16r10000000 highBit == 29).
-    self assert:( 16r20000000 highBit == 30).
-    self assert:( 16r3FFFFFFF highBit == 30).
-    self assert:( 16r40000000 highBit == 31).
-    self assert:( 16r7FFFFFFF highBit == 31).
-    self assert:( 16r80000000 highBit == 32).
-    self assert:( 16rFFFFFFFF highBit == 32).
-    self assert:( 16r100000000 highBit == 33).
-    self assert:( 16r1FFFFFFFF highBit == 33).
-    self assert:( 16r100000001 highBit == 33).
-    self assert:( 16r1000000000 highBit == 37).
-    self assert:( 16r10000000000 highBit == 41).
-    self assert:( 16r100000000000 highBit == 45).
-    self assert:( 16r1000000000000 highBit == 49).
-    self assert:( 16r1FFFFFFFFFFFF highBit == 49).
-    self assert:( 16r2000000000000 highBit == 50).
-    self assert:( 16r4000000000000 highBit == 51).
-    self assert:( 16r7FFFFFFFFFFFF highBit == 51).
-    self assert:( 16r8000000000000 highBit == 52).
-    self assert:( 16rFFFFFFFFFFFFF highBit == 52).
-    self assert:( 16r10000000000000 highBit == 53).
-    self assert:( 16r1FFFFFFFFFFFFF highBit == 53).
-    self assert:( 16r20000000000000 highBit == 54).
-    self assert:( 16r3FFFFFFFFFFFFF highBit == 54).
-    self assert:( 16r40000000000000 highBit == 55).
-    self assert:( 16r5FFFFFFFFFFFFF highBit == 55).
-    self assert:( 16r7FFFFFFFFFFFFF highBit == 55).
-    self assert:( 16r80000000000000 highBit == 56).
-    self assert:( 16r100000000000000 highBit == 57).
-    self assert:( 16r1000000000000000 highBit == 61).
-    self assert:( 16r1FFFFFFFFFFFFFFF highBit == 61).
-    self assert:( 16r2000000000000000 highBit == 62).
-    self assert:( 16r3FFFFFFFFFFFFFFF highBit == 62).
-    self assert:( 16r4000000000000000 highBit == 63).
-    self assert:( 16r7FFFFFFFFFFFFFFF highBit == 63).
-    self assert:( 16r8000000000000000 highBit == 64).
-    self assert:( 16rFFFFFFFFFFFFFFFF highBit == 64).
-    self assert:( 16r10000000000000000 highBit == 65).
-    self assert:( 16r1FFFFFFFFFFFFFFFF highBit == 65).
-    self assert:( (1 bitShift:1000) highBit == 1001).
-
-    self assert:( 2r0 lowBit == 0).
-    self assert:( 2r1 lowBit == 1).
-    self assert:( 2r10 lowBit == 2).  
-    self assert:( 2r100 lowBit == 3).  
-    self assert:( 2r1000 lowBit == 4).  
-    self assert:( 16r10 lowBit == 5).
-    self assert:( 16r100 lowBit == 9).
-    self assert:( 16r1000 lowBit == 13).
-    self assert:( 16r10000 lowBit == 17).
-    self assert:( 16r100000 lowBit == 21).
-    self assert:( 16r1000000 lowBit == 25).
-    self assert:( 16r10000000 lowBit == 29).
-    self assert:( 16r100000000 lowBit == 33).
-    self assert:( 16r1000000000 lowBit == 37).
-    self assert:( 16r10000000000 lowBit == 41).
-    self assert:( 16r100000000000 lowBit == 45).
-    self assert:( 16r1000000000000 lowBit == 49).
-    self assert:( 16r10000000000000 lowBit == 53).
-    self assert:( 16r100000000000000 lowBit == 57).
-    self assert:( 16r1000000000000000 lowBit == 61).
-    self assert:( 16r10000000000000000 lowBit == 65).
-    self assert:( (1 bitShift:1000) lowBit == 1001).
-    
-    self assert:(( 2r1 bitOr: 16r10000000000) lowBit = 1).
-    self assert:(( 2r10 bitOr: 16r10000000000) lowBit = 2).  
-    self assert:(( 2r100 bitOr: 16r10000000000) lowBit = 3).  
-    self assert:(( 2r1000 bitOr: 16r10000000000) lowBit = 4).  
-    self assert:(( 16r10 bitOr: 16r10000000000) lowBit = 5).
-    self assert:(( 16r100 bitOr: 16r10000000000) lowBit = 9).
-    self assert:(( 16r1000 bitOr: 16r10000000000) lowBit = 13).
-    self assert:(( 16r10000 bitOr: 16r10000000000) lowBit = 17).
-    self assert:(( 16r100000 bitOr: 16r10000000000) lowBit = 21).
-    self assert:(( 16r1000000 bitOr: 16r10000000000) lowBit = 25).
-    self assert:(( 16r10000000 bitOr: 16r10000000000) lowBit = 29).
-    self assert:(( 16r100000000 bitOr: 16r10000000000) lowBit = 33).
-    self assert:(( 16r1000000000 bitOr: 16r10000000000) lowBit = 37).
-    self assert:(( 16r10000000000 bitOr: 16r10000000000) lowBit = 41).
-    self assert:(( 16r100000000000 bitOr: 16r100000000000) lowBit = 45).
-    self assert:(( 16r1000000000000 bitOr: 16r1000000000000) lowBit = 49).
-    self assert:(( 16r10000000000000 bitOr: 16r10000000000000) lowBit = 53).
-    self assert:(( 16r100000000000000 bitOr: 16r100000000000000) lowBit = 57).
-    self assert:(( 16r1000000000000000 bitOr: 16r1000000000000000) lowBit = 61).
-    self assert:(( 16r10000000000000000 bitOr: 16r10000000000000000) lowBit = 65).
-    self assert:(( (1 bitShift:1000) bitOr: (1 bitShift:1001)) lowBit = 1001).
-
-    "
-     self basicNew testHighBitLowBit
-    "
-
-    "Modified: / 05-07-2017 / 16:00:51 / 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 class == SmallInteger).
-    self assert:(maxVal class == SmallInteger).
-
-    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 := 16r-20000000.
-        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 := 16r-2000000000000000.
-        halfMax := 16r2000000000000000.
-    ].
-    
-    self assert:(minValMinus1 class == LargeInteger).
-    self assert:(maxValPlus1 class == LargeInteger).
-
-    "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: / 19-09-2017 / 16:27:24 / stefan"
-    "Modified: / 10-10-2017 / 12:13:02 / 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 class == SmallInteger).
-    "/ Transcript showCR:n1 printString.
-    "/ Transcript showCR:n1 negated printString.
-    "/ Transcript showCR:n1 negated class printString.
-    self assert:(n1 negated class == LargeInteger).
-    self assert:((n1 perform:'negated' asSymbol) class == LargeInteger).
-
-    n1 := SmallInteger maxVal.
-    self assert:(n1 negated negated class == SmallInteger).
-    self assert:(((n1 perform:'negated' asSymbol) perform:'negated' asSymbol) class == SmallInteger).
-
-    n1 := SmallInteger minVal.
-    self assert:(n1 negated negated class == SmallInteger).
-    self assert:(((n1 perform:'negated' asSymbol) perform:'negated' asSymbol) class == SmallInteger).
-
-    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 assert:(16r100000000000000000000000 isPowerOfTwo).
-    self assert:(16r300000000000000000000000 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
@@ -2314,225 +2361,6 @@
     "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 assert:( 16r800008 signExtendedFromBit:4 ) = -8. 
-    self assert:( 16r7FFF07 signExtendedFromBit:4 ) = 7.     
-    self assert:( 16r7FFF0F signExtendedFromBit:4 ) = -1.    
-
-    self assert:( 16rFFFFFF signExtendedFromBit:8 ) = -1.   
-    self assert:( 16rFFFF7F signExtendedFromBit:8 ) = 16r7F.   
-
-    self assert:( 16rFFFFFF signExtendedByteValue ) = -1.   
-    self assert:( 16rFFFF7F signExtendedByteValue ) = 16r7F.   
-
-    self assert:( 16rFFFF signExtendedShortValue ) = -1.   
-    self assert:( 16r7FFF signExtendedShortValue ) = 16r7FFF.   
-    self assert:( 16rFFFFFFFF signExtendedShortValue ) = -1.   
-    self assert:( 16rFFFF7FFF signExtendedShortValue ) = 16r7FFF.   
-    self assert:( 16rFFFFFFFFFF signExtendedShortValue ) = -1.   
-    self assert:( 16rFFFFFF7FFF signExtendedShortValue ) = 16r7FFF.   
-    self assert:( 16rFFFFFFFFFFFF signExtendedShortValue ) = -1.   
-    self assert:( 16rFFFFFFFF7FFF signExtendedShortValue ) = 16r7FFF.   
-
-    self assert:( 16rFFFFFFFF signExtendedLongValue ) = -1.   
-    self assert:( 16r7FFFFFFF signExtendedLongValue ) = 2147483647.   
-    self assert:( 16r80000000 signExtendedLongValue ) = -2147483648.   
-    self assert:( 16rFFFFFFFFFFFF signExtendedLongValue ) = -1.   
-    self assert:( 16rFFFF7FFFFFFF signExtendedLongValue ) = 2147483647.   
-    self assert:( 16rFFFF80000000 signExtendedLongValue ) = -2147483648.   
-    self assert:( 16rFFFFFFFFFFFFFFFF signExtendedLongValue ) = -1.   
-    self assert:( 16rFFFFFFFF7FFFFFFF signExtendedLongValue ) = 2147483647.   
-    self assert:( 16rFFFFFFFF80000000 signExtendedLongValue ) = -2147483648.   
-
-    self assert:( 16rFFFFFFFFFFFFFFFF signExtendedLongLongValue ) = -1.   
-    self assert:( 16r7FFFFFFFFFFFFFFF signExtendedLongLongValue ) = 16r7FFFFFFFFFFFFFFF.   
-    self assert:( 16rFFFFFFFFFFFFFFFFFFFF signExtendedLongLongValue ) = -1.   
-    self assert:( 16rFFFF7FFFFFFFFFFFFFFF signExtendedLongLongValue ) = 16r7FFFFFFFFFFFFFFF.   
-
-    "
-     self basicNew testLargeBitOperations
-    "
-
-    "Modified: / 26-02-2016 / 19:47:25 / cg"
-!
-
-testLargeCompare
-    "compare tests"
-
-    #(
-        ( 16r3fffffff 16r40000000 #less )
-        ( 16r40000000 16r3fffffff #greater )
-        ( 16r40000000 16r40000000 #equal )
-
-        ( 16r40000000 16r40000001 #less )
-        ( 16r40000001 16r40000000 #greater )
-        ( 16r40000001 16r40000001 #equal )
-        
-        ( 16r3fffffffffffffff 16r4000000000000000 #less )
-        ( 16r4000000000000000 16r3fffffffffffffff #greater )
-        ( 16r4000000000000000 16r4000000000000000 #equal )
-
-        ( 16r4000000000000000 16r4000000000000001 #less )
-        ( 16r4000000000000001 16r4000000000000000 #greater )
-        ( 16r4000000000000001 16r4000000000000001 #equal )
-
-        ( 16r3fffffffffffffffffffffff 16r400000000000000000000000 #less )
-        ( 16r400000000000000000000000 16r3fffffffffffffffffffffff #greater )
-        ( 16r400000000000000000000000 16r400000000000000000000000 #equal )
-
-        ( 16r400000000000000000000000 16r400000000000000000000001 #less )
-        ( 16r400000000000000000000001 16r400000000000000000000000 #greater )
-        ( 16r400000000000000000000001 16r400000000000000000000001 #equal )
-
-        ( 16r3fffffff 16r400000000000 #less )
-        ( 16r400000000000 16r3fffffff #greater )
-
-        ( 16r40000000 16r400000000001 #less )
-        ( 16r400000000001 16r40000000 #greater )
-
-        ( 16r3fffffffffffffff 16r40000000000000000000 #less )
-        ( 16r40000000000000000000 16r3fffffffffffffff #greater )
-
-        ( 16r4000000000000000 16r40000000000000000001 #less )
-        ( 16r40000000000000000001 16r4000000000000000 #greater )
-
-        ( 16r3fffffffffffffffffffffff 16r400000000000000000000000 #less )
-        ( 16r400000000000000000000000 16r3fffffffffffffffffffffff #greater )
-        ( 16r400000000000000000000000 16r400000000000000000000000 #equal )
-
-        ( 16r400000000000000000000000 16r400000000000000000000001 #less )
-        ( 16r400000000000000000000001 16r400000000000000000000000 #greater )
-        ( 16r400000000000000000000001 16r400000000000000000000001 #equal )
-    ) do:[:triple |
-        |v1 v2 expected rslt|
-        
-        v1 := triple at:1.
-        v2 := triple at:2.
-        expected := triple at:3.
-        expected == #less ifTrue:[
-            self assert:(v1 < v2).
-            self assert:(v1 <= v2).
-            self assert:(v1 > v2) not.
-            self assert:(v1 >= v2) not.
-            self assert:(v1 = v2) not.
-            self assert:(v1 ~= v2).
-        ].    
-        expected == #greater ifTrue:[
-            self assert:(v1 > v2).
-            self assert:(v1 >= v2).
-            self assert:(v1 < v2) not.
-            self assert:(v1 <= v2) not.
-            self assert:(v1 = v2) not.
-            self assert:(v1 ~= v2).
-        ].    
-        expected == #equal ifTrue:[
-            self assert:(v1 > v2) not.
-            self assert:(v1 >= v2).
-            self assert:(v1 < v2) not.
-            self assert:(v1 <= v2).
-            self assert:(v1 = v2).
-            self assert:(v1 ~= v2) not.
-        ].    
-    ].
-    self assert:(100 factorial < 101 factorial).
-    self assert:(100 factorial > 100 factorial negated).
-    
-    "
-     self basicNew testLargeCompare
-    "
-!
-
-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 a b|
 
@@ -2936,368 +2764,6 @@
     "Created: / 05-07-2017 / 16:37:06 / 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"
-!
-
-testLargeIntegerHelpers2
-    |t1 r|
-
-    "/ absSubtract:
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r00ffffffffffffffff.
-    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == true).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r010000000000000000.
-    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == false).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r00ffffffffffffffffff.
-    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == true).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r01000000000000000000.
-    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == false).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffff.
-    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == true).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r0100000000000000000000.
-    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == false).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffffff.
-    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == true).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r010000000000000000000000.
-    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == false).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffffffff.
-    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == true).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r01000000000000000000000000.
-    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == false).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffffffffff.
-    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == true).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r0100000000000000000000000000.
-    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == false).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffffffffffff.
-    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == true).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r010000000000000000000000000000.
-    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == false).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r00ffffffffffffffffffffffffffffff.
-    self assert:(t1 digitBytes = #[16r01 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == true).
-
-    t1 := LargeInteger digitBytes:#[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r01 ] copy sign:1.
-    r := t1 absDestructiveSubtract:16r01000000000000000000000000000000.
-    self assert:(t1 digitBytes = #[16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 16r00 ]).
-    self assert:(r == false).
-    "
-     self basicNew testLargeIntegerHelpers2
-    "
-!
-
-testLargeIntegerHelpers3
-    "/ absDivMod:
-
-     self assert:(9000000000000000000 absDivMod: 4000) = #(2250000000000000 0).
-     self assert:(-9000000000000000000 absDivMod: 4000) = #(2250000000000000 0).
-     self assert:(9000000000000000000 absDivMod: -4000) = #(2250000000000000 0).
-     self assert:(-9000000000000000000 absDivMod: -4000) = #(2250000000000000 0).
-
-     self assert:(9000000000000000001 absDivMod: 4000) = #(2250000000000000 1).
-     self assert:(-9000000000000000001 absDivMod: 4000) = #(2250000000000000 1).
-     self assert:(9000000000000000001 absDivMod: -4000) = #(2250000000000000 1).
-     self assert:(-9000000000000000001 absDivMod: -4000) = #(2250000000000000 1).
-
-     self assert:(9000000000000000000 absDivMod: 40000) = #(225000000000000 0).
-     self assert:(-9000000000000000000 absDivMod: 40000) = #(225000000000000 0).
-     self assert:(9000000000000000000 absDivMod: -40000) = #(225000000000000 0).
-     self assert:(-9000000000000000000 absDivMod: -40000) = #(225000000000000 0).
-
-     self assert:(9000000000000000000 absDivMod: 400000) = #(22500000000000 0).
-     self assert:(-9000000000000000000 absDivMod: 400000) = #(22500000000000 0).
-     self assert:(9000000000000000000 absDivMod: -400000) = #(22500000000000 0).
-     self assert:(-9000000000000000000 absDivMod: -400000) = #(22500000000000 0).
-
-     self assert:(9000000000000000000 absDivMod: 4000000) = #(2250000000000 0).
-     self assert:(-9000000000000000000 absDivMod: 4000000) = #(2250000000000 0).
-     self assert:(9000000000000000000 absDivMod: -4000000) = #(2250000000000 0).
-     self assert:(-9000000000000000000 absDivMod: -4000000) = #(2250000000000 0).
-
-     self assert:(9000000000000000000 absDivMod: 40000000) = #(225000000000 0).
-     self assert:(-9000000000000000000 absDivMod: 40000000) = #(225000000000 0).
-     self assert:(9000000000000000000 absDivMod: -40000000) = #(225000000000 0).
-     self assert:(-9000000000000000000 absDivMod: -40000000) = #(225000000000 0).
-
-     self assert:(9000000000000000000 absDivMod: 400000000) = #(22500000000 0).
-     self assert:(-9000000000000000000 absDivMod: 400000000) = #(22500000000 0).
-     self assert:(9000000000000000000 absDivMod: -400000000) = #(22500000000 0).
-     self assert:(-9000000000000000000 absDivMod: -400000000) = #(22500000000 0).
-
-     self assert:(9000000000000000000 absDivMod: 4000000000) = #(2250000000 0).
-     self assert:(-9000000000000000000 absDivMod: 4000000000) = #(2250000000 0).
-     self assert:(9000000000000000000 absDivMod: -4000000000) = #(2250000000 0).
-     self assert:(-9000000000000000000 absDivMod: -4000000000) = #(2250000000 0).
-
-     self assert:(9000000000000000000 absDivMod: 40000000000) = #(225000000 0).
-     self assert:(-9000000000000000000 absDivMod: 40000000000) = #(225000000 0).
-     self assert:(9000000000000000000 absDivMod: -40000000000) = #(225000000 0).
-     self assert:(-9000000000000000000 absDivMod: -40000000000) = #(225000000 0).
-
-     self assert:(9000000000000000000 absDivMod: 400000000000) = #(22500000 0).
-     self assert:(-9000000000000000000 absDivMod: 400000000000) = #(22500000 0).
-     self assert:(9000000000000000000 absDivMod: -400000000000) = #(22500000 0).
-     self assert:(-9000000000000000000 absDivMod: -400000000000) = #(22500000 0).
-
-     self assert:(9000000000000000000 absDivMod: 4000000000000) = #(2250000 0).
-     self assert:(-9000000000000000000 absDivMod: 4000000000000) = #(2250000 0).
-     self assert:(9000000000000000000 absDivMod: -4000000000000) = #(2250000 0).
-     self assert:(-9000000000000000000 absDivMod: -4000000000000) = #(2250000 0).
-
-     self assert:(9000000000000000000 absDivMod: 40000000000000) = #(225000 0).
-     self assert:(-9000000000000000000 absDivMod: 40000000000000) = #(225000 0).
-     self assert:(9000000000000000000 absDivMod: -40000000000000) = #(225000 0).
-     self assert:(-9000000000000000000 absDivMod: -40000000000000) = #(225000 0).
-
-     self assert:(9000000000000000000 absDivMod: 400000000000000) = #(22500 0).
-     self assert:(-9000000000000000000 absDivMod: 400000000000000) = #(22500 0).
-     self assert:(9000000000000000000 absDivMod: -400000000000000) = #(22500 0).
-     self assert:(-9000000000000000000 absDivMod: -400000000000000) = #(22500 0).
-
-     self assert:(9000000000000000000 absDivMod: 4000000000000000) = #(2250 0).
-     self assert:(-9000000000000000000 absDivMod: 4000000000000000) = #(2250 0).
-     self assert:(9000000000000000000 absDivMod: -4000000000000000) = #(2250 0).
-     self assert:(-9000000000000000000 absDivMod: -4000000000000000) = #(2250 0).
-
-     self assert:(9000000000000000000 absDivMod: 4000000000000000000) = #(2 1000000000000000000).
-     self assert:(-9000000000000000000 absDivMod: 4000000000000000000) = #(2 1000000000000000000).
-     self assert:(9000000000000000000 absDivMod: -4000000000000000000) = #(2 1000000000000000000).
-     self assert:(-9000000000000000000 absDivMod: -4000000000000000000) = #(2 1000000000000000000).
-
-    "
-     self basicNew testLargeIntegerHelpers3
-    "
-!
-
-testLargeIntegerHelpers4
-    "/ absDivMod:
-
-     self assert:(9000000000000000000 absMod: 4000) = 0.
-     self assert:(-9000000000000000000 absMod: 4000) = 0.
-     self assert:(9000000000000000000 absMod: -4000) = 0.
-     self assert:(-9000000000000000000 absMod: -4000) = 0.
-
-     self assert:(9000000000000000001 absMod: 4000) = 1.
-     self assert:(-9000000000000000001 absMod: 4000) = 1.
-     self assert:(9000000000000000001 absMod: -4000) = 1.
-     self assert:(-9000000000000000001 absMod: -4000) = 1.
-
-     self assert:(9000000000000000000 absMod: 40000) = 0.
-     self assert:(-9000000000000000000 absMod: 40000) = 0.
-     self assert:(9000000000000000000 absMod: -40000) = 0.
-     self assert:(-9000000000000000000 absMod: -40000) = 0.
-
-     self assert:(9000000000000000000 absMod: 400000) = 0.
-     self assert:(-9000000000000000000 absMod: 400000) = 0.
-     self assert:(9000000000000000000 absMod: -400000) = 0.
-     self assert:(-9000000000000000000 absMod: -400000) = 0.
-
-     self assert:(9000000000000000000 absMod: 4000000) = 0.
-     self assert:(-9000000000000000000 absMod: 4000000) = 0.
-     self assert:(9000000000000000000 absMod: -4000000) = 0.
-     self assert:(-9000000000000000000 absMod: -4000000) = 0.
-
-     self assert:(9000000000000000000 absMod: 40000000) = 0.
-     self assert:(-9000000000000000000 absMod: 40000000) = 0.
-     self assert:(9000000000000000000 absMod: -40000000) = 0.
-     self assert:(-9000000000000000000 absMod: -40000000) = 0.
-
-     self assert:(9000000000000000000 absMod: 400000000) = 0.
-     self assert:(-9000000000000000000 absMod: 400000000) = 0.
-     self assert:(9000000000000000000 absMod: -400000000) = 0.
-     self assert:(-9000000000000000000 absMod: -400000000) = 0.
-
-     self assert:(9000000000000000000 absMod: 4000000000) = 0.
-     self assert:(-9000000000000000000 absMod: 4000000000) = 0.
-     self assert:(9000000000000000000 absMod: -4000000000) = 0.
-     self assert:(-9000000000000000000 absMod: -4000000000) = 0.
-
-     self assert:(9000000000000000000 absMod: 40000000000) = 0.
-     self assert:(-9000000000000000000 absMod: 40000000000) = 0.
-     self assert:(9000000000000000000 absMod: -40000000000) = 0.
-     self assert:(-9000000000000000000 absMod: -40000000000) = 0.
-
-     self assert:(9000000000000000000 absMod: 400000000000) = 0.
-     self assert:(-9000000000000000000 absMod: 400000000000) = 0.
-     self assert:(9000000000000000000 absMod: -400000000000) = 0.
-     self assert:(-9000000000000000000 absMod: -400000000000) = 0.
-
-     self assert:(9000000000000000000 absMod: 4000000000000) = 0.
-     self assert:(-9000000000000000000 absMod: 4000000000000) = 0.
-     self assert:(9000000000000000000 absMod: -4000000000000) = 0.
-     self assert:(-9000000000000000000 absMod: -4000000000000) = 0.
-
-     self assert:(9000000000000000000 absMod: 40000000000000) = 0.
-     self assert:(-9000000000000000000 absMod: 40000000000000) = 0.
-     self assert:(9000000000000000000 absMod: -40000000000000) = 0.
-     self assert:(-9000000000000000000 absMod: -40000000000000) = 0.
-
-     self assert:(9000000000000000000 absMod: 400000000000000) = 0.
-     self assert:(-9000000000000000000 absMod: 400000000000000) = 0.
-     self assert:(9000000000000000000 absMod: -400000000000000) = 0.
-     self assert:(-9000000000000000000 absMod: -400000000000000) = 0.
-
-     self assert:(9000000000000000000 absMod: 4000000000000000) = 0.
-     self assert:(-9000000000000000000 absMod: 4000000000000000) = 0.
-     self assert:(9000000000000000000 absMod: -4000000000000000) = 0.
-     self assert:(-9000000000000000000 absMod: -4000000000000000) = 0.
-
-     self assert:(9000000000000000000 absMod: 4000000000000000000) = 1000000000000000000.
-     self assert:(-9000000000000000000 absMod: 4000000000000000000) = 1000000000000000000.
-     self assert:(9000000000000000000 absMod: -4000000000000000000) = 1000000000000000000.
-     self assert:(-9000000000000000000 absMod: -4000000000000000000) = 1000000000000000000.
-
-    "
-     self basicNew testLargeIntegerHelpers4
-    "
-
-    "Created: / 05-07-2017 / 16:15:30 / cg"
-!
-
 testLargeMultiplication
     |t1 t2 p|
 
@@ -3867,56 +3333,6 @@
     "
 !
 
-testMiscMath
-    self assert:(2 raisedTo:2) == 4.
-    self assert:(2 raisedTo:2.0) = 4.0.
-    self assert:(2 raisedTo:100) = 1267650600228229401496703205376.
-    
-    self assert:(((2 raisedTo:100) log:2) isAlmostEqualTo:100 nEpsilon:1) 
-         message:('(2^100)log2 is %1' bindWith:((2 raisedTo:100) log:2)).
-    self assert:(((2 raisedTo:100) integerLog2) == 100)
-         message:('(2^100)integerLog2 is %1' bindWith:((2 raisedTo:100) integerLog2)).
-
-    self assert:(((10 raisedTo:100) integerLog10) == 100)
-         message:('(10^100)integerLog10 is %1' bindWith:((10 raisedTo:100) integerLog10)).
-
-    "/ currently, integerLog10 does not work with largeInts
-    "/ self assert:(((10 raisedTo:1000) integerLog10) == 1000).
-
-    "
-     self basicNew testMiscMath
-    "
-
-    "Created: / 02-07-2017 / 00:52:25 / cg"
-    "Modified (comment): / 02-07-2017 / 14:39:26 / cg"
-    "Modified: / 22-07-2019 / 12:44:41 / Claus Gittinger"
-!
-
-testMiscMath2
-    self assert:(10000000000000000000000001 isPrime) not.
-    self assert:(76 factorial + 1) isPrime not.
-
-    "/ Would take far too long with fallback implementation.
-    PrimeNumberGenerator notNil ifTrue:[
-        self assert:(77 factorial + 1) isPrime.
-        self assert:(872 factorial + 1) isPrime.
-        self assert:(1000 factorial + 1) isPrime not.
-    ].
-
-    "
-    Time millisecondsToRun:[
-        1000000 factorial.
-    ].
-    "
-
-    "
-     self basicNew testMiscMath2
-    "
-
-    "Created: / 05-07-2017 / 16:18:54 / cg"
-    "Modified (comment): / 26-07-2017 / 12:48:11 / mawalch"
-!
-
 testModulu
     |a b op|
 
@@ -4129,95 +3545,6 @@
     self assert:(self doNegate2:SmallInteger minVal) = (SmallInteger maxVal + 1).
 !
 
-testNextPowerOfTwo
-    "/ self assert:(0 nextPowerOf2 = 0).
-    self assert:(1 nextPowerOf2 = 1).
-    self assert:(2 nextPowerOf2 = 2).
-    self assert:(3 nextPowerOf2 = 4).
-    self assert:(4 nextPowerOf2 = 4).
-    self assert:(5 nextPowerOf2 = 8).
-    self assert:(6 nextPowerOf2 = 8).
-    self assert:(7 nextPowerOf2 = 8).
-    self assert:(8 nextPowerOf2 = 8).
-    self assert:(9 nextPowerOf2 = 16).
-
-    self assert:(22 nextPowerOf2 = 32).
-    self assert:(32 nextPowerOf2 = 32).
-    self assert:(16rFFFF nextPowerOf2 = 16r10000).  
-    self assert:(16r1FFFFFFF nextPowerOf2 = 16r20000000).  
-    self assert:(16r3FFFFFFF nextPowerOf2 = 16r40000000).  
-    self assert:(16r7FFFFFFF nextPowerOf2 = 16r80000000).  
-    self assert:(16rFFFFFFFF nextPowerOf2 = 16r100000000). 
-    self assert:(16r1FFFFFFFFFFFFFFF nextPowerOf2 = 16r2000000000000000).  
-    self assert:(16r3FFFFFFFFFFFFFFF nextPowerOf2 = 16r4000000000000000).  
-    self assert:(16r7FFFFFFFFFFFFFFF nextPowerOf2 = 16r8000000000000000).  
-    self assert:(16rFFFFFFFFFFFFFFFF nextPowerOf2 = 16r10000000000000000).  
-    self assert:(16rFFFFFFFFFFFFFFFFFFFF nextPowerOf2 = 16r100000000000000000000).  
-
-    "
-     self basicNew testNextPowerOfTwo
-    "
-!
-
-testSignExtension
-    "/ 8bit
-    self assert:( 16r80 signExtendedByteValue = -128 ).
-    self assert:( 16r7F signExtendedByteValue = 127 ).  
-    self assert:( 16rFF signExtendedByteValue = -1 ).
-
-    "/ higher bits are ignored
-    self assert:( 16rF80 signExtendedByteValue = -128 ).
-    self assert:( 16rF7F signExtendedByteValue = 127 ).  
-    self assert:( 16rFFF signExtendedByteValue = -1 ).
-
-    "/ 16bit
-    self assert:( 16r8000 signExtendedShortValue = -32768 ).
-    self assert:( 16r7FFF signExtendedShortValue = 32767 ).  
-    self assert:( 16rFFFF signExtendedShortValue = -1 ).
-
-    "/ higher bits are ignored
-    self assert:( 16rF8000 signExtendedShortValue = -32768 ).
-    self assert:( 16rF7FFF signExtendedShortValue = 32767 ).  
-    self assert:( 16rFFFFF signExtendedShortValue = -1 ).
-
-    "/ 24bit
-    self assert:( 16r800000 signExtended24BitValue = -8388608 ).
-    self assert:( 16r7FFFFF signExtended24BitValue = 8388607 ).  
-    self assert:( 16rFFFFFF signExtended24BitValue = -1 ).
-
-    "/ higher bits are ignored
-    self assert:( 16rF800000 signExtended24BitValue = -8388608 ).
-    self assert:( 16rF7FFFFF signExtended24BitValue = 8388607 ).  
-    self assert:( 16rFFFFFFF signExtended24BitValue = -1 ).
-
-    "/ 32bit
-    self assert:( 16r80000000 signExtendedLongValue = -2147483648 ).
-    self assert:( 16r7FFFFFFF signExtendedLongValue = 2147483647 ).  
-    self assert:( 16rFFFFFFFF signExtendedLongValue = -1 ).
-
-    "/ higher bits are ignored
-    self assert:( 16rF80000000 signExtendedLongValue = -2147483648 ).
-    self assert:( 16rF7FFFFFFF signExtendedLongValue = 2147483647 ).  
-    self assert:( 16rFFFFFFFFF signExtendedLongValue = -1 ).
-
-    "/ 64bit
-    self assert:( 16r8000000000000000 signExtendedLongLongValue = -9223372036854775808 ).
-    self assert:( 16r7FFFFFFFFFFFFFFF signExtendedLongLongValue = 9223372036854775807 ).  
-    self assert:( 16rFFFFFFFFFFFFFFFF signExtendedLongLongValue = -1 ).
-
-    "/ higher bits are ignored
-    self assert:( 16rF8000000000000000 signExtendedLongLongValue = -9223372036854775808 ).
-    self assert:( 16rF7FFFFFFFFFFFFFFF signExtendedLongLongValue = 9223372036854775807 ).  
-    self assert:( 16rFFFFFFFFFFFFFFFFF signExtendedLongLongValue = -1 ).
-
-    "/ arbitrary nr of bits
-    self assert:( 2r1000 signExtendedFromBit:4) = -8 .
-    self assert:( 2r0111 signExtendedFromBit:4) = 7 .  
-    self assert:( 2r1111 signExtendedFromBit:4) = -1 .
-
-    "Created: / 21-07-2017 / 15:15:53 / cg"
-!
-
 testSmallIntegerArithmetic
     "arithmetic tests.
      Notice, the arithmetic tests are both performed via regular sends
@@ -5065,6 +4392,454 @@
     "Created: / 04-06-2019 / 00:58:47 / Claus Gittinger"
 !
 
+testByteSwap
+    "/ <testedMethods: #( (Integer >> #byteSwapped32) (Integer >> #byteSwapped64)) >
+
+    self assert:(16r1122 byteSwapped16) = 16r2211.
+    self assert:(16r2211 byteSwapped16) = 16r1122.
+
+    self assert:(16r11223344 byteSwapped32) = 16r44332211.
+    self assert:(16r44332211 byteSwapped32) = 16r11223344.
+
+    self assert:(16r11223344 byteSwapped64) = 16r4433221100000000.
+    self assert:(16r44332211 byteSwapped64) = 16r1122334400000000.
+
+    self assert:(16r8877665544332211 byteSwapped64) = 16r1122334455667788.
+    self assert:(16r1122334455667788 byteSwapped64) = 16r8877665544332211.
+
+    "/ higher bits are ignored!!
+    self assert:(16r33441122 byteSwapped16) = 16r2211.
+
+    self assert:(16r9911223344 byteSwapped32) = 16r44332211.
+    self assert:(16r8877665544332211 byteSwapped32) = 16r11223344.
+    self assert:(16r998877665544332211 byteSwapped64) = 16r1122334455667788.
+    self assert:(16r991122334455667788 byteSwapped64) = 16r8877665544332211.
+
+    "
+     self basicNew testByteSwap
+    "
+!
+
+testHighBitLowBit
+    self assert:( 2r0 highBit == 0).
+    self assert:( 2r1 highBit == 1).
+    self assert:( 2r10 highBit == 2).  
+    self assert:( 2r100 highBit == 3).  
+    self assert:( 2r1000 highBit == 4).  
+    self assert:( 16r10 highBit == 5).
+    self assert:( 16r100 highBit == 9).
+    self assert:( 16r1000 highBit == 13).
+    self assert:( 16r10000 highBit == 17).
+    self assert:( 16r100000 highBit == 21).
+    self assert:( 16r1000000 highBit == 25).
+    self assert:( 16r10000000 highBit == 29).
+    self assert:( 16r20000000 highBit == 30).
+    self assert:( 16r3FFFFFFF highBit == 30).
+    self assert:( 16r40000000 highBit == 31).
+    self assert:( 16r7FFFFFFF highBit == 31).
+    self assert:( 16r80000000 highBit == 32).
+    self assert:( 16rFFFFFFFF highBit == 32).
+    self assert:( 16r100000000 highBit == 33).
+    self assert:( 16r1FFFFFFFF highBit == 33).
+    self assert:( 16r100000001 highBit == 33).
+    self assert:( 16r1000000000 highBit == 37).
+    self assert:( 16r10000000000 highBit == 41).
+    self assert:( 16r100000000000 highBit == 45).
+    self assert:( 16r1000000000000 highBit == 49).
+    self assert:( 16r1FFFFFFFFFFFF highBit == 49).
+    self assert:( 16r2000000000000 highBit == 50).
+    self assert:( 16r4000000000000 highBit == 51).
+    self assert:( 16r7FFFFFFFFFFFF highBit == 51).
+    self assert:( 16r8000000000000 highBit == 52).
+    self assert:( 16rFFFFFFFFFFFFF highBit == 52).
+    self assert:( 16r10000000000000 highBit == 53).
+    self assert:( 16r1FFFFFFFFFFFFF highBit == 53).
+    self assert:( 16r20000000000000 highBit == 54).
+    self assert:( 16r3FFFFFFFFFFFFF highBit == 54).
+    self assert:( 16r40000000000000 highBit == 55).
+    self assert:( 16r5FFFFFFFFFFFFF highBit == 55).
+    self assert:( 16r7FFFFFFFFFFFFF highBit == 55).
+    self assert:( 16r80000000000000 highBit == 56).
+    self assert:( 16r100000000000000 highBit == 57).
+    self assert:( 16r1000000000000000 highBit == 61).
+    self assert:( 16r1FFFFFFFFFFFFFFF highBit == 61).
+    self assert:( 16r2000000000000000 highBit == 62).
+    self assert:( 16r3FFFFFFFFFFFFFFF highBit == 62).
+    self assert:( 16r4000000000000000 highBit == 63).
+    self assert:( 16r7FFFFFFFFFFFFFFF highBit == 63).
+    self assert:( 16r8000000000000000 highBit == 64).
+    self assert:( 16rFFFFFFFFFFFFFFFF highBit == 64).
+    self assert:( 16r10000000000000000 highBit == 65).
+    self assert:( 16r1FFFFFFFFFFFFFFFF highBit == 65).
+    self assert:( (1 bitShift:1000) highBit == 1001).
+
+    self assert:( 2r0 lowBit == 0).
+    self assert:( 2r1 lowBit == 1).
+    self assert:( 2r10 lowBit == 2).  
+    self assert:( 2r100 lowBit == 3).  
+    self assert:( 2r1000 lowBit == 4).  
+    self assert:( 16r10 lowBit == 5).
+    self assert:( 16r100 lowBit == 9).
+    self assert:( 16r1000 lowBit == 13).
+    self assert:( 16r10000 lowBit == 17).
+    self assert:( 16r100000 lowBit == 21).
+    self assert:( 16r1000000 lowBit == 25).
+    self assert:( 16r10000000 lowBit == 29).
+    self assert:( 16r100000000 lowBit == 33).
+    self assert:( 16r1000000000 lowBit == 37).
+    self assert:( 16r10000000000 lowBit == 41).
+    self assert:( 16r100000000000 lowBit == 45).
+    self assert:( 16r1000000000000 lowBit == 49).
+    self assert:( 16r10000000000000 lowBit == 53).
+    self assert:( 16r100000000000000 lowBit == 57).
+    self assert:( 16r1000000000000000 lowBit == 61).
+    self assert:( 16r10000000000000000 lowBit == 65).
+    self assert:( (1 bitShift:1000) lowBit == 1001).
+    
+    self assert:(( 2r1 bitOr: 16r10000000000) lowBit = 1).
+    self assert:(( 2r10 bitOr: 16r10000000000) lowBit = 2).  
+    self assert:(( 2r100 bitOr: 16r10000000000) lowBit = 3).  
+    self assert:(( 2r1000 bitOr: 16r10000000000) lowBit = 4).  
+    self assert:(( 16r10 bitOr: 16r10000000000) lowBit = 5).
+    self assert:(( 16r100 bitOr: 16r10000000000) lowBit = 9).
+    self assert:(( 16r1000 bitOr: 16r10000000000) lowBit = 13).
+    self assert:(( 16r10000 bitOr: 16r10000000000) lowBit = 17).
+    self assert:(( 16r100000 bitOr: 16r10000000000) lowBit = 21).
+    self assert:(( 16r1000000 bitOr: 16r10000000000) lowBit = 25).
+    self assert:(( 16r10000000 bitOr: 16r10000000000) lowBit = 29).
+    self assert:(( 16r100000000 bitOr: 16r10000000000) lowBit = 33).
+    self assert:(( 16r1000000000 bitOr: 16r10000000000) lowBit = 37).
+    self assert:(( 16r10000000000 bitOr: 16r10000000000) lowBit = 41).
+    self assert:(( 16r100000000000 bitOr: 16r100000000000) lowBit = 45).
+    self assert:(( 16r1000000000000 bitOr: 16r1000000000000) lowBit = 49).
+    self assert:(( 16r10000000000000 bitOr: 16r10000000000000) lowBit = 53).
+    self assert:(( 16r100000000000000 bitOr: 16r100000000000000) lowBit = 57).
+    self assert:(( 16r1000000000000000 bitOr: 16r1000000000000000) lowBit = 61).
+    self assert:(( 16r10000000000000000 bitOr: 16r10000000000000000) lowBit = 65).
+    self assert:(( (1 bitShift:1000) bitOr: (1 bitShift:1001)) lowBit = 1001).
+
+    "
+     self basicNew testHighBitLowBit
+    "
+
+    "Modified: / 05-07-2017 / 16:00:51 / cg"
+!
+
+testIntegerShifts
+    "arithmetic tests.
+     Notice, the arithmetic tests are both performed via regular sends
+     and via constructed performs. The reason is to test both inlined
+     JIT-compiler code AND the regular methods code."
+
+    self testIntegerShifts1.
+    self testIntegerShifts2.
+
+    self assert:(
+     (((0 to:64) collect:[:s | 1 bitShift:s])
+	collect:[:n | n highBit]) = (1 to:65)
+    ).
+
+    1 to:10000 do:[:s |
+	self assert:( (1 bitShift:s) highBit == (s+1) )
+    ].
+    1 to:10000 do:[:s |
+	self assert:( ((1 bitShift:s) - 1) highBit == s )
+    ].
+
+    "
+     self basicNew testIntegerShifts
+    "
+
+    "Created: / 6.6.1999 / 14:47:51 / cg"
+    "Modified: / 9.6.1999 / 17:49:57 / cg"
+!
+
+testIntegerShifts1
+    "arithmetic tests.
+     Notice, the arithmetic tests are both performed via regular sends
+     and via constructed performs. The reason is to test both inlined
+     JIT-compiler code AND the regular methods code."
+
+    |n1 n2 s|
+
+    n1 := 100000.
+    n2 := n1 negated.
+    s := 1.
+
+    self assert:(n1 printString = '100000').
+    self assert:(n2 printString = '-100000').
+
+    self assert:((n1 bitShift:s) printString = '200000').
+    self assert:((n1 bitShift:1) printString = '200000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '200000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:1) printString = '200000').
+
+    s := s + 1.
+    self assert:((n1 bitShift:s) printString = '400000').
+    self assert:((n1 bitShift:2) printString = '400000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '400000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:2) printString = '400000').
+
+    s := s + 1.
+    self assert:((n1 bitShift:s) printString = '800000').
+    self assert:((n1 bitShift:3) printString = '800000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '800000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:3) printString = '800000').
+
+    s := s + 1.
+    self assert:((n1 bitShift:s) printString = '1600000').
+    self assert:((n1 bitShift:4) printString = '1600000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '1600000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:4) printString = '1600000').
+
+    s := s + 1.
+    self assert:((n1 bitShift:s) printString = '3200000').
+    self assert:((n1 bitShift:5) printString = '3200000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '3200000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:5) printString = '3200000').
+
+    s := s + 1.
+    self assert:((n1 bitShift:s) printString = '6400000').
+    self assert:((n1 bitShift:6) printString = '6400000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '6400000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:6) printString = '6400000').
+
+    s := s + 1.
+    self assert:((n1 bitShift:s) printString = '12800000').
+    self assert:((n1 bitShift:7) printString = '12800000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '12800000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:7) printString = '12800000').
+
+    "
+     self basicNew testIntegerShifts1
+    "
+
+    "Created: / 6.6.1999 / 14:47:51 / cg"
+    "Modified: / 9.6.1999 / 17:49:57 / cg"
+!
+
+testIntegerShifts2
+    "arithmetic tests.
+     Notice, the arithmetic tests are both performed via regular sends
+     and via constructed performs. The reason is to test both inlined
+     JIT-compiler code AND the regular methods code."
+
+    |n1 s|
+
+    n1 := 12800000.
+    s := -1.
+    self assert:((n1 bitShift:s) printString = '6400000').
+    self assert:((n1 bitShift:-1) printString = '6400000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '6400000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:-1) printString = '6400000').
+
+    s := s - 1.
+    self assert:((n1 bitShift:s) printString = '3200000').
+    self assert:((n1 bitShift:-2) printString = '3200000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '3200000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:-2) printString = '3200000').
+
+    s := s - 1.
+    self assert:((n1 bitShift:s) printString = '1600000').
+    self assert:((n1 bitShift:-3) printString = '1600000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '1600000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:-3) printString = '1600000').
+
+    s := s - 1.
+    self assert:((n1 bitShift:s) printString = '800000').
+    self assert:((n1 bitShift:-4) printString = '800000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '800000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:-4) printString = '800000').
+
+    s := s - 1.
+    self assert:((n1 bitShift:s) printString = '400000').
+    self assert:((n1 bitShift:-5) printString = '400000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '400000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:-5) printString = '400000').
+
+    s := s - 1.
+    self assert:((n1 bitShift:s) printString = '200000').
+    self assert:((n1 bitShift:-6) printString = '200000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '200000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:-6) printString = '200000').
+
+    s := s - 1.
+    self assert:((n1 bitShift:s) printString = '100000').
+    self assert:((n1 bitShift:-7) printString = '100000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '100000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:-7) printString = '100000').
+
+    s := s - 1.
+    self assert:((n1 bitShift:s) printString = '50000').
+    self assert:((n1 bitShift:-8) printString = '50000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '50000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:-8) printString = '50000').
+
+    s := s - 1.
+    self assert:((n1 bitShift:s) printString = '25000').
+    self assert:((n1 bitShift:-9) printString = '25000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '25000').
+    self assert:((n1 perform:'bitShift:' asSymbol with:-9) printString = '25000').
+
+    s := s - 1.
+    self assert:((n1 bitShift:s) printString = '12500').
+    self assert:((n1 bitShift:-10) printString = '12500').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '12500').
+    self assert:((n1 perform:'bitShift:' asSymbol with:-10) printString = '12500').
+
+    s := s - 1.
+    self assert:((n1 bitShift:s) printString = '6250').
+    self assert:((n1 bitShift:-11) printString = '6250').
+    self assert:((n1 perform:'bitShift:' asSymbol with:s) printString = '6250').
+    self assert:((n1 perform:'bitShift:' asSymbol with:-11) printString = '6250').
+
+    "
+     self basicNew testIntegerShifts2
+    "
+
+    "Created: / 6.6.1999 / 14:47:51 / cg"
+    "Modified: / 9.6.1999 / 17:49:57 / cg"
+!
+
+testIntegerShifts3
+    "arithmetic tests.
+     Notice, the arithmetic tests are both performed via regular sends
+     and via constructed performs. The reason is to test both inlined
+     JIT-compiler code AND the regular methods code."
+
+    self assert:( self doConstantIntegerShift == 1).
+
+    "
+     self basicNew testIntegerShifts3
+    "
+!
+
+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
+    "
+!
+
+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 assert:( 16r800008 signExtendedFromBit:4 ) = -8. 
+    self assert:( 16r7FFF07 signExtendedFromBit:4 ) = 7.     
+    self assert:( 16r7FFF0F signExtendedFromBit:4 ) = -1.    
+
+    self assert:( 16rFFFFFF signExtendedFromBit:8 ) = -1.   
+    self assert:( 16rFFFF7F signExtendedFromBit:8 ) = 16r7F.   
+
+    self assert:( 16rFFFFFF signExtendedByteValue ) = -1.   
+    self assert:( 16rFFFF7F signExtendedByteValue ) = 16r7F.   
+
+    self assert:( 16rFFFF signExtendedShortValue ) = -1.   
+    self assert:( 16r7FFF signExtendedShortValue ) = 16r7FFF.   
+    self assert:( 16rFFFFFFFF signExtendedShortValue ) = -1.   
+    self assert:( 16rFFFF7FFF signExtendedShortValue ) = 16r7FFF.   
+    self assert:( 16rFFFFFFFFFF signExtendedShortValue ) = -1.   
+    self assert:( 16rFFFFFF7FFF signExtendedShortValue ) = 16r7FFF.   
+    self assert:( 16rFFFFFFFFFFFF signExtendedShortValue ) = -1.   
+    self assert:( 16rFFFFFFFF7FFF signExtendedShortValue ) = 16r7FFF.   
+
+    self assert:( 16rFFFFFFFF signExtendedLongValue ) = -1.   
+    self assert:( 16r7FFFFFFF signExtendedLongValue ) = 2147483647.   
+    self assert:( 16r80000000 signExtendedLongValue ) = -2147483648.   
+    self assert:( 16rFFFFFFFFFFFF signExtendedLongValue ) = -1.   
+    self assert:( 16rFFFF7FFFFFFF signExtendedLongValue ) = 2147483647.   
+    self assert:( 16rFFFF80000000 signExtendedLongValue ) = -2147483648.   
+    self assert:( 16rFFFFFFFFFFFFFFFF signExtendedLongValue ) = -1.   
+    self assert:( 16rFFFFFFFF7FFFFFFF signExtendedLongValue ) = 2147483647.   
+    self assert:( 16rFFFFFFFF80000000 signExtendedLongValue ) = -2147483648.   
+
+    self assert:( 16rFFFFFFFFFFFFFFFF signExtendedLongLongValue ) = -1.   
+    self assert:( 16r7FFFFFFFFFFFFFFF signExtendedLongLongValue ) = 16r7FFFFFFFFFFFFFFF.   
+    self assert:( 16rFFFFFFFFFFFFFFFFFFFF signExtendedLongLongValue ) = -1.   
+    self assert:( 16rFFFF7FFFFFFFFFFFFFFF signExtendedLongLongValue ) = 16r7FFFFFFFFFFFFFFF.   
+
+    "
+     self basicNew testLargeBitOperations
+    "
+
+    "Modified: / 26-02-2016 / 19:47:25 / cg"
+!
+
 testRightShift
     "right shifts must preserve the sign - even for large integers"
     
@@ -5083,6 +4858,65 @@
     "Created: / 04-06-2019 / 01:05:30 / Claus Gittinger"
 !
 
+testSignExtension
+    "/ 8bit
+    self assert:( 16r80 signExtendedByteValue = -128 ).
+    self assert:( 16r7F signExtendedByteValue = 127 ).  
+    self assert:( 16rFF signExtendedByteValue = -1 ).
+
+    "/ higher bits are ignored
+    self assert:( 16rF80 signExtendedByteValue = -128 ).
+    self assert:( 16rF7F signExtendedByteValue = 127 ).  
+    self assert:( 16rFFF signExtendedByteValue = -1 ).
+
+    "/ 16bit
+    self assert:( 16r8000 signExtendedShortValue = -32768 ).
+    self assert:( 16r7FFF signExtendedShortValue = 32767 ).  
+    self assert:( 16rFFFF signExtendedShortValue = -1 ).
+
+    "/ higher bits are ignored
+    self assert:( 16rF8000 signExtendedShortValue = -32768 ).
+    self assert:( 16rF7FFF signExtendedShortValue = 32767 ).  
+    self assert:( 16rFFFFF signExtendedShortValue = -1 ).
+
+    "/ 24bit
+    self assert:( 16r800000 signExtended24BitValue = -8388608 ).
+    self assert:( 16r7FFFFF signExtended24BitValue = 8388607 ).  
+    self assert:( 16rFFFFFF signExtended24BitValue = -1 ).
+
+    "/ higher bits are ignored
+    self assert:( 16rF800000 signExtended24BitValue = -8388608 ).
+    self assert:( 16rF7FFFFF signExtended24BitValue = 8388607 ).  
+    self assert:( 16rFFFFFFF signExtended24BitValue = -1 ).
+
+    "/ 32bit
+    self assert:( 16r80000000 signExtendedLongValue = -2147483648 ).
+    self assert:( 16r7FFFFFFF signExtendedLongValue = 2147483647 ).  
+    self assert:( 16rFFFFFFFF signExtendedLongValue = -1 ).
+
+    "/ higher bits are ignored
+    self assert:( 16rF80000000 signExtendedLongValue = -2147483648 ).
+    self assert:( 16rF7FFFFFFF signExtendedLongValue = 2147483647 ).  
+    self assert:( 16rFFFFFFFFF signExtendedLongValue = -1 ).
+
+    "/ 64bit
+    self assert:( 16r8000000000000000 signExtendedLongLongValue = -9223372036854775808 ).
+    self assert:( 16r7FFFFFFFFFFFFFFF signExtendedLongLongValue = 9223372036854775807 ).  
+    self assert:( 16rFFFFFFFFFFFFFFFF signExtendedLongLongValue = -1 ).
+
+    "/ higher bits are ignored
+    self assert:( 16rF8000000000000000 signExtendedLongLongValue = -9223372036854775808 ).
+    self assert:( 16rF7FFFFFFFFFFFFFFF signExtendedLongLongValue = 9223372036854775807 ).  
+    self assert:( 16rFFFFFFFFFFFFFFFFF signExtendedLongLongValue = -1 ).
+
+    "/ arbitrary nr of bits
+    self assert:( 2r1000 signExtendedFromBit:4) = -8 .
+    self assert:( 2r0111 signExtendedFromBit:4) = 7 .  
+    self assert:( 2r1111 signExtendedFromBit:4) = -1 .
+
+    "Created: / 21-07-2017 / 15:15:53 / cg"
+!
+
 testZigZagCoding
     "zigzag is used by google's protocol buffer encoding"
     
@@ -5283,6 +5117,207 @@
 
 !IntegerTest methodsFor:'tests-misc'!
 
+testBinco
+     self assert: (10 binomialCoefficient:5) = (10 factorial / (5 factorial * 5 factorial)).
+     self assert: (100 binomialCoefficient:78) = (100 factorial / (78 factorial * (100-78) factorial)).
+     self assert: (1000 binomialCoefficient:5) = (1000 factorial / (5 factorial * (1000-5) factorial)).
+     self assert: (10000 binomialCoefficient:78) = (10000 factorial / (78 factorial * (10000-78) factorial)).
+     self assert: (0 binomialCoefficient:0) = 1.
+     self assert: (10 binomialCoefficient:10) = 1.
+
+    "
+     self basicNew testBinco
+    "
+!
+
+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:(0 factorial = 1).
+    self assert:(1 factorial = 1).
+    self assert:(2 factorial = 2).
+    self assert:(10 factorial = 3628800).
+    self assert:(11 factorial = 39916800).
+    self assert:(12 factorial = 479001600).
+    self assert:(13 factorial digitBytes = #[0 204 40 115 1]).
+    self assert:(13 factorial = 6227020800).
+    self assert:(14 factorial digitBytes = #[0 40 59 76 20]).
+    self assert:(14 factorial = 87178291200).
+    self assert:(15 factorial digitBytes = #[0 88 119 119 48 1]).
+    self assert:(15 factorial = 1307674368000).
+    self assert:(16 factorial digitBytes = #[0 128 117 119 7 19]).
+    self assert:(16 factorial = 20922789888000).
+    self assert:(17 factorial digitBytes = #[0 128 205 238 126 67 1]).
+    self assert:(17 factorial = 355687428096000).
+    self assert:(18 factorial digitBytes = #[0 0 115 202 236 190 22]).
+    self assert:(18 factorial = 6402373705728000).
+    self assert:(19 factorial digitBytes = #[0 0 137 6 147 43 176 1]).
+    self assert:(19 factorial = 121645100408832000).
+    self assert:(20 factorial digitBytes = #[0 0 180 130 124 103 195 33]).
+    self assert:(20 factorial = 2432902008176640000).
+    self assert:(50 factorial = 30414093201713378043612608166064768844377641568960512000000000000).
+
+    "
+     self basicNew testFactorial
+    "
+
+    "Created: / 24-04-2010 / 13:52:23 / cg"
+    "Modified: / 26-02-2016 / 15:43:16 / 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 assert:(20 factorial gcd:(5*6*7)) = (5*6*7).
+    self assert:(20 factorial gcd:(20 factorial / 20)) = (19 factorial).
+
+    "
+     self basicNew testGCD
+    "
+
+    "Created: / 27-04-2010 / 09:49:31 / cg"
+!
+
+testIsPowerOfTwo
+    self assert:(1 isPowerOfTwo).
+    self assert:(2 isPowerOfTwo).
+    self assert:(4 isPowerOfTwo).
+    self assert:(3 isPowerOfTwo not).
+    self assert:(16r100000000000000000000000 isPowerOfTwo).
+    self assert:(16r300000000000000000000000 isPowerOfTwo not).
+
+    "
+     self basicNew testIsPowerOfTwo
+    "
+
+    "Created: / 27-04-2010 / 10:35:36 / cg"
+!
+
+testNextPowerOfTwo
+    "/ self assert:(0 nextPowerOf2 = 0).
+    self assert:(1 nextPowerOf2 = 1).
+    self assert:(2 nextPowerOf2 = 2).
+    self assert:(3 nextPowerOf2 = 4).
+    self assert:(4 nextPowerOf2 = 4).
+    self assert:(5 nextPowerOf2 = 8).
+    self assert:(6 nextPowerOf2 = 8).
+    self assert:(7 nextPowerOf2 = 8).
+    self assert:(8 nextPowerOf2 = 8).
+    self assert:(9 nextPowerOf2 = 16).
+
+    self assert:(22 nextPowerOf2 = 32).
+    self assert:(32 nextPowerOf2 = 32).
+    self assert:(16rFFFF nextPowerOf2 = 16r10000).  
+    self assert:(16r1FFFFFFF nextPowerOf2 = 16r20000000).  
+    self assert:(16r3FFFFFFF nextPowerOf2 = 16r40000000).  
+    self assert:(16r7FFFFFFF nextPowerOf2 = 16r80000000).  
+    self assert:(16rFFFFFFFF nextPowerOf2 = 16r100000000). 
+    self assert:(16r1FFFFFFFFFFFFFFF nextPowerOf2 = 16r2000000000000000).  
+    self assert:(16r3FFFFFFFFFFFFFFF nextPowerOf2 = 16r4000000000000000).  
+    self assert:(16r7FFFFFFFFFFFFFFF nextPowerOf2 = 16r8000000000000000).  
+    self assert:(16rFFFFFFFFFFFFFFFF nextPowerOf2 = 16r10000000000000000).  
+    self assert:(16rFFFFFFFFFFFFFFFFFFFF nextPowerOf2 = 16r100000000000000000000).  
+
+    "
+     self basicNew testNextPowerOfTwo
+    "
+!
+
+testProduct
+    self assert:(1 to:1) product = 1.
+    self assert:(1 to:100) product = 100 factorial.
+    self assert:(1 to:0) product = 1.
+
+    self assert:(1 to:1) asArray product = 1.
+    self assert:(1 to:100) asArray product = 100 factorial.
+    self assert:#() product = 1.
+    self assert:#(2) product = 2.
+
+    "
+     self basicNew testSum
+    "
+!
+
+testSum
+    self assert:(1 to:1) sum = 1.
+    self assert:(1 to:100) sum = 5050.
+    self assert:(1 to:0) sum = 0.
+
+    self assert:(1 to:1) asArray sum = 1.
+    self assert:(1 to:100) asArray sum = 5050.
+    self assert:#() sum = 0.
+    self assert:#(2) sum = 2.
+
+    "
+     self basicNew testSum
+    "
+!
+
 test_primes
     self 
         assert: ((1 to: 30) select: [:i | i isPrime] as:Array)