...
Run Format

Source file test/zerodivide.go

Documentation: test

     1  // run
     2  
     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.
     6  
     7  // Test that zero division causes a panic.
     8  
     9  package main
    10  
    11  import (
    12  	"fmt"
    13  	"math"
    14  	"runtime"
    15  	"strings"
    16  )
    17  
    18  type ErrorTest struct {
    19  	name string
    20  	fn   func()
    21  	err  string
    22  }
    23  
    24  var (
    25  	i, j, k       int   = 0, 0, 1
    26  	i8, j8, k8    int8  = 0, 0, 1
    27  	i16, j16, k16 int16 = 0, 0, 1
    28  	i32, j32, k32 int32 = 0, 0, 1
    29  	i64, j64, k64 int64 = 0, 0, 1
    30  
    31  	bb = []int16{2, 0}
    32  
    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
    39  
    40  	f, g, h                         float64 = 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()
    43  
    44  	c, d, e          complex128 = 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
    47  )
    48  
    49  // Fool gccgo into thinking that these variables can change.
    50  func NotCalled() {
    51  	i++
    52  	j++
    53  	k++
    54  	i8++
    55  	j8++
    56  	k8++
    57  	i16++
    58  	j16++
    59  	k16++
    60  	i32++
    61  	j32++
    62  	k32++
    63  	i64++
    64  	j64++
    65  	k64++
    66  
    67  	u++
    68  	v++
    69  	w++
    70  	u8++
    71  	v8++
    72  	w8++
    73  	u16++
    74  	v16++
    75  	w16++
    76  	u32++
    77  	v32++
    78  	w32++
    79  	u64++
    80  	v64++
    81  	w64++
    82  	up++
    83  	vp++
    84  	wp++
    85  
    86  	f += 1
    87  	g += 1
    88  	h += 1
    89  	f32 += 1
    90  	g32 += 1
    91  	h32 += 1
    92  	f64 += 1
    93  	g64 += 1
    94  	h64 += 1
    95  
    96  	c += 1 + 1i
    97  	d += 1 + 1i
    98  	e += 1 + 1i
    99  	c64 += 1 + 1i
   100  	d64 += 1 + 1i
   101  	e64 += 1 + 1i
   102  	c128 += 1 + 1i
   103  	d128 += 1 + 1i
   104  	e128 += 1 + 1i
   105  }
   106  
   107  var tmp interface{}
   108  
   109  // We could assign to _ but the compiler optimizes it too easily.
   110  func use(v interface{}) {
   111  	tmp = v
   112  }
   113  
   114  // Verify error/no error for all types.
   115  var errorTests = []ErrorTest{
   116  	// All integer divide by zero should error.
   117  	ErrorTest{"int 0/0", func() { use(i / j) }, "divide"},
   118  	ErrorTest{"int8 0/0", func() { use(i8 / j8) }, "divide"},
   119  	ErrorTest{"int16 0/0", func() { use(i16 / j16) }, "divide"},
   120  	ErrorTest{"int32 0/0", func() { use(i32 / j32) }, "divide"},
   121  	ErrorTest{"int64 0/0", func() { use(i64 / j64) }, "divide"},
   122  
   123  	ErrorTest{"int 1/0", func() { use(k / j) }, "divide"},
   124  	ErrorTest{"int8 1/0", func() { use(k8 / j8) }, "divide"},
   125  	ErrorTest{"int16 1/0", func() { use(k16 / j16) }, "divide"},
   126  	ErrorTest{"int32 1/0", func() { use(k32 / j32) }, "divide"},
   127  	ErrorTest{"int64 1/0", func() { use(k64 / j64) }, "divide"},
   128  
   129  	// From issue 5790, we should ensure that _ assignments
   130  	// still evaluate and generate zerodivide panics.
   131  	ErrorTest{"int16 _ = bb[0]/bb[1]", func() { _ = bb[0] / bb[1] }, "divide"},
   132  
   133  	ErrorTest{"uint 0/0", func() { use(u / v) }, "divide"},
   134  	ErrorTest{"uint8 0/0", func() { use(u8 / v8) }, "divide"},
   135  	ErrorTest{"uint16 0/0", func() { use(u16 / v16) }, "divide"},
   136  	ErrorTest{"uint32 0/0", func() { use(u32 / v32) }, "divide"},
   137  	ErrorTest{"uint64 0/0", func() { use(u64 / v64) }, "divide"},
   138  	ErrorTest{"uintptr 0/0", func() { use(up / vp) }, "divide"},
   139  
   140  	ErrorTest{"uint 1/0", func() { use(w / v) }, "divide"},
   141  	ErrorTest{"uint8 1/0", func() { use(w8 / v8) }, "divide"},
   142  	ErrorTest{"uint16 1/0", func() { use(w16 / v16) }, "divide"},
   143  	ErrorTest{"uint32 1/0", func() { use(w32 / v32) }, "divide"},
   144  	ErrorTest{"uint64 1/0", func() { use(w64 / v64) }, "divide"},
   145  	ErrorTest{"uintptr 1/0", func() { use(wp / vp) }, "divide"},
   146  
   147  	// All float64ing divide by zero should not error.
   148  	ErrorTest{"float64 0/0", func() { use(f / g) }, ""},
   149  	ErrorTest{"float32 0/0", func() { use(f32 / g32) }, ""},
   150  	ErrorTest{"float64 0/0", func() { use(f64 / g64) }, ""},
   151  
   152  	ErrorTest{"float64 1/0", func() { use(h / g) }, ""},
   153  	ErrorTest{"float32 1/0", func() { use(h32 / g32) }, ""},
   154  	ErrorTest{"float64 1/0", func() { use(h64 / g64) }, ""},
   155  	ErrorTest{"float64 inf/0", func() { use(inf / g64) }, ""},
   156  	ErrorTest{"float64 -inf/0", func() { use(negInf / g64) }, ""},
   157  	ErrorTest{"float64 nan/0", func() { use(nan / g64) }, ""},
   158  
   159  	// All complex divide by zero should not error.
   160  	ErrorTest{"complex 0/0", func() { use(c / d) }, ""},
   161  	ErrorTest{"complex64 0/0", func() { use(c64 / d64) }, ""},
   162  	ErrorTest{"complex128 0/0", func() { use(c128 / d128) }, ""},
   163  
   164  	ErrorTest{"complex 1/0", func() { use(e / d) }, ""},
   165  	ErrorTest{"complex64 1/0", func() { use(e64 / d64) }, ""},
   166  	ErrorTest{"complex128 1/0", func() { use(e128 / d128) }, ""},
   167  }
   168  
   169  func error_(fn func()) (error string) {
   170  	defer func() {
   171  		if e := recover(); e != nil {
   172  			error = e.(runtime.Error).Error()
   173  		}
   174  	}()
   175  	fn()
   176  	return ""
   177  }
   178  
   179  type FloatTest struct {
   180  	f, g float64
   181  	out  float64
   182  }
   183  
   184  var float64Tests = []FloatTest{
   185  	FloatTest{0, 0, nan},
   186  	FloatTest{nan, 0, nan},
   187  	FloatTest{inf, 0, inf},
   188  	FloatTest{negInf, 0, negInf},
   189  }
   190  
   191  func alike(a, b float64) bool {
   192  	switch {
   193  	case math.IsNaN(a) && math.IsNaN(b):
   194  		return true
   195  	case a == b:
   196  		return math.Signbit(a) == math.Signbit(b)
   197  	}
   198  	return false
   199  }
   200  
   201  func main() {
   202  	bad := false
   203  	for _, t := range errorTests {
   204  		err := error_(t.fn)
   205  		switch {
   206  		case t.err == "" && err == "":
   207  			// fine
   208  		case t.err != "" && err == "":
   209  			if !bad {
   210  				bad = true
   211  				fmt.Printf("BUG\n")
   212  			}
   213  			fmt.Printf("%s: expected %q; got no error\n", t.name, t.err)
   214  		case t.err == "" && err != "":
   215  			if !bad {
   216  				bad = true
   217  				fmt.Printf("BUG\n")
   218  			}
   219  			fmt.Printf("%s: expected no error; got %q\n", t.name, err)
   220  		case t.err != "" && err != "":
   221  			if strings.Index(err, t.err) < 0 {
   222  				if !bad {
   223  					bad = true
   224  					fmt.Printf("BUG\n")
   225  				}
   226  				fmt.Printf("%s: expected %q; got %q\n", t.name, t.err, err)
   227  				continue
   228  			}
   229  		}
   230  	}
   231  
   232  	// At this point we know we don't error on the values we're testing
   233  	for _, t := range float64Tests {
   234  		x := t.f / t.g
   235  		if !alike(x, t.out) {
   236  			if !bad {
   237  				bad = true
   238  				fmt.Printf("BUG\n")
   239  			}
   240  			fmt.Printf("%v/%v: expected %g error; got %g\n", t.f, t.g, t.out, x)
   241  		}
   242  	}
   243  	if bad {
   244  		panic("zerodivide")
   245  	}
   246  }
   247  

View as plain text