From c475df7cfbfab932ff2a21678fa244094c7c49ee Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Thu, 16 Aug 2018 18:54:44 +0000
Subject: Undo various test-case changes, in order to prove platform
 compatibility

---
 tests/compExpr-old.test |   8 +-
 tests/execute.test      |  15 ++--
 tests/expr.test         | 224 +++++++++++++++++++++++++-----------------------
 tests/format.test       |  15 ++--
 tests/obj.test          |  24 +++---
 tests/scan.test         |   4 +-
 6 files changed, 155 insertions(+), 135 deletions(-)

diff --git a/tests/compExpr-old.test b/tests/compExpr-old.test
index 267b228..0136ccd 100644
--- a/tests/compExpr-old.test
+++ b/tests/compExpr-old.test
@@ -78,6 +78,9 @@ proc testIEEE {} {
 }
 testConstraint ieeeFloatingPoint [testIEEE]
 
+testConstraint longIs32bit [expr {int(0x80000000) < 0}]
+testConstraint longIs64bit [expr {int(0x8000000000000000) < 0}]
+
 # procedures used below
 
 proc put_hello_char {c} {
@@ -332,9 +335,12 @@ test compExpr-old-9.4 {CompileRelationalExpr: just shift expr} {expr {1<<3}} 8
 # The following test is different for 32-bit versus 64-bit
 # architectures because LONG_MIN is different
 
-test compExpr-old-9.5 {CompileRelationalExpr: shift expr producing LONG_MIN} {
+test compExpr-old-9.5a {CompileRelationalExpr: shift expr producing LONG_MIN} longIs64bit {
     expr {int(1<<63)}
 } -9223372036854775808
+test compExpr-old-9.5b {CompileRelationalExpr: shift expr producing LONG_MIN} longIs32bit {
+    expr {int(1<<31)}
+} -2147483648
 
 test compExpr-old-9.6 {CompileRelationalExpr: error in shift expr} -body {
     expr x>>3
diff --git a/tests/execute.test b/tests/execute.test
index ac97c6c..6c277f8 100644
--- a/tests/execute.test
+++ b/tests/execute.test
@@ -34,6 +34,7 @@ testConstraint testobj [expr {
     && [llength [info commands teststringobj]]
 }]
 
+testConstraint longIs32bit [expr {int(0x80000000) < 0}]
 testConstraint testexprlongobj [llength [info commands testexprlongobj]]
 
 # Tests for the omnibus TclExecuteByteCode function:
@@ -804,9 +805,9 @@ test execute-7.7 {Wide int handling in INST_EQ and [incr]} {
     set y [expr {$x+1}]
     expr {double($x) == double($y)}
 } 1
-test execute-7.8 {Wide int conversions can change sign} {
-    set x 0x8000000000000000
-    expr {int($x) < $x}
+test execute-7.8 {Wide int conversions can change sign} longIs32bit {
+    set x 0x80000000
+    expr {int($x) < wide($x)}
 } 1
 test execute-7.9 {Wide int handling in INST_MOD} {
     expr {(wide(1)<<60) % ((wide(47)<<45)-1)}
@@ -886,11 +887,11 @@ test execute-7.31 {Wide int handling in abs()} {
     set y 0x123456871234568
     concat [expr {abs($x)}] [expr {abs($y)}]
 } {730503879441204585 81985533099853160}
-test execute-7.32 {Wide int handling} {
-    expr {int(1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024)}
+test execute-7.32 {Wide int handling} longIs32bit {
+    expr {int(1024 * 1024 * 1024 * 1024)}
 } 0
-test execute-7.33 {Wide int handling} {
-    expr {int(0x1 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024)}
+test execute-7.33 {Wide int handling} longIs32bit {
+    expr {int(0x1 * 1024 * 1024 * 1024 * 1024)}
 } 0
 test execute-7.34 {Wide int handling} {
     expr {wide(0x1) * 1024 * 1024 * 1024 * 1024}
diff --git a/tests/expr.test b/tests/expr.test
index 9f36823..713681a 100644
--- a/tests/expr.test
+++ b/tests/expr.test
@@ -18,10 +18,13 @@ if {[lsearch [namespace children] ::tcltest] == -1} {
 ::tcltest::loadTestedCommands
 catch [list package require -exact Tcltest [info patchlevel]]
 
-# Determine if "long int" type is a 32 bit number.
+# Determine if "long int" type is a 32 bit number and if the wide
+# type is a 64 bit number on this machine.
 
 testConstraint longIs32bit [expr {int(0x80000000) < 0}]
 testConstraint longIs64bit [expr {int(0x8000000000000000) < 0}]
+testConstraint wideIs64bit \
+	[expr {(wide(0x80000000) > 0) && (wide(0x8000000000000000) < 0)}]
 
 # Big test for correct ordering of data in [expr]
 
@@ -414,9 +417,12 @@ test expr-9.1 {CompileRelationalExpr: just shift expr} {expr 3<<2} 12
 test expr-9.2 {CompileRelationalExpr: just shift expr} {expr 0xff>>2} 63
 test expr-9.3 {CompileRelationalExpr: just shift expr} {expr -1>>2} -1
 test expr-9.4 {CompileRelationalExpr: just shift expr} {expr {1<<3}} 8
-test expr-9.5 {CompileRelationalExpr: shift expr producing LONG_MIN} {
+test expr-9.5a {CompileRelationalExpr: shift expr producing LONG_MIN} longIs64bit {
     expr {int(1<<63)}
 } -9223372036854775808
+test expr-9.5b {CompileRelationalExpr: shift expr producing LONG_MIN} longIs32bit {
+    expr {int(1<<31)}
+} -2147483648
 test expr-9.6 {CompileRelationalExpr: error in shift expr} -body {
     expr x>>3
 } -returnCodes error -match glob -result *
@@ -5840,7 +5846,7 @@ test expr-33.2 {parse smallest long value} longIs32bit {
         [expr {int(-2147483648 - 1) == 0x7FFFFFFF}] \
 
 } {-2147483648 -2147483648 -2147483648 -2147483648 1 1}
-test expr-33.3 {parse largest wide value} {
+test expr-33.3 {parse largest wide value} wideIs64bit {
     set max_wide_str 9223372036854775807
     set max_wide_hex "0x7FFFFFFFFFFFFFFF "
 
@@ -5857,7 +5863,7 @@ test expr-33.3 {parse largest wide value} {
         [expr {wide(9223372036854775807 + 1) < 0}] \
 
 } {9223372036854775807 9223372036854775807 9223372036854775807 9223372036854775807 1 1}
-test expr-33.4 {parse smallest wide value} {
+test expr-33.4 {parse smallest wide value} wideIs64bit {
     set min_wide_str -9223372036854775808
     set min_wide_hex "-0x8000000000000000 "
 
@@ -6265,341 +6271,341 @@ test expr-35.14 {expr edge cases} {
 set min -9223372036854775808
 set max 9223372036854775807
 
-test expr-36.1 {expr edge cases} {
+test expr-36.1 {expr edge cases} {wideIs64bit} {
     expr {$min / $min}
 } {1}
-test expr-36.2 {expr edge cases} {
+test expr-36.2 {expr edge cases} {wideIs64bit} {
     expr {$min % $min}
 } {0}
-test expr-36.3 {expr edge cases} {
+test expr-36.3 {expr edge cases} {wideIs64bit} {
     expr {$min / ($min + 1)}
 } {1}
-test expr-36.4 {expr edge cases} {
+test expr-36.4 {expr edge cases} {wideIs64bit} {
     expr {$min % ($min + 1)}
 } {-1}
-test expr-36.5 {expr edge cases} {
+test expr-36.5 {expr edge cases} {wideIs64bit} {
     expr {$min / ($min + 2)}
 } {1}
-test expr-36.6 {expr edge cases} {
+test expr-36.6 {expr edge cases} {wideIs64bit} {
     expr {$min % ($min + 2)}
 } {-2}
-test expr-36.7 {expr edge cases} {
+test expr-36.7 {expr edge cases} {wideIs64bit} {
     expr {$min / ($min + 3)}
 } {1}
-test expr-36.8 {expr edge cases} {
+test expr-36.8 {expr edge cases} {wideIs64bit} {
     expr {$min % ($min + 3)}
 } {-3}
-test expr-36.9 {expr edge cases} {
+test expr-36.9 {expr edge cases} {wideIs64bit} {
     expr {$min / -3}
 } {3074457345618258602}
-test expr-36.10 {expr edge cases} {
+test expr-36.10 {expr edge cases} {wideIs64bit} {
     expr {$min % -3}
 } {-2}
-test expr-36.11 {expr edge cases} {
+test expr-36.11 {expr edge cases} {wideIs64bit} {
     expr {$min / -2}
 } {4611686018427387904}
-test expr-36.12 {expr edge cases} {
+test expr-36.12 {expr edge cases} {wideIs64bit} {
     expr {$min % -2}
 } {0}
-test expr-36.13 {expr edge cases} {
+test expr-36.13 {expr edge cases} wideIs64bit {
     expr {wide($min / -1)}
 } $min
-test expr-36.14 {expr edge cases} {
+test expr-36.14 {expr edge cases} {wideIs64bit} {
     expr {$min % -1}
 } {0}
-test expr-36.15 {expr edge cases} {
+test expr-36.15 {expr edge cases} wideIs64bit {
     expr {wide($min * -1)}
 } $min
-test expr-36.16 {expr edge cases} {
+test expr-36.16 {expr edge cases} wideIs64bit {
     expr {wide(-$min)}
 } $min
-test expr-36.17 {expr edge cases} {
+test expr-36.17 {expr edge cases} {wideIs64bit} {
     expr {$min / 1}
 } $min
-test expr-36.18 {expr edge cases} {
+test expr-36.18 {expr edge cases} {wideIs64bit} {
     expr {$min % 1}
 } {0}
-test expr-36.19 {expr edge cases} {
+test expr-36.19 {expr edge cases} {wideIs64bit} {
     expr {$min / 2}
 } {-4611686018427387904}
-test expr-36.20 {expr edge cases} {
+test expr-36.20 {expr edge cases} {wideIs64bit} {
     expr {$min % 2}
 } {0}
-test expr-36.21 {expr edge cases} {
+test expr-36.21 {expr edge cases} {wideIs64bit} {
     expr {$min / 3}
 } {-3074457345618258603}
-test expr-36.22 {expr edge cases} {
+test expr-36.22 {expr edge cases} {wideIs64bit} {
     expr {$min % 3}
 } {1}
-test expr-36.23 {expr edge cases} {
+test expr-36.23 {expr edge cases} {wideIs64bit} {
     expr {$min / ($max - 3)}
 } {-2}
-test expr-36.24 {expr edge cases} {
+test expr-36.24 {expr edge cases} {wideIs64bit} {
     expr {$min % ($max - 3)}
 } {9223372036854775800}
-test expr-36.25 {expr edge cases} {
+test expr-36.25 {expr edge cases} {wideIs64bit} {
     expr {$min / ($max - 2)}
 } {-2}
-test expr-36.26 {expr edge cases} {
+test expr-36.26 {expr edge cases} {wideIs64bit} {
     expr {$min % ($max - 2)}
 } {9223372036854775802}
-test expr-36.27 {expr edge cases} {
+test expr-36.27 {expr edge cases} {wideIs64bit} {
     expr {$min / ($max - 1)}
 } {-2}
-test expr-36.28 {expr edge cases} {
+test expr-36.28 {expr edge cases} {wideIs64bit} {
     expr {$min % ($max - 1)}
 } {9223372036854775804}
-test expr-36.29 {expr edge cases} {
+test expr-36.29 {expr edge cases} {wideIs64bit} {
     expr {$min / $max}
 } {-2}
-test expr-36.30 {expr edge cases} {
+test expr-36.30 {expr edge cases} {wideIs64bit} {
     expr {$min % $max}
 } {9223372036854775806}
-test expr-36.31 {expr edge cases} {
+test expr-36.31 {expr edge cases} {wideIs64bit} {
     expr {$max / $max}
 } {1}
-test expr-36.32 {expr edge cases} {
+test expr-36.32 {expr edge cases} {wideIs64bit} {
     expr {$max % $max}
 } {0}
-test expr-36.33 {expr edge cases} {
+test expr-36.33 {expr edge cases} {wideIs64bit} {
     expr {$max / ($max - 1)}
 } {1}
-test expr-36.34 {expr edge cases} {
+test expr-36.34 {expr edge cases} {wideIs64bit} {
     expr {$max % ($max - 1)}
 } {1}
-test expr-36.35 {expr edge cases} {
+test expr-36.35 {expr edge cases} {wideIs64bit} {
     expr {$max / ($max - 2)}
 } {1}
-test expr-36.36 {expr edge cases} {
+test expr-36.36 {expr edge cases} {wideIs64bit} {
     expr {$max % ($max - 2)}
 } {2}
-test expr-36.37 {expr edge cases} {
+test expr-36.37 {expr edge cases} {wideIs64bit} {
     expr {$max / ($max - 3)}
 } {1}
-test expr-36.38 {expr edge cases} {
+test expr-36.38 {expr edge cases} {wideIs64bit} {
     expr {$max % ($max - 3)}
 } {3}
-test expr-36.39 {expr edge cases} {
+test expr-36.39 {expr edge cases} {wideIs64bit} {
     expr {$max / 3}
 } {3074457345618258602}
-test expr-36.40 {expr edge cases} {
+test expr-36.40 {expr edge cases} {wideIs64bit} {
     expr {$max % 3}
 } {1}
-test expr-36.41 {expr edge cases} {
+test expr-36.41 {expr edge cases} {wideIs64bit} {
     expr {$max / 2}
 } {4611686018427387903}
-test expr-36.42 {expr edge cases} {
+test expr-36.42 {expr edge cases} {wideIs64bit} {
     expr {$max % 2}
 } {1}
-test expr-36.43 {expr edge cases} {
+test expr-36.43 {expr edge cases} {wideIs64bit} {
     expr {$max / 1}
 } $max
-test expr-36.44 {expr edge cases} {
+test expr-36.44 {expr edge cases} {wideIs64bit} {
     expr {$max % 1}
 } {0}
-test expr-36.45 {expr edge cases} {
+test expr-36.45 {expr edge cases} {wideIs64bit} {
     expr {$max / -1}
 } "-$max"
-test expr-36.46 {expr edge cases} {
+test expr-36.46 {expr edge cases} {wideIs64bit} {
     expr {$max % -1}
 } {0}
-test expr-36.47 {expr edge cases} {
+test expr-36.47 {expr edge cases} {wideIs64bit} {
     expr {$max / -2}
 } {-4611686018427387904}
-test expr-36.48 {expr edge cases} {
+test expr-36.48 {expr edge cases} {wideIs64bit} {
     expr {$max % -2}
 } {-1}
-test expr-36.49 {expr edge cases} {
+test expr-36.49 {expr edge cases} {wideIs64bit} {
     expr {$max / -3}
 } {-3074457345618258603}
-test expr-36.50 {expr edge cases} {
+test expr-36.50 {expr edge cases} {wideIs64bit} {
     expr {$max % -3}
 } {-2}
-test expr-36.51 {expr edge cases} {
+test expr-36.51 {expr edge cases} {wideIs64bit} {
     expr {$max / ($min + 3)}
 } {-2}
-test expr-36.52 {expr edge cases} {
+test expr-36.52 {expr edge cases} {wideIs64bit} {
     expr {$max % ($min + 3)}
 } {-9223372036854775803}
-test expr-36.53 {expr edge cases} {
+test expr-36.53 {expr edge cases} {wideIs64bit} {
     expr {$max / ($min + 2)}
 } {-2}
-test expr-36.54 {expr edge cases} {
+test expr-36.54 {expr edge cases} {wideIs64bit} {
     expr {$max % ($min + 2)}
 } {-9223372036854775805}
-test expr-36.55 {expr edge cases} {
+test expr-36.55 {expr edge cases} {wideIs64bit} {
     expr {$max / ($min + 1)}
 } {-1}
-test expr-36.56 {expr edge cases} {
+test expr-36.56 {expr edge cases} {wideIs64bit} {
     expr {$max % ($min + 1)}
 } {0}
-test expr-36.57 {expr edge cases} {
+test expr-36.57 {expr edge cases} {wideIs64bit} {
     expr {$max / $min}
 } {-1}
-test expr-36.58 {expr edge cases} {
+test expr-36.58 {expr edge cases} {wideIs64bit} {
     expr {$max % $min}
 } {-1}
-test expr-36.59 {expr edge cases} {
+test expr-36.59 {expr edge cases} {wideIs64bit} {
     expr {($min + 1) / ($max - 1)}
 } {-2}
-test expr-36.60 {expr edge cases} {
+test expr-36.60 {expr edge cases} {wideIs64bit} {
     expr {($min + 1) % ($max - 1)}
 } {9223372036854775805}
-test expr-36.61 {expr edge cases} {
+test expr-36.61 {expr edge cases} {wideIs64bit} {
     expr {($max - 1) / ($min + 1)}
 } {-1}
-test expr-36.62 {expr edge cases} {
+test expr-36.62 {expr edge cases} {wideIs64bit} {
     expr {($max - 1) % ($min + 1)}
 } {-1}
-test expr-36.63 {expr edge cases} {
+test expr-36.63 {expr edge cases} {wideIs64bit} {
     expr {($max - 1) / $min}
 } {-1}
-test expr-36.64 {expr edge cases} {
+test expr-36.64 {expr edge cases} {wideIs64bit} {
     expr {($max - 1) % $min}
 } {-2}
-test expr-36.65 {expr edge cases} {
+test expr-36.65 {expr edge cases} {wideIs64bit} {
     expr {($max - 2) / $min}
 } {-1}
-test expr-36.66 {expr edge cases} {
+test expr-36.66 {expr edge cases} {wideIs64bit} {
     expr {($max - 2) % $min}
 } {-3}
-test expr-36.67 {expr edge cases} {
+test expr-36.67 {expr edge cases} {wideIs64bit} {
     expr {($max - 3) / $min}
 } {-1}
-test expr-36.68 {expr edge cases} {
+test expr-36.68 {expr edge cases} {wideIs64bit} {
     expr {($max - 3) % $min}
 } {-4}
-test expr-36.69 {expr edge cases} {
+test expr-36.69 {expr edge cases} {wideIs64bit} {
     expr {-3 / $min}
 } {0}
-test expr-36.70 {expr edge cases} {
+test expr-36.70 {expr edge cases} {wideIs64bit} {
     expr {-3 % $min}
 } {-3}
-test expr-36.71 {expr edge cases} {
+test expr-36.71 {expr edge cases} {wideIs64bit} {
     expr {-2 / $min}
 } {0}
-test expr-36.72 {expr edge cases} {
+test expr-36.72 {expr edge cases} {wideIs64bit} {
     expr {-2 % $min}
 } {-2}
-test expr-36.73 {expr edge cases} {
+test expr-36.73 {expr edge cases} {wideIs64bit} {
     expr {-1 / $min}
 } {0}
-test expr-36.74 {expr edge cases} {
+test expr-36.74 {expr edge cases} {wideIs64bit} {
     expr {-1 % $min}
 } {-1}
-test expr-36.75 {expr edge cases} {
+test expr-36.75 {expr edge cases} {wideIs64bit} {
     expr {0 / $min}
 } {0}
-test expr-36.76 {expr edge cases} {
+test expr-36.76 {expr edge cases} {wideIs64bit} {
     expr {0 % $min}
 } {0}
-test expr-36.77 {expr edge cases} {
+test expr-36.77 {expr edge cases} {wideIs64bit} {
     expr {0 / ($min + 1)}
 } {0}
-test expr-36.78 {expr edge cases} {
+test expr-36.78 {expr edge cases} {wideIs64bit} {
     expr {0 % ($min + 1)}
 } {0}
-test expr-36.79 {expr edge cases} {
+test expr-36.79 {expr edge cases} {wideIs64bit} {
     expr {1 / $min}
 } {-1}
-test expr-36.80 {expr edge cases} {
+test expr-36.80 {expr edge cases} {wideIs64bit} {
     expr {1 % $min}
 } {-9223372036854775807}
-test expr-36.81 {expr edge cases} {
+test expr-36.81 {expr edge cases} {wideIs64bit} {
     expr {1 / ($min + 1)}
 } {-1}
-test expr-36.82 {expr edge cases} {
+test expr-36.82 {expr edge cases} {wideIs64bit} {
     expr {1 % ($min + 1)}
 } {-9223372036854775806}
-test expr-36.83 {expr edge cases} {
+test expr-36.83 {expr edge cases} {wideIs64bit} {
     expr {2 / $min}
 } {-1}
-test expr-36.84 {expr edge cases} {
+test expr-36.84 {expr edge cases} {wideIs64bit} {
     expr {2 % $min}
 } {-9223372036854775806}
-test expr-36.85 {expr edge cases} {
+test expr-36.85 {expr edge cases} {wideIs64bit} {
     expr {2 / ($min + 1)}
 } {-1}
-test expr-36.86 {expr edge cases} {
+test expr-36.86 {expr edge cases} {wideIs64bit} {
     expr {2 % ($min + 1)}
 } {-9223372036854775805}
-test expr-36.87 {expr edge cases} {
+test expr-36.87 {expr edge cases} {wideIs64bit} {
     expr {3 / $min}
 } {-1}
-test expr-36.88 {expr edge cases} {
+test expr-36.88 {expr edge cases} {wideIs64bit} {
     expr {3 % $min}
 } {-9223372036854775805}
-test expr-36.89 {expr edge cases} {
+test expr-36.89 {expr edge cases} {wideIs64bit} {
     expr {3 / ($min + 1)}
 } {-1}
-test expr-36.90 {expr edge cases} {
+test expr-36.90 {expr edge cases} {wideIs64bit} {
     expr {3 % ($min + 1)}
 } {-9223372036854775804}
 
-test expr-37.1 {expr edge cases} {
+test expr-37.1 {expr edge cases} {wideIs64bit} {
     set dividend $max
     set divisor 2
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($divisor * $q) + $r}]
 } {4611686018427387903 * 2 + 1 = 9223372036854775807}
-test expr-37.2 {expr edge cases} {
+test expr-37.2 {expr edge cases} {wideIs64bit} {
     set dividend [expr {$max - 1}]
     set divisor 2
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {4611686018427387903 * 2 + 0 = 9223372036854775806}
-test expr-37.3 {expr edge cases} {
+test expr-37.3 {expr edge cases} {wideIs64bit} {
     set dividend [expr {$max - 2}]
     set divisor 2
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {4611686018427387902 * 2 + 1 = 9223372036854775805}
-test expr-37.4 {expr edge cases} {
+test expr-37.4 {expr edge cases} {wideIs64bit} {
     set dividend $max
     set divisor 3
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {3074457345618258602 * 3 + 1 = 9223372036854775807}
-test expr-37.5 {expr edge cases} {
+test expr-37.5 {expr edge cases} {wideIs64bit} {
     set dividend [expr {$max - 1}]
     set divisor 3
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {3074457345618258602 * 3 + 0 = 9223372036854775806}
-test expr-37.6 {expr edge cases} {
+test expr-37.6 {expr edge cases} {wideIs64bit} {
     set dividend [expr {$max - 2}]
     set divisor 3
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {3074457345618258601 * 3 + 2 = 9223372036854775805}
-test expr-37.7 {expr edge cases} {
+test expr-37.7 {expr edge cases} {wideIs64bit} {
     set dividend $min
     set divisor 2
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {-4611686018427387904 * 2 + 0 = -9223372036854775808}
-test expr-37.8 {expr edge cases} {
+test expr-37.8 {expr edge cases} {wideIs64bit} {
     set dividend [expr {$min + 1}]
     set divisor 2
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {-4611686018427387904 * 2 + 1 = -9223372036854775807}
-test expr-37.9 {expr edge cases} {
+test expr-37.9 {expr edge cases} {wideIs64bit} {
     set dividend [expr {$min + 2}]
     set divisor 2
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {-4611686018427387903 * 2 + 0 = -9223372036854775806}
-test expr-37.10 {expr edge cases} {
+test expr-37.10 {expr edge cases} {wideIs64bit} {
     # Multiplication overflows 64 bit type here,
     # so when the 1 is added it overflows
     # again and we end up back at min.
@@ -6609,28 +6615,28 @@ test expr-37.10 {expr edge cases} {
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {-3074457345618258603 * 3 + 1 = -9223372036854775808}
-test expr-37.11 {expr edge cases} {
+test expr-37.11 {expr edge cases} {wideIs64bit} {
     set dividend $min
     set divisor -3
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {3074457345618258602 * -3 + -2 = -9223372036854775808}
-test expr-37.12 {expr edge cases} {
+test expr-37.12 {expr edge cases} {wideIs64bit} {
     set dividend $min
     set divisor $min
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {1 * -9223372036854775808 + 0 = -9223372036854775808}
-test expr-37.13 {expr edge cases} {
+test expr-37.13 {expr edge cases} {wideIs64bit} {
     set dividend $min
     set divisor [expr {$min + 1}]
     set q [expr {$dividend / $divisor}]
     set r [expr {$dividend % $divisor}]
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {1 * -9223372036854775807 + -1 = -9223372036854775808}
-test expr-37.14 {expr edge cases} {
+test expr-37.14 {expr edge cases} {wideIs64bit} {
     set dividend $min
     set divisor [expr {$min + 2}]
     set q [expr {$dividend / $divisor}]
@@ -6638,7 +6644,7 @@ test expr-37.14 {expr edge cases} {
     list $q * $divisor + $r = [expr {($q * $divisor) + $r}]
 } {1 * -9223372036854775806 + -2 = -9223372036854775808}
 
-test expr-38.1 {abs of smallest 32-bit integer [Bug 1241572]} {
+test expr-38.1 {abs of smallest 32-bit integer [Bug 1241572]} {wideIs64bit} {
     expr {abs(-2147483648)}
 } 2147483648
 test expr-38.2 {abs and -0 [Bug 1893815]} {
diff --git a/tests/format.test b/tests/format.test
index ff85cb2..cdea545 100644
--- a/tests/format.test
+++ b/tests/format.test
@@ -18,6 +18,9 @@ if {[lsearch [namespace children] ::tcltest] == -1} {
 # %u output depends on word length, so this test is not portable.
 testConstraint longIs32bit [expr {int(0x80000000) < 0}]
 testConstraint longIs64bit [expr {int(0x8000000000000000) < 0}]
+testConstraint wideIs64bit \
+	[expr {(wide(0x80000000) > 0) && (wide(0x8000000000000000) < 0)}]
+testConstraint wideBiggerThanInt [expr {wide(0x80000000) != int(0x80000000)}]
 testConstraint pointerIs64bit [expr {$tcl_platform(pointerSize) >= 8}]
 
 test format-1.1 {integer formatting} {
@@ -544,13 +547,13 @@ for {set i 290} {$i < 400} {incr i} {
     append b "x"
 }
 
-test format-17.1 {testing %d with wide} {
+test format-17.1 {testing %d with wide} {wideIs64bit wideBiggerThanInt} {
     format %d 7810179016327718216
-} 7810179016327718216
-test format-17.2 {testing %ld with wide} {
+} 1819043144
+test format-17.2 {testing %ld with wide} {wideIs64bit} {
     format %ld 7810179016327718216
 } 7810179016327718216
-test format-17.3 {testing %ld with non-wide} {
+test format-17.3 {testing %ld with non-wide} {wideIs64bit} {
     format %ld 42
 } 42
 test format-17.4 {testing %l with non-integer} {
@@ -577,11 +580,11 @@ test format-18.1 {do not demote existing numeric values} {
     format %08x $b
     lappend result [expr {$a == $b}]
 } {1 1 1 1}
-test format-18.2 {do not demote existing numeric values} {
+test format-18.2 {do not demote existing numeric values} {wideBiggerThanInt} {
     set a [expr {0xaaaaaaaaaa + 1}]
     set b 0xaaaaaaaaab
     list [format %08x $a] [expr {$a == $b}]
-} {aaaaaaaaab 1}
+} {aaaaaaab 1}
 
 test format-19.1 {regression test - tcl-core message by Brian Griffin on 26 0ctober 2004} -body {
     set x 0x8fedc654
diff --git a/tests/obj.test b/tests/obj.test
index 41b1428..ffd1a59 100644
--- a/tests/obj.test
+++ b/tests/obj.test
@@ -20,6 +20,8 @@ if {[lsearch [namespace children] ::tcltest] == -1} {
 catch [list package require -exact Tcltest [info patchlevel]]
 
 testConstraint testobj [llength [info commands testobj]]
+testConstraint longIs32bit	[expr {int(0x80000000) < 0}]
+testConstraint wideBiggerThanInt [expr {wide(0x80000000) != int(0x80000000)}]
 
 test obj-1.1 {Tcl_AppendAllObjTypes, and InitTypeTable, Tcl_RegisterObjType} testobj {
     set r 1
@@ -547,34 +549,34 @@ test obj-32.1 {freeing very large object trees} {
     unset x
 } {}
 
-test obj-33.1 {integer overflow on input} {
+test obj-33.1 {integer overflow on input} {longIs32bit wideBiggerThanInt} {
     set x 0x8000; append x 0000
     list [string is integer $x] [expr { wide($x) }]
 } {1 2147483648}
-test obj-33.2 {integer overflow on input} {
+test obj-33.2 {integer overflow on input} {longIs32bit wideBiggerThanInt} {
     set x 0xffff; append x ffff
     list [string is integer $x] [expr { wide($x) }]
 } {1 4294967295}
 test obj-33.3 {integer overflow on input} {
-    set x 0x10000; append x 0000
-    list [string is integer $x] [expr { wide($x) }]
-} {1 4294967296}
-test obj-33.4 {integer overflow on input} {
+    set x 0x100000000; append x 00000000
+    list [string is integer $x] [expr { $x }]
+} {0 18446744073709551616}
+test obj-33.4 {integer overflow on input} {longIs32bit wideBiggerThanInt} {
     set x -0x8000; append x 0000
     list [string is integer $x] [expr { wide($x) }]
 } {1 -2147483648}
-test obj-33.5 {integer overflow on input} {
+test obj-33.5 {integer overflow on input} {longIs32bit wideBiggerThanInt} {
     set x -0x8000; append x 0001
     list [string is integer $x] [expr { wide($x) }]
 } {1 -2147483649}
-test obj-33.6 {integer overflow on input} {
+test obj-33.6 {integer overflow on input} {longIs32bit wideBiggerThanInt} {
     set x -0xffff; append x ffff
     list [string is integer $x] [expr { wide($x) }]
 } {1 -4294967295}
 test obj-33.7 {integer overflow on input} {
-    set x -0x10000; append x 0000
-    list [string is integer $x] [expr { wide($x) }]
-} {1 -4294967296}
+    set x -0x100000000; append x 00000000
+    list [string is integer $x] [expr { $x }]
+} {0 -18446744073709551616}
 
 test obj-34.1 {mp_iseven} testobj {
     set result ""
diff --git a/tests/scan.test b/tests/scan.test
index 0b7b14a..1f32b9f 100644
--- a/tests/scan.test
+++ b/tests/scan.test
@@ -85,6 +85,8 @@ proc testIEEE {} {
 }
 
 testConstraint ieeeFloatingPoint [testIEEE]
+testConstraint wideIs64bit \
+	[expr {(wide(0x80000000) > 0) && (wide(0x8000000000000000) < 0)}]
 
 test scan-1.1 {BuildCharSet, CharInSet} {
     list [scan foo {%[^o]} x] $x
@@ -519,7 +521,7 @@ test scan-5.11 {integer scanning} -constraints {nonPortable} -setup {
     list [scan "4294967280 4294967280" "%u %d" a b] $a \
 	    [expr {$b == -16 || $b == 0x7fffffff}]
 } -result {2 4294967280 1}
-test scan-5.12 {integer scanning} -setup {
+test scan-5.12 {integer scanning} -constraints {wideIs64bit} -setup {
     set a {}; set b {}; set c {}
 } -body {
     list [scan "7810179016327718216,6c63546f6c6c6548,661432506755433062510" \
-- 
cgit v0.12