// $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")
}