1 // $G $F.go && $L $F.$A && ./$A.out
3 // Copyright 2010 The Go Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file.
16 type Error interface {
20 type ErrorTest struct {
28 i8, j8, k8 int8 = 0, 0, 1
29 i16, j16, k16 int16 = 0, 0, 1
30 i32, j32, k32 int32 = 0, 0, 1
31 i64, j64, k64 int64 = 0, 0, 1
33 u, v, w uint = 0, 0, 1
34 u8, v8, w8 uint8 = 0, 0, 1
35 u16, v16, w16 uint16 = 0, 0, 1
36 u32, v32, w32 uint32 = 0, 0, 1
37 u64, v64, w64 uint64 = 0, 0, 1
38 up, vp, wp uintptr = 0, 0, 1
40 f, g, h float = 0, 0, 1
41 f32, g32, h32 float32 = 0, 0, 1
42 f64, g64, h64, inf, negInf, nan float64 = 0, 0, 1, math.Inf(1), math.Inf(-1), math.NaN()
44 c, d, e complex = 0+0i, 0+0i, 1+1i
45 c64, d64, e64 complex64 = 0+0i, 0+0i, 1+1i
46 c128, d128, e128 complex128 = 0+0i, 0+0i, 1+1i
51 // We could assign to _ but the compiler optimizes it too easily.
52 func use(v interface{}) {
56 // Verify error/no error for all types.
57 var errorTests = []ErrorTest{
58 // All integer divide by zero should error.
59 ErrorTest{ "int 0/0", func() { use(i/j) }, "divide", },
60 ErrorTest{ "int8 0/0", func() { use(i8/j8) }, "divide", },
61 ErrorTest{ "int16 0/0", func() { use(i16/j16) }, "divide", },
62 ErrorTest{ "int32 0/0", func() { use(i32/j32) }, "divide", },
63 ErrorTest{ "int64 0/0", func() { use(i64/j64) }, "divide", },
65 ErrorTest{ "int 1/0", func() { use(k/j) }, "divide", },
66 ErrorTest{ "int8 1/0", func() { use(k8/j8) }, "divide", },
67 ErrorTest{ "int16 1/0", func() { use(k16/j16) }, "divide", },
68 ErrorTest{ "int32 1/0", func() { use(k32/j32) }, "divide", },
69 ErrorTest{ "int64 1/0", func() { use(k64/j64) }, "divide", },
71 ErrorTest{ "uint 0/0", func() { use(u/v) }, "divide", },
72 ErrorTest{ "uint8 0/0", func() { use(u8/v8) }, "divide", },
73 ErrorTest{ "uint16 0/0", func() { use(u16/v16) }, "divide", },
74 ErrorTest{ "uint32 0/0", func() { use(u32/v32) }, "divide", },
75 ErrorTest{ "uint64 0/0", func() { use(u64/v64) }, "divide", },
76 ErrorTest{ "uintptr 0/0", func() { use(up/vp) }, "divide", },
78 ErrorTest{ "uint 1/0", func() { use(w/v) }, "divide", },
79 ErrorTest{ "uint8 1/0", func() { use(w8/v8) }, "divide", },
80 ErrorTest{ "uint16 1/0", func() { use(w16/v16) }, "divide", },
81 ErrorTest{ "uint32 1/0", func() { use(w32/v32) }, "divide", },
82 ErrorTest{ "uint64 1/0", func() { use(w64/v64) }, "divide", },
83 ErrorTest{ "uintptr 1/0", func() { use(wp/vp) }, "divide", },
85 // All floating divide by zero should not error.
86 ErrorTest{ "float 0/0", func() { use(f/g) }, "", },
87 ErrorTest{ "float32 0/0", func() { use(f32/g32) }, "", },
88 ErrorTest{ "float64 0/0", func() { use(f64/g64) }, "", },
90 ErrorTest{ "float 1/0", func() { use(h/g) }, "", },
91 ErrorTest{ "float32 1/0", func() { use(h32/g32) }, "", },
92 ErrorTest{ "float64 1/0", func() { use(h64/g64) }, "", },
93 ErrorTest{ "float64 inf/0", func() { use(inf/g64) }, "", },
94 ErrorTest{ "float64 -inf/0", func() { use(negInf/g64) }, "", },
95 ErrorTest{ "float64 nan/0", func() { use(nan/g64) }, "", },
97 // All complex divide by zero should not error.
98 ErrorTest{ "complex 0/0", func() { use(c/d) }, "", },
99 ErrorTest{ "complex64 0/0", func() { use(c64/d64) }, "", },
100 ErrorTest{ "complex128 0/0", func() { use(c128/d128) }, "", },
102 ErrorTest{ "complex 1/0", func() { use(e/d) }, "", },
103 ErrorTest{ "complex64 1/0", func() { use(e64/d64) }, "", },
104 ErrorTest{ "complex128 1/0", func() { use(e128/d128) }, "", },
107 func error(fn func()) (error string) {
109 if e := recover(); e != nil {
110 error = e.(Error).String()
117 type FloatTest struct{
122 var floatTests = []FloatTest{
123 FloatTest{0, 0, nan},
124 FloatTest{nan, 0, nan},
125 FloatTest{inf, 0, inf},
126 FloatTest{negInf, 0, negInf},
129 func alike(a, b float64) bool {
131 case math.IsNaN(a) && math.IsNaN(b):
134 return math.Signbit(a) == math.Signbit(b)
141 for _, t := range errorTests {
142 if t.err != "" && syscall.OS == "nacl" {
147 case t.err == "" && err == "":
149 case t.err != "" && err == "":
150 fmt.Printf("%s: expected %q; got no error\n", t.name, t.err)
151 case t.err == "" && err != "":
152 fmt.Printf("%s: expected no error; got %q\n", t.name, err)
153 case t.err != "" && err != "":
154 if strings.Index(err, t.err) < 0 {
155 fmt.Printf("%s: expected %q; got %q\n", t.name, t.err, err)
161 // At this point we know we don't error on the values we're testing
162 for _, t := range floatTests {
164 if !alike(x, t.out) {
169 fmt.Printf("%v/%v: expected %g error; got %g\n", t.f, t.g, t.out, x)