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/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
