diff options
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/mathop.test | 381 |
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 |