diff options
Diffstat (limited to 'test/zerodivide.go')
| -rw-r--r-- | test/zerodivide.go | 246 |
1 files changed, 246 insertions, 0 deletions
diff --git a/test/zerodivide.go b/test/zerodivide.go new file mode 100644 index 0000000..fd36d67 --- /dev/null +++ b/test/zerodivide.go @@ -0,0 +1,246 @@ +// run + +// Copyright 2010 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Test that zero division causes a panic. + +package main + +import ( + "fmt" + "math" + "runtime" + "strings" +) + +type ErrorTest struct { + name string + fn func() + err string +} + +var ( + i, j, k int = 0, 0, 1 + i8, j8, k8 int8 = 0, 0, 1 + i16, j16, k16 int16 = 0, 0, 1 + i32, j32, k32 int32 = 0, 0, 1 + i64, j64, k64 int64 = 0, 0, 1 + + bb = []int16{2, 0} + + u, v, w uint = 0, 0, 1 + u8, v8, w8 uint8 = 0, 0, 1 + u16, v16, w16 uint16 = 0, 0, 1 + u32, v32, w32 uint32 = 0, 0, 1 + u64, v64, w64 uint64 = 0, 0, 1 + up, vp, wp uintptr = 0, 0, 1 + + f, g, h float64 = 0, 0, 1 + f32, g32, h32 float32 = 0, 0, 1 + f64, g64, h64, inf, negInf, nan float64 = 0, 0, 1, math.Inf(1), math.Inf(-1), math.NaN() + + c, d, e complex128 = 0 + 0i, 0 + 0i, 1 + 1i + c64, d64, e64 complex64 = 0 + 0i, 0 + 0i, 1 + 1i + c128, d128, e128 complex128 = 0 + 0i, 0 + 0i, 1 + 1i +) + +// Fool gccgo into thinking that these variables can change. +func NotCalled() { + i++ + j++ + k++ + i8++ + j8++ + k8++ + i16++ + j16++ + k16++ + i32++ + j32++ + k32++ + i64++ + j64++ + k64++ + + u++ + v++ + w++ + u8++ + v8++ + w8++ + u16++ + v16++ + w16++ + u32++ + v32++ + w32++ + u64++ + v64++ + w64++ + up++ + vp++ + wp++ + + f += 1 + g += 1 + h += 1 + f32 += 1 + g32 += 1 + h32 += 1 + f64 += 1 + g64 += 1 + h64 += 1 + + c += 1 + 1i + d += 1 + 1i + e += 1 + 1i + c64 += 1 + 1i + d64 += 1 + 1i + e64 += 1 + 1i + c128 += 1 + 1i + d128 += 1 + 1i + e128 += 1 + 1i +} + +var tmp interface{} + +// We could assign to _ but the compiler optimizes it too easily. +func use(v interface{}) { + tmp = v +} + +// Verify error/no error for all types. +var errorTests = []ErrorTest{ + // All integer divide by zero should error. + ErrorTest{"int 0/0", func() { use(i / j) }, "divide"}, + ErrorTest{"int8 0/0", func() { use(i8 / j8) }, "divide"}, + ErrorTest{"int16 0/0", func() { use(i16 / j16) }, "divide"}, + ErrorTest{"int32 0/0", func() { use(i32 / j32) }, "divide"}, + ErrorTest{"int64 0/0", func() { use(i64 / j64) }, "divide"}, + + ErrorTest{"int 1/0", func() { use(k / j) }, "divide"}, + ErrorTest{"int8 1/0", func() { use(k8 / j8) }, "divide"}, + ErrorTest{"int16 1/0", func() { use(k16 / j16) }, "divide"}, + ErrorTest{"int32 1/0", func() { use(k32 / j32) }, "divide"}, + ErrorTest{"int64 1/0", func() { use(k64 / j64) }, "divide"}, + + // From issue 5790, we should ensure that _ assignments + // still evaluate and generate zerodivide panics. + ErrorTest{"int16 _ = bb[0]/bb[1]", func() { _ = bb[0] / bb[1] }, "divide"}, + + ErrorTest{"uint 0/0", func() { use(u / v) }, "divide"}, + ErrorTest{"uint8 0/0", func() { use(u8 / v8) }, "divide"}, + ErrorTest{"uint16 0/0", func() { use(u16 / v16) }, "divide"}, + ErrorTest{"uint32 0/0", func() { use(u32 / v32) }, "divide"}, + ErrorTest{"uint64 0/0", func() { use(u64 / v64) }, "divide"}, + ErrorTest{"uintptr 0/0", func() { use(up / vp) }, "divide"}, + + ErrorTest{"uint 1/0", func() { use(w / v) }, "divide"}, + ErrorTest{"uint8 1/0", func() { use(w8 / v8) }, "divide"}, + ErrorTest{"uint16 1/0", func() { use(w16 / v16) }, "divide"}, + ErrorTest{"uint32 1/0", func() { use(w32 / v32) }, "divide"}, + ErrorTest{"uint64 1/0", func() { use(w64 / v64) }, "divide"}, + ErrorTest{"uintptr 1/0", func() { use(wp / vp) }, "divide"}, + + // All float64ing divide by zero should not error. + ErrorTest{"float64 0/0", func() { use(f / g) }, ""}, + ErrorTest{"float32 0/0", func() { use(f32 / g32) }, ""}, + ErrorTest{"float64 0/0", func() { use(f64 / g64) }, ""}, + + ErrorTest{"float64 1/0", func() { use(h / g) }, ""}, + ErrorTest{"float32 1/0", func() { use(h32 / g32) }, ""}, + ErrorTest{"float64 1/0", func() { use(h64 / g64) }, ""}, + ErrorTest{"float64 inf/0", func() { use(inf / g64) }, ""}, + ErrorTest{"float64 -inf/0", func() { use(negInf / g64) }, ""}, + ErrorTest{"float64 nan/0", func() { use(nan / g64) }, ""}, + + // All complex divide by zero should not error. + ErrorTest{"complex 0/0", func() { use(c / d) }, ""}, + ErrorTest{"complex64 0/0", func() { use(c64 / d64) }, ""}, + ErrorTest{"complex128 0/0", func() { use(c128 / d128) }, ""}, + + ErrorTest{"complex 1/0", func() { use(e / d) }, ""}, + ErrorTest{"complex64 1/0", func() { use(e64 / d64) }, ""}, + ErrorTest{"complex128 1/0", func() { use(e128 / d128) }, ""}, +} + +func error_(fn func()) (error string) { + defer func() { + if e := recover(); e != nil { + error = e.(runtime.Error).Error() + } + }() + fn() + return "" +} + +type FloatTest struct { + f, g float64 + out float64 +} + +var float64Tests = []FloatTest{ + FloatTest{0, 0, nan}, + FloatTest{nan, 0, nan}, + FloatTest{inf, 0, inf}, + FloatTest{negInf, 0, negInf}, +} + +func alike(a, b float64) bool { + switch { + case math.IsNaN(a) && math.IsNaN(b): + return true + case a == b: + return math.Signbit(a) == math.Signbit(b) + } + return false +} + +func main() { + bad := false + for _, t := range errorTests { + err := error_(t.fn) + switch { + case t.err == "" && err == "": + // fine + case t.err != "" && err == "": + if !bad { + bad = true + fmt.Printf("BUG\n") + } + fmt.Printf("%s: expected %q; got no error\n", t.name, t.err) + case t.err == "" && err != "": + if !bad { + bad = true + fmt.Printf("BUG\n") + } + fmt.Printf("%s: expected no error; got %q\n", t.name, err) + case t.err != "" && err != "": + if !strings.Contains(err, t.err) { + if !bad { + bad = true + fmt.Printf("BUG\n") + } + fmt.Printf("%s: expected %q; got %q\n", t.name, t.err, err) + continue + } + } + } + + // At this point we know we don't error on the values we're testing + for _, t := range float64Tests { + x := t.f / t.g + if !alike(x, t.out) { + if !bad { + bad = true + fmt.Printf("BUG\n") + } + fmt.Printf("%v/%v: expected %g error; got %g\n", t.f, t.g, t.out, x) + } + } + if bad { + panic("zerodivide") + } +} |