-// errchk $G $D/$F.go
+// ! $G $D/$F.go || echo BUG: compilation succeeds incorrectly
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
-// Copyright 2009 The Go Authors. All rights reserved.
+// $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.
-// $G $D/$F.go && $L $F.$A && ./$A.out
-
package main
import "os"
var shift uint
func GetValue() uint {
- counter++;
- return 1 << shift
+ counter++;
+ return 1 << shift
}
func Send(a, b chan uint) int {
- var i int;
- LOOP:
- for {
- select {
- case a <- GetValue():
- i++;
- a = nil;
- case b <- GetValue():
- i++;
- b = nil;
- default:
- break LOOP;
- }
- shift++;
- }
- return i;
+ var i int;
+
+LOOP:
+ for {
+ select {
+ case a <- GetValue():
+ i++;
+ a = nil;
+ case b <- GetValue():
+ i++;
+ b = nil;
+ default:
+ break LOOP;
+ }
+ shift++;
+ }
+ return i;
}
func main() {
- a := make(chan uint, 1);
- b := make(chan uint, 1);
- if v := Send(a, b); v != 2 {
- panicln("Send returned", v, "!= 2");
- }
- if av, bv := <- a, <- b; av | bv != 3 {
- panicln("bad values", av, bv);
- }
- if v := Send(a, nil); v != 1 {
- panicln("Send returned", v, "!= 1");
- }
- if counter != 10 {
- panicln("counter is", counter, "!= 10");
- }
+ a := make(chan uint, 1);
+ b := make(chan uint, 1);
+ if v := Send(a, b); v != 2 {
+ panicln("Send returned", v, "!= 2");
+ }
+ if av, bv := <- a, <- b; av | bv != 3 {
+ panicln("bad values", av, bv);
+ }
+ if v := Send(a, nil); v != 1 {
+ panicln("Send returned", v, "!= 1");
+ }
+ if counter != 10 {
+ panicln("counter is", counter, "!= 10");
+ }
}
import "os"
func main() {
- var i uint64 =
- ' ' +
- 'a' +
- 'ä' +
- '本' +
- '\a' +
- '\b' +
- '\f' +
- '\n' +
- '\r' +
- '\t' +
- '\v' +
- '\\' +
- '\'' +
- '\000' +
- '\123' +
- '\x00' +
- '\xca' +
- '\xFE' +
- '\u0123' +
- '\ubabe' +
- '\U0123ABCD' +
- '\Ucafebabe'
- ;
- if '\Ucafebabe' != 0xcafebabe {
- print("cafebabe wrong\n");
- os.Exit(1)
- }
- if i != 0xcc238de1 {
- print("number is ", i, " should be ", 0xcc238de1, "\n");
- os.Exit(1)
- }
+ var i uint64 =
+ ' ' +
+ 'a' +
+ 'ä' +
+ '本' +
+ '\a' +
+ '\b' +
+ '\f' +
+ '\n' +
+ '\r' +
+ '\t' +
+ '\v' +
+ '\\' +
+ '\'' +
+ '\000' +
+ '\123' +
+ '\x00' +
+ '\xca' +
+ '\xFE' +
+ '\u0123' +
+ '\ubabe' +
+ '\U0123ABCD' +
+ '\Ucafebabe'
+ ;
+ if '\Ucafebabe' != 0xcafebabe {
+ print("cafebabe wrong\n");
+ os.Exit(1)
+ }
+ if i != 0xcc238de1 {
+ print("number is ", i, " should be ", 0xcc238de1, "\n");
+ os.Exit(1)
+ }
}
package main
func main() {
- var i int;
- i = '\'';
- i = '\\';
- var s string;
- s = "\"";
+ var i int;
+ i = '\'';
+ i = '\\';
+ var s string;
+ s = "\"";
}
/*
bug.go:5: unknown escape sequence: '
package main
func main() {
- var x int;
- x := 0; // ERROR "declar|:="
+ var x int;
+ x := 0; // ERROR "declar|:="
}
package main
func main (x int) { // GCCGO_ERROR "previous"
- var x int; // ERROR "redecl|redefinition"
+ var x int; // ERROR "redecl|redefinition"
}
package main
func f() int {
- return 0;
+ return 0;
}
func main() {
- const n = f(); // ERROR "const"
+ const n = f(); // ERROR "const"
}
package main
func main() {
- c := 10;
- d := 7;
- var x [10]int;
- i := 0;
- /* this works:
- q := c/d;
- x[i] = q;
- */
- // this doesn't:
- x[i] = c/d; // BUG segmentation fault
+ c := 10;
+ d := 7;
+ var x [10]int;
+ i := 0;
+ /* this works:
+ q := c/d;
+ x[i] = q;
+ */
+ // this doesn't:
+ x[i] = c/d; // BUG segmentation fault
}
package main
func main() {
- var len int; // len should not be a keyword - this doesn't compile
+ var len int; // len should not be a keyword - this doesn't compile
}
package main
type T struct {
- s string;
+ s string;
}
func main() {
- s := "";
- l1 := len(s);
- var t T;
- l2 := len(t.s); // BUG: cannot take len() of a string field
+ s := "";
+ l1 := len(s);
+ var t T;
+ l2 := len(t.s); // BUG: cannot take len() of a string field
}
/*
var m map[string] *Box;
func main() {
- m := make(map[string] *Box);
- s := "foo";
- var x *Box = nil;
- m[s] = x;
+ m := make(map[string] *Box);
+ s := "foo";
+ var x *Box = nil;
+ m[s] = x;
}
/*
package main
func main() {
- var s string = nil; // ERROR "illegal|invalid|incompatible|cannot"
+ var s string = nil; // ERROR "illegal|invalid|incompatible|cannot"
}
*/
/* An array composite literal needs to be created freshly every time.
- It is a "construction" of an array after all. If I pass the address
- of the array to some function, it may store it globally. Same applies
- to struct literals.
+ It is a "construction" of an array after all. If I pass the address
+ of the array to some function, it may store it globally. Same applies
+ to struct literals.
*/
// license that can be found in the LICENSE file.
package bug0
+
const A = -1
// license that can be found in the LICENSE file.
package bug1
+
import "./bug0"
package main
import os "os"
func f() (os int) {
- // In the next line "os" should refer to the result variable, not
- // to the package.
- v := os.Open("", 0, 0); // ERROR "undefined"
- return 0
+ // In the next line "os" should refer to the result variable, not
+ // to the package.
+ v := os.Open("", 0, 0); // ERROR "undefined"
+ return 0
}
/*
6g bugs/bug109.go
bugs/bug109.go:5: illegal types for operand: MUL
- (<float64>FLOAT64)
- (<float32>FLOAT32)
+ (<float64>FLOAT64)
+ (<float32>FLOAT32)
bugs/bug109.go:5: illegal types for operand: AS
- (<float64>FLOAT64)
+ (<float64>FLOAT64)
bugs/bug109.go:6: illegal types for operand: RETURN
- (<float32>FLOAT32)
- (<float64>FLOAT64)
+ (<float32>FLOAT32)
+ (<float64>FLOAT64)
*/
func foo1(i int) int { return i }
func foo2(i int32) int32 { return i }
func main() {
- var i I;
- i = 1;
- var v1 = i.(int);
- if foo1(v1) != 1 { panicln(1) }
- var v2 = int32(i.(int));
- if foo2(v2) != 1 { panicln(2) }
- var v3 = i.(int32); // This type conversion should fail at runtime.
- if foo2(v3) != 1 { panicln(3) }
+ var i I;
+ i = 1;
+ var v1 = i.(int);
+ if foo1(v1) != 1 { panicln(1) }
+ var v2 = int32(i.(int));
+ if foo2(v2) != 1 { panicln(2) }
+ var v3 = i.(int32); // This type conversion should fail at runtime.
+ if foo2(v3) != 1 { panicln(3) }
}
type S struct { a int }
type PS *S
func (p *S) get() int {
- return p.a
+ return p.a
}
func fn(p PS) int {
- // p has type PS, and PS has no methods.
- // (a compiler might see that p is a pointer
- // and go looking in S without noticing PS.)
- return p.get() // ERROR "undefined"
+ // p has type PS, and PS has no methods.
+ // (a compiler might see that p is a pointer
+ // and go looking in S without noticing PS.)
+ return p.get() // ERROR "undefined"
}
func main() {
- s := S{1};
- if s.get() != 1 {
- panic()
- }
+ s := S{1};
+ if s.get() != 1 {
+ panic()
+ }
}
package main
func Send(c chan int) int {
- select {
- default:
- return 1;
- }
- return 2;
+ select {
+ default:
+ return 1;
+ }
+ return 2;
}
package main
const ( F = 1 )
func fn(i int) int {
- if i == F() { // ERROR "func"
- return 0
- }
- return 1
+ if i == F() { // ERROR "func"
+ return 0
+ }
+ return 1
}
package main
func main() {
- var x int64 = 0;
- println(x != nil); // ERROR "illegal|incompatible|nil"
- println(0 != nil); // ERROR "illegal|incompatible|nil"
+ var x int64 = 0;
+ println(x != nil); // ERROR "illegal|incompatible|nil"
+ println(0 != nil); // ERROR "illegal|incompatible|nil"
}
func (p *S) send(c chan <- int) { c <- p.v }
func main() {
- s := S{0};
- var i I = &s;
- c := make(chan int);
- go i.send(c);
- os.Exit(<-c);
+ s := S{0};
+ var i I = &s;
+ c := make(chan int);
+ go i.send(c);
+ os.Exit(<-c);
}
package main
func main() {
- const a uint64 = 10;
- var b int64 = a; // ERROR "convert|cannot|incompatible"
+ const a uint64 = 10;
+ var b int64 = a; // ERROR "convert|cannot|incompatible"
}
func (t *T) foo() {}
func main() {
- t := new(T);
- var i interface {};
- f, ok := i.(Foo);
+ t := new(T);
+ var i interface {};
+ f, ok := i.(Foo);
}
== fixedbugs/
=========== fixedbugs/bug016.go
-fixedbugs/bug016.go:7: constant -3 overflows uint
+fixedbugs/bug016.go:11: constant -3 overflows uint
=========== fixedbugs/bug027.go
hi
broke
=========== fixedbugs/bug081.go
-fixedbugs/bug081.go:5: fatal error: typecheck loop
+fixedbugs/bug081.go:9: fatal error: typecheck loop
=========== fixedbugs/bug093.go
M
import "os"
func main() {
- s :=
- 0 +
- 123 +
- 0123 +
- 0000 +
- 0x0 +
- 0x123 +
- 0X0 +
- 0X123;
- if s != 788 {
- print("s is ", s, "; should be 788\n");
- os.Exit(1);
- }
+ s := 0 +
+ 123 +
+ 0123 +
+ 0000 +
+ 0x0 +
+ 0x123 +
+ 0X0 +
+ 0X123;
+ if s != 788 {
+ print("s is ", s, "; should be 788\n");
+ os.Exit(1);
+ }
}
var fail int
func check(b bool, msg string) {
- if (!b) {
- println("failure in", msg);
- fail++;
- }
+ if (!b) {
+ println("failure in", msg);
+ fail++;
+ }
}
type I1 interface { Get() int; Put(int); }
func (p S1) Put(i int) { p.i = i }
func f1() {
- s := S1{1};
- var i I1 = s;
- i.Put(2);
- check(i.Get() == 1, "f1 i");
- check(s.i == 1, "f1 s");
+ s := S1{1};
+ var i I1 = s;
+ i.Put(2);
+ check(i.Get() == 1, "f1 i");
+ check(s.i == 1, "f1 s");
}
func f2() {
- s := S1{1};
- var i I1 = &s;
- i.Put(2);
- check(i.Get() == 1, "f2 i");
- check(s.i == 1, "f2 s");
+ s := S1{1};
+ var i I1 = &s;
+ i.Put(2);
+ check(i.Get() == 1, "f2 i");
+ check(s.i == 1, "f2 s");
}
func f3() {
- s := &S1{1};
- var i I1 = s;
- i.Put(2);
- check(i.Get() == 1, "f3 i");
- check(s.i == 1, "f3 s");
+ s := &S1{1};
+ var i I1 = s;
+ i.Put(2);
+ check(i.Get() == 1, "f3 i");
+ check(s.i == 1, "f3 s");
}
type S2 struct { i int }
func (p *S2) Put(i int) { p.i = i }
// func f4() {
-// s := S2{1};
-// var i I1 = s;
-// i.Put(2);
-// check(i.Get() == 2, "f4 i");
-// check(s.i == 1, "f4 s");
+// s := S2{1};
+// var i I1 = s;
+// i.Put(2);
+// check(i.Get() == 2, "f4 i");
+// check(s.i == 1, "f4 s");
// }
func f5() {
- s := S2{1};
- var i I1 = &s;
- i.Put(2);
- check(i.Get() == 2, "f5 i");
- check(s.i == 2, "f5 s");
+ s := S2{1};
+ var i I1 = &s;
+ i.Put(2);
+ check(i.Get() == 2, "f5 i");
+ check(s.i == 2, "f5 s");
}
func f6() {
- s := &S2{1};
- var i I1 = s;
- i.Put(2);
- check(i.Get() == 2, "f6 i");
- check(s.i == 2, "f6 s");
+ s := &S2{1};
+ var i I1 = s;
+ i.Put(2);
+ check(i.Get() == 2, "f6 i");
+ check(s.i == 2, "f6 s");
}
type I2 interface { Get() int64; Put(int64); }
func (p S3) Put(i int64) { p.l = i }
func f7() {
- s := S3{1, 2, 3, 4};
- var i I2 = s;
- i.Put(5);
- check(i.Get() == 4, "f7 i");
- check(s.l == 4, "f7 s");
+ s := S3{1, 2, 3, 4};
+ var i I2 = s;
+ i.Put(5);
+ check(i.Get() == 4, "f7 i");
+ check(s.l == 4, "f7 s");
}
func f8() {
- s := S3{1, 2, 3, 4};
- var i I2 = &s;
- i.Put(5);
- check(i.Get() == 4, "f8 i");
- check(s.l == 4, "f8 s");
+ s := S3{1, 2, 3, 4};
+ var i I2 = &s;
+ i.Put(5);
+ check(i.Get() == 4, "f8 i");
+ check(s.l == 4, "f8 s");
}
func f9() {
- s := &S3{1, 2, 3, 4};
- var i I2 = s;
- i.Put(5);
- check(i.Get() == 4, "f9 i");
- check(s.l == 4, "f9 s");
+ s := &S3{1, 2, 3, 4};
+ var i I2 = s;
+ i.Put(5);
+ check(i.Get() == 4, "f9 i");
+ check(s.l == 4, "f9 s");
}
type S4 struct { i, j, k, l int64 }
func (p *S4) Put(i int64) { p.l = i }
// func f10() {
-// s := S4{1, 2, 3, 4};
-// var i I2 = s;
-// i.Put(5);
-// check(i.Get() == 5, "f10 i");
-// check(s.l == 4, "f10 s");
+// s := S4{1, 2, 3, 4};
+// var i I2 = s;
+// i.Put(5);
+// check(i.Get() == 5, "f10 i");
+// check(s.l == 4, "f10 s");
// }
func f11() {
- s := S4{1, 2, 3, 4};
- var i I2 = &s;
- i.Put(5);
- check(i.Get() == 5, "f11 i");
- check(s.l == 5, "f11 s");
+ s := S4{1, 2, 3, 4};
+ var i I2 = &s;
+ i.Put(5);
+ check(i.Get() == 5, "f11 i");
+ check(s.l == 5, "f11 s");
}
func f12() {
- s := &S4{1, 2, 3, 4};
- var i I2 = s;
- i.Put(5);
- check(i.Get() == 5, "f12 i");
- check(s.l == 5, "f12 s");
+ s := &S4{1, 2, 3, 4};
+ var i I2 = s;
+ i.Put(5);
+ check(i.Get() == 5, "f12 i");
+ check(s.l == 5, "f12 s");
}
func main() {
- f1();
- f2();
- f3();
-// f4();
- f5();
- f6();
- f7();
- f8();
- f9();
-// f10();
- f11();
- f12();
- if fail > 0 {
- os.Exit(1)
- }
+ f1();
+ f2();
+ f3();
+// f4();
+ f5();
+ f6();
+ f7();
+ f8();
+ f9();
+// f10();
+ f11();
+ f12();
+ if fail > 0 {
+ os.Exit(1)
+ }
}
r(c chan int, m int)
{
for {
- select {
+ select {
case r := <- c:
if h[r] != 1 {
panicln("r",
}
h[r] = 2;
}
- }
+ }
}
func
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-
package main
import "rand"
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-
package main
import "rand"
-// errchk $G $D/$F.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
-#!/bin/sh
# 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.
+#!/bin/sh
+
case X"$GOARCH" in
Xamd64)
export A=6
}
func main() {
- Sieve()
+ Sieve()
}
"\a\b\f\n\r\t\v\\\"",
"backslashes");
assert("\\a\\b\\f\\n\\r\\t\\v\\\\\\\"",
- `\a\b\f\n\r\t\v\\\"`,
+ `\a\b\f\n\r\t\v\\\"`,
"backslashes (backquote)");
assert("\x00\x53\000\xca\376S몾몾",
- "\000\123\x00\312\xFE\u0053\ubabe\U0000babe",
- "backslashes 2");
+ "\000\123\x00\312\xFE\u0053\ubabe\U0000babe",
+ "backslashes 2");
assert("\\000\\123\\x00\\312\\xFE\\u0123\\ubabe\\U0000babe",
- `\000\123\x00\312\xFE\u0123\ubabe\U0000babe`,
- "backslashes 2 (backquote)");
+ `\000\123\x00\312\xFE\u0123\ubabe\U0000babe`,
+ "backslashes 2 (backquote)");
assert("\\x\\u\\U\\", `\x\u\U\`, "backslash 3 (backquote)");
// test large runes. perhaps not the most logical place for this test.
package main
-import(
- "fmt";
- "os";
- "utf8";
+import (
+ "fmt";
+ "os";
+ "utf8";
)
func main() {
package main
const
- a_const = 0
+ a_const = 0
const (
- pi = /* the usual */ 3.14159265358979323;
- e = 2.718281828;
- mask1 int = 1 << iota;
- mask2 = 1 << iota;
- mask3 = 1 << iota;
- mask4 = 1 << iota;
+ pi = /* the usual */ 3.14159265358979323;
+ e = 2.718281828;
+ mask1 int = 1 << iota;
+ mask2 = 1 << iota;
+ mask3 = 1 << iota;
+ mask4 = 1 << iota;
)
type (
- Empty interface {};
- Point struct {
- x, y int;
- };
- Point2 Point
+ Empty interface {};
+ Point struct {
+ x, y int;
+ };
+ Point2 Point
)
func (p *Point) Initialize(x, y int) *Point {
- p.x, p.y = x, y;
- return p;
+ p.x, p.y = x, y;
+ return p;
}
func (p *Point) Distance() int {
- return p.x * p.x + p.y * p.y;
+ return p.x * p.x + p.y * p.y;
}
var (
- x1 int;
- x2 int;
- u, v, w float
+ x1 int;
+ x2 int;
+ u, v, w float
)
func foo() {}
func min(x, y int) int {
- if x < y { return x; }
- return y;
+ if x < y { return x; }
+ return y;
}
func swap(x, y int) (u, v int) {
- u = y;
- v = x;
- return;
+ u = y;
+ v = x;
+ return;
}
func control_structs() {
- var p *Point = new(Point).Initialize(2, 3);
- i := p.Distance();
- var f float = 0.3;
- for {}
- for {};
- for j := 0; j < i; j++ {
- if i == 0 {
- } else i = 0;
- var x float;
- }
- foo: // a label
- var j int;
- switch y := 0; true {
- case i < y:
- fallthrough;
- case i < j:
- case i == 0, i == 1, i == j:
- i++; i++;
- goto foo;
- default:
- i = -+-+i;
- break;
- }
+ var p *Point = new(Point).Initialize(2, 3);
+ i := p.Distance();
+ var f float = 0.3;
+ for {}
+ for {};
+ for j := 0; j < i; j++ {
+ if i == 0 {
+ } else i = 0;
+ var x float;
+ }
+ foo: // a label
+ var j int;
+ switch y := 0; true {
+ case i < y:
+ fallthrough;
+ case i < j:
+ case i == 0, i == 1, i == j:
+ i++; i++;
+ goto foo;
+ default:
+ i = -+-+i;
+ break;
+ }
}
func main() {
package main
func main() {
- var x int = 1;
- if x != 1 { panic("found ", x, ", expected 1\n"); }
- {
- var x int = x + 1;
- if x != 2 { panic("found ", x, ", expected 2\n"); }
- }
- {
- x := x + 1;
- if x != 2 { panic("found ", x, ", expected 2\n"); }
- }
+ var x int = 1;
+ if x != 1 { panic("found ", x, ", expected 1\n"); }
+ {
+ var x int = x + 1;
+ if x != 2 { panic("found ", x, ", expected 2\n"); }
+ }
+ {
+ x := x + 1;
+ if x != 2 { panic("found ", x, ", expected 2\n"); }
+ }
}