More tests for bitops

1 files changed, 344 insertions, 37 deletions

diff --git a/tests/mathop.test b/tests/mathop.test
index 09e1c71..66c7221 100644
--- a/tests/mathop.test
+++ b/tests/mathop.test
@@ -10,7 +10,7 @@
 # See the file "license.terms" for information on usage and redistribution of
 # this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: mathop.test,v 1.4 2006/12/07 16:12:04 dgp Exp $
+# RCS: @(#) $Id: mathop.test,v 1.5 2006/12/08 10:59:45 dkf Exp $
 
 if {[lsearch [namespace children] ::tcltest] == -1} {
     package require tcltest 2.1
@@ -366,24 +366,360 @@ namespace eval ::testmathop {
     } -returnCodes error -result foobar
     test mathop-5.20 {interpreted eq} {$op NaN Na NaN} 0
 
-    # TODO: & | ^  % ** << >>  - /  == != < <= > >=  ne  in ni
-
-    test mathop-6.18 {compiled /: argument processing order} -body {
+    variable big1      12135435435354435435342423948763867876
+    variable big2       2746237174783836746262564892918327847
+    variable wide1                             12345678912345
+    variable wide2                             87321847232215
+    variable small1                                     87345
+    variable small2                                     16753
+
+    test mathop-6.1 {compiled &} { & } -1
+    test mathop-6.2 {compiled &} { & 1 } 1
+    test mathop-6.3 {compiled &} { & 1 2 } 0
+    test mathop-6.4 {compiled &} { & 3 7 6 } 2
+    test mathop-6.5 {compiled &} -returnCodes error -body {
+	& 1.0 2 3
+    } -result {can't use floating-point value as operand of "&"}
+    test mathop-6.6 {compiled &} -returnCodes error -body {
+	& 1 2 3.0
+    } -result {can't use floating-point value as operand of "&"}
+    test mathop-6.7 {compiled &} { & 100000000002 18 -126 } 2
+    test mathop-6.8 {compiled &} { & 0xff 0377 333333333333 } 85
+    test mathop-6.9 {compiled &} { & 1000000000000000000002 18 -126 } 2
+    test mathop-6.10 {compiled &} { & 0xff 0377 3333333333333333333333 } 85
+    test mathop-6.11 {compiled &: errors} -returnCodes error -body {
+	& x 0
+    } -result {can't use non-numeric string as operand of "&"}
+    test mathop-6.12 {compiled &: errors} -returnCodes error -body {
+	& nan 0
+    } -result {can't use non-numeric floating-point value as operand of "&"}
+    test mathop-6.13 {compiled &: errors} -returnCodes error -body {
+	& 0 x
+    } -result {can't use non-numeric string as operand of "&"}
+    test mathop-6.14 {compiled &: errors} -returnCodes error -body {
+	& 0 nan
+    } -result {can't use non-numeric floating-point value as operand of "&"}
+    test mathop-6.15 {compiled &: errors} -returnCodes error -body {
+	& 08 0
+    } -result {can't use invalid octal number as operand of "&"}
+    test mathop-6.16 {compiled &: errors} -returnCodes error -body {
+	& 0 08
+    } -result {can't use invalid octal number as operand of "&"}
+    test mathop-6.17 {compiled &: errors} -returnCodes error -body {
+	& 0 [error expectedError]
+    } -result expectedError
+    test mathop-6.18 {compiled &: argument processing order} -body {
+	# Bytecode compilation known hard for 3+ arguments
+	list [catch {
+	    & [set x 0] [incr x] NaN [incr x] [error expected] [incr x]
+	} msg] $msg $x
+    } -result {1 expected 2}
+    set op &
+    test mathop-6.19 {interpreted &} { $op } -1
+    test mathop-6.20 {interpreted &} { $op 1 } 1
+    test mathop-6.21 {interpreted &} { $op 1 2 } 0
+    test mathop-6.22 {interpreted &} { $op 3 7 6 } 2
+    test mathop-6.23 {interpreted &} -returnCodes error -body {
+	$op 1.0 2 3
+    } -result {can't use floating-point value as operand of "&"}
+    test mathop-6.24 {interpreted &} -returnCodes error -body {
+	$op 1 2 3.0
+    } -result {can't use floating-point value as operand of "&"}
+    test mathop-6.25 {interpreted &} { $op 100000000002 18 -126 } 2
+    test mathop-6.26 {interpreted &} { $op 0xff 0377 333333333333 } 85
+    test mathop-6.27 {interpreted &} { $op 1000000000000000000002 18 -126 } 2
+    test mathop-6.28 {interpreted &} { $op 0xff 0377 3333333333333333333333 } 85
+    test mathop-6.29 {interpreted &: errors} -returnCodes error -body {
+	$op x 0
+    } -result {can't use non-numeric string as operand of "&"}
+    test mathop-6.30 {interpreted &: errors} -returnCodes error -body {
+	$op nan 0
+    } -result {can't use non-numeric floating-point value as operand of "&"}
+    test mathop-6.31 {interpreted &: errors} -returnCodes error -body {
+	$op 0 x
+    } -result {can't use non-numeric string as operand of "&"}
+    test mathop-6.32 {interpreted &: errors} -returnCodes error -body {
+	$op 0 nan
+    } -result {can't use non-numeric floating-point value as operand of "&"}
+    test mathop-6.33 {interpreted &: errors} -returnCodes error -body {
+	$op 08 0
+    } -result {can't use invalid octal number as operand of "&"}
+    test mathop-6.34 {interpreted &: errors} -returnCodes error -body {
+	$op 0 08
+    } -result {can't use invalid octal number as operand of "&"}
+    test mathop-6.35 {interpreted &: errors} -returnCodes error -body {
+	$op 0 [error expectedError]
+    } -result expectedError
+    test mathop-6.36 {interpreted &: argument processing order} -body {
+	list [catch {
+	    $op [set x 0] [incr x] NaN [incr x] [error expected] [incr x]
+	} msg] $msg $x
+    } -result {1 expected 2}
+    test mathop-6.37 {& and bignums} {
+	list [& $big1 $big2] [$op $big1 $big2]
+    } {712439449294653815890598856501796 712439449294653815890598856501796}
+    test mathop-6.38 {& and bignums} {
+	list [& $big1 $wide2] [$op $big1 $wide2]
+    } {78521450111684 78521450111684}
+    test mathop-6.39 {& and bignums} {
+	list [& $big1 $small2] [$op $big1 $small2]
+    } {96 96}
+    test mathop-6.40 {& and bignums} {
+	list [& $wide1 $big2] [$op $wide1 $big2]
+    } {2371422390785 2371422390785}
+    test mathop-6.41 {& and bignums} {
+	list [& $wide1 $wide2] [$op $wide1 $wide2]
+    } {12275881497169 12275881497169}
+    test mathop-6.42 {& and bignums} {
+	list [& $wide1 $small2] [$op $wide1 $small2]
+    } {16721 16721}
+    test mathop-6.43 {& and bignums} {
+	list [& $small1 $big2] [$op $small1 $big2]
+    } {33 33}
+    test mathop-6.44 {& and bignums} {
+	list [& $small1 $wide2] [$op $small1 $wide2]
+    } {87057 87057}
+    test mathop-6.45 {& and bignums} {
+	list [& $small1 $small2] [$op $small1 $small2]
+    } {16689 16689}
+
+    test mathop-7.1 {compiled |} { | } 0
+    test mathop-7.2 {compiled |} { | 1 } 1
+    test mathop-7.3 {compiled |} { | 1 2 } 3
+    test mathop-7.4 {compiled |} { | 3 7 6 } 7
+    test mathop-7.5 {compiled |} -returnCodes error -body {
+	| 1.0 2 3
+    } -result {can't use floating-point value as operand of "|"}
+    test mathop-7.6 {compiled |} -returnCodes error -body {
+	| 1 2 3.0
+    } -result {can't use floating-point value as operand of "|"}
+    test mathop-7.7 {compiled |} { | 100000000002 18 -126 } -110
+    test mathop-7.8 {compiled |} { | 0xff 0377 333333333333 } 333333333503
+    test mathop-7.9 {compiled |} { | 1000000000000000000002 18 -126 } -110
+    test mathop-7.10 {compiled |} { | 0xff 0377 3333333333333333333333 } 3333333333333333333503
+    test mathop-7.11 {compiled |: errors} -returnCodes error -body {
+	| x 0
+    } -result {can't use non-numeric string as operand of "|"}
+    test mathop-7.12 {compiled |: errors} -returnCodes error -body {
+	| nan 0
+    } -result {can't use non-numeric floating-point value as operand of "|"}
+    test mathop-7.13 {compiled |: errors} -returnCodes error -body {
+	| 0 x
+    } -result {can't use non-numeric string as operand of "|"}
+    test mathop-7.14 {compiled |: errors} -returnCodes error -body {
+	| 0 nan
+    } -result {can't use non-numeric floating-point value as operand of "|"}
+    test mathop-7.15 {compiled |: errors} -returnCodes error -body {
+	| 08 0
+    } -result {can't use invalid octal number as operand of "|"}
+    test mathop-7.16 {compiled |: errors} -returnCodes error -body {
+	| 0 08
+    } -result {can't use invalid octal number as operand of "|"}
+    test mathop-7.17 {compiled |: errors} -returnCodes error -body {
+	| 0 [error expectedError]
+    } -result expectedError
+    test mathop-7.18 {compiled |: argument processing order} -body {
+	# Bytecode compilation known hard for 3+ arguments
+	list [catch {
+	    | [set x 0] [incr x] NaN [incr x] [error expected] [incr x]
+	} msg] $msg $x
+    } -result {1 expected 2}
+    set op |
+    test mathop-7.19 {interpreted |} { $op } 0
+    test mathop-7.20 {interpreted |} { $op 1 } 1
+    test mathop-7.21 {interpreted |} { $op 1 2 } 3
+    test mathop-7.22 {interpreted |} { $op 3 7 6 } 7
+    test mathop-7.23 {interpreted |} -returnCodes error -body {
+	$op 1.0 2 3
+    } -result {can't use floating-point value as operand of "|"}
+    test mathop-7.24 {interpreted |} -returnCodes error -body {
+	$op 1 2 3.0
+    } -result {can't use floating-point value as operand of "|"}
+    test mathop-7.25 {interpreted |} { $op 100000000002 18 -126 } -110
+    test mathop-7.26 {interpreted |} { $op 0xff 0377 333333333333 } 333333333503
+    test mathop-7.27 {interpreted |} { $op 1000000000000000000002 18 -126 } -110
+    test mathop-7.28 {interpreted |} { $op 0xff 0377 3333333333333333333333 } 3333333333333333333503
+    test mathop-7.29 {interpreted |: errors} -returnCodes error -body {
+	$op x 0
+    } -result {can't use non-numeric string as operand of "|"}
+    test mathop-7.30 {interpreted |: errors} -returnCodes error -body {
+	$op nan 0
+    } -result {can't use non-numeric floating-point value as operand of "|"}
+    test mathop-7.31 {interpreted |: errors} -returnCodes error -body {
+	$op 0 x
+    } -result {can't use non-numeric string as operand of "|"}
+    test mathop-7.32 {interpreted |: errors} -returnCodes error -body {
+	$op 0 nan
+    } -result {can't use non-numeric floating-point value as operand of "|"}
+    test mathop-7.33 {interpreted |: errors} -returnCodes error -body {
+	$op 08 0
+    } -result {can't use invalid octal number as operand of "|"}
+    test mathop-7.34 {interpreted |: errors} -returnCodes error -body {
+	$op 0 08
+    } -result {can't use invalid octal number as operand of "|"}
+    test mathop-7.35 {interpreted |: errors} -returnCodes error -body {
+	$op 0 [error expectedError]
+    } -result expectedError
+    test mathop-7.36 {interpreted |: argument processing order} -body {
+	list [catch {
+	    $op [set x 0] [incr x] NaN [incr x] [error expected] [incr x]
+	} msg] $msg $x
+    } -result {1 expected 2}
+    test mathop-7.37 {| and bignums} {
+	list [| $big1 $big2] [$op $big1 $big2]
+    } {14880960170688977527789098242825693927 14880960170688977527789098242825693927}
+    test mathop-7.38 {| and bignums} {
+	list [| $big1 $wide2] [$op $big1 $wide2]
+    } {12135435435354435435342432749160988407 12135435435354435435342432749160988407}
+    test mathop-7.39 {| and bignums} {
+	list [| $big1 $small2] [$op $big1 $small2]
+    } {12135435435354435435342423948763884533 12135435435354435435342423948763884533}
+    test mathop-7.40 {| and bignums} {
+	list [| $wide1 $big2] [$op $wide1 $big2]
+    } {2746237174783836746262574867174849407 2746237174783836746262574867174849407}
+    test mathop-7.41 {| and bignums} {
+	list [| $wide1 $wide2] [$op $wide1 $wide2]
+    } {87391644647391 87391644647391}
+    test mathop-7.42 {| and bignums} {
+	list [| $wide1 $small2] [$op $wide1 $small2]
+    } {12345678912377 12345678912377}
+    test mathop-7.43 {| and bignums} {
+	list [| $small1 $big2] [$op $small1 $big2]
+    } {2746237174783836746262564892918415159 2746237174783836746262564892918415159}
+    test mathop-7.44 {| and bignums} {
+	list [| $small1 $wide2] [$op $small1 $wide2]
+    } {87321847232503 87321847232503}
+    test mathop-7.45 {| and bignums} {
+	list [| $small1 $small2] [$op $small1 $small2]
+    } {87409 87409}
+
+    test mathop-8.1 {compiled ^} { ^ } 0
+    test mathop-8.2 {compiled ^} { ^ 1 } 1
+    test mathop-8.3 {compiled ^} { ^ 1 2 } 3
+    test mathop-8.4 {compiled ^} { ^ 3 7 6 } 2
+    test mathop-8.5 {compiled ^} -returnCodes error -body {
+	^ 1.0 2 3
+    } -result {can't use floating-point value as operand of "^"}
+    test mathop-8.6 {compiled ^} -returnCodes error -body {
+	^ 1 2 3.0
+    } -result {can't use floating-point value as operand of "^"}
+    test mathop-8.7 {compiled ^} { ^ 100000000002 18 -126 } -100000000110
+    test mathop-8.8 {compiled ^} { ^ 0xff 0377 333333333333 } 333333333333
+    test mathop-8.9 {compiled ^} { ^ 1000000000000000000002 18 -126 } -1000000000000000000110
+    test mathop-8.10 {compiled ^} { ^ 0xff 0377 3333333333333333333333 } 3333333333333333333333
+    test mathop-8.11 {compiled ^: errors} -returnCodes error -body {
+	^ x 0
+    } -result {can't use non-numeric string as operand of "^"}
+    test mathop-8.12 {compiled ^: errors} -returnCodes error -body {
+	^ nan 0
+    } -result {can't use non-numeric floating-point value as operand of "^"}
+    test mathop-8.13 {compiled ^: errors} -returnCodes error -body {
+	^ 0 x
+    } -result {can't use non-numeric string as operand of "^"}
+    test mathop-8.14 {compiled ^: errors} -returnCodes error -body {
+	^ 0 nan
+    } -result {can't use non-numeric floating-point value as operand of "^"}
+    test mathop-8.15 {compiled ^: errors} -returnCodes error -body {
+	^ 08 0
+    } -result {can't use invalid octal number as operand of "^"}
+    test mathop-8.16 {compiled ^: errors} -returnCodes error -body {
+	^ 0 08
+    } -result {can't use invalid octal number as operand of "^"}
+    test mathop-8.17 {compiled ^: errors} -returnCodes error -body {
+	^ 0 [error expectedError]
+    } -result expectedError
+    test mathop-8.18 {compiled ^: argument processing order} -body {
+	# Bytecode compilation known hard for 3+ arguments
+	list [catch {
+	    ^ [set x 0] [incr x] NaN [incr x] [error expected] [incr x]
+	} msg] $msg $x
+    } -result {1 expected 2}
+    set op ^
+    test mathop-8.19 {interpreted ^} { $op } 0
+    test mathop-8.20 {interpreted ^} { $op 1 } 1
+    test mathop-8.21 {interpreted ^} { $op 1 2 } 3
+    test mathop-8.22 {interpreted ^} { $op 3 7 6 } 2
+    test mathop-8.23 {interpreted ^} -returnCodes error -body {
+	$op 1.0 2 3
+    } -result {can't use floating-point value as operand of "^"}
+    test mathop-8.24 {interpreted ^} -returnCodes error -body {
+	$op 1 2 3.0
+    } -result {can't use floating-point value as operand of "^"}
+    test mathop-8.25 {interpreted ^} { $op 100000000002 18 -126 } -100000000110
+    test mathop-8.26 {interpreted ^} { $op 0xff 0377 333333333333 } 333333333333
+    test mathop-8.27 {interpreted ^} { $op 1000000000000000000002 18 -126 } -1000000000000000000110
+    test mathop-8.28 {interpreted ^} { $op 0xff 0377 3333333333333333333333 } 3333333333333333333333
+    test mathop-8.29 {interpreted ^: errors} -returnCodes error -body {
+	$op x 0
+    } -result {can't use non-numeric string as operand of "^"}
+    test mathop-8.30 {interpreted ^: errors} -returnCodes error -body {
+	$op nan 0
+    } -result {can't use non-numeric floating-point value as operand of "^"}
+    test mathop-8.31 {interpreted ^: errors} -returnCodes error -body {
+	$op 0 x
+    } -result {can't use non-numeric string as operand of "^"}
+    test mathop-8.32 {interpreted ^: errors} -returnCodes error -body {
+	$op 0 nan
+    } -result {can't use non-numeric floating-point value as operand of "^"}
+    test mathop-8.33 {interpreted ^: errors} -returnCodes error -body {
+	$op 08 0
+    } -result {can't use invalid octal number as operand of "^"}
+    test mathop-8.34 {interpreted ^: errors} -returnCodes error -body {
+	$op 0 08
+    } -result {can't use invalid octal number as operand of "^"}
+    test mathop-8.35 {interpreted ^: errors} -returnCodes error -body {
+	$op 0 [error expectedError]
+    } -result expectedError
+    test mathop-8.36 {interpreted ^: argument processing order} -body {
+	list [catch {
+	    $op [set x 0] [incr x] NaN [incr x] [error expected] [incr x]
+	} msg] $msg $x
+    } -result {1 expected 2}
+    test mathop-8.37 {^ and bignums} {
+	list [^ $big1 $big2] [$op $big1 $big2]
+    } {14880247731239682873973207643969192131 14880247731239682873973207643969192131}
+    test mathop-8.38 {^ and bignums} {
+	list [^ $big1 $wide2] [$op $big1 $wide2]
+    } {12135435435354435435342354227710876723 12135435435354435435342354227710876723}
+    test mathop-8.39 {^ and bignums} {
+	list [^ $big1 $small2] [$op $big1 $small2]
+    } {12135435435354435435342423948763884437 12135435435354435435342423948763884437}
+    test mathop-8.40 {^ and bignums} {
+	list [^ $wide1 $big2] [$op $wide1 $big2]
+    } {2746237174783836746262572495752458622 2746237174783836746262572495752458622}
+    test mathop-8.41 {^ and bignums} {
+	list [^ $wide1 $wide2] [$op $wide1 $wide2]
+    } {75115763150222 75115763150222}
+    test mathop-8.42 {^ and bignums} {
+	list [^ $wide1 $small2] [$op $wide1 $small2]
+    } {12345678895656 12345678895656}
+    test mathop-8.43 {^ and bignums} {
+	list [^ $small1 $big2] [$op $small1 $big2]
+    } {2746237174783836746262564892918415126 2746237174783836746262564892918415126}
+    test mathop-8.44 {^ and bignums} {
+	list [^ $small1 $wide2] [$op $small1 $wide2]
+    } {87321847145446 87321847145446}
+    test mathop-8.45 {^ and bignums} {
+	list [^ $small1 $small2] [$op $small1 $small2]
+    } {70720 70720}
+
+    # TODO: % ** << >>  - /  == != < <= > >=  ne  in ni
+
+    test mathop-13.100 {compiled -: argument processing order} -body {
       # Bytecode compilation known hard for 3+ arguments
       list [catch {
-          / [set x 0] [incr x] NaN [incr x] [error expected] [incr x]
+          - [set x 0] [incr x] NaN [incr x] [error expected] [incr x]
       } msg] $msg $x
     } -result {1 expected 2}
 
-    test mathop-7.18 {compiled -: argument processing order} -body {
+    test mathop-14.100 {compiled /: argument processing order} -body {
       # Bytecode compilation known hard for 3+ arguments
       list [catch {
-          - [set x 0] [incr x] NaN [incr x] [error expected] [incr x]
+          / [set x 0] [incr x] NaN [incr x] [error expected] [incr x]
       } msg] $msg $x
     } -result {1 expected 2}
 }
 
-
 test mathop-20.1 { zero args, return unit } {
     set res {}
     foreach op {+ * & ^ | ** < <= > >= == eq} {
@@ -391,7 +727,6 @@ test mathop-20.1 { zero args, return unit } {
     }
     set res
 } {0 1 -1 0 0 1 1 1 1 1 1 1}
-
 test mathop-20.2 { zero args, not allowed } {
     set exp {}
     foreach op {~ ! << >> % != ne in ni - /} {
@@ -404,7 +739,6 @@ test mathop-20.2 { zero args, not allowed } {
     }
     set exp
 } {0 0 0 0 0 0 0 0 0 0 0}
-
 test mathop-20.3 { one arg } {
     set res {}
     foreach val {7 8.3} {
@@ -415,7 +749,6 @@ test mathop-20.3 { one arg } {
     set res
 } [list 7   7   -7   7   [expr {1.0/7.0}] 1 1 1 1 1 1 0 \
         8.3 8.3 -8.3 8.3 [expr {1.0/8.3}] 1 1 1 1 1 1 0]
-
 test mathop-20.4 { one arg, integer only ops } {
     set res {}
     foreach val {23} {
@@ -425,7 +758,6 @@ test mathop-20.4 { one arg, integer only ops } {
     }
     set res
 } [list 23 23 23 -24]
-
 test mathop-20.5 { one arg, not allowed } {
     set exp {}
     foreach op {% != ne in ni << >>} {
@@ -438,7 +770,6 @@ test mathop-20.5 { one arg, not allowed } {
     }
     set exp
 } {0 0 0 0 0 0 0}
-
 test mathop-20.6 { one arg, error } {
     set res {}
     set exp {}
@@ -451,7 +782,6 @@ test mathop-20.6 { one arg, error } {
     }
     expr {$res eq $exp ? 0 : $res}
 } 0
-
 test mathop-20.7 { multi arg } {
     set res {}
     foreach vals {{1 2} {3 4 5} {4 3 2 1}} {
@@ -461,7 +791,6 @@ test mathop-20.7 { multi arg } {
     }
     set res
 } [list 3 -1 2 0  12 -6 60 0  10 -2 24 0]
-
 test mathop-20.8 { multi arg, double } {
     set res {}
     foreach vals {{1.0 2} {3.0 4 5} {4 3.0 2 1}} {
@@ -480,7 +809,6 @@ test mathop-21.1 { unary ops, bitnot } {
     lappend res [TestOp ~ 123456789123456789123456789]
     set res
 } [list -8 4 -354657483923457 -123456789123456789123456790]
-
 test mathop-21.2 { unary ops, logical not } {
     set res {}
     lappend res [TestOp ! 0]
@@ -491,7 +819,6 @@ test mathop-21.2 { unary ops, logical not } {
     lappend res [TestOp ! 8.5]
     set res
 } [list 1 0 0 1 0 0]
-
 test mathop-21.3 { unary ops, negation } {
     set res {}
     lappend res [TestOp -  7.2]
@@ -503,7 +830,6 @@ test mathop-21.3 { unary ops, negation } {
     set res
 } [list -7.2 5 2147483648 9223372036854775808 -354657483923456 \
            -123456789123456789123456789]
-
 test mathop-21.4 { unary ops, inversion } {
     set res {}
     lappend res [TestOp / 1]
@@ -515,7 +841,6 @@ test mathop-21.4 { unary ops, inversion } {
     set res
 } [list 1.0 0.2 0.17857142857142858 -0.125 \
            2.8196218755553604e-15 8.10000006561e-27]
-
 test mathop-21.5 { unary ops, bad values } {
     set res {}
     set exp {}
@@ -531,7 +856,6 @@ test mathop-21.5 { unary ops, bad values } {
     lappend exp "can't use floating-point value as operand of \"~\" NONE"
     expr {$res eq $exp ? 0 : $res}
 } 0
-
 test mathop-21.6 { unary ops, too many } {
     set exp {}
     foreach op {~ !} {
@@ -554,7 +878,6 @@ test mathop-22.1 { bitwise ops } {
     }
     set res
 } [list 5 5 5  0 7 7  0 3 0  0 7 4]
-
 test mathop-22.2 { bitwise ops on bignums } {
     set dig 50
     set a 0x[string repeat 5 $dig]
@@ -582,7 +905,6 @@ test mathop-22.2 { bitwise ops on bignums } {
     }
     expr {$exp eq $res ? 1 : "($res != $exp"}
 } 1
-
 test mathop-22.3 { bitwise ops } {
     set big1      12135435435354435435342423948763867876
     set big2       2746237174783836746262564892918327847
@@ -633,7 +955,6 @@ test mathop-22.3 { bitwise ops } {
            87321847145446 \
            70720 \
           ]
-
 test mathop-22.4 { unary ops, bad values } {
     set res {}
     set exp {}
@@ -679,7 +1000,6 @@ test mathop-23.1 { comparison ops, numerical } {
         1 1 0 0 0 0 \
         0 1 0 1 1 1 \
        ]
-
 test mathop-23.2 { comparison ops, string } {
     set res {}
     set todo {a {a b} {5 b b c} {d c b a} {xy xy} {gy ef ef ab}}
@@ -699,7 +1019,6 @@ test mathop-23.2 { comparison ops, string } {
         0 0 0 1 0 0 \
         0 1 0 1 1 1 \
        ]
-
 test mathop-23.3 { comparison ops, nonequal} {
     set res {}
     foreach vals {{a b} {17.0 0x11} {foo foo} {10 10}} {
@@ -722,7 +1041,6 @@ test mathop-24.1 { binary ops } {
 } [list 3 96 0 0 1  3 2176 0 0 1  4 6368 6 0 1 \
         14 38434855421664852505557661908992 2237203031642412097749 0 1 \
         0 10 2 0 1  0 0 0 0 1]
-
 test mathop-24.2 { binary ops, modulo } {
     # Test different combinations to get all code paths
     set res {}
@@ -752,7 +1070,6 @@ test mathop-24.2 { binary ops, modulo } {
                                  12345678912340 \
                                               0 \
           ]
-
 test mathop-24.3 { binary ops, bad values } {
     set res {}
     set exp {}
@@ -782,7 +1099,6 @@ test mathop-24.3 { binary ops, bad values } {
     lappend exp "divide by zero ARITH DIVZERO {divide by zero}"
     expr {$res eq $exp ? 0 : $res}
 } 0
-
 test mathop-24.4 { binary ops, negative shift } {
     set res {}
 
@@ -800,7 +1116,6 @@ test mathop-24.4 { binary ops, negative shift } {
     set exp [lrepeat 6 "negative shift argument NONE"]
     expr {$res eq $exp ? 0 : $res}
 } 0
-
 test mathop-24.5 { binary ops, large shift } {
     set res {}
     set exp {}
@@ -838,7 +1153,6 @@ test mathop-24.5 { binary ops, large shift } {
 
     expr {$res eq $exp ? 0 : $res}
 } 0
-
 test mathop-24.6 { binary ops, shift } {
     # Test different combinations to get all code paths
     set res {}
@@ -856,7 +1170,6 @@ test mathop-24.6 { binary ops, shift } {
 } [list   395061725195040 \
              385802466010 \
           ]
-
 test mathop-24.7 { binary ops, list search } {
     set res {}
 
@@ -867,7 +1180,6 @@ test mathop-24.7 { binary ops, list search } {
     }
     set res
 } [list 1 1 0  0 0 1]
-
 test mathop-24.8 { binary ops, too many } {
     set exp {}
     foreach op {<< >> % != ne in ni ~ !} {
@@ -881,7 +1193,6 @@ test mathop-24.8 { binary ops, too many } {
     set exp
 } {0 0 0 0 0 0 0 0 0}
 
-
 test mathop-25.1  { exp operator } {TestOp **        } 1
 test mathop-25.2  { exp operator } {TestOp **   0    } 0
 test mathop-25.3  { exp operator } {TestOp **   0   5} 0
@@ -904,7 +1215,6 @@ test mathop-25.19 { exp operator } {TestOp **  -1   3} -1
 test mathop-25.20 { exp operator } {TestOp **  -1   4} 1
 test mathop-25.21 { exp operator } {TestOp **   2  63} 9223372036854775808
 test mathop-25.22 { exp operator } {TestOp ** 83756485763458746358734658473567847567473 2} 7015148907444467657897585474493757781161998914521537835809623408157343003287605729
-
 test mathop-25.23 { exp operator errors } {
     set res {}
     set exp {}
@@ -932,7 +1242,6 @@ test mathop-25.23 { exp operator errors } {
     expr {$res eq $exp ? 0 : $res}
 } 0
 
-
 test mathop-26.1 { misc ops, size combinations } {
     set big1      12135435435354435435342423948763867876
     set big2       2746237174783836746262564892918327847
@@ -992,7 +1301,6 @@ test mathop-26.1 { misc ops, size combinations } {
            0 \
            5 \
           ]
-
 test mathop-26.2 { misc ops, corner cases } {
     set res {}
     lappend res [TestOp - 0 -2147483648]                  ;# -2**31
@@ -1014,7 +1322,6 @@ if 0 {
     set ::tcl_traceCompile 2
     _X 3 4 5
     set ::tcl_traceCompile 0
-
 }
 
 # cleanup