URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [go.test/] [test/] [nil.go] - Blame information for rev 858

Go to most recent revision | Details | Compare with Previous | View Log


// $G $F.go && $L $F.$A && ./$A.out
 
// Copyright 2009 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.
 
package main
 
import (
        "fmt"
        "time"
)
 
type T struct {
        i int
}
 
type IN interface{}
 
func main() {
        var i *int
        var f *float32
        var s *string
        var m map[float32]*int
        var c chan int
        var t *T
        var in IN
        var ta []IN
 
        i = nil
        f = nil
        s = nil
        m = nil
        c = nil
        t = nil
        i = nil
        ta = make([]IN, 1)
        ta[0] = nil
 
        _, _, _, _, _, _, _, _ = i, f, s, m, c, t, in, ta
 
        arraytest()
        chantest()
        maptest()
        slicetest()
}
 
func shouldPanic(f func()) {
        defer func() {
                if recover() == nil {
                        panic("not panicking")
                }
        }()
        f()
}
 
func shouldBlock(f func()) {
        go func() {
                f()
                panic("did not block")
        }()
        time.Sleep(1e7)
}
 
// nil array pointer
 
func arraytest() {
        var p *[10]int
 
        // Looping over indices is fine.
        s := 0
        for i := range p {
                s += i
        }
        if s != 45 {
                panic(s)
        }
 
        s = 0
        for i := 0; i < len(p); i++ {
                s += i
        }
        if s != 45 {
                panic(s)
        }
 
        // Looping over values is not.
        shouldPanic(func() {
                for i, v := range p {
                        s += i + v
                }
        })
 
        shouldPanic(func() {
                for i := 0; i < len(p); i++ {
                        s += p[i]
                }
        })
}
 
// nil channel
// select tests already handle select on nil channel
 
func chantest() {
        var ch chan int
 
        // nil channel is never ready
        shouldBlock(func() {
                ch <- 1
        })
        shouldBlock(func() {
                <-ch
        })
        shouldBlock(func() {
                x, ok := <-ch
                println(x, ok)
        })
 
        if len(ch) != 0 {
                panic(len(ch))
        }
        if cap(ch) != 0 {
                panic(cap(ch))
        }
}
 
// nil map
 
func maptest() {
        var m map[int]int
 
        // nil map appears empty
        if len(m) != 0 {
                panic(len(m))
        }
        if m[1] != 0 {
                panic(m[1])
        }
        if x, ok := m[1]; x != 0 || ok {
                panic(fmt.Sprint(x, ok))
        }
 
        for k, v := range m {
                panic(k)
                panic(v)
        }
 
        // but cannot be written to
        shouldPanic(func() {
                m[2] = 3
        })
        shouldPanic(func() {
                delete(m, 2)
        })
}
 
// nil slice
 
func slicetest() {
        var x []int
 
        // nil slice is just a 0-element slice.
        if len(x) != 0 {
                panic(len(x))
        }
        if cap(x) != 0 {
                panic(cap(x))
        }
 
        // no 0-element slices can be read from or written to
        var s int
        shouldPanic(func() {
                s += x[1]
        })
        shouldPanic(func() {
                x[2] = s
        })
}

Line No.	Rev	Author	Line
1	700	jeremybenn	`// $G $F.go && $L $F.$A && ./$A.out`
2
3			`// Copyright 2009 The Go Authors. All rights reserved.`
4			`// Use of this source code is governed by a BSD-style`
5			`// license that can be found in the LICENSE file.`
6
7			`package main`
8
9			`import (`
10			`"fmt"`
11			`"time"`
12			`)`
13
14			`type T struct {`
15			`i int`
16			`}`
17
18			`type IN interface{}`
19
20			`func main() {`
21			`var i *int`
22			`var f *float32`
23			`var s *string`
24			`var m map[float32]*int`
25			`var c chan int`
26			`var t *T`
27			`var in IN`
28			`var ta []IN`
29
30			`i = nil`
31			`f = nil`
32			`s = nil`
33			`m = nil`
34			`c = nil`
35			`t = nil`
36			`i = nil`
37			`ta = make([]IN, 1)`
38			`ta[0] = nil`
39
40			`_, _, _, _, _, _, _, _ = i, f, s, m, c, t, in, ta`
41
42			`arraytest()`
43			`chantest()`
44			`maptest()`
45			`slicetest()`
46			`}`
47
48			`func shouldPanic(f func()) {`
49			`defer func() {`
50			`if recover() == nil {`
51			`panic("not panicking")`
52			`}`
53			`}()`
54			`f()`
55			`}`
56
57			`func shouldBlock(f func()) {`
58			`go func() {`
59			`f()`
60			`panic("did not block")`
61			`}()`
62			`time.Sleep(1e7)`
63			`}`
64
65			`// nil array pointer`
66
67			`func arraytest() {`
68			`var p *[10]int`
69
70			`// Looping over indices is fine.`
71			`s := 0`
72			`for i := range p {`
73			`s += i`
74			`}`
75			`if s != 45 {`
76			`panic(s)`
77			`}`
78
79			`s = 0`
80			`for i := 0; i < len(p); i++ {`
81			`s += i`
82			`}`
83			`if s != 45 {`
84			`panic(s)`
85			`}`
86
87			`// Looping over values is not.`
88			`shouldPanic(func() {`
89			`for i, v := range p {`
90			`s += i + v`
91			`}`
92			`})`
93
94			`shouldPanic(func() {`
95			`for i := 0; i < len(p); i++ {`
96			`s += p[i]`
97			`}`
98			`})`
99			`}`
100
101			`// nil channel`
102			`// select tests already handle select on nil channel`
103
104			`func chantest() {`
105			`var ch chan int`
106
107			`// nil channel is never ready`
108			`shouldBlock(func() {`
109			`ch <- 1`
110			`})`
111			`shouldBlock(func() {`
112			`<-ch`
113			`})`
114			`shouldBlock(func() {`
115			`x, ok := <-ch`
116			`println(x, ok)`
117			`})`
118
119			`if len(ch) != 0 {`
120			`panic(len(ch))`
121			`}`
122			`if cap(ch) != 0 {`
123			`panic(cap(ch))`
124			`}`
125			`}`
126
127			`// nil map`
128
129			`func maptest() {`
130			`var m map[int]int`
131
132			`// nil map appears empty`
133			`if len(m) != 0 {`
134			`panic(len(m))`
135			`}`
136			`if m[1] != 0 {`
137			`panic(m[1])`
138			`}`
139			`if x, ok := m[1]; x != 0 \|\| ok {`
140			`panic(fmt.Sprint(x, ok))`
141			`}`
142
143			`for k, v := range m {`
144			`panic(k)`
145			`panic(v)`
146			`}`
147
148			`// but cannot be written to`
149			`shouldPanic(func() {`
150			`m[2] = 3`
151			`})`
152			`shouldPanic(func() {`
153			`delete(m, 2)`
154			`})`
155			`}`
156
157			`// nil slice`
158
159			`func slicetest() {`
160			`var x []int`
161
162			`// nil slice is just a 0-element slice.`
163			`if len(x) != 0 {`
164			`panic(len(x))`
165			`}`
166			`if cap(x) != 0 {`
167			`panic(cap(x))`
168			`}`
169
170			`// no 0-element slices can be read from or written to`
171			`var s int`
172			`shouldPanic(func() {`
173			`s += x[1]`
174			`})`
175			`shouldPanic(func() {`
176			`x[2] = s`
177			`})`
178			`}`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [go.test/] [test/] [nil.go] - Blame information for rev 858