code stringlengths 10 1.34M | language stringclasses 1
value |
|---|---|
// $G $D/$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.
// Check methods with different return types.
package main
type S struct { a int }
type T struct { b string }
func (s... | Go |
// true # used by private.go
// Copyright 2011 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 p
type Exported interface {
private()
}
type Implementation struct{}
func (p *Implementation) private() {}
var X = n... | Go |
// $G $D/$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.
// check that big vs small, pointer vs not
// interface methods work.
package main
type I interface { M() int64 }
typ... | Go |
// true # used by embed1.go
// 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.
// Check that embedded interface types can have local methods.
package p
type T int
func (t T) m() {}
type I interface { m() }
t... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: interface/noeq
// Copyright 2011 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.
// Interface values containing types that cannot be compared for equality.
package main
f... | Go |
// errchk $G -e $D/$F.go
// 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
func main() {
var n byte // ERROR "not a type|expected type"
var y = float(0) // ERROR "cannot call|expected fu... | Go |
// errchk $G -e $D/$F.go
// Copyright 2011 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.
// Each test is in a separate function just so that if the
// compiler stops processing after one error, we don't
// lose other ones.... | Go |
// $G $D/$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.
// trivial finalizer test
package main
import (
"runtime"
"time"
)
const N = 250
type A struct {
b *B
n int
}
t... | Go |
// $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 "runtime"
func mk2() {
b := new([10000]byte)
_ = b
// println(b, "stored at", &b)
}
func mk1() { ... | Go |
// $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
type T chan uint64
func M(f uint64) (in, out T) {
in = make(T, 100)
out = make(T, 100)
go func(in, out T,... | Go |
// errchk $G -e $D/$F.go
// 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.
package main
func use(bool) {}
type T1 *int
type T2 *int
type T3 struct{}
var t3 T3
func main() {
// Arguments to comparison mus... | Go |
// $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 "os"
var ecode int
func assert(a, b, c string) {
if a != b {
ecode = 1
print("FAIL: ", c, ": ",... | Go |
// $G $D/$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
// check for correct heap-moving of escaped variables.
// it is hard to check for the allocations, but it ... | Go |
// errchk $G -e $D/$F.go
// 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.
package main
var (
f32 float32
f64 float64
c64 complex64
c128 complex128
)
func main() {
// ok
c64 = complex(f32, f32)
c128... | Go |
// errchk $G -e $F.go
// 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.
// Incorrect short declarations and redeclarations.
package main
func f1() int { return 1 }
func f2() (float32, int)... | Go |
// $G $D/$F.go
// 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
func f(interface{})
func g() {}
func main() {
f(map[string]string{"a":"b","c":"d"})
f([...]int{1,2,3})
f(map[string]func(){"a":... | Go |
// $G $D/$F.go
// 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
type T struct {
s string;
}
func main() {
s := "";
l1 := len(s);
var t T;
l2 := len(t.s); // BUG: cannot take len() of a st... | Go |
// $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.
package main
var n int
func f() int {
n++
return n
}
func main() {
x := []int{0,1,2,3,4,5,6,7,8,9,10}
n = 5
y :... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: issue2056
// Copyright 2011 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 "os"
func main() {
x := 4
a, b, c, d := func(i int) (p int, q int, r int,... | Go |
// $G $D/$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
type T struct {
i int
}
func main() {
var ta []*T;
ta = new([1]*T)[0:];
ta[0] = nil;
}
/*
bug045.go:... | Go |
// $G $D/$F.go && $L $F.$A || echo BUG: bug155
// 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
const big uint64 = 1<<63
func f(a uint64) uint64 {
return a << big
}
func main() {
f(1)
}
/*
... | Go |
// errchk $G -e $D/$F.go
// 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
func main() {
var i int = 100
i = i << -3 // ERROR "overflows|negative"
}
/*
ixedbugs/bug016.go:7: overflow convertin... | Go |
// errchk $G $D/$F.go
// 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" // GCCGO_ERROR "previous"
var fmt int // ERROR "redecl|redefinition"
| Go |
// $G $D/$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
func main() {
type T struct {
s string
f float64
}
var s string = "hello"
var f float64 = 0.2
t ... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug260 failed
// Test that structures pack densely, according to the alignment of the largest field.
package main
import (
"fmt"
"os"
"strconv"
)
type T1 struct {
x uint8
}
type T2 struct {
x uint16
}
type T4 struct {
x uint32
}
func main() {
report := len... | Go |
// $G $D/$F.go || echo BUG: fails incorrectly
// 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
const s string = "foo";
func main() {
i := len(s); // should be legal to take len() of a constan... | Go |
// errchk $G $D/$F.go
// 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.
// Use //line to set the line number of the next line to 20.
//line fixedbugs/bug305.go:20
package p
// Introduce an error which shoul... | Go |
// $G $D/$F.go
// 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.
// Used to run out of registers on 8g. Issue 868.
package main
func main() {
var r uint32
var buf [4]byte
a := buf[0:4]
r = (((((uint32(... | Go |
// $G $D/$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
type Type interface {
TypeName() string;
}
type TInt struct {
}
// TInt
func (i *TInt) TypeName() strin... | Go |
// $G $D/$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
func main() {
var len int; // len should not be a keyword - this doesn't compile
_ = len;
}
| Go |
// $G $D/$F.dir/p1.go && $G $D/$F.dir/p2.go
// 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.
ignored
| Go |
// $G $D/$F.go
// 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
type I interface { X(...int) }
| Go |
// $G $D/$F.go
// 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
const c = 0 ^ 0
| Go |
// errchk $G $D/$F.go
// 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
type T struct
{
f int;
}
// 6g used to get confused by the f:1 above
// and allow uses of f that would be silently
// dro... | Go |
// $G $D/$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
type T1 struct {
x, y int
}
type T2 struct {
z, w byte
}
type T3 T1
type MyInt int
func (MyInt) m(*T1)... | Go |
// errchk $G $D/$F.go
// 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.
package main
type I1 interface {
m() I2
I2 // GCCGO_ERROR "loop|interface"
}
type I2 interface {
I1 // GC_ERROR "loop|interface"
}
... | Go |
// $G $D/$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
func Alloc(i int) int {
switch i {
default:
return 5;
case 1:
return 1;
case 10:
return 10;
}
... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: should run
// 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 "os"
type S struct { i int }
func (p *S) Get() int { return p.i }
type Em... | Go |
// $G $D/$F.go || echo BUG: bug156
// 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
func f(a int64) int64 {
const b int64 = 0;
n := a &^ b;
return n;
}
func main() {
f(1)
}
/*
bug156.go:7:... | Go |
// $G $D/$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
func g() {}
func f1() (a, b int) {
a, b = 2, 1
g() // defeat optimizer
return a, b
}
func f2() (a, b ... | Go |
// errchk $G $D/$F.go
// 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.
// This is a test case for issue 804.
package main
func f() [10]int {
return [10]int{}
}
var m map[int][10]int
func main() {
f()[1... | Go |
// $G $D/$F.go || echo BUG: bug150
// 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
type T int
func (t T) M()
type M interface { M() }
func g() (T, T)
func f() (a, b M) {
a, b = g();
retu... | Go |
// $G $D/$F.go || echo BUG: bug239
// 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.
// Test case for issue 475. This file should compile.
package main
import . "unsafe"
func main() {
var x int
println(Si... | Go |
// $G $D/$F.go && $L $F.$A
// 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
func f() {
exit:
;
goto exit
}
func main() {
exit:
; // this should be legal (labels not properly scoped?)
goto ... | Go |
// $G $D/$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
func main() {
L:
for i := 0; i < 1; i++ {
L1:
for {
break L
}
panic("BUG: not reached - break")... | Go |
// errchk $G $D/$F.go
// 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.
// RESOLUTION: This program is illegal. We should reject all unnecessary backslashes.
package main
const c = '\''; // this works
cons... | Go |
// errchk $G $D/$F.go
// Copyright 2011 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 p
func f() (_ int, err error) {
return
}
func g() (x int, _ error) {
return
}
func h() (_ int, _ error) {
return
}
func i... | Go |
// $G $D/$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
func frexp() (a int, b float64) {
return 1, 2.0
}
func main() {
a, b := frexp();
_, _ = a, b;
}
/*
bu... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG should run
// 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
func f() {
v := [...]string{"a", "b"};
_ = v;
}
func main() {
f();
}
| Go |
// 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 bug0
const A = -1
| Go |
// 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 bug1
import _ "./bug0"
| Go |
// $G $D/$F.go || echo BUG: should compile
// 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
type S struct {
p *S;
s []S;
m map[int] S;
c chan S;
i interface { f(S); };
f func(S) S;
}
func... | Go |
// $G $D/$F.go || echo BUG: fails incorrectly
// 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
func f1() (x int, y float64) {
return
}
func f2(x int, y float64) {
return
}
func main() {
f2(... | Go |
// $G $D/$F.dir/bug0.go && $G $D/$F.dir/bug1.go || echo BUG: fails incorrectly
// 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.
ignored
| Go |
// errchk $G $D/$F.go
// Copyright 2011 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.
// issue 1993.
// error used to have last line number in file
package main
func bla1() bool {
return false
}
func bla5() bool {
_ =... | Go |
// $G $D/$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
var s [8]string
func
init() {
s = [...]string{ "now", "is", "the", "time", "to", "fix", "this", "... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug352
// Copyright 2011 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
var x [10][0]byte
var y = make([]struct{}, 10)
func main() {
if &x[1] != &x[2] {
... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: should not fail
// 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
func foo(a []int) int {
return a[0] // this seems to do the wrong thing
}
f... | Go |
// $G $D/$F.go
// 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.
// Valid program, gccgo reported an error.
// bug307.go:14:6: error: complex arguments must have identical types
package main
func main() {
v... | Go |
// $G $D/$F.go || echo BUG: bug316
// 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.
// Issue 1369.
package main
const (
c = complex(1, 2)
r = real(c) // was: const initializer must be constant
i = imag(c... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG should not crash
// 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
// Interface
type I interface { F() int }
// Implements interface
type S str... | Go |
// $G $D/$F.dir/one.go && $G $D/$F.dir/two.go
// Copyright 2011 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.
// Issue 1802
package ignored
| Go |
// errchk $G $D/$F.go
// 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
func f() /* no return type */ {}
func main() {
x := f(); // ERROR "mismatch|as value|no type"
}
| Go |
// $G $D/$F.go
// Copyright 2011 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.
// Issue 1787.
package main
import "unsafe"
const x = unsafe.Sizeof([8]byte{})
func main() {
var b [x]int
_ = b
}
/*
bug338.go:14: array... | Go |
// $G $D/$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
func main() {
c := 10;
d := 7;
var x [10]int;
i := 0;
/* this works:
q := c/d;
x[i] = q;
*/
// th... | Go |
// errchk $G -e $D/$F.go
// 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.
// Test cases for revised conversion rules.
package main
func main() {
type NewInt int
i0 := 0
var i1 int = 1
var i2 NewInt = 1
... | Go |
package main
import "fmt"
var s string
func accum(args ...interface{}) {
s += fmt.Sprintln(args...)
}
func f(){
v := 0.0
for i := 0; i < 3; i++ {
v += 0.1
defer accum(v)
}
}
func main() {
f()
if s != "0.30000000000000004\n0.2\n0.1\n" {
println("BUG: defer")
print(s)
}
}
| Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: fails incorrectly
// 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
type S struct {
}
func (p *S) M() {
}
type I interface {
M();
}
func ma... | Go |
// errchk $G $D/$F.go
// 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
type R interface { duplicate() }
type S interface { duplicate() }
type T interface { R; S } // ERROR "duplicate"
func main... | Go |
// $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=920
package main
type X struct { x []X }
func main() {
type Y struc... | Go |
// $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=915
package main
type T struct {
x int
}
var t = &T{42}
var i inter... | Go |
// $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
func main() {
n := int64(100)
x := make([]int, n)... | Go |
// errchk $G $D/$F.go
// 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.
// Used to crash; issue 961.
package main
type ByteSize float64
const (
_ = iota; // ignore first value by assigning to blank ident... | Go |
// $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
va... | Go |
// errchk $G -e $D/$F.go
// 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.
package main
type T U // bogus "invalid recursive type T" from 6g
type U int
const x T = 123
type V V // ERROR "invalid recursive ... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out
// Copyright 2011 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.
// Issue 2206. Incorrect sign extension of div arguments.
package main
func five(x int64) {
if x != 5 {
panic(x)
... | Go |
// $G $D/$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 "reflect"
type S1 struct{ i int }
type S2 struct{ S1 }
func main() {
typ := reflect.TypeOf(S2{})... | Go |
// $G $D/$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
func main() {
k, l, m := 0,0,0;
_, _, _ = k, l, m;
}
| Go |
// errchk $G $D/$F.go
// Copyright 2011 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
type T struct{}
type P *T
func (t *T) Meth() {}
func (t T) Meth2() {}
func main() {
t := &T{}
p := P(t)
p.Meth() // ... | Go |
// errchk $G $D/$F.go
// Copyright 2011 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.
// Issue 1411.
package main
const ui uint = 0
const i int = ui // ERROR "type"
| Go |
// $G $D/$F.dir/bug0.go && errchk $G $D/$F.dir/bug1.go
// 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.
ignored
| Go |
// errchk $G $D/$F.go
// 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 P
var x int
func foo() {
print(P.x); // ERROR "undefined"
}
/*
uetli:~/Source/go1/test/bugs gri$ 6g bug085.go
bug085.go:6: P... | Go |
// 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 bug0
var V0 func() int;
var V1 func() (a int);
var V2 func() (a, b int);
| Go |
// 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 P "./bug0"
func main() {
a0 := P.V0(); // works
a1 := P.V1(); // works
a2, b2 := P.V2(); // doesn't work
_, _, _, _ = a0, a1, a2, ... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG
// 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.
// Test case for http://code.google.com/p/go/issues/detail?id=692
package main
var fooCount = 0
var barCou... | Go |
package main
import (
"./p"
)
type T struct{ *p.S }
type I interface {
get()
}
func main() {
var t T
p.F(t)
var x interface{} = t
_, ok := x.(I)
if ok {
panic("should not satisfy main.I")
}
_, ok = x.(p.I)
if !ok {
panic("should satisfy p.I")
}
}
| Go |
package p
type T struct{ x int }
type S struct{}
func (p *S) get() {
}
type I interface {
get()
}
func F(i I) {
i.get()
}
| Go |
package Bar
import _ "chanbug"
| Go |
package chanbug
var C chan<- (chan int)
var D chan<- func()
var E func() chan int
var F func() (func())
| Go |
// errchk $G $D/$F.go
// 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
type I int
type S struct { f map[I]int }
var v1 = S{ make(map[int]int) } // ERROR "cannot|illegal|incompatible|wrong"
var v... | Go |
// $G $D/$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
type S struct {
a []int
}
var s = &S{make([]int, 10)}
func main() {
s.a[f()] = 1 // 6g used to call f ... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: should not crash
// 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
func main() {
var b [0]byte
s := string(b[0:]) // out of bounds trap
if s... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: tuple evaluation order
// 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.
// Test order of evaluation in tuple assignments.
package main
var i byte = 0
var ... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug286 failed
// 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.
// Test case for issue 849.
package main
type I interface {
f()
}
var callee string
var ... | Go |
// errchk $G $D/$F.go
// 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
func main() {
var s string = nil; // ERROR "illegal|invalid|incompatible|cannot"
}
| Go |
// errchk $G $D/$F.go
// 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
func f() (int, bool) { return 0, true }
func main() {
x, y := f(), 2; // ERROR "multi"
}
| Go |
// $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=807
package main
type Point struct {
X, Y int64
}
type Rect struct ... | Go |
// errchk $G $D/$F.go
// 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
const (
c3div2 = 3/2;
f3div2 = 3./2.;
)
func assert(t bool, s string) {
if !t {
panic(s)
}
}
func main() {
var i i... | Go |
// $G $D/$F.go && $L $F.$A || echo BUG: bug167
// 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
func f1() {
type T struct {
x int
}
}
func f2() {
type T struct {
x float64
}
}
func mai... | Go |
// $G $D/bug160.dir/x.go && $G $D/bug160.dir/y.go && $L y.$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.
nothing to see here
| Go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.