code stringlengths 10 1.34M | language stringclasses 1
value |
|---|---|
// errorcheck
// 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 "unsafe"
func main() {
var x unsafe.Pointer
println(*x) // ERROR "invalid indirect.*unsafe.Pointer"
var _ = (unsafe.Poi... | Go |
// 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
func f0() {
const x = 0;
}
func f1() {
x := 0;
_ = x;
}
func main() {
f0();
f1();
}
/*
uetli:~/Source/go1/test/bugs gri$ 6g ... | Go |
// run
// 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 main() {
data := make(map[int]string, 1)
data[0] = "hello, "
data[0] += "world!"
if data[0] != "hello, world!" {
panic("BUG: " ... | Go |
// errorcheck
// Copyright 2012 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 1927.
// gccgo failed to issue the first error below.
package main
func main() {
println(int(1) == uint(1)) // ERROR "types"
var x i... | Go |
// run
// 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 "io"
func f() (_ string, x float64, err error) {
return
}
func g() (_ string, x float64, err error) {
return "hello", 3.14, io... | Go |
// errorcheck
// 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 := 1 << 1025; // ERROR "overflow|stupid shift"
_ = v
}
| Go |
// $G $D/$F.dir/p.go && $G $D/$F.dir/main.go
// Copyright 2012 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 2716. Export metadata error made main.go not compile.
package ignored
| Go |
// [ $A == 6 ] || 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.
// Issue 2444
package main
func main() {
var arr [1000200030]int // ERROR "type .* too large"
arr_bkup := arr
_ ... | Go |
// run
// 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
import "errors"
// Issue 481: closures and var declarations
// with multiple variables assigned from one
// function call.
func main() ... | Go |
// compile
// Copyright 2012 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 1757.
// gccgo failed to compile this.
package main
func main() {
(_) = 0
}
| Go |
// run
// 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 Value struct {
X interface{}
Y int
}
type Struct struct {
X complex128
}
const magic = 1 + 2i
func (Value) Complex(x complex12... | Go |
// 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 main() {
x := 0
x = ^x // unary ^ not yet implemented
if x != ^0 {
println(x, " ", ^0)
panic("fail")
}
}
/*
uetli:~/Source/g... | Go |
// compile
// Copyright 2012 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=3119
package main
import "fmt"
func main() {
s := "hello"
fmt.Println(s == "")
fmt.Println(s +... | Go |
// 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
var c chan int
func main() {
c = make(chan int);
go func() { c <- 0 } ();
<-c
}
| Go |
// compile
// Copyright 2012 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 2588. Used to trigger internal compiler error on 8g,
// because the compiler tried to registerize the int64 being
// used as a memory ope... | Go |
// errorcheck
// 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 a [10]int // ok
var b [1e1]int // ok
var c [1.5]int // ERROR "truncated"
var d ["abc"]int // ERROR "invalid array bound|not nu... | Go |
// 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 bug233
import p "fmt"
var _ = p.Print
var fmt = 10
| Go |
// errorcheck
// 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 1664
package main
func main() {
var i uint = 33
var a = (1<<i) + 4.5 // ERROR "shift of type float64|invalid.*shift"
println(a)
... | Go |
// $G $D/$F.dir/bug0.go && $G $D/$F.dir/bug1.go && errchk $G $D/$F.dir/bug2.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 |
// errorcheck
// 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 {
m(map[I] bool); // ok
}
type S struct {
m map[S] bool; // ERROR "map key type"
}
| Go |
// 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
var a = []int { 1, 2, 3 }
func main() {
if len(a) != 3 { panic("array len") }
// print(a[0], " ", a[1], " ", a[2], "\n")
if a[0] != 1 ... | Go |
// errorcheck
// 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 2343
package main
type T struct {}
func (t *T) pm() {}
func (t T) m() {}
func main() {
p := &T{}
p.pm()
p.m()
q := &p
q.m() ... | 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.
package ignored
| Go |
// run
// 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 2497
package main
type Header struct{}
func (h Header) Method() {}
var _ interface{} = Header{}
func main() {
type X Header
var _ in... | 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
import (
"bufio"
"./io"
goio "io"
)
func main() {
// The errors here complain that io.X != io.X
// for different values of io so they shoul... | 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 io
type Writer interface {
WrongWrite()
}
type SectionReader struct {
X int
}
func SR(*SectionReader) {}
| Go |
// 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
func isuint(i uint) { }
func main() {
i := ^uint(0);
isuint(i);
}
| Go |
// 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 main() {
type M map[int] int;
m1 := M{7 : 8};
_ = m1;
}
| Go |
// 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
// Multi-line string literal now allowed.
const s = `
Hello, World!
`
func main() {
print(s)
}
| Go |
// 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 main() {
var s2 string = "\a\b\f\n\r\t\v"; // \r is miscompiled
_ = s2;
}
/*
main.go.c: In function ‘main_main’:
main.go.c:20: err... | 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
import "./lib"
type I interface {
M()
}
type PI interface {
PM()
}
func main() {
var t lib.T
t.M()
t.PM()
// This is still an error.
//... | 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 lib
type T struct {
x int // non-exported field
}
func (t T) M() {
}
func (t *T) PM() {
}
| Go |
// run
// 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 main() {
m := make(map[string][1000]byte)
m["hi"] = [1000]byte{1}
v := m["hi"]
for k, vv := range m {
if k != "hi" || stri... | Go |
// build
// 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 a = 0
func f() {
const a = 5
}
func main() {
if a != 0 {
println("a=", a)
panic("fail")
}
}
| Go |
// 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"
func main() {
// This bug doesn't arise with [...]int, or []interface{} or [3]interface{}.
a := [...]interface{} { 1, 2, 3 ... | Go |
// 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
type Element interface {
}
type Vector struct {
elem []Element;
}
func (v *Vector) At(i int) Element {
return v.elem[i];
}
type TStru... | Go |
// errorcheck
// 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=808
package main
type A [...]int // ERROR "outside of array literal"
| Go |
// 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 I1 interface {}
type I2 interface { pr() }
func e() I1;
var i1 I1;
var i2 I2;
func
main() {
i2 = e().(I2); // bug089.go:16: ... | Go |
// errorcheck
// 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 Slice []byte;
a := [...]byte{ 0 };
b := Slice(a[0:]); // This should be OK.
c := Slice(a); // ERROR "invali... | Go |
// errorcheck
// 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 int = 0;
var x int = 0;
x = x << s; // ERROR "illegal|inval|shift"
x = x >> s; // ERROR "illegal|inval|sh... | Go |
// run
// 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
const (
joao = "João"
jose = "José"
)
func main() {
s1 := joao
s2 := jose
if (s1 < s2) != (joao < jose) {
panic("unequal")
}
}
| Go |
// errorcheck
// 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 x = '''; // ERROR "char"
| Go |
// Copyright 2012 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 one
// Issue 2877
type T struct {
f func(t *T, arg int)
g func(t T, arg int)
}
func (t *T) foo(arg int) {}
func (t T) goo(arg int) {}
func (t *T) ... | Go |
// Copyright 2012 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 the functions in one.go so that the inlined
// forms get type-checked.
package two
import "./one"
func use() {
var r one.T
r.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 pkg
func NonASCII(b []byte, i int) int {
for i = 0; i < len(b); i++ {
if b[i] >= 0x80 {
break
}
}
return i
}
| Go |
// errorcheck
// 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 1662
// iota inside var
package main
var (
a = iota // ERROR "undefined: iota|iota is only defined in const"
b = iota // ERROR "u... | Go |
// 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 main() {
switch {
// empty switch is allowed according to syntax
// unclear why it shouldn't be allowed
}
switch tag := 0; tag ... | Go |
// errorcheck
// 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() {
x⊛y := 1; // ERROR "identifier"
}
| Go |
// $G $D/bug302.dir/p.go && pack grc pp.a p.$A && $G $D/bug302.dir/main.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.
| Go |
// 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
type Element interface {
}
type Vector struct {
}
func (v *Vector) Insert(i int, e Element) {
}
func main() {
type I struct { val int... | Go |
// 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 dosplit(wait chan int ){
select {
case <-wait:
}
}
func main() {
}
| Go |
// errorcheck
// 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 873, 2162
package foo
func f(x interface{}) {
switch t := x.(type) { // ERROR "declared and not used"
case int:
}
}
func g(x int... | Go |
// run
// 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
// 5g bug used to set up the 0 for -f() before calling f,
// and the call to f smashed the register.
func f(n int) int {
s := 0
for i ... | Go |
// 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.
// Test the behavior of closures.
package main
import "runtime"
var c = make(chan int)
func check(a []int) {
for i := 0; i < len(a); i++ {
n := <... | Go |
// 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.
// Test floating-point comparison involving NaN.
package main
import "math"
type floatTest struct {
name string
expr bool
want bool
}
var nan flo... | Go |
// cmpout
// 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 that big numbers work as constants and print can print them.
package main
func main() {
print(-(1<<63), "\n")
print((1<<63)-1, "\n")
}
| Go |
// 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.
// Test behavior of the blank identifier (_).
package main
import _ "fmt"
var call string
type T struct {
_, _, _ int
}
func (T) _() {
}
func (T)... | Go |
// errorcheck
// 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.
// Verify that import conflicts are detected by the compiler.
// Does not compile.
package main
import "bufio" // GCCGO_ERROR "previous|not use... | Go |
// run
// 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.
// Test that goroutines and garbage collection run during init.
package main
import "runtime"
var x []byte
func init() {
c := make(chan int)
go s... | Go |
// 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.
// Test function signatures.
// Compiled but not run.
package main
type t1 int
type t2 int
type t3 int
func f1(t1, t2, t3)
func f2(t1, t2, t3 boo... | Go |
// 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.
// Test simulating a Turing machine, sort of.
package main
// brainfuck
var p, pc int
var a [30000]byte
const prog = "++++++++++[>+++++++>++++++++++... | Go |
// errorcheck
// 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.
// Verify overflow is detected when using numeric constants.
// Does not compile.
package main
type I interface{}
const (
// assume all types... | Go |
// 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.
// Test the internal "algorithms" for objects larger than a word: hashing, equality etc.
package main
type T struct {
a float64
b int64
c string
d... | Go |
// 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.
// Test character literal syntax.
package main
import "os"
func main() {
var i uint64 =
' ' +
'a' +
'ä' +
'本' +
'\a' +
'\b' +
'\f' +
... | Go |
// echo bug395 is broken # takes 90+ seconds to break
// # $G $D/$F.go || echo bug395
// 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 1909
// Would OOM due to exponential recursion on Foo's expand... | Go |
// errorcheck
// 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.
// Verify that illegal uses of ... are detected.
// Does not compile.
package main
import "unsafe"
func sum(args ...int) int { return 0 }
va... | Go |
// errorcheck
// 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.
// Test illegal shifts.
// Issue 1708, illegal cases.
// Does not compile.
package p
func f(x int) int { return 0 }
func g(x interface... | Go |
// 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.
// Test initialization of package-level variables.
package main
import "fmt"
import "reflect"
type S struct {
A, B, C, X, Y, Z int
}
type T struct ... | Go |
// run
// 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 of basic recover functionality.
package main
import "runtime"
func main() {
test1()
test1WithClosures()
test2()
test3()
test4()
test5(... | Go |
// errorcheck
// 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.
// Verify that illegal uses of indirection are caught by the compiler.
// Does not compile.
package main
var m0 map[string]int
var m1 *map[stri... | Go |
// errorcheck
// 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.
// Verify that large integer constant expressions cause overflow.
// Does not compile.
package main
const (
A int = 1
B byte; // ERROR "type ... | Go |
// 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.
// A simple test of the garbage collector.
package main
func main() {
for i := 0; i < 1e5; i++ {
x := new([100]byte)
_ = x
}
}
| Go |
// errorcheck
// 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 line numbers in error messages.
// Does not compile.
package main
var (
_ = x // ERROR "undefined.*x"
_ = x // ERROR "undefined.*x"
... | Go |
// 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.
// Test for loops.
package main
func assertequal(is, shouldbe int, msg string) {
if is != shouldbe {
print("assertion fail", msg, "\n")
panic(1)
... | Go |
// errorcheck
// 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.
// Verify simple assignment errors are caught by the compiler.
// Does not compile.
package main
import "sync"
type T struct {
int
sync.Mute... | Go |
// errorcheck
// 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 that basic operations on named types are valid
// and preserve the type.
// Does not compile.
package main
type Bool bool
type Map ma... | Go |
// 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.
// Test the 'for range' construct.
package main
// test range over channels
func gen(c chan int, lo, hi int) {
for i := lo; i <= hi; i++ {
c <- i
... | Go |
// 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.
// Test switch statements.
package main
import "os"
func assert(cond bool, msg string) {
if !cond {
print("assertion fail: ", msg, "\n")
panic(1... | Go |
// run
// 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 of recover for run-time errors.
// TODO(rsc):
// null pointer accesses
package main
import "strings"
var x = make([]byte, 10)
func main() ... | Go |
// run
// 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.
// Test evaluation order.
package main
var calledf int
func f() int {
calledf++
return 0
}
func g() int {
return calledf
}
var xy string
func ... | Go |
// run
// 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.
// Test closures in if conditions.
package main
func main() {
if func() bool { return true }() {} // 6g used to say this was a syntax error
if (fu... | Go |
// 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.
// Test UTF-8 in strings and character constants.
package main
import "unicode/utf8"
func main() {
var chars [6]rune
chars[0] = 'a'
chars[1] = 'b'... | Go |
// errorcheck
// 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.
// Test that error messages say what the source file says
// (uint8 vs byte, int32 vs. rune).
// Does not compile.
package main
import (
"fmt... | Go |
// run
// 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.
// Test zero length structs.
// Used to not be evaluated.
// Issue 2232.
package main
func recv(c chan interface{}) struct{} {
return (<-c).(struct{... | Go |
// 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.
// Test literal syntax for basic types.
package main
var nbad int
func assert(cond bool, msg string) {
if !cond {
if nbad == 0 {
print("BUG")
... | Go |
// compile
// 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.
// Test legal shifts.
// Issue 1708, legal cases.
// Compiles but does not run.
package p
func f(x int) int { return 0 }
func g(x interfa... | Go |
// errorcheck
// 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 that even if a file imports runtime,
// it cannot get at the low-level runtime definitions
// known to the compiler. For normal package... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out >tmp.go &&
// $G tmp.go && $L tmp.$A && ./$A.out
// rm -f tmp.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.
// Test source files and strings containing \r and \r\n... | Go |
// 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.
// Test integer literal syntax.
package main
import "os"
func main() {
s := 0 +
123 +
0123 +
0000 +
0x0 +
0x123 +
0X0 +
0X123
if s !... | Go |
// 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.
// Test methods on slices.
package main
type T []int
func (t T) Len() int { return len(t) }
type I interface {
Len() int
}
func main() {
var t T ... | Go |
// 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.
// Test that heavy recursion works. Simple torture test for
// segmented stacks: do math in unary by recursion.
package main
type Number *Number
// -... | Go |
// run
// 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 variadic functions and calls (dot-dot-dot).
package main
func sum(args ...int) int {
s := 0
for _, v := range args {
s += v
}
return s
... | 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.
// Garbage collection benchmark: parse Go packages repeatedly.
package main
import (
"flag"
"fmt"
"go/ast"
"go/parser"
"go/token"
"log"
"net/http"
_ ... | Go |
// 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 (
"fmt"
"runtime"
"time"
)
type Number struct {
next *Number
}
// -------------------------------------
// Peano primitives
... | Go |
// Copyright 2012 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 (
"flag"
"fmt"
"log"
"os"
"runtime"
"runtime/pprof"
"unsafe"
)
const BranchingFactor = 4
type Object struct {
child [BranchingFa... | Go |
/*
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form ... | 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
import (
"fmt"
"runtime"
"sort"
"time"
)
func gcstats(name string, n int, t time.Duration) {
st := new(runtime.MemStats)
runtime.ReadMemSt... | Go |
// errorcheck
// 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.
// Verify that erroneous type switches are caught be the compiler.
// Issue 2700, among other things.
// Does not compile.
package main
import ... | Go |
// [ "$GORUN" == "" ] || exit 0 # Android runner gets confused by the NUL output
// $G $D/$F.go && $L $F.$A && ./$A.out >tmp.go &&
// errchk $G -e tmp.go
// rm -f tmp.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 LI... | Go |
// 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.
// Test that when import gives multiple names
// to a single type, they still all refer to the same type.
package main
import _os_ "os"
import "os... | Go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.