...
Run Format

Source file test/index.go

Documentation: test

  // skip
  
  // 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.
  
  // Generate test of index and slice bounds checks.
  // The actual tests are index0.go, index1.go, index2.go.
  
  package main
  
  import (
  	"bufio"
  	"fmt"
  	"os"
  	"unsafe"
  )
  
  const prolog = `
  
  package main
  
  import (
  	"runtime"
  )
  
  type quad struct { x, y, z, w int }
  
  const (
  	cj = 100011
  	ci int = 100012
  	ci8 int8 = 115
  	ci16 int16 = 10016
  	ci32 int32 = 100013
  	ci64 int64 = 100014
  	ci64big int64 = 1<<31
  	ci64bigger int64 = 1<<32
  	chuge = 1<<100
  	cfgood = 2.0
  	cfbad = 2.1
  
  	cnj = -2
  	cni int = -3
  	cni8 int8 = -6
  	cni16 int16 = -7
  	cni32 int32 = -4
  	cni64 int64 = -5
  	cni64big int64 = -1<<31
  	cni64bigger int64 = -1<<32
  	cnhuge = -1<<100
  	cnfgood = -2.0
  	cnfbad = -2.1
  )
  
  var j int = 100020
  var i int = 100021
  var i8 int8 = 126
  var i16 int16 = 10025
  var i32 int32 = 100022
  var i64 int64 = 100023
  var i64big int64 = 1<<31
  var i64bigger int64 = 1<<32
  var huge uint64 = 1<<64 - 1
  var fgood float64 = 2.0
  var fbad float64 = 2.1
  
  var nj int = -10
  var ni int = -11
  var ni8 int8 = -14
  var ni16 int16 = -15
  var ni32 int32 = -12
  var ni64 int64 = -13
  var ni64big int64 = -1<<31
  var ni64bigger int64 = -1<<32
  var nhuge int64 = -1<<63
  var nfgood float64 = -2.0
  var nfbad float64 = -2.1
  
  var si []int = make([]int, 10)
  var ai [10]int
  var pai *[10]int = &ai
  
  var sq []quad = make([]quad, 10)
  var aq [10]quad
  var paq *[10]quad = &aq
  
  var sib []int = make([]int, 100000)
  var aib [100000]int
  var paib *[100000]int = &aib
  
  var sqb []quad = make([]quad, 100000)
  var aqb [100000]quad
  var paqb *[100000]quad = &aqb
  
  type T struct {
  	si []int
  	ai [10]int
  	pai *[10]int
  	sq []quad
  	aq [10]quad
  	paq *[10]quad
  
  	sib []int
  	aib [100000]int
  	paib *[100000]int
  	sqb []quad
  	aqb [100000]quad
  	paqb *[100000]quad
  }
  
  var t = T{si, ai, pai, sq, aq, paq, sib, aib, paib, sqb, aqb, paqb}
  
  var pt = &T{si, ai, pai, sq, aq, paq, sib, aib, paib, sqb, aqb, paqb}
  
  // test that f panics
  func test(f func(), s string) {
  	defer func() {
  		if err := recover(); err == nil {
  			_, file, line, _ := runtime.Caller(2)
  			bug()
  			print(file, ":", line, ": ", s, " did not panic\n")
  		} else if !contains(err.(error).Error(), "out of range") {
  			_, file, line, _ := runtime.Caller(2)
  			bug()
  			print(file, ":", line, ": ", s, " unexpected panic: ", err.(error).Error(), "\n")
  		}
  	}()
  	f()
  }
  
  func contains(x, y string) bool {
  	for i := 0; i+len(y) <= len(x); i++ {
  		if x[i:i+len(y)] == y {
  			return true
  		}
  	}
  	return false
  }
  
  
  var X interface{}
  func use(y interface{}) {
  	X = y
  }
  
  var didBug = false
  
  func bug() {
  	if !didBug {
  		didBug = true
  		println("BUG")
  	}
  }
  
  func main() {
  `
  
  // pass variable set in index[012].go
  //	0 - dynamic checks
  //	1 - static checks of invalid constants (cannot assign to types)
  //	2 - static checks of array bounds
  
  func testExpr(b *bufio.Writer, expr string) {
  	if pass == 0 {
  		fmt.Fprintf(b, "\ttest(func(){use(%s)}, %q)\n", expr, expr)
  	} else {
  		fmt.Fprintf(b, "\tuse(%s)  // ERROR \"index|overflow|truncated|must be integer\"\n", expr)
  	}
  }
  
  func main() {
  	b := bufio.NewWriter(os.Stdout)
  
  	if pass == 0 {
  		fmt.Fprint(b, "// run\n\n")
  	} else {
  		fmt.Fprint(b, "// errorcheck\n\n")
  	}
  	fmt.Fprint(b, prolog)
  
  	var choices = [][]string{
  		// Direct value, fetch from struct, fetch from struct pointer.
  		// The last two cases get us to oindex_const_sudo in gsubr.c.
  		[]string{"", "t.", "pt."},
  
  		// Array, pointer to array, slice.
  		[]string{"a", "pa", "s"},
  
  		// Element is int, element is quad (struct).
  		// This controls whether we end up in gsubr.c (i) or cgen.c (q).
  		[]string{"i", "q"},
  
  		// Small or big len.
  		[]string{"", "b"},
  
  		// Variable or constant.
  		[]string{"", "c"},
  
  		// Positive or negative.
  		[]string{"", "n"},
  
  		// Size of index.
  		[]string{"j", "i", "i8", "i16", "i32", "i64", "i64big", "i64bigger", "huge", "fgood", "fbad"},
  	}
  
  	forall(choices, func(x []string) {
  		p, a, e, big, c, n, i := x[0], x[1], x[2], x[3], x[4], x[5], x[6]
  
  		// Pass: dynamic=0, static=1, 2.
  		// Which cases should be caught statically?
  		// Only constants, obviously.
  		// Beyond that, must be one of these:
  		//	indexing into array or pointer to array
  		//	negative constant
  		//	large constant
  		thisPass := 0
  		if c == "c" && (a == "a" || a == "pa" || n == "n" || i == "i64big" || i == "i64bigger" || i == "huge" || i == "fbad") {
  			if i == "huge" {
  				// Due to a detail of gc's internals,
  				// the huge constant errors happen in an
  				// earlier pass than the others and inhibits
  				// the next pass from running.
  				// So run it as a separate check.
  				thisPass = 1
  			} else if a == "s" && n == "" && (i == "i64big" || i == "i64bigger") && unsafe.Sizeof(int(0)) > 4 {
  				// If int is 64 bits, these huge
  				// numbers do fit in an int, so they
  				// are not rejected at compile time.
  				thisPass = 0
  			} else {
  				thisPass = 2
  			}
  		}
  
  		pae := p + a + e + big
  		cni := c + n + i
  
  		// If we're using the big-len data, positive int8 and int16 cannot overflow.
  		if big == "b" && n == "" && (i == "i8" || i == "i16") {
  			if pass == 0 {
  				fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni)
  				fmt.Fprintf(b, "\tuse(%s[0:%s])\n", pae, cni)
  				fmt.Fprintf(b, "\tuse(%s[1:%s])\n", pae, cni)
  				fmt.Fprintf(b, "\tuse(%s[%s:])\n", pae, cni)
  				fmt.Fprintf(b, "\tuse(%s[%s:%s])\n", pae, cni, cni)
  			}
  			return
  		}
  
  		// Float variables cannot be used as indices.
  		if c == "" && (i == "fgood" || i == "fbad") {
  			return
  		}
  		// Integral float constat is ok.
  		if c == "c" && n == "" && i == "fgood" {
  			if pass == 0 {
  				fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni)
  				fmt.Fprintf(b, "\tuse(%s[0:%s])\n", pae, cni)
  				fmt.Fprintf(b, "\tuse(%s[1:%s])\n", pae, cni)
  				fmt.Fprintf(b, "\tuse(%s[%s:])\n", pae, cni)
  				fmt.Fprintf(b, "\tuse(%s[%s:%s])\n", pae, cni, cni)
  			}
  			return
  		}
  
  		// Only print the test case if it is appropriate for this pass.
  		if thisPass == pass {
  			// Index operation
  			testExpr(b, pae+"["+cni+"]")
  
  			// Slice operation.
  			// Low index 0 is a special case in ggen.c
  			// so test both 0 and 1.
  			testExpr(b, pae+"[0:"+cni+"]")
  			testExpr(b, pae+"[1:"+cni+"]")
  			testExpr(b, pae+"["+cni+":]")
  			testExpr(b, pae+"["+cni+":"+cni+"]")
  		}
  	})
  
  	fmt.Fprintln(b, "}")
  	b.Flush()
  }
  
  func forall(choices [][]string, f func([]string)) {
  	x := make([]string, len(choices))
  
  	var recurse func(d int)
  	recurse = func(d int) {
  		if d >= len(choices) {
  			f(x)
  			return
  		}
  		for _, x[d] = range choices[d] {
  			recurse(d + 1)
  		}
  	}
  	recurse(0)
  }
  

View as plain text