| // $G $D/$F.go && $L $F.$A && ./$A.out |
| |
| // 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. |
| |
| // http://code.google.com/p/go/issues/detail?id=589 |
| |
| package main |
| |
| import "unsafe" |
| |
| var bug = false |
| |
| var minus1 = -1 |
| var big int64 = 10 | 1<<32 |
| |
| func shouldfail(f func(), desc string) { |
| defer func() { recover() }() |
| f() |
| if !bug { |
| println("BUG") |
| bug = true |
| } |
| println("didn't crash: ", desc) |
| } |
| |
| func badlen() { |
| _ = make([]int, minus1) |
| } |
| |
| func biglen() { |
| _ = make([]int, big) |
| } |
| |
| func badcap() { |
| _ = make([]int, 10, minus1) |
| } |
| |
| func badcap1() { |
| _ = make([]int, 10, 5) |
| } |
| |
| func bigcap() { |
| _ = make([]int, 10, big) |
| } |
| |
| const ( |
| addrBits = 8*uint(unsafe.Sizeof((*byte)(nil))) |
| sh = addrBits/2 - 2 |
| ) |
| func overflow() { |
| _ = make([][1<<sh][1<<sh]byte, 64) |
| } |
| |
| func badmapcap() { |
| _ = make(map[int]int, minus1) |
| } |
| |
| func bigmapcap() { |
| _ = make(map[int]int, big) |
| } |
| |
| func badchancap() { |
| _ = make(chan int, minus1) |
| } |
| |
| func bigchancap() { |
| _ = make(chan int, big) |
| } |
| |
| func overflowchan() { |
| if addrBits == 32 { |
| _ = make(chan [1<<15]byte, 1<<20) |
| } else { |
| // cannot overflow on 64-bit, because |
| // int is 32 bits and max chan value size |
| // in the implementation is 64 kB. |
| panic(1) |
| } |
| } |
| |
| func main() { |
| shouldfail(badlen, "badlen") |
| shouldfail(biglen, "biglen") |
| shouldfail(badcap, "badcap") |
| shouldfail(badcap1, "badcap1") |
| shouldfail(bigcap, "bigcap") |
| shouldfail(overflow, "overflow") |
| shouldfail(badmapcap, "badmapcap") |
| shouldfail(bigmapcap, "bigmapcap") |
| shouldfail(badchancap, "badchancap") |
| shouldfail(bigchancap, "bigchancap") |
| shouldfail(overflowchan, "overflowchan") |
| } |