...
Run Format

Source file test/index.go

Documentation: test

     1  // skip
     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  // Generate test of index and slice bounds checks.
     8  // The actual tests are index0.go, index1.go, index2.go.
     9  
    10  package main
    11  
    12  import (
    13  	"bufio"
    14  	"fmt"
    15  	"os"
    16  	"unsafe"
    17  )
    18  
    19  const prolog = `
    20  
    21  package main
    22  
    23  import (
    24  	"runtime"
    25  )
    26  
    27  type quad struct { x, y, z, w int }
    28  
    29  const (
    30  	cj = 100011
    31  	ci int = 100012
    32  	ci8 int8 = 115
    33  	ci16 int16 = 10016
    34  	ci32 int32 = 100013
    35  	ci64 int64 = 100014
    36  	ci64big int64 = 1<<31
    37  	ci64bigger int64 = 1<<32
    38  	chuge = 1<<100
    39  	cfgood = 2.0
    40  	cfbad = 2.1
    41  
    42  	cnj = -2
    43  	cni int = -3
    44  	cni8 int8 = -6
    45  	cni16 int16 = -7
    46  	cni32 int32 = -4
    47  	cni64 int64 = -5
    48  	cni64big int64 = -1<<31
    49  	cni64bigger int64 = -1<<32
    50  	cnhuge = -1<<100
    51  	cnfgood = -2.0
    52  	cnfbad = -2.1
    53  )
    54  
    55  var j int = 100020
    56  var i int = 100021
    57  var i8 int8 = 126
    58  var i16 int16 = 10025
    59  var i32 int32 = 100022
    60  var i64 int64 = 100023
    61  var i64big int64 = 1<<31
    62  var i64bigger int64 = 1<<32
    63  var huge uint64 = 1<<64 - 1
    64  var fgood float64 = 2.0
    65  var fbad float64 = 2.1
    66  
    67  var nj int = -10
    68  var ni int = -11
    69  var ni8 int8 = -14
    70  var ni16 int16 = -15
    71  var ni32 int32 = -12
    72  var ni64 int64 = -13
    73  var ni64big int64 = -1<<31
    74  var ni64bigger int64 = -1<<32
    75  var nhuge int64 = -1<<63
    76  var nfgood float64 = -2.0
    77  var nfbad float64 = -2.1
    78  
    79  var si []int = make([]int, 10)
    80  var ai [10]int
    81  var pai *[10]int = &ai
    82  
    83  var sq []quad = make([]quad, 10)
    84  var aq [10]quad
    85  var paq *[10]quad = &aq
    86  
    87  var sib []int = make([]int, 100000)
    88  var aib [100000]int
    89  var paib *[100000]int = &aib
    90  
    91  var sqb []quad = make([]quad, 100000)
    92  var aqb [100000]quad
    93  var paqb *[100000]quad = &aqb
    94  
    95  type T struct {
    96  	si []int
    97  	ai [10]int
    98  	pai *[10]int
    99  	sq []quad
   100  	aq [10]quad
   101  	paq *[10]quad
   102  
   103  	sib []int
   104  	aib [100000]int
   105  	paib *[100000]int
   106  	sqb []quad
   107  	aqb [100000]quad
   108  	paqb *[100000]quad
   109  }
   110  
   111  var t = T{si, ai, pai, sq, aq, paq, sib, aib, paib, sqb, aqb, paqb}
   112  
   113  var pt = &T{si, ai, pai, sq, aq, paq, sib, aib, paib, sqb, aqb, paqb}
   114  
   115  // test that f panics
   116  func test(f func(), s string) {
   117  	defer func() {
   118  		if err := recover(); err == nil {
   119  			_, file, line, _ := runtime.Caller(2)
   120  			bug()
   121  			print(file, ":", line, ": ", s, " did not panic\n")
   122  		} else if !contains(err.(error).Error(), "out of range") {
   123  			_, file, line, _ := runtime.Caller(2)
   124  			bug()
   125  			print(file, ":", line, ": ", s, " unexpected panic: ", err.(error).Error(), "\n")
   126  		}
   127  	}()
   128  	f()
   129  }
   130  
   131  func contains(x, y string) bool {
   132  	for i := 0; i+len(y) <= len(x); i++ {
   133  		if x[i:i+len(y)] == y {
   134  			return true
   135  		}
   136  	}
   137  	return false
   138  }
   139  
   140  
   141  var X interface{}
   142  func use(y interface{}) {
   143  	X = y
   144  }
   145  
   146  var didBug = false
   147  
   148  func bug() {
   149  	if !didBug {
   150  		didBug = true
   151  		println("BUG")
   152  	}
   153  }
   154  
   155  func main() {
   156  `
   157  
   158  // pass variable set in index[012].go
   159  //	0 - dynamic checks
   160  //	1 - static checks of invalid constants (cannot assign to types)
   161  //	2 - static checks of array bounds
   162  
   163  func testExpr(b *bufio.Writer, expr string) {
   164  	if pass == 0 {
   165  		fmt.Fprintf(b, "\ttest(func(){use(%s)}, %q)\n", expr, expr)
   166  	} else {
   167  		fmt.Fprintf(b, "\tuse(%s)  // ERROR \"index|overflow|truncated|must be integer\"\n", expr)
   168  	}
   169  }
   170  
   171  func main() {
   172  	b := bufio.NewWriter(os.Stdout)
   173  
   174  	if pass == 0 {
   175  		fmt.Fprint(b, "// run\n\n")
   176  	} else {
   177  		fmt.Fprint(b, "// errorcheck\n\n")
   178  	}
   179  	fmt.Fprint(b, prolog)
   180  
   181  	var choices = [][]string{
   182  		// Direct value, fetch from struct, fetch from struct pointer.
   183  		// The last two cases get us to oindex_const_sudo in gsubr.c.
   184  		[]string{"", "t.", "pt."},
   185  
   186  		// Array, pointer to array, slice.
   187  		[]string{"a", "pa", "s"},
   188  
   189  		// Element is int, element is quad (struct).
   190  		// This controls whether we end up in gsubr.c (i) or cgen.c (q).
   191  		[]string{"i", "q"},
   192  
   193  		// Small or big len.
   194  		[]string{"", "b"},
   195  
   196  		// Variable or constant.
   197  		[]string{"", "c"},
   198  
   199  		// Positive or negative.
   200  		[]string{"", "n"},
   201  
   202  		// Size of index.
   203  		[]string{"j", "i", "i8", "i16", "i32", "i64", "i64big", "i64bigger", "huge", "fgood", "fbad"},
   204  	}
   205  
   206  	forall(choices, func(x []string) {
   207  		p, a, e, big, c, n, i := x[0], x[1], x[2], x[3], x[4], x[5], x[6]
   208  
   209  		// Pass: dynamic=0, static=1, 2.
   210  		// Which cases should be caught statically?
   211  		// Only constants, obviously.
   212  		// Beyond that, must be one of these:
   213  		//	indexing into array or pointer to array
   214  		//	negative constant
   215  		//	large constant
   216  		thisPass := 0
   217  		if c == "c" && (a == "a" || a == "pa" || n == "n" || i == "i64big" || i == "i64bigger" || i == "huge" || i == "fbad") {
   218  			if i == "huge" {
   219  				// Due to a detail of gc's internals,
   220  				// the huge constant errors happen in an
   221  				// earlier pass than the others and inhibits
   222  				// the next pass from running.
   223  				// So run it as a separate check.
   224  				thisPass = 1
   225  			} else if a == "s" && n == "" && (i == "i64big" || i == "i64bigger") && unsafe.Sizeof(int(0)) > 4 {
   226  				// If int is 64 bits, these huge
   227  				// numbers do fit in an int, so they
   228  				// are not rejected at compile time.
   229  				thisPass = 0
   230  			} else {
   231  				thisPass = 2
   232  			}
   233  		}
   234  
   235  		pae := p + a + e + big
   236  		cni := c + n + i
   237  
   238  		// If we're using the big-len data, positive int8 and int16 cannot overflow.
   239  		if big == "b" && n == "" && (i == "i8" || i == "i16") {
   240  			if pass == 0 {
   241  				fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni)
   242  				fmt.Fprintf(b, "\tuse(%s[0:%s])\n", pae, cni)
   243  				fmt.Fprintf(b, "\tuse(%s[1:%s])\n", pae, cni)
   244  				fmt.Fprintf(b, "\tuse(%s[%s:])\n", pae, cni)
   245  				fmt.Fprintf(b, "\tuse(%s[%s:%s])\n", pae, cni, cni)
   246  			}
   247  			return
   248  		}
   249  
   250  		// Float variables cannot be used as indices.
   251  		if c == "" && (i == "fgood" || i == "fbad") {
   252  			return
   253  		}
   254  		// Integral float constat is ok.
   255  		if c == "c" && n == "" && i == "fgood" {
   256  			if pass == 0 {
   257  				fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni)
   258  				fmt.Fprintf(b, "\tuse(%s[0:%s])\n", pae, cni)
   259  				fmt.Fprintf(b, "\tuse(%s[1:%s])\n", pae, cni)
   260  				fmt.Fprintf(b, "\tuse(%s[%s:])\n", pae, cni)
   261  				fmt.Fprintf(b, "\tuse(%s[%s:%s])\n", pae, cni, cni)
   262  			}
   263  			return
   264  		}
   265  
   266  		// Only print the test case if it is appropriate for this pass.
   267  		if thisPass == pass {
   268  			// Index operation
   269  			testExpr(b, pae+"["+cni+"]")
   270  
   271  			// Slice operation.
   272  			// Low index 0 is a special case in ggen.c
   273  			// so test both 0 and 1.
   274  			testExpr(b, pae+"[0:"+cni+"]")
   275  			testExpr(b, pae+"[1:"+cni+"]")
   276  			testExpr(b, pae+"["+cni+":]")
   277  			testExpr(b, pae+"["+cni+":"+cni+"]")
   278  		}
   279  	})
   280  
   281  	fmt.Fprintln(b, "}")
   282  	b.Flush()
   283  }
   284  
   285  func forall(choices [][]string, f func([]string)) {
   286  	x := make([]string, len(choices))
   287  
   288  	var recurse func(d int)
   289  	recurse = func(d int) {
   290  		if d >= len(choices) {
   291  			f(x)
   292  			return
   293  		}
   294  		for _, x[d] = range choices[d] {
   295  			recurse(d + 1)
   296  		}
   297  	}
   298  	recurse(0)
   299  }
   300  

View as plain text