Subversion Repositories openrisc

// $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

var g1 []int

func shouldfail(f func(), desc string) {
        defer func() { recover() }()
        f()
        if !bug {
                println("BUG")
                bug = true
        }
        println("didn't crash: ", desc)
}

func badlen() {
        g1 = make([]int, minus1)
}

func biglen() {
        g1 = make([]int, big)
}

func badcap() {
        g1 = make([]int, 10, minus1)
}

func badcap1() {
        g1 = make([]int, 10, 5)
}

func bigcap() {
        g1 = make([]int, 10, big)
}

var g3 map[int]int
func badmapcap() {
        g3 = make(map[int]int, minus1)
}

func bigmapcap() {
        g3 = make(map[int]int, big)
}

var g4 chan int
func badchancap() {
        g4 = make(chan int, minus1)
}

func bigchancap() {
        g4 = make(chan int, big)
}

const addrBits = unsafe.Sizeof((*byte)(nil))

var g5 chan [1<<15]byte
func overflowchan() {
        if addrBits == 32 {
                g5 = 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(badmapcap, "badmapcap")
        shouldfail(bigmapcap, "bigmapcap")
        shouldfail(badchancap, "badchancap")
        shouldfail(bigchancap, "bigchancap")
        shouldfail(overflowchan, "overflowchan")
}