test: ensure all failing tests exit nonzero.
Previously merely printing an error would cause the golden
file comparison (in 'bash run') to fail, but that is no longer
the case with the new run.go driver.
R=iant
CC=golang-dev
https://golang.org/cl/7310087
diff --git a/test/alias1.go b/test/alias1.go
index 4219af8..42cf693 100644
--- a/test/alias1.go
+++ b/test/alias1.go
@@ -17,7 +17,7 @@
case uint8:
// ok
default:
- println("byte != uint8")
+ panic("byte != uint8")
}
x = uint8(2)
@@ -25,7 +25,7 @@
case byte:
// ok
default:
- println("uint8 != byte")
+ panic("uint8 != byte")
}
rune32 := false
@@ -37,7 +37,7 @@
// must be new code
rune32 = true
default:
- println("rune != int and rune != int32")
+ panic("rune != int and rune != int32")
}
if rune32 {
@@ -49,6 +49,6 @@
case rune:
// ok
default:
- println("int (or int32) != rune")
+ panic("int (or int32) != rune")
}
}
diff --git a/test/bigalg.go b/test/bigalg.go
index 55a15c3..60e8229 100644
--- a/test/bigalg.go
+++ b/test/bigalg.go
@@ -15,18 +15,21 @@
d byte
}
-var a = []int{ 1, 2, 3 }
+var a = []int{1, 2, 3}
var NIL []int
func arraycmptest() {
if NIL != nil {
println("fail1:", NIL, "!= nil")
+ panic("bigalg")
}
if nil != NIL {
println("fail2: nil !=", NIL)
+ panic("bigalg")
}
if a == nil || nil == a {
println("fail3:", a, "== nil")
+ panic("bigalg")
}
}
@@ -49,12 +52,14 @@
t1 := mt[0]
if t1.a != t.a || t1.b != t.b || t1.c != t.c || t1.d != t.d {
println("fail: map val struct", t1.a, t1.b, t1.c, t1.d)
+ panic("bigalg")
}
ma[1] = a
a1 := ma[1]
if !SameArray(a, a1) {
println("fail: map val array", a, a1)
+ panic("bigalg")
}
}
@@ -72,15 +77,18 @@
t1 := <-ct
if t1.a != t.a || t1.b != t.b || t1.c != t.c || t1.d != t.d {
println("fail: map val struct", t1.a, t1.b, t1.c, t1.d)
+ panic("bigalg")
}
a1 := <-ca
if !SameArray(a, a1) {
println("fail: map val array", a, a1)
+ panic("bigalg")
}
}
-type E struct { }
+type E struct{}
+
var e E
func interfacetest() {
@@ -90,6 +98,7 @@
a1 := i.([]int)
if !SameArray(a, a1) {
println("interface <-> []int", a, a1)
+ panic("bigalg")
}
pa := new([]int)
*pa = a
@@ -97,12 +106,14 @@
a1 = *i.(*[]int)
if !SameArray(a, a1) {
println("interface <-> *[]int", a, a1)
+ panic("bigalg")
}
i = t
t1 := i.(T)
if t1.a != t.a || t1.b != t.b || t1.c != t.c || t1.d != t.d {
println("interface <-> struct", t1.a, t1.b, t1.c, t1.d)
+ panic("bigalg")
}
i = e
diff --git a/test/cmplxdivide.go b/test/cmplxdivide.go
index 92a9835..40c8448 100644
--- a/test/cmplxdivide.go
+++ b/test/cmplxdivide.go
@@ -45,4 +45,7 @@
fmt.Printf("%v/%v: expected %v error; got %v\n", t.f, t.g, t.out, x)
}
}
+ if bad {
+ panic("cmplxdivide failed.")
+ }
}
diff --git a/test/const4.go b/test/const4.go
index 677fcef..2fb2d06 100644
--- a/test/const4.go
+++ b/test/const4.go
@@ -9,7 +9,7 @@
package main
var b struct {
- a[10]int
+ a [10]int
}
var m map[string][20]int
@@ -61,17 +61,22 @@
func main() {
if n1 != 10 || n2 != 20 || n3 != 30 || n4 != 40 || n5 != 50 || n6 != 60 || n7 != 70 {
println("BUG:", n1, n2, n3, n4, n5, n6, n7)
+ panic("fail")
}
if !calledF {
println("BUG: did not call f")
+ panic("fail")
}
if <-c == nil {
println("BUG: did not receive from c")
+ panic("fail")
}
if !calledG {
println("BUG: did not call g")
+ panic("fail")
}
if <-c1 == nil {
println("BUG: did not receive from c1")
+ panic("fail")
}
}
diff --git a/test/copy.go b/test/copy.go
index 65ffb6f..e6108d9 100644
--- a/test/copy.go
+++ b/test/copy.go
@@ -132,6 +132,7 @@
n := ncopied(length, in, out)
if m != n {
fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
+ os.Exit(1)
return
}
// before
@@ -172,6 +173,7 @@
n := ncopied(length, in, out)
if m != n {
fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
+ os.Exit(1)
return
}
// before
@@ -212,6 +214,7 @@
n := ncopied(length, in, out)
if m != n {
fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
+ os.Exit(1)
return
}
// before
@@ -252,6 +255,7 @@
n := ncopied(length, in, out)
if m != n {
fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
+ os.Exit(1)
return
}
// before
@@ -292,6 +296,7 @@
n := ncopied(length, in, out)
if m != n {
fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
+ os.Exit(1)
return
}
// before
diff --git a/test/decl.go b/test/decl.go
index 6f84245..e2f126a 100644
--- a/test/decl.go
+++ b/test/decl.go
@@ -33,8 +33,9 @@
m, h, s := f3()
_, _, _, _, _, _, _, _, _ = i, f, s, j, k, m, g, s, h
}
- if x() != "3" {
- println("x() failed")
+ if y := x(); y != "3" {
+ println("x() failed", y)
+ panic("fail")
}
_, _, _, _, _, _, _, _, _ = i, f, s, j, k, m, g, s, h
}
diff --git a/test/defer.go b/test/defer.go
index 2f67d35..6731ab7 100644
--- a/test/defer.go
+++ b/test/defer.go
@@ -25,6 +25,7 @@
test1helper()
if result != "9876543210" {
fmt.Printf("test1: bad defer result (should be 9876543210): %q\n", result)
+ panic("defer")
}
}
@@ -41,6 +42,7 @@
test2helper()
if result != "9876543210" {
fmt.Printf("test2: bad defer result (should be 9876543210): %q\n", result)
+ panic("defer")
}
}
diff --git a/test/divide.go b/test/divide.go
index c91a33e..b20f106 100644
--- a/test/divide.go
+++ b/test/divide.go
@@ -13,36 +13,44 @@
func f8(x, y, q, r int8) {
if t := x / y; t != q {
fmt.Printf("%d/%d = %d, want %d\n", x, y, t, q)
+ panic("divide")
}
if t := x % y; t != r {
fmt.Printf("%d%%%d = %d, want %d\n", x, y, t, r)
+ panic("divide")
}
}
func f16(x, y, q, r int16) {
if t := x / y; t != q {
fmt.Printf("%d/%d = %d, want %d\n", x, y, t, q)
+ panic("divide")
}
if t := x % y; t != r {
fmt.Printf("%d%%%d = %d, want %d\n", x, y, t, r)
+ panic("divide")
}
}
func f32(x, y, q, r int32) {
if t := x / y; t != q {
fmt.Printf("%d/%d = %d, want %d\n", x, y, t, q)
+ panic("divide")
}
if t := x % y; t != r {
fmt.Printf("%d%%%d = %d, want %d\n", x, y, t, r)
+ panic("divide")
}
}
func f64(x, y, q, r int64) {
if t := x / y; t != q {
fmt.Printf("%d/%d = %d, want %d\n", x, y, t, q)
+ panic("divide")
}
if t := x % y; t != r {
fmt.Printf("%d%%%d = %d, want %d\n", x, y, t, r)
+ panic("divide")
}
}
diff --git a/test/escape.go b/test/escape.go
index e8ede52..252a1e59 100644
--- a/test/escape.go
+++ b/test/escape.go
@@ -52,9 +52,11 @@
func chkalias(p, q *int, v int, s string) {
if p != q {
println("want aliased pointers but got different after", s)
+ bad = true
}
if *q != v+1 {
println("wrong value want", v+1, "got", *q, "after", s)
+ bad = true
}
}
diff --git a/test/float_lit.go b/test/float_lit.go
index 2912c37..4efae23 100644
--- a/test/float_lit.go
+++ b/test/float_lit.go
@@ -196,4 +196,8 @@
if !close(-210.012e19, -210012, 1000, 19) {
print("-210.012e19 is ", -210.012e19, "\n")
}
+
+ if bad {
+ panic("float_lit")
+ }
}
diff --git a/test/floatcmp.go b/test/floatcmp.go
index f9f59a9..6c424cc 100644
--- a/test/floatcmp.go
+++ b/test/floatcmp.go
@@ -87,4 +87,7 @@
println(t.name, "=", t.expr, "want", t.want)
}
}
+ if bad {
+ panic("floatcmp failed")
+ }
}
diff --git a/test/func7.go b/test/func7.go
index 6f6766f..2d646b6 100644
--- a/test/func7.go
+++ b/test/func7.go
@@ -17,7 +17,7 @@
func g() int {
if !calledf {
- println("BUG: func7 - called g before f")
+ panic("BUG: func7 - called g before f")
}
return 0
}
@@ -28,4 +28,3 @@
panic("wrong answer")
}
}
-
diff --git a/test/func8.go b/test/func8.go
index 7defe26..1305180 100644
--- a/test/func8.go
+++ b/test/func8.go
@@ -37,13 +37,13 @@
func main() {
if f() == g() {
- println("wrong f,g order")
+ panic("wrong f,g order")
}
if x() == (y() == "abc") {
panic("wrong compare")
}
if xy != "xy" {
- println("wrong x,y order")
+ panic("wrong x,y order")
}
}
diff --git a/test/init1.go b/test/init1.go
index a888ad7..f6eda6e 100644
--- a/test/init1.go
+++ b/test/init1.go
@@ -33,6 +33,7 @@
sys1 := memstats.Sys
if sys1-sys > chunk*50 {
println("allocated 1000 chunks of", chunk, "and used ", sys1-sys, "memory")
+ panic("init1")
}
}
diff --git a/test/literal.go b/test/literal.go
index ba185fc..c3d6bc1 100644
--- a/test/literal.go
+++ b/test/literal.go
@@ -24,7 +24,6 @@
return a == b
}
-
func main() {
// bool
var t bool = true
@@ -225,6 +224,6 @@
assert(sj0 == sj3, "sj3")
if nbad > 0 {
- println()
+ panic("literal failed")
}
}
diff --git a/test/map.go b/test/map.go
index 6dec0df..041c8fb 100644
--- a/test/map.go
+++ b/test/map.go
@@ -41,7 +41,7 @@
for i := 0; i < len(mlit); i++ {
s := string([]byte{byte(i) + '0'})
if mlit[s] != i {
- fmt.Printf("mlit[%s] = %d\n", s, mlit[s])
+ panic(fmt.Sprintf("mlit[%s] = %d\n", s, mlit[s]))
}
}
@@ -102,46 +102,46 @@
// test len
if len(mib) != count {
- fmt.Printf("len(mib) = %d\n", len(mib))
+ panic(fmt.Sprintf("len(mib) = %d\n", len(mib)))
}
if len(mii) != count {
- fmt.Printf("len(mii) = %d\n", len(mii))
+ panic(fmt.Sprintf("len(mii) = %d\n", len(mii)))
}
if len(mfi) != count {
- fmt.Printf("len(mfi) = %d\n", len(mfi))
+ panic(fmt.Sprintf("len(mfi) = %d\n", len(mfi)))
}
if len(mif) != count {
- fmt.Printf("len(mif) = %d\n", len(mif))
+ panic(fmt.Sprintf("len(mif) = %d\n", len(mif)))
}
if len(msi) != count {
- fmt.Printf("len(msi) = %d\n", len(msi))
+ panic(fmt.Sprintf("len(msi) = %d\n", len(msi)))
}
if len(mis) != count {
- fmt.Printf("len(mis) = %d\n", len(mis))
+ panic(fmt.Sprintf("len(mis) = %d\n", len(mis)))
}
if len(mss) != count {
- fmt.Printf("len(mss) = %d\n", len(mss))
+ panic(fmt.Sprintf("len(mss) = %d\n", len(mss)))
}
if len(mspa) != count {
- fmt.Printf("len(mspa) = %d\n", len(mspa))
+ panic(fmt.Sprintf("len(mspa) = %d\n", len(mspa)))
}
if len(mipT) != count {
- fmt.Printf("len(mipT) = %d\n", len(mipT))
+ panic(fmt.Sprintf("len(mipT) = %d\n", len(mipT)))
}
if len(mpTi) != count {
- fmt.Printf("len(mpTi) = %d\n", len(mpTi))
+ panic(fmt.Sprintf("len(mpTi) = %d\n", len(mpTi)))
}
// if len(mti) != count {
- // fmt.Printf("len(mti) = %d\n", len(mti))
+ // panic(fmt.Sprintf("len(mti) = %d\n", len(mti)))
// }
if len(mipM) != count {
- fmt.Printf("len(mipM) = %d\n", len(mipM))
+ panic(fmt.Sprintf("len(mipM) = %d\n", len(mipM)))
}
// if len(mti) != count {
- // fmt.Printf("len(mti) = %d\n", len(mti))
+ // panic(fmt.Sprintf("len(mti) = %d\n", len(mti)))
// }
if len(mit) != count {
- fmt.Printf("len(mit) = %d\n", len(mit))
+ panic(fmt.Sprintf("len(mit) = %d\n", len(mit)))
}
// test construction directly
@@ -151,48 +151,48 @@
f := float32(i)
// BUG m := M(i, i+1)
if mib[i] != (i != 0) {
- fmt.Printf("mib[%d] = %t\n", i, mib[i])
+ panic(fmt.Sprintf("mib[%d] = %t\n", i, mib[i]))
}
if mii[i] != 10*i {
- fmt.Printf("mii[%d] = %d\n", i, mii[i])
+ panic(fmt.Sprintf("mii[%d] = %d\n", i, mii[i]))
}
if mfi[f] != 10*i {
- fmt.Printf("mfi[%d] = %d\n", i, mfi[f])
+ panic(fmt.Sprintf("mfi[%d] = %d\n", i, mfi[f]))
}
if mif[i] != 10.0*f {
- fmt.Printf("mif[%d] = %g\n", i, mif[i])
+ panic(fmt.Sprintf("mif[%d] = %g\n", i, mif[i]))
}
if mis[i] != s {
- fmt.Printf("mis[%d] = %s\n", i, mis[i])
+ panic(fmt.Sprintf("mis[%d] = %s\n", i, mis[i]))
}
if msi[s] != i {
- fmt.Printf("msi[%s] = %d\n", s, msi[s])
+ panic(fmt.Sprintf("msi[%s] = %d\n", s, msi[s]))
}
if mss[s] != s10 {
- fmt.Printf("mss[%s] = %g\n", s, mss[s])
+ panic(fmt.Sprintf("mss[%s] = %g\n", s, mss[s]))
}
for j := 0; j < len(mspa[s]); j++ {
if mspa[s][j] != s10 {
- fmt.Printf("mspa[%s][%d] = %s\n", s, j, mspa[s][j])
+ panic(fmt.Sprintf("mspa[%s][%d] = %s\n", s, j, mspa[s][j]))
}
}
if mipT[i].i != int64(i) || mipT[i].f != f {
- fmt.Printf("mipT[%d] = %v\n", i, mipT[i])
+ panic(fmt.Sprintf("mipT[%d] = %v\n", i, mipT[i]))
}
if mpTi[apT[i]] != i {
- fmt.Printf("mpTi[apT[%d]] = %d\n", i, mpTi[apT[i]])
+ panic(fmt.Sprintf("mpTi[apT[%d]] = %d\n", i, mpTi[apT[i]]))
}
// if(mti[t] != i) {
- // fmt.Printf("mti[%s] = %s\n", s, mti[t])
+ // panic(fmt.Sprintf("mti[%s] = %s\n", s, mti[t]))
// }
if mipM[i][i] != i+1 {
- fmt.Printf("mipM[%d][%d] = %d\n", i, i, mipM[i][i])
+ panic(fmt.Sprintf("mipM[%d][%d] = %d\n", i, i, mipM[i][i]))
}
// if(mti[t] != i) {
- // fmt.Printf("mti[%v] = %d\n", t, mti[t])
+ // panic(fmt.Sprintf("mti[%v] = %d\n", t, mti[t]))
// }
if mit[i].i != int64(i) || mit[i].f != f {
- fmt.Printf("mit[%d] = {%d %g}\n", i, mit[i].i, mit[i].f)
+ panic(fmt.Sprintf("mit[%d] = {%d %g}\n", i, mit[i].i, mit[i].f))
}
}
@@ -204,131 +204,131 @@
{
_, b := mib[i]
if !b {
- fmt.Printf("tuple existence decl: mib[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: mib[%d]\n", i))
}
_, b = mib[i]
if !b {
- fmt.Printf("tuple existence assign: mib[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: mib[%d]\n", i))
}
}
{
_, b := mii[i]
if !b {
- fmt.Printf("tuple existence decl: mii[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: mii[%d]\n", i))
}
_, b = mii[i]
if !b {
- fmt.Printf("tuple existence assign: mii[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: mii[%d]\n", i))
}
}
{
_, b := mfi[f]
if !b {
- fmt.Printf("tuple existence decl: mfi[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: mfi[%d]\n", i))
}
_, b = mfi[f]
if !b {
- fmt.Printf("tuple existence assign: mfi[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: mfi[%d]\n", i))
}
}
{
_, b := mif[i]
if !b {
- fmt.Printf("tuple existence decl: mif[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: mif[%d]\n", i))
}
_, b = mif[i]
if !b {
- fmt.Printf("tuple existence assign: mif[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: mif[%d]\n", i))
}
}
{
_, b := mis[i]
if !b {
- fmt.Printf("tuple existence decl: mis[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: mis[%d]\n", i))
}
_, b = mis[i]
if !b {
- fmt.Printf("tuple existence assign: mis[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: mis[%d]\n", i))
}
}
{
_, b := msi[s]
if !b {
- fmt.Printf("tuple existence decl: msi[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: msi[%d]\n", i))
}
_, b = msi[s]
if !b {
- fmt.Printf("tuple existence assign: msi[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: msi[%d]\n", i))
}
}
{
_, b := mss[s]
if !b {
- fmt.Printf("tuple existence decl: mss[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: mss[%d]\n", i))
}
_, b = mss[s]
if !b {
- fmt.Printf("tuple existence assign: mss[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: mss[%d]\n", i))
}
}
{
_, b := mspa[s]
if !b {
- fmt.Printf("tuple existence decl: mspa[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: mspa[%d]\n", i))
}
_, b = mspa[s]
if !b {
- fmt.Printf("tuple existence assign: mspa[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: mspa[%d]\n", i))
}
}
{
_, b := mipT[i]
if !b {
- fmt.Printf("tuple existence decl: mipT[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: mipT[%d]\n", i))
}
_, b = mipT[i]
if !b {
- fmt.Printf("tuple existence assign: mipT[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: mipT[%d]\n", i))
}
}
{
_, b := mpTi[apT[i]]
if !b {
- fmt.Printf("tuple existence decl: mpTi[apT[%d]]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: mpTi[apT[%d]]\n", i))
}
_, b = mpTi[apT[i]]
if !b {
- fmt.Printf("tuple existence assign: mpTi[apT[%d]]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: mpTi[apT[%d]]\n", i))
}
}
{
_, b := mipM[i]
if !b {
- fmt.Printf("tuple existence decl: mipM[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: mipM[%d]\n", i))
}
_, b = mipM[i]
if !b {
- fmt.Printf("tuple existence assign: mipM[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: mipM[%d]\n", i))
}
}
{
_, b := mit[i]
if !b {
- fmt.Printf("tuple existence decl: mit[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence decl: mit[%d]\n", i))
}
_, b = mit[i]
if !b {
- fmt.Printf("tuple existence assign: mit[%d]\n", i)
+ panic(fmt.Sprintf("tuple existence assign: mit[%d]\n", i))
}
}
// {
// _, b := mti[t]
// if !b {
- // fmt.Printf("tuple existence decl: mti[%d]\n", i)
+ // panic(fmt.Sprintf("tuple existence decl: mti[%d]\n", i))
// }
// _, b = mti[t]
// if !b {
- // fmt.Printf("tuple existence assign: mti[%d]\n", i)
+ // panic(fmt.Sprintf("tuple existence assign: mti[%d]\n", i))
// }
// }
}
@@ -341,131 +341,131 @@
{
_, b := mib[i]
if b {
- fmt.Printf("tuple nonexistence decl: mib[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: mib[%d]", i))
}
_, b = mib[i]
if b {
- fmt.Printf("tuple nonexistence assign: mib[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: mib[%d]", i))
}
}
{
_, b := mii[i]
if b {
- fmt.Printf("tuple nonexistence decl: mii[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: mii[%d]", i))
}
_, b = mii[i]
if b {
- fmt.Printf("tuple nonexistence assign: mii[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: mii[%d]", i))
}
}
{
_, b := mfi[f]
if b {
- fmt.Printf("tuple nonexistence decl: mfi[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: mfi[%d]", i))
}
_, b = mfi[f]
if b {
- fmt.Printf("tuple nonexistence assign: mfi[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: mfi[%d]", i))
}
}
{
_, b := mif[i]
if b {
- fmt.Printf("tuple nonexistence decl: mif[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: mif[%d]", i))
}
_, b = mif[i]
if b {
- fmt.Printf("tuple nonexistence assign: mif[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: mif[%d]", i))
}
}
{
_, b := mis[i]
if b {
- fmt.Printf("tuple nonexistence decl: mis[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: mis[%d]", i))
}
_, b = mis[i]
if b {
- fmt.Printf("tuple nonexistence assign: mis[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: mis[%d]", i))
}
}
{
_, b := msi[s]
if b {
- fmt.Printf("tuple nonexistence decl: msi[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: msi[%d]", i))
}
_, b = msi[s]
if b {
- fmt.Printf("tuple nonexistence assign: msi[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: msi[%d]", i))
}
}
{
_, b := mss[s]
if b {
- fmt.Printf("tuple nonexistence decl: mss[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: mss[%d]", i))
}
_, b = mss[s]
if b {
- fmt.Printf("tuple nonexistence assign: mss[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: mss[%d]", i))
}
}
{
_, b := mspa[s]
if b {
- fmt.Printf("tuple nonexistence decl: mspa[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: mspa[%d]", i))
}
_, b = mspa[s]
if b {
- fmt.Printf("tuple nonexistence assign: mspa[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: mspa[%d]", i))
}
}
{
_, b := mipT[i]
if b {
- fmt.Printf("tuple nonexistence decl: mipT[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: mipT[%d]", i))
}
_, b = mipT[i]
if b {
- fmt.Printf("tuple nonexistence assign: mipT[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: mipT[%d]", i))
}
}
{
_, b := mpTi[apT[i]]
if b {
- fmt.Printf("tuple nonexistence decl: mpTi[apt[%d]]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: mpTi[apt[%d]]", i))
}
_, b = mpTi[apT[i]]
if b {
- fmt.Printf("tuple nonexistence assign: mpTi[apT[%d]]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: mpTi[apT[%d]]", i))
}
}
{
_, b := mipM[i]
if b {
- fmt.Printf("tuple nonexistence decl: mipM[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: mipM[%d]", i))
}
_, b = mipM[i]
if b {
- fmt.Printf("tuple nonexistence assign: mipM[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: mipM[%d]", i))
}
}
// {
// _, b := mti[t]
// if b {
- // fmt.Printf("tuple nonexistence decl: mti[%d]", i)
+ // panic(fmt.Sprintf("tuple nonexistence decl: mti[%d]", i))
// }
// _, b = mti[t]
// if b {
- // fmt.Printf("tuple nonexistence assign: mti[%d]", i)
+ // panic(fmt.Sprintf("tuple nonexistence assign: mti[%d]", i))
// }
// }
{
_, b := mit[i]
if b {
- fmt.Printf("tuple nonexistence decl: mit[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence decl: mit[%d]", i))
}
_, b = mit[i]
if b {
- fmt.Printf("tuple nonexistence assign: mit[%d]", i)
+ panic(fmt.Sprintf("tuple nonexistence assign: mit[%d]", i))
}
}
}
@@ -475,21 +475,25 @@
s := strconv.Itoa(i)
mspa[s][i%2] = "deleted"
if mspa[s][i%2] != "deleted" {
- fmt.Printf("update mspa[%s][%d] = %s\n", s, i%2, mspa[s][i%2])
+ panic(fmt.Sprintf("update mspa[%s][%d] = %s\n", s, i%2, mspa[s][i%2]))
+
}
mipT[i].i += 1
if mipT[i].i != int64(i)+1 {
- fmt.Printf("update mipT[%d].i = %d\n", i, mipT[i].i)
+ panic(fmt.Sprintf("update mipT[%d].i = %d\n", i, mipT[i].i))
+
}
mipT[i].f = float32(i + 1)
if mipT[i].f != float32(i+1) {
- fmt.Printf("update mipT[%d].f = %g\n", i, mipT[i].f)
+ panic(fmt.Sprintf("update mipT[%d].f = %g\n", i, mipT[i].f))
+
}
mipM[i][i]++
if mipM[i][i] != (i+1)+1 {
- fmt.Printf("update mipM[%d][%d] = %d\n", i, i, mipM[i][i])
+ panic(fmt.Sprintf("update mipM[%d][%d] = %d\n", i, i, mipM[i][i]))
+
}
}
@@ -519,29 +523,29 @@
nanb: "NaN",
}
if m[pz] != "+0" {
- fmt.Println("float32 map cannot read back m[+0]:", m[pz])
+ panic(fmt.Sprintln("float32 map cannot read back m[+0]:", m[pz]))
}
if m[nz] != "+0" {
- fmt.Println("float32 map does not treat", pz, "and", nz, "as equal for read")
- fmt.Println("float32 map does not treat -0 and +0 as equal for read")
+ fmt.Sprintln("float32 map does not treat", pz, "and", nz, "as equal for read")
+ panic(fmt.Sprintln("float32 map does not treat -0 and +0 as equal for read"))
}
m[nz] = "-0"
if m[pz] != "-0" {
- fmt.Println("float32 map does not treat -0 and +0 as equal for write")
+ panic(fmt.Sprintln("float32 map does not treat -0 and +0 as equal for write"))
}
if _, ok := m[nana]; ok {
- fmt.Println("float32 map allows NaN lookup (a)")
+ panic(fmt.Sprintln("float32 map allows NaN lookup (a)"))
}
if _, ok := m[nanb]; ok {
- fmt.Println("float32 map allows NaN lookup (b)")
+ panic(fmt.Sprintln("float32 map allows NaN lookup (b)"))
}
if len(m) != 3 {
- fmt.Println("float32 map should have 3 entries:", m)
+ panic(fmt.Sprintln("float32 map should have 3 entries:", m))
}
m[nana] = "NaN"
m[nanb] = "NaN"
if len(m) != 5 {
- fmt.Println("float32 map should have 5 entries:", m)
+ panic(fmt.Sprintln("float32 map should have 5 entries:", m))
}
}
@@ -559,25 +563,25 @@
nanb: "NaN",
}
if m[nz] != "+0" {
- fmt.Println("float64 map does not treat -0 and +0 as equal for read")
+ panic(fmt.Sprintln("float64 map does not treat -0 and +0 as equal for read"))
}
m[nz] = "-0"
if m[pz] != "-0" {
- fmt.Println("float64 map does not treat -0 and +0 as equal for write")
+ panic(fmt.Sprintln("float64 map does not treat -0 and +0 as equal for write"))
}
if _, ok := m[nana]; ok {
- fmt.Println("float64 map allows NaN lookup (a)")
+ panic(fmt.Sprintln("float64 map allows NaN lookup (a)"))
}
if _, ok := m[nanb]; ok {
- fmt.Println("float64 map allows NaN lookup (b)")
+ panic(fmt.Sprintln("float64 map allows NaN lookup (b)"))
}
if len(m) != 3 {
- fmt.Println("float64 map should have 3 entries:", m)
+ panic(fmt.Sprintln("float64 map should have 3 entries:", m))
}
m[nana] = "NaN"
m[nanb] = "NaN"
if len(m) != 5 {
- fmt.Println("float64 map should have 5 entries:", m)
+ panic(fmt.Sprintln("float64 map should have 5 entries:", m))
}
}
@@ -595,25 +599,25 @@
nanb: "NaN",
}
if m[nz] != "+0" {
- fmt.Println("complex64 map does not treat -0 and +0 as equal for read")
+ panic(fmt.Sprintln("complex64 map does not treat -0 and +0 as equal for read"))
}
m[nz] = "-0"
if m[pz] != "-0" {
- fmt.Println("complex64 map does not treat -0 and +0 as equal for write")
+ panic(fmt.Sprintln("complex64 map does not treat -0 and +0 as equal for write"))
}
if _, ok := m[nana]; ok {
- fmt.Println("complex64 map allows NaN lookup (a)")
+ panic(fmt.Sprintln("complex64 map allows NaN lookup (a)"))
}
if _, ok := m[nanb]; ok {
- fmt.Println("complex64 map allows NaN lookup (b)")
+ panic(fmt.Sprintln("complex64 map allows NaN lookup (b)"))
}
if len(m) != 3 {
- fmt.Println("complex64 map should have 3 entries:", m)
+ panic(fmt.Sprintln("complex64 map should have 3 entries:", m))
}
m[nana] = "NaN"
m[nanb] = "NaN"
if len(m) != 5 {
- fmt.Println("complex64 map should have 5 entries:", m)
+ panic(fmt.Sprintln("complex64 map should have 5 entries:", m))
}
}
@@ -631,25 +635,25 @@
nanb: "NaN",
}
if m[nz] != "+0" {
- fmt.Println("complex128 map does not treat -0 and +0 as equal for read")
+ panic(fmt.Sprintln("complex128 map does not treat -0 and +0 as equal for read"))
}
m[nz] = "-0"
if m[pz] != "-0" {
- fmt.Println("complex128 map does not treat -0 and +0 as equal for write")
+ panic(fmt.Sprintln("complex128 map does not treat -0 and +0 as equal for write"))
}
if _, ok := m[nana]; ok {
- fmt.Println("complex128 map allows NaN lookup (a)")
+ panic(fmt.Sprintln("complex128 map allows NaN lookup (a)"))
}
if _, ok := m[nanb]; ok {
- fmt.Println("complex128 map allows NaN lookup (b)")
+ panic(fmt.Sprintln("complex128 map allows NaN lookup (b)"))
}
if len(m) != 3 {
- fmt.Println("complex128 map should have 3 entries:", m)
+ panic(fmt.Sprintln("complex128 map should have 3 entries:", m))
}
m[nana] = "NaN"
m[nanb] = "NaN"
if len(m) != 5 {
- fmt.Println("complex128 map should have 5 entries:", m)
+ panic(fmt.Sprintln("complex128 map should have 5 entries:", m))
}
}
}
@@ -685,7 +689,7 @@
}
fails++
if fails == 4 {
- fmt.Printf("too slow: %d inserts: %v; %d inserts: %v\n", n, t1, 2*n, t2)
+ panic(fmt.Sprintf("too slow: %d inserts: %v; %d inserts: %v\n", n, t1, 2*n, t2))
return
}
n *= 2
diff --git a/test/nil.go b/test/nil.go
index 44ca79e..f8300bf 100644
--- a/test/nil.go
+++ b/test/nil.go
@@ -115,7 +115,7 @@
})
shouldBlock(func() {
x, ok := <-ch
- println(x, ok)
+ println(x, ok) // unreachable
})
if len(ch) != 0 {
diff --git a/test/recover3.go b/test/recover3.go
index 9870023..ebfa0a3 100644
--- a/test/recover3.go
+++ b/test/recover3.go
@@ -71,6 +71,10 @@
inter = 1
check("type-concrete", func() { println(inter.(string)) }, "int, not string")
check("type-interface", func() { println(inter.(m)) }, "missing method m")
+
+ if didbug {
+ panic("recover3")
+ }
}
type m interface {
diff --git a/test/rename.go b/test/rename.go
index e544274..dc43417 100644
--- a/test/rename.go
+++ b/test/rename.go
@@ -8,7 +8,10 @@
package main
-import "fmt"
+import (
+ "fmt"
+ "runtime"
+)
func main() {
n :=
@@ -52,6 +55,7 @@
iota
if n != NUM*(NUM-1)/2 {
fmt.Println("BUG: wrong n", n, NUM*(NUM-1)/2)
+ runtime.Breakpoint() // panic is inaccessible
}
}
diff --git a/test/string_lit.go b/test/string_lit.go
index 457faaa..fea6f55 100644
--- a/test/string_lit.go
+++ b/test/string_lit.go
@@ -33,6 +33,7 @@
print("\ta[", i, "] = ", ac, "; b[", i, "] =", bc, "\n")
}
}
+ panic("string_lit")
}
}
@@ -110,7 +111,7 @@
r = -1
s = string(r)
assert(s, "\xef\xbf\xbd", "negative rune")
-
+
// the large rune tests again, this time using constants instead of a variable.
// these conversions will be done at compile time.
s = string(0x10ffff) // largest rune value
diff --git a/test/zerodivide.go b/test/zerodivide.go
index 673d1d1..9ab2713 100644
--- a/test/zerodivide.go
+++ b/test/zerodivide.go
@@ -237,4 +237,7 @@
fmt.Printf("%v/%v: expected %g error; got %g\n", t.f, t.g, t.out, x)
}
}
+ if bad {
+ panic("zerodivide")
+ }
}
