diff options
Diffstat (limited to '')
| -rw-r--r-- | test/index.go | 299 |
1 files changed, 299 insertions, 0 deletions
diff --git a/test/index.go b/test/index.go new file mode 100644 index 0000000..91195ad --- /dev/null +++ b/test/index.go @@ -0,0 +1,299 @@ +// 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 constant 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) +} |